ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.
Python ai-agentsamdcomfyuidockerllama-cppllmlocal-ain8nnvidiaopen-webuiragself-hostedspeech-to-textstrix-halotext-to-speechworkflow-automation
"""Pydantic response models for ODS Dashboard API."""
from typing import Annotated, Any, Optional
from pydantic import BaseModel, Field
from config import GPU_BACKEND
from context_policy import HERMES_MIN_CONTEXT, HERMES_TARGET_CONTEXT, PIXEL_MIN_CONTEXT
class GPUInfo(BaseModel):
name: str
memory_used_mb: int
memory_total_mb: int
memory_percent: float
utilization_percent: int
temperature_c: int
power_w: Optional[float] = None
memory_type: str = "discrete"
gpu_backend: str = GPU_BACKEND
gpu_count: int = 1
memory_usage_available: bool = True
utilization_available: bool = True
temperature_available: bool = True
class ServiceStatus(BaseModel):
id: str
name: str
port: int
external_port: int
status: str # "healthy", "unhealthy", "unknown", "degraded", "down", "not_deployed"
response_time_ms: Optional[float] = None
# Internal health provenance; a slow HTTP probe alone cannot establish startup.
startup_pending: bool = Field(default=False, exclude=True)
# Internal: the restart policy keeps bringing a crashing container back up.
crash_looping: bool = Field(default=False, exclude=True)
class NodeCapabilities(BaseModel):
ods_version: str
gpu: Optional[GPUInfo] = None
loaded_model: Optional[str] = None
services: list[ServiceStatus] = []
service_count: int = 0
running_service_count: int = 0
class DiskUsage(BaseModel):
path: str
used_gb: float
total_gb: float
percent: float
class ModelInfo(BaseModel):
name: str
size_gb: float
context_length: int
quantization: Optional[str] = None
class BootstrapStatus(BaseModel):
active: bool
phase: Optional[str] = None
model_name: Optional[str] = None
percent: Optional[float] = None
downloaded_gb: Optional[float] = None
total_gb: Optional[float] = None
speed_mbps: Optional[float] = None
eta_seconds: Optional[int] = None
class FullStatus(BaseModel):
timestamp: str
gpu: Optional[GPUInfo] = None
services: list[ServiceStatus]
disk: DiskUsage
model: Optional[ModelInfo] = None
bootstrap: BootstrapStatus
uptime_seconds: int
PortNumber = Annotated[int, Field(ge=1, le=65535)]
class PortCheckRequest(BaseModel):
# preflight_ports binds a socket per entry synchronously on the event loop,
# so cap the list. A real install exposes a couple dozen service ports;
# 128 leaves ample headroom while preventing bind-probe amplification.
ports: Annotated[list[PortNumber], Field(max_length=128)]
class PortConflict(BaseModel):
port: int
service: str
in_use: bool
class PersonaRequest(BaseModel):
persona: str
class ChatRequest(BaseModel):
message: str = Field(..., max_length=100000)
system: Optional[str] = Field(None, max_length=10000)
class VersionInfo(BaseModel):
current: str
latest: Optional[str] = None
update_available: bool = False
changelog_url: Optional[str] = None
checked_at: Optional[str] = None
check_status: str = "unavailable"
# Why GitHub gave no release, while a failed check holds further requests.
check_error: Optional[str] = None
class UpdateAction(BaseModel):
action: str # "check", "backup", "update"
class PrivacyShieldStatus(BaseModel):
enabled: bool
container_running: bool
port: int
target_api: str
pii_cache_enabled: bool
message: str
class PrivacyShieldToggle(BaseModel):
enable: bool
class IndividualGPU(BaseModel):
index: int
uuid: str
name: str
memory_used_mb: int
memory_total_mb: int
memory_percent: float
utilization_percent: int
temperature_c: int
power_w: Optional[float] = None
memory_type: str = "discrete"
assigned_services: list[str] = []
memory_usage_available: bool = True
utilization_available: bool = True
temperature_available: bool = True
class MultiGPUStatus(BaseModel):
gpu_count: int
backend: str # "nvidia", "amd", "apple"
gpus: list[IndividualGPU]
topology: Optional[dict] = None
assignment: Optional[dict] = None
split_mode: Optional[str] = None
tensor_split: Optional[str] = None
aggregate: GPUInfo
class AmdRuntimeStatus(BaseModel):
available: bool
reason: Optional[str] = None
runtime: str = "none"
location: str = "none"
runtimeMode: str = "unknown"
managedByODS: bool = False
selectedBackend: str = "none"
supportedBackends: list[str] = Field(default_factory=list)
defaultBackend: str = "none"
apiBase: Optional[str] = None
healthUrl: Optional[str] = None
health: Optional[str] = None
version: str = "unknown"
loadedModel: Optional[str] = None
modelCount: Optional[int] = None
capabilities: list[str] = Field(default_factory=list)
warnings: list[str] = Field(default_factory=list)
class ModelLibraryEntry(BaseModel):
id: str
name: str
gguf: Optional[str] = None
ggufParts: Optional[list[dict[str, Any]]] = None
downloadUrl: Optional[str] = None
downloadSha256: Optional[str] = None
llmModelName: Optional[str] = None
size: Optional[str]
sizeGb: Optional[float]
vramRequired: Optional[float]
estimatedRequired: Optional[float] = None
contextLength: Optional[int]
maxContextLength: Optional[int] = None
contextOptions: list[dict[str, Any]] = Field(default_factory=list)
specialty: str
description: str
tokensPerSec: Optional[float] = None
tokensPerSecEstimate: Optional[float] = None
quantization: Optional[str] = None
architecture: Optional[str] = None
activeParamsB: Optional[float] = None
publisher: Optional[dict[str, str]] = None
metadata: dict[str, Any] = Field(default_factory=dict)
appCompatibility: dict[str, Any] = Field(default_factory=dict)
status: str # "loaded", "downloaded", "available"
modelOperation: Optional[dict[str, Any]] = None
recommended: bool = False
configured: bool = False
recommendation: Optional[dict[str, Any]] = None
fitsVram: Optional[bool]
activationSupport: Optional[dict[str, Any]] = None
fitsCurrentVram: Optional[bool]
performance: Optional[dict[str, Any]] = None
performanceLabel: Optional[str] = None
class ModelLibraryGpu(BaseModel):
vramTotal: float
modelMemoryBudgetGb: Optional[float] = None
vramUsed: float
vramFree: float
class ModelLibraryResponse(BaseModel):
models: list[ModelLibraryEntry]
gpu: Optional[ModelLibraryGpu] = None
currentModel: Optional[str] = None
activationReadyModel: Optional[str] = None
loadedModel: Optional[str] = None
configuredModel: Optional[str] = None
hermesMinimumContext: int = HERMES_MIN_CONTEXT
hermesTargetContext: int = HERMES_TARGET_CONTEXT
pixelMinimumContext: int = PIXEL_MIN_CONTEXT
recommendationPolicy: Optional[str] = None
recommendationAlternatives: list[dict[str, Any]] = Field(default_factory=list)
modelLifecycle: Optional[dict[str, Any]] = None
modelActivation: Optional[dict[str, Any]] = None
modelRecoveryPending: bool = False
odsMode: str = "unknown"
configuredMode: str = "unknown"
llmBackend: str = "unknown"
# API mode (llmBackend "external"): the model the API serves and the API's
# host, so the Models page can say what answers chat. Never the key.
externalModel: Optional[str] = None
externalHost: Optional[str] = None
# The model runs on the Windows host (the WSL Portal); modelManagement
# carries the host agent's proof of what this installation may control.
hostRuntime: bool = False
modelManagement: Optional[dict[str, Any]] = None
# Host-authoritative active runtime projection (local-switchboard,
# external-host, or remote-provider). Nonsecret identity, limits and
# capabilities; None when unknown, pending, or malformed.
activeRuntime: Optional[dict[str, Any]] = None