@next-open-ai/openbot 0.2.8 → 0.6.6

package/dist/core/tools/bookmark-tool.js

@@ -0,0 +1,118 @@
+import { Type } from "@sinclair/typebox";
+import { getBackendBaseUrl } from "../../gateway/backend-url.js";
+const GetBookmarkTagsSchema = Type.Object({});
+const SaveBookmarkSchema = Type.Object({
+    url: Type.String({ description: "要收藏的 URL" }),
+    title: Type.Optional(Type.String({ description: "可选标题" })),
+    tagNames: Type.Optional(Type.Array(Type.String(), {
+        description: "标签名称列表，须与系统中已维护的标签一致。保存前应先用 get_bookmark_tags 获取可用标签。",
+    })),
+});
+async function apiGet(path) {
+    const base = getBackendBaseUrl();
+    if (!base) {
+        throw new Error("收藏功能需要在前端/桌面环境中使用，当前无法访问后端。");
+    }
+    const res = await fetch(`${base.replace(/\/$/, "")}/server-api${path}`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`请求失败: ${res.status} ${text}`);
+    }
+    return res.json();
+}
+async function apiPost(path, body) {
+    const base = getBackendBaseUrl();
+    if (!base) {
+        throw new Error("收藏功能需要在前端/桌面环境中使用，当前无法访问后端。");
+    }
+    const res = await fetch(`${base.replace(/\/$/, "")}/server-api${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`请求失败: ${res.status} ${text}`);
+    }
+    return res.json();
+}
+/**
+ * 获取当前系统中已维护的标签列表，供保存 URL 时选择匹配的标签。
+ */
+export function createGetBookmarkTagsTool() {
+    return {
+        name: "get_bookmark_tags",
+        label: "Get Bookmark Tags",
+        description: "获取系统中已维护的收藏标签列表。在用户要求保存链接时，应先调用本工具获取可用标签，再根据用户意图匹配最合适的标签名，并用 save_bookmark 保存。",
+        parameters: GetBookmarkTagsSchema,
+        execute: async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
+            try {
+                const json = await apiGet("/tags");
+                const data = json.data ?? [];
+                const names = data.map((t) => t.name);
+                const text = names.length > 0
+                    ? `当前可用标签：${names.join("、")}。请根据用户意图选择匹配的标签名用于 save_bookmark。`
+                    : "当前暂无标签。请在设置中先添加标签，或使用 save_bookmark 时不传 tagNames。";
+                return {
+                    content: [{ type: "text", text }],
+                    details: { tags: data },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `获取标签失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}
+/**
+ * 将 URL 保存为收藏，并关联指定标签（标签名须与 get_bookmark_tags 返回的一致）。
+ */
+export function createSaveBookmarkTool() {
+    return {
+        name: "save_bookmark",
+        label: "Save Bookmark",
+        description: "将用户提供的 URL 保存到收藏库，并可关联一个或多个标签。标签名必须使用 get_bookmark_tags 返回的已有标签；若用户未指定标签，可根据上下文推断或留空。",
+        parameters: SaveBookmarkSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const url = (params.url ?? "").trim();
+            if (!url) {
+                return {
+                    content: [{ type: "text", text: "请提供要收藏的 URL。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                const json = await apiPost("/saved-items", {
+                    url,
+                    title: params.title?.trim() || undefined,
+                    tagNames: params.tagNames?.length ? params.tagNames.map((n) => n.trim()).filter(Boolean) : undefined,
+                });
+                const data = json.data;
+                const tagStr = data?.tagNames?.length ? `，标签：${data.tagNames.join("、")}` : "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `已收藏：${data?.url ?? url}${tagStr}`,
+                        },
+                    ],
+                    details: data,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `保存失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/create-agent-tool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建 create_agent 工具：根据用户意图创建新智能体配置，供用户在对话中选择使用。
+ * 缺省：未提供 workspace 时根据 name 生成英文标识；未提供 system_prompt 时根据 language 生成简短描述；模型使用全局缺省。
+ */
+export declare function createCreateAgentTool(): ToolDefinition;

package/dist/core/tools/create-agent-tool.js

@@ -0,0 +1,97 @@
+import { Type } from "@sinclair/typebox";
+import { getCreateAgentProvider } from "../session-current-agent.js";
+const CreateAgentSchema = Type.Object({
+    name: Type.String({
+        description: "智能体显示名称，如用户说的「美妆助手」「代码审查助手」",
+    }),
+    workspace: Type.Optional(Type.String({
+        description: "工作空间英文标识，仅允许字母、数字、下划线、连字符。不传则根据 name 自动生成（如 My Assistant → my-assistant）",
+    })),
+    system_prompt: Type.Optional(Type.String({
+        description: "系统提示词/角色描述。不传则根据 language 生成一句最简短的角色描述。",
+    })),
+    language: Type.Optional(Type.Union([Type.Literal("zh"), Type.Literal("en")], {
+        description: "用户语言，用于生成缺省 system_prompt。不传默认 en。",
+    })),
+});
+const WORKSPACE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+const RESERVED_WORKSPACE = "default";
+function slugifyFromName(name) {
+    const trimmed = (name || "").trim();
+    if (!trimmed)
+        return "agent-" + Date.now().toString(36);
+    const asciiOnly = trimmed
+        .replace(/\s+/g, "-")
+        .replace(/[^a-zA-Z0-9_-]/g, "")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+    if (asciiOnly && WORKSPACE_NAME_REGEX.test(asciiOnly) && asciiOnly !== RESERVED_WORKSPACE)
+        return asciiOnly;
+    return "agent-" + Date.now().toString(36);
+}
+function getDefaultSystemPrompt(lang) {
+    if (lang === "zh")
+        return "你是根据用户需求定制的助手，请按用户描述的角色与能力提供帮助。";
+    return "You are a helpful assistant customized as requested by the user.";
+}
+/**
+ * 创建 create_agent 工具：根据用户意图创建新智能体配置，供用户在对话中选择使用。
+ * 缺省：未提供 workspace 时根据 name 生成英文标识；未提供 system_prompt 时根据 language 生成简短描述；模型使用全局缺省。
+ */
+export function createCreateAgentTool() {
+    return {
+        name: "create_agent",
+        label: "Create Agent",
+        description: "根据用户意图创建一个新的智能体配置。用户可在对话中通过 list_agents 与 switch_agent 选择使用。需提供智能体名称；工作空间名与系统提示词可选，未提供时自动生成。",
+        parameters: CreateAgentSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const provider = getCreateAgentProvider();
+            if (!provider) {
+                return {
+                    content: [{ type: "text", text: "当前环境不支持创建智能体。" }],
+                    details: undefined,
+                };
+            }
+            const name = (params.name ?? "").trim();
+            if (!name) {
+                return {
+                    content: [{ type: "text", text: "请提供智能体名称（name）。" }],
+                    details: undefined,
+                };
+            }
+            let workspace = (params.workspace ?? "").trim() && WORKSPACE_NAME_REGEX.test((params.workspace ?? "").trim())
+                ? (params.workspace ?? "").trim()
+                : slugifyFromName(name);
+            if (workspace === RESERVED_WORKSPACE)
+                workspace = "agent-" + Date.now().toString(36);
+            const systemPrompt = (params.system_prompt ?? "").trim() ||
+                getDefaultSystemPrompt(params.language === "zh" ? "zh" : "en");
+            try {
+                const result = await provider({
+                    name,
+                    workspace,
+                    systemPrompt,
+                });
+                if ("error" in result) {
+                    return {
+                        content: [{ type: "text", text: `创建失败: ${result.error}` }],
+                        details: undefined,
+                    };
+                }
+                const text = `已创建智能体「${result.name}」（ID: ${result.id}）。用户可通过 list_agents 查看、并调用 switch_agent 切换到该智能体使用。`;
+                return {
+                    content: [{ type: "text", text }],
+                    details: result,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `创建失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/index.d.ts

@@ -1,3 +1,7 @@
 export { createBrowserTool, closeBrowser } from "./browser-tool.js";
 export { createSaveExperienceTool } from "./save-experience-tool.js";
 export { createInstallSkillTool } from "./install-skill-tool.js";
+export { createSwitchAgentTool } from "./switch-agent-tool.js";
+export { createListAgentsTool } from "./list-agents-tool.js";
+export { createCreateAgentTool } from "./create-agent-tool.js";
+export { createGetBookmarkTagsTool, createSaveBookmarkTool } from "./bookmark-tool.js";

package/dist/core/tools/index.js

@@ -1,3 +1,7 @@
 export { createBrowserTool, closeBrowser } from "./browser-tool.js";
 export { createSaveExperienceTool } from "./save-experience-tool.js";
 export { createInstallSkillTool } from "./install-skill-tool.js";
+export { createSwitchAgentTool } from "./switch-agent-tool.js";
+export { createListAgentsTool } from "./list-agents-tool.js";
+export { createCreateAgentTool } from "./create-agent-tool.js";
+export { createGetBookmarkTagsTool, createSaveBookmarkTool } from "./bookmark-tool.js";

package/dist/core/tools/list-agents-tool.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建 list_agents 工具：返回当前节点上配置的所有智能体列表，供用户在对话中选择切换。
+ */
+export declare function createListAgentsTool(): ToolDefinition;

package/dist/core/tools/list-agents-tool.js

@@ -0,0 +1,45 @@
+import { Type } from "@sinclair/typebox";
+import { getAgentListProvider } from "../session-current-agent.js";
+const ListAgentsSchema = Type.Object({});
+/**
+ * 创建 list_agents 工具：返回当前节点上配置的所有智能体列表，供用户在对话中选择切换。
+ */
+export function createListAgentsTool() {
+    return {
+        name: "list_agents",
+        label: "List Agents",
+        description: "列出当前可用的所有智能体（id 与名称）。用户可根据列表选择并让助手调用 switch_agent 切换到对应智能体。",
+        parameters: ListAgentsSchema,
+        execute: async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
+            const provider = getAgentListProvider();
+            if (!provider) {
+                return {
+                    content: [{ type: "text", text: "当前无法获取智能体列表。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                const list = await provider();
+                if (!list?.length) {
+                    return {
+                        content: [{ type: "text", text: "暂无配置的智能体。" }],
+                        details: { agents: [] },
+                    };
+                }
+                const lines = list.map((a) => `- **${a.id}**${a.name ? `：${a.name}` : ""}`);
+                const text = "当前可用智能体：\n\n" + lines.join("\n") + "\n\n使用 switch_agent 工具并传入上述 id 可切换。";
+                return {
+                    content: [{ type: "text", text }],
+                    details: { agents: list },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `获取列表失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/switch-agent-tool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建 switch_agent 工具：将当前会话的下一次及后续对话切换到指定 agent。
+ * 需在 Gateway 启动时通过 setSessionCurrentAgentUpdater 注入更新函数。
+ */
+export declare function createSwitchAgentTool(businessSessionId: string): ToolDefinition;

package/dist/core/tools/switch-agent-tool.js

@@ -0,0 +1,54 @@
+import { Type } from "@sinclair/typebox";
+import { getSessionCurrentAgentUpdater } from "../session-current-agent.js";
+const SwitchAgentSchema = Type.Object({
+    agent_id: Type.String({
+        description: "要切换到的智能体 ID，与设置中智能体列表一致（如 default 或工作空间名）",
+    }),
+});
+/**
+ * 创建 switch_agent 工具：将当前会话的下一次及后续对话切换到指定 agent。
+ * 需在 Gateway 启动时通过 setSessionCurrentAgentUpdater 注入更新函数。
+ */
+export function createSwitchAgentTool(businessSessionId) {
+    return {
+        name: "switch_agent",
+        label: "Switch Agent",
+        description: "将当前对话切换为使用指定智能体。切换后，用户下一次及后续消息将由该智能体处理。可用于在对话中更换助手（如从主智能体切换到专项智能体）。",
+        parameters: SwitchAgentSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const agentId = (params.agent_id ?? "").trim();
+            if (!agentId) {
+                return {
+                    content: [{ type: "text", text: "请提供要切换到的智能体 ID（如 default 或工作空间名）。" }],
+                    details: undefined,
+                };
+            }
+            const updateFn = getSessionCurrentAgentUpdater();
+            if (!updateFn) {
+                return {
+                    content: [{ type: "text", text: "当前环境不支持切换智能体。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                updateFn(businessSessionId, agentId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `已切换到智能体「${agentId}」。后续回复将由该智能体处理。`,
+                        },
+                    ],
+                    details: { agentId },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `切换失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

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/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>;