@next-open-ai/openbot 0.3.2 → 0.6.8

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

@@ -0,0 +1,190 @@
+/**
+ * 钉钉通道适配器：使用 dingtalk-stream SDK Stream 模式接收机器人消息，通过 sessionWebhook 回传回复。
+ */
+import { DWClient, EventAck, TOPIC_ROBOT } from "dingtalk-stream";
+import { dispatchMessage } from "../registry.js";
+/** conversationId -> sessionWebhook，用于回复时 POST；收到新消息时更新 */
+const sessionWebhookByConversation = new Map();
+/**
+ * 钉钉 Stream 入站：DWClient + registerCallbackListener(TOPIC_ROBOT)，解析 RobotMessage 转 UnifiedMessage。
+ * 回复发送完成后需调用 ack（socketCallBackResponse）避免钉钉重试。
+ */
+class DingTalkStreamInbound {
+    client;
+    messageHandler = null;
+    constructor(client) {
+        this.client = client;
+    }
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+    }
+    async start() {
+        this.client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
+            try {
+                const data = JSON.parse(res.data);
+                const conversationId = data.conversationId;
+                const sessionWebhook = data.sessionWebhook;
+                if (sessionWebhook) {
+                    sessionWebhookByConversation.set(conversationId, sessionWebhook);
+                }
+                const textContent = data.msgtype === "text" && data.text?.content ? data.text.content.trim() : "";
+                if (!textContent)
+                    return;
+                const messageId = res.headers?.messageId ?? "";
+                const unified = {
+                    channelId: "dingtalk",
+                    threadId: conversationId,
+                    userId: data.senderStaffId ?? data.senderId ?? "unknown",
+                    userName: data.senderNick,
+                    messageText: textContent,
+                    replyTarget: "default",
+                    messageId,
+                    raw: data,
+                    ack: (sendResult) => {
+                        if (messageId) {
+                            this.client.socketCallBackResponse(messageId, sendResult ?? {});
+                        }
+                    },
+                };
+                if (this.messageHandler) {
+                    await this.messageHandler(unified);
+                }
+                else {
+                    await dispatchMessage(unified);
+                }
+            }
+            catch (e) {
+                console.error("[DingTalk] onBotMessage error:", e);
+            }
+        });
+        this.client.registerAllEventListener(() => ({ status: EventAck.SUCCESS }));
+        await this.client.connect();
+        console.log("[DingTalk] Stream client connected");
+    }
+    async stop() {
+        try {
+            this.client.disconnect();
+        }
+        catch (e) {
+            console.warn("[DingTalk] disconnect error", e);
+        }
+    }
+}
+/**
+ * 钉钉出站：通过 sessionWebhook POST 发送文本回复（需 access_token）。
+ * 支持 sendStream：按 agent 每轮（turn_end）发一条消息，不拆解最终回答。
+ */
+class DingTalkWebhookOutbound {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async postOne(sessionWebhook, text) {
+        const accessToken = await this.client.getAccessToken();
+        const body = JSON.stringify({
+            msgtype: "text",
+            text: { content: text },
+        });
+        const res = await fetch(sessionWebhook, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-acs-dingtalk-access-token": accessToken,
+            },
+            body,
+        });
+        return res.json().catch(() => ({}));
+    }
+    async send(targetId, reply) {
+        const sessionWebhook = sessionWebhookByConversation.get(targetId);
+        if (!sessionWebhook) {
+            console.error("[DingTalk] send skipped: no sessionWebhook for conversationId", targetId);
+            return undefined;
+        }
+        const text = reply.text?.trim() || "(无内容)";
+        try {
+            return await this.postOne(sessionWebhook, text);
+        }
+        catch (e) {
+            console.error("[DingTalk] send message failed:", e);
+            throw e;
+        }
+    }
+    async sendStream(targetId) {
+        const sessionWebhook = sessionWebhookByConversation.get(targetId);
+        if (!sessionWebhook) {
+            throw new Error("[DingTalk] sendStream: no sessionWebhook for conversationId " + targetId);
+        }
+        /** 已发送的字符右边界，[lastSentIndex, accumulated.length) 为未发送 */
+        let lastSentIndex = 0;
+        /** 串行锁：onTurnEnd 与 onDone 可能不 await，必须顺序执行发送，避免重复发同一段 */
+        let sendLock = Promise.resolve();
+        const sendOne = (text) => {
+            if (!text.trim())
+                return Promise.resolve();
+            return this.postOne(sessionWebhook, text.trim()).then(() => { }, (e) => {
+                console.error("[DingTalk] sendStream post failed:", e);
+            });
+        };
+        /** 仅发送尚未发送的区间，并推进 lastSentIndex；在锁内执行 */
+        const flushPending = (accumulated) => {
+            const pending = accumulated.slice(lastSentIndex).trim();
+            if (!pending)
+                return Promise.resolve();
+            return sendOne(pending).then(() => {
+                lastSentIndex = accumulated.length;
+            });
+        };
+        return {
+            onChunk: async () => {
+                // 钉钉按轮发，不按 chunk 发
+            },
+            onTurnEnd: async (accumulated) => {
+                sendLock = sendLock.then(() => flushPending(accumulated));
+                await sendLock;
+            },
+            onDone: async (accumulated) => {
+                const final = accumulated.trim() || "(无内容)";
+                sendLock = sendLock.then(() => {
+                    const remaining = final.slice(lastSentIndex).trim();
+                    if (remaining) {
+                        return sendOne(remaining).then(() => {
+                            lastSentIndex = final.length;
+                        });
+                    }
+                    if (lastSentIndex === 0) {
+                        return sendOne(final).then(() => {
+                            lastSentIndex = final.length;
+                        });
+                    }
+                    return Promise.resolve();
+                });
+                await sendLock;
+            },
+        };
+    }
+}
+/**
+ * 钉钉通道：Stream 入站 + Webhook 出站，共用一个 DWClient。
+ */
+export function createDingTalkChannel(config) {
+    const { clientId, clientSecret } = config;
+    if (!clientId?.trim() || !clientSecret?.trim()) {
+        throw new Error("[DingTalk] clientId and clientSecret are required");
+    }
+    const client = new DWClient({
+        clientId: clientId.trim(),
+        clientSecret: clientSecret.trim(),
+        debug: false,
+    });
+    const inbound = new DingTalkStreamInbound(client);
+    const outbound = new DingTalkWebhookOutbound(client);
+    inbound.setMessageHandler((msg) => dispatchMessage(msg));
+    return {
+        id: "dingtalk",
+        name: "钉钉",
+        defaultAgentId: config.defaultAgentId ?? "default",
+        getInbounds: () => [inbound],
+        getOutbounds: () => [outbound],
+    };
+}

package/dist/gateway/channel/adapters/feishu.d.ts

@@ -0,0 +1,11 @@
+import type { IChannel } from "../types.js";
+export interface FeishuChannelConfig {
+    appId: string;
+    appSecret: string;
+    /** 默认绑定的 agentId */
+    defaultAgentId?: string;
+}
+/**
+ * 飞书通道：WebSocket 入站 + API 出站，使用官方 Node SDK。
+ */
+export declare function createFeishuChannel(config: FeishuChannelConfig): IChannel;

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/adapters/telegram.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Telegram 通道适配器：长轮询（getUpdates）接收消息，sendMessage / editMessageText 发送与流式更新。
+ * 桌面端无公网 URL 时用 long polling 是官方推荐方式；支持流式输出（先发占位再 editMessageText 更新）。
+ */
+import type { IChannel } from "../types.js";
+export interface TelegramChannelConfig {
+    botToken: string;
+    /** 默认绑定的 agentId */
+    defaultAgentId?: string;
+}
+/**
+ * Telegram 通道：长轮询入站 + API 出站，支持流式（editMessageText）。
+ */
+export declare function createTelegramChannel(config: TelegramChannelConfig): IChannel;

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

@@ -0,0 +1,197 @@
+import { dispatchMessage } from "../registry.js";
+const TELEGRAM_API_BASE = "https://api.telegram.org/bot";
+/** getUpdates 长轮询等待秒数（1–50） */
+const LONG_POLL_TIMEOUT = 25;
+/** 单条消息/编辑最大长度 */
+const MAX_MESSAGE_LENGTH = 4096;
+function apiUrl(token, method) {
+    return `${TELEGRAM_API_BASE}${encodeURIComponent(token)}/${method}`;
+}
+async function telegramGet(token, method, params = {}) {
+    const q = new URLSearchParams();
+    for (const [k, v] of Object.entries(params))
+        q.set(k, String(v));
+    const url = `${apiUrl(token, method)}?${q.toString()}`;
+    const res = await fetch(url, { method: "GET" });
+    return res.json();
+}
+async function telegramPost(token, method, body) {
+    const res = await fetch(apiUrl(token, method), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    return res.json();
+}
+function truncateForTelegram(text) {
+    if (text.length <= MAX_MESSAGE_LENGTH)
+        return text;
+    return text.slice(0, MAX_MESSAGE_LENGTH - 3) + "...";
+}
+/**
+ * 入站：长轮询 getUpdates，收到 message/edited_message 后转 UnifiedMessage 并分发。
+ */
+class TelegramLongPollInbound {
+    config;
+    messageHandler = null;
+    stopped = false;
+    lastOffset = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    setMessageHandler(handler) {
+        this.messageHandler = handler;
+    }
+    async start() {
+        const token = this.config.botToken?.trim();
+        if (!token) {
+            console.warn("[Telegram] botToken missing, skip long poll start");
+            return;
+        }
+        this.stopped = false;
+        this.lastOffset = 0;
+        const poll = async () => {
+            while (!this.stopped) {
+                try {
+                    const resp = await telegramGet(token, "getUpdates", {
+                        offset: this.lastOffset,
+                        timeout: LONG_POLL_TIMEOUT,
+                    });
+                    if (!resp.ok || !Array.isArray(resp.result)) {
+                        if (resp.description)
+                            console.warn("[Telegram] getUpdates error:", resp.description);
+                        await new Promise((r) => setTimeout(r, 1000));
+                        continue;
+                    }
+                    for (const update of resp.result) {
+                        if (update.update_id >= this.lastOffset)
+                            this.lastOffset = update.update_id + 1;
+                        const msg = update.message ?? update.edited_message;
+                        if (!msg?.text?.trim() || !msg.chat?.id)
+                            continue;
+                        const from = msg.from;
+                        const userId = from?.id != null ? String(from.id) : "unknown";
+                        const userName = [from?.first_name, from?.last_name].filter(Boolean).join(" ").trim() || from?.username;
+                        const unified = {
+                            channelId: "telegram",
+                            threadId: String(msg.chat.id),
+                            userId,
+                            userName: userName || undefined,
+                            messageText: msg.text.trim(),
+                            replyTarget: "default",
+                            messageId: String(msg.message_id),
+                            raw: msg,
+                        };
+                        if (this.messageHandler) {
+                            await this.messageHandler(unified);
+                        }
+                        else {
+                            await dispatchMessage(unified);
+                        }
+                    }
+                }
+                catch (e) {
+                    if (!this.stopped)
+                        console.error("[Telegram] long poll error:", e);
+                    await new Promise((r) => setTimeout(r, 2000));
+                }
+            }
+        };
+        void poll();
+        console.log("[Telegram] long poll started");
+    }
+    async stop() {
+        this.stopped = true;
+    }
+}
+/**
+ * 出站：sendMessage 一次性发送；sendStream 先发占位再 editMessageText 流式更新（真流式）。
+ */
+class TelegramApiOutbound {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getToken() {
+        const t = this.config.botToken?.trim();
+        if (!t)
+            throw new Error("[Telegram] botToken required");
+        return t;
+    }
+    async send(targetId, reply) {
+        const text = reply.text?.trim() || "(无内容)";
+        const resp = await telegramPost(this.getToken(), "sendMessage", {
+            chat_id: targetId,
+            text: truncateForTelegram(text),
+        });
+        if (!resp.ok)
+            throw new Error(resp.description ?? "Telegram sendMessage failed");
+        return resp.result;
+    }
+    async sendStream(targetId) {
+        const token = this.getToken();
+        const placeholder = "…";
+        const createResp = await telegramPost(token, "sendMessage", {
+            chat_id: targetId,
+            text: placeholder,
+        });
+        if (!createResp.ok || createResp.result?.message_id == null) {
+            throw new Error(createResp.description ?? "Telegram sendMessage (stream placeholder) failed");
+        }
+        const messageId = createResp.result.message_id;
+        const chatId = targetId;
+        const edit = async (content) => {
+            const body = truncateForTelegram(content || " ");
+            const r = await telegramPost(token, "editMessageText", {
+                chat_id: chatId,
+                message_id: messageId,
+                text: body,
+            });
+            if (!r.ok && r.description?.includes("message is not modified"))
+                return;
+            if (!r.ok)
+                console.error("[Telegram] editMessageText failed:", r.description);
+        };
+        return {
+            onChunk: async (accumulated) => {
+                try {
+                    await edit(accumulated + " ▌");
+                }
+                catch (e) {
+                    console.error("[Telegram] stream edit failed:", e);
+                }
+            },
+            onTurnEnd: async (accumulated) => {
+                try {
+                    await edit(accumulated || " ");
+                }
+                catch (e) {
+                    console.error("[Telegram] stream onTurnEnd edit failed:", e);
+                }
+            },
+            onDone: async (accumulated) => {
+                try {
+                    await edit(accumulated.trim() || "(无内容)");
+                }
+                catch (e) {
+                    console.error("[Telegram] stream onDone edit failed:", e);
+                }
+            },
+        };
+    }
+}
+/**
+ * Telegram 通道：长轮询入站 + API 出站，支持流式（editMessageText）。
+ */
+export function createTelegramChannel(config) {
+    const inbound = new TelegramLongPollInbound(config);
+    const outbound = new TelegramApiOutbound(config);
+    inbound.setMessageHandler((msg) => dispatchMessage(msg));
+    return {
+        id: "telegram",
+        name: "Telegram",
+        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>;