@wwlocal/aibot-plugin-node 20260409.20.0

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

@@ -0,0 +1,176 @@
+'use strict';
+
+/**
+ * 适配器基础抽象类
+ *
+ * 提供所有适配器共用的能力：
+ * - 超时控制
+ * - 请求头构建
+ * - 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}`);
+    }
+}
+
+exports.BaseAdapter = BaseAdapter;

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

@@ -0,0 +1,328 @@
+'use strict';
+
+var openaiAdapter = require('./openai-adapter.js');
+
+/**
+ * DeepSeek 适配器
+ *
+ * 适用于：DeepSeek Chat (deepseek-chat) 和 DeepSeek Reasoner (deepseek-reasoner) 模型
+ *
+ * 与 OpenAI 适配器的差异：
+ * - 响应中额外包含 reasoning_content 字段（思维链）
+ * - 支持 reasoningDisplay 配置：show/hide/collapse（默认）
+ * - Reasoner 模型自动添加 thinking 参数
+ *
+ * 推理内容折叠展示格式（collapse 模式）：
+ * <think>
+ * {reasoning_content}
+ * </think>
+ *
+ * {content}
+ */
+/**
+ * DeepSeek 适配器
+ */
+class DeepSeekAdapter extends openaiAdapter.OpenAIAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = "deepseek";
+        this.displayName = "DeepSeek";
+        // 累积的推理内容（用于流式处理）
+        this.accumulatedReasoning = "";
+    }
+    /**
+     * 获取推理内容展示模式
+     */
+    getReasoningDisplayMode(endpoint) {
+        const options = endpoint.providerOptions;
+        return options?.reasoningDisplay || "collapse";
+    }
+    /**
+     * 是否为 Reasoner 模型
+     */
+    isReasonerModel(endpoint) {
+        return endpoint.model?.includes("reasoner") || false;
+    }
+    /**
+     * 构建请求体（覆写以添加 thinking 参数）
+     */
+    buildRequestBody(messages, endpoint) {
+        const requestBody = super.buildRequestBody(messages, endpoint);
+        // Reasoner 模型自动启用 thinking
+        if (this.isReasonerModel(endpoint)) {
+            requestBody.thinking = { type: "enabled" };
+        }
+        return requestBody;
+    }
+    /**
+     * 解析流式 delta 内容（覆写以处理 reasoning_content）
+     */
+    parseStreamDelta(parsed) {
+        const delta = parsed.choices?.[0]?.delta;
+        return {
+            content: delta?.content,
+            reasoningContent: delta?.reasoning_content,
+        };
+    }
+    /**
+     * 累积内容（覆写以处理推理内容）
+     *
+     * 注意：此方法需要知道 endpoint 配置，但父类签名不包含
+     * 因此使用实例变量 accumulatedReasoning 来跨调用保持状态
+     */
+    accumulateContent(accumulated, content, reasoningContent) {
+        // 累积推理内容
+        if (reasoningContent) {
+            this.accumulatedReasoning += reasoningContent;
+        }
+        // 累积主内容
+        if (content) {
+            // 注意：这里无法直接获取 displayMode
+            // 实际的格式化在 formatFinalOutput 中处理
+            return accumulated + content;
+        }
+        return accumulated;
+    }
+    /**
+     * 格式化最终输出（根据 displayMode 配置）
+     */
+    formatOutput(content, reasoningContent, displayMode) {
+        if (!reasoningContent) {
+            return content;
+        }
+        switch (displayMode) {
+            case "show":
+                // 直接展示推理内容和回答
+                return `${reasoningContent}\n\n${content}`;
+            case "hide":
+                // 仅展示回答，隐藏推理过程
+                return content;
+            case "collapse":
+            default:
+                // 折叠展示
+                return `<think>\n${reasoningContent}\n</think>\n\n${content}`;
+        }
+    }
+    /**
+     * 处理流式响应（覆写以支持推理内容格式化）
+     */
+    async handleStreamResponse(params) {
+        // 重置累积状态
+        this.accumulatedReasoning = "";
+        const result = await super.handleStreamResponse(params);
+        // 如果有推理内容，需要重新格式化输出
+        if (this.accumulatedReasoning && params.endpoint) {
+            const displayMode = this.getReasoningDisplayMode(params.endpoint);
+            return this.formatOutput(result, this.accumulatedReasoning, displayMode);
+        }
+        return result;
+    }
+    /**
+     * 解析非流式响应内容（覆写以处理 reasoning_content）
+     */
+    parseNonStreamResponse(data) {
+        const message = data.choices?.[0]?.message;
+        const content = message?.content || "";
+        const reasoningContent = message?.reasoning_content || "";
+        // 非流式时无法获取 endpoint，使用默认 collapse 模式
+        // 实际调用时应通过 forward 方法传递正确的 displayMode
+        if (reasoningContent) {
+            return this.formatOutput(content, reasoningContent, "collapse");
+        }
+        return content;
+    }
+    /**
+     * 转发请求（覆写以传递 endpoint 到流式处理）
+     */
+    async forward(request, endpoint, callbacks) {
+        const { text, mediaPaths, quoteContent, abortSignal, runtime, historyMessages } = request;
+        const { deliver, onReplyStart, onError } = callbacks;
+        this.log(runtime, `Forwarding to DeepSeek: url=${endpoint.url}, model=${endpoint.model}`);
+        // 重置状态
+        this.accumulatedReasoning = "";
+        // 构建消息
+        const messages = this.buildMessages({
+            text,
+            mediaPaths,
+            quoteContent,
+            systemPrompt: endpoint.systemPrompt,
+            historyMessages,
+        });
+        // 构建请求体
+        const requestBody = this.buildRequestBody(messages, endpoint);
+        // 构建请求头
+        const headers = this.buildHeaders(endpoint);
+        // 超时控制
+        const timeoutMs = endpoint.timeoutMs || 300000;
+        const { controller, timeoutId } = this.createTimeoutController(timeoutMs, abortSignal);
+        try {
+            const response = await this.fetchWithErrorHandling(endpoint.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.handleDeepSeekStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                    displayMode,
+                });
+            }
+            else {
+                // 非流式响应
+                finalText = await this.handleDeepSeekNonStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                    displayMode,
+                });
+            }
+            // 最终 deliver
+            if (finalText) {
+                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);
+        }
+    }
+    /**
+     * 处理 DeepSeek 流式响应
+     *
+     * 注意：节流逻辑已移至 monitor 层统一控制，适配器层每个有效 delta 都直接 deliver
+     */
+    async handleDeepSeekStreamResponse(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 accumulatedReasoning = "";
+        let replyStarted = false;
+        try {
+            for await (const { data } of this.readSSEStream(reader, runtime)) {
+                if (data === "[DONE]") {
+                    this.log(runtime, "SSE stream [DONE]");
+                    continue;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    this.log(runtime, `Failed to parse SSE JSON: ${data.slice(0, 200)}`);
+                    continue;
+                }
+                const { content, reasoningContent } = this.parseStreamDelta(parsed);
+                // 累积推理内容
+                if (reasoningContent) {
+                    accumulatedReasoning += reasoningContent;
+                }
+                // 累积主内容
+                if (content) {
+                    accumulatedContent += content;
+                }
+                // 判断是否有新增内容
+                // - hide 模式下：仅当有主内容 (content) 时才考虑 deliver
+                // - show/collapse 模式下：有推理内容或主内容都考虑
+                const hasNewContent = displayMode === "hide" ? !!content : !!(content || reasoningContent);
+                if (hasNewContent) {
+                    // 首次收到有效内容时触发 onReplyStart
+                    if (!replyStarted) {
+                        replyStarted = true;
+                        try {
+                            await onReplyStart?.();
+                        }
+                        catch (e) {
+                            this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                        }
+                    }
+                    // 直接 deliver，节流由 monitor 层统一控制
+                    const formattedText = this.formatOutput(accumulatedContent, accumulatedReasoning, displayMode);
+                    try {
+                        await deliver({ text: formattedText }, { kind: "block" });
+                    }
+                    catch (e) {
+                        onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                    }
+                }
+                const finishReason = parsed.choices?.[0]?.finish_reason;
+                if (finishReason && finishReason !== "null") {
+                    this.log(runtime, `SSE finish_reason: ${finishReason}`);
+                }
+            }
+        }
+        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, accumulatedReasoning, displayMode);
+    }
+    /**
+     * 处理 DeepSeek 非流式响应
+     */
+    async handleDeepSeekNonStreamResponse(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 response JSON: ${String(err)}`);
+            onError?.(error, { kind: "parse" });
+            throw error;
+        }
+        const message = data.choices?.[0]?.message;
+        const content = message?.content || "";
+        const reasoningContent = message?.reasoning_content || "";
+        const formattedText = this.formatOutput(content, reasoningContent, 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 使用情况（含推理 token）
+        if (data.usage?.completion_tokens_details?.reasoning_tokens) {
+            this.log(runtime, `Token usage: reasoning_tokens=${data.usage.completion_tokens_details.reasoning_tokens}, total=${data.usage.total_tokens}`);
+        }
+        return formattedText;
+    }
+}
+
+exports.DeepSeekAdapter = DeepSeekAdapter;