@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

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

@@ -1,23 +1,22 @@
-import { prepareInvokeInput } from "@mininglamp-oss/octo-runtime-core";
-import { createHash, randomUUID } from "node:crypto";
+import { prepareInvokeInput } from "./invoke-input.js";
+import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { access, stat } from "node:fs/promises";
 import { sanitizePublicValue } from "@mininglamp-oss/octo-runtime-adapter-sdk";
-export { HostRunService } from "./host-run-service.js";
-export { readAdapterConfigurations } from "./runtime-configuration.js";
-export { startHostSocketServer, streamHostRun } from "./socket-server.js";
+export { prepareInvokeInput } from "./invoke-input.js";
+export { resolveLocalContext, localRuntimeLimits } from "./context.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";
 import { AdapterWatchdogTimeoutError, InvocationWatchdog } from "./watchdog.js";
 /**
- * The in-process registry and lifecycle gatekeeper for adapters.
- * It validates plugin input/output, fills in the message lifecycle, guarantees
- * a single terminal, and turns cancellation into an AbortSignal.
+ * 唯一的进程内执行实现：校验输入/Adapter 输出、补齐消息生命周期、约束单个终态并传递取消。
+ * Kernel worker 和显式进程内接入共用本类；它不拥有独立 Kernel、业务会话或 IM 投递。
+ * 接入方须消费流并在退出时检查 shutdown 的 cleanup 结果；终态不能替代资源回收确认。
  */
-export class AdapterHost {
+export class AgentExecutor {
     // F31：.octospec/tasks/gateway-august-feature-assessment/assessment.md
     #log;
     constructor(options = {}) {
@@ -31,15 +30,25 @@ export class AdapterHost {
             }
         };
     }
+    /**
+     * 常规接入入口：默认返回 native HostFrame，显式 canonical 返回 CanonicalEvent。
+     * 与 Kernel 的观察 iterator 不同，本地 Core 提前结束迭代会请求取消并进入 Adapter 清理。
+     */
     invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
     #adapters = new Map();
     #active = new Map();
     #activeAdapters = new Map();
+    // 资源所有权独立于活动执行/终态：清理未确认的 owner 必须留存，供 shutdown 返回真实遗留项。
+    #owners = new Map();
+    #state = "open";
+    #shutdownAttempt;
+    #shutdownResult;
     #acceptedTerminals = new Set();
     #runs = new Map();
     #modes = new Map();
     /** Register an adapter by `metadata.type`; the same type cannot be overwritten twice. */
     register(adapter) {
+        this.#assertOpen();
         assertAdapterProtocolSupport(adapter.metadata.protocolSupport);
         if (this.#adapters.has(adapter.metadata.type))
             throw new Error(`duplicate adapter: ${adapter.metadata.type}`);
@@ -115,19 +124,10 @@ export class AdapterHost {
         }
         if (!registered?.metadata.agentSources.includes(request.agentSource))
             throw new Error("AGENT_SOURCE_UNSUPPORTED: " + adapterType);
-        const { signal: _signal, ...wire } = request;
-        void _signal;
-        const fingerprint = createHash("sha256")
-            .update(stableJson([adapterType, resolved.protocolMode, support.protocol, wire]))
-            .digest("hex");
-        const existing = this.#runs.get(request.invocationId);
-        if (existing) {
-            if (existing.fingerprint !== fingerprint)
-                throw protocolError("EXECUTION_IDENTITY_CONFLICT");
-            return { ...existing.receipt };
-        }
+        if (this.#runs.has(request.invocationId))
+            throw protocolError("EXECUTION_IDENTITY_CONFLICT", "EXECUTION_IDENTITY_CONFLICT: Invocation already executed");
         for (const [id, run] of this.#runs) {
-            if (!this.#active.has(id) && Date.now() - run.at > 120_000)
+            if (!this.#owners.has(id) && !this.#modes.has(id) && Date.now() - run.at > 120_000)
                 this.#runs.delete(id);
         }
         if (this.#runs.size >= 1024)
@@ -145,14 +145,14 @@ export class AdapterHost {
         };
         this.#runs.set(request.invocationId, {
             receipt,
-            fingerprint,
-            request: structuredClone(wire),
-            started: false,
             at: Date.now()
         });
         return { ...receipt };
     }
-    /** Public invocations default to native; canonical consumers explicitly select their view. */
+    /**
+     * 同步校验并冻结单次输入，开始迭代时接纳执行；native 为默认，canonical 须显式选择。
+     * signal、执行环境和容量限制来自本次 environment，不从业务会话或其他 Run 继承。
+     */
     invokeFrames(input, environment = {}) {
         const received = Date.now();
         try {
@@ -173,22 +173,10 @@ export class AdapterHost {
             request.signal = environment.signal;
             if (environment.executionEnvOverrides)
                 request.executionEnvOverrides = structuredClone(environment.executionEnvOverrides);
-            const receipt = this.#prepare(adapterType, request, { protocolMode });
-            const run = this.#runs.get(request.invocationId);
-            if (run.started)
-                throw protocolError("EXECUTION_IDENTITY_CONFLICT", "Invocation already executed; subscribe to the retained stream");
-            run.started = true;
-            this.#log("info", "invoke.accepted", {
-                run_id: request.runId,
-                invocation_id: request.invocationId,
-                session_id: request.agentSessionId,
-                adapter_type: adapterType,
-                model: request.agentConfig?.model,
-                duration_ms: Date.now() - received
-            });
-            const frozenRequest = withModelContexts({ ...run.request, signal: request.signal });
-            run.request = undefined;
-            return this.#streamInvocation(adapterType, frozenRequest, receipt);
+            const streamLimits = resolveStreamLimitPolicy(environment.streamLimits);
+            const { signal, ...wire } = request;
+            const frozenRequest = withModelContexts({ ...structuredClone(wire), signal });
+            return this.#admit(adapterType, frozenRequest, protocolMode, streamLimits, received);
         }
         catch (error) {
             this.#log("warn", "invoke.rejected", {
@@ -198,7 +186,77 @@ export class AdapterHost {
             throw error;
         }
     }
-    async *#streamInvocation(adapterType, request, receipt) {
+    #assertOpen() {
+        if (this.#state !== "open")
+            throw new Error("EXECUTOR_CLOSED");
+    }
+    async *#admit(adapterType, request, protocolMode, streamLimits, received) {
+        // 延迟到消费时再次检查关闭/取消，防止创建生成器后、开始迭代前 shutdown 的竞态。
+        this.#assertOpen();
+        request.signal?.throwIfAborted();
+        const receipt = this.#prepare(adapterType, request, { protocolMode });
+        const controller = new AbortController();
+        const invocationId = request.invocationId;
+        const signal = request.signal;
+        const callerAbort = () => {
+            if (!this.#acceptedTerminals.has(invocationId))
+                controller.abort(signal?.reason);
+        };
+        const owner = {
+            streamId: receipt.stream_id,
+            controller,
+            detach: () => {
+                signal?.removeEventListener("abort", callerAbort);
+                controller.signal.removeEventListener("abort", onAbort);
+            }
+        };
+        const onAbort = () => {
+            void this.#cleanupOwner(invocationId, owner).catch(() => undefined);
+        };
+        this.#owners.set(request.invocationId, owner);
+        this.#active.set(request.invocationId, controller);
+        request.signal?.addEventListener("abort", callerAbort, { once: true });
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+        this.#log("info", "invoke.accepted", {
+            run_id: request.runId,
+            invocation_id: request.invocationId,
+            session_id: request.agentSessionId,
+            adapter_type: adapterType,
+            model: request.agentConfig?.model,
+            duration_ms: Date.now() - received
+        });
+        yield* this.#streamInvocation(adapterType, request, receipt, streamLimits, owner);
+    }
+    #isCurrent(id, owner) {
+        return this.#runs.get(id)?.receipt.stream_id === owner.streamId;
+    }
+    #cleanupOwner(id, owner) {
+        // 生成器 finally 失败后再次 return() 无法重跑清理；缓存首次结果并保留失败 owner 供 shutdown 报告。
+        if (owner.cleanupAttempt)
+            return owner.cleanupAttempt;
+        owner.cleanupState = "pending";
+        owner.cleanupAttempt = Promise.resolve()
+            .then(() => owner.close?.())
+            .then(() => {
+            if (this.#owners.get(id) === owner)
+                this.#owners.delete(id);
+            if (this.#isCurrent(id, owner)) {
+                this.#active.delete(id);
+                this.#activeAdapters.delete(id);
+                if (owner.controller.signal.aborted)
+                    this.#modes.delete(id);
+            }
+        }, (error) => {
+            owner.cleanupState = "failed";
+            throw error;
+        })
+            .finally(() => {
+            owner.detach();
+            owner.detach = () => { };
+        });
+        return owner.cleanupAttempt;
+    }
+    async *#streamInvocation(adapterType, request, receipt, streamLimits, owner) {
         const started = Date.now();
         const identity = {
             run_id: request.runId,
@@ -221,8 +279,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 +292,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, owner)
+            : this.#invokeProvider(adapterType, request, "native", streamLimits, owner);
         try {
             yield frame({ kind: "control", control: { type: "state", state: "running" } });
             let pending = source.next();
@@ -258,7 +320,7 @@ export class AdapterHost {
                     output.control.type === "state" &&
                     output.control.state !== "running")
                     state = output.control;
-                else if (!("kind" in output) && isTerminal(output))
+                else if (!("kind" in output) && isTerminal(output)) {
                     state = {
                         type: "state",
                         state: output.type === "run.completed"
@@ -267,6 +329,11 @@ export class AdapterHost {
                                 ? "cancelled"
                                 : "failed"
                     };
+                    // Canonical consumers may stop at the event instead of the Host state.
+                    await source.return(undefined);
+                    if (this.#isCurrent(request.invocationId, owner))
+                        this.#modes.delete(request.invocationId);
+                }
                 if (!("kind" in output &&
                     output.kind === "control" &&
                     output.control.type === "state" &&
@@ -292,12 +359,25 @@ export class AdapterHost {
                     control: { type: "interaction", requestId, status: "invalidated" }
                 });
             pendingInteractions.clear();
+            if (this.#isCurrent(request.invocationId, owner))
+                this.#modes.delete(request.invocationId);
             yield frame({ kind: "control", control: state });
         }
         catch (error) {
-            this.#active.get(request.invocationId)?.abort(error);
+            owner.controller.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,20 +391,34 @@ 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 } : {})
                 }
             };
+            if (this.#isCurrent(request.invocationId, owner))
+                this.#modes.delete(request.invocationId);
             yield { ...receipt, kind: "control", seq: ++seq, control: state };
         }
         finally {
             try {
-                this.cancel(request.invocationId, "consumer_closed");
+                if (this.#active.get(request.invocationId) === owner.controller)
+                    this.cancel(request.invocationId, "consumer_closed");
                 await source.return(undefined);
             }
             finally {
-                this.#modes.delete(request.invocationId);
-                this.#runs.get(request.invocationId).at = Date.now();
+                if (this.#isCurrent(request.invocationId, owner))
+                    this.#modes.delete(request.invocationId);
+                const cleanup = this.#cleanupOwner(request.invocationId, owner).catch(() => undefined);
+                // Provider cleanup already used its grace budget; retain pending ownership
+                // without adding a second shutdown-sized delay to stream completion.
+                if (!owner.close)
+                    await cleanup;
+                else
+                    void cleanup;
+                const run = this.#runs.get(request.invocationId);
+                if (run?.receipt.stream_id === owner.streamId)
+                    run.at = Date.now();
                 if (state?.state === "failed")
                     this.#log("error", "invoke.failed", {
                         ...identity,
@@ -339,9 +433,9 @@ export class AdapterHost {
             }
         }
     }
-    async *#invokeCanonical(adapterType, request) {
+    async *#invokeCanonical(adapterType, request, streamLimits, owner) {
         const experience = new InvocationExperience();
-        const provider = this.#invokeProvider(adapterType, request);
+        const provider = this.#invokeProvider(adapterType, request, "canonical", streamLimits, owner);
         let pending = provider.next();
         void pending.catch(() => undefined);
         let finalBody = false;
@@ -386,7 +480,7 @@ export class AdapterHost {
             await provider.return(undefined);
         }
     }
-    async *#invokeProvider(adapterType, request, protocolMode = "canonical") {
+    async *#invokeProvider(adapterType, request, protocolMode, streamLimits, owner) {
         this.#log("info", "invoke.started", {
             run_id: request.runId,
             invocation_id: request.invocationId,
@@ -396,16 +490,9 @@ export class AdapterHost {
         const adapter = this.#adapters.get(adapterType);
         if (!adapter)
             throw new Error(`unknown adapter: ${adapterType}`);
-        const controller = new AbortController();
-        const callerAbort = () => {
-            if (!this.#acceptedTerminals.has(request.invocationId))
-                controller.abort(request.signal?.reason);
-        };
-        request.signal?.addEventListener("abort", callerAbort, { once: true });
-        if (request.signal?.aborted)
-            callerAbort();
-        this.#active.set(request.invocationId, controller);
-        this.#activeAdapters.set(request.invocationId, adapter);
+        const controller = owner.controller;
+        if (!controller.signal.aborted)
+            this.#activeAdapters.set(request.invocationId, adapter);
         let terminal;
         let nativeTerminal;
         let outcome = "stopped";
@@ -421,13 +508,46 @@ export class AdapterHost {
             code: diagnostic.event
         }));
         let iterator;
-        let cleanup;
+        let nextFailed = false;
+        let iteratorDone = false;
         let cleanupWait;
-        const closeIterator = () => (cleanup ??= Promise.resolve().then(() => iterator?.return?.()));
-        const waitCleanup = () => (cleanupWait ??= boundedCleanup(closeIterator(), watchdog.limits.cancelGraceMs));
+        let cleanupDeadline;
+        const beginCleanup = () => (cleanupDeadline ??= performance.now() + watchdog.limits.cancelGraceMs);
+        const remainingCleanup = () => Math.max(0, beginCleanup() - performance.now());
+        owner.close = async () => {
+            if (!iterator)
+                return;
+            if (iterator.return) {
+                const closed = await iterator.return();
+                if (closed?.done !== true)
+                    throw new Error("EXECUTOR_CLEANUP_UNVERIFIED");
+            }
+            else if (!iteratorDone)
+                throw new Error("EXECUTOR_CLEANUP_UNVERIFIED");
+            // next() rejection can originate in finally; a later return() is not proof.
+            if (nextFailed)
+                throw new Error("EXECUTOR_CLEANUP_UNVERIFIED");
+        };
+        const readNext = async (source) => {
+            try {
+                const result = await source.next();
+                if (result.done)
+                    iteratorDone = true;
+                return result;
+            }
+            catch (error) {
+                nextFailed = true;
+                throw error;
+            }
+        };
+        const closeIterator = () => {
+            beginCleanup();
+            return this.#cleanupOwner(request.invocationId, owner);
+        };
+        const waitCleanup = () => (cleanupWait ??= boundedCleanup(closeIterator(), remainingCleanup()));
         // The timer can fire while a consumer is paused at yield.
         const onAbort = () => {
-            void closeIterator().catch(() => undefined);
+            void waitCleanup().catch(() => undefined);
         };
         controller.signal.addEventListener("abort", onAbort, { once: true });
         const messages = new Map();
@@ -435,6 +555,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");
@@ -526,14 +647,15 @@ export class AdapterHost {
             return closed;
         };
         try {
+            controller.signal.throwIfAborted();
             const invocation = adapter.invoke({ ...request, signal: controller.signal }, context);
             iterator = invocation[Symbol.asyncIterator]();
             while (true) {
                 if (controller.signal.aborted)
                     throw controller.signal.reason;
-                const pendingNext = iterator.next();
+                const pendingNext = readNext(iterator);
                 const next = terminal || nativeTerminal
-                    ? await withCleanupDeadline(pendingNext, watchdog.limits.cancelGraceMs, controller)
+                    ? await withCleanupDeadline(pendingNext, beginCleanup(), watchdog.limits.cancelGraceMs, controller)
                     : await waitForNext(pendingNext, controller.signal);
                 if (controller.signal.aborted)
                     throw controller.signal.reason;
@@ -551,6 +673,7 @@ export class AdapterHost {
                         adapterEvent.control.type === "state" &&
                         adapterEvent.control.state !== "running") {
                         nativeTerminal = adapterEvent.control;
+                        beginCleanup();
                         watchdog.terminal();
                         this.#acceptedTerminals.add(request.invocationId);
                     }
@@ -576,6 +699,7 @@ export class AdapterHost {
                     throw new Error(`${adapterType} emitted after terminal event`);
                 if (isTerminal(event)) {
                     terminal = event;
+                    beginCleanup();
                     // A later user cancellation cannot replace an accepted provider terminal.
                     this.#acceptedTerminals.add(request.invocationId);
                 }
@@ -606,7 +730,7 @@ export class AdapterHost {
                     yield prepared.event;
                 }
             }
-            await withCleanupDeadline(closeIterator(), watchdog.limits.cancelGraceMs, controller);
+            await withCleanupDeadline(closeIterator(), beginCleanup(), watchdog.limits.cancelGraceMs, controller);
             if (protocolMode === "native") {
                 if (!nativeTerminal)
                     throw protocolError("HOST_ENDED_WITHOUT_TERMINAL");
@@ -634,6 +758,7 @@ export class AdapterHost {
                 message: errorMessage(error),
                 adapterType,
                 ...(errorCode(error) ? { code: errorCode(error) } : {}),
+                ...capacityFailureDetails(error),
                 ...watchdogFailureDetails(error)
             }, request.workdir, {
                 stage: "adapter.invoke",
@@ -661,17 +786,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 {
@@ -712,10 +839,11 @@ export class AdapterHost {
                 controller.abort("consumer closed");
             await waitCleanup().catch(() => undefined);
             controller.signal.removeEventListener("abort", onAbort);
-            request.signal?.removeEventListener("abort", callerAbort);
-            this.#active.delete(request.invocationId);
-            this.#activeAdapters.delete(request.invocationId);
-            this.#acceptedTerminals.delete(request.invocationId);
+            if (this.#isCurrent(request.invocationId, owner)) {
+                this.#active.delete(request.invocationId);
+                this.#activeAdapters.delete(request.invocationId);
+                this.#acceptedTerminals.delete(request.invocationId);
+            }
         }
     }
     /** Run the adapter's own environment probe; return an unchecked-available status when there is no probe. */
@@ -727,10 +855,10 @@ export class AdapterHost {
             return { available: true, adapterType, unchecked: true };
         return adapter.probe(options);
     }
-    /** Abort an active invocation; returns false when that invocation no longer exists or has already ended. */
+    /** 请求取消活动执行；true 仅表示已触发 abort，仍须消费终态并等待 Adapter 清理。 */
     cancel(invocationId, reason = "cancelled") {
         const controller = this.#active.get(invocationId);
-        if (!controller || this.#acceptedTerminals.has(invocationId))
+        if (!controller || controller.signal.aborted || this.#acceptedTerminals.has(invocationId))
             return false;
         this.#log("info", "invoke.cancel_requested", { invocation_id: invocationId });
         controller.abort(reason);
@@ -760,31 +888,41 @@ export class AdapterHost {
             throw protocolError("INTERACTION_NOT_ACTIVE");
         await adapter.respondNative(invocationId, response);
     }
-    /** Abort every invocation and wait briefly for adapter cleanup to reap its
-     * provider processes. Used when the RPC parent disappears or shuts down. */
-    async shutdown(reason = "adapter host shutdown", timeoutMs = 2_500) {
-        for (const controller of this.#active.values())
-            controller.abort(reason);
-        if (this.#active.size === 0)
-            return;
-        const deadline = Date.now() + timeoutMs;
-        await new Promise((resolve) => {
-            const check = () => {
-                if (this.#active.size === 0 || Date.now() >= deadline) {
-                    resolve();
-                    return;
-                }
-                setTimeout(check, 10);
-            };
-            check();
+    /**
+     * 停止接纳并取消未终结执行，在 timeoutMs 内等待 Adapter 清理；不负责业务投递收尾。
+     * 并发调用共用当前尝试；超时或清理失败返回 incomplete 和遗留身份，不冒充资源已回收。
+     */
+    shutdown(reason = "executor shutdown", timeoutMs = 2_500) {
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)
+            throw new Error("shutdown timeoutMs must be a positive safe integer");
+        if (this.#shutdownAttempt)
+            return this.#shutdownAttempt;
+        if (this.#shutdownResult?.cleanup === "complete")
+            return Promise.resolve(this.#shutdownResult);
+        this.#state = "closing";
+        const pending = [];
+        for (const [id, owner] of this.#owners) {
+            if (!this.#acceptedTerminals.has(id))
+                owner.controller.abort(reason);
+            pending.push(this.#cleanupOwner(id, owner));
+        }
+        this.#shutdownAttempt = boundedCleanup(Promise.allSettled(pending), timeoutMs).then(() => {
+            this.#state = "closed";
+            const unresolvedInvocationIds = Object.freeze([...this.#owners.keys()]);
+            const failedCleanupInvocationIds = Object.freeze([...this.#owners].filter(([, owner]) => owner.cleanupState === "failed").map(([id]) => id));
+            const result = Object.freeze({
+                state: "closed",
+                cleanup: unresolvedInvocationIds.length ? "incomplete" : "complete",
+                unresolvedInvocationIds,
+                failedCleanupInvocationIds
+            });
+            this.#shutdownResult = result;
+            this.#shutdownAttempt = undefined;
+            return result;
         });
+        return this.#shutdownAttempt;
     }
 }
-function stableJson(value) {
-    return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item)
-        ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))
-        : item);
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -843,6 +981,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 {
@@ -878,7 +1024,7 @@ async function boundedCleanup(cleanup, graceMs) {
             clearTimeout(timer);
     }
 }
-async function withCleanupDeadline(pending, graceMs, controller) {
+async function withCleanupDeadline(pending, deadline, graceMs, controller) {
     let timer;
     try {
         return await Promise.race([
@@ -888,7 +1034,7 @@ async function withCleanupDeadline(pending, graceMs, controller) {
                     const error = new AdapterWatchdogTimeoutError("cleanup", graceMs, "cleanup_timeout");
                     reject(error);
                     controller.abort(error);
-                }, graceMs);
+                }, Math.max(0, deadline - performance.now()));
             })
         ]);
     }
@@ -907,7 +1053,4 @@ function watchdogFailureDetails(error) {
         }
         : {};
 }
-export { spawnAdapterHost } from "./process.js";
-export { serveAdapterHost } from "./serve.js";
-export { AdapterHostRpcClient, AdapterHostRpcServer } from "./rpc.js";
 export { DEFAULT_RUNTIME_LIMITS } from "./watchdog.js";

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

@@ -0,0 +1,11 @@
+import { type InvokeRequest } from "@mininglamp-oss/octo-runtime-protocol";
+/**
+ * 将调用方本轮 JSON 快照解析为执行计划与内部请求，不读取持久会话或创建 Provider。
+ * sessionId 只标识业务会话；续接必须显式携带 providerSession，不能由同名会话推断。
+ * 这里只解析执行设置，完整业务 Context 保留给后续共享渲染流程。
+ */
+export declare function prepareInvokeInput(value: unknown): {
+    adapterType: string;
+    protocolMode: "native" | "canonical";
+    request: InvokeRequest;
+};

package/node_modules/@mininglamp-oss/{octo-runtime-core → octo-runtime-executor-core}/dist/invoke-input.js

@@ -22,7 +22,11 @@ function inputContext(value) {
     assertContextEnvelope(value);
     return value;
 }
-/** One caller-owned snapshot, with no persistent session or daemon state. */
+/**
+ * 将调用方本轮 JSON 快照解析为执行计划与内部请求，不读取持久会话或创建 Provider。
+ * sessionId 只标识业务会话；续接必须显式携带 providerSession，不能由同名会话推断。
+ * 这里只解析执行设置，完整业务 Context 保留给后续共享渲染流程。
+ */
 export function prepareInvokeInput(value) {
     if (!isRecord(value))
         throw new TypeError("invoke input must be a JSON object");

package/node_modules/@mininglamp-oss/octo-runtime-executor-core/dist/model-input.d.ts

@@ -0,0 +1,8 @@
+import type { ContextEnvelope, InvokeRequest } from "@mininglamp-oss/octo-runtime-protocol";
+/** 仅渲染允许进入模型的业务 Context，执行/安全配置不作为普通提示词；对象键排序使同一快照稳定。 */
+export declare function renderModelContexts(context: ContextEnvelope): string;
+/**
+ * Core 冻结原请求后、派发 Adapter 前调用一次；接入方不应预先渲染而造成 Context 重复。
+ * 正常输入与 fresh fallback 同步添加上下文，保证恢复路径没有额外丢失本轮业务快照。
+ */
+export declare function withModelContexts(request: InvokeRequest): InvokeRequest;