@wwlocal/aibot-plugin-node 20260409.20.0

package/dist/cjs/src/adapters/index.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var openaiAdapter = require('./openai-adapter.js');
+var deepseekAdapter = require('./deepseek-adapter.js');
+var anthropicAdapter = require('./anthropic-adapter.js');
+var difyAdapter = require('./dify-adapter.js');
+var webhookAdapter = require('./webhook-adapter.js');
+
+/**
+ * 适配器注册表
+ *
+ * 管理所有智能体适配器的注册与发现
+ */
+// 导入内置适配器
+/**
+ * 适配器注册表实现
+ */
+class AdapterRegistry {
+    constructor() {
+        this.adapters = new Map();
+    }
+    /**
+     * 注册适配器
+     */
+    register(adapter) {
+        if (this.adapters.has(adapter.name)) {
+            console.warn(`[wecom][adapter] Adapter "${adapter.name}" is already registered, overwriting.`);
+        }
+        this.adapters.set(adapter.name, adapter);
+    }
+    /**
+     * 按 provider 名称获取适配器
+     */
+    get(provider) {
+        return this.adapters.get(provider);
+    }
+    /**
+     * 列出所有已注册适配器
+     */
+    list() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * 解析并返回适配器
+     *
+     * 解析优先级：
+     * 1. 优先使用 endpoint.provider 指定的适配器
+     * 2. 若 provider 未配置，尝试从 url 自动推断
+     * 3. 兜底使用 openai 适配器
+     */
+    resolve(endpoint) {
+        // 1. 优先使用显式配置的 provider
+        if (endpoint.provider) {
+            const adapter = this.adapters.get(endpoint.provider);
+            if (adapter) {
+                return adapter;
+            }
+            // provider 配置了但找不到对应适配器，抛出错误
+            const availableProviders = this.list().map((a) => a.name).join(", ");
+            throw new Error(`Unknown provider "${endpoint.provider}" for endpoint "${endpoint.name}". ` +
+                `Available providers: ${availableProviders}`);
+        }
+        // 2. 尝试从 URL 自动推断
+        const inferredProvider = this.inferProviderFromUrl(endpoint.url);
+        if (inferredProvider) {
+            const adapter = this.adapters.get(inferredProvider);
+            if (adapter) {
+                return adapter;
+            }
+        }
+        // 3. 兜底使用 openai 适配器
+        const defaultAdapter = this.adapters.get("openai");
+        if (!defaultAdapter) {
+            throw new Error("Default OpenAI adapter not found. This should not happen.");
+        }
+        return defaultAdapter;
+    }
+    /**
+     * 从 URL 推断 provider 类型
+     */
+    inferProviderFromUrl(url) {
+        const lowerUrl = url.toLowerCase();
+        // DeepSeek
+        if (lowerUrl.includes("deepseek")) {
+            return "deepseek";
+        }
+        // Anthropic（原生 API 或包含 /v1/messages 路径的兼容接口）
+        if (lowerUrl.includes("anthropic.com") || lowerUrl.includes("anthropic")) {
+            return "anthropic";
+        }
+        // Dify
+        if (lowerUrl.includes("dify") || lowerUrl.includes("chat-messages")) {
+            return "dify";
+        }
+        // 无法推断
+        return null;
+    }
+}
+// ============================================================================
+// 全局注册表实例
+// ============================================================================
+/**
+ * 全局适配器注册表
+ */
+const adapterRegistry = new AdapterRegistry();
+/**
+ * 注册内置适配器
+ */
+function registerBuiltinAdapters() {
+    adapterRegistry.register(new openaiAdapter.OpenAIAdapter());
+    adapterRegistry.register(new deepseekAdapter.DeepSeekAdapter());
+    adapterRegistry.register(new anthropicAdapter.AnthropicAdapter());
+    adapterRegistry.register(new difyAdapter.DifyAdapter());
+    adapterRegistry.register(new webhookAdapter.WebhookAdapter());
+}
+// 自动注册内置适配器
+registerBuiltinAdapters();
+/**
+ * 根据端点配置解析适配器
+ */
+function resolveAdapter(endpoint) {
+    return adapterRegistry.resolve(endpoint);
+}
+
+exports.OpenAIAdapter = openaiAdapter.OpenAIAdapter;
+exports.DeepSeekAdapter = deepseekAdapter.DeepSeekAdapter;
+exports.AnthropicAdapter = anthropicAdapter.AnthropicAdapter;
+exports.DifyAdapter = difyAdapter.DifyAdapter;
+exports.WebhookAdapter = webhookAdapter.WebhookAdapter;
+exports.adapterRegistry = adapterRegistry;
+exports.resolveAdapter = resolveAdapter;

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

@@ -0,0 +1,361 @@
+'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);
+
+/**
+ * OpenAI 适配器
+ *
+ * 适用于：OpenAI、Azure OpenAI、Ollama、vLLM、LocalAI 及任何 OpenAI Chat Completions API 兼容服务
+ *
+ * 特性：
+ * - 请求：{ messages, model, stream }
+ * - 流式响应：SSE data: {...} → 提取 choices[0].delta.content
+ * - 非流式响应：JSON → 提取 choices[0].message.content
+ * - 认证：Authorization: Bearer {apiKey}
+ */
+/**
+ * OpenAI 适配器
+ */
+class OpenAIAdapter extends baseAdapter.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = "openai";
+        this.displayName = "OpenAI";
+    }
+    /**
+     * 转发请求到 OpenAI 兼容 API
+     */
+    async forward(request, endpoint, callbacks) {
+        const { text, mediaPaths, quoteContent, abortSignal, runtime, historyMessages } = request;
+        const { deliver, onReplyStart, onError } = callbacks;
+        this.log(runtime, `Forwarding to: url=${endpoint.url}, stream=${endpoint.stream}`);
+        // 构建消息
+        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;
+            if (requestBody.stream) {
+                // 流式响应
+                finalText = await this.handleStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                });
+            }
+            else {
+                // 非流式响应
+                finalText = await this.handleNonStreamResponse({
+                    response,
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                });
+            }
+            // 最终 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);
+        }
+    }
+    // ==========================================================================
+    // 消息构建
+    // ==========================================================================
+    /**
+     * 将企微消息构建为 OpenAI messages 数组
+     */
+    buildMessages(options) {
+        const messages = [];
+        // 系统提示词
+        if (options.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: options.systemPrompt,
+            });
+        }
+        // 注入对话历史（在 system 之后、当前 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_url",
+                            image_url: {
+                                url: `data:${mimeType};base64,${base64}`,
+                                detail: "auto",
+                            },
+                        });
+                    }
+                    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;
+    }
+    /**
+     * 构建请求体
+     */
+    buildRequestBody(messages, endpoint) {
+        const requestBody = {
+            messages,
+            stream: endpoint.stream !== false,
+        };
+        if (endpoint.model) {
+            requestBody.model = endpoint.model;
+        }
+        return requestBody;
+    }
+    // ==========================================================================
+    // 流式响应处理
+    // ==========================================================================
+    /**
+     * 处理流式响应
+     *
+     * 注意：节流逻辑已移至 monitor 层统一控制，适配器层每个有效 delta 都直接 deliver
+     */
+    async handleStreamResponse(params) {
+        const { response, deliver, onReplyStart, onError, runtime } = params;
+        const body = response.body;
+        if (!body) {
+            throw new Error("Response has no body for streaming");
+        }
+        const reader = body.getReader();
+        let accumulatedText = "";
+        let replyStarted = false;
+        try {
+            for await (const { data } of this.readSSEStream(reader, runtime)) {
+                // [DONE] 标记
+                if (data === "[DONE]") {
+                    this.log(runtime, "SSE stream [DONE]");
+                    continue;
+                }
+                // 解析 JSON
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    this.log(runtime, `Failed to parse SSE JSON: ${data.slice(0, 200)}`);
+                    continue;
+                }
+                // 解析 delta 内容（子类可覆写此方法）
+                const { content, reasoningContent } = this.parseStreamDelta(parsed);
+                if (content || reasoningContent) {
+                    // 首次收到内容时触发 onReplyStart
+                    if (!replyStarted) {
+                        replyStarted = true;
+                        try {
+                            await onReplyStart?.();
+                        }
+                        catch (e) {
+                            this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                        }
+                    }
+                    // 累积文本（子类可自定义累积逻辑）
+                    accumulatedText = this.accumulateContent(accumulatedText, content, reasoningContent);
+                    // 直接 deliver，节流由 monitor 层统一控制
+                    try {
+                        await deliver({ text: accumulatedText }, { kind: "block" });
+                    }
+                    catch (e) {
+                        onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                    }
+                }
+                // 检查 finish_reason
+                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 accumulatedText;
+    }
+    /**
+     * 解析流式 delta 内容（子类可覆写）
+     */
+    parseStreamDelta(parsed) {
+        const delta = parsed.choices?.[0]?.delta;
+        return {
+            content: delta?.content,
+            reasoningContent: delta?.reasoning_content,
+        };
+    }
+    /**
+     * 累积内容（子类可覆写以自定义格式）
+     */
+    accumulateContent(accumulated, content, _reasoningContent) {
+        // OpenAI 适配器只累积 content，忽略 reasoning_content
+        if (content) {
+            return accumulated + content;
+        }
+        return accumulated;
+    }
+    // ==========================================================================
+    // 非流式响应处理
+    // ==========================================================================
+    /**
+     * 处理非流式响应
+     */
+    async handleNonStreamResponse(params) {
+        const { response, deliver, onReplyStart, onError, runtime } = 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 content = this.parseNonStreamResponse(data);
+        if (content) {
+            try {
+                await onReplyStart?.();
+            }
+            catch (e) {
+                this.logError(runtime, `onReplyStart error: ${String(e)}`);
+            }
+            try {
+                await deliver({ text: content }, { kind: "block" });
+            }
+            catch (e) {
+                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+            }
+        }
+        return content;
+    }
+    /**
+     * 解析非流式响应内容（子类可覆写）
+     */
+    parseNonStreamResponse(data) {
+        return data.choices?.[0]?.message?.content || "";
+    }
+}
+
+exports.OpenAIAdapter = OpenAIAdapter;