koishi-plugin-chat-model 1.0.0

package/README.md

@@ -0,0 +1,114 @@
+# koishi-plugin-chat-model
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-chat-model?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-chat-model)
+
+当消息没有触发其他命令时，自动使用大型语言模型（LLM）进行对话，支持记忆上下文。
+
+## 功能特点
+
+- 支持多种大型语言模型：
+  - OpenAI GPT系列 (GPT-3.5-turbo、GPT-4等)
+  - Anthropic Claude系列 (Claude 3 Opus、Claude 3 Sonnet、Claude 3 Haiku等)
+  - Google Gemini系列 (Gemini Pro、Gemini 1.5等)
+  - 自定义模型 (通过适配器支持)
+- 自动在没有匹配到其他命令的情况下触发对话
+- 保持上下文记忆，支持连续对话
+- 可配置触发条件（私聊/群聊、前缀、触发概率等）
+- 支持自定义系统提示语
+- 支持用户使用限制（每日最大对话次数）
+- 提供清除上下文的命令
+
+## 安装
+
+```bash
+npm install koishi-plugin-chat-model
+```
+
+## 配置项
+
+| 配置项 | 类型 | 默认值 | 说明 |
+|-------|------|-------|------|
+| modelType | select | openai | 对话模型类型，可选：openai、claude、gemini、custom |
+| apiKey | string | | API密钥，必填 |
+| apiEndpoint | string | (根据模型不同) | API地址，可选，用于修改默认API端点 |
+| modelName | string | (根据模型不同) | 模型名称，如：gpt-3.5-turbo、claude-3-sonnet等 |
+| systemPrompt | string | 你是一个有用的AI助手。 | 系统提示词，用于定义AI助手的行为和能力 |
+| contextSize | number | 10 | 上下文记忆的消息数量（轮数），每轮包含一条用户消息和一条助手回复 |
+| temperature | number | 0.7 | 温度参数，控制回复的随机性，0-2之间 |
+| responseTimeout | number | 60 | 响应超时时间，单位为秒 |
+| triggerRatio | number | 100 | 触发概率，范围0-100%之间 |
+| triggerPrefix | string | | 触发前缀，不填则任何未命中命令的消息都会触发 |
+| triggerPrivate | boolean | true | 是否在私聊中自动触发 |
+| triggerGroup | boolean | false | 是否在群聊中自动触发 |
+| customModelAdapter | string | | 自定义模型适配器路径（仅在modelType=custom时有效） |
+| usageLimit.enabled | boolean | false | 是否启用使用限制 |
+| usageLimit.maxMessagesPerUser | number | 100 | 每用户每日最大消息数 |
+| usageLimit.resetTime | string | 00:00 | 使用计数重置时间，24小时制 |
+
+## 使用方法
+
+1. 在Koishi应用中安装并启用本插件
+2. 配置相应的API密钥和其他设置
+3. 向机器人发送不匹配其他命令的消息即可触发对话
+
+### 清除上下文
+
+当需要重置对话上下文时，可使用以下命令：
+
+```
+清除上下文
+```
+
+### 使用系统提示词
+
+通过修改系统提示词，可以改变AI助手的行为和风格。例如：
+
+```
+你是一位资深的编程助手，擅长解答与JavaScript、Python和数据库相关的问题，回答简洁专业，并提供实用的代码示例。
+```
+
+### 使用前缀过滤
+
+如果只希望特定格式的消息触发AI对话，可以设置`triggerPrefix`。比如设置为`@AI `（注意结尾有空格），则只有以`@AI `开头的消息才会触发AI回复。
+
+## 自定义模型适配器
+
+如果需要支持其他语言模型，可以创建自定义适配器：
+
+1. 创建一个实现了`generateResponse`方法的类
+2. 将该类的路径填入`customModelAdapter`配置项
+3. 设置`modelType`为`custom`
+
+自定义适配器的最小实现示例：
+
+```javascript
+class CustomAdapter {
+  constructor(ctx, config) {
+    this.ctx = ctx
+    this.config = config
+  }
+  
+  async generateResponse(messages, session) {
+    // 实现与您的模型API通信的逻辑
+    // 返回生成的文本回复
+    return '这是自定义模型的回复'
+  }
+  
+  async dispose() {
+    // 清理资源（如果需要）
+  }
+}
+
+module.exports = CustomAdapter
+```
+
+## 数据库表
+
+本插件会创建以下数据库表：
+
+- `chatModelContext`：存储用户的对话上下文
+- `chatModelUsage`：存储用户的使用统计
+
+## 协议
+
+MIT 

package/index.js

@@ -0,0 +1,378 @@
+const { Context, Schema } = require('koishi')
+
+// 插件名称
+exports.name = 'chat-model'
+
+// 插件配置项
+exports.Config = Schema.object({
+  modelType: Schema.union([
+    Schema.const('openai').description('OpenAI (GPT-3.5/GPT-4)'),
+    Schema.const('claude').description('Anthropic Claude'),
+    Schema.const('gemini').description('Google Gemini'),
+    Schema.const('custom').description('自定义模型')
+  ]).default('openai').description('对话模型类型'),
+  apiKey: Schema.string().role('secret').description('API密钥'),
+  apiEndpoint: Schema.string().default('https://api.openai.com/v1').description('API地址(可选)'),
+  modelName: Schema.string().default('gpt-3.5-turbo').description('模型名称'),
+  systemPrompt: Schema.string().default('你是一个有用的AI助手。').description('系统提示词'),
+  contextSize: Schema.number().default(10).description('上下文记忆的消息数量(默认: 10)'),
+  temperature: Schema.number().min(0).max(2).step(0.1).default(0.7).description('温度参数(0-2之间)'),
+  responseTimeout: Schema.number().default(60).description('响应超时时间(秒)'),
+  triggerRatio: Schema.number().min(0).max(100).step(1).default(100).description('触发概率(0-100%之间)'),
+  triggerPrefix: Schema.string().description('触发前缀，不填则任何未命中命令的消息都会触发模型响应'),
+  triggerPrivate: Schema.boolean().default(true).description('是否在私聊中自动触发'),
+  triggerGroup: Schema.boolean().default(false).description('是否在群聊中自动触发'),
+  customModelAdapter: Schema.string().description('自定义模型适配器路径(仅modelType=custom时有效)'),
+  usageLimit: Schema.object({
+    enabled: Schema.boolean().default(false).description('是否启用使用限制'),
+    maxMessagesPerUser: Schema.number().default(100).description('每用户每日最大消息数'),
+    resetTime: Schema.string().default('00:00').description('计数重置时间(24小时制,如 00:00)')
+  }).description('使用限制配置')
+})
+
+// 声明依赖的服务或插件
+exports.using = ['database']
+
+// 插件主体逻辑
+exports.apply = (ctx, config) => {
+  // 从lib目录加载适配器
+  const ModelAdapter = loadModelAdapter(ctx, config)
+  const modelInstance = new ModelAdapter(ctx, config)
+
+  // 初始化数据库
+  setupDatabase(ctx)
+  
+  // 消息处理器
+  const messageHandler = createMessageHandler(ctx, config, modelInstance)
+  
+  // 注册middleware - 在消息中间件管道的末尾捕获未处理的消息
+  ctx.middleware(async (session, next) => {
+    // 首先尝试使用Koishi的其他处理器处理消息
+    const handled = await next()
+    
+    // 如果消息已被处理，或者是不应该触发的消息类型，则直接返回
+    if (handled || shouldIgnoreMessage(session, config)) {
+      return handled
+    }
+    
+    // 检查是否有自定义前缀，如果有则检查消息是否以该前缀开头
+    if (config.triggerPrefix && !session.content.startsWith(config.triggerPrefix)) {
+      return
+    }
+    
+    // 移除前缀（如果有）
+    let content = session.content
+    if (config.triggerPrefix) {
+      content = content.substring(config.triggerPrefix.length).trim()
+    }
+    
+    // 如果内容为空，则不处理
+    if (!content) {
+      return
+    }
+    
+    // 使用概率判断是否响应
+    if (config.triggerRatio < 100 && Math.random() * 100 > config.triggerRatio) {
+      ctx.logger.debug('根据概率设置不响应此消息')
+      return
+    }
+    
+    // 检查用户使用限制
+    if (config.usageLimit?.enabled && !await checkUsageLimit(ctx, session.userId)) {
+      await session.send('今日对话次数已达上限，请明天再来')
+      return true
+    }
+    
+    try {
+      // 显示正在输入状态
+      await session.sendQueued('正在思考中...')
+      
+      // 处理消息并发送回复
+      const reply = await messageHandler(session, content)
+      
+      // 如果没有回复内容，则跳过发送
+      if (!reply) {
+        ctx.logger.warn('模型没有返回有效回复')
+        return
+      }
+      
+      // 发送回复
+      await session.send(reply)
+      
+      // 更新用户使用计数
+      if (config.usageLimit?.enabled) {
+        await updateUsageCount(ctx, session.userId)
+      }
+      
+      // 标记消息为已处理
+      return true
+    } catch (error) {
+      ctx.logger.error('处理消息时出错:', error)
+      await session.send(`处理消息时出错: ${error.message}`)
+      return true
+    }
+  }, true) // true表示这个中间件应该在所有其他中间件之后执行
+  
+  // 注册清理上下文的命令
+  ctx.command('清除上下文', '清除与AI助手的对话上下文')
+    .action(async ({ session }) => {
+      await clearUserContext(ctx, session.userId)
+      return '已清除对话上下文'
+    })
+  
+  // 关闭插件时清理资源
+  ctx.on('dispose', async () => {
+    // 清理资源
+    await modelInstance.dispose()
+    ctx.logger.info('聊天模型插件已卸载')
+  })
+}
+
+// 加载对应的模型适配器
+function loadModelAdapter(ctx, config) {
+  try {
+    switch(config.modelType) {
+      case 'openai':
+        return require('./lib/openai-adapter')
+      case 'claude':
+        return require('./lib/claude-adapter')
+      case 'gemini':
+        return require('./lib/gemini-adapter')
+      case 'custom':
+        if (!config.customModelAdapter) {
+          throw new Error('使用自定义模型时必须提供适配器路径')
+        }
+        return require(config.customModelAdapter)
+      default:
+        ctx.logger.warn(`未知模型类型: ${config.modelType}，将使用OpenAI适配器`)
+        return require('./lib/openai-adapter')
+    }
+  } catch (error) {
+    ctx.logger.error(`加载模型适配器失败: ${error.message}`)
+    throw new Error(`加载模型适配器失败: ${error.message}`)
+  }
+}
+
+// 设置数据库表结构
+function setupDatabase(ctx) {
+  // 用于存储上下文历史记录
+  ctx.model.extend('chatModelContext', {
+    // 用户ID
+    userId: 'string',
+    // 上下文历史（作为JSON字符串存储）
+    context: 'json',
+    // 最后更新时间
+    updatedAt: 'timestamp'
+  }, {
+    primary: 'userId'
+  })
+  
+  // 用于存储使用统计
+  ctx.model.extend('chatModelUsage', {
+    // 用户ID
+    userId: 'string',
+    // 当日消息计数
+    dailyCount: 'integer',
+    // 上次重置时间
+    lastResetDate: 'string'
+  }, {
+    primary: 'userId'
+  })
+}
+
+// 创建消息处理器函数
+function createMessageHandler(ctx, config, modelInstance) {
+  return async (session, content) => {
+    // 获取用户上下文
+    const userContext = await getUserContext(ctx, session.userId)
+    
+    // 添加新的用户消息
+    userContext.push({
+      role: 'user',
+      content: content
+    })
+    
+    // 限制上下文大小
+    while (userContext.length > config.contextSize * 2 + 1) { // +1是因为我们要保留system消息
+      // 移除最早的用户消息和对应的助手回复(成对删除)
+      userContext.splice(1, 2)
+    }
+    
+    // 从配置中获取系统提示，并确保它始终是第一条消息
+    if (userContext.length === 0 || userContext[0].role !== 'system') {
+      userContext.unshift({
+        role: 'system',
+        content: config.systemPrompt
+      })
+    } else {
+      // 更新系统提示内容
+      userContext[0].content = config.systemPrompt
+    }
+    
+    // 设置超时
+    const timeout = (config.responseTimeout || 60) * 1000
+    
+    try {
+      // 请求模型响应
+      const response = await Promise.race([
+        modelInstance.generateResponse(userContext, session),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('响应超时')), timeout)
+        )
+      ])
+      
+      // 添加助手回复到上下文
+      userContext.push({
+        role: 'assistant',
+        content: response
+      })
+      
+      // 保存更新的上下文
+      await saveUserContext(ctx, session.userId, userContext)
+      
+      return response
+    } catch (error) {
+      ctx.logger.error('生成回复失败:', error)
+      return `抱歉，生成回复时发生错误: ${error.message}`
+    }
+  }
+}
+
+// 获取用户上下文
+async function getUserContext(ctx, userId) {
+  const record = await ctx.database.get('chatModelContext', { userId })
+  
+  if (record && record.length > 0) {
+    return record[0].context || []
+  }
+  
+  return []
+}
+
+// 保存用户上下文
+async function saveUserContext(ctx, userId, context) {
+  const now = new Date().getTime()
+  
+  // 尝试更新现有记录
+  const result = await ctx.database.set('chatModelContext', { userId }, {
+    context,
+    updatedAt: now
+  })
+  
+  // 如果没有更新任何记录，则创建新记录
+  if (result === 0) {
+    await ctx.database.create('chatModelContext', {
+      userId,
+      context,
+      updatedAt: now
+    })
+  }
+}
+
+// 清除用户上下文
+async function clearUserContext(ctx, userId) {
+  await ctx.database.set('chatModelContext', { userId }, {
+    context: [],
+    updatedAt: new Date().getTime()
+  })
+}
+
+// 检查当前日期是否需要重置使用计数
+async function checkAndResetUsage(ctx, userId, config) {
+  const records = await ctx.database.get('chatModelUsage', { userId })
+  
+  if (!records || records.length === 0) {
+    return true
+  }
+  
+  const record = records[0]
+  const today = new Date().toISOString().split('T')[0] // YYYY-MM-DD
+  
+  // 如果日期不同，重置计数
+  if (record.lastResetDate !== today) {
+    await ctx.database.set('chatModelUsage', { userId }, {
+      dailyCount: 0,
+      lastResetDate: today
+    })
+    return true
+  }
+  
+  // 返回是否未超过限制
+  return record.dailyCount < (config.usageLimit?.maxMessagesPerUser || 100)
+}
+
+// 检查使用限制
+async function checkUsageLimit(ctx, userId) {
+  const records = await ctx.database.get('chatModelUsage', { userId })
+  
+  if (!records || records.length === 0) {
+    return true // 首次使用，允许
+  }
+  
+  const record = records[0]
+  const today = new Date().toISOString().split('T')[0] // YYYY-MM-DD
+  
+  // 如果日期不同，重置计数
+  if (record.lastResetDate !== today) {
+    await ctx.database.set('chatModelUsage', { userId }, {
+      dailyCount: 0,
+      lastResetDate: today
+    })
+    return true
+  }
+  
+  // 返回是否未超过限制
+  const config = ctx.config.chatModel
+  return record.dailyCount < (config.usageLimit?.maxMessagesPerUser || 100)
+}
+
+// 更新使用计数
+async function updateUsageCount(ctx, userId) {
+  const today = new Date().toISOString().split('T')[0] // YYYY-MM-DD
+  const records = await ctx.database.get('chatModelUsage', { userId })
+  
+  if (!records || records.length === 0) {
+    // 创建新记录
+    await ctx.database.create('chatModelUsage', {
+      userId,
+      dailyCount: 1,
+      lastResetDate: today
+    })
+  } else {
+    // 更新现有记录
+    const record = records[0]
+    
+    // 如果是新的一天，重置计数
+    if (record.lastResetDate !== today) {
+      await ctx.database.set('chatModelUsage', { userId }, {
+        dailyCount: 1,
+        lastResetDate: today
+      })
+    } else {
+      // 增加计数
+      await ctx.database.set('chatModelUsage', { userId }, {
+        dailyCount: record.dailyCount + 1
+      })
+    }
+  }
+}
+
+// 判断是否应该忽略消息
+function shouldIgnoreMessage(session, config) {
+  // 忽略自己发送的消息
+  if (session.userId === session.selfId) {
+    return true
+  }
+  
+  // 根据配置决定是否处理私聊/群聊消息
+  const isPrivate = session.channelId === session.userId
+  if (isPrivate && !config.triggerPrivate) {
+    return true
+  }
+  
+  if (!isPrivate && !config.triggerGroup) {
+    return true
+  }
+  
+  return false
+} 

package/lib/claude-adapter.js

@@ -0,0 +1,140 @@
+const fetch = require('node-fetch')
+const AbortController = require('abort-controller')
+
+class ClaudeAdapter {
+  constructor(ctx, config) {
+    this.ctx = ctx
+    this.config = config
+    this.apiKey = config.apiKey
+    this.apiEndpoint = config.apiEndpoint || 'https://api.anthropic.com/v1'
+    // Claude模型名称映射
+    const modelMap = {
+      'claude-3-opus': 'claude-3-opus-20240229',
+      'claude-3-sonnet': 'claude-3-sonnet-20240229',
+      'claude-3-haiku': 'claude-3-haiku-20240307',
+      'claude-2': 'claude-2.0',
+      'claude-instant': 'claude-instant-1.2'
+    }
+    
+    this.modelName = modelMap[config.modelName] || config.modelName || 'claude-3-sonnet-20240229'
+    this.temperature = config.temperature ?? 0.7
+    
+    // 验证必要参数
+    if (!this.apiKey) {
+      ctx.logger.error('Claude API密钥未设置')
+      throw new Error('Claude API密钥未设置')
+    }
+    
+    ctx.logger.info(`Claude适配器已初始化，使用模型: ${this.modelName}`)
+  }
+  
+  /**
+   * 将Koishi消息格式转换为Claude格式
+   * @param {Array} koishiMessages - Koishi格式的消息数组
+   * @returns {Array} - Claude API格式的消息数组
+   */
+  formatMessages(koishiMessages) {
+    // 获取system message (如果有)
+    const systemMessage = koishiMessages.find(msg => msg.role === 'system')?.content || ''
+    
+    // 过滤掉system message，只保留user和assistant消息
+    const conversationMessages = koishiMessages.filter(msg => msg.role !== 'system')
+    
+    const claudeMessages = conversationMessages.map(msg => ({
+      role: msg.role === 'assistant' ? 'assistant' : 'user',
+      content: msg.content
+    }))
+    
+    return {
+      systemMessage,
+      messages: claudeMessages
+    }
+  }
+  
+  /**
+   * 生成回复
+   * @param {Array} messages - 对话历史消息
+   * @param {Object} session - Koishi会话对象
+   * @returns {Promise<string>} - 生成的回复文本
+   */
+  async generateResponse(messages, session) {
+    this.ctx.logger.debug(`向Claude发送请求，消息数: ${messages.length}`)
+    
+    try {
+      // 格式化消息为Claude格式
+      const { systemMessage, messages: claudeMessages } = this.formatMessages(messages)
+      
+      // 设置超时
+      const timeout = 60000 // 60秒超时
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), timeout)
+      
+      // 构建API请求
+      const response = await fetch(`${this.apiEndpoint}/messages`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+          model: this.modelName,
+          messages: claudeMessages,
+          system: systemMessage,
+          temperature: this.temperature,
+          max_tokens: 4000,
+          metadata: {
+            user_id: session.userId
+          }
+        }),
+        signal: controller.signal
+      })
+      
+      // 清除超时定时器
+      clearTimeout(timeoutId)
+      
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}))
+        this.ctx.logger.error(`Claude API请求失败: ${response.status} ${response.statusText}`, error)
+        throw new Error(`API请求失败: ${response.status} ${response.statusText}${error.error ? ': ' + error.error : ''}`)
+      }
+      
+      const data = await response.json()
+      
+      // 检查响应格式
+      if (!data.content || !data.content[0] || !data.content[0].text) {
+        this.ctx.logger.error('Claude返回了无效的响应格式', data)
+        throw new Error('收到无效的API响应')
+      }
+      
+      // 记录使用情况
+      if (data.usage) {
+        this.ctx.logger.debug(`使用了 ${data.usage.input_tokens} 输入令牌和 ${data.usage.output_tokens} 输出令牌`)
+      }
+      
+      return data.content[0].text.trim()
+    } catch (error) {
+      this.ctx.logger.error('Claude请求失败:', error)
+      if (error.name === 'AbortError') {
+        throw new Error('请求超时，请稍后再试')
+      } else if (error.message.includes('429')) {
+        throw new Error('请求过于频繁，请稍后再试')
+      } else if (error.message.includes('401')) {
+        throw new Error('API密钥无效或已过期')
+      } else if (error.message.includes('quota')) {
+        throw new Error('API配额已用尽')
+      }
+      throw error
+    }
+  }
+  
+  /**
+   * 当插件卸载时清理资源
+   */
+  async dispose() {
+    // Claude适配器不需要特别的清理工作
+    this.ctx.logger.debug('Claude适配器资源已清理')
+  }
+}
+
+module.exports = ClaudeAdapter 

package/lib/gemini-adapter.js

@@ -0,0 +1,171 @@
+const fetch = require('node-fetch')
+const AbortController = require('abort-controller')
+
+class GeminiAdapter {
+  constructor(ctx, config) {
+    this.ctx = ctx
+    this.config = config
+    this.apiKey = config.apiKey
+    this.apiEndpoint = config.apiEndpoint || 'https://generativelanguage.googleapis.com/v1beta'
+    
+    // Gemini模型映射
+    const modelMap = {
+      'gemini-pro': 'gemini-pro',
+      'gemini-1.5-pro': 'gemini-1.5-pro',
+      'gemini-1.5-flash': 'gemini-1.5-flash'
+    }
+    
+    this.modelName = modelMap[config.modelName] || config.modelName || 'gemini-pro'
+    this.temperature = config.temperature ?? 0.7
+    
+    // 验证必要参数
+    if (!this.apiKey) {
+      ctx.logger.error('Gemini API密钥未设置')
+      throw new Error('Gemini API密钥未设置')
+    }
+    
+    ctx.logger.info(`Gemini适配器已初始化，使用模型: ${this.modelName}`)
+  }
+  
+  /**
+   * 将Koishi消息格式转换为Gemini格式
+   * @param {Array} koishiMessages - Koishi格式的消息数组
+   * @returns {Array} - Gemini API格式的消息数组
+   */
+  formatMessages(koishiMessages) {
+    // 获取system message (如果有)
+    const systemMessage = koishiMessages.find(msg => msg.role === 'system')?.content || ''
+    
+    // 将系统消息作为用户的第一条消息(Gemini不直接支持system role)
+    let geminiMessages = []
+    
+    if (systemMessage) {
+      geminiMessages.push({
+        role: 'user',
+        parts: [{ text: `系统指令: ${systemMessage}` }]
+      })
+      
+      // 如果只有系统消息，添加一个模型回复，否则会报错
+      geminiMessages.push({
+        role: 'model',
+        parts: [{ text: '我明白了，我会按照指示行动。有什么可以帮助你的吗？' }]
+      })
+    }
+    
+    // 添加用户和助手的消息
+    for (let i = 0; i < koishiMessages.length; i++) {
+      const msg = koishiMessages[i]
+      
+      // 跳过system消息，因为已经处理过了
+      if (msg.role === 'system') continue
+      
+      geminiMessages.push({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: [{ text: msg.content }]
+      })
+    }
+    
+    // 确保消息数组是以用户消息开始，并交替出现
+    if (geminiMessages.length === 0 || geminiMessages[0].role !== 'user') {
+      this.ctx.logger.warn('消息格式不正确，已调整为Gemini的要求')
+      // 添加一个空的用户消息
+      geminiMessages.unshift({
+        role: 'user',
+        parts: [{ text: '你好' }]
+      })
+    }
+    
+    return geminiMessages
+  }
+  
+  /**
+   * 生成回复
+   * @param {Array} messages - 对话历史消息
+   * @param {Object} session - Koishi会话对象
+   * @returns {Promise<string>} - 生成的回复文本
+   */
+  async generateResponse(messages, session) {
+    this.ctx.logger.debug(`向Gemini发送请求，消息数: ${messages.length}`)
+    
+    try {
+      // 格式化消息为Gemini格式
+      const geminiMessages = this.formatMessages(messages)
+      
+      // 设置超时
+      const timeout = 60000 // 60秒超时
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), timeout)
+      
+      // 构建API请求URL
+      const apiUrl = `${this.apiEndpoint}/models/${this.modelName}:generateContent?key=${this.apiKey}`
+      
+      const response = await fetch(apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          contents: geminiMessages,
+          generationConfig: {
+            temperature: this.temperature,
+            maxOutputTokens: 2048,
+            topP: 0.95,
+            topK: 40
+          }
+        }),
+        signal: controller.signal
+      })
+      
+      // 清除超时定时器
+      clearTimeout(timeoutId)
+      
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}))
+        this.ctx.logger.error(`Gemini API请求失败: ${response.status} ${response.statusText}`, error)
+        throw new Error(`API请求失败: ${response.status} ${response.statusText}${error.error ? ': ' + error.error.message : ''}`)
+      }
+      
+      const data = await response.json()
+      
+      // 检查响应格式
+      if (!data.candidates || !data.candidates[0] || !data.candidates[0].content || !data.candidates[0].content.parts) {
+        this.ctx.logger.error('Gemini返回了无效的响应格式', data)
+        throw new Error('收到无效的API响应')
+      }
+      
+      // 如果响应中包含屏蔽标记，返回相应提示
+      if (data.candidates[0].finishReason === 'SAFETY') {
+        return '抱歉，您的请求触发了内容安全策略，我无法提供相关内容。'
+      }
+      
+      // 记录使用情况
+      if (data.usageMetadata) {
+        this.ctx.logger.debug(`使用了 ${data.usageMetadata.promptTokenCount} 提示令牌和 ${data.usageMetadata.candidatesTokenCount} 回复令牌`)
+      }
+      
+      return data.candidates[0].content.parts[0].text.trim()
+    } catch (error) {
+      this.ctx.logger.error('Gemini请求失败:', error)
+      if (error.name === 'AbortError') {
+        throw new Error('请求超时，请稍后再试')
+      } else if (error.message.includes('429')) {
+        throw new Error('请求过于频繁，请稍后再试')
+      } else if (error.message.includes('400') && error.message.includes('Invalid API key')) {
+        throw new Error('API密钥无效')
+      } else if (error.message.includes('quota')) {
+        throw new Error('API配额已用尽')
+      }
+      throw error
+    }
+  }
+  
+  /**
+   * 当插件卸载时清理资源
+   */
+  async dispose() {
+    // Gemini适配器不需要特别的清理工作
+    this.ctx.logger.debug('Gemini适配器资源已清理')
+  }
+}
+
+module.exports = GeminiAdapter 

package/lib/openai-adapter.js

@@ -0,0 +1,100 @@
+const fetch = require('node-fetch')
+const AbortController = require('abort-controller')
+
+class OpenAIAdapter {
+  constructor(ctx, config) {
+    this.ctx = ctx
+    this.config = config
+    this.apiKey = config.apiKey
+    this.apiEndpoint = config.apiEndpoint || 'https://api.openai.com/v1'
+    this.modelName = config.modelName || 'gpt-3.5-turbo'
+    this.temperature = config.temperature ?? 0.7
+    
+    // 验证必要参数
+    if (!this.apiKey) {
+      ctx.logger.error('OpenAI API密钥未设置')
+      throw new Error('OpenAI API密钥未设置')
+    }
+    
+    ctx.logger.info(`OpenAI适配器已初始化，使用模型: ${this.modelName}`)
+  }
+  
+  /**
+   * 生成回复
+   * @param {Array} messages - 对话历史消息
+   * @param {Object} session - Koishi会话对象
+   * @returns {Promise<string>} - 生成的回复文本
+   */
+  async generateResponse(messages, session) {
+    this.ctx.logger.debug(`向OpenAI发送请求，消息数: ${messages.length}`)
+    
+    try {
+      // 设置超时
+      const timeout = 60000 // 60秒超时
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), timeout)
+      
+      // 构建API请求
+      const response = await fetch(`${this.apiEndpoint}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.modelName,
+          messages: messages,
+          temperature: this.temperature,
+          user: session.userId, // 传递用户ID以便OpenAI分析滥用情况
+        }),
+        signal: controller.signal
+      })
+      
+      // 清除超时定时器
+      clearTimeout(timeoutId)
+      
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}))
+        this.ctx.logger.error(`OpenAI API请求失败: ${response.status} ${response.statusText}`, error)
+        throw new Error(`API请求失败: ${response.status} ${response.statusText}${error.error?.message ? ': ' + error.error.message : ''}`)
+      }
+      
+      const data = await response.json()
+      
+      // 检查响应格式
+      if (!data.choices || !data.choices[0] || !data.choices[0].message) {
+        this.ctx.logger.error('OpenAI返回了无效的响应格式', data)
+        throw new Error('收到无效的API响应')
+      }
+      
+      // 记录令牌使用情况
+      if (data.usage) {
+        this.ctx.logger.debug(`使用了 ${data.usage.total_tokens} 个令牌 (提示: ${data.usage.prompt_tokens}, 完成: ${data.usage.completion_tokens})`)
+      }
+      
+      return data.choices[0].message.content.trim()
+    } catch (error) {
+      this.ctx.logger.error('OpenAI请求失败:', error)
+      if (error.name === 'AbortError') {
+        throw new Error('请求超时，请稍后再试')
+      } else if (error.message.includes('429')) {
+        throw new Error('请求过于频繁，请稍后再试')
+      } else if (error.message.includes('401')) {
+        throw new Error('API密钥无效或已过期')
+      } else if (error.message.includes('insufficient_quota')) {
+        throw new Error('API配额已用尽')
+      }
+      throw error
+    }
+  }
+  
+  /**
+   * 当插件卸载时清理资源
+   */
+  async dispose() {
+    // OpenAI适配器不需要特别的清理工作
+    this.ctx.logger.debug('OpenAI适配器资源已清理')
+  }
+}
+
+module.exports = OpenAIAdapter 

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "koishi-plugin-chat-model",
+  "description": "在没有命令匹配时自动调用大型语言模型进行对话，支持OpenAI、Claude、Gemini等",
+  "version": "1.0.0",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "ai",
+    "openai",
+    "gpt",
+    "claude",
+    "gemini",
+    "llm"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.13.0"
+  },
+  "dependencies": {
+    "abort-controller": "^3.0.0",
+    "node-fetch": "^2.6.9"
+  },
+  "koishi": {
+    "description": {
+      "zh": "当消息没有触发其他命令时，使用大型语言模型进行对话，支持记忆上下文",
+      "en": "Use LLM for conversations when messages don't match other commands, with context memory"
+    },
+    "locales": {
+      "zh": {
+        "name": "对话模型",
+        "description": "当消息没有触发其他命令时，使用大型语言模型进行对话，支持记忆上下文"
+      },
+      "en": {
+        "name": "Chat Model",
+        "description": "Use LLM for conversations when messages don't match other commands, with context memory"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/koishi-plugin-chat-model.git"
+  },
+  "author": "YourName"
+}