wechaty-web-panel 1.6.112 → 1.6.113

package/dist/botInstance/sdk/coze.js

@@ -0,0 +1,200 @@
+import Keyv from "keyv";
+import pTimeout from "./pTimeout.js";
+import QuickLRU from "./quick-lru.js";
+import { v4 as uuidv4 } from "uuid";
+const ChatCozeError = class extends Error {
+};
+const fetch = globalThis.fetch;
+let CozeAPI = class {
+    constructor(opts) {
+        const { apiKey, apiBaseUrl = "https://api.coze.com/open_api/v2", debug = false, messageStore, systemMessage, getMessageById, upsertMessage, botId, fetch: fetch2 = fetch } = opts;
+        this._apiKey = apiKey;
+        this._apiBaseUrl = apiBaseUrl || "https://api.coze.com/open_api/v2";
+        this._debug = !!debug;
+        this._fetch = fetch2;
+        this._completionParams = {
+            bot_id: botId
+        };
+        this._systemMessage = systemMessage;
+        if (this._systemMessage === void 0) {
+            const currentDate = new Date().toISOString().split("T")[0];
+            this._systemMessage = `You are ChatGPT, a large language model trained by OpenAI. Answer as concisely as possible.
+Knowledge cutoff: 2023-12-31
+Current date: ${currentDate}`;
+        }
+        this._getMessageById = getMessageById ?? this._defaultGetMessageById;
+        this._upsertMessage = upsertMessage ?? this._defaultUpsertMessage;
+        if (messageStore) {
+            this._messageStore = messageStore;
+        }
+        else {
+            this._messageStore = new Keyv({
+                store: new QuickLRU({ maxSize: 1e4 })
+            });
+        }
+        if (!this._apiKey) {
+            throw new Error("Coze missing required PERSONAL_ACCESS_TOKEN");
+        }
+        if (!this._fetch) {
+            throw new Error("Invalid environment; fetch is not defined");
+        }
+        if (typeof this._fetch !== "function") {
+            throw new Error("Invalid \"fetch\" is not a function");
+        }
+    }
+    async sendMessage(text, opts = {}) {
+        const { parentMessageId, messageId = uuidv4(), timeoutMs, onProgress, stream = !!onProgress, user, conversationId, } = opts;
+        let { abortSignal } = opts;
+        let abortController = null;
+        if (timeoutMs && !abortSignal) {
+            abortController = new AbortController();
+            abortSignal = abortController.signal;
+        }
+        const latestQuestion = {
+            role: "user",
+            id: messageId,
+            conversationId,
+            parentMessageId,
+            text,
+            user
+        };
+        const { messages } = await this._buildMessages(text, opts);
+        const result = {
+            role: "assistant",
+            id: uuidv4(),
+            conversationId,
+            parentMessageId: messageId,
+            text: "",
+            suggestions: [],
+            user,
+            type: 'answer'
+        };
+        const responseP = new Promise(async (resolve, reject) => {
+            let _a, _b;
+            const url = `${this._apiBaseUrl}/chat`;
+            const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this._apiKey}`
+            };
+            const body = {
+                query: text,
+                stream,
+                conversation_id: conversationId,
+                ...this._completionParams,
+                user,
+                chat_history: messages,
+            };
+            if (this._debug) {
+                console.log(`Coze send body`, body);
+            }
+            try {
+                const res = await this._fetch(url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: abortSignal
+                });
+                if (!res.ok) {
+                    const reason = await res.text();
+                    const msg = `Coze error ${res.status || res.statusText}: ${reason}`;
+                    const error = new ChatCozeError(msg, { cause: res });
+                    error.statusCode = res.status;
+                    error.statusText = res.statusText;
+                    return reject(error);
+                }
+                const response = await res.json();
+                if (this._debug) {
+                    console.log('Coze response', response);
+                }
+                if (response.code === 0 && response.msg === "success") {
+                    result.id = uuidv4();
+                    result.conversationId = response.conversation_id;
+                    const messages = response.messages;
+                    const message2 = messages.find((message) => message.role === "assistant" && message.type === "answer");
+                    result.text = message2.content;
+                    result.type = message2.type;
+                    if (message2.role) {
+                        result.role = message2.role;
+                    }
+                    result.suggestions = messages.filter((message) => message.role === "assistant" && message.type === "follow_up") || [];
+                }
+                else {
+                    return reject(new Error(`Coze error: ${response.msg}`));
+                }
+                result.detail = response;
+                return resolve(result);
+            }
+            catch (err) {
+                return reject(err);
+            }
+        }).then(async (message2) => {
+            return Promise.all([
+                this._upsertMessage(latestQuestion),
+                this._upsertMessage(message2)
+            ]).then(() => message2);
+        });
+        if (timeoutMs) {
+            if (abortController) {
+                responseP.cancel = () => {
+                    abortController.abort();
+                };
+            }
+            return pTimeout(responseP, {
+                milliseconds: timeoutMs,
+                message: "Coze timed out waiting for response"
+            });
+        }
+        else {
+            return responseP;
+        }
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    set apiKey(apiKey) {
+        this._apiKey = apiKey;
+    }
+    async _buildMessages(msg, opts) {
+        const { systemMessage = this._systemMessage } = opts;
+        let { parentMessageId } = opts;
+        let messages = [];
+        if (systemMessage) {
+            messages.push({
+                role: "system",
+                content: systemMessage,
+                content_type: "text"
+            });
+        }
+        const systemMessageOffset = messages.length;
+        let nextMessages = messages;
+        do {
+            messages = nextMessages;
+            if (!parentMessageId) {
+                break;
+            }
+            const parentMessage = await this._getMessageById(parentMessageId);
+            if (!parentMessage) {
+                break;
+            }
+            const parentMessageRole = parentMessage.role || "user";
+            nextMessages = nextMessages.slice(0, systemMessageOffset).concat([
+                {
+                    role: parentMessageRole,
+                    content: parentMessage.text,
+                    type: parentMessage.type,
+                },
+                ...nextMessages.slice(systemMessageOffset)
+            ]);
+            parentMessageId = parentMessage.parentMessageId;
+        } while (true);
+        return { messages };
+    }
+    async _defaultGetMessageById(id) {
+        return await this._messageStore.get(id);
+    }
+    async _defaultUpsertMessage(message) {
+        await this._messageStore.set(message.id, message);
+    }
+};
+export { CozeAPI };
+//# sourceMappingURL=coze.js.map

package/dist/botInstance/sdk/difyClient.js

@@ -0,0 +1,354 @@
+import axios from 'axios';
+export const BASE_URL = 'https://api.dify.ai/v1';
+export const routes = {
+    application: {
+        method: 'GET',
+        url: () => `/parameters`,
+    },
+    feedback: {
+        method: 'POST',
+        url: (messageId) => `/messages/${messageId}/feedbacks`,
+    },
+    createCompletionMessage: {
+        method: 'POST',
+        url: () => `/completion-messages`,
+    },
+    createChatMessage: {
+        method: 'POST',
+        url: () => `/chat-messages`,
+    },
+    getConversationMessages: {
+        method: 'GET',
+        url: () => '/messages',
+    },
+    getConversations: {
+        method: 'GET',
+        url: () => '/conversations',
+    },
+    renameConversation: {
+        method: 'PATCH',
+        url: (conversationId) => `/conversations/${conversationId}`,
+    },
+    deleteConversation: {
+        method: 'DELETE',
+        url: (conversation_id) => `/conversations/${conversation_id}`,
+    },
+    fileUpload: {
+        method: 'POST',
+        url: () => `/files/upload`,
+    },
+};
+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 streamToString(stream) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            stream.on('data', (chunk) => (data += chunk.toString()));
+            stream.on('end', () => resolve(data));
+            stream.on('error', reject);
+        });
+    }
+    async sendRequest({ method, endpoint, data, params, stream = false, headerParams = {}, timeoutMs = 100 * 1000 }) {
+        try {
+            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,
+                    data: data || null,
+                    params: params || null,
+                    headers,
+                    timeout: timeoutMs,
+                    responseType: 'json',
+                });
+            }
+            else {
+                response = await axios.request({
+                    method,
+                    url,
+                    data,
+                    params,
+                    headers,
+                    responseType: 'stream',
+                });
+            }
+            return response;
+        }
+        catch (e) {
+            if (stream && e.response) {
+                const errorText = await this.streamToString(e.response.data);
+                return Promise.reject(errorText);
+            }
+            console.log('error', e.response.data);
+            return Promise.reject(e);
+        }
+    }
+    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',
+        });
+    }
+}
+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,
+        });
+    }
+}
+function checkFileType(fileExtname) {
+    // 移除扩展名前的点号并转换为大写
+    const ext = fileExtname.replace('.', '').toUpperCase();
+    // 文档类型
+    const documentTypes = ['TXT', 'MD', 'MARKDOWN', 'PDF', 'HTML', 'XLSX', 'XLS', 'DOCX', 'CSV', 'EML', 'MSG', 'PPTX', 'PPT', 'XML', 'EPUB'];
+    if (documentTypes.includes(ext)) {
+        return 'document';
+    }
+    // 图片类型
+    const imageTypes = ['JPG', 'JPEG', 'PNG', 'GIF', 'WEBP', 'SVG'];
+    if (imageTypes.includes(ext)) {
+        return 'image';
+    }
+    // 音频类型
+    const audioTypes = ['MP3', 'M4A', 'WAV', 'WEBM', 'AMR'];
+    if (audioTypes.includes(ext)) {
+        return 'audio';
+    }
+    // 视频类型
+    const videoTypes = ['MP4', 'MOV', 'MPEG', 'MPGA'];
+    if (videoTypes.includes(ext)) {
+        return 'video';
+    }
+    // 其他类型返回 custom
+    return 'custom';
+}
+export class ChatClient extends DifyClient {
+    async sendMessage({ query, file }, { systemMessage, user, conversationId = null, timeoutMs = 100 * 1000, inputs }) {
+        const data = {
+            inputs: {
+                ...inputs,
+            },
+            query,
+            user,
+            response_mode: this.stream ? 'streaming' : 'blocking',
+        };
+        if (file) {
+            data['files'] = [
+                {
+                    type: file.fileType === '图片' ? 'image' : checkFileType(file.fileExtname),
+                    transfer_method: 'remote_url',
+                    url: file.fileUrl,
+                },
+            ];
+        }
+        if (systemMessage || this.systemMessage) {
+            data.inputs['systemMessage'] = systemMessage || this.systemMessage;
+        }
+        if (conversationId)
+            data.conversation_id = conversationId;
+        if (this.debug) {
+            console.log('request data', JSON.stringify(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) => {
+                                if (item.belongs_to !== 'user') {
+                                    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,
+        });
+    }
+}
+//# sourceMappingURL=difyClient.js.map

package/dist/botInstance/sdk/pTimeout.js

@@ -0,0 +1,97 @@
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ An error to be thrown when the request is aborted by AbortController.
+ DOMException is thrown instead of this Error when DOMException is available.
+ */
+export class AbortError extends Error {
+    constructor(message) {
+        super();
+        this.name = 'AbortError';
+        this.message = message;
+    }
+}
+/**
+ TODO: Remove AbortError and just throw DOMException when targeting Node 18.
+ */
+const getDOMException = errorMessage => globalThis.DOMException === undefined
+    ? new AbortError(errorMessage)
+    : new DOMException(errorMessage);
+/**
+ TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
+ */
+const getAbortedReason = signal => {
+    const reason = signal.reason === undefined
+        ? getDOMException('This operation was aborted.')
+        : signal.reason;
+    return reason instanceof Error ? reason : getDOMException(reason);
+};
+export default function pTimeout(promise, options) {
+    const { milliseconds, fallback, message, customTimers = { setTimeout, clearTimeout }, } = options;
+    let timer;
+    const cancelablePromise = new Promise((resolve, reject) => {
+        if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
+            throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+        }
+        if (milliseconds === Number.POSITIVE_INFINITY) {
+            resolve(promise);
+            return;
+        }
+        if (options.signal) {
+            const { signal } = options;
+            if (signal.aborted) {
+                reject(getAbortedReason(signal));
+            }
+            signal.addEventListener('abort', () => {
+                reject(getAbortedReason(signal));
+            });
+        }
+        // We create the error outside of `setTimeout` to preserve the stack trace.
+        const timeoutError = new TimeoutError();
+        timer = customTimers.setTimeout.call(undefined, () => {
+            if (fallback) {
+                try {
+                    resolve(fallback());
+                }
+                catch (error) {
+                    reject(error);
+                }
+                return;
+            }
+            if (typeof promise.cancel === 'function') {
+                promise.cancel();
+            }
+            if (message === false) {
+                resolve();
+            }
+            else if (message instanceof Error) {
+                reject(message);
+            }
+            else {
+                timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+                reject(timeoutError);
+            }
+        }, milliseconds);
+        (async () => {
+            try {
+                resolve(await promise);
+            }
+            catch (error) {
+                reject(error);
+            }
+            finally {
+                customTimers.clearTimeout.call(undefined, timer);
+            }
+        })();
+    });
+    cancelablePromise.clear = () => {
+        customTimers.clearTimeout.call(undefined, timer);
+        timer = undefined;
+    };
+    return cancelablePromise;
+}
+//# sourceMappingURL=pTimeout.js.map