koishi-plugin-openai-compatible 1.0.7 → 1.0.9

package/lib/index.js

@@ -1,157 +1,681 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inject = exports.name = void 0;
-exports.apply = apply;
-const api_1 = require("./api");
-const emotion_1 = require("./emotion");
-const storage_1 = require("./storage");
-exports.name = 'openai-compatible';
-exports.inject = {
-    required: [],
-    optional: [],
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-function apply(ctx, config) {
-    // 导出配置 Schema
-    ctx.i18n.define('zh', require('./locales/zh'));
-    // 初始化存储
-    const storage = new storage_1.Storage();
-    // 初始化 API 客户端
-    const api = new api_1.OpenAICompatibleAPI(config.endpoint, config.apiKey);
-    // 初始化情绪分析器
-    let emotionAnalyzer = null;
-    if (config.enableEmotion) {
-        const emotionApi = new api_1.OpenAICompatibleAPI(config.emotionEndpoint, config.emotionApiKey);
-        emotionAnalyzer = new emotion_1.EmotionAnalyzer(emotionApi, config);
-    }
-    // 注册命令
-    ctx.command(config.commandName, { authority: 1 })
-        .alias('chat')
-        .action(async ({ session }, content) => {
-        if (!session)
-            return;
-        const userId = session.userId;
-        if (!userId)
-            return;
-        // 检查黑名单
-        if (config.blacklist.includes(userId)) {
-            if (config.enableMessage) {
-                await session.send('您在黑名单中，无法使用此功能。');
-            }
-            return;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmotionAnalyzer = exports.Config = exports.OpenAICompatible = void 0;
+const types_1 = require("./types");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return types_1.Config; } });
+// 冷却时间管理器
+class CooldownManager {
+    constructor(cooldown) {
+        this.cooldown = cooldown;
+        this.cooldowns = new Map();
+    }
+    check(userId) {
+        if (this.cooldown <= 0)
+            return { available: true, remaining: 0 };
+        const lastTime = this.cooldowns.get(userId);
+        const now = Date.now();
+        if (!lastTime) {
+            this.cooldowns.set(userId, now);
+            return { available: true, remaining: 0 };
         }
-        // 检查冷却时间
-        if (storage.isOnCooldown(userId, config.cooldown)) {
-            const data = storage.getCooldown(userId);
-            const remaining = config.cooldown - (Date.now() - data.lastRequestTime);
-            const remainingSeconds = Math.ceil(remaining / 1000);
-            if (config.enableMessage) {
-                await session.send(`请求过于频繁，请等待 ${remainingSeconds} 秒后再试。`);
-            }
-            return;
+        const elapsed = (now - lastTime) / 1000;
+        const remaining = this.cooldown - elapsed;
+        if (remaining > 0) {
+            return { available: false, remaining: Math.ceil(remaining) };
         }
-        // 获取用户输入
-        if (!content || content.trim() === '') {
-            if (config.enableMessage) {
-                await session.send('请输入要聊天的内容。');
+        this.cooldowns.set(userId, now);
+        return { available: true, remaining: 0 };
+    }
+    reset(userId) {
+        this.cooldowns.delete(userId);
+    }
+}
+// OpenAI兼容客户端
+class OpenAICompatibleClient {
+    constructor(config, logger, isEmotion = false) {
+        this.config = config;
+        this.logger = logger.extend(isEmotion ? 'emotion-client' : 'client');
+        // 如果是情绪分析客户端，使用情绪分析配置（如果提供）
+        if (isEmotion && config.emotionAnalysis.enabled) {
+            this.endpoint = config.emotionAnalysis.endpoint || config.endpoint;
+            this.endpoint = this.endpoint.replace(/\/$/, '');
+            this.apiKey = config.emotionAnalysis.apiKey || config.apiKey;
+            this.timeout = config.emotionTimeout;
+        }
+        else {
+            this.endpoint = config.endpoint.replace(/\/$/, '');
+            this.apiKey = config.apiKey;
+            this.timeout = config.timeout;
+        }
+        this.maxRetries = config.maxRetries;
+    }
+    async createChatCompletion(messages, config, isEmotion = false) {
+        var _a, _b, _c, _d;
+        const url = `${this.endpoint}/chat/completions`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`,
+        };
+        // 根据是否为情绪分析设置不同的参数
+        let requestConfig;
+        if (isEmotion) {
+            requestConfig = {
+                model: ((_a = config === null || config === void 0 ? void 0 : config.emotionAnalysis) === null || _a === void 0 ? void 0 : _a.model) || this.config.emotionAnalysis.model,
+                messages,
+                max_tokens: (config === null || config === void 0 ? void 0 : config.emotionMaxTokens) || this.config.emotionMaxTokens,
+                temperature: (config === null || config === void 0 ? void 0 : config.emotionTemperature) || this.config.emotionTemperature,
+                top_p: 1,
+                presence_penalty: 0,
+                frequency_penalty: 0,
+                stream: false,
+            };
+        }
+        else {
+            requestConfig = {
+                model: (config === null || config === void 0 ? void 0 : config.model) || this.config.model,
+                messages,
+                max_tokens: (config === null || config === void 0 ? void 0 : config.maxTokens) || this.config.maxTokens,
+                temperature: (config === null || config === void 0 ? void 0 : config.temperature) || this.config.temperature,
+                top_p: (config === null || config === void 0 ? void 0 : config.topP) || this.config.topP,
+                presence_penalty: (config === null || config === void 0 ? void 0 : config.presencePenalty) || this.config.presencePenalty,
+                frequency_penalty: (config === null || config === void 0 ? void 0 : config.frequencyPenalty) || this.config.frequencyPenalty,
+                stream: false,
+            };
+        }
+        let lastError = null;
+        for (let i = 0; i <= this.maxRetries; i++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(requestConfig),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+                const data = await response.json();
+                if (data.error) {
+                    throw new Error(data.error.message || 'Unknown API error');
+                }
+                return ((_d = (_c = (_b = data.choices[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.trim()) || '';
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.warn(`Request failed (attempt ${i + 1}/${this.maxRetries + 1}):`, error.message);
+                if (i < this.maxRetries) {
+                    // 指数退避
+                    await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
+                }
             }
-            return;
+        }
+        if (lastError) {
+            throw lastError;
+        }
+        else {
+            throw new Error('Unknown error occurred');
+        }
+    }
+    async testConnection() {
+        try {
+            const url = `${this.endpoint}/models`;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch(url, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return response.ok;
+        }
+        catch (error) {
+            this.logger.error('Connection test failed:', error.message);
+            return false;
+        }
+    }
+}
+// 情绪分析器
+class EmotionAnalyzer {
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger.extend('emotion-analyzer');
+        this.client = new OpenAICompatibleClient(config, logger, true);
+        this.emotionEmojis = { ...config.emotionEmojis };
+        this.showEmotionImage = config.showEmotionImage;
+        this.imageAsMarkdown = config.imageAsMarkdown;
+    }
+    async analyze(text) {
+        if (!this.config.emotionAnalysis.enabled || !text.trim()) {
+            const neutralConfig = this.emotionEmojis['neutral'] || { text: '😐', image: '' };
+            return {
+                emotion: 'neutral',
+                emoji: neutralConfig.text,
+                imageUrl: neutralConfig.image,
+                displayText: neutralConfig.text,
+                success: true,
+            };
         }
         try {
-            // 构建消息列表
             const messages = [
-                { role: 'system', content: config.systemPrompt },
-                { role: 'user', content: content },
+                {
+                    role: 'system',
+                    content: '你是一个情绪分析专家，只能返回单个情绪类型单词，不要解释，不要额外文本。',
+                },
+                {
+                    role: 'user',
+                    content: `${this.config.emotionAnalysis.prompt}\n\n文本：${text}`,
+                },
             ];
-            // 调用 AI
-            const request = {
-                model: config.model,
-                messages,
-                temperature: config.temperature,
-                max_tokens: config.maxTokens,
-                top_p: config.topP,
-                frequency_penalty: config.frequencyPenalty,
-                presence_penalty: config.presencePenalty,
-            };
-            const response = await api.chatCompletion(request);
-            let finalResponse = response;
-            // 如果启用了情绪分析，则分析 AI 输出的内容
-            if (config.enableEmotion && emotionAnalyzer) {
-                const emotion = await emotionAnalyzer.analyzeEmotion(response);
-                const emotionImage = emotionAnalyzer.getEmotionImage(emotion);
-                if (emotion && emotionImage) {
-                    finalResponse = `${response}\n\n${emotionImage}`;
+            const response = await this.client.createChatCompletion(messages, this.config, true);
+            // 清理和标准化情绪类型
+            const emotion = this.normalizeEmotion(response);
+            // 获取对应的表情配置
+            const emojiConfig = this.getEmojiConfig(emotion);
+            // 构建显示文本
+            let displayText = emojiConfig.text;
+            // 如果有图片链接且启用了图片显示
+            if (emojiConfig.image && this.showEmotionImage) {
+                if (this.imageAsMarkdown) {
+                    // 使用Markdown格式
+                    displayText = `![${emotion}](${emojiConfig.image})`;
+                }
+                else {
+                    // 使用CQ码格式（适用于QQ平台）
+                    displayText = `[CQ:image,file=${emojiConfig.image}]`;
                 }
             }
-            // 发送回复
-            await session.send(finalResponse);
-            // 更新冷却时间
-            storage.setCooldown(userId, { lastRequestTime: Date.now() });
+            this.logger.debug(`Analyzed emotion: ${emotion} -> ${displayText}`);
+            return {
+                emotion,
+                emoji: emojiConfig.text,
+                imageUrl: emojiConfig.image,
+                displayText,
+                success: true,
+            };
         }
         catch (error) {
-            console.error('AI 请求失败:', error);
-            if (config.enableMessage) {
-                await session.send(`请求失败: ${error instanceof Error ? error.message : '未知错误'}`);
-            }
-        }
-    });
-    // 黑名单管理命令
-    ctx.command(`${config.commandName}.admin`)
-        .subcommand('.add <userId:string>', '添加黑名单')
-        .action(async ({ session }, userId) => {
-        if (!session)
-            return;
-        config.blacklist.push(userId);
-        await session.send(`已将用户 ${userId} 添加到黑名单。`);
-    });
-    ctx.command(`${config.commandName}.admin`)
-        .subcommand('.remove <userId:string>', '移除黑名单')
-        .action(async ({ session }, userId) => {
-        if (!session)
-            return;
-        const index = config.blacklist.indexOf(userId);
-        if (index > -1) {
-            config.blacklist.splice(index, 1);
-            await session.send(`已将用户 ${userId} 从黑名单中移除。`);
+            this.logger.error('Emotion analysis failed:', error);
+            const neutralConfig = this.emotionEmojis['neutral'] || { text: '😐', image: '' };
+            return {
+                emotion: 'neutral',
+                emoji: neutralConfig.text,
+                imageUrl: neutralConfig.image,
+                displayText: neutralConfig.text,
+                success: false,
+                error: error.message,
+            };
         }
-        else {
-            await session.send(`用户 ${userId} 不在黑名单中。`);
+    }
+    normalizeEmotion(text) {
+        if (!text)
+            return 'neutral';
+        // 清理文本
+        const cleaned = text.toLowerCase().trim();
+        // 常见的情绪类型映射
+        const emotionMap = {
+            'happy': 'happy',
+            'happiness': 'happy',
+            'joy': 'happy',
+            'joyful': 'happy',
+            'glad': 'happy',
+            'sad': 'sad',
+            'sadness': 'sad',
+            'unhappy': 'sad',
+            'depressed': 'sad',
+            'angry': 'angry',
+            'anger': 'angry',
+            'mad': 'angry',
+            'furious': 'angry',
+            'neutral': 'neutral',
+            'normal': 'neutral',
+            'default': 'neutral',
+            'surprised': 'surprised',
+            'surprise': 'surprised',
+            'shocked': 'surprised',
+            'fearful': 'fearful',
+            'fear': 'fearful',
+            'scared': 'fearful',
+            'afraid': 'fearful',
+            'disgusted': 'disgusted',
+            'disgust': 'disgusted',
+            'excited': 'excited',
+            'excitement': 'excited',
+            'calm': 'calm',
+            'calmness': 'calm',
+            'peaceful': 'calm',
+            'confused': 'confused',
+            'confusion': 'confused',
+            'puzzled': 'confused',
+        };
+        // 检查是否包含已知情绪关键词
+        for (const [key, emotion] of Object.entries(emotionMap)) {
+            if (cleaned.includes(key) || cleaned === key) {
+                return emotion;
+            }
         }
-    });
-    ctx.command(`${config.commandName}.admin`)
-        .subcommand('.list', '查看黑名单')
-        .action(async ({ session }) => {
-        if (!session)
-            return;
-        if (config.blacklist.length === 0) {
-            await session.send('黑名单为空。');
+        // 如果没有匹配，尝试提取第一个单词
+        const firstWord = cleaned.split(/[,\s\.]+/)[0];
+        if (firstWord && firstWord.length > 1) {
+            return firstWord;
         }
-        else {
-            await session.send(`黑名单列表:\n${config.blacklist.join('\n')}`);
-        }
-    });
-    // 冷却时间管理命令
-    ctx.command(`${config.commandName}.admin`)
-        .subcommand('.clearcooldown <userId:string>', '清除用户冷却')
-        .action(async ({ session }, userId) => {
-        if (!session)
-            return;
-        storage.deleteCooldown(userId);
-        await session.send(`已清除用户 ${userId} 的冷却时间。`);
-    });
-    // 配置信息查看命令
-    ctx.command(`${config.commandName}.admin`)
-        .subcommand('.status', '查看插件状态')
-        .action(async ({ session }) => {
-        if (!session)
-            return;
-        const status = [
-            `模型: ${config.model}`,
-            `端点: ${config.endpoint}`,
-            `情绪分析: ${config.enableEmotion ? '已启用' : '未启用'}`,
-            `冷却时间: ${config.cooldown / 1000} 秒`,
-            `黑名单数量: ${config.blacklist.length}`,
-        ];
-        await session.send(`插件状态:\n${status.join('\n')}`);
-    });
-    ctx.logger.info('koishi-plugin-openai-compatible 插件已加载');
+        return 'neutral';
+    }
+    getEmojiConfig(emotion) {
+        // 首先尝试精确匹配
+        const exactMatch = this.emotionEmojis[emotion];
+        if (exactMatch)
+            return exactMatch;
+        // 尝试小写匹配
+        const lowerMatch = this.emotionEmojis[emotion.toLowerCase()];
+        if (lowerMatch)
+            return lowerMatch;
+        // 默认返回中性表情
+        return this.emotionEmojis['neutral'] || { text: '😐', image: '' };
+    }
+    setEmotionEmojis(emojis) {
+        this.emotionEmojis = { ...this.emotionEmojis, ...emojis };
+    }
+    getEmotionEmojis() {
+        return { ...this.emotionEmojis };
+    }
+    getEmojiConfigForEmotion(emotion) {
+        return this.getEmojiConfig(emotion);
+    }
+    updateDisplaySettings(showImage, useMarkdown) {
+        this.showEmotionImage = showImage;
+        this.imageAsMarkdown = useMarkdown;
+    }
+}
+exports.EmotionAnalyzer = EmotionAnalyzer;
+// 主插件类
+class OpenAICompatible {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.logger = ctx.logger('openai-compatible');
+        this.client = new OpenAICompatibleClient(config, this.logger);
+        this.emotionAnalyzer = new EmotionAnalyzer(config, this.logger);
+        this.cooldownManager = new CooldownManager(config.cooldown);
+        this.registerCommand();
+        this.registerService();
+    }
+    registerService() {
+        this.ctx.openai = this;
+        this.ctx.on('dispose', () => {
+            this.ctx.openai = undefined;
+        });
+    }
+    registerCommand() {
+        const { showError } = this.config;
+        this.ctx.command('ai <message:text>', '与AI对话')
+            .option('model', '-m <model:string>', { fallback: this.config.model })
+            .option('temperature', '-t <temp:number>', { fallback: this.config.temperature })
+            .option('system', '-s <systemPrompt:string>', { fallback: this.config.systemPrompt })
+            .option('noEmotion', '-n')
+            .option('noImage', '-i')
+            .action(async ({ session, options }, message) => {
+            if (!message)
+                return '请输入消息内容。';
+            const userId = (session === null || session === void 0 ? void 0 : session.userId) || 'unknown';
+            // 检查黑名单
+            if (this.config.blacklist.includes(userId)) {
+                return showError ? '您已被加入黑名单，无法使用此功能。' : '';
+            }
+            // 检查冷却时间
+            const cooldownCheck = this.cooldownManager.check(userId);
+            if (!cooldownCheck.available) {
+                return showError ? `冷却时间剩余 ${cooldownCheck.remaining} 秒。` : '';
+            }
+            try {
+                if (session) {
+                    await session.send('正在思考中...');
+                }
+                // 构建消息
+                const messages = [];
+                // 添加系统提示
+                const systemContent = (options === null || options === void 0 ? void 0 : options.system) || this.config.systemPrompt;
+                if (systemContent) {
+                    messages.push({
+                        role: 'system',
+                        content: systemContent,
+                    });
+                }
+                // 添加用户消息和提示词
+                let userMessage = message;
+                if (this.config.prompt) {
+                    userMessage = `${this.config.prompt}\n\n${message}`;
+                }
+                messages.push({
+                    role: 'user',
+                    content: userMessage,
+                });
+                // 调用API获取主回复
+                const mainResponse = await this.client.createChatCompletion(messages, {
+                    model: options === null || options === void 0 ? void 0 : options.model,
+                    temperature: options === null || options === void 0 ? void 0 : options.temperature,
+                });
+                if (!mainResponse) {
+                    return 'AI没有返回任何内容。';
+                }
+                // 情绪分析（如果不禁用）
+                let emotionResult = null;
+                if (this.config.emotionAnalysis.enabled && !(options === null || options === void 0 ? void 0 : options.noEmotion)) {
+                    try {
+                        // 临时修改显示设置（如果指定了禁用图片）
+                        const showImage = !(options === null || options === void 0 ? void 0 : options.noImage) && this.config.showEmotionImage;
+                        this.emotionAnalyzer.updateDisplaySettings(showImage, this.config.imageAsMarkdown);
+                        // 并行处理情绪分析，设置超时
+                        const emotionPromise = this.emotionAnalyzer.analyze(mainResponse);
+                        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('情绪分析超时')), this.config.emotionTimeout));
+                        emotionResult = await Promise.race([emotionPromise, timeoutPromise]);
+                    }
+                    catch (error) {
+                        this.logger.warn('Emotion analysis skipped or failed:', error.message);
+                        emotionResult = {
+                            emotion: 'neutral',
+                            emoji: '😐',
+                            displayText: '😐',
+                            success: false,
+                            error: error.message,
+                        };
+                    }
+                }
+                // 构建最终回复
+                let finalResponse = mainResponse;
+                if (emotionResult === null || emotionResult === void 0 ? void 0 : emotionResult.success) {
+                    // 添加情绪显示
+                    finalResponse += `\n\n${emotionResult.displayText} (情绪: ${emotionResult.emotion})`;
+                }
+                else if (emotionResult && this.config.showError) {
+                    // 情绪分析失败但启用了错误提示
+                    this.logger.debug('Emotion analysis failed, but main response sent');
+                }
+                return finalResponse;
+            }
+            catch (error) {
+                this.logger.error('AI request failed:', error);
+                return showError ? `请求失败：${error.message}` : '';
+            }
+        });
+        // 添加测试命令
+        this.ctx.command('ai.test', '测试AI连接')
+            .option('emotion', '-e')
+            .option('image', '-i')
+            .action(async ({ session, options }) => {
+            try {
+                if (session) {
+                    await session.send('正在测试连接...');
+                }
+                if ((options === null || options === void 0 ? void 0 : options.emotion) && this.config.emotionAnalysis.enabled) {
+                    const connected = await this.client.testConnection();
+                    if (connected) {
+                        // 测试情绪分析
+                        const testText = '我今天非常开心！';
+                        const emotionResult = await this.emotionAnalyzer.analyze(testText);
+                        let resultText = `连接测试成功！\n情绪分析测试：\n文本："${testText}"\n分析结果：${emotionResult.emotion} ${emotionResult.displayText}`;
+                        if (emotionResult.imageUrl) {
+                            resultText += `\n图片链接：${emotionResult.imageUrl}`;
+                        }
+                        return resultText;
+                    }
+                    else {
+                        return '连接测试失败！';
+                    }
+                }
+                else {
+                    const connected = await this.client.testConnection();
+                    return connected ? '连接测试成功！' : '连接测试失败！';
+                }
+            }
+            catch (error) {
+                return showError ? `测试失败：${error.message}` : '';
+            }
+        });
+        // 添加重置冷却命令
+        this.ctx.command('ai.reset <userId:string>', '重置用户冷却时间')
+            .action(({ session }, userId) => {
+            if (!userId && session) {
+                const sessionUserId = session.userId;
+                if (sessionUserId) {
+                    this.cooldownManager.reset(sessionUserId);
+                    return '已重置您的冷却时间。';
+                }
+                else {
+                    return '无法获取您的用户ID。';
+                }
+            }
+            else if (userId) {
+                this.cooldownManager.reset(userId);
+                return `已重置用户 ${userId} 的冷却时间。`;
+            }
+            else {
+                return '请提供用户ID。';
+            }
+        });
+        // 添加情绪表情管理命令
+        this.ctx.command('ai.emotion', '情绪分析管理')
+            .subcommand('.test <text:text>', '测试情绪分析')
+            .option('image', '-i')
+            .action(async ({ session, options }, text) => {
+            if (!this.config.emotionAnalysis.enabled) {
+                return '情绪分析功能未启用。';
+            }
+            if (!text) {
+                return '请输入要分析的文本。';
+            }
+            try {
+                if (session) {
+                    await session.send('正在分析情绪...');
+                }
+                // 临时修改显示设置
+                const showImage = (options === null || options === void 0 ? void 0 : options.image) ? this.config.showEmotionImage : false;
+                this.emotionAnalyzer.updateDisplaySettings(showImage, this.config.imageAsMarkdown);
+                const result = await this.emotionAnalyzer.analyze(text);
+                let responseText = `文本："${text}"\n情绪分析结果：${result.emotion} ${result.displayText}`;
+                if (result.imageUrl) {
+                    responseText += `\n图片链接：${result.imageUrl}`;
+                }
+                if (result.success) {
+                    return responseText;
+                }
+                else {
+                    return `情绪分析失败：${result.error}\n${responseText}`;
+                }
+            }
+            catch (error) {
+                return showError ? `情绪分析失败：${error.message}` : '';
+            }
+        })
+            .subcommand('.list', '查看情绪表情映射')
+            .action(() => {
+            const emojis = this.emotionAnalyzer.getEmotionEmojis();
+            const list = Object.entries(emojis)
+                .map(([emotion, config]) => {
+                const imageInfo = config.image ? `\n  图片链接: ${config.image}` : '';
+                return `${emotion}: ${config.text}${imageInfo}`;
+            })
+                .join('\n\n');
+            return `情绪表情映射：\n${list}`;
+        })
+            .subcommand('.get <emotion:string>', '获取情绪表情配置')
+            .action(({ session }, emotion) => {
+            if (!emotion) {
+                return '请提供情绪类型。';
+            }
+            const config = this.emotionAnalyzer.getEmojiConfigForEmotion(emotion);
+            let response = `${emotion}: ${config.text}`;
+            if (config.image) {
+                response += `\n图片链接: ${config.image}`;
+                if (this.config.showEmotionImage) {
+                    if (this.config.imageAsMarkdown) {
+                        response += `\n显示为: ![${emotion}](${config.image})`;
+                    }
+                    else {
+                        response += `\n显示为: [CQ:image,file=${config.image}]`;
+                    }
+                }
+            }
+            else {
+                response += '\n未配置图片链接';
+            }
+            return response;
+        })
+            .subcommand('.set <emotion:string> <text:string> [image:string]', '设置情绪表情配置', { authority: 3 })
+            .action(({ session }, emotion, text, image) => {
+            if (!emotion || !text) {
+                return '请提供情绪类型和文本表情。';
+            }
+            const newConfig = {
+                text,
+                image: image || '',
+            };
+            const newEmojis = { [emotion]: newConfig };
+            this.emotionAnalyzer.setEmotionEmojis(newEmojis);
+            // 更新配置（内存中）
+            this.config.emotionEmojis = this.emotionAnalyzer.getEmotionEmojis();
+            let response = `已设置 ${emotion} 的配置：\n文本表情: ${text}`;
+            if (image) {
+                response += `\n图片链接: ${image}`;
+            }
+            return response;
+        })
+            .subcommand('.image <enabled:boolean>', '启用/禁用情绪图片显示', { authority: 3 })
+            .action(({ session }, enabled) => {
+            if (enabled === undefined) {
+                return `当前情绪图片显示状态: ${this.config.showEmotionImage ? '启用' : '禁用'}`;
+            }
+            this.config.showEmotionImage = enabled;
+            this.emotionAnalyzer.updateDisplaySettings(enabled, this.config.imageAsMarkdown);
+            return `已${enabled ? '启用' : '禁用'}情绪图片显示`;
+        })
+            .subcommand('.format <format:string>', '设置图片显示格式（markdown/cq）', { authority: 3 })
+            .action(({ session }, format) => {
+            if (!format || !['markdown', 'cq'].includes(format.toLowerCase())) {
+                return '请指定格式：markdown 或 cq';
+            }
+            const useMarkdown = format.toLowerCase() === 'markdown';
+            this.config.imageAsMarkdown = useMarkdown;
+            this.emotionAnalyzer.updateDisplaySettings(this.config.showEmotionImage, useMarkdown);
+            return `已设置图片显示格式为: ${format}`;
+        });
+    }
+    // 公共API方法
+    async chat(message, options) {
+        var _a, _b;
+        const userId = (options === null || options === void 0 ? void 0 : options.userId) || 'anonymous';
+        // 检查黑名单
+        if (this.config.blacklist.includes(userId)) {
+            throw new Error('User is blacklisted');
+        }
+        // 检查冷却时间
+        const cooldownCheck = this.cooldownManager.check(userId);
+        if (!cooldownCheck.available) {
+            throw new Error(`Cooldown: ${cooldownCheck.remaining}s remaining`);
+        }
+        // 构建消息
+        const messages = [];
+        if ((options === null || options === void 0 ? void 0 : options.systemPrompt) || this.config.systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: (options === null || options === void 0 ? void 0 : options.systemPrompt) || this.config.systemPrompt,
+            });
+        }
+        let userMessage = message;
+        if (this.config.prompt) {
+            userMessage = `${this.config.prompt}\n\n${message}`;
+        }
+        messages.push({
+            role: 'user',
+            content: userMessage,
+        });
+        // 获取主回复
+        const mainResponse = await this.client.createChatCompletion(messages, {
+            model: options === null || options === void 0 ? void 0 : options.model,
+            temperature: options === null || options === void 0 ? void 0 : options.temperature,
+        });
+        // 情绪分析
+        let emotionResult = null;
+        const enableEmotion = (_a = options === null || options === void 0 ? void 0 : options.enableEmotion) !== null && _a !== void 0 ? _a : this.config.emotionAnalysis.enabled;
+        if (enableEmotion) {
+            try {
+                // 临时修改显示设置
+                const showImage = (_b = options === null || options === void 0 ? void 0 : options.showImage) !== null && _b !== void 0 ? _b : this.config.showEmotionImage;
+                this.emotionAnalyzer.updateDisplaySettings(showImage, this.config.imageAsMarkdown);
+                emotionResult = await this.emotionAnalyzer.analyze(mainResponse);
+            }
+            catch (error) {
+                this.logger.warn('Emotion analysis failed in API call:', error.message);
+            }
+        }
+        // 构建结果
+        const result = {
+            text: mainResponse,
+        };
+        if (emotionResult) {
+            result.emotion = emotionResult.emotion;
+            result.emoji = emotionResult.emoji;
+            result.imageUrl = emotionResult.imageUrl;
+            result.displayText = emotionResult.displayText;
+            result.emotionSuccess = emotionResult.success;
+        }
+        return result;
+    }
+    async analyzeEmotion(text, showImage) {
+        // 临时修改显示设置
+        const displayImage = showImage !== null && showImage !== void 0 ? showImage : this.config.showEmotionImage;
+        this.emotionAnalyzer.updateDisplaySettings(displayImage, this.config.imageAsMarkdown);
+        return this.emotionAnalyzer.analyze(text);
+    }
+    async test() {
+        return this.client.testConnection();
+    }
+    // 获取情绪分析器实例
+    getEmotionAnalyzer() {
+        return this.emotionAnalyzer;
+    }
+    // 更新配置（供运行时调整）
+    updateConfig(newConfig) {
+        var _a, _b;
+        // 更新相关配置
+        if (newConfig.emotionEmojis) {
+            this.emotionAnalyzer.setEmotionEmojis(newConfig.emotionEmojis);
+            this.config.emotionEmojis = { ...this.config.emotionEmojis, ...newConfig.emotionEmojis };
+        }
+        if (newConfig.showEmotionImage !== undefined || newConfig.imageAsMarkdown !== undefined) {
+            const showImage = (_a = newConfig.showEmotionImage) !== null && _a !== void 0 ? _a : this.config.showEmotionImage;
+            const useMarkdown = (_b = newConfig.imageAsMarkdown) !== null && _b !== void 0 ? _b : this.config.imageAsMarkdown;
+            this.emotionAnalyzer.updateDisplaySettings(showImage, useMarkdown);
+            if (newConfig.showEmotionImage !== undefined) {
+                this.config.showEmotionImage = newConfig.showEmotionImage;
+            }
+            if (newConfig.imageAsMarkdown !== undefined) {
+                this.config.imageAsMarkdown = newConfig.imageAsMarkdown;
+            }
+        }
+    }
 }
+exports.OpenAICompatible = OpenAICompatible;
+__exportStar(require("./types"), exports);
+exports.default = (ctx, config) => {
+    return new OpenAICompatible(ctx, config);
+};