Skip to content
Capsem

Python SDK reference

This reference lists the public Python SDK interfaces, including signatures, resource helpers, and model types, so you can look up how to call the SDK and interpret its results. 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 | None=None, token: str | None=None, *, run_dir: str | Path | None=None, timeout: float=30) -> None:
        ...
    @classmethod
    def connect(cls, url: str | None=None, token: str | None=None, *, run_dir: str | Path | None=None, timeout: float=30) -> Self:
        'Create a `Hypervisor` client using gateway discovery when `url` or `token` is omitted.'
        ...
    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, labels: dict[str, str] | None=None, networks: Sequence[models.NetworkInfo]=(), image: str | None=None, command: Sequence[str]=(), registry: Registry | None=None) -> VM:
        'Provision a VM or container workload.\n\nArgs:\n    name: Persistent VM name; omit or pass empty string for an ephemeral VM.\n    cpus: Optional vCPU count override.\n    memory: Optional RAM size in GiB.\n    env: Optional environment variables for the VM or container workload.\n    labels: Optional string labels attached at creation.\n    networks: Private networks to attach to the VM at creation.\n    image: Optional OCI image reference to run as a container workload.\n    command: Optional command argv override for the container workload.\n    registry: Optional custom OCI registry configuration for pulling ``image``.'
        ...
    def managed(self, *, cpus: int | None=None, memory: int | None=None, env: dict[str, str] | None=None, labels: 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 | None=None, token: str | None=None, *, name: str | None=None, id: str | None=None, run_dir: str | Path | 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, labels: dict[str, str] | None=None) -> VM:
        "Fork this VM into a new persistent VM.\n\nArgs:\n    name: Persistent name for the forked VM.\n    description: Optional description for the forked VM.\n    labels: Optional labels overriding the source VM's labels (`{}` clears)."
        ...
    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:
        ...

CapsemError, HttpError

class CapsemError(Exception):
    'Base exception for Capsem SDK errors.'


class HttpError(CapsemError):
    'The gateway returned an unsuccessful HTTP status.'
    args: object
    body: object
    code: object
    response: ErrorResponse.model_validate_json
    status: object
    status: int
    body: str
    response: ErrorResponse | None
    code: ErrorCode | None
    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.'
        ...

GatewayEndpoint

class GatewayEndpoint():
    'Resolved HTTP gateway base URL and bearer token.'
    url: str
    token: str = field(repr=False)
    run_dir: Path | None = None

CapsemTimeoutError, CreateTimeoutError, ExecTimeoutError, VmNotFoundError

class CapsemTimeoutError(TimeoutError, CapsemError):
    'Base exception for Capsem SDK operation timeouts.'
    body: object
    command: object
    deadline_secs: object
    status: object
    timeout_secs: object
    vm: object
    vm_id: object
    vm_name: object
    status: int | None
    body: str | None
    vm_id: str | None
    vm_name: str | None
    vm: VM | None
    command: str | None
    timeout_secs: int | None
    deadline_secs: float | None
    def __init__(self, message: str, *, vm_id: str | None=None, vm_name: str | None=None, vm: VM | None=None, command: str | None=None, timeout_secs: int | None=None, deadline_secs: float | None=None, status: int | None=None, body: str | None=None) -> None:
        ...


class CreateTimeoutError(CapsemTimeoutError):
    'Raised when `Hypervisor.create` crosses the HTTP 504 or client deadline.'


class ExecTimeoutError(CapsemTimeoutError):
    'Raised when `VM.exec` or `Hypervisor.run` times out on the service or client.'


class VmNotFoundError(HttpError, LookupError):
    'Raised when a VM handle cannot be resolved by name or ID (HTTP 404).'
    vm_id: object
    vm_name: object
    vm_id: str | None
    vm_name: str | None
    def __init__(self, body: str, *, vm_id: str | None=None, vm_name: str | None=None, status: int=404) -> None:
        ...

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.BrowserAcknowledgeRequest

class BrowserAcknowledgeRequest(Model):
    owner_generation: StrictStr
    request_id: Annotated[StrictInt, Field(ge=0)]

models.BrowserAcknowledgeResponse

class BrowserAcknowledgeResponse(Model):
    owner_generation: StrictStr
    request_id: Annotated[StrictInt, Field(ge=0)]
    vm_id: StrictStr

models.BrowserRequest

class BrowserRequest(Model):
    id: Annotated[StrictInt, Field(ge=0)]
    owner_generation: StrictStr | None = None
    url: Annotated[StrictStr, Field(max_length=8192)]

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.CostCoverage

class CostCoverage(Model):
    priced_calls: Annotated[StrictInt, Field(ge=0)]
    unknown_calls: Annotated[StrictInt, Field(ge=0)]
    unpriced_calls: Annotated[StrictInt, Field(ge=0)]

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.ErrorCode

class ErrorCode(StrEnum):
    VM_NOT_FOUND = 'vm_not_found'
    CREATE_TIMEOUT = 'create_timeout'
    EXEC_TIMEOUT = 'exec_timeout'
    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.ErrorEvent

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

models.ErrorResponse

class ErrorResponse(Model):
    code: ErrorCode | None = None
    error: StrictStr
    timeout_secs: Annotated[StrictInt, Field(ge=0)] | None = None
    vm_id: StrictStr | None = None

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
    labels: dict[str, 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.ImageApp

class ImageApp(Model):
    nonnullable_optional = frozenset(['evidence', 'interfaces'])
    architecture: StrictStr
    catalog_name: StrictStr
    category: StrictStr | None = None
    description: StrictStr
    display_name: StrictStr
    evidence: list[ImageEvidence] | None = None
    icon: StrictStr | None = None
    image: StrictStr
    interfaces: list[ImageInterface] | None = None
    publisher: StrictStr | None = None
    url: StrictStr | None = None

models.ImageCacheState

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

models.ImageDownloadPhase

class ImageDownloadPhase(StrEnum):
    PREPARING = 'preparing'
    DOWNLOADING = 'downloading'
    VERIFYING = 'verifying'

models.ImageDownloadProgress

class ImageDownloadProgress(Model):
    completed_bytes: Annotated[StrictInt, Field(ge=0)]
    phase: ImageDownloadPhase
    total_bytes: Annotated[StrictInt, Field(ge=0)] | None = None

models.ImageEvidence

class ImageEvidence(Model):
    kind: ImageEvidenceKind
    media_type: StrictStr
    reference: StrictStr

models.ImageEvidenceKind

class ImageEvidenceKind(StrEnum):
    OBOM = 'obom'
    SBOM = 'sbom'
    ABOM = 'abom'
    PACKAGE_INVENTORY = 'package_inventory'

models.ImageInfo

class ImageInfo(Model):
    app: ImageApp | None = None
    architectures: list[StrictStr]
    cached: ImageCacheState
    description: StrictStr
    image: StrictStr | None = None
    name: StrictStr
    previous_image: StrictStr | None = None
    progress: ImageDownloadProgress | None = None
    surface: ImageSurface | None = None

models.ImageInterface

class ImageInterface(StrEnum):
    TERMINAL = 'terminal'
    GRAPHICAL = 'graphical'
    WEB = 'web'
    API = 'api'

models.ImageInventoryResponse

class ImageInventoryResponse(Model):
    architecture: StrictStr
    artifact_reference: StrictStr | None = None
    image: StrictStr
    inventory: ImagePackageInventory | None = None

models.ImageListResponse

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

models.ImagePackage

class ImagePackage(Model):
    architecture: StrictStr
    name: StrictStr
    version: StrictStr

models.ImagePackageInventory

class ImagePackageInventory(Model):
    architecture: StrictStr
    packages: list[ImagePackage]
    schema_: StrictStr = Field(alias='schema')
    subject: StrictStr
    tools: list[ImageTool]

models.ImagePullRequest

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

models.ImagePullResponse

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

models.ImageSurface

class ImageSurface(StrEnum):
    TERMINAL = 'terminal'
    XPRA = 'xpra'

models.ImageTool

class ImageTool(Model):
    name: StrictStr
    version: 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)]
    cost_coverage: CostCoverage | None = None
    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')
    labels: dict[str, StrictStr] | None = None
    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', 'pending_approval_count', 'persistent'])
    ai: VmAiInfo | None = None
    allowed_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    app: ImageApp | None = None
    available_actions: list[VmAction]
    browser_request: BrowserRequest | None = None
    can_resume: StrictBool | None = None
    cost_coverage: CostCoverage | 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
    labels: dict[str, StrictStr] | None = None
    last_error: StrictStr | None = None
    model_call_count: Annotated[StrictInt, Field(ge=0)] | None = None
    name: StrictStr | None = None
    network: VmNetworkInfo | None = None
    pending_approval_count: Annotated[StrictInt, Field(ge=0)] | 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
    terminal: TerminalSummary | 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.SecurityAskDecision

class SecurityAskDecision(StrEnum):
    APPROVE = 'approve'
    DENY = 'deny'

models.SecurityAskListResponse

class SecurityAskListResponse(Model):
    generation: StrictStr
    pending_count: Annotated[StrictInt, Field(ge=0)]
    requests: list[SecurityAskRequest]
    vm_id: StrictStr

models.SecurityAskRequest

class SecurityAskRequest(Model):
    ask_id: StrictStr
    created_at_unix_ms: StrictInt
    event_id: StrictStr
    event_type: StrictStr
    expires_at_unix_ms: StrictInt
    resolution_reason: StrictStr | None = None
    resolved_at_unix_ms: StrictInt | None = None
    rule_id: StrictStr
    rule_name: StrictStr
    status: SecurityAskStatus
    summary: StrictStr

models.SecurityAskResolveRequest

class SecurityAskResolveRequest(Model):
    decision: SecurityAskDecision
    generation: StrictStr

models.SecurityAskStatus

class SecurityAskStatus(StrEnum):
    PENDING = 'pending'
    APPROVED = 'approved'
    DENIED = 'denied'
    EXPIRED = 'expired'
    CANCELLED = 'cancelled'

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.StreamControlCloseStdin

class StreamControlCloseStdin(Model):
    type: Literal['close_stdin']

models.StreamControlFocus

class StreamControlFocus(Model):
    cols: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=512)]
    rows: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=256)]
    type: Literal['focus']

models.StreamControlResize

class StreamControlResize(Model):
    cols: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=512)]
    rows: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=256)]
    type: Literal['resize']

models.StreamControlStart

class StreamControlStart(Model):
    command: StrictStr | None = None
    kind: StreamKind
    type: Literal['start']

models.StreamKind

class StreamKind(StrEnum):
    TERMINAL = 'terminal'
    EXEC = 'exec'
    CONTAINER = 'container'

models.StreamStatusError

class StreamStatusError(Model):
    message: StrictStr
    type: Literal['error']

models.StreamStatusExit

class StreamStatusExit(Model):
    code: StrictInt
    truncated: StrictBool
    type: Literal['exit']

models.StreamStatusStarted

class StreamStatusStarted(Model):
    type: Literal['started']

models.StreamStatusTerminal

class StreamStatusTerminal(Model):
    state: TerminalState
    type: Literal['terminal']

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.TerminalCursor

class TerminalCursor(Model):
    col: Annotated[StrictInt, Field(ge=0)]
    hidden: StrictBool
    row: Annotated[StrictInt, Field(ge=0)]

models.TerminalEvent

class TerminalEvent(Model):
    kind: TerminalEventKind
    notification: TerminalNotification | None = None
    visual: StrictBool

models.TerminalEventKind

class TerminalEventKind(StrEnum):
    BELL = 'bell'
    NOTIFICATION = 'notification'

models.TerminalModes

class TerminalModes(Model):
    alternate_screen: StrictBool
    application_cursor: StrictBool
    application_keypad: StrictBool
    bracketed_paste: StrictBool
    mouse_encoding: Annotated[StrictStr, Field(max_length=1024)]
    mouse_protocol: Annotated[StrictStr, Field(max_length=1024)]

models.TerminalNotification

class TerminalNotification(Model):
    body: Annotated[StrictStr, Field(max_length=1024)]
    id: Annotated[StrictStr, Field(max_length=1024)]
    title: Annotated[StrictStr, Field(max_length=1024)]

models.TerminalState

class TerminalState(Model):
    bell_count: Annotated[StrictInt, Field(ge=0)]
    cols: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=512)]
    cursor: TerminalCursor
    events: Annotated[list[TerminalEvent], Field(max_length=32)]
    icon_name: Annotated[StrictStr, Field(max_length=1024)]
    last_notification: TerminalNotification | None = None
    modes: TerminalModes
    reset: StrictBool
    revision: Annotated[StrictInt, Field(ge=0)]
    rows: Annotated[Annotated[StrictInt, Field(ge=1)], Field(le=256)]
    title: Annotated[StrictStr, Field(max_length=1024)]

models.TerminalSummary

class TerminalSummary(Model):
    bell_count: Annotated[StrictInt, Field(ge=0)]
    last_notification: TerminalNotification | None = None
    revision: Annotated[StrictInt, Field(ge=0)]
    title: Annotated[StrictStr, Field(max_length=1024)]

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.UpdateCheckRequest

class UpdateCheckRequest(Model):
    nonnullable_optional = frozenset(['dry_run'])
    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):
    cost_coverage: CostCoverage | None = None
    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)]
    cost_coverage: CostCoverage | None = None
    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', 'pending_approval_count', 'persistent'])
    available_actions: list[VmAction]
    can_resume: StrictBool | None = None
    created_at: StrictStr | None = None
    id: StrictStr
    last_error: StrictStr | None = None
    name: StrictStr
    pending_approval_count: Annotated[StrictInt, Field(ge=0)] | None = None
    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', 'pending_approval_count'])
    allowed_requests: Annotated[StrictInt, Field(ge=0)] | None = None
    app: ImageApp | None = None
    available_actions: list[VmAction]
    browser_request: BrowserRequest | None = None
    can_resume: StrictBool | None = None
    cost_coverage: CostCoverage | 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
    pending_approval_count: Annotated[StrictInt, Field(ge=0)] | None = None
    persistent: StrictBool
    resume_blocked_reason: StrictStr | None = None
    status: VmLifecycleState
    terminal: TerminalSummary | 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_tool_calls: Annotated[StrictInt, Field(ge=0)] | None = None
    uptime_secs: Annotated[StrictInt, Field(ge=0)] | None = None