@rivet-dev/agentos-runtime-core 0.0.0-codex-actor-plugin-contract-coverage.115ca8a → 0.0.0-fix-main-wasm-ownership.150c49a

package/dist/protocol-client.d.ts

@@ -1,24 +1,36 @@
 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;
     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 +39,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,9 +182,11 @@ export class SidecarProtocolClient {
             }
         }
         this.closedError = error;
+        this.stopSilenceWatchdog();
         this.rejectPending(error);
     }
     dispose() {
+        this.stopSilenceWatchdog();
         this.frameTransport.dispose();
     }
     async writeFrame(frame) {
@@ -148,6 +206,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 +245,89 @@ 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.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;

package/dist/response-payloads.js

@@ -1,5 +1,5 @@
-import { fromGeneratedRootFilesystemEntry, } from "./filesystem.js";
 import { fromGeneratedExtEnvelope } from "./ext.js";
+import { fromGeneratedRootFilesystemEntry, } from "./filesystem.js";
 import { bigIntToSafeNumber } from "./numbers.js";
 import { fromGeneratedFilesystemOperation, fromGeneratedGuestFilesystemOperation, fromGeneratedRootFilesystemEntryEncoding, fromGeneratedSignalDispositionAction, } from "./protocol-maps.js";
 import { fromGeneratedGuestFilesystemStat, fromGeneratedProcessSnapshotEntry, fromGeneratedSocketStateEntry, } from "./state.js";
@@ -55,6 +55,15 @@ export function fromGeneratedResponsePayload(payload) {
                     commands: [...pkg.commands],
                 })),
             };
+        case "ListMountsResponse":
+            return {
+                type: "mounts_listed",
+                mounts: payload.val.mounts.map((mount) => ({
+                    path: mount.path,
+                    kind: mount.kind,
+                    read_only: mount.readOnly,
+                })),
+            };
         case "HostCallbacksRegisteredResponse":
             return {
                 type: "host_callbacks_registered",
@@ -95,7 +104,7 @@ export function fromGeneratedResponsePayload(payload) {
                             path: entry.path,
                             isDirectory: entry.isDirectory,
                             isSymbolicLink: entry.isSymbolicLink,
-                            size: bigIntToSafeNumber(entry.size, "guest dir entry size"),
+                            size: entry.size,
                         })),
                     }
                     : {}),
@@ -228,6 +237,29 @@ export function fromGeneratedResponsePayload(payload) {
                 type: "rejected",
                 code: payload.val.code,
                 message: payload.val.message,
+                limit_name: payload.val.limitName,
+                configured_limit: payload.val.configuredLimit === null
+                    ? null
+                    : bigIntToSafeNumber(payload.val.configuredLimit, "rejected.configured_limit"),
+                current_usage: payload.val.currentUsage === null
+                    ? null
+                    : bigIntToSafeNumber(payload.val.currentUsage, "rejected.current_usage"),
+                requested: payload.val.requested === null
+                    ? null
+                    : bigIntToSafeNumber(payload.val.requested, "rejected.requested"),
+                unit: payload.val.unit,
+                scope: payload.val.scope,
+                vm_id: payload.val.vmId,
+                session_generation: payload.val.sessionGeneration === null
+                    ? null
+                    : bigIntToSafeNumber(payload.val.sessionGeneration, "rejected.session_generation"),
+                capability_id: payload.val.capabilityId === null
+                    ? null
+                    : bigIntToSafeNumber(payload.val.capabilityId, "rejected.capability_id"),
+                operation: payload.val.operation,
+                configuration_path: payload.val.configurationPath,
+                retryable: payload.val.retryable,
+                errno: payload.val.errno,
             };
         case "VmFetchResponse":
             return {

package/dist/sidecar-errors.d.ts

@@ -1,3 +1,25 @@
+export interface SidecarRejectionDetail {
+    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;
+}
+export declare class SidecarRejectedError extends Error {
+    readonly requestId: number;
+    readonly detail: SidecarRejectionDetail;
+    constructor(requestId: number, detail: SidecarRejectionDetail);
+}
 export declare class SidecarProcessExited extends Error {
     readonly exitCode: number | null;
     readonly signal: string | null;
@@ -8,6 +30,21 @@ export declare class SidecarProcessExited extends Error {
         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;

package/dist/sidecar-errors.js

@@ -1,6 +1,16 @@
 function formatSidecarStderrSuffix(stderr) {
     return stderr ? `\nstderr:\n${stderr}` : "";
 }
+export class SidecarRejectedError extends Error {
+    requestId;
+    detail;
+    constructor(requestId, detail) {
+        super(`sidecar rejected request ${requestId}: ${detail.code}: ${detail.message}`);
+        this.name = "SidecarRejectedError";
+        this.requestId = requestId;
+        this.detail = detail;
+    }
+}
 export class SidecarProcessExited extends Error {
     exitCode;
     signal;
@@ -18,6 +28,23 @@ export class SidecarProcessExited extends Error {
         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;