@rivet-dev/agentos-runtime-core 0.2.8-rc.1 → 0.2.8-rc.3

package/dist/frame-stream.js

@@ -1,4 +1,117 @@
 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;

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/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,30 @@
 import type { AcpLimitsConfig } from "./AcpLimitsConfig.js";
+import type { BindingLimitsConfig } from "./BindingLimitsConfig.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;
+    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;
 };

package/dist/generated-protocol.d.ts

@@ -241,11 +241,20 @@ export declare function readMountPluginDescriptor(bc: bare.ByteCursor): MountPlu
 export declare function writeMountPluginDescriptor(bc: bare.ByteCursor, x: MountPluginDescriptor): void;
 export type MountDescriptor = {
     readonly guestPath: string;
+    readonly guestSource: string;
+    readonly guestFstype: string;
     readonly readOnly: boolean;
     readonly plugin: MountPluginDescriptor;
 };
 export declare function readMountDescriptor(bc: bare.ByteCursor): MountDescriptor;
 export declare function writeMountDescriptor(bc: bare.ByteCursor, x: MountDescriptor): void;
+export type MountInfo = {
+    readonly path: string;
+    readonly kind: string;
+    readonly readOnly: boolean;
+};
+export declare function readMountInfo(bc: bare.ByteCursor): MountInfo;
+export declare function writeMountInfo(bc: bare.ByteCursor, x: MountInfo): void;
 export type SoftwareDescriptor = {
     readonly packageName: string;
     readonly root: string;
@@ -330,7 +339,7 @@ export type ConfigureVmRequest = {
     readonly packages: readonly PackageDescriptor[];
     readonly packagesMountAt: string;
     readonly bootstrapCommands: readonly string[];
-    readonly toolShimCommands: readonly string[];
+    readonly bindingShimCommands: readonly string[];
 };
 export declare function readConfigureVmRequest(bc: bare.ByteCursor): ConfigureVmRequest;
 export declare function writeConfigureVmRequest(bc: bare.ByteCursor, x: ConfigureVmRequest): void;
@@ -435,7 +444,12 @@ export type GuestKernelCallRequest = {
 };
 export declare function readGuestKernelCallRequest(bc: bare.ByteCursor): GuestKernelCallRequest;
 export declare function writeGuestKernelCallRequest(bc: bare.ByteCursor, x: GuestKernelCallRequest): void;
-export type SnapshotRootFilesystemRequest = null;
+export type SnapshotRootFilesystemRequest = {
+    readonly maxBytes: u64;
+};
+export declare function readSnapshotRootFilesystemRequest(bc: bare.ByteCursor): SnapshotRootFilesystemRequest;
+export declare function writeSnapshotRootFilesystemRequest(bc: bare.ByteCursor, x: SnapshotRootFilesystemRequest): void;
+export type ListMountsRequest = null;
 export type ExecuteRequest = {
     readonly processId: string;
     readonly command: string | null;
@@ -630,6 +644,9 @@ export type RequestPayload = {
 } | {
     readonly tag: "ProvidedCommandsRequest";
     readonly val: ProvidedCommandsRequest;
+} | {
+    readonly tag: "ListMountsRequest";
+    readonly val: ListMountsRequest;
 };
 export declare function readRequestPayload(bc: bare.ByteCursor): RequestPayload;
 export declare function writeRequestPayload(bc: bare.ByteCursor, x: RequestPayload): void;
@@ -759,6 +776,11 @@ export type RootFilesystemSnapshotResponse = {
 };
 export declare function readRootFilesystemSnapshotResponse(bc: bare.ByteCursor): RootFilesystemSnapshotResponse;
 export declare function writeRootFilesystemSnapshotResponse(bc: bare.ByteCursor, x: RootFilesystemSnapshotResponse): void;
+export type ListMountsResponse = {
+    readonly mounts: readonly MountInfo[];
+};
+export declare function readListMountsResponse(bc: bare.ByteCursor): ListMountsResponse;
+export declare function writeListMountsResponse(bc: bare.ByteCursor, x: ListMountsResponse): void;
 export type ProcessStartedResponse = {
     readonly processId: string;
     readonly pid: u32 | null;
@@ -916,6 +938,19 @@ export declare function writePersistenceFlushedResponse(bc: bare.ByteCursor, x:
 export type RejectedResponse = {
     readonly code: string;
     readonly message: string;
+    readonly limitName: string | null;
+    readonly configuredLimit: u64 | null;
+    readonly currentUsage: u64 | null;
+    readonly requested: u64 | null;
+    readonly unit: string | null;
+    readonly scope: string | null;
+    readonly vmId: string | null;
+    readonly sessionGeneration: u64 | null;
+    readonly capabilityId: u64 | null;
+    readonly operation: string | null;
+    readonly configurationPath: string | null;
+    readonly retryable: boolean | null;
+    readonly errno: string | null;
 };
 export declare function readRejectedResponse(bc: bare.ByteCursor): RejectedResponse;
 export declare function writeRejectedResponse(bc: bare.ByteCursor, x: RejectedResponse): void;
@@ -1029,6 +1064,9 @@ export type ResponsePayload = {
 } | {
     readonly tag: "ProvidedCommandsResponse";
     readonly val: ProvidedCommandsResponse;
+} | {
+    readonly tag: "ListMountsResponse";
+    readonly val: ListMountsResponse;
 };
 export declare function readResponsePayload(bc: bare.ByteCursor): ResponsePayload;
 export declare function writeResponsePayload(bc: bare.ByteCursor, x: ResponsePayload): void;
@@ -1174,6 +1212,23 @@ export type SidecarResponseFrame = {
 };
 export declare function readSidecarResponseFrame(bc: bare.ByteCursor): SidecarResponseFrame;
 export declare function writeSidecarResponseFrame(bc: bare.ByteCursor, x: SidecarResponseFrame): void;
+export type ShutdownControl = {
+    readonly reason: string;
+};
+export declare function readShutdownControl(bc: bare.ByteCursor): ShutdownControl;
+export declare function writeShutdownControl(bc: bare.ByteCursor, x: ShutdownControl): void;
+export type ControlPayload = {
+    readonly tag: "ShutdownControl";
+    readonly val: ShutdownControl;
+};
+export declare function readControlPayload(bc: bare.ByteCursor): ControlPayload;
+export declare function writeControlPayload(bc: bare.ByteCursor, x: ControlPayload): void;
+export type ControlFrame = {
+    readonly schema: ProtocolSchema;
+    readonly payload: ControlPayload;
+};
+export declare function readControlFrame(bc: bare.ByteCursor): ControlFrame;
+export declare function writeControlFrame(bc: bare.ByteCursor, x: ControlFrame): void;
 export type ProtocolFrame = {
     readonly tag: "RequestFrame";
     readonly val: RequestFrame;
@@ -1189,6 +1244,9 @@ export type ProtocolFrame = {
 } | {
     readonly tag: "SidecarResponseFrame";
     readonly val: SidecarResponseFrame;
+} | {
+    readonly tag: "ControlFrame";
+    readonly val: ControlFrame;
 };
 export declare function readProtocolFrame(bc: bare.ByteCursor): ProtocolFrame;
 export declare function writeProtocolFrame(bc: bare.ByteCursor, x: ProtocolFrame): void;