@wwlocal/aibot-plugin-node 20260409.20.0

package/dist/cjs/index.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var config = require('./src/config.js');
+var serviceManager = require('./src/service-manager.js');
+var server = require('./src/server.js');
+
+/**
+ * @wecom/aibot-plugin — 企业微信私有部署 AI 机器人插件
+ *
+ * 独立运行的 Node.js 服务入口
+ *
+ * 启动流程：
+ * 1. 解析命令行参数，确定配置文件路径
+ * 2. 加载 JSON 配置文件
+ * 3. 注入 CA 证书（如配置）
+ * 4. 启动 Express HTTP 服务
+ * 5. 为每个启用的账号创建 WSClient 连接
+ * 6. 注册进程信号处理（SIGINT/SIGTERM 优雅退出）
+ */
+// ============================================================================
+// 运行时日志
+// ============================================================================
+const runtime = {
+    log: (...args) => {
+        console.log(new Date().toISOString(), ...args);
+    },
+    error: (...args) => {
+        console.error(new Date().toISOString(), ...args);
+    },
+};
+// ============================================================================
+// 主函数
+// ============================================================================
+async function main() {
+    // 解析配置文件路径（默认 ./config.json）
+    const configPath = process.argv[2] || process.env.AIBOT_CONFIG || "./config.json";
+    runtime.log?.(`[main] Loading config from: ${configPath}`);
+    // 加载配置
+    let config$1;
+    try {
+        config$1 = config.loadConfig(configPath);
+    }
+    catch (err) {
+        runtime.error?.(`[main] Failed to load config: ${String(err)}`);
+        process.exit(1);
+    }
+    runtime.log?.(`[main] Config loaded: ${config$1.accounts.length} account(s), ${config$1.agents.length} agent(s)`);
+    // 创建服务管理器
+    const serviceManager$1 = new serviceManager.ServiceManager({ config: config$1, runtime });
+    // 创建 Express 应用
+    const app = server.createServer({ serviceManager: serviceManager$1, runtime });
+    const port = config$1.port || 3000;
+    // 启动 HTTP 服务
+    server.startServer(app, port, runtime);
+    // 启动所有 WSClient 连接
+    await serviceManager$1.startAll();
+    // 注册优雅退出信号
+    const shutdown = async (signal) => {
+        runtime.log?.(`[main] Received ${signal}, shutting down...`);
+        await serviceManager$1.stopAll();
+        runtime.log?.("[main] Shutdown complete");
+        process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    // 捕获未处理的 Promise rejection
+    process.on("unhandledRejection", (reason) => {
+        runtime.error?.(`[main] Unhandled rejection: ${String(reason)}`);
+    });
+    runtime.log?.("[main] Service started successfully");
+}
+// 启动
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/cjs/src/adapters/anthropic-adapter.js

@@ -0,0 +1,534 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var baseAdapter = require('./base-adapter.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+/**
+ * Anthropic 适配器
+ *
+ * 适用于：Anthropic Claude 原生 API，以及阿里百炼、腾讯混元、MiniMax、
+ *         AWS Bedrock、Google Vertex AI 等提供 Anthropic Messages API 兼容接口的平台
+ *
+ * 与 OpenAI 的核心差异：
+ * - 接口路径：POST /v1/messages（而非 /v1/chat/completions）
+ * - 系统提示词：顶层 system 字段（而非 messages[0].role = "system"）
+ * - 认证方式：x-api-key 头（而非 Authorization: Bearer）
+ * - 响应结构：content[] 块数组（而非 choices[0].message.content 字符串）
+ * - 流式格式：多事件类型（message_start → content_block_delta → message_stop）
+ * - 思维链：原生 type: "thinking" 块（而非私有 reasoning_content 字段）
+ * - 必填字段：max_tokens（OpenAI 可选）
+ *
+ * 推理内容折叠展示格式（collapse 模式，复用 DeepSeek 策略）：
+ * <think>
+ * {thinking}
+ * </think>
+ *
+ * {content}
+ */
+/**
+ * Anthropic 适配器
+ */
+class AnthropicAdapter extends baseAdapter.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = "anthropic";
+        this.displayName = "Anthropic";
+    }
+    /**
+     * 获取 Anthropic 配置选项
+     */
+    getOptions(endpoint) {
+        return endpoint.providerOptions || {};
+    }
+    /**
+     * 获取推理内容展示模式
+     */
+    getReasoningDisplayMode(endpoint) {
+        return this.getOptions(endpoint).reasoningDisplay || "collapse";
+    }
+    // ==========================================================================
+    // URL 规范化
+    // ==========================================================================
+    /**
+     * 规范化 Anthropic API URL
+     *
+     * 用户可能配置为 base URL（如 https://api.minimaxi.com/anthropic）
+     * 或完整路径（如 https://api.anthropic.com/v1/messages）。
+     * 如果 URL 不以 /v1/messages 结尾，则自动拼接。
+     */
+    normalizeUrl(url) {
+        const trimmed = url.replace(/\/+$/, ""); // 去掉尾部斜杠
+        if (trimmed.endsWith("/v1/messages")) {
+            return trimmed;
+        }
+        return `${trimmed}/v1/messages`;
+    }
+    // ==========================================================================
+    // 请求头构建（覆写：支持 x-api-key 认证方式）
+    // ==========================================================================
+    /**
+     * 构建 Anthropic 请求头
+     *
+     * 认证方式：
+     * - useXApiKey=true（默认）：使用 x-api-key 头（Anthropic 原生）
+     * - useXApiKey=false：使用 Authorization: Bearer（第三方兼容平台）
+     */
+    buildHeaders(endpoint) {
+        const options = this.getOptions(endpoint);
+        const headers = {
+            "Content-Type": "application/json",
+            ...(endpoint.headers || {}),
+        };
+        // 认证方式
+        const useXApiKey = options.useXApiKey !== false; // 默认 true
+        if (endpoint.apiKey) {
+            if (useXApiKey) {
+                headers["x-api-key"] = endpoint.apiKey;
+            }
+            else {
+                headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
+            }
+        }
+        // Anthropic API 版本头
+        const anthropicVersion = options.anthropicVersion || "2023-06-01";
+        headers["anthropic-version"] = anthropicVersion;
+        return headers;
+    }
+    // ==========================================================================
+    // 转发主流程
+    // ==========================================================================
+    /**
+     * 转发请求到 Anthropic Messages API
+     */
+    async forward(request, endpoint, callbacks) {
+        const { text, mediaPaths, quoteContent, abortSignal, runtime, historyMessages } = request;
+        const { deliver, onReplyStart, onError } = callbacks;
+        const options = this.getOptions(endpoint);
+        // 规范化 URL：自动补全 /v1/messages 路径
+        const url = this.normalizeUrl(endpoint.url);
+        this.log(runtime, `Forwarding to Anthropic: url=${url}, model=${endpoint.model}`);
+        // 构建消息
+        const messages = this.buildMessages({
+            text,
+            mediaPaths,
+            quoteContent,
+            historyMessages,
+        });
+        // 构建请求体
+        const requestBody = this.buildRequestBody(messages, endpoint, options);
+        // 调试日志：记录请求体关键信息（不记录完整 messages 避免泄露用户内容）
+        this.log(runtime, `Request params: model=${requestBody.model}, stream=${requestBody.stream}, max_tokens=${requestBody.max_tokens}, hasSystem=${!!requestBody.system}, messagesCount=${requestBody.messages.length}`);
+        // 构建请求头
+        const headers = this.buildHeaders(endpoint);
+        // 超时控制
+        const timeoutMs = endpoint.timeoutMs || 300000;
+        const { controller, timeoutId } = this.createTimeoutController(timeoutMs, abortSignal);
+        try {
+            const response = await this.fetchWithErrorHandling(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            }, runtime);
+            let finalText;
+            const displayMode = this.getReasoningDisplayMode(endpoint);
+            if (requestBody.stream) {
+                // 流式响应
+                finalText = await this.handleStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                    displayMode,
+                });
+            }
+            else {
+                // 非流式响应
+                finalText = await this.handleNonStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                    displayMode,
+                });
+            }
+            // 空响应防御：API 返回了有效 HTTP 200 但没有生成任何内容
+            if (!finalText) {
+                this.logError(runtime, `Empty response from API (textLength=0). This usually means the model returned no content blocks. Check: 1) model name is correct, 2) systemPrompt is set, 3) the API provider supports the requested model.`);
+                finalText = "⚠️ AI 未返回有效内容，请稍后重试。";
+            }
+            // 最终 deliver
+            try {
+                await deliver({ text: finalText }, { kind: "final" });
+            }
+            catch (e) {
+                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "final" });
+            }
+            this.log(runtime, `Response complete: textLength=${finalText.length}`);
+            return finalText;
+        }
+        catch (err) {
+            if (err?.name === "AbortError") {
+                const error = new Error(`Request timed out after ${timeoutMs}ms`);
+                this.logError(runtime, error.message);
+                onError?.(error, { kind: "timeout" });
+                throw error;
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    // ==========================================================================
+    // 消息构建
+    // ==========================================================================
+    /**
+     * 构建 Anthropic messages 数组
+     *
+     * 与 OpenAI 的差异：
+     * - 系统提示词不在 messages 中，而是顶层 system 字段（在 buildRequestBody 中处理）
+     * - 图片使用 { type: "image", source: { type: "base64", ... } } 格式
+     * - 不支持 role: "system"，只有 "user" 和 "assistant"
+     */
+    buildMessages(options) {
+        const messages = [];
+        // 注入对话历史（在当前 user 消息之前）
+        if (options.historyMessages && options.historyMessages.length > 0) {
+            for (const msg of options.historyMessages) {
+                messages.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
+        }
+        // 用户消息
+        const hasMedia = options.mediaPaths && options.mediaPaths.length > 0;
+        if (hasMedia) {
+            // 多模态消息：文本 + 图片
+            const contentParts = [];
+            // 添加引用内容
+            if (options.quoteContent) {
+                contentParts.push({
+                    type: "text",
+                    text: `[引用消息] ${options.quoteContent}`,
+                });
+            }
+            // 添加文本
+            if (options.text) {
+                contentParts.push({
+                    type: "text",
+                    text: options.text,
+                });
+            }
+            // 添加媒体文件
+            for (const media of options.mediaPaths) {
+                const isImage = media.contentType?.startsWith("image/");
+                if (isImage) {
+                    try {
+                        const buffer = fs__namespace.readFileSync(media.path);
+                        const base64 = buffer.toString("base64");
+                        const mimeType = media.contentType || "image/jpeg";
+                        contentParts.push({
+                            type: "image",
+                            source: {
+                                type: "base64",
+                                media_type: mimeType,
+                                data: base64,
+                            },
+                        });
+                    }
+                    catch {
+                        contentParts.push({
+                            type: "text",
+                            text: `[图片文件: ${path__namespace.basename(media.path)}] (读取失败)`,
+                        });
+                    }
+                }
+                else {
+                    // 非图片文件，以文本描述形式传入
+                    const fileName = path__namespace.basename(media.path);
+                    const fileType = media.contentType || "unknown";
+                    contentParts.push({
+                        type: "text",
+                        text: `[文件: ${fileName}, 类型: ${fileType}]`,
+                    });
+                }
+            }
+            // 确保至少有一个 content part
+            if (contentParts.length === 0) {
+                contentParts.push({ type: "text", text: "(空消息)" });
+            }
+            messages.push({ role: "user", content: contentParts });
+        }
+        else {
+            // 纯文本消息
+            let content = "";
+            if (options.quoteContent) {
+                content += `[引用消息] ${options.quoteContent}\n\n`;
+            }
+            content += options.text || "(空消息)";
+            messages.push({ role: "user", content });
+        }
+        return messages;
+    }
+    /**
+     * 构建 Anthropic 请求体
+     */
+    buildRequestBody(messages, endpoint, options) {
+        const requestBody = {
+            model: endpoint.model || "claude-sonnet-4-20250514",
+            messages,
+            max_tokens: options.maxTokens || 4096,
+            stream: endpoint.stream !== false,
+        };
+        // 系统提示词放在顶层 system 字段
+        if (endpoint.systemPrompt) {
+            requestBody.system = endpoint.systemPrompt;
+        }
+        return requestBody;
+    }
+    // ==========================================================================
+    // 流式响应处理
+    // ==========================================================================
+    /**
+     * 处理 Anthropic 流式响应
+     *
+     * Anthropic SSE 事件流程：
+     * message_start → content_block_start → content_block_delta(多次) →
+     * content_block_stop → ... → message_delta → message_stop
+     */
+    async handleStreamResponse(params) {
+        const { response, deliver, onReplyStart, onError, runtime, displayMode } = params;
+        const body = response.body;
+        if (!body) {
+            throw new Error("Response has no body for streaming");
+        }
+        const reader = body.getReader();
+        let accumulatedContent = "";
+        let accumulatedThinking = "";
+        let replyStarted = false;
+        let currentBlockType;
+        try {
+            for await (const { event, data } of this.readSSEStream(reader, runtime)) {
+                // 解析 JSON
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    this.log(runtime, `Failed to parse Anthropic SSE JSON: ${data.slice(0, 200)}`);
+                    continue;
+                }
+                // 使用 SSE event 字段或 JSON 中的 type 字段确定事件类型
+                const eventType = event || parsed.type;
+                switch (eventType) {
+                    case "message_start":
+                        // 记录 message id，初始化状态
+                        this.log(runtime, `Anthropic message_start: id=${parsed.message?.id}`);
+                        break;
+                    case "content_block_start":
+                        // 记录当前块类型（text / thinking / tool_use）
+                        currentBlockType = parsed.content_block?.type;
+                        this.log(runtime, `Anthropic content_block_start: type=${currentBlockType}, index=${parsed.index}`);
+                        // 当 thinking 块开始时，提前触发 onReplyStart（让 thinking 动画立即显示）
+                        // 这样 thinking 阶段用户能看到 thinking 动画，而不是完全无反馈
+                        if (currentBlockType === "thinking" && !replyStarted) {
+                            replyStarted = true;
+                            try {
+                                await onReplyStart?.();
+                            }
+                            catch (e) {
+                                this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                            }
+                        }
+                        break;
+                    case "content_block_delta": {
+                        const deltaType = parsed.delta?.type;
+                        if (deltaType === "text_delta" && parsed.delta?.text) {
+                            // 文本增量
+                            accumulatedContent += parsed.delta.text;
+                        }
+                        else if (deltaType === "thinking_delta" && parsed.delta?.thinking) {
+                            // 思维链增量
+                            accumulatedThinking += parsed.delta.thinking;
+                        }
+                        // 判断是否需要 deliver
+                        const hasNewContent = deltaType === "text_delta" && parsed.delta?.text;
+                        const hasNewThinking = deltaType === "thinking_delta" && parsed.delta?.thinking;
+                        // deliver 策略：
+                        // - hide 模式：仅有主内容 (content) 时 deliver，跳过纯推理帧
+                        // - collapse 模式：thinking 阶段和 text 阶段都 deliver，但中间帧**不带 <think> 标签**
+                        //   thinking 阶段：直接发纯 thinking 文本（让用户看到模型在想什么）
+                        //   text 阶段：只发 content（不带 <think> 包裹），避免企微反复渲染巨大 think 块导致闪烁
+                        //   final 帧由 finishThinkingStream 发完整格式（含 <think> 标签）
+                        // - show 模式：有推理或主内容时都 deliver
+                        let shouldDeliver;
+                        if (displayMode === "hide") {
+                            shouldDeliver = !!hasNewContent;
+                        }
+                        else {
+                            // collapse 和 show 模式：thinking 或 content 都 deliver
+                            shouldDeliver = !!(hasNewContent || hasNewThinking);
+                        }
+                        if (shouldDeliver) {
+                            // 首次收到有效内容时触发 onReplyStart（如果还未触发）
+                            if (!replyStarted) {
+                                replyStarted = true;
+                                try {
+                                    await onReplyStart?.();
+                                }
+                                catch (e) {
+                                    this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                                }
+                            }
+                            // 中间帧 deliver：使用统一的 formatOutput，节流由 monitor 层统一控制
+                            // 适配器层每个有效 delta 直接 deliver，monitor 层根据时间+增量双重条件决定是否发送到企微
+                            const deliverText = this.formatOutput(accumulatedContent, accumulatedThinking, displayMode);
+                            try {
+                                await deliver({ text: deliverText }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        break;
+                    }
+                    case "content_block_stop":
+                        // 当前内容块结束
+                        currentBlockType = undefined;
+                        break;
+                    case "message_delta":
+                        // 提取 stop_reason 和 usage
+                        if (parsed.delta?.stop_reason) {
+                            this.log(runtime, `Anthropic stop_reason: ${parsed.delta.stop_reason}`);
+                        }
+                        if (parsed.usage?.output_tokens) {
+                            this.log(runtime, `Anthropic output_tokens: ${parsed.usage.output_tokens}`);
+                        }
+                        break;
+                    case "message_stop":
+                        this.log(runtime, "Anthropic message_stop");
+                        break;
+                    case "ping":
+                        // 忽略心跳
+                        break;
+                    case "error":
+                        // 错误事件
+                        const errorMsg = parsed.error?.message || "Unknown Anthropic error";
+                        this.logError(runtime, `Anthropic error: ${errorMsg}`);
+                        onError?.(new Error(errorMsg), { kind: "anthropic-error" });
+                        break;
+                    default:
+                        this.log(runtime, `Unknown Anthropic event: ${eventType}`);
+                }
+            }
+        }
+        catch (err) {
+            this.logError(runtime, `SSE stream error: ${String(err)}`);
+            onError?.(err instanceof Error ? err : new Error(String(err)), { kind: "stream" });
+        }
+        return this.formatOutput(accumulatedContent, accumulatedThinking, displayMode);
+    }
+    // ==========================================================================
+    // 非流式响应处理
+    // ==========================================================================
+    /**
+     * 处理 Anthropic 非流式响应
+     *
+     * 遍历 content[] 数组，按 type 提取 text 和 thinking 内容
+     */
+    async handleNonStreamResponse(params) {
+        const { response, deliver, onReplyStart, onError, runtime, displayMode } = params;
+        let data;
+        try {
+            data = (await response.json());
+        }
+        catch (err) {
+            const error = new Error(`Failed to parse Anthropic response JSON: ${String(err)}`);
+            onError?.(error, { kind: "parse" });
+            throw error;
+        }
+        // 遍历 content[] 块数组，分离 text 和 thinking
+        let content = "";
+        let thinking = "";
+        for (const block of data.content || []) {
+            if (block.type === "thinking" && "thinking" in block) {
+                thinking += block.thinking;
+            }
+            else if (block.type === "text" && "text" in block) {
+                content += block.text;
+            }
+        }
+        const formattedText = this.formatOutput(content, thinking, displayMode);
+        if (formattedText) {
+            try {
+                await onReplyStart?.();
+            }
+            catch (e) {
+                this.logError(runtime, `onReplyStart error: ${String(e)}`);
+            }
+            try {
+                await deliver({ text: formattedText }, { kind: "block" });
+            }
+            catch (e) {
+                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+            }
+        }
+        // 记录 token 使用情况
+        if (data.usage) {
+            this.log(runtime, `Token usage: input_tokens=${data.usage.input_tokens}, output_tokens=${data.usage.output_tokens}`);
+        }
+        return formattedText;
+    }
+    // ==========================================================================
+    // 输出格式化
+    // ==========================================================================
+    /**
+     * 格式化最终输出（根据 displayMode 配置）
+     *
+     * 复用 DeepSeek 的 show/hide/collapse 策略
+     */
+    formatOutput(content, thinking, displayMode) {
+        if (!thinking) {
+            return content;
+        }
+        switch (displayMode) {
+            case "show":
+                // 直接展示推理内容和回答
+                return `${thinking}\n\n${content}`;
+            case "hide":
+                // 仅展示回答，隐藏推理过程
+                return content;
+            case "collapse":
+            default:
+                // 折叠展示
+                return `<think>\n${thinking}\n</think>\n\n${content}`;
+        }
+    }
+}
+
+exports.AnthropicAdapter = AnthropicAdapter;