@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

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

@@ -1,11 +1,10 @@
-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, isStreamCapacityReason, resolveStreamLimitPolicy, streamCapacityError, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
 import { InvocationExperience } from "./experience.js";
@@ -13,11 +12,11 @@ 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, resolveStreamLimitPolicy(environment.streamLimits));
+            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, streamLimits) {
+    #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,
@@ -234,8 +292,8 @@ export class AdapterHost {
         let failureCode;
         const pendingInteractions = new Set();
         const source = receipt.protocol_mode === "canonical"
-            ? this.#invokeCanonical(adapterType, request, streamLimits)
-            : this.#invokeProvider(adapterType, request, "native", streamLimits);
+            ? 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();
@@ -262,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"
@@ -271,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" &&
@@ -296,10 +359,12 @@ 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);
@@ -331,16 +396,29 @@ export class AdapterHost {
                     ...(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,
@@ -355,9 +433,9 @@ export class AdapterHost {
             }
         }
     }
-    async *#invokeCanonical(adapterType, request, streamLimits) {
+    async *#invokeCanonical(adapterType, request, streamLimits, owner) {
         const experience = new InvocationExperience();
-        const provider = this.#invokeProvider(adapterType, request, "canonical", streamLimits);
+        const provider = this.#invokeProvider(adapterType, request, "canonical", streamLimits, owner);
         let pending = provider.next();
         void pending.catch(() => undefined);
         let finalBody = false;
@@ -402,7 +480,7 @@ export class AdapterHost {
             await provider.return(undefined);
         }
     }
-    async *#invokeProvider(adapterType, request, protocolMode = "canonical", streamLimits = resolveStreamLimitPolicy(undefined)) {
+    async *#invokeProvider(adapterType, request, protocolMode, streamLimits, owner) {
         this.#log("info", "invoke.started", {
             run_id: request.runId,
             invocation_id: request.invocationId,
@@ -412,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";
@@ -437,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();
@@ -543,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;
@@ -568,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);
                     }
@@ -593,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);
                 }
@@ -623,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");
@@ -732,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. */
@@ -747,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);
@@ -780,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);
 }
@@ -906,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([
@@ -916,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()));
             })
         ]);
     }
@@ -935,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;

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

@@ -1,20 +1,20 @@
 const MODEL_CONTEXT_PATTERNS = [/^extra\.[^/]+\/[^/]+$/, /^octo\.content\/(inline|references)$/];
-/** Fixed model text rendering; business capture and execution configuration are separate. */
+/** 仅渲染允许进入模型的业务 Context；固定格式使用英文，业务内容保留原文，对象键排序使同一快照稳定。 */
 export function renderModelContexts(context) {
     const items = context.items.filter((item) => MODEL_CONTEXT_PATTERNS.some((pattern) => pattern.test(item.namespace + "/" + item.name)));
     if (!items.length)
         return "";
     return [
-        "<--- 上下文信息开始：以下内容为当前上下文信息 --->",
+        "<--- Context information begins: the following is the current context --->",
         "<contexts>",
         ...items.map((item) => [
             `  <context-item namespace="${item.namespace}" name="${item.name}">`,
-            ...(item.guidance ? [`    指引: ${item.guidance}`] : []),
-            `    数据: ${JSON.stringify(sorted(item.payload))}`,
+            ...(item.guidance ? [`    Guidance: ${item.guidance}`] : []),
+            `    Data: ${JSON.stringify(sorted(item.payload))}`,
             "  </context-item>"
         ].join("\n")),
         "</contexts>",
-        "<--- 上下文信息结束 --->"
+        "<--- Context information ends --->"
     ].join("\n");
 }
 function sorted(value) {
@@ -26,7 +26,10 @@ function sorted(value) {
             .map(([key, child]) => [key, sorted(child)]));
     return value;
 }
-/** Called once, after Host freezes the original request and before adapter dispatch. */
+/**
+ * Core 冻结原请求后、派发 Adapter 前调用一次；接入方不应预先渲染而造成 Context 重复。
+ * 正常输入与 fresh fallback 同步添加上下文，保证恢复路径没有额外丢失本轮业务快照。
+ */
 export function withModelContexts(request) {
     const rendered = renderModelContexts(request.context);
     if (!rendered)

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

@@ -22,7 +22,10 @@ export interface WatchdogClock {
     now(): number;
     schedule(callback: () => void, delayMs: number): () => void;
 }
-/** One autonomous timer per invocation. Neither consumer pulls nor logging drive deadlines. */
+/**
+ * 每次执行独立的单调时钟看门狗；期限由定时器推进，不依赖消费者拉流速度或日志输出。
+ * Provider 进度与传输响应分开记录，避免心跳/RPC 响应掩盖模型停滞；超时通过 controller 请求取消。
+ */
 export declare class InvocationWatchdog {
     #private;
     readonly controller: AbortController;

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

@@ -21,7 +21,10 @@ const clock = {
         return () => clearTimeout(timer);
     }
 };
-/** One autonomous timer per invocation. Neither consumer pulls nor logging drive deadlines. */
+/**
+ * 每次执行独立的单调时钟看门狗；期限由定时器推进，不依赖消费者拉流速度或日志输出。
+ * Provider 进度与传输响应分开记录，避免心跳/RPC 响应掩盖模型停滞；超时通过 controller 请求取消。
+ */
 export class InvocationWatchdog {
     controller;
     diagnostic;

package/node_modules/@mininglamp-oss/octo-runtime-executor-core/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-executor-core",
+  "version": "1.1.1",
+  "private": true,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.1",
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.1"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ]
+}

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

@@ -0,0 +1,8 @@
+import { type KernelClient } from "./types.js";
+/**
+ * 连接本机 socket/Windows Pipe，返回不拥有 Kernel 进程的客户端。
+ * invoke 提供登记、取消和尾流观察；关闭连接或迭代器不会隐式取消已接纳 Run。
+ */
+export declare function attachKernel(options: {
+    endpoint: string;
+}): KernelClient;