koishi-plugin-best-cave 2.7.4 → 2.7.6

package/lib/AIManager.d.ts

@@ -2,7 +2,12 @@ import { Context, Logger } from 'koishi';
 import { Config, CaveObject, StoredElement } from './index';
 import { FileManager } from './FileManager';
 /**
- * @description 数据库 `cave_meta` 表的完整对象模型。
+ * @interface CaveMetaObject
+ * @description 定义了数据库 `cave_meta` 表的结构模型。
+ * @property {number} cave - 关联的回声洞 `id`，作为外键和主键。
+ * @property {string[]} keywords - AI 从回声洞内容中提取的核心关键词数组。
+ * @property {string} description - AI 生成的对回声洞内容的简洁摘要或描述。
+ * @property {number} rating - AI 对内容质量、趣味性或相关性的综合评分，范围为 0 到 100。
  */
 export interface CaveMetaObject {
     cave: number;
@@ -17,8 +22,7 @@ declare module 'koishi' {
 }
 /**
  * @class AIManager
- * @description 负责 AI 分析（描述、评分、关键词）和 AI 查重。
- * 通过与外部 AI 服务接口交互，实现对回声洞内容的深度分析和重复性检查。
+ * @description AI 管理器，是连接 AI 服务与回声洞功能的核心模块。
  */
 export declare class AIManager {
     private ctx;
@@ -26,25 +30,24 @@ export declare class AIManager {
     private logger;
     private fileManager;
     private http;
+    private requestCount;
+    private rateLimitResetTime;
     /**
      * @constructor
-     * @param {Context} ctx - Koishi 的上下文对象。
-     * @param {Config} config - 插件的配置信息。
-     * @param {Logger} logger - 日志记录器实例。
-     * @param {FileManager} fileManager - 文件管理器实例。
+     * @description AIManager 类的构造函数，负责初始化依赖项，并向 Koishi 的数据库模型中注册 `cave_meta` 表。
      */
     constructor(ctx: Context, config: Config, logger: Logger, fileManager: FileManager);
     /**
-     * @description 注册与 AI 功能相关的 `.ai` 子命令。
-     * @param {any} cave - 主 `cave` 命令实例。
+     * @description 注册所有与 AIManager 功能相关的 Koishi 命令。
+     * @param {any} cave - 主 `cave` 命令的实例，用于在其下注册子命令。
      */
     registerCommands(cave: any): void;
     /**
-     * @description 对新内容进行两阶段 AI 查重。
-     * @param {StoredElement[]} newElements - 新内容的元素数组。
-     * @param {{ sourceUrl: string, fileName: string }[]} newMediaToSave - 新内容中待上传的媒体文件信息。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-     * @returns {Promise<{ duplicate: boolean; id?: number }>} - 返回 AI 判断结果。
+     * @description 对新提交的内容执行 AI 驱动的查重检查。
+     * @param {StoredElement[]} newElements - 待检查的新内容的结构化数组（包含文本、图片等）。
+     * @param {{ sourceUrl: string, fileName: string }[]} newMediaToSave - 伴随新内容提交的、需要从 URL 下载的媒体文件列表。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）已经加载到内存中的媒体文件 Buffer，可用于优化性能。
+     * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个包含查重结果的对象。
      */
     checkForDuplicates(newElements: StoredElement[], newMediaToSave: {
         sourceUrl: string;
@@ -57,57 +60,31 @@ export declare class AIManager {
         id?: number;
     }>;
     /**
-     * @description 分析单个回声洞，并将分析结果存入数据库。
-     * @param {CaveObject} cave - 需要分析的回声洞对象。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-     * @returns {Promise<void>}
+     * @description 对单个回声洞对象执行完整的分析和存储流程。
+     * @param {CaveObject} cave - 需要被分析的完整回声洞对象，包含 `id` 和 `elements`。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）与该回声洞相关的、已加载到内存的媒体文件 Buffer。
+     * @returns {Promise<void>} 操作完成后 resolve 的 Promise。
+     * @throws {Error} 如果在分析或数据库存储过程中发生错误，则会向上抛出异常。
      */
     analyzeAndStore(cave: CaveObject, mediaBuffers?: {
         fileName: string;
         buffer: Buffer;
     }[]): Promise<void>;
     /**
-     * @description 调用 AI 模型获取内容的分析结果。
-     * @param {StoredElement[]} elements - 内容的元素数组。
-     * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - (可选) 待保存的媒体文件信息。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-     * @returns {Promise<Omit<CaveMetaObject, 'cave'>>} - 返回分析结果对象。
+     * @description 准备并发送内容给 AI 模型以获取分析结果。
+     * @param {StoredElement[]} elements - 内容的结构化元素数组。
+     * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - （可选）需要从网络下载的媒体文件信息。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）已存在于内存中的媒体文件 Buffer。
+     * @returns {Promise<Omit<CaveMetaObject, 'cave'>>} 返回一个不含 `cave` 字段的分析结果对象。如果内容为空或无法处理，则返回 `null`。
      */
     private getAnalysis;
     /**
-     * @description 使用 Jaccard 相似度系数计算两组关键词的相似度。
-     * @param {Set<string>} setA - 第一组关键词集合。
-     * @param {Set<string>} setB - 第二组关键词集合。
-     * @returns {number} - 返回 0 到 1 之间的相似度值。
+     * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
+     * @param {any[]} messages - 要发送给 AI 的消息数组，格式遵循 OpenAI API 规范。
+     * @param {string} systemPrompt - 指导 AI 行为的系统级提示词。
+     * @param {string} schemaString - 一个 JSON 字符串，定义了期望 AI 返回的 JSON 对象的结构。
+     * @returns {Promise<any>} AI 返回的、经过 JSON 解析的响应体。
+     * @throws {Error} 当 JSON Schema 解析失败、网络请求失败或 AI 返回错误时，抛出异常。
      */
-    private calculateKeywordSimilarity;
-    /**
-     * @description 准备发送给 AI 模型的请求体（Payload）。
-     * @param {string} prompt - 系统提示词。
-     * @param {string} schemaString - JSON Schema 字符串。
-     * @param {StoredElement[]} elements - 内容的元素数组。
-     * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - (可选) 待保存的媒体文件信息。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-     * @returns {Promise<{ payload: any }>} - 返回包含请求体的对象。
-     */
-    private preparePayload;
-    /**
-     * @description 准备用于 AI 精准查重的请求体（Payload）。
-     * @param {StoredElement[]} newElements - 新内容的元素。
-     * @param {CaveObject[]} existingCaves - 经过初筛的疑似重复的旧内容。
-     * @returns {Promise<{ payload: any }>} - 返回适用于查重场景的请求体。
-     */
-    private prepareDedupePayload;
-    /**
-     * @description 解析 AI 返回的分析响应。
-     * @param {any} response - AI 服务的原始响应对象。
-     * @returns {Omit<CaveMetaObject, 'cave'>} - 返回结构化的分析结果。
-     */
-    private parseAnalysisResponse;
-    /**
-     * @description 解析 AI 返回的查重响应。
-     * @param {any} response - AI 服务的原始响应对象。
-     * @returns {{ duplicate: boolean; id?: number }} - 返回查重结果。
-     */
-    private parseDedupeResponse;
+    private requestAI;
 }

package/lib/index.d.ts

@@ -61,6 +61,7 @@ export interface Config {
     aiEndpoint?: string;
     aiApiKey?: string;
     aiModel?: string;
+    aiTPM?: number;
     AnalysePrompt?: string;
     aiCheckPrompt?: string;
     aiAnalyseSchema?: string;

package/lib/index.js

@@ -978,10 +978,7 @@ var path3 = __toESM(require("path"));
 var AIManager = class {
   /**
    * @constructor
-   * @param {Context} ctx - Koishi 的上下文对象。
-   * @param {Config} config - 插件的配置信息。
-   * @param {Logger} logger - 日志记录器实例。
-   * @param {FileManager} fileManager - 文件管理器实例。
+   * @description AIManager 类的构造函数，负责初始化依赖项，并向 Koishi 的数据库模型中注册 `cave_meta` 表。
    */
   constructor(ctx, config, logger2, fileManager) {
     this.ctx = ctx;
@@ -1002,31 +999,37 @@ var AIManager = class {
     __name(this, "AIManager");
   }
   http;
+  requestCount = 0;
+  rateLimitResetTime = 0;
   /**
-   * @description 注册与 AI 功能相关的 `.ai` 子命令。
-   * @param {any} cave - 主 `cave` 命令实例。
+   * @description 注册所有与 AIManager 功能相关的 Koishi 命令。
+   * @param {any} cave - 主 `cave` 命令的实例，用于在其下注册子命令。
    */
   registerCommands(cave) {
     cave.subcommand(".ai", "分析回声洞", { hidden: true, authority: 4 }).usage("分析尚未分析的回声洞，补全回声洞记录。").action(async ({ session }) => {
-      const adminError = requireAdmin(session, this.config);
-      if (adminError) return adminError;
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
       try {
         const allCaves = await this.ctx.database.get("cave", { status: "active" });
         const analyzedCaveIds = new Set((await this.ctx.database.get("cave_meta", {})).map((meta) => meta.cave));
         const cavesToAnalyze = allCaves.filter((cave2) => !analyzedCaveIds.has(cave2.id));
         if (cavesToAnalyze.length === 0) return "无需分析回声洞";
         await session.send(`开始分析 ${cavesToAnalyze.length} 个回声洞...`);
-        let totalSuccessCount = 0;
-        for (let i = 0; i < cavesToAnalyze.length; i += 5) {
-          const batch = cavesToAnalyze.slice(i, i + 5);
-          this.logger.info(`[${totalSuccessCount}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 条回声洞...`);
-          await Promise.all(batch.map((cave2) => this.analyzeAndStore(cave2)));
-          totalSuccessCount += batch.length;
+        let successCount = 0;
+        let failedCount = 0;
+        for (const [index, cave2] of cavesToAnalyze.entries()) {
+          this.logger.info(`[${index + 1}/${cavesToAnalyze.length}] 正在分析回声洞 (${cave2.id})...`);
+          try {
+            await this.analyzeAndStore(cave2);
+            successCount++;
+          } catch (error) {
+            failedCount++;
+            this.logger.error(`分析回声洞（${cave2.id}）时出错:`, error);
+          }
         }
-        return `已分析 ${totalSuccessCount} 个回声洞`;
+        return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
       } catch (error) {
-        this.logger.error("已中断分析回声洞:", error);
-        return `分析回声洞失败：${error.message}`;
+        this.logger.error("分析回声洞失败:", error);
+        return `操作失败: ${error.message}`;
       }
     });
     cave.subcommand(".desc <id:posint>", "查询回声洞").action(async ({}, id) => {
@@ -1034,12 +1037,11 @@ var AIManager = class {
       try {
         const [meta] = await this.ctx.database.get("cave_meta", { cave: id });
         if (!meta) return `回声洞（${id}）尚未分析`;
-        const keywordsText = meta.keywords.join(", ");
         const report = [
           `回声洞（${id}）分析结果：`,
           `描述：${meta.description}`,
-          `关键词：${keywordsText}`,
-          `评分：${meta.rating}/100`
+          `关键词：${meta.keywords.join(", ")}`,
+          `综合评分：${meta.rating}/100`
         ];
         return import_koishi3.h.text(report.join("\n"));
       } catch (error) {
@@ -1049,90 +1051,83 @@ var AIManager = class {
     });
   }
   /**
-   * @description 对新内容进行两阶段 AI 查重。
-   * @param {StoredElement[]} newElements - 新内容的元素数组。
-   * @param {{ sourceUrl: string, fileName: string }[]} newMediaToSave - 新内容中待上传的媒体文件信息。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-   * @returns {Promise<{ duplicate: boolean; id?: number }>} - 返回 AI 判断结果。
+   * @description 对新提交的内容执行 AI 驱动的查重检查。
+   * @param {StoredElement[]} newElements - 待检查的新内容的结构化数组（包含文本、图片等）。
+   * @param {{ sourceUrl: string, fileName: string }[]} newMediaToSave - 伴随新内容提交的、需要从 URL 下载的媒体文件列表。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）已经加载到内存中的媒体文件 Buffer，可用于优化性能。
+   * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个包含查重结果的对象。
    */
   async checkForDuplicates(newElements, newMediaToSave, mediaBuffers) {
     try {
       const newAnalysis = await this.getAnalysis(newElements, newMediaToSave, mediaBuffers);
       if (!newAnalysis || newAnalysis.keywords.length === 0) return { duplicate: false };
-      const newKeywords = new Set(newAnalysis.keywords);
       const allMeta = await this.ctx.database.get("cave_meta", {});
-      const potentialDuplicates = [];
-      for (const meta of allMeta) {
-        const existingKeywords = new Set(meta.keywords);
-        const similarity = this.calculateKeywordSimilarity(newKeywords, existingKeywords);
+      const potentialDuplicates = (await Promise.all(allMeta.map(async (meta) => {
+        const setA = new Set(newAnalysis.keywords);
+        const setB = new Set(meta.keywords);
+        let similarity = 0;
+        if (setA.size > 0 && setB.size > 0) {
+          const intersection = new Set([...setA].filter((x) => setB.has(x)));
+          const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+          similarity = intersection.size / union.size;
+        }
         if (similarity * 100 >= 80) {
           const [cave] = await this.ctx.database.get("cave", { id: meta.cave });
-          if (cave) potentialDuplicates.push(cave);
+          return cave;
         }
-      }
+      }))).filter(Boolean);
       if (potentialDuplicates.length === 0) return { duplicate: false };
-      const { payload } = await this.prepareDedupePayload(newElements, potentialDuplicates);
-      const fullUrl = `${this.config.aiEndpoint}/models/${this.config.aiModel}:generateContent?key=${this.config.aiApiKey}`;
-      const response = await this.http.post(fullUrl, payload, { headers: { "Content-Type": "application/json" }, timeout: 9e4 });
-      return this.parseDedupeResponse(response);
+      const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text").map((el) => el.content).join(" "), "formatContent");
+      const userMessage = {
+        role: "user",
+        content: JSON.stringify({
+          new_content: { text: formatContent(newElements) },
+          existing_contents: potentialDuplicates.map((cave) => ({ id: cave.id, text: formatContent(cave.elements) }))
+        })
+      };
+      const response = await this.requestAI([userMessage], this.config.aiCheckPrompt, this.config.aiCheckSchema);
+      return {
+        duplicate: response.duplicate || false,
+        id: response.id ? Number(response.id) : void 0
+      };
     } catch (error) {
       this.logger.error("查重回声洞出错:", error);
       return { duplicate: false };
     }
   }
   /**
-   * @description 分析单个回声洞，并将分析结果存入数据库。
-   * @param {CaveObject} cave - 需要分析的回声洞对象。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-   * @returns {Promise<void>}
+   * @description 对单个回声洞对象执行完整的分析和存储流程。
+   * @param {CaveObject} cave - 需要被分析的完整回声洞对象，包含 `id` 和 `elements`。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）与该回声洞相关的、已加载到内存的媒体文件 Buffer。
+   * @returns {Promise<void>} 操作完成后 resolve 的 Promise。
+   * @throws {Error} 如果在分析或数据库存储过程中发生错误，则会向上抛出异常。
    */
   async analyzeAndStore(cave, mediaBuffers) {
     try {
-      const analysisResult = await this.getAnalysis(cave.elements, void 0, mediaBuffers);
-      if (analysisResult) await this.ctx.database.upsert("cave_meta", [{ cave: cave.id, ...analysisResult }]);
+      const result = await this.getAnalysis(cave.elements, void 0, mediaBuffers);
+      if (result) {
+        await this.ctx.database.upsert("cave_meta", [{
+          cave: cave.id,
+          ...result,
+          rating: Math.max(0, Math.min(100, result.rating || 0))
+        }]);
+      }
     } catch (error) {
       this.logger.error(`分析回声洞（${cave.id}）失败:`, error);
       throw error;
     }
   }
   /**
-   * @description 调用 AI 模型获取内容的分析结果。
-   * @param {StoredElement[]} elements - 内容的元素数组。
-   * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - (可选) 待保存的媒体文件信息。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-   * @returns {Promise<Omit<CaveMetaObject, 'cave'>>} - 返回分析结果对象。
+   * @description 准备并发送内容给 AI 模型以获取分析结果。
+   * @param {StoredElement[]} elements - 内容的结构化元素数组。
+   * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - （可选）需要从网络下载的媒体文件信息。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）已存在于内存中的媒体文件 Buffer。
+   * @returns {Promise<Omit<CaveMetaObject, 'cave'>>} 返回一个不含 `cave` 字段的分析结果对象。如果内容为空或无法处理，则返回 `null`。
    */
   async getAnalysis(elements, mediaToSave, mediaBuffers) {
-    const { payload } = await this.preparePayload(this.config.AnalysePrompt, this.config.aiAnalyseSchema, elements, mediaToSave, mediaBuffers);
-    if (!payload.contents) return null;
-    const fullUrl = `${this.config.aiEndpoint}/models/${this.config.aiModel}:generateContent?key=${this.config.aiApiKey}`;
-    const response = await this.http.post(fullUrl, payload, { headers: { "Content-Type": "application/json" }, timeout: 6e4 });
-    return this.parseAnalysisResponse(response);
-  }
-  /**
-   * @description 使用 Jaccard 相似度系数计算两组关键词的相似度。
-   * @param {Set<string>} setA - 第一组关键词集合。
-   * @param {Set<string>} setB - 第二组关键词集合。
-   * @returns {number} - 返回 0 到 1 之间的相似度值。
-   */
-  calculateKeywordSimilarity(setA, setB) {
-    const intersection = new Set([...setA].filter((x) => setB.has(x)));
-    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-    return union.size === 0 ? 0 : intersection.size / union.size;
-  }
-  /**
-   * @description 准备发送给 AI 模型的请求体（Payload）。
-   * @param {string} prompt - 系统提示词。
-   * @param {string} schemaString - JSON Schema 字符串。
-   * @param {StoredElement[]} elements - 内容的元素数组。
-   * @param {{ sourceUrl: string, fileName: string }[]} [mediaToSave] - (可选) 待保存的媒体文件信息。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - (可选) 已下载的媒体文件 Buffer。
-   * @returns {Promise<{ payload: any }>} - 返回包含请求体的对象。
-   */
-  async preparePayload(prompt, schemaString, elements, mediaToSave, mediaBuffers) {
-    const parts = [{ text: prompt }];
+    const userContent = [];
     const combinedText = elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join("\n");
-    if (combinedText) parts.push({ text: combinedText });
+    if (combinedText.trim()) userContent.push({ type: "text", text: combinedText });
     const mediaMap = new Map(mediaBuffers?.map((m) => [m.fileName, m.buffer]));
     const imageElements = elements.filter((el) => el.type === "image" && el.file);
     for (const el of imageElements) {
@@ -1148,93 +1143,57 @@ var AIManager = class {
         }
         if (buffer) {
           const mimeType = path3.extname(el.file).toLowerCase() === ".png" ? "image/png" : "image/jpeg";
-          parts.push({ inline_data: { mime_type: mimeType, data: buffer.toString("base64") } });
+          userContent.push({
+            type: "image_url",
+            image_url: { url: `data:${mimeType};base64,${buffer.toString("base64")}` }
+          });
         }
       } catch (error) {
         this.logger.warn(`分析内容（${el.file}）失败:`, error);
       }
     }
-    if (parts.length <= 1) return { payload: {} };
-    try {
-      const schema = JSON.parse(schemaString);
-      return {
-        payload: {
-          contents: [{ parts }],
-          generationConfig: {
-            responseMimeType: "application/json",
-            responseSchema: schema
-          }
-        }
-      };
-    } catch (error) {
-      this.logger.error("分析 JSON Schema 解析失败:", error);
-      return { payload: {} };
-    }
+    if (userContent.length === 0) return null;
+    const userMessage = { role: "user", content: userContent };
+    return await this.requestAI([userMessage], this.config.AnalysePrompt, this.config.aiAnalyseSchema);
   }
   /**
-   * @description 准备用于 AI 精准查重的请求体（Payload）。
-   * @param {StoredElement[]} newElements - 新内容的元素。
-   * @param {CaveObject[]} existingCaves - 经过初筛的疑似重复的旧内容。
-   * @returns {Promise<{ payload: any }>} - 返回适用于查重场景的请求体。
+   * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
+   * @param {any[]} messages - 要发送给 AI 的消息数组，格式遵循 OpenAI API 规范。
+   * @param {string} systemPrompt - 指导 AI 行为的系统级提示词。
+   * @param {string} schemaString - 一个 JSON 字符串，定义了期望 AI 返回的 JSON 对象的结构。
+   * @returns {Promise<any>} AI 返回的、经过 JSON 解析的响应体。
+   * @throws {Error} 当 JSON Schema 解析失败、网络请求失败或 AI 返回错误时，抛出异常。
    */
-  async prepareDedupePayload(newElements, existingCaves) {
-    const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text").map((el) => el.content).join(" "), "formatContent");
-    const payloadContent = JSON.stringify({
-      new_content: { text: formatContent(newElements) },
-      existing_contents: existingCaves.map((cave) => ({ id: cave.id, text: formatContent(cave.elements) }))
-    });
-    const parts = [{ text: this.config.aiCheckPrompt }, { text: payloadContent }];
-    try {
-      const schema = JSON.parse(this.config.aiCheckSchema);
-      return {
-        payload: {
-          contents: [{ parts }],
-          generationConfig: {
-            responseMimeType: "application/json",
-            responseSchema: schema
-          }
-        }
-      };
-    } catch (error) {
-      this.logger.error("查重 JSON Schema 解析失败:", error);
-      return { payload: {} };
+  async requestAI(messages, systemPrompt, schemaString) {
+    const now = Date.now();
+    if (now > this.rateLimitResetTime) {
+      this.rateLimitResetTime = now + 6e4;
+      this.requestCount = 0;
     }
-  }
-  /**
-   * @description 解析 AI 返回的分析响应。
-   * @param {any} response - AI 服务的原始响应对象。
-   * @returns {Omit<CaveMetaObject, 'cave'>} - 返回结构化的分析结果。
-   */
-  parseAnalysisResponse(response) {
-    try {
-      if (!response?.candidates?.[0]?.content?.parts?.[0]?.text) throw new Error("分析响应解析失败");
-      const content = response.candidates[0].content.parts[0].text;
-      const parsed = JSON.parse(content);
-      const keywords = Array.isArray(parsed.keywords) ? parsed.keywords : [];
-      return {
-        keywords,
-        description: parsed.description || "无",
-        rating: Math.max(0, Math.min(100, parsed.rating || 0))
-      };
-    } catch (error) {
-      this.logger.error("分析响应解析失败:", error, "原始响应:", JSON.stringify(response));
-      throw error;
+    if (this.requestCount >= this.config.aiTPM) {
+      const delay = this.rateLimitResetTime - now;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      this.rateLimitResetTime = Date.now() + 6e4;
+      this.requestCount = 0;
     }
-  }
-  /**
-   * @description 解析 AI 返回的查重响应。
-   * @param {any} response - AI 服务的原始响应对象。
-   * @returns {{ duplicate: boolean; id?: number }} - 返回查重结果。
-   */
-  parseDedupeResponse(response) {
+    let schema = JSON.parse(schemaString);
+    const payload = {
+      model: this.config.aiModel,
+      messages: [{ role: "system", content: systemPrompt }, ...messages],
+      response_format: { type: "json_schema", strict: true, schema }
+    };
+    const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/chat/completions`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.config.aiApiKey}`
+    };
     try {
-      if (!response?.candidates?.[0]?.content?.parts?.[0]?.text) throw new Error("查重响应解析失败");
-      const content = response.candidates[0].content.parts[0].text;
-      const parsed = JSON.parse(content);
-      if (parsed.duplicate === true && parsed.id) return { duplicate: true, id: Number(parsed.id) };
-      return { duplicate: false };
+      this.requestCount++;
+      const response = await this.http.post(fullUrl, payload, { headers, timeout: 9e4 });
+      return JSON.parse(response.choices[0].message.content);
     } catch (error) {
-      this.logger.error("查重响应解析失败:", error, "原始响应:", JSON.stringify(response));
+      const errorMessage = error.response ? JSON.stringify(error.response.data) : error.message;
+      this.logger.error(`请求 API 失败: ${errorMessage}`);
       throw error;
     }
   }
@@ -1272,10 +1231,11 @@ var Config = import_koishi4.Schema.intersect([
   }).description("复核配置"),
   import_koishi4.Schema.object({
     enableAI: import_koishi4.Schema.boolean().default(false).description("启用 AI"),
-    aiEndpoint: import_koishi4.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta"),
+    aiEndpoint: import_koishi4.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta/openai"),
     aiApiKey: import_koishi4.Schema.string().description("密钥 (Key)").role("secret"),
-    aiModel: import_koishi4.Schema.string().description("模型").default("gemini-2.5-flash"),
-    AnalysePrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我提供的内容，总结关键词，概括内容并进行评分。`).description("分析提示词 (Prompt)"),
+    aiModel: import_koishi4.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
+    aiTPM: import_koishi4.Schema.number().description("每分钟请求数 (TPM)").default(60),
+    AnalysePrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我提供的内容，总结关键词，概括内容并进行评分。`).description("分析 Prompt"),
     aiAnalyseSchema: import_koishi4.Schema.string().role("textarea").default(
       `{
         "type": "object",
@@ -1298,8 +1258,8 @@ var Config = import_koishi4.Schema.intersect([
         },
         "required": ["keywords", "description", "rating"]
       }`
-    ).description("分析输出模式 (JSON Schema)"),
-    aiCheckPrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重提示词 (Prompt)"),
+    ).description("分析 JSON Schema"),
+    aiCheckPrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
     aiCheckSchema: import_koishi4.Schema.string().role("textarea").default(
       `{
         "type": "object",
@@ -1315,7 +1275,7 @@ var Config = import_koishi4.Schema.intersect([
         },
         "required": ["duplicate"]
       }`
-    ).description("查重输出模式 (JSON Schema)")
+    ).description("查重 JSON Schema")
   }).description("模型配置"),
   import_koishi4.Schema.object({
     localPath: import_koishi4.Schema.string().description("文件映射路径"),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "功能强大、高度可定制的回声洞。支持丰富的媒体类型、内容查重、人工审核、用户昵称、数据迁移以及本地/S3 双重文件存储后端。",
-  "version": "2.7.4",
+  "version": "2.7.6",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],