koishi-plugin-best-cave 2.7.9 → 2.7.11

package/lib/AIManager.d.ts

@@ -2,7 +2,6 @@ import { Context, Logger } from 'koishi';
 import { Config, CaveObject, StoredElement } from './index';
 import { FileManager } from './FileManager';
 /**
- * @interface CaveMetaObject
  * @description 定义了数据库 `cave_meta` 表的结构模型。
  * @property {number} cave - 关联的回声洞 `id`，作为外键和主键。
  * @property {string[]} keywords - AI 从回声洞内容中提取的核心关键词数组。
@@ -22,7 +21,7 @@ declare module 'koishi' {
 }
 /**
  * @class AIManager
- * @description AI 管理器，是连接 AI 服务与回声洞功能的核心模块。
+ * @description AI 管理器，连接 AI 服务与回声洞功能的核心模块。
  */
 export declare class AIManager {
     private ctx;
@@ -34,25 +33,24 @@ export declare class AIManager {
     private rateLimitResetTime;
     /**
      * @constructor
-     * @description AIManager 类的构造函数，负责初始化依赖项，并向 Koishi 的数据库模型中注册 `cave_meta` 表。
+     * @param {Context} ctx - Koishi 的上下文对象，提供框架核心功能。
+     * @param {Config} config - 插件的配置对象。
+     * @param {Logger} logger - 日志记录器实例，用于输出日志。
+     * @param {FileManager} fileManager - 文件管理器实例，用于处理媒体文件。
      */
     constructor(ctx: Context, config: Config, logger: Logger, fileManager: FileManager);
     /**
      * @description 注册所有与 AIManager 功能相关的 Koishi 命令。
-     * @param {any} cave - 主 `cave` 命令的实例，用于在其下注册子命令。
+     * @param {any} cave - Koishi 命令实例，用于挂载子命令。
      */
     registerCommands(cave: any): void;
     /**
      * @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 }>} 一个包含查重结果的对象。
+     * @param {StoredElement[]} newElements - 新提交的内容元素数组。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
+     * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
      */
-    checkForDuplicates(newElements: StoredElement[], newMediaToSave: {
-        sourceUrl: string;
-        fileName: string;
-    }[], mediaBuffers?: {
+    checkForDuplicates(newElements: StoredElement[], mediaBuffers?: {
         fileName: string;
         buffer: Buffer;
     }[]): Promise<{
@@ -61,30 +59,45 @@ export declare class AIManager {
     }>;
     /**
      * @description 对单个回声洞对象执行完整的分析和存储流程。
-     * @param {CaveObject} cave - 需要被分析的完整回声洞对象，包含 `id` 和 `elements`。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）与该回声洞相关的、已加载到内存的媒体文件 Buffer。
-     * @returns {Promise<void>} 操作完成后 resolve 的 Promise。
-     * @throws {Error} 如果在分析或数据库存储过程中发生错误，则会向上抛出异常。
+     * @param {CaveObject} cave - 要分析的回声洞对象。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
+     * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
      */
     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'>>} 返回一个不含 `cave` 字段的分析结果对象。如果内容为空或无法处理，则返回 `null`。
+     * @description 对一批回声洞执行分析并存储结果。
+     * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+     * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
+     */
+    private analyzeAndStoreBatch;
+    /**
+     * @description 根据新内容的关键词，查找并返回可能重复的回声洞。
+     * @param {string[]} newKeywords - 新内容的关键词数组。
+     * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
+     */
+    private findPotentialDuplicates;
+    /**
+     * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
+     * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+     * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
+     * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+     */
+    private getAnalyses;
+    /**
+     * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
+     * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
      */
-    private getAnalysis;
+    private ensureRateLimit;
     /**
      * @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 返回错误时，抛出异常。
+     * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
+     * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
+     * @param {string} schemaString - 定义期望响应格式的 JSON Schema 字符串。
+     * @returns {Promise<any>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+     * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
      */
     private requestAI;
 }

package/lib/HashManager.d.ts

@@ -1,5 +1,5 @@
 import { Context, Logger } from 'koishi';
-import { Config, CaveObject } from './index';
+import { Config } from './index';
 import { FileManager } from './FileManager';
 /**
  * @description 数据库 `cave_hash` 表的完整对象模型。
@@ -32,12 +32,6 @@ export declare class HashManager {
      * @param cave - 主 `cave` 命令实例。
      */
     registerCommands(cave: any): void;
-    /**
-     * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
-     * @param cave - 回声洞对象。
-     * @returns 生成的哈希对象数组。
-     */
-    generateAllHashesForCave(cave: Pick<CaveObject, 'id' | 'elements'>): Promise<CaveHashObject[]>;
     /**
      * @description 执行一维离散余弦变换 (DCT-II) 的方法。
      * @param input - 输入的数字数组。

package/lib/index.js

@@ -727,22 +727,50 @@ var HashManager = class {
         const cavesToProcess = allCaves.filter((cave2) => !hashedCaveIds.has(cave2.id));
         if (cavesToProcess.length === 0) return "无需补全回声洞哈希";
         await session.send(`开始补全 ${cavesToProcess.length} 个回声洞的哈希...`);
-        const hashesToInsert = [];
+        let hashesToInsert = [];
         let processedCaveCount = 0;
+        let totalHashesGenerated = 0;
         let errorCount = 0;
+        const flushBatch = /* @__PURE__ */ __name(async () => {
+          if (hashesToInsert.length === 0) return;
+          await this.ctx.database.upsert("cave_hash", hashesToInsert);
+          totalHashesGenerated += hashesToInsert.length;
+          this.logger.info(`[${processedCaveCount}/${cavesToProcess.length}] 正在导入 ${hashesToInsert.length} 条回声洞哈希...`);
+          hashesToInsert = [];
+        }, "flushBatch");
         for (const cave2 of cavesToProcess) {
           processedCaveCount++;
           try {
-            const newHashesForCave = await this.generateAllHashesForCave(cave2);
+            const tempHashes = [];
+            const uniqueHashTracker = /* @__PURE__ */ new Set();
+            const addUniqueHash = /* @__PURE__ */ __name((hashObj) => {
+              const key = `${hashObj.hash}-${hashObj.type}`;
+              if (!uniqueHashTracker.has(key)) {
+                tempHashes.push(hashObj);
+                uniqueHashTracker.add(key);
+              }
+            }, "addUniqueHash");
+            const combinedText = cave2.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
+            if (combinedText) {
+              const textHash = this.generateTextSimhash(combinedText);
+              if (textHash) addUniqueHash({ cave: cave2.id, hash: textHash, type: "text" });
+            }
+            for (const el of cave2.elements.filter((el2) => el2.type === "image" && el2.file)) {
+              const imageBuffer = await this.fileManager.readFile(el.file);
+              const imageHash = await this.generatePHash(imageBuffer);
+              addUniqueHash({ cave: cave2.id, hash: imageHash, type: "image" });
+            }
+            const newHashesForCave = tempHashes;
             if (newHashesForCave.length > 0) hashesToInsert.push(...newHashesForCave);
+            if (hashesToInsert.length >= 100) await flushBatch();
           } catch (error) {
             errorCount++;
             this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error.message}`);
           }
         }
-        if (hashesToInsert.length > 0) await this.ctx.database.upsert("cave_hash", hashesToInsert);
+        await flushBatch();
         const successCount = processedCaveCount - errorCount;
-        return `已补全 ${successCount} 个回声洞的 ${hashesToInsert.length} 条哈希（失败 ${errorCount} 条）`;
+        return `已补全 ${successCount} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
       } catch (error) {
         this.logger.error("补全哈希失败:", error);
         return `操作失败: ${error.message}`;
@@ -867,38 +895,6 @@ var HashManager = class {
       }
     });
   }
-  /**
-   * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
-   * @param cave - 回声洞对象。
-   * @returns 生成的哈希对象数组。
-   */
-  async generateAllHashesForCave(cave) {
-    const tempHashes = [];
-    const uniqueHashTracker = /* @__PURE__ */ new Set();
-    const addUniqueHash = /* @__PURE__ */ __name((hashObj) => {
-      const key = `${hashObj.hash}-${hashObj.type}`;
-      if (!uniqueHashTracker.has(key)) {
-        tempHashes.push(hashObj);
-        uniqueHashTracker.add(key);
-      }
-    }, "addUniqueHash");
-    const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
-    if (combinedText) {
-      const textHash = this.generateTextSimhash(combinedText);
-      if (textHash) addUniqueHash({ cave: cave.id, hash: textHash, type: "text" });
-    }
-    for (const el of cave.elements.filter((el2) => el2.type === "image" && el2.file)) {
-      try {
-        const imageBuffer = await this.fileManager.readFile(el.file);
-        const imageHash = await this.generatePHash(imageBuffer);
-        addUniqueHash({ cave: cave.id, hash: imageHash, type: "image" });
-      } catch (error) {
-        this.logger.warn(`无法为回声洞（${cave.id}）的图片（${el.file}）生成哈希:`, error);
-        throw error;
-      }
-    }
-    return tempHashes;
-  }
   /**
    * @description 执行一维离散余弦变换 (DCT-II) 的方法。
    * @param input - 输入的数字数组。
@@ -1005,7 +1001,10 @@ var path3 = __toESM(require("path"));
 var AIManager = class {
   /**
    * @constructor
-   * @description AIManager 类的构造函数，负责初始化依赖项，并向 Koishi 的数据库模型中注册 `cave_meta` 表。
+   * @param {Context} ctx - Koishi 的上下文对象，提供框架核心功能。
+   * @param {Config} config - 插件的配置对象。
+   * @param {Logger} logger - 日志记录器实例，用于输出日志。
+   * @param {FileManager} fileManager - 文件管理器实例，用于处理媒体文件。
    */
   constructor(ctx, config, logger2, fileManager) {
     this.ctx = ctx;
@@ -1030,28 +1029,26 @@ var AIManager = class {
   rateLimitResetTime = 0;
   /**
    * @description 注册所有与 AIManager 功能相关的 Koishi 命令。
-   * @param {any} cave - 主 `cave` 命令的实例，用于在其下注册子命令。
+   * @param {any} cave - Koishi 命令实例，用于挂载子命令。
    */
   registerCommands(cave) {
     cave.subcommand(".ai", "分析回声洞", { hidden: true, authority: 4 }).usage("分析尚未分析的回声洞，补全回声洞记录。").action(async ({ session }) => {
       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 analyzedCaveIds = new Set((await this.ctx.database.get("cave_meta", {}, { fields: ["cave"] })).map((meta) => meta.cave));
         const cavesToAnalyze = allCaves.filter((cave2) => !analyzedCaveIds.has(cave2.id));
         if (cavesToAnalyze.length === 0) return "无需分析回声洞";
         await session.send(`开始分析 ${cavesToAnalyze.length} 个回声洞...`);
-        let successCount = 0;
-        for (const [index, cave2] of cavesToAnalyze.entries()) {
-          try {
-            this.logger.info(`[${index + 1}/${cavesToAnalyze.length}] 正在分析回声洞 (${cave2.id})...`);
-            await this.analyzeAndStore(cave2);
-            successCount++;
-          } catch (error) {
-            return `分析回声洞（${cave2.id}）时出错: ${error.message}`;
-          }
+        let totalSuccessCount = 0;
+        const batchSize = 10;
+        for (let i = 0; i < cavesToAnalyze.length; i += batchSize) {
+          const batch = cavesToAnalyze.slice(i, i + batchSize);
+          this.logger.info(`[${i + 1}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 条回声洞...`);
+          const successCountInBatch = await this.analyzeAndStoreBatch(batch);
+          totalSuccessCount += successCountInBatch;
         }
-        return `已分析 ${successCount} 个回声洞`;
+        return `已分析 ${totalSuccessCount} 个回声洞`;
       } catch (error) {
         this.logger.error("分析回声洞失败:", error);
         return `操作失败: ${error.message}`;
@@ -1060,30 +1057,17 @@ var AIManager = class {
   }
   /**
    * @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 }>} 一个包含查重结果的对象。
+   * @param {StoredElement[]} newElements - 新提交的内容元素数组。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
+   * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
    */
-  async checkForDuplicates(newElements, newMediaToSave, mediaBuffers) {
+  async checkForDuplicates(newElements, mediaBuffers) {
     try {
-      const newAnalysis = await this.getAnalysis(newElements, newMediaToSave, mediaBuffers);
-      if (!newAnalysis || newAnalysis.keywords.length === 0) return { duplicate: false };
-      const allMeta = await this.ctx.database.get("cave_meta", {});
-      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 });
-          return cave;
-        }
-      }))).filter(Boolean);
+      const dummyCave = { id: 0, elements: newElements, channelId: "", userId: "", userName: "", status: "preload", time: /* @__PURE__ */ new Date() };
+      const mediaMap = mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0;
+      const [newAnalysis] = await this.getAnalyses([dummyCave], mediaMap);
+      if (!newAnalysis?.keywords?.length) return { duplicate: false };
+      const potentialDuplicates = await this.findPotentialDuplicates(newAnalysis.keywords);
       if (potentialDuplicates.length === 0) return { duplicate: false };
       const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text").map((el) => el.content).join(" "), "formatContent");
       const userMessage = {
@@ -1105,74 +1089,92 @@ var AIManager = class {
   }
   /**
    * @description 对单个回声洞对象执行完整的分析和存储流程。
-   * @param {CaveObject} cave - 需要被分析的完整回声洞对象，包含 `id` 和 `elements`。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - （可选）与该回声洞相关的、已加载到内存的媒体文件 Buffer。
-   * @returns {Promise<void>} 操作完成后 resolve 的 Promise。
-   * @throws {Error} 如果在分析或数据库存储过程中发生错误，则会向上抛出异常。
+   * @param {CaveObject} cave - 要分析的回声洞对象。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
+   * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
    */
   async analyzeAndStore(cave, mediaBuffers) {
-    try {
-      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;
+    const mediaMap = mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0;
+    const [result] = await this.getAnalyses([cave], mediaMap);
+    if (result) {
+      await this.ctx.database.upsert("cave_meta", [{
+        cave: cave.id,
+        keywords: result.keywords || [],
+        description: result.description || "",
+        rating: Math.max(0, Math.min(100, result.rating || 0))
+      }]);
     }
   }
   /**
-   * @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`。
+   * @description 对一批回声洞执行分析并存储结果。
+   * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+   * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
    */
-  async getAnalysis(elements, mediaToSave, mediaBuffers) {
-    const userContent = [];
-    const combinedText = elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join("\n");
-    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) {
-      try {
-        let buffer;
-        if (mediaMap.has(el.file)) {
-          buffer = mediaMap.get(el.file);
-        } else if (mediaToSave) {
-          const item = mediaToSave.find((m) => m.fileName === el.file);
-          if (item) buffer = Buffer.from(await this.ctx.http.get(item.sourceUrl, { responseType: "arraybuffer" }));
-        } else {
-          buffer = await this.fileManager.readFile(el.file);
-        }
-        if (buffer) {
-          const mimeType = path3.extname(el.file).toLowerCase() === ".png" ? "image/png" : "image/jpeg";
-          userContent.push({
-            type: "image_url",
-            image_url: { url: `data:${mimeType};base64,${buffer.toString("base64")}` }
-          });
-        }
-      } catch (error) {
-        this.logger.warn(`分析内容（${el.file}）失败:`, error);
-      }
-    }
-    if (userContent.length === 0) return null;
-    const userMessage = { role: "user", content: userContent };
-    return await this.requestAI([userMessage], this.config.AnalysePrompt, this.config.aiAnalyseSchema);
+  async analyzeAndStoreBatch(caves) {
+    const results = await this.getAnalyses(caves);
+    if (!results?.length) return 0;
+    const caveMetaObjects = results.map((res) => ({
+      cave: res.id,
+      keywords: res.keywords || [],
+      description: res.description || "",
+      rating: Math.max(0, Math.min(100, res.rating || 0))
+    }));
+    await this.ctx.database.upsert("cave_meta", caveMetaObjects);
+    return caveMetaObjects.length;
   }
   /**
-   * @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 返回错误时，抛出异常。
+   * @description 根据新内容的关键词，查找并返回可能重复的回声洞。
+   * @param {string[]} newKeywords - 新内容的关键词数组。
+   * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
    */
-  async requestAI(messages, systemPrompt, schemaString) {
+  async findPotentialDuplicates(newKeywords) {
+    const allMeta = await this.ctx.database.get("cave_meta", {}, { fields: ["cave", "keywords"] });
+    const newKeywordsSet = new Set(newKeywords);
+    const similarCaveIds = allMeta.filter((meta) => {
+      if (!meta.keywords?.length) return false;
+      const existingKeywordsSet = new Set(meta.keywords);
+      const intersection = new Set([...newKeywordsSet].filter((x) => existingKeywordsSet.has(x)));
+      const union = /* @__PURE__ */ new Set([...newKeywordsSet, ...existingKeywordsSet]);
+      const similarity = union.size > 0 ? intersection.size / union.size : 0;
+      return similarity * 100 >= 80;
+    }).map((meta) => meta.cave);
+    if (similarCaveIds.length === 0) return [];
+    return this.ctx.database.get("cave", { id: { $in: similarCaveIds } });
+  }
+  /**
+   * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
+   * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+   * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
+   * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+   */
+  async getAnalyses(caves, mediaBufferMap) {
+    const batchPayload = await Promise.all(caves.map(async (cave) => {
+      const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join("\n");
+      const imagesBase64 = (await Promise.all(
+        cave.elements.filter((el) => el.type === "image" && el.file).map(async (el) => {
+          try {
+            const buffer = mediaBufferMap?.get(el.file) ?? await this.fileManager.readFile(el.file);
+            const mimeType = path3.extname(el.file).toLowerCase() === ".png" ? "image/png" : "image/jpeg";
+            return `data:${mimeType};base64,${buffer.toString("base64")}`;
+          } catch (error) {
+            this.logger.warn(`读取文件（${el.file}）失败:`, error);
+            return null;
+          }
+        })
+      )).filter(Boolean);
+      return { id: cave.id, text: combinedText, images: imagesBase64 };
+    }));
+    const nonEmptyPayload = batchPayload.filter((p) => p.text.trim() || p.images.length > 0);
+    if (nonEmptyPayload.length === 0) return [];
+    const userMessage = { role: "user", content: JSON.stringify(nonEmptyPayload) };
+    const response = await this.requestAI([userMessage], this.config.AnalysePrompt, this.config.aiAnalyseSchema);
+    return response.analyses || [];
+  }
+  /**
+   * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
+   * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
+   */
+  async ensureRateLimit() {
     const now = Date.now();
     if (now > this.rateLimitResetTime) {
       this.rateLimitResetTime = now + 6e4;
@@ -1180,45 +1182,43 @@ var AIManager = class {
     }
     if (this.requestCount >= this.config.aiRPM) {
       const delay = this.rateLimitResetTime - now;
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
       this.rateLimitResetTime = Date.now() + 6e4;
       this.requestCount = 0;
     }
-    let schema = JSON.parse(schemaString);
-    const toolName = "extract_data";
+  }
+  /**
+   * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
+   * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
+   * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
+   * @param {string} schemaString - 定义期望响应格式的 JSON Schema 字符串。
+   * @returns {Promise<any>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+   * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
+   */
+  async requestAI(messages, systemPrompt, schemaString) {
+    await this.ensureRateLimit();
     const payload = {
       model: this.config.aiModel,
       messages: [{ role: "system", content: systemPrompt }, ...messages],
-      tools: [{
-        type: "function",
-        function: {
-          name: toolName,
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: "extract_data",
           description: "根据提供的内容提取或分析信息。",
-          parameters: schema
+          schema: JSON.parse(schemaString)
         }
-      }],
-      tool_choice: { type: "function", function: { name: toolName } }
+      }
     };
     const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/chat/completions`;
     const headers = {
       "Content-Type": "application/json",
       "Authorization": `Bearer ${this.config.aiApiKey}`
     };
-    try {
-      this.requestCount++;
-      const response = await this.http.post(fullUrl, payload, { headers, timeout: 9e4 });
-      const toolCall = response.choices?.[0]?.message?.tool_calls?.[0];
-      if (toolCall?.function?.arguments) {
-        return JSON.parse(toolCall.function.arguments);
-      } else {
-        this.logger.error("AI 响应格式不正确:", JSON.stringify(response));
-        throw new Error("AI 响应格式不正确");
-      }
-    } catch (error) {
-      const errorMessage = error.response ? JSON.stringify(error.response.data) : error.message;
-      this.logger.error(`请求 API 失败: ${errorMessage}`);
-      throw error;
-    }
+    this.requestCount++;
+    const response = await this.http.post(fullUrl, payload, { headers, timeout: 9e4 });
+    const content = response.choices?.[0]?.message?.content;
+    if (typeof content === "string" && content.trim()) return JSON.parse(content);
+    throw new Error("响应无效");
   }
 };
 
@@ -1249,8 +1249,8 @@ var Config = import_koishi3.Schema.intersect([
   import_koishi3.Schema.object({
     enablePend: import_koishi3.Schema.boolean().default(false).description("启用审核"),
     enableSimilarity: import_koishi3.Schema.boolean().default(false).description("启用查重"),
-    textThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(90).description("文本相似度阈值 (%)"),
-    imageThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(90).description("图片相似度阈值 (%)")
+    textThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("文本相似度阈值 (%)"),
+    imageThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("图片相似度阈值 (%)")
   }).description("复核配置"),
   import_koishi3.Schema.object({
     enableAI: import_koishi3.Schema.boolean().default(false).description("启用 AI"),
@@ -1258,28 +1258,42 @@ var Config = import_koishi3.Schema.intersect([
     aiApiKey: import_koishi3.Schema.string().description("密钥 (Key)").role("secret"),
     aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
     aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60),
-    AnalysePrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我提供的内容，总结关键词，概括内容并进行评分。`).description("分析 Prompt"),
+    AnalysePrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我以JSON格式提供的一组内容（每项包含ID、文本和图片），为每一项内容总结关键词、概括内容并评分。你需要返回一个包含所有分析结果的JSON对象。`).description("分析 Prompt"),
     aiAnalyseSchema: import_koishi3.Schema.string().role("textarea").default(
       `{
         "type": "object",
         "properties": {
-          "keywords": {
+          "analyses": {
             "type": "array",
-            "items": { "type": "string" },
-            "description": "使用尽可能多的关键词准确形容内容"
-          },
-          "description": {
-            "type": "string",
-            "description": "概括或描述这部分内容"
-          },
-          "rating": {
-            "type": "integer",
-            "description": "对内容的综合质量进行评分",
-            "minimum": 0,
-            "maximum": 100
+            "description": "分析结果的数组",
+            "items": {
+              "type": "object",
+              "properties": {
+                "id": {
+                  "type": "integer",
+                  "description": "内容的唯一ID"
+                },
+                "keywords": {
+                  "type": "array",
+                  "items": { "type": "string" },
+                  "description": "使用尽可能多的关键词准确形容内容"
+                },
+                "description": {
+                  "type": "string",
+                  "description": "概括或描述这部分内容"
+                },
+                "rating": {
+                  "type": "integer",
+                  "description": "对内容的综合质量进行评分",
+                  "minimum": 0,
+                  "maximum": 100
+                }
+              },
+              "required": ["id", "keywords", "description", "rating"]
+            }
           }
         },
-        "required": ["keywords", "description", "rating"]
+        "required": ["analyses"]
       }`
     ).description("分析 JSON Schema"),
     aiCheckPrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
@@ -1395,7 +1409,7 @@ function apply(ctx, config) {
         imageHashesToStore = checkResult.imageHashesToStore;
       }
       if (aiManager) {
-        const duplicateResult = await aiManager.checkForDuplicates(finalElementsForDb, mediaToSave, downloadedMedia);
+        const duplicateResult = await aiManager.checkForDuplicates(finalElementsForDb, downloadedMedia);
         if (duplicateResult && duplicateResult.duplicate) return `内容与回声洞（${duplicateResult.id}）重复`;
       }
       const userName = (config.enableName ? await profileManager.getNickname(session.userId) : null) || session.username;

package/package.json

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