koishi-plugin-best-cave 2.7.10 → 2.7.12

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` 表的完整对象模型。
@@ -33,11 +33,11 @@ export declare class HashManager {
      */
     registerCommands(cave: any): void;
     /**
-     * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
-     * @param cave - 回声洞对象。
-     * @returns 生成的哈希对象数组。
+     * @description 扫描并修复单个图片 Buffer，移除文件结束符之后的多余数据。
+     * @param imageBuffer - 原始的图片 Buffer。
+     * @returns 修复后的图片 Buffer。如果无需修复，则返回原始 Buffer。
      */
-    generateAllHashesForCave(cave: Pick<CaveObject, 'id' | 'elements'>): Promise<CaveHashObject[]>;
+    sanitizeImageBuffer(imageBuffer: Buffer): Buffer;
     /**
      * @description 执行一维离散余弦变换 (DCT-II) 的方法。
      * @param input - 输入的数字数组。

package/lib/Utils.d.ts

@@ -57,7 +57,7 @@ export declare function processMessageElements(sourceElements: h[], newId: numbe
  * @description 执行文本 (Simhash) 和图片 (pHash) 相似度查重。
  * @returns 一个对象，指示是否发现重复项；如果未发现，则返回生成的哈希。
  */
-export declare function performSimilarityChecks(ctx: Context, config: Config, hashManager: HashManager, finalElementsForDb: StoredElement[], downloadedMedia: {
+export declare function performSimilarityChecks(ctx: Context, config: Config, hashManager: HashManager, logger: Logger, finalElementsForDb: StoredElement[], downloadedMedia: {
     fileName: string;
     buffer: Buffer;
 }[]): Promise<{
@@ -81,7 +81,7 @@ export declare function performSimilarityChecks(ctx: Context, config: Config, ha
 export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, cave: CaveObject, downloadedMedia: {
     fileName: string;
     buffer: Buffer;
-}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active'>;
+}[], reusableIds: Set<number>, needsReview: boolean): Promise<'pending' | 'active'>;
 /**
  * @description 校验会话是否来自指定的管理群组。
  * @param session 当前会话。

package/lib/index.js

@@ -450,42 +450,46 @@ async function processMessageElements(sourceElements, newId, session, creationTi
   return { finalElementsForDb, mediaToSave };
 }
 __name(processMessageElements, "processMessageElements");
-async function performSimilarityChecks(ctx, config, hashManager, finalElementsForDb, downloadedMedia) {
-  const textHashesToStore = [];
-  const imageHashesToStore = [];
-  const combinedText = finalElementsForDb.filter((el) => el.type === "text" && typeof el.content === "string").map((el) => el.content).join(" ");
-  if (combinedText) {
-    const newSimhash = hashManager.generateTextSimhash(combinedText);
-    if (newSimhash) {
-      const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
-      for (const existing of existingTextHashes) {
-        const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
-        if (similarity >= config.textThreshold) return { duplicate: true, message: `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+async function performSimilarityChecks(ctx, config, hashManager, logger2, finalElementsForDb, downloadedMedia) {
+  try {
+    const textHashesToStore = [];
+    const imageHashesToStore = [];
+    const combinedText = finalElementsForDb.filter((el) => el.type === "text" && typeof el.content === "string").map((el) => el.content).join(" ");
+    if (combinedText) {
+      const newSimhash = hashManager.generateTextSimhash(combinedText);
+      if (newSimhash) {
+        const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
+        for (const existing of existingTextHashes) {
+          const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
+          if (similarity >= config.textThreshold) return { duplicate: true, message: `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+        }
+        textHashesToStore.push({ hash: newSimhash, type: "text" });
       }
-      textHashesToStore.push({ hash: newSimhash, type: "text" });
     }
-  }
-  if (downloadedMedia.length > 0) {
-    const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
-    for (const media of downloadedMedia) {
-      if ([".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
-        const imageHash = await hashManager.generatePHash(media.buffer);
-        for (const existing of allExistingImageHashes) {
-          const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
-          if (similarity >= config.imageThreshold) return { duplicate: true, message: `图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+    if (downloadedMedia.length > 0) {
+      const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
+      for (const media of downloadedMedia) {
+        if ([".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
+          const imageHash = await hashManager.generatePHash(media.buffer);
+          for (const existing of allExistingImageHashes) {
+            const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
+            if (similarity >= config.imageThreshold) return { duplicate: true, message: `图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
+          }
+          imageHashesToStore.push({ hash: imageHash, type: "image" });
+          allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "image" });
         }
-        imageHashesToStore.push({ hash: imageHash, type: "image" });
-        allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "image" });
       }
     }
+    return { duplicate: false, textHashesToStore, imageHashesToStore };
+  } catch (error) {
+    logger2.warn("相似度比较失败:", error);
+    return { duplicate: false, textHashesToStore: [], imageHashesToStore: [] };
   }
-  return { duplicate: false, textHashesToStore, imageHashesToStore };
 }
 __name(performSimilarityChecks, "performSimilarityChecks");
-async function handleFileUploads(ctx, config, fileManager, logger2, cave, downloadedMedia, reusableIds, session) {
+async function handleFileUploads(ctx, config, fileManager, logger2, cave, downloadedMedia, reusableIds, needsReview) {
   try {
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
-    const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
     const finalStatus = needsReview ? "pending" : "active";
     await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
     return finalStatus;
@@ -741,10 +745,27 @@ var HashManager = class {
         for (const cave2 of cavesToProcess) {
           processedCaveCount++;
           try {
-            const newHashesForCave = await this.generateAllHashesForCave(cave2);
-            if (newHashesForCave.length > 0) {
-              hashesToInsert.push(...newHashesForCave);
+            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++;
@@ -828,37 +849,12 @@ var HashManager = class {
         if (!cavesToProcess.length) return "无可修复的回声洞";
         let fixedFiles = 0;
         let errorCount = 0;
-        const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-        const JPEG_SIGNATURE = Buffer.from([255, 216]);
-        const GIF_SIGNATURE = Buffer.from("GIF");
         for (const cave2 of cavesToProcess) {
           const imageElements = cave2.elements.filter((el) => el.type === "image" && el.file);
           for (const element of imageElements) {
             try {
               const originalBuffer = await this.fileManager.readFile(element.file);
-              let sanitizedBuffer = originalBuffer;
-              if (originalBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
-                const IEND_CHUNK = Buffer.from("IEND");
-                const iendIndex = originalBuffer.lastIndexOf(IEND_CHUNK);
-                if (iendIndex !== -1) {
-                  const endOfPngData = iendIndex + 8;
-                  if (originalBuffer.length > endOfPngData) sanitizedBuffer = originalBuffer.slice(0, endOfPngData);
-                }
-              } else if (originalBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
-                const EOI_MARKER = Buffer.from([255, 217]);
-                const eoiIndex = originalBuffer.lastIndexOf(EOI_MARKER);
-                if (eoiIndex !== -1) {
-                  const endOfJpegData = eoiIndex + 2;
-                  if (originalBuffer.length > endOfJpegData) sanitizedBuffer = originalBuffer.slice(0, endOfJpegData);
-                }
-              } else if (originalBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
-                const GIF_TERMINATOR = Buffer.from([59]);
-                const terminatorIndex = originalBuffer.lastIndexOf(GIF_TERMINATOR);
-                if (terminatorIndex !== -1) {
-                  const endOfGifData = terminatorIndex + 1;
-                  if (originalBuffer.length > endOfGifData) sanitizedBuffer = originalBuffer.slice(0, endOfGifData);
-                }
-              }
+              const sanitizedBuffer = this.sanitizeImageBuffer(originalBuffer);
               if (!originalBuffer.equals(sanitizedBuffer)) {
                 await this.fileManager.saveFile(element.file, sanitizedBuffer);
                 fixedFiles++;
@@ -879,36 +875,38 @@ var HashManager = class {
     });
   }
   /**
-   * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
-   * @param cave - 回声洞对象。
-   * @returns 生成的哈希对象数组。
+   * @description 扫描并修复单个图片 Buffer，移除文件结束符之后的多余数据。
+   * @param imageBuffer - 原始的图片 Buffer。
+   * @returns 修复后的图片 Buffer。如果无需修复，则返回原始 Buffer。
    */
-  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);
+  sanitizeImageBuffer(imageBuffer) {
+    const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const JPEG_SIGNATURE = Buffer.from([255, 216]);
+    const GIF_SIGNATURE = Buffer.from("GIF");
+    let sanitizedBuffer = imageBuffer;
+    if (imageBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
+      const IEND_CHUNK = Buffer.from("IEND");
+      const iendIndex = imageBuffer.lastIndexOf(IEND_CHUNK);
+      if (iendIndex !== -1) {
+        const endOfPngData = iendIndex + 8;
+        if (imageBuffer.length > endOfPngData) sanitizedBuffer = imageBuffer.slice(0, endOfPngData);
       }
-    }, "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;
+    } else if (imageBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
+      const EOI_MARKER = Buffer.from([255, 217]);
+      const eoiIndex = imageBuffer.lastIndexOf(EOI_MARKER);
+      if (eoiIndex !== -1) {
+        const endOfJpegData = eoiIndex + 2;
+        if (imageBuffer.length > endOfJpegData) sanitizedBuffer = imageBuffer.slice(0, endOfJpegData);
+      }
+    } else if (imageBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
+      const GIF_TERMINATOR = Buffer.from([59]);
+      const terminatorIndex = imageBuffer.lastIndexOf(GIF_TERMINATOR);
+      if (terminatorIndex !== -1) {
+        const endOfGifData = terminatorIndex + 1;
+        if (imageBuffer.length > endOfGifData) sanitizedBuffer = imageBuffer.slice(0, endOfGifData);
       }
     }
-    return tempHashes;
+    return sanitizedBuffer;
   }
   /**
    * @description 执行一维离散余弦变换 (DCT-II) 的方法。
@@ -1016,7 +1014,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;
@@ -1041,28 +1042,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}`;
@@ -1071,41 +1070,25 @@ 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 = {
         role: "user",
-        content: [{
-          type: "input_text",
-          text: JSON.stringify({
-            new_content: { text: formatContent(newElements) },
-            existing_contents: potentialDuplicates.map((cave) => ({ id: cave.id, text: formatContent(cave.elements) }))
-          })
-        }]
+        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 {
@@ -1119,74 +1102,96 @@ 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);
+      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,
-          ...result,
+          keywords: result.keywords || [],
+          description: result.description || "",
           rating: Math.max(0, Math.min(100, result.rating || 0))
         }]);
       }
     } catch (error) {
-      this.logger.error(`分析回声洞（${cave.id}）失败:`, error);
-      throw error;
+      this.logger.error(`分析回声洞（${cave.id}）出错:`, error);
     }
   }
   /**
-   * @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: "input_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: "input_image",
-            image_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;
@@ -1194,51 +1199,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;
-    try {
-      schema = JSON.parse(schemaString);
-    } catch (error) {
-      this.logger.error("解析 JSON Schema 失败:", error);
-      throw new Error("无效的 JSON Schema 配置");
-    }
+  }
+  /**
+   * @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,
-      input: [
-        { role: "system", content: systemPrompt },
-        ...messages
-      ],
-      text: {
-        format: {
-          type: "json_schema",
-          name: "extracted_data",
-          schema
+      messages: [{ role: "system", content: systemPrompt }, ...messages],
+      response_format: {
+        type: "json_schema",
+        json_schema: {
+          name: "extract_data",
+          description: "根据提供的内容提取或分析信息。",
+          schema: JSON.parse(schemaString)
         }
       }
     };
-    const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/responses`;
+    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 responseText = response.output?.[0]?.content?.[0]?.text;
-      if (responseText) {
-        return JSON.parse(responseText);
-      } 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("响应无效");
   }
 };
 
@@ -1276,30 +1273,44 @@ var Config = import_koishi3.Schema.intersect([
     enableAI: import_koishi3.Schema.boolean().default(false).description("启用 AI"),
     aiEndpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta/openai"),
     aiApiKey: import_koishi3.Schema.string().description("密钥 (Key)").role("secret"),
-    aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
+    aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-1.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"),
@@ -1409,17 +1420,18 @@ function apply(ctx, config) {
       let textHashesToStore = [];
       let imageHashesToStore = [];
       if (hashManager) {
-        const checkResult = await performSimilarityChecks(ctx, config, hashManager, finalElementsForDb, downloadedMedia);
+        for (const media of downloadedMedia) media.buffer = hashManager.sanitizeImageBuffer(media.buffer);
+        const checkResult = await performSimilarityChecks(ctx, config, hashManager, logger, finalElementsForDb, downloadedMedia);
         if (checkResult.duplicate) return checkResult.message;
         textHashesToStore = checkResult.textHashesToStore;
         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;
-      const needsReview = config.enablePend && session.channelId !== config.adminChannel?.split(":")[1];
+      const needsReview = config.enablePend && session.cid !== config.adminChannel;
       let finalStatus = hasMedia ? "preload" : needsReview ? "pending" : "active";
       const newCave = await ctx.database.create("cave", {
         id: newId,
@@ -1430,7 +1442,7 @@ function apply(ctx, config) {
         status: finalStatus,
         time: creationTime
       });
-      if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, session);
+      if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, needsReview);
       if (finalStatus !== "preload") {
         newCave.status = finalStatus;
         if (aiManager) await aiManager.analyzeAndStore(newCave, downloadedMedia);
@@ -1464,7 +1476,7 @@ function apply(ctx, config) {
       const [targetCave] = await ctx.database.get("cave", { id, status: "active" });
       if (!targetCave) return `回声洞（${id}）不存在`;
       const isAuthor = targetCave.userId === session.userId;
-      const isAdmin = session.channelId === config.adminChannel?.split(":")[1];
+      const isAdmin = session.cid === config.adminChannel;
       if (!isAuthor && !isAdmin) return "你没有权限删除这条回声洞";
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform, "已删除");
@@ -1477,8 +1489,8 @@ function apply(ctx, config) {
   });
   cave.subcommand(".list", "查询投稿统计").option("user", "-u <user:user> 指定用户").option("all", "-a 查看排行").action(async ({ session, options }) => {
     if (options.all) {
-      const adminChannelId = config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
+      const adminError = requireAdmin(session, config);
+      if (adminError) return adminError;
       try {
         const aggregatedStats = await ctx.database.select("cave", { status: "active" }).groupBy(["userId", "userName"], { count: /* @__PURE__ */ __name((row) => import_koishi3.$.count(row.id), "count") }).execute();
         if (!aggregatedStats.length) return "目前没有回声洞投稿";

package/package.json

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