koishi-plugin-isthattrue 0.1.0

package/lib/index.js

@@ -0,0 +1,1026 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi3 = require("koishi");
+
+// src/services/chatluna.ts
+var import_messages = require("@langchain/core/messages");
+var ChatlunaAdapter = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.logger = ctx.logger("isthattrue");
+  }
+  static {
+    __name(this, "ChatlunaAdapter");
+  }
+  logger;
+  /**
+   * 检查 Chatluna 服务是否可用
+   */
+  isAvailable() {
+    return !!this.ctx.chatluna;
+  }
+  /**
+   * 发送聊天请求
+   */
+  async chat(request) {
+    if (!this.isAvailable()) {
+      throw new Error("Chatluna 服务不可用，请确保已安装并启用 koishi-plugin-chatluna");
+    }
+    const startTime = Date.now();
+    let originalProxies = {};
+    try {
+      if (this.config?.bypassProxy) {
+        const proxyVars = ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"];
+        proxyVars.forEach((v) => {
+          originalProxies[v] = process.env[v];
+          delete process.env[v];
+        });
+        this.logger.debug("已临时移除系统代理环境变量");
+      } else {
+        const proxyVars = ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"];
+        const activeProxies = proxyVars.filter((v) => process.env[v]).map((v) => `${v}=${process.env[v]}`);
+        if (activeProxies.length > 0) {
+          this.logger.debug(`当前环境代理: ${activeProxies.join(", ")}`);
+        } else {
+          this.logger.debug("当前环境未检测到系统代理环境变量");
+        }
+      }
+      const modelRef = await this.ctx.chatluna.createChatModel(request.model);
+      const model = modelRef.value;
+      if (!model) {
+        throw new Error(`无法创建模型: ${request.model}，请确保模型已正确配置`);
+      }
+      const messages = [];
+      if (request.systemPrompt) {
+        messages.push(new import_messages.SystemMessage(request.systemPrompt));
+      }
+      let messageContent = request.message;
+      if (request.images && request.images.length > 0) {
+        messageContent = `[图片内容需要分析]
+
+${request.message}`;
+      }
+      messages.push(new import_messages.HumanMessage(messageContent));
+      if (this.config?.logLLMDetails) {
+        this.logger.info(`[LLM Request] Model: ${request.model}
+System: ${request.systemPrompt || "None"}
+Message: ${messageContent}`);
+      }
+      const response = await model.invoke(messages, {
+        temperature: 0.3
+        // 低温度以减少幻觉
+      });
+      if (this.config?.bypassProxy) {
+        Object.keys(originalProxies).forEach((v) => {
+          if (originalProxies[v] !== void 0) {
+            process.env[v] = originalProxies[v];
+          }
+        });
+      }
+      const processingTime = Date.now() - startTime;
+      this.logger.debug(`Chatluna 请求完成，耗时 ${processingTime}ms`);
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      if (this.config?.logLLMDetails) {
+        this.logger.info(`[LLM Response] Model: ${request.model}
+Content: ${content}`);
+      }
+      return {
+        content,
+        model: request.model,
+        sources: this.extractSources(content)
+      };
+    } catch (error) {
+      if (this.config?.bypassProxy) {
+        Object.keys(originalProxies).forEach((v) => {
+          if (originalProxies[v] !== void 0) {
+            process.env[v] = originalProxies[v];
+          }
+        });
+      }
+      this.logger.error("Chatluna 请求失败:", error);
+      throw error;
+    }
+  }
+  /**
+   * 带重试的聊天请求
+   */
+  async chatWithRetry(request, maxRetries = 2, fallbackModel) {
+    let lastError = null;
+    let currentModel = request.model;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await this.chat({
+          ...request,
+          model: currentModel
+        });
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`请求失败 (尝试 ${attempt + 1}/${maxRetries + 1}):`, error);
+        if (attempt === maxRetries - 1 && fallbackModel && fallbackModel !== currentModel) {
+          this.logger.info(`切换到备用模型: ${fallbackModel}`);
+          currentModel = fallbackModel;
+        }
+        if (attempt < maxRetries) {
+          await this.sleep(1e3 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError || new Error("请求失败，已达最大重试次数");
+  }
+  /**
+   * 从响应中提取来源链接
+   */
+  extractSources(content) {
+    const sources = [];
+    const urlRegex = /https?:\/\/[^\s\])"']+/g;
+    const matches = content.match(urlRegex);
+    if (matches) {
+      sources.push(...matches);
+    }
+    const sourceRegex = /\[来源[：:]\s*([^\]]+)\]/g;
+    let match;
+    while ((match = sourceRegex.exec(content)) !== null) {
+      sources.push(match[1]);
+    }
+    return [...new Set(sources)];
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/utils/prompts.ts
+var SEARCH_AGENT_SYSTEM_PROMPT = `你是一个专业的事实核查搜索员。你的任务是针对给定的声明，从特定角度搜索相关信息。
+
+## 你的职责:
+1. 仔细分析待验证的声明
+2. 从你被分配的角度进行深度搜索
+3. 收集相关的证据和来源
+4. 客观评估找到的信息
+
+## 输出格式:
+请以JSON格式返回你的搜索结果:
+\`\`\`json
+{
+  "perspective": "你的搜索角度",
+  "findings": "详细的搜索发现",
+  "sources": ["来源1", "来源2"],
+  "supports_claim": true/false/null,
+  "confidence": 0.0-1.0,
+  "key_evidence": "最关键的证据摘要"
+}
+\`\`\`
+
+## 注意事项:
+- 保持客观中立，不要预设立场
+- 如果找不到相关信息，诚实说明
+- 注明信息来源的可信度
+- 区分事实陈述和观点表达`;
+function getSearchPerspectives(count) {
+  const perspectives = [
+    "官方来源和权威机构",
+    "新闻媒体报道",
+    "学术研究和专家观点",
+    "社交媒体和公众讨论",
+    "历史背景和上下文"
+  ];
+  return perspectives.slice(0, count);
+}
+__name(getSearchPerspectives, "getSearchPerspectives");
+function buildSearchPrompt(content, perspective) {
+  return `## 待验证声明:
+"${content}"
+
+## 你的搜索角度: ${perspective}
+
+请从这个角度搜索相关信息，验证上述声明的真实性。注意收集具体的证据和可靠的来源。`;
+}
+__name(buildSearchPrompt, "buildSearchPrompt");
+var VERIFY_AGENT_SYSTEM_PROMPT = `你是一个严谨的事实核查裁判员。你的任务是基于多个搜索Agent收集的证据，做出最终判决。
+
+## 你的职责:
+1. 综合分析所有搜索结果
+2. 评估各来源的可信度
+3. 识别证据之间的一致性和矛盾
+4. 做出谨慎的最终判决
+
+## 判决类别:
+- TRUE (真实): 有充分可靠证据支持
+- FALSE (虚假): 有充分可靠证据反驳
+- PARTIALLY_TRUE (部分真实): 声明中部分内容属实
+- UNCERTAIN (无法确定): 证据不足或相互矛盾
+
+## 输出格式:
+请以JSON格式返回你的判决:
+\`\`\`json
+{
+  "verdict": "TRUE/FALSE/PARTIALLY_TRUE/UNCERTAIN",
+  "confidence": 0.0-1.0,
+  "reasoning": "详细的判决理由",
+  "key_evidence": "支持判决的关键证据",
+  "caveats": "需要注意的限制或例外",
+  "sources": ["最可靠的来源列表"]
+}
+\`\`\`
+
+## 判决原则:
+- 遵循"无罪推定"原则，证据不足时倾向于"无法确定"
+- 重视权威来源，但也关注多方交叉验证
+- 考虑信息的时效性
+- 区分事实错误和表述不精确
+- 保持谦逊，承认认知局限`;
+function buildVerifyPrompt(originalContent, searchResults) {
+  const resultsText = searchResults.map((r, i) => `### 搜索Agent ${i + 1} (角度: ${r.perspective})
+${r.findings}
+来源: ${r.sources.join(", ") || "无"}`).join("\n\n");
+  return `## 待验证的原始声明:
+"${originalContent}"
+
+## 各搜索Agent的调查结果:
+
+${resultsText}
+
+---
+
+请综合以上所有搜索结果，对原始声明做出最终判决。`;
+}
+__name(buildVerifyPrompt, "buildVerifyPrompt");
+var OCR_PROMPT = `请识别并提取这张图片中的所有文字内容。
+如果图片中没有文字，请描述图片的主要内容。
+直接输出识别结果，不需要额外说明。`;
+function formatVerificationOutput(content, searchResults, verdict, reasoning, sources, confidence, processingTime, format = "markdown") {
+  const verdictEmoji = {
+    true: "✅ 真实",
+    false: "❌ 虚假",
+    partially_true: "⚠️ 部分真实",
+    uncertain: "❓ 无法确定"
+  };
+  const confidenceValue = Math.round(confidence * 100);
+  const confidenceBar = "█".repeat(Math.round(confidence * 10)) + "░".repeat(10 - Math.round(confidence * 10));
+  if (format === "plain") {
+    let output2 = `🔍 事实核查结果
+
+`;
+    output2 += `📋 待验证内容:
+${content.substring(0, 200)}${content.length > 200 ? "..." : ""}
+
+`;
+    output2 += `🤖 搜索发现:
+`;
+    output2 += searchResults.map((r) => `• ${r.perspective}: ${r.findings.substring(0, 100)}...`).join("\n");
+    output2 += `
+
+⚖️ 最终判决: ${verdictEmoji[verdict] || verdict}
+`;
+    output2 += `📊 可信度: ${confidenceValue}%
+
+`;
+    output2 += `📝 判决依据:
+${reasoning}
+`;
+    if (sources.length > 0) {
+      output2 += `
+源：
+`;
+      output2 += sources.map((s) => `• ${s}`).join("\n");
+      output2 += `
+`;
+    }
+    output2 += `
+⏱️ 处理耗时: ${(processingTime / 1e3).toFixed(1)}秒`;
+    return output2;
+  }
+  let output = `🔍 **事实核查结果**
+
+📋 **待验证内容:**
+> ${content.substring(0, 200)}${content.length > 200 ? "..." : ""}
+
+---
+
+🤖 **搜索Agent结果:**
+${searchResults.map((r) => `• **${r.perspective}**: ${r.findings.substring(0, 100)}...`).join("\n")}
+
+---
+
+⚖️ **最终判决: ${verdictEmoji[verdict] || verdict}**
+
+📊 **可信度:** ${confidenceBar} ${confidenceValue}%
+
+📝 **判决依据:**
+${reasoning}
+`;
+  if (sources.length > 0) {
+    output += `
+🔗 **参考来源:**
+${sources.map((s) => `• ${s}`).join("\n")}
+`;
+  }
+  output += `
+⏱️ *处理耗时: ${(processingTime / 1e3).toFixed(1)}秒*`;
+  return output;
+}
+__name(formatVerificationOutput, "formatVerificationOutput");
+var VERDICT_EMOJI = {
+  true: "✅ 真实",
+  false: "❌ 虚假",
+  partially_true: "⚠️ 部分真实",
+  uncertain: "❓ 无法确定"
+};
+function formatForwardMessages(content, searchResults, verdict, reasoning, sources, confidence, processingTime) {
+  const confidenceValue = Math.round(confidence * 100);
+  const summary = `${VERDICT_EMOJI[verdict] || verdict} (${confidenceValue}%)
+
+📋 ${content.substring(0, 100)}${content.length > 100 ? "..." : ""}
+
+⏱️ ${(processingTime / 1e3).toFixed(1)}秒`;
+  const details = [];
+  details.push(`📝 判决依据
+
+${reasoning}`);
+  for (const r of searchResults) {
+    details.push(`🔍 ${r.perspective}
+
+${r.findings}`);
+  }
+  if (sources.length > 0) {
+    details.push(`🔗 参考来源
+
+${sources.map((s) => `• ${s}`).join("\n")}`);
+  }
+  return { summary, details };
+}
+__name(formatForwardMessages, "formatForwardMessages");
+
+// src/agents/searchAgent.ts
+var SearchAgent = class {
+  constructor(ctx, config, agentIndex, model) {
+    this.ctx = ctx;
+    this.config = config;
+    const perspectives = getSearchPerspectives(config.searchModels.length);
+    this.perspective = perspectives[agentIndex] || `角度 ${agentIndex + 1}`;
+    this.id = `agent-${agentIndex + 1}`;
+    this.model = model;
+    this.chatluna = new ChatlunaAdapter(ctx, config);
+  }
+  static {
+    __name(this, "SearchAgent");
+  }
+  id;
+  perspective;
+  model;
+  chatluna;
+  /**
+   * 执行搜索
+   */
+  async search(content) {
+    const logger = this.ctx.logger("isthattrue");
+    logger.info(`[${this.id}] 开始搜索，模型: ${this.model}，角度: ${this.perspective}`);
+    const startTime = Date.now();
+    try {
+      const response = await this.chatluna.chatWithRetry(
+        {
+          model: this.model,
+          message: buildSearchPrompt(content, this.perspective),
+          systemPrompt: SEARCH_AGENT_SYSTEM_PROMPT,
+          enableSearch: true
+        },
+        this.config.maxRetries
+      );
+      const parsed = this.parseResponse(response.content);
+      const result = {
+        agentId: this.id,
+        perspective: this.perspective,
+        findings: parsed.findings || response.content,
+        sources: parsed.sources || response.sources || [],
+        confidence: parsed.confidence || 0.5
+      };
+      const elapsed = Date.now() - startTime;
+      logger.info(`[${this.id}] 搜索完成，耗时 ${elapsed}ms`);
+      return result;
+    } catch (error) {
+      logger.error(`[${this.id}] 搜索失败:`, error);
+      return {
+        agentId: this.id,
+        perspective: this.perspective,
+        findings: `搜索失败: ${error.message}`,
+        sources: [],
+        confidence: 0
+      };
+    }
+  }
+  /**
+   * 解析Agent响应的JSON
+   */
+  parseResponse(content) {
+    try {
+      const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
+      if (jsonMatch) {
+        const parsed2 = JSON.parse(jsonMatch[1]);
+        return {
+          findings: parsed2.findings || parsed2.key_evidence,
+          sources: parsed2.sources || [],
+          confidence: parsed2.confidence
+        };
+      }
+      const parsed = JSON.parse(content);
+      return {
+        findings: parsed.findings || parsed.key_evidence,
+        sources: parsed.sources || [],
+        confidence: parsed.confidence
+      };
+    } catch {
+      return {};
+    }
+  }
+};
+var SearchAgentManager = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.initAgents();
+  }
+  static {
+    __name(this, "SearchAgentManager");
+  }
+  agents = [];
+  initAgents() {
+    const models = this.config.searchModels;
+    for (let i = 0; i < models.length; i++) {
+      this.agents.push(new SearchAgent(this.ctx, this.config, i, models[i]));
+    }
+  }
+  /**
+   * 并行执行所有Agent的搜索
+   */
+  async searchAll(content) {
+    const logger = this.ctx.logger("isthattrue");
+    if (this.agents.length === 0) {
+      logger.warn("未配置搜索模型");
+      return [];
+    }
+    logger.info(`启动 ${this.agents.length} 个搜索Agent`);
+    const results = await Promise.all(
+      this.agents.map(
+        (agent) => this.withTimeout(
+          agent.search(content),
+          this.config.timeout,
+          agent
+        )
+      )
+    );
+    return results;
+  }
+  /**
+   * 带超时的Promise包装
+   */
+  async withTimeout(promise, timeout, agent) {
+    return Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("搜索超时")), timeout);
+      })
+    ]).catch((error) => ({
+      agentId: agent.id,
+      perspective: agent.perspective,
+      findings: `错误: ${error.message}`,
+      sources: [],
+      confidence: 0
+    }));
+  }
+};
+
+// src/agents/verifyAgent.ts
+var VerifyAgent = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.chatluna = new ChatlunaAdapter(ctx, config);
+    this.logger = ctx.logger("isthattrue");
+  }
+  static {
+    __name(this, "VerifyAgent");
+  }
+  chatluna;
+  logger;
+  /**
+   * 执行验证判决
+   */
+  async verify(originalContent, searchResults) {
+    const startTime = Date.now();
+    this.logger.info("开始综合验证...");
+    try {
+      const prompt = buildVerifyPrompt(
+        originalContent.text,
+        searchResults.map((r) => ({
+          perspective: r.perspective,
+          findings: r.findings,
+          sources: r.sources
+        }))
+      );
+      const response = await this.chatluna.chatWithRetry(
+        {
+          model: this.config.verifyModel,
+          message: prompt,
+          systemPrompt: VERIFY_AGENT_SYSTEM_PROMPT
+        },
+        this.config.maxRetries
+      );
+      const parsed = this.parseVerifyResponse(response.content);
+      const processingTime = Date.now() - startTime;
+      const result = {
+        originalContent,
+        searchResults,
+        verdict: parsed.verdict,
+        reasoning: parsed.reasoning,
+        sources: this.aggregateSources(searchResults, parsed.sources),
+        confidence: parsed.confidence,
+        processingTime
+      };
+      this.logger.info(`验证完成，判决: ${result.verdict}，可信度: ${result.confidence}`);
+      return result;
+    } catch (error) {
+      this.logger.error("验证失败:", error);
+      return {
+        originalContent,
+        searchResults,
+        verdict: "uncertain" /* UNCERTAIN */,
+        reasoning: `验证过程发生错误: ${error.message}`,
+        sources: this.aggregateSources(searchResults, []),
+        confidence: 0,
+        processingTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * 解析验证响应
+   */
+  parseVerifyResponse(content) {
+    try {
+      const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
+      let parsed;
+      if (jsonMatch) {
+        parsed = JSON.parse(jsonMatch[1]);
+      } else {
+        parsed = JSON.parse(content);
+      }
+      return {
+        verdict: this.normalizeVerdict(parsed.verdict),
+        reasoning: parsed.reasoning || parsed.key_evidence || "无详细说明",
+        sources: parsed.sources || [],
+        confidence: parsed.confidence || 0.5
+      };
+    } catch {
+      return {
+        verdict: this.extractVerdictFromText(content),
+        reasoning: content,
+        sources: [],
+        confidence: 0.3
+      };
+    }
+  }
+  /**
+   * 标准化判决结果
+   */
+  normalizeVerdict(verdict) {
+    const normalized = verdict?.toLowerCase()?.trim();
+    const mapping = {
+      "true": "true" /* TRUE */,
+      "真实": "true" /* TRUE */,
+      "正确": "true" /* TRUE */,
+      "false": "false" /* FALSE */,
+      "虚假": "false" /* FALSE */,
+      "错误": "false" /* FALSE */,
+      "partially_true": "partially_true" /* PARTIALLY_TRUE */,
+      "partial": "partially_true" /* PARTIALLY_TRUE */,
+      "部分真实": "partially_true" /* PARTIALLY_TRUE */,
+      "uncertain": "uncertain" /* UNCERTAIN */,
+      "不确定": "uncertain" /* UNCERTAIN */,
+      "无法确定": "uncertain" /* UNCERTAIN */
+    };
+    return mapping[normalized] || "uncertain" /* UNCERTAIN */;
+  }
+  /**
+   * 从文本中提取判决
+   */
+  extractVerdictFromText(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("虚假") || lower.includes("false") || lower.includes("错误")) {
+      return "false" /* FALSE */;
+    }
+    if (lower.includes("部分真实") || lower.includes("partially")) {
+      return "partially_true" /* PARTIALLY_TRUE */;
+    }
+    if (lower.includes("真实") || lower.includes("true") || lower.includes("正确")) {
+      return "true" /* TRUE */;
+    }
+    return "uncertain" /* UNCERTAIN */;
+  }
+  /**
+   * 汇总所有来源
+   */
+  aggregateSources(searchResults, verifySources) {
+    const allSources = /* @__PURE__ */ new Set();
+    for (const result of searchResults) {
+      for (const source of result.sources) {
+        allSources.add(source);
+      }
+    }
+    for (const source of verifySources) {
+      allSources.add(source);
+    }
+    return [...allSources];
+  }
+};
+
+// src/services/messageParser.ts
+var import_koishi = require("koishi");
+var MessageParser = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  static {
+    __name(this, "MessageParser");
+  }
+  /**
+   * 从会话中提取引用消息的内容
+   */
+  async parseQuotedMessage(session) {
+    const result = {
+      text: "",
+      images: [],
+      hasQuote: false
+    };
+    const quote = session.quote;
+    if (!quote) {
+      return null;
+    }
+    result.hasQuote = true;
+    const elements = quote.elements || [];
+    for (const element of elements) {
+      if (element.type === "text") {
+        result.text += element.attrs?.content || "";
+      } else if (element.type === "img" || element.type === "image") {
+        const src = element.attrs?.src || element.attrs?.url;
+        if (src) {
+          result.images.push(src);
+        }
+      }
+    }
+    if (elements.length === 0 && quote.content) {
+      const parsed = this.parseContent(quote.content);
+      result.text = parsed.text;
+      result.images = parsed.images;
+    }
+    return result;
+  }
+  /**
+   * 从整个会话中提取可验证内容（优先引用，其次是当前消息）
+   */
+  async parseSession(session) {
+    const quoted = await this.parseQuotedMessage(session);
+    if (quoted) return quoted;
+    const result = {
+      text: "",
+      images: [],
+      hasQuote: false
+    };
+    const elements = session.elements || [];
+    this.ctx.logger("isthattrue").debug("Parsing session elements:", JSON.stringify(elements));
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i];
+      if (element.type === "text") {
+        let content = element.attrs?.content || "";
+        if (i === 0) {
+          content = content.replace(/^[^\s]+\s*/, "");
+        }
+        result.text += content;
+      } else if (element.type === "img" || element.type === "image") {
+        const src = element.attrs?.src || element.attrs?.url;
+        if (src) {
+          result.images.push(src);
+        }
+      }
+    }
+    if (result.text.trim() || result.images.length > 0) {
+      return result;
+    }
+    return null;
+  }
+  /**
+   * 解析消息内容字符串
+   */
+  parseContent(content) {
+    const text = [];
+    const images = [];
+    try {
+      const elements = import_koishi.h.parse(content);
+      for (const el of elements) {
+        if (el.type === "text") {
+          text.push(el.attrs?.content || String(el));
+        } else if (el.type === "img" || el.type === "image") {
+          const src = el.attrs?.src || el.attrs?.url;
+          if (src) {
+            images.push(src);
+          }
+        }
+      }
+    } catch {
+      text.push(content);
+    }
+    return {
+      text: text.join(" ").trim(),
+      images
+    };
+  }
+  /**
+   * 获取图片的base64编码
+   */
+  async imageToBase64(url) {
+    try {
+      if (url.startsWith("data:image")) {
+        return url.split(",")[1] || url;
+      }
+      if (url.startsWith("file://")) {
+        this.ctx.logger("isthattrue").warn("本地文件暂不支持:", url);
+        return null;
+      }
+      const response = await this.ctx.http.get(url, {
+        responseType: "arraybuffer"
+      });
+      const buffer = Buffer.from(response);
+      return buffer.toString("base64");
+    } catch (error) {
+      this.ctx.logger("isthattrue").error("图片转换失败:", error);
+      return null;
+    }
+  }
+  /**
+   * 准备消息内容用于LLM处理
+   * 将图片转换为base64，合并文本
+   */
+  async prepareForLLM(content) {
+    const imageBase64List = [];
+    for (const imageUrl of content.images) {
+      const base64 = await this.imageToBase64(imageUrl);
+      if (base64) {
+        imageBase64List.push(base64);
+      }
+    }
+    return {
+      text: content.text,
+      imageBase64List
+    };
+  }
+};
+
+// src/config.ts
+var import_koishi2 = require("koishi");
+var Config = import_koishi2.Schema.intersect([
+  import_koishi2.Schema.object({
+    searchModels: import_koishi2.Schema.array(import_koishi2.Schema.dynamic("model")).default([]).description("搜索用模型列表 (每个模型对应一个搜索Agent，需要支持联网搜索)"),
+    verifyModel: import_koishi2.Schema.dynamic("model").default("无").description("验证用模型 (推荐使用低幻觉率模型)")
+  }).description("模型配置"),
+  import_koishi2.Schema.object({
+    timeout: import_koishi2.Schema.number().min(1e4).max(3e5).default(6e4).description("单次请求超时时间(毫秒)"),
+    maxRetries: import_koishi2.Schema.number().min(0).max(5).default(2).description("失败重试次数")
+  }).description("Agent配置"),
+  import_koishi2.Schema.object({
+    verbose: import_koishi2.Schema.boolean().default(false).description("显示详细验证过程 (进度提示)"),
+    enableOCR: import_koishi2.Schema.boolean().default(true).description("启用图片文字识别"),
+    outputFormat: import_koishi2.Schema.union([
+      import_koishi2.Schema.const("auto").description("自动 (QQ使用纯文本)"),
+      import_koishi2.Schema.const("markdown").description("Markdown"),
+      import_koishi2.Schema.const("plain").description("纯文本")
+    ]).default("auto").description("输出格式"),
+    useForwardMessage: import_koishi2.Schema.boolean().default(true).description("使用合并转发消息展示详情 (仅支持QQ)"),
+    bypassProxy: import_koishi2.Schema.boolean().default(false).description("是否绕过系统代理"),
+    logLLMDetails: import_koishi2.Schema.boolean().default(false).description("是否打印 LLM 请求体和响应详情 (Debug用)")
+  }).description("其他设置")
+]);
+
+// src/index.ts
+var name = "isthattrue";
+var inject = ["chatluna"];
+var usage = `
+## 事实核查插件
+
+使用多Agent架构对消息进行事实核查验证。
+
+### 使用方法
+
+1. 引用一条需要验证的消息
+2. 发送 \`tof\` 指令
+3. 等待验证结果
+
+### 工作流程
+
+1. **解析阶段**: 提取引用消息中的文本和图片
+2. **搜索阶段**: 多个Agent并行从不同角度搜索信息
+3. **验证阶段**: 综合搜索结果，由低幻觉率LLM做出判决
+
+### 判决类别
+
+- ✅ **真实**: 有充分可靠证据支持
+- ❌ **虚假**: 有充分可靠证据反驳
+- ⚠️ **部分真实**: 声明中部分内容属实
+- ❓ **无法确定**: 证据不足或相互矛盾
+`;
+function apply(ctx, config) {
+  const logger = ctx.logger("isthattrue");
+  const messageParser = new MessageParser(ctx);
+  ctx.command("tof", "验证消息的真实性").alias("真假").alias("事实核查").alias("factcheck").option("verbose", "-v 显示详细过程").action(async ({ session, options }) => {
+    logger.info("tof 命令被触发");
+    if (!session) {
+      logger.warn("session 为空");
+      return "无法获取会话信息";
+    }
+    logger.info(`用户 ${session.userId} 在 ${session.channelId} 触发 tof 命令`);
+    logger.debug("Session elements:", JSON.stringify(session.elements));
+    const verbose = options?.verbose ?? config.verbose;
+    const format = config.outputFormat === "auto" ? session.platform === "qq" ? "plain" : "markdown" : config.outputFormat;
+    const chatluna = new ChatlunaAdapter(ctx, config);
+    if (!chatluna.isAvailable()) {
+      return "❌ Chatluna 服务不可用，请确保已安装并启用 koishi-plugin-chatluna";
+    }
+    const content = await messageParser.parseSession(session);
+    if (!content || !content.text && content.images.length === 0) {
+      return "❌ 请提供需要验证的内容\n\n使用方法:\n1. 引用一条消息后发送 tof\n2. 直接发送 tof [文本或图片]";
+    }
+    if (verbose) {
+      await session.send("🔍 正在验证消息真实性，请稍候...");
+    }
+    try {
+      const startTime = Date.now();
+      let textToVerify = content.text;
+      if (content.images.length > 0 && config.enableOCR) {
+        if (verbose) {
+          await session.send("📷 正在识别图片内容...");
+        }
+        try {
+          const prepared = await messageParser.prepareForLLM(content);
+          if (prepared.imageBase64List.length > 0) {
+            const ocrResponse = await chatluna.chat({
+              model: config.verifyModel,
+              message: OCR_PROMPT,
+              images: prepared.imageBase64List
+            });
+            textToVerify = `${content.text}
+
+[图片内容]: ${ocrResponse.content}`;
+          }
+        } catch (error) {
+          logger.warn("OCR识别失败:", error);
+        }
+      }
+      if (!textToVerify.trim()) {
+        return "❌ 无法提取可验证的内容";
+      }
+      if (config.searchModels.length === 0) {
+        return "❌ 请先在配置中添加至少一个搜索模型";
+      }
+      if (verbose) {
+        await session.send(`🤖 启动 ${config.searchModels.length} 个搜索Agent...`);
+      }
+      const searchManager = new SearchAgentManager(ctx, config);
+      const searchResults = await searchManager.searchAll(textToVerify);
+      if (verbose) {
+        const successCount = searchResults.filter((r) => r.confidence > 0).length;
+        await session.send(`✅ 搜索完成 (${successCount}/${searchResults.length} 成功)`);
+        await session.send("⚖️ 正在综合分析...");
+      }
+      const verifyAgent = new VerifyAgent(ctx, config);
+      const result = await Promise.race([
+        verifyAgent.verify(content, searchResults),
+        new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("验证阶段超时")), config.timeout);
+        })
+      ]).catch((error) => {
+        logger.error("验证超时或出错:", error);
+        return {
+          originalContent: content,
+          searchResults,
+          verdict: "uncertain" /* UNCERTAIN */,
+          reasoning: `验证超时或出错: ${error.message}`,
+          sources: [],
+          confidence: 0,
+          processingTime: Date.now() - startTime
+        };
+      });
+      const searchResultsForOutput = searchResults.map((r) => ({
+        agentId: r.agentId,
+        perspective: r.perspective,
+        findings: r.findings
+      }));
+      const useForward = config.useForwardMessage && session.platform === "onebot";
+      if (useForward) {
+        const { summary, details } = formatForwardMessages(
+          textToVerify,
+          searchResultsForOutput,
+          result.verdict,
+          result.reasoning,
+          result.sources,
+          result.confidence,
+          result.processingTime
+        );
+        const forwardNodes = details.map(
+          (detail) => (0, import_koishi3.h)("message", { nickname: "事实核查", userId: session.selfId }, detail)
+        );
+        await session.send(summary);
+        await session.send((0, import_koishi3.h)("message", { forward: true }, forwardNodes));
+        return;
+      }
+      const output = formatVerificationOutput(
+        textToVerify,
+        searchResultsForOutput,
+        result.verdict,
+        result.reasoning,
+        result.sources,
+        result.confidence,
+        result.processingTime,
+        format
+      );
+      return output;
+    } catch (error) {
+      logger.error("验证过程出错:", error);
+      return `❌ 验证过程发生错误: ${error.message}`;
+    }
+  });
+  ctx.command("tof.quick <text:text>", "快速验证文本真实性").action(async ({ session }, text) => {
+    if (!session) return "无法获取会话信息";
+    if (!text?.trim()) return "请提供需要验证的文本";
+    const format = config.outputFormat === "auto" ? session.platform === "qq" ? "plain" : "markdown" : config.outputFormat;
+    const chatluna = new ChatlunaAdapter(ctx, config);
+    if (!chatluna.isAvailable()) {
+      return "❌ Chatluna 服务不可用";
+    }
+    await session.send("🔍 快速验证中...");
+    try {
+      if (config.searchModels.length === 0) {
+        return "❌ 请先在配置中添加至少一个搜索模型";
+      }
+      const quickConfig = { ...config, searchModels: [config.searchModels[0]] };
+      const searchManager = new SearchAgentManager(ctx, quickConfig);
+      const searchResults = await searchManager.searchAll(text);
+      const verifyAgent = new VerifyAgent(ctx, quickConfig);
+      const result = await verifyAgent.verify(
+        { text, images: [], hasQuote: false },
+        searchResults
+      );
+      const verdictEmoji = {
+        ["true" /* TRUE */]: "✅ 真实",
+        ["false" /* FALSE */]: "❌ 虚假",
+        ["partially_true" /* PARTIALLY_TRUE */]: "⚠️ 部分真实",
+        ["uncertain" /* UNCERTAIN */]: "❓ 无法确定"
+      };
+      const confidenceValue = Math.round(result.confidence * 100);
+      const reasoning = result.reasoning.substring(0, 200);
+      if (format === "plain") {
+        return `${verdictEmoji[result.verdict]} (${confidenceValue}%)
+${reasoning}`;
+      }
+      return `**${verdictEmoji[result.verdict]}** (${confidenceValue}%)
+
+${reasoning}`;
+    } catch (error) {
+      return `❌ 验证失败: ${error.message}`;
+    }
+  });
+  logger.info("isthattrue 插件已加载");
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name,
+  usage
+});