@next-open-ai/openbot 0.3.2 → 0.6.6

package/dist/gateway/channel/adapters/feishu.js

@@ -0,0 +1,218 @@
+/**
+ * 飞书通道适配器：使用 @larksuiteoapi/node-sdk WebSocket 长连接模式接收消息，API 发送回复。
+ */
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { dispatchMessage } from "../registry.js";
+function parseFeishuTextContent(content) {
+    try {
+        const obj = JSON.parse(content);
+        if (obj && typeof obj.text === "string")
+            return obj.text;
+        return String(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+/** 已处理的飞书 message_id 缓存，避免同一条消息被重复触发导致多条回复与顺序错乱。TTL 5 分钟。 */
+const PROCESSED_MESSAGE_IDS = new Map();
+const PROCESSED_TTL_MS = 5 * 60 * 1000;
+function isMessageAlreadyProcessed(messageId) {
+    const now = Date.now();
+    if (PROCESSED_MESSAGE_IDS.has(messageId)) {
+        const ts = PROCESSED_MESSAGE_IDS.get(messageId);
+        if (now - ts < PROCESSED_TTL_MS)
+            return true;
+        PROCESSED_MESSAGE_IDS.delete(messageId);
+    }
+    return false;
+}
+function markMessageProcessed(messageId) {
+    const now = Date.now();
+    PROCESSED_MESSAGE_IDS.set(messageId, now);
+    if (PROCESSED_MESSAGE_IDS.size > 5000) {
+        for (const [id, ts] of PROCESSED_MESSAGE_IDS.entries()) {
+            if (now - ts > PROCESSED_TTL_MS)
+                PROCESSED_MESSAGE_IDS.delete(id);
+        }
+    }
+}
+/**
+ * 飞书 WebSocket 入站：SDK WSClient + EventDispatcher，收到 im.message.receive_v1 后转 UnifiedMessage。
+ * 按 message_id 去重，同一条用户消息只处理一次，避免重复回复与顺序错乱。
+ */
+class FeishuWSInbound {
+    config;
+    wsClient = null;
+    messageHandler = null;
+    constructor(config) {
+        this.config = config;
+    }
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+    }
+    async start() {
+        if (this.wsClient)
+            return;
+        const { appId, appSecret } = this.config;
+        if (!appId?.trim() || !appSecret?.trim()) {
+            console.warn("[Feishu] appId/appSecret missing, skip WS start");
+            return;
+        }
+        const eventDispatcher = new Lark.EventDispatcher({}).register({
+            // 已读回执事件，无需处理，注册空 handler 避免 SDK 打 no handle 的 warn
+            "im.message.message_read_v1": async () => { },
+            "im.message.receive_v1": async (data) => {
+                const msg = data?.message;
+                if (!msg?.chat_id)
+                    return;
+                const messageId = msg?.message_id;
+                if (messageId && isMessageAlreadyProcessed(messageId)) {
+                    return;
+                }
+                if (messageId)
+                    markMessageProcessed(messageId);
+                const content = msg.content ? parseFeishuTextContent(msg.content) : "";
+                if (!content.trim())
+                    return;
+                const sender = data?.sender?.sender_id?.open_id ?? data?.sender?.sender_id?.user_id ?? "";
+                const unified = {
+                    channelId: "feishu",
+                    threadId: msg.chat_id,
+                    userId: sender || "unknown",
+                    userName: data?.sender?.sender_id?.name,
+                    messageText: content,
+                    replyTarget: "default",
+                    messageId,
+                    raw: data,
+                };
+                if (this.messageHandler) {
+                    await this.messageHandler(unified);
+                }
+                else {
+                    await dispatchMessage(unified);
+                }
+            },
+        });
+        this.wsClient = new Lark.WSClient({
+            appId,
+            appSecret,
+            loggerLevel: Lark.LoggerLevel.warn,
+        });
+        await this.wsClient.start({ eventDispatcher });
+        console.log("[Feishu] WS client started");
+    }
+    async stop() {
+        if (this.wsClient) {
+            try {
+                await this.wsClient.stop?.();
+            }
+            catch (e) {
+                console.warn("[Feishu] WS stop error", e);
+            }
+            this.wsClient = null;
+        }
+    }
+}
+/**
+ * 飞书 API 出站：用 Client 调发送消息接口。
+ */
+class FeishuApiOutbound {
+    client;
+    constructor(config) {
+        this.client = new Lark.Client({
+            appId: config.appId,
+            appSecret: config.appSecret,
+            appType: Lark.AppType.SelfBuild,
+            domain: Lark.Domain.Feishu,
+        });
+    }
+    async send(targetId, reply) {
+        if (!targetId || targetId === "default") {
+            console.error("[Feishu] send skipped: invalid receive_id (missing or 'default'), check threadId from event");
+            return;
+        }
+        const text = reply.text?.trim() || "(无内容)";
+        try {
+            await this.client.im.v1.message.create({
+                params: { receive_id_type: "chat_id" },
+                data: {
+                    receive_id: targetId,
+                    content: JSON.stringify({ text }),
+                    msg_type: "text",
+                },
+            });
+        }
+        catch (e) {
+            console.error("[Feishu] send message failed:", e);
+            throw e;
+        }
+    }
+    async sendStream(targetId) {
+        if (!targetId || targetId === "default") {
+            throw new Error("[Feishu] sendStream: invalid receive_id");
+        }
+        const initialCard = {
+            config: { wide_screen_mode: true },
+            header: { title: { tag: "plain_text", content: "🤔 思考中..." } },
+            elements: [{ tag: "div", text: { tag: "plain_text", content: "正在生成回答，请稍候..." } }],
+        };
+        const createRes = await this.client.im.v1.message.create({
+            params: { receive_id_type: "chat_id" },
+            data: {
+                receive_id: targetId,
+                msg_type: "interactive",
+                content: JSON.stringify(initialCard),
+            },
+        });
+        const messageId = createRes.data?.message_id;
+        if (!messageId) {
+            throw new Error("[Feishu] sendStream: create card did not return message_id");
+        }
+        const patch = async (content, title, showCursor) => {
+            const card = {
+                config: { wide_screen_mode: true },
+                header: { title: { tag: "plain_text", content: title } },
+                elements: [{ tag: "markdown", content: content + (showCursor ? " ▌" : "") }],
+            };
+            await this.client.im.v1.message.patch({
+                path: { message_id: messageId },
+                data: { content: JSON.stringify(card) },
+            });
+        };
+        return {
+            onChunk: async (accumulated) => {
+                try {
+                    await patch(accumulated || " ", "🤖 回答中...", true);
+                }
+                catch (e) {
+                    console.error("[Feishu] stream patch failed:", e);
+                }
+            },
+            onDone: async (accumulated) => {
+                try {
+                    await patch(accumulated || "(无内容)", "✅ 回答完成", false);
+                }
+                catch (e) {
+                    console.error("[Feishu] stream final patch failed:", e);
+                }
+            },
+        };
+    }
+}
+/**
+ * 飞书通道：WebSocket 入站 + API 出站，使用官方 Node SDK。
+ */
+export function createFeishuChannel(config) {
+    const inbound = new FeishuWSInbound(config);
+    const outbound = new FeishuApiOutbound(config);
+    // 入站回调统一走 registry 分发（会带上 channelId，找到本 channel 再处理）
+    inbound.setMessageHandler((msg) => dispatchMessage(msg));
+    return {
+        id: "feishu",
+        name: "飞书",
+        defaultAgentId: config.defaultAgentId ?? "default",
+        getInbounds: () => [inbound],
+        getOutbounds: () => [outbound],
+    };
+}

package/dist/gateway/channel/channel-core.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 通道核心：收 UnifiedMessage → 会话映射 → 调 Agent → 选 Outbound → 发 UnifiedReply。
+ */
+import type { UnifiedMessage, IChannel } from "./types.js";
+/**
+ * 处理一条入站消息：映射 session、跑 Agent、选出站并发送回复。
+ * 若 outbound 支持 sendStream，则用流式（先发卡片再逐次更新）；否则一次性 send。
+ */
+export declare function handleChannelMessage(channel: IChannel, msg: UnifiedMessage): Promise<void>;

package/dist/gateway/channel/channel-core.js

@@ -0,0 +1,127 @@
+import { runAgentAndCollectReply, runAgentAndStreamReply } from "./run-agent.js";
+import { getChannelSessionPersistence, persistChannelUserMessage, persistChannelAssistantMessage } from "./session-persistence.js";
+const STREAM_THROTTLE_MS = 280;
+function toSessionId(channelId, threadId) {
+    return `channel:${channelId}:${threadId}`;
+}
+/** 节流：在间隔内只执行最后一次 */
+function throttle(fn, ms) {
+    let timer = null;
+    let lastRun = 0;
+    const run = () => {
+        const now = Date.now();
+        if (timer)
+            clearTimeout(timer);
+        const elapsed = now - lastRun;
+        if (elapsed >= ms || lastRun === 0) {
+            lastRun = now;
+            fn();
+        }
+        else {
+            timer = setTimeout(() => {
+                timer = null;
+                lastRun = Date.now();
+                fn();
+            }, ms - elapsed);
+        }
+    };
+    const flush = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        lastRun = Date.now();
+        fn();
+    };
+    const cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    };
+    return { run, flush, cancel };
+}
+/**
+ * 处理一条入站消息：映射 session、跑 Agent、选出站并发送回复。
+ * 若 outbound 支持 sendStream，则用流式（先发卡片再逐次更新）；否则一次性 send。
+ */
+export async function handleChannelMessage(channel, msg) {
+    const sessionId = toSessionId(msg.channelId, msg.threadId);
+    const defaultAgentId = channel.defaultAgentId ?? "default";
+    // 当前 agent：已存（DB）> 通道默认，保证对话中切换 agent 后下次仍用新 agent
+    const persistence = getChannelSessionPersistence();
+    const currentAgentId = persistence?.getSession(sessionId)?.agentId ?? defaultAgentId;
+    const outbound = channel.getOutboundForMessage
+        ? channel.getOutboundForMessage(msg)
+        : channel.getOutbounds()[0];
+    if (!outbound) {
+        console.warn("[ChannelCore] no outbound for message", msg.channelId, msg.threadId);
+        return;
+    }
+    const threadId = msg.threadId;
+    if (!threadId || threadId === "default") {
+        console.warn("[ChannelCore] invalid threadId, skip reply");
+        return;
+    }
+    // 与 Web/Desktop 统一：通道会话入库并追加用户消息（用 currentAgentId）
+    await persistChannelUserMessage(sessionId, {
+        agentId: currentAgentId,
+        title: msg.messageText?.trim().slice(0, 50) || undefined,
+        messageText: msg.messageText?.trim() || "",
+    });
+    const useStream = typeof outbound.sendStream === "function";
+    if (useStream) {
+        let sink;
+        try {
+            sink = await outbound.sendStream(threadId);
+        }
+        catch (err) {
+            console.error("[ChannelCore] sendStream init failed:", err);
+            const reply = { text: "发信失败，请稍后再试。" };
+            await outbound.send(threadId, reply);
+            return;
+        }
+        let accumulated = "";
+        let donePromise = null;
+        const throttled = throttle(() => {
+            if (sink.onChunk)
+                void Promise.resolve(sink.onChunk(accumulated)).catch((e) => console.error("[ChannelCore] stream onChunk error:", e));
+        }, STREAM_THROTTLE_MS);
+        try {
+            await runAgentAndStreamReply({ sessionId, message: msg.messageText, agentId: currentAgentId }, {
+                onChunk(delta) {
+                    accumulated += delta;
+                    throttled.run();
+                },
+                onDone() {
+                    throttled.cancel();
+                    const final = accumulated.trim() || "(无文本回复)";
+                    persistChannelAssistantMessage(sessionId, final);
+                    donePromise = Promise.resolve(sink.onDone(final)).catch((e) => console.error("[ChannelCore] stream onDone error:", e));
+                },
+            });
+            if (donePromise)
+                await donePromise;
+        }
+        catch (err) {
+            console.error("[ChannelCore] runAgent failed:", err);
+            throttled.cancel();
+            const fallback = accumulated.trim() || "处理时出错，请稍后再试。";
+            await Promise.resolve(sink.onDone(fallback)).catch(() => { });
+        }
+        return;
+    }
+    let replyText;
+    try {
+        replyText = await runAgentAndCollectReply({
+            sessionId,
+            message: msg.messageText,
+            agentId: currentAgentId,
+        });
+    }
+    catch (err) {
+        console.error("[ChannelCore] runAgent failed:", err);
+        replyText = "处理时出错，请稍后再试。";
+    }
+    persistChannelAssistantMessage(sessionId, replyText);
+    const reply = { text: replyText };
+    await outbound.send(threadId, reply);
+}

package/dist/gateway/channel/registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 通道注册表：按 channelId 注册与获取通道，供入站回调分发。
+ */
+import type { IChannel, UnifiedMessage } from "./types.js";
+export declare function registerChannel(channel: IChannel): void;
+export declare function unregisterChannel(channelId: string): void;
+export declare function getChannel(channelId: string): IChannel | undefined;
+export declare function listChannels(): IChannel[];
+/**
+ * 入站收到统一消息时调用：按 channelId 找到通道并交给核心处理。
+ */
+export declare function dispatchMessage(msg: UnifiedMessage): Promise<void>;
+/** 启动所有已注册通道的入站传输 */
+export declare function startAllChannels(): Promise<void>;
+/** 停止所有已注册通道的入站传输 */
+export declare function stopAllChannels(): Promise<void>;

package/dist/gateway/channel/registry.js

@@ -0,0 +1,54 @@
+import { handleChannelMessage } from "./channel-core.js";
+const channels = new Map();
+export function registerChannel(channel) {
+    if (channels.has(channel.id)) {
+        console.warn(`[ChannelRegistry] overwriting channel ${channel.id}`);
+    }
+    channels.set(channel.id, channel);
+}
+export function unregisterChannel(channelId) {
+    channels.delete(channelId);
+}
+export function getChannel(channelId) {
+    return channels.get(channelId);
+}
+export function listChannels() {
+    return Array.from(channels.values());
+}
+/**
+ * 入站收到统一消息时调用：按 channelId 找到通道并交给核心处理。
+ */
+export async function dispatchMessage(msg) {
+    const channel = channels.get(msg.channelId);
+    if (!channel) {
+        console.warn("[ChannelRegistry] no channel for", msg.channelId);
+        return;
+    }
+    await handleChannelMessage(channel, msg);
+}
+/** 启动所有已注册通道的入站传输 */
+export async function startAllChannels() {
+    for (const ch of channels.values()) {
+        for (const inbound of ch.getInbounds()) {
+            try {
+                await inbound.start();
+            }
+            catch (e) {
+                console.warn("[ChannelRegistry] start inbound failed for", ch.id, e);
+            }
+        }
+    }
+}
+/** 停止所有已注册通道的入站传输 */
+export async function stopAllChannels() {
+    for (const ch of channels.values()) {
+        for (const inbound of ch.getInbounds()) {
+            try {
+                await inbound.stop();
+            }
+            catch (e) {
+                console.warn("[ChannelRegistry] stop inbound failed for", ch.id, e);
+            }
+        }
+    }
+}

package/dist/gateway/channel/run-agent.d.ts

@@ -0,0 +1,26 @@
+export interface RunAgentForChannelOptions {
+    /** 会话 ID，建议 channel:platform:threadId */
+    sessionId: string;
+    /** 用户消息正文 */
+    message: string;
+    /** 使用的 agentId，缺省 default */
+    agentId?: string;
+}
+export interface RunAgentStreamCallbacks {
+    /** 每收到一段助手文本 delta 时调用 */
+    onChunk(delta: string): void;
+    /** turn_end 时可选调用，供通道按需处理（如本小轮结束、tool 结果已出） */
+    onTurnEnd?: () => void;
+    /** agent_end 时调用，表示整轮对话真正结束 */
+    onDone(): void;
+}
+/**
+ * 使用现有 agentManager 跑一轮对话，以流式回调方式推送助手回复（onChunk/onDone）。
+ * onDone 在 agent_end 时调用，保证「对话真正结束」语义（多轮 tool+文本合并为一条回复）。
+ */
+export declare function runAgentAndStreamReply(options: RunAgentForChannelOptions, callbacks: RunAgentStreamCallbacks): Promise<void>;
+/**
+ * 使用现有 agentManager 跑一轮对话，收集助手完整回复文本后返回。
+ * 不依赖 WebSocket 客户端，供通道核心调用。
+ */
+export declare function runAgentAndCollectReply(options: RunAgentForChannelOptions): Promise<string>;

package/dist/gateway/channel/run-agent.js

@@ -0,0 +1,137 @@
+/**
+ * 通道用：跑 Agent 并收集完整回复文本（无 WebSocket 客户端）。
+ */
+import { agentManager } from "../../core/agent/agent-manager.js";
+import { getDesktopConfig, loadDesktopAgentConfig } from "../../core/config/desktop-config.js";
+import { getExperienceContextForUserMessage } from "../../core/memory/index.js";
+/**
+ * 使用现有 agentManager 跑一轮对话，以流式回调方式推送助手回复（onChunk/onDone）。
+ * onDone 在 agent_end 时调用，保证「对话真正结束」语义（多轮 tool+文本合并为一条回复）。
+ */
+export async function runAgentAndStreamReply(options, callbacks) {
+    const { sessionId, message, agentId: optionAgentId } = options;
+    const sessionAgentId = optionAgentId ?? "default";
+    let workspace = "default";
+    let provider;
+    let modelId;
+    let apiKey;
+    const agentConfig = await loadDesktopAgentConfig(sessionAgentId);
+    if (agentConfig) {
+        if (agentConfig.workspace)
+            workspace = agentConfig.workspace;
+        provider = agentConfig.provider;
+        modelId = agentConfig.model;
+        if (agentConfig.apiKey)
+            apiKey = agentConfig.apiKey;
+    }
+    const { maxAgentSessions } = getDesktopConfig();
+    const session = await agentManager.getOrCreateSession(sessionId, {
+        agentId: sessionAgentId,
+        workspace,
+        provider,
+        modelId,
+        apiKey,
+        maxSessions: maxAgentSessions,
+        targetAgentId: sessionAgentId,
+        mcpServers: agentConfig?.mcpServers,
+        systemPrompt: agentConfig?.systemPrompt,
+    });
+    let resolveDone;
+    const donePromise = new Promise((r) => {
+        resolveDone = r;
+    });
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type === "message_update") {
+            const update = event;
+            if (update.assistantMessageEvent?.type === "text_delta" && update.assistantMessageEvent?.delta) {
+                callbacks.onChunk(update.assistantMessageEvent.delta);
+            }
+        }
+        else if (event.type === "turn_end") {
+            callbacks.onTurnEnd?.();
+        }
+        else if (event.type === "agent_end") {
+            callbacks.onDone();
+            resolveDone();
+        }
+    });
+    try {
+        const experienceBlock = await getExperienceContextForUserMessage();
+        const userMessageToSend = experienceBlock.trim().length > 0
+            ? `${experienceBlock}\n\n用户问题：\n${message}`
+            : message;
+        await session.sendUserMessage(userMessageToSend, { deliverAs: "followUp" });
+        await Promise.race([
+            donePromise,
+            new Promise((_, rej) => setTimeout(() => rej(new Error("Channel agent reply timeout")), 120_000)),
+        ]);
+    }
+    finally {
+        unsubscribe();
+    }
+}
+/**
+ * 使用现有 agentManager 跑一轮对话，收集助手完整回复文本后返回。
+ * 不依赖 WebSocket 客户端，供通道核心调用。
+ */
+export async function runAgentAndCollectReply(options) {
+    const { sessionId, message, agentId: optionAgentId } = options;
+    const sessionAgentId = optionAgentId ?? "default";
+    let workspace = "default";
+    let provider;
+    let modelId;
+    let apiKey;
+    const agentConfig = await loadDesktopAgentConfig(sessionAgentId);
+    if (agentConfig) {
+        if (agentConfig.workspace)
+            workspace = agentConfig.workspace;
+        provider = agentConfig.provider;
+        modelId = agentConfig.model;
+        if (agentConfig.apiKey)
+            apiKey = agentConfig.apiKey;
+    }
+    const { maxAgentSessions } = getDesktopConfig();
+    const session = await agentManager.getOrCreateSession(sessionId, {
+        agentId: sessionAgentId,
+        workspace,
+        provider,
+        modelId,
+        apiKey,
+        maxSessions: maxAgentSessions,
+        targetAgentId: sessionAgentId,
+        mcpServers: agentConfig?.mcpServers,
+        systemPrompt: agentConfig?.systemPrompt,
+    });
+    const chunks = [];
+    let resolveDone;
+    const donePromise = new Promise((r) => {
+        resolveDone = r;
+    });
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type === "message_update") {
+            const update = event;
+            if (update.assistantMessageEvent?.type === "text_delta" && update.assistantMessageEvent?.delta) {
+                chunks.push(update.assistantMessageEvent.delta);
+            }
+        }
+        else if (event.type === "agent_end") {
+            resolveDone();
+        }
+    });
+    try {
+        const experienceBlock = await getExperienceContextForUserMessage();
+        const userMessageToSend = experienceBlock.trim().length > 0
+            ? `${experienceBlock}\n\n用户问题：\n${message}`
+            : message;
+        await session.sendUserMessage(userMessageToSend, { deliverAs: "followUp" });
+        // 等待 agent_end（整轮对话真正结束）或超时
+        await Promise.race([
+            donePromise,
+            new Promise((_, rej) => setTimeout(() => rej(new Error("Channel agent reply timeout")), 120_000)),
+        ]);
+    }
+    finally {
+        unsubscribe();
+    }
+    return chunks.join("").trim() || "(无文本回复)";
+}

package/dist/gateway/channel/session-persistence.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 通道会话持久化：与 Web/Desktop 统一使用同一套 session + chat_messages 入库。
+ * 由 Gateway 启动时注入 AgentsService，通道在处理消息前后调用 ensureSession / appendMessage。
+ */
+export type SessionType = "chat" | "scheduled" | "system";
+export interface IChannelSessionPersistence {
+    getOrCreateSession(sessionId: string, options?: {
+        agentId?: string;
+        workspace?: string;
+        title?: string;
+        type?: SessionType;
+    }): Promise<unknown>;
+    getSession(sessionId: string): {
+        agentId?: string;
+    } | undefined;
+    appendMessage(sessionId: string, role: "user" | "assistant", content: string, options?: {
+        toolCalls?: unknown[];
+        contentParts?: unknown[];
+    }): void;
+}
+export declare function setChannelSessionPersistence(service: IChannelSessionPersistence | null): void;
+export declare function getChannelSessionPersistence(): IChannelSessionPersistence | null;
+/**
+ * 确保通道会话已入库（getOrCreateSession），并追加一条用户消息。
+ * 在跑 Agent 前调用；若未注入持久化则静默跳过。
+ */
+export declare function persistChannelUserMessage(sessionId: string, options: {
+    agentId: string;
+    title?: string;
+    messageText: string;
+}): Promise<void>;
+/**
+ * 通道本轮助手回复结束时，将助手消息入库。
+ * 在 onDone 时调用；若未注入持久化则静默跳过。
+ */
+export declare function persistChannelAssistantMessage(sessionId: string, content: string): void;

package/dist/gateway/channel/session-persistence.js

@@ -0,0 +1,46 @@
+/**
+ * 通道会话持久化：与 Web/Desktop 统一使用同一套 session + chat_messages 入库。
+ * 由 Gateway 启动时注入 AgentsService，通道在处理消息前后调用 ensureSession / appendMessage。
+ */
+let persistence = null;
+export function setChannelSessionPersistence(service) {
+    persistence = service;
+}
+export function getChannelSessionPersistence() {
+    return persistence;
+}
+/**
+ * 确保通道会话已入库（getOrCreateSession），并追加一条用户消息。
+ * 在跑 Agent 前调用；若未注入持久化则静默跳过。
+ */
+export async function persistChannelUserMessage(sessionId, options) {
+    const p = getChannelSessionPersistence();
+    if (!p)
+        return;
+    try {
+        await p.getOrCreateSession(sessionId, {
+            agentId: options.agentId,
+            title: options.title ?? (options.messageText.slice(0, 50) || undefined),
+            type: "chat",
+        });
+        p.appendMessage(sessionId, "user", options.messageText);
+    }
+    catch (e) {
+        console.warn("[ChannelSessionPersistence] persist user message failed:", e);
+    }
+}
+/**
+ * 通道本轮助手回复结束时，将助手消息入库。
+ * 在 onDone 时调用；若未注入持久化则静默跳过。
+ */
+export function persistChannelAssistantMessage(sessionId, content) {
+    const p = getChannelSessionPersistence();
+    if (!p)
+        return;
+    try {
+        p.appendMessage(sessionId, "assistant", content);
+    }
+    catch (e) {
+        console.warn("[ChannelSessionPersistence] persist assistant message failed:", e);
+    }
+}