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

package/dist/correlation.js

@@ -0,0 +1,52 @@
+export class PendingResponseRegistry {
+    pending = new Map();
+    // Deliberately no per-request timer: local framed stdio never loses frames,
+    // so a response is bounded by the transport's silence watchdog (a dead or
+    // wedged sidecar rejects all pending requests through `rejectAll`) rather
+    // than by guessing how long any one request should take.
+    waitForResponse(requestId, onResponse) {
+        if (this.pending.has(requestId)) {
+            throw new Error(`response waiter already registered for request ${requestId}`);
+        }
+        return new Promise((resolve, reject) => {
+            this.pending.set(requestId, {
+                resolve: (frame) => {
+                    this.pending.delete(requestId);
+                    try {
+                        onResponse?.(frame);
+                        resolve(frame);
+                    }
+                    catch (error) {
+                        reject(error instanceof Error ? error : new Error(String(error)));
+                    }
+                },
+                reject: (error) => {
+                    this.pending.delete(requestId);
+                    reject(error);
+                },
+            });
+        });
+    }
+    resolve(requestId, frame) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        pending.resolve(frame);
+        return true;
+    }
+    reject(requestId, error) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        pending.reject(error);
+        return true;
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}

package/dist/descriptors.d.ts

@@ -0,0 +1,81 @@
+import type * as protocol from "./generated-protocol.js";
+export type LiveSidecarPlacement = {
+    kind: "shared";
+    pool?: string | null;
+} | {
+    kind: "explicit";
+    sidecar_id: string;
+};
+export type MountConfigJsonPrimitive = string | number | boolean | null;
+export type MountConfigJsonValue = MountConfigJsonPrimitive | MountConfigJsonObject | MountConfigJsonValue[];
+export interface MountConfigJsonObject {
+    [key: string]: MountConfigJsonValue | undefined;
+}
+export interface NativeMountPluginDescriptor<TConfig extends MountConfigJsonObject = MountConfigJsonObject> {
+    id: string;
+    config?: TConfig;
+}
+export interface S3MountCredentialsConfig {
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export interface ObjectS3MountConfig {
+    bucket: string;
+    prefix?: string;
+    region?: string;
+    credentials?: S3MountCredentialsConfig;
+    endpoint?: string;
+    uid?: number;
+    gid?: number;
+    fileMode?: number;
+    dirMode?: number;
+}
+export interface ChunkedS3MountConfig {
+    bucket: string;
+    prefix?: string;
+    region?: string;
+    credentials?: S3MountCredentialsConfig;
+    endpoint?: string;
+    metadataBackend?: "sqlite" | "local" | "callback";
+    metadataPath?: string;
+    mountId?: string;
+    chunkSize?: number;
+    inlineThreshold?: number;
+    uid?: number;
+    gid?: number;
+    fileMode?: number;
+    dirMode?: number;
+    metadataCacheEntries?: number;
+}
+export interface ChunkedLocalMountConfig {
+    metadataPath: string;
+    blockRoot: string;
+    chunkSize?: number;
+    inlineThreshold?: number;
+    uid?: number;
+    gid?: number;
+    fileMode?: number;
+    dirMode?: number;
+    metadataCacheEntries?: number;
+}
+export declare function objectS3MountPlugin(config: ObjectS3MountConfig): NativeMountPluginDescriptor;
+export declare function chunkedS3MountPlugin(config: ChunkedS3MountConfig): NativeMountPluginDescriptor;
+export declare function chunkedLocalMountPlugin(config: ChunkedLocalMountConfig): NativeMountPluginDescriptor;
+export interface LiveMountDescriptor {
+    guest_path: string;
+    read_only?: boolean;
+    plugin: NativeMountPluginDescriptor;
+}
+/** Opaque package transport. Native callers forward a trusted host path;
+ * browser package managers forward the complete `.aospkg` bytes. Neither form
+ * carries parsed package metadata. */
+export type LivePackageDescriptor = {
+    path: string;
+    content?: never;
+} | {
+    content: Uint8Array;
+    path?: never;
+};
+export declare function toGeneratedSidecarPlacement(placement: LiveSidecarPlacement): protocol.SidecarPlacement;
+export declare function toGeneratedMountDescriptor(descriptor: LiveMountDescriptor): protocol.MountDescriptor;
+export declare function toGeneratedPackageDescriptor(descriptor: LivePackageDescriptor): protocol.PackageDescriptor;

package/dist/descriptors.js

@@ -0,0 +1,57 @@
+import { toExactArrayBuffer } from "./bytes.js";
+import { stringifyJsonUtf8 } from "./json.js";
+export function objectS3MountPlugin(config) {
+    return {
+        id: "object_s3",
+        config: config,
+    };
+}
+export function chunkedS3MountPlugin(config) {
+    return {
+        id: "chunked_s3",
+        config: config,
+    };
+}
+export function chunkedLocalMountPlugin(config) {
+    return {
+        id: "chunked_local",
+        config: config,
+    };
+}
+export function toGeneratedSidecarPlacement(placement) {
+    switch (placement.kind) {
+        case "shared":
+            return {
+                tag: "SidecarPlacementShared",
+                val: { pool: placement.pool ?? null },
+            };
+        case "explicit":
+            return {
+                tag: "SidecarPlacementExplicit",
+                val: { sidecarId: placement.sidecar_id },
+            };
+    }
+}
+export function toGeneratedMountDescriptor(descriptor) {
+    return {
+        guestPath: descriptor.guest_path,
+        readOnly: descriptor.read_only ?? null,
+        plugin: {
+            id: descriptor.plugin.id,
+            config: descriptor.plugin.config === undefined
+                ? null
+                : stringifyJsonUtf8(descriptor.plugin.config, "mount plugin config"),
+        },
+    };
+}
+export function toGeneratedPackageDescriptor(descriptor) {
+    return "path" in descriptor && descriptor.path !== undefined
+        ? {
+            tag: "PackagePath",
+            val: { path: descriptor.path },
+        }
+        : {
+            tag: "PackageInline",
+            val: { content: toExactArrayBuffer(descriptor.content) },
+        };
+}

package/dist/event-buffer.d.ts

@@ -0,0 +1,98 @@
+import { type LiveExtEnvelope } from "./ext.js";
+import type * as protocol from "./generated-protocol.js";
+import { type LiveOwnershipScope } from "./ownership.js";
+import { type LiveCronDispatch } from "./response-payloads.js";
+export declare const ANY_BUFFERED_EVENT_KEY = "*";
+export type { LiveOwnershipScope } from "./ownership.js";
+export type LiveSidecarEventPayload = {
+    type: "vm_lifecycle";
+    state: "creating" | "ready" | "disposing" | "disposed" | "failed";
+} | {
+    type: "process_output";
+    process_id: string;
+    channel: "stdout" | "stderr";
+    chunk: Uint8Array;
+} | {
+    type: "process_exited";
+    process_id: string;
+    exit_code: number;
+    stdout?: Uint8Array;
+    stderr?: Uint8Array;
+    error_code?: string;
+    error_message?: string;
+} | {
+    type: "cron_dispatch";
+    dispatch: LiveCronDispatch;
+} | {
+    type: "structured";
+    name: string;
+    detail: Record<string, string>;
+} | {
+    type: "ext";
+    envelope: LiveExtEnvelope;
+};
+export interface LiveSidecarEventFrame {
+    ownership: LiveOwnershipScope;
+    payload: LiveSidecarEventPayload;
+}
+export type LiveSidecarEventSelector = {
+    any: true;
+} | {
+    type: "vm_lifecycle";
+    ownership?: LiveOwnershipScope;
+    state?: Extract<LiveSidecarEventPayload, {
+        type: "vm_lifecycle";
+    }>["state"];
+} | {
+    type: "process_output";
+    ownership?: LiveOwnershipScope;
+    processId?: string;
+    channel?: Extract<LiveSidecarEventPayload, {
+        type: "process_output";
+    }>["channel"];
+} | {
+    type: "process_exited";
+    ownership?: LiveOwnershipScope;
+    processId?: string;
+} | {
+    type: "structured";
+    ownership?: LiveOwnershipScope;
+    name?: string;
+    detail?: Record<string, string>;
+};
+export type LiveSidecarBufferedEventRecord<TEvent extends LiveSidecarEventFrame> = {
+    event: TEvent;
+    keys: readonly string[];
+};
+export type LiveSidecarEventWaitMatcher<TEvent extends LiveSidecarEventFrame> = {
+    matches: (event: TEvent) => boolean;
+    bufferKey: string | null;
+};
+export declare class SidecarEventBufferOverflow extends Error {
+    readonly capacity: number;
+    readonly bufferedEvents: number;
+    readonly eventType: LiveSidecarEventPayload["type"];
+    constructor(options: {
+        capacity: number;
+        bufferedEvents: number;
+        eventType: LiveSidecarEventPayload["type"];
+    });
+}
+export declare class SidecarEventBuffer<TEvent extends LiveSidecarEventFrame> {
+    private readonly capacity;
+    private readonly bufferedEvents;
+    private readonly bufferedEventQueues;
+    private nextBufferedEventId;
+    constructor(capacity: number);
+    get size(): number;
+    buffer(event: TEvent): SidecarEventBufferOverflow | null;
+    take(matcher: LiveSidecarEventWaitMatcher<TEvent>): TEvent | null;
+    private takeFromKey;
+    private remove;
+}
+export declare function sidecarSelectorMatchesEvent<TEvent extends LiveSidecarEventFrame>(selector: LiveSidecarEventSelector, event: TEvent): boolean;
+export declare function sidecarSelectorBufferKey(selector: LiveSidecarEventSelector): string | null;
+export declare function normalizeSidecarEventMatcher<TEvent extends LiveSidecarEventFrame>(selector: LiveSidecarEventSelector | ((event: TEvent) => boolean)): LiveSidecarEventWaitMatcher<TEvent>;
+export declare function fromGeneratedEventPayload(payload: protocol.EventPayload): LiveSidecarEventPayload;
+export declare function sidecarEventWaitAbortError(reason: unknown): Error;
+export declare function sidecarEventBufferKeys<TEvent extends LiveSidecarEventFrame>(event: TEvent): string[];

package/dist/event-buffer.js

@@ -0,0 +1,333 @@
+import { fromGeneratedExtEnvelope } from "./ext.js";
+import { ownershipMatchesSelector, ownershipSelectorKey, } from "./ownership.js";
+import { fromGeneratedStreamChannel, fromGeneratedVmLifecycleState, } from "./protocol-maps.js";
+import { fromGeneratedCronDispatch, } from "./response-payloads.js";
+export const ANY_BUFFERED_EVENT_KEY = "*";
+export class SidecarEventBufferOverflow extends Error {
+    capacity;
+    bufferedEvents;
+    eventType;
+    constructor(options) {
+        super(`sidecar event buffer overflow after ${options.bufferedEvents} queued events (capacity ${options.capacity}) while buffering ${options.eventType}`);
+        this.name = "SidecarEventBufferOverflow";
+        this.capacity = options.capacity;
+        this.bufferedEvents = options.bufferedEvents;
+        this.eventType = options.eventType;
+    }
+}
+export class SidecarEventBuffer {
+    capacity;
+    bufferedEvents = new Map();
+    bufferedEventQueues = new Map();
+    nextBufferedEventId = 1;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get size() {
+        return this.bufferedEvents.size;
+    }
+    buffer(event) {
+        if (this.bufferedEvents.size >= this.capacity) {
+            return new SidecarEventBufferOverflow({
+                capacity: this.capacity,
+                bufferedEvents: this.bufferedEvents.size,
+                eventType: event.payload.type,
+            });
+        }
+        const eventId = this.nextBufferedEventId++;
+        const keys = sidecarEventBufferKeys(event);
+        this.bufferedEvents.set(eventId, {
+            event,
+            keys,
+        });
+        for (const key of keys) {
+            const queue = this.bufferedEventQueues.get(key);
+            if (queue) {
+                queue.add(eventId);
+                continue;
+            }
+            this.bufferedEventQueues.set(key, new Set([eventId]));
+        }
+        return null;
+    }
+    take(matcher) {
+        if (matcher.bufferKey !== null) {
+            return this.takeFromKey(matcher.bufferKey);
+        }
+        const queue = this.bufferedEventQueues.get(ANY_BUFFERED_EVENT_KEY);
+        if (!queue) {
+            return null;
+        }
+        for (const eventId of queue) {
+            const record = this.bufferedEvents.get(eventId);
+            if (!record) {
+                continue;
+            }
+            if (!matcher.matches(record.event)) {
+                continue;
+            }
+            return this.remove(eventId);
+        }
+        return null;
+    }
+    takeFromKey(key) {
+        const queue = this.bufferedEventQueues.get(key);
+        if (!queue) {
+            return null;
+        }
+        for (const eventId of queue) {
+            const record = this.bufferedEvents.get(eventId);
+            if (!record) {
+                queue.delete(eventId);
+                continue;
+            }
+            return this.remove(eventId);
+        }
+        return null;
+    }
+    remove(eventId) {
+        const record = this.bufferedEvents.get(eventId);
+        if (!record) {
+            return null;
+        }
+        this.bufferedEvents.delete(eventId);
+        for (const key of record.keys) {
+            const queue = this.bufferedEventQueues.get(key);
+            if (!queue) {
+                continue;
+            }
+            queue.delete(eventId);
+            if (queue.size === 0) {
+                this.bufferedEventQueues.delete(key);
+            }
+        }
+        return record.event;
+    }
+}
+function buildBufferKey(type, options) {
+    const parts = [`type:${type}`];
+    if (options?.ownership) {
+        parts.push(`ownership:${ownershipSelectorKey(options.ownership)}`);
+    }
+    if (options?.state) {
+        parts.push(`state:${options.state}`);
+    }
+    if (options?.processId) {
+        parts.push(`process:${options.processId}`);
+    }
+    if (options?.channel) {
+        parts.push(`channel:${options.channel}`);
+    }
+    if (options?.name) {
+        parts.push(`name:${options.name}`);
+    }
+    return parts.join("|");
+}
+export function sidecarSelectorMatchesEvent(selector, event) {
+    if ("any" in selector) {
+        return true;
+    }
+    if (event.payload.type !== selector.type) {
+        return false;
+    }
+    if (!ownershipMatchesSelector(selector.ownership, event.ownership)) {
+        return false;
+    }
+    switch (selector.type) {
+        case "vm_lifecycle": {
+            const payload = event.payload;
+            return selector.state === undefined || payload.state === selector.state;
+        }
+        case "process_output": {
+            const payload = event.payload;
+            return ((selector.processId === undefined ||
+                payload.process_id === selector.processId) &&
+                (selector.channel === undefined || payload.channel === selector.channel));
+        }
+        case "process_exited": {
+            const payload = event.payload;
+            return (selector.processId === undefined ||
+                payload.process_id === selector.processId);
+        }
+        case "structured": {
+            const payload = event.payload;
+            if (selector.name !== undefined && payload.name !== selector.name) {
+                return false;
+            }
+            if (!selector.detail) {
+                return true;
+            }
+            for (const [key, value] of Object.entries(selector.detail)) {
+                if (payload.detail[key] !== value) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}
+export function sidecarSelectorBufferKey(selector) {
+    if ("any" in selector) {
+        return ANY_BUFFERED_EVENT_KEY;
+    }
+    switch (selector.type) {
+        case "vm_lifecycle":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                state: selector.state,
+            });
+        case "process_output":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                processId: selector.processId,
+                channel: selector.channel,
+            });
+        case "process_exited":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                processId: selector.processId,
+            });
+        case "structured":
+            if (selector.detail) {
+                return null;
+            }
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                name: selector.name,
+            });
+    }
+}
+export function normalizeSidecarEventMatcher(selector) {
+    if (typeof selector === "function") {
+        return {
+            matches: selector,
+            bufferKey: null,
+        };
+    }
+    return {
+        matches: (event) => sidecarSelectorMatchesEvent(selector, event),
+        bufferKey: sidecarSelectorBufferKey(selector),
+    };
+}
+export function fromGeneratedEventPayload(payload) {
+    switch (payload.tag) {
+        case "VmLifecycleEvent":
+            return {
+                type: "vm_lifecycle",
+                state: fromGeneratedVmLifecycleState(payload.val.state),
+            };
+        case "ProcessOutputEvent":
+            return {
+                type: "process_output",
+                process_id: payload.val.processId,
+                channel: fromGeneratedStreamChannel(payload.val.channel),
+                chunk: Buffer.from(payload.val.chunk),
+            };
+        case "ProcessExitedEvent":
+            return {
+                type: "process_exited",
+                process_id: payload.val.processId,
+                exit_code: payload.val.exitCode,
+                ...(payload.val.stdout === null
+                    ? {}
+                    : { stdout: Buffer.from(payload.val.stdout) }),
+                ...(payload.val.stderr === null
+                    ? {}
+                    : { stderr: Buffer.from(payload.val.stderr) }),
+                ...(payload.val.error === null
+                    ? {}
+                    : {
+                        error_code: payload.val.error.code,
+                        error_message: payload.val.error.message,
+                    }),
+            };
+        case "CronDispatchEvent":
+            return {
+                type: "cron_dispatch",
+                dispatch: fromGeneratedCronDispatch(payload.val),
+            };
+        case "StructuredEvent":
+            return {
+                type: "structured",
+                name: payload.val.name,
+                detail: Object.fromEntries(payload.val.detail),
+            };
+        case "ExtEnvelope":
+            return {
+                type: "ext",
+                envelope: fromGeneratedExtEnvelope(payload.val),
+            };
+    }
+}
+export function sidecarEventWaitAbortError(reason) {
+    return reason instanceof Error
+        ? reason
+        : new Error(reason ? String(reason) : "sidecar event wait aborted");
+}
+export function sidecarEventBufferKeys(event) {
+    const owner = event.ownership;
+    const keys = new Set([
+        ANY_BUFFERED_EVENT_KEY,
+        buildBufferKey(event.payload.type),
+        buildBufferKey(event.payload.type, { ownership: owner }),
+    ]);
+    switch (event.payload.type) {
+        case "vm_lifecycle":
+            keys.add(buildBufferKey(event.payload.type, {
+                state: event.payload.state,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                state: event.payload.state,
+            }));
+            break;
+        case "process_output":
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                channel: event.payload.channel,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+                channel: event.payload.channel,
+            }));
+            break;
+        case "process_exited":
+            keys.add(buildBufferKey(event.payload.type, {
+                processId: event.payload.process_id,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                processId: event.payload.process_id,
+            }));
+            break;
+        case "cron_dispatch":
+            break;
+        case "structured":
+            keys.add(buildBufferKey(event.payload.type, {
+                name: event.payload.name,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                name: event.payload.name,
+            }));
+            break;
+        case "ext":
+            break;
+    }
+    return [...keys];
+}

package/dist/ext.d.ts

@@ -0,0 +1,7 @@
+import type * as sidecarProtocol from "./generated-protocol.js";
+export interface LiveExtEnvelope {
+    namespace: string;
+    payload: Uint8Array;
+}
+export declare function toGeneratedExtEnvelope(envelope: LiveExtEnvelope): sidecarProtocol.ExtEnvelope;
+export declare function fromGeneratedExtEnvelope(envelope: sidecarProtocol.ExtEnvelope): LiveExtEnvelope;

package/dist/ext.js

@@ -0,0 +1,13 @@
+import { toExactArrayBuffer } from "./bytes.js";
+export function toGeneratedExtEnvelope(envelope) {
+    return {
+        namespace: envelope.namespace,
+        payload: toExactArrayBuffer(envelope.payload),
+    };
+}
+export function fromGeneratedExtEnvelope(envelope) {
+    return {
+        namespace: envelope.namespace,
+        payload: Buffer.from(envelope.payload),
+    };
+}

package/dist/filesystem.d.ts

@@ -0,0 +1,33 @@
+import type * as protocol from "./generated-protocol.js";
+import { type LiveRootFilesystemEntryEncoding } from "./protocol-maps.js";
+export type { LiveRootFilesystemEntryEncoding } from "./protocol-maps.js";
+export type GuestFilesystemContentEncoding = "utf8" | "base64";
+export interface GuestFilesystemContentResult {
+    path: string;
+    content?: string;
+    encoding?: GuestFilesystemContentEncoding;
+}
+export type LiveRootFilesystemEntry = {
+    path: string;
+    kind: "file" | "directory" | "symlink";
+    mode?: number;
+    uid?: number;
+    gid?: number;
+    content?: string;
+    encoding?: LiveRootFilesystemEntryEncoding;
+    target?: string;
+    executable?: boolean;
+};
+export type LiveRootFilesystemLowerDescriptor = {
+    kind: "snapshot";
+    entries: LiveRootFilesystemEntry[];
+} | {
+    kind: "bundled_base_filesystem";
+};
+export declare function encodeGuestFilesystemContent(content: string | Uint8Array): {
+    content: string;
+    encoding?: GuestFilesystemContentEncoding;
+};
+export declare function decodeGuestFilesystemContent(response: GuestFilesystemContentResult): Uint8Array;
+export declare function toGeneratedRootFilesystemEntry(entry: LiveRootFilesystemEntry): protocol.RootFilesystemEntry;
+export declare function fromGeneratedRootFilesystemEntry(entry: protocol.RootFilesystemEntry): LiveRootFilesystemEntry;