wechaty-web-panel 1.6.80 → 1.6.82

package/.github/workflows/npm.yml

@@ -11,10 +11,8 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
-          cache: npm
-          cache-dependency-path: package.json
 
       - name: Install Dependencies
         run: npm install --force

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wechaty-web-panel",
-  "version": "1.6.80",
+  "version": "1.6.82",
   "exports": {
     ".": {
       "import": "./dist/esm/src/index.js",

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

@@ -1,60 +0,0 @@
-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

@@ -1,235 +0,0 @@
-"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/coze/sdk/index.d.ts

@@ -1,45 +0,0 @@
-export class CozeV3Api extends CozeClient {
-    sendMessage(query: any, { file, fileType, fileUrl, systemMessage, user, needConversation, conversationId, timeoutMs, files, variables, }: {
-        file: any;
-        fileType: any;
-        fileUrl: any;
-        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

@@ -1,108 +0,0 @@
-"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, fileType, fileUrl, 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 (fileUrl) {
-                const mediaMessage = [{
-                        type: 'text',
-                        text: query,
-                    }, {
-                        type: fileType,
-                        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

@@ -1,167 +0,0 @@
-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