Skip to content
Capsem

Python SDK reference

Public signatures and types from the Python SDK, including resource helpers and model contracts. Start with Getting started with the SDK; see Errors and recovery for connection lifetime, deadlines, and retries.

Hypervisor

class Hypervisor(Client):
    connections: Connections
    credentials: Credentials
    debug: Debug
    images: Images
    mcp: Mcp
    networks: Networks
    def __init__(self, url: str, token: str, *, timeout: float=30) -> None:
        ...
    async def info(self) -> models.HypervisorInfo:
        ...
    async def list(self) -> models.ListResponse:
        ...
    def vm(self, *, name: str | None=None, id: str | None=None) -> VM:
        "A handle for an existing VM on this hypervisor's transport, selected by\nexactly one nonempty name or id."
        ...
    async def create(self, *, name: str='', cpus: int | None=None, memory: int | None=None, env: dict[str, str] | None=None, networks: Sequence[models.NetworkInfo]=(), image: str | None=None, command: Sequence[str]=(), registry: Registry | None=None) -> VM:
        ...
    def managed(self, *, cpus: int | None=None, memory: int | None=None, env: dict[str, str] | None=None, networks: Sequence[models.NetworkInfo]=(), image: str | None=None, command: Sequence[str]=(), registry: Registry | None=None) -> ManagedSession:
        'An ephemeral ownership scope: renew while entered, await cleanup on exit.'
        ...
    async def log(self, source: models.HostLogSource=models.HostLogSource.SERVICE, *, grep: str | None=None, tail: int | None=None, max_bytes: int | None=None) -> models.HostLogsResponse:
        ...
    async def run(self, command: str, *, timeout_secs: int | None=None, cpus: int | None=None, memory: int | None=None, env: dict[str, str] | None=None) -> ExecResult:
        ...
    async def purge(self, *, all: bool=False) -> models.PurgeResponse:
        ...
    async def update(self) -> models.UpdateActionResponse:
        ...
    async def restart(self) -> models.RestartResponse:
        'Restart an idle managed service; reconnect with a new gateway token.'
        ...

VM

class VM(Client):
    container: Container
    credential_grants: CredentialGrants
    files: Files
    networks: VmNetworks
    ports: Ports
    stats: Stats
    def __init__(self, url: str, token: str, *, name: str | None=None, id: str | None=None, timeout: float=30) -> None:
        ...
    @property
    def id(self) -> str | None:
        'Canonical ID, populated by the first request when selecting by name.'
        ...
    @property
    def name(self) -> str | None:
        ...
    async def info(self) -> models.SandboxInfo:
        ...
    async def exec(self, command: str, *, timeout_secs: int | None=None, target: models.ExecTarget | None=None) -> ExecResult:
        ...
    async def start(self) -> models.ProvisionResponse:
        ...
    async def persist(self, name: str) -> models.PersistResponse:
        ...
    async def stop(self) -> models.StopResponse:
        ...
    async def pause(self) -> models.VmActionResponse:
        ...
    async def resume(self) -> models.ProvisionResponse:
        ...
    async def delete(self) -> models.VmActionResponse:
        ...
    async def fork(self, name: str, *, description: str | None=None) -> VM:
        ...
    async def log(self, *, grep: str | None=None, tail: int | None=None, max_bytes: int | None=None) -> models.LogsResponse:
        ...
    async def history(self, *, limit: int | None=None, offset: int | None=None, search: str | None=None, layer: models.HistoryLayerFilter | None=None) -> models.HistoryResponse:
        ...
    async def timeline(self, *, trace_id: str | None=None, since: str | None=None, limit: int | None=None, layers: Sequence[models.TimelineLayer] | None=None) -> models.TimelineResponse:
        ...

ManagedSession

class ManagedSession():
    'Use ``async with hv.managed(...) as vm`` for an owned ephemeral VM.\n\nOne create is issued. Connection loss, cancellation and close never replay\nit. A client crash stops renewal; the service owns finite lease expiry.'
    def __init__(self, transport: Transport, request: models.ProvisionRequest) -> None:
        ...
    @property
    def ownership(self) -> models.ManagedSessionOwnership | None:
        'Verified nonsecret metadata; the capability is never exposed here.'
        ...
    async def __aenter__(self) -> VM:
        ...
    async def __aexit__(self, _kind: type[BaseException] | None, error: BaseException | None, _traceback: TracebackType | None) -> None:
        ...
    async def close(self, outcome: models.ManagedSessionOutcome=models.ManagedSessionOutcome.COMPLETED) -> None:
        'Join cleanup, including repeated cancellation; a failed close may be retried explicitly.'
        ...

ExecResult

class ExecResult(ExecResponse):
    'Command result with exact byte access and a useful string form.'
    @property
    def stdout_bytes(self) -> bytes:
        ...
    @property
    def stderr_bytes(self) -> bytes:
        ...
    def __str__(self) -> str:
        ...
    @classmethod
    def from_wire(cls, response: ExecResponse) -> ExecResult:
        ...

Registry

class Registry():
    username: str | None = None
    password: str | None = None
    ca_pem: str | None = None

Connections, CredentialGrants

class Connections():
    'Consent never implicitly grants a VM access or launches a browser.'
    def __init__(self, transport: Transport) -> None:
        ...
    async def list(self, *, limit: int | None=None, cursor: str | None=None, request_timeout: float | None=None) -> models.ConnectionListResponse:
        ...
    async def authorize_google(self, request: models.AuthorizeGoogleRequest, *, request_timeout: float | None=None) -> models.AuthorizeGoogleResponse:
        'The caller retains the request ID, opens the URL and polls explicitly.'
        ...
    async def authorization(self, id: str, *, request_timeout: float | None=None) -> models.AuthorizationTransaction:
        ...
    async def cancel_authorization(self, id: str, *, request_timeout: float | None=None) -> models.AuthorizationTransaction:
        ...
    async def get(self, id: str, *, request_timeout: float | None=None) -> models.ConnectionSummary:
        ...
    async def disconnect(self, id: str, *, request_timeout: float | None=None) -> models.DisconnectResponse:
        'Fence grants; poll explicitly to confirm provider retirement.'
        ...


class CredentialGrants():
    def __init__(self, vm: VM) -> None:
        ...
    async def list(self, *, request_timeout: float | None=None) -> models.SessionGrantListResponse:
        ...
    async def create(self, request: models.CreateSessionGrantRequest, *, request_timeout: float | None=None) -> models.SessionGrantSummary:
        'Explicit approval for this owner; never reconnect or replay a mutation.'
        ...
    async def revoke(self, grant_id: str, *, request_timeout: float | None=None) -> models.RevokeSessionGrantResponse:
        ...

Container

class Container():
    def __init__(self, vm: _Vm) -> None:
        ...
    async def status(self) -> models.ContainerStatusResponse:
        ...

Credentials

class Credentials():
    def __init__(self, transport: Transport) -> None:
        ...
    async def inject(self, provider: str, value: str, *, storage: str='file', request_timeout: float | None=None) -> models.CredentialInjectResponse:
        'Register host material and use its reference in a VM environment.\n\nMemory storage lasts for this service lifetime. This operation never\nretries or starts consent, and does not refresh supplied OAuth tokens.'
        ...

Debug

class Debug():
    def __init__(self, transport: Transport) -> None:
        ...
    async def panics(self, *, since: str | None=None, limit: int | None=None) -> models.PanicsResponse:
        ...
    async def triage(self, *, vm_id: str | None=None, since: str | None=None, limit: int | None=None) -> models.TriageResponse:
        ...

Images

class Images():
    def __init__(self, transport: Transport) -> None:
        ...
    async def list(self, *, refresh: bool=False, request_timeout: float | None=None) -> models.ImageListResponse:
        "Return catalog identity, compatible pins and the service's cache state."
        ...
    async def pull(self, image: str, *, registry: Registry | None=None, request_timeout: float | None=None) -> models.ImagePullResponse:
        'Prefetch an admitted image; registry access belongs to this call only.'
        ...

McpTools, McpServer, Mcp

class McpTools():
    def __init__(self, transport: Transport, server_id: str) -> None:
        ...
    async def list(self) -> models.McpToolsListResponse:
        ...
    async def call(self, name: str, arguments: models.Value) -> models.Value:
        ...


class McpServer():
    info: object
    tools: McpTools
    def __init__(self, transport: Transport, info: models.McpServerInfoResponse) -> None:
        ...
    async def refresh(self) -> models.McpRefreshResponse:
        ...


class Mcp():
    def __init__(self, transport: Transport) -> None:
        ...
    async def info(self) -> models.McpInfoResponse:
        ...
    async def servers(self) -> models.McpServersListResponse:
        ...
    async def default_permission(self) -> models.McpDefaultPermissionResponse:
        ...
    async def get(self, name: str) -> McpServer:
        ...

Networks, VmNetworks

class Networks():
    def __init__(self, transport: Transport) -> None:
        ...
    async def create(self, name: str) -> models.NetworkInfo:
        ...
    async def list(self) -> builtins.list[models.NetworkInfo]:
        ...
    async def inspect(self, network_id: str) -> models.NetworkInfo:
        ...
    async def delete(self, network: models.NetworkInfo) -> models.VmActionResponse:
        ...
    async def logs(self, network: models.NetworkInfo, *, cursor: str | None=None, limit: int | None=None, vm: str | None=None, connection: str | None=None, event_type: str | None=None, decision: str | None=None, since: int | None=None, until: int | None=None) -> models.NetworkLogsResponse:
        ...


class VmNetworks():
    def __init__(self, vm: VM) -> None:
        ...
    async def list(self) -> builtins.list[models.NetworkInfo]:
        ...
    async def attach(self, network: models.NetworkInfo) -> models.NetworkInfo:
        ...
    async def detach(self, network: models.NetworkInfo) -> models.NetworkInfo:
        ...

Port, Ports

class Port():
    id: str
    guest: int
    host: int | None
    authenticate: bool
    url: str | None = None
    bootstrap_token: str | None = None
    expires_in_seconds: int | None = None


class Ports():
    def __init__(self, vm: _Vm) -> None:
        ...
    async def open(self, guest: int, *, host: int=0, authenticate: bool=False) -> Port:
        ...
    async def list(self) -> builtins.list[Port]:
        ...
    async def close(self, port: Port) -> models.VmActionResponse:
        ...

Files, Stats

class Files(Resource):
    "Paths are the guest's: `/root/x` in a VM, `/workspace/x` in its container,\nor `x` relative to the workspace. `exact=True` takes a path literally,\nrelative to the workspace root, even when it is absolute."
    async def read(self, path: str, *, exact: bool=False) -> bytes:
        ...
    async def write(self, path: str, data: bytes, *, exact: bool=False) -> models.UploadResponse:
        ...
    async def list(self, path: str='', *, depth: int | None=None, exact: bool=False) -> models.FileListResponse:
        'An empty `path` lists the workspace root.'
        ...


class Stats(Resource):
    async def summary(self) -> models.VmStatsSummaryResponse:
        ...
    async def details(self) -> models.VmStatsDetailResponse:
        ...

HttpError

class HttpError(Exception):
    'The gateway returned an unsuccessful HTTP status.'
    body: object
    status: object
    def __init__(self, status: int, body: str) -> None:
        ...
    @property
    def credential_code(self) -> CredentialErrorCode | None:
        'Known credential refusal code; future/non-JSON errors remain HTTP errors.'
        ...

models.ArchivedEventBody

class ArchivedEventBody(Model):
    body_hash: StrictStr
    content: StrictStr
    content_type: StrictStr | None = None
    direction: StrictStr
    encoding: BodyEncoding
    event_id: StrictStr
    original_bytes: Annotated[StrictInt, Field(ge=0)]
    source_table: StrictStr
    stored_bytes: Annotated[StrictInt, Field(ge=0)]
    truncated: StrictBool
    truncated_for_transport: StrictBool

models.AssetFileState

class AssetFileState(StrEnum):
    PRESENT = 'present'
    MISSING = 'missing'
    INVALID = 'invalid'

models.AssetFileStatus

class AssetFileStatus(Model):
    actual_size: Annotated[StrictInt, Field(ge=0)] | None = None
    expected_hash: StrictStr
    expected_size: Annotated[StrictInt, Field(ge=0)] | None = None
    kind: StrictStr
    name: StrictStr
    path: StrictStr
    status: AssetFileState

models.AssetManifestStatus

class AssetManifestStatus(Model):
    assets_current: StrictStr | None = None
    binaries_current: StrictStr | None = None
    blake3: StrictStr | None = None
    format: Annotated[StrictInt, Field(ge=0)] | None = None
    origin: StrictStr
    origin_path: StrictStr | None = None
    origin_source: StrictStr | None = None
    packaged_at: StrictStr | None = None
    path: StrictStr
    refresh_policy: StrictStr | None = None
    refreshed_at: StrictStr | None = None
    validation_error: StrictStr | None = None
    validation_status: ValidationStatus

models.AssetStatus

class AssetStatus(Model):
    asset_version: StrictStr | None = None
    assets: list[AssetFileStatus]
    bytes_done: Annotated[StrictInt, Field(ge=0)] | None = None
    bytes_total: Annotated[StrictInt, Field(ge=0)] | None = None
    current_arch: StrictStr
    current_asset: StrictStr | None = None
    downloaded: Annotated[StrictInt, Field(ge=0)] | None = None
    downloading: StrictBool
    errors: list[StrictStr]
    manifest: AssetManifestStatus
    ready: StrictBool
    reconcile_error: StrictStr | None = None
    started: StrictBool | None = None

models.AuditEvent

class AuditEvent(Model):
    argv: StrictStr
    audit_id: StrictStr | None = None
    comm: StrictStr | None = None
    credential_ref: StrictStr | None = None
    cwd: StrictStr | None = None
    event_id: StrictStr
    exe: StrictStr
    exec_event_id: StrictInt | None = None
    exit_code: StrictInt | None = None
    parent_exe: StrictStr | None = None
    pid: Annotated[StrictInt, Field(ge=0)]
    ppid: Annotated[StrictInt, Field(ge=0)]
    session_id: Annotated[StrictInt, Field(ge=0)] | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None
    tty: StrictStr | None = None
    uid: Annotated[StrictInt, Field(ge=0)]

models.AuditHistoryDetails

class AuditHistoryDetails(Model):
    audit_id: StrictStr | None = None
    comm: StrictStr | None = None
    cwd: StrictStr | None = None
    exe: StrictStr
    parent_exe: StrictStr | None = None
    pid: Annotated[StrictInt, Field(ge=0)]
    ppid: Annotated[StrictInt, Field(ge=0)]
    session_id: Annotated[StrictInt, Field(ge=0)] | None = None
    tty: StrictStr | None = None
    uid: Annotated[StrictInt, Field(ge=0)]

models.AuthorizationTransaction

class AuthorizationTransaction(Model):
    connection_id: StrictStr | None
    error_code: CredentialErrorCode | None
    expires_at: DateTimeString
    id: StrictStr
    state: TransactionState

models.AuthorizeGoogleRequest

class AuthorizeGoogleRequest(Model):
    reconnect_connection_id: StrictStr | None
    request_id: UuidString
    scope_profile_id: StrictStr

models.AuthorizeGoogleResponse

class AuthorizeGoogleResponse(Model):
    authorization_url: StrictStr | None
    transaction: AuthorizationTransaction

models.BodyEncoding

class BodyEncoding(StrEnum):
    UTF8 = 'utf8'
    BASE64 = 'base64'

models.CapabilitySummary

class CapabilitySummary(Model):
    consumer: StrictStr
    id: StrictStr
    label: StrictStr
    required_scopes: list[StrictStr]
    supported: StrictBool

models.CaptureStatus

class CaptureStatus(StrEnum):
    COMPLETE = 'complete'
    TRUNCATED = 'truncated'
    UNKNOWN = 'unknown'

models.CapturedPayload

class CapturedPayload(Model):
    content: CapturedContent
    status: CaptureStatus

models.CatalogInfo

class CatalogInfo(Model):
    channel: StrictStr
    digest: StrictStr
    generated_at: StrictStr | None = None
    reference: StrictStr

models.ConnectionListResponse

class ConnectionListResponse(Model):
    connections: list[ConnectionSummary]
    next_cursor: StrictStr | None
    scope_profiles: list[ScopeProfileSummary]

models.ConnectionProvider

class ConnectionProvider(StrEnum):
    GOOGLE = 'google'

models.ConnectionState

class ConnectionState(StrEnum):
    CONNECTED = 'connected'
    REAUTH_REQUIRED = 'reauth_required'
    DISCONNECTING = 'disconnecting'
    DISCONNECTED = 'disconnected'
    DEGRADED = 'degraded'

models.ConnectionSummary

class ConnectionSummary(Model):
    account_label: StrictStr | None
    available_capabilities: list[StrictStr]
    created_at: DateTimeString
    error_code: CredentialErrorCode | None
    granted_scopes: list[StrictStr]
    id: StrictStr
    last_refresh_at: DateTimeString | None
    provider: ConnectionProvider
    provider_revocation: ProviderRevocationState
    revision: Annotated[Annotated[StrictInt, Field(ge=0)], Field(le=9007199254740991)]
    scope_profile_id: StrictStr
    state: ConnectionState
    updated_at: DateTimeString

models.ContainerSpec

class ContainerSpec(Model):
    nonnullable_optional = frozenset(['args', 'attach', 'env'])
    args: list[StrictStr] | None = None
    attach: StrictBool | None = None
    env: dict[str, StrictStr] | None = None
    image: StrictStr
    registry: RegistryAccess | None = None

models.ContainerState

class ContainerState(StrEnum):
    PULLING = 'pulling'
    STAGING = 'staging'
    STAGED = 'staged'
    STARTING = 'starting'
    RUNNING = 'running'
    EXITED = 'exited'
    FAILED = 'failed'

models.ContainerStatusResponse

class ContainerStatusResponse(Model):
    digest: StrictStr | None = None
    error: StrictStr | None = None
    exit_code: StrictInt | None = None
    image: StrictStr
    resolved: StrictStr | None = None
    state: ContainerState
    surface: ContainerSurface | None = None

models.ContainerSurface

class ContainerSurface(Model):
    exposure_id: StrictStr | None = None
    kind: ContainerSurfaceKind
    port: Annotated[StrictInt, Field(ge=0)]

models.ContainerSurfaceKind

class ContainerSurfaceKind(StrEnum):
    XPRA = 'xpra'

models.CreateNetworkRequest

class CreateNetworkRequest(Model):
    name: StrictStr

models.CreateProxyRequest

class CreateProxyRequest(Model):
    bind: StrictStr
    port: Annotated[StrictInt, Field(ge=0)]
    provider: StrictStr

models.CreateProxyResponse

class CreateProxyResponse(Model):
    base_url: StrictStr
    bind: StrictStr
    lease_expires_unix_ms: Annotated[StrictInt, Field(ge=0)]
    lease_token: StrictStr
    port: Annotated[StrictInt, Field(ge=0)]
    provider: StrictStr
    session_id: StrictStr

models.CreateSessionGrantRequest

class CreateSessionGrantRequest(Model):
    capability_ids: list[StrictStr]
    connection_id: StrictStr
    expected_owner_generation: UuidString
    expires_at: DateTimeString | None
    request_id: UuidString

models.CredentialErrorCode

class CredentialErrorCode(StrEnum):
    CONFIGURATION_REQUIRED = 'configuration_required'
    UNSUPPORTED_CAPABILITY = 'unsupported_capability'
    UNKNOWN_SCOPE_PROFILE = 'unknown_scope_profile'
    POLICY_DENIED = 'policy_denied'
    SCOPE_DENIED = 'scope_denied'
    CONNECTION_UNAVAILABLE = 'connection_unavailable'
    REAUTH_REQUIRED = 'reauth_required'
    STORAGE_UNAVAILABLE = 'storage_unavailable'
    STORAGE_COMMIT_FAILED = 'storage_commit_failed'
    TRANSACTION_EXPIRED = 'transaction_expired'
    TRANSACTION_CANCELLED = 'transaction_cancelled'
    INVALID_CALLBACK = 'invalid_callback'
    PROVIDER_REJECTED = 'provider_rejected'
    PROVIDER_TIMEOUT = 'provider_timeout'
    OWNER_CHANGED = 'owner_changed'
    SESSION_UNAVAILABLE = 'session_unavailable'
    GRANT_UNAVAILABLE = 'grant_unavailable'
    REQUEST_CONFLICT = 'request_conflict'
    REVOCATION_PENDING = 'revocation_pending'

models.CredentialEvent

class CredentialEvent(Model):
    context_json: StrictStr | None = None
    event_id: StrictStr
    event_type: CredentialEventType | None = None
    material_class: MaterialClass
    origin: CredentialEventType | None = None
    provider: StrictStr | None = None
    source: StrictStr
    timestamp: StrictStr
    trace_id: StrictStr | None = None
    verb: CredentialOutcome

models.CredentialEventType

class CredentialEventType(StrEnum):
    HTTP_REQUEST = 'http.request'
    HTTP_RESPONSE = 'http.response'
    MODEL_CALL = 'model.call'
    MCP_TOOL_CALL = 'mcp.tool_call'
    MCP_TOOL_LIST = 'mcp.tool_list'
    MCP_EVENT = 'mcp.event'
    DNS_QUERY = 'dns.query'
    FILE_EVENT = 'file.event'
    FILE_IMPORT = 'file.import'
    FILE_EXPORT = 'file.export'
    PROCESS_EXEC = 'process.exec'
    PROCESS_EXEC_COMPLETE = 'process.exec_complete'
    PROCESS_AUDIT = 'process.audit'
    CREDENTIAL_SUBSTITUTION = 'credential.substitution'
    SECURITY_RULE = 'security.rule'
    SECURITY_ASK = 'security.ask'

models.CredentialInjectProvider

class CredentialInjectProvider(StrEnum):
    ANTHROPIC = 'anthropic'
    GOOGLE = 'google'
    OPENAI = 'openai'
    GITHUB = 'github'
    MCP = 'mcp'

models.CredentialInjectRequest

class CredentialInjectRequest(Model):
    private_input = True
    nonnullable_optional = frozenset(['storage'])
    provider: CredentialInjectProvider
    storage: CredentialStorage | None = None
    value: StrictStr = Field(repr=False)

models.CredentialInjectResponse

class CredentialInjectResponse(Model):
    credential_ref: StrictStr
    storage: CredentialStorage

models.CredentialOutcome

class CredentialOutcome(StrEnum):
    CAPTURED = 'captured'
    BROKERED = 'brokered'
    INJECTED = 'injected'
    ERROR = 'error'

models.CredentialStorage

class CredentialStorage(StrEnum):
    FILE = 'file'
    MEMORY = 'memory'

models.DisconnectResponse

class DisconnectResponse(Model):
    connection: ConnectionSummary
    local_authority: LocalCredentialAuthority
    revoked_grant_count: Annotated[StrictInt, Field(ge=0)]

models.DnsEvent

class DnsEvent(Model):
    credential_ref: StrictStr | None = None
    decision: NetworkDecision
    event_id: StrictStr
    matched_rule: StrictStr | None = None
    policy_rule: StrictStr | None = None
    process_name: StrictStr | None = None
    qclass: Annotated[StrictInt, Field(ge=0)]
    qname: StrictStr
    qtype: Annotated[StrictInt, Field(ge=0)]
    rcode: Annotated[StrictInt, Field(ge=0)]
    source_proto: NetworkProtocol | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None
    upstream_resolver_ms: Annotated[StrictInt, Field(ge=0)] | None = None

models.EnrollmentKind

class EnrollmentKind(StrEnum):
    OWNED_OAUTH_CLIENT = 'owned_oauth_client'
    NATIVE_CONSUMER_SIGN_IN = 'native_consumer_sign_in'

models.ErrorEvent

class ErrorEvent(Model):
    binary: StrictStr
    level: StrictStr
    message: StrictStr
    target: StrictStr | None = None
    ts: StrictStr

models.ErrorResponse

class ErrorResponse(Model):
    code: StrictStr | None = None
    error: StrictStr

models.EventBodiesResponse

class EventBodiesResponse(Model):
    bodies: list[ArchivedEventBody]
    event_id: StrictStr

models.EventBody

class EventBody(Model):
    body_hash: StrictStr
    content_type: StrictStr | None = None
    direction: StrictStr
    event_id: StrictStr
    original_bytes: Annotated[StrictInt, Field(ge=0)]
    source_table: StrictStr
    stored_bytes: Annotated[StrictInt, Field(ge=0)]
    truncated: StrictBool

models.ExecHistoryDetails

class ExecHistoryDetails(Model):
    exec_id: Annotated[StrictInt, Field(ge=0)]
    process_name: StrictStr | None = None
    source: ExecSource
    trace_id: StrictStr | None = None

models.ExecOutput

class ExecOutput(Model):
    data: StrictStr
    encoding: ExecOutputEncoding

models.ExecOutputEncoding

class ExecOutputEncoding(StrEnum):
    UTF8 = 'utf8'
    BASE64 = 'base64'

models.ExecRequest

class ExecRequest(Model):
    command: StrictStr
    target: ExecTarget | None = None
    timeout_secs: Annotated[StrictInt, Field(ge=0)] | None = None

models.ExecResponse

class ExecResponse(Model):
    nonnullable_optional = frozenset(['truncated'])
    exit_code: StrictInt
    stderr: ExecOutput
    stdout: ExecOutput
    truncated: StrictBool | None = None

models.ExecSource

class ExecSource(StrEnum):
    API = 'api'
    CLI = 'cli'
    MCP = 'mcp'
    FRONTEND = 'frontend'

models.ExecTarget

class ExecTarget(StrEnum):
    WORKLOAD = 'workload'
    VM = 'vm'

models.ExposureAccess

class ExposureAccess(StrEnum):
    LOOPBACK_TCP = 'loopback_tcp'
    HTTP_PREVIEW = 'http_preview'

models.ExposureInfo

class ExposureInfo(Model):
    access: ExposureAccess
    guest_port: Annotated[StrictInt, Field(ge=0)]
    host_port: Annotated[StrictInt, Field(ge=0)] | None = None
    id: StrictStr
    target: ExposureTarget

models.ExposureListResponse

class ExposureListResponse(Model):
    exposures: list[ExposureInfo]
    owner_generation: StrictStr

models.ExposureRequest

class ExposureRequest(Model):
    nonnullable_optional = frozenset(['access', 'host_port', 'target'])
    access: ExposureAccess | None = None
    guest_port: Annotated[StrictInt, Field(ge=0)]
    host_port: Annotated[StrictInt, Field(ge=0)] | None = None
    target: ExposureTarget | None = None

models.ExposureTarget

class ExposureTarget(StrEnum):
    CONTAINER = 'container'
    VM = 'vm'

models.FileActionCount

class FileActionCount(Model):
    action: FileEventAction
    count: Annotated[StrictInt, Field(ge=0)]

models.FileEntryType

class FileEntryType(StrEnum):
    FILE = 'file'
    DIRECTORY = 'directory'

models.FileEvent

class FileEvent(Model):
    action: FileEventAction
    credential_ref: StrictStr | None = None
    event_id: StrictStr
    path: StrictStr
    size: Annotated[StrictInt, Field(ge=0)] | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None

models.FileEventAction

class FileEventAction(StrEnum):
    CREATED = 'created'
    MODIFIED = 'modified'
    DELETED = 'deleted'
    RESTORED = 'restored'
    READ = 'read'
    IMPORT = 'import'
    EXPORT = 'export'

models.FileListEntry

class FileListEntry(Model):
    children: list[FileListEntry] | None = None
    is_text: StrictBool | None = None
    label: StrictStr | None = None
    mime: StrictStr | None = None
    mtime: Annotated[StrictInt, Field(ge=0)]
    name: StrictStr
    path: StrictStr
    size: Annotated[StrictInt, Field(ge=0)]
    type: FileEntryType

models.FileListResponse

class FileListResponse(Model):
    entries: list[FileListEntry]

models.ForkRequest

class ForkRequest(Model):
    description: StrictStr | None = None
    name: StrictStr

models.ForkResponse

class ForkResponse(Model):
    id: StrictStr
    name: StrictStr
    size_bytes: Annotated[StrictInt, Field(ge=0)]

models.GrantState

class GrantState(StrEnum):
    ACTIVE = 'active'
    REVOKED = 'revoked'
    EXPIRED = 'expired'

models.HistoryEntry

class HistoryEntry(Model):
    command: StrictStr
    details: HistoryDetails
    duration_ms: Annotated[StrictInt, Field(ge=0)] | None = None
    exit_code: StrictInt | None = None
    layer: HistoryLayer
    stderr_preview: StrictStr | None = None
    stdout_preview: StrictStr | None = None
    timestamp: StrictStr

models.HistoryLayer

class HistoryLayer(StrEnum):
    EXEC = 'exec'
    AUDIT = 'audit'

models.HistoryLayerFilter

class HistoryLayerFilter(StrEnum):
    ALL = 'all'
    EXEC = 'exec'
    AUDIT = 'audit'

models.HistoryResponse

class HistoryResponse(Model):
    commands: list[HistoryEntry]
    has_more: StrictBool
    total: Annotated[StrictInt, Field(ge=0)]

models.HostLogSource

class HostLogSource(StrEnum):
    SERVICE = 'service'
    MCP = 'mcp'
    GATEWAY = 'gateway'
    TRAY = 'tray'
    APP = 'app'

models.HostLogsResponse

class HostLogsResponse(Model):
    source: HostLogSource
    text: StrictStr

models.HostTriageResponse

class HostTriageResponse(Model):
    errors: list[ErrorEvent]
    panics: list[PanicEvent]
    slow_ops: list[SlowOpEvent]

models.HttpEvent

class HttpEvent(Model):
    bytes_received: Annotated[StrictInt, Field(ge=0)] | None = None
    bytes_sent: Annotated[StrictInt, Field(ge=0)] | None = None
    credential_ref: StrictStr | None = None
    decision: NetworkDecision
    domain: StrictStr
    duration_ms: Annotated[StrictInt, Field(ge=0)] | None = None
    event_id: StrictStr
    matched_rule: StrictStr | None = None
    method: StrictStr | None = None
    path: StrictStr | None = None
    policy_rule: StrictStr | None = None
    port: Annotated[StrictInt, Field(ge=0)] | None = None
    query: StrictStr | None = None
    request_headers: StrictStr | None = None
    response_headers: StrictStr | None = None
    status_code: Annotated[StrictInt, Field(ge=0)] | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None

models.HypervisorInfo

class HypervisorInfo(Model):
    assets: AssetStatus | None = None
    gateway_version: StrictStr
    resource_summary: ResourceSummary | None = None
    service: ServiceAvailability
    updates: UpdateStatusResponse | None = None
    vm_count: Annotated[StrictInt, Field(ge=0)]
    vms: list[VmSummary]

models.ImageCacheState

class ImageCacheState(StrEnum):
    UNKNOWN = 'unknown'
    MISSING = 'missing'
    PARTIAL = 'partial'
    READY = 'ready'

models.ImageInfo

class ImageInfo(Model):
    architectures: list[StrictStr]
    cached: ImageCacheState
    description: StrictStr
    image: StrictStr | None = None
    name: StrictStr

models.ImageListResponse

class ImageListResponse(Model):
    catalog: CatalogInfo | None = None
    images: list[ImageInfo]

models.ImagePullRequest

class ImagePullRequest(Model):
    image: StrictStr
    registry: RegistryAccess | None = None

models.ImagePullResponse

class ImagePullResponse(Model):
    digest: StrictStr
    image: StrictStr
    resolved: StrictStr

models.Interaction

class Interaction(Model):
    content: InteractionContent
    event_id: StrictStr
    item_index: Annotated[StrictInt, Field(ge=0)] | None = None
    model_call_id: StrictInt | None = None
    model_event_id: StrictStr | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None
    turn_id: StrictStr | None = None

models.InteractionBlock

class InteractionBlock(Model):
    kind: InteractionBlockKind
    payload: CapturedPayload | None = None

models.InteractionBlockKind

class InteractionBlockKind(StrEnum):
    TEXT = 'text'
    REASONING = 'reasoning'

models.InteractionBody

class InteractionBody(Model):
    body_hash: StrictStr
    content_type: StrictStr | None = None
    direction: StrictStr
    event_id: StrictStr
    original_bytes: Annotated[StrictInt, Field(ge=0)]
    source_table: StrictStr
    stored_bytes: Annotated[StrictInt, Field(ge=0)]
    truncated: StrictBool

models.InteractionMessage

class InteractionMessage(Model):
    blocks: list[InteractionBlock]
    kind: InteractionMessageKind
    role: InteractionRole

models.InteractionMessageKind

class InteractionMessageKind(StrEnum):
    MESSAGE = 'message'

models.InteractionReport

class InteractionReport(Model):
    bodies: list[InteractionBody]
    items: list[Interaction]

models.InteractionRequest

class InteractionRequest(Model):
    kind: InteractionRequestKind
    payload: CapturedPayload | None = None

models.InteractionRequestKind

class InteractionRequestKind(StrEnum):
    REQUEST_PREVIEW = 'request_preview'

models.InteractionRole

class InteractionRole(StrEnum):
    ASSISTANT = 'assistant'

models.InteractionToolCall

class InteractionToolCall(Model):
    arguments: CapturedPayload | None = None
    call_id: StrictStr
    decision: ToolDecision
    kind: InteractionToolCallKind
    origin: ToolOrigin
    request: CapturedPayload | None = None
    result: InteractionToolResult | None = None
    server_name: StrictStr | None = None
    tool_name: StrictStr

models.InteractionToolCallKind

class InteractionToolCallKind(StrEnum):
    TOOL_CALL = 'tool_call'

models.InteractionToolResult

class InteractionToolResult(Model):
    call_id: StrictStr
    error_message: StrictStr | None = None
    is_error: StrictBool | None = None
    kind: InteractionToolResultKind
    payload: CapturedPayload | None = None
    response: CapturedPayload | None = None

models.InteractionToolResultKind

class InteractionToolResultKind(StrEnum):
    TOOL_RESULT = 'tool_result'

models.JsonContent

class JsonContent(Model):
    kind: JsonContentKind
    value: JsonValue

models.JsonContentKind

class JsonContentKind(StrEnum):
    JSON = 'json'

models.ListResponse

class ListResponse(Model):
    sandboxes: list[SandboxInfo]

models.LocalCredentialAuthority

class LocalCredentialAuthority(StrEnum):
    REVOKING = 'revoking'
    REVOKED = 'revoked'

models.LogsResponse

class LogsResponse(Model):
    logs: StrictStr
    process_logs: StrictStr | None = None
    serial_logs: StrictStr | None = None

models.ManagedSessionClaimRequest

class ManagedSessionClaimRequest(Model):
    private_input = True
    ownership_token: Annotated[StrictStr, Field(pattern='^[0-9a-f]{64}$', min_length=64, max_length=64)] = Field(repr=False)

models.ManagedSessionClaimResponse

class ManagedSessionClaimResponse(Model):
    error: ManagedSessionFailure | None = None
    ownership: ManagedSessionOwnership
    session: ProvisionResponse | None = None
    state: ManagedSessionState

models.ManagedSessionCloseRequest

class ManagedSessionCloseRequest(Model):
    private_input = True
    outcome: ManagedSessionOutcome
    ownership_token: Annotated[StrictStr, Field(pattern='^[0-9a-f]{64}$', min_length=64, max_length=64)] = Field(repr=False)

models.ManagedSessionCloseResponse

class ManagedSessionCloseResponse(Model):
    evidence_retained: StrictBool
    generation: StrictStr
    request_id: StrictStr
    session_id: StrictStr | None = None
    state: ManagedSessionClosedState

models.ManagedSessionClosedState

class ManagedSessionClosedState(StrEnum):
    CLOSED = 'closed'

models.ManagedSessionCreate

class ManagedSessionCreate(Model):
    private_input = True
    ownership_token: Annotated[StrictStr, Field(pattern='^[0-9a-f]{64}$', min_length=64, max_length=64)] = Field(repr=False)
    request_id: UuidString

models.ManagedSessionErrorCode

class ManagedSessionErrorCode(StrEnum):
    INVALID_REQUEST = 'invalid_request'
    FORBIDDEN = 'forbidden'
    NOT_FOUND = 'not_found'
    DUPLICATE_REQUEST = 'duplicate_request'
    EXPIRED = 'expired'
    CREATION_FAILED = 'creation_failed'
    CLEANUP_FAILED = 'cleanup_failed'
    RECOVERY_PENDING = 'recovery_pending'
    STORE_UNAVAILABLE = 'store_unavailable'

models.ManagedSessionFailure

class ManagedSessionFailure(Model):
    code: ManagedSessionErrorCode
    error: StrictStr

models.ManagedSessionOutcome

class ManagedSessionOutcome(StrEnum):
    COMPLETED = 'completed'
    FAILED = 'failed'
    CANCELLED = 'cancelled'

models.ManagedSessionOwnership

class ManagedSessionOwnership(Model):
    expires_at: StrictStr
    generation: StrictStr
    lease_seconds: Annotated[StrictInt, Field(ge=0)]
    renew_after_seconds: Annotated[StrictInt, Field(ge=0)]
    request_id: StrictStr

models.ManagedSessionState

class ManagedSessionState(StrEnum):
    PENDING = 'pending'
    ACTIVE = 'active'
    CLOSING = 'closing'
    CLOSED = 'closed'
    FAILED = 'failed'

models.MaterialClass

class MaterialClass(StrEnum):
    CREDENTIAL = 'credential'

models.McpDefaultPermissionResponse

class McpDefaultPermissionResponse(Model):
    action: McpPermissionAction
    rule_id: StrictStr | None = None
    source: StrictStr

models.McpInfoResponse

class McpInfoResponse(Model):
    builtin_local_enabled: StrictBool
    manual_server_count: Annotated[StrictInt, Field(ge=0)]
    server_count: Annotated[StrictInt, Field(ge=0)]

models.McpPermissionAction

class McpPermissionAction(StrEnum):
    ALLOW = 'allow'
    ASK = 'ask'
    BLOCK = 'block'
    PREPROCESS = 'preprocess'
    REWRITE = 'rewrite'
    POSTPROCESS = 'postprocess'

models.McpRefreshResponse

class McpRefreshResponse(Model):
    instances: Annotated[StrictInt, Field(ge=0)]
    server_id: StrictStr
    success: StrictBool

models.McpServerInfoResponse

class McpServerInfoResponse(Model):
    custom_header_count: Annotated[StrictInt, Field(ge=0)]
    enabled: StrictBool
    has_auth_credential: StrictBool
    is_stdio: StrictBool
    name: StrictStr
    running: StrictBool
    source: StrictStr
    tool_count: Annotated[StrictInt, Field(ge=0)]
    url: StrictStr

models.McpToolInfoResponse

class McpToolInfoResponse(Model):
    annotations: JsonValue = None
    description: StrictStr | None = None
    namespaced_name: StrictStr
    original_name: StrictStr
    permission_action: McpPermissionAction
    permission_source: StrictStr
    pin_changed: StrictBool
    pin_hash: StrictStr | None = None
    server_name: StrictStr

models.McpUsage

class McpUsage(Model):
    bytes_received: Annotated[StrictInt, Field(ge=0)]
    bytes_sent: Annotated[StrictInt, Field(ge=0)]
    call_count: Annotated[StrictInt, Field(ge=0)]
    duration_ms: Annotated[StrictInt, Field(ge=0)]
    server_name: StrictStr | None = None
    tool_name: StrictStr

models.Model

class Model(BaseModel):
    nonnullable_optional: ClassVar[frozenset[str]] = frozenset()
    private_input: ClassVar[bool] = False
    @model_validator(mode='wrap')
    @classmethod
    def redact_private_validation(cls, value: object, handler: ValidatorFunctionWrapHandler) -> object:
        ...
    @model_validator(mode='before')
    @classmethod
    def reject_explicit_null(cls, value: object) -> object:
        ...

models.ModelEvent

class ModelEvent(Model):
    credential_ref: StrictStr | None = None
    duration_ms: Annotated[StrictInt, Field(ge=0)] | None = None
    event_id: StrictStr
    input_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    method: StrictStr
    model: StrictStr | None = None
    output_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    path: StrictStr
    provider: StrictStr
    response_bytes: Annotated[StrictInt, Field(ge=0)] | None = None
    status_code: Annotated[StrictInt, Field(ge=0)] | None = None
    stop_reason: StrictStr | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None

models.ModelUsage

class ModelUsage(Model):
    call_count: Annotated[StrictInt, Field(ge=0)]
    duration_ms: Annotated[StrictInt, Field(ge=0)]
    estimated_cost_usd: StrictFloat
    input_tokens: Annotated[StrictInt, Field(ge=0)]
    model: StrictStr
    output_tokens: Annotated[StrictInt, Field(ge=0)]
    provider: StrictStr

models.NetworkDecision

class NetworkDecision(StrEnum):
    ALLOWED = 'allowed'
    DENIED = 'denied'
    ERROR = 'error'
    REDIRECTED = 'redirected'

models.NetworkInfo

class NetworkInfo(Model):
    created_unix_ms: StrictInt
    id: StrictStr
    members: list[NetworkMemberInfo]
    name: StrictStr
    subnet: StrictStr

models.NetworkListResponse

class NetworkListResponse(Model):
    networks: list[NetworkInfo]

models.NetworkLogEvent

class NetworkLogEvent(Model):
    connection_id: StrictStr | None = None
    event: JsonValue
    event_id: StrictStr
    event_type: StrictStr
    sequence: StrictInt
    timestamp_unix_ms: StrictInt

models.NetworkLogsResponse

class NetworkLogsResponse(Model):
    cursor: StrictStr
    events: list[NetworkLogEvent]
    next_cursor: StrictStr | None = None

models.NetworkMemberInfo

class NetworkMemberInfo(Model):
    address: IPv4Address
    state: NetworkMemberState
    updated_unix_ms: StrictInt
    vm_id: StrictStr

models.NetworkMemberState

class NetworkMemberState(StrEnum):
    DECLARED = 'declared'
    ATTACHING = 'attaching'
    READY = 'ready'
    FAILED = 'failed'

models.NetworkProtocol

class NetworkProtocol(StrEnum):
    TCP = 'tcp'
    UDP = 'udp'

models.PanicEvent

class PanicEvent(Model):
    binary: StrictStr
    frames: list[StrictStr]
    location: StrictStr | None = None
    message: StrictStr
    thread: StrictStr | None = None
    ts: StrictStr

models.PanicsResponse

class PanicsResponse(Model):
    panics: list[PanicEvent]

models.PersistRequest

class PersistRequest(Model):
    name: StrictStr

models.PersistResponse

class PersistResponse(Model):
    name: StrictStr
    success: StrictBool

models.PreviewSessionResponse

class PreviewSessionResponse(Model):
    bootstrap_token: StrictStr
    expires_in_seconds: Annotated[StrictInt, Field(ge=0)]
    url: StrictStr

models.PreviewSessionsRevokedResponse

class PreviewSessionsRevokedResponse(Model):
    revoked: Annotated[StrictInt, Field(ge=0)]

models.ProcessEvent

class ProcessEvent(Model):
    command: StrictStr
    credential_ref: StrictStr | None = None
    duration_ms: Annotated[StrictInt, Field(ge=0)] | None = None
    event_id: StrictStr
    exec_id: Annotated[StrictInt, Field(ge=0)]
    exit_code: StrictInt | None = None
    pid: Annotated[StrictInt, Field(ge=0)] | None = None
    process_name: StrictStr | None = None
    source: ExecSource
    stderr_bytes: Annotated[StrictInt, Field(ge=0)] | None = None
    stdout_bytes: Annotated[StrictInt, Field(ge=0)] | None = None
    timestamp: StrictStr
    trace_id: StrictStr | None = None

models.ProviderRevocationState

class ProviderRevocationState(StrEnum):
    NOT_STARTED = 'not_started'
    PENDING = 'pending'
    SUCCEEDED = 'succeeded'
    FAILED = 'failed'

models.ProvisionRequest

class ProvisionRequest(Model):
    private_input = True
    nonnullable_optional = frozenset(['networks', 'persistent'])
    container: ContainerSpec | None = None
    cpus: Annotated[StrictInt, Field(ge=0)] | None = None
    env: dict[str, StrictStr] | None = None
    from_: StrictStr | None = Field(default=None, alias='from')
    managed: ManagedSessionCreate | None = None
    name: StrictStr | None = None
    networks: list[StrictStr] | None = None
    persistent: StrictBool | None = None
    ram_mb: Annotated[StrictInt, Field(ge=0)] | None = None

models.ProvisionResponse

class ProvisionResponse(Model):
    nonnullable_optional = frozenset(['can_resume', 'persistent'])
    available_actions: list[VmAction]
    can_resume: StrictBool | None = None
    id: StrictStr
    name: StrictStr
    ownership: ManagedSessionOwnership | None = None
    persistent: StrictBool | None = None
    status: VmLifecycleState

models.ProxyHeartbeatResponse

class ProxyHeartbeatResponse(Model):
    lease_expires_unix_ms: Annotated[StrictInt, Field(ge=0)]
    session_id: StrictStr

models.ProxyLeaseRequest

class ProxyLeaseRequest(Model):
    lease_token: StrictStr

models.PurgeRequest

class PurgeRequest(Model):
    nonnullable_optional = frozenset(['all'])
    all: StrictBool | None = None

models.PurgeResponse

class PurgeResponse(Model):
    ephemeral_purged: Annotated[StrictInt, Field(ge=0)]
    persistent_purged: Annotated[StrictInt, Field(ge=0)]
    purged: Annotated[StrictInt, Field(ge=0)]

models.RawContent

class RawContent(Model):
    kind: RawContentKind
    raw: StrictStr
    reason: RawContentReason

models.RawContentKind

class RawContentKind(StrEnum):
    RAW = 'raw'

models.RawContentReason

class RawContentReason(StrEnum):
    TRUNCATED = 'truncated'
    INVALID_JSON = 'invalid_json'
    UNPARSED = 'unparsed'

models.RegistryAccess

class RegistryAccess(Model):
    ca_pem: StrictStr | None = None
    password: StrictStr | None = None
    username: StrictStr | None = None

models.ResourceSummary

class ResourceSummary(Model):
    running_count: Annotated[StrictInt, Field(ge=0)]
    stopped_count: Annotated[StrictInt, Field(ge=0)]
    suspended_count: Annotated[StrictInt, Field(ge=0)]
    total_cpus: Annotated[StrictInt, Field(ge=0)]
    total_ram_mb: Annotated[StrictInt, Field(ge=0)]

models.RestartAuthentication

class RestartAuthentication(StrEnum):
    NEW_TOKEN_REQUIRED = 'new_token_required'

models.RestartResponse

class RestartResponse(Model):
    authentication: RestartAuthentication
    manager: ServiceManager
    status: RestartStatus

models.RestartStatus

class RestartStatus(StrEnum):
    ACCEPTED = 'accepted'

models.RevokeSessionGrantResponse

class RevokeSessionGrantResponse(Model):
    grant: SessionGrantSummary
    local_authority: RevokedCredentialAuthority

models.RevokedCredentialAuthority

class RevokedCredentialAuthority(StrEnum):
    REVOKED = 'revoked'

models.RunRequest

class RunRequest(Model):
    command: StrictStr
    cpus: Annotated[StrictInt, Field(ge=0)] | None = None
    env: dict[str, StrictStr] | None = None
    ram_mb: Annotated[StrictInt, Field(ge=0)] | None = None
    timeout_secs: Annotated[StrictInt, Field(ge=0)] | None = None

models.SandboxInfo

class SandboxInfo(Model):
    nonnullable_optional = frozenset(['can_resume', 'persistent'])
    ai: VmAiInfo | None = None
    allowed_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    available_actions: list[VmAction]
    can_resume: StrictBool | None = None
    cpus: Annotated[StrictInt, Field(ge=0)] | None = None
    created_at: StrictStr | None = None
    denied_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    description: StrictStr | None = None
    files: VmFilesInfo | None = None
    forked_from: StrictStr | None = None
    id: StrictStr
    last_error: StrictStr | None = None
    model_call_count: Annotated[StrictInt, Field(ge=0)] | None = None
    name: StrictStr | None = None
    network: VmNetworkInfo | None = None
    persistent: StrictBool | None = None
    pid: Annotated[StrictInt, Field(ge=0)]
    ram_mb: Annotated[StrictInt, Field(ge=0)] | None = None
    resume_blocked_reason: StrictStr | None = None
    session_db: SessionDbStatus | None = None
    size_bytes: Annotated[StrictInt, Field(ge=0)] | None = None
    status: VmLifecycleState
    storage: StorageDiagnostics | None = None
    total_estimated_cost: StrictFloat | None = None
    total_file_events: Annotated[StrictInt, Field(ge=0)] | None = None
    total_input_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    total_output_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    total_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    total_thinking_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    total_tool_calls: Annotated[StrictInt, Field(ge=0)] | None = None
    uptime_secs: Annotated[StrictInt, Field(ge=0)] | None = None
    version: StrictStr | None = None

models.ScopeProfileSummary

class ScopeProfileSummary(Model):
    application_label: StrictStr
    capabilities: list[CapabilitySummary]
    enabled: StrictBool
    enrollment_kind: EnrollmentKind
    id: StrictStr
    label: StrictStr
    requested_scopes: list[StrictStr]

models.ServiceAvailability

class ServiceAvailability(StrEnum):
    RUNNING = 'running'
    UNAVAILABLE = 'unavailable'

models.ServiceManager

class ServiceManager(StrEnum):
    LAUNCHD = 'launchd'
    SYSTEMD = 'systemd'

models.SessionDbStatus

class SessionDbStatus(Model):
    error: StrictStr | None = None
    ready: StrictBool

models.SessionGrantListResponse

class SessionGrantListResponse(Model):
    denied_capability_ids: list[StrictStr]
    grants: list[SessionGrantSummary]
    owner_generation: StrictStr
    session_id: StrictStr

models.SessionGrantSummary

class SessionGrantSummary(Model):
    capability_ids: list[StrictStr]
    connection_id: StrictStr
    created_at: DateTimeString
    expires_at: DateTimeString
    id: StrictStr
    owner_generation: StrictStr
    revision: Annotated[Annotated[StrictInt, Field(ge=0)], Field(le=9007199254740991)]
    revoked_at: DateTimeString | None
    runtime_bound: StrictBool
    session_id: StrictStr
    state: GrantState

models.SlowOpEvent

class SlowOpEvent(Model):
    binary: StrictStr
    duration_ms: Annotated[StrictInt, Field(ge=0)]
    op: StrictStr
    ts: StrictStr

models.StopProxyResponse

class StopProxyResponse(Model):
    session_id: StrictStr
    stopped: StrictBool

models.StopResponse

class StopResponse(Model):
    persistent: StrictBool
    success: StrictBool

models.StorageDiagnostics

class StorageDiagnostics(Model):
    guest_overlay_device: StrictStr
    guest_overlay_mount: StrictStr
    host_available_bytes: Annotated[StrictInt, Field(ge=0)]
    host_free_bytes: Annotated[StrictInt, Field(ge=0)]
    host_total_bytes: Annotated[StrictInt, Field(ge=0)]
    rootfs_image_logical_bytes: Annotated[StrictInt, Field(ge=0)]
    rootfs_image_path: StrictStr
    rootfs_image_physical_bytes: Annotated[StrictInt, Field(ge=0)]

models.SupplyChainChannelEvidence

class SupplyChainChannelEvidence(Model):
    sha256: StrictStr | None = None
    url: StrictStr | None = None

models.SupplyChainEvidence

class SupplyChainEvidence(Model):
    attestations: list[SupplyChainReference]
    channel_index: SupplyChainChannelEvidence
    host_sbom: SupplyChainReference
    manifest: SupplyChainManifestEvidence
    vm_obom: SupplyChainReference

models.SupplyChainManifestEvidence

class SupplyChainManifestEvidence(Model):
    blake3: StrictStr | None = None
    origin: StrictStr | None = None
    path: StrictStr
    source: StrictStr | None = None

models.SupplyChainReference

class SupplyChainReference(Model):
    format: StrictStr | None = None
    generator: StrictStr | None = None
    name: StrictStr
    release_artifact: StrictStr | None = None
    route: StrictStr | None = None
    scope: StrictStr | None = None
    workflow: StrictStr | None = None

models.TextContent

class TextContent(Model):
    kind: TextContentKind
    text: StrictStr

models.TextContentKind

class TextContentKind(StrEnum):
    TEXT = 'text'

models.TimelineEvent

class TimelineEvent(Model):
    duration_ms: Annotated[StrictInt, Field(ge=0)] | None = None
    layer: TimelineLayer
    ref: TimelineReference
    status: TimelineStatus | None = None
    summary: StrictStr
    timestamp: StrictStr
    trace_id: StrictStr | None = None

models.TimelineLayer

class TimelineLayer(StrEnum):
    EXEC = 'exec'
    TOOL = 'tool'
    NET = 'net'
    FS = 'fs'
    MODEL = 'model'

models.TimelineResponse

class TimelineResponse(Model):
    events: list[TimelineEvent]

models.ToolDecision

class ToolDecision(StrEnum):
    ALLOWED = 'allowed'
    DENIED = 'denied'
    WARNED = 'warned'
    ERROR = 'error'

models.ToolEvent

class ToolEvent(Model):
    arguments: StrictStr | None = None
    bytes: Annotated[StrictInt, Field(ge=0)]
    call_id: StrictStr
    credential_ref: StrictStr | None = None
    decision: ToolDecision
    duration_ms: Annotated[StrictInt, Field(ge=0)]
    error_message: StrictStr | None = None
    event_id: StrictStr
    method: StrictStr | None = None
    model_call_id: StrictInt | None = None
    model_parent_missing: StrictBool
    process_name: StrictStr | None = None
    response_event_id: StrictStr | None = None
    response_preview: StrictStr | None = None
    server_name: StrictStr
    source: ToolOrigin
    timestamp: StrictStr | None = None
    tool_name: StrictStr

models.ToolOrigin

class ToolOrigin(StrEnum):
    MODEL = 'model'
    NATIVE = 'native'
    MCP = 'mcp'
    BUILTIN = 'builtin'
    LOCAL = 'local'
    MCP_PROXY = 'mcp_proxy'

models.TransactionState

class TransactionState(StrEnum):
    PENDING = 'pending'
    CONNECTED = 'connected'
    DENIED = 'denied'
    EXPIRED = 'expired'
    CANCELLED = 'cancelled'
    FAILED = 'failed'

models.TriageResponse

class TriageResponse(Model):
    host: HostTriageResponse
    rank: list[StrictStr]
    session: JsonValue
    session_id: StrictStr | None = None
    since: StrictStr

models.UpdateActionResponse

class UpdateActionResponse(Model):
    command: UpdateCommandPlan
    exit_code: StrictInt | None = None
    status: UpdateActionStatus
    stderr: StrictStr | None = None
    stdout: StrictStr | None = None

models.UpdateActionStatus

class UpdateActionStatus(StrEnum):
    PLANNED = 'planned'
    SUCCEEDED = 'succeeded'
    FAILED = 'failed'

models.UpdateApplyRequest

class UpdateApplyRequest(Model):
    nonnullable_optional = frozenset(['confirmed', 'dry_run'])
    confirmed: StrictBool | None = None
    dry_run: StrictBool | None = None

models.UpdateCommandPlan

class UpdateCommandPlan(Model):
    args: list[StrictStr]
    program: StrictStr

models.UpdateCompatibilityState

class UpdateCompatibilityState(StrEnum):
    COMPATIBLE = 'compatible'
    UNKNOWN = 'unknown'
    NOT_APPLICABLE = 'not_applicable'

models.UpdateStatusResponse

class UpdateStatusResponse(Model):
    assets: UpdateTrackStatus
    binary: UpdateTrackStatus
    channel_hash: StrictStr | None = None
    channel_url: StrictStr | None = None
    checked_at: Annotated[StrictInt, Field(ge=0)] | None = None
    images: UpdateTrackStatus
    last_error: StrictStr | None = None
    stale: StrictBool
    supply_chain: SupplyChainEvidence
    validation_error: StrictStr | None = None
    validation_status: ValidationStatus | None = None

models.UpdateTrackState

class UpdateTrackState(StrEnum):
    CURRENT = 'current'
    UPDATE_AVAILABLE = 'update_available'
    UNKNOWN = 'unknown'
    NOT_PUBLISHED = 'not_published'

models.UpdateTrackStatus

class UpdateTrackStatus(Model):
    blocked_reason: StrictStr | None = None
    compatibility: UpdateCompatibilityState
    current: StrictStr | None = None
    latest: StrictStr | None = None
    state: UpdateTrackState
    update_available: StrictBool

models.UploadResponse

class UploadResponse(Model):
    container_path: StrictStr | None = None
    size: Annotated[StrictInt, Field(ge=0)]
    success: StrictBool
    vm_path: StrictStr

models.ValidationStatus

class ValidationStatus(StrEnum):
    VALID = 'valid'
    INVALID = 'invalid'
    MISSING = 'missing'
    FETCH_ERROR = 'fetch_error'

models.VmAction

class VmAction(StrEnum):
    PAUSE = 'pause'
    STOP = 'stop'
    START = 'start'
    RESUME = 'resume'
    FORK = 'fork'
    DELETE = 'delete'

models.VmActionResponse

class VmActionResponse(Model):
    success: StrictBool

models.VmAiInfo

class VmAiInfo(Model):
    mcp: list[McpUsage]
    model_call_count: Annotated[StrictInt, Field(ge=0)]
    models: list[ModelUsage]
    total_estimated_cost_usd: StrictFloat
    total_input_tokens: Annotated[StrictInt, Field(ge=0)]
    total_output_tokens: Annotated[StrictInt, Field(ge=0)]
    total_thinking_tokens: Annotated[StrictInt, Field(ge=0)]
    total_tool_calls: Annotated[StrictInt, Field(ge=0)]

models.VmFilesInfo

class VmFilesInfo(Model):
    actions: list[FileActionCount]
    total_events: Annotated[StrictInt, Field(ge=0)]

models.VmLifecycleState

class VmLifecycleState(StrEnum):
    RUNNING = 'Running'
    STOPPED = 'Stopped'
    SUSPENDED = 'Suspended'
    DEFUNCT = 'Defunct'
    INCOMPATIBLE = 'Incompatible'

models.VmNetworkInfo

class VmNetworkInfo(Model):
    allowed_requests: Annotated[StrictInt, Field(ge=0)]
    bytes_received: Annotated[StrictInt, Field(ge=0)]
    bytes_sent: Annotated[StrictInt, Field(ge=0)]
    denied_requests: Annotated[StrictInt, Field(ge=0)]
    errors: Annotated[StrictInt, Field(ge=0)]
    total_requests: Annotated[StrictInt, Field(ge=0)]

models.VmStatsDetailResponse

class VmStatsDetailResponse(Model):
    audit_events: list[AuditEvent]
    body_blobs: dict[str, list[EventBody]]
    credential_events: list[CredentialEvent]
    dns_events: list[DnsEvent]
    file_events: list[FileEvent]
    http_events: list[HttpEvent]
    interactions: InteractionReport
    model_events: list[ModelEvent]
    model_stats: list[ModelUsage]
    process_events: list[ProcessEvent]
    tool_events: list[ToolEvent]

models.VmStatsSummaryResponse

class VmStatsSummaryResponse(Model):
    allowed_requests: Annotated[StrictInt, Field(ge=0)]
    denied_requests: Annotated[StrictInt, Field(ge=0)]
    total_estimated_cost: StrictFloat
    total_input_tokens: Annotated[StrictInt, Field(ge=0)]
    total_output_tokens: Annotated[StrictInt, Field(ge=0)]
    total_requests: Annotated[StrictInt, Field(ge=0)]
    total_thinking_tokens: Annotated[StrictInt, Field(ge=0)]
    total_tool_calls: Annotated[StrictInt, Field(ge=0)]

models.VmStatusResponse

class VmStatusResponse(Model):
    nonnullable_optional = frozenset(['can_resume', 'persistent'])
    available_actions: list[VmAction]
    can_resume: StrictBool | None = None
    created_at: StrictStr | None = None
    id: StrictStr
    last_error: StrictStr | None = None
    name: StrictStr
    persistent: StrictBool | None = None
    pid: Annotated[StrictInt, Field(ge=0)] | None = None
    resume_blocked_reason: StrictStr | None = None
    status: VmLifecycleState
    storage: StorageDiagnostics | None = None
    uptime_secs: Annotated[StrictInt, Field(ge=0)] | None = None

models.VmSummary

class VmSummary(Model):
    nonnullable_optional = frozenset(['can_resume'])
    allowed_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    available_actions: list[VmAction]
    can_resume: StrictBool | None = None
    denied_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    id: StrictStr
    last_error: StrictStr | None = None
    model_call_count: Annotated[StrictInt, Field(ge=0)] | None = None
    name: StrictStr | None = None
    persistent: StrictBool
    resume_blocked_reason: StrictStr | None = None
    status: VmLifecycleState
    total_estimated_cost: StrictFloat | None = None
    total_file_events: Annotated[StrictInt, Field(ge=0)] | None = None
    total_input_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    total_output_tokens: Annotated[StrictInt, Field(ge=0)] | None = None
    total_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    total_tool_calls: Annotated[StrictInt, Field(ge=0)] | None = None
    uptime_secs: Annotated[StrictInt, Field(ge=0)] | None = None