wechaty-web-panel 1.6.87 → 1.6.88

package/dist/cjs/src/bot/chatgpt/index.d.ts

@@ -0,0 +1,60 @@
+export class ChatGPTAPI {
+    constructor({ apiKey, apiBaseUrl, completionParams, debug, systemMessage, maxModelTokens, maxResponseTokens, memoryConfig, streaming, redis }: {
+        apiKey: any;
+        apiBaseUrl?: string | undefined;
+        completionParams?: {} | undefined;
+        debug?: boolean | undefined;
+        systemMessage?: string | undefined;
+        maxModelTokens?: number | undefined;
+        maxResponseTokens?: number | undefined;
+        memoryConfig?: {
+            type: string;
+            redisConfig: null;
+            expireTime: null;
+        } | undefined;
+        streaming?: boolean | undefined;
+        redis: any;
+    });
+    apiKey: any;
+    apiBaseUrl: string;
+    completionParams: {};
+    debug: boolean;
+    systemMessage: string;
+    maxModelTokens: number;
+    maxResponseTokens: number;
+    memoryConfig: {
+        type: string;
+        redisConfig: null;
+        expireTime: null;
+    };
+    conversations: Map<any, any>;
+    streaming: boolean;
+    redisClient: any;
+    /**
+     * Create a new conversation chain or retrieve an existing one
+     * @param {string} chatId - Unique identifier for the conversation
+     * @param {string} systemMessage - Optional system message to override the default
+     * @param {boolean} streaming - Whether to enable streaming for this conversation
+     * @returns {Object} - Conversation object with chain and metadata
+     */
+    getOrCreateConversation(chatId: string, { systemMessage, streaming, timeoutMs }: string): Object;
+    /**
+     * Send a message to the model and get a response
+     * @param {string} message - The message to send
+     * @param {Object} options - Additional options
+     * @returns {Promise<Object>} - The response
+     */
+    sendMessage({ message, file }: string, options?: Object): Promise<Object>;
+    /**
+     * Clear a specific conversation or all conversations
+     * @param {string} chatId - Optional chat ID to clear a specific conversation
+     */
+    clearConversations(chatId?: string): Promise<void>;
+    /**
+     * Set expiration time for a conversation
+     * @param {string} chatId - The chat ID
+     * @param {number} seconds - Time in seconds until expiration
+     */
+    setExpiration(chatId: string, seconds: number): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/bot/chatgpt/index.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGPTAPI = void 0;
+const openai_1 = require("@langchain/openai");
+const chains_1 = require("langchain/chains");
+const memory_1 = require("langchain/memory");
+const prompts_1 = require("@langchain/core/prompts");
+const output_parsers_1 = require("@langchain/core/output_parsers");
+const redis_1 = require("@langchain/redis");
+const openai_2 = require("@langchain/openai");
+const uuid_1 = require("uuid");
+class ChatGPTAPI {
+    constructor({ apiKey, apiBaseUrl = "https://api.openai.com/v1", completionParams = {}, debug = false, systemMessage = "", maxModelTokens = 4096, maxResponseTokens = 1024, memoryConfig = {
+        type: "memory",
+        redisConfig: null,
+        expireTime: null, // Time in seconds, null means no expiration
+    }, streaming = true, // Enable streaming mode by default
+    redis }) {
+        this.apiKey = apiKey;
+        this.apiBaseUrl = apiBaseUrl;
+        this.completionParams = completionParams;
+        this.debug = debug;
+        this.systemMessage = systemMessage;
+        this.maxModelTokens = maxModelTokens;
+        this.maxResponseTokens = maxResponseTokens;
+        this.memoryConfig = memoryConfig;
+        this.conversations = new Map();
+        this.streaming = streaming;
+        // Initialize Redis if needed
+        if (memoryConfig.type === "redis" && memoryConfig.redisConfig) {
+            this.redisClient = redis;
+        }
+    }
+    /**
+     * Create a new conversation chain or retrieve an existing one
+     * @param {string} chatId - Unique identifier for the conversation
+     * @param {string} systemMessage - Optional system message to override the default
+     * @param {boolean} streaming - Whether to enable streaming for this conversation
+     * @returns {Object} - Conversation object with chain and metadata
+     */
+    async getOrCreateConversation(chatId, { systemMessage = null, streaming = null, timeoutMs = 60000 }) {
+        // If conversation exists and no specific system message is requested, return it
+        if (this.conversations.has(chatId) && !systemMessage) {
+            return this.conversations.get(chatId);
+        }
+        // Calculate context window size
+        const contextWindowSize = this.maxModelTokens - this.maxResponseTokens - 500; // Buffer for metadata
+        // Create the appropriate memory system
+        let memory;
+        if (this.memoryConfig.type === "redis") {
+            // Setup Redis vector store for memory
+            const vectorStore = new redis_1.RedisVectorStore(new openai_2.OpenAIEmbeddings({
+                openAIApiKey: this.apiKey,
+                configuration: {
+                    baseURL: this.apiBaseUrl
+                }
+            }), {
+                redisClient: this.redisClient,
+                indexName: `chat:${chatId}`,
+            });
+            memory = new memory_1.BufferMemory({
+                memoryKey: "chat_history",
+                chatHistory: vectorStore,
+                returnMessages: true,
+                outputKey: "output",
+                inputKey: "input",
+            });
+            // Set expiration if configured
+            if (this.memoryConfig.expireTime) {
+                const expireTimeSeconds = this.memoryConfig.expireTime;
+                this.redisClient.expire(`chat:${chatId}`, expireTimeSeconds);
+            }
+        }
+        else {
+            // Use in-memory storage
+            memory = new memory_1.BufferWindowMemory({
+                memoryKey: "chat_history",
+                // k: 10, // Keep last 10 interactions by default, adjust based on token size
+                returnMessages: true,
+                outputKey: "output",
+                inputKey: "input",
+            });
+        }
+        // Determine if streaming should be enabled
+        const useStreaming = streaming !== null ? streaming : this.streaming;
+        // Create chat model
+        const chatModel = new openai_1.ChatOpenAI({
+            openAIApiKey: this.apiKey,
+            modelName: this.completionParams.model,
+            temperature: this.completionParams.temperature || 0.7,
+            topP: this.completionParams.top_p || 1,
+            presencePenalty: this.completionParams.presence_penalty || 0,
+            frequencyPenalty: this.completionParams.frequency_penalty || 0,
+            maxTokens: this.maxResponseTokens,
+            timeout: timeoutMs || 60000,
+            streaming: useStreaming,
+            verbose: this.debug,
+            configuration: {
+                baseURL: this.apiBaseUrl
+            }
+        });
+        // Create prompt template with system message
+        const finalSystemMessage = systemMessage || this.systemMessage || "You are a helpful assistant.";
+        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
+            prompts_1.SystemMessagePromptTemplate.fromTemplate(finalSystemMessage),
+            new prompts_1.MessagesPlaceholder("chat_history"),
+            prompts_1.HumanMessagePromptTemplate.fromTemplate("{input}"),
+        ]);
+        // Create conversation chain using the new Runnable API in v0.3
+        const chain = new chains_1.ConversationChain({
+            memory,
+            llm: chatModel,
+            prompt,
+            verbose: this.debug,
+            outputParser: new output_parsers_1.StringOutputParser(),
+            inputKey: "input",
+            outputKey: "output"
+        });
+        // Store the conversation
+        this.conversations.set(chatId, {
+            chain,
+            createdAt: Date.now(),
+            model: this.completionParams.model,
+            contextWindowSize,
+            streaming: useStreaming
+        });
+        return this.conversations.get(chatId);
+    }
+    /**
+     * Send a message to the model and get a response
+     * @param {string} message - The message to send
+     * @param {Object} options - Additional options
+     * @returns {Promise<Object>} - The response
+     */
+    async sendMessage({ message, file }, options = {}) {
+        const chatId = options.chatId || (0, uuid_1.v4)();
+        const systemMsg = options.systemMessage || this.systemMessage;
+        const timeoutMs = options.timeoutMs || 60000;
+        const streaming = options.streaming !== undefined ? options.streaming : this.streaming;
+        try {
+            if (this.debug) {
+                console.log(`Sending message to ${this.completionParams.model} with chatId: ${chatId}`);
+                console.log(`Message: ${message}`);
+                console.log(`Streaming: ${streaming}`);
+            }
+            // Get or create conversation
+            const conversation = await this.getOrCreateConversation(chatId, { systemMessage: systemMsg, streaming, timeoutMs: timeoutMs });
+            let responseText = "";
+            const inputMessage = file && file.fileUrl ? {
+                input: {
+                    text: message,
+                    image_url: file.fileUrl
+                }
+            } : {
+                input: message
+            };
+            // Handle streaming or non-streaming response using v0.3 API
+            if (streaming) {
+                const responsePromise = new Promise(async (resolve, reject) => {
+                    try {
+                        responseText = "";
+                        // Using v0.3 streaming API
+                        const stream = await conversation.chain.stream(inputMessage);
+                        for await (const chunk of stream) {
+                            if (chunk.output) {
+                                responseText += chunk.output;
+                            }
+                        }
+                        resolve(responseText);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                // Race between response and timeout
+                await Promise.race([responsePromise]);
+            }
+            else {
+                // Non-streaming request using v0.3 API
+                const responsePromise = conversation.chain.invoke(inputMessage);
+                // Race between response and timeout
+                const response = await Promise.race([responsePromise]);
+                responseText = response.output;
+            }
+            // Return formatted response (same format for both streaming and non-streaming)
+            return {
+                chatId: chatId,
+                text: responseText,
+                id: (0, uuid_1.v4)()
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                console.error("Error in sendMessage:", error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Clear a specific conversation or all conversations
+     * @param {string} chatId - Optional chat ID to clear a specific conversation
+     */
+    async clearConversations(chatId = null) {
+        if (chatId) {
+            // Clear a specific conversation
+            this.conversations.delete(chatId);
+            // Clear from Redis if using Redis
+            if (this.memoryConfig.type === "redis" && this.redisClient) {
+                await this.redisClient.del(`chat:${chatId}`);
+            }
+        }
+        else {
+            // Clear all conversations
+            this.conversations.clear();
+            // Would need to implement a more complex Redis cleanup if needed
+        }
+    }
+    /**
+     * Set expiration time for a conversation
+     * @param {string} chatId - The chat ID
+     * @param {number} seconds - Time in seconds until expiration
+     */
+    async setExpiration(chatId, seconds) {
+        if (!this.conversations.has(chatId)) {
+            throw new Error(`Conversation with ID ${chatId} not found`);
+        }
+        if (this.memoryConfig.type === "redis" && this.redisClient) {
+            await this.redisClient.expire(`chat:${chatId}`, seconds);
+        }
+        else {
+            // For in-memory, we can set a timer to delete the conversation
+            setTimeout(() => {
+                this.conversations.delete(chatId);
+            }, seconds * 1000);
+        }
+    }
+}
+exports.ChatGPTAPI = ChatGPTAPI;
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/bot/coze/sdk/index.d.ts

@@ -0,0 +1,45 @@
+export class CozeV3Api extends CozeClient {
+    sendMessage({ query, file }: {
+        query: any;
+        file: any;
+    }, { systemMessage, user, needConversation, conversationId, timeoutMs, files, variables }: {
+        systemMessage: any;
+        user: any;
+        needConversation?: boolean | undefined;
+        conversationId?: null | undefined;
+        timeoutMs?: number | undefined;
+        files?: null | undefined;
+        variables: any;
+    }): Promise<{
+        text: any;
+        conversationId: null;
+        id: string;
+        files: never[];
+        messages?: undefined;
+    } | {
+        text: string | undefined;
+        conversationId: null;
+        id: string;
+        files: never[];
+        messages: string[];
+    }>;
+}
+declare class CozeClient {
+    constructor({ apiKey, baseUrl, debug, systemMessage, stream, botId }: {
+        apiKey: any;
+        baseUrl?: string | undefined;
+        debug?: boolean | undefined;
+        systemMessage?: null | undefined;
+        stream?: boolean | undefined;
+        botId: any;
+    });
+    apiKey: any;
+    baseUrl: string;
+    debug: boolean;
+    stream: boolean;
+    botId: any;
+    systemMessage: any;
+    updateApiKey(apiKey: any): void;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/src/bot/coze/sdk/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CozeV3Api = void 0;
+const api_1 = require("@coze/api");
+// import { FileBox } from 'file-box';
+// import fs from 'fs';
+class CozeClient {
+    constructor({ apiKey, baseUrl = api_1.COZE_CN_BASE_URL, debug = false, systemMessage = null, stream = false, botId }) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.debug = debug;
+        this.stream = stream;
+        this.botId = botId;
+        this.systemMessage = systemMessage;
+    }
+    updateApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+}
+class CozeV3Api extends CozeClient {
+    async sendMessage({ query, file }, { systemMessage, user, needConversation = true, conversationId = null, timeoutMs = 100 * 1000, files = null, variables }) {
+        try {
+            const client = new api_1.CozeAPI({ baseURL: this.baseUrl, token: this.apiKey });
+            let messages = [
+                {
+                    role: 'user',
+                    content: query,
+                    content_type: 'text',
+                },
+            ];
+            if (file && file.fileUrl) {
+                const mediaMessage = [
+                    {
+                        type: 'text',
+                        text: query,
+                    },
+                    {
+                        type: file.fileType === '图片' ? 'image' : 'file',
+                        file_url: fileUrl,
+                    },
+                ];
+                messages = [
+                    {
+                        role: 'user',
+                        content: JSON.stringify(mediaMessage),
+                        content_type: 'object_string',
+                    },
+                ];
+            }
+            // else if(file) {
+            //     const fileBuffer = await file.toStream()
+            //     const fileRes = await client.files.upload({file: fileBuffer})
+            //     const mediaMessage = [{
+            //         type: 'text',
+            //         text: query,
+            //     }, {
+            //         type: fileType,
+            //         file_id: fileRes.id
+            //     }]
+            //     messages = [{
+            //         role: 'user',
+            //         content: JSON.stringify(mediaMessage),
+            //         content_type: 'object_string',
+            //     }]
+            // }
+            if (!conversationId && needConversation) {
+                const res = await client.conversations.create({
+                    messages,
+                    timeoutMs,
+                });
+                console.log('conversation', res);
+                conversationId = res?.id;
+                messages = [];
+            }
+            const data = {
+                bot_id: this.botId,
+                custom_variables: {
+                    ...variables,
+                },
+                additional_messages: messages,
+                user_id: user,
+                auto_save_history: true,
+            };
+            if (systemMessage || this.systemMessage) {
+                data.custom_variables.systemMessage = systemMessage || this.systemMessage;
+            }
+            if (conversationId && needConversation) {
+                data.conversation_id = conversationId;
+            }
+            const stream = await client.chat.stream(data);
+            let answers = [];
+            let lastMessageId = '';
+            for await (const part of stream) {
+                if (part.event === api_1.ChatEventType.CONVERSATION_CHAT_FAILED || part.event === api_1.ChatEventType.ERROR) {
+                    console.log('Coze 请求失败,请根据失败原因进行排查问题', JSON.stringify(part.data));
+                    return { text: answer, conversationId, id: lastMessageId, files: [] };
+                }
+                if (part.event === api_1.ChatEventType.CONVERSATION_MESSAGE_COMPLETED && part.data.type === 'answer' && part.data.content_type === 'text') {
+                    answers.push(part.data.content);
+                    lastMessageId = part.data.id;
+                }
+            }
+            console.log('messages', answers);
+            return { text: answers[0], conversationId, id: lastMessageId, files: [], messages: answers };
+        }
+        catch (error) {
+            console.log('Coze 请求失败,请根据失败原因进行排查问题', JSON.stringify(error));
+            return { text: '', conversationId: conversationId, id: '', files: [], messages: [] };
+        }
+    }
+}
+exports.CozeV3Api = CozeV3Api;
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/bot/dify/sdk/index.d.ts

@@ -0,0 +1,167 @@
+export const BASE_URL: "https://api.dify.ai/v1";
+export namespace routes {
+    namespace feedback {
+        const method: string;
+        function url(messageId: any): string;
+    }
+    namespace application {
+        const method_1: string;
+        export { method_1 as method };
+        export function url_1(): string;
+        export { url_1 as url };
+    }
+    namespace fileUpload {
+        const method_2: string;
+        export { method_2 as method };
+        export function url_2(): string;
+        export { url_2 as url };
+    }
+    namespace textToAudio {
+        const method_3: string;
+        export { method_3 as method };
+        export function url_3(): string;
+        export { url_3 as url };
+    }
+    namespace getMeta {
+        const method_4: string;
+        export { method_4 as method };
+        export function url_4(): string;
+        export { url_4 as url };
+    }
+    namespace createCompletionMessage {
+        const method_5: string;
+        export { method_5 as method };
+        export function url_5(): string;
+        export { url_5 as url };
+    }
+    namespace createChatMessage {
+        const method_6: string;
+        export { method_6 as method };
+        export function url_6(): string;
+        export { url_6 as url };
+    }
+    namespace getSuggested {
+        const method_7: string;
+        export { method_7 as method };
+        export function url_7(message_id: any): string;
+        export { url_7 as url };
+    }
+    namespace stopChatMessage {
+        const method_8: string;
+        export { method_8 as method };
+        export function url_8(task_id: any): string;
+        export { url_8 as url };
+    }
+    namespace getConversations {
+        const method_9: string;
+        export { method_9 as method };
+        export function url_9(): string;
+        export { url_9 as url };
+    }
+    namespace getConversationMessages {
+        const method_10: string;
+        export { method_10 as method };
+        export function url_10(): string;
+        export { url_10 as url };
+    }
+    namespace renameConversation {
+        const method_11: string;
+        export { method_11 as method };
+        export function url_11(conversation_id: any): string;
+        export { url_11 as url };
+    }
+    namespace deleteConversation {
+        const method_12: string;
+        export { method_12 as method };
+        export function url_12(conversation_id: any): string;
+        export { url_12 as url };
+    }
+    namespace audioToText {
+        const method_13: string;
+        export { method_13 as method };
+        export function url_13(): string;
+        export { url_13 as url };
+    }
+    namespace getWorkflowInfo {
+        const method_14: string;
+        export { method_14 as method };
+        export function url_14(): string;
+        export { url_14 as url };
+    }
+    namespace runWorkflow {
+        const method_15: string;
+        export { method_15 as method };
+        export function url_15(): string;
+        export { url_15 as url };
+    }
+    namespace stopWorkflow {
+        const method_16: string;
+        export { method_16 as method };
+        export function url_16(task_id: any): string;
+        export { url_16 as url };
+    }
+    namespace getWorkflowResult {
+        const method_17: string;
+        export { method_17 as method };
+        export function url_17(task_id: any): string;
+        export { url_17 as url };
+    }
+}
+export class DifyClient {
+    constructor({ apiKey, baseUrl, debug, systemMessage, stream }: {
+        apiKey: any;
+        baseUrl?: string | undefined;
+        debug?: boolean | undefined;
+        systemMessage?: null | undefined;
+        stream?: boolean | undefined;
+    });
+    apiKey: any;
+    baseUrl: string;
+    debug: boolean;
+    stream: boolean;
+    systemMessage: any;
+    updateApiKey(apiKey: any): void;
+    sendUploadRequest(method: any, endpoint: any, data?: null, params?: null, stream?: boolean, headerParams?: {}): Promise<import("axios").AxiosResponse<any, any>>;
+    sendRequest({ method, endpoint, data, params, stream, headerParams, timeoutMs }: {
+        method: any;
+        endpoint: any;
+        data: any;
+        params: any;
+        stream?: boolean | undefined;
+        headerParams?: {} | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<import("axios").AxiosResponse<any, any>>;
+    messageFeedback(messageId: any, rating: any, user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    getApplicationParameters(user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    fileUpload(data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    textToAudio(text: any, user: any, streaming?: boolean): Promise<import("axios").AxiosResponse<any, any>>;
+    getMeta(user: any): Promise<import("axios").AxiosResponse<any, any>>;
+}
+export class CompletionClient extends DifyClient {
+    createCompletionMessage(inputs: any, user: any, stream?: boolean, files?: null): Promise<import("axios").AxiosResponse<any, any>>;
+    runWorkflow(inputs: any, user: any, stream?: boolean, files?: null): Promise<import("axios").AxiosResponse<any, any>>;
+}
+export class ChatClient extends DifyClient {
+    sendMessage(query: any, { systemMessage, user, conversationId, timeoutMs, files, inputs }: {
+        systemMessage: any;
+        user: any;
+        conversationId?: null | undefined;
+        timeoutMs?: number | undefined;
+        files?: null | undefined;
+        inputs: any;
+    }): Promise<any>;
+    getConversationMessages(user: any, conversationId?: string, firstId?: null, limit?: null): Promise<import("axios").AxiosResponse<any, any>>;
+    getConversations(user: any, firstId?: null, limit?: null, pinned?: null): Promise<import("axios").AxiosResponse<any, any>>;
+    renameConversation(conversationId: any, name: any, user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    getSuggested(message_id: any, user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    stopMessage(task_id: any, user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    audioToText(data: any): Promise<import("axios").AxiosResponse<any, any>>;
+}
+export class WorkflowClient extends DifyClient {
+    run(inputs: any, user: any, stream: any): Promise<import("axios").AxiosResponse<any, any>>;
+    stop(task_id: any, user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    info(user: any): Promise<import("axios").AxiosResponse<any, any>>;
+    result(task_id: any): Promise<import("axios").AxiosResponse<any, any>>;
+    getWorkflowResult(input: any, user: any, isStream: any): Promise<any>;
+}
+//# sourceMappingURL=index.d.ts.map