@mininglamp-oss/octo-runtime 1.0.0 → 1.0.1

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

@@ -7,7 +7,7 @@ export { HostRunService } from "./host-run-service.js";
 export { readAdapterConfigurations } from "./runtime-configuration.js";
 export { startHostSocketServer, streamHostRun } from "./socket-server.js";
 export { prepareRunContext } from "./execution-preparation.js";
-import { createInputInvoke, assertInvokeRequestSize, assertProtocolSupport, assertAdapterProtocolSupport, assertHostFrame, assertHostFrameIdentity, assertNativeInteractionResponse, resolveHostInvokeOptions, protocolError, assertCanonicalEvent, assertInteractionResponse, assertInvokeRequest, failurePayload, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { createInputInvoke, assertInvokeRequestSize, assertProtocolSupport, assertAdapterProtocolSupport, assertHostFrame, assertHostFrameIdentity, assertNativeInteractionResponse, resolveHostInvokeOptions, protocolError, assertCanonicalEvent, assertInteractionResponse, assertInvokeRequest, failurePayload, isStreamCapacityReason, resolveStreamLimitPolicy, streamCapacityError, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
 import { InvocationExperience } from "./experience.js";
 import { withModelContexts } from "./model-input.js";
 import { noopRuntimeLog } from "@mininglamp-oss/octo-runtime-adapter-sdk";
@@ -188,7 +188,7 @@ export class AdapterHost {
             });
             const frozenRequest = withModelContexts({ ...run.request, signal: request.signal });
             run.request = undefined;
-            return this.#streamInvocation(adapterType, frozenRequest, receipt);
+            return this.#streamInvocation(adapterType, frozenRequest, receipt, resolveStreamLimitPolicy(environment.streamLimits));
         }
         catch (error) {
             this.#log("warn", "invoke.rejected", {
@@ -198,7 +198,7 @@ export class AdapterHost {
             throw error;
         }
     }
-    async *#streamInvocation(adapterType, request, receipt) {
+    async *#streamInvocation(adapterType, request, receipt, streamLimits) {
         const started = Date.now();
         const identity = {
             run_id: request.runId,
@@ -221,8 +221,12 @@ export class AdapterHost {
             assertHostFrame(result);
             assertHostFrameIdentity(result, receipt);
             const size = Buffer.byteLength(JSON.stringify(result));
-            if (size > 256 * 1024)
-                throw new Error("STREAM_EVENT_TOO_LARGE");
+            if (size > streamLimits.hostFrameMaxBytes)
+                throw streamCapacityError("HOST_FRAME_TOO_LARGE", {
+                    boundary: "adapter_host.frame",
+                    measuredBytes: size,
+                    limitBytes: streamLimits.hostFrameMaxBytes
+                });
             seq++;
             return result;
         };
@@ -230,8 +234,8 @@ export class AdapterHost {
         let failureCode;
         const pendingInteractions = new Set();
         const source = receipt.protocol_mode === "canonical"
-            ? this.#invokeCanonical(adapterType, request)
-            : this.#invokeProvider(adapterType, request, "native");
+            ? this.#invokeCanonical(adapterType, request, streamLimits)
+            : this.#invokeProvider(adapterType, request, "native", streamLimits);
         try {
             yield frame({ kind: "control", control: { type: "state", state: "running" } });
             let pending = source.next();
@@ -298,6 +302,17 @@ export class AdapterHost {
             this.#active.get(request.invocationId)?.abort(error);
             await source.return(undefined);
             state = { type: "state", state: "failed" };
+            const causeCode = errorCode(error);
+            const controlCode = isStreamCapacityReason(causeCode) ? causeCode : "HOST_FRAME_INVALID";
+            failureCode = controlCode;
+            const failure = isStreamCapacityReason(causeCode)
+                ? failurePayload({ code: causeCode, ...capacityFailureDetails(error) }, {
+                    stage: "adapter_host.frame",
+                    defaultDomain: "adapter",
+                    runId: request.runId,
+                    source: { component: "octo-runtime", adapter: adapterType }
+                }).failure
+                : undefined;
             for (const requestId of pendingInteractions)
                 yield {
                     ...receipt,
@@ -311,8 +326,9 @@ export class AdapterHost {
                 seq: ++seq,
                 control: {
                     type: "error",
-                    code: "HOST_FRAME_INVALID",
-                    message: "Host output violated the selected stream contract"
+                    code: controlCode,
+                    message: "Host output violated the selected stream contract",
+                    ...(failure ? { failure } : {})
                 }
             };
             yield { ...receipt, kind: "control", seq: ++seq, control: state };
@@ -339,9 +355,9 @@ export class AdapterHost {
             }
         }
     }
-    async *#invokeCanonical(adapterType, request) {
+    async *#invokeCanonical(adapterType, request, streamLimits) {
         const experience = new InvocationExperience();
-        const provider = this.#invokeProvider(adapterType, request);
+        const provider = this.#invokeProvider(adapterType, request, "canonical", streamLimits);
         let pending = provider.next();
         void pending.catch(() => undefined);
         let finalBody = false;
@@ -386,7 +402,7 @@ export class AdapterHost {
             await provider.return(undefined);
         }
     }
-    async *#invokeProvider(adapterType, request, protocolMode = "canonical") {
+    async *#invokeProvider(adapterType, request, protocolMode = "canonical", streamLimits = resolveStreamLimitPolicy(undefined)) {
         this.#log("info", "invoke.started", {
             run_id: request.runId,
             invocation_id: request.invocationId,
@@ -435,6 +451,7 @@ export class AdapterHost {
         let messageNumber = 0;
         const context = {
             protocolMode,
+            streamLimits,
             reportConversion: () => {
                 if (protocolMode === "native")
                     throw protocolError("EXECUTION_PROTOCOL_MISMATCH", "Native execution invoked a canonical converter");
@@ -634,6 +651,7 @@ export class AdapterHost {
                 message: errorMessage(error),
                 adapterType,
                 ...(errorCode(error) ? { code: errorCode(error) } : {}),
+                ...capacityFailureDetails(error),
                 ...watchdogFailureDetails(error)
             }, request.workdir, {
                 stage: "adapter.invoke",
@@ -661,17 +679,19 @@ export class AdapterHost {
                 controller.abort(error);
             await waitCleanup().catch(() => undefined);
             if (protocolMode === "native") {
+                const nativeFailureCode = errorCode(error);
                 if (!userCancelled)
                     yield {
                         kind: "control",
                         control: {
                             type: "error",
-                            code: error instanceof Error &&
-                                "code" in error &&
-                                error.code === "HOST_ENDED_WITHOUT_TERMINAL"
+                            code: nativeFailureCode === "HOST_ENDED_WITHOUT_TERMINAL"
                                 ? "HOST_ENDED_WITHOUT_TERMINAL"
-                                : "HOST_EXECUTION_FAILED",
-                            message: String(failure.message)
+                                : isStreamCapacityReason(nativeFailureCode)
+                                    ? nativeFailureCode
+                                    : "HOST_EXECUTION_FAILED",
+                            message: String(failure.message),
+                            ...(isStreamCapacityReason(nativeFailureCode) ? { failure: failure.failure } : {})
                         }
                     };
                 yield {
@@ -843,6 +863,14 @@ function errorCode(error) {
         ? error.code
         : undefined;
 }
+function capacityFailureDetails(error) {
+    if (!error || typeof error !== "object")
+        return {};
+    const input = error;
+    return Object.fromEntries(["boundary", "measuredBytes", "limitBytes", "itemCount", "limitItems"]
+        .filter((key) => Object.hasOwn(input, key))
+        .map((key) => [key, input[key]]));
+}
 async function waitForNext(pending, signal) {
     let onAbort = () => { };
     try {

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/rpc.d.ts

@@ -37,10 +37,11 @@ export declare class AdapterHostRpcServer {
 export declare class AdapterHostRpcClient implements AdapterHostRpc {
     #private;
     readonly invoke: InputInvoke;
-    constructor({ input, output, trace }: {
+    constructor({ input, output, trace, maximumInputBytes }: {
         input: Readable;
         output: Writable;
         trace?: RpcTrace;
+        maximumInputBytes?: number;
     });
     /** Send an ordinary JSON-RPC request and await the matching response by random ID. */
     request<T = unknown>(method: string, params?: JsonRecord, signal?: AbortSignal): Promise<T>;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/rpc.js

@@ -1,27 +1,51 @@
 import { createInterface } from "node:readline";
 import { randomUUID } from "node:crypto";
 import { watchLineLimit, readBoundedLines } from "@mininglamp-oss/octo-runtime-adapter-sdk";
-import { createInputInvoke, INVOKE_REQUEST_MAX_BYTES, assertJsonByteLimit, assertHostFrame, assertHostRunReceipt, assertHostFrameIdentity, isHostTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { createInputInvoke, HOST_RPC_MAX_LINE_BYTES, INVOKE_REQUEST_MAX_BYTES, resolveStreamLimitPolicy, streamCapacityError, assertJsonByteLimit, assertHostFrame, assertHostRunReceipt, assertHostFrameIdentity, isHostTerminal } from "@mininglamp-oss/octo-runtime-protocol";
 /** A single-consumer async queue: producers `push`, one consumer iterates, and `close` ends the stream (optionally with an error). */
 class AsyncQueue {
+    limits;
     #items = [];
     #bytes = 0;
     #waiters = [];
     #closed = false;
     #error;
+    constructor(limits) {
+        this.limits = limits;
+    }
     push(value) {
         if (this.#closed)
             return;
         const bytes = Buffer.byteLength(JSON.stringify(value));
-        if (bytes > 256 * 1024 || this.#items.length >= 4096 || this.#bytes + bytes > 4 * 1024 * 1024) {
-            this.close(new Error("STREAM_BUFFER_OVERFLOW"));
+        if (bytes > this.limits.itemMaxBytes) {
+            this.close(streamCapacityError("STREAM_QUEUE_ITEM_TOO_LARGE", {
+                boundary: this.limits.boundary,
+                measuredBytes: bytes,
+                limitBytes: this.limits.itemMaxBytes
+            }));
+            return;
+        }
+        if (this.#items.length >= this.limits.maxItems) {
+            this.close(streamCapacityError("STREAM_QUEUE_ITEMS_EXCEEDED", {
+                boundary: this.limits.boundary,
+                itemCount: this.#items.length + 1,
+                limitItems: this.limits.maxItems
+            }));
+            return;
+        }
+        if (this.#bytes + bytes > this.limits.maxBytes) {
+            this.close(streamCapacityError("STREAM_QUEUE_BYTES_EXCEEDED", {
+                boundary: this.limits.boundary,
+                measuredBytes: this.#bytes + bytes,
+                limitBytes: this.limits.maxBytes
+            }));
             return;
         }
         const waiter = this.#waiters.shift();
         if (waiter)
             waiter.resolve({ value, done: false });
         else {
-            this.#items.push(value);
+            this.#items.push({ value, bytes });
             this.#bytes += bytes;
         }
     }
@@ -38,10 +62,10 @@ class AsyncQueue {
         }
     }
     next() {
-        const value = this.#items.shift();
-        if (value !== undefined) {
-            this.#bytes -= Buffer.byteLength(JSON.stringify(value));
-            return Promise.resolve({ value, done: false });
+        const item = this.#items.shift();
+        if (item !== undefined) {
+            this.#bytes -= item.bytes;
+            return Promise.resolve({ value: item.value, done: false });
         }
         if (this.#error)
             return Promise.reject(this.#error);
@@ -204,7 +228,8 @@ export class AdapterHostRpcServer {
                     signal: controller.signal,
                     ...(method === "invoke.with-environment"
                         ? {
-                            executionEnvOverrides: params.executionEnvOverrides
+                            executionEnvOverrides: params.executionEnvOverrides,
+                            streamLimits: resolveStreamLimitPolicy(params.streamLimits)
                         }
                         : {})
                 });
@@ -282,7 +307,10 @@ export class AdapterHostRpcServer {
             this.#send({
                 jsonrpc: "2.0",
                 method: "invoke.done",
-                params: { invocationId, error: { message: errorMessage(error) } }
+                params: {
+                    invocationId,
+                    error: { message: errorMessage(error), ...safeStreamErrorDetails(error) }
+                }
             });
         }
         finally {
@@ -334,11 +362,20 @@ export class AdapterHostRpcClient {
     #pending = new Map();
     #invocations = new Map();
     #closedError;
-    constructor({ input, output, trace }) {
+    constructor({ input, output, trace, maximumInputBytes = HOST_RPC_MAX_LINE_BYTES }) {
         this.#send = writer(output, trace, (error) => this.close(error));
-        const removeGuard = watchLineLimit(input, 512 * 1024, (error) => {
-            this.close(error);
-            input.destroy(error);
+        const removeGuard = watchLineLimit(input, maximumInputBytes, (error) => {
+            const measuredBytes = "measuredBytes" in error && typeof error.measuredBytes === "number"
+                ? error.measuredBytes
+                : undefined;
+            const failure = streamCapacityError("HOST_FRAME_TOO_LARGE", {
+                boundary: "host.rpc_transport",
+                limitBytes: maximumInputBytes,
+                ...(measuredBytes === undefined ? {} : { measuredBytes })
+            });
+            failure.cause = error;
+            this.close(failure);
+            input.destroy(failure);
         });
         const lines = createInterface({ input });
         lines.once("close", removeGuard);
@@ -369,7 +406,10 @@ export class AdapterHostRpcClient {
             const params = message.params ?? {};
             const invocationId = requiredString(params.invocationId, "invocationId");
             const queue = this.#invocations.get(invocationId);
-            const rpcError = isRecord(params.error) ? new Error(errorMessage(params.error)) : undefined;
+            const detail = isRecord(params.error) ? params.error : undefined;
+            const rpcError = detail
+                ? Object.assign(new Error(errorMessage(detail)), safeStreamErrorDetails(detail))
+                : undefined;
             queue?.close(rpcError);
             this.#invocations.delete(invocationId);
             return;
@@ -460,13 +500,19 @@ export class AdapterHostRpcClient {
     /** Await the invoke ACK first, then keep yielding this invocation's event notifications until done. */
     async *invokeFrames(input, environment = {}) {
         const { signal, executionEnvOverrides } = environment;
+        const streamLimits = resolveStreamLimitPolicy(environment.streamLimits);
         const invocationId = input.invocationId ?? randomUUID();
         const wireInput = { ...input, invocationId };
         if (signal?.aborted)
             throw abortError(signal);
         if (this.#invocations.has(invocationId))
             throw new Error("EXECUTION_IDENTITY_CONFLICT");
-        const queue = new AsyncQueue();
+        const queue = new AsyncQueue({
+            itemMaxBytes: streamLimits.hostFrameMaxBytes,
+            maxBytes: streamLimits.rpcQueueMaxBytes,
+            maxItems: streamLimits.rpcQueueMaxItems,
+            boundary: "host.rpc_queue"
+        });
         let terminal = false;
         let accepted = false;
         this.#invocations.set(invocationId, queue);
@@ -477,7 +523,13 @@ export class AdapterHostRpcClient {
         };
         signal?.addEventListener("abort", onAbort, { once: true });
         try {
-            const receipt = await this.request(executionEnvOverrides?.env_variables.length ? "invoke.with-environment" : "invoke", { input: wireInput, ...(executionEnvOverrides ? { executionEnvOverrides } : {}) }, signal);
+            const receipt = await this.request(executionEnvOverrides?.env_variables.length || environment.streamLimits
+                ? "invoke.with-environment"
+                : "invoke", {
+                input: wireInput,
+                ...(executionEnvOverrides ? { executionEnvOverrides } : {}),
+                ...(environment.streamLimits ? { streamLimits } : {})
+            }, signal);
             assertHostRunReceipt(receipt);
             accepted = true;
             assertReceiptInput(receipt, wireInput);
@@ -521,6 +573,21 @@ function asRpcMessage(value) {
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function safeStreamErrorDetails(value) {
+    if (!isRecord(value))
+        return {};
+    const result = {};
+    if (typeof value.code === "string" && /^[A-Z][A-Z0-9_]{0,127}$/.test(value.code))
+        result.code = value.code;
+    if (typeof value.boundary === "string" && /^[a-z0-9][a-z0-9._-]{0,127}$/i.test(value.boundary))
+        result.boundary = value.boundary;
+    for (const key of ["measuredBytes", "limitBytes", "itemCount", "limitItems"]) {
+        const entry = value[key];
+        if (typeof entry === "number" && Number.isSafeInteger(entry) && entry >= 0)
+            result[key] = entry;
+    }
+    return result;
+}
 function requiredString(value, name) {
     if (typeof value !== "string" || value.length === 0)
         throw new TypeError(`${name} must be a non-empty string`);
@@ -567,7 +634,12 @@ function probeOptions(value) {
             Array.isArray(options.providerOptions) ||
             Object.values(options.providerOptions).some((v) => typeof v !== "string")))
         throw new TypeError("invalid probe provider options");
-    return options;
+    return {
+        ...options,
+        ...(options.streamLimits === undefined
+            ? {}
+            : { streamLimits: resolveStreamLimitPolicy(options.streamLimits) })
+    };
 }
 function probeConfigurations(value) {
     if (value === undefined)

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/runtime-configuration.js

@@ -1,5 +1,6 @@
 import { readFileSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { resolveStreamLimitPolicy } from "@mininglamp-oss/octo-runtime-protocol";
 export function readAdapterConfigurations(profileRoot, adaptersValue) {
     const adapters = objectValue(adaptersValue);
     const connections = { openclaw: { providerOptions: { OPENCLAW_RUNTIME_ROOT: profileRoot } } };
@@ -28,12 +29,42 @@ export function readAdapterConfigurations(profileRoot, adaptersValue) {
             return [
                 adapterType,
                 {
-                    providerOptions: { ...publicOptions, ...credentialOptions }
+                    providerOptions: { ...publicOptions, ...credentialOptions },
+                    ...(execution.stream_limits === undefined
+                        ? {}
+                        : { streamLimits: readStreamLimits(execution.stream_limits, adapterType) })
                 }
             ];
         }))
     };
 }
+const STREAM_LIMIT_FIELDS = {
+    raw_message_max_bytes: "rawMessageMaxBytes",
+    adapter_queue_item_max_bytes: "adapterQueueItemMaxBytes",
+    adapter_queue_max_bytes: "adapterQueueMaxBytes",
+    adapter_queue_max_items: "adapterQueueMaxItems",
+    host_frame_max_bytes: "hostFrameMaxBytes",
+    rpc_queue_max_bytes: "rpcQueueMaxBytes",
+    rpc_queue_max_items: "rpcQueueMaxItems",
+    replay_run_max_bytes: "replayRunMaxBytes",
+    replay_run_max_items: "replayRunMaxItems",
+    replay_global_max_bytes: "replayGlobalMaxBytes"
+};
+function readStreamLimits(value, adapterType) {
+    const record = objectValue(value);
+    if (!record)
+        throw new TypeError(`managed ${adapterType} stream_limits must be an object`);
+    const overrides = {};
+    for (const [key, entry] of Object.entries(record)) {
+        const field = STREAM_LIMIT_FIELDS[key];
+        if (!field)
+            throw new TypeError(`managed ${adapterType} stream_limits.${key} is unknown`);
+        if (!Number.isSafeInteger(entry) || entry < 1)
+            throw new TypeError(`managed ${adapterType} stream_limits.${key} must be a positive integer`);
+        overrides[field] = entry;
+    }
+    return { ...resolveStreamLimitPolicy(overrides) };
+}
 function readCredentialOptions(profileRoot, credentialRef, adapterType) {
     const credentialsRoot = realpathSync(join(profileRoot, "credentials"));
     const credentialPath = realpathSync(resolve(profileRoot, credentialRef));

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/socket-server.js

@@ -40,6 +40,11 @@ export async function startHostSocketServer(options) {
             }
             : request;
     };
+    const configuredStreamLimits = (request) => {
+        const adapterType = contextItem(request.contexts, "octo.execution", "adapter")?.payload.type;
+        const type = typeof adapterType === "string" ? adapterType : "codex";
+        return options.configurations?.(typeof request.runMetadata?.runtimeId === "string" ? request.runMetadata.runtimeId : undefined)?.[type]?.streamLimits;
+    };
     const transport = {
         list: (configs) => processHost.client.list(configs ?? options.configurations?.()),
         probe: (type, config) => processHost.client.probe(type, config ?? options.configurations?.()?.[type]),
@@ -49,7 +54,7 @@ export async function startHostSocketServer(options) {
         invoke: createInputInvoke((input, environment) => transport.invokeFrames(input, environment)),
         invokeFrames: (input, environment) => processHost.client.invokeFrames(configure(input), environment)
     };
-    const host = new HostRunService(transport);
+    const host = new HostRunService(transport, configuredStreamLimits);
     const connections = new Set();
     let closing = false;
     const server = net.createServer((socket) => {

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-host",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": {
@@ -14,21 +14,21 @@
     }
   },
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-core": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-antigravity": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-claude-code": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-codebuddy": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-codex": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-hermes": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-kimi-code": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-mcode": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-openclaw": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-opencode": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-qodercli": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-qoderclicn": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-zcode-gui": "1.0.0",
-    "@mininglamp-oss/octo-runtime-protocol": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.0"
+    "@mininglamp-oss/octo-runtime-core": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-antigravity": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-claude-code": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-codebuddy": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-codex": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-hermes": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-kimi-code": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-mcode": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-openclaw": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-opencode": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-qodercli": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-qoderclicn": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-zcode-gui": "1.0.1",
+    "@mininglamp-oss/octo-runtime-protocol": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.1"
   },
   "types": "./dist/index.d.ts",
   "files": [

package/node_modules/@mininglamp-oss/octo-runtime-adapter-kimi-code/dist/index.d.ts

@@ -6,6 +6,6 @@ export declare const kimiCodeAdapter: Readonly<{
     };
     probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
     respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
-    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
 }>;
 export default kimiCodeAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-kimi-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-kimi-code",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.1"
   }
 }

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

@@ -18,6 +18,6 @@ export declare const mcodeAdapter: Readonly<{
     };
     probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
     respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
-    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
 }>;
 export default mcodeAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-mcode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-mcode",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.1"
   }
 }

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

@@ -494,6 +494,8 @@ async function* invokeOpenClawGateway(req, invocation, context, clientFactory, p
     permissions.bindTransport(() => stop(!terminal));
     const queue = new DriverQueue({
         discardOnFailure: true,
+        limits: context?.streamLimits,
+        boundary: "openclaw.event_queue",
         onFailure: () => {
             resourceFailure = true;
             void stop(true);

package/node_modules/@mininglamp-oss/octo-runtime-adapter-openclaw/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-openclaw",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.0",
-    "ws": "8.21.3"
+    "@mininglamp-oss/octo-runtime-protocol": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.1",
+    "ws": "8.22.0"
   },
   "types": "./dist/index.d.ts",
   "files": [

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

@@ -321,7 +321,7 @@ export function createOpenCodeAdapter({ command = "opencode" } = {}) {
             if (request.approvalMode === "assisted")
                 throw new Error("APPROVAL_MODE_UNSUPPORTED: opencode has no qualified assisted policy");
             if (request.approvalMode === "ask") {
-                yield* interactive.invoke(request);
+                yield* interactive.invoke(request, context);
                 return;
             }
             const normalizer = new OpenCodeEventNormalizer();

package/node_modules/@mininglamp-oss/octo-runtime-adapter-opencode/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-opencode",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0",
-    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.0"
+    "@mininglamp-oss/octo-runtime-protocol": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.1",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.1"
   },
   "types": "./dist/index.d.ts",
   "files": [

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

@@ -18,6 +18,6 @@ export declare const qoderCliAdapter: Readonly<{
     };
     probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
     respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
-    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
 }>;
 export default qoderCliAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qodercli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-qodercli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.1"
   }
 }

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

@@ -18,6 +18,6 @@ export declare const qoderCliCnAdapter: Readonly<{
     };
     probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
     respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
-    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
 }>;
 export default qoderCliCnAdapter;