wechaty-web-panel 1.6.112 → 1.6.113

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

@@ -0,0 +1,319 @@
+import axios from "axios";
+export const BASE_URL = "https://api.dify.ai/v1";
+export const routes = {
+    //  app's
+    feedback: {
+        method: "POST",
+        url: (message_id) => `/messages/${message_id}/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) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+    }
+    updateApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async sendRequest(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;
+        if (stream) {
+            response = await axios({
+                method,
+                url,
+                data,
+                params,
+                headers,
+                responseType: "stream",
+            });
+        }
+        else {
+            response = await axios({
+                method,
+                url,
+                ...(method !== "GET" && { data }),
+                params,
+                headers,
+                responseType: "json",
+            });
+        }
+        return response;
+    }
+    messageFeedback(message_id, rating, user) {
+        const data = {
+            rating,
+            user,
+        };
+        return this.sendRequest(routes.feedback.method, routes.feedback.url(message_id), data);
+    }
+    getApplicationParameters(user) {
+        const params = { user };
+        return this.sendRequest(routes.application.method, routes.application.url(), null, params);
+    }
+    fileUpload(data) {
+        return this.sendRequest(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(routes.createCompletionMessage.method, routes.createCompletionMessage.url(), data, null, 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 {
+    createChatMessage(inputs, query, user, stream = false, conversation_id = null, files = null) {
+        const data = {
+            inputs,
+            query,
+            user,
+            response_mode: stream ? "streaming" : "blocking",
+            files,
+        };
+        if (conversation_id)
+            data.conversation_id = conversation_id;
+        return this.sendRequest(routes.createChatMessage.method, routes.createChatMessage.url(), data, null, stream);
+    }
+    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);
+    }
+    getConversations(user, first_id = null, limit = null, pinned = null) {
+        const params = { user, first_id: first_id, limit, pinned };
+        return this.sendRequest(routes.getConversations.method, routes.getConversations.url(), null, params);
+    }
+    getConversationMessages(user, conversation_id = "", first_id = null, limit = null) {
+        const params = { user };
+        if (conversation_id)
+            params.conversation_id = conversation_id;
+        if (first_id)
+            params.first_id = first_id;
+        if (limit)
+            params.limit = limit;
+        return this.sendRequest(routes.getConversationMessages.method, routes.getConversationMessages.url(), null, params);
+    }
+    renameConversation(conversation_id, name, user, auto_generate) {
+        const data = { name, user, auto_generate };
+        return this.sendRequest(routes.renameConversation.method, routes.renameConversation.url(conversation_id), data);
+    }
+    deleteConversation(conversation_id, user) {
+        const data = { user };
+        return this.sendRequest(routes.deleteConversation.method, routes.deleteConversation.url(conversation_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=office.js.map

package/dist/bot/fastgpt/index.js

@@ -0,0 +1,98 @@
+import axios from 'axios';
+export class FastGPTAPI {
+    constructor(opts) {
+        const { apiKey, apiBaseUrl = 'https://cloud.fastgpt.cn/api/v1', debug } = opts;
+        this._apiKey = apiKey;
+        this._apiBaseUrl = apiBaseUrl;
+        this._debug = debug;
+        if (!this._apiKey) {
+            throw new Error('缺少 apiKey');
+        }
+    }
+    async sendMessage({ text, file }, opts = {}) {
+        const { timeoutMs, chatId, variables } = opts;
+        const body = {
+            chatId,
+            variables: {
+                ...variables,
+            },
+            messages: [
+                {
+                    role: 'user',
+                    content: text,
+                },
+            ],
+            stream: false,
+            customUid: `${variables?.uname || ''}${variables?.ualias ? `(${variables?.ualias})` : ''}`,
+            detail: false,
+        };
+        if (file && file.fileType === '图片') {
+            body.messages[0].content = [
+                {
+                    type: "text",
+                    text: text
+                },
+                {
+                    type: 'image_url',
+                    image_url: {
+                        url: file.fileUrl,
+                    },
+                },
+            ];
+        }
+        else if (file && file.fileType === '文件') {
+            body.messages[0].content = [
+                {
+                    type: "text",
+                    text: text
+                },
+                {
+                    type: 'file_url',
+                    name: file.fileName,
+                    url: file.fileUrl,
+                },
+            ];
+        }
+        if (this._debug) {
+            console.log('request body', body);
+        }
+        const response = await axios({
+            method: 'POST',
+            url: `${this._apiBaseUrl}/chat/completions`,
+            data: body || null,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this._apiKey}`,
+            },
+            timeout: timeoutMs,
+            responseType: 'json',
+        });
+        if (response.status === 200) {
+            if (this._debug) {
+                console.log('response.data', JSON.stringify(response.data));
+            }
+            if (response.data.code) {
+                console.log('FastGPT请求出错', JSON.stringify(response.data));
+                return {
+                    text: '',
+                };
+            }
+            const data = response.data.choices[0].message;
+            let finalText = data.content;
+            if (Array.isArray(finalText)) {
+                const finalContent = finalText.find((item) => item.type === 'text');
+                if (finalContent) {
+                    finalText = finalContent.text.content || '';
+                }
+            }
+            return {
+                text: finalText,
+            };
+        }
+        console.log('接口请求报错', response.data);
+        return {
+            text: '',
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/bot/qanything/index.js

@@ -0,0 +1,136 @@
+import axios from 'axios';
+const BASE_URL = 'https://openapi.youdao.com';
+const routes = {
+    // 发起对话
+    creatChat: {
+        method: 'POST', url: () => '/q_anything/api/bot/chat_stream',
+    }
+};
+class QAnyClient {
+    constructor({ apiKey, baseUrl = BASE_URL, debug = false, stream = true, botId }) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl || BASE_URL;
+        this.debug = debug;
+        this.stream = stream;
+        this.botId = botId;
+        this.history = [];
+    }
+    updateApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async sendRequest({ method, endpoint, data, params, stream = false, headerParams = {}, timeoutMs = 100 * 1000 }) {
+        const headers = {
+            ...{
+                Authorization: `${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            ...headerParams,
+        };
+        const url = `${this.baseUrl}${endpoint}`;
+        let response;
+        if (this.debug) {
+            console.log('request', url, { data, headers, params });
+        }
+        if (!stream) {
+            response = await axios.request({
+                method,
+                url,
+                data: data || {},
+                params: params || {},
+                headers,
+                timeout: timeoutMs,
+            });
+        }
+        else {
+            response = await axios({
+                method,
+                url,
+                data,
+                params,
+                headers,
+                responseType: 'stream',
+            });
+        }
+        return response;
+    }
+}
+export class QAnyApi extends QAnyClient {
+    async sendMessage(query, { needHistory, user, timeoutMs = 100 * 1000, variables, }) {
+        if (needHistory) {
+            this.history = this.history.slice(-2);
+        }
+        else {
+            this.history = [];
+        }
+        const data = {
+            uuid: this.botId,
+            question: query,
+            history: this.history
+        };
+        const res = await this.sendRequest({
+            method: routes.creatChat.method,
+            endpoint: routes.creatChat.url(),
+            data,
+            stream: this.stream,
+            timeoutMs,
+        });
+        const asyncSSE = stream => {
+            return new Promise((resolve, reject) => {
+                const answers = [];
+                let answer = '';
+                let id = '';
+                const chunks = [];
+                try {
+                    stream.on('data', data => {
+                        chunks.push(data);
+                    });
+                    stream.on('end', async () => {
+                        const result = Buffer.concat(chunks);
+                        console.log('思考完毕，准备回复');
+                        const streams = new TextDecoder('utf-8').decode(result, { stream: true }).split('\n');
+                        for (const stream of streams) {
+                            let res = {};
+                            try {
+                                res = JSON.parse(stream.substring(5)) || {};
+                            }
+                            catch (e) {
+                                // console.log('json 解析错误，不影响输出', stream)
+                                try {
+                                    res = JSON.parse(stream) || {};
+                                }
+                                catch (e) {
+                                    // console.log('json 解析错误，不影响输出', stream)
+                                }
+                            }
+                            if (res.errorCode && res.errorCode !== '0') {
+                                console.log('QAnything 请求报错', res.msg);
+                                answer = res.msg;
+                            }
+                            else if (res.errorCode) {
+                                if (res.result.response && !res.result.singleQAId) {
+                                    answers.push(res.result.response);
+                                }
+                                if (res.result.singleQAId) {
+                                    this.history = res.result.history;
+                                    id = res.result.singleQAId;
+                                    answer = res.result.response;
+                                }
+                            }
+                        }
+                        if (!answer) {
+                            answer = answers.join('');
+                        }
+                        resolve({ text: answer, conversationId: '', id: id });
+                    });
+                }
+                catch (e) {
+                    resolve({ text: `agent 出错，${e}`, conversationId: '', files: [] });
+                }
+            });
+        };
+        console.log('进入流式输出模式，请耐心等待模型的思考');
+        const result = await asyncSSE(res.data);
+        return result;
+    }
+}
+//# sourceMappingURL=index.js.map