@next-open-ai/openbot 0.3.2 → 0.6.8

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

@@ -0,0 +1,135 @@
+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();
+                },
+                onTurnEnd() {
+                    throttled.flush();
+                    if (sink.onTurnEnd)
+                        void Promise.resolve(sink.onTurnEnd(accumulated)).catch((e) => console.error("[ChannelCore] stream onTurnEnd error:", e));
+                },
+                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;
+            await msg.ack?.(undefined);
+        }
+        catch (err) {
+            console.error("[ChannelCore] runAgent failed:", err);
+            throttled.cancel();
+            const fallback = accumulated.trim() || "处理时出错，请稍后再试。";
+            await Promise.resolve(sink.onDone(fallback)).catch(() => { });
+            await msg.ack?.(undefined);
+        }
+        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 };
+    const sendResult = await outbound.send(threadId, reply);
+    await msg.ack?.(sendResult);
+}

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);
+    }
+}

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

@@ -0,0 +1,74 @@
+/**
+ * 通道模块统一类型：与传输方式（webhook / 长连接）解耦。
+ */
+/** 统一入站消息：所有入站解析后的共同结构 */
+export interface UnifiedMessage {
+    /** 通道标识，如 feishu / telegram */
+    channelId: string;
+    /** 平台内会话/群组/单聊标识，回复时用 */
+    threadId: string;
+    /** 平台内用户标识 */
+    userId: string;
+    /** 用户显示名（可选） */
+    userName?: string;
+    /** 消息正文 */
+    messageText: string;
+    /** 附件（可选） */
+    attachments?: {
+        type: string;
+        url?: string;
+        name?: string;
+    }[];
+    /** 原始 payload（排查用） */
+    raw?: unknown;
+    /** 回复应交给哪个出站，如 "default" 或 connectionId */
+    replyTarget?: string;
+    /** 平台消息 ID（可选，用于回复引用等） */
+    messageId?: string;
+    /** 通道可选：回复发送完成后调用的 ack（如钉钉 Stream 需回调响应防重试），参数为 send 返回值 */
+    ack?: (sendResult?: unknown) => void | Promise<void>;
+}
+/** 统一出站回复 */
+export interface UnifiedReply {
+    text: string;
+    attachments?: {
+        type: string;
+        url?: string;
+        name?: string;
+    }[];
+}
+/** 入站传输：从外部收数据 → 产出 UnifiedMessage */
+export interface IInboundTransport {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** 设置收到消息时的回调 */
+    setMessageHandler(handler: (msg: UnifiedMessage) => void | Promise<void>): void;
+}
+/** 流式出站：先发一条占位消息，再由调用方按累积内容多次更新。返回的 sink 由 channel-core 在 onChunk / onTurnEnd / onDone 时调用。 */
+export interface StreamSink {
+    /** 更新当前已累积的全文（节流后调用），通道可用来做占位或实时更新 */
+    onChunk(accumulated: string): void | Promise<void>;
+    /** 可选：agent 每轮结束（turn_end）时调用，通道可在此发一条消息（如钉钉按轮发） */
+    onTurnEnd?(accumulated: string): void | Promise<void>;
+    /** 流结束，做最终一次更新 */
+    onDone(accumulated: string): void | Promise<void>;
+}
+/** 出站传输：将 UnifiedReply 发到外部；返回值可传给 UnifiedMessage.ack */
+export interface IOutboundTransport {
+    send(targetId: string, reply: UnifiedReply): Promise<unknown>;
+    /** 可选：该出站是否还能往 targetId 发（如连接是否有效） */
+    canSend?(targetId: string): boolean;
+    /** 可选：流式发送。先创建占位消息，返回 sink 供调用方按累积内容更新（如飞书 create + patch）。 */
+    sendStream?(targetId: string): Promise<StreamSink>;
+}
+/** 通道：身份 + 入站/出站列表 + 回复路由 */
+export interface IChannel {
+    id: string;
+    name: string;
+    /** 默认 agentId，用于会话 */
+    defaultAgentId?: string;
+    getInbounds(): IInboundTransport[];
+    getOutbounds(): IOutboundTransport[];
+    /** 根据消息或 threadId 选择出站；默认返回第一个 outbound */
+    getOutboundForMessage?(msg: UnifiedMessage): IOutboundTransport | undefined;
+}

package/dist/gateway/channel/types.js

@@ -0,0 +1,4 @@
+/**
+ * 通道模块统一类型：与传输方式（webhook / 长连接）解耦。
+ */
+export {};

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

@@ -1,6 +1,5 @@
 /**
- * 通道模块 HTTP 处理（占位）。
- * 后续：接收外部 webhook、回调，校验后转内部事件；当前返回 501。
+ * 通道模块 HTTP 处理：GET 列出已配置通道；具体入站由各通道（如飞书 WebSocket）自行处理。
  */
-import type { Request, Response } from 'express';
-export declare function handleChannel(_req: Request, res: Response): void;
+import type { Request, Response } from "express";
+export declare function handleChannel(req: Request, res: Response): void;

package/dist/gateway/channel-handler.js

@@ -1,3 +1,9 @@
-export function handleChannel(_req, res) {
-    res.status(501).setHeader('Content-Type', 'application/json').end(JSON.stringify({ ok: false, message: 'Channel module not implemented yet' }));
+import { listChannels } from "./channel/registry.js";
+export function handleChannel(req, res) {
+    if (req.method === "GET") {
+        const channels = listChannels().map((c) => ({ id: c.id, name: c.name }));
+        res.status(200).setHeader("Content-Type", "application/json").end(JSON.stringify({ ok: true, channels }));
+        return;
+    }
+    res.status(404).setHeader("Content-Type", "application/json").end(JSON.stringify({ ok: false, message: "Not found" }));
 }

package/dist/gateway/methods/agent-chat.js

@@ -1,8 +1,10 @@
 import { agentManager } from "../../core/agent/agent-manager.js";
+import { getSessionCurrentAgentResolver, getSessionCurrentAgentUpdater } from "../../core/session-current-agent.js";
 import { getExperienceContextForUserMessage } from "../../core/memory/index.js";
 import { send, createEvent } from "../utils.js";
 import { connectedClients } from "../clients.js";
 import { getDesktopConfig, loadDesktopAgentConfig } from "../../core/config/desktop-config.js";
+const COMPOSITE_KEY_SEP = "::";
 /**
  * Broadcast message to all clients subscribed to a session
  */
@@ -31,14 +33,21 @@ export async function handleAgentChat(client, params) {
 }
 async function handleAgentChatInner(client, targetSessionId, message, params) {
     const { targetAgentId } = params;
-    // 客户端在 connect 或 agent.chat 传入 agentId/sessionType，Gateway 不再请求 Nest
-    const sessionAgentId = params.agentId ?? client.agentId ?? "default";
     const sessionType = params.sessionType ?? client.sessionType ?? "chat";
+    // 当前 agent：请求传入 > 已存（DB）> 连接/默认
+    const resolveCurrentAgent = getSessionCurrentAgentResolver();
+    const storedAgentId = resolveCurrentAgent?.(targetSessionId);
+    const clientAgentId = params.agentId ?? client.agentId ?? "default";
+    let currentAgentId = params.agentId ?? storedAgentId ?? clientAgentId ?? "default";
+    if (params.agentId) {
+        getSessionCurrentAgentUpdater()?.(targetSessionId, params.agentId);
+        currentAgentId = params.agentId;
+    }
     let workspace = "default";
     let provider;
     let modelId;
     let apiKey;
-    const agentConfig = await loadDesktopAgentConfig(sessionAgentId);
+    const agentConfig = await loadDesktopAgentConfig(currentAgentId);
     if (agentConfig) {
         if (agentConfig.workspace)
             workspace = agentConfig.workspace;
@@ -47,17 +56,16 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
         if (agentConfig.apiKey)
             apiKey = agentConfig.apiKey;
     }
-    // system / scheduled：每次对话前先删再建，对话结束马上关闭，节省资源
     const isEphemeralSession = sessionType === "system" || sessionType === "scheduled";
     if (isEphemeralSession) {
-        agentManager.deleteSession(targetSessionId);
+        agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId);
     }
-    // system 会话用请求里的 targetAgentId；chat/scheduled 用 session 对应的 agentId 传给 install_skill
-    const effectiveTargetAgentId = sessionType === "system" ? targetAgentId : sessionAgentId;
+    const effectiveTargetAgentId = sessionType === "system" ? targetAgentId : currentAgentId;
     const { maxAgentSessions } = getDesktopConfig();
     let session;
     try {
         session = await agentManager.getOrCreateSession(targetSessionId, {
+            agentId: currentAgentId,
             workspace,
             provider,
             modelId,
@@ -65,6 +73,7 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             maxSessions: maxAgentSessions,
             targetAgentId: effectiveTargetAgentId,
             mcpServers: agentConfig?.mcpServers,
+            systemPrompt: agentConfig?.systemPrompt,
         });
     }
     catch (err) {
@@ -75,7 +84,7 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
         }
         throw err;
     }
-    // Set up event listener for streaming
+    // 向各通道广播：turn_end（本小轮结束）、agent_end（整轮对话结束），并保留 message_complete / conversation_end 兼容。各端按需处理。
     const unsubscribe = session.subscribe((event) => {
         // console.log(`Agent event received: ${event.type}`); // Reduce noise
         let wsMessage = null;
@@ -112,17 +121,26 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             const usagePayload = promptTokens > 0 || completionTokens > 0
                 ? { promptTokens, completionTokens }
                 : undefined;
-            wsMessage = createEvent("message_complete", {
+            const turnPayload = {
                 sessionId: targetSessionId,
                 content: "",
                 ...(usagePayload && { usage: usagePayload }),
-            });
+            };
+            broadcastToSession(targetSessionId, createEvent("turn_end", turnPayload));
+            broadcastToSession(targetSessionId, createEvent("message_complete", turnPayload));
+            wsMessage = null;
+        }
+        else if (event.type === "agent_end") {
+            const agentPayload = { sessionId: targetSessionId };
+            broadcastToSession(targetSessionId, createEvent("agent_end", agentPayload));
+            broadcastToSession(targetSessionId, createEvent("conversation_end", agentPayload));
+            wsMessage = null;
         }
         if (wsMessage) {
             broadcastToSession(targetSessionId, wsMessage);
         }
-        if (event.type === "turn_end" && isEphemeralSession) {
-            agentManager.deleteSession(targetSessionId);
+        if (event.type === "agent_end" && isEphemeralSession) {
+            agentManager.deleteSession(targetSessionId + COMPOSITE_KEY_SEP + currentAgentId);
         }
     });
     try {