koishi-plugin-isthattrue 0.2.0 → 0.2.2

package/README.md

@@ -1,104 +1,104 @@
-# koishi-plugin-isthattrue
-
-[![npm](https://img.shields.io/npm/v/koishi-plugin-isthattrue?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-isthattrue)
-
-事实核查插件 - 使用多 Agent LLM 架构验证消息真实性
-
-## 功能特点
-
-- 多 Agent 协作：主控 Agent 编排任务，子搜索 Agent 并行检索
-- 多搜索源支持：Tavily、Anspire、Kimi、智谱、Chatluna Search
-- 支持文本和图片内容（OCR 识别）
-- 可引用消息进行核查
-- 输出判定结果：TRUE / FALSE / PARTIALLY_TRUE / UNCERTAIN
-
-## 安装
-
-```bash
-npm install koishi-plugin-isthattrue
-```
-
-## 依赖
-
-- [koishi-plugin-chatluna](https://github.com/ChatLunaLab/chatluna) - LLM 服务接入
-
-## 使用方法
-
-```
-tof [内容]        # 核查指定内容
-tof               # 引用一条消息后使用，核查被引用的消息
-```
-
-别名：`鉴定`、`核查`
-
-## 配置说明
-
-### 模型配置
-
-| 配置项 | 说明 | 推荐 |
-|--------|------|------|
-| mainModel | 主控 Agent 模型，用于编排和最终判决 | Gemini-3-Flash |
-| subSearchModel | 子搜索 Agent 模型，用于深度搜索 | Grok-4-1 |
-
-### 搜索 API 配置
-
-| 配置项 | 说明 |
-|--------|------|
-| tavilyApiKey | Tavily API Key（可选） |
-| anspireApiKey | Anspire API Key（可选） |
-| kimiApiKey | Kimi API Key（可选） |
-| zhipuApiKey | 智谱 API Key（可选） |
-| chatlunaSearchModel | Chatluna Search 使用的模型 |
-| enableChatlunaSearch | 启用 Chatluna 搜索集成 |
-| chatlunaSearchDiversifyModel | 搜索关键词多样化模型 |
-
-### Agent 配置
-
-| 配置项 | 默认值 | 说明 |
-|--------|--------|------|
-| timeout | 60000 | 单次请求超时时间（毫秒） |
-| maxRetries | 2 | 失败重试次数 |
-
-### 其他设置
-
-| 配置项 | 默认值 | 说明 |
-|--------|--------|------|
-| verbose | false | 显示详细验证过程 |
-| outputFormat | auto | 输出格式（auto/markdown/plain） |
-| useForwardMessage | true | 使用合并转发消息展示详情（仅 QQ） |
-| bypassProxy | false | 绕过系统代理 |
-| logLLMDetails | false | 打印 LLM 请求详情（调试用） |
-
-## 工作流程
-
-1. 用户发送 `tof` 命令（可引用消息或直接输入内容）
-2. MessageParser 提取文本和图片，如有图片则进行 OCR
-3. 主控 Agent 分析内容，生成搜索计划
-4. 子搜索 Agent 并行执行多源搜索
-5. 主控 Agent 综合搜索结果，输出最终判定
-
-## 架构
-
-```
-src/
-├── index.ts              # 插件入口，注册 tof 命令
-├── config.ts             # 配置 Schema
-├── types.ts              # TypeScript 类型定义
-├── agents/
-│   ├── mainAgent.ts      # 主控 Agent（编排 + 判决）
-│   └── subSearchAgent.ts # 子搜索 Agent（多源检索）
-├── services/
-│   ├── chatluna.ts       # Chatluna LLM 适配器
-│   ├── chatlunaSearch.ts # Chatluna Search 集成
-│   ├── messageParser.ts  # 消息解析（文本/图片）
-│   ├── tavily.ts         # Tavily 搜索
-│   ├── anspire.ts        # Anspire 搜索
-│   ├── kimi.ts           # Kimi 搜索
-│   └── zhipu.ts          # 智谱搜索
-└── utils/
-    └── prompts.ts        # LLM Prompt 模板
-```
-
-## License
-
-MIT
+# koishi-plugin-isthattrue
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-isthattrue?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-isthattrue)
+
+事实核查插件 - 使用多 Agent LLM 架构验证消息真实性
+
+## 功能特点
+
+- 多 Agent 协作：主控 Agent 编排任务，子搜索 Agent 并行检索
+- 多搜索源支持：Tavily、Anspire、Kimi、智谱、Chatluna Search
+- 支持文本和图片内容（OCR 识别）
+- 可引用消息进行核查
+- 输出判定结果：TRUE / FALSE / PARTIALLY_TRUE / UNCERTAIN
+
+## 安装
+
+```bash
+npm install koishi-plugin-isthattrue
+```
+
+## 依赖
+
+- [koishi-plugin-chatluna](https://github.com/ChatLunaLab/chatluna) - LLM 服务接入
+
+## 使用方法
+
+```
+tof [内容]        # 核查指定内容
+tof               # 引用一条消息后使用，核查被引用的消息
+```
+
+别名：`鉴定`、`核查`
+
+## 配置说明
+
+### 模型配置
+
+| 配置项 | 说明 | 推荐 |
+|--------|------|------|
+| mainModel | 主控 Agent 模型，用于编排和最终判决 | Gemini-3-Flash |
+| subSearchModel | 子搜索 Agent 模型，用于深度搜索 | Grok-4-1 |
+
+### 搜索 API 配置
+
+| 配置项 | 说明 |
+|--------|------|
+| tavilyApiKey | Tavily API Key（可选） |
+| anspireApiKey | Anspire API Key（可选） |
+| kimiApiKey | Kimi API Key（可选） |
+| zhipuApiKey | 智谱 API Key（可选） |
+| chatlunaSearchModel | Chatluna Search 使用的模型 |
+| enableChatlunaSearch | 启用 Chatluna 搜索集成 |
+| chatlunaSearchDiversifyModel | 搜索关键词多样化模型 |
+
+### Agent 配置
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| timeout | 60000 | 单次请求超时时间（毫秒） |
+| maxRetries | 2 | 失败重试次数 |
+
+### 其他设置
+
+| 配置项 | 默认值 | 说明 |
+|--------|--------|------|
+| verbose | false | 显示详细验证过程 |
+| outputFormat | auto | 输出格式（auto/markdown/plain） |
+| useForwardMessage | true | 使用合并转发消息展示详情（仅 QQ） |
+| bypassProxy | false | 绕过系统代理 |
+| logLLMDetails | false | 打印 LLM 请求详情（调试用） |
+
+## 工作流程
+
+1. 用户发送 `tof` 命令（可引用消息或直接输入内容）
+2. MessageParser 提取文本和图片，如有图片则进行 OCR
+3. 主控 Agent 分析内容，生成搜索计划
+4. 子搜索 Agent 并行执行多源搜索
+5. 主控 Agent 综合搜索结果，输出最终判定
+
+## 架构
+
+```
+src/
+├── index.ts              # 插件入口，注册 tof 命令
+├── config.ts             # 配置 Schema
+├── types.ts              # TypeScript 类型定义
+├── agents/
+│   ├── mainAgent.ts      # 主控 Agent（编排 + 判决）
+│   └── subSearchAgent.ts # 子搜索 Agent（多源检索）
+├── services/
+│   ├── chatluna.ts       # Chatluna LLM 适配器
+│   ├── chatlunaSearch.ts # Chatluna Search 集成
+│   ├── messageParser.ts  # 消息解析（文本/图片）
+│   ├── tavily.ts         # Tavily 搜索
+│   ├── anspire.ts        # Anspire 搜索
+│   ├── kimi.ts           # Kimi 搜索
+│   └── zhipu.ts          # 智谱搜索
+└── utils/
+    └── prompts.ts        # LLM Prompt 模板
+```
+
+## License
+
+MIT

package/lib/agents/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubSearchAgent = exports.MainAgent = exports.VerifyAgent = void 0;
+var verifyAgent_1 = require("./verifyAgent");
+Object.defineProperty(exports, "VerifyAgent", { enumerable: true, get: function () { return verifyAgent_1.VerifyAgent; } });
+var mainAgent_1 = require("./mainAgent");
+Object.defineProperty(exports, "MainAgent", { enumerable: true, get: function () { return mainAgent_1.MainAgent; } });
+var subSearchAgent_1 = require("./subSearchAgent");
+Object.defineProperty(exports, "SubSearchAgent", { enumerable: true, get: function () { return subSearchAgent_1.SubSearchAgent; } });

package/lib/agents/mainAgent.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainAgent = void 0;
+const types_1 = require("../types");
+const subSearchAgent_1 = require("./subSearchAgent");
+const verifyAgent_1 = require("./verifyAgent");
+const chatlunaSearch_1 = require("../services/chatlunaSearch");
+const chatluna_1 = require("../services/chatluna");
+const messageParser_1 = require("../services/messageParser");
+const prompts_1 = require("../utils/prompts");
+/**
+ * 主控 Agent
+ * 流程：并行搜索 (Chatluna + Grok) -> URL处理 -> Gemini判决
+ */
+class MainAgent {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.subSearchAgent = new subSearchAgent_1.SubSearchAgent(ctx, config);
+        this.chatlunaSearchAgent = new chatlunaSearch_1.ChatlunaSearchAgent(ctx, config);
+        this.verifyAgent = new verifyAgent_1.VerifyAgent(ctx, config);
+        this.chatluna = new chatluna_1.ChatlunaAdapter(ctx, config);
+        this.messageParser = new messageParser_1.MessageParser(ctx);
+        this.logger = ctx.logger('isthattrue');
+    }
+    /**
+     * 执行完整的核查流程
+     */
+    async verify(content) {
+        const startTime = Date.now();
+        this.logger.info('开始主控 Agent 核查流程...');
+        try {
+            // 准备图片 base64
+            let imageBase64List = [];
+            if (content.images.length > 0) {
+                this.logger.info(`[Phase 0] 处理 ${content.images.length} 张图片...`);
+                const prepared = await this.messageParser.prepareForLLM(content);
+                imageBase64List = prepared.imageBase64List;
+                this.logger.info(`[Phase 0] 成功转换 ${imageBase64List.length} 张图片为 base64`);
+            }
+            // 确定搜索用的文本
+            let searchText = content.text;
+            // 如果是纯图片（没有文本），先让 Gemini 描述图片
+            if (!content.text.trim() && imageBase64List.length > 0) {
+                this.logger.info('[Phase 0] 纯图片输入，提取图片描述...');
+                searchText = await this.extractImageDescription(imageBase64List);
+                this.logger.info(`[Phase 0] 图片描述：${searchText.substring(0, 100)}...`);
+            }
+            // Phase 1+2: 并行执行搜索
+            this.logger.info('[Phase 1+2] 并行搜索中 (Chatluna + Grok)...');
+            const searchPromises = [];
+            // Chatluna 搜索 (通用网页)
+            if (this.chatlunaSearchAgent.isAvailable()) {
+                searchPromises.push(this.withTimeout(this.chatlunaSearchAgent.search(searchText), this.config.timeout, 'ChatlunaSearch'));
+            }
+            // Grok 深度搜索 (独立，专注 X/Twitter)
+            searchPromises.push(this.withTimeout(this.subSearchAgent.deepSearch(searchText), this.config.timeout, 'GrokSearch'));
+            const results = await Promise.allSettled(searchPromises);
+            // 收集成功的结果
+            const searchResults = results
+                .filter((r) => r.status === 'fulfilled' && r.value !== null)
+                .map(r => r.value);
+            // 记录失败的搜索
+            results.forEach((r, i) => {
+                if (r.status === 'rejected') {
+                    this.logger.warn(`搜索 ${i === 0 ? 'Chatluna' : 'Grok'} 失败: ${r.reason}`);
+                }
+            });
+            this.logger.info(`[Phase 1+2] 搜索完成，成功 ${searchResults.length} 个`);
+            // 如果没有任何搜索结果，返回不确定
+            if (searchResults.length === 0) {
+                return {
+                    originalContent: content,
+                    searchResults: [],
+                    verdict: types_1.Verdict.UNCERTAIN,
+                    reasoning: '所有搜索都失败了，无法验证',
+                    sources: [],
+                    confidence: 0,
+                    processingTime: Date.now() - startTime,
+                };
+            }
+            // Phase 3: Gemini 综合判决 (传递原图)
+            this.logger.info('[Phase 3] Gemini 判决中...');
+            const finalResult = await this.verifyAgent.verify(content, searchResults, imageBase64List);
+            return {
+                ...finalResult,
+                processingTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            this.logger.error('主控 Agent 流程出错:', error);
+            return {
+                originalContent: content,
+                searchResults: [],
+                verdict: types_1.Verdict.UNCERTAIN,
+                reasoning: `流程执行失败: ${error.message}`,
+                sources: [],
+                confidence: 0,
+                processingTime: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * 带超时的 Promise 包装
+     */
+    async withTimeout(promise, timeout, name) {
+        try {
+            return await Promise.race([
+                promise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`${name} 超时`)), timeout))
+            ]);
+        }
+        catch (error) {
+            this.logger.warn(`[${name}] 失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 从图片中提取描述（用于纯图片输入场景）
+     */
+    async extractImageDescription(images) {
+        try {
+            const response = await this.chatluna.chat({
+                model: this.config.mainModel,
+                message: prompts_1.IMAGE_DESCRIPTION_PROMPT,
+                images: images,
+            });
+            return response.content;
+        }
+        catch (error) {
+            this.logger.error('图片描述提取失败:', error);
+            return '图片内容需要验证';
+        }
+    }
+}
+exports.MainAgent = MainAgent;

package/lib/agents/subSearchAgent.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubSearchAgent = void 0;
+const chatluna_1 = require("../services/chatluna");
+const prompts_1 = require("../utils/prompts");
+/**
+ * 子搜索 Agent
+ * 专门负责深度搜索（主要使用 Grok，擅长 X/Twitter 搜索）
+ * 独立搜索，不依赖其他搜索结果
+ */
+class SubSearchAgent {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.chatluna = new chatluna_1.ChatlunaAdapter(ctx, config);
+        this.logger = ctx.logger('isthattrue');
+    }
+    /**
+     * 执行深度搜索
+     * @param claim 原始声明文本
+     */
+    async deepSearch(claim) {
+        this.logger.info(`[SubSearchAgent] 开始深度搜索，模型: ${this.config.subSearchModel}`);
+        try {
+            const response = await this.chatluna.chatWithRetry({
+                model: this.config.subSearchModel,
+                message: (0, prompts_1.buildSubSearchPrompt)(claim),
+                systemPrompt: prompts_1.SUB_SEARCH_AGENT_SYSTEM_PROMPT,
+                enableSearch: true,
+            }, this.config.maxRetries);
+            // 解析响应
+            const parsed = this.parseResponse(response.content);
+            return {
+                agentId: 'grok-deep-search',
+                perspective: 'Grok 深度搜索 (X/Twitter)',
+                findings: parsed.findings || response.content,
+                sources: parsed.sources || response.sources || [],
+                confidence: parsed.confidence || 0.8,
+            };
+        }
+        catch (error) {
+            this.logger.error('[SubSearchAgent] 搜索失败:', error);
+            return {
+                agentId: 'grok-deep-search',
+                perspective: 'Grok 深度搜索 (X/Twitter)',
+                findings: `深度搜索失败: ${error.message}`,
+                sources: [],
+                confidence: 0,
+            };
+        }
+    }
+    parseResponse(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 {
+                findings: parsed.findings,
+                sources: parsed.sources,
+                confidence: parsed.confidence,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+}
+exports.SubSearchAgent = SubSearchAgent;

package/lib/agents/verifyAgent.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyAgent = void 0;
+const types_1 = require("../types");
+const chatluna_1 = require("../services/chatluna");
+const prompts_1 = require("../utils/prompts");
+/**
+ * 验证Agent
+ * 负责综合搜索结果并做出最终判决
+ */
+class VerifyAgent {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.chatluna = new chatluna_1.ChatlunaAdapter(ctx, config);
+        this.logger = ctx.logger('isthattrue');
+    }
+    /**
+     * 执行验证判决
+     * @param originalContent 原始消息内容
+     * @param searchResults 搜索结果
+     * @param images 可选的图片 base64 列表（多模态验证）
+     */
+    async verify(originalContent, searchResults, images) {
+        const startTime = Date.now();
+        const hasImages = images && images.length > 0;
+        this.logger.info(`开始综合验证...${hasImages ? ' (包含图片)' : ''}`);
+        try {
+            // 构建验证请求
+            const prompt = (0, prompts_1.buildVerifyPrompt)(originalContent.text, searchResults.map(r => ({
+                perspective: r.perspective,
+                findings: r.findings,
+                sources: r.sources,
+            })), hasImages // 传递是否有图片
+            );
+            // 选择系统提示词（多模态或普通）
+            const systemPrompt = hasImages
+                ? prompts_1.VERIFY_AGENT_SYSTEM_PROMPT_MULTIMODAL
+                : prompts_1.VERIFY_AGENT_SYSTEM_PROMPT;
+            // 调用低幻觉率模型进行验证
+            const response = await this.chatluna.chatWithRetry({
+                model: this.config.mainModel,
+                message: prompt,
+                systemPrompt: systemPrompt,
+                images: images, // 传递图片
+            }, 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: types_1.Verdict.UNCERTAIN,
+                reasoning: `验证过程发生错误: ${error.message}`,
+                sources: this.aggregateSources(searchResults, []),
+                confidence: 0,
+                processingTime: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * 解析验证响应
+     */
+    parseVerifyResponse(content) {
+        try {
+            // 提取JSON块
+            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': types_1.Verdict.TRUE,
+            '真实': types_1.Verdict.TRUE,
+            '正确': types_1.Verdict.TRUE,
+            'false': types_1.Verdict.FALSE,
+            '虚假': types_1.Verdict.FALSE,
+            '错误': types_1.Verdict.FALSE,
+            'partially_true': types_1.Verdict.PARTIALLY_TRUE,
+            'partial': types_1.Verdict.PARTIALLY_TRUE,
+            '部分真实': types_1.Verdict.PARTIALLY_TRUE,
+            'uncertain': types_1.Verdict.UNCERTAIN,
+            '不确定': types_1.Verdict.UNCERTAIN,
+            '无法确定': types_1.Verdict.UNCERTAIN,
+        };
+        return mapping[normalized] || types_1.Verdict.UNCERTAIN;
+    }
+    /**
+     * 从文本中提取判决
+     */
+    extractVerdictFromText(text) {
+        const lower = text.toLowerCase();
+        if (lower.includes('虚假') || lower.includes('false') || lower.includes('错误')) {
+            return types_1.Verdict.FALSE;
+        }
+        if (lower.includes('部分真实') || lower.includes('partially')) {
+            return types_1.Verdict.PARTIALLY_TRUE;
+        }
+        if (lower.includes('真实') || lower.includes('true') || lower.includes('正确')) {
+            return types_1.Verdict.TRUE;
+        }
+        return types_1.Verdict.UNCERTAIN;
+    }
+    /**
+     * 汇总所有来源
+     */
+    aggregateSources(searchResults, verifySources) {
+        const allSources = 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];
+    }
+}
+exports.VerifyAgent = VerifyAgent;

package/lib/config.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const koishi_1 = require("koishi");
+// 使用 Chatluna 的动态模型选择器
+exports.Config = koishi_1.Schema.intersect([
+    koishi_1.Schema.object({
+        mainModel: koishi_1.Schema.dynamic('model')
+            .default('google/gemini-3-flash')
+            .description('主控 Agent 模型 (用于编排和最终判决，推荐 Gemini-3-Flash)'),
+        subSearchModel: koishi_1.Schema.dynamic('model')
+            .default('x-ai/grok-4-1')
+            .description('子搜索 Agent 模型 (用于深度搜索，推荐 Grok-4-1)'),
+    }).description('模型配置'),
+    koishi_1.Schema.object({
+        chatlunaSearchModel: koishi_1.Schema.dynamic('model')
+            .default('')
+            .description('Chatluna Search 使用的模型 (可选，用于调用 chatluna-search-service)'),
+        enableChatlunaSearch: koishi_1.Schema.boolean()
+            .default(true)
+            .description('启用 Chatluna 搜索集成'),
+        chatlunaSearchDiversifyModel: koishi_1.Schema.dynamic('model')
+            .default('')
+            .description('搜索关键词多样化模型 (可选，推荐 Gemini 2.5 Flash Lite)'),
+    }).description('搜索配置'),
+    koishi_1.Schema.object({
+        timeout: koishi_1.Schema.number()
+            .min(10000)
+            .max(300000)
+            .default(60000)
+            .description('单次请求超时时间(毫秒)'),
+        maxRetries: koishi_1.Schema.number()
+            .min(0)
+            .max(5)
+            .default(2)
+            .description('失败重试次数'),
+    }).description('Agent配置'),
+    koishi_1.Schema.object({
+        verbose: koishi_1.Schema.boolean()
+            .default(false)
+            .description('显示详细验证过程 (进度提示)'),
+        outputFormat: koishi_1.Schema.union([
+            koishi_1.Schema.const('auto').description('自动 (QQ使用纯文本)'),
+            koishi_1.Schema.const('markdown').description('Markdown'),
+            koishi_1.Schema.const('plain').description('纯文本'),
+        ]).default('auto').description('输出格式'),
+        useForwardMessage: koishi_1.Schema.boolean()
+            .default(true)
+            .description('使用合并转发消息展示详情 (仅支持QQ)'),
+        forwardMaxNodes: koishi_1.Schema.number()
+            .min(0)
+            .max(99)
+            .default(8)
+            .description('合并转发最大节点数，超过则回退普通消息（0 表示直接回退）'),
+        forwardMaxTotalChars: koishi_1.Schema.number()
+            .min(0)
+            .max(20000)
+            .default(3000)
+            .description('合并转发总字符数上限，超过则回退普通消息（0 表示直接回退）'),
+        forwardMaxSegmentChars: koishi_1.Schema.number()
+            .min(50)
+            .max(2000)
+            .default(500)
+            .description('合并转发单节点字符数上限'),
+        bypassProxy: koishi_1.Schema.boolean()
+            .default(false)
+            .description('是否绕过系统代理'),
+        logLLMDetails: koishi_1.Schema.boolean()
+            .default(false)
+            .description('是否打印 LLM 请求体和响应详情 (Debug用)'),
+    }).description('其他设置'),
+]);