@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.2

package/dist/sdk/src/auth.d.ts

@@ -0,0 +1,43 @@
+import type { ServiceTransport } from './transport.js';
+import type { AuthorizationEvents } from './authorization-events.js';
+import type { AuthTokens, LoginRequest, LoginResult, AuthStatus, BrowserLoginOptions, BrowserLoginStatus } from './types.js';
+import type { AuthSession, AuthRequiredPasswordChangeRequest, AuthSwitchSubjectRequest, LoginContext } from '../../shared/desktop-api.js';
+export declare class AuthApi {
+    private readonly connection;
+    private readonly authorizationEvents?;
+    constructor(connection: () => ServiceTransport, authorizationEvents?: (() => AuthorizationEvents | undefined) | undefined);
+    /** Owner-only, in-memory notifications. Cancelling observation never revokes authorization. */
+    managedEvents(options?: {
+        after?: string;
+        signal?: AbortSignal;
+    }): AsyncIterable<import("./types.js").ManagedAuthorizationEvent>;
+    login(request: LoginRequest): Promise<LoginResult>;
+    getToken(): Promise<AuthTokens>;
+    refresh(): Promise<AuthTokens>;
+    /** Ask the application's provider for fresh credentials; no tokens are returned. */
+    refreshManaged(): Promise<AuthSession>;
+    revokeManaged(): Promise<void>;
+    status(): Promise<AuthStatus>;
+    context(): Promise<LoginContext | null>;
+    logout(): Promise<void>;
+    completePasswordChange(request: AuthRequiredPasswordChangeRequest): Promise<LoginResult>;
+    switchSubject(request: AuthSwitchSubjectRequest): Promise<AuthSession>;
+    startBrowserLogin(options?: BrowserLoginOptions): Promise<BrowserLogin>;
+    resumeBrowserLogin(requestId: string): BrowserLogin;
+}
+/** The application opens the URL. No Electron or OS browser launcher is required. */
+export declare class BrowserLogin {
+    private readonly transport;
+    readonly id: string;
+    constructor(transport: ServiceTransport, id: string);
+    status(): Promise<BrowserLoginStatus>;
+    cancel(): Promise<BrowserLoginStatus>;
+    getAuthorizationUrl(options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /** Aborting the wait leaves the authorization active; cancel() explicitly revokes it. */
+    wait(options?: {
+        signal?: AbortSignal;
+    }): Promise<AuthSession>;
+    private checkFailure;
+}

package/dist/sdk/src/authorization-events.d.ts

@@ -0,0 +1,16 @@
+import { type ManagedAuthorizationEvent } from '../../shared/managed-authorization.js';
+/** In-memory owner notifications; never store credentials or callback error text. */
+export declare class AuthorizationEvents {
+    private readonly id;
+    private sequence;
+    private readonly records;
+    private readonly listeners;
+    private closed;
+    publish(value: Omit<ManagedAuthorizationEvent, 'cursor' | 'occurredAt'>): void;
+    close(): void;
+    private wake;
+    stream(options?: {
+        after?: string;
+        signal?: AbortSignal;
+    }): AsyncIterable<ManagedAuthorizationEvent>;
+}

package/dist/sdk/src/authorization.d.ts

@@ -0,0 +1,10 @@
+export interface SessionAuthorizationRequest {
+    method: string;
+    sessionId?: string;
+    scope?: string;
+    runId?: string;
+}
+/** An application policy, independent of platform account and model credentials. */
+export type SessionAuthorizer = (request: Readonly<SessionAuthorizationRequest>, context: {
+    signal: AbortSignal;
+}) => boolean | Promise<boolean>;

package/dist/sdk/src/communication.d.ts

@@ -0,0 +1,9 @@
+export interface CommunicationOptions {
+    startupTimeoutMs?: number;
+    /** Observation only. A timeout never cancels or retries the task. Zero disables the timer. */
+    rpcTimeoutMs?: number;
+    methodTimeoutMs?: Record<string, number>;
+    shutdownTimeoutMs?: number;
+}
+export declare function validateCommunication(value?: CommunicationOptions): void;
+export declare function rpcTimeout(method: string, options?: CommunicationOptions): number;

package/dist/sdk/src/diagnostics.d.ts

@@ -0,0 +1,24 @@
+import type { ServiceTransport } from './transport.js';
+export interface DiagnosticRecord {
+    name: 'sdk.rpc';
+    method: string;
+    requestId: string;
+    phase: 'started' | 'completed' | 'failed';
+    durationMs?: number;
+    errorCode?: string;
+}
+export interface DiagnosticSink {
+    log?(record: Readonly<DiagnosticRecord>): void;
+    metric?(name: 'sdk.rpc.duration_ms', value: number, labels: {
+        method: string;
+        outcome: 'completed' | 'failed';
+    }): void;
+    startSpan?(name: 'sdk.rpc', attributes: {
+        method: string;
+        requestId: string;
+    }): {
+        end(record: Readonly<DiagnosticRecord>): void;
+    };
+}
+/** Diagnostic exporters never receive credentials, prompts, arguments or error messages. */
+export declare function instrumentTransport(transport: ServiceTransport, sink?: DiagnosticSink): ServiceTransport;

package/dist/sdk/src/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class AiosSdkError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: ErrorOptions);
+}

package/dist/sdk/src/events.d.ts

@@ -0,0 +1,4 @@
+/** Browser-safe presentation helpers; importing this entry never starts a runtime. */
+export { toolActivityTitle } from '../../shared/tool-activity.js';
+export type { ToolActivityTitle, ToolActivityCategory, ToolDisplayIdentity } from '../../shared/tool-activity.js';
+export type { TaskEvent, SessionEvent, SessionEventPage, TaskMessage, TaskInteraction, RunState } from './types.js';

package/dist/sdk/src/file-api.d.ts

@@ -0,0 +1,29 @@
+import type { ServiceTransport } from './transport.js';
+import type { FileReference, FileStorageAdapter, StoredFileReference } from './file-storage.js';
+export declare class SessionFiles {
+    private readonly transport;
+    private readonly sessionId;
+    constructor(transport: ServiceTransport, sessionId: string);
+    resolve(path: string, access?: 'read' | 'write', signal?: AbortSignal): Promise<FileReference>;
+    private call;
+    export(path: string, adapter: FileStorageAdapter, options: {
+        key: string;
+        expectedVersion?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        stored: StoredFileReference;
+        file: FileReference;
+        sha256: string;
+        bytes: number;
+    }>;
+    import(reference: StoredFileReference, adapter: FileStorageAdapter, options: {
+        path: string;
+        expectedVersion: string | null;
+        signal?: AbortSignal;
+    }): Promise<{
+        file: FileReference & {
+            sha256: string;
+        };
+        source: StoredFileReference;
+    }>;
+}

package/dist/sdk/src/file-storage.d.ts

@@ -0,0 +1,34 @@
+export interface FileReference {
+    absolutePath: string;
+    toolPath: string;
+    workspaceRelativePath?: string;
+    access: 'read' | 'write';
+    exists: boolean;
+    bytes?: number;
+}
+export interface StoredFileReference {
+    key: string;
+    version: string;
+    metadata?: Record<string, string>;
+}
+export interface FileStorageAdapter {
+    /** Export immutable bytes; return the object version actually stored. */
+    put(request: {
+        key: string;
+        source: AsyncIterable<Uint8Array>;
+        sha256: string;
+        bytes: number;
+        expectedVersion?: string;
+        signal?: AbortSignal;
+    }): Promise<StoredFileReference>;
+    /** Fetch an explicit version, never silently return the latest version. */
+    get(request: {
+        key: string;
+        version: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        source: AsyncIterable<Uint8Array>;
+        sha256: string;
+        bytes: number;
+    }>;
+}

package/dist/sdk/src/index.d.ts

@@ -0,0 +1,260 @@
+import { type ServiceTransport } from './transport.js';
+import type { CliConnectionOptions, ClientServices } from './types.js';
+import { serveBusinessTools } from './tool-server.js';
+import { SessionFiles } from './file-api.js';
+export type { ToolLifecycleEvent, ToolHookDecision } from '../../shared/js-agent-hooks.js';
+export type { SessionAuthorizer, SessionAuthorizationRequest } from './authorization.js';
+export type { MemoryConfiguration, MemoryExtractionPolicy, MemorySnapshot, MemoryStoreAdapter } from '../../shared/memory-customization.js';
+export type { DiagnosticSink, DiagnosticRecord } from './diagnostics.js';
+export type { CommunicationOptions } from './communication.js';
+export type { FileReference, StoredFileReference, FileStorageAdapter } from './file-storage.js';
+export { applicationToolProviderId, applicationToolReference } from './tool-reference.js';
+import { AuthApi } from './auth.js';
+import { PlatformApi } from './platform.js';
+import { ManagedHost } from './managed-host.js';
+import type { AgentDefinition, CapabilityQuery, ClientOptions, ClientConfiguration, ConfigurationUpdate, EffectiveCapability, ExecutionDefaults, LocalPreferences, LocalPreferenceDomain, RunState, SendOptions, SessionInfo, TaskEvent } from './types.js';
+export * from './types.js';
+export type { CompactionPolicy, RuntimeTuning, GenerationOptions, GenerationCapabilities } from '../../shared/runtime-tuning.js';
+export * from './runtime-control.js';
+export { ManagedHost } from './managed-host.js';
+export type { VerifiedRuntime } from './runtime-integrity.js';
+export { toolResult } from './tool-result.js';
+export type { ToolResult, ToolContent } from './tool-result.js';
+export { AiosSdkError } from './errors.js';
+export { AuthApi, BrowserLogin } from './auth.js';
+export { PlatformApi } from './platform.js';
+export { validateSdkRuntimeDirectory as validateRuntime } from './runtime-integrity.js';
+export declare class AiosClient {
+    private transport;
+    private options;
+    readonly mode: ClientOptions['mode'];
+    private readonly services;
+    private readonly toolProviders;
+    private readonly activeToolProviders;
+    private credentialProvider?;
+    private callbacks?;
+    private readonly callbackHandlers;
+    private lifecycleQueue;
+    private closed;
+    private scheduleLifecycle;
+    private assertOpen;
+    private startCallbacks;
+    private constructor();
+    private static start;
+    static create(input: ClientOptions, services?: ClientServices): Promise<AiosClient>;
+    static startManaged(input: ClientOptions, lifecycle: import('./runtime-control.js').ManagedHostOptions): Promise<ManagedHost>;
+    static connectCli(options: CliConnectionOptions): Promise<AiosClient>;
+    readonly auth: AuthApi;
+    readonly platform: PlatformApi;
+    readonly runtime: {
+        health: (signal?: AbortSignal) => Promise<import("./runtime-control.js").RuntimeHealth>;
+        activity: () => Promise<import("./runtime-control.js").RuntimeActivity>;
+        drain: (options: import("./runtime-control.js").DrainOptions, signal?: AbortSignal) => Promise<import("./runtime-control.js").DrainResult>;
+    };
+    readonly resources: {
+        limits: {
+            get: () => Promise<import("../../cli/daemon/resource-limits.js").ResourceSettings>;
+            set: <K extends import("./runtime-control.js").RuntimeLimitKey>(key: K, value: import("./runtime-control.js").RuntimeLimits["values"][K] | undefined, revision: number) => Promise<import("../../cli/daemon/resource-limits.js").ResourceSettings>;
+        };
+        cache: {
+            status: () => Promise<import("./runtime-control.js").RuntimeCacheStatus>;
+            prune: (options?: {
+                apply?: boolean;
+                revision?: string;
+            }) => Promise<import("./runtime-control.js").RuntimeCachePruneResult>;
+        };
+    };
+    readonly skills: {
+        list: () => Promise<import("./types.js").LocalSkillDefinition[]>;
+        /** Installs an additive immutable package version; does not change task selections. */
+        importVersion: (request: {
+            packagePath: string;
+            folderName: string;
+            packageSha256: string;
+        }) => Promise<import("./types.js").LocalSkillDefinition>;
+        importPaths: (paths: string[]) => Promise<import("./types.js").LocalSkillDefinition[]>;
+        remove: (reference: string) => Promise<void>;
+    };
+    readonly plugins: {
+        list: () => Promise<import("./types.js").LocalPluginInstallation[]>;
+        install: (recordId: string, source: "PLATFORM" | "ENTERPRISE") => Promise<import("./types.js").LocalPluginInstallation>;
+        update: (pluginId: string, recordId: string, expectedRevision: string) => Promise<import("./types.js").PluginUpdateResult>;
+        setEnabled: (pluginId: string, enabled: boolean, expectedRevision: string) => Promise<import("./types.js").LocalPluginInstallation>;
+        remove: (pluginId: string, expectedRevision: string) => Promise<void>;
+    };
+    readonly settings: {
+        get: () => Promise<import("../../cli/daemon/preferences.js").Preferences>;
+        set: <K extends LocalPreferenceDomain>(domain: K, value: LocalPreferences[K], revision: number) => Promise<import("../../cli/daemon/preferences.js").Preferences>;
+    };
+    readonly native: {
+        settings: () => Promise<import("./native-status.js").NativeSettings>;
+        configure: (value: import("./types.js").ComputerUseSettings, revision: number) => Promise<import("./native-status.js").NativeSettings>;
+        status: (kind: "computer" | "browser") => Promise<import("./native-status.js").NativeCapabilityStatus>;
+        registerBrowser: () => Promise<unknown>;
+        unregisterBrowser: () => Promise<unknown>;
+    };
+    readonly memory: import('./types.js').SessionMemoryApi;
+    setPlatformBaseUrl(url: string): Promise<void>;
+    getConfiguration(): Promise<ClientConfiguration>;
+    /** Runtime settings require exclusive idle ownership. Reopen sessions and register agents afterwards. */
+    configure(patch: ConfigurationUpdate): Promise<ClientConfiguration>;
+    private applyConfiguration;
+    capabilities(query?: CapabilityQuery): Promise<EffectiveCapability[]>;
+    dependencies(): Promise<import("../../core/host/runtime-dependencies.js").ResolvedRuntimeDependencies>;
+    defineAgent(definition: AgentDefinition): Promise<Agent>;
+    private registerAgent;
+    openSession(id: string): Promise<Session>;
+    /** Reopen an immutable, already defined agent version without replacing its tool registrations. */
+    openAgent(id: string, version: string): Promise<Agent>;
+    listSessions(query?: {
+        scope?: string;
+        includeArchived?: boolean;
+    }): Promise<SessionInfo[]>;
+    shutdown(): Promise<void>;
+    close(): Promise<void>;
+    private disconnect;
+}
+export declare class Agent {
+    private readonly transport;
+    readonly id: string;
+    readonly version: string;
+    private readonly provider?;
+    readonly tools: ReadonlyArray<{
+        name: string;
+        reference: string;
+    }>;
+    private readonly assertCurrentProvider;
+    constructor(transport: ServiceTransport, id: string, version: string, provider?: Awaited<ReturnType<typeof serveBusinessTools>> | undefined, tools?: ReadonlyArray<{
+        name: string;
+        reference: string;
+    }>, assertCurrentProvider?: () => void);
+    createSession(options?: import('./types.js').SessionCreateOptions): Promise<Session>;
+    adoptSession(id: string, options?: {
+        policy?: import('./types.js').SessionScopePolicy;
+    }): Promise<Session>;
+    providerStatus(): Promise<import("./types.js").ProviderStatus>;
+    /** Removes registration for future turns. Existing calls finish or use their normal cancellation path. */
+    unregisterProvider(): Promise<import("./types.js").ProviderStatus>;
+    /** Stop new MCP sessions; existing sessions and calls drain before the HTTP server closes. */
+    releaseProvider(): Promise<{
+        retired: boolean;
+        sessions: number;
+        calls: number;
+        closing: boolean;
+    } | undefined>;
+    waitProviderClosed(): Promise<void>;
+}
+export declare class Session {
+    private readonly transport;
+    readonly info: SessionInfo;
+    readonly id: string;
+    readonly files: SessionFiles;
+    runtimeTuning(): Promise<import("../../shared/runtime-tuning.js").RuntimeTuningState>;
+    constructor(transport: ServiceTransport, info: SessionInfo);
+    readonly memory: {
+        get: (request?: {
+            page?: number;
+        }) => Promise<import("./types.js").MemoryView>;
+        edit: (request: Omit<import("./types.js").MemoryEditRequest, "sessionId">) => Promise<import("./types.js").MemoryView>;
+        reset: () => Promise<import("./types.js").MemoryView>;
+        setEnabled: (enabled: boolean) => Promise<import("./types.js").MemoryView>;
+    };
+    send(content: string, options?: SendOptions): Promise<Run>;
+    enqueue(content: string, options?: SendOptions): Promise<import("../../shared/local-task-command.js").LocalTaskCommandResult>;
+    queue(): Promise<import("./types.js").QueueSnapshot>;
+    editQueued(messageId: string, content: string, queueVersion: string, commandId?: string): Promise<import("../../shared/local-task-command.js").LocalTaskCommandResult>;
+    removeQueued(messageId: string, snapshot: Pick<import('./types.js').QueueSnapshot, 'queueVersion' | 'activeRunId'>, commandId?: string): Promise<import("../../shared/local-task-command.js").LocalTaskCommandResult>;
+    reorderQueue(messageIds: string[], queueVersion: string, commandId?: string): Promise<import("../../shared/local-task-command.js").LocalTaskCommandResult>;
+    /** A non-null targetRunId adds this message to that active run; null starts its own run. */
+    dispatchQueued(messageId: string, queueVersion: string, targetRunId: string | null, commandId?: string): Promise<import("../../shared/local-task-command.js").LocalTaskCommandResult>;
+    history(): Promise<import("../../shared/local-task-api.js").LocalTaskMessage[]>;
+    rename(name: string, expectedRevision: string): Promise<SessionInfo>;
+    setArchived(archived: boolean, expectedRevision: string): Promise<SessionInfo>;
+    runs(query?: import('./types.js').RunQuery, signal?: AbortSignal): Promise<import("./types.js").RunPage>;
+    /** Durable execution events across runs. Aborting this observer never cancels a task. */
+    events(options?: import('./types.js').EventObservationOptions): AsyncGenerator<import('./types.js').SessionEvent>;
+    eventPage(options?: {
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").SessionEventPage>;
+    queryHistory(query?: import('./types.js').HistoryQuery): Promise<import("./types.js").HistoryPage>;
+    clear(options: {
+        historyVersion: string;
+        cancelActive?: boolean;
+    }): Promise<SessionInfo>;
+    delete(options: {
+        historyVersion: string;
+        cancelActive?: boolean;
+    }): Promise<{
+        retainedWorkspace?: string;
+    }>;
+    artifacts(query?: import('./types.js').ArtifactQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").SessionArtifact[]>;
+    operations(query?: {
+        runId?: string;
+    }): Promise<import("./types.js").TaskOperationReference[]>;
+    teamState(): Promise<import("./types.js").TeamState | null>;
+    /** Independent Session: send explicitly; the parent neither waits for it nor cancels it. */
+    createBackgroundSession(memberId: string, creationId?: string): Promise<Session>;
+    operation(operationId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").TaskOperationSnapshot>;
+    cancelOperation(operationId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").TaskOperationSnapshot>;
+    configuration(revision?: number): Promise<import("./types.js").SessionConfiguration>;
+    configure(defaults: Partial<Omit<ExecutionDefaults, 'contextWindow' | 'reasoningEffort' | 'runtimeTuning'>> & {
+        contextWindow?: number | null;
+        reasoningEffort?: ExecutionDefaults['reasoningEffort'] | null;
+        runtimeTuning?: ExecutionDefaults['runtimeTuning'] | null;
+    }, expectedRevision?: number): Promise<ExecutionDefaults>;
+    configureBuiltins(builtins: import('./types.js').BuiltinSelection, expectedRevision?: number): Promise<void>;
+    /** Applies a registered agent version at the target session's idle boundary, preserving its history. */
+    updateAgent(update: import('./types.js').SessionAgentUpdate): Promise<import("./types.js").SessionConfiguration>;
+    receipt(commandId: string): Promise<import("./types.js").CommandReceipt>;
+    resumeRun(runId: string): Run;
+    compact(commandId?: string): Promise<Run>;
+}
+export declare class Run {
+    private readonly transport;
+    readonly taskId: string;
+    readonly id: string;
+    readonly commandId?: string | undefined;
+    constructor(transport: ServiceTransport, taskId: string, id: string, commandId?: string | undefined);
+    state(options?: {
+        signal?: AbortSignal;
+    }): Promise<RunState>;
+    context(): Promise<import("./types.js").ExecutionBinding | null>;
+    memoryPolicy(): Promise<import("./types.js").SessionMemoryPolicy | null>;
+    team(command: import('./types.js').TeamCommand, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").TeamCommandResult>;
+    artifacts(query?: Omit<import('./types.js').ArtifactQuery, 'runId'>, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").SessionArtifact[]>;
+    operations(): Promise<import("./types.js").TaskOperationReference[]>;
+    operation(operationId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").TaskOperationSnapshot>;
+    cancelOperation(operationId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./types.js").TaskOperationSnapshot>;
+    cancel(commandId?: string): Promise<void>;
+    detach(): Promise<void>;
+    approve(toolCallId: string, decision: 'approve' | 'approve_for_session' | 'deny', commandId?: string): Promise<void>;
+    answer(requestId: string, response: Record<string, unknown>, commandId?: string): Promise<void>;
+    cancelInput(requestId: string, commandId?: string): Promise<void>;
+    confirmPlan(commandId?: string): Promise<Run>;
+    /** Aborting observation never sends task cancellation. */
+    events(options?: {
+        cursor?: string;
+        signal?: AbortSignal;
+    }): AsyncGenerator<TaskEvent>;
+    wait(options?: {
+        signal?: AbortSignal;
+    }): Promise<RunState>;
+}
+export declare const createClient: typeof AiosClient.create;
+export declare const connectCli: typeof AiosClient.connectCli;
+export declare const startManagedHost: typeof AiosClient.startManaged;

package/dist/sdk/src/local-connection.d.ts

@@ -0,0 +1,9 @@
+import { type DaemonMetadata } from '../../cli/daemon/protocol.js';
+export interface SdkServiceMetadata extends DaemonMetadata {
+    sdkProtocol: 1;
+    manifestSha256?: string;
+}
+export declare function readCliService(root: string): DaemonMetadata;
+export declare function readSdkService(root: string): SdkServiceMetadata | undefined;
+export declare function waitSdkService(root: string, signal: AbortSignal): Promise<SdkServiceMetadata>;
+export declare function callSdkService<T>(metadata: DaemonMetadata, clientId: string, method: string, params: unknown, requestId: string, signal?: AbortSignal, timeoutMs?: number): Promise<T>;

package/dist/sdk/src/managed-host.d.ts

@@ -0,0 +1,32 @@
+import type { AiosClient } from './index.js';
+import type { ClientOptions, ClientServices, ResolvedClientOptions } from './types.js';
+import type { DrainResult, HostExit, ManagedHostOptions } from './runtime-control.js';
+import type { SdkServiceMetadata } from './local-connection.js';
+import { type VerifiedRuntime } from './runtime-integrity.js';
+type Connect = (options: ResolvedClientOptions, metadata: SdkServiceMetadata, verified: VerifiedRuntime, services: ClientServices, exitSignal: AbortSignal) => Promise<AiosClient>;
+/** Owns one child process. Closing an attached client never closes this handle or the process. */
+export declare class ManagedHost {
+    private readonly options;
+    private readonly metadata;
+    private readonly verified;
+    private readonly child;
+    private readonly exited;
+    private readonly connector;
+    private exit?;
+    private readonly exitController;
+    private shutdownRequest?;
+    private readonly pending;
+    private constructor();
+    /** @internal Use startManagedHost, which supplies the public client connection factory. */
+    static start(input: ClientOptions, lifecycle: ManagedHostOptions, connect: Connect): Promise<ManagedHost>;
+    get pid(): number;
+    get instanceId(): string;
+    connect(services?: ClientServices): Promise<AiosClient>;
+    /** No observer timeout or implicit kill. The startup shutdown policy controls drain and cancellation. */
+    shutdown(): Promise<DrainResult>;
+    wait(): Promise<HostExit>;
+    private readonly onMessage;
+    private readonly onError;
+    private readonly onDisconnect;
+}
+export {};

package/dist/sdk/src/native-status.d.ts

@@ -0,0 +1,59 @@
+import type { ComputerUseSettings } from '../../shared/computer-use-api.js';
+import type { ComputerUseBrowserAction } from '../../shared/computer-use-protocol.js';
+import type { ComputerUsePeerMetadata } from '../../shared/computer-use-handshake.js';
+export interface NativeSettings {
+    version: 1;
+    revision: number;
+    computerUse: ComputerUseSettings;
+}
+export interface NativeHelperStatus {
+    running: boolean;
+    pid?: number;
+    platform: 'darwin' | 'win32' | 'linux';
+    executablePath: string;
+    executableAvailable: boolean;
+    protocolVersion: number;
+    protocolValidated: boolean;
+    architectureVersion?: number;
+    architectureValidated?: boolean;
+    invariants?: string[];
+    capabilities?: {
+        uiAutomation?: boolean;
+        screenCapture?: boolean;
+        targetIntegrityBoundary?: string;
+        uiAutomationError?: string;
+        screenCaptureError?: string;
+    };
+    error?: string;
+}
+export interface NativeRegistrationStatus {
+    registered: boolean;
+    manifestPath: string;
+    extensionDirectory: string;
+    error?: string;
+}
+export interface NativeConnectionStatus {
+    running: boolean;
+    hostConnected: boolean;
+    extensionConnected: boolean;
+    extensionUserAgent?: string;
+    extensionSupportedActions: ComputerUseBrowserAction[];
+    protocolVersion: number;
+    peers?: Partial<Record<ComputerUsePeerMetadata['role'], ComputerUsePeerMetadata>>;
+    native?: NativeHelperStatus;
+    lastHeartbeatAt?: string;
+    error?: string;
+}
+/** Serialized SDK response; no dependency on an execution host implementation. */
+export interface NativeCapabilityStatus {
+    id: string;
+    available: boolean;
+    reason: string | null;
+    configuration: NativeSettings;
+    verification?: string;
+    helper?: NativeHelperStatus;
+    permissions?: unknown;
+    extensionId?: string;
+    registration?: NativeRegistrationStatus;
+    connection?: NativeConnectionStatus;
+}

package/dist/sdk/src/platform.d.ts

@@ -0,0 +1,39 @@
+import type { ServiceTransport } from './transport.js';
+import type { AuthSession, PlatformUser, TenantSummary, LoginContext } from '../../shared/desktop-api.js';
+import type { AvailableChatModel } from '../../shared/cloud-assistant-api.js';
+import type { AccountContextQuery, AccountContextSummary, AccountPlanPurchase } from '../../shared/account-context-api.js';
+import type { PersonalUsageStatistics } from '../../shared/usage-statistics-api.js';
+import type { SkillMarketApi } from '../../shared/skill-market-api.js';
+import type { PluginMarketApi } from '../../shared/plugin-market-api.js';
+import type { EnterpriseKnowledgeApi } from '../../shared/enterprise-knowledge-api.js';
+import type { ExpertSelection, PreparedExpertAgent, ResolvedExpertSource } from '../../shared/expert-selection.js';
+/** Explicit platform queries, independent of the model's builtin tool permissions. */
+export declare class PlatformApi {
+    private readonly connection;
+    constructor(connection: () => ServiceTransport);
+    private call;
+    getSession(): Promise<AuthSession>;
+    getUser(): Promise<PlatformUser>;
+    getTenants(): Promise<TenantSummary[]>;
+    getContext(): Promise<LoginContext | null>;
+    readonly models: {
+        list: () => Promise<AvailableChatModel[]>;
+        listSpeechRecognition: () => Promise<AvailableChatModel[]>;
+    };
+    readonly experts: {
+        prepare: (selection: ExpertSelection, resolved?: ResolvedExpertSource) => Promise<PreparedExpertAgent>;
+    };
+    readonly account: {
+        getSummary: (query?: AccountContextQuery) => Promise<AccountContextSummary>;
+        listPlanPurchases: () => Promise<AccountPlanPurchase[]>;
+        getUsage: (query: {
+            endDate: string;
+        }) => Promise<PersonalUsageStatistics>;
+    };
+    readonly skills: SkillMarketApi & {
+        getVersions: (selection: import('./types.js').SkillVersionSelection) => Promise<import('./types.js').SkillVersionInfo>;
+        updateVersion: (request: import('./types.js').SkillVersionUpdate) => Promise<import('./types.js').SkillVersionUpdateResult>;
+    };
+    readonly plugins: PluginMarketApi;
+    readonly knowledge: EnterpriseKnowledgeApi;
+}