@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/generated/protocol-types.d.ts

@@ -4,14 +4,9 @@
  */
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "RunProtocolErrorCode".
- */
-export type RunProtocolErrorCode = "PROTOCOL_MODE_INVALID" | "PROTOCOL_MODE_UNSUPPORTED" | "EXECUTION_PROTOCOL_MISMATCH" | "EXECUTION_IDENTITY_CONFLICT" | "NATIVE_METHOD_UNSUPPORTED" | "NATIVE_RESPONSE_INVALID" | "INTERACTION_NOT_ACTIVE" | "HOST_EXECUTION_FAILED" | "HOST_ENDED_WITHOUT_TERMINAL" | "STREAM_GAP" | "STREAM_EXPIRED" | "REMOTE_NATIVE_UNSUPPORTED" | "HOST_FRAME_INVALID" | "HOST_CONTROL_INVALID" | "HOST_RECEIPT_INVALID" | "PROTOCOL_SUPPORT_INVALID";
-/**
- * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "ProtocolMode".
+ * via the `definition` "HostFrame".
  */
-export type ProtocolMode = "native" | "canonical";
+export type HostFrame = NativeHostFrame | CanonicalHostFrame | ControlHostFrame;
 /**
  * Provider-neutral assistant output channel. analysis is reasoning-class content gated by exposure; commentary is public in-run progress; final is answer content delivered only after the Run reaches a completed terminal state.
  *
@@ -26,7 +21,11 @@ export type MessageChannel = "analysis" | "commentary" | "final";
  * via the `definition` "MessageExposure".
  */
 export type MessageExposure = "public_reasoning" | "public_summary" | "public_plan" | "private_reasoning" | "unknown";
-export type ProtocolMode1 = "native" | "canonical";
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "ProtocolMode".
+ */
+export type ProtocolMode = "native" | "canonical";
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
  * via the `definition` "HostControl".
@@ -48,6 +47,7 @@ export type HostControl = {
     type: "error";
     code: RunProtocolErrorCode;
     message: string;
+    failure?: FailureEnvelope;
 } | {
     type: "interaction";
     requestId: string | number;
@@ -61,9 +61,10 @@ export type HostControl = {
 };
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "HostFrame".
+ * via the `definition` "RunProtocolErrorCode".
  */
-export type HostFrame = NativeHostFrame | CanonicalHostFrame | ControlHostFrame;
+export type RunProtocolErrorCode = "PROTOCOL_MODE_INVALID" | "PROTOCOL_MODE_UNSUPPORTED" | "EXECUTION_PROTOCOL_MISMATCH" | "EXECUTION_IDENTITY_CONFLICT" | "NATIVE_METHOD_UNSUPPORTED" | "NATIVE_RESPONSE_INVALID" | "INTERACTION_NOT_ACTIVE" | "HOST_EXECUTION_FAILED" | "HOST_ENDED_WITHOUT_TERMINAL" | "PROVIDER_MESSAGE_TOO_LARGE" | "HOST_FRAME_TOO_LARGE" | "STREAM_QUEUE_ITEM_TOO_LARGE" | "STREAM_QUEUE_BYTES_EXCEEDED" | "STREAM_QUEUE_ITEMS_EXCEEDED" | "STREAM_GAP" | "STREAM_EXPIRED" | "REMOTE_NATIVE_UNSUPPORTED" | "HOST_FRAME_INVALID" | "HOST_CONTROL_INVALID" | "HOST_RECEIPT_INVALID" | "PROTOCOL_SUPPORT_INVALID";
+export type ProtocolMode1 = "native" | "canonical";
 /**
  * Public, channel-neutral project notification. No runtime context, reasoning, credentials, or tool payloads belong in this envelope.
  *
@@ -297,6 +298,76 @@ export type ContextReferenceEntry = {
  */
 export interface OctoRuntimeProtocolSchema {
 }
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "KernelLookupKey".
+ */
+export interface KernelLookupKey {
+    run_id: string;
+    invocation_id: string;
+    agent_session_id: string;
+    session_generation: number;
+    protocol_mode: "canonical" | "native";
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "KernelRunRef".
+ */
+export interface KernelRunRef {
+    kernel_instance_id: string;
+    run_id: string;
+    invocation_id: string;
+    stream_id: string;
+    agent_session_id: string;
+    session_generation: number;
+    protocol_mode: "canonical" | "native";
+    protocol: string;
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "KernelRunSnapshot".
+ */
+export interface KernelRunSnapshot {
+    ref: KernelRunRef;
+    oldest_seq: number;
+    latest_seq: number;
+    terminal?: HostFrame;
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "NativeHostFrame".
+ */
+export interface NativeHostFrame {
+    run_id: string;
+    invocation_id: string;
+    stream_id: string;
+    agent_session_id: string;
+    session_generation: number;
+    seq: number;
+    protocol_mode: "native";
+    protocol: string;
+    kind: "native";
+    messageKind: "response" | "notification" | "request" | "message";
+    payload: {
+        [k: string]: unknown;
+    };
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "CanonicalHostFrame".
+ */
+export interface CanonicalHostFrame {
+    run_id: string;
+    invocation_id: string;
+    stream_id: string;
+    agent_session_id: string;
+    session_generation: number;
+    seq: number;
+    protocol_mode: "canonical";
+    protocol: string;
+    kind: "canonical";
+    event: CanonicalEventWire;
+}
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
  * via the `definition` "CanonicalEventWire".
@@ -452,46 +523,19 @@ export interface FailureCause {
 }
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "HostInvokeOptions".
- */
-export interface HostInvokeOptions {
-    protocolMode?: ProtocolMode1;
-    protocol?: string;
-}
-/**
- * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "HostRunReceipt".
+ * via the `definition` "ControlHostFrame".
  */
-export interface HostRunReceipt {
+export interface ControlHostFrame {
     run_id: string;
     invocation_id: string;
     stream_id: string;
     agent_session_id: string;
     session_generation: number;
+    seq: number;
     protocol_mode: ProtocolMode;
     protocol: string;
-}
-/**
- * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "AdapterProtocolSupport".
- */
-export interface AdapterProtocolSupport {
-    protocol: string;
-    /**
-     * @minItems 1
-     */
-    modes: [ProtocolMode, ...ProtocolMode[]];
-    nativeMethods: string[];
-}
-/**
- * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "NativeInteractionResponse".
- */
-export interface NativeInteractionResponse {
-    requestId: string | number;
-    payload: {
-        [k: string]: unknown;
-    };
+    kind: "control";
+    control: HostControl;
 }
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
@@ -508,54 +552,62 @@ export interface ExecutionEvidence {
 }
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "NativeHostFrame".
+ * via the `definition` "KernelStatus".
  */
-export interface NativeHostFrame {
-    run_id: string;
-    invocation_id: string;
-    stream_id: string;
-    agent_session_id: string;
-    session_generation: number;
-    seq: number;
-    protocol_mode: "native";
-    protocol: string;
-    kind: "native";
-    messageKind: "response" | "notification" | "request" | "message";
-    payload: {
-        [k: string]: unknown;
+export interface KernelStatus {
+    ipc_version: 1;
+    kernel_instance_id: string;
+    pid: number;
+    execution_ready: boolean;
+    worker: {
+        pid?: number;
+        generation: number;
+        restart_attempt: number;
+        state: "starting" | "ready" | "recovering" | "stopped" | "exhausted";
     };
 }
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "CanonicalHostFrame".
+ * via the `definition` "HostInvokeOptions".
  */
-export interface CanonicalHostFrame {
-    run_id: string;
-    invocation_id: string;
-    stream_id: string;
-    agent_session_id: string;
-    session_generation: number;
-    seq: number;
-    protocol_mode: "canonical";
-    protocol: string;
-    kind: "canonical";
-    event: CanonicalEventWire;
+export interface HostInvokeOptions {
+    protocolMode?: ProtocolMode1;
+    protocol?: string;
 }
 /**
  * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
- * via the `definition` "ControlHostFrame".
+ * via the `definition` "HostRunReceipt".
  */
-export interface ControlHostFrame {
+export interface HostRunReceipt {
     run_id: string;
     invocation_id: string;
     stream_id: string;
     agent_session_id: string;
     session_generation: number;
-    seq: number;
     protocol_mode: ProtocolMode;
     protocol: string;
-    kind: "control";
-    control: HostControl;
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "AdapterProtocolSupport".
+ */
+export interface AdapterProtocolSupport {
+    protocol: string;
+    /**
+     * @minItems 1
+     */
+    modes: [ProtocolMode, ...ProtocolMode[]];
+    nativeMethods: string[];
+}
+/**
+ * This interface was referenced by `OctoRuntimeProtocolSchema`'s JSON-Schema
+ * via the `definition` "NativeInteractionResponse".
+ */
+export interface NativeInteractionResponse {
+    requestId: string | number;
+    payload: {
+        [k: string]: unknown;
+    };
 }
 export interface NotificationMessage1 {
     schema: "octo.notification.v2";

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { assertJsonByteLimit } from "./json-size.js";
 export { INVOKE_REQUEST_MAX_BYTES, assertInvokeRequestSize } from "./invoke-size.js";
+export * from "./stream-limits.js";
 export * from "./run-protocol.js";
+export type { KernelLookupKey, KernelRunRef, KernelRunSnapshot, KernelStatus } from "./generated/protocol-types.js";
 export * from "./invoke-input.js";
 export * from "./model-context.js";
 export * from "./execution-plan.js";

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/index.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 export { assertJsonByteLimit } from "./json-size.js";
 export { INVOKE_REQUEST_MAX_BYTES, assertInvokeRequestSize } from "./invoke-size.js";
+export * from "./stream-limits.js";
 export * from "./run-protocol.js";
 export * from "./invoke-input.js";
 export * from "./model-context.js";

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-input.d.ts

@@ -1,4 +1,5 @@
 import { type AgentConfig, type AgentSource, type ApprovalMode, type CanonicalEvent, type ContextEnvelope, type ContextEnvsPayload, type HostFrame, type InvokeRequest, type ModelInputPart, type ProviderSession, type RuntimeLimits } from "./index.js";
+import type { StreamLimitPolicy } from "./stream-limits.js";
 /**
  * Public JSON invocation contract shared by CLI, SDK and channels.
  * A plain JSON object satisfies this class structurally; `new` is not required.
@@ -58,6 +59,8 @@ export interface InvokeEnvironment {
     signal?: AbortSignal;
     /** Trusted per-invocation values; forwarded privately across the Host process boundary. */
     executionEnvOverrides?: ContextEnvsPayload;
+    /** Trusted transport and replay budgets; never sourced from caller Context. */
+    streamLimits?: StreamLimitPolicy;
 }
 export type InputFrames = (input: InvokeInput, environment?: InvokeEnvironment) => AsyncGenerator<HostFrame>;
 /** Stable correlation IDs for cancellation and stream reconnection, without resolving execution. */

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-input.js

@@ -30,15 +30,12 @@ export function createInputInvoke(source) {
     return async function* (input, environment) {
         environment?.signal?.throwIfAborted();
         const frames = source(input, environment);
-        try {
-            if (input.protocol_mode === "canonical")
-                yield* canonicalEvents(frames);
-            else
-                yield* frames;
-        }
-        finally {
-            environment?.signal?.throwIfAborted();
-        }
+        if (input.protocol_mode === "canonical")
+            yield* canonicalEvents(frames);
+        else
+            yield* frames;
+        // Only normal exhaustion reports local abort; never replace a source error or iterator return.
+        environment?.signal?.throwIfAborted();
     };
 }
 export function assertInvokeInput(value) {

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-size.js

@@ -5,6 +5,7 @@ export function assertInvokeRequestSize(input, environment = {}) {
         input: { ...input },
         ...(environment.executionEnvOverrides
             ? { executionEnvOverrides: environment.executionEnvOverrides }
-            : {})
+            : {}),
+        ...(environment.streamLimits ? { streamLimits: environment.streamLimits } : {})
     }, INVOKE_REQUEST_MAX_BYTES, "INVOKE_REQUEST_TOO_LARGE");
 }

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/run-protocol.d.ts

@@ -1,7 +1,7 @@
 import { type CanonicalEvent } from "./index.js";
 import type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport } from "./generated/protocol-types.js";
 export type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport };
-export declare const RUN_PROTOCOL_ERRORS: readonly ["PROTOCOL_MODE_INVALID", "PROTOCOL_MODE_UNSUPPORTED", "EXECUTION_PROTOCOL_MISMATCH", "EXECUTION_IDENTITY_CONFLICT", "NATIVE_METHOD_UNSUPPORTED", "NATIVE_RESPONSE_INVALID", "INTERACTION_NOT_ACTIVE", "HOST_EXECUTION_FAILED", "HOST_ENDED_WITHOUT_TERMINAL", "STREAM_GAP", "STREAM_EXPIRED", "REMOTE_NATIVE_UNSUPPORTED", "HOST_FRAME_INVALID", "HOST_CONTROL_INVALID", "HOST_RECEIPT_INVALID", "PROTOCOL_SUPPORT_INVALID"];
+export declare const RUN_PROTOCOL_ERRORS: readonly ["PROTOCOL_MODE_INVALID", "PROTOCOL_MODE_UNSUPPORTED", "EXECUTION_PROTOCOL_MISMATCH", "EXECUTION_IDENTITY_CONFLICT", "NATIVE_METHOD_UNSUPPORTED", "NATIVE_RESPONSE_INVALID", "INTERACTION_NOT_ACTIVE", "HOST_EXECUTION_FAILED", "HOST_ENDED_WITHOUT_TERMINAL", "PROVIDER_MESSAGE_TOO_LARGE", "HOST_FRAME_TOO_LARGE", "STREAM_QUEUE_ITEM_TOO_LARGE", "STREAM_QUEUE_BYTES_EXCEEDED", "STREAM_QUEUE_ITEMS_EXCEEDED", "STREAM_GAP", "STREAM_EXPIRED", "REMOTE_NATIVE_UNSUPPORTED", "HOST_FRAME_INVALID", "HOST_CONTROL_INVALID", "HOST_RECEIPT_INVALID", "PROTOCOL_SUPPORT_INVALID"];
 export declare function protocolError(code: (typeof RUN_PROTOCOL_ERRORS)[number], message?: string): Error & {
     code: (typeof RUN_PROTOCOL_ERRORS)[number];
 };

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/run-protocol.js

@@ -1,6 +1,8 @@
 import { assertJsonValue } from "./context.js";
 import { assertExecutionEvidence } from "./actmode.js";
-import { assertCanonicalEvent } from "./index.js";
+import { assertCanonicalEvent, assertFailureEnvelope } from "./index.js";
+import { safeCapacityEvidence } from "./failure.js";
+import { isStreamCapacityReason } from "./stream-limits.js";
 export const RUN_PROTOCOL_ERRORS = [
     "PROTOCOL_MODE_INVALID",
     "PROTOCOL_MODE_UNSUPPORTED",
@@ -11,6 +13,11 @@ export const RUN_PROTOCOL_ERRORS = [
     "INTERACTION_NOT_ACTIVE",
     "HOST_EXECUTION_FAILED",
     "HOST_ENDED_WITHOUT_TERMINAL",
+    "PROVIDER_MESSAGE_TOO_LARGE",
+    "HOST_FRAME_TOO_LARGE",
+    "STREAM_QUEUE_ITEM_TOO_LARGE",
+    "STREAM_QUEUE_BYTES_EXCEEDED",
+    "STREAM_QUEUE_ITEMS_EXCEEDED",
     "STREAM_GAP",
     "STREAM_EXPIRED",
     "REMOTE_NATIVE_UNSUPPORTED",
@@ -110,10 +117,42 @@ export function assertHostControl(value) {
         ["running", "completed", "failed", "cancelled", "lost"].includes(String(value.state)))
         return;
     if (value.type === "error" &&
-        exactKeys(value, ["type", "code", "message"]) &&
+        exactKeys(value, ["type", "code", "message"], ["failure"]) &&
         RUN_PROTOCOL_ERRORS.some((code) => code === value.code) &&
-        typeof value.message === "string")
+        typeof value.message === "string") {
+        if (Object.hasOwn(value, "failure")) {
+            try {
+                assertFailureEnvelope(value.failure);
+                const evidence = safeCapacityEvidence(value.failure.params);
+                if (!isStreamCapacityReason(value.code) ||
+                    value.failure.reasonCode !== value.code ||
+                    !exactKeys(value.failure, [
+                        "schemaVersion",
+                        "code",
+                        "reasonCode",
+                        "category",
+                        "stage",
+                        "messageKey",
+                        "params",
+                        "retryable",
+                        "action",
+                        "diagnosticId",
+                        "source",
+                        "occurredAt"
+                    ], ["retryAfterMs", "cause"]) ||
+                    !exactKeys(value.failure.source, ["component"], ["adapter"]) ||
+                    !exactKeys(value.failure.action, ["type", "labelKey"]) ||
+                    (value.failure.cause !== undefined &&
+                        !exactKeys(value.failure.cause, ["reasonCode"], ["httpStatus"])) ||
+                    Object.entries(value.failure.params).some(([key, entry]) => evidence[key] !== entry))
+                    throw protocolError("HOST_CONTROL_INVALID");
+            }
+            catch {
+                throw protocolError("HOST_CONTROL_INVALID");
+            }
+        }
         return;
+    }
     if (value.type === "interaction" &&
         exactKeys(value, ["type", "requestId", "status"], ["expiresAt"]) &&
         requestId(value.requestId) &&
@@ -206,7 +245,15 @@ export async function* canonicalEvents(frames) {
         else if (frame.kind === "control" && frame.control.type === "gap")
             throw protocolError("STREAM_GAP");
         else if (frame.kind === "control" && frame.control.type === "error")
-            throw Object.assign(new Error(frame.control.message), { code: frame.control.code });
+            throw Object.assign(new Error(frame.control.message), {
+                code: frame.control.code,
+                ...(frame.control.failure
+                    ? {
+                        ...safeCapacityEvidence(frame.control.failure.params),
+                        failure: frame.control.failure
+                    }
+                    : {})
+            });
     }
 }
 function validIdentity(value) {

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/stream-limits.d.ts

@@ -0,0 +1,27 @@
+export interface StreamLimitPolicy {
+    rawMessageMaxBytes: number;
+    adapterQueueItemMaxBytes: number;
+    adapterQueueMaxBytes: number;
+    adapterQueueMaxItems: number;
+    hostFrameMaxBytes: number;
+    rpcQueueMaxBytes: number;
+    rpcQueueMaxItems: number;
+    replayRunMaxBytes: number;
+    replayRunMaxItems: number;
+    replayGlobalMaxBytes: number;
+}
+export type StreamLimitOverrides = Partial<StreamLimitPolicy>;
+export declare const DEFAULT_STREAM_LIMIT_POLICY: Readonly<StreamLimitPolicy>;
+export declare const MAX_STREAM_LIMIT_POLICY: Readonly<StreamLimitPolicy>;
+export declare const HOST_RPC_MAX_LINE_BYTES: number;
+export declare function resolveStreamLimitPolicy(overrides: StreamLimitOverrides | undefined): Readonly<StreamLimitPolicy>;
+export declare const STREAM_CAPACITY_REASONS: readonly ["PROVIDER_MESSAGE_TOO_LARGE", "HOST_FRAME_TOO_LARGE", "STREAM_QUEUE_ITEM_TOO_LARGE", "STREAM_QUEUE_BYTES_EXCEEDED", "STREAM_QUEUE_ITEMS_EXCEEDED"];
+export type StreamCapacityReason = (typeof STREAM_CAPACITY_REASONS)[number];
+export declare function isStreamCapacityReason(value: unknown): value is StreamCapacityReason;
+export declare function streamCapacityError(code: StreamCapacityReason, detail: {
+    boundary: string;
+    measuredBytes?: number;
+    limitBytes?: number;
+    itemCount?: number;
+    limitItems?: number;
+}): Error;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/stream-limits.js

@@ -0,0 +1,56 @@
+const MIB = 1024 * 1024;
+export const DEFAULT_STREAM_LIMIT_POLICY = Object.freeze({
+    rawMessageMaxBytes: 16 * MIB,
+    adapterQueueItemMaxBytes: 20 * MIB,
+    adapterQueueMaxBytes: 32 * MIB,
+    adapterQueueMaxItems: 4096,
+    hostFrameMaxBytes: 20 * MIB,
+    rpcQueueMaxBytes: 32 * MIB,
+    rpcQueueMaxItems: 4096,
+    replayRunMaxBytes: 32 * MIB,
+    replayRunMaxItems: 4096,
+    replayGlobalMaxBytes: 128 * MIB
+});
+export const MAX_STREAM_LIMIT_POLICY = Object.freeze(Object.fromEntries(Object.entries(DEFAULT_STREAM_LIMIT_POLICY).map(([key, value]) => [key, value * 2])));
+export const HOST_RPC_MAX_LINE_BYTES = MAX_STREAM_LIMIT_POLICY.hostFrameMaxBytes + 64 * 1024;
+export function resolveStreamLimitPolicy(overrides) {
+    if (overrides !== undefined &&
+        (overrides === null || typeof overrides !== "object" || Array.isArray(overrides)))
+        throw new TypeError("stream_limits must be an object");
+    const fields = new Set(Object.keys(DEFAULT_STREAM_LIMIT_POLICY));
+    for (const key of Object.keys(overrides ?? {})) {
+        if (!fields.has(key))
+            throw new TypeError(`unknown stream_limits.${key}`);
+    }
+    const policy = { ...DEFAULT_STREAM_LIMIT_POLICY, ...(overrides ?? {}) };
+    for (const key of Object.keys(DEFAULT_STREAM_LIMIT_POLICY)) {
+        const value = policy[key];
+        if (!Number.isSafeInteger(value) || value < 1 || value > MAX_STREAM_LIMIT_POLICY[key]) {
+            throw new TypeError(`invalid stream_limits.${key}`);
+        }
+    }
+    if (policy.rawMessageMaxBytes > policy.adapterQueueItemMaxBytes)
+        throw new TypeError("stream_limits.rawMessageMaxBytes exceeds adapterQueueItemMaxBytes");
+    if (policy.adapterQueueItemMaxBytes > policy.adapterQueueMaxBytes)
+        throw new TypeError("stream_limits.adapterQueueItemMaxBytes exceeds adapterQueueMaxBytes");
+    if (policy.hostFrameMaxBytes > policy.rpcQueueMaxBytes)
+        throw new TypeError("stream_limits.hostFrameMaxBytes exceeds rpcQueueMaxBytes");
+    if (policy.hostFrameMaxBytes > policy.replayRunMaxBytes)
+        throw new TypeError("stream_limits.hostFrameMaxBytes exceeds replayRunMaxBytes");
+    if (policy.replayRunMaxBytes > policy.replayGlobalMaxBytes)
+        throw new TypeError("stream_limits.replayRunMaxBytes exceeds replayGlobalMaxBytes");
+    return Object.freeze(policy);
+}
+export const STREAM_CAPACITY_REASONS = [
+    "PROVIDER_MESSAGE_TOO_LARGE",
+    "HOST_FRAME_TOO_LARGE",
+    "STREAM_QUEUE_ITEM_TOO_LARGE",
+    "STREAM_QUEUE_BYTES_EXCEEDED",
+    "STREAM_QUEUE_ITEMS_EXCEEDED"
+];
+export function isStreamCapacityReason(value) {
+    return STREAM_CAPACITY_REASONS.includes(value);
+}
+export function streamCapacityError(code, detail) {
+    return Object.assign(new Error(code), { code, ...detail });
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-protocol",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/ws/lib/websocket.js

@@ -75,11 +75,24 @@ class WebSocket extends EventEmitter {
       this._redirects = 0;
 
       if (protocols === undefined) {
-        protocols = [];
+        if (!options || options.protocols === undefined) {
+          protocols = [];
+        } else if (Array.isArray(options.protocols)) {
+          protocols = options.protocols;
+        } else {
+          protocols = [options.protocols];
+        }
       } else if (!Array.isArray(protocols)) {
         if (typeof protocols === 'object' && protocols !== null) {
           options = protocols;
-          protocols = [];
+
+          if (options.protocols === undefined) {
+            protocols = [];
+          } else if (Array.isArray(options.protocols)) {
+            protocols = options.protocols;
+          } else {
+            protocols = [options.protocols];
+          }
         } else {
           protocols = [protocols];
         }
@@ -318,7 +331,6 @@ class WebSocket extends EventEmitter {
       return;
     }
 
-    this._readyState = WebSocket.CLOSING;
     this._sender.close(code, data, !this._isServer, (err) => {
       //
       // This error is handled by the `'error'` listener on the socket. We only
@@ -336,6 +348,7 @@ class WebSocket extends EventEmitter {
       }
     });
 
+    this._readyState = WebSocket.CLOSING;
     setCloseTimer(this);
   }
 
@@ -681,6 +694,7 @@ function initAsClient(websocket, address, protocols, options) {
     socketPath: undefined,
     hostname: undefined,
     protocol: undefined,
+    protocols: undefined,
     timeout: undefined,
     method: 'GET',
     host: undefined,

package/node_modules/ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ws",
-  "version": "8.21.3",
+  "version": "8.22.0",
   "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
   "keywords": [
     "HyBi",