@wwlocal/aibot-plugin-node 20260409.20.0

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

@@ -0,0 +1,512 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { BaseAdapter } from './base-adapter.js';
+
+/**
+ * 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 {
+    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.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.basename(media.path)}] (读取失败)`,
+                        });
+                    }
+                }
+                else {
+                    // 非图片文件，以文本描述形式传入
+                    const fileName = path.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}`;
+        }
+    }
+}
+
+export { AnthropicAdapter };

package/dist/esm/src/adapters/base-adapter.js

@@ -0,0 +1,174 @@
+/**
+ * 适配器基础抽象类
+ *
+ * 提供所有适配器共用的能力：
+ * - 超时控制
+ * - 请求头构建
+ * - SSE 流式解析工具方法
+ * - 日志工具
+ */
+/**
+ * 适配器基础抽象类
+ */
+class BaseAdapter {
+    // ==========================================================================
+    // 请求头构建
+    // ==========================================================================
+    /**
+     * 构建通用请求头
+     */
+    buildHeaders(endpoint) {
+        const headers = {
+            "Content-Type": "application/json",
+            ...(endpoint.headers || {}),
+        };
+        if (endpoint.apiKey) {
+            headers["Authorization"] = `Bearer ${endpoint.apiKey}`;
+        }
+        return headers;
+    }
+    // ==========================================================================
+    // 超时控制
+    // ==========================================================================
+    /**
+     * 创建带超时的 AbortController
+     *
+     * @param timeoutMs 超时时间（毫秒）
+     * @param externalSignal 外部中止信号（可选）
+     * @returns { controller, timeoutId }
+     */
+    createTimeoutController(timeoutMs, externalSignal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        // 合并外部 abortSignal
+        if (externalSignal) {
+            externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
+        return { controller, timeoutId };
+    }
+    /**
+     * 包装 Promise 添加超时控制
+     */
+    async withTimeout(promise, timeoutMs, timeoutMessage = "Request timed out") {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(`${timeoutMessage} after ${timeoutMs}ms`));
+            }, timeoutMs);
+        });
+        try {
+            return await Promise.race([promise, timeoutPromise]);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    // ==========================================================================
+    // SSE 解析工具
+    // ==========================================================================
+    /**
+     * 解析单行 SSE 数据
+     *
+     * @param line 原始 SSE 行
+     * @returns { event, data } 或 null（非 data 行或空行）
+     */
+    parseSSELine(line) {
+        const trimmed = line.trim();
+        // 跳过空行和注释
+        if (!trimmed || trimmed.startsWith(":")) {
+            return null;
+        }
+        // 解析 event: 行
+        if (trimmed.startsWith("event:")) {
+            return { event: trimmed.slice(6).trim() };
+        }
+        // 解析 data: 行
+        if (trimmed.startsWith("data:")) {
+            return { data: trimmed.slice(5).trim() };
+        }
+        return null;
+    }
+    /**
+     * 创建 SSE 流读取器
+     *
+     * 返回一个异步生成器，逐行产出 SSE 数据
+     */
+    async *readSSEStream(reader, runtime) {
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        let currentEvent;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // 逐行处理
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const parsed = this.parseSSELine(line);
+                    if (!parsed)
+                        continue;
+                    if (parsed.event !== undefined) {
+                        currentEvent = parsed.event;
+                    }
+                    else if (parsed.data !== undefined) {
+                        yield { event: currentEvent, data: parsed.data };
+                        currentEvent = undefined; // 重置 event
+                    }
+                }
+            }
+            // 处理残留 buffer
+            if (buffer.trim()) {
+                const parsed = this.parseSSELine(buffer);
+                if (parsed?.data !== undefined) {
+                    yield { event: currentEvent, data: parsed.data };
+                }
+            }
+        }
+        catch (err) {
+            runtime?.error?.(`[wecom][adapter] SSE stream error: ${String(err)}`);
+            throw err;
+        }
+    }
+    // ==========================================================================
+    // HTTP 请求工具
+    // ==========================================================================
+    /**
+     * 发起 HTTP 请求并处理错误
+     */
+    async fetchWithErrorHandling(url, options, runtime) {
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "(unreadable)");
+            const error = new Error(`API error: HTTP ${response.status} ${response.statusText} — ${errorBody.slice(0, 500)}`);
+            runtime?.error?.(`[wecom][adapter] ${error.message}`);
+            throw error;
+        }
+        return response;
+    }
+    // ==========================================================================
+    // 日志工具
+    // ==========================================================================
+    /**
+     * 日志前缀
+     */
+    get logPrefix() {
+        return `[wecom][adapter:${this.name}]`;
+    }
+    /**
+     * 打印日志
+     */
+    log(runtime, message) {
+        runtime?.log?.(`${this.logPrefix} ${message}`);
+    }
+    /**
+     * 打印错误日志
+     */
+    logError(runtime, message) {
+        runtime?.error?.(`${this.logPrefix} ${message}`);
+    }
+}
+
+export { BaseAdapter };