wechaty-web-panel 1.6.112 → 1.6.113

package/dist/bot/chatgpt/index.js

@@ -0,0 +1,235 @@
+import { ChatOpenAI } from "@langchain/openai";
+import { ConversationChain } from "langchain/chains";
+import { BufferMemory, BufferWindowMemory, } from "langchain/memory";
+import { SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { RedisVectorStore } from "@langchain/redis";
+import { OpenAIEmbeddings } from "@langchain/openai";
+import { v4 as uuidv4 } from "uuid";
+export class ChatGPTAPI {
+    constructor({ apiKey, apiBaseUrl = "https://api.openai.com/v1", completionParams = {}, debug = false, systemMessage = "", maxModelTokens = 4096, maxResponseTokens = 1024, memoryConfig = {
+        type: "memory", // "memory" or "redis"
+        redisConfig: null, // Only used if type is "redis"
+        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 RedisVectorStore(new OpenAIEmbeddings({
+                openAIApiKey: this.apiKey,
+                configuration: {
+                    baseURL: this.apiBaseUrl
+                }
+            }), {
+                redisClient: this.redisClient,
+                indexName: `chat:${chatId}`,
+            });
+            memory = new 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 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 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, // 60 seconds default timeout
+            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 = ChatPromptTemplate.fromMessages([
+            SystemMessagePromptTemplate.fromTemplate(finalSystemMessage),
+            new MessagesPlaceholder("chat_history"),
+            HumanMessagePromptTemplate.fromTemplate("{input}"),
+        ]);
+        // Create conversation chain using the new Runnable API in v0.3
+        const chain = new ConversationChain({
+            memory,
+            llm: chatModel,
+            prompt,
+            verbose: this.debug,
+            outputParser: new 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 || uuidv4();
+        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: uuidv4()
+            };
+        }
+        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);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,110 @@
+import { CozeAPI, ChatEventType, ChatStatus, COZE_CN_BASE_URL, RoleType } from '@coze/api';
+// import { FileBox } from 'file-box';
+// import fs from 'fs';
+class CozeClient {
+    constructor({ apiKey, baseUrl = 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 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 === ChatEventType.CONVERSATION_CHAT_FAILED || part.event === ChatEventType.ERROR) {
+                    console.log('Coze 请求失败,请根据失败原因进行排查问题', JSON.stringify(part.data));
+                    return { text: answer, conversationId, id: lastMessageId, files: [] };
+                }
+                if (part.event === 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: [] };
+        }
+    }
+}
+export { CozeV3Api };
+//# sourceMappingURL=index.js.map