wechaty-web-panel 1.6.78 → 1.6.79

package/.github/workflows/npm.yml

@@ -17,7 +17,7 @@ jobs:
           cache-dependency-path: package.json
 
       - name: Install Dependencies
-        run: npm install
+        run: npm install --force
 
       - name: Generate Package JSON
         run: ./scripts/generate-package-json.sh

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: 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,235 @@
+"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, 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 = "";
+            // 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({
+                            input: message
+                        });
+                        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({
+                    input: message
+                });
+                // 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/fastgpt/index.d.ts

@@ -0,0 +1,10 @@
+export class FastGPTAPI {
+    constructor(opts: any);
+    _apiKey: any;
+    _apiBaseUrl: any;
+    _debug: any;
+    sendMessage(text: any, opts?: {}): Promise<{
+        text: any;
+    }>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastGPTAPI = void 0;
+const axios = require('axios');
+const axiosRetry = require('axios-retry').default;
+axiosRetry(axios, { retries: 3, retryDelay: () => 1000 });
+class FastGPTAPI {
+    constructor(opts) {
+        const { apiKey, apiBaseUrl = 'https://api.openai.com/v1', debug, } = opts;
+        this._apiKey = apiKey;
+        this._apiBaseUrl = apiBaseUrl;
+        this._debug = debug;
+        if (!this._apiKey) {
+            throw new Error('缺少 apiKey');
+        }
+    }
+    async sendMessage(text, opts = {}) {
+        const { timeoutMs, chatId, variables } = opts;
+        const body = {
+            chatId,
+            variables: {
+                ...variables,
+            },
+            messages: [{
+                    role: 'user',
+                    content: text,
+                }],
+            stream: false,
+            detail: false,
+        };
+        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) {
+            console.log('response.data.choices', JSON.stringify(response.data));
+            if (response.data.code) {
+                console.log('私有知识库请求出错', 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: '',
+        };
+    }
+}
+exports.FastGPTAPI = FastGPTAPI;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,35 @@
+export class QAnyApi extends QAnyClient {
+    sendMessage(query: any, { needHistory, user, timeoutMs, variables, }: {
+        needHistory: any;
+        user: any;
+        timeoutMs?: number | undefined;
+        variables: any;
+    }): Promise<any>;
+}
+declare class QAnyClient {
+    constructor({ apiKey, baseUrl, debug, stream, botId }: {
+        apiKey: any;
+        baseUrl?: string | undefined;
+        debug?: boolean | undefined;
+        stream?: boolean | undefined;
+        botId: any;
+    });
+    apiKey: any;
+    baseUrl: string;
+    debug: boolean;
+    stream: boolean;
+    botId: any;
+    history: any[];
+    updateApiKey(apiKey: any): void;
+    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>>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QAnyApi = void 0;
+const axios_1 = __importDefault(require("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_1.default.request({
+                method,
+                url,
+                data: data || {},
+                params: params || {},
+                headers,
+                timeout: timeoutMs,
+            });
+        }
+        else {
+            response = await (0, axios_1.default)({
+                method,
+                url,
+                data,
+                params,
+                headers,
+                responseType: 'stream',
+            });
+        }
+        return response;
+    }
+}
+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;
+    }
+}
+exports.QAnyApi = QAnyApi;
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/botInstance/officialOpenAi.d.ts

@@ -14,34 +14,7 @@ declare class OfficialOpenAi {
         promotId: string;
         systemMessage: string;
     });
-    chatGPT: {
-        _apiKey: any;
-        _apiOrg: any;
-        _apiBaseUrl: any;
-        _debug: boolean;
-        _fetch: any;
-        _completionParams: any;
-        _systemMessage: any;
-        _maxModelTokens: any;
-        _maxResponseTokens: any;
-        _getMessageById: any;
-        _upsertMessage: any;
-        _messageStore: any;
-        sendMessage(text: any, opts?: {}): Promise<any>;
-        apiKey: any;
-        apiOrg: any;
-        _buildMessages(text: any, opts: any): Promise<{
-            messages: {
-                role: string;
-                content: any;
-            }[];
-            maxTokens: number;
-            numTokens: number;
-        }>;
-        _getTokenCount(text: any): Promise<number>;
-        _defaultGetMessageById(id: any): Promise<any>;
-        _defaultUpsertMessage(message: any): Promise<void>;
-    } | null;
+    chatGPT: ChatGPTAPI | null;
     config: {
         temperature: number;
         top_p: number;
@@ -68,5 +41,6 @@ declare class OfficialOpenAi {
     reset(): Promise<void>;
     getReply(content: any, uid: any, adminId: string | undefined, systemMessage: string | undefined, isFastGPT: any, variables: any): Promise<any>;
 }
+import { ChatGPTAPI } from "../bot/chatgpt/index.js";
 import { ContentCensor } from "../lib/contentCensor.js";
 //# sourceMappingURL=officialOpenAi.d.ts.map