Skip to content

armgit / ODS

Public Imported from GitHub
0

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.

7.8 KB
Raw Blame
"""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