@rivet-dev/agentos-core 0.0.0-integrate-dylib-into-main.815fcda → 0.0.0-main.29b0797

package/dist/runtime.d.ts

@@ -10,6 +10,7 @@ export interface VirtualDirEntry {
 export interface VirtualStat {
     mode: number;
     size: number;
+    sizeExact?: bigint;
     blocks: number;
     dev: number;
     rdev: number;
@@ -20,7 +21,9 @@ export interface VirtualStat {
     ctimeMs: number;
     birthtimeMs: number;
     ino: number;
+    inoExact?: bigint;
     nlink: number;
+    nlinkExact?: bigint;
     uid: number;
     gid: number;
 }
@@ -45,7 +48,9 @@ export interface VirtualFileSystem {
     lstat(path: string): Promise<VirtualStat>;
     link(oldPath: string, newPath: string): Promise<void>;
     chmod(path: string, mode: number): Promise<void>;
-    chown(path: string, uid: number, gid: number): Promise<void>;
+    chown(path: string, uid: number, gid: number, options?: {
+        followSymlinks?: boolean;
+    }): Promise<void>;
     utimes(path: string, atime: number, mtime: number): Promise<void>;
     truncate(path: string, length: number): Promise<void>;
     pread(path: string, offset: number, length: number): Promise<Uint8Array>;
@@ -76,7 +81,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type ToolPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -93,15 +98,16 @@ export interface ProcessInfo {
 }
 export interface ManagedProcess {
     pid: number;
-    writeStdin(data: Uint8Array | string): void;
-    closeStdin(): void;
+    writeStdin(data: Uint8Array | string): Promise<void>;
+    closeStdin(): Promise<void>;
     kill(signal?: number): void;
     wait(): Promise<number>;
     readonly exitCode: number | null;
 }
 export interface ShellHandle {
     pid: number;
-    write(data: Uint8Array | string): void;
+    write(data: Uint8Array | string): Promise<void>;
+    /** Ordered PTY output containing stdout and stderr exactly once. */
     onData: ((data: Uint8Array) => void) | null;
     resize(cols: number, rows: number): void;
     kill(signal?: number): void;
@@ -114,6 +120,7 @@ export interface OpenShellOptions {
     cwd?: string;
     cols?: number;
     rows?: number;
+    /** Optional stderr-only diagnostic tap; do not render it alongside `onData`. */
     onStderr?: (data: Uint8Array) => void;
 }
 export interface ConnectTerminalOptions extends OpenShellOptions {
@@ -163,7 +170,7 @@ export interface Permissions {
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    tool?: ToolPermissions;
+    binding?: BindingPermissions;
 }
 export interface ResourceBudgets {
     maxOutputBytes?: number;
@@ -224,6 +231,7 @@ export interface SystemDriver {
     network?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts: readonly NodeModulesMountConfig[];
     runtime: {
         process: ProcessConfig;
         os: OSConfig;
@@ -258,6 +266,13 @@ export interface NodeRuntimeDriverFactory {
 export interface KernelInterface {
     vfs: VirtualFileSystem;
 }
+export interface KernelRecursiveDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+}
 export interface Kernel extends KernelInterface {
     mount(driver: KernelRuntimeDriver): Promise<void>;
     dispose(): Promise<void>;
@@ -267,17 +282,24 @@ export interface Kernel extends KernelInterface {
     connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
     mountFs(path: string, fs: VirtualFileSystem, options?: {
         readOnly?: boolean;
-    }): void;
-    unmountFs(path: string): void;
+    }): void | Promise<void>;
+    unmountFs(path: string): void | Promise<void>;
     readFile(path: string): Promise<Uint8Array>;
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
     mkdir(path: string): Promise<void>;
     readdir(path: string): Promise<string[]>;
+    readdirRecursive(path: string, options?: {
+        maxDepth?: number;
+    }): Promise<KernelRecursiveDirEntry[]>;
     stat(path: string): Promise<VirtualStat>;
     exists(path: string): Promise<boolean>;
     removeFile(path: string): Promise<void>;
     removeDir(path: string): Promise<void>;
+    removePath(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
+    movePath(oldPath: string, newPath: string): Promise<void>;
     readonly commands: ReadonlyMap<string, string>;
     readonly processes: ReadonlyMap<number, ProcessInfo>;
     readonly env: Record<string, string>;
@@ -299,11 +321,23 @@ export interface BindingTree {
     [key: string]: BindingFunction | BindingTree;
 }
 export type BindingFunction = (...args: unknown[]) => unknown;
+export interface NodeModulesMountConfig {
+    path: string;
+    plugin: {
+        id: "host_dir";
+        config: {
+            hostPath: string;
+            readOnly: boolean;
+        };
+    };
+    readOnly: boolean;
+}
 export interface NodeDriverOptions {
     filesystem?: VirtualFileSystem;
     networkAdapter?: NetworkAdapter;
     commandExecutor?: CommandExecutor;
     permissions?: Permissions;
+    mounts?: readonly NodeModulesMountConfig[];
     processConfig?: ProcessConfig;
     osConfig?: OSConfig;
 }

package/dist/sandbox.d.ts

@@ -0,0 +1,112 @@
+import type { MountConfig, MountConfigJsonObject, NativeMountPluginDescriptor } from "./agent-os.js";
+import type { Bindings } from "./bindings.js";
+export interface AgentOsSandboxProcessResult {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number | null;
+    timedOut?: boolean;
+    durationMs?: number;
+}
+export interface AgentOsSandboxProcessInfo {
+    id: string;
+    command?: string;
+    args?: string[];
+    status?: string;
+    exitCode?: number | null;
+    pid?: number | null;
+}
+export interface AgentOsSandboxProcessLogs {
+    entries: Array<{
+        data: string;
+        encoding?: "base64" | string;
+        stream?: "stdout" | "stderr" | "combined" | string;
+        timestampMs?: number;
+    }>;
+}
+export interface AgentOsSandboxClient {
+    dispose?(): Promise<void> | void;
+    runProcess(options: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+        timeoutMs?: number;
+    }): Promise<AgentOsSandboxProcessResult>;
+    createProcess(options: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<AgentOsSandboxProcessInfo>;
+    listProcesses(): Promise<{
+        processes: AgentOsSandboxProcessInfo[];
+    }>;
+    stopProcess(id: string): Promise<AgentOsSandboxProcessInfo>;
+    killProcess(id: string): Promise<AgentOsSandboxProcessInfo>;
+    getProcessLogs(id: string, options?: {
+        stream?: "stdout" | "stderr" | "combined";
+        tail?: number;
+    }): Promise<AgentOsSandboxProcessLogs>;
+    sendProcessInput(id: string, input: {
+        data: string;
+        encoding: "base64";
+    }): Promise<unknown>;
+}
+export interface AgentOsSandboxProvider {
+    start(): Promise<AgentOsSandboxClient>;
+}
+export interface AgentOsSandboxCommonOptions {
+    /** Mount path inside the agentOS VM. Defaults to "/mnt/sandbox". */
+    mountPath?: string;
+    /** Root path inside the external sandbox provider. Defaults to "/". */
+    sandboxRoot?: string;
+    /** Per-request timeout for sandbox-agent filesystem calls. */
+    timeoutMs?: number;
+    /** Maximum file size allowed for buffered pread/truncate fallbacks. */
+    maxFullReadBytes?: number;
+    /** Marks the VM mount read-only. Defaults to false. */
+    readOnly?: boolean;
+}
+export interface AgentOsSandboxProviderOptions extends AgentOsSandboxCommonOptions {
+    /** Provider used to start a Sandbox Agent client for this VM. */
+    provider: AgentOsSandboxProvider;
+}
+export interface AgentOsSandboxClientOptions extends AgentOsSandboxCommonOptions {
+    /** Externally provisioned Sandbox Agent-compatible client instance. */
+    client: AgentOsSandboxClient;
+    /**
+     * Advanced lifecycle control. Set true to dispose `client` with the VM, or
+     * provide a custom dispose hook. Defaults to false for the object form.
+     */
+    dispose?: boolean | (() => void | Promise<void>);
+}
+export type AgentOsSandboxOptions = AgentOsSandboxProviderOptions | AgentOsSandboxClientOptions;
+export type AgentOsSandboxInput = AgentOsSandboxOptions;
+declare const sandboxDisposeHooks: unique symbol;
+type SandboxDisposeHook = () => void | Promise<void>;
+export type AgentOsSandboxExpandedOptions = {
+    mounts?: MountConfig[];
+    bindings?: Bindings[];
+    [sandboxDisposeHooks]?: SandboxDisposeHook[];
+};
+type ResolvedSandboxOptions = AgentOsSandboxCommonOptions & {
+    client: AgentOsSandboxClient;
+};
+export type SandboxMountPluginConfig = MountConfigJsonObject & {
+    baseUrl: string;
+    token?: string;
+    headers?: Record<string, string>;
+    basePath?: string;
+    timeoutMs?: number;
+    maxFullReadBytes?: number;
+};
+export declare function createSandboxFs(input: ResolvedSandboxOptions | AgentOsSandboxClientOptions): NativeMountPluginDescriptor<SandboxMountPluginConfig>;
+export declare function createSandboxBindings(input: ResolvedSandboxOptions | AgentOsSandboxClientOptions): Bindings;
+export declare function getSandboxDisposeHooks(options: object | undefined): SandboxDisposeHook[];
+export declare function resolveSandboxOptions<T extends {
+    sandbox?: AgentOsSandboxInput;
+}>(options: T): Promise<Omit<T, "sandbox"> & {
+    mounts?: MountConfig[];
+    bindings?: Bindings[];
+}>;
+export {};

package/dist/sandbox.js

@@ -0,0 +1,264 @@
+import { z } from "zod";
+const sandboxDisposeHooks = Symbol("agentos.sandboxDisposeHooks");
+function binding(def) {
+    return def;
+}
+function normalizeHeaders(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    if (headers instanceof Headers) {
+        return Object.fromEntries(headers.entries());
+    }
+    if (Array.isArray(headers)) {
+        return Object.fromEntries(headers);
+    }
+    return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
+}
+function getSerializableClientConfig(client) {
+    const serializable = client;
+    const baseUrl = serializable.baseUrl?.trim().replace(/\/+$/, "");
+    if (!baseUrl) {
+        throw new Error("Sandbox client does not expose a serializable baseUrl; connect with a standard SandboxAgent client instance");
+    }
+    return {
+        baseUrl,
+        ...(serializable.token ? { token: serializable.token } : {}),
+        ...(serializable.defaultHeaders
+            ? { headers: normalizeHeaders(serializable.defaultHeaders) }
+            : {}),
+    };
+}
+export function createSandboxFs(input) {
+    const options = input;
+    return {
+        id: "sandbox_agent",
+        config: {
+            ...getSerializableClientConfig(options.client),
+            ...(options.sandboxRoot ? { basePath: options.sandboxRoot } : {}),
+            ...(options.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}),
+            ...(options.maxFullReadBytes != null
+                ? { maxFullReadBytes: options.maxFullReadBytes }
+                : {}),
+        },
+    };
+}
+export function createSandboxBindings(input) {
+    const options = input;
+    const { client } = options;
+    return {
+        name: "sandbox",
+        description: "Execute commands and manage processes in a remote sandbox environment.",
+        bindings: {
+            "run-command": binding({
+                description: "Run a command synchronously in the sandbox and return its stdout, stderr, and exit code.",
+                inputSchema: z.object({
+                    command: z
+                        .string()
+                        .describe("The command to execute (e.g. 'ls', 'python3')."),
+                    args: z.array(z.string()).optional(),
+                    cwd: z.string().optional(),
+                    env: z.record(z.string(), z.string()).optional(),
+                    timeoutMs: z.number().optional(),
+                }),
+                timeout: 120_000,
+                execute: async (input) => {
+                    const result = await client.runProcess(input);
+                    return {
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                        exitCode: result.exitCode,
+                        timedOut: result.timedOut,
+                        durationMs: result.durationMs,
+                    };
+                },
+            }),
+            "create-process": binding({
+                description: "Start a long-running background process in the sandbox. Returns a process ID for later management.",
+                inputSchema: z.object({
+                    command: z.string(),
+                    args: z.array(z.string()).optional(),
+                    cwd: z.string().optional(),
+                    env: z.record(z.string(), z.string()).optional(),
+                }),
+                execute: async (input) => {
+                    const proc = await client.createProcess(input);
+                    return {
+                        id: proc.id,
+                        command: proc.command,
+                        args: proc.args,
+                        status: proc.status,
+                        pid: proc.pid,
+                    };
+                },
+            }),
+            "list-processes": binding({
+                description: "List all processes running in the sandbox.",
+                inputSchema: z.object({}),
+                execute: async () => {
+                    const result = await client.listProcesses();
+                    return {
+                        processes: result.processes.map((p) => ({
+                            id: p.id,
+                            command: p.command,
+                            args: p.args,
+                            status: p.status,
+                            exitCode: p.exitCode,
+                            pid: p.pid,
+                        })),
+                    };
+                },
+            }),
+            "stop-process": binding({
+                description: "Gracefully stop a running process in the sandbox.",
+                inputSchema: z.object({ id: z.string() }),
+                execute: async (input) => {
+                    const proc = await client.stopProcess(input.id);
+                    return {
+                        id: proc.id,
+                        status: proc.status,
+                        exitCode: proc.exitCode,
+                    };
+                },
+            }),
+            "kill-process": binding({
+                description: "Forcefully kill a running process in the sandbox.",
+                inputSchema: z.object({ id: z.string() }),
+                execute: async (input) => {
+                    const proc = await client.killProcess(input.id);
+                    return {
+                        id: proc.id,
+                        status: proc.status,
+                        exitCode: proc.exitCode,
+                    };
+                },
+            }),
+            "get-process-logs": binding({
+                description: "Get stdout/stderr logs from a sandbox process.",
+                inputSchema: z.object({
+                    id: z.string(),
+                    stream: z.enum(["stdout", "stderr", "combined"]).optional(),
+                    tail: z.number().optional(),
+                }),
+                execute: async (input) => {
+                    const result = await client.getProcessLogs(input.id, {
+                        stream: input.stream,
+                        tail: input.tail,
+                    });
+                    return {
+                        logs: result.entries.map((e) => {
+                            const data = e.encoding === "base64"
+                                ? Buffer.from(e.data, "base64").toString("utf-8")
+                                : e.data;
+                            return {
+                                data,
+                                stream: e.stream,
+                                timestampMs: e.timestampMs,
+                            };
+                        }),
+                    };
+                },
+            }),
+            "send-input": binding({
+                description: "Send text input to an interactive sandbox process via stdin.",
+                inputSchema: z.object({
+                    id: z.string(),
+                    data: z.string(),
+                }),
+                execute: async (input) => {
+                    await client.sendProcessInput(input.id, {
+                        data: Buffer.from(input.data, "utf-8").toString("base64"),
+                        encoding: "base64",
+                    });
+                    return { sent: true };
+                },
+            }),
+        },
+    };
+}
+function isProviderOptions(input) {
+    return "provider" in input;
+}
+function isClientOptions(input) {
+    return "client" in input;
+}
+function assertNoLegacySandboxOptions(input) {
+    const legacyKeys = ["mount", "bindings", "path", "basePath"];
+    for (const key of legacyKeys) {
+        if (key in input) {
+            const replacement = key === "path" || key === "basePath" ? "sandboxRoot" : undefined;
+            throw new Error(replacement
+                ? `sandbox.${key} has been removed; use sandbox.${replacement} instead.`
+                : `sandbox.${key} has been removed; sandbox mounts and bindings are always enabled.`);
+        }
+    }
+}
+async function normalizeSandboxInput(input) {
+    assertNoLegacySandboxOptions(input);
+    if (isProviderOptions(input)) {
+        if (typeof input.provider?.start !== "function") {
+            throw new Error("sandbox.provider must expose a start() function.");
+        }
+        const client = await input.provider.start();
+        return {
+            options: { ...input, client },
+            dispose: () => client.dispose?.(),
+        };
+    }
+    if (!isClientOptions(input)) {
+        throw new Error("sandbox must be configured with either { provider } or { client }.");
+    }
+    const dispose = typeof input.dispose === "function"
+        ? input.dispose
+        : input.dispose === true
+            ? () => input.client.dispose?.()
+            : undefined;
+    return {
+        options: input,
+        dispose,
+    };
+}
+function attachSandboxDisposeHooks(options, hooks) {
+    if (hooks.length === 0) {
+        return options;
+    }
+    Object.defineProperty(options, sandboxDisposeHooks, {
+        value: hooks,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return options;
+}
+export function getSandboxDisposeHooks(options) {
+    return options
+        ? (options[sandboxDisposeHooks] ?? [])
+        : [];
+}
+export async function resolveSandboxOptions(options) {
+    const { sandbox, ...rest } = options;
+    if (!sandbox) {
+        return rest;
+    }
+    const normalizedSandbox = await normalizeSandboxInput(sandbox);
+    const sandboxOptions = normalizedSandbox.options;
+    const expanded = rest;
+    const mountPath = sandboxOptions.mountPath ?? "/mnt/sandbox";
+    const mounts = [
+        ...(expanded.mounts ?? []),
+        {
+            path: mountPath,
+            plugin: createSandboxFs(sandboxOptions),
+            readOnly: sandboxOptions.readOnly,
+        },
+    ];
+    const bindings = [
+        ...(expanded.bindings ?? []),
+        createSandboxBindings(sandboxOptions),
+    ];
+    return attachSandboxDisposeHooks({
+        ...expanded,
+        mounts,
+        bindings,
+    }, normalizedSandbox.dispose ? [normalizedSandbox.dispose] : []);
+}

package/dist/session-api.d.ts

@@ -0,0 +1,180 @@
+import type { ContentBlock, Implementation, McpServer, RequestPermissionRequest, RequestPermissionResponse, SessionConfigOption, SessionUpdate, StopReason } from "@agentclientprotocol/sdk";
+export type { ContentBlock, McpServer, SessionConfigOption, SessionUpdate, StopReason, };
+export type { RequestPermissionRequest, RequestPermissionResponse };
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface SerializedError {
+    code: string;
+    message: string;
+    details?: JsonValue;
+    retryable?: boolean;
+}
+/** Exact upstream ACP MCP server configuration. */
+export type McpServerConfig = McpServer;
+export type PermissionPolicy = "reject_all" | "ask" | "allow_all";
+export interface OpenSessionInput {
+    sessionId?: string;
+    agent: string;
+    cwd?: string;
+    additionalDirectories?: string[];
+    env?: Record<string, string>;
+    mcpServers?: McpServerConfig[];
+    /**
+     * Immutable AgentOS strategy for native ACP permission requests. Defaults to
+     * `allow_all`. This does not configure VM permissions or adapter tool access.
+     */
+    permissionPolicy?: PermissionPolicy;
+    skipOsInstructions?: boolean;
+    additionalInstructions?: string;
+}
+export interface SessionTarget {
+    sessionId?: string;
+}
+export type DeleteSessionInput = SessionTarget;
+export type SessionState = {
+    status: "idle";
+} | {
+    status: "running";
+    startedAt: string;
+} | {
+    status: "waiting";
+    waitingSince: string;
+    requests: PendingPermissionRequest[];
+} | {
+    status: "failed";
+    error: SerializedError;
+};
+export interface SessionInfo {
+    sessionId: string;
+    agent: string;
+    cwd: string;
+    additionalDirectories: string[];
+    state: SessionState;
+    latestSequence: number;
+    title?: string;
+    metadata?: Record<string, JsonValue> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListSessionsInput {
+    cursor?: string;
+    limit?: number;
+}
+export interface SessionPage {
+    sessions: SessionInfo[];
+    nextCursor: string | null;
+}
+export interface PromptInput {
+    sessionId?: string;
+    idempotencyKey?: string;
+    content: ContentBlock[];
+}
+export interface UserMessage {
+    id: string;
+    role: "user";
+    content: ContentBlock[];
+}
+export interface AgentMessage {
+    id: string;
+    role: "agent";
+    content: ContentBlock[];
+}
+export interface PromptResult {
+    sessionId: string;
+    message: AgentMessage | null;
+    stopReason: StopReason;
+}
+export interface CancelPromptResult {
+    status: "cancelled" | "no_active_prompt";
+}
+export interface DurableSessionEventEnvelope {
+    durability: "durable";
+    sessionId: string;
+    sequence: number;
+    timestamp: string;
+}
+export interface EphemeralSessionEventEnvelope {
+    durability: "ephemeral";
+    sessionId: string;
+    afterSequence: number;
+}
+type FlatAcpSessionUpdate<Update extends SessionUpdate = SessionUpdate> = Update extends SessionUpdate ? Omit<Update, "sessionUpdate"> & {
+    type: Update["sessionUpdate"];
+} : never;
+/** Exact ACP session-update payloads with the ACP discriminator promoted to `type`. */
+export type AcpSessionEvent = FlatAcpSessionUpdate;
+export type DurableSessionUpdateEntry = DurableSessionEventEnvelope & AcpSessionEvent;
+export type DurablePermissionRequestEntry = DurableSessionEventEnvelope & {
+    type: "permission_request";
+    requestId: string;
+} & Omit<RequestPermissionRequest, "sessionId">;
+export type DurablePermissionResponseEntry = DurableSessionEventEnvelope & {
+    type: "permission_response";
+    requestId: string;
+    status: "accepted" | "not_pending";
+    reason?: PermissionTerminalReason;
+} & RequestPermissionResponse;
+export type DurableSessionEventEntry = DurableSessionUpdateEntry | DurablePermissionRequestEntry | DurablePermissionResponseEntry;
+export type EphemeralSessionEventEntry = EphemeralSessionEventEnvelope & FlatAcpSessionUpdate<Extract<SessionUpdate, {
+    sessionUpdate: "agent_message_chunk" | "agent_thought_chunk";
+}>>;
+export type SessionStreamEntry = DurableSessionEventEntry | EphemeralSessionEventEntry;
+export interface ReadHistoryInput extends SessionTarget {
+    before?: number;
+    after?: number;
+    limit?: number;
+}
+export interface HistoryPage {
+    events: DurableSessionEventEntry[];
+    hasMoreBefore: boolean;
+    hasMoreAfter: boolean;
+}
+export interface SessionConfig {
+    revision: number;
+    options: SessionConfigOption[];
+}
+export interface SetSessionConfigOptionInput extends SessionTarget {
+    configId: string;
+    value: string | boolean;
+}
+export interface SessionCapabilities {
+    protocolVersion: number;
+    loadSession: boolean;
+    prompt?: {
+        audio?: boolean;
+        embeddedContext?: boolean;
+        image?: boolean;
+    };
+    mcp?: {
+        http?: boolean;
+        sse?: boolean;
+    };
+    session?: {
+        list?: boolean;
+        resume?: boolean;
+        close?: boolean;
+        delete?: boolean;
+        additionalDirectories?: boolean;
+    };
+    extensions?: Record<string, JsonValue>;
+}
+export type SessionAgentInfo = Implementation;
+export interface PendingPermissionRequest {
+    requestId: string;
+    options: RequestPermissionRequest["options"];
+    toolCall: RequestPermissionRequest["toolCall"];
+    _meta?: RequestPermissionRequest["_meta"];
+}
+export interface PermissionResponse {
+    sessionId: string;
+    requestId: string;
+    optionId: string;
+}
+export type PermissionTerminalReason = "already_resolved" | "prompt_cancelled" | "adapter_exited" | "session_deleted" | "vm_shutdown" | "request_not_found";
+export type PermissionResponseResult = {
+    status: "accepted";
+} | {
+    status: "not_pending";
+    reason: PermissionTerminalReason;
+};