@rivet-dev/agentos-core 0.0.0-feat-on-limit-warning.62a2bc2 → 0.0.0-main.ab2ce7c

package/dist/sandbox.d.ts

@@ -0,0 +1,112 @@
+import type { MountConfig, MountConfigJsonObject, NativeMountPluginDescriptor } from "./agent-os.js";
+import type { ToolKit } from "./host-tools.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[];
+    toolKits?: ToolKit[];
+    [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): ToolKit;
+export declare function getSandboxDisposeHooks(options: object | undefined): SandboxDisposeHook[];
+export declare function resolveSandboxOptions<T extends {
+    sandbox?: AgentOsSandboxInput;
+}>(options: T): Promise<Omit<T, "sandbox"> & {
+    mounts?: MountConfig[];
+    toolKits?: ToolKit[];
+}>;
+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.",
+        tools: {
+            "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 toolKits = [
+        ...(expanded.toolKits ?? []),
+        createSandboxBindings(sandboxOptions),
+    ];
+    return attachSandboxDisposeHooks({
+        ...expanded,
+        mounts,
+        toolKits,
+    }, normalizedSandbox.dispose ? [normalizedSandbox.dispose] : []);
+}

package/dist/sidecar/agentos-protocol.d.ts

@@ -14,7 +14,6 @@ export declare function writeAcpRuntimeKind(bc: bare.ByteCursor, x: AcpRuntimeKi
 export type AcpCreateSessionRequest = {
     readonly agentType: string;
     readonly runtime: AcpRuntimeKind;
-    readonly adapterEntrypoint: string;
     readonly cwd: string;
     readonly args: readonly string[];
     readonly env: ReadonlyMap<string, string>;
@@ -33,6 +32,27 @@ export type AcpSessionRequest = {
 };
 export declare function readAcpSessionRequest(bc: bare.ByteCursor): AcpSessionRequest;
 export declare function writeAcpSessionRequest(bc: bare.ByteCursor, x: AcpSessionRequest): void;
+/**
+ * Enumerate the agents available in this VM. The sidecar answers from the already
+ * projected `/opt/agentos` packages (client parses no manifests).
+ */
+export type AcpListAgentsRequest = {
+    readonly reserved: boolean;
+};
+export declare function readAcpListAgentsRequest(bc: bare.ByteCursor): AcpListAgentsRequest;
+export declare function writeAcpListAgentsRequest(bc: bare.ByteCursor, x: AcpListAgentsRequest): void;
+export type AcpAgentEntry = {
+    readonly id: string;
+    readonly installed: boolean;
+    readonly adapterEntrypoint: string;
+};
+export declare function readAcpAgentEntry(bc: bare.ByteCursor): AcpAgentEntry;
+export declare function writeAcpAgentEntry(bc: bare.ByteCursor, x: AcpAgentEntry): void;
+export type AcpListAgentsResponse = {
+    readonly agents: readonly AcpAgentEntry[];
+};
+export declare function readAcpListAgentsResponse(bc: bare.ByteCursor): AcpListAgentsResponse;
+export declare function writeAcpListAgentsResponse(bc: bare.ByteCursor, x: AcpListAgentsResponse): void;
 export type AcpGetSessionStateRequest = {
     readonly sessionId: string;
 };
@@ -60,6 +80,21 @@ export type AcpResumeSessionRequest = {
 };
 export declare function readAcpResumeSessionRequest(bc: bare.ByteCursor): AcpResumeSessionRequest;
 export declare function writeAcpResumeSessionRequest(bc: bare.ByteCursor, x: AcpResumeSessionRequest): void;
+/**
+ * Browser RESUMABLE path only (AGENTOS-WEB-ASYNC-AGENTS.md §3.2.1): the kernel
+ * worker feeds a chunk of the agent's stdout into the in-flight create_session /
+ * session/prompt handshake. The synchronous sidecar would block inside one
+ * pushFrame; the resumable browser path returns between steps so the worker can
+ * service the agent's own syscalls (incl. pi's net call for inference) on fresh,
+ * non-nested pushFrames. `processId` is the handshake handle returned in the
+ * AcpPendingResponse for the originating create/prompt request.
+ */
+export type AcpDeliverAgentOutputRequest = {
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readAcpDeliverAgentOutputRequest(bc: bare.ByteCursor): AcpDeliverAgentOutputRequest;
+export declare function writeAcpDeliverAgentOutputRequest(bc: bare.ByteCursor, x: AcpDeliverAgentOutputRequest): void;
 export type AcpRequest = {
     readonly tag: "AcpCreateSessionRequest";
     readonly val: AcpCreateSessionRequest;
@@ -75,6 +110,12 @@ export type AcpRequest = {
 } | {
     readonly tag: "AcpResumeSessionRequest";
     readonly val: AcpResumeSessionRequest;
+} | {
+    readonly tag: "AcpDeliverAgentOutputRequest";
+    readonly val: AcpDeliverAgentOutputRequest;
+} | {
+    readonly tag: "AcpListAgentsRequest";
+    readonly val: AcpListAgentsRequest;
 };
 export declare function readAcpRequest(bc: bare.ByteCursor): AcpRequest;
 export declare function writeAcpRequest(bc: bare.ByteCursor, x: AcpRequest): void;
@@ -134,6 +175,18 @@ export type AcpErrorResponse = {
 };
 export declare function readAcpErrorResponse(bc: bare.ByteCursor): AcpErrorResponse;
 export declare function writeAcpErrorResponse(bc: bare.ByteCursor, x: AcpErrorResponse): void;
+/**
+ * Browser RESUMABLE path: the create_session / session/prompt request (and each
+ * AcpDeliverAgentOutputRequest that has not yet completed the handshake) returns
+ * this, carrying the `processId` handle the kernel worker drives the interaction
+ * with. The real result (AcpSessionCreatedResponse / AcpSessionRpcResponse) is
+ * delivered as the response to the AcpDeliverAgentOutputRequest that completes it.
+ */
+export type AcpPendingResponse = {
+    readonly processId: string;
+};
+export declare function readAcpPendingResponse(bc: bare.ByteCursor): AcpPendingResponse;
+export declare function writeAcpPendingResponse(bc: bare.ByteCursor, x: AcpPendingResponse): void;
 export type AcpResponse = {
     readonly tag: "AcpSessionCreatedResponse";
     readonly val: AcpSessionCreatedResponse;
@@ -152,6 +205,12 @@ export type AcpResponse = {
 } | {
     readonly tag: "AcpErrorResponse";
     readonly val: AcpErrorResponse;
+} | {
+    readonly tag: "AcpPendingResponse";
+    readonly val: AcpPendingResponse;
+} | {
+    readonly tag: "AcpListAgentsResponse";
+    readonly val: AcpListAgentsResponse;
 };
 export declare function readAcpResponse(bc: bare.ByteCursor): AcpResponse;
 export declare function writeAcpResponse(bc: bare.ByteCursor, x: AcpResponse): void;
@@ -171,12 +230,40 @@ export type AcpAgentStderrEvent = {
 };
 export declare function readAcpAgentStderrEvent(bc: bare.ByteCursor): AcpAgentStderrEvent;
 export declare function writeAcpAgentStderrEvent(bc: bare.ByteCursor, x: AcpAgentStderrEvent): void;
+/**
+ * Emitted when the ACP adapter process exits without an explicit close_session —
+ * a crash from the host's perspective (any spontaneous exit, including code 0).
+ * `restart` reports the sidecar's bounded auto-restart outcome:
+ *   "restarted"   — adapter respawned and the session was natively re-attached
+ *                   (session/load | session/resume) under the same sessionId;
+ *                   the session stays live.
+ *   "unsupported" — the respawned adapter does not advertise a native resume
+ *                   capability; the session record was evicted.
+ *   "failed"      — the respawn or the native re-attach errored; evicted.
+ *   "exhausted"   — maxRestarts was already spent for this session; evicted.
+ * `exitCode` is absent when the exit was observed indirectly (e.g. a write to
+ * the adapter's stdin failed because the process was already gone).
+ */
+export type AcpAgentExitedEvent = {
+    readonly sessionId: string;
+    readonly agentType: string;
+    readonly processId: string;
+    readonly exitCode: i32 | null;
+    readonly restart: string;
+    readonly restartCount: u32;
+    readonly maxRestarts: u32;
+};
+export declare function readAcpAgentExitedEvent(bc: bare.ByteCursor): AcpAgentExitedEvent;
+export declare function writeAcpAgentExitedEvent(bc: bare.ByteCursor, x: AcpAgentExitedEvent): void;
 export type AcpEvent = {
     readonly tag: "AcpSessionEvent";
     readonly val: AcpSessionEvent;
 } | {
     readonly tag: "AcpAgentStderrEvent";
     readonly val: AcpAgentStderrEvent;
+} | {
+    readonly tag: "AcpAgentExitedEvent";
+    readonly val: AcpAgentExitedEvent;
 };
 export declare function readAcpEvent(bc: bare.ByteCursor): AcpEvent;
 export declare function writeAcpEvent(bc: bare.ByteCursor, x: AcpEvent): void;