@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/rules-context.d.ts

@@ -0,0 +1,25 @@
+import type { ContextEnvelope, ContextItem, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ImInvocationInput } from "../execution/dispatcher.js";
+interface RuleStamp {
+    version: number | null;
+    status: "present" | "empty" | "not_found";
+}
+export interface ImRulesVersions {
+    group: RuleStamp;
+    topic?: RuleStamp;
+}
+export interface ImRulesContext {
+    revision: number;
+    supplied?: ImRulesVersions & {
+        providerSessionId: string;
+    };
+}
+/** 仅选择 Gateway 自动读取的规则；宿主显式提交的 Context 不参与省略。 */
+export declare function selectRulesContext(context: ContextEnvelope, cursor: ImRulesContext | undefined, provider: ProviderSession | undefined): {
+    context: ContextEnvelope;
+    versions?: ImRulesVersions;
+    omitted: ContextItem[];
+};
+/** 恢复新 Provider 会话时显式重带本轮规则和原 inputs，不改变普通续聊输入。 */
+export declare function addRulesRecovery(input: ImInvocationInput, rules: ContextItem[]): void;
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/rules-context.js

@@ -0,0 +1,39 @@
+/** 仅选择 Gateway 自动读取的规则；宿主显式提交的 Context 不参与省略。 */
+export function selectRulesContext(context, cursor, provider) {
+    const rules = context.items.filter((item) => item.namespace === "extra.im" &&
+        ["group-rules", "topic-rules"].includes(item.name) &&
+        item.payload.automatic === true);
+    const stamp = (item) => ({
+        version: typeof item.payload.version === "number" ? item.payload.version : null,
+        status: item.payload.status
+    });
+    const group = rules.find((item) => item.name === "group-rules");
+    if (!group)
+        return { context, omitted: [] };
+    const topic = rules.find((item) => item.name === "topic-rules");
+    const versions = { group: stamp(group), ...(topic ? { topic: stamp(topic) } : {}) };
+    const supplied = cursor?.supplied;
+    const same = (left, right) => left?.version === right?.version && left?.status === right?.status;
+    if (!provider?.sessionId ||
+        provider.resumable === false ||
+        !supplied ||
+        supplied.providerSessionId !== provider.sessionId ||
+        !same(supplied.group, versions.group) ||
+        !same(supplied.topic, versions.topic))
+        return { context, versions, omitted: [] };
+    return {
+        context: { ...context, items: context.items.filter((item) => !rules.includes(item)) },
+        versions,
+        omitted: rules
+    };
+}
+/** 恢复新 Provider 会话时显式重带本轮规则和原 inputs，不改变普通续聊输入。 */
+export function addRulesRecovery(input, rules) {
+    if (!rules.length)
+        return;
+    const text = `以下为当前群和话题规则，替代旧版本；empty/not_found 表示旧规则已撤销。\n${JSON.stringify(rules)}`;
+    input.freshFallbackModelInputParts = [{ type: "text", text }, ...structuredClone(input.inputs)];
+    input.freshFallbackModelInput = input.freshFallbackModelInputParts
+        .map((part) => (part.type === "text" ? part.text : "[Image]"))
+        .join("\n\n");
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/session-store.d.ts

@@ -1,6 +1,8 @@
 import type { ImInvocationInput } from "../execution/dispatcher.js";
 import type { ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
 import type { ImTaskAttempt } from "../contracts.js";
+import type { ImGapMetadata, ImGapTurnToken } from "./context-gap.js";
+import type { ImRulesContext } from "./rules-context.js";
 export interface ImSessionOccurrence {
     text: string;
     sessionId: string;
@@ -15,20 +17,46 @@ export interface ImSessionBinding {
     lastEventId?: string;
     lastRunId?: string;
     initialContextPrepared?: boolean;
+    gap?: ImGapMetadata;
+    rulesContext?: ImRulesContext;
 }
+/**
+ * Gateway 的会话状态合同，与数据库无关；常规方法必须同步完成并返回独立快照。
+ * key 是不透明聊天身份，宿主另按可信 Bot/账号 scope 分区，不从消息正文选择租户。
+ */
 export interface ImSessionStore {
+    /** 未命中返回 undefined；返回值的后续修改不能直接改变已保存状态。 */
     read(key: string): ImSessionBinding | undefined;
+    /** 保存完整 binding；宿主负责提交及容量策略，Gateway 保持既有代次检查。 */
     save(key: string, binding: ImSessionBinding): void;
+    /** 原子记录控制 ID 并递增 generation；重复控制不得再次重置当前 binding。 */
     reset(key: string, controlId: string): ImSessionBinding;
+    /** 消息处理及重试快照；未命中返回 undefined，宿主自行设置保留期限。 */
     occurrence(key: string, id: string): ImSessionOccurrence | undefined;
     remember(key: string, id: string, value: ImSessionOccurrence): void;
-    close?(): void;
+    /** 仅在当前 sessionId/generation 匹配时原子合并；未命中或拒绝更新返回 false。 */
+    patchGap?(key: string, identity: Pick<ImGapTurnToken, "sessionId" | "generation">, update: (current: ImGapMetadata | undefined) => ImGapMetadata): boolean;
+    /** 只使匹配的现有规则游标失效，不创建 binding 或改变聊天代次。 */
+    invalidateRules?(matches: (key: string) => boolean): void;
+    /** 与 patchGap 相同的身份校验；update 返回 undefined 时不写入。 */
+    patchRules?(key: string, identity: {
+        sessionId: string;
+        generation: number;
+    }, update: (current: ImRulesContext | undefined) => ImRulesContext | undefined): boolean;
+    /** 工厂句柄由 Gateway 调用一次；只释放该句柄，不能关闭宿主共享数据库。 */
+    close?(): void | Promise<void>;
 }
 export declare class MemoryImSessionStore implements ImSessionStore {
     #private;
     constructor();
     read(key: string): ImSessionBinding | undefined;
     save(key: string, value: ImSessionBinding): void;
+    patchGap(key: string, identity: Pick<ImGapTurnToken, "sessionId" | "generation">, update: (current: ImGapMetadata | undefined) => ImGapMetadata): boolean;
+    invalidateRules(matches: (key: string) => boolean): void;
+    patchRules(key: string, identity: {
+        sessionId: string;
+        generation: number;
+    }, update: (current: ImRulesContext | undefined) => ImRulesContext | undefined): boolean;
     reset(key: string, id: string): ImSessionBinding;
     occurrence(key: string, id: string): ImSessionOccurrence | undefined;
     remember(key: string, id: string, value: ImSessionOccurrence): void;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/session-store.js

@@ -36,6 +36,27 @@ class BoundedEntries {
             if (entry.expires <= now)
                 this.#delete(key);
     }
+    keys() {
+        this.prune();
+        return [...this.#entries.keys()];
+    }
+    /** 同步合并最新条目；观察不续TTL、不改变淘汰顺序，超预算拒绝辅助patch而不淘汰其他binding。 */
+    patch(key, update) {
+        this.prune();
+        const entry = this.#entries.get(key);
+        if (!entry)
+            return false;
+        const value = update(structuredClone(entry.value));
+        if (!value)
+            return false;
+        const bytes = Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value));
+        if (bytes > this.bytes || this.#bytes - entry.bytes + bytes > this.bytes)
+            return false;
+        this.#bytes += bytes - entry.bytes;
+        entry.value = structuredClone(value);
+        entry.bytes = bytes;
+        return true;
+    }
     #delete(key) {
         const previous = this.#entries.get(key);
         if (previous)
@@ -63,8 +84,47 @@ export class MemoryImSessionStore {
         return this.#bindings.get(key);
     }
     save(key, value) {
+        if (value.gap &&
+            Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value)) > this.#bindings.bytes) {
+            value = { ...value };
+            delete value.gap;
+        }
         this.#bindings.set(key, value);
     }
+    patchGap(key, identity, update) {
+        return this.#bindings.patch(key, (binding) => {
+            if (binding.id !== identity.sessionId || binding.generation !== identity.generation)
+                return undefined;
+            const previous = binding.gap;
+            binding.gap = update(previous);
+            binding.gap.revision = (previous?.revision ?? 0) + 1;
+            return binding;
+        });
+    }
+    invalidateRules(matches) {
+        for (const key of this.#bindings.keys()) {
+            if (!matches(key))
+                continue;
+            this.#bindings.patch(key, (binding) => {
+                if (!binding.id)
+                    return undefined;
+                // 只改规则状态，不续 TTL、不推进聊天水位，也不为通知创建会话。
+                binding.rulesContext = { revision: (binding.rulesContext?.revision ?? 0) + 1 };
+                return binding;
+            });
+        }
+    }
+    patchRules(key, identity, update) {
+        return this.#bindings.patch(key, (binding) => {
+            if (binding.id !== identity.sessionId || binding.generation !== identity.generation)
+                return undefined;
+            const next = update(binding.rulesContext);
+            if (!next)
+                return undefined;
+            binding.rulesContext = next;
+            return binding;
+        });
+    }
     reset(key, id) {
         const controlKey = JSON.stringify([key, id]);
         if (this.#controls.get(controlKey)) {

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/contracts.d.ts

@@ -1,8 +1,16 @@
 /**
  * Octo gateway 配置、入站消息、执行端口和投递回执。
  */
-import type { ApprovalMode, ContextEnvelope, ContextItem, CanonicalEvent, InteractionResponse, InteractionRequestedPayload, InvokeInput, InvokeEnvironment, ModelInputPart, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ApprovalMode, ContextEnvelope, ContextItem, CanonicalEvent, InteractionResponse, InteractionRequestedPayload, InvokeEnvironment, ModelInputPart, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
 import type { RunPresentation } from "./presentation/run-projector.js";
+import type { ImGapPlan, ImGapTurnToken } from "./application/context-gap.js";
+export interface ImPositionObservation {
+    conversationId: string;
+    conversationKind: "group" | "thread";
+    messageSeq: number;
+    own?: boolean;
+    turn?: ImGapTurnToken;
+}
 export interface ImAdapterConfig {
     adapter_type?: string;
     workdir?: string;
@@ -46,6 +54,11 @@ export type ScopedOctoBotConfig = OctoBotConfig & {
 };
 /** 平台归一化后的单条消息。平台回调身份与正文保留在 connector 的闭包内。 */
 export interface ImInboundMessage {
+    position?: {
+        messageSeq: number;
+    };
+    historyRetry?: boolean;
+    bindHistoryTurn?(token: ImGapTurnToken): void;
     markRead?(signal: AbortSignal): Promise<void>;
     messageId: string;
     senderId: string;
@@ -62,6 +75,8 @@ export interface ImInboundMessage {
         initialSession: boolean;
         mentionGuidance?: boolean;
         configuredItems?: readonly ContextItem[];
+        historyGap?: ImGapPlan;
+        onHistoryGapPrepared?(plan: ImGapPlan): void;
     }): Promise<ContextEnvelope>;
     executionEnvironment?(): InvokeEnvironment;
     runMetadata?: Record<string, unknown>;
@@ -87,6 +102,11 @@ export interface ImTaskAttempt {
     diagnosticId?: string;
 }
 export interface ChannelCallbacks {
+    onRulesChanged?(change: {
+        groupNo: string;
+        shortId?: string;
+    }): void;
+    onPosition?(position: ImPositionObservation): void;
     authorizeSpace?: (spaceId: string) => void;
     onMessage(message: ImInboundMessage): void;
     onDisconnect(code: string, retryable?: boolean): void;
@@ -97,15 +117,6 @@ export interface ImAddress {
     channelType: number;
 }
 export type ImConnectionState = "stopped" | "connecting" | "online" | "retrying" | "failed";
-export interface ImExecutionPort {
-    invoke(input: InvokeInput & {
-        protocol_mode: "canonical";
-    }, environment?: InvokeEnvironment): AsyncIterable<CanonicalEvent>;
-    cancel(invocationId: string, reason?: string): Promise<{
-        cancelled: boolean;
-    }>;
-    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
-}
 export interface ImSession {
     id?: string;
     generation: number;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.d.ts

@@ -7,7 +7,8 @@ export declare class ImDeliveryDispatcher {
     #private;
     readonly signal: AbortSignal;
     constructor(signal: AbortSignal);
-    get receipts(): ImDeliveryReceipt[];
+    /** 状态仅读取数量，避免复制和输出用于防重的内部回执。 */
+    get receiptCount(): number;
     deliver(effectKey: string, operation: () => Promise<string | void>, options?: {
         transient?: boolean;
         obsolete?: () => boolean;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.js

@@ -6,8 +6,9 @@ export class ImDeliveryDispatcher {
     constructor(signal) {
         this.signal = signal;
     }
-    get receipts() {
-        return [...this.#receipts.values()].map((r) => ({ ...r }));
+    /** 状态仅读取数量，避免复制和输出用于防重的内部回执。 */
+    get receiptCount() {
+        return this.#receipts.size;
     }
     async deliver(effectKey, operation, options = {}) {
         const previous = this.#receipts.get(effectKey);

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/dispatcher.js

@@ -8,6 +8,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { assertContextEnvelope, mergeContext } from "@mininglamp-oss/octo-runtime-protocol";
 import { validateImConfig } from "../lifecycle/configuration.js";
+import { compactHistoryGap, historyGapContext } from "../application/context-gap.js";
 export function createImInvocation(config, message, context, sessionKey, session, _signal, occurrenceId = message.messageId) {
     validateImConfig(config);
     assertContextEnvelope(context);
@@ -79,7 +80,13 @@ export function createImInvocation(config, message, context, sessionKey, session
     let submitted = context;
     let snapshot;
     // 执行默认项也占协议预算；只降级本渠道自动追加的辅助材料，不丢弃显式业务项。
-    for (const optional of ["history", "mention-instructions", undefined]) {
+    for (const optional of [
+        "history",
+        "history-gap-compact",
+        "mention-instructions",
+        "history-gap",
+        undefined
+    ]) {
         try {
             snapshot = mergeContext(defaults, submitted);
             break;
@@ -89,10 +96,53 @@ export function createImInvocation(config, message, context, sessionKey, session
                 throw error;
             submitted = {
                 ...submitted,
-                items: submitted.items.filter((item) => !(item.namespace === "extra.im" &&
-                    item.name === optional &&
-                    item.payload.automatic === true))
+                items: optional === "history-gap-compact"
+                    ? submitted.items.flatMap((item) => {
+                        if (item.namespace !== "extra.im" ||
+                            item.name !== "history-gap" ||
+                            item.payload.automatic !== true)
+                            return [item];
+                        const compact = compactHistoryGap(item);
+                        return compact ? [compact] : [];
+                    })
+                    : submitted.items.filter((item) => !(item.namespace === "extra.im" &&
+                        item.name === optional &&
+                        item.payload.automatic === true))
             };
+            if (optional === "history") {
+                const history = context.items.find((item) => item.namespace === "extra.im" &&
+                    item.name === "history" &&
+                    item.payload.automatic === true);
+                const source = history?.payload.source;
+                if (source &&
+                    [2, 5].includes(Number(source.channelType)) &&
+                    !submitted.items.some((item) => item.namespace === "extra.im" &&
+                        item.name === "history-gap" &&
+                        item.payload.automatic !== true)) {
+                    const existing = submitted.items.find((item) => item.namespace === "extra.im" && item.name === "history-gap");
+                    const replacement = existing
+                        ? {
+                            ...existing,
+                            payload: {
+                                ...existing.payload,
+                                status: "omitted",
+                                materialProvided: false,
+                                reason: "context-budget"
+                            }
+                        }
+                        : historyGapContext(source, message.messageId, {
+                            mode: "unavailable",
+                            beforeSeq: Number(history.payload.upperMessageSeq),
+                            retrieval: "omitted",
+                            reason: "context-budget"
+                        });
+                    submitted.items = submitted.items.filter((item) => !(item.namespace === "extra.im" &&
+                        item.name === "history-gap" &&
+                        item.payload.automatic === true));
+                    if (replacement)
+                        submitted.items.push(replacement);
+                }
+            }
         }
     }
     if (!snapshot)

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.d.ts

@@ -1,6 +1,7 @@
+import type { ImModuleDependencies } from "../ports.js";
 import type { ImInvocationInput } from "./dispatcher.js";
 import { type CanonicalEvent, type InvokeEnvironment } from "@mininglamp-oss/octo-runtime-protocol";
-import type { ImBotConfig, ImExecutionPort, ImTaskAttempt } from "../contracts.js";
+import type { ImBotConfig, ImTaskAttempt } from "../contracts.js";
 export declare const DEFAULT_CODEX_RETRY: Readonly<{
     enabled: true;
     max_consecutive_retries: 5;
@@ -18,7 +19,7 @@ export interface ImTaskClock {
 /** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
 export declare class ImTask {
     #private;
-    readonly host: ImExecutionPort;
+    readonly kernel: ImModuleDependencies["kernel"];
     readonly request: ImInvocationInput;
     readonly adapterType: string;
     readonly environment: InvokeEnvironment;
@@ -26,9 +27,11 @@ export declare class ImTask {
     readonly time: ImTaskClock;
     readonly attempts: ImTaskAttempt[];
     stopReason?: string;
-    constructor(host: ImExecutionPort, request: ImInvocationInput, adapterType: string, config: ImBotConfig, environment: InvokeEnvironment, onAttempt: (request: ImInvocationInput) => void, time?: ImTaskClock);
+    constructor(kernel: ImModuleDependencies["kernel"], request: ImInvocationInput, adapterType: string, config: ImBotConfig, environment: InvokeEnvironment, onAttempt: (request: ImInvocationInput) => void, time?: ImTaskClock);
     /** reset 只阻止后续尝试，不把 reset 变成取消当前 Provider 执行。 */
     stopRetries(): void;
+    /** owner stop 只取消执行和后续尝试；当前订阅须继续消费真实终态。 */
+    drain(reason?: string): Promise<void>;
     cancel(reason?: string): Promise<boolean>;
     events(): AsyncGenerator<CanonicalEvent>;
 }

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.js

@@ -2,6 +2,7 @@
 import { randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { setTimeout as delay } from "node:timers/promises";
+import { KernelError } from "@mininglamp-oss/octo-runtime-executor-kernel";
 export const DEFAULT_CODEX_RETRY = Object.freeze({
     enabled: true,
     max_consecutive_retries: 5,
@@ -24,7 +25,7 @@ const clock = {
 };
 /** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
 export class ImTask {
-    host;
+    kernel;
     request;
     adapterType;
     environment;
@@ -43,9 +44,10 @@ export class ImTask {
     #recoveryTimer;
     #replaySafe = true;
     #started = false;
+    #draining = false;
     stopReason;
-    constructor(host, request, adapterType, config, environment, onAttempt, time = clock) {
-        this.host = host;
+    constructor(kernel, request, adapterType, config, environment, onAttempt, time = clock) {
+        this.kernel = kernel;
         this.request = request;
         this.adapterType = adapterType;
         this.environment = environment;
@@ -61,12 +63,31 @@ export class ImTask {
     stopRetries() {
         this.#retryStop.abort();
     }
+    /** owner stop 只取消执行和后续尝试；当前订阅须继续消费真实终态。 */
+    async drain(reason = "IM shutdown") {
+        this.#draining = true;
+        this.stopRetries();
+        const active = this.#active;
+        if (!active)
+            return;
+        try {
+            this.#cancelPending ??= this.kernel.cancelInvocation(active.invocationId, reason);
+            await this.#cancelPending;
+        }
+        catch (error) {
+            // Kernel 可在订阅 ACK 时先确认终态并释放登记，业务迭代器此时仍可能等待交互展示。
+            // 登记缺失本身不是完成证据；只接受同次原流正常耗尽且包含真实终态，仍受 owner 共享期限约束。
+            if (!(error instanceof KernelError && error.code === "INVOCATION_NOT_TRACKED") ||
+                !(await active.finished))
+                throw error;
+        }
+    }
     async cancel(reason = "IM user stop") {
         this.#abort.abort(reason);
         if (!this.#active)
             return true; // 退避阶段也属于可停止的业务任务。
-        this.#cancelPending ??= this.host.cancel(this.#active, reason);
-        return (await this.#cancelPending).cancelled;
+        this.#cancelPending ??= this.kernel.cancelInvocation(this.#active.invocationId, reason);
+        return (await this.#cancelPending).accepted;
     }
     #stop(reason) {
         this.stopReason ??= reason;
@@ -142,7 +163,7 @@ export class ImTask {
         const clearDeadline = this.time.schedule(() => this.#stop("IM_TASK_DEADLINE"), deadline - this.time.now());
         let request = this.request;
         try {
-            while (!this.#signal.aborted) {
+            while (!this.#signal.aborted && !this.#draining) {
                 const remaining = Math.ceil(deadline - this.time.now());
                 if (remaining < 100) {
                     this.#stop("IM_TASK_DEADLINE");
@@ -154,7 +175,13 @@ export class ImTask {
                     if (item.namespace === "octo.execution" && item.name === "limits")
                         item.payload.run_timeout_ms = remaining;
                 this.onAttempt(request);
-                this.#active = request.invocationId;
+                let finish;
+                this.#active = {
+                    invocationId: request.invocationId,
+                    finished: new Promise((resolve) => {
+                        finish = resolve;
+                    })
+                };
                 this.#cancelPending = undefined;
                 const attempt = {
                     runId: request.runId,
@@ -163,8 +190,9 @@ export class ImTask {
                 };
                 this.attempts.push(attempt);
                 let terminal;
+                let confirmed = false;
                 try {
-                    for await (const event of this.host.invoke(request, {
+                    for await (const event of this.kernel.invoke(request, {
                         ...this.environment,
                         signal: this.#signal
                     })) {
@@ -181,6 +209,8 @@ export class ImTask {
                         else
                             yield event;
                     }
+                    // 看到终态后仍须正常耗尽：终态后的传输/控制错误不能被 drain 当成成功。
+                    confirmed = terminal !== undefined;
                 }
                 catch (error) {
                     attempt.outcome = "unknown";
@@ -190,6 +220,8 @@ export class ImTask {
                     // 必须等待消费结束及取消回执；未知结果不会进入下一次 invoke。
                     await this.#settleCancellation();
                     this.#active = undefined;
+                    // #cancelPending 只保存原始取消回执，不能反过来等待 finished，否则这里会循环等待。
+                    finish(confirmed);
                 }
                 if (!terminal)
                     throw new Error("IM_RUN_WITHOUT_TERMINAL");

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/extra.d.ts

@@ -1,3 +1,4 @@
-import { type ChannelDependencies, type ExtraInitializer, type ExtraContext, type JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+import { type ExtraInitializer, type ExtraContext, type JsonObject } from "@mininglamp-oss/octo-runtime-host-sdk";
+import type { GatewayDependencies } from "./ports.js";
 export declare const name = "channel-gateway";
-export default function load(context: ExtraContext, config: JsonObject): ExtraInitializer<ChannelDependencies>;
+export default function load(context: ExtraContext, config: JsonObject): ExtraInitializer<GatewayDependencies>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/extra.js

@@ -1,4 +1,4 @@
-import { createContextLoader } from "@mininglamp-oss/octo-runtime-daemon";
+import { createContextLoader } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { ImChannelManager } from "./lifecycle/manager.js";
 import { validateImBots, configuredCredential, imBotIdentity, IM_MAX_BOTS } from "./lifecycle/configuration.js";
 export const name = "channel-gateway";
@@ -28,9 +28,10 @@ async function initialize(context, config, dependencies) {
     }
     const allowed = spaces;
     channels = new ImChannelManager({
-        host: context.adapterHost,
+        kernel: context.kernel,
         signal: context.signal,
         log: context.log,
+        createSessionStore: dependencies.createSessionStore,
         // 只保存调用入口，不预取提示词；宿主更新业务存储后，下一个接纳的逻辑轮重新读取。
         prepareContexts: (bot, signal) => contexts.load(bot, signal),
         credentials: (bot) => Promise.resolve(configuredCredential(bot)),

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/index.d.ts

@@ -7,7 +7,10 @@ export { octoCliEnvironment } from "./execution/tool-environment.js";
 export { default, name } from "./extra.js";
 export { ImChannelManager } from "./lifecycle/manager.js";
 export { MemoryImSessionStore } from "./application/session-store.js";
-export type { ImSessionStore, ImSessionBinding } from "./application/session-store.js";
+export type { ImSessionStore, ImSessionBinding, ImSessionOccurrence } from "./application/session-store.js";
+export type { ImGapMetadata, ImGapTurnToken } from "./application/context-gap.js";
+export type { ImRulesContext, ImRulesVersions } from "./application/rules-context.js";
+export type { ImInvocationInput } from "./execution/dispatcher.js";
 export { validateImConfig, validateImBots, configuredCredential, imBotIdentity } from "./lifecycle/configuration.js";
 export { build_im_contexts } from "./transport/contexts.js";
 export { registerBot, WukongConnection } from "./transport/wukong.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/lifecycle/manager.d.ts

@@ -1,10 +1,10 @@
 import type { ImBotConfig } from "../contracts.js";
-import type { ImModuleDependencies } from "../ports.js";
-/** Serial updates replace only the target connection. */
+import type { ImChannelManagerDependencies } from "../ports.js";
+/** 串行替换单个 Bot；工厂句柄归 Manager，只有旧 endpoint 完整释放才允许替换。 */
 export declare class ImChannelManager {
     #private;
-    readonly dependencies: ImModuleDependencies;
-    constructor(dependencies: ImModuleDependencies);
+    readonly dependencies: ImChannelManagerDependencies;
+    constructor(dependencies: ImChannelManagerDependencies);
     get status(): Record<string, unknown>[];
     upsert(config: ImBotConfig): Promise<Record<string, unknown>>;
     remove(id: string): Promise<void>;