@rivet-dev/agentos-runtime-core 0.0.0-codex-actor-plugin-contract-coverage.115ca8a → 0.0.0-eve-integration.9df6f34

package/dist/process.js

@@ -1,13 +1,17 @@
-import { spawn, } from "node:child_process";
+import { spawn } from "node:child_process";
 export { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
-import { SidecarProcessError, SidecarProcessExited, } from "./sidecar-errors.js";
+import { SidecarProcessError, SidecarProcessExited } from "./sidecar-errors.js";
 export class StdioSidecarProcess {
     child;
+    control;
+    combinedStdio;
     stderrChunks = [];
     exitListeners = new Set();
     errorListeners = new Set();
-    constructor(child) {
+    constructor(child, control) {
         this.child = child;
+        this.control = control;
+        this.combinedStdio = control === null;
         this.child.stderr.on("data", (chunk) => {
             this.stderrChunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
         });
@@ -30,13 +34,26 @@ export class StdioSidecarProcess {
         });
     }
     static spawn(options) {
-        return new StdioSidecarProcess(spawn(options.command, options.args ?? [], {
+        const combinedStdio = options.combinedStdio === true;
+        const child = spawn(options.command, options.args ?? [], {
             cwd: options.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-        }));
+            env: combinedStdio
+                ? { ...process.env, AGENTOS_SIDECAR_COMBINED_STDIO: "1" }
+                : process.env,
+            stdio: combinedStdio
+                ? ["pipe", "pipe", "pipe"]
+                : ["pipe", "pipe", "pipe", "pipe"],
+        });
+        try {
+            return new StdioSidecarProcess(child, combinedStdio ? null : requireControlStream(child));
+        }
+        catch (error) {
+            child.kill("SIGKILL");
+            throw error;
+        }
     }
-    static fromChild(child) {
-        return new StdioSidecarProcess(child);
+    static fromChild(child, control) {
+        return new StdioSidecarProcess(child, control === null ? null : (control ?? requireControlStream(child)));
     }
     onExit(handler) {
         this.exitListeners.add(handler);
@@ -95,3 +112,13 @@ export class StdioSidecarProcess {
         });
     }
 }
+function requireControlStream(child) {
+    const stream = child.stdio[3];
+    if (!stream ||
+        typeof stream.write !== "function" ||
+        typeof stream.on !== "function" ||
+        typeof stream.read !== "function") {
+        throw new Error("sidecar process did not expose a full-duplex fd 3");
+    }
+    return stream;
+}

package/dist/protocol-client.d.ts

@@ -1,24 +1,38 @@
 import type { Readable, Writable } from "node:stream";
 import { type LiveSidecarEventSelector } from "./event-buffer.js";
-import type { FrameTransport } from "./frame-stream.js";
-import { type LiveEventFrame, type LiveProtocolFrame, type LiveResponseFrame, type LiveSidecarRequestFrame, type LiveSidecarRequestHandler, type ProtocolFramePayloadCodec } from "./protocol-frames.js";
+import { type FrameTransport } from "./frame-stream.js";
 import type { LiveOwnershipScope } from "./ownership.js";
+import { type LiveControlFrame, type LiveEventFrame, type LiveProtocolFrame, type LiveRequestFrame, type LiveResponseFrame, type LiveSidecarRequestFrame, type LiveSidecarRequestHandler, type LiveSidecarResponseFrame, type ProtocolFramePayloadCodec } from "./protocol-frames.js";
 import type { LiveRequestPayload } from "./request-payloads.js";
 export interface SidecarProtocolClientOptions {
+    /** A combined transport remains supported for embedders and focused tests. */
     frameTransport?: FrameTransport<LiveResponseFrame | LiveEventFrame | LiveSidecarRequestFrame, LiveProtocolFrame>;
+    ordinaryFrameTransport?: FrameTransport<LiveEventFrame, LiveRequestFrame>;
+    controlFrameTransport?: FrameTransport<LiveResponseFrame | LiveSidecarRequestFrame | LiveEventFrame, LiveSidecarResponseFrame | LiveControlFrame>;
     stdin?: Writable;
     stdout?: Readable;
-    frameTimeoutMs: number;
+    control?: Readable & Writable;
+    /** Use one bidirectional stdin/stdout transport when the host cannot inherit fd 3. */
+    combinedStdio?: boolean;
     eventBufferCapacity: number;
     payloadCodec?: ProtocolFramePayloadCodec;
     stderrText?: () => string;
     frameError?: (error: Error) => Error;
     streamEndedError?: () => Error;
+    /** Override the silence watchdog window. Tests only; production uses the default. */
+    silenceTimeoutMs?: number;
+    /**
+     * Runs when the silence watchdog fires, before pending work is rejected.
+     * The stdio layer uses it to SIGKILL the sidecar child.
+     */
+    onSilenceExpired?: () => void;
 }
 export declare class SidecarProtocolClient {
     private readonly eventBuffer;
     private readonly eventListeners;
-    private readonly frameTimeoutMs;
+    private readonly silenceTimeoutMs;
+    private silenceTimer;
+    private lastInboundAtMs;
     private readonly payloadCodec;
     private readonly stderrText;
     private readonly hostFrameFactory;
@@ -27,12 +41,22 @@ export declare class SidecarProtocolClient {
     private readonly eventWaiters;
     private sidecarRequestHandler;
     constructor(options: SidecarProtocolClientOptions);
+    /**
+     * Arm the silence watchdog: ANY inbound frame resets the clock (see the
+     * `onFrameActivity` tap above), and the sidecar heartbeats every 10s even
+     * while busy, so sustained silence for the full window means the process
+     * is dead or wedged — not slow. The check interval is unref'd so an idle
+     * host process can still exit naturally.
+     */
+    private startSilenceWatchdog;
+    private stopSilenceWatchdog;
     setSidecarRequestHandler(handler: LiveSidecarRequestHandler | null): void;
     onEvent(handler: (event: LiveEventFrame) => void): () => void;
     sendRequest(input: {
         ownership: LiveOwnershipScope;
         payload: LiveRequestPayload;
     }): Promise<LiveResponseFrame>;
+    shutdown(reason: string): Promise<void>;
     waitForEvent(matcher: LiveSidecarEventSelector | ((event: LiveEventFrame) => boolean), timeoutMs?: number, options?: {
         signal?: AbortSignal;
     }): Promise<LiveEventFrame>;

package/dist/protocol-client.js

@@ -1,10 +1,22 @@
-import { SidecarEventBuffer, SidecarEventBufferOverflow, normalizeSidecarEventMatcher, sidecarEventWaitAbortError, } from "./event-buffer.js";
+import { normalizeSidecarEventMatcher, SidecarEventBuffer, SidecarEventBufferOverflow, sidecarEventWaitAbortError, } from "./event-buffer.js";
 import { FrameRpcTransport } from "./frame-rpc.js";
-import { HostProtocolFrameFactory, classifySidecarWrittenProtocolFrame, decodeProtocolFramePayload, encodeProtocolFramePayload, resolveSidecarRequestFramePayload, } from "./protocol-frames.js";
+import { SplitLaneFrameTransport, StdioFrameTransport, } from "./frame-stream.js";
+import { classifySidecarWrittenProtocolFrame, decodeProtocolFramePayload, encodeProtocolFramePayload, HostProtocolFrameFactory, resolveSidecarRequestFramePayload, } from "./protocol-frames.js";
+import { SidecarRejectedError, SidecarSilenceTimeout, } from "./sidecar-errors.js";
+/**
+ * How long the host tolerates TOTAL inbound silence (no responses, events,
+ * sidecar requests, or heartbeats) before declaring the sidecar dead. The
+ * sidecar heartbeats every 10s from a dedicated thread, so this allows two
+ * missed beats plus margin; it bounds "sidecar is dead or wedged", never "this
+ * request is slow" — individual requests have no deadline of their own.
+ */
+const DEFAULT_SIDECAR_SILENCE_TIMEOUT_MS = 30_000;
 export class SidecarProtocolClient {
     eventBuffer;
     eventListeners = new Set();
-    frameTimeoutMs;
+    silenceTimeoutMs;
+    silenceTimer = null;
+    lastInboundAtMs = 0;
     payloadCodec;
     stderrText;
     hostFrameFactory = new HostProtocolFrameFactory();
@@ -13,14 +25,13 @@ export class SidecarProtocolClient {
     eventWaiters = new Set();
     sidecarRequestHandler = null;
     constructor(options) {
-        this.frameTimeoutMs = options.frameTimeoutMs;
+        this.silenceTimeoutMs =
+            options.silenceTimeoutMs ?? DEFAULT_SIDECAR_SILENCE_TIMEOUT_MS;
         this.eventBuffer = new SidecarEventBuffer(options.eventBufferCapacity);
         this.payloadCodec = options.payloadCodec ?? "bare";
         this.stderrText = options.stderrText ?? (() => "");
         this.frameTransport = new FrameRpcTransport({
-            frameTransport: options.frameTransport,
-            stdin: options.stdin,
-            stdout: options.stdout,
+            frameTransport: resolveProtocolFrameTransport(options, this.payloadCodec),
             encodeFrame: (frame) => encodeProtocolFramePayload(frame, this.payloadCodec),
             decodeFrame: (payload) => decodeProtocolFramePayload(payload, this.payloadCodec),
             classifyFrame: classifySidecarWrittenProtocolFrame,
@@ -38,6 +49,45 @@ export class SidecarProtocolClient {
             this.failPermanently(options.streamEndedError?.() ??
                 new Error("sidecar protocol stream ended"));
         });
+        this.frameTransport.onFrameActivity(() => {
+            this.lastInboundAtMs = performance.now();
+        });
+        this.startSilenceWatchdog(options.onSilenceExpired);
+    }
+    /**
+     * Arm the silence watchdog: ANY inbound frame resets the clock (see the
+     * `onFrameActivity` tap above), and the sidecar heartbeats every 10s even
+     * while busy, so sustained silence for the full window means the process
+     * is dead or wedged — not slow. The check interval is unref'd so an idle
+     * host process can still exit naturally.
+     */
+    startSilenceWatchdog(onExpired) {
+        this.lastInboundAtMs = performance.now();
+        const checkIntervalMs = Math.max(Math.min(this.silenceTimeoutMs / 4, 1_000), 10);
+        this.silenceTimer = setInterval(() => {
+            const silenceMs = performance.now() - this.lastInboundAtMs;
+            if (silenceMs < this.silenceTimeoutMs) {
+                return;
+            }
+            this.stopSilenceWatchdog();
+            const error = new SidecarSilenceTimeout({
+                silenceMs,
+                stderr: this.stderrText(),
+            });
+            try {
+                onExpired?.();
+            }
+            finally {
+                this.failPermanently(error);
+            }
+        }, checkIntervalMs);
+        this.silenceTimer.unref?.();
+    }
+    stopSilenceWatchdog() {
+        if (this.silenceTimer !== null) {
+            clearInterval(this.silenceTimer);
+            this.silenceTimer = null;
+        }
     }
     setSidecarRequestHandler(handler) {
         this.sidecarRequestHandler = handler;
@@ -53,15 +103,21 @@ export class SidecarProtocolClient {
             throw this.closedError;
         }
         const request = this.hostFrameFactory.createRequestFrame(input);
-        const response = await this.frameTransport.sendFrame(request.request_id, request, {
-            timeoutMs: this.frameTimeoutMs,
-            timeoutMessage: () => `timed out waiting for sidecar protocol frame for ${input.payload.type}\nstderr:\n${this.stderrText()}`,
-        });
+        // No per-request deadline: only the caller knows whether an operation is
+        // legitimately long (a whole agent turn is one request). A dead or
+        // wedged sidecar rejects this via the silence watchdog instead.
+        const response = await this.frameTransport.sendFrame(request.request_id, request);
         if (response.payload.type === "rejected") {
-            throw new Error(`sidecar rejected request ${request.request_id}: ${response.payload.code}: ${response.payload.message}`);
+            throw new SidecarRejectedError(request.request_id, response.payload);
         }
         return response;
     }
+    async shutdown(reason) {
+        if (this.closedError) {
+            throw this.closedError;
+        }
+        await this.frameTransport.writeFrame(this.hostFrameFactory.createControlFrame({ type: "shutdown", reason }));
+    }
     async waitForEvent(matcher, timeoutMs, options) {
         if (this.closedError instanceof SidecarEventBufferOverflow) {
             throw this.closedError;
@@ -126,15 +182,31 @@ export class SidecarProtocolClient {
             }
         }
         this.closedError = error;
+        this.stopSilenceWatchdog();
         this.rejectPending(error);
     }
     dispose() {
+        this.stopSilenceWatchdog();
         this.frameTransport.dispose();
     }
     async writeFrame(frame) {
         await this.frameTransport.writeFrame(frame);
     }
     async dispatchSidecarRequest(request) {
+        // A callback can arrive immediately before the response that acknowledges
+        // the command which created it. Let the inbound decoder finish that turn
+        // before writing a callback response; otherwise a very fast host callback
+        // can complete and reap the guest process while its execute request is
+        // still being admitted, leaving the host waiting for an exit it missed.
+        await new Promise((resolve) => {
+            const scheduleImmediate = globalThis.setImmediate;
+            if (scheduleImmediate) {
+                scheduleImmediate(resolve);
+            }
+            else {
+                setTimeout(resolve, 0);
+            }
+        });
         const payload = await resolveSidecarRequestFramePayload(request, this.sidecarRequestHandler);
         try {
             await this.writeFrame(this.hostFrameFactory.createSidecarResponseFrame({
@@ -148,6 +220,14 @@ export class SidecarProtocolClient {
         }
     }
     dispatchEvent(event) {
+        // Transport-level liveness beats from the sidecar. Their arrival already
+        // reset the silence watchdog at the frame layer; they carry no meaning
+        // for consumers and must never reach the bounded event buffer, where a
+        // long-idle VM would accumulate one every 10s until overflow.
+        if (event.payload.type === "structured" &&
+            event.payload.name === "heartbeat") {
+            return;
+        }
         for (const listener of this.eventListeners) {
             try {
                 listener(event);
@@ -179,3 +259,104 @@ export class SidecarProtocolClient {
         this.eventWaiters.clear();
     }
 }
+function resolveProtocolFrameTransport(options, payloadCodec) {
+    const hasSplitTransport = options.ordinaryFrameTransport !== undefined ||
+        options.controlFrameTransport !== undefined;
+    const hasStdio = options.stdin !== undefined ||
+        options.stdout !== undefined ||
+        options.control !== undefined;
+    if (options.combinedStdio) {
+        if (options.frameTransport ||
+            hasSplitTransport ||
+            options.control !== undefined ||
+            !options.stdin ||
+            !options.stdout) {
+            throw new Error("SidecarProtocolClient combinedStdio requires only stdin and stdout streams");
+        }
+        return new StdioFrameTransport({
+            stdin: options.stdin,
+            stdout: options.stdout,
+            encodeFrame: (frame) => encodeProtocolFramePayload(frame, payloadCodec),
+            decodeFrame: (payload) => decodeProtocolFramePayload(payload, payloadCodec),
+        });
+    }
+    if (options.frameTransport) {
+        if (hasSplitTransport || hasStdio) {
+            throw new Error("SidecarProtocolClient frameTransport cannot be combined with split-lane transports or streams");
+        }
+        return options.frameTransport;
+    }
+    let ordinary = options.ordinaryFrameTransport;
+    let control = options.controlFrameTransport;
+    if (hasSplitTransport) {
+        if (!ordinary || !control || hasStdio) {
+            throw new Error("SidecarProtocolClient requires both ordinaryFrameTransport and controlFrameTransport, without stdio streams");
+        }
+    }
+    else {
+        if (!options.stdin || !options.stdout || !options.control) {
+            throw new Error("SidecarProtocolClient requires a combined frameTransport or stdin/stdout/control streams");
+        }
+        ordinary = new StdioFrameTransport({
+            stdin: options.stdin,
+            stdout: options.stdout,
+            encodeFrame: (frame) => encodeProtocolFramePayload(frame, payloadCodec),
+            decodeFrame: (payload) => {
+                const frame = decodeProtocolFramePayload(payload, payloadCodec);
+                validateOrdinaryInboundFrame(frame);
+                return frame;
+            },
+        });
+        control = new StdioFrameTransport({
+            stdin: options.control,
+            stdout: options.control,
+            encodeFrame: (frame) => encodeProtocolFramePayload(frame, payloadCodec),
+            decodeFrame: (payload) => {
+                const frame = decodeProtocolFramePayload(payload, payloadCodec);
+                validateControlInboundFrame(frame);
+                return frame;
+            },
+        });
+    }
+    return new SplitLaneFrameTransport({
+        ordinary,
+        control,
+        validateOrdinaryFrame: validateOrdinaryInboundFrame,
+        validateControlFrame: validateControlInboundFrame,
+        selectWriteLane: (frame) => {
+            switch (frame.frame_type) {
+                case "request":
+                    return "ordinary";
+                case "sidecar_response":
+                case "control":
+                    return "control";
+                default: {
+                    const invalidFrame = frame;
+                    throw new Error(`host frame ${invalidFrame.frame_type} is not valid on either writable protocol lane`);
+                }
+            }
+        },
+    });
+}
+function validateOrdinaryInboundFrame(frame) {
+    if (frame.frame_type !== "event") {
+        throw new Error(`sidecar frame ${frame.frame_type} is not valid on the ordinary protocol lane`);
+    }
+    if (isHeartbeatFrame(frame)) {
+        throw new Error("sidecar heartbeat event is not valid on the ordinary protocol lane");
+    }
+}
+function validateControlInboundFrame(frame) {
+    if (frame.frame_type === "response" ||
+        frame.frame_type === "sidecar_request") {
+        return;
+    }
+    if (frame.frame_type === "event" &&
+        isHeartbeatFrame(frame)) {
+        return;
+    }
+    throw new Error(`sidecar frame ${frame.frame_type} is not valid on the control protocol lane`);
+}
+function isHeartbeatFrame(frame) {
+    return (frame.payload.type === "structured" && frame.payload.name === "heartbeat");
+}

package/dist/protocol-frames.d.ts

@@ -1,7 +1,7 @@
-import { type TransportPayloadCodec } from "./frame-payload-codec.js";
-import type { ClassifiedFrame } from "./frame-rpc.js";
 import { type LiveSidecarRequestPayload, type LiveSidecarResponsePayload } from "./callbacks.js";
 import { type LiveSidecarEventPayload } from "./event-buffer.js";
+import { type TransportPayloadCodec } from "./frame-payload-codec.js";
+import type { ClassifiedFrame } from "./frame-rpc.js";
 import * as protocol from "./generated-protocol.js";
 import { type LiveOwnershipScope } from "./ownership.js";
 import { SIDECAR_PROTOCOL_SCHEMA } from "./protocol-schema.js";
@@ -41,7 +41,16 @@ export interface LiveSidecarResponseFrame {
     ownership: LiveOwnershipScope;
     payload: LiveSidecarResponsePayload;
 }
-export type LiveProtocolFrame = LiveRequestFrame | LiveResponseFrame | LiveEventFrame | LiveSidecarRequestFrame | LiveSidecarResponseFrame;
+export type LiveControlPayload = {
+    type: "shutdown";
+    reason: string;
+};
+export interface LiveControlFrame {
+    frame_type: "control";
+    schema: typeof SIDECAR_PROTOCOL_SCHEMA;
+    payload: LiveControlPayload;
+}
+export type LiveProtocolFrame = LiveRequestFrame | LiveResponseFrame | LiveEventFrame | LiveSidecarRequestFrame | LiveSidecarResponseFrame | LiveControlFrame;
 export type LiveSidecarWrittenProtocolFrame = LiveResponseFrame | LiveEventFrame | LiveSidecarRequestFrame;
 export type ProtocolFramePayloadCodec = TransportPayloadCodec;
 export type ClassifiedSidecarWrittenProtocolFrame = ClassifiedFrame<LiveResponseFrame, LiveEventFrame, LiveSidecarRequestFrame>;
@@ -56,6 +65,7 @@ export declare class HostProtocolFrameFactory {
         request: LiveSidecarRequestFrame;
         payload: LiveSidecarResponsePayload;
     }): LiveSidecarResponseFrame;
+    createControlFrame(payload: LiveControlPayload): LiveControlFrame;
 }
 export declare function resolveSidecarRequestFramePayload(request: LiveSidecarRequestFrame, handler: LiveSidecarRequestHandler | null): Promise<LiveSidecarResponsePayload>;
 export declare function toGeneratedProtocolFrame(frame: LiveProtocolFrame): protocol.ProtocolFrame;
@@ -65,4 +75,5 @@ export declare function encodeProtocolFramePayload(frame: LiveProtocolFrame, cod
 export declare function decodeProtocolFramePayload(payload: Uint8Array, codec: ProtocolFramePayloadCodec): LiveSidecarWrittenProtocolFrame;
 export declare function classifySidecarWrittenProtocolFrame(frame: LiveSidecarWrittenProtocolFrame): ClassifiedSidecarWrittenProtocolFrame;
 export declare function fromGeneratedSidecarWrittenProtocolFrame(frame: protocol.ProtocolFrame): LiveSidecarWrittenProtocolFrame;
+export declare function toGeneratedControlPayload(payload: LiveControlPayload): protocol.ControlPayload;
 export declare function toLiveProtocolSchema(schema: protocol.ProtocolSchema): typeof SIDECAR_PROTOCOL_SCHEMA;

package/dist/protocol-frames.js

@@ -1,7 +1,7 @@
 import { toExactUint8Array } from "./bytes.js";
-import { decodeJsonFramePayload, encodeJsonFramePayload, } from "./frame-payload-codec.js";
 import { errorSidecarResponsePayload, fromGeneratedSidecarRequestPayload, isMatchingSidecarResponsePayload, toGeneratedSidecarResponsePayload, } from "./callbacks.js";
 import { fromGeneratedEventPayload, } from "./event-buffer.js";
+import { decodeJsonFramePayload, encodeJsonFramePayload, } from "./frame-payload-codec.js";
 import * as protocol from "./generated-protocol.js";
 import { bigIntToSafeNumber } from "./numbers.js";
 import { fromGeneratedOwnershipScope, toGeneratedOwnershipScope, } from "./ownership.js";
@@ -28,6 +28,13 @@ export class HostProtocolFrameFactory {
             payload: input.payload,
         };
     }
+    createControlFrame(payload) {
+        return {
+            frame_type: "control",
+            schema: SIDECAR_PROTOCOL_SCHEMA,
+            payload,
+        };
+    }
 }
 export async function resolveSidecarRequestFramePayload(request, handler) {
     try {
@@ -66,6 +73,14 @@ export function toGeneratedProtocolFrame(frame) {
                     payload: toGeneratedSidecarResponsePayload(frame.payload),
                 },
             };
+        case "control":
+            return {
+                tag: "ControlFrame",
+                val: {
+                    schema: frame.schema,
+                    payload: toGeneratedControlPayload(frame.payload),
+                },
+            };
         case "response":
         case "event":
         case "sidecar_request":
@@ -131,9 +146,19 @@ export function fromGeneratedSidecarWrittenProtocolFrame(frame) {
             };
         case "RequestFrame":
         case "SidecarResponseFrame":
+        case "ControlFrame":
             throw new Error(`unsupported BARE protocol frame tag: ${frame.tag}`);
     }
 }
+export function toGeneratedControlPayload(payload) {
+    switch (payload.type) {
+        case "shutdown":
+            return {
+                tag: "ShutdownControl",
+                val: { reason: payload.reason },
+            };
+    }
+}
 export function toLiveProtocolSchema(schema) {
     return validateSidecarProtocolSchema(schema);
 }

package/dist/protocol-schema.d.ts

@@ -1,6 +1,6 @@
 export declare const SIDECAR_PROTOCOL_SCHEMA: {
     readonly name: "agentos-native-sidecar";
-    readonly version: 7;
+    readonly version: 8;
 };
 export type LiveProtocolSchema = typeof SIDECAR_PROTOCOL_SCHEMA;
 export type ProtocolSchemaLike = {

package/dist/protocol-schema.js

@@ -1,6 +1,6 @@
 export const SIDECAR_PROTOCOL_SCHEMA = {
     name: "agentos-native-sidecar",
-    version: 7,
+    version: 8,
 };
 export function validateSidecarProtocolSchema(schema) {
     if (schema.name !== SIDECAR_PROTOCOL_SCHEMA.name ||

package/dist/request-payloads.d.ts

@@ -42,7 +42,7 @@ export type LiveRequestPayload = {
     packages?: LivePackageDescriptor[];
     packages_mount_at?: string;
     bootstrap_commands?: string[];
-    tool_shim_commands?: string[];
+    binding_shim_commands?: string[];
 } | {
     type: "link_package";
     package: LivePackageDescriptor;
@@ -79,6 +79,9 @@ export type LiveRequestPayload = {
     lower_layer_ids: string[];
 } | {
     type: "snapshot_root_filesystem";
+    max_bytes: number;
+} | {
+    type: "list_mounts";
 } | {
     type: "guest_kernel_call";
     execution_id: string;

package/dist/request-payloads.js

@@ -58,7 +58,7 @@ export function toGeneratedRequestPayload(payload) {
                     packages: (payload.packages ?? []).map(toGeneratedPackageDescriptor),
                     packagesMountAt: payload.packages_mount_at ?? "",
                     bootstrapCommands: payload.bootstrap_commands ?? [],
-                    toolShimCommands: payload.tool_shim_commands ?? [],
+                    bindingShimCommands: payload.binding_shim_commands ?? [],
                 },
             };
         case "link_package":
@@ -153,7 +153,12 @@ export function toGeneratedRequestPayload(payload) {
                 },
             };
         case "snapshot_root_filesystem":
-            return { tag: "SnapshotRootFilesystemRequest", val: null };
+            return {
+                tag: "SnapshotRootFilesystemRequest",
+                val: { maxBytes: BigInt(payload.max_bytes) },
+            };
+        case "list_mounts":
+            return { tag: "ListMountsRequest", val: null };
         case "execute":
             return {
                 tag: "ExecuteRequest",

package/dist/response-payloads.d.ts

@@ -1,5 +1,5 @@
-import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
 import { type LiveExtEnvelope } from "./ext.js";
+import { type LiveRootFilesystemEntry, type LiveRootFilesystemEntryEncoding } from "./filesystem.js";
 import type * as protocol from "./generated-protocol.js";
 import { type LiveFilesystemOperation, type LiveGuestFilesystemOperation, type LiveSignalDispositionAction } from "./protocol-maps.js";
 import { type LiveGuestFilesystemStat, type LiveProcessSnapshotEntry, type LiveSocketStateEntry } from "./state.js";
@@ -9,7 +9,7 @@ export interface LiveGuestDirEntry {
     path: string;
     isDirectory: boolean;
     isSymbolicLink: boolean;
-    size: number;
+    size: bigint;
 }
 export interface LiveSignalHandlerRegistration {
     action: LiveSignalDispositionAction;
@@ -49,6 +49,11 @@ export interface LivePackageCommands {
     package_name: string;
     commands: string[];
 }
+export interface LiveMountInfo {
+    path: string;
+    kind: string;
+    read_only: boolean;
+}
 export interface LiveAgentosProjectedAgent {
     id: string;
     acp_entrypoint: string;
@@ -79,6 +84,9 @@ export type LiveResponsePayload = {
 } | {
     type: "provided_commands_response";
     packages: LivePackageCommands[];
+} | {
+    type: "mounts_listed";
+    mounts: LiveMountInfo[];
 } | {
     type: "host_callbacks_registered";
     registration: string;
@@ -179,6 +187,19 @@ export type LiveResponsePayload = {
     type: "rejected";
     code: string;
     message: string;
+    limit_name: string | null;
+    configured_limit: number | null;
+    current_usage: number | null;
+    requested: number | null;
+    unit: string | null;
+    scope: string | null;
+    vm_id: string | null;
+    session_generation: number | null;
+    capability_id: number | null;
+    operation: string | null;
+    configuration_path: string | null;
+    retryable: boolean | null;
+    errno: string | null;
 } | {
     type: "ext_result";
     envelope: LiveExtEnvelope;