@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/lifecycle.d.ts

@@ -0,0 +1,23 @@
+export type ServicePhase = "created" | "initializing" | "ready" | "closing" | "closed" | "failed";
+export interface ServiceCleanupResult {
+    readonly complete: boolean;
+    readonly errors: readonly {
+        resource: string;
+        code: string;
+    }[];
+    readonly pendingResources: readonly string[];
+}
+export interface ServiceLifecycle<S> {
+    initialize(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    status(): Promise<S>;
+    close(): Promise<ServiceCleanupResult>;
+    readonly closed: Promise<ServiceCleanupResult>;
+}
+export declare class ServiceInitializationError extends Error {
+    readonly cleanup: ServiceCleanupResult;
+    constructor(cause: unknown, cleanup: ServiceCleanupResult);
+}
+/** 所有阶段共用停止起点，超时只结束等待，不代表底层资源已释放。 */
+export declare function beforeDeadline<T>(operation: Promise<T>, until: number): Promise<T>;

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/lifecycle.js

@@ -0,0 +1,23 @@
+export class ServiceInitializationError extends Error {
+    cleanup;
+    constructor(cause, cleanup) {
+        super("SERVICE_INITIALIZATION_FAILED", { cause });
+        this.cleanup = cleanup;
+        this.name = "ServiceInitializationError";
+    }
+}
+/** 所有阶段共用停止起点，超时只结束等待，不代表底层资源已释放。 */
+export async function beforeDeadline(operation, until) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error("SERVICE_CLEANUP_TIMEOUT")), Math.max(1, until - Date.now()));
+            })
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/module-specifier.d.ts

@@ -0,0 +1,2 @@
+/** 内部加载边界：按本机路径语义识别文件，避免把 Windows 盘符交给 ESM 当作 URL 协议。 */
+export declare function resolveAdapterModuleSpecifier(module: string, manifestPath: string): string;

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/module-specifier.js

@@ -0,0 +1,9 @@
+import { dirname, isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+/** 内部加载边界：按本机路径语义识别文件，避免把 Windows 盘符交给 ESM 当作 URL 协议。 */
+export function resolveAdapterModuleSpecifier(module, manifestPath) {
+    // 相对路径属于 manifest 所在目录；包名及现有 URL 保持 Node 的解析语义。
+    return module.startsWith(".") || isAbsolute(module)
+        ? pathToFileURL(resolve(dirname(manifestPath), module)).href
+        : module;
+}

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/process.d.ts

@@ -0,0 +1,30 @@
+import { type ChildProcess, type ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+import type { HostedAdapterMetadata } from "./index.js";
+import { WorkerRpcClient } from "./rpc.js";
+export interface SpawnWorkerOptions {
+    entrypoint: string;
+    /** CLI JSON 来源；SDK 的直接 import 入口不需要此参数。 */
+    manifest?: string;
+    env?: NodeJS.ProcessEnv;
+    /** 取消就绪等待并请求回收子进程；POSIX 使用进程组，Windows taskkill 不保证父先退后的后代回收。 */
+    signal?: AbortSignal;
+    /** Maximum time allowed for the initial RPC readiness handshake. */
+    readyTimeoutMs?: number;
+    onSpawn?: (child: ChildProcess) => Promise<void>;
+}
+type HostedChild = ChildProcessByStdio<Writable, Readable, Readable>;
+export interface WorkerProcess {
+    client: WorkerRpcClient;
+    child: HostedChild;
+    adapters: HostedAdapterMetadata[];
+    close(): Promise<void>;
+    stderr(): string;
+}
+/**
+ * 启动 Node worker，以首次 list RPC 成功作为就绪确认，再返回客户端与进程所有权。
+ * 入口/manifest/环境错误在启动阶段携带有界 stderr 抛出；失败路径仍须回收已创建的进程。
+ * owner 必须等待 close；清理失败不能当作可安全启动替代 worker 的普通启动错误。
+ */
+export declare function spawnWorker({ entrypoint, manifest, env, signal, onSpawn, readyTimeoutMs }: SpawnWorkerOptions): Promise<WorkerProcess>;
+export {};

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/process.js

@@ -1,14 +1,12 @@
 import { createProcessCleanup } from "@mininglamp-oss/octo-runtime-adapter-sdk/process-cleanup";
 import { spawn } from "node:child_process";
-import { AdapterHostRpcClient } from "./rpc.js";
+import { WorkerRpcClient } from "./rpc.js";
 /**
- * Spawn the adapter-host as a child process and return a ready-to-use RPC
- * client. It waits for the first `list` to succeed as a readiness handshake, so
- * a failed spawn (bad manifest, missing binary) surfaces here with the child's
- * captured stderr rather than at first invoke. The child inherits the debug
- * environment and writes its own Host log.
+ * 启动 Node worker，以首次 list RPC 成功作为就绪确认，再返回客户端与进程所有权。
+ * 入口/manifest/环境错误在启动阶段携带有界 stderr 抛出；失败路径仍须回收已创建的进程。
+ * owner 必须等待 close；清理失败不能当作可安全启动替代 worker 的普通启动错误。
  */
-export async function spawnAdapterHost({ entrypoint, manifest, env = process.env, signal, readyTimeoutMs = 15_000 }) {
+export async function spawnWorker({ entrypoint, manifest, env = process.env, signal, onSpawn, readyTimeoutMs = 15_000 }) {
     if (signal?.aborted)
         throw new Error("adapter-host spawn cancelled");
     if (!Number.isFinite(readyTimeoutMs) || readyTimeoutMs < 1) {
@@ -16,19 +14,22 @@ export async function spawnAdapterHost({ entrypoint, manifest, env = process.env
     }
     // 跨进程只传程序入口及可选文件路径，不序列化 Adapter 实例或工厂函数。
     const child = spawn(process.execPath, [entrypoint, ...(manifest ? ["--manifest", manifest] : [])], {
-        argv0: "octo-runtime-adapter-host",
+        argv0: "octo-runtime-executor-kernel",
         env,
-        stdio: ["pipe", "pipe", "pipe"],
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
         detached: process.platform !== "win32"
     });
-    const cleanup = createProcessCleanup(child, { processGroup: process.platform !== "win32" });
+    const cleanup = createProcessCleanup(child, {
+        processGroup: process.platform !== "win32",
+        processTree: true
+    });
     let stderr = "";
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (value) => {
         // Keep only the tail so a chatty child cannot grow this buffer unbounded.
         stderr = (stderr + value.toString()).slice(-8192);
     });
-    const client = new AdapterHostRpcClient({
+    const client = new WorkerRpcClient({
         input: child.stdout,
         output: child.stdin
     });
@@ -37,6 +38,7 @@ export async function spawnAdapterHost({ entrypoint, manifest, env = process.env
     child.on("error", (error) => client.close(error));
     let adapters;
     try {
+        await onSpawn?.(child);
         adapters = await waitForReady(client.list(), readyTimeoutMs, signal);
     }
     catch (error) {
@@ -53,8 +55,8 @@ export async function spawnAdapterHost({ entrypoint, manifest, env = process.env
         client,
         child,
         adapters,
-        // S02：关闭 RPC 后等待本次进程组，不以 leader exit 结束回收。
-        // .octospec/tasks/pr1-yujiawei-review/assessment.md
+        // 先断开 RPC，再等待平台清理；POSIX 不以 leader exit 结束进程组回收。
+        // Windows 仅有 Node/taskkill 的常规树清理能力，不能承诺父进程提前退出后的后代已清空。
         close() {
             client.close();
             return cleanup();
@@ -63,8 +65,6 @@ export async function spawnAdapterHost({ entrypoint, manifest, env = process.env
     };
 }
 function waitForReady(operation, timeoutMs, signal) {
-    if (signal?.aborted)
-        return Promise.reject(new Error("adapter-host spawn cancelled"));
     return new Promise((resolve, reject) => {
         let settled = false;
         const finish = (callback) => {
@@ -79,6 +79,9 @@ function waitForReady(operation, timeoutMs, signal) {
         const timer = setTimeout(() => finish(() => reject(new Error(`adapter-host readiness timed out after ${timeoutMs}ms`))), timeoutMs);
         signal?.addEventListener("abort", onAbort, { once: true });
         operation.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error instanceof Error ? error : new Error(errorMessage(error)))));
+        // 即使 onSpawn 期间已取消，也必须观察已创建的 RPC，避免回滚触发未处理拒绝。
+        if (signal?.aborted)
+            onAbort();
     });
 }
 function errorMessage(error) {

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/rpc.d.ts

@@ -1,12 +1,12 @@
 import type { Readable, Writable } from "node:stream";
 import { type RuntimeLog, type AdapterProbeOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
 import { type InputFrames, type InvokeInput, type InvokeEnvironment, type InputInvoke, type HostFrame, type NativeInteractionResponse, type InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
-import type { AdapterHost, HostedAdapterMetadata } from "./index.js";
+import type { AgentExecutor, HostedAdapterMetadata } from "@mininglamp-oss/octo-runtime-executor-core";
 type JsonRecord = Record<string, unknown>;
 export type RpcTraceDirection = "send" | "receive";
 export type RpcTrace = (direction: RpcTraceDirection, frame: string) => void;
-/** Stable client contract used by daemon-owned host lifecycle wrappers. */
-export interface AdapterHostRpc {
+/** Kernel 到 worker 的内部执行合同；取消回执 cancelled 由外层 RPC 映射为 accepted，均不表示终态。 */
+export interface WorkerRpc {
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;
     cancel(invocationId: string, reason?: string): Promise<{
@@ -18,14 +18,13 @@ export interface AdapterHostRpc {
     invokeFrames: InputFrames;
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export declare class AdapterHostRpcServer {
+export declare class WorkerRpcServer {
     #private;
     constructor({ host, output, trace, log }: {
-        host: AdapterHost;
+        host: AgentExecutor;
         output: Writable;
         trace?: RpcTrace;
         log?: RuntimeLog;
@@ -33,18 +32,22 @@ export declare class AdapterHostRpcServer {
     /** Start consuming the input stream; each line must be one complete JSON-RPC object. */
     listen(input: Readable): void;
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export declare class AdapterHostRpcClient implements AdapterHostRpc {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export declare class WorkerRpcClient implements WorkerRpc {
     #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>;
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error?: Error): void;
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/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);
@@ -71,11 +95,10 @@ function writer(output, trace, onError) {
     };
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export class AdapterHostRpcServer {
+export class WorkerRpcServer {
     #log;
     #controllers = new Map();
     #host;
@@ -204,7 +227,8 @@ export class AdapterHostRpcServer {
                     signal: controller.signal,
                     ...(method === "invoke.with-environment"
                         ? {
-                            executionEnvOverrides: params.executionEnvOverrides
+                            executionEnvOverrides: params.executionEnvOverrides,
+                            streamLimits: resolveStreamLimitPolicy(params.streamLimits)
                         }
                         : {})
                 });
@@ -282,7 +306,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 {
@@ -301,7 +328,16 @@ export class AdapterHostRpcServer {
         for (const controller of this.#controllers.values())
             controller.abort(error);
         this.#controllers.clear();
-        void this.#host.shutdown(error.message).catch(() => undefined);
+        void this.#host
+            .shutdown(error.message)
+            .then((result) => {
+            if (result.cleanup === "incomplete")
+                this.#log("error", "rpc.cleanup_incomplete", {
+                    code: "EXECUTOR_CLEANUP_INCOMPLETE",
+                    unresolved_count: result.unresolvedInvocationIds.length
+                });
+        })
+            .catch(() => undefined);
     }
     #waitForDrain() {
         return new Promise((resolve, reject) => {
@@ -327,18 +363,30 @@ export class AdapterHostRpcServer {
         });
     }
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export class AdapterHostRpcClient {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export class WorkerRpcClient {
     invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
     #send;
     #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 +417,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;
@@ -430,7 +481,7 @@ export class AdapterHostRpcClient {
         this.#send(message);
         return promise;
     }
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error = new Error("adapter-host client closed")) {
         if (this.#closedError)
             return;
@@ -460,13 +511,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 +534,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 +584,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 +645,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 → octo-runtime-executor-kernel}/dist/runner.js

@@ -1,23 +1,19 @@
 #!/usr/bin/env node
-// Standalone adapter-host process: load the adapters listed in a JSON manifest,
-// register them into an AdapterHost, then serve invocations over NDJSON JSON-RPC
-// on stdio (the daemon-to-host transport). Kept separate from the daemon so
-// provider processes are isolated behind a process boundary.
+// CLI 使用的独立 worker 入口：只加载显式 manifest 中的 Adapter，注册到唯一 AgentExecutor。
+// 通过 stdio NDJSON 为父 Kernel 提供执行；SDK 可用自有代码入口调用 serveWorker，毋须采用此 manifest。
 import { readFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { serveAdapterHost } from "./index.js";
+import { resolve } from "node:path";
+import { resolveAdapterModuleSpecifier } from "./module-specifier.js";
+import { serveWorker } from "./index.js";
 const index = process.argv.indexOf("--manifest");
 if (index < 0 || !process.argv[index + 1])
-    throw new Error("usage: octo-runtime-adapter-host --manifest <file>");
+    throw new Error("usage: octo-runtime-executor-kernel --manifest <file>");
 const manifestPath = resolve(process.argv[index + 1]);
 const rawManifest = JSON.parse(await readFile(manifestPath, "utf8"));
 const manifest = parseManifest(rawManifest);
 const adapters = [];
 for (const entry of manifest.adapters) {
-    const specifier = entry.module.startsWith(".") || entry.module.startsWith("/")
-        ? pathToFileURL(resolve(dirname(manifestPath), entry.module)).href
-        : entry.module;
+    const specifier = resolveAdapterModuleSpecifier(entry.module, manifestPath);
     const loaded = await import(specifier);
     const moduleExports = asRecord(loaded, `adapter module ${entry.module}`);
     const exported = moduleExports[entry.exportName];
@@ -36,7 +32,7 @@ for (const entry of manifest.adapters) {
     adapters.push(instance);
 }
 // JSON 是 CLI 的装配来源；注册、RPC 和退出清理与 SDK 的代码入口共用。
-serveAdapterHost(adapters);
+serveWorker(adapters);
 /** Parse and validate the on-disk manifest. Only version 1 is supported; each
  * entry names a module, an export, whether that export is a factory, and options. */
 function parseManifest(value) {

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/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-executor-kernel/dist/serve.d.ts

@@ -0,0 +1,10 @@
+import { type HostedAdapter } from "@mininglamp-oss/octo-runtime-executor-core";
+import { type RuntimeLoggingOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/**
+ * 在当前独立 worker 子进程中提供 Core 执行服务。调用方已经决定加载集合：
+ * CLI 可从自己的 JSON 动态加载，SDK 可直接 import；这里不扫描或补齐任何 Adapter。
+ * 该函数只在 worker 入口调用；宿主 App 和 Kernel 监督进程通过客户端接入，不直接调用。
+ */
+export declare function serveWorker(adapters: readonly HostedAdapter[], options?: {
+    logging?: RuntimeLoggingOptions;
+}): void;