@wwlocal/aibot-plugin-node 20260409.20.0

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

@@ -0,0 +1,636 @@
+'use strict';
+
+var baseAdapter = require('./base-adapter.js');
+
+/**
+ * Dify 适配器
+ *
+ * 适用于：Dify 平台的 Chat 应用（ChatBot / Chatflow）
+ *
+ * 与 OpenAI 的核心差异：
+ * - 接口路径：/v1/chat-messages（而非 /v1/chat/completions）
+ * - 请求格式：{ query, user, conversation_id, response_mode, inputs, files }
+ * - 流式标识：response_mode: "streaming"
+ * - SSE 事件类型：
+ *   - ChatBot 模式：message（answer 字段）
+ *   - Chatflow 模式：text_chunk（text 字段）+ workflow/node/iteration/loop 事件
+ * - 会话管理：conversation_id（有状态多轮对话）
+ * - 文件上传：/v1/files/upload（multipart form-data）
+ */
+/**
+ * 会话 ID 缓存（chatId -> conversation_id）
+ * 带 TTL 清理，防止内存泄漏
+ */
+class ConversationCache {
+    constructor(ttlMs = 24 * 60 * 60 * 1000) {
+        this.cache = new Map();
+        // 默认 24 小时
+        this.ttlMs = ttlMs;
+    }
+    get(chatId) {
+        const entry = this.cache.get(chatId);
+        if (!entry)
+            return undefined;
+        // 检查 TTL
+        if (Date.now() - entry.timestamp > this.ttlMs) {
+            this.cache.delete(chatId);
+            return undefined;
+        }
+        return entry.conversationId;
+    }
+    set(chatId, conversationId) {
+        this.cache.set(chatId, {
+            conversationId,
+            timestamp: Date.now(),
+        });
+        // 定期清理过期条目（简单实现）
+        if (this.cache.size > 1000) {
+            this.cleanup();
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.ttlMs) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+/**
+ * Dify 适配器
+ */
+class DifyAdapter extends baseAdapter.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = "dify";
+        this.displayName = "Dify";
+    }
+    /**
+     * 获取 Dify 配置选项
+     */
+    getOptions(endpoint) {
+        return endpoint.providerOptions || {};
+    }
+    /**
+     * 转发请求到 Dify API
+     */
+    async forward(request, endpoint, callbacks) {
+        const { text, mediaPaths, abortSignal, runtime, context } = request;
+        const { deliver, onReplyStart, onError } = callbacks;
+        const options = this.getOptions(endpoint);
+        this.log(runtime, `Forwarding to Dify: url=${endpoint.url}, appType=${options.difyAppType || "chat"}`);
+        // 获取 chatId（用于会话管理）
+        const chatId = context?.chatId || "default";
+        const userId = options.difyUser || context?.userId || "wecom-user";
+        // 构建会话隔离 key：accountId + endpointName + chatId
+        // 防止不同账号/不同 Dify 应用共用 conversation_id
+        const accountId = context?.accountId || "default";
+        const conversationKey = `${accountId}:${endpoint.name}:${chatId}`;
+        // 获取已有的 conversation_id
+        const existingConversationId = DifyAdapter.conversationCache.get(conversationKey);
+        // 处理文件（如果有 mediaPaths）
+        // - 远程 URL：直接使用 transfer_method: "remote_url"，无需上传
+        // - 本地文件：先上传到 Dify /v1/files/upload，再用 transfer_method: "local_file"
+        let difyFiles;
+        if (mediaPaths && mediaPaths.length > 0) {
+            difyFiles = await this.prepareDifyFiles({
+                mediaPaths,
+                baseUrl: endpoint.url,
+                apiKey: endpoint.apiKey || "",
+                user: userId,
+                runtime,
+            });
+        }
+        // 构建请求体
+        const requestBody = this.buildDifyRequest({
+            query: text,
+            user: userId,
+            conversationId: existingConversationId,
+            inputs: options.difyInputs,
+            stream: endpoint.stream !== false,
+            files: difyFiles,
+        });
+        // 构建请求头
+        const headers = this.buildHeaders(endpoint);
+        // 拼接 chat-messages 路径
+        const chatMessagesUrl = this.buildChatMessagesUrl(endpoint.url);
+        // 超时控制
+        const timeoutMs = endpoint.timeoutMs || 300000;
+        const { controller, timeoutId } = this.createTimeoutController(timeoutMs, abortSignal);
+        try {
+            const response = await this.fetchWithErrorHandling(chatMessagesUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            }, runtime);
+            let finalText;
+            if (requestBody.response_mode === "streaming") {
+                // 流式响应
+                finalText = await this.handleStreamResponse({
+                    response,
+                    chatId: conversationKey,
+                    baseUrl: endpoint.url,
+                    apiKey: endpoint.apiKey || "",
+                    deliver,
+                    onReplyStart,
+                    onError,
+                    runtime,
+                    showWorkflowProgress: options.showWorkflowProgress,
+                });
+            }
+            else {
+                // 非流式响应
+                finalText = await this.handleBlockingResponse({
+                    response,
+                    chatId: conversationKey,
+                    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);
+        }
+    }
+    /**
+     * 构建 Dify 请求体
+     */
+    buildDifyRequest(params) {
+        const request = {
+            query: params.query,
+            user: params.user,
+            response_mode: params.stream ? "streaming" : "blocking",
+            // Dify 文档要求 inputs 必传，即使为空也需传 {}
+            inputs: params.inputs && Object.keys(params.inputs).length > 0
+                ? params.inputs
+                : {},
+        };
+        if (params.conversationId) {
+            request.conversation_id = params.conversationId;
+        }
+        if (params.files && params.files.length > 0) {
+            request.files = params.files;
+        }
+        return request;
+    }
+    /**
+     * 处理流式响应
+     */
+    async handleStreamResponse(params) {
+        const { response, chatId, baseUrl, deliver, onReplyStart, onError, runtime, showWorkflowProgress } = 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;
+        let currentEvent;
+        try {
+            for await (const { event, data } of this.readSSEStream(reader, runtime)) {
+                // 更新当前事件类型
+                if (event) {
+                    currentEvent = event;
+                }
+                // 跳过 ping 事件
+                if (currentEvent === "ping" || data === "") {
+                    continue;
+                }
+                // 解析事件数据
+                let eventData;
+                try {
+                    eventData = JSON.parse(data);
+                }
+                catch {
+                    this.log(runtime, `Failed to parse Dify SSE JSON: ${data.slice(0, 200)}`);
+                    continue;
+                }
+                // 处理不同事件类型
+                const eventType = eventData.event || currentEvent;
+                switch (eventType) {
+                    case "message":
+                        // ChatBot 模式：文本增量（answer 字段）
+                        if (eventData.answer) {
+                            if (!replyStarted) {
+                                replyStarted = true;
+                                try {
+                                    await onReplyStart?.();
+                                }
+                                catch (e) {
+                                    this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                                }
+                            }
+                            accumulatedText += eventData.answer;
+                            try {
+                                await deliver({ text: accumulatedText }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        // 保存 conversation_id
+                        if (eventData.conversation_id) {
+                            DifyAdapter.conversationCache.set(chatId, eventData.conversation_id);
+                        }
+                        break;
+                    case "text_chunk":
+                        // Chatflow 模式：文本片段（text 字段，非 answer）
+                        if (eventData.text) {
+                            if (!replyStarted) {
+                                replyStarted = true;
+                                try {
+                                    await onReplyStart?.();
+                                }
+                                catch (e) {
+                                    this.logError(runtime, `onReplyStart error: ${String(e)}`);
+                                }
+                            }
+                            accumulatedText += eventData.text;
+                            try {
+                                await deliver({ text: accumulatedText }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        // 保存 conversation_id
+                        if (eventData.conversation_id) {
+                            DifyAdapter.conversationCache.set(chatId, eventData.conversation_id);
+                        }
+                        break;
+                    case "message_end":
+                        // 消息结束
+                        this.log(runtime, "Dify message_end received");
+                        if (eventData.conversation_id) {
+                            DifyAdapter.conversationCache.set(chatId, eventData.conversation_id);
+                        }
+                        break;
+                    case "message_file":
+                        // 文件消息：优先使用 url，如果是相对路径则拼接完整 URL
+                        if (eventData.url) {
+                            const fileUrl = this.resolveFileUrl(eventData.url, baseUrl);
+                            this.log(runtime, `Dify file received: type=${eventData.type || "unknown"}, url=${fileUrl}`);
+                            try {
+                                await deliver({ mediaUrl: fileUrl }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        break;
+                    case "message_replace":
+                        // 替换消息（用新内容覆盖）—— ChatBot 模式
+                        if (eventData.answer !== undefined) {
+                            accumulatedText = eventData.answer;
+                            try {
+                                await deliver({ text: accumulatedText }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        break;
+                    case "text_replace":
+                        // 替换文本（用新内容覆盖）—— Chatflow 模式
+                        if (eventData.text !== undefined) {
+                            accumulatedText = eventData.text;
+                            try {
+                                await deliver({ text: accumulatedText }, { kind: "block" });
+                            }
+                            catch (e) {
+                                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+                            }
+                        }
+                        break;
+                    case "workflow_started":
+                        if (showWorkflowProgress) {
+                            this.log(runtime, "Dify workflow started");
+                        }
+                        // 保存 conversation_id
+                        if (eventData.conversation_id) {
+                            DifyAdapter.conversationCache.set(chatId, eventData.conversation_id);
+                        }
+                        break;
+                    case "workflow_finished":
+                        if (showWorkflowProgress) {
+                            this.log(runtime, `Dify workflow finished: status=${eventData.data?.status}`);
+                        }
+                        break;
+                    case "node_started":
+                        if (showWorkflowProgress && eventData.data?.title) {
+                            this.log(runtime, `Dify node started: ${eventData.data.title}`);
+                        }
+                        break;
+                    case "node_finished":
+                        if (showWorkflowProgress && eventData.data?.title) {
+                            this.log(runtime, `Dify node finished: ${eventData.data.title}`);
+                        }
+                        break;
+                    case "node_retry":
+                        if (showWorkflowProgress && eventData.data?.title) {
+                            this.log(runtime, `Dify node retry: ${eventData.data.title}, retryIndex=${eventData.data.retry_index}`);
+                        }
+                        break;
+                    case "iteration_started":
+                    case "iteration_next":
+                    case "iteration_completed":
+                        if (showWorkflowProgress) {
+                            this.log(runtime, `Dify ${eventType}: index=${eventData.data?.index}`);
+                        }
+                        break;
+                    case "loop_started":
+                    case "loop_next":
+                    case "loop_completed":
+                        if (showWorkflowProgress) {
+                            this.log(runtime, `Dify ${eventType}: index=${eventData.data?.index}`);
+                        }
+                        break;
+                    case "workflow_paused":
+                        this.log(runtime, "Dify workflow paused (waiting for human input)");
+                        break;
+                    case "agent_log":
+                        if (showWorkflowProgress) {
+                            this.log(runtime, `Dify agent_log: ${data.slice(0, 200)}`);
+                        }
+                        break;
+                    case "error":
+                        // 错误事件
+                        const errorMsg = eventData.message || "Unknown Dify error";
+                        this.logError(runtime, `Dify error: code=${eventData.code}, status=${eventData.status}, message=${errorMsg}`);
+                        onError?.(new Error(errorMsg), { kind: "dify-error" });
+                        break;
+                    default:
+                        // 未知事件类型，记录日志
+                        this.log(runtime, `Unknown Dify event: ${eventType}`);
+                }
+            }
+        }
+        catch (err) {
+            this.logError(runtime, `SSE stream error: ${String(err)}`);
+            onError?.(err instanceof Error ? err : new Error(String(err)), { kind: "stream" });
+        }
+        return accumulatedText;
+    }
+    /**
+     * 处理非流式（blocking）响应
+     */
+    async handleBlockingResponse(params) {
+        const { response, chatId, deliver, onReplyStart, onError, runtime } = params;
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch (err) {
+            const error = new Error(`Failed to parse Dify response JSON: ${String(err)}`);
+            onError?.(error, { kind: "parse" });
+            throw error;
+        }
+        // 保存 conversation_id
+        if (data.conversation_id) {
+            DifyAdapter.conversationCache.set(chatId, data.conversation_id);
+        }
+        const answer = data.answer || "";
+        if (answer) {
+            try {
+                await onReplyStart?.();
+            }
+            catch (e) {
+                this.logError(runtime, `onReplyStart error: ${String(e)}`);
+            }
+            try {
+                await deliver({ text: answer }, { kind: "block" });
+            }
+            catch (e) {
+                onError?.(e instanceof Error ? e : new Error(String(e)), { kind: "block" });
+            }
+        }
+        return answer;
+    }
+    // ==========================================================================
+    // 文件上传
+    // ==========================================================================
+    /**
+     * 准备 Dify 文件参数
+     *
+     * 根据 Dify 文档，文件有两种传输方式：
+     * - remote_url：直接传 URL，Dify 自行下载（适用于远程 URL）
+     * - local_file：先通过 /v1/files/upload 上传，再传 upload_file_id（适用于本地文件）
+     *
+     * @returns DifyFile 列表（处理失败的跳过并记录日志）
+     */
+    async prepareDifyFiles(params) {
+        const { mediaPaths, baseUrl, apiKey, user, runtime } = params;
+        const results = [];
+        for (const media of mediaPaths) {
+            try {
+                if (media.path.startsWith("http://") || media.path.startsWith("https://")) {
+                    // 远程 URL：直接使用 remote_url 方式，无需上传
+                    const contentType = media.contentType || this.guessContentTypeFromUrl(media.path);
+                    const difyType = this.inferDifyFileType(contentType);
+                    this.log(runtime, `Using remote_url for Dify file: type=${difyType}, url=${media.path}`);
+                    results.push({
+                        type: difyType,
+                        transfer_method: "remote_url",
+                        url: media.path,
+                    });
+                }
+                else {
+                    // 本地文件：先上传到 Dify，再用 local_file 方式
+                    const uploaded = await this.uploadLocalFile({
+                        filePath: media.path,
+                        contentType: media.contentType,
+                        baseUrl,
+                        apiKey,
+                        user,
+                        runtime,
+                    });
+                    if (uploaded) {
+                        results.push(uploaded);
+                    }
+                }
+            }
+            catch (err) {
+                this.logError(runtime, `Failed to prepare file ${media.path}: ${String(err)}`);
+            }
+        }
+        return results;
+    }
+    /**
+     * 上传本地文件到 Dify（/v1/files/upload）
+     *
+     * @returns 上传成功的 DifyFile，失败返回 undefined
+     */
+    async uploadLocalFile(params) {
+        const { filePath, contentType: providedContentType, baseUrl, apiKey, user, runtime } = params;
+        const uploadUrl = this.buildApiUrl(baseUrl, "/files/upload");
+        const { readFile } = await import('node:fs/promises');
+        const { basename } = await import('node:path');
+        const fileBuffer = await readFile(filePath);
+        const filename = basename(filePath);
+        const contentType = providedContentType || this.guessContentType(filename);
+        const difyType = this.inferDifyFileType(contentType);
+        this.log(runtime, `Uploading local file to Dify: name=${filename}, type=${difyType}, size=${fileBuffer.byteLength}`);
+        // 构建 multipart/form-data
+        const formData = new FormData();
+        const blob = new Blob([fileBuffer], { type: contentType });
+        formData.append("file", blob, filename);
+        formData.append("user", user);
+        const response = await fetch(uploadUrl, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "(unreadable)");
+            this.logError(runtime, `Dify file upload failed: HTTP ${response.status} — ${errorBody.slice(0, 300)}`);
+            return undefined;
+        }
+        const uploadResult = await response.json();
+        this.log(runtime, `Dify file uploaded: id=${uploadResult.id}, name=${uploadResult.name}`);
+        return {
+            type: difyType,
+            transfer_method: "local_file",
+            upload_file_id: uploadResult.id,
+        };
+    }
+    /**
+     * 从 URL 中提取文件名
+     */
+    extractFilename(url) {
+        try {
+            const pathname = new URL(url).pathname;
+            const parts = pathname.split("/");
+            return parts[parts.length - 1] || "file";
+        }
+        catch {
+            return "file";
+        }
+    }
+    /**
+     * 根据文件名猜测 Content-Type
+     */
+    guessContentType(filename) {
+        const ext = filename.split(".").pop()?.toLowerCase() || "";
+        const mimeMap = {
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            gif: "image/gif",
+            webp: "image/webp",
+            svg: "image/svg+xml",
+            pdf: "application/pdf",
+            doc: "application/msword",
+            docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            xls: "application/vnd.ms-excel",
+            xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            ppt: "application/vnd.ms-powerpoint",
+            pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            txt: "text/plain",
+            csv: "text/csv",
+            mp3: "audio/mpeg",
+            wav: "audio/wav",
+            mp4: "video/mp4",
+            avi: "video/x-msvideo",
+        };
+        return mimeMap[ext] || "application/octet-stream";
+    }
+    /**
+     * 从 URL 中猜测 Content-Type
+     */
+    guessContentTypeFromUrl(url) {
+        const filename = this.extractFilename(url);
+        return this.guessContentType(filename);
+    }
+    /**
+     * 根据 Content-Type 推断 Dify 文件类型
+     */
+    inferDifyFileType(contentType) {
+        if (contentType.startsWith("image/"))
+            return "image";
+        if (contentType.startsWith("audio/"))
+            return "audio";
+        if (contentType.startsWith("video/"))
+            return "video";
+        return "document";
+    }
+    // ==========================================================================
+    // URL 工具
+    // ==========================================================================
+    /**
+     * 拼接 Dify API URL
+     *
+     * 支持多种 baseUrl 格式：
+     * - http://host/v1 → http://host/v1/chat-messages
+     * - http://host/v1/ → http://host/v1/chat-messages
+     * - http://host → http://host/v1/chat-messages
+     * - http://host/v1/chat-messages → http://host/v1/chat-messages (不变)
+     */
+    buildChatMessagesUrl(baseUrl) {
+        // 如果已经包含 chat-messages 路径，直接返回
+        if (baseUrl.includes("/chat-messages")) {
+            return baseUrl;
+        }
+        return this.buildApiUrl(baseUrl, "/chat-messages");
+    }
+    /**
+     * 拼接 Dify API 通用路径
+     */
+    buildApiUrl(baseUrl, path) {
+        let base = baseUrl.replace(/\/+$/, "");
+        // 如果 baseUrl 不包含 /v1，自动补上
+        if (!base.includes("/v1")) {
+            base += "/v1";
+        }
+        return `${base}${path}`;
+    }
+    /**
+     * 解析文件 URL（处理相对路径）
+     *
+     * Dify 返回的 message_file.url 可能是：
+     * - 完整的 HTTP URL → 直接使用
+     * - 相对路径（如 /files/xxx/preview） → 拼接 baseUrl
+     */
+    resolveFileUrl(url, baseUrl) {
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+            return url;
+        }
+        // 相对路径：从 baseUrl 提取 origin
+        try {
+            const origin = new URL(baseUrl).origin;
+            return `${origin}${url.startsWith("/") ? url : `/${url}`}`;
+        }
+        catch {
+            return url;
+        }
+    }
+}
+// 全局会话缓存
+DifyAdapter.conversationCache = new ConversationCache();
+
+exports.DifyAdapter = DifyAdapter;