@rivet-dev/agentos-core 0.0.0-main.29b0797 → 0.0.0-main.5ac5a14

package/dist/agent-os.d.ts

@@ -1,13 +1,16 @@
 import type { NativeMountPluginDescriptor } from "@rivet-dev/agentos-runtime-core/descriptors";
 import type { VmUserConfig } from "@rivet-dev/agentos-runtime-core/vm-config";
-import type { CancelPromptResult, HistoryPage, ListSessionsInput, OpenSessionInput, PermissionResponse, PermissionResponseResult, PromptInput, PromptResult as DurablePromptResult, ReadHistoryInput, SessionCapabilities, SessionAgentInfo, SessionConfig, SessionInfo as DurableSessionInfo, SessionPage, SessionStreamEntry, SessionTarget, SetSessionConfigOptionInput } from "./session-api.js";
 import { type Bindings } from "./bindings.js";
-import type { ConnectTerminalOptions, Kernel, KernelExecOptions, KernelExecResult, ProcessInfo as KernelProcessInfo, KernelSpawnOptions, OpenShellOptions, Permissions, VirtualFileSystem, VirtualStat } from "./runtime-compat.js";
+import type { CodeEvaluationResult, CodeExecutionResult, ContextDescriptor, ExecutionSignal, InlineExecutionOptions, JavaScriptEvaluationOptions, JavaScriptExecutionOptions, LanguageExecutionOptions, LanguageSpawnOptions, NpmPackageInstallOptions, NpmProjectInstallOptions, OutputReplay, ProcessDescriptor, ProcessExit, PythonInstallOptions, SpawnOptions, TypeScriptCheckOptions, TypeScriptCheckResult, TypeScriptEvaluationOptions, TypeScriptExecutionOptions, TypeScriptFileExecutionOptions } from "./language-execution.js";
+import type { ConnectTerminalOptions, Kernel, KernelExecOptions, KernelExecResult, OpenShellOptions, Permissions, VirtualFileSystem, VirtualStat } from "./runtime-compat.js";
+import { type AgentOsSandboxInput } from "./sandbox.js";
+import type { CancelPromptResult, PromptResult as DurablePromptResult, SessionInfo as DurableSessionInfo, HistoryPage, JsonValue, ListSessionsInput, OpenSessionInput, PermissionResponse, PermissionResponseResult, PromptInput, ReadHistoryInput, SessionAgentInfo, SessionCapabilities, SessionConfig, SessionPage, SessionStreamEntry, SessionTarget, SetSessionConfigOptionInput } from "./session-api.js";
 export type { MountConfigJsonObject, MountConfigJsonPrimitive, MountConfigJsonValue, NativeMountPluginDescriptor, } from "@rivet-dev/agentos-runtime-core/descriptors";
 export type { ConnectTerminalOptions } from "./runtime-compat.js";
 export type * from "./session-api.js";
-/** Process tree node: extends kernel ProcessInfo with child references. */
-export interface ProcessTreeNode extends KernelProcessInfo {
+/** Process tree node using the same descriptor shape as process.get/list. */
+export interface ProcessTreeNode extends ProcessDescriptor {
+    ppid?: number;
     children: ProcessTreeNode[];
 }
 /** A directory entry with metadata. */
@@ -43,10 +46,6 @@ export interface ProcessOutput {
     stream: "stdout" | "stderr";
     data: Uint8Array;
 }
-export interface ProcessExit {
-    pid: number;
-    exitCode: number;
-}
 export interface ShellData {
     shellId: string;
     data: Uint8Array;
@@ -71,8 +70,6 @@ export interface DynamicMountDescriptor {
     plugin: NativeMountPluginDescriptor;
     readOnly?: boolean;
 }
-/** Callback-free options accepted by the portable spawn API. */
-export type SpawnOptions = Omit<KernelSpawnOptions, "onStdout" | "onStderr">;
 /** Callback-free options accepted by the portable openShell API. */
 export type ShellOptions = Omit<OpenShellOptions, "onStderr">;
 /** Options for readdirRecursive(). */
@@ -149,7 +146,6 @@ export type RootFilesystemConfig = OverlayRootFilesystemConfig | NativeRootFiles
 export type VmSqliteConfig = {
     type: "actor_uds";
     path: string;
-    token: string;
 } | {
     type: "sqlite_file";
     path: string;
@@ -226,12 +222,16 @@ export interface AgentOsLimits {
         /** Cap on `vm.httpRequest()` buffered response bodies. Must be <= the sidecar wire frame cap. */
         maxFetchResponseBytes?: number;
     };
+    /** TLS plaintext buffering limits. */
+    tls?: {
+        maxBufferedBytes?: number;
+    };
     /** Host binding registration and invocation limits. */
     bindings?: {
         defaultBindingTimeoutMs?: number;
         maxBindingTimeoutMs?: number;
         maxRegisteredCollections?: number;
-        maxRegisteredCollectionsPerVm?: number;
+        maxRegisteredBindingsPerVm?: number;
         maxBindingsPerCollection?: number;
         maxBindingSchemaBytes?: number;
         maxExamplesPerBinding?: number;
@@ -394,6 +394,8 @@ export interface AgentOsOptions {
     rootFilesystem?: RootFilesystemConfig;
     /** Filesystems to mount at boot time. */
     mounts?: MountConfig[];
+    /** External sandbox mounted into this VM with process bindings. */
+    sandbox?: AgentOsSandboxInput;
     /** Custom schedule driver for cron jobs. Defaults to TimerScheduleDriver. */
     scheduleDriver?: ScheduleDriver;
     /** Host-side bindings available to agents inside the VM. */
@@ -440,20 +442,16 @@ export interface AgentOsRuntimeAdmin {
     env: Record<string, string>;
     sidecar: AgentOsSidecar;
 }
-/** Information about a process spawned via AgentOs.spawn(). */
-export interface SpawnedProcessInfo {
-    pid: number;
-    command: string;
-    args: string[];
-    running: boolean;
-    exitCode: number | null;
-}
 export declare class AgentOs {
     #private;
     readonly sidecar: AgentOsSidecar;
     private _durableSessionEventHandlers;
     private _agentExitHandlers;
     private _processes;
+    private _languageProcesses;
+    private _languageProcessIds;
+    private _executionOutputHandlers;
+    private _executionCompletedHandlers;
     private _shells;
     private _closedShellIds;
     private _pendingShellExitPromises;
@@ -476,64 +474,293 @@ export declare class AgentOs {
     private readonly _agentStderrHandler?;
     private readonly _agentExitHandler?;
     private readonly _limitWarningHandler?;
+    private readonly _disposeHooks;
+    /**
+     * Execute commands and manage child processes in the VM.
+     *
+     * `exec` evaluates a command with the configured shell, while `execFile`
+     * invokes an executable directly with an argv array.
+     */
+    readonly process: {
+        exec: (command: string, options?: LanguageExecutionOptions) => Promise<CodeExecutionResult>;
+        execFile: (command: string, args?: readonly string[], options?: Omit<LanguageExecutionOptions, "args">) => Promise<CodeExecutionResult>;
+        spawn: (command: string, args?: string[], options?: SpawnOptions) => Promise<ProcessDescriptor>;
+        get: (pid: number) => Promise<ProcessDescriptor>;
+        list: () => Promise<ProcessDescriptor[]>;
+        tree: () => Promise<ProcessTreeNode[]>;
+        wait: (pid: number) => Promise<ProcessExit>;
+        signal: (pid: number, signal: ExecutionSignal) => Promise<void>;
+        kill: (pid: number) => Promise<void>;
+        writeStdin: (pid: number, data: string | Uint8Array) => Promise<void>;
+        closeStdin: (pid: number) => Promise<void>;
+        resizePty: (pid: number, size: {
+            cols: number;
+            rows: number;
+        }) => Promise<void>;
+        readOutput: (pid: number, options?: {
+            after?: number;
+        }) => Promise<OutputReplay>;
+    };
+    readonly javascript: {
+        execute: (source: string, options?: JavaScriptExecutionOptions) => Promise<CodeExecutionResult>;
+        evaluate: <T = JsonValue>(expression: string, options?: JavaScriptEvaluationOptions) => Promise<CodeEvaluationResult<T>>;
+        executeFile: (path: string, options?: LanguageExecutionOptions) => Promise<CodeExecutionResult>;
+        spawn: (source: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        spawnFile: (path: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        npm: {
+            install: {
+                (options?: NpmProjectInstallOptions): Promise<CodeExecutionResult>;
+                (packages: string | string[], options?: NpmPackageInstallOptions): Promise<CodeExecutionResult>;
+            };
+            runScript: (script: string, options?: LanguageExecutionOptions) => Promise<CodeExecutionResult>;
+            runPackage: (packageSpec: string, options?: LanguageExecutionOptions & {
+                binary?: string;
+            }) => Promise<CodeExecutionResult>;
+        };
+    };
+    readonly typescript: {
+        execute: (source: string, options?: TypeScriptExecutionOptions) => Promise<CodeExecutionResult>;
+        evaluate: <T = JsonValue>(expression: string, options?: TypeScriptEvaluationOptions) => Promise<CodeEvaluationResult<T>>;
+        executeFile: (path: string, options?: TypeScriptFileExecutionOptions) => Promise<CodeExecutionResult>;
+        spawn: (source: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        spawnFile: (path: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        check: (source: string, options?: TypeScriptCheckOptions) => Promise<TypeScriptCheckResult>;
+        checkProject: (options?: Omit<TypeScriptCheckOptions, "filePath" | "compilerOptions">) => Promise<TypeScriptCheckResult>;
+    };
+    readonly python: {
+        execute: (source: string, options?: InlineExecutionOptions) => Promise<CodeExecutionResult>;
+        evaluate: <T = JsonValue>(expression: string, options?: InlineExecutionOptions) => Promise<CodeEvaluationResult<T>>;
+        executeFile: (path: string, options?: LanguageExecutionOptions) => Promise<CodeExecutionResult>;
+        executeModule: (module: string, options?: LanguageExecutionOptions) => Promise<CodeExecutionResult>;
+        spawn: (source: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        spawnFile: (path: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        spawnModule: (module: string, options?: LanguageSpawnOptions) => Promise<ProcessDescriptor>;
+        install: {
+            (options?: PythonInstallOptions): Promise<CodeExecutionResult>;
+            (packages: string | string[], options?: PythonInstallOptions): Promise<CodeExecutionResult>;
+        };
+    };
+    readonly contexts: {
+        get: (contextId: string) => Promise<ContextDescriptor>;
+        list: () => Promise<ContextDescriptor[]>;
+        reset: (contextId: string) => Promise<void>;
+        delete: (contextId: string) => Promise<void>;
+    };
+    readonly terminal: {
+        open: (options?: ShellOptions) => {
+            shellId: string;
+        };
+        write: (shellId: string, data: string | Uint8Array) => Promise<void>;
+        resize: (shellId: string, cols: number, rows: number) => void;
+        wait: (shellId: string) => Promise<number>;
+        close: (shellId: string) => void;
+    };
+    readonly filesystem: {
+        readFile: (path: string) => Promise<Uint8Array>;
+        writeFile: (path: string, content: string | Uint8Array) => Promise<void>;
+        readFiles: (paths: string[]) => Promise<BatchReadResult[]>;
+        writeFiles: (entries: BatchWriteEntry[]) => Promise<BatchWriteResult[]>;
+        stat: (path: string) => Promise<VirtualStat>;
+        mkdir: (path: string, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
+        readdir: (path: string) => Promise<string[]>;
+        readdirEntries: (path: string) => Promise<ReaddirEntry[]>;
+        readdirRecursive: (path: string, options?: ReaddirRecursiveOptions) => Promise<DirEntry[]>;
+        exists: (path: string) => Promise<boolean>;
+        move: (from: string, to: string) => Promise<void>;
+        remove: (path: string, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
+        export: (options: ExportRootFilesystemOptions) => Promise<RootSnapshotExport>;
+        mount: (descriptor: DynamicMountDescriptor) => Promise<void>;
+        unmount: (path: string) => Promise<void>;
+        listMounts: () => Promise<MountInfo[]>;
+    };
+    readonly network: {
+        httpRequest: (request: HttpRequest) => Promise<HttpResponse>;
+    };
+    readonly software: {
+        list: () => Promise<{
+            packageName: string;
+            commands: string[];
+        }[]>;
+        link: (descriptor: PackageDescriptor) => Promise<void>;
+    };
+    readonly agents: {
+        list: () => Promise<AgentRegistryEntry[]>;
+    };
+    readonly sessions: {
+        open: (input: OpenSessionInput) => Promise<void>;
+        get: (input?: SessionTarget) => Promise<DurableSessionInfo>;
+        list: (input?: ListSessionsInput) => Promise<SessionPage>;
+        delete: (input?: SessionTarget) => Promise<void>;
+        unload: (input?: SessionTarget) => Promise<void>;
+        prompt: (input: PromptInput) => Promise<DurablePromptResult>;
+        cancelPrompt: (input?: SessionTarget) => Promise<CancelPromptResult>;
+        respondPermission: (input: PermissionResponse) => Promise<PermissionResponseResult>;
+        readHistory: (input?: ReadHistoryInput) => Promise<HistoryPage>;
+        getConfig: (input?: SessionTarget) => Promise<SessionConfig>;
+        setConfigOption: (input: SetSessionConfigOptionInput) => Promise<SessionConfig>;
+        getCapabilities: (input?: SessionTarget) => Promise<SessionCapabilities | null>;
+        getAgentInfo: (input?: SessionTarget) => Promise<SessionAgentInfo | null>;
+    };
+    readonly cron: {
+        schedule: (options: CronJobOptions) => CronJob;
+        list: () => CronJobInfo[];
+        cancel: (id: string) => void;
+    };
     private constructor();
     static createSidecar(options?: AgentOsCreateSidecarOptions): Promise<AgentOsSidecar>;
     static getSharedSidecar(options?: AgentOsSharedSidecarOptions): Promise<AgentOsSidecar>;
     static create(options?: AgentOsOptions): Promise<AgentOs>;
+    createContext(contextId: string): Promise<void>;
+    private _executionOperation;
+    private _spawnLanguageOperation;
+    private _exec;
+    private _execFile;
+    /** @deprecated Use `process.exec()` for lifecycle-aware execution. */
     exec(command: string, options?: KernelExecOptions): Promise<KernelExecResult>;
+    /** @deprecated Use `process.execFile()` for lifecycle-aware execution. */
     execArgv(command: string, args?: readonly string[], options?: KernelExecOptions): Promise<KernelExecResult>;
+    private _executeJavaScript;
+    private _evaluationOperation;
+    private _evaluateJavaScript;
+    private _executeJavaScriptFile;
+    private _spawnJavaScript;
+    private _spawnJavaScriptFile;
+    private _executeTypeScript;
+    private _evaluateTypeScript;
+    private _executeTypeScriptFile;
+    private _spawnTypeScript;
+    private _spawnTypeScriptFile;
+    private _checkTypeScript;
+    private _checkTypeScriptProject;
+    private _installNpmPackages;
+    private _executeNpmScript;
+    private _executeNpmPackage;
+    private _executePython;
+    private _evaluatePython;
+    private _executePythonFile;
+    private _executePythonModule;
+    private _spawnPython;
+    private _spawnPythonFile;
+    private _spawnPythonModule;
+    private _installPythonPackages;
+    private _getContext;
+    private _listContexts;
+    private _waitExecutionResult;
+    private _cancelExecution;
+    private _signalExecution;
+    private _resetContext;
+    private _descriptorLifecycleRequest;
+    private _deleteContext;
+    private _writeExecutionStdin;
+    private _closeExecutionStdin;
+    private _resizeExecutionPty;
+    private _readExecutionOutput;
+    private _onExecutionOutput;
+    private _onExecutionCompleted;
     private _trackProcess;
-    spawn(command: string, args: string[], options?: SpawnOptions): {
-        pid: number;
-    };
+    private _spawnProcess;
+    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<ProcessDescriptor>;
     /** Write data to a process's stdin. */
-    writeProcessStdin(pid: number, data: string | Uint8Array): Promise<void>;
+    private _writeProcessStdin;
     /** Close a process's stdin stream. */
-    closeProcessStdin(pid: number): Promise<void>;
+    private _closeProcessStdin;
     /** Subscribe to stdout and stderr from a process. */
     onProcessOutput(pid: number, handler: (event: ProcessOutput) => void): () => void;
     /** Subscribe to process exit. Returns an unsubscribe function. */
     onProcessExit(pid: number, handler: (event: ProcessExit) => void): () => void;
     /** Wait for a process to exit. Returns the exit code. */
-    waitProcess(pid: number): Promise<number>;
+    private _waitProcess;
     private _assertSafeAbsolutePath;
     private _assertWritableAbsolutePath;
     private _vfs;
+    private _readFile;
+    private _writeFile;
+    private _writeFiles;
+    private _readFiles;
+    /** Recursively create directories (mkdir -p). */
+    private _mkdirp;
+    private _mkdir;
+    private _readdir;
+    private _readdirEntries;
+    private _readdirRecursive;
+    private _stat;
+    private _exists;
+    private _exportRootFilesystem;
+    /**
+     * Mount a filesystem into the running VM. Resolves once the mount has been
+     * delivered to the native sidecar, so guest code can use it immediately
+     * after the returned promise settles; a delivery failure rejects instead of
+     * leaving the mount silently host-only.
+     */
+    private _mountFs;
+    private _unmountFs;
+    private _listMounts;
+    private _move;
+    private _remove;
+    /** @deprecated Use `filesystem.readFile()`. */
     readFile(path: string): Promise<Uint8Array>;
+    /** @deprecated Use `filesystem.writeFile()`. */
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    /** @deprecated Use `filesystem.writeFiles()`. */
     writeFiles(entries: BatchWriteEntry[]): Promise<BatchWriteResult[]>;
+    /** @deprecated Use `filesystem.readFiles()`. */
     readFiles(paths: string[]): Promise<BatchReadResult[]>;
-    /** Recursively create directories (mkdir -p). */
-    private _mkdirp;
+    /** @deprecated Use `filesystem.mkdir()`. */
     mkdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    /** @deprecated Use `filesystem.readdir()`. */
     readdir(path: string): Promise<string[]>;
+    /** @deprecated Use `filesystem.readdirEntries()`. */
     readdirEntries(path: string): Promise<ReaddirEntry[]>;
+    /** @deprecated Use `filesystem.readdirRecursive()`. */
     readdirRecursive(path: string, options?: ReaddirRecursiveOptions): Promise<DirEntry[]>;
+    /** @deprecated Use `filesystem.stat()`. */
     stat(path: string): Promise<VirtualStat>;
+    /** @deprecated Use `filesystem.exists()`. */
     exists(path: string): Promise<boolean>;
+    /** @deprecated Use `filesystem.export()`. */
     exportRootFilesystem(options: ExportRootFilesystemOptions): Promise<RootSnapshotExport>;
-    /**
-     * Mount a filesystem into the running VM. Resolves once the mount has been
-     * delivered to the native sidecar, so guest code can use it immediately
-     * after the returned promise settles; a delivery failure rejects instead of
-     * leaving the mount silently host-only.
-     */
+    /** @deprecated Use `filesystem.mount()`. */
     mountFs(descriptor: DynamicMountDescriptor): Promise<void>;
+    /** @deprecated Use `filesystem.unmount()`. */
     unmountFs(path: string): Promise<void>;
+    /** @deprecated Use `filesystem.listMounts()`. */
     listMounts(): Promise<MountInfo[]>;
+    /** @deprecated Use `filesystem.move()`. */
     move(from: string, to: string): Promise<void>;
+    /** @deprecated Use `filesystem.remove()`. */
     remove(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    private _httpRequest;
+    /** @deprecated Use `network.httpRequest()`. */
     httpRequest(request: HttpRequest): Promise<HttpResponse>;
-    openShell(options?: ShellOptions): {
-        shellId: string;
-    };
+    /**
+     * Fetch an HTTP endpoint inside the VM while preserving duplicate response
+     * headers and arbitrary binary bodies. agentOS Apps uses this compatibility
+     * surface for its direct actor API.
+     */
+    fetch(port: number, request: Request): Promise<Response>;
+    fetchStreamStart(port: number, request: Request): Promise<{
+        streamId: string;
+        status: number;
+        statusText: string;
+        headers: Array<[string, string]>;
+    }>;
+    fetchStreamRead(streamId: string, maxBytes?: number): Promise<{
+        body: Uint8Array;
+        done: boolean;
+    }>;
+    fetchStreamCancel(streamId: string): Promise<void>;
+    private _openTerminal;
     connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
     /** Write data to a shell's PTY input. */
-    writeShell(shellId: string, data: string | Uint8Array): Promise<void>;
+    private _writeTerminal;
     /**
      * Subscribe to ordered PTY output (stdout and stderr). Returns an unsubscribe
      * function. `OpenShellOptions.onStderr` is a diagnostic tap for callers that
@@ -545,40 +772,79 @@ export declare class AgentOs {
     /** Subscribe to shell exit. */
     onShellExit(shellId: string, handler: (event: ShellExit) => void): () => void;
     /** Notify a shell of terminal resize. */
-    resizeShell(shellId: string, cols: number, rows: number): void;
+    private _resizeTerminal;
     /**
      * Wait for a shell to exit and return its process exit code. Resolves
      * immediately for a shell that has already exited (within the closed-shell
      * retention window).
      */
-    waitShell(shellId: string): Promise<number>;
+    private _waitTerminal;
     /** Kill a shell process and remove it from tracking. */
+    private _closeTerminal;
+    /** @deprecated Use `terminal.open()`. */
+    openShell(options?: ShellOptions): {
+        shellId: string;
+    };
+    /** @deprecated Use `terminal.write()`. */
+    writeShell(shellId: string, data: string | Uint8Array): Promise<void>;
+    /** @deprecated Use `terminal.resize()`. */
+    resizeShell(shellId: string, cols: number, rows: number): void;
+    /** @deprecated Use `terminal.wait()`. */
+    waitShell(shellId: string): Promise<number>;
+    /** @deprecated Use `terminal.close()`. */
     closeShell(shellId: string): void;
     private _resolveVmPathToHostPath;
     /** Returns info about all processes spawned via spawn(). */
-    listProcesses(): SpawnedProcessInfo[];
+    private _listProcesses;
     /** Returns all kernel processes across all active runtimes (WASM and Node). */
-    allProcesses(): KernelProcessInfo[];
+    private _listAllProcesses;
     /** Returns processes organized as a tree using ppid relationships. */
-    processTree(): ProcessTreeNode[];
+    private _processTree;
     /** Returns info about a specific process by PID. Throws if not found. */
-    getProcess(pid: number): SpawnedProcessInfo;
-    /** Send SIGTERM to gracefully stop a process. No-op if already exited. */
-    stopProcess(pid: number): void;
+    private _getProcess;
+    private _signalProcess;
     /** Send SIGKILL to force-kill a process. No-op if already exited. */
-    killProcess(pid: number): void;
+    private _killProcess;
+    private _resizeProcessPty;
+    private _readProcessOutput;
+    private _openSession;
+    private _getSession;
+    private _listSessions;
+    private _deleteSession;
+    private _unloadSession;
+    private _prompt;
+    private _cancelPrompt;
+    private _respondPermission;
+    private _readHistory;
+    private _getSessionConfig;
+    private _setSessionConfigOption;
+    private _getSessionCapabilities;
+    private _getSessionAgentInfo;
+    /** @deprecated Use `sessions.open()`. */
     openSession(input: OpenSessionInput): Promise<void>;
+    /** @deprecated Use `sessions.get()`. */
     getSession(input?: SessionTarget): Promise<DurableSessionInfo>;
+    /** @deprecated Use `sessions.list()`. */
     listSessions(input?: ListSessionsInput): Promise<SessionPage>;
+    /** @deprecated Use `sessions.delete()`. */
     deleteSession(input?: SessionTarget): Promise<void>;
+    /** @deprecated Use `sessions.unload()`. */
     unloadSession(input?: SessionTarget): Promise<void>;
+    /** @deprecated Use `sessions.prompt()`. */
     prompt(input: PromptInput): Promise<DurablePromptResult>;
+    /** @deprecated Use `sessions.cancelPrompt()`. */
     cancelPrompt(input?: SessionTarget): Promise<CancelPromptResult>;
+    /** @deprecated Use `sessions.respondPermission()`. */
     respondPermission(input: PermissionResponse): Promise<PermissionResponseResult>;
+    /** @deprecated Use `sessions.readHistory()`. */
     readHistory(input?: ReadHistoryInput): Promise<HistoryPage>;
+    /** @deprecated Use `sessions.getConfig()`. */
     getSessionConfig(input?: SessionTarget): Promise<SessionConfig>;
+    /** @deprecated Use `sessions.setConfigOption()`. */
     setSessionConfigOption(input: SetSessionConfigOptionInput): Promise<SessionConfig>;
+    /** @deprecated Use `sessions.getCapabilities()`. */
     getSessionCapabilities(input?: SessionTarget): Promise<SessionCapabilities | null>;
+    /** @deprecated Use `sessions.getAgentInfo()`. */
     getSessionAgentInfo(input?: SessionTarget): Promise<SessionAgentInfo | null>;
     /**
      * Dynamically link a software package into the RUNNING VM. The package's
@@ -588,17 +854,23 @@ export declare class AgentOs {
      * block registers the package for `openSession({ agent: name })`. Persists for the VM's
      * lifetime (and across a snapshot iff the volume persists).
      */
-    linkSoftware(descriptor: PackageDescriptor): Promise<void>;
-    listSoftware(): Promise<{
-        packageName: string;
-        commands: string[];
-    }[]>;
+    private _linkSoftware;
+    private _listSoftware;
     /**
      * Returns all registered agents with their installation status. Thin forwarder:
      * sends `AcpListAgentsRequest` and maps the response. The sidecar enumerates the
      * projected `/opt/agentos` packages (the client parses no manifests). Every such
      * agent is a package materialized into the VM, so `installed` is always `true`.
      */
+    private _listAgents;
+    /** @deprecated Use `software.link()`. */
+    linkSoftware(descriptor: PackageDescriptor): Promise<void>;
+    /** @deprecated Use `software.list()`. */
+    listSoftware(): Promise<{
+        packageName: string;
+        commands: string[];
+    }[]>;
+    /** @deprecated Use `agents.list()`. */
     listAgents(): Promise<AgentRegistryEntry[]>;
     private _recordAgentStderr;
     private _recordAgentExit;
@@ -635,10 +907,16 @@ export declare class AgentOs {
     onAgentExit(handler: AgentExitHandler): () => void;
     onAgentExit(sessionId: string | undefined, handler: AgentExitHandler): () => void;
     /** Schedule a cron job. Returns a handle with the job ID and a cancel method. */
-    scheduleCron(options: CronJobOptions): CronJob;
+    private _scheduleCron;
     /** List all registered cron jobs. */
-    listCronJobs(): CronJobInfo[];
+    private _listCronJobs;
     /** Cancel a cron job by ID. */
+    private _cancelCronJob;
+    /** @deprecated Use `cron.schedule()`. */
+    scheduleCron(options: CronJobOptions): CronJob;
+    /** @deprecated Use `cron.list()`. */
+    listCronJobs(): CronJobInfo[];
+    /** @deprecated Use `cron.cancel()`. */
     cancelCronJob(id: string): void;
     /** Subscribe to cron lifecycle events (fire, complete, error). */
     onCronEvent(handler: CronEventHandler): void;