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

package/dist/event-buffer.js

@@ -1,4 +1,4 @@
-import { fromGeneratedExtEnvelope, } from "./ext.js";
+import { fromGeneratedExtEnvelope } from "./ext.js";
 import { ownershipMatchesSelector, ownershipSelectorKey, } from "./ownership.js";
 import { fromGeneratedStreamChannel, fromGeneratedVmLifecycleState, } from "./protocol-maps.js";
 export const ANY_BUFFERED_EVENT_KEY = "*";
@@ -114,6 +114,9 @@ function buildBufferKey(type, options) {
     if (options?.processId) {
         parts.push(`process:${options.processId}`);
     }
+    if (options?.executionId) {
+        parts.push(`execution:${options.executionId}`);
+    }
     if (options?.channel) {
         parts.push(`channel:${options.channel}`);
     }
@@ -163,6 +166,12 @@ export function sidecarSelectorMatchesEvent(selector, event) {
             }
             return true;
         }
+        case "execution_output":
+        case "execution_completed": {
+            const payload = event.payload;
+            return (selector.executionId === undefined ||
+                payload.event.executionId === selector.executionId);
+        }
     }
 }
 export function sidecarSelectorBufferKey(selector) {
@@ -194,6 +203,12 @@ export function sidecarSelectorBufferKey(selector) {
                 ownership: selector.ownership,
                 name: selector.name,
             });
+        case "execution_output":
+        case "execution_completed":
+            return buildBufferKey(selector.type, {
+                ownership: selector.ownership,
+                executionId: selector.executionId,
+            });
     }
 }
 export function normalizeSidecarEventMatcher(selector) {
@@ -239,6 +254,10 @@ export function fromGeneratedEventPayload(payload) {
                 type: "ext",
                 envelope: fromGeneratedExtEnvelope(payload.val),
             };
+        case "ExecutionOutputEvent":
+            return { type: "execution_output", event: payload.val };
+        case "ExecutionCompletedEvent":
+            return { type: "execution_completed", event: payload.val };
     }
 }
 export function sidecarEventWaitAbortError(reason) {
@@ -306,6 +325,16 @@ export function sidecarEventBufferKeys(event) {
                 name: event.payload.name,
             }));
             break;
+        case "execution_output":
+        case "execution_completed":
+            keys.add(buildBufferKey(event.payload.type, {
+                executionId: event.payload.event.executionId,
+            }));
+            keys.add(buildBufferKey(event.payload.type, {
+                ownership: owner,
+                executionId: event.payload.event.executionId,
+            }));
+            break;
         case "ext":
             break;
     }

package/dist/frame-stream.d.ts

@@ -12,11 +12,45 @@ export interface FrameTransport<TReadFrame, TWriteFrame = TReadFrame> {
     writeFrame(frame: TWriteFrame): Promise<void>;
     dispose(): void;
 }
+export type FrameTransportLane = "ordinary" | "control";
+export interface SplitLaneFrameTransportOptions<TOrdinaryReadFrame, TOrdinaryWriteFrame, TControlReadFrame, TControlWriteFrame> {
+    ordinary: FrameTransport<TOrdinaryReadFrame, TOrdinaryWriteFrame>;
+    control: FrameTransport<TControlReadFrame, TControlWriteFrame>;
+    validateOrdinaryFrame?: (frame: TOrdinaryReadFrame) => void;
+    validateControlFrame?: (frame: TControlReadFrame) => void;
+    selectWriteLane: (frame: TOrdinaryWriteFrame | TControlWriteFrame) => FrameTransportLane;
+}
+/**
+ * Presents two physically independent frame streams as one transport while
+ * retaining strict lane ownership. An error or EOF on either lane is terminal
+ * to consumers of the combined transport.
+ */
+export declare class SplitLaneFrameTransport<TOrdinaryReadFrame, TOrdinaryWriteFrame, TControlReadFrame, TControlWriteFrame> implements FrameTransport<TOrdinaryReadFrame | TControlReadFrame, TOrdinaryWriteFrame | TControlWriteFrame> {
+    private readonly ordinary;
+    private readonly control;
+    private readonly selectWriteLane;
+    private readonly frameListeners;
+    private readonly errorListeners;
+    private readonly endListeners;
+    private readonly removeLaneListeners;
+    private terminalError;
+    constructor(options: SplitLaneFrameTransportOptions<TOrdinaryReadFrame, TOrdinaryWriteFrame, TControlReadFrame, TControlWriteFrame>);
+    onFrame(handler: (frame: TOrdinaryReadFrame | TControlReadFrame) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    onEnd(handler: () => void): () => void;
+    writeFrame(frame: TOrdinaryWriteFrame | TControlWriteFrame): Promise<void>;
+    dispose(): void;
+    private emitFrame;
+    private emitError;
+    private emitEnd;
+    private detachLaneTransports;
+}
 export declare class StdioFrameTransport<TReadFrame, TWriteFrame = TReadFrame> implements FrameTransport<TReadFrame, TWriteFrame> {
     private readonly stdin;
     private readonly stdout;
     private readonly encodeFrame;
     private readonly decodeFrame;
+    private readonly sharedStdio;
     private readonly frameListeners;
     private readonly errorListeners;
     private readonly endListeners;

package/dist/frame-stream.js

@@ -1,9 +1,123 @@
 import { encodeLengthPrefixedPayload, tryDecodeLengthPrefixedPayload, } from "./framing.js";
+/**
+ * Presents two physically independent frame streams as one transport while
+ * retaining strict lane ownership. An error or EOF on either lane is terminal
+ * to consumers of the combined transport.
+ */
+export class SplitLaneFrameTransport {
+    ordinary;
+    control;
+    selectWriteLane;
+    frameListeners = new Set();
+    errorListeners = new Set();
+    endListeners = new Set();
+    removeLaneListeners = [];
+    terminalError = null;
+    constructor(options) {
+        this.ordinary = options.ordinary;
+        this.control = options.control;
+        this.selectWriteLane = options.selectWriteLane;
+        this.removeLaneListeners.push(this.ordinary.onFrame((frame) => {
+            try {
+                options.validateOrdinaryFrame?.(frame);
+            }
+            catch (error) {
+                this.emitError(error);
+                return;
+            }
+            this.emitFrame(frame);
+        }), this.control.onFrame((frame) => {
+            try {
+                options.validateControlFrame?.(frame);
+            }
+            catch (error) {
+                this.emitError(error);
+                return;
+            }
+            this.emitFrame(frame);
+        }), this.ordinary.onError((error) => this.emitError(error)), this.control.onError((error) => this.emitError(error)), this.ordinary.onEnd(() => this.emitEnd()), this.control.onEnd(() => this.emitEnd()));
+    }
+    onFrame(handler) {
+        this.frameListeners.add(handler);
+        return () => {
+            this.frameListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    onEnd(handler) {
+        this.endListeners.add(handler);
+        return () => {
+            this.endListeners.delete(handler);
+        };
+    }
+    async writeFrame(frame) {
+        if (this.terminalError) {
+            throw this.terminalError;
+        }
+        switch (this.selectWriteLane(frame)) {
+            case "ordinary":
+                await this.ordinary.writeFrame(frame);
+                return;
+            case "control":
+                await this.control.writeFrame(frame);
+                return;
+        }
+    }
+    dispose() {
+        this.terminalError ??= new Error("split-lane frame transport disposed");
+        this.detachLaneTransports();
+        this.frameListeners.clear();
+        this.errorListeners.clear();
+        this.endListeners.clear();
+    }
+    emitFrame(frame) {
+        if (this.terminalError) {
+            return;
+        }
+        for (const listener of this.frameListeners) {
+            listener(frame);
+        }
+    }
+    emitError(error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        if (this.terminalError) {
+            return;
+        }
+        this.terminalError = normalized;
+        this.detachLaneTransports();
+        for (const listener of this.errorListeners) {
+            listener(normalized);
+        }
+    }
+    emitEnd() {
+        if (this.terminalError) {
+            return;
+        }
+        this.terminalError = new Error("split-lane frame transport ended");
+        this.detachLaneTransports();
+        for (const listener of this.endListeners) {
+            listener();
+        }
+    }
+    detachLaneTransports() {
+        for (const removeListener of this.removeLaneListeners.splice(0)) {
+            removeListener();
+        }
+        this.ordinary.dispose();
+        this.control.dispose();
+    }
+}
 export class StdioFrameTransport {
     stdin;
     stdout;
     encodeFrame;
     decodeFrame;
+    sharedStdio;
     frameListeners = new Set();
     errorListeners = new Set();
     endListeners = new Set();
@@ -13,6 +127,10 @@ export class StdioFrameTransport {
         this.stdout = options.stdout;
         this.encodeFrame = options.encodeFrame;
         this.decodeFrame = options.decodeFrame;
+        this.sharedStdio = this.stdin === this.stdout;
+        if (!this.sharedStdio) {
+            this.stdin.on("error", this.handleError);
+        }
         this.stdout.on("data", this.handleData);
         this.stdout.on("end", this.handleEnd);
         this.stdout.on("error", this.handleError);
@@ -49,6 +167,9 @@ export class StdioFrameTransport {
         });
     }
     dispose() {
+        if (!this.sharedStdio) {
+            this.stdin.off("error", this.handleError);
+        }
         this.stdout.off("data", this.handleData);
         this.stdout.off("end", this.handleEnd);
         this.stdout.off("error", this.handleError);

package/dist/generated/AcpLimitsConfig.d.ts

@@ -1,4 +1,20 @@
 export type AcpLimitsConfig = {
     maxReadLineBytes?: number;
     stdoutBufferByteLimit?: number;
+    maxCompletedMessageBytes?: number;
+    maxTurnOutputBytes?: number;
+    maxPromptBytes?: number;
+    maxPromptBlocks?: number;
+    maxFallbackContinuationBytes?: number;
+    maxSessionHistoryBytes?: number;
+    maxSessionHistoryEvents?: number;
+    maxHistoryPageEntries?: number;
+    maxSessionListEntries?: number;
+    maxSessionsPerVm?: number;
+    maxPromptsPerSession?: number;
+    maxPromptsPerVm?: number;
+    maxPendingPermissionsPerSession?: number;
+    maxPendingPermissionsPerVm?: number;
+    maxPermissionOutcomesPerSession?: number;
+    maxPermissionOutcomesPerVm?: number;
 };

package/dist/generated/BindingLimitsConfig.d.ts

@@ -0,0 +1,10 @@
+export type BindingLimitsConfig = {
+    defaultBindingTimeoutMs?: number;
+    maxBindingTimeoutMs?: number;
+    maxRegisteredCollections?: number;
+    maxRegisteredBindingsPerVm?: number;
+    maxBindingsPerCollection?: number;
+    maxBindingSchemaBytes?: number;
+    maxExamplesPerBinding?: number;
+    maxBindingExampleInputBytes?: number;
+};

package/dist/generated/CreateVmConfig.d.ts

@@ -5,6 +5,8 @@ import type { RootFilesystemConfig } from "./RootFilesystemConfig.js";
 import type { VmDnsConfig } from "./VmDnsConfig.js";
 import type { VmLimitsConfig } from "./VmLimitsConfig.js";
 import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
+import type { VmSqliteDescriptor } from "./VmSqliteDescriptor.js";
+import type { VmUserConfig } from "./VmUserConfig.js";
 /**
  * Canonical Rust-side VM config. Unknown fields must stay rejected here and in
  * the TS preflight schema at
@@ -14,6 +16,8 @@ import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
 export type CreateVmConfig = {
     cwd?: string;
     env: Record<string, string>;
+    database?: VmSqliteDescriptor;
+    user?: VmUserConfig;
     rootFilesystem: RootFilesystemConfig;
     permissions?: PermissionsPolicy;
     limits?: VmLimitsConfig;

package/dist/generated/ExecutionLimitsConfig.d.ts

@@ -0,0 +1,5 @@
+export type ExecutionLimitsConfig = {
+    completedTtlMs?: number;
+    maxCompletedExecutions?: number;
+    liveExecutionWarningThreshold?: number;
+};

package/dist/generated/ExecutionLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/Http2LimitsConfig.d.ts

@@ -0,0 +1,12 @@
+export type Http2LimitsConfig = {
+    maxConnections?: number;
+    maxStreams?: number;
+    maxStreamsPerConnection?: number;
+    maxBufferedBytes?: number;
+    maxHeaderBytes?: number;
+    maxDataBytes?: number;
+    maxPendingCommands?: number;
+    maxPendingCommandBytes?: number;
+    maxPendingEvents?: number;
+    maxPendingEventBytes?: number;
+};

package/dist/generated/Http2LimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/JsRuntimeLimitsConfig.d.ts

@@ -7,5 +7,6 @@ export type JsRuntimeLimitsConfig = {
     capturedOutputLimitBytes?: number;
     stdinBufferLimitBytes?: number;
     eventPayloadLimitBytes?: number;
+    maxTimers?: number;
     v8IpcMaxFrameBytes?: number;
 };

package/dist/generated/MountPluginDescriptor.d.ts

@@ -1,4 +1,4 @@
 export type MountPluginDescriptor = {
     id: string;
-    config: import("../descriptors.js").MountConfigJsonValue;
+    config: import("@rivet-dev/agentos-runtime-core/descriptors").MountConfigJsonValue;
 };

package/dist/generated/ProcessLimitsConfig.d.ts

@@ -0,0 +1,7 @@
+export type ProcessLimitsConfig = {
+    maxSpawnFileActions?: number;
+    maxSpawnFileActionBytes?: number;
+    pendingStdinBytes?: number;
+    pendingEventCount?: number;
+    pendingEventBytes?: number;
+};

package/dist/generated/ProcessLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/ReactorLimitsConfig.d.ts

@@ -0,0 +1,23 @@
+export type ReactorLimitsConfig = {
+    maxCapabilities?: number;
+    maxReadyHandles?: number;
+    maxTasks?: number;
+    workQuantum?: number;
+    byteQuantum?: number;
+    maxHandleCommands?: number;
+    maxHandleCommandBytes?: number;
+    maxBridgeCalls?: number;
+    maxBridgeRequestBytes?: number;
+    maxBridgeResponseBytes?: number;
+    maxAsyncCompletions?: number;
+    maxAsyncCompletionBytes?: number;
+    maxBlockingJobs?: number;
+    maxBlockingBytes?: number;
+    perHandleOperationQuantum?: number;
+    acceptQuantum?: number;
+    datagramQuantum?: number;
+    completionQuantum?: number;
+    signalQuantum?: number;
+    shutdownDeadlineMs?: number;
+    operationDeadlineMs?: number;
+};

package/dist/generated/ReactorLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/SqliteLimitsConfig.d.ts

@@ -0,0 +1,3 @@
+export type SqliteLimitsConfig = {
+    maxResultBytes?: number;
+};

package/dist/generated/SqliteLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/TlsLimitsConfig.d.ts

@@ -0,0 +1,3 @@
+export type TlsLimitsConfig = {
+    maxBufferedBytes?: number;
+};

package/dist/generated/TlsLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/UdpLimitsConfig.d.ts

@@ -0,0 +1,4 @@
+export type UdpLimitsConfig = {
+    maxBufferedDatagrams?: number;
+    maxBufferedBytes?: number;
+};

package/dist/generated/UdpLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmGroupConfig.d.ts

@@ -0,0 +1,5 @@
+export type VmGroupConfig = {
+    gid: number;
+    name: string;
+    members: Array<string>;
+};

package/dist/generated/VmGroupConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmLimitsConfig.d.ts

@@ -1,18 +1,32 @@
 import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
+import type { BindingLimitsConfig } from "./BindingLimitsConfig.js";
+import type { ExecutionLimitsConfig } from "./ExecutionLimitsConfig.js";
+import type { Http2LimitsConfig } from "./Http2LimitsConfig.js";
 import type { HttpLimitsConfig } from "./HttpLimitsConfig.js";
 import type { JsRuntimeLimitsConfig } from "./JsRuntimeLimitsConfig.js";
 import type { PluginLimitsConfig } from "./PluginLimitsConfig.js";
+import type { ProcessLimitsConfig } from "./ProcessLimitsConfig.js";
 import type { PythonLimitsConfig } from "./PythonLimitsConfig.js";
+import type { ReactorLimitsConfig } from "./ReactorLimitsConfig.js";
 import type { ResourceLimitsConfig } from "./ResourceLimitsConfig.js";
-import type { ToolLimitsConfig } from "./ToolLimitsConfig.js";
+import type { SqliteLimitsConfig } from "./SqliteLimitsConfig.js";
+import type { TlsLimitsConfig } from "./TlsLimitsConfig.js";
+import type { UdpLimitsConfig } from "./UdpLimitsConfig.js";
 import type { WasmLimitsConfig } from "./WasmLimitsConfig.js";
 export type VmLimitsConfig = {
+    reactor?: ReactorLimitsConfig;
     resources?: ResourceLimitsConfig;
     http?: HttpLimitsConfig;
-    tools?: ToolLimitsConfig;
+    udp?: UdpLimitsConfig;
+    tls?: TlsLimitsConfig;
+    http2?: Http2LimitsConfig;
+    bindings?: BindingLimitsConfig;
     plugins?: PluginLimitsConfig;
     acp?: AcpLimitsConfig;
+    sqlite?: SqliteLimitsConfig;
     jsRuntime?: JsRuntimeLimitsConfig;
     python?: PythonLimitsConfig;
     wasm?: WasmLimitsConfig;
+    execution?: ExecutionLimitsConfig;
+    process?: ProcessLimitsConfig;
 };

package/dist/generated/VmSqliteDescriptor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transport used by the VM-scoped SQLite substrate.
+ */
+export type VmSqliteDescriptor = {
+    "type": "actor_uds";
+    path: string;
+} | {
+    "type": "sqlite_file";
+    path: string;
+};

package/dist/generated/VmSqliteDescriptor.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmUserAccountConfig.d.ts

@@ -0,0 +1,9 @@
+export type VmUserAccountConfig = {
+    uid: number;
+    gid: number;
+    username: string;
+    homedir: string;
+    shell: string;
+    gecos?: string;
+    supplementaryGids: Array<number>;
+};

package/dist/generated/VmUserAccountConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/VmUserConfig.d.ts

@@ -0,0 +1,19 @@
+import type { VmGroupConfig } from "./VmGroupConfig.js";
+import type { VmUserAccountConfig } from "./VmUserAccountConfig.js";
+/**
+ * Initial Linux-style credentials and account record for processes in a VM.
+ */
+export type VmUserConfig = {
+    uid?: number;
+    gid?: number;
+    euid?: number;
+    egid?: number;
+    username?: string;
+    homedir?: string;
+    shell?: string;
+    gecos?: string;
+    groupName?: string;
+    supplementaryGids?: Array<number>;
+    accounts?: Array<VmUserAccountConfig>;
+    groups?: Array<VmGroupConfig>;
+};

package/dist/generated/VmUserConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/WasmLimitsConfig.d.ts

@@ -4,4 +4,5 @@ export type WasmLimitsConfig = {
     syncReadLimitBytes?: number;
     prewarmTimeoutMs?: number;
     runnerHeapLimitMb?: number;
+    runnerCpuTimeLimitMs?: number;
 };