@wwlocal/aibot-plugin-node 20260409.20.0

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

@@ -0,0 +1,326 @@
+import { OpenAIAdapter } from './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 {
+    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;
+    }
+}
+
+export { DeepSeekAdapter };