koishi-plugin-openai-compatible 1.0.8 → 1.0.9

package/src/index.ts

@@ -1,174 +1,835 @@
-import { Context, Schema } from 'koishi';
-import type { Config } from './config';
-import { OpenAICompatibleAPI } from './api';
-import { EmotionAnalyzer } from './emotion';
-import { Storage } from './storage';
-import type { Message } from './types';
-
-export const name = 'openai-compatible';
-
-export const inject = {
-  required: [],
-  optional: [],
-};
-
-export function apply(ctx: Context, config: Config) {
-  // 导出配置 Schema
-  ctx.i18n.define('zh', require('./locales/zh'));
-
-  // 确保命令名称存在且有效
-  const commandName = config.commandName || 'ai';
-
-  // 初始化存储
-  const storage = new Storage();
-
-  // 初始化 API 客户端
-  const api = new OpenAICompatibleAPI(config.endpoint, config.apiKey);
-
-  // 初始化情绪分析器
-  let emotionAnalyzer: EmotionAnalyzer | null = null;
-  if (config.enableEmotion) {
-    const emotionApi = new OpenAICompatibleAPI(config.emotionEndpoint, config.emotionApiKey);
-    emotionAnalyzer = new EmotionAnalyzer(emotionApi, config);
-  }
-
-  // 注册命令
-  ctx.command(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;
-      }
-
-      // 检查冷却时间
-      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;
-      }
-
-      // 获取用户输入
-      if (!content || content.trim() === '') {
-        if (config.enableMessage) {
-          await session.send('请输入要聊天的内容。');
-        }
-        return;
-      }
-
-      try {
-        // 构建消息列表
-        const messages: Message[] = [
-          { role: 'system', content: config.systemPrompt },
-          { role: 'user', content: content },
-        ];
-
-        // 调用 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}`;
-          }
-        }
-
-        // 发送回复
-        await session.send(finalResponse);
-
-        // 更新冷却时间
-        storage.setCooldown(userId, { lastRequestTime: Date.now() });
-
-      } 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} 从黑名单中移除。`);
-      } else {
-        await session.send(`用户 ${userId} 不在黑名单中。`);
-      }
-    });
-
-  ctx.command(`${config.commandName}.admin`)
-    .subcommand('.list', '查看黑名单')
-    .action(async ({ session }) => {
-      if (!session) return;
-      if (config.blacklist.length === 0) {
-        await session.send('黑名单为空。');
-      } 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 插件已加载');
-}
+import { Context, Schema, Session, Logger } from 'koishi'
+import { Config, EmotionType, EmojiConfig } from './types'
+
+declare module 'koishi' {
+  interface Context {
+    openai?: OpenAICompatible
+  }
+}
+
+// 冷却时间管理器
+class CooldownManager {
+  private cooldowns = new Map<string, number>()
+  
+  constructor(private cooldown: number) {}
+  
+  check(userId: string): { available: boolean; remaining: number } {
+    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 }
+    }
+    
+    const elapsed = (now - lastTime) / 1000
+    const remaining = this.cooldown - elapsed
+    
+    if (remaining > 0) {
+      return { available: false, remaining: Math.ceil(remaining) }
+    }
+    
+    this.cooldowns.set(userId, now)
+    return { available: true, remaining: 0 }
+  }
+  
+  reset(userId: string) {
+    this.cooldowns.delete(userId)
+  }
+}
+
+// OpenAI兼容客户端
+class OpenAICompatibleClient {
+  private logger: Logger
+  private endpoint: string
+  private apiKey: string
+  private timeout: number
+  private maxRetries: number
+  
+  constructor(
+    private config: Config,
+    logger: Logger,
+    isEmotion: boolean = false
+  ) {
+    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: any[], 
+    config?: Partial<Config>,
+    isEmotion: boolean = false
+  ): Promise<string> {
+    const url = `${this.endpoint}/chat/completions`
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this.apiKey}`,
+    }
+    
+    // 根据是否为情绪分析设置不同的参数
+    let requestConfig: any
+    
+    if (isEmotion) {
+      requestConfig = {
+        model: config?.emotionAnalysis?.model || this.config.emotionAnalysis.model,
+        messages,
+        max_tokens: config?.emotionMaxTokens || this.config.emotionMaxTokens,
+        temperature: config?.emotionTemperature || this.config.emotionTemperature,
+        top_p: 1,
+        presence_penalty: 0,
+        frequency_penalty: 0,
+        stream: false,
+      }
+    } else {
+      requestConfig = {
+        model: config?.model || this.config.model,
+        messages,
+        max_tokens: config?.maxTokens || this.config.maxTokens,
+        temperature: config?.temperature || this.config.temperature,
+        top_p: config?.topP || this.config.topP,
+        presence_penalty: config?.presencePenalty || this.config.presencePenalty,
+        frequency_penalty: config?.frequencyPenalty || this.config.frequencyPenalty,
+        stream: false,
+      }
+    }
+    
+    let lastError: Error | null = 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 data.choices[0]?.message?.content?.trim() || ''
+      } catch (error: any) {
+        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)))
+        }
+      }
+    }
+    
+    if (lastError) {
+      throw lastError
+    } else {
+      throw new Error('Unknown error occurred')
+    }
+  }
+  
+  async testConnection(): Promise<boolean> {
+    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: any) {
+      this.logger.error('Connection test failed:', error.message)
+      return false
+    }
+  }
+}
+
+// 情绪分析器
+class EmotionAnalyzer {
+  private client: OpenAICompatibleClient
+  private logger: Logger
+  private emotionEmojis: Record<string, EmojiConfig>
+  private showEmotionImage: boolean
+  private imageAsMarkdown: boolean
+  
+  constructor(
+    private config: Config,
+    logger: Logger
+  ) {
+    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: string): Promise<{
+    emotion: EmotionType
+    emoji: string
+    imageUrl?: string
+    displayText: string
+    success: boolean
+    error?: string
+  }> {
+    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: '你是一个情绪分析专家，只能返回单个情绪类型单词，不要解释，不要额外文本。',
+        },
+        {
+          role: 'user',
+          content: `${this.config.emotionAnalysis.prompt}\n\n文本：${text}`,
+        },
+      ]
+      
+      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}]`
+        }
+      }
+      
+      this.logger.debug(`Analyzed emotion: ${emotion} -> ${displayText}`)
+      
+      return {
+        emotion,
+        emoji: emojiConfig.text,
+        imageUrl: emojiConfig.image,
+        displayText,
+        success: true,
+      }
+    } catch (error: any) {
+      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,
+      }
+    }
+  }
+  
+  private normalizeEmotion(text: string): EmotionType {
+    if (!text) return 'neutral'
+    
+    // 清理文本
+    const cleaned = text.toLowerCase().trim()
+    
+    // 常见的情绪类型映射
+    const emotionMap: Record<string, EmotionType> = {
+      '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
+      }
+    }
+    
+    // 如果没有匹配，尝试提取第一个单词
+    const firstWord = cleaned.split(/[,\s\.]+/)[0]
+    if (firstWord && firstWord.length > 1) {
+      return firstWord as EmotionType
+    }
+    
+    return 'neutral'
+  }
+  
+  private getEmojiConfig(emotion: EmotionType): EmojiConfig {
+    // 首先尝试精确匹配
+    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: Record<string, EmojiConfig>) {
+    this.emotionEmojis = { ...this.emotionEmojis, ...emojis }
+  }
+  
+  getEmotionEmojis(): Record<string, EmojiConfig> {
+    return { ...this.emotionEmojis }
+  }
+  
+  getEmojiConfigForEmotion(emotion: string): EmojiConfig {
+    return this.getEmojiConfig(emotion)
+  }
+  
+  updateDisplaySettings(showImage: boolean, useMarkdown: boolean) {
+    this.showEmotionImage = showImage
+    this.imageAsMarkdown = useMarkdown
+  }
+}
+
+// 主插件类
+class OpenAICompatible {
+  private client: OpenAICompatibleClient
+  private emotionAnalyzer: EmotionAnalyzer
+  private cooldownManager: CooldownManager
+  private logger: Logger
+  
+  constructor(
+    private ctx: Context,
+    private 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()
+  }
+  
+  private registerService() {
+    this.ctx.openai = this
+    
+    this.ctx.on('dispose', () => {
+      this.ctx.openai = undefined
+    })
+  }
+  
+  private 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?.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?.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?.model,
+            temperature: options?.temperature,
+          })
+          
+          if (!mainResponse) {
+            return 'AI没有返回任何内容。'
+          }
+          
+          // 情绪分析（如果不禁用）
+          let emotionResult = null
+          if (this.config.emotionAnalysis.enabled && !options?.noEmotion) {
+            try {
+              // 临时修改显示设置（如果指定了禁用图片）
+              const showImage = !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]) as any
+            } catch (error: any) {
+              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?.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: any) {
+          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?.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: any) {
+          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?.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: any) {
+          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: EmojiConfig = {
+          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: string, 
+    options?: {
+      userId?: string
+      model?: string
+      temperature?: number
+      systemPrompt?: string
+      enableEmotion?: boolean
+      showImage?: boolean
+    }
+  ): Promise<{
+    text: string
+    emotion?: EmotionType
+    emoji?: string
+    imageUrl?: string
+    displayText?: string
+    emotionSuccess?: boolean
+  }> {
+    const userId = 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?.systemPrompt || this.config.systemPrompt) {
+      messages.push({
+        role: 'system',
+        content: 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?.model,
+      temperature: options?.temperature,
+    })
+    
+    // 情绪分析
+    let emotionResult = null
+    const enableEmotion = options?.enableEmotion ?? this.config.emotionAnalysis.enabled
+    if (enableEmotion) {
+      try {
+        // 临时修改显示设置
+        const showImage = options?.showImage ?? this.config.showEmotionImage
+        this.emotionAnalyzer.updateDisplaySettings(showImage, this.config.imageAsMarkdown)
+        
+        emotionResult = await this.emotionAnalyzer.analyze(mainResponse)
+      } catch (error: any) {
+        this.logger.warn('Emotion analysis failed in API call:', error.message)
+      }
+    }
+    
+    // 构建结果
+    const result: any = {
+      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: string, showImage?: boolean): Promise<{
+    emotion: EmotionType
+    emoji: string
+    imageUrl?: string
+    displayText: string
+    success: boolean
+    error?: string
+  }> {
+    // 临时修改显示设置
+    const displayImage = showImage ?? this.config.showEmotionImage
+    this.emotionAnalyzer.updateDisplaySettings(displayImage, this.config.imageAsMarkdown)
+    
+    return this.emotionAnalyzer.analyze(text)
+  }
+  
+  async test(): Promise<boolean> {
+    return this.client.testConnection()
+  }
+  
+  // 获取情绪分析器实例
+  getEmotionAnalyzer(): EmotionAnalyzer {
+    return this.emotionAnalyzer
+  }
+  
+  // 更新配置（供运行时调整）
+  updateConfig(newConfig: Partial<Config>) {
+    // 更新相关配置
+    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 = newConfig.showEmotionImage ?? this.config.showEmotionImage
+      const useMarkdown = newConfig.imageAsMarkdown ?? 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
+      }
+    }
+  }
+}
+
+export { OpenAICompatible, Config, EmotionAnalyzer }
+export * from './types'
+
+export default (ctx: Context, config: Config) => {
+  return new OpenAICompatible(ctx, config)
+}