@rivet-dev/agentos-runtime-core 0.0.0-main.29b0797 → 0.0.0-main.5ac5a14

package/dist/kernel-proxy.js

@@ -26,7 +26,7 @@ export function serializeMountConfigForSidecar(mount) {
 }
 const SYNTHETIC_PID_BASE = 1_000_000;
 const MISSING_EXIT_EVENT_GRACE_MS = 500;
-const PROTECTED_READ_ONLY_GUEST_ROOTS = ["/etc/secure-exec"];
+const PROTECTED_READ_ONLY_GUEST_ROOTS = ["/etc/agentos"];
 const TRAILING_OUTPUT_DRAIN_INTERVAL_MS = 10;
 const TRAILING_OUTPUT_DRAIN_MAX_MS = 250;
 const TRAILING_OUTPUT_DRAIN_QUIET_TURNS = 2;

package/dist/native-client.js

@@ -18,10 +18,19 @@ export class StdioSidecarProtocolClient {
         this.gracefulExitMs = options.gracefulExitMs;
         this.forceExitMs = options.forceExitMs;
         this.disposedErrorMessage = options.disposedErrorMessage;
+        const transportOptions = this.sidecarProcess.combinedStdio
+            ? {
+                stdin: this.child.stdin,
+                stdout: this.child.stdout,
+                combinedStdio: true,
+            }
+            : {
+                stdin: this.child.stdin,
+                stdout: this.child.stdout,
+                control: this.sidecarProcess.control,
+            };
         this.protocolClient = new SidecarProtocolClient({
-            stdin: this.child.stdin,
-            stdout: this.child.stdout,
-            control: this.sidecarProcess.control,
+            ...transportOptions,
             eventBufferCapacity: options.eventBufferCapacity,
             payloadCodec: options.payloadCodec,
             silenceTimeoutMs: options.silenceTimeoutMs,
@@ -53,10 +62,12 @@ export class StdioSidecarProtocolClient {
         });
     }
     static spawn(options = {}) {
+        const combinedStdio = typeof globalThis._childProcessSpawnStart !== "undefined";
         return new StdioSidecarProtocolClient(StdioSidecarProcess.spawn({
             command: options.command ?? resolvePublishedSidecarBinary(),
             args: options.args ?? [],
             cwd: options.cwd,
+            combinedStdio,
         }), {
             silenceTimeoutMs: options.silenceTimeoutMs,
             eventBufferCapacity: options.eventBufferCapacity ?? DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY,
@@ -95,7 +106,7 @@ export class StdioSidecarProtocolClient {
                 // Stdin may already be closing. The child exit watcher will catch up.
             }
         }
-        if (!this.sidecarProcess.control.destroyed) {
+        if (this.sidecarProcess.control && !this.sidecarProcess.control.destroyed) {
             try {
                 this.sidecarProcess.control.end();
             }
@@ -132,11 +143,13 @@ export class StdioSidecarProtocolClient {
         catch {
             // Best effort. The child is gone so the descriptor will close on its own.
         }
-        try {
-            this.sidecarProcess.control.destroy();
-        }
-        catch {
-            // Best effort. The child is gone so the descriptor will close on its own.
+        if (this.sidecarProcess.control) {
+            try {
+                this.sidecarProcess.control.destroy();
+            }
+            catch {
+                // Best effort. The child is gone so the descriptor will close on its own.
+            }
         }
         if (exitCode !== null && exitCode !== 0 && this.child.signalCode === null) {
             throw new Error(`sidecar exited with code ${exitCode}\nstderr:\n${this.sidecarProcess.stderrText()}`);

package/dist/node-runtime.js

@@ -35,7 +35,7 @@ const REPO_COMMANDS_DIR = path.join(REPO_ROOT, "toolchain/target/wasm32-wasip1/r
 /**
  * Commands vendored into the published `@rivet-dev/agentos-runtime-core` package by
  * `scripts/copy-wasm-commands.mjs` (listed in `files` as `commands`). This is
- * the directory a real `npm install secure-exec` resolves: from the compiled
+ * the directory a real `npm install agentos` resolves: from the compiled
  * `dist/node-runtime.js` it sits at `<package>/commands`. This is the analogue
  * of how the sidecar binary ships inside `@rivet-dev/agentos-runtime-sidecar`.
  */
@@ -222,7 +222,7 @@ export class NodeRuntime {
      * `node <file>`; it runs as standard ESM (top-level `await`, `import`).
      */
     async exec(code, options = {}) {
-        const programPath = `/tmp/secure-exec-program-${nextProgramId++}.mjs`;
+        const programPath = `/tmp/agentos-program-${nextProgramId++}.mjs`;
         await this.kernel.writeFile(programPath, withBindingPreamble(code));
         return this.runProgram(programPath, options);
     }
@@ -328,7 +328,7 @@ export class NodeRuntime {
      * ```
      */
     async spawn(code, options = {}) {
-        const programPath = `/tmp/secure-exec-program-${nextProgramId++}.mjs`;
+        const programPath = `/tmp/agentos-program-${nextProgramId++}.mjs`;
         await this.kernel.writeFile(programPath, withBindingPreamble(code));
         const proc = this.kernel.spawn("node", [programPath], {
             env: options.env,
@@ -442,8 +442,8 @@ export class NodeRuntime {
      */
     async run(code, options = {}) {
         const id = nextProgramId++;
-        const resultPath = `/tmp/secure-exec-result-${id}.json`;
-        const programPath = `/tmp/secure-exec-program-${id}.mjs`;
+        const resultPath = `/tmp/agentos-result-${id}.json`;
+        const programPath = `/tmp/agentos-program-${id}.mjs`;
         // Inject the __return helper as a module-level preamble, then the user
         // code at module top level. Import declarations (preamble's and the
         // user's) are hoisted, so __return is defined before the user's

package/dist/process.d.ts

@@ -6,16 +6,18 @@ export interface StdioSidecarProcessSpawnOptions {
     command: string;
     args?: string[];
     cwd?: string;
+    combinedStdio?: boolean;
 }
 export declare class StdioSidecarProcess {
     readonly child: ChildProcessWithoutNullStreams;
-    readonly control: Duplex;
+    readonly control: Duplex | null;
+    readonly combinedStdio: boolean;
     private readonly stderrChunks;
     private readonly exitListeners;
     private readonly errorListeners;
     private constructor();
     static spawn(options: StdioSidecarProcessSpawnOptions): StdioSidecarProcess;
-    static fromChild(child: ChildProcessWithoutNullStreams, control?: Duplex): StdioSidecarProcess;
+    static fromChild(child: ChildProcessWithoutNullStreams, control?: Duplex | null): StdioSidecarProcess;
     onExit(handler: (error: SidecarProcessExited) => void): () => void;
     onError(handler: (error: SidecarProcessError) => void): () => void;
     stderrText(): string;

package/dist/process.js

@@ -4,12 +4,14 @@ import { SidecarProcessError, SidecarProcessExited } from "./sidecar-errors.js";
 export class StdioSidecarProcess {
     child;
     control;
+    combinedStdio;
     stderrChunks = [];
     exitListeners = new Set();
     errorListeners = new Set();
     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));
         });
@@ -32,12 +34,18 @@ export class StdioSidecarProcess {
         });
     }
     static spawn(options) {
+        const combinedStdio = options.combinedStdio === true;
         const child = spawn(options.command, options.args ?? [], {
             cwd: options.cwd,
-            stdio: ["pipe", "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, requireControlStream(child));
+            return new StdioSidecarProcess(child, combinedStdio ? null : requireControlStream(child));
         }
         catch (error) {
             child.kill("SIGKILL");
@@ -45,7 +53,7 @@ export class StdioSidecarProcess {
         }
     }
     static fromChild(child, control) {
-        return new StdioSidecarProcess(child, control ?? requireControlStream(child));
+        return new StdioSidecarProcess(child, control === null ? null : (control ?? requireControlStream(child)));
     }
     onExit(handler) {
         this.exitListeners.add(handler);

package/dist/protocol-client.d.ts

@@ -12,6 +12,8 @@ export interface SidecarProtocolClientOptions {
     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;

package/dist/protocol-client.js

@@ -193,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({
@@ -251,6 +265,21 @@ function resolveProtocolFrameTransport(options, payloadCodec) {
     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");

package/dist/request-payloads.d.ts

@@ -150,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;
@@ -167,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

@@ -231,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":
@@ -262,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

@@ -200,6 +200,33 @@ export type LiveResponsePayload = {
     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;

package/dist/response-payloads.js

@@ -271,6 +271,24 @@ export function fromGeneratedResponsePayload(payload) {
                 type: "ext_result",
                 envelope: fromGeneratedExtEnvelope(payload.val),
             };
+        case "ExecutionAcceptedResponse":
+            return { type: "execution_accepted", response: payload.val };
+        case "ExecutionCompletedResponse":
+            return { type: "execution_completed", response: payload.val };
+        case "ExecutionEvaluationResponse":
+            return { type: "execution_evaluation", response: payload.val };
+        case "TypeScriptCheckResponse":
+            return { type: "typescript_check", response: payload.val };
+        case "ExecutionDescriptorResponse":
+            return { type: "execution_descriptor", response: payload.val };
+        case "ExecutionListResponse":
+            return { type: "execution_list", response: payload.val };
+        case "ExecutionDeletedResponse":
+            return { type: "execution_deleted", response: payload.val };
+        case "ExecutionIoResponse":
+            return { type: "execution_io", response: payload.val };
+        case "ExecutionOutputPageResponse":
+            return { type: "execution_output_page", response: payload.val };
     }
 }
 function fromGeneratedAgentosProjectedAgent(agent) {

package/dist/sidecar-process.d.ts

@@ -7,7 +7,8 @@ import type { SidecarProcessTransport } from "./sidecar-client.js";
 import { type LiveFsPermissionRule, type LivePatternPermissionRule, type LivePermissionMode, type LivePermissionScope, type LiveRulePermissions } from "./permissions.js";
 import type { LiveFilesystemOperation, LiveGuestRuntimeKind, LiveWasmPermissionTier } from "./protocol-maps.js";
 import { type LiveEventFrame, type LiveSidecarRequestHandler, type LiveSidecarRequestFrame, type LiveSidecarResponseFrame, type ProtocolFramePayloadCodec } from "./protocol-frames.js";
-import type { LiveGuestDirEntry } from "./response-payloads.js";
+import { type LiveRequestPayload } from "./request-payloads.js";
+import type { LiveGuestDirEntry, LiveResponsePayload } from "./response-payloads.js";
 import { type LiveGuestFilesystemStat } from "./state.js";
 export { SidecarProcessError, SidecarProcessExited, SidecarSilenceTimeout, } from "./sidecar-errors.js";
 export { SidecarEventBufferOverflow } from "./event-buffer.js";
@@ -348,6 +349,10 @@ export declare class SidecarProcess {
         path: string;
         headersJson: string;
         body?: string;
+        bodyBase64?: string;
+        streamOperation?: "start" | "read" | "cancel";
+        streamId?: string;
+        maxBytes?: number;
     }): Promise<string>;
     getSignalState(session: AuthenticatedSession, vm: CreatedVm, processId: string): Promise<SidecarSignalState>;
     getZombieTimerCount(session: AuthenticatedSession, vm: CreatedVm): Promise<SidecarZombieTimerCount>;
@@ -364,6 +369,8 @@ export declare class SidecarProcess {
     waitForEvent(matcher: SidecarEventSelector | ((event: EventFrame) => boolean), timeoutMs?: number, options?: {
         signal?: AbortSignal;
     }): Promise<EventFrame>;
+    /** Internal semantic request entrypoint used by the AgentOS client surface. */
+    sendVmRequest(session: AuthenticatedSession, vm: CreatedVm, payload: LiveRequestPayload): Promise<LiveResponsePayload>;
     dispose(): Promise<void>;
     private sendRequest;
     private guestFilesystemCall;

package/dist/sidecar-process.js

@@ -53,8 +53,8 @@ export class SidecarProcess {
             },
             payload: {
                 type: "authenticate",
-                client_name: "secure-exec-core-client",
-                auth_token: "secure-exec-core-client-token",
+                client_name: "agentos-core-client",
+                auth_token: "agentos-core-client-token",
                 protocol_version: SIDECAR_PROTOCOL_SCHEMA.version,
                 bridge_version: BRIDGE_CONTRACT_VERSION,
             },
@@ -814,6 +814,18 @@ export class SidecarProcess {
                 path: request.path,
                 headers_json: request.headersJson,
                 ...(request.body !== undefined ? { body: request.body } : {}),
+                ...(request.bodyBase64 !== undefined
+                    ? { body_base64: request.bodyBase64 }
+                    : {}),
+                ...(request.streamOperation !== undefined
+                    ? { stream_operation: request.streamOperation }
+                    : {}),
+                ...(request.streamId !== undefined
+                    ? { stream_id: request.streamId }
+                    : {}),
+                ...(request.maxBytes !== undefined
+                    ? { max_bytes: request.maxBytes }
+                    : {}),
             },
         });
         if (response.payload.type !== "vm_fetch_result") {
@@ -934,6 +946,19 @@ export class SidecarProcess {
     async waitForEvent(matcher, timeoutMs, options) {
         return await this.protocolClient.waitForEvent(matcher, timeoutMs, options);
     }
+    /** Internal semantic request entrypoint used by the AgentOS client surface. */
+    async sendVmRequest(session, vm, payload) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload,
+        });
+        return response.payload;
+    }
     async dispose() {
         await this.protocolClient.dispose();
     }

package/dist/test-runtime.d.ts

@@ -1,7 +1,8 @@
 import "./native-client.js";
-import { SidecarProcess } from "./kernel-proxy.js";
 import type { JsRuntimeConfig } from "./generated/JsRuntimeConfig.js";
+import type { VmLimitsConfig } from "./generated/VmLimitsConfig.js";
 import type { VmUserConfig } from "./generated/VmUserConfig.js";
+import { SidecarProcess } from "./kernel-proxy.js";
 export declare const AF_INET = 2;
 export declare const AF_UNIX = 1;
 export declare const SOCK_STREAM = 1;
@@ -341,6 +342,10 @@ export interface Kernel extends KernelInterface {
         path: string;
         headersJson: string;
         body?: string;
+        bodyBase64?: string;
+        streamOperation?: "start" | "read" | "cancel";
+        streamId?: string;
+        maxBytes?: number;
     }): Promise<string>;
     registerBindings(bindings: Record<string, BindingDefinition>): Promise<void>;
     getResourceSnapshot(): Promise<{
@@ -567,6 +572,7 @@ export declare function createKernel(options: {
     hostNetworkAdapter?: unknown;
     loopbackExemptPorts?: number[];
     jsRuntime?: Partial<JsRuntimeConfig>;
+    limits?: VmLimitsConfig;
     logger?: unknown;
     mounts?: Array<{
         path: string;