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

package/dist/protocol-maps.js

@@ -0,0 +1,273 @@
+import * as protocol from "./generated-protocol.js";
+export function toGeneratedPermissionMode(mode) {
+    switch (mode) {
+        case "allow":
+            return protocol.PermissionMode.Allow;
+        case "ask":
+            return protocol.PermissionMode.Ask;
+        case "deny":
+            return protocol.PermissionMode.Deny;
+    }
+}
+export function toGeneratedGuestRuntimeKind(runtime) {
+    switch (runtime) {
+        case "java_script":
+            return protocol.GuestRuntimeKind.JavaScript;
+        case "python":
+            return protocol.GuestRuntimeKind.Python;
+        case "web_assembly":
+            return protocol.GuestRuntimeKind.WebAssembly;
+    }
+}
+export function toGeneratedDisposeReason(reason) {
+    switch (reason) {
+        case "requested":
+            return protocol.DisposeReason.Requested;
+        case "connection_closed":
+            return protocol.DisposeReason.ConnectionClosed;
+        case "host_shutdown":
+            return protocol.DisposeReason.HostShutdown;
+    }
+}
+export function toGeneratedRootFilesystemMode(mode) {
+    switch (mode) {
+        case "ephemeral":
+            return protocol.RootFilesystemMode.Ephemeral;
+        case "read_only":
+            return protocol.RootFilesystemMode.ReadOnly;
+    }
+}
+export function toGeneratedRootFilesystemEntryKind(kind) {
+    switch (kind) {
+        case "file":
+            return protocol.RootFilesystemEntryKind.File;
+        case "directory":
+            return protocol.RootFilesystemEntryKind.Directory;
+        case "symlink":
+            return protocol.RootFilesystemEntryKind.Symlink;
+    }
+}
+export function toGeneratedRootFilesystemEntryEncoding(encoding) {
+    switch (encoding) {
+        case "utf8":
+            return protocol.RootFilesystemEntryEncoding.UtF8;
+        case "base64":
+            return protocol.RootFilesystemEntryEncoding.BasE64;
+    }
+}
+export function toGeneratedWasmPermissionTier(tier) {
+    switch (tier) {
+        case "full":
+            return protocol.WasmPermissionTier.Full;
+        case "read-write":
+            return protocol.WasmPermissionTier.ReadWrite;
+        case "read-only":
+            return protocol.WasmPermissionTier.ReadOnly;
+        case "isolated":
+            return protocol.WasmPermissionTier.Isolated;
+    }
+}
+export function toGeneratedGuestFilesystemOperation(operation) {
+    switch (operation) {
+        case "read_file":
+            return protocol.GuestFilesystemOperation.ReadFile;
+        case "write_file":
+            return protocol.GuestFilesystemOperation.WriteFile;
+        case "create_dir":
+            return protocol.GuestFilesystemOperation.CreateDir;
+        case "mkdir":
+            return protocol.GuestFilesystemOperation.Mkdir;
+        case "exists":
+            return protocol.GuestFilesystemOperation.Exists;
+        case "stat":
+            return protocol.GuestFilesystemOperation.Stat;
+        case "lstat":
+            return protocol.GuestFilesystemOperation.Lstat;
+        case "read_dir":
+            return protocol.GuestFilesystemOperation.ReadDir;
+        case "read_dir_recursive":
+            return protocol.GuestFilesystemOperation.ReadDirRecursive;
+        case "remove_file":
+            return protocol.GuestFilesystemOperation.RemoveFile;
+        case "remove_dir":
+            return protocol.GuestFilesystemOperation.RemoveDir;
+        case "remove":
+            return protocol.GuestFilesystemOperation.Remove;
+        case "copy":
+            return protocol.GuestFilesystemOperation.Copy;
+        case "move":
+            return protocol.GuestFilesystemOperation.Move;
+        case "rename":
+            return protocol.GuestFilesystemOperation.Rename;
+        case "realpath":
+            return protocol.GuestFilesystemOperation.Realpath;
+        case "symlink":
+            return protocol.GuestFilesystemOperation.Symlink;
+        case "read_link":
+            return protocol.GuestFilesystemOperation.ReadLink;
+        case "link":
+            return protocol.GuestFilesystemOperation.Link;
+        case "chmod":
+            return protocol.GuestFilesystemOperation.Chmod;
+        case "chown":
+            return protocol.GuestFilesystemOperation.Chown;
+        case "utimes":
+            return protocol.GuestFilesystemOperation.Utimes;
+        case "truncate":
+            return protocol.GuestFilesystemOperation.Truncate;
+        case "pread":
+            return protocol.GuestFilesystemOperation.Pread;
+        case "pwrite":
+            return protocol.GuestFilesystemOperation.Pwrite;
+    }
+}
+export function toGeneratedFilesystemOperation(operation) {
+    switch (operation) {
+        case "read":
+            return protocol.FilesystemOperation.Read;
+        case "write":
+            return protocol.FilesystemOperation.Write;
+        case "stat":
+            return protocol.FilesystemOperation.Stat;
+        case "read_dir":
+            return protocol.FilesystemOperation.ReadDir;
+        case "mkdir":
+            return protocol.FilesystemOperation.Mkdir;
+        case "remove":
+            return protocol.FilesystemOperation.Remove;
+        case "rename":
+            return protocol.FilesystemOperation.Rename;
+    }
+}
+export function fromGeneratedFilesystemOperation(operation) {
+    switch (operation) {
+        case protocol.FilesystemOperation.Read:
+            return "read";
+        case protocol.FilesystemOperation.Write:
+            return "write";
+        case protocol.FilesystemOperation.Stat:
+            return "stat";
+        case protocol.FilesystemOperation.ReadDir:
+            return "read_dir";
+        case protocol.FilesystemOperation.Mkdir:
+            return "mkdir";
+        case protocol.FilesystemOperation.Remove:
+            return "remove";
+        case protocol.FilesystemOperation.Rename:
+            return "rename";
+    }
+}
+export function fromGeneratedVmLifecycleState(state) {
+    switch (state) {
+        case protocol.VmLifecycleState.Creating:
+            return "creating";
+        case protocol.VmLifecycleState.Ready:
+            return "ready";
+        case protocol.VmLifecycleState.Disposing:
+            return "disposing";
+        case protocol.VmLifecycleState.Disposed:
+            return "disposed";
+        case protocol.VmLifecycleState.Failed:
+            return "failed";
+    }
+}
+export function fromGeneratedStreamChannel(channel) {
+    switch (channel) {
+        case protocol.StreamChannel.Stdout:
+            return "stdout";
+        case protocol.StreamChannel.Stderr:
+            return "stderr";
+    }
+}
+export function fromGeneratedProcessSnapshotStatus(status) {
+    switch (status) {
+        case protocol.ProcessSnapshotStatus.Running:
+            return "running";
+        case protocol.ProcessSnapshotStatus.Exited:
+            return "exited";
+        case protocol.ProcessSnapshotStatus.Stopped:
+            return "stopped";
+    }
+}
+export function fromGeneratedSignalDispositionAction(action) {
+    switch (action) {
+        case protocol.SignalDispositionAction.Default:
+            return "default";
+        case protocol.SignalDispositionAction.Ignore:
+            return "ignore";
+        case protocol.SignalDispositionAction.User:
+            return "user";
+    }
+}
+export function fromGeneratedRootFilesystemEntryKind(kind) {
+    switch (kind) {
+        case protocol.RootFilesystemEntryKind.File:
+            return "file";
+        case protocol.RootFilesystemEntryKind.Directory:
+            return "directory";
+        case protocol.RootFilesystemEntryKind.Symlink:
+            return "symlink";
+    }
+}
+export function fromGeneratedRootFilesystemEntryEncoding(encoding) {
+    switch (encoding) {
+        case protocol.RootFilesystemEntryEncoding.UtF8:
+            return "utf8";
+        case protocol.RootFilesystemEntryEncoding.BasE64:
+            return "base64";
+    }
+}
+export function fromGeneratedGuestFilesystemOperation(operation) {
+    switch (operation) {
+        case protocol.GuestFilesystemOperation.ReadFile:
+            return "read_file";
+        case protocol.GuestFilesystemOperation.WriteFile:
+            return "write_file";
+        case protocol.GuestFilesystemOperation.CreateDir:
+            return "create_dir";
+        case protocol.GuestFilesystemOperation.Mkdir:
+            return "mkdir";
+        case protocol.GuestFilesystemOperation.Exists:
+            return "exists";
+        case protocol.GuestFilesystemOperation.Stat:
+            return "stat";
+        case protocol.GuestFilesystemOperation.Lstat:
+            return "lstat";
+        case protocol.GuestFilesystemOperation.ReadDir:
+            return "read_dir";
+        case protocol.GuestFilesystemOperation.ReadDirRecursive:
+            return "read_dir_recursive";
+        case protocol.GuestFilesystemOperation.RemoveFile:
+            return "remove_file";
+        case protocol.GuestFilesystemOperation.RemoveDir:
+            return "remove_dir";
+        case protocol.GuestFilesystemOperation.Remove:
+            return "remove";
+        case protocol.GuestFilesystemOperation.Copy:
+            return "copy";
+        case protocol.GuestFilesystemOperation.Move:
+            return "move";
+        case protocol.GuestFilesystemOperation.Rename:
+            return "rename";
+        case protocol.GuestFilesystemOperation.Realpath:
+            return "realpath";
+        case protocol.GuestFilesystemOperation.Symlink:
+            return "symlink";
+        case protocol.GuestFilesystemOperation.ReadLink:
+            return "read_link";
+        case protocol.GuestFilesystemOperation.Link:
+            return "link";
+        case protocol.GuestFilesystemOperation.Chmod:
+            return "chmod";
+        case protocol.GuestFilesystemOperation.Chown:
+            return "chown";
+        case protocol.GuestFilesystemOperation.Utimes:
+            return "utimes";
+        case protocol.GuestFilesystemOperation.Truncate:
+            return "truncate";
+        case protocol.GuestFilesystemOperation.Pread:
+            return "pread";
+        case protocol.GuestFilesystemOperation.Pwrite:
+            return "pwrite";
+    }
+}

package/dist/protocol-schema.d.ts

@@ -0,0 +1,10 @@
+export declare const SIDECAR_PROTOCOL_SCHEMA: {
+    readonly name: "agentos-native-sidecar";
+    readonly version: 7;
+};
+export type LiveProtocolSchema = typeof SIDECAR_PROTOCOL_SCHEMA;
+export type ProtocolSchemaLike = {
+    name: string;
+    version: number;
+};
+export declare function validateSidecarProtocolSchema(schema: ProtocolSchemaLike): LiveProtocolSchema;

package/dist/protocol-schema.js

@@ -0,0 +1,11 @@
+export const SIDECAR_PROTOCOL_SCHEMA = {
+    name: "agentos-native-sidecar",
+    version: 7,
+};
+export function validateSidecarProtocolSchema(schema) {
+    if (schema.name !== SIDECAR_PROTOCOL_SCHEMA.name ||
+        schema.version !== SIDECAR_PROTOCOL_SCHEMA.version) {
+        throw new Error(`unsupported sidecar protocol schema ${schema.name}@${schema.version}`);
+    }
+    return SIDECAR_PROTOCOL_SCHEMA;
+}

package/dist/request-payloads.d.ts

@@ -0,0 +1,207 @@
+import { type LiveMountDescriptor, type LivePackageDescriptor, type LiveSidecarPlacement } from "./descriptors.js";
+import { type LiveExtEnvelope } from "./ext.js";
+import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
+import type { CreateVmConfig } from "./generated/CreateVmConfig.js";
+import * as protocol from "./generated-protocol.js";
+import { type LivePermissionsPolicy } from "./permissions.js";
+import { type LiveDisposeReason, type LiveFilesystemOperation, type LiveGuestFilesystemOperation, type LiveGuestRuntimeKind, type LiveRootFilesystemMode, type LiveWasmPermissionTier } from "./protocol-maps.js";
+export interface LiveRegisteredHostCallbackExample {
+    description: string;
+    input: unknown;
+}
+export interface LiveRegisteredHostCallbackDefinition {
+    description: string;
+    input_schema: unknown;
+    timeout_ms?: number;
+    examples?: LiveRegisteredHostCallbackExample[];
+}
+export interface LiveHostCallbackRegistration {
+    name: string;
+    description: string;
+    callbacks: Record<string, LiveRegisteredHostCallbackDefinition>;
+}
+export type LiveCronOverlap = "allow" | "skip" | "queue";
+export type LiveRequestPayload = {
+    type: "authenticate";
+    client_name: string;
+    auth_token: string;
+    protocol_version: number;
+    bridge_version: number;
+} | {
+    type: "open_session";
+    placement: LiveSidecarPlacement;
+} | {
+    type: "close_session";
+    session_id: string;
+} | {
+    type: "create_vm";
+    runtime: LiveGuestRuntimeKind;
+    config: CreateVmConfig;
+} | {
+    type: "initialize_vm";
+    runtime: LiveGuestRuntimeKind;
+    config: CreateVmConfig;
+    mounts?: LiveMountDescriptor[];
+    packages?: LivePackageDescriptor[];
+    packages_mount_at?: string;
+    host_callbacks?: LiveHostCallbackRegistration[];
+} | {
+    type: "configure_vm";
+    mounts?: LiveMountDescriptor[];
+    permissions?: LivePermissionsPolicy;
+    command_permissions?: Record<string, LiveWasmPermissionTier>;
+    loopback_exempt_ports?: number[];
+    packages?: LivePackageDescriptor[];
+    packages_mount_at?: string;
+} | {
+    type: "link_package";
+    package: LivePackageDescriptor;
+} | {
+    type: "provided_commands";
+} | {
+    type: "schedule_cron";
+    id?: string;
+    schedule: string;
+    action: unknown;
+    overlap?: LiveCronOverlap;
+} | {
+    type: "list_cron_jobs";
+} | {
+    type: "cancel_cron_job";
+    id: string;
+} | {
+    type: "wake_cron";
+    generation: number;
+} | {
+    type: "complete_cron_run";
+    run_id: string;
+    error?: string;
+} | {
+    type: "export_cron_state";
+} | {
+    type: "import_cron_state";
+    state: string;
+} | ({
+    type: "register_host_callbacks";
+} & LiveHostCallbackRegistration) | {
+    type: "dispose_vm";
+    reason: LiveDisposeReason;
+} | {
+    type: "bootstrap_root_filesystem";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "create_layer";
+} | {
+    type: "seal_layer";
+    layer_id: string;
+} | {
+    type: "import_snapshot";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    type: "export_snapshot";
+    layer_id: string;
+} | {
+    type: "create_overlay";
+    mode?: LiveRootFilesystemMode;
+    upper_layer_id?: string;
+    lower_layer_ids: string[];
+} | {
+    type: "snapshot_root_filesystem";
+} | {
+    type: "guest_kernel_call";
+    execution_id: string;
+    operation: string;
+    payload: ArrayBuffer;
+} | {
+    type: "guest_filesystem_call";
+    operation: LiveGuestFilesystemOperation;
+    path: string;
+    destination_path?: string;
+    target?: string;
+    content?: string;
+    encoding?: LiveRootFilesystemEntryEncoding;
+    recursive?: boolean;
+    max_depth?: number;
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    atime_ms?: number;
+    mtime_ms?: number;
+    len?: number;
+    offset?: number;
+} | {
+    type: "execute";
+    process_id?: string;
+    command?: string;
+    shell_command?: string;
+    runtime?: LiveGuestRuntimeKind;
+    entrypoint?: string;
+    args: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    wasm_permission_tier?: LiveWasmPermissionTier;
+    pty?: {
+        cols?: number;
+        rows?: number;
+    };
+    keep_stdin_open?: boolean;
+    timeout_ms?: number;
+    capture_output?: boolean;
+} | {
+    type: "write_stdin";
+    process_id: string;
+    chunk: Uint8Array;
+} | {
+    type: "resize_pty";
+    process_id: string;
+    cols: number;
+    rows: number;
+} | {
+    type: "close_stdin";
+    process_id: string;
+} | {
+    type: "kill_process";
+    process_id: string;
+    signal: string;
+} | {
+    type: "get_process_snapshot";
+} | {
+    type: "get_resource_snapshot";
+} | {
+    type: "find_listener";
+    host?: string;
+    port?: number;
+    path?: string;
+} | {
+    type: "find_bound_udp";
+    host?: string;
+    port?: number;
+} | {
+    type: "vm_fetch";
+    port: number;
+    method: string;
+    path: string;
+    headers_json: string;
+    body?: string;
+} | {
+    type: "get_signal_state";
+    process_id: string;
+} | {
+    type: "get_zombie_timer_count";
+} | {
+    type: "host_filesystem_call";
+    operation: LiveFilesystemOperation;
+    path: string;
+    payload_size_bytes: number;
+} | {
+    type: "persistence_load";
+    key: string;
+} | {
+    type: "persistence_flush";
+    key: string;
+    payload_size_bytes: number;
+} | {
+    type: "ext";
+    envelope: LiveExtEnvelope;
+};
+export declare function toGeneratedRequestPayload(payload: LiveRequestPayload): protocol.RequestPayload;