koishi-plugin-openai-compatible 1.0.5 → 1.0.6

package/README.md

@@ -1,60 +1,161 @@
 # koishi-plugin-openai-compatible
 
-A Koishi plugin for interacting with OpenAI-compatible APIs.
+一个支持所有兼容 OpenAI API 的 Koishi 插件，提供完整的 AI 对话功能，包括黑名单、请求冷却、自定义指令和情绪分析等高级功能。
 
-## 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.
+## 功能特性
+
+- ✅ 支持所有兼容 OpenAI 的 API（OpenAI、Azure OpenAI、各类国产大模型等）
+- ✅ 可配置 API 端点、模型和参数
+- ✅ 可设置自定义系统提示词
+- ✅ 支持黑名单功能，阻止特定用户使用
+- ✅ 支持请求冷却配置，防止滥用
+- ✅ 支持自定义指令名
+- ✅ 支持控制是否开启提示（关闭后所有错误提示都不会输出）
+- ✅ 支持情绪分析功能（可选）
+  - 分析 AI 输出内容的情绪
+  - 自动添加对应的情绪表情包
+  - 支持自定义情绪与表情包的映射
+
+## 安装
 
-## Installation
 ```bash
+# 使用 npm
 npm install koishi-plugin-openai-compatible
+
+# 或使用 yarn
+yarn add koishi-plugin-openai-compatible
+
+# 或使用 pnpm
+pnpm add koishi-plugin-openai-compatible
+```
+
+## 配置
+
+在 Koishi 配置文件中启用插件并配置：
+
+```yaml
+plugins:
+  openai-compatible:
+    # API 配置
+    endpoint: 'https://api.openai.com/v1/chat/completions'
+    apiKey: 'your-api-key-here'
+    model: 'gpt-3.5-turbo'
+
+    # 情绪分析配置
+    enableEmotion: false  # 是否启用情绪分析
+    emotionEndpoint: 'https://api.openai.com/v1/chat/completions'
+    emotionApiKey: 'your-emotion-api-key'
+    emotionModel: 'gpt-3.5-turbo'  # 推荐使用较快的模型
+    emotionImages:
+      '快乐': 'https://example.com/happy.gif'
+      '伤心': 'https://example.com/sad.gif'
+      '生气': 'https://example.com/angry.gif'
+
+    # 提示词配置
+    systemPrompt: '你是一个友好的 AI 助手。'
+    emotionSystemPrompt: '分析文本的情绪，只返回情绪名称。'
+
+    # 参数配置
+    temperature: 0.7
+    maxTokens: 2000
+    topP: 1
+    frequencyPenalty: 0
+    presencePenalty: 0
+
+    # 黑名单和冷却
+    blacklist: []
+    cooldown: 10000  # 10 秒
+
+    # 命令名和提示
+    commandName: 'ai'
+    enableMessage: true  # 是否开启提示（关闭后所有错误提示都不会输出）
+```
+
+### 情绪分析配置
+
+启用情绪分析功能时，需要注意：
+
+1. **推荐使用较快的模型**：情绪分析需要额外一次 API 调用，建议使用响应速度快的模型（如 `gpt-3.5-turbo`）
+2. **配置情绪映射**：在 `emotionImages` 中配置情绪名称与表情包图片链接的映射
+3. **系统提示词**：插件内置了严格的系统提示词，确保情绪分析模型只返回情绪名称
+
+### 情绪类型
+
+支持的情绪类型：
+- 快乐、开心、高兴
+- 伤心、难过、悲伤
+- 生气、愤怒
+- 惊讶
+- 疑惑
+- 害怕、恐惧
+- 平静、中立
+
+## 使用方法
+
+### 基本对话
+
 ```
+.ai 你好
+.ai 解释什么是量子力学
+.ai 写一首关于春天的诗
+```
+
+### 管理命令
+
+需要管理员权限：
+
+```
+# 黑名单管理
+.ai.admin.add <userId>        # 添加用户到黑名单
+.ai.admin.remove <userId>     # 从黑名单移除用户
+.ai.admin.list                # 查看黑名单
+
+# 冷却管理
+.ai.admin.clearcooldown <userId>  # 清除用户冷却时间
+
+# 状态查看
+.ai.admin.status              # 查看插件状态
+```
+
+## API 兼容性
+
+本插件支持所有兼容 OpenAI API 格式的服务：
+
+- OpenAI 官方 API
+- Azure OpenAI
+- 通义千问（通过兼容 API）
+- 智谱 AI（通过兼容 API）
+- 百度文心一言（通过兼容 API）
+- 其他兼容 OpenAI API 格式的服务
+
+### 使用自定义 API 示例
+
+```yaml
+plugins:
+  openai-compatible:
+    endpoint: 'https://your-custom-api.com/v1/chat/completions'
+    apiKey: 'your-api-key'
+    model: 'your-model-name'
+```
+
+## 注意事项
+
+1. **API Key 安全**：请妥善保管您的 API Key，不要泄露给他人
+2. **成本控制**：建议设置合理的冷却时间和令牌限制，避免产生高额费用
+3. **情绪分析成本**：启用情绪分析会使每次请求的成本增加约一倍
+4. **黑名单管理**：定期检查黑名单，及时移除已解除限制的用户
+5. **提示控制**：关闭提示功能后，用户将不会收到任何错误提示（包括黑名单、冷却、输入为空、请求失败等），适用于需要静默处理的场景
+
+## 开发
+
+```bash
+# 安装依赖
+npm install
+
+# 构建项目
+npm run build
+```
+
+## 许可证
 
-## 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
+MIT License

package/lib/api.d.ts

@@ -0,0 +1,7 @@
+import type { ChatCompletionRequest } from './types';
+export declare class OpenAICompatibleAPI {
+    private endpoint;
+    private apiKey;
+    constructor(endpoint: string, apiKey: string);
+    chatCompletion(request: ChatCompletionRequest): Promise<string>;
+}

package/lib/api.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleAPI = void 0;
+class OpenAICompatibleAPI {
+    constructor(endpoint, apiKey) {
+        this.endpoint = endpoint;
+        this.apiKey = apiKey;
+    }
+    async chatCompletion(request) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API 请求失败: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.choices || data.choices.length === 0) {
+            throw new Error('API 返回了空的选择列表');
+        }
+        return data.choices[0].message.content;
+    }
+}
+exports.OpenAICompatibleAPI = OpenAICompatibleAPI;

package/lib/config.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from 'koishi';
+export interface Config {
+    endpoint: string;
+    apiKey: string;
+    model: string;
+    enableEmotion: boolean;
+    emotionEndpoint: string;
+    emotionApiKey: string;
+    emotionModel: string;
+    emotionImages: Record<string, string>;
+    systemPrompt: string;
+    emotionSystemPrompt: string;
+    temperature: number;
+    maxTokens: number;
+    topP: number;
+    frequencyPenalty: number;
+    presencePenalty: number;
+    blacklist: string[];
+    cooldown: number;
+    commandName: string;
+    enableMessage: boolean;
+}
+export declare const Config: Schema<Config>;

package/lib/config.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const koishi_1 = require("koishi");
+exports.Config = koishi_1.Schema.intersect([
+    koishi_1.Schema.object({
+        endpoint: koishi_1.Schema.string().default('https://api.openai.com/v1/chat/completions'),
+        apiKey: koishi_1.Schema.string().default('').description('OpenAI API Key'),
+        model: koishi_1.Schema.string().default('gpt-3.5-turbo'),
+    }).description('API 配置'),
+    koishi_1.Schema.object({
+        enableEmotion: koishi_1.Schema.boolean().default(false).description('是否启用情绪分析'),
+        emotionEndpoint: koishi_1.Schema.string().default('https://api.openai.com/v1/chat/completions'),
+        emotionApiKey: koishi_1.Schema.string().default('').description('情绪分析 API Key'),
+        emotionModel: koishi_1.Schema.string().default('gpt-3.5-turbo').description('推荐使用较快的模型'),
+        emotionImages: koishi_1.Schema.dict(koishi_1.Schema.string().description('情绪表情包图片链接')).default({
+            '快乐': 'https://example.com/happy.gif',
+            '开心': 'https://example.com/happy.gif',
+            '高兴': 'https://example.com/happy.gif',
+            '伤心': 'https://example.com/sad.gif',
+            '难过': 'https://example.com/sad.gif',
+            '悲伤': 'https://example.com/sad.gif',
+            '生气': 'https://example.com/angry.gif',
+            '愤怒': 'https://example.com/angry.gif',
+            '惊讶': 'https://example.com/surprised.gif',
+            '疑惑': 'https://example.com/confused.gif',
+            '害怕': 'https://example.com/afraid.gif',
+            '恐惧': 'https://example.com/afraid.gif',
+            '平静': 'https://example.com/calm.gif',
+            '中立': 'https://example.com/neutral.gif',
+        }).description('情绪名称对应的表情包图片链接'),
+    }).description('情绪分析配置'),
+    koishi_1.Schema.object({
+        systemPrompt: koishi_1.Schema.string()
+            .default('你是一个友好的 AI 助手，请用简洁、准确的语言回答用户的问题。')
+            .description('系统提示词'),
+        emotionSystemPrompt: koishi_1.Schema.string()
+            .default('你是一个情绪分析助手。分析给定的文本内容，并判断其中表达的情绪。\n\n情绪类型包括：快乐、开心、高兴、伤心、难过、悲伤、生气、愤怒、惊讶、疑惑、害怕、恐惧、平静、中立。\n\n请直接输出一个情绪名称，不要输出任何其他内容，不要解释，不要添加标点符号。\n\n例如：\n- "今天天气真好，我很开心！" -> 快乐\n- "这次考试失败了，我好难过。" -> 伤心\n- "什么？这太不可思议了！" -> 惊讶\n- "我不知道该怎么办。" -> 疑惑\n- "这真是太可怕了！" -> 害怕\n- "一切都很平静。" -> 平静')
+            .description('情绪分析系统提示词'),
+    }).description('提示词配置'),
+    koishi_1.Schema.object({
+        temperature: koishi_1.Schema.number().min(0).max(2).default(0.7).description('温度参数'),
+        maxTokens: koishi_1.Schema.number().min(1).default(2000).description('最大令牌数'),
+        topP: koishi_1.Schema.number().min(0).max(1).default(1).description('Top P 参数'),
+        frequencyPenalty: koishi_1.Schema.number().min(-2).max(2).default(0).description('频率惩罚'),
+        presencePenalty: koishi_1.Schema.number().min(-2).max(2).default(0).description('存在惩罚'),
+    }).description('参数配置'),
+    koishi_1.Schema.object({
+        blacklist: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('黑名单用户 ID'),
+        cooldown: koishi_1.Schema.number().min(0).default(10000).description('请求冷却时间（毫秒）'),
+        commandName: koishi_1.Schema.string().default('ai').description('自定义指令名称'),
+        enableMessage: koishi_1.Schema.boolean().default(true).description('是否开启提示（关闭后所有错误提示都不会输出）'),
+    }).description('其他配置'),
+]);

package/lib/emotion.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAICompatibleAPI } from './api';
+import type { Config } from './config';
+export declare class EmotionAnalyzer {
+    private api;
+    private config;
+    constructor(api: OpenAICompatibleAPI, config: Config);
+    analyzeEmotion(text: string): Promise<string>;
+    getEmotionImage(emotion: string): string | null;
+}

package/lib/emotion.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmotionAnalyzer = void 0;
+class EmotionAnalyzer {
+    constructor(api, config) {
+        this.api = api;
+        this.config = config;
+    }
+    async analyzeEmotion(text) {
+        const request = {
+            model: this.config.emotionModel,
+            messages: [
+                { role: 'system', content: this.config.emotionSystemPrompt },
+                { role: 'user', content: text },
+            ],
+            temperature: 0.3,
+            max_tokens: 50,
+        };
+        try {
+            const emotion = await this.api.chatCompletion(request);
+            return emotion.trim();
+        }
+        catch (error) {
+            console.error('情绪分析失败:', error);
+            return '';
+        }
+    }
+    getEmotionImage(emotion) {
+        return this.config.emotionImages[emotion] || null;
+    }
+}
+exports.EmotionAnalyzer = EmotionAnalyzer;

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'koishi';
+import type { Config } from './config';
+export declare const name = "openai-compatible";
+export declare const inject: {
+    required: never[];
+    optional: never[];
+};
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,157 @@
+"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: [],
+};
+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;
+        }
+        // 检查冷却时间
+        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 = [
+                { 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 插件已加载');
+}

package/lib/locales/zh.d.ts

@@ -0,0 +1,44 @@
+declare const _default: {
+    commands: {
+        ai: {
+            name: string;
+            description: string;
+            input: string;
+            cooldown: string;
+            blacklist: string;
+            error: string;
+        };
+        admin: {
+            add: {
+                description: string;
+                success: string;
+            };
+            remove: {
+                description: string;
+                success: string;
+                notFound: string;
+            };
+            list: {
+                description: string;
+                empty: string;
+                title: string;
+            };
+            clearcooldown: {
+                description: string;
+                success: string;
+            };
+            status: {
+                description: string;
+                title: string;
+                model: string;
+                endpoint: string;
+                emotion: string;
+                enabled: string;
+                disabled: string;
+                cooldown: string;
+                blacklistCount: string;
+            };
+        };
+    };
+};
+export default _default;

package/lib/locales/zh.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    commands: {
+        ai: {
+            name: 'AI 对话',
+            description: '与 AI 进行对话',
+            input: '请输入要聊天的内容。',
+            cooldown: '请求过于频繁，请等待 {0} 秒后再试。',
+            blacklist: '您在黑名单中，无法使用此功能。',
+            error: '请求失败: {0}',
+        },
+        admin: {
+            add: {
+                description: '添加黑名单',
+                success: '已将用户 {0} 添加到黑名单。',
+            },
+            remove: {
+                description: '移除黑名单',
+                success: '已将用户 {0} 从黑名单中移除。',
+                notFound: '用户 {0} 不在黑名单中。',
+            },
+            list: {
+                description: '查看黑名单',
+                empty: '黑名单为空。',
+                title: '黑名单列表:',
+            },
+            clearcooldown: {
+                description: '清除用户冷却',
+                success: '已清除用户 {0} 的冷却时间。',
+            },
+            status: {
+                description: '查看插件状态',
+                title: '插件状态:',
+                model: '模型: {0}',
+                endpoint: '端点: {0}',
+                emotion: '情绪分析: {0}',
+                enabled: '已启用',
+                disabled: '未启用',
+                cooldown: '冷却时间: {0} 秒',
+                blacklistCount: '黑名单数量: {0}',
+            },
+        },
+    },
+};

package/lib/storage.d.ts

@@ -0,0 +1,10 @@
+export interface CooldownData {
+    lastRequestTime: number;
+}
+export declare class Storage {
+    private cooldowns;
+    getCooldown(userId: string): CooldownData | undefined;
+    setCooldown(userId: string, data: CooldownData): void;
+    deleteCooldown(userId: string): void;
+    isOnCooldown(userId: string, cooldownTime: number): boolean;
+}

package/lib/storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+class Storage {
+    constructor() {
+        this.cooldowns = new Map();
+    }
+    getCooldown(userId) {
+        return this.cooldowns.get(userId);
+    }
+    setCooldown(userId, data) {
+        this.cooldowns.set(userId, data);
+    }
+    deleteCooldown(userId) {
+        this.cooldowns.delete(userId);
+    }
+    isOnCooldown(userId, cooldownTime) {
+        const data = this.getCooldown(userId);
+        if (!data)
+            return false;
+        const elapsed = Date.now() - data.lastRequestTime;
+        return elapsed < cooldownTime;
+    }
+}
+exports.Storage = Storage;