@rivet-dev/agentos-core 0.2.5-rc.2 → 0.2.5-rc.4

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;
 };
@@ -93,6 +113,9 @@ export type AcpRequest = {
 } | {
     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;
@@ -185,6 +208,9 @@ export type AcpResponse = {
 } | {
     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;

package/dist/sidecar/agentos-protocol.js

@@ -96,7 +96,6 @@ export function readAcpCreateSessionRequest(bc) {
     return {
         agentType: bare.readString(bc),
         runtime: readAcpRuntimeKind(bc),
-        adapterEntrypoint: bare.readString(bc),
         cwd: bare.readString(bc),
         args: read0(bc),
         env: read1(bc),
@@ -110,7 +109,6 @@ export function readAcpCreateSessionRequest(bc) {
 export function writeAcpCreateSessionRequest(bc, x) {
     bare.writeString(bc, x.agentType);
     writeAcpRuntimeKind(bc, x.runtime);
-    bare.writeString(bc, x.adapterEntrypoint);
     bare.writeString(bc, x.cwd);
     write0(bc, x.args);
     write1(bc, x.env);
@@ -141,6 +139,51 @@ export function writeAcpSessionRequest(bc, x) {
     bare.writeString(bc, x.method);
     write3(bc, x.params);
 }
+export function readAcpListAgentsRequest(bc) {
+    return {
+        reserved: bare.readBool(bc),
+    };
+}
+export function writeAcpListAgentsRequest(bc, x) {
+    bare.writeBool(bc, x.reserved);
+}
+export function readAcpAgentEntry(bc) {
+    return {
+        id: bare.readString(bc),
+        installed: bare.readBool(bc),
+        adapterEntrypoint: bare.readString(bc),
+    };
+}
+export function writeAcpAgentEntry(bc, x) {
+    bare.writeString(bc, x.id);
+    bare.writeBool(bc, x.installed);
+    bare.writeString(bc, x.adapterEntrypoint);
+}
+function read4(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readAcpAgentEntry(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readAcpAgentEntry(bc);
+    }
+    return result;
+}
+function write4(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeAcpAgentEntry(bc, x[i]);
+    }
+}
+export function readAcpListAgentsResponse(bc) {
+    return {
+        agents: read4(bc),
+    };
+}
+export function writeAcpListAgentsResponse(bc, x) {
+    write4(bc, x.agents);
+}
 export function readAcpGetSessionStateRequest(bc) {
     return {
         sessionId: bare.readString(bc),
@@ -199,6 +242,8 @@ export function readAcpRequest(bc) {
             return { tag: "AcpResumeSessionRequest", val: readAcpResumeSessionRequest(bc) };
         case 5:
             return { tag: "AcpDeliverAgentOutputRequest", val: readAcpDeliverAgentOutputRequest(bc) };
+        case 6:
+            return { tag: "AcpListAgentsRequest", val: readAcpListAgentsRequest(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -237,6 +282,11 @@ export function writeAcpRequest(bc, x) {
             writeAcpDeliverAgentOutputRequest(bc, x.val);
             break;
         }
+        case "AcpListAgentsRequest": {
+            bare.writeU8(bc, 6);
+            writeAcpListAgentsRequest(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpRequest(x, config) {
@@ -253,16 +303,16 @@ export function decodeAcpRequest(bytes) {
     }
     return result;
 }
-function read4(bc) {
+function read5(bc) {
     return bare.readBool(bc) ? bare.readU32(bc) : null;
 }
-function write4(bc, x) {
+function write5(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeU32(bc, x);
     }
 }
-function read5(bc) {
+function read6(bc) {
     const len = bare.readUintSafe(bc);
     if (len === 0) {
         return [];
@@ -273,7 +323,7 @@ function read5(bc) {
     }
     return result;
 }
-function write5(bc, x) {
+function write6(bc, x) {
     bare.writeUintSafe(bc, x.length);
     for (let i = 0; i < x.length; i++) {
         writeJsonUtf8(bc, x[i]);
@@ -282,18 +332,18 @@ function write5(bc, x) {
 export function readAcpSessionCreatedResponse(bc) {
     return {
         sessionId: bare.readString(bc),
-        pid: read4(bc),
+        pid: read5(bc),
         modes: read3(bc),
-        configOptions: read5(bc),
+        configOptions: read6(bc),
         agentCapabilities: read3(bc),
         agentInfo: read3(bc),
     };
 }
 export function writeAcpSessionCreatedResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
-    write4(bc, x.pid);
+    write5(bc, x.pid);
     write3(bc, x.modes);
-    write5(bc, x.configOptions);
+    write6(bc, x.configOptions);
     write3(bc, x.agentCapabilities);
     write3(bc, x.agentInfo);
 }
@@ -307,10 +357,10 @@ export function writeAcpSessionRpcResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     writeJsonUtf8(bc, x.response);
 }
-function read6(bc) {
+function read7(bc) {
     return bare.readBool(bc) ? bare.readI32(bc) : null;
 }
-function write6(bc, x) {
+function write7(bc, x) {
     bare.writeBool(bc, x != null);
     if (x != null) {
         bare.writeI32(bc, x);
@@ -321,11 +371,11 @@ export function readAcpSessionStateResponse(bc) {
         sessionId: bare.readString(bc),
         agentType: bare.readString(bc),
         processId: bare.readString(bc),
-        pid: read4(bc),
+        pid: read5(bc),
         closed: bare.readBool(bc),
-        exitCode: read6(bc),
+        exitCode: read7(bc),
         modes: read3(bc),
-        configOptions: read5(bc),
+        configOptions: read6(bc),
         agentCapabilities: read3(bc),
         agentInfo: read3(bc),
     };
@@ -334,11 +384,11 @@ export function writeAcpSessionStateResponse(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.agentType);
     bare.writeString(bc, x.processId);
-    write4(bc, x.pid);
+    write5(bc, x.pid);
     bare.writeBool(bc, x.closed);
-    write6(bc, x.exitCode);
+    write7(bc, x.exitCode);
     write3(bc, x.modes);
-    write5(bc, x.configOptions);
+    write6(bc, x.configOptions);
     write3(bc, x.agentCapabilities);
     write3(bc, x.agentInfo);
 }
@@ -396,6 +446,8 @@ export function readAcpResponse(bc) {
             return { tag: "AcpErrorResponse", val: readAcpErrorResponse(bc) };
         case 6:
             return { tag: "AcpPendingResponse", val: readAcpPendingResponse(bc) };
+        case 7:
+            return { tag: "AcpListAgentsResponse", val: readAcpListAgentsResponse(bc) };
         default: {
             bc.offset = offset;
             throw new bare.BareError(offset, "invalid tag");
@@ -439,6 +491,11 @@ export function writeAcpResponse(bc, x) {
             writeAcpPendingResponse(bc, x.val);
             break;
         }
+        case "AcpListAgentsResponse": {
+            bare.writeU8(bc, 7);
+            writeAcpListAgentsResponse(bc, x.val);
+            break;
+        }
     }
 }
 export function encodeAcpResponse(x, config) {
@@ -484,7 +541,7 @@ export function readAcpAgentExitedEvent(bc) {
         sessionId: bare.readString(bc),
         agentType: bare.readString(bc),
         processId: bare.readString(bc),
-        exitCode: read6(bc),
+        exitCode: read7(bc),
         restart: bare.readString(bc),
         restartCount: bare.readU32(bc),
         maxRestarts: bare.readU32(bc),
@@ -494,7 +551,7 @@ export function writeAcpAgentExitedEvent(bc, x) {
     bare.writeString(bc, x.sessionId);
     bare.writeString(bc, x.agentType);
     bare.writeString(bc, x.processId);
-    write6(bc, x.exitCode);
+    write7(bc, x.exitCode);
     bare.writeString(bc, x.restart);
     bare.writeU32(bc, x.restartCount);
     bare.writeU32(bc, x.maxRestarts);

package/dist/sidecar/native-process-client.d.ts

@@ -1,5 +1,6 @@
-import "@secure-exec/core/native-client";
-import { SidecarProcess } from "@secure-exec/core/sidecar-client";
-export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, SidecarEventBufferOverflow, SidecarProcess, SidecarProcessError, SidecarProcessExited, } from "@secure-exec/core/sidecar-client";
+import "@rivet-dev/agentos-runtime-core/native-client";
+import { SidecarProcess } from "@rivet-dev/agentos-runtime-core/sidecar-client";
+export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, SidecarEventBufferOverflow, SidecarProcess, SidecarProcessError, SidecarProcessExited, } from "@rivet-dev/agentos-runtime-core/sidecar-client";
 export declare const NativeSidecarProcessClient: typeof SidecarProcess;
-export type { AuthenticatedSession, CreatedVm, ExtEnvelope, GuestFilesystemStat, RootFilesystemEntry, RootFilesystemLowerDescriptor, SidecarEventSelector, SidecarFsPermissionRule, SidecarMountDescriptor, SidecarMountPluginDescriptor, SidecarPatternPermissionRule, SidecarPermissionMode, SidecarPermissionScope, SidecarPermissionsPolicy, SidecarProcessSnapshotEntry, SidecarProjectedModuleDescriptor, SidecarRegisteredHostCallbackDefinition, SidecarRegisteredHostCallbackExample, SidecarRequestFrame, SidecarRequestHandler, SidecarRequestPayload, SidecarResponseFrame, SidecarResponsePayload, SidecarRulePermissions, SidecarSessionState, SidecarSignalHandlerRegistration, SidecarSignalState, SidecarSocketStateEntry, SidecarSoftwareDescriptor, SidecarSpawnOptions, SidecarSpawnOptions as NativeSidecarSpawnOptions, SidecarZombieTimerCount, } from "@secure-exec/core/sidecar-client";
+export type { AuthenticatedSession, CreatedVm, ExtEnvelope, GuestFilesystemStat, RootFilesystemEntry, RootFilesystemLowerDescriptor, SidecarEventSelector, SidecarFsPermissionRule, SidecarLinkPackageResult, SidecarMountDescriptor, SidecarMountPluginDescriptor, SidecarPatternPermissionRule, SidecarPermissionMode, SidecarPermissionScope, SidecarPermissionsPolicy, SidecarProcessSnapshotEntry, SidecarProjectedAgent, SidecarProjectedModuleDescriptor, SidecarRegisteredHostCallbackDefinition, SidecarRegisteredHostCallbackExample, SidecarRequestFrame, SidecarRequestHandler, SidecarRequestPayload, SidecarResponseFrame, SidecarResponsePayload, SidecarRulePermissions, SidecarSessionState, SidecarSignalHandlerRegistration, SidecarSignalState, SidecarSocketStateEntry, SidecarSoftwareDescriptor, SidecarSpawnOptions, SidecarSpawnOptions as NativeSidecarSpawnOptions, SidecarZombieTimerCount, } from "@rivet-dev/agentos-runtime-core/sidecar-client";
+export type { SidecarVmConfiguredResponse as SidecarConfigureVmResult, } from "@rivet-dev/agentos-runtime-core/sidecar-client";

package/dist/sidecar/native-process-client.js

@@ -1,8 +1,8 @@
 // Register the native sidecar spawn factory (side effect). After the
-// @secure-exec/core SidecarProcess refactor, native spawn is provided by a
+// @rivet-dev/agentos-runtime-core SidecarProcess refactor, native spawn is provided by a
 // separately-registered factory; importing native-client wires it up so
 // SidecarProcess.spawn works in this native runtime.
-import "@secure-exec/core/native-client";
-import { SidecarProcess } from "@secure-exec/core/sidecar-client";
-export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, SidecarEventBufferOverflow, SidecarProcess, SidecarProcessError, SidecarProcessExited, } from "@secure-exec/core/sidecar-client";
+import "@rivet-dev/agentos-runtime-core/native-client";
+import { SidecarProcess } from "@rivet-dev/agentos-runtime-core/sidecar-client";
+export { NATIVE_SIDECAR_FRAME_TIMEOUT_MS, SidecarEventBufferOverflow, SidecarProcess, SidecarProcessError, SidecarProcessExited, } from "@rivet-dev/agentos-runtime-core/sidecar-client";
 export const NativeSidecarProcessClient = SidecarProcess;

package/dist/sidecar/permissions.d.ts

@@ -1,3 +1,3 @@
-import type { PermissionsPolicy } from "@secure-exec/core/vm-config";
+import type { PermissionsPolicy } from "@rivet-dev/agentos-runtime-core/vm-config";
 import type { Permissions } from "../runtime-compat.js";
 export declare function serializePermissionsForSidecar(permissions?: Permissions): PermissionsPolicy;