@rivet-dev/agentos-runtime-core 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/response-payloads.js

@@ -0,0 +1,402 @@
+import { fromGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import { fromGeneratedExtEnvelope } from "./ext.js";
+import * as protocol from "./generated-protocol.js";
+import { parseJsonUtf8 } from "./json.js";
+import { bigIntToSafeNumber } from "./numbers.js";
+import { fromGeneratedFilesystemOperation, fromGeneratedGuestFilesystemOperation, fromGeneratedRootFilesystemEntryEncoding, fromGeneratedSignalDispositionAction, } from "./protocol-maps.js";
+import { fromGeneratedGuestFilesystemStat, fromGeneratedProcessSnapshotEntry, fromGeneratedSocketStateEntry, } from "./state.js";
+export function fromGeneratedResponsePayload(payload) {
+    switch (payload.tag) {
+        case "AuthenticatedResponse":
+            return {
+                type: "authenticated",
+                sidecar_id: payload.val.sidecarId,
+                connection_id: payload.val.connectionId,
+                max_frame_bytes: payload.val.maxFrameBytes,
+            };
+        case "SessionOpenedResponse":
+            return {
+                type: "session_opened",
+                session_id: payload.val.sessionId,
+                owner_connection_id: payload.val.ownerConnectionId,
+            };
+        case "SessionClosedResponse":
+            return {
+                type: "session_closed",
+                session_id: payload.val.sessionId,
+            };
+        case "VmCreatedResponse":
+            return {
+                type: "vm_created",
+                vm_id: payload.val.vmId,
+                guest_cwd: payload.val.guestCwd,
+                guest_env: Object.fromEntries(payload.val.guestEnv),
+                process_route_retention: bigIntToSafeNumber(payload.val.processRouteRetention, "vm_created.process_route_retention"),
+            };
+        case "VmInitializedResponse":
+            return {
+                type: "vm_initialized",
+                vm_id: payload.val.vmId,
+                guest_cwd: payload.val.guestCwd,
+                guest_env: Object.fromEntries(payload.val.guestEnv),
+                process_route_retention: bigIntToSafeNumber(payload.val.processRouteRetention, "vm_initialized.process_route_retention"),
+                applied_mounts: payload.val.appliedMounts,
+                projected_commands: payload.val.projectedCommands.map((command) => ({
+                    name: command.name,
+                    guest_path: command.guestPath,
+                })),
+                agents: payload.val.agents.map(fromGeneratedAgentosProjectedAgent),
+                host_callbacks: payload.val.hostCallbacks.map((registration) => ({
+                    registration: registration.registration,
+                    command_count: registration.commandCount,
+                })),
+            };
+        case "VmDisposedResponse":
+            return { type: "vm_disposed", vm_id: payload.val.vmId };
+        case "RootFilesystemBootstrappedResponse":
+            return {
+                type: "root_filesystem_bootstrapped",
+                entry_count: payload.val.entryCount,
+            };
+        case "VmConfiguredResponse":
+            return {
+                type: "vm_configured",
+                applied_mounts: payload.val.appliedMounts,
+                projected_commands: payload.val.projectedCommands.map((command) => ({
+                    name: command.name,
+                    guest_path: command.guestPath,
+                })),
+                agents: payload.val.agents.map(fromGeneratedAgentosProjectedAgent),
+            };
+        case "PackageLinkedResponse":
+            return {
+                type: "package_linked",
+                projected_commands: payload.val.projectedCommands.map((command) => ({
+                    name: command.name,
+                    guest_path: command.guestPath,
+                })),
+                agents: payload.val.agents.map(fromGeneratedAgentosProjectedAgent),
+            };
+        case "ProvidedCommandsResponse":
+            return {
+                type: "provided_commands_response",
+                packages: payload.val.packages.map((pkg) => ({
+                    package_name: pkg.packageName,
+                    commands: [...pkg.commands],
+                })),
+            };
+        case "CronScheduledResponse":
+            return {
+                type: "cron_scheduled",
+                id: payload.val.id,
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+            };
+        case "CronJobsResponse":
+            return {
+                type: "cron_jobs",
+                jobs: payload.val.jobs.map(fromGeneratedCronJobEntry),
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+            };
+        case "CronCancelledResponse":
+            return {
+                type: "cron_cancelled",
+                id: payload.val.id,
+                cancelled: payload.val.cancelled,
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+            };
+        case "CronWakeResponse":
+            return {
+                type: "cron_wake",
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+                runs: payload.val.runs.map(fromGeneratedCronRun),
+                events: payload.val.events.map(fromGeneratedCronEvent),
+            };
+        case "CronRunCompletedResponse":
+            return {
+                type: "cron_run_completed",
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+                runs: payload.val.runs.map(fromGeneratedCronRun),
+                events: payload.val.events.map(fromGeneratedCronEvent),
+            };
+        case "CronStateExportedResponse":
+            return {
+                type: "cron_state_exported",
+                state: payload.val.state,
+            };
+        case "CronStateImportedResponse":
+            return {
+                type: "cron_state_imported",
+                alarm: fromGeneratedCronAlarm(payload.val.alarm),
+                runs: payload.val.runs.map(fromGeneratedCronRun),
+                events: payload.val.events.map(fromGeneratedCronEvent),
+            };
+        case "HostCallbacksRegisteredResponse":
+            return {
+                type: "host_callbacks_registered",
+                registration: payload.val.registration,
+                command_count: payload.val.commandCount,
+            };
+        case "LayerCreatedResponse":
+            return { type: "layer_created", layer_id: payload.val.layerId };
+        case "LayerSealedResponse":
+            return { type: "layer_sealed", layer_id: payload.val.layerId };
+        case "SnapshotImportedResponse":
+            return { type: "snapshot_imported", layer_id: payload.val.layerId };
+        case "SnapshotExportedResponse":
+            return {
+                type: "snapshot_exported",
+                layer_id: payload.val.layerId,
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "OverlayCreatedResponse":
+            return { type: "overlay_created", layer_id: payload.val.layerId };
+        case "GuestFilesystemResultResponse":
+            return {
+                type: "guest_filesystem_result",
+                operation: fromGeneratedGuestFilesystemOperation(payload.val.operation),
+                path: payload.val.path,
+                ...(payload.val.content !== null
+                    ? { content: payload.val.content }
+                    : {}),
+                ...(payload.val.encoding !== null
+                    ? {
+                        encoding: fromGeneratedRootFilesystemEntryEncoding(payload.val.encoding),
+                    }
+                    : {}),
+                ...(payload.val.entries !== null
+                    ? {
+                        entries: payload.val.entries.map((entry) => ({
+                            name: entry.name,
+                            path: entry.path,
+                            isDirectory: entry.isDirectory,
+                            isSymbolicLink: entry.isSymbolicLink,
+                            size: entry.size,
+                        })),
+                    }
+                    : {}),
+                ...(payload.val.stat !== null
+                    ? { stat: fromGeneratedGuestFilesystemStat(payload.val.stat) }
+                    : {}),
+                ...(payload.val.exists !== null ? { exists: payload.val.exists } : {}),
+                ...(payload.val.target !== null ? { target: payload.val.target } : {}),
+            };
+        case "GuestKernelResultResponse":
+            return {
+                type: "guest_kernel_result",
+                payload: payload.val.payload,
+            };
+        case "RootFilesystemSnapshotResponse":
+            return {
+                type: "root_filesystem_snapshot",
+                entries: payload.val.entries.map(fromGeneratedRootFilesystemEntry),
+            };
+        case "ProcessStartedResponse":
+            return {
+                type: "process_started",
+                process_id: payload.val.processId,
+                ...(payload.val.pid !== null ? { pid: payload.val.pid } : {}),
+            };
+        case "StdinWrittenResponse":
+            return {
+                type: "stdin_written",
+                process_id: payload.val.processId,
+                accepted_bytes: bigIntToSafeNumber(payload.val.acceptedBytes, "stdin_written.accepted_bytes"),
+            };
+        case "PtyResizedResponse":
+            return {
+                type: "pty_resized",
+                process_id: payload.val.processId,
+                cols: payload.val.cols,
+                rows: payload.val.rows,
+            };
+        case "StdinClosedResponse":
+            return { type: "stdin_closed", process_id: payload.val.processId };
+        case "ProcessKilledResponse":
+            return { type: "process_killed", process_id: payload.val.processId };
+        case "ProcessSnapshotResponse":
+            return {
+                type: "process_snapshot",
+                processes: payload.val.processes.map(fromGeneratedProcessSnapshotEntry),
+            };
+        case "ResourceSnapshotResponse":
+            return {
+                type: "resource_snapshot",
+                running_processes: bigIntToSafeNumber(payload.val.runningProcesses, "resource_snapshot.running_processes"),
+                exited_processes: bigIntToSafeNumber(payload.val.exitedProcesses, "resource_snapshot.exited_processes"),
+                fd_tables: bigIntToSafeNumber(payload.val.fdTables, "resource_snapshot.fd_tables"),
+                open_fds: bigIntToSafeNumber(payload.val.openFds, "resource_snapshot.open_fds"),
+                pipes: bigIntToSafeNumber(payload.val.pipes, "resource_snapshot.pipes"),
+                pipe_buffered_bytes: bigIntToSafeNumber(payload.val.pipeBufferedBytes, "resource_snapshot.pipe_buffered_bytes"),
+                ptys: bigIntToSafeNumber(payload.val.ptys, "resource_snapshot.ptys"),
+                pty_buffered_input_bytes: bigIntToSafeNumber(payload.val.ptyBufferedInputBytes, "resource_snapshot.pty_buffered_input_bytes"),
+                pty_buffered_output_bytes: bigIntToSafeNumber(payload.val.ptyBufferedOutputBytes, "resource_snapshot.pty_buffered_output_bytes"),
+                sockets: bigIntToSafeNumber(payload.val.sockets, "resource_snapshot.sockets"),
+                socket_listeners: bigIntToSafeNumber(payload.val.socketListeners, "resource_snapshot.socket_listeners"),
+                socket_connections: bigIntToSafeNumber(payload.val.socketConnections, "resource_snapshot.socket_connections"),
+                socket_buffered_bytes: bigIntToSafeNumber(payload.val.socketBufferedBytes, "resource_snapshot.socket_buffered_bytes"),
+                socket_datagram_queue_len: bigIntToSafeNumber(payload.val.socketDatagramQueueLen, "resource_snapshot.socket_datagram_queue_len"),
+                queue_snapshots: payload.val.queueSnapshots.map((queue) => ({
+                    name: queue.name,
+                    category: queue.category,
+                    depth: bigIntToSafeNumber(queue.depth, "resource_snapshot.queue.depth"),
+                    high_water: bigIntToSafeNumber(queue.highWater, "resource_snapshot.queue.high_water"),
+                    capacity: bigIntToSafeNumber(queue.capacity, "resource_snapshot.queue.capacity"),
+                    fill_percent: bigIntToSafeNumber(queue.fillPercent, "resource_snapshot.queue.fill_percent"),
+                })),
+            };
+        case "ListenerSnapshotResponse":
+            return {
+                type: "listener_snapshot",
+                ...(payload.val.listener !== null
+                    ? { listener: fromGeneratedSocketStateEntry(payload.val.listener) }
+                    : {}),
+            };
+        case "BoundUdpSnapshotResponse":
+            return {
+                type: "bound_udp_snapshot",
+                ...(payload.val.socket !== null
+                    ? { socket: fromGeneratedSocketStateEntry(payload.val.socket) }
+                    : {}),
+            };
+        case "SignalStateResponse":
+            return {
+                type: "signal_state",
+                process_id: payload.val.processId,
+                handlers: Object.fromEntries([...payload.val.handlers].map(([signal, registration]) => [
+                    String(signal),
+                    {
+                        action: fromGeneratedSignalDispositionAction(registration.action),
+                        mask: Array.from(registration.mask),
+                        flags: registration.flags,
+                    },
+                ])),
+            };
+        case "ZombieTimerCountResponse":
+            return {
+                type: "zombie_timer_count",
+                count: bigIntToSafeNumber(payload.val.count, "zombie_timer_count.count"),
+            };
+        case "FilesystemResultResponse":
+            return {
+                type: "filesystem_result",
+                operation: fromGeneratedFilesystemOperation(payload.val.operation),
+                status: payload.val.status,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "filesystem_result.payload_size_bytes"),
+            };
+        case "PermissionDecisionResponse":
+            throw new Error("unsupported bare response payload tag: permission_decision");
+        case "PersistenceStateResponse":
+            return {
+                type: "persistence_state",
+                key: payload.val.key,
+                found: payload.val.found,
+                payload_size_bytes: bigIntToSafeNumber(payload.val.payloadSizeBytes, "persistence_state.payload_size_bytes"),
+            };
+        case "PersistenceFlushedResponse":
+            return {
+                type: "persistence_flushed",
+                key: payload.val.key,
+                committed_bytes: bigIntToSafeNumber(payload.val.committedBytes, "persistence_flushed.committed_bytes"),
+            };
+        case "RejectedResponse":
+            return {
+                type: "rejected",
+                code: payload.val.code,
+                message: payload.val.message,
+            };
+        case "VmFetchResponse":
+            return {
+                type: "vm_fetch_result",
+                response_json: payload.val.responseJson,
+            };
+        case "ExtEnvelope":
+            return {
+                type: "ext_result",
+                envelope: fromGeneratedExtEnvelope(payload.val),
+            };
+    }
+}
+function fromGeneratedCronAlarm(value) {
+    return {
+        generation: bigIntToSafeNumber(value.generation, "cron_alarm.generation"),
+        ...(value.nextAlarmMs === null
+            ? {}
+            : {
+                next_alarm_ms: bigIntToSafeNumber(value.nextAlarmMs, "cron_alarm.next_alarm_ms"),
+            }),
+    };
+}
+function fromGeneratedCronOverlap(value) {
+    switch (value) {
+        case protocol.CronOverlap.Allow:
+            return "allow";
+        case protocol.CronOverlap.Skip:
+            return "skip";
+        case protocol.CronOverlap.Queue:
+            return "queue";
+    }
+}
+function fromGeneratedCronJobEntry(value) {
+    return {
+        id: value.id,
+        schedule: value.schedule,
+        action: parseJsonUtf8(value.action, "cron_job.action"),
+        overlap: fromGeneratedCronOverlap(value.overlap),
+        ...(value.lastRunMs === null
+            ? {}
+            : {
+                last_run_ms: bigIntToSafeNumber(value.lastRunMs, "cron_job.last_run_ms"),
+            }),
+        ...(value.nextRunMs === null
+            ? {}
+            : {
+                next_run_ms: bigIntToSafeNumber(value.nextRunMs, "cron_job.next_run_ms"),
+            }),
+        run_count: bigIntToSafeNumber(value.runCount, "cron_job.run_count"),
+        running: value.running,
+    };
+}
+function fromGeneratedCronRun(value) {
+    return {
+        run_id: value.runId,
+        job_id: value.jobId,
+        action: parseJsonUtf8(value.action, "cron_run.action"),
+    };
+}
+function fromGeneratedCronEvent(value) {
+    const kind = (() => {
+        switch (value.kind) {
+            case protocol.CronEventKind.Fire:
+                return "fire";
+            case protocol.CronEventKind.Complete:
+                return "complete";
+            case protocol.CronEventKind.Error:
+                return "error";
+        }
+    })();
+    return {
+        kind,
+        job_id: value.jobId,
+        time_ms: bigIntToSafeNumber(value.timeMs, "cron_event.time_ms"),
+        ...(value.durationMs === null
+            ? {}
+            : {
+                duration_ms: bigIntToSafeNumber(value.durationMs, "cron_event.duration_ms"),
+            }),
+        ...(value.error === null ? {} : { error: value.error }),
+    };
+}
+export function fromGeneratedCronDispatch(value) {
+    return {
+        alarm: fromGeneratedCronAlarm(value.alarm),
+        runs: value.runs.map(fromGeneratedCronRun),
+        events: value.events.map(fromGeneratedCronEvent),
+    };
+}
+function fromGeneratedAgentosProjectedAgent(agent) {
+    return {
+        id: agent.id,
+        acp_entrypoint: agent.acpEntrypoint,
+        adapter_entrypoint: agent.adapterEntrypoint,
+    };
+}

package/dist/sidecar-client.d.ts

@@ -0,0 +1,19 @@
+import type { LiveSidecarEventSelector } from "./event-buffer.js";
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveEventFrame, LiveResponseFrame, LiveSidecarRequestHandler } from "./protocol-frames.js";
+import type { LiveRequestPayload } from "./request-payloads.js";
+export interface SidecarProcessTransport {
+    registerSidecarRequestHandler(ownership: LiveOwnershipScope, handler: LiveSidecarRequestHandler): () => void;
+    onEvent(handler: (event: LiveEventFrame) => void, ownership?: LiveOwnershipScope): () => void;
+    sendRequest(input: {
+        ownership: LiveOwnershipScope;
+        payload: LiveRequestPayload;
+        /** Runs synchronously while the response frame is routed, before later frames. */
+        onResponse?: (response: LiveResponseFrame) => void;
+    }): Promise<LiveResponseFrame>;
+    waitForEvent(matcher: LiveSidecarEventSelector | ((event: LiveEventFrame) => boolean), timeoutMs?: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<LiveEventFrame>;
+    failPermanently(error: Error): void;
+    dispose(): Promise<void>;
+}

package/dist/sidecar-client.js

@@ -0,0 +1 @@
+export {};

package/dist/sidecar-errors.d.ts

@@ -0,0 +1,44 @@
+import type { LiveOwnershipScope } from "./ownership.js";
+import type { LiveResponseFrame } from "./protocol-frames.js";
+/** A sidecar-owned request failure, preserving its stable code and wire context. */
+export declare class SidecarRequestRejected extends Error {
+    readonly code: string;
+    readonly requestId: number;
+    readonly ownership: LiveOwnershipScope;
+    readonly response: LiveResponseFrame;
+    constructor(options: {
+        code: string;
+        message: string;
+        response: LiveResponseFrame;
+    });
+}
+export declare class SidecarProcessExited extends Error {
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly stderr: string;
+    constructor(options: {
+        exitCode: number | null;
+        signal: string | null;
+        stderr: string;
+    });
+}
+/**
+ * The silence watchdog fired: the sidecar produced no protocol frames at all —
+ * not even its 10s liveness heartbeats — for the full silence window, so the
+ * process is dead or wedged (not merely busy: a busy sidecar still heartbeats
+ * from a dedicated thread). The host kills the sidecar and rejects every
+ * in-flight request with this error.
+ */
+export declare class SidecarSilenceTimeout extends Error {
+    readonly silenceMs: number;
+    readonly stderr: string;
+    constructor(options: {
+        silenceMs: number;
+        stderr: string;
+    });
+}
+export declare class SidecarProcessError extends Error {
+    readonly childError: Error;
+    readonly stderr: string;
+    constructor(error: Error, stderr: string);
+}

package/dist/sidecar-errors.js

@@ -0,0 +1,62 @@
+function formatSidecarStderrSuffix(stderr) {
+    return stderr ? `\nstderr:\n${stderr}` : "";
+}
+/** A sidecar-owned request failure, preserving its stable code and wire context. */
+export class SidecarRequestRejected extends Error {
+    code;
+    requestId;
+    ownership;
+    response;
+    constructor(options) {
+        super(options.message);
+        this.name = "SidecarRequestRejected";
+        this.code = options.code;
+        this.requestId = options.response.request_id;
+        this.ownership = options.response.ownership;
+        this.response = options.response;
+    }
+}
+export class SidecarProcessExited extends Error {
+    exitCode;
+    signal;
+    stderr;
+    constructor(options) {
+        const reason = options.signal !== null
+            ? `signal ${options.signal}`
+            : options.exitCode !== null
+                ? `code ${options.exitCode}`
+                : "disconnect";
+        super(`sidecar process exited with ${reason}${formatSidecarStderrSuffix(options.stderr)}`);
+        this.name = "SidecarProcessExited";
+        this.exitCode = options.exitCode;
+        this.signal = options.signal;
+        this.stderr = options.stderr;
+    }
+}
+/**
+ * The silence watchdog fired: the sidecar produced no protocol frames at all —
+ * not even its 10s liveness heartbeats — for the full silence window, so the
+ * process is dead or wedged (not merely busy: a busy sidecar still heartbeats
+ * from a dedicated thread). The host kills the sidecar and rejects every
+ * in-flight request with this error.
+ */
+export class SidecarSilenceTimeout extends Error {
+    silenceMs;
+    stderr;
+    constructor(options) {
+        super(`sidecar unresponsive: no protocol frames or heartbeats for ${Math.round(options.silenceMs)}ms; killing sidecar${formatSidecarStderrSuffix(options.stderr)}`);
+        this.name = "SidecarSilenceTimeout";
+        this.silenceMs = options.silenceMs;
+        this.stderr = options.stderr;
+    }
+}
+export class SidecarProcessError extends Error {
+    childError;
+    stderr;
+    constructor(error, stderr) {
+        super(`sidecar process error: ${error.message}${formatSidecarStderrSuffix(stderr)}`);
+        this.name = "SidecarProcessError";
+        this.childError = error;
+        this.stderr = stderr;
+    }
+}