koishi-plugin-openai-compatible 1.0.3 → 1.0.4

package/README.md

@@ -1,106 +1,60 @@
 # koishi-plugin-openai-compatible
 
-[![npm](https://img.shields.io/npm/v/koishi-plugin-openai-compatible?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-openai-compatible)
+A Koishi plugin for interacting with OpenAI-compatible APIs.
 
-这是一个适用于Koishi的OpenAI兼容聊天插件，支持与所有兼容OpenAI API的大模型进行聊天交互。
-
-## 特性
-
-- 兼容所有支持OpenAI协议的AI聊天服务
-- 可自定义API端点、模型名称等参数
-- 支持系统预设提示词
-- 支持为特定用户设置专属预设提示词
-- 可选的自定义指令名
-- 支持会话上下文记忆
-- 自动清理过期的聊天历史
-- 提供管理命令，方便管理用户预设和历史记录
-
-## 安装
+## Features
+- Supports all OpenAI-compatible APIs.
+- Configurable API endpoint, model, and parameters.
+- Customizable prompts (system, user-specific, and thinking prompts).
+- Blacklist support for blocking specific users.
+- Flexible command or message-based interaction.
 
+## Installation
 ```bash
 npm install koishi-plugin-openai-compatible
 ```
 
-或者在Koishi插件市场中搜索"openai-compatible"安装。
-
-## 配置项
-
-| 配置项 | 类型 | 默认值 | 说明 |
-|-------|------|-------|------|
-| apiEndpoint | string | https://api.openai.com/v1 | API端点URL |
-| apiKey | string | - | API密钥 |
-| model | string | gpt-3.5-turbo | 使用的模型名称 |
-| temperature | number | 0.7 | 温度参数，控制回复的随机性 (0-2) |
-| maxTokens | number | 2000 | 最大生成的token数量 |
-| systemPrompt | string | 你是一个有用的AI助手。 | 系统预设提示词（可选） |
-| commandName | string | - | 自定义指令名（可选，如不设置则默认处理所有消息） |
-| triggerPrefix | string | - | 触发前缀（可选，仅在未设置commandName时有效） |
-| userPrompts | object | {} | 特定用户的预设提示词（可选，格式为 {"用户ID": "预设提示词"}） |
-| thinkingPrompt | string | - | 思考提示词（可选，留空则不显示思考提示） |
-
-## 使用方法
-
-### 方式一：使用自定义指令
-
-如果在配置中设置了`commandName`（例如"chat"），则可以通过以下方式使用：
-
-```
-/chat 今天天气怎么样？
-```
-
-### 方式二：处理所有消息
-
-如果未设置`commandName`，则插件会处理所有接收到的消息。可以通过设置`triggerPrefix`来过滤需要处理的消息，例如设置为"@AI "，则只有以"@AI "开头的消息会被处理：
-
-```
-@AI 今天天气怎么样？
-```
-
-如果`triggerPrefix`也未设置，则所有消息都会被处理。
-
-## 支持的服务
-
-本插件可以连接到任何兼容OpenAI API的服务，包括但不限于：
-
-- OpenAI官方API
-- Azure OpenAI服务
-- Claude API（通过兼容层）
-- 本地部署的开源模型（如通过LM Studio、ollama等提供的兼容API）
-- 各种云服务提供的兼容OpenAI的API端点
-
-## 管理命令
-
-插件提供了一系列管理命令，用于管理用户预设和聊天历史：
-
-### 设置用户预设
-
-为特定用户设置专属的系统提示词：
-
-```
-/openai-admin.set-user-prompt <用户ID> <预设提示词>
-```
-
-例如：
-```
-/openai-admin.set-user-prompt 123456 你是一个专业的翻译助手，擅长中英文互译。
-```
-
-### 移除用户预设
-
-移除特定用户的专属系统提示词：
-
-```
-/openai-admin.remove-user-prompt <用户ID>
-```
-
-### 清除用户历史
-
-清除特定用户的聊天历史记录：
-
-```
-/openai-admin.clear-history <用户ID>
-```
-
-## 许可证
-
+## Configuration
+```ts
+export interface Config {
+  apiEndpoint: string
+  apiKey: string
+  model: string
+  temperature?: number
+  maxTokens?: number
+  systemPrompt?: string
+  commandName?: string
+  triggerPrefix?: string
+  userPrompts?: Record<string, string>
+  thinkingPrompt?: string
+  blacklist?: string[]
+  blacklistResponse?: string
+}
+```
+
+## Usage
+1. **Command Mode**: If `commandName` is set, use `/commandName your question`.
+2. **Message Mode**: If no `commandName` is set, all messages trigger the plugin (filtered by `triggerPrefix` if set).
+
+## Example
+```ts
+// koishi.config.ts
+import OpenAICompatible from 'koishi-plugin-openai-compatible'
+
+export default {
+  plugins: {
+    'openai-compatible': {
+      apiEndpoint: 'https://api.openai.com/v1',
+      apiKey: 'your-api-key',
+      model: 'gpt-3.5-turbo',
+      temperature: 1,
+      maxTokens: 2048,
+      systemPrompt: 'You are a helpful assistant.',
+      commandName: 'chat',
+    },
+  },
+}
+```
+
+## License
 MIT

package/dist/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+exports.name = 'openai-compatible';
+exports.Config = koishi_1.Schema.object({
+    apiEndpoint: koishi_1.Schema.string().required().description('API endpoint URL, e.g., "https://api.openai.com/v1"'),
+    apiKey: koishi_1.Schema.string().required().description('API key'),
+    model: koishi_1.Schema.string().required().description('Model name, e.g., "gpt-3.5-turbo"'),
+    temperature: koishi_1.Schema.number().min(0).max(2).default(1).description('Controls randomness of responses (0-2)'),
+    maxTokens: koishi_1.Schema.number().min(1).default(2048).description('Maximum number of tokens to generate'),
+    systemPrompt: koishi_1.Schema.string().description('System prompt (optional)'),
+    commandName: koishi_1.Schema.string().description('Custom command name (optional)'),
+    triggerPrefix: koishi_1.Schema.string().description('Trigger prefix (optional, used when no commandName is set)'),
+    userPrompts: koishi_1.Schema.dict(koishi_1.Schema.string()).description('User-specific prompts (optional)'),
+    thinkingPrompt: koishi_1.Schema.string().description('Thinking prompt (optional)'),
+    blacklist: koishi_1.Schema.array(koishi_1.Schema.string()).description('List of blacklisted user IDs (optional)'),
+    blacklistResponse: koishi_1.Schema.string().description('Response for blacklisted users (text or image URL)'),
+});
+function apply(ctx, config) {
+    const { apiEndpoint, apiKey, model, temperature, maxTokens, systemPrompt, commandName, triggerPrefix, userPrompts, thinkingPrompt, blacklist, blacklistResponse } = config;
+    // Register command if commandName is provided
+    if (commandName) {
+        ctx.command(commandName, 'Chat with OpenAI-compatible API')
+            .action(async ({ session }, ...args) => {
+            if (!session || !session.userId || blacklist?.includes(session.userId)) {
+                return blacklistResponse || 'You are not allowed to use this command.';
+            }
+            const userPrompt = !session || !session.userId ? '' : userPrompts?.[session.userId] || '';
+            const prompt = args.join(' ');
+            const fullPrompt = systemPrompt ? `${systemPrompt}\n${userPrompt}\n${prompt}` : `${userPrompt}\n${prompt}`;
+            if (thinkingPrompt) {
+                if (session)
+                    session.send(thinkingPrompt);
+            }
+            try {
+                const response = await ctx.http.post(`${apiEndpoint}/chat/completions`, {
+                    model,
+                    messages: [
+                        { role: 'user', content: fullPrompt },
+                    ],
+                    temperature,
+                    max_tokens: maxTokens,
+                }, {
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                return response.choices[0].message.content;
+            }
+            catch (error) {
+                ctx.logger.error('OpenAI API error:', error);
+                return 'Failed to get response from the API.';
+            }
+        });
+    }
+    else {
+        // Handle all messages if no commandName is provided
+        ctx.middleware(async (session, next) => {
+            if (!session || !session.userId || blacklist?.includes(session.userId)) {
+                return blacklistResponse || 'You are not allowed to use this command.';
+            }
+            const content = session.content;
+            if (!content || (triggerPrefix && !content.startsWith(triggerPrefix)))
+                return next();
+            const userPrompt = !session || !session.userId ? '' : userPrompts?.[session.userId] || '';
+            const prompt = !content ? '' : triggerPrefix ? content.slice(triggerPrefix.length) : content;
+            const fullPrompt = systemPrompt ? `${systemPrompt}\n${userPrompt}\n${prompt}` : `${userPrompt}\n${prompt}`;
+            if (thinkingPrompt) {
+                if (session)
+                    session.send(thinkingPrompt);
+            }
+            try {
+                const response = await ctx.http.post(`${apiEndpoint}/chat/completions`, {
+                    model,
+                    messages: [
+                        { role: 'user', content: fullPrompt },
+                    ],
+                    temperature,
+                    max_tokens: maxTokens,
+                }, {
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                return response.choices[0].message.content;
+            }
+            catch (error) {
+                ctx.logger.error('OpenAI API error:', error);
+                return 'Failed to get response from the API.';
+            }
+        });
+    }
+}

package/package.json

@@ -1,43 +1,19 @@
 {
-    "name": "koishi-plugin-openai-compatible",
-    "version": "1.0.3",
-    "description": "这是一个适用于Koishi的OpenAI兼容聊天插件，支持与所有兼容OpenAI API的大模型进行聊天交互。",
-    "main": "lib/index.js",
-    "scripts": {
-      "build": "tsc",
-      "test": "echo \"Error: no test specified\" && exit 1"
-    },
-    "keywords": [
-      "koishi",
-      "plugin",
-      "openai",
-      "chat",
-      "ai"
-    ],
-    "author": "",
-    "license": "MIT",
-    "type": "commonjs",
-    "dependencies": {
-      "@koishijs/plugin-help": "^2.4.5",
-      "koishi": "^4.0.0"
-    },
-    "peerDependencies": {
-      "koishi": "^4.0.0"
-    },
-    "koishi": {
-      "description": {
-        "en": "Chat plugin compatible with OpenAI API",
-        "zh": "兼容OpenAI API的聊天插件"
-      },
-      "service": {
-        "required": [
-          "database"
-        ]
-      }
-    },
-    "devDependencies": {
-      "@types/node": "^24.3.1",
-      "typescript": "^5.9.2"
-    }
-  }
-  
+  "name": "koishi-plugin-openai-compatible",
+  "version": "1.0.4",
+  "description": "A Koishi plugin for OpenAI compatibility",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "koishi": "^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "keywords": ["koishi", "plugin", "openai"],
+  "author": "Your Name",
+  "license": "MIT"
+}

package/src/index.ts

@@ -1,176 +1,112 @@
-import { Context, Schema, h, Database } from 'koishi'
-import { OpenAICompatibleService } from './service'
-import { Config as ConfigInterface } from './config'
+import { Context, Schema } from 'koishi'
 
 export const name = 'openai-compatible'
-export const usage = `## 🤖 OpenAI兼容聊天插件
 
-该插件支持与所有兼容OpenAI API的大模型进行聊天交互。
+export interface Config {
+  apiEndpoint: string
+  apiKey: string
+  model: string
+  temperature?: number
+  maxTokens?: number
+  systemPrompt?: string
+  commandName?: string
+  triggerPrefix?: string
+  userPrompts?: Record<string, string>
+  thinkingPrompt?: string
+  blacklist?: string[]
+  blacklistResponse?: string
+}
 
-### 配置说明
-
-- **apiEndpoint**: API端点URL，例如 "https://api.openai.com/v1"
-- **apiKey**: API密钥
-- **model**: 使用的模型名称，例如 "gpt-3.5-turbo"
-- **temperature**: 温度参数，控制回复的随机性 (0-2)
-- **maxTokens**: 最大生成的token数量
-- **systemPrompt**: 系统预设提示词（可选）
-- **commandName**: 自定义指令名（可选，如不设置则默认处理所有消息）
-- **triggerPrefix**: 触发前缀（可选，仅在未设置commandName时有效）
-- **userPrompts**: 特定用户的预设提示词（可选，格式为 {"用户ID": "预设提示词"}）
-- **thinkingPrompt**: 思考提示词（可选，留空则不显示思考提示）
-
-### 使用方法
-
-如果设置了自定义指令名，可以通过 \`/指令名 你的问题\` 来使用。
-如果未设置指令名，则所有消息都会触发插件（可通过前缀过滤）。
-
-### 示例
-
-\`\`\`
-/chat 今天天气怎么样？
-\`\`\`
-
-或者在未设置指令名的情况下直接发送消息：
+export const Config: Schema<Config> = Schema.object({
+  apiEndpoint: Schema.string().required().description('API endpoint URL, e.g., "https://api.openai.com/v1"'),
+  apiKey: Schema.string().required().description('API key'),
+  model: Schema.string().required().description('Model name, e.g., "gpt-3.5-turbo"'),
+  temperature: Schema.number().min(0).max(2).default(1).description('Controls randomness of responses (0-2)'),
+  maxTokens: Schema.number().min(1).default(2048).description('Maximum number of tokens to generate'),
+  systemPrompt: Schema.string().description('System prompt (optional)'),
+  commandName: Schema.string().description('Custom command name (optional)'),
+  triggerPrefix: Schema.string().description('Trigger prefix (optional, used when no commandName is set)'),
+  userPrompts: Schema.dict(Schema.string()).description('User-specific prompts (optional)'),
+  thinkingPrompt: Schema.string().description('Thinking prompt (optional)'),
+  blacklist: Schema.array(Schema.string()).description('List of blacklisted user IDs (optional)'),
+  blacklistResponse: Schema.string().description('Response for blacklisted users (text or image URL)'),
+})
 
-\`\`\`
-今天天气怎么样？
-\`\`\`
-`
+export function apply(ctx: Context, config: Config) {
+  const { apiEndpoint, apiKey, model, temperature, maxTokens, systemPrompt, commandName, triggerPrefix, userPrompts, thinkingPrompt, blacklist, blacklistResponse } = config
 
-export const Config: Schema<ConfigInterface> = Schema.object({
-  apiEndpoint: Schema.string()
-    .description('API端点URL')
-    .default('https://api.openai.com/v1')
-    .required(),
-  apiKey: Schema.string()
-    .description('API密钥')
-    .role('secret')
-    .required(),
-  model: Schema.string()
-    .description('使用的模型名称')
-    .default('gpt-3.5-turbo')
-    .required(),
-  temperature: Schema.number()
-    .description('温度参数，控制回复的随机性 (0-2)')
-    .default(0.7)
-    .min(0)
-    .max(2),
-  maxTokens: Schema.number()
-    .description('最大生成的token数量')
-    .default(2000)
-    .min(1),
-  systemPrompt: Schema.string()
-    .description('系统预设提示词（可选）')
-    .default('你是一个有用的AI助手。'),
-  commandName: Schema.string()
-    .description('自定义指令名（可选，如不设置则默认处理所有消息）'),
-  triggerPrefix: Schema.string()
-    .description('触发前缀（可选，仅在未设置commandName时有效）')
-    .default(''),
-  userPrompts: Schema.dict(Schema.string())
-    .description('特定用户的预设提示词（可选，格式为 {"用户ID": "预设提示词"}）')
-    .default({}),
-  thinkingPrompt: Schema.string()
-    .description('思考提示词（可选，留空则不显示思考提示）')
-    .default(''),
-})
+  // Register command if commandName is provided
+  if (commandName) {
+    ctx.command(commandName, 'Chat with OpenAI-compatible API')
+      .action(async ({ session }, ...args) => {
+        if (!session || !session.userId || blacklist?.includes(session.userId)) {
+          return blacklistResponse || 'You are not allowed to use this command.'
+        }
+        const userPrompt = !session || !session.userId ? '' : userPrompts?.[session.userId] || ''
+        const prompt = args.join(' ')
+        const fullPrompt = systemPrompt ? `${systemPrompt}\n${userPrompt}\n${prompt}` : `${userPrompt}\n${prompt}`
 
-export function apply(ctx: Context, config: ConfigInterface) {
-  // 创建服务实例
-  const service = new OpenAICompatibleService(ctx, config)
-  
-  // 注册管理命令
-  ctx.command('ai管理', '管理AI插件')
-    .usage('管理OpenAI兼容插件的设置和用户预设')
-    .userFields(['authority'])
-    .action(({ session }) => {
-      if (session.user.authority < 3) return '权限不足'
-      return '管理功能已启用'
-    })
-    
-  // 设置用户预设命令
-  ctx.command('ai预设 <userId:string> <prompt:text>', '设置用户专属AI行为')
-    .usage('设置用户专属AI行为\n示例：ai预设 123456 你是一个专业翻译')
-    .example('ai预设 123456 你是一个专业翻译')
-    .action(async ({ session }, userId, prompt) => {
-      if (!userId || !prompt) return '请提供用户ID和预设提示词'
-      
-      service.setUserPrompt(userId, prompt)
-      return `已为用户 ${userId} 设置预设提示词`
-    })
-    
-  // 移除用户预设命令
-  ctx.command('ai清除 <userId:string>', '删除用户专属设置')
-    .usage('移除特定用户的预设提示词')
-    .example('ai清除 123456')
-    .action(async ({ session }, userId) => {
-      if (!userId) return '请提供用户ID'
-      
-      service.removeUserPrompt(userId)
-      return `已移除用户 ${userId} 的预设提示词`
-    })
-    
-  // 清除用户历史命令
-  ctx.command('ai清除记录 <userId:string>', '清除用户聊天历史')
-    .usage('清除特定用户的聊天历史')
-    .example('ai清除记录 123456')
-    .action(async ({ session }, userId) => {
-      if (!userId) return '请提供用户ID'
-      
-      service.clearHistory(userId)
-      return `已清除用户 ${userId} 的聊天历史`
-    })
+        if (thinkingPrompt) {
+          if (session) session.send(thinkingPrompt)
+        }
 
-  // 如果设置了指令名，则注册指令
-  if (config.commandName) {
-    ctx.command(config.commandName, '与AI助手对话')
-      .action(async ({ session }, text) => {
-        if (!text) return '请输入您想问的内容。'
-        
         try {
-          // 仅当配置了思考提示时才发送
-          if (config.thinkingPrompt) {
-            session.send(h.text(config.thinkingPrompt))
-          }
-          const response = await service.chat(session.userId, text)
-          return response
+          const response = await ctx.http.post(`${apiEndpoint}/chat/completions`, {
+            model,
+            messages: [
+              { role: 'user', content: fullPrompt },
+            ],
+            temperature,
+            max_tokens: maxTokens,
+          }, {
+            headers: {
+              'Authorization': `Bearer ${apiKey}`,
+              'Content-Type': 'application/json',
+            },
+          })
+
+          return response.choices[0].message.content
         } catch (error) {
-          ctx.logger('openai-compatible').error(error)
-          return `发生错误: ${error.message || '未知错误'}`
+          ctx.logger.error('OpenAI API error:', error)
+          return 'Failed to get response from the API.'
         }
       })
   } else {
-    // 如果没有设置指令名，则处理所有消息
+    // Handle all messages if no commandName is provided
     ctx.middleware(async (session, next) => {
-      // 如果是自己发送的消息，则跳过
-      if (session.userId === session.bot.selfId) return next()
-      
-      // 检查前缀
+      if (!session || !session.userId || blacklist?.includes(session.userId)) {
+        return blacklistResponse || 'You are not allowed to use this command.'
+      }
       const content = session.content
-      if (config.triggerPrefix && !content.startsWith(config.triggerPrefix)) {
-        return next()
+      if (!content || (triggerPrefix && !content.startsWith(triggerPrefix))) return next()
+
+      const userPrompt = !session || !session.userId ? '' : userPrompts?.[session.userId] || ''
+      const prompt = !content ? '' : triggerPrefix ? content.slice(triggerPrefix.length) : content
+      const fullPrompt = systemPrompt ? `${systemPrompt}\n${userPrompt}\n${prompt}` : `${userPrompt}\n${prompt}`
+
+      if (thinkingPrompt) {
+        if (session) session.send(thinkingPrompt)
       }
-      
-      // 去除前缀
-      const text = config.triggerPrefix 
-        ? content.slice(config.triggerPrefix.length).trim() 
-        : content.trim()
-      
-      if (!text) return next()
-      
+
       try {
-        // 仅当配置了思考提示时才发送
-        if (config.thinkingPrompt) {
-          await session.send(h.text(config.thinkingPrompt))
-        }
-        
-        // 获取回复
-        const response = await service.chat(session.userId, text)
-        return response
+        const response = await ctx.http.post(`${apiEndpoint}/chat/completions`, {
+          model,
+          messages: [
+            { role: 'user', content: fullPrompt },
+          ],
+          temperature,
+          max_tokens: maxTokens,
+        }, {
+          headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+        })
+
+        return response.choices[0].message.content
       } catch (error) {
-        ctx.logger('openai-compatible').error(error)
-        return `发生错误: ${error.message || '未知错误'}`
+        ctx.logger.error('OpenAI API error:', error)
+        return 'Failed to get response from the API.'
       }
     })
   }

package/tsconfig.json

@@ -1,19 +1,14 @@
 {
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "lib",
-    "target": "es2020",
+    "target": "ES2020",
     "module": "commonjs",
-    "declaration": true,
-    "composite": true,
-    "incremental": true,
-    "skipLibCheck": true,
+    "strict": true,
     "esModuleInterop": true,
-    "moduleResolution": "node",
-    "jsx": "react-jsx",
-    "jsxImportSource": "@satorijs/element"
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
   },
-  "include": [
-    "src"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
 }

package/lib/config.d.ts

@@ -1,21 +0,0 @@
-export interface Config {
-    apiEndpoint: string;
-    apiKey: string;
-    model: string;
-    temperature: number;
-    maxTokens: number;
-    systemPrompt: string;
-    commandName?: string;
-    triggerPrefix?: string;
-    userPrompts?: Record<string, string>;
-    thinkingPrompt?: string;
-}
-export interface Message {
-    role: 'system' | 'user' | 'assistant';
-    content: string;
-}
-export interface ChatHistory {
-    userId: string;
-    messages: Message[];
-    lastUpdated: number;
-}

package/lib/config.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });