@rivet-dev/agentos-runtime-core 0.0.0-main.2f99c77 → 0.0.0-main.5ac5a14

package/dist/protocol-client.d.ts

@@ -1,13 +1,19 @@
 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;
+    control?: Readable & Writable;
+    /** Use one bidirectional stdin/stdout transport when the host cannot inherit fd 3. */
+    combinedStdio?: boolean;
     eventBufferCapacity: number;
     payloadCodec?: ProtocolFramePayloadCodec;
     stderrText?: () => string;
@@ -50,6 +56,7 @@ export declare class SidecarProtocolClient {
         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,7 +1,8 @@
-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 { SidecarSilenceTimeout } from "./sidecar-errors.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
@@ -30,9 +31,7 @@ export class SidecarProtocolClient {
         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,
@@ -109,10 +108,16 @@ export class SidecarProtocolClient {
         // 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;
@@ -188,6 +193,20 @@ export class SidecarProtocolClient {
         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({
@@ -240,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;
@@ -147,6 +150,10 @@ export type LiveRequestPayload = {
     path: string;
     headers_json: string;
     body?: string;
+    body_base64?: string;
+    stream_operation?: "start" | "read" | "cancel";
+    stream_id?: string;
+    max_bytes?: number;
 } | {
     type: "get_signal_state";
     process_id: string;
@@ -164,6 +171,98 @@ export type LiveRequestPayload = {
     type: "persistence_flush";
     key: string;
     payload_size_bytes: number;
+} | {
+    type: "shell_execution";
+    request: protocol.ShellExecutionRequest;
+} | {
+    type: "argv_execution";
+    request: protocol.ArgvExecutionRequest;
+} | {
+    type: "javascript_execution";
+    request: protocol.JavaScriptExecutionRequest;
+} | {
+    type: "javascript_evaluation";
+    request: protocol.JavaScriptEvaluationRequest;
+} | {
+    type: "javascript_file_execution";
+    request: protocol.JavaScriptFileExecutionRequest;
+} | {
+    type: "typescript_execution";
+    request: protocol.TypeScriptExecutionRequest;
+} | {
+    type: "typescript_evaluation";
+    request: protocol.TypeScriptEvaluationRequest;
+} | {
+    type: "typescript_file_execution";
+    request: protocol.TypeScriptFileExecutionRequest;
+} | {
+    type: "typescript_check";
+    request: protocol.TypeScriptCheckRequest;
+} | {
+    type: "typescript_project_check";
+    request: protocol.TypeScriptProjectCheckRequest;
+} | {
+    type: "npm_project_install";
+    request: protocol.NpmProjectInstallRequest;
+} | {
+    type: "npm_package_install";
+    request: protocol.NpmPackageInstallRequest;
+} | {
+    type: "npm_script_execution";
+    request: protocol.NpmScriptExecutionRequest;
+} | {
+    type: "npm_package_execution";
+    request: protocol.NpmPackageExecutionRequest;
+} | {
+    type: "python_execution";
+    request: protocol.PythonExecutionRequest;
+} | {
+    type: "python_evaluation";
+    request: protocol.PythonEvaluationRequest;
+} | {
+    type: "python_file_execution";
+    request: protocol.PythonFileExecutionRequest;
+} | {
+    type: "python_module_execution";
+    request: protocol.PythonModuleExecutionRequest;
+} | {
+    type: "python_install";
+    request: protocol.PythonInstallRequest;
+} | {
+    type: "create_context";
+    request: protocol.CreateContextRequest;
+} | {
+    type: "get_execution";
+    request: protocol.GetExecutionRequest;
+} | {
+    type: "list_executions";
+} | {
+    type: "wait_execution";
+    request: protocol.WaitExecutionRequest;
+} | {
+    type: "cancel_execution";
+    request: protocol.CancelExecutionRequest;
+} | {
+    type: "signal_execution";
+    request: protocol.SignalExecutionRequest;
+} | {
+    type: "reset_execution";
+    request: protocol.ResetExecutionRequest;
+} | {
+    type: "delete_execution";
+    request: protocol.DeleteExecutionRequest;
+} | {
+    type: "write_execution_stdin";
+    request: protocol.WriteExecutionStdinRequest;
+} | {
+    type: "close_execution_stdin";
+    request: protocol.CloseExecutionStdinRequest;
+} | {
+    type: "resize_execution_pty";
+    request: protocol.ResizeExecutionPtyRequest;
+} | {
+    type: "read_execution_output";
+    request: protocol.ReadExecutionOutputRequest;
 } | {
     type: "ext";
     envelope: LiveExtEnvelope;

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",
@@ -226,6 +231,10 @@ export function toGeneratedRequestPayload(payload) {
                     path: payload.path,
                     headersJson: payload.headers_json,
                     body: payload.body ?? null,
+                    bodyBase64: payload.body_base64 ?? null,
+                    streamOperation: payload.stream_operation ?? null,
+                    streamId: payload.stream_id ?? null,
+                    maxBytes: payload.max_bytes ?? null,
                 },
             };
         case "get_signal_state":
@@ -257,6 +266,68 @@ export function toGeneratedRequestPayload(payload) {
                     payloadSizeBytes: BigInt(payload.payload_size_bytes),
                 },
             };
+        case "shell_execution":
+            return { tag: "ShellExecutionRequest", val: payload.request };
+        case "argv_execution":
+            return { tag: "ArgvExecutionRequest", val: payload.request };
+        case "javascript_execution":
+            return { tag: "JavaScriptExecutionRequest", val: payload.request };
+        case "javascript_evaluation":
+            return { tag: "JavaScriptEvaluationRequest", val: payload.request };
+        case "javascript_file_execution":
+            return { tag: "JavaScriptFileExecutionRequest", val: payload.request };
+        case "typescript_execution":
+            return { tag: "TypeScriptExecutionRequest", val: payload.request };
+        case "typescript_evaluation":
+            return { tag: "TypeScriptEvaluationRequest", val: payload.request };
+        case "typescript_file_execution":
+            return { tag: "TypeScriptFileExecutionRequest", val: payload.request };
+        case "typescript_check":
+            return { tag: "TypeScriptCheckRequest", val: payload.request };
+        case "typescript_project_check":
+            return { tag: "TypeScriptProjectCheckRequest", val: payload.request };
+        case "npm_project_install":
+            return { tag: "NpmProjectInstallRequest", val: payload.request };
+        case "npm_package_install":
+            return { tag: "NpmPackageInstallRequest", val: payload.request };
+        case "npm_script_execution":
+            return { tag: "NpmScriptExecutionRequest", val: payload.request };
+        case "npm_package_execution":
+            return { tag: "NpmPackageExecutionRequest", val: payload.request };
+        case "python_execution":
+            return { tag: "PythonExecutionRequest", val: payload.request };
+        case "python_evaluation":
+            return { tag: "PythonEvaluationRequest", val: payload.request };
+        case "python_file_execution":
+            return { tag: "PythonFileExecutionRequest", val: payload.request };
+        case "python_module_execution":
+            return { tag: "PythonModuleExecutionRequest", val: payload.request };
+        case "python_install":
+            return { tag: "PythonInstallRequest", val: payload.request };
+        case "create_context":
+            return { tag: "CreateContextRequest", val: payload.request };
+        case "get_execution":
+            return { tag: "GetExecutionRequest", val: payload.request };
+        case "list_executions":
+            return { tag: "ListExecutionsRequest", val: null };
+        case "wait_execution":
+            return { tag: "WaitExecutionRequest", val: payload.request };
+        case "cancel_execution":
+            return { tag: "CancelExecutionRequest", val: payload.request };
+        case "signal_execution":
+            return { tag: "SignalExecutionRequest", val: payload.request };
+        case "reset_execution":
+            return { tag: "ResetExecutionRequest", val: payload.request };
+        case "delete_execution":
+            return { tag: "DeleteExecutionRequest", val: payload.request };
+        case "write_execution_stdin":
+            return { tag: "WriteExecutionStdinRequest", val: payload.request };
+        case "close_execution_stdin":
+            return { tag: "CloseExecutionStdinRequest", val: payload.request };
+        case "resize_execution_pty":
+            return { tag: "ResizeExecutionPtyRequest", val: payload.request };
+        case "read_execution_output":
+            return { tag: "ReadExecutionOutputRequest", val: payload.request };
         case "ext":
             return {
                 tag: "ExtEnvelope",

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";
@@ -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,46 @@ 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: "execution_accepted";
+    response: protocol.ExecutionAcceptedResponse;
+} | {
+    type: "execution_completed";
+    response: protocol.ExecutionCompletedResponse;
+} | {
+    type: "execution_evaluation";
+    response: protocol.ExecutionEvaluationResponse;
+} | {
+    type: "typescript_check";
+    response: protocol.TypeScriptCheckResponse;
+} | {
+    type: "execution_descriptor";
+    response: protocol.ExecutionDescriptorResponse;
+} | {
+    type: "execution_list";
+    response: protocol.ExecutionListResponse;
+} | {
+    type: "execution_deleted";
+    response: protocol.ExecutionDeletedResponse;
+} | {
+    type: "execution_io";
+    response: protocol.ExecutionIoResponse;
+} | {
+    type: "execution_output_page";
+    response: protocol.ExecutionOutputPageResponse;
 } | {
     type: "ext_result";
     envelope: LiveExtEnvelope;