wechaty-web-panel 1.6.112 → 1.6.113

package/dist/bot/dify/sdk/index.js

@@ -0,0 +1,461 @@
+import axios from 'axios';
+export const BASE_URL = 'https://api.dify.ai/v1';
+export const routes = {
+    //  app's
+    feedback: {
+        method: 'POST', url: (messageId) => `/messages/${messageId}/feedbacks`
+    },
+    application: {
+        method: 'GET', url: () => `/parameters`
+    },
+    fileUpload: {
+        method: 'POST',
+        url: () => `/files/upload`
+    },
+    textToAudio: {
+        method: "POST",
+        url: () => `/text-to-audio`,
+    },
+    getMeta: {
+        method: "GET",
+        url: () => `/meta`,
+    },
+    // completion's
+    createCompletionMessage: {
+        method: 'POST', url: () => `/completion-messages`
+    },
+    // chat's
+    createChatMessage: {
+        method: 'POST', url: () => `/chat-messages`
+    },
+    getSuggested: {
+        method: "GET",
+        url: (message_id) => `/messages/${message_id}/suggested`,
+    },
+    stopChatMessage: {
+        method: "POST",
+        url: (task_id) => `/chat-messages/${task_id}/stop`,
+    },
+    getConversations: {
+        method: 'GET', url: () => '/conversations'
+    },
+    getConversationMessages: {
+        method: 'GET', url: () => '/messages'
+    },
+    renameConversation: {
+        method: "POST",
+        url: (conversation_id) => `/conversations/${conversation_id}/name`,
+    },
+    deleteConversation: {
+        method: 'DELETE',
+        url: (conversation_id) => `/conversations/${conversation_id}`
+    },
+    audioToText: {
+        method: "POST",
+        url: () => `/audio-to-text`,
+    },
+    // workflow‘s
+    getWorkflowInfo: {
+        method: "GET",
+        url: () => `/info`,
+    },
+    runWorkflow: {
+        method: "POST",
+        url: () => `/workflows/run`,
+    },
+    stopWorkflow: {
+        method: "POST",
+        url: (task_id) => `/workflows/${task_id}/stop`,
+    },
+    getWorkflowResult: {
+        method: "GET",
+        url: (task_id) => `/workflows/run/${task_id}`,
+    },
+};
+export class DifyClient {
+    constructor({ apiKey, baseUrl = BASE_URL, debug = false, systemMessage = null, stream = false }) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.debug = debug;
+        this.stream = stream;
+        this.systemMessage = systemMessage;
+    }
+    updateApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async sendUploadRequest(method, endpoint, data = null, params = null, stream = false, headerParams = {}) {
+        const headers = {
+            ...{
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            ...headerParams
+        };
+        const url = `${this.baseUrl}${endpoint}`;
+        let response = await axios({
+            method,
+            url,
+            data,
+            params,
+            headers,
+            responseType: 'json'
+        });
+        return response;
+    }
+    async sendRequest({ method, endpoint, data, params, stream = false, headerParams = {}, timeoutMs = 100 * 1000 }) {
+        const headers = {
+            ...{
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            ...headerParams
+        };
+        const url = `${this.baseUrl}${endpoint}`;
+        let response;
+        if (this.debug) {
+            console.log('dify request', url, { data, headers, params });
+        }
+        if (!stream) {
+            response = await axios({
+                method,
+                url,
+                ...(method !== "GET" && { data }),
+                params: params || null,
+                headers,
+                timeout: timeoutMs,
+                responseType: 'json'
+            });
+        }
+        else {
+            response = await axios({
+                method,
+                url,
+                data,
+                params,
+                headers,
+                responseType: 'stream'
+            });
+        }
+        return response;
+    }
+    messageFeedback(messageId, rating, user) {
+        const data = {
+            rating, user
+        };
+        return this.sendRequest({ method: routes.feedback.method, endpoint: routes.feedback.url(messageId), data });
+    }
+    getApplicationParameters(user) {
+        const params = { user };
+        return this.sendRequest({ method: routes.application.method, endpoint: routes.application.url(), params });
+    }
+    fileUpload(data) {
+        return this.sendUploadRequest(routes.fileUpload.method, routes.fileUpload.url(), data, null, false, {
+            'Content-Type': 'multipart/form-data'
+        });
+    }
+    textToAudio(text, user, streaming = false) {
+        const data = {
+            text,
+            user,
+            streaming
+        };
+        return this.sendRequest(routes.textToAudio.method, routes.textToAudio.url(), data, null, streaming);
+    }
+    getMeta(user) {
+        const params = { user };
+        return this.sendRequest(routes.meta.method, routes.meta.url(), null, params);
+    }
+}
+export class CompletionClient extends DifyClient {
+    createCompletionMessage(inputs, user, stream = false, files = null) {
+        const data = {
+            inputs,
+            user,
+            response_mode: stream ? 'streaming' : 'blocking',
+            files
+        };
+        return this.sendRequest({
+            method: routes.createCompletionMessage.method,
+            endpoint: routes.createCompletionMessage.url(),
+            data,
+            stream
+        });
+    }
+    runWorkflow(inputs, user, stream = false, files = null) {
+        const data = {
+            inputs,
+            user,
+            response_mode: stream ? "streaming" : "blocking",
+        };
+        return this.sendRequest(routes.runWorkflow.method, routes.runWorkflow.url(), data, null, stream);
+    }
+}
+export class ChatClient extends DifyClient {
+    async sendMessage(query, { systemMessage, user, conversationId = null, timeoutMs = 100 * 1000, files = null, inputs }) {
+        const data = {
+            inputs: {
+                ...inputs
+            },
+            query,
+            user,
+            response_mode: this.stream ? 'streaming' : 'blocking',
+            files
+        };
+        if (systemMessage || this.systemMessage) {
+            data.inputs['systemMessage'] = systemMessage || this.systemMessage;
+        }
+        if (conversationId)
+            data.conversation_id = conversationId;
+        if (this.debug) {
+            console.log('request data', data);
+        }
+        const res = await this.sendRequest({
+            method: routes.createChatMessage.method,
+            endpoint: routes.createChatMessage.url(),
+            data,
+            stream: this.stream,
+            timeoutMs
+        });
+        function unicodeToChar(text) {
+            if (!text)
+                return '';
+            return text.replace(/\\u[0-9a-f]{4}/g, (_match, p1) => {
+                return String.fromCharCode(parseInt(p1, 16));
+            });
+        }
+        const asyncSSE = (stream) => {
+            return new Promise((resolve, reject) => {
+                const answers = [];
+                const thought = [];
+                const files = [];
+                let conversation_id = '';
+                let id = '';
+                try {
+                    stream.on('data', data => {
+                        const streams = new TextDecoder('utf-8').decode(data, { stream: true }).split('\n');
+                        streams.forEach(stream => {
+                            if (stream && stream.startsWith('data: ')) {
+                                let res = {};
+                                try {
+                                    res = JSON.parse(stream.substring(6)) || {};
+                                }
+                                catch (e) {
+                                    // console.log('json 解析错误，不影响输出', e)
+                                    return;
+                                }
+                                if (!res.event || res.event === 'error' || res.status === 400) {
+                                    console.log(`流式输出错误code:${res.code}`, res.message);
+                                    answers.push(res.message);
+                                    return;
+                                }
+                                if (res.event === 'agent_message' && res.answer || res.event === 'message' && res.answer) {
+                                    conversation_id = res.conversation_id;
+                                    answers.push(unicodeToChar(res.answer));
+                                }
+                                if (res.event === 'message_file') {
+                                    console.log('收到一个需要展示的文件，稍后发送');
+                                    files.push(res.url);
+                                }
+                                if (res.event === 'agent_thought' && res.thought) {
+                                    console.log('Dify Agent 正在思考...');
+                                    thought.push(res.thought);
+                                }
+                                if (res.event === 'message_end') {
+                                    console.log('流数据接收完毕，正在组装数据进行发送');
+                                    conversation_id = res.conversation_id;
+                                    id = res.id;
+                                }
+                            }
+                        });
+                    });
+                    stream.on('end', async () => {
+                        const { data } = conversation_id ? await this.getConversationMessages(user, conversation_id, null, 2) : { data: { data: [] } };
+                        const lastMessage = data.data[data.data.length - 1] || {};
+                        if (this.debug) {
+                            console.log('获取最后一条对话记录', lastMessage);
+                        }
+                        let answer = '';
+                        let finalFiles = [];
+                        if (lastMessage.answer) {
+                            answer = lastMessage.answer;
+                        }
+                        else {
+                            answer = thought[thought.length - 1] ? thought[thought.length - 1] : answers.join('');
+                        }
+                        if (lastMessage.message_files && lastMessage.message_files.length) {
+                            lastMessage.message_files.forEach(item => {
+                                finalFiles.push(item.url);
+                            });
+                        }
+                        else {
+                            finalFiles = files;
+                        }
+                        resolve({ text: answer, conversationId: conversation_id, id, files: finalFiles });
+                    });
+                }
+                catch (e) {
+                    resolve({ text: `AI agent 出错，${e}`, conversationId: '', files: [] });
+                }
+            });
+        };
+        if (!this.stream) {
+            if (res.data.code) {
+                if (this.debug) {
+                    console.log('dify request error', res.data.code, res.data.message);
+                }
+                return Promise.reject(res.message);
+            }
+            const response = res.data;
+            return {
+                text: response.answer,
+                conversationId: response.conversation_id,
+                files: [],
+                id: response.id
+            };
+        }
+        else {
+            console.log('进入Dify Agent 智能助手输出模式，请耐心等待模型的思考');
+            const result = await asyncSSE(res.data);
+            return result;
+        }
+    }
+    getConversationMessages(user, conversationId = '', firstId = null, limit = null) {
+        const params = { user };
+        if (conversationId)
+            params.conversation_id = conversationId;
+        if (firstId)
+            params.first_id = firstId;
+        if (limit)
+            params.limit = limit;
+        return this.sendRequest({
+            method: routes.getConversationMessages.method, endpoint: routes.getConversationMessages.url(), params
+        });
+    }
+    getConversations(user, firstId = null, limit = null, pinned = null) {
+        const params = { user, first_id: firstId, limit, pinned };
+        return this.sendRequest({
+            method: routes.getConversations.method, endpoint: routes.getConversations.url(), params
+        });
+    }
+    renameConversation(conversationId, name, user) {
+        const data = { name, user };
+        return this.sendRequest({
+            method: routes.renameConversation.method, endpoint: routes.renameConversation.url(conversationId), data
+        });
+    }
+    getSuggested(message_id, user) {
+        const data = { user };
+        return this.sendRequest(routes.getSuggested.method, routes.getSuggested.url(message_id), data);
+    }
+    stopMessage(task_id, user) {
+        const data = { user };
+        return this.sendRequest(routes.stopChatMessage.method, routes.stopChatMessage.url(task_id), data);
+    }
+    audioToText(data) {
+        return this.sendRequest(routes.audioToText.method, routes.audioToText.url(), data, null, false, {
+            "Content-Type": 'multipart/form-data'
+        });
+    }
+}
+export class WorkflowClient extends DifyClient {
+    run(inputs, user, stream) {
+        const data = {
+            inputs,
+            response_mode: stream ? "streaming" : "blocking",
+            user
+        };
+        return this.sendRequest(routes.runWorkflow.method, routes.runWorkflow.url(), data, null, stream);
+    }
+    stop(task_id, user) {
+        const data = { user };
+        return this.sendRequest(routes.stopWorkflow.method, routes.stopWorkflow.url(task_id), data);
+    }
+    info(user) {
+        const params = { user };
+        return this.sendRequest(routes.getWorkflowInfo.method, routes.getWorkflowInfo.url(), null, params);
+    }
+    result(task_id) {
+        return this.sendRequest(routes.getWorkflowResult.method, routes.getWorkflowResult.url(task_id), null);
+    }
+    async getWorkflowResult(input, user, isStream) {
+        const res = await this.run(input, user, isStream);
+        function unicodeToChar(text) {
+            if (!text)
+                return '';
+            return text.replace(/\\u[0-9a-f]{4}/g, (_match, p1) => {
+                return String.fromCharCode(parseInt(p1, 16));
+            });
+        }
+        const asyncSSE = (stream) => {
+            return new Promise((resolve, reject) => {
+                let task_id = '';
+                try {
+                    stream.on('data', data => {
+                        const streams = new TextDecoder('utf-8').decode(data, { stream: true }).split('\n');
+                        streams.forEach(stream => {
+                            if (stream && stream.startsWith('data: ')) {
+                                let res = {};
+                                try {
+                                    res = JSON.parse(stream.substring(6)) || {};
+                                }
+                                catch (e) {
+                                    return;
+                                }
+                                if (!res.event || res.event === 'error' || res.status === 400) {
+                                    console.log(`工作流输出错误code:${res.code}`, res.message);
+                                    return;
+                                }
+                                if (res.event === 'workflow_started' || res.event === 'tts_message') {
+                                    task_id = res?.workflow_run_id;
+                                    console.log('工作流开始执行');
+                                }
+                                if (res.event === 'node_started' || res.event === 'node_finished') {
+                                    task_id = res?.workflow_run_id;
+                                    console.log('工作流node节点执行任务中');
+                                }
+                                if (res.event === 'workflow_finished' || res.event === 'tts_message_end') {
+                                    console.log('工作流执行完毕，正在组装数据进行发送');
+                                    task_id = res?.workflow_run_id;
+                                }
+                            }
+                        });
+                    });
+                    stream.on('end', async () => {
+                        const { data } = task_id ? await this.result(task_id) : { data: { outputs: '' } };
+                        console.log('获取工作流执行结果', task_id, JSON.stringify(data.outputs));
+                        let outputs = {};
+                        if (data.outputs) {
+                            try {
+                                outputs = JSON.parse(data.outputs);
+                            }
+                            catch (error) {
+                                console.log(`获取工作流执行结果,失败:${error}`);
+                            }
+                        }
+                        resolve({ text: outputs?.text, task_id: task_id });
+                    });
+                }
+                catch (e) {
+                    resolve({ text: `Dify工作流执行出错，${e}`, task_id: '' });
+                }
+            });
+        };
+        if (!isStream) {
+            if (res.data.code) {
+                console.log('Dify 工作流执行失败', res.data.code, res.data.message);
+                return Promise.reject(res.message);
+            }
+            const response = res.data;
+            return {
+                text: response?.data?.outputs?.text || '',
+                task_id: response?.task_id,
+            };
+        }
+        else {
+            console.log('进入Dify工作流，请耐心等待...');
+            const result = await asyncSSE(res.data);
+            return result;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map