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

package/dist/request-payloads.js

@@ -0,0 +1,357 @@
+import { toExactArrayBuffer } from "./bytes.js";
+import { toGeneratedMountDescriptor, toGeneratedPackageDescriptor, toGeneratedSidecarPlacement, } from "./descriptors.js";
+import { toGeneratedExtEnvelope } from "./ext.js";
+import { toGeneratedRootFilesystemEntry, } from "./filesystem.js";
+import * as protocol from "./generated-protocol.js";
+import { stringifyJsonUtf8 } from "./json.js";
+import { toGeneratedPermissionsPolicy, } from "./permissions.js";
+import { toGeneratedDisposeReason, toGeneratedFilesystemOperation, toGeneratedGuestFilesystemOperation, toGeneratedGuestRuntimeKind, toGeneratedRootFilesystemEntryEncoding, toGeneratedRootFilesystemMode, toGeneratedWasmPermissionTier, } from "./protocol-maps.js";
+export function toGeneratedRequestPayload(payload) {
+    switch (payload.type) {
+        case "authenticate":
+            return {
+                tag: "AuthenticateRequest",
+                val: {
+                    clientName: payload.client_name,
+                    authToken: payload.auth_token,
+                    protocolVersion: payload.protocol_version,
+                    bridgeVersion: payload.bridge_version,
+                },
+            };
+        case "open_session":
+            return {
+                tag: "OpenSessionRequest",
+                val: {
+                    placement: toGeneratedSidecarPlacement(payload.placement),
+                },
+            };
+        case "close_session":
+            return {
+                tag: "CloseSessionRequest",
+                val: { sessionId: payload.session_id },
+            };
+        case "create_vm":
+            return {
+                tag: "CreateVmRequest",
+                val: {
+                    runtime: toGeneratedGuestRuntimeKind(payload.runtime),
+                    config: stringifyJsonUtf8(payload.config, "create VM config"),
+                },
+            };
+        case "initialize_vm":
+            return {
+                tag: "InitializeVmRequest",
+                val: {
+                    runtime: toGeneratedGuestRuntimeKind(payload.runtime),
+                    config: stringifyJsonUtf8(payload.config, "initialize VM config"),
+                    mounts: payload.mounts === undefined
+                        ? null
+                        : payload.mounts.map(toGeneratedMountDescriptor),
+                    packages: payload.packages === undefined
+                        ? null
+                        : payload.packages.map(toGeneratedPackageDescriptor),
+                    packagesMountAt: payload.packages_mount_at ?? null,
+                    hostCallbacks: payload.host_callbacks === undefined
+                        ? null
+                        : payload.host_callbacks.map(toGeneratedHostCallbackRegistration),
+                },
+            };
+        case "dispose_vm":
+            return {
+                tag: "DisposeVmRequest",
+                val: { reason: toGeneratedDisposeReason(payload.reason) },
+            };
+        case "bootstrap_root_filesystem":
+            return {
+                tag: "BootstrapRootFilesystemRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "configure_vm":
+            return {
+                tag: "ConfigureVmRequest",
+                val: {
+                    mounts: payload.mounts === undefined
+                        ? null
+                        : payload.mounts.map(toGeneratedMountDescriptor),
+                    permissions: toGeneratedPermissionsPolicy(payload.permissions),
+                    commandPermissions: payload.command_permissions === undefined
+                        ? null
+                        : new Map(Object.entries(payload.command_permissions).map(([name, tier]) => [
+                            name,
+                            toGeneratedWasmPermissionTier(tier),
+                        ])),
+                    loopbackExemptPorts: payload.loopback_exempt_ports === undefined
+                        ? null
+                        : new Uint16Array(payload.loopback_exempt_ports),
+                    packages: payload.packages === undefined
+                        ? null
+                        : payload.packages.map(toGeneratedPackageDescriptor),
+                    packagesMountAt: payload.packages_mount_at ?? null,
+                },
+            };
+        case "link_package":
+            return {
+                tag: "LinkPackageRequest",
+                val: {
+                    package: toGeneratedPackageDescriptor(payload.package),
+                },
+            };
+        case "provided_commands":
+            return {
+                tag: "ProvidedCommandsRequest",
+                val: null,
+            };
+        case "schedule_cron":
+            return {
+                tag: "ScheduleCronRequest",
+                val: {
+                    id: payload.id ?? null,
+                    schedule: payload.schedule,
+                    action: stringifyJsonUtf8(payload.action, "schedule_cron.action"),
+                    overlap: payload.overlap === undefined
+                        ? null
+                        : toGeneratedCronOverlap(payload.overlap),
+                },
+            };
+        case "list_cron_jobs":
+            return { tag: "ListCronJobsRequest", val: null };
+        case "cancel_cron_job":
+            return { tag: "CancelCronJobRequest", val: { id: payload.id } };
+        case "wake_cron":
+            return {
+                tag: "WakeCronRequest",
+                val: { generation: BigInt(payload.generation) },
+            };
+        case "complete_cron_run":
+            return {
+                tag: "CompleteCronRunRequest",
+                val: { runId: payload.run_id, error: payload.error ?? null },
+            };
+        case "export_cron_state":
+            return { tag: "ExportCronStateRequest", val: null };
+        case "import_cron_state":
+            return {
+                tag: "ImportCronStateRequest",
+                val: { state: payload.state },
+            };
+        case "register_host_callbacks":
+            return {
+                tag: "RegisterHostCallbacksRequest",
+                val: toGeneratedHostCallbackRegistration(payload),
+            };
+        case "create_layer":
+            return { tag: "CreateLayerRequest", val: null };
+        case "seal_layer":
+            return { tag: "SealLayerRequest", val: { layerId: payload.layer_id } };
+        case "import_snapshot":
+            return {
+                tag: "ImportSnapshotRequest",
+                val: { entries: payload.entries.map(toGeneratedRootFilesystemEntry) },
+            };
+        case "export_snapshot":
+            return {
+                tag: "ExportSnapshotRequest",
+                val: { layerId: payload.layer_id },
+            };
+        case "create_overlay":
+            return {
+                tag: "CreateOverlayRequest",
+                val: {
+                    mode: payload.mode === undefined
+                        ? null
+                        : toGeneratedRootFilesystemMode(payload.mode),
+                    upperLayerId: payload.upper_layer_id ?? null,
+                    lowerLayerIds: payload.lower_layer_ids,
+                },
+            };
+        case "guest_filesystem_call":
+            return {
+                tag: "GuestFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedGuestFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    destinationPath: payload.destination_path ?? null,
+                    target: payload.target ?? null,
+                    content: payload.content ?? null,
+                    encoding: payload.encoding === undefined
+                        ? null
+                        : toGeneratedRootFilesystemEntryEncoding(payload.encoding),
+                    recursive: payload.recursive ?? null,
+                    maxDepth: payload.max_depth ?? null,
+                    mode: payload.mode ?? null,
+                    uid: payload.uid ?? null,
+                    gid: payload.gid ?? null,
+                    atimeMs: toGeneratedOptionalU64(payload.atime_ms),
+                    mtimeMs: toGeneratedOptionalU64(payload.mtime_ms),
+                    len: toGeneratedOptionalU64(payload.len),
+                    offset: toGeneratedOptionalU64(payload.offset),
+                },
+            };
+        case "guest_kernel_call":
+            return {
+                tag: "GuestKernelCallRequest",
+                val: {
+                    executionId: payload.execution_id,
+                    operation: payload.operation,
+                    payload: payload.payload,
+                },
+            };
+        case "snapshot_root_filesystem":
+            return { tag: "SnapshotRootFilesystemRequest", val: null };
+        case "execute":
+            return {
+                tag: "ExecuteRequest",
+                val: {
+                    processId: payload.process_id ?? null,
+                    command: payload.command ?? null,
+                    shellCommand: payload.shell_command ?? null,
+                    runtime: payload.runtime === undefined
+                        ? null
+                        : toGeneratedGuestRuntimeKind(payload.runtime),
+                    entrypoint: payload.entrypoint ?? null,
+                    args: payload.args ?? [],
+                    env: payload.env === undefined
+                        ? null
+                        : new Map(Object.entries(payload.env)),
+                    cwd: payload.cwd ?? null,
+                    wasmPermissionTier: payload.wasm_permission_tier === undefined
+                        ? null
+                        : toGeneratedWasmPermissionTier(payload.wasm_permission_tier),
+                    pty: payload.pty === undefined
+                        ? null
+                        : {
+                            cols: payload.pty.cols ?? null,
+                            rows: payload.pty.rows ?? null,
+                        },
+                    keepStdinOpen: payload.keep_stdin_open ?? null,
+                    timeoutMs: payload.timeout_ms === undefined
+                        ? null
+                        : BigInt(payload.timeout_ms),
+                    captureOutput: payload.capture_output ?? null,
+                },
+            };
+        case "write_stdin":
+            return {
+                tag: "WriteStdinRequest",
+                val: {
+                    processId: payload.process_id,
+                    chunk: toExactArrayBuffer(payload.chunk),
+                },
+            };
+        case "resize_pty":
+            return {
+                tag: "ResizePtyRequest",
+                val: {
+                    processId: payload.process_id,
+                    cols: payload.cols,
+                    rows: payload.rows,
+                },
+            };
+        case "close_stdin":
+            return {
+                tag: "CloseStdinRequest",
+                val: { processId: payload.process_id },
+            };
+        case "kill_process":
+            return {
+                tag: "KillProcessRequest",
+                val: { processId: payload.process_id, signal: payload.signal },
+            };
+        case "get_process_snapshot":
+            return { tag: "GetProcessSnapshotRequest", val: null };
+        case "get_resource_snapshot":
+            return { tag: "GetResourceSnapshotRequest", val: null };
+        case "find_listener":
+            return {
+                tag: "FindListenerRequest",
+                val: {
+                    host: payload.host ?? null,
+                    port: payload.port ?? null,
+                    path: payload.path ?? null,
+                },
+            };
+        case "find_bound_udp":
+            return {
+                tag: "FindBoundUdpRequest",
+                val: { host: payload.host ?? null, port: payload.port ?? null },
+            };
+        case "vm_fetch":
+            return {
+                tag: "VmFetchRequest",
+                val: {
+                    port: payload.port,
+                    method: payload.method,
+                    path: payload.path,
+                    headersJson: payload.headers_json,
+                    body: payload.body ?? null,
+                },
+            };
+        case "get_signal_state":
+            return {
+                tag: "GetSignalStateRequest",
+                val: { processId: payload.process_id },
+            };
+        case "get_zombie_timer_count":
+            return { tag: "GetZombieTimerCountRequest", val: null };
+        case "host_filesystem_call":
+            return {
+                tag: "HostFilesystemCallRequest",
+                val: {
+                    operation: toGeneratedFilesystemOperation(payload.operation),
+                    path: payload.path,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "persistence_load":
+            return {
+                tag: "PersistenceLoadRequest",
+                val: { key: payload.key },
+            };
+        case "persistence_flush":
+            return {
+                tag: "PersistenceFlushRequest",
+                val: {
+                    key: payload.key,
+                    payloadSizeBytes: BigInt(payload.payload_size_bytes),
+                },
+            };
+        case "ext":
+            return {
+                tag: "ExtEnvelope",
+                val: toGeneratedExtEnvelope(payload.envelope),
+            };
+    }
+}
+function toGeneratedHostCallbackRegistration(registration) {
+    return {
+        name: registration.name,
+        description: registration.description,
+        callbacks: new Map(Object.entries(registration.callbacks).map(([name, callback]) => [
+            name,
+            {
+                description: callback.description,
+                inputSchema: stringifyJsonUtf8(callback.input_schema, "host callback input schema"),
+                timeoutMs: callback.timeout_ms === undefined
+                    ? null
+                    : BigInt(callback.timeout_ms),
+                examples: (callback.examples ?? []).map((example) => ({
+                    description: example.description,
+                    input: stringifyJsonUtf8(example.input, "host callback example"),
+                })),
+            },
+        ])),
+    };
+}
+function toGeneratedCronOverlap(value) {
+    switch (value) {
+        case "allow":
+            return protocol.CronOverlap.Allow;
+        case "skip":
+            return protocol.CronOverlap.Skip;
+        case "queue":
+            return protocol.CronOverlap.Queue;
+    }
+}
+function toGeneratedOptionalU64(value) {
+    return value === undefined ? null : BigInt(value);
+}

package/dist/response-payloads.d.ts

@@ -0,0 +1,268 @@
+import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
+import { type LiveExtEnvelope } from "./ext.js";
+import * as protocol from "./generated-protocol.js";
+import type { LiveCronOverlap } from "./request-payloads.js";
+import { type LiveFilesystemOperation, type LiveGuestFilesystemOperation, type LiveSignalDispositionAction } from "./protocol-maps.js";
+import { type LiveGuestFilesystemStat, type LiveProcessSnapshotEntry, type LiveSocketStateEntry } from "./state.js";
+/** A directory child with its file type, from `read_dir` (no extra lstat). */
+export interface LiveGuestDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: bigint;
+}
+export interface LiveSignalHandlerRegistration {
+    action: LiveSignalDispositionAction;
+    mask: number[];
+    flags: number;
+}
+export interface LiveQueueSnapshotEntry {
+    name: string;
+    category: string;
+    depth: number;
+    high_water: number;
+    capacity: number;
+    fill_percent: number;
+}
+export interface LiveResourceSnapshot {
+    running_processes: number;
+    exited_processes: number;
+    fd_tables: number;
+    open_fds: number;
+    pipes: number;
+    pipe_buffered_bytes: number;
+    ptys: number;
+    pty_buffered_input_bytes: number;
+    pty_buffered_output_bytes: number;
+    sockets: number;
+    socket_listeners: number;
+    socket_connections: number;
+    socket_buffered_bytes: number;
+    socket_datagram_queue_len: number;
+    queue_snapshots: LiveQueueSnapshotEntry[];
+}
+export interface LiveProjectedCommand {
+    name: string;
+    guest_path: string;
+}
+export interface LivePackageCommands {
+    package_name: string;
+    commands: string[];
+}
+export interface LiveAgentosProjectedAgent {
+    id: string;
+    acp_entrypoint: string;
+    adapter_entrypoint: string;
+}
+export interface LiveCronAlarm {
+    generation: number;
+    next_alarm_ms?: number;
+}
+export interface LiveCronJobEntry {
+    id: string;
+    schedule: string;
+    action: unknown;
+    overlap: LiveCronOverlap;
+    last_run_ms?: number;
+    next_run_ms?: number;
+    run_count: number;
+    running: boolean;
+}
+export interface LiveCronRun {
+    run_id: string;
+    job_id: string;
+    action: unknown;
+}
+export interface LiveCronEventRecord {
+    kind: "fire" | "complete" | "error";
+    job_id: string;
+    time_ms: number;
+    duration_ms?: number;
+    error?: string;
+}
+export interface LiveCronDispatch {
+    alarm: LiveCronAlarm;
+    runs: LiveCronRun[];
+    events: LiveCronEventRecord[];
+}
+export type LiveResponsePayload = {
+    type: "authenticated";
+    sidecar_id: string;
+    connection_id: string;
+    max_frame_bytes: number;
+} | {
+    type: "session_opened";
+    session_id: string;
+    owner_connection_id: string;
+} | {
+    type: "session_closed";
+    session_id: string;
+} | {
+    type: "vm_created";
+    vm_id: string;
+    guest_cwd: string;
+    guest_env: Record<string, string>;
+    process_route_retention: number;
+} | {
+    type: "vm_initialized";
+    vm_id: string;
+    guest_cwd: string;
+    guest_env: Record<string, string>;
+    process_route_retention: number;
+    applied_mounts: number;
+    projected_commands: LiveProjectedCommand[];
+    agents: LiveAgentosProjectedAgent[];
+    host_callbacks: Array<{
+        registration: string;
+        command_count: number;
+    }>;
+} | {
+    type: "vm_configured";
+    applied_mounts: number;
+    projected_commands: LiveProjectedCommand[];
+    agents: LiveAgentosProjectedAgent[];
+} | {
+    type: "package_linked";
+    projected_commands: LiveProjectedCommand[];
+    agents: LiveAgentosProjectedAgent[];
+} | {
+    type: "provided_commands_response";
+    packages: LivePackageCommands[];
+} | {
+    type: "cron_scheduled";
+    id: string;
+    alarm: LiveCronAlarm;
+} | {
+    type: "cron_jobs";
+    jobs: LiveCronJobEntry[];
+    alarm: LiveCronAlarm;
+} | {
+    type: "cron_cancelled";
+    id: string;
+    cancelled: boolean;
+    alarm: LiveCronAlarm;
+} | {
+    type: "cron_wake";
+    alarm: LiveCronAlarm;
+    runs: LiveCronRun[];
+    events: LiveCronEventRecord[];
+} | {
+    type: "cron_run_completed";
+    alarm: LiveCronAlarm;
+    runs: LiveCronRun[];
+    events: LiveCronEventRecord[];
+} | {
+    type: "cron_state_exported";
+    state: string;
+} | {
+    type: "cron_state_imported";
+    alarm: LiveCronAlarm;
+    runs: LiveCronRun[];
+    events: LiveCronEventRecord[];
+} | {
+    type: "host_callbacks_registered";
+    registration: string;
+    command_count: number;
+} | {
+    type: "layer_created";
+    layer_id: string;
+} | {
+    type: "layer_sealed";
+    layer_id: string;
+} | {
+    type: "snapshot_imported";
+    layer_id: string;
+} | {
+    type: "snapshot_exported";
+    layer_id: string;
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "overlay_created";
+    layer_id: string;
+} | {
+    type: "root_filesystem_bootstrapped";
+    entry_count: number;
+} | {
+    type: "guest_filesystem_result";
+    operation: LiveGuestFilesystemOperation;
+    path: string;
+    content?: string;
+    encoding?: LiveRootFilesystemEntryEncoding;
+    entries?: LiveGuestDirEntry[];
+    stat?: LiveGuestFilesystemStat;
+    exists?: boolean;
+    target?: string;
+} | {
+    type: "guest_kernel_result";
+    payload: ArrayBuffer;
+} | {
+    type: "root_filesystem_snapshot";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "vm_disposed";
+    vm_id: string;
+} | {
+    type: "process_started";
+    process_id: string;
+    pid?: number;
+} | {
+    type: "stdin_written";
+    process_id: string;
+    accepted_bytes: number;
+} | {
+    type: "pty_resized";
+    process_id: string;
+    cols: number;
+    rows: number;
+} | {
+    type: "stdin_closed";
+    process_id: string;
+} | {
+    type: "process_killed";
+    process_id: string;
+} | {
+    type: "process_snapshot";
+    processes: LiveProcessSnapshotEntry[];
+} | ({
+    type: "resource_snapshot";
+} & LiveResourceSnapshot) | {
+    type: "listener_snapshot";
+    listener?: LiveSocketStateEntry;
+} | {
+    type: "bound_udp_snapshot";
+    socket?: LiveSocketStateEntry;
+} | {
+    type: "vm_fetch_result";
+    response_json: string;
+} | {
+    type: "signal_state";
+    process_id: string;
+    handlers: Record<string, LiveSignalHandlerRegistration>;
+} | {
+    type: "zombie_timer_count";
+    count: number;
+} | {
+    type: "filesystem_result";
+    operation: LiveFilesystemOperation;
+    status: string;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_state";
+    key: string;
+    found: boolean;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_flushed";
+    key: string;
+    committed_bytes: number;
+} | {
+    type: "rejected";
+    code: string;
+    message: string;
+} | {
+    type: "ext_result";
+    envelope: LiveExtEnvelope;
+};
+export declare function fromGeneratedResponsePayload(payload: protocol.ResponsePayload): LiveResponsePayload;
+export declare function fromGeneratedCronDispatch(value: protocol.CronDispatchEvent): LiveCronDispatch;