koishi-plugin-best-cave 2.7.12 → 2.7.14

package/lib/AIManager.d.ts

@@ -48,55 +48,44 @@ export declare class AIManager {
      * @description 对新提交的内容执行 AI 驱动的查重检查。
      * @param {StoredElement[]} newElements - 新提交的内容元素数组。
      * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
-     * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
+     * @returns {Promise<{ duplicate: boolean; ids?: number[] }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID 数组（如果存在）。
      */
     checkForDuplicates(newElements: StoredElement[], mediaBuffers?: {
         fileName: string;
         buffer: Buffer;
     }[]): Promise<{
         duplicate: boolean;
-        id?: number;
+        ids?: number[];
     }>;
     /**
-     * @description 对单个回声洞对象执行完整的分析和存储流程。
-     * @param {CaveObject} cave - 要分析的回声洞对象。
-     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
-     * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
-     */
-    analyzeAndStore(cave: CaveObject, mediaBuffers?: {
-        fileName: string;
-        buffer: Buffer;
-    }[]): Promise<void>;
-    /**
-     * @description 对一批回声洞执行分析并存储结果。
+     * @description 对单个或批量回声洞执行完整的分析和存储流程。
      * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+     * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，仅在分析新内容时使用。
      * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
      */
-    private analyzeAndStoreBatch;
+    analyzeAndStore(caves: CaveObject[], mediaBuffers?: {
+        fileName: string;
+        buffer: Buffer;
+    }[]): Promise<number>;
     /**
-     * @description 根据新内容的关键词，查找并返回可能重复的回声洞。
-     * @param {string[]} newKeywords - 新内容的关键词数组。
-     * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
+     * @description 调用 AI 判断两个回声洞内容是否重复或高度相似。
+     * @param {CaveObject} caveA - 第一个回声洞对象。
+     * @param {CaveObject} caveB - 第二个回声洞对象。
+     * @returns {Promise<boolean>} 如果内容相似则返回 true，否则返回 false。
      */
-    private findPotentialDuplicates;
+    private isContentDuplicateAI;
     /**
      * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
      * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
      * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
-     * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+     * @returns {Promise<CaveMetaObject[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
      */
     private getAnalyses;
     /**
-     * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
-     * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
-     */
-    private ensureRateLimit;
-    /**
-     * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑。
+     * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑，并稳健地解析 JSON 响应。
      * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
      * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
-     * @param {string} schemaString - 定义期望响应格式的 JSON Schema 字符串。
-     * @returns {Promise<any>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+     * @returns {Promise<T>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
      * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
      */
     private requestAI;

package/lib/index.d.ts

@@ -62,10 +62,6 @@ export interface Config {
     aiApiKey?: string;
     aiModel?: string;
     aiRPM?: number;
-    AnalysePrompt?: string;
-    aiCheckPrompt?: string;
-    aiAnalyseSchema?: string;
-    aiCheckSchema?: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -1058,7 +1058,7 @@ var AIManager = class {
         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);
+          const successCountInBatch = await this.analyzeAndStore(batch);
           totalSuccessCount += successCountInBatch;
         }
         return `已分析 ${totalSuccessCount} 个回声洞`;
@@ -1067,102 +1067,130 @@ var AIManager = class {
         return `操作失败: ${error.message}`;
       }
     });
+    cave.subcommand(".compare", "比较重复性", { hidden: true }).usage("检查回声洞，找出可能重复的内容。").action(async ({ session }) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
+      await session.send("正在检查，请稍候...");
+      try {
+        const allMeta = await this.ctx.database.get("cave_meta", {});
+        if (allMeta.length < 2) return "无可比较数据";
+        const allCaves = new Map((await this.ctx.database.get("cave", { status: "active" })).map((c) => [c.id, c]));
+        const foundPairs = /* @__PURE__ */ new Set();
+        const checkedPairs = /* @__PURE__ */ new Set();
+        for (let i = 0; i < allMeta.length; i++) {
+          for (let j = i + 1; j < allMeta.length; j++) {
+            const meta1 = allMeta[i];
+            const meta2 = allMeta[j];
+            const pairKey = [meta1.cave, meta2.cave].sort((a, b) => a - b).join("-");
+            if (checkedPairs.has(pairKey)) continue;
+            const keywords1 = new Set(meta1.keywords);
+            const keywords2 = new Set(meta2.keywords);
+            const intersection = new Set([...keywords1].filter((x) => keywords2.has(x)));
+            const union = /* @__PURE__ */ new Set([...keywords1, ...keywords2]);
+            const similarity = union.size > 0 ? intersection.size / union.size : 0;
+            if (similarity * 100 >= 80) {
+              const cave1 = allCaves.get(meta1.cave);
+              const cave2 = allCaves.get(meta2.cave);
+              if (cave1 && cave2 && await this.isContentDuplicateAI(cave1, cave2)) foundPairs.add(`${cave1.id} & ${cave2.id}`);
+              checkedPairs.add(pairKey);
+            }
+          }
+        }
+        if (foundPairs.size === 0) return "未发现高重复性的内容";
+        let report = `已发现 ${foundPairs.size} 组高重复性的内容:
+`;
+        report += [...foundPairs].join("\n");
+        return report.trim();
+      } catch (error) {
+        this.logger.error("检查重复性失败:", error);
+        return `检查失败: ${error.message}`;
+      }
+    });
   }
   /**
    * @description 对新提交的内容执行 AI 驱动的查重检查。
    * @param {StoredElement[]} newElements - 新提交的内容元素数组。
    * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组。
-   * @returns {Promise<{ duplicate: boolean; id?: number }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID（如果存在）。
+   * @returns {Promise<{ duplicate: boolean; ids?: number[] }>} 一个 Promise，解析为一个对象，指示内容是否重复以及重复的回声洞 ID 数组（如果存在）。
    */
   async checkForDuplicates(newElements, mediaBuffers) {
     try {
       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: 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
-      };
+      const [newAnalysis] = await this.getAnalyses([dummyCave], mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0);
+      if (!newAnalysis?.keywords?.length) return { duplicate: false, ids: [] };
+      const allMeta = await this.ctx.database.get("cave_meta", {}, { fields: ["cave", "keywords"] });
+      const newKeywordsSet = new Set(newAnalysis.keywords);
+      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 { duplicate: false, ids: [] };
+      const potentialDuplicates = await this.ctx.database.get("cave", { id: { $in: similarCaveIds } });
+      const duplicateIds = [];
+      for (const existingCave of potentialDuplicates) if (await this.isContentDuplicateAI(dummyCave, existingCave)) duplicateIds.push(existingCave.id);
+      return { duplicate: duplicateIds.length > 0, ids: duplicateIds };
     } catch (error) {
       this.logger.error("查重回声洞出错:", error);
-      return { duplicate: false };
+      return { duplicate: false, ids: [] };
     }
   }
   /**
-   * @description 对单个回声洞对象执行完整的分析和存储流程。
-   * @param {CaveObject} cave - 要分析的回声洞对象。
-   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，用于新提交内容的分析。
-   * @returns {Promise<void>} 分析和存储操作完成后解析的 Promise。
+   * @description 对单个或批量回声洞执行完整的分析和存储流程。
+   * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓冲区数组，仅在分析新内容时使用。
+   * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
    */
-  async analyzeAndStore(cave, mediaBuffers) {
+  async analyzeAndStore(caves, mediaBuffers) {
     try {
       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))
-        }]);
-      }
+      const results = await this.getAnalyses(caves, mediaMap);
+      if (!results?.length) return 0;
+      const caveMetaObjects = results.map((res) => ({
+        cave: res.cave,
+        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;
     } catch (error) {
-      this.logger.error(`分析回声洞（${cave.id}）出错:`, error);
+      const caveIds = caves.map((c) => c.id).join(", ");
+      this.logger.error(`分析回声洞 (${caveIds}) 出错:`, error);
+      return 0;
     }
   }
   /**
-   * @description 对一批回声洞执行分析并存储结果。
-   * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
-   * @returns {Promise<number>} 一个 Promise，解析为成功分析和存储的条目数。
-   */
-  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 根据新内容的关键词，查找并返回可能重复的回声洞。
-   * @param {string[]} newKeywords - 新内容的关键词数组。
-   * @returns {Promise<CaveObject[]>} 一个 Promise，解析为可能重复的回声洞对象数组。
+   * @description 调用 AI 判断两个回声洞内容是否重复或高度相似。
+   * @param {CaveObject} caveA - 第一个回声洞对象。
+   * @param {CaveObject} caveB - 第二个回声洞对象。
+   * @returns {Promise<boolean>} 如果内容相似则返回 true，否则返回 false。
    */
-  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 } });
+  async isContentDuplicateAI(caveA, caveB) {
+    try {
+      const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" "), "formatContent");
+      const userMessage = {
+        role: "user",
+        content: JSON.stringify({
+          content_a: { id: caveA.id, text: formatContent(caveA.elements) },
+          content_b: { id: caveB.id, text: formatContent(caveB.elements) }
+        })
+      };
+      const prompt = `你是一位内容查重专家。请判断 content_a 和 content_b 是否重复或高度相似。你的回复必须且只能是一个包裹在 \`\`\`json ... \`\`\` 代码块中的 JSON 对象，该对象仅包含一个键 "duplicate" (布尔值)。`;
+      const response = await this.requestAI([userMessage], prompt);
+      return response.duplicate || false;
+    } catch (error) {
+      this.logger.error(`比较回声洞（${caveA.id}）与（${caveB.id}）失败:`, error);
+      return false;
+    }
   }
   /**
    * @description 为一批回声洞准备内容，并向 AI 发送单个请求以获取所有分析结果。
    * @param {CaveObject[]} caves - 要分析的回声洞对象数组。
    * @param {Map<string, Buffer>} [mediaBufferMap] - 可选的媒体文件名到其缓冲区的映射。
-   * @returns {Promise<any[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
+   * @returns {Promise<CaveMetaObject[]>} 一个 Promise，解析为 AI 返回的分析结果数组。
    */
   async getAnalyses(caves, mediaBufferMap) {
     const batchPayload = await Promise.all(caves.map(async (cave) => {
@@ -1184,14 +1212,23 @@ var AIManager = class {
     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 || [];
+    const analysePrompt = `你是一位内容分析专家。请使用中文，分析我以JSON格式提供的一组内容，为每一项内容总结关键词、概括内容并评分。你的回复必须且只能是一个包裹在 \`\`\`json ... \`\`\` 代码块中的有效 JSON 对象。该JSON对象应有一个 "analyses" 键，其值为一个数组。数组中的每个对象都必须包含 "id" (整数), "keywords" (字符串数组), "description" (字符串), 和 "rating" (0-100的整数)。`;
+    const response = await this.requestAI([userMessage], analysePrompt);
+    return (response.analyses || []).map((res) => ({
+      cave: res.id,
+      keywords: res.keywords,
+      description: res.description,
+      rating: res.rating
+    }));
   }
   /**
-   * @description 确保请求不会超过设定的速率限制（RPM）。如果需要，会延迟执行。
-   * @returns {Promise<void>} 当可以继续发送请求时解析的 Promise。
+   * @description 封装了向 OpenAI 兼容的 API 发送请求的底层逻辑，并稳健地解析 JSON 响应。
+   * @param {any[]} messages - 发送给 AI 的消息数组，遵循 OpenAI 格式。
+   * @param {string} systemPrompt - 系统提示词，用于指导 AI 的行为。
+   * @returns {Promise<T>} 一个 Promise，解析为从 AI 接收到的、解析后的 JSON 对象。
+   * @throws {Error} 当 AI 返回空或无效内容时抛出错误。
    */
-  async ensureRateLimit() {
+  async requestAI(messages, systemPrompt) {
     const now = Date.now();
     if (now > this.rateLimitResetTime) {
       this.rateLimitResetTime = now + 6e4;
@@ -1203,28 +1240,9 @@ var AIManager = class {
       this.rateLimitResetTime = Date.now() + 6e4;
       this.requestCount = 0;
     }
-  }
-  /**
-   * @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],
-      response_format: {
-        type: "json_schema",
-        json_schema: {
-          name: "extract_data",
-          description: "根据提供的内容提取或分析信息。",
-          schema: JSON.parse(schemaString)
-        }
-      }
+      messages: [{ role: "system", content: systemPrompt }, ...messages]
     };
     const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/chat/completions`;
     const headers = {
@@ -1234,8 +1252,22 @@ var AIManager = class {
     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("响应无效");
+    this.logger.info("原始响应:", content);
+    try {
+      const jsonRegex = /```json\s*([\s\S]*?)\s*```/;
+      const match = content?.match(jsonRegex);
+      let jsonString = "";
+      if (match && match[1]) {
+        jsonString = match[1];
+      } else {
+        jsonString = content;
+      }
+      return JSON.parse(jsonString);
+    } catch (error) {
+      this.logger.error("解析 JSON 失败:", error);
+      this.logger.error("原始响应:", content);
+      throw new Error("解析失败");
+    }
   }
 };
 
@@ -1273,63 +1305,8 @@ 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-1.5-flash"),
-    aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60),
-    AnalysePrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我以JSON格式提供的一组内容（每项包含ID、文本和图片），为每一项内容总结关键词、概括内容并评分。你需要返回一个包含所有分析结果的JSON对象。`).description("分析 Prompt"),
-    aiAnalyseSchema: import_koishi3.Schema.string().role("textarea").default(
-      `{
-        "type": "object",
-        "properties": {
-          "analyses": {
-            "type": "array",
-            "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": ["analyses"]
-      }`
-    ).description("分析 JSON Schema"),
-    aiCheckPrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
-    aiCheckSchema: import_koishi3.Schema.string().role("textarea").default(
-      `{
-        "type": "object",
-        "properties": {
-          "duplicate": {
-            "type": "boolean",
-            "description": "新内容是否与已有内容重复"
-          },
-          "id": {
-            "type": "integer",
-            "description": "如果重复，此为第一个重复的已有内容的ID"
-          }
-        },
-        "required": ["duplicate"]
-      }`
-    ).description("查重 JSON Schema")
+    aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
+    aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60)
   }).description("模型配置"),
   import_koishi3.Schema.object({
     localPath: import_koishi3.Schema.string().description("文件映射路径"),
@@ -1428,7 +1405,7 @@ function apply(ctx, config) {
       }
       if (aiManager) {
         const duplicateResult = await aiManager.checkForDuplicates(finalElementsForDb, downloadedMedia);
-        if (duplicateResult && duplicateResult.duplicate) return `内容与回声洞（${duplicateResult.id}）重复`;
+        if (duplicateResult?.duplicate && duplicateResult.ids?.length > 0) return `内容与回声洞（${duplicateResult.ids.join("|")}）重复`;
       }
       const userName = (config.enableName ? await profileManager.getNickname(session.userId) : null) || session.username;
       const needsReview = config.enablePend && session.cid !== config.adminChannel;
@@ -1445,7 +1422,7 @@ function apply(ctx, config) {
       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);
+        if (aiManager) await aiManager.analyzeAndStore([newCave], downloadedMedia);
         if (hashManager) {
           const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: newCave.id }));
           if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);

package/package.json

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