@rivet-dev/agentos-browser 0.2.4 → 0.2.5-rc.1

package/dist/agent-drive-loop.d.ts

@@ -0,0 +1,29 @@
+export type AgentOutputKind = "stdout" | "stderr" | "exit";
+export interface AgentOutput {
+    kind: AgentOutputKind;
+    payload: Uint8Array;
+}
+export interface DriveResult {
+    /** True while the interaction is still in flight (AcpPendingResponse). */
+    pending: boolean;
+    /** The decoded response frame bytes (the real ACP result when !pending). */
+    response: Uint8Array;
+}
+export interface AgentDriveDeps {
+    /** Read the next output for this execution from the reactor, servicing the
+     * agent's syscalls while waiting; null on timeout. */
+    pollAgentOutput(processId: string, deadlineMs: number): AgentOutput | null;
+    /** Feed a chunk of agent stdout into the resumable handshake (a non-nested
+     * pushFrame) and return whether it is still pending + the response frame. */
+    deliverAgentOutput(processId: string, chunk: Uint8Array): DriveResult;
+    now(): number;
+}
+export declare class AgentInteractionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Drive a resumable ACP interaction to completion. Returns the real ACP result
+ * frame bytes (the deferred response the kernel worker relays to the client).
+ * Throws if the agent exits or times out before producing a result.
+ */
+export declare function driveAgentInteraction(deps: AgentDriveDeps, processId: string, deadlineMs: number): Uint8Array;

package/dist/agent-drive-loop.js

@@ -0,0 +1,43 @@
+// The kernel-worker drive loop for a resumable ACP interaction (AGENTOS-WEB-ASYNC-
+// AGENTS.md §3.2.1). After a create_session / session/prompt wire frame returns
+// AcpPending{processId}, the kernel worker drives the agent to completion: it reads
+// the agent's stdout from the reactor (which services the agent's own syscalls in
+// the meantime — legal, because we are NOT inside a pushFrame here) and feeds each
+// chunk back via deliver_agent_output (a fresh, non-nested pushFrame) until the
+// handshake/turn completes and yields the real result.
+//
+// This is pure orchestration over injected dependencies, so it is unit-testable
+// without the wasm kernel, the reactor, or real workers.
+export class AgentInteractionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AgentInteractionError";
+    }
+}
+/**
+ * Drive a resumable ACP interaction to completion. Returns the real ACP result
+ * frame bytes (the deferred response the kernel worker relays to the client).
+ * Throws if the agent exits or times out before producing a result.
+ */
+export function driveAgentInteraction(deps, processId, deadlineMs) {
+    for (;;) {
+        if (deps.now() >= deadlineMs) {
+            throw new AgentInteractionError(`agent interaction timed out (${processId})`);
+        }
+        const out = deps.pollAgentOutput(processId, deadlineMs);
+        if (out === null) {
+            throw new AgentInteractionError(`agent produced no output before the deadline (${processId})`);
+        }
+        if (out.kind === "exit") {
+            throw new AgentInteractionError(`agent exited before completing the ACP interaction (${processId})`);
+        }
+        if (out.kind === "stderr") {
+            // stderr is diagnostic; it does not advance the JSON-RPC handshake.
+            continue;
+        }
+        const result = deps.deliverAgentOutput(processId, out.payload);
+        if (!result.pending) {
+            return result.response;
+        }
+    }
+}

package/dist/chrome-llm-adapter.d.ts

@@ -0,0 +1,55 @@
+/** The slice of Chrome's built-in `LanguageModel` we use (a created session). */
+export interface LanguageModelSession {
+    prompt(input: string): Promise<string>;
+}
+export declare const LANGUAGE_MODEL_OPTIONS: {
+    expectedInputs: {
+        type: string;
+        languages: string[];
+    }[];
+    expectedOutputs: {
+        type: string;
+        languages: string[];
+    }[];
+};
+export interface ChromeLanguageModelSessionOptions {
+    allowDownload?: boolean;
+    onDownloadProgress?(progress: number): void;
+    signal?: AbortSignal;
+}
+export declare function getChromeLanguageModelAvailability(): Promise<string>;
+/** Minimal chat request shape — accepts OpenAI (`messages`) and Anthropic
+ * (`messages` + top-level `system`) bodies; both are `{role, content}` arrays. */
+interface ChatRequest {
+    model?: string;
+    system?: string;
+    messages?: {
+        role: string;
+        content: unknown;
+    }[];
+    prompt?: string;
+}
+/** Flatten a chat request into a single prompt string for the on-device model. */
+export declare function chatRequestToPrompt(request: ChatRequest): string;
+/**
+ * Handle one chat-completion request against the on-device model. Returns an
+ * OpenAI-chat-completion-shaped JSON string (the shape pi's client decodes).
+ */
+export declare function handleChatCompletion(requestBody: string, session: LanguageModelSession): Promise<string>;
+/**
+ * MANUAL-TESTING STAND-IN ONLY — not a real model. Returns a fake
+ * `LanguageModelSession` whose `prompt()` yields a deterministic canned reply
+ * instead of calling Chrome's on-device model. This exists so the real terminal
+ * + pi TUI flow can be driven end-to-end on hosts where `window.LanguageModel`
+ * cannot be provisioned (e.g. a headless Linux box). It is OPT-IN and is NEVER
+ * used by the strict real-model gates (`verify:real-pi-model` /
+ * `verify:real-language-model`), which require a genuine `window.LanguageModel`
+ * answer and fail honestly when it is absent. Callers that use this must report
+ * `usedRealLanguageModel: false`.
+ */
+export declare function createMockLanguageModelSession(reply?: (prompt: string) => string): LanguageModelSession;
+/** Create a `LanguageModelSession` from the real Chrome `LanguageModel` global, or
+ * return null if it is unavailable (CI / unsupported). Probed lazily so the bundle
+ * loads without it. */
+export declare function createChromeLanguageModelSession(options?: ChromeLanguageModelSessionOptions): Promise<LanguageModelSession | null>;
+export {};

package/dist/chrome-llm-adapter.js

@@ -0,0 +1,135 @@
+// The chrome-llm host-callback handler core (AGENTOS-WEB-ASYNC-AGENTS.md §6): the
+// trusted main-thread adapter that turns a chat-completion request (the shape pi's
+// HTTP client sends to its baseUrl) into a Chrome built-in `LanguageModel` call and
+// formats the reply back. This is the browser twin of native's `llmock-server.mjs`,
+// except backed by on-device inference instead of a mock/remote API.
+//
+// It is the only NEW trusted code in the inference path: the in-sandbox proxy guest
+// reaches it via the existing kernel-brokered host-callback (so it is mediated by
+// the policy, not an ambient capability), and pi reaches the proxy over the kernel
+// loopback. pi needs ZERO changes beyond a baseUrl.
+//
+// Pure + injectable: the model is an interface, so a mock (returning a fixed
+// sentinel) drives the deterministic CI gate and the real `LanguageModel` drives
+// the best-effort Nano smoke. Non-streaming for now (single prompt → single reply).
+export const LANGUAGE_MODEL_OPTIONS = {
+    expectedInputs: [{ type: "text", languages: ["en"] }],
+    expectedOutputs: [{ type: "text", languages: ["en"] }],
+};
+function getLanguageModelGlobal() {
+    return globalThis.LanguageModel;
+}
+export async function getChromeLanguageModelAvailability() {
+    const LanguageModel = getLanguageModelGlobal();
+    if (!LanguageModel)
+        return "missing-global";
+    try {
+        return await LanguageModel.availability(LANGUAGE_MODEL_OPTIONS);
+    }
+    catch (error) {
+        return `availability-error:${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    // Anthropic/OpenAI content can be an array of parts ({type:"text", text}).
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => part && typeof part === "object" && "text" in part
+            ? String(part.text)
+            : typeof part === "string"
+                ? part
+                : "")
+            .join("");
+    }
+    return "";
+}
+/** Flatten a chat request into a single prompt string for the on-device model. */
+export function chatRequestToPrompt(request) {
+    if (typeof request.prompt === "string")
+        return request.prompt;
+    const lines = [];
+    if (request.system)
+        lines.push(`system: ${request.system}`);
+    for (const message of request.messages ?? []) {
+        lines.push(`${message.role}: ${contentToText(message.content)}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Handle one chat-completion request against the on-device model. Returns an
+ * OpenAI-chat-completion-shaped JSON string (the shape pi's client decodes).
+ */
+export async function handleChatCompletion(requestBody, session) {
+    let request;
+    try {
+        request = JSON.parse(requestBody);
+    }
+    catch {
+        return JSON.stringify({ error: { type: "invalid_request", message: "invalid JSON body" } });
+    }
+    const text = await session.prompt(chatRequestToPrompt(request));
+    return JSON.stringify({
+        id: "chatcmpl-chrome-local",
+        object: "chat.completion",
+        model: request.model ?? "chrome-local",
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: text },
+                finish_reason: "stop",
+            },
+        ],
+    });
+}
+/**
+ * MANUAL-TESTING STAND-IN ONLY — not a real model. Returns a fake
+ * `LanguageModelSession` whose `prompt()` yields a deterministic canned reply
+ * instead of calling Chrome's on-device model. This exists so the real terminal
+ * + pi TUI flow can be driven end-to-end on hosts where `window.LanguageModel`
+ * cannot be provisioned (e.g. a headless Linux box). It is OPT-IN and is NEVER
+ * used by the strict real-model gates (`verify:real-pi-model` /
+ * `verify:real-language-model`), which require a genuine `window.LanguageModel`
+ * answer and fail honestly when it is absent. Callers that use this must report
+ * `usedRealLanguageModel: false`.
+ */
+export function createMockLanguageModelSession(reply) {
+    return {
+        async prompt(input) {
+            if (reply)
+                return reply(input);
+            const lastUser = input
+                .split("\n")
+                .reverse()
+                .find((line) => line.trimStart().startsWith("user:"));
+            const echo = (lastUser ?? input).replace(/^\s*user:\s*/, "").trim();
+            return ("[MOCK on-device model — not real] No real window.LanguageModel is " +
+                "available on this host, so this is a placeholder reply for manual " +
+                `testing. You said: ${echo || "(nothing)"}`);
+        },
+    };
+}
+/** Create a `LanguageModelSession` from the real Chrome `LanguageModel` global, or
+ * return null if it is unavailable (CI / unsupported). Probed lazily so the bundle
+ * loads without it. */
+export async function createChromeLanguageModelSession(options = {}) {
+    const LanguageModel = getLanguageModelGlobal();
+    if (!LanguageModel)
+        return null;
+    const availability = await getChromeLanguageModelAvailability();
+    if (availability !== "available" &&
+        !(options.allowDownload && (availability === "downloadable" || availability === "downloading"))) {
+        return null;
+    }
+    return LanguageModel.create({
+        ...LANGUAGE_MODEL_OPTIONS,
+        signal: options.signal,
+        monitor(monitor) {
+            monitor.addEventListener("downloadprogress", (event) => {
+                const progress = Number(event.loaded ?? 0);
+                options.onDownloadProgress?.(progress);
+            });
+        },
+    });
+}

package/dist/converged-execution-host-bridge.d.ts

@@ -0,0 +1,27 @@
+/** A synchronous ACP agent: each newline-delimited stdin JSON-RPC line maps to
+ * zero or more response lines, computed with no async I/O. */
+export interface SyncAgent {
+    /** Handle one complete stdin line (no trailing newline); return response lines. */
+    handleLine(line: string): string[];
+}
+/** Creates a {@link SyncAgent} for one execution (the launched ACP adapter). */
+export interface SyncAgentExecutor {
+    createAgent(request: {
+        executionId: string;
+        vmId: string;
+        argv: string[];
+        env: Record<string, string>;
+        cwd: string;
+    }): SyncAgent;
+}
+export interface ConvergedExecutionHostBridgeOptions {
+    /** When set, `startExecution` runs a synchronous in-process agent (AGENT mode). */
+    agentExecutor?: SyncAgentExecutor;
+}
+export interface ConvergedExecutionHostBridge {
+    /** Set the execution id `startExecution` echoes next (DRIVER mode). */
+    setNextExecutionId(executionId: string): void;
+    /** The host-bridge object passed to `new AgentOsBrowserSidecarWasm(bridge)`. */
+    readonly bridge: Record<string, (requestJson: string) => unknown>;
+}
+export declare function createConvergedExecutionHostBridge(options?: ConvergedExecutionHostBridgeOptions): ConvergedExecutionHostBridge;

package/dist/converged-execution-host-bridge.js

@@ -0,0 +1,180 @@
+// Execution host bridge for the converged Agent OS wasm sidecar.
+//
+// Two roles, selected by configuration:
+//
+// 1. DRIVER mode (default, no `agentExecutor`): mirrors secure-exec's no-op
+//    execution host bridge. In the converged browser runtime the guest runs in the
+//    browser worker (driven by @secure-exec/browser's runtime driver), not in the
+//    wasm sidecar; the sidecar only needs a kernel process (pid) for socket
+//    ownership, created by an `execute` wire request. `startExecution` echoes the
+//    driver-provided execution id (set via `setNextExecutionId`); the stdio
+//    callbacks are no-ops (the driver owns the guest's stdio).
+//
+// 2. AGENT mode (`agentExecutor` provided): runs a SYNCHRONOUS in-process agent for
+//    ACP `create_session`. Because the converged sidecar + the host-free `AcpCore`
+//    run synchronously on the main thread (a single `pushFrame` drives the whole
+//    initialize+session/new handshake), and the main thread may NOT block-wait on a
+//    Worker (`Atomics.wait` is forbidden there; postMessage can't arrive mid-frame),
+//    an *async* agent worker cannot be driven from here — see
+//    AGENTOS-WEB-CONVERGENCE.md Step 7. A synchronous agent (each stdin line maps to
+//    response lines with no async I/O, e.g. an ACP echo/test adapter) CAN: it runs
+//    in the same call stack, so `writeExecutionStdin` synchronously produces the
+//    output that the immediately-following `pollExecutionEvent` returns, and the
+//    synchronous `AcpCore` completes within the one `pushFrame`.
+//
+// The wasm `AgentOsBrowserSidecarWasm` host bridge invokes each method with a JSON
+// request string and JSON-decodes the return value.
+function decodeBase64ToText(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1)
+        bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+}
+function encodeTextToBase64(text) {
+    const bytes = new TextEncoder().encode(text);
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+export function createConvergedExecutionHostBridge(options = {}) {
+    let nextExecutionId = "converged-exec";
+    let contextCounter = 0;
+    let workerCounter = 0;
+    let agentCounter = 0;
+    const executor = options.agentExecutor;
+    const sessions = new Map();
+    const bridge = {
+        createJavascriptContext() {
+            contextCounter += 1;
+            return { contextId: `converged-ctx-${contextCounter}` };
+        },
+        createWasmContext() {
+            contextCounter += 1;
+            return { contextId: `converged-wasm-ctx-${contextCounter}` };
+        },
+        startExecution(requestJson) {
+            if (!executor) {
+                // DRIVER mode: echo the driver-provided id.
+                return { executionId: nextExecutionId };
+            }
+            // AGENT mode: mint a fresh id and instantiate the synchronous agent.
+            const request = parse(requestJson);
+            agentCounter += 1;
+            const executionId = `agent-exec-${agentCounter}`;
+            const vmId = typeof request.vmId === "string" ? request.vmId : "";
+            const agent = executor.createAgent({
+                executionId,
+                vmId,
+                argv: Array.isArray(request.argv) ? request.argv : [],
+                env: request.env && typeof request.env === "object"
+                    ? request.env
+                    : {},
+                cwd: typeof request.cwd === "string" ? request.cwd : "",
+            });
+            sessions.set(executionId, {
+                vmId,
+                agent,
+                buffer: "",
+                events: [],
+                exited: false,
+            });
+            return { executionId };
+        },
+        createWorker(requestJson) {
+            workerCounter += 1;
+            const request = parse(requestJson);
+            return {
+                workerId: `converged-worker-${workerCounter}`,
+                runtime: typeof request.runtime === "string" ? request.runtime : undefined,
+            };
+        },
+        writeExecutionStdin(requestJson) {
+            const request = parse(requestJson);
+            const executionId = typeof request.executionId === "string" ? request.executionId : "";
+            const session = sessions.get(executionId);
+            if (!session)
+                return {};
+            const chunkBase64 = typeof request.chunkBase64 === "string" ? request.chunkBase64 : "";
+            session.buffer += decodeBase64ToText(chunkBase64);
+            let newlineIndex = session.buffer.indexOf("\n");
+            while (newlineIndex >= 0) {
+                const line = session.buffer.slice(0, newlineIndex);
+                session.buffer = session.buffer.slice(newlineIndex + 1);
+                if (line.trim()) {
+                    for (const output of session.agent.handleLine(line)) {
+                        session.events.push({
+                            type: "stdout",
+                            vmId: session.vmId,
+                            executionId,
+                            chunkBase64: encodeTextToBase64(`${output}\n`),
+                        });
+                    }
+                }
+                newlineIndex = session.buffer.indexOf("\n");
+            }
+            return {};
+        },
+        closeExecutionStdin() {
+            return {};
+        },
+        killExecution(requestJson) {
+            const request = parse(requestJson);
+            const executionId = typeof request.executionId === "string" ? request.executionId : "";
+            const session = sessions.get(executionId);
+            if (session && !session.exited) {
+                session.exited = true;
+                session.events.push({
+                    type: "exited",
+                    vmId: session.vmId,
+                    executionId,
+                    exitCode: 0,
+                });
+            }
+            return {};
+        },
+        pollExecutionEvent(requestJson) {
+            const request = parse(requestJson);
+            const vmId = typeof request.vmId === "string" ? request.vmId : "";
+            for (const session of sessions.values()) {
+                if (session.vmId === vmId && session.events.length > 0) {
+                    return session.events.shift();
+                }
+            }
+            return null;
+        },
+        terminateWorker() {
+            return {};
+        },
+        emitStructuredEvent() {
+            return {};
+        },
+        emitDiagnostic() {
+            return {};
+        },
+        emitLog() {
+            return {};
+        },
+        emitLifecycle() {
+            return {};
+        },
+    };
+    return {
+        setNextExecutionId(executionId) {
+            nextExecutionId = executionId;
+        },
+        bridge,
+    };
+}
+function parse(requestJson) {
+    try {
+        const value = JSON.parse(requestJson);
+        return typeof value === "object" && value !== null
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/converged-sidecar.d.ts

@@ -0,0 +1,39 @@
+import type { CreateVmConfig } from "@secure-exec/core/vm-config";
+import type { ProtocolFramePayloadCodec } from "@secure-exec/core/protocol-frames";
+import type { ConvergedSidecarFactoryOptions } from "@secure-exec/browser";
+import { type SyncAgentExecutor } from "./converged-execution-host-bridge.js";
+export interface AgentOsConvergedSidecarOptions {
+    /** Wire codec; defaults to the same-version BARE codec. */
+    codec?: ProtocolFramePayloadCodec;
+    /** Invoked when the kernel denies a guest fs read with EACCES. */
+    onFsReadDenied?: () => void;
+    /**
+     * Override the wasm glue-module URL (advanced; defaults to the bundled
+     * dist/sidecar-wasm-web output resolved relative to this module).
+     */
+    moduleUrl?: URL | string;
+    /** Override the wasm binary URL (advanced; see `moduleUrl`). */
+    binaryUrl?: URL | string;
+    /**
+     * Run a SYNCHRONOUS in-process ACP agent for `create_session` (e.g. an ACP
+     * echo/test adapter). Required to drive an agent process in-browser, because
+     * the synchronous main-thread `AcpCore` cannot block-wait on an async agent
+     * worker (see AGENTOS-WEB-CONVERGENCE.md Step 7). Omit for guest-only use.
+     */
+    agentExecutor?: SyncAgentExecutor;
+}
+/**
+ * Build the {@link ConvergedSidecarFactoryOptions} for the Agent OS web-target
+ * wasm kernel (with the ACP extension). Pass the result to
+ * `createBrowserRuntimeDriverFactory`'s `convergedSidecar` option:
+ *
+ * ```ts
+ * import { createBrowserRuntimeDriverFactory } from "@secure-exec/browser";
+ * import { createAgentOsConvergedSidecar } from "@rivet-dev/agentos-browser";
+ *
+ * const factory = createBrowserRuntimeDriverFactory({
+ *   convergedSidecar: createAgentOsConvergedSidecar(config),
+ * });
+ * ```
+ */
+export declare function createAgentOsConvergedSidecar(config: CreateVmConfig, options?: AgentOsConvergedSidecarOptions): ConvergedSidecarFactoryOptions;

package/dist/converged-sidecar.js

@@ -0,0 +1,60 @@
+// Agent OS converged sidecar loader.
+//
+// The converged browser runtime lives in `@secure-exec/browser`: the worker, the
+// SharedArrayBuffer sync-bridge, and the fs/net/dns/module servicers are all
+// reused verbatim. Agent OS plugs in its OWN wasm sidecar — the one that registers
+// `BrowserAcpExtension` — via `createBrowserRuntimeDriverFactory({ convergedSidecar })`.
+// This is the Agent OS analogue of secure-exec's `createDefaultConvergedSidecar`:
+// same `ConvergedSidecarFactoryOptions` contract, different (ACP-bearing) wasm.
+//
+// The kernel (wasm) remains the sole enforcement point; no guest-side permission
+// eval, one transport. The agentos wasm-bindgen web output fetches its own
+// `_bg.wasm`; both URLs resolve relative to this module so a consumer's bundler
+// (or native ESM loader) emits/serves them.
+import { createConvergedExecutionHostBridge, } from "./converged-execution-host-bridge.js";
+const WASM_MODULE_URL = new URL("./sidecar-wasm-web/agentos_sidecar_browser.js", import.meta.url);
+const WASM_BINARY_URL = new URL("./sidecar-wasm-web/agentos_sidecar_browser_bg.wasm", import.meta.url);
+/**
+ * Build the {@link ConvergedSidecarFactoryOptions} for the Agent OS web-target
+ * wasm kernel (with the ACP extension). Pass the result to
+ * `createBrowserRuntimeDriverFactory`'s `convergedSidecar` option:
+ *
+ * ```ts
+ * import { createBrowserRuntimeDriverFactory } from "@secure-exec/browser";
+ * import { createAgentOsConvergedSidecar } from "@rivet-dev/agentos-browser";
+ *
+ * const factory = createBrowserRuntimeDriverFactory({
+ *   convergedSidecar: createAgentOsConvergedSidecar(config),
+ * });
+ * ```
+ */
+export function createAgentOsConvergedSidecar(config, options = {}) {
+    const moduleUrl = options.moduleUrl ?? WASM_MODULE_URL;
+    const binaryUrl = options.binaryUrl ?? WASM_BINARY_URL;
+    return {
+        config,
+        codec: options.codec ?? "bare",
+        onFsReadDenied: options.onFsReadDenied,
+        async loadSidecar() {
+            const host = createConvergedExecutionHostBridge({
+                agentExecutor: options.agentExecutor,
+            });
+            const wasmModule = (await import(
+            /* @vite-ignore */ String(moduleUrl)));
+            await wasmModule.default(String(binaryUrl));
+            const sidecar = new wasmModule.AgentOsBrowserSidecarWasm(host.bridge);
+            return {
+                pushFrame: (frame) => {
+                    const response = sidecar.pushFrame(frame);
+                    if (!(response instanceof Uint8Array)) {
+                        throw new Error("agentos wasm sidecar returned no response frame");
+                    }
+                    return response;
+                },
+                setNextExecutionId: (executionId) => {
+                    host.setNextExecutionId(executionId);
+                },
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,9 +1,12 @@
-export type { BrowserDriverOptions, BrowserRuntimeSystemOptions, } from "./driver.js";
-export { createBrowserDriver, createBrowserNetworkAdapter, createOpfsFileSystem, listOpfsNamespaces, releaseOpfsNamespace, } from "./driver.js";
-export { InMemoryFileSystem } from "./os-filesystem.js";
-export type { ExecOptions, ExecResult, NodeRuntimeDriver, StdioChannel, StdioEvent, TimingMitigation, } from "./runtime.js";
-export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createInMemoryFileSystem, } from "./runtime.js";
-export type { BrowserRuntimeDriverFactoryOptions } from "./runtime-driver.js";
-export { createBrowserRuntimeDriverFactory } from "./runtime-driver.js";
-export type { WorkerHandle } from "./worker-adapter.js";
-export { BrowserWorkerAdapter } from "./worker-adapter.js";
+export type { BrowserDriverOptions, BrowserRuntimeSystemOptions, } from "@secure-exec/browser";
+export { createBrowserDriver, createBrowserNetworkAdapter, createOpfsFileSystem, InMemoryFileSystem, } from "@secure-exec/browser";
+export type { ExecOptions, ExecResult, NodeRuntimeDriver, StdioChannel, StdioEvent, TimingMitigation, } from "@secure-exec/browser";
+export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createInMemoryFileSystem, } from "@secure-exec/browser";
+export type { BrowserRuntimeDriverFactoryOptions, ConvergedSidecarFactoryOptions, ConvergedSidecarHandle, } from "@secure-exec/browser";
+export { createBrowserRuntimeDriverFactory } from "@secure-exec/browser";
+export type { WorkerHandle } from "@secure-exec/browser";
+export { BrowserWorkerAdapter } from "@secure-exec/browser";
+export type { AgentOsConvergedSidecarOptions } from "./converged-sidecar.js";
+export { createAgentOsConvergedSidecar } from "./converged-sidecar.js";
+export type { ConvergedExecutionHostBridge } from "./converged-execution-host-bridge.js";
+export { createConvergedExecutionHostBridge } from "./converged-execution-host-bridge.js";

package/dist/index.js

@@ -1,5 +1,19 @@
-export { createBrowserDriver, createBrowserNetworkAdapter, createOpfsFileSystem, listOpfsNamespaces, releaseOpfsNamespace, } from "./driver.js";
-export { InMemoryFileSystem } from "./os-filesystem.js";
-export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createInMemoryFileSystem, } from "./runtime.js";
-export { createBrowserRuntimeDriverFactory } from "./runtime-driver.js";
-export { BrowserWorkerAdapter } from "./worker-adapter.js";
+// @rivet-dev/agentos-browser — converged browser runtime for Agent OS.
+//
+// The browser runtime is @secure-exec/browser's CONVERGED stack (worker,
+// SharedArrayBuffer sync-bridge, fs/net/dns/module servicers, all enforced by the
+// wasm kernel). Agent OS does not carry its own copy; it re-exports that runtime
+// and adds only the ACP/wasm-sidecar layer (createAgentOsConvergedSidecar). The
+// pre-convergence TS-kernel files (worker/runtime/driver/sync-bridge/permission
+// eval) were deleted in the reconciliation — the kernel is the sole enforcement
+// point, so guest-side permission eval no longer exists here.
+//
+// Per the converged model (kernel-owns-fs), per-runtime OPFS *namespace* helpers
+// (listOpfsNamespaces/releaseOpfsNamespace) are gone: storage isolation is the
+// kernel's responsibility, not a TS-layer concern.
+export { createBrowserDriver, createBrowserNetworkAdapter, createOpfsFileSystem, InMemoryFileSystem, } from "@secure-exec/browser";
+export { allowAll, allowAllChildProcess, allowAllEnv, allowAllFs, allowAllNetwork, createInMemoryFileSystem, } from "@secure-exec/browser";
+export { createBrowserRuntimeDriverFactory } from "@secure-exec/browser";
+export { BrowserWorkerAdapter } from "@secure-exec/browser";
+export { createAgentOsConvergedSidecar } from "./converged-sidecar.js";
+export { createConvergedExecutionHostBridge } from "./converged-execution-host-bridge.js";

package/dist/openai-proxy.d.ts

@@ -0,0 +1,23 @@
+export interface HttpRequest {
+    method: string;
+    path: string;
+    headers: Map<string, string>;
+    body: string;
+}
+export interface HttpResponse {
+    status: number;
+    headers: Map<string, string>;
+    body: string;
+}
+/** Build a minimal HTTP/1.1 request (the client/pi side). */
+export declare function buildHttpRequest(method: string, path: string, body: string, host?: string): Uint8Array;
+/** Build a minimal HTTP/1.1 response (the proxy side). */
+export declare function buildHttpResponse(status: number, body: string): Uint8Array;
+/** Parse a complete HTTP request, reading more via `readChunk` until the body is in. */
+export declare function readHttpRequest(initial: Uint8Array, readChunk: () => Uint8Array | null): HttpRequest | null;
+/** Parse a complete HTTP response (the client/pi side). */
+export declare function readHttpResponse(initial: Uint8Array, readChunk: () => Uint8Array | null): HttpResponse | null;
+/** The proxy core: turn one parsed HTTP request into an HTTP response by forwarding
+ * the body to `infer` (the host.inference call). Only POSTs to a chat/completions or
+ * /v1/messages path are forwarded; anything else is a 404-shaped error. */
+export declare function handleProxyRequest(request: HttpRequest, infer: (body: string) => Promise<string> | string): Promise<Uint8Array>;