koishi-plugin-openai-compatible 1.0.5 → 1.0.6

package/lib/types.d.ts

@@ -0,0 +1,32 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: Message[];
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}

package/lib/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-openai-compatible",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "这是一个适用于Koishi的OpenAI兼容聊天插件，支持与所有兼容OpenAI API的大模型进行聊天交互。",
   "main": "dist/index.js",
   "scripts": {

package/src/api.ts

@@ -0,0 +1,40 @@
+import type { ChatCompletionRequest, ChatCompletionResponse } from './types';
+
+export class OpenAICompatibleAPI {
+  private endpoint: string;
+  private apiKey: string;
+
+  constructor(endpoint: string, apiKey: string) {
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+  }
+
+  async chatCompletion(request: ChatCompletionRequest): Promise<string> {
+    const headers: Record<string, string> = {
+      '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: ChatCompletionResponse = await response.json();
+
+    if (!data.choices || data.choices.length === 0) {
+      throw new Error('API 返回了空的选择列表');
+    }
+
+    return data.choices[0].message.content;
+  }
+}

package/src/config.ts

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

package/src/emotion.ts

@@ -0,0 +1,37 @@
+import type { OpenAICompatibleAPI } from './api';
+import type { Config } from './config';
+import type { Message, ChatCompletionRequest } from './types';
+
+export class EmotionAnalyzer {
+  private api: OpenAICompatibleAPI;
+  private config: Config;
+
+  constructor(api: OpenAICompatibleAPI, config: Config) {
+    this.api = api;
+    this.config = config;
+  }
+
+  async analyzeEmotion(text: string): Promise<string> {
+    const request: ChatCompletionRequest = {
+      model: this.config.emotionModel,
+      messages: [
+        { role: 'system', content: this.config.emotionSystemPrompt } as Message,
+        { role: 'user', content: text } as Message,
+      ],
+      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: string): string | null {
+    return this.config.emotionImages[emotion] || null;
+  }
+}

package/src/index.ts

@@ -1,113 +1,171 @@
-import { Context, Schema } from 'koishi'
-
-export const name = 'openai-compatible'
-
-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
-}
+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 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 const inject = {
+  required: [],
+  optional: [],
+};
 
 export function apply(ctx: Context, config: 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}`
+  // 导出配置 Schema
+  ctx.i18n.define('zh', require('./locales/zh'));
 
-        if (thinkingPrompt) {
-          if (session) session.send(thinkingPrompt)
-        }
+  // 初始化存储
+  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(config.commandName, { authority: 1 })
+    .alias('chat')
+    .action(async ({ session }, content) => {
+      if (!session) return;
 
-        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.'
+      const userId = session.userId;
+      if (!userId) return;
+
+      // 检查黑名单
+      if (config.blacklist.includes(userId)) {
+        if (config.enableMessage) {
+          await session.send('您在黑名单中，无法使用此功能。');
         }
-      })
-  } 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.'
+        return;
       }
-      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 (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 (thinkingPrompt) {
-        if (session) session.send(thinkingPrompt)
+      // 获取用户输入
+      if (!content || content.trim() === '') {
+        if (config.enableMessage) {
+          await session.send('请输入要聊天的内容。');
+        }
+        return;
       }
 
       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
+        // 构建消息列表
+        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) {
-        ctx.logger.error('OpenAI API error:', error)
-        return 'Failed to get response from the API.'
+        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/src/locales/zh.ts

@@ -0,0 +1,43 @@
+export 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/src/storage.ts

@@ -0,0 +1,27 @@
+export interface CooldownData {
+  lastRequestTime: number;
+}
+
+export class Storage {
+  private cooldowns = new Map<string, CooldownData>();
+
+  getCooldown(userId: string): CooldownData | undefined {
+    return this.cooldowns.get(userId);
+  }
+
+  setCooldown(userId: string, data: CooldownData): void {
+    this.cooldowns.set(userId, data);
+  }
+
+  deleteCooldown(userId: string): void {
+    this.cooldowns.delete(userId);
+  }
+
+  isOnCooldown(userId: string, cooldownTime: number): boolean {
+    const data = this.getCooldown(userId);
+    if (!data) return false;
+
+    const elapsed = Date.now() - data.lastRequestTime;
+    return elapsed < cooldownTime;
+  }
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+export interface Message {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: Message[];
+  temperature?: number;
+  max_tokens?: number;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string;
+    };
+    finish_reason: string;
+  }>;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}

package/tsconfig.json

@@ -1,14 +1,21 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
+    "target": "ES2019",
     "module": "commonjs",
+    "outDir": "./lib",
+    "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
+    "declaration": true,
+    "resolveJsonModule": true
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules"]
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
 }