1834 lines
79 KiB
JavaScript
1834 lines
79 KiB
JavaScript
// js/chatbot/core/streaming-multi-hop.js
|
||
// 流式多轮取材 - 实时进度反馈
|
||
(function(window) {
|
||
'use strict';
|
||
|
||
/**
|
||
* 估算文本的token数量（简化版）
|
||
* @param {string} text - 要估算的文本
|
||
* @returns {number} 估算的token数
|
||
*/
|
||
function estimateTokens(text) {
|
||
if (!text || typeof text !== 'string') return 0;
|
||
|
||
// 中文字符：平均1.5字符 = 1 token
|
||
const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
|
||
const chineseTokens = Math.ceil(chineseChars / 1.5);
|
||
|
||
// 英文单词：平均1个单词 = 0.75 token
|
||
const englishWords = (text.match(/[a-zA-Z]+/g) || []).length;
|
||
const englishTokens = Math.ceil(englishWords * 0.75);
|
||
|
||
// 数字和符号：粗略估算
|
||
const otherChars = text.length - chineseChars - text.match(/[a-zA-Z\s]/g)?.length || 0;
|
||
const otherTokens = Math.ceil(otherChars / 4);
|
||
|
||
return chineseTokens + englishTokens + otherTokens;
|
||
}
|
||
|
||
/**
|
||
* 流式多轮取材
|
||
* 使用 Generator 函数实现流式输出，每个步骤都实时反馈给UI
|
||
*
|
||
* @param {string} userQuestion - 用户问题
|
||
* @param {Object} docContentInfo - 文档内容信息
|
||
* @param {Object} config - 配置
|
||
* @param {Object} options - 选项
|
||
* @returns {AsyncGenerator} 异步生成器
|
||
*/
|
||
async function* streamingMultiHopRetrieve(userQuestion, docContentInfo, config, options = {}) {
|
||
const userSet = window.semanticGroupsSettings || {};
|
||
// 设置较大上限防止死循环，但主要由AI通过final标志决定何时结束
|
||
const maxRounds = Number(options.maxRounds ?? userSet.maxRounds) > 0 ? Number(options.maxRounds ?? userSet.maxRounds) : 10;
|
||
|
||
try {
|
||
const groups = Array.isArray(docContentInfo.semanticGroups) ? docContentInfo.semanticGroups : [];
|
||
const hasGroups = groups.length > 0;
|
||
|
||
if (!hasGroups) {
|
||
console.log('[StreamingMultiHop] 没有意群数据，将只使用grep工具进行检索');
|
||
}
|
||
|
||
// 1. 分析问题，获取候选意群（如果有的话）
|
||
if (hasGroups) {
|
||
yield {
|
||
type: 'status',
|
||
phase: 'analyze',
|
||
message: '正在分析问题...'
|
||
};
|
||
}
|
||
|
||
const candidates = groups;
|
||
|
||
|
||
// 2. 多轮取材循环
|
||
const fetched = new Map();
|
||
const detail = [];
|
||
let contextParts = [];
|
||
const gist = (window.data && window.data.semanticDocGist) ? window.data.semanticDocGist : '';
|
||
const searchHistory = []; // 记录搜索历史
|
||
|
||
// 任务追踪状态
|
||
let taskStatusHistory = {
|
||
completed: [],
|
||
current: '',
|
||
pending: []
|
||
};
|
||
|
||
/**
|
||
* 升级或获取意群内容
|
||
* @param {Set<string>} groupIds - 意群ID集合
|
||
* @param {string} targetGranularity - 目标粒度 (summary/digest/full)
|
||
*/
|
||
const upgradeOrFetchGroups = async (groupIds, targetGranularity = 'digest') => {
|
||
if (groupIds.size === 0) {
|
||
console.warn('[StreamingMultiHop] upgradeOrFetchGroups: groupIds为空');
|
||
return;
|
||
}
|
||
|
||
console.log(`[StreamingMultiHop] 开始升级/获取 ${groupIds.size} 个意群到 ${targetGranularity}`);
|
||
|
||
for (const groupId of groupIds) {
|
||
if (window.SemanticTools && typeof window.SemanticTools.fetchGroupText === 'function') {
|
||
try {
|
||
const existing = fetched.get(groupId);
|
||
const shouldFetch = !existing ||
|
||
(existing.granularity === 'summary' && targetGranularity !== 'summary') ||
|
||
(existing.granularity === 'digest' && targetGranularity === 'full');
|
||
|
||
if (shouldFetch) {
|
||
const groupRes = window.SemanticTools.fetchGroupText(groupId, targetGranularity);
|
||
if (groupRes && groupRes.text) {
|
||
const isUpgrade = fetched.has(groupId);
|
||
fetched.set(groupId, { granularity: groupRes.granularity, text: groupRes.text });
|
||
|
||
console.log(`[StreamingMultiHop] ${isUpgrade ? '升级' : '新增'} ${groupId}: ${existing?.granularity || '无'} → ${groupRes.granularity}`);
|
||
|
||
// 更新detail和contextParts
|
||
if (isUpgrade) {
|
||
// 升级：替换原有内容
|
||
const idx = detail.findIndex(d => d.groupId === groupId);
|
||
if (idx >= 0) detail[idx].granularity = groupRes.granularity;
|
||
|
||
const ctxIdx = contextParts.findIndex(c => c.startsWith(`【${groupId}`));
|
||
if (ctxIdx >= 0) {
|
||
contextParts[ctxIdx] = `【${groupId} - ${groupRes.granularity}】\n${groupRes.text}`;
|
||
}
|
||
} else {
|
||
// 新增
|
||
detail.push({ groupId: groupId, granularity: groupRes.granularity });
|
||
contextParts.push(`【${groupId} - ${groupRes.granularity}】\n${groupRes.text}`);
|
||
}
|
||
} else {
|
||
console.warn(`[StreamingMultiHop] fetchGroupText返回空: ${groupId}`);
|
||
}
|
||
} else {
|
||
console.log(`[StreamingMultiHop] 跳过 ${groupId}: 已有${existing.granularity}，无需升级到${targetGranularity}`);
|
||
}
|
||
} catch (e) {
|
||
console.error(`[StreamingMultiHop] 升级${groupId}失败:`, e);
|
||
}
|
||
}
|
||
}
|
||
|
||
console.log(`[StreamingMultiHop] 升级完成，当前detail数量: ${detail.length}`);
|
||
};
|
||
|
||
// 预加载策略：第一轮给AI所有意群的summary，让AI判断哪些需要详细内容
|
||
// 后续轮会清理掉AI不感兴趣的意群，只保留AI操作过的内容
|
||
let preloadedInFirstRound = false;
|
||
const interestedGroups = new Set(); // 记录AI感兴趣的意群（fetch过或搜索命中）
|
||
let aiRequestedMapInFinalContext = false; // AI决定是否在最终上下文中包含地图
|
||
let aiRequestedGroupListInFinalContext = false; // AI决定是否在最终上下文中包含意群简要列表
|
||
|
||
if (hasGroups && userSet && userSet.preloadFirstRound === true && groups.length <= 50) {
|
||
yield {
|
||
type: 'status',
|
||
phase: 'preload',
|
||
message: `预加载 ${groups.length} 个意群摘要供AI判断...`
|
||
};
|
||
|
||
// 第一轮：预加载所有summary
|
||
for (const g of groups) {
|
||
if (window.SemanticTools?.fetchGroupText) {
|
||
try {
|
||
const res = window.SemanticTools.fetchGroupText(g.groupId, 'summary');
|
||
if (res && res.text) {
|
||
fetched.set(g.groupId, { granularity: 'summary', text: res.text });
|
||
detail.push({ groupId: g.groupId, granularity: 'summary' });
|
||
contextParts.push(`【${g.groupId} - summary】\n${res.text}`);
|
||
}
|
||
} catch (_) {}
|
||
}
|
||
}
|
||
|
||
preloadedInFirstRound = true;
|
||
yield {
|
||
type: 'status',
|
||
phase: 'preload_complete',
|
||
message: `已预加载 ${fetched.size} 个意群摘要，等待AI判断...`
|
||
};
|
||
}
|
||
|
||
for (let round = 0; round < maxRounds; round++) {
|
||
yield {
|
||
type: 'round_start',
|
||
round,
|
||
message: `第 ${round + 1} 轮取材...`
|
||
};
|
||
|
||
// 地图文本：仅在AI通过 map 工具请求后注入
|
||
const listText = (typeof window._multiHopLastMapText === 'string' && window._multiHopLastMapText) ? window._multiHopLastMapText : '';
|
||
|
||
// 构造已获取内容的摘要
|
||
let fetchedSummary = '无';
|
||
if (fetched.size > 0) {
|
||
const fetchedDetails = [];
|
||
for (const [groupId, data] of fetched.entries()) {
|
||
const preview = data.text.length > 500 ? data.text.substring(0, 500) + '...' : data.text;
|
||
fetchedDetails.push(`【${groupId}】(${data.granularity})\n${preview}`);
|
||
}
|
||
fetchedSummary = fetchedDetails.join('\n\n');
|
||
}
|
||
|
||
// 构造搜索历史提示
|
||
let searchHistoryText = '';
|
||
if (searchHistory.length > 0) {
|
||
const recentSearches = searchHistory.slice(-5); // 最近5次
|
||
searchHistoryText = '\n\n【搜索历史】(避免重复搜索这些查询):\n' + recentSearches.map(s => {
|
||
const status = s.resultCount > 0 ? `✓ ${s.resultCount}个结果` : '✗ 无结果';
|
||
const toolName = {
|
||
'vector_search': '向量',
|
||
'keyword_search': '关键词',
|
||
'grep': 'GREP',
|
||
'regex_search': '正则',
|
||
'boolean_search': '布尔'
|
||
}[s.tool] || s.tool;
|
||
return `- ${toolName}搜索 "${s.query}" → ${status}`;
|
||
}).join('\n');
|
||
}
|
||
|
||
const preloadedNotice = (round === 0 && fetched.size > 0) ? `
|
||
|
||
提示：已缓存 ${fetched.size} 个意群摘要在【已获取内容】中；若需整体地图，请调用 map 工具。` : '';
|
||
|
||
// 检查文档配置
|
||
const docId = (window.data && window.data.currentPdfName) || 'unknown';
|
||
const docConfig = window.data?.multiHopConfig?.[docId];
|
||
const useSemanticGroups = docConfig?.useSemanticGroups !== false; // 默认true
|
||
const useVectorSearch = docConfig?.useVectorSearch !== false; // 默认true
|
||
|
||
// 根据配置动态构建工具列表说明
|
||
const vectorSearchTool = useVectorSearch ? `**推荐优先使用：**
|
||
- {"tool":"vector_search","args":{"query":"语义描述","limit":15}}
|
||
用途：**智能语义搜索**（理解同义词、相关概念、隐含关系）
|
||
返回：语义最相关的chunks（每个1500-3000字）
|
||
**优势**：
|
||
* 理解问题的深层含义，不局限于字面匹配
|
||
* 能找到换了说法但意思相同的内容
|
||
* 适合概念性、开放性、探索性问题
|
||
* 召回率高，不会因为换词而漏掉相关内容
|
||
**你可以调整limit**：概念性问题可用limit=10-15，精确查找可用limit=5
|
||
|
||
` : '';
|
||
|
||
// BM25搜索：无论是否有意群都可用（基于chunks）
|
||
const keywordSearchTool = `
|
||
- {"tool":"keyword_search","args":{"keywords":["词1","词2"],"limit":8}}
|
||
用途：多关键词加权搜索（BM25算法）
|
||
返回：包含关键词的文档片段（按相关度评分）
|
||
**使用时机**：精确查找特定关键词组合${!useVectorSearch ? '（主要搜索工具）' : '，或vector_search失败时的降级方案'}
|
||
**你可以调整limit**：关键词明确可用limit=5，模糊查找可用limit=10
|
||
`;
|
||
|
||
const advancedSearchTools = `
|
||
**高级匹配工具（特殊场景使用）：**
|
||
- {"tool":"regex_search","args":{"pattern":"\\\\d{4}年\\\\d{1,2}月","limit":10,"context":1500}}
|
||
用途：正则表达式搜索（匹配特定格式）
|
||
返回：符合正则模式的文本片段
|
||
**适用场景**：
|
||
* 搜索特定格式（日期"2023年5月"、编号"公式3.2"、"Fig. 1"）
|
||
* 匹配复杂模式（电话、邮箱、特殊符号组合）
|
||
* 数学公式编号、图表引用等
|
||
* OCR错误的容错匹配（如"注[意愈]力"可用"注.力"匹配）
|
||
**注意**：pattern需要转义特殊字符（\\\\d 表示数字，\\\\. 表示点号）
|
||
|
||
- {"tool":"boolean_search","args":{"query":"(CNN OR RNN) AND 对比 NOT 图像","limit":10,"context":1500}}
|
||
用途：布尔逻辑搜索（AND/OR/NOT组合）
|
||
返回：同时满足多个条件的文本片段
|
||
**适用场景**：
|
||
* 复杂逻辑查询（必须包含A和B，但不包含C）
|
||
* 多概念精确组合（比grep的OR更强大）
|
||
* 排除干扰信息（NOT关键词）
|
||
**语法**：支持 AND, OR, NOT 和括号，如 "(词1 OR 词2) AND 词3 NOT 词4"
|
||
`;
|
||
|
||
const mapFetchTools = useSemanticGroups ? `
|
||
### 获取详细内容工具
|
||
- {"tool":"fetch","args":{"groupId":"group-1"}}
|
||
用途：获取指定意群详细内容（包含完整论述、公式、数据、图表）
|
||
返回：完整文本（最多8000字）+ 结构信息
|
||
**使用时机**：当搜索到的chunk片段信息不足，需要看到完整上下文时
|
||
|
||
- {"tool":"map","args":{"limit":50,"includeStructure":true}}
|
||
用途：获取文档整体结构
|
||
返回：意群地图（ID、字数、关键词、摘要、章节/图表/公式）
|
||
${preloadedNotice}
|
||
` : `${preloadedNotice}
|
||
`;
|
||
|
||
const sys = `你是检索规划助手，专门负责规划如何从文档中检索相关内容。
|
||
|
||
**重要：你的角色定位**
|
||
- ⚠️ **你不负责回答用户问题**，你只负责规划如何检索文档内容
|
||
- ⚠️ **不要生成mermaid图表、思维导图或任何最终答案**
|
||
- ✓ 你的任务：分析用户问题 → 规划使用哪些工具检索文档 → 输出JSON格式的检索计划
|
||
- ✓ 检索到的内容会交给另一个AI来回答用户问题
|
||
|
||
**你的工作流程**
|
||
1. 分析用户问题，判断需要什么类型的信息
|
||
2. 选择合适的检索工具组合
|
||
3. **规划任务清单**：将复杂问题拆解为多个检索子任务
|
||
4. 输出JSON格式的检索计划（不是答案！）
|
||
|
||
## 工具定义（JSON格式）
|
||
|
||
### 搜索工具（返回chunk内容，由你决定是否需要完整意群）
|
||
|
||
${vectorSearchTool}**精确匹配场景使用：**
|
||
- {"tool":"grep","args":{"query":"具体短语","limit":20,"context":2000,"caseInsensitive":true}}
|
||
用途：字面文本搜索（适合已知精确关键词）
|
||
返回：包含该短语的原文片段（前后2000字上下文）
|
||
**适用场景**：
|
||
* 搜索专有名词、特定数字、固定术语
|
||
* 用户问题中明确提到某个词，需要找原文
|
||
* 你已经知道文档中的确切表达方式
|
||
**支持OR逻辑**：query可用 | 分隔多个关键词，如 "方程|公式|equation"
|
||
**你可以调整limit**：需要更多结果就增大limit，只需少量结果就减小limit
|
||
|
||
${keywordSearchTool}
|
||
${advancedSearchTools}
|
||
${mapFetchTools}
|
||
|
||
## 智能决策流程
|
||
|
||
**第一步：分析问题复杂度，选择工具组合策略**
|
||
|
||
**简单问题（单工具足够）：**
|
||
1. 精确实体查找
|
||
- 示例："雷曼公司何时破产？"
|
||
→ grep("雷曼|Lehman", limit=5)
|
||
|
||
${useVectorSearch ? `2. 单一概念解释
|
||
- 示例："什么是注意力机制？"
|
||
→ vector_search("注意力机制 原理", limit=8)
|
||
|
||
` : ''}3. 特定格式查找（编号、日期）
|
||
- 示例："找出公式3.2的内容"
|
||
→ regex_search("公式\\\\s*3\\\\.2|式\\\\s*\\\\(3\\\\.2\\\\)", limit=5)
|
||
- 示例："2023年的相关研究"
|
||
→ regex_search("2023年", limit=10)
|
||
|
||
4. 复杂逻辑排除
|
||
- 示例："讨论模型但不涉及训练的内容"
|
||
→ boolean_search("模型 NOT (训练 OR train)", limit=8)
|
||
|
||
**复杂问题（建议多工具并用）：**
|
||
${useVectorSearch && useSemanticGroups ? `1. 综合性分析（如"研究背景与意义"）
|
||
- 策略：**并发使用多个工具，全方位检索**
|
||
- 示例："研究背景与意义？"
|
||
→ 第1轮并发（推荐加入map获取整体结构）：
|
||
{"operations":[
|
||
{"tool":"vector_search","args":{"query":"研究背景 意义 动机","limit":10}},
|
||
{"tool":"grep","args":{"query":"背景|意义|动机|研究目的","limit":8}},
|
||
{"tool":"map","args":{"limit":30}}
|
||
],"final":false}
|
||
→ 第2轮根据结果决定是否需要fetch关键意群
|
||
|
||
2. 多维度对比（如"CNN和RNN的区别"）
|
||
- 策略：**搜索两个主体 + 对比关系**
|
||
- 示例："CNN和RNN的区别"
|
||
→ {"operations":[
|
||
{"tool":"vector_search","args":{"query":"CNN RNN 区别 对比","limit":12}},
|
||
{"tool":"grep","args":{"query":"CNN|RNN","limit":10}}
|
||
],"final":false}
|
||
|
||
3. 历史/因果关系（如"金融危机的原因和影响"）
|
||
- 策略：**语义搜索 + 关键词 + 可能需要map**
|
||
- 示例："金融危机的原因和影响"
|
||
→ {"operations":[
|
||
{"tool":"vector_search","args":{"query":"金融危机 原因 影响","limit":12}},
|
||
{"tool":"grep","args":{"query":"危机|原因|影响|导致","limit":8}},
|
||
{"tool":"map","args":{"limit":30}}
|
||
],"final":false}
|
||
|
||
4. 整体理解类（如"文档的主要内容"）
|
||
- 策略：**先map看结构，再fetch关键部分**
|
||
- 示例："文档讲了什么？"
|
||
→ 第1轮：{"operations":[{"tool":"map","args":{"limit":50}}],"final":false}
|
||
→ 第2轮：根据地图fetch重要意群
|
||
|
||
` : `1. 多关键词搜索
|
||
- 策略：**使用grep进行关键词检索**
|
||
- 示例："研究背景与意义？"
|
||
→ {"operations":[
|
||
{"tool":"grep","args":{"query":"背景|意义|动机|研究目的","limit":15}}
|
||
],"final":false}
|
||
|
||
2. 特定概念搜索
|
||
- 策略：**使用keyword_search进行BM25搜索**
|
||
- 示例："什么是注意力机制？"
|
||
→ {"operations":[
|
||
{"tool":"keyword_search","args":{"keywords":["注意力","机制","attention"],"limit":10}}
|
||
],"final":false}
|
||
|
||
`}**工具组合原则：**
|
||
- **复杂问题优先多工具并用**（同一轮并发执行）
|
||
${useVectorSearch ? `- vector_search（语义）+ grep（精确）= 更高召回率和准确率
|
||
${useSemanticGroups ? `- **综合性分析问题（如"研究背景与意义"）强烈建议使用map**：map提供文档整体结构，有助于理解背景脉络
|
||
- 多维度问题建议3个工具：vector + grep + map
|
||
` : ''}` : `- grep（精确）+ keyword_search（BM25）= 提高召回率
|
||
- 多个关键词组合使用，提高搜索准确性
|
||
`}- 简单问题可以单工具，但不确定时宁可多用
|
||
- **优先级判断**：
|
||
* 有明确格式（日期、编号、公式）→ 首选 regex_search
|
||
* 需要排除干扰词（NOT逻辑）→ 首选 boolean_search
|
||
* 普通精确词匹配 → 使用 grep
|
||
* 语义理解、同义词 → 使用 vector_search
|
||
- regex和boolean是**特殊场景工具**，不要过度使用，普通查询用grep/vector即可
|
||
|
||
${useSemanticGroups ? `**第二步：判断是否需要fetch意群完整内容**
|
||
- 搜索工具会返回：chunk内容 + suggestedGroups（所属意群列表）
|
||
- 如果chunk片段**已包含足够信息**回答问题 → 不需要fetch，直接final=true
|
||
- 如果chunk片段**信息不足**（如缺少公式细节、数据表、完整论述） → fetch相关意群
|
||
- **优先精准而非全面**：只fetch真正需要的意群，不要全部fetch
|
||
|
||
` : ''}**核心原则：提供充分、详细、准确的上下文**
|
||
- 你的目标是为最终AI提供**足够回答用户问题的完整上下文**
|
||
- 不要因为担心token浪费而过早结束检索
|
||
- 宁可多获取一些内容，也不要让最终AI因为信息不足而无法回答
|
||
- 【已获取内容】为空时，**绝不能**返回空操作，必须至少执行一次检索
|
||
|
||
**第三步：控制结果数量，避免噪音**
|
||
${useVectorSearch ? `- **优先用vector_search**，概念性问题用limit=10-15，精确查找用limit=5-8
|
||
- grep仅用于精确匹配场景，limit=5-10即可
|
||
` : `- **优先用grep**，精确匹配场景用limit=10-15
|
||
`}- keyword_search作为降级方案，limit=8-10
|
||
- 避免一次性返回过多结果造成token浪费
|
||
- 如果第一次搜索结果不足，可以增加limit或换工具
|
||
|
||
${useSemanticGroups ? `**第四步：地图信息的智能使用**
|
||
- 【候选意群地图】提供了文档结构概览（如果执行过map工具）
|
||
- **你可以根据任务类型自主决定是否需要地图信息辅助回答**：
|
||
* 宏观任务（如"总结主要内容"、"思维导图"）：地图很有用，可直接引用地图结构
|
||
* 微观任务（如"雷曼公司何时破产"）：地图意义不大，依赖具体检索结果
|
||
* 混合/长难任务（如"谁做了什么经历"）：地图可提供流程框架，再用fetch补充细节
|
||
- **你的决策方式**：在final=true时，【已获取内容】中包含的信息应该足够最终AI回答
|
||
* 如果认为地图有助于宏观理解，可以确保地图已在【候选意群地图】中（map工具已执行）
|
||
* 如果地图无关紧要，只需确保检索到的chunks/groups足够即可
|
||
|
||
**第五步：并发与结束**
|
||
` : `**第四步：并发与结束**
|
||
`}
|
||
- 可以在同一轮并发执行多个操作
|
||
- 获取到足够内容后立即final=true
|
||
- **严格检查【搜索历史】避免重复搜索**：
|
||
* ⚠️ 如果【搜索历史】中已有完全相同的查询（query相同），**绝对不要**再次执行
|
||
* ⚠️ 如果【搜索历史】中显示某个查询"✗ 无结果"，不要换工具重试相同查询（大概率还是无结果）
|
||
* ✓ 应该换用不同的关键词、或使用不同策略（如用map看整体结构）
|
||
- **只有当【已获取内容】真正充足时**，才返回{"operations":[],"final":true}
|
||
- **如果【已获取内容】为空或不足**，必须继续检索，不能直接final=true
|
||
|
||
## 任务追踪机制（Task Status Tracking）
|
||
|
||
**多轮检索时使用taskStatus追踪进度**，帮助你在复杂问题中保持目标清晰：
|
||
|
||
**taskStatus字段说明**（可选，但复杂问题强烈推荐）：
|
||
{
|
||
"operations": [...],
|
||
"final": false,
|
||
"taskStatus": {
|
||
"completed": ["✓ 已获取研究背景(vector_search+grep, 找到18个chunks)"],
|
||
"current": "→ 正在获取方法论详细描述",
|
||
"pending": ["待检索实验设计", "待检索结论和展望"]
|
||
}
|
||
}
|
||
|
||
- **completed**: 已完成的检索任务（附工具和结果数）
|
||
* 示例："✓ 已获取研究动机(vector_search, 3个chunks)"
|
||
* **重要**：记录已搜索的query，避免下一轮重复执行
|
||
* 作用：避免重复检索，展示进度
|
||
|
||
- **current**: 当前正在执行的任务
|
||
* 示例："→ 正在查找公式推导过程"
|
||
* 作用：明确本轮目标
|
||
|
||
- **pending**: 后续待完成的任务列表
|
||
* 示例：["待补充图表说明", "待验证时间线"]
|
||
* 作用：规划下一步，防止遗漏
|
||
|
||
**使用场景**：
|
||
- **简单问题**（1轮完成）：可省略taskStatus
|
||
- **复杂问题**（需多轮）：必须使用taskStatus
|
||
* 第1轮：分解任务到pending，设置current
|
||
* 中间轮：更新completed，调整current和pending
|
||
* 最终轮：所有任务在completed，pending为空
|
||
|
||
**完整示例：复杂问题的追踪**
|
||
问题："分析论文的背景、方法、实验和结论"
|
||
|
||
第1轮规划：
|
||
{"operations":[{"tool":"vector_search","args":{"query":"研究背景 动机","limit":10}}],"final":false,"taskStatus":{"completed":[],"current":"→ 检索研究背景和动机","pending":["待检索方法论","待检索实验","待检索结论"]}}
|
||
|
||
第2轮规划：
|
||
{"operations":[{"tool":"fetch","args":{"groupId":"group-5"}}],"final":false,"taskStatus":{"completed":["✓ 已获取研究背景(vector+grep, 18个chunks)"],"current":"→ 获取方法论详细内容","pending":["待检索实验","待检索结论"]}}
|
||
|
||
第3轮（完成）：
|
||
{"operations":[],"final":true,"taskStatus":{"completed":["✓ 研究背景","✓ 方法论","✓ 实验结果","✓ 结论"],"current":"→ 检索完成","pending":[]}}
|
||
|
||
## 示例决策
|
||
|
||
⚠️ **输出示例对比**：
|
||
问题："生成思维导图"
|
||
|
||
❌ 错误输出（直接生成mermaid代码块）：禁止！那是回答问题，不是规划检索。
|
||
|
||
✓ 正确输出（规划检索+简短说明）：
|
||
需要获取文档结构和主要内容，使用map工具。
|
||
{"operations":[{"tool":"map","args":{"limit":50}}],"final":false,"includeMapInFinalContext":true}
|
||
|
||
说明：你只规划"如何检索"，不生成"最终答案"。另一个AI会用检索结果生成mermaid。
|
||
|
||
---
|
||
|
||
示例1（复杂综合问题，多工具并用）：
|
||
问题："研究背景与意义？"
|
||
→ {"operations":[
|
||
{"tool":"vector_search","args":{"query":"研究背景 意义 动机","limit":10}},
|
||
{"tool":"grep","args":{"query":"背景|意义|动机|研究目的","limit":8}}
|
||
],"final":false}
|
||
→ 返回vector: 8个语义相关chunk + grep: 5个精确匹配chunk
|
||
→ 两者互补，语义覆盖+精确补充
|
||
→ {"operations":[{"tool":"fetch","args":{"groupId":"group-1"}}],"final":true}
|
||
|
||
示例2（对比分析，多工具）：
|
||
问题："CNN和RNN的区别"
|
||
→ {"operations":[
|
||
{"tool":"vector_search","args":{"query":"CNN RNN 区别 对比","limit":12}},
|
||
{"tool":"grep","args":{"query":"CNN|RNN","limit":10}}
|
||
],"final":false}
|
||
→ vector找语义关系，grep确保两个主体都覆盖
|
||
→ chunk足够，{"operations":[],"final":true}
|
||
|
||
示例3（简单精确查找，单工具足够）：
|
||
问题："雷曼公司何时破产"
|
||
→ {"operations":[{"tool":"grep","args":{"query":"雷曼|Lehman","limit":5}}],"final":true}
|
||
→ 返回3个chunk，包含"2008年9月15日申请破产"
|
||
→ 单工具足够
|
||
|
||
示例4（查找特定格式内容，使用正则）：
|
||
问题："找出文中所有的公式编号"
|
||
→ {"operations":[{"tool":"regex_search","args":{"pattern":"公式\\\\s*\\\\d+\\\\.\\\\d+|式\\\\s*\\\\(\\\\d+\\\\)","limit":20}}],"final":true}
|
||
→ 正则匹配"公式3.2"、"式(15)"等格式
|
||
→ 比grep更精确，避免误匹配
|
||
|
||
示例5（复杂逻辑查询，使用布尔搜索）：
|
||
问题："提到CNN但不涉及图像的内容"
|
||
→ {"operations":[{"tool":"boolean_search","args":{"query":"CNN AND (网络 OR 模型) NOT (图像 OR 视觉)","limit":10}}],"final":false}
|
||
→ 找到讨论CNN网络结构但不涉及图像应用的段落
|
||
→ 比单独用grep的OR更精确
|
||
|
||
示例6（查找日期或时间信息，用正则）：
|
||
问题："论文发表时间"
|
||
→ {"operations":[
|
||
{"tool":"regex_search","args":{"pattern":"\\\\d{4}年|\\\\d{4}-\\\\d{2}|20\\\\d{2}","limit":10}},
|
||
{"tool":"grep","args":{"query":"发表|出版|published","limit":5}}
|
||
],"final":true}
|
||
→ 正则找日期格式 + grep找相关词汇
|
||
|
||
示例7（宏观理解，map+fetch）：
|
||
问题："生成思维导图"
|
||
→ {"operations":[{"tool":"map","args":{"limit":50}}],"final":false}
|
||
→ 获取意群地图
|
||
→ {"operations":[
|
||
{"tool":"fetch","args":{"groupId":"group-1"}},
|
||
{"tool":"fetch","args":{"groupId":"group-5"}},
|
||
{"tool":"fetch","args":{"groupId":"group-10"}}
|
||
],"final":true,"includeMapInFinalContext":true}
|
||
→ fetch关键意群 + 包含地图
|
||
|
||
示例8（❌ 错误：重复搜索）：
|
||
问题："找电影《猜火车》的引用"
|
||
第1轮：{"operations":[{"tool":"grep","args":{"query":"TRAINSPOTTING|猜火车","limit":20}}],"final":false}
|
||
→ 搜索历史显示：GREP搜索 "TRAINSPOTTING|猜火车" → ✓ 4个结果
|
||
|
||
❌ 第2轮错误做法：{"operations":[{"tool":"grep","args":{"query":"TRAINSPOTTING|猜火车","limit":20}}],"final":true}
|
||
（完全相同的query，禁止重复！）
|
||
|
||
✓ 第2轮正确做法：
|
||
- 如果4个结果已足够 → {"operations":[],"final":true}
|
||
- 如果需要更多上下文 → {"operations":[{"tool":"fetch","args":{"groupId":"group-2"}}],"final":true}
|
||
（fetch包含这些结果的意群，获取完整上下文）
|
||
|
||
## 限制与原则
|
||
- 每轮最多5个操作
|
||
- **复杂问题优先多工具并用**（在同一轮operations数组中并发执行）
|
||
- vector_search擅长语义理解，grep擅长精确匹配，**两者结合效果最佳**
|
||
- 简单精确查找可以只用grep，但综合性/分析性问题**必须多工具**
|
||
- 搜索limit不要超过20（避免噪音）
|
||
- 只fetch真正需要的意群（2-5个为宜）
|
||
- 优先chunk片段，确实不足才fetch意群
|
||
|
||
## 返回格式要求（严格遵守）
|
||
|
||
⚠️ **你只能返回JSON格式的检索计划，但可以在JSON前后添加简短说明**
|
||
|
||
**允许的输出格式**：
|
||
1. 纯JSON（推荐）
|
||
2. 简短说明 + JSON（可选，用于解释检索策略）
|
||
例如："需要获取研究背景信息，使用向量搜索和关键词检索。\n{...JSON...}"
|
||
|
||
**禁止输出的内容**：
|
||
* ❌ mermaid图表、思维导图代码
|
||
* ❌ 对用户问题的直接回答（如"该研究的背景是..."）
|
||
* ❌ 详细的论述或分析
|
||
* ✓ 可以：简短的检索策略说明（1-2句话）
|
||
|
||
**正确格式**：
|
||
{
|
||
"operations": [...],
|
||
"final": true/false,
|
||
"taskStatus": { // 可选，复杂问题建议使用
|
||
"completed": ["已完成的任务..."],
|
||
"current": "当前任务",
|
||
"pending": ["待做任务..."]
|
||
},
|
||
"includeMapInFinalContext": true/false,
|
||
"includeGroupListInFinalContext": true/false
|
||
}
|
||
|
||
**给最终AI的上下文自主控制**（可选字段，默认false）：
|
||
- **includeMapInFinalContext**: 是否包含完整地图结构
|
||
* 宏观任务（思维导图、总结全文）→ true
|
||
* 微观任务（查找具体事实）→ false
|
||
|
||
- **includeGroupListInFinalContext**: 是否包含所有意群的简要列表（ID+字数+摘要）
|
||
* 需要全局视角但不需要详细地图 → true
|
||
* 只需要精确检索结果 → false
|
||
|
||
- **你fetch的意群**: 会自动包含在最终上下文中（full/digest粒度）
|
||
|
||
**灵活组合示例**：
|
||
- 微观查询："公式7是什么" → fetch(group-5) + 无地图无列表
|
||
- 宏观总结："生成思维导图" → map + includeMapInFinalContext:true + includeGroupListInFinalContext:true
|
||
- 混合任务："分析影响因素" → 搜索 + fetch若干意群 + includeGroupListInFinalContext:true（提供背景）
|
||
|
||
示例JSON：
|
||
- 示例1（继续检索，带任务追踪）：
|
||
{"operations":[{"tool":"fetch","args":{"groupId":"group-1"}}],"final":false,"taskStatus":{"completed":["✓ 已搜索背景"],"current":"→ 获取方法论","pending":["待查实验"]}}
|
||
- 示例2（完成，仅fetch内容）：
|
||
{"operations":[],"final":true}
|
||
- 示例3（完成，需要地图+列表）：
|
||
{"operations":[],"final":true,"includeMapInFinalContext":true,"includeGroupListInFinalContext":true}
|
||
- 示例4（完成，带任务总结）：
|
||
{"operations":[],"final":true,"taskStatus":{"completed":["✓ 背景","✓ 方法","✓ 实验","✓ 结论"],"current":"→ 完成","pending":[]}}
|
||
|
||
**taskStatus字段说明**（详见上方"任务追踪机制"章节）`;
|
||
|
||
// 构建任务状态提示文本
|
||
let taskStatusText = '';
|
||
if (round > 0 && (taskStatusHistory.completed.length > 0 || taskStatusHistory.current || taskStatusHistory.pending.length > 0)) {
|
||
const parts = [];
|
||
if (taskStatusHistory.completed.length > 0) {
|
||
parts.push(`已完成: ${taskStatusHistory.completed.join('; ')}`);
|
||
}
|
||
if (taskStatusHistory.current) {
|
||
parts.push(`上轮任务: ${taskStatusHistory.current}`);
|
||
}
|
||
if (taskStatusHistory.pending.length > 0) {
|
||
parts.push(`待完成: ${taskStatusHistory.pending.join('; ')}`);
|
||
}
|
||
taskStatusText = '\n\n【任务追踪状态】\n' + parts.join('\n');
|
||
}
|
||
|
||
let content = `文档总览:\n${gist}\n\n用户问题:\n${String(userQuestion || '')}${searchHistoryText}${taskStatusText}\n\n${listText ? '【候选意群地图】：\n' + listText + '\n\n' : ''}【已获取内容】：\n${fetchedSummary}`;
|
||
|
||
// 调用LLM规划（支持重试）
|
||
yield {
|
||
type: 'status',
|
||
phase: 'planning',
|
||
round,
|
||
message: 'LLM规划中...'
|
||
};
|
||
|
||
const apiKey = config.apiKey;
|
||
let plannerOutput = null;
|
||
let retryCount = 0;
|
||
const maxRetries = 2; // 最多重试2次
|
||
let parseSuccess = false;
|
||
let plan = null;
|
||
|
||
// 重试循环：如果JSON解析失败，给AI反馈并重试
|
||
while (!parseSuccess && retryCount <= maxRetries) {
|
||
if (retryCount > 0) {
|
||
yield {
|
||
type: 'info',
|
||
message: `JSON格式错误，正在重试 (${retryCount}/${maxRetries})...`
|
||
};
|
||
}
|
||
|
||
plannerOutput = await window.ChatbotCore.singleChunkSummary(sys, content, config, apiKey);
|
||
|
||
// 统计规划器token使用
|
||
const plannerInputTokens = estimateTokens(sys) + estimateTokens(content);
|
||
const plannerOutputTokens = estimateTokens(plannerOutput);
|
||
const plannerTotalTokens = plannerInputTokens + plannerOutputTokens;
|
||
|
||
yield {
|
||
type: 'token_usage',
|
||
phase: 'planner',
|
||
round,
|
||
tokens: {
|
||
input: plannerInputTokens,
|
||
output: plannerOutputTokens,
|
||
total: plannerTotalTokens
|
||
}
|
||
};
|
||
|
||
// 尝试解析计划
|
||
try {
|
||
let cleaned = plannerOutput
|
||
.replace(/```jsonc?|```tool|```/gi,'')
|
||
.replace(/[\u0000-\u001f]/g, ' ')
|
||
.trim();
|
||
|
||
if (!cleaned) {
|
||
yield { type: 'warning', message: '规划输出为空，使用后备策略' };
|
||
break;
|
||
}
|
||
|
||
// 如果输出不是JSON（以中文或非{开头），尝试提取JSON
|
||
if (!cleaned.startsWith('{') && !cleaned.startsWith('[')) {
|
||
// 尝试提取JSON块
|
||
const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
|
||
if (jsonMatch) {
|
||
cleaned = jsonMatch[0];
|
||
console.log('[streamingMultiHop] 从文本中提取JSON:', cleaned.substring(0, 100));
|
||
} else {
|
||
// 尝试从文本中提取operations和final信息
|
||
console.log('[streamingMultiHop] 尝试从自然语言提取结构:', cleaned.substring(0, 200));
|
||
|
||
// 检查是否明确表达"已完成"、"足够"等含义
|
||
if (cleaned.match(/已.*足够|无需.*操作|不需要.*继续|已经.*完成|内容.*充足/i)) {
|
||
plan = { operations: [], final: true };
|
||
console.log('[streamingMultiHop] 识别为完成信号，设置final=true');
|
||
} else {
|
||
// 完全没有JSON且无法解析，返回空操作+final
|
||
console.warn('[streamingMultiHop] LLM输出非JSON格式，自动结束:', cleaned.substring(0, 100));
|
||
yield {
|
||
type: 'warning',
|
||
message: `第 ${round + 1} 轮LLM返回非JSON格式，已获取 ${fetched.size} 个意群，使用已有内容`
|
||
};
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!plan) {
|
||
try {
|
||
plan = JSON.parse(cleaned);
|
||
} catch (parseErr) {
|
||
// 尝试各种清理策略
|
||
let normalized = cleaned
|
||
// 移除所有控制字符和特殊空白
|
||
.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
|
||
// 修复中文引号
|
||
.replace(/[""]/g, '"')
|
||
.replace(/['']/g, "'")
|
||
// 修复JSON中的常见错误
|
||
.replace(/"(\w+)"\s*:\s*'([^']*)'/g, '"$1":"$2"') // 单引号改双引号
|
||
.replace(/(\w+):/g, '"$1":') // 无引号键名加引号
|
||
.replace(/,\s*}/g, '}') // 移除对象尾随逗号
|
||
.replace(/,\s*]/g, ']') // 移除数组尾随逗号
|
||
// 修复 ," "final": 这种错误
|
||
.replace(/,\s*"\s+"(\w+)"\s*:/g, ',"$1":')
|
||
// 修复 "operations" " 这种空格
|
||
.replace(/"(\w+)"\s+"/g, '"$1":')
|
||
// 修复键名周围的多余空格
|
||
.replace(/"\s+([\w-]+)"\s*:/g, '"$1":')
|
||
// 修复值周围的多余空格
|
||
.replace(/:\s*"\s+/g, ':"')
|
||
.replace(/\s+"/g, '"')
|
||
// 修复final前的空格
|
||
.replace(/"\s*final\s*"/gi, '"final"')
|
||
// 修复operations
|
||
.replace(/"operations"\s*"/i, '"operations":')
|
||
// 移除注释
|
||
.replace(/\/\*[\s\S]*?\*\//g, '')
|
||
.replace(/\/\/.*/g, '')
|
||
// 压缩空格
|
||
.replace(/\s+/g, ' ')
|
||
.trim();
|
||
|
||
console.log('[streamingMultiHop] 清理后的JSON:', normalized.substring(0, 200));
|
||
plan = JSON.parse(normalized);
|
||
}
|
||
}
|
||
|
||
yield {
|
||
type: 'plan',
|
||
round,
|
||
data: {
|
||
operations: plan.operations || [],
|
||
final: plan.final,
|
||
taskStatus: plan.taskStatus || null // 传递任务状态
|
||
}
|
||
};
|
||
|
||
// 捕获AI的任务状态更新
|
||
if (plan.taskStatus) {
|
||
// 更新任务追踪历史
|
||
if (Array.isArray(plan.taskStatus.completed)) {
|
||
taskStatusHistory.completed = plan.taskStatus.completed;
|
||
}
|
||
if (typeof plan.taskStatus.current === 'string') {
|
||
taskStatusHistory.current = plan.taskStatus.current;
|
||
}
|
||
if (Array.isArray(plan.taskStatus.pending)) {
|
||
taskStatusHistory.pending = plan.taskStatus.pending;
|
||
}
|
||
|
||
// 输出任务状态到UI
|
||
yield {
|
||
type: 'task_status',
|
||
round,
|
||
status: {
|
||
completed: taskStatusHistory.completed,
|
||
current: taskStatusHistory.current,
|
||
pending: taskStatusHistory.pending
|
||
}
|
||
};
|
||
|
||
console.log('[StreamingMultiHop] 任务状态更新:', taskStatusHistory);
|
||
}
|
||
|
||
// 捕获AI关于地图包含的决策
|
||
if (plan.includeMapInFinalContext === true) {
|
||
aiRequestedMapInFinalContext = true;
|
||
console.log('[StreamingMultiHop] AI请求在最终上下文中包含地图概览');
|
||
}
|
||
|
||
// 捕获AI关于意群列表包含的决策
|
||
if (plan.includeGroupListInFinalContext === true) {
|
||
aiRequestedGroupListInFinalContext = true;
|
||
console.log('[StreamingMultiHop] AI请求在最终上下文中包含意群简要列表');
|
||
}
|
||
|
||
parseSuccess = true; // 成功解析，退出重试循环
|
||
} catch (e) {
|
||
console.error('[streamingMultiHop] 解析计划失败:', e.message);
|
||
console.error('[streamingMultiHop] LLM原始输出:', plannerOutput);
|
||
|
||
retryCount++;
|
||
|
||
if (retryCount <= maxRetries) {
|
||
// 还有重试机会，构造错误提示
|
||
const errorFeedback = `\n\n【上次输出解析失败】\n错误信息: ${e.message}\n你的输出: ${plannerOutput.substring(0, 300)}\n\n请注意：\n1. 必须输出严格的JSON格式\n2. 字符串中的特殊字符需要转义（如 $ 应写成 \\$ 或避免使用）\n3. 不要在JSON字符串值中使用 | $ \\ 等特殊字符，或使用中文替代\n4. 示例正确格式：{"operations":[{"tool":"grep","args":{"query":"公式 模型 回归","limit":10}}],"final":false}\n\n请重新输出正确的JSON：`;
|
||
content = content + errorFeedback;
|
||
console.log(`[streamingMultiHop] 准备第 ${retryCount} 次重试，已添加错误提示`);
|
||
} else {
|
||
// 重试耗尽，执行原有的fallback逻辑
|
||
yield {
|
||
type: 'error',
|
||
phase: 'parse_plan',
|
||
message: `解析计划失败（已重试${maxRetries}次）: ${e.message}`,
|
||
raw: plannerOutput
|
||
};
|
||
|
||
// 如果已经获取到内容，直接使用，不要丢弃
|
||
if (fetched.size > 0) {
|
||
yield {
|
||
type: 'warning',
|
||
message: `第 ${round + 1} 轮规划失败，但已获取 ${fetched.size} 个意群，使用已有内容`
|
||
};
|
||
break; // 结束for循环，使用已fetch的内容
|
||
}
|
||
|
||
// 只有在完全没有内容时才使用后备策略
|
||
const fallback = buildFallbackSemanticContext(userQuestion, groups);
|
||
if (fallback) {
|
||
yield {
|
||
type: 'fallback',
|
||
reason: 'parse-error',
|
||
context: fallback.context
|
||
};
|
||
return fallback;
|
||
}
|
||
break; // 结束for循环
|
||
}
|
||
}
|
||
} // 结束重试while循环
|
||
|
||
// 如果重试循环结束但没有成功解析，跳过这一轮
|
||
if (!parseSuccess) {
|
||
console.log('[streamingMultiHop] 解析失败且已耗尽重试次数，跳过本轮');
|
||
continue; // 继续下一轮round
|
||
}
|
||
|
||
let ops = Array.isArray(plan.operations) ? plan.operations : [];
|
||
|
||
// 若首轮规划为空且尚无任何已获取内容，自动注入一次默认检索，避免空转
|
||
if (round === 0 && ops.length === 0 && fetched.size === 0) {
|
||
const buildDefaultOpsFromQuestion = (q, preferVector) => {
|
||
try {
|
||
const raw = String(q || '').toLowerCase();
|
||
// 去掉无信息量的泛化词
|
||
const stop = /(用通俗语言|通俗解释|解释一下|解释|概述|总结|主要内容|全文|请|如何|是什么|简单|大致|大概|说明|讲一讲|讲一下|阐述|简介|介绍|说明一下)/g;
|
||
const cleaned = raw.replace(stop, ' ').replace(/[\p{P}\p{S}]+/gu, ' ').replace(/\s+/g, ' ').trim();
|
||
const tokens = cleaned.split(/\s+/).filter(w => w && w.length > 1);
|
||
const query = tokens.slice(0, 6).join(' ');
|
||
if (!query) return [];
|
||
if (preferVector) {
|
||
return [{ tool: 'vector_search', args: { query, limit: 8 } }];
|
||
} else {
|
||
return [{ tool: 'grep', args: { query, limit: 12, context: 2000, caseInsensitive: true } }];
|
||
}
|
||
} catch (_) { return []; }
|
||
};
|
||
|
||
// 判断是否可用向量（来自前面的配置判断）
|
||
const docIdTmp = (window.data && window.data.currentPdfName) || 'unknown';
|
||
const docCfgTmp = window.data?.multiHopConfig?.[docIdTmp];
|
||
const preferVector = docCfgTmp?.useVectorSearch !== false;
|
||
const injected = buildDefaultOpsFromQuestion(userQuestion, preferVector);
|
||
if (injected && injected.length > 0) {
|
||
ops = injected;
|
||
yield { type: 'info', message: '规划为空，已自动注入默认检索' };
|
||
}
|
||
}
|
||
|
||
// 如果operations为空但已有内容，说明AI认为当前内容已足够
|
||
if (ops.length === 0) {
|
||
if (fetched.size > 0) {
|
||
yield {
|
||
type: 'info',
|
||
message: `AI判断已有 ${fetched.size} 个意群的内容足够回答问题，结束取材`
|
||
};
|
||
break; // 直接使用已有内容，不触发fallback
|
||
}
|
||
|
||
// 只有在完全没有内容时才使用后备策略
|
||
yield { type: 'warning', message: '规划无操作且无已获取内容，使用后备策略' };
|
||
const fallback = buildFallbackSemanticContext(userQuestion, groups);
|
||
if (fallback) {
|
||
yield {
|
||
type: 'fallback',
|
||
reason: 'empty-ops',
|
||
context: fallback.context
|
||
};
|
||
return fallback;
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 3. 执行工具
|
||
for (const [opIndex, op] of ops.entries()) {
|
||
yield {
|
||
type: 'tool_start',
|
||
round,
|
||
opIndex,
|
||
tool: op.tool,
|
||
args: op.args
|
||
};
|
||
|
||
try {
|
||
// 检查文档配置
|
||
const docId = (window.data && window.data.currentPdfName) || 'unknown';
|
||
const docConfig = window.data?.multiHopConfig?.[docId];
|
||
const useSemanticGroups = docConfig?.useSemanticGroups !== false;
|
||
const useVectorSearch = docConfig?.useVectorSearch !== false;
|
||
|
||
if (op.tool === 'vector_search' && op.args) {
|
||
if (!useVectorSearch) {
|
||
throw new Error('向量搜索功能已禁用，vector_search不可用');
|
||
}
|
||
|
||
// 向量语义搜索chunks
|
||
const query = String(op.args.query || userQuestion);
|
||
const limit = Math.min(Number(op.args.limit) || 15, 30);
|
||
|
||
if (window.SemanticVectorSearch && window.EmbeddingClient?.config?.enabled) {
|
||
// 获取enrichedChunks
|
||
const chunks = window.data?.enrichedChunks || [];
|
||
const res = await window.SemanticVectorSearch.search(query, chunks, {
|
||
topK: limit,
|
||
threshold: 0.3
|
||
});
|
||
|
||
// 记录搜索结果（包括无结果的情况）
|
||
const resultCount = (Array.isArray(res) && res.length) ? res.length : 0;
|
||
searchHistory.push({ tool: 'vector_search', query, resultCount });
|
||
|
||
if (resultCount > 0) {
|
||
// 只添加搜索到的chunks完整文本，不自动fetch意群
|
||
res.forEach((r, idx) => {
|
||
const chunkText = r.text || '';
|
||
if (chunkText) {
|
||
contextParts.push(`【向量搜索片段${idx + 1}】(chunk-${r.chunkId}, 来自${r.belongsToGroup}, 相似度${r.score.toFixed(3)})\n${chunkText}`);
|
||
}
|
||
});
|
||
|
||
// 提取所属意群信息，供AI判断
|
||
const groupIds = new Set();
|
||
res.forEach(r => {
|
||
if (r.belongsToGroup) {
|
||
groupIds.add(r.belongsToGroup);
|
||
interestedGroups.add(r.belongsToGroup); // 标记AI感兴趣的意群
|
||
}
|
||
});
|
||
|
||
console.log(`[StreamingMultiHop] 向量搜索命中 ${resultCount} 个chunks，所属意群: [${Array.from(groupIds).join(', ')}]`);
|
||
|
||
// 计算返回内容的token数
|
||
const returnedText = res.map(r => r.text).join('\n');
|
||
const contentTokens = estimateTokens(returnedText);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'vector_search',
|
||
result: res.map(r => ({
|
||
chunkId: r.chunkId,
|
||
belongsToGroup: r.belongsToGroup,
|
||
score: r.score,
|
||
rerankScore: r.rerankScore, // 重排分数（如果有）
|
||
originalScore: r.originalScore, // 原始向量分数（如果有）
|
||
preview: r.text.substring(0, 500)
|
||
})),
|
||
suggestedGroups: Array.from(groupIds), // 提示AI可以fetch这些意群
|
||
tokens: contentTokens // 返回内容的token数
|
||
};
|
||
} else {
|
||
// 明确返回空结果，便于UI闭环
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'vector_search',
|
||
result: []
|
||
};
|
||
}
|
||
}
|
||
|
||
} else if (op.tool === 'keyword_search' && op.args) {
|
||
// 关键词精确匹配
|
||
const keywords = Array.isArray(op.args.keywords) ? op.args.keywords : [String(op.args.keywords || '')];
|
||
const limit = Math.min(Number(op.args.limit) || 8, 30);
|
||
|
||
if (window.SemanticBM25Search) {
|
||
// 使用BM25进行关键词搜索chunks（不做n-gram拆分）
|
||
const chunks = window.data?.enrichedChunks || [];
|
||
const res = window.SemanticBM25Search.searchChunksKeywords(keywords, chunks, {
|
||
topK: limit,
|
||
threshold: 0.0
|
||
});
|
||
|
||
// 记录搜索结果（包括无结果的情况）
|
||
const resultCount = (Array.isArray(res) && res.length) ? res.length : 0;
|
||
searchHistory.push({ tool: 'keyword_search', query: keywords.join(','), resultCount });
|
||
|
||
if (resultCount > 0) {
|
||
// 只添加搜索到的chunks完整文本，不自动fetch意群
|
||
res.forEach((r, idx) => {
|
||
const chunkText = r.text || '';
|
||
if (chunkText) {
|
||
const matched = keywords.filter(kw => chunkText.includes(kw)).join(', ');
|
||
contextParts.push(`【关键词搜索片段${idx + 1}】(chunk-${r.chunkId}, 来自${r.belongsToGroup}, 匹配词: ${matched})\n${chunkText}`);
|
||
}
|
||
});
|
||
|
||
// 提取所属意群信息，供AI判断
|
||
const groupIds = new Set();
|
||
res.forEach(r => {
|
||
if (r.belongsToGroup) {
|
||
groupIds.add(r.belongsToGroup);
|
||
interestedGroups.add(r.belongsToGroup); // 标记AI感兴趣的意群
|
||
}
|
||
});
|
||
|
||
console.log(`[StreamingMultiHop] 关键词搜索命中 ${resultCount} 个chunks，所属意群: [${Array.from(groupIds).join(', ')}]`);
|
||
|
||
// 计算返回内容的token数
|
||
const returnedText = res.map(r => r.text).join('\n');
|
||
const contentTokens = estimateTokens(returnedText);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'keyword_search',
|
||
result: res.map(r => ({
|
||
chunkId: r.chunkId,
|
||
belongsToGroup: r.belongsToGroup,
|
||
preview: r.text.substring(0, 500),
|
||
matchedKeywords: keywords.filter(kw => r.text.includes(kw))
|
||
})),
|
||
suggestedGroups: Array.from(groupIds), // 提示AI可以fetch这些意群
|
||
tokens: contentTokens
|
||
};
|
||
} else {
|
||
// 明确返回空结果，便于UI闭环
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'keyword_search',
|
||
result: []
|
||
};
|
||
}
|
||
}
|
||
|
||
} else if ((op.tool === 'fetch' || op.tool === 'fetch_group') && op.args) {
|
||
if (!useSemanticGroups) {
|
||
throw new Error('意群功能已禁用，fetch不可用');
|
||
}
|
||
|
||
const id = op.args.groupId;
|
||
const gran = (op.args.granularity || (op.tool === 'fetch' ? 'full' : 'digest'));
|
||
|
||
interestedGroups.add(id); // 标记AI感兴趣的意群
|
||
|
||
const existing = fetched.get(id);
|
||
|
||
// 如果已经有了，检查是否需要升级
|
||
if (existing) {
|
||
const needUpgrade = (existing.granularity === 'summary' && gran !== 'summary') ||
|
||
(existing.granularity === 'digest' && gran === 'full');
|
||
|
||
if (needUpgrade) {
|
||
// 需要升级，执行fetch（优先详细接口）
|
||
let res = null;
|
||
if (op.tool === 'fetch' && typeof window.SemanticTools?.fetchGroupDetailed === 'function') {
|
||
res = window.SemanticTools.fetchGroupDetailed(id);
|
||
} else if (typeof window.SemanticTools?.fetchGroupText === 'function') {
|
||
res = window.SemanticTools.fetchGroupText(id, gran);
|
||
}
|
||
if (res && res.text) {
|
||
fetched.set(id, { granularity: res.granularity, text: res.text });
|
||
|
||
const idx = detail.findIndex(d => d.groupId === id);
|
||
if (idx >= 0) detail[idx].granularity = res.granularity;
|
||
|
||
const ctxIdx = contextParts.findIndex(c => c.startsWith(`【${id}`));
|
||
if (ctxIdx >= 0) {
|
||
contextParts[ctxIdx] = `【${id} - ${res.granularity}】\n${res.text}`;
|
||
}
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: op.tool,
|
||
result: {
|
||
groupId: id,
|
||
granularity: res.granularity,
|
||
preview: res.text.slice(0, 200),
|
||
action: 'upgraded'
|
||
},
|
||
tokens: estimateTokens(res.text)
|
||
};
|
||
}
|
||
} else {
|
||
// 已有更高级别的，跳过
|
||
yield {
|
||
type: 'tool_skip',
|
||
round,
|
||
opIndex,
|
||
tool: op.tool,
|
||
reason: existing.granularity === gran ? 'already_fetched' : 'higher_granularity_exists',
|
||
groupId: id,
|
||
existingGranularity: existing.granularity
|
||
};
|
||
}
|
||
} else {
|
||
// 不存在，执行fetch
|
||
let res = null;
|
||
if (op.tool === 'fetch' && typeof window.SemanticTools?.fetchGroupDetailed === 'function') {
|
||
res = window.SemanticTools.fetchGroupDetailed(id);
|
||
} else if (typeof window.SemanticTools?.fetchGroupText === 'function') {
|
||
res = window.SemanticTools.fetchGroupText(id, gran);
|
||
}
|
||
|
||
if (res && res.text) {
|
||
fetched.set(id, { granularity: res.granularity, text: res.text });
|
||
detail.push({ groupId: id, granularity: res.granularity });
|
||
contextParts.push(`【${id} - ${res.granularity}】\n${res.text}`);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: op.tool,
|
||
result: {
|
||
groupId: id,
|
||
granularity: res.granularity,
|
||
preview: res.text.slice(0, 200)
|
||
},
|
||
tokens: estimateTokens(res.text)
|
||
};
|
||
}
|
||
}
|
||
} else if (op.tool === 'map') {
|
||
if (!useSemanticGroups) {
|
||
throw new Error('意群功能已禁用，map不可用');
|
||
}
|
||
|
||
// 生成候选意群地图（结构+摘要）
|
||
const limit = Math.min(Number(op.args?.limit) || 50, candidates.length);
|
||
const includeStructure = op.args?.includeStructure !== false;
|
||
const items = candidates.slice(0, limit).map(g => {
|
||
const struct = g.structure || {};
|
||
const parts = [`【${g.groupId}】 ${g.charCount || 0}字`];
|
||
if (includeStructure && struct.orderedElements && struct.orderedElements.length > 0) {
|
||
const typeIcons = { 'title': '📌', 'section': '▸', 'keypoint': '•', 'figure': '🖼', 'table': '📊', 'formula': '📐' };
|
||
struct.orderedElements.forEach(elem => {
|
||
const icon = typeIcons[elem.type] || '-';
|
||
parts.push(` ${icon} ${elem.content}`);
|
||
});
|
||
} else {
|
||
if (g.keywords && g.keywords.length > 0) parts.push(`关键词: ${g.keywords.join('、')}`);
|
||
const s = g.structure || {};
|
||
if (s.sections && s.sections.length > 0) parts.push(`章节: ${s.sections.join('; ')}`);
|
||
if (s.keyPoints && s.keyPoints.length > 0) parts.push(`要点: ${s.keyPoints.join('; ')}`);
|
||
}
|
||
if (g.summary) parts.push(`摘要: ${g.summary}`);
|
||
return parts.join('\n');
|
||
});
|
||
const mapText = items.join('\n\n');
|
||
window._multiHopLastMapText = mapText; // 供下一轮规划使用
|
||
|
||
// 记录已生成地图（用于最终汇总时判断是否需要包含地图）
|
||
window._multiHopHasMap = true;
|
||
window._multiHopMapSummary = {
|
||
text: mapText,
|
||
count: items.length,
|
||
includeStructure: includeStructure
|
||
};
|
||
|
||
// 自动策略：AI主动调用map工具，说明需要地图信息，自动包含到最终上下文
|
||
aiRequestedMapInFinalContext = true;
|
||
console.log('[StreamingMultiHop] AI调用map工具，自动将地图包含到最终上下文');
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'map',
|
||
result: { count: items.length },
|
||
tokens: estimateTokens(mapText)
|
||
};
|
||
} else if (op.tool === 'grep' && op.args) {
|
||
// 传统文本搜索，支持多关键词OR查询（用|分隔）
|
||
const q = String(op.args.query || '').trim();
|
||
const limit = Math.min(Number(op.args.limit) || 20, 100);
|
||
const ctxChars = Math.min(Number(op.args.context) || 2000, 4000); // 默认提升到2000字符
|
||
const caseInsensitive = !!op.args.caseInsensitive;
|
||
const chunks = window.data?.enrichedChunks || [];
|
||
const hits = [];
|
||
|
||
if (q) {
|
||
// 支持OR逻辑：将 "方程|公式|k-ε" 拆分为多个关键词
|
||
const keywords = q.includes('|') ? q.split('|').map(k => k.trim()).filter(k => k) : [q];
|
||
console.log(`[StreamingMultiHop] GREP搜索关键词: [${keywords.join(', ')}]`);
|
||
|
||
// 1) 整篇文档
|
||
const docText = String(docContentInfo.translation || docContentInfo.ocr || '');
|
||
if (docText) {
|
||
const hay = caseInsensitive ? docText.toLowerCase() : docText;
|
||
|
||
for (const keyword of keywords) {
|
||
const needle = caseInsensitive ? keyword.toLowerCase() : keyword;
|
||
let from = 0;
|
||
while (from < hay.length) {
|
||
const pos = hay.indexOf(needle, from);
|
||
if (pos < 0) break;
|
||
const end = pos + keyword.length;
|
||
const s = Math.max(0, pos - ctxChars);
|
||
const e = Math.min(docText.length, end + ctxChars);
|
||
const snippet = docText.slice(s, e);
|
||
hits.push({
|
||
preview: snippet,
|
||
matchOffset: pos,
|
||
matchLength: keyword.length,
|
||
matchedKeyword: keyword // 记录匹配的关键词
|
||
});
|
||
from = end;
|
||
if (hits.length >= limit) break;
|
||
}
|
||
if (hits.length >= limit) break;
|
||
}
|
||
}
|
||
|
||
// 2) chunks 级（补充）
|
||
if (hits.length < limit && Array.isArray(chunks) && chunks.length > 0) {
|
||
for (const keyword of keywords) {
|
||
const needle = caseInsensitive ? keyword.toLowerCase() : keyword;
|
||
for (const chunk of chunks) {
|
||
const text = String(chunk.text || '');
|
||
if (!text) continue;
|
||
const hay = caseInsensitive ? text.toLowerCase() : text;
|
||
const pos = hay.indexOf(needle);
|
||
if (pos >= 0) {
|
||
const end = pos + keyword.length;
|
||
const s = Math.max(0, pos - ctxChars);
|
||
const e = Math.min(text.length, end + ctxChars);
|
||
const snippet = text.slice(s, e);
|
||
hits.push({
|
||
chunkId: chunk.chunkId,
|
||
belongsToGroup: chunk.belongsToGroup,
|
||
preview: snippet,
|
||
matchOffset: pos,
|
||
matchLength: keyword.length,
|
||
matchedKeyword: keyword
|
||
});
|
||
if (hits.length >= limit) break;
|
||
}
|
||
}
|
||
if (hits.length >= limit) break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (hits.length > 0) {
|
||
// 添加grep搜索到的片段（精确匹配的上下文）
|
||
console.log(`[StreamingMultiHop] GREP命中 ${hits.length} 个片段，准备添加到contextParts`);
|
||
hits.forEach((h, idx) => {
|
||
const src = h.belongsToGroup ? `chunk-${h.chunkId}, 来自${h.belongsToGroup}` : '全文';
|
||
const contextItem = `【GREP片段${idx + 1}】(${src})\n${h.preview}`;
|
||
contextParts.push(contextItem);
|
||
console.log(`[StreamingMultiHop] 添加GREP片段${idx + 1}，长度: ${contextItem.length}字符`);
|
||
});
|
||
|
||
// 提取所属意群信息，供AI判断
|
||
const groupIds = new Set();
|
||
hits.forEach(h => {
|
||
if (h.belongsToGroup) {
|
||
groupIds.add(h.belongsToGroup);
|
||
interestedGroups.add(h.belongsToGroup); // 标记AI感兴趣的意群
|
||
}
|
||
});
|
||
|
||
if (groupIds.size > 0) {
|
||
console.log(`[StreamingMultiHop] GREP搜索命中 ${hits.length} 个片段，所属意群: [${Array.from(groupIds).join(', ')}]`);
|
||
} else {
|
||
console.log(`[StreamingMultiHop] GREP搜索命中 ${hits.length} 个片段（来自全文，无所属意群）`);
|
||
}
|
||
} else {
|
||
console.log(`[StreamingMultiHop] GREP搜索"${q}"无结果`);
|
||
}
|
||
|
||
// 记录搜索结果（包括无结果的情况）
|
||
searchHistory.push({ tool: 'grep', query: q, resultCount: hits.length });
|
||
|
||
const groupIds = new Set();
|
||
hits.forEach(h => { if (h.belongsToGroup) groupIds.add(h.belongsToGroup); });
|
||
|
||
// 计算返回内容的token数
|
||
const returnedText = hits.map(h => h.preview).join('\n');
|
||
const contentTokens = estimateTokens(returnedText);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'grep',
|
||
result: hits.map(h => ({
|
||
preview: h.preview.substring(0, 500),
|
||
belongsToGroup: h.belongsToGroup,
|
||
chunkId: h.chunkId
|
||
})),
|
||
suggestedGroups: Array.from(groupIds), // 提示AI可以fetch这些意群
|
||
tokens: contentTokens
|
||
};
|
||
} else if (op.tool === 'regex_search' && op.args) {
|
||
// 正则表达式搜索
|
||
if (!window.AdvancedSearchTools) {
|
||
throw new Error('AdvancedSearchTools 模块未加载');
|
||
}
|
||
|
||
const pattern = String(op.args.pattern || '');
|
||
const limit = Math.min(Number(op.args.limit) || 10, 50);
|
||
const ctxChars = Math.min(Number(op.args.context) || 1500, 4000);
|
||
const caseInsensitive = op.args.caseInsensitive !== false;
|
||
|
||
const docText = String(docContentInfo.translation || docContentInfo.ocr || '');
|
||
const chunks = window.data?.enrichedChunks || [];
|
||
|
||
if (!docText && chunks.length === 0) {
|
||
throw new Error('没有可搜索的文本内容');
|
||
}
|
||
|
||
try {
|
||
const results = window.AdvancedSearchTools.regexSearch(
|
||
pattern,
|
||
docText,
|
||
{ limit, context: ctxChars, caseInsensitive }
|
||
);
|
||
|
||
if (results.length > 0) {
|
||
// 添加正则搜索结果到上下文
|
||
results.forEach((r, idx) => {
|
||
contextParts.push(`【正则搜索片段${idx + 1}】(匹配: "${r.match}")\n${r.preview}`);
|
||
});
|
||
|
||
// 尝试关联到chunks和意群
|
||
const groupIds = new Set();
|
||
results.forEach(r => {
|
||
// 查找包含此匹配的chunk
|
||
const matchingChunk = chunks.find(chunk =>
|
||
chunk.text && chunk.text.includes(r.match)
|
||
);
|
||
if (matchingChunk?.belongsToGroup) {
|
||
groupIds.add(matchingChunk.belongsToGroup);
|
||
interestedGroups.add(matchingChunk.belongsToGroup);
|
||
}
|
||
});
|
||
|
||
console.log(`[StreamingMultiHop] 正则搜索命中 ${results.length} 个片段`);
|
||
|
||
const returnedText = results.map(r => r.preview).join('\n');
|
||
const contentTokens = estimateTokens(returnedText);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'regex_search',
|
||
result: results.map(r => ({
|
||
match: r.match,
|
||
preview: r.preview.substring(0, 500),
|
||
groups: r.groups
|
||
})),
|
||
suggestedGroups: Array.from(groupIds),
|
||
tokens: contentTokens
|
||
};
|
||
} else {
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'regex_search',
|
||
result: []
|
||
};
|
||
}
|
||
} catch (regexError) {
|
||
throw new Error(`正则表达式错误: ${regexError.message}`);
|
||
}
|
||
|
||
// 记录搜索历史
|
||
searchHistory.push({ tool: 'regex_search', query: pattern, resultCount: results.length || 0 });
|
||
|
||
} else if (op.tool === 'boolean_search' && op.args) {
|
||
// 布尔逻辑搜索
|
||
if (!window.AdvancedSearchTools) {
|
||
throw new Error('AdvancedSearchTools 模块未加载');
|
||
}
|
||
|
||
const query = String(op.args.query || '');
|
||
const limit = Math.min(Number(op.args.limit) || 10, 50);
|
||
const ctxChars = Math.min(Number(op.args.context) || 1500, 4000);
|
||
const caseInsensitive = op.args.caseInsensitive !== false;
|
||
|
||
const docText = String(docContentInfo.translation || docContentInfo.ocr || '');
|
||
const chunks = window.data?.enrichedChunks || [];
|
||
|
||
if (!docText && chunks.length === 0) {
|
||
throw new Error('没有可搜索的文本内容');
|
||
}
|
||
|
||
try {
|
||
const results = window.AdvancedSearchTools.booleanSearch(
|
||
query,
|
||
docText,
|
||
{ limit, context: ctxChars, caseInsensitive }
|
||
);
|
||
|
||
if (results.length > 0) {
|
||
// 添加布尔搜索结果到上下文
|
||
results.forEach((r, idx) => {
|
||
const terms = r.matchedTerms.join(', ');
|
||
contextParts.push(`【布尔搜索片段${idx + 1}】(匹配词: ${terms}, 相关度: ${r.relevanceScore})\n${r.preview}`);
|
||
});
|
||
|
||
// 尝试关联到chunks和意群
|
||
const groupIds = new Set();
|
||
results.forEach(r => {
|
||
const matchingChunk = chunks.find(chunk =>
|
||
chunk.text && r.matchedTerms.some(term => chunk.text.includes(term))
|
||
);
|
||
if (matchingChunk?.belongsToGroup) {
|
||
groupIds.add(matchingChunk.belongsToGroup);
|
||
interestedGroups.add(matchingChunk.belongsToGroup);
|
||
}
|
||
});
|
||
|
||
console.log(`[StreamingMultiHop] 布尔搜索命中 ${results.length} 个片段`);
|
||
|
||
const returnedText = results.map(r => r.preview).join('\n');
|
||
const contentTokens = estimateTokens(returnedText);
|
||
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'boolean_search',
|
||
result: results.map(r => ({
|
||
preview: r.preview.substring(0, 500),
|
||
matchedTerms: r.matchedTerms,
|
||
relevanceScore: r.relevanceScore
|
||
})),
|
||
suggestedGroups: Array.from(groupIds),
|
||
tokens: contentTokens
|
||
};
|
||
} else {
|
||
yield {
|
||
type: 'tool_result',
|
||
round,
|
||
opIndex,
|
||
tool: 'boolean_search',
|
||
result: []
|
||
};
|
||
}
|
||
} catch (boolError) {
|
||
throw new Error(`布尔查询错误: ${boolError.message}`);
|
||
}
|
||
|
||
// 记录搜索历史
|
||
searchHistory.push({ tool: 'boolean_search', query, resultCount: results.length || 0 });
|
||
}
|
||
|
||
} catch (toolError) {
|
||
yield {
|
||
type: 'tool_error',
|
||
round,
|
||
opIndex,
|
||
tool: op.tool,
|
||
error: toolError.message
|
||
};
|
||
}
|
||
}
|
||
|
||
// 第一轮结束后，清理不相关的预加载内容
|
||
// 保护机制：
|
||
// 1. 只有当找到足够多（>=3）的感兴趣意群时才清理，避免在"大海捞针"场景中误删
|
||
// 2. 如果第一轮没有进行任何搜索，不清理（可能AI还在探索阶段）
|
||
const hasSearch = searchHistory.some(h => h.tool === 'vector_search' || h.tool === 'keyword_search' || h.tool === 'grep');
|
||
console.log(`[StreamingMultiHop] 第${round + 1}轮结束，hasSearch=${hasSearch}, interestedGroups.size=${interestedGroups.size}, contextParts.length=${contextParts.length}`);
|
||
|
||
if (round === 0 && preloadedInFirstRound && interestedGroups.size >= 3 && hasSearch) {
|
||
// 清理fetched：只保留AI感兴趣的意群
|
||
for (const [groupId] of fetched.entries()) {
|
||
if (!interestedGroups.has(groupId)) {
|
||
fetched.delete(groupId);
|
||
}
|
||
}
|
||
|
||
// 清理detail：只保留AI感兴趣的意群
|
||
const filteredDetail = detail.filter(d => interestedGroups.has(d.groupId));
|
||
detail.length = 0;
|
||
detail.push(...filteredDetail);
|
||
|
||
// 清理contextParts：只保留搜索片段和AI感兴趣的意群
|
||
const filteredContextParts = contextParts.filter(part => {
|
||
// 保留搜索片段
|
||
if (part.startsWith('【向量搜索片段') ||
|
||
part.startsWith('【关键词搜索片段') ||
|
||
part.startsWith('【GREP片段') ||
|
||
part.startsWith('【正则搜索片段') ||
|
||
part.startsWith('【布尔搜索片段')) {
|
||
return true;
|
||
}
|
||
// 保留AI感兴趣的意群
|
||
for (const groupId of interestedGroups) {
|
||
if (part.startsWith(`【${groupId}`)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
});
|
||
contextParts.length = 0;
|
||
contextParts.push(...filteredContextParts);
|
||
|
||
const removedCount = groups.length - interestedGroups.size;
|
||
if (removedCount > 0) {
|
||
yield {
|
||
type: 'info',
|
||
message: `已清理 ${removedCount} 个不相关意群，保留 ${interestedGroups.size} 个AI感兴趣的内容`
|
||
};
|
||
}
|
||
}
|
||
|
||
// 检查是否final：优先尊重AI的final判断
|
||
const hadContextThisRound = contextParts.length > 0 || detail.length > 0;
|
||
console.log(`[StreamingMultiHop] 第${round + 1}轮结束检查：contextParts=${contextParts.length}, detail=${detail.length}, final=${plan.final}`);
|
||
|
||
// 若首轮没有任何搜索也没有上下文，发出提示，继续下一轮（已在执行阶段注入默认检索）
|
||
if (round === 0 && !hasSearch && !hadContextThisRound) {
|
||
yield { type: 'warning', message: '首轮未产生上下文，将继续并执行默认检索' };
|
||
}
|
||
|
||
// 优先判断：AI明确说final=true，直接结束
|
||
if (plan.final === true) {
|
||
yield {
|
||
type: 'round_end',
|
||
round,
|
||
final: true,
|
||
message: 'AI判断内容已充分，取材完成'
|
||
};
|
||
break;
|
||
}
|
||
|
||
// 次要判断：AI说final=false，但已经到最后一轮了，强制结束
|
||
if (round === maxRounds - 1 && hadContextThisRound) {
|
||
yield {
|
||
type: 'round_end',
|
||
round,
|
||
final: true,
|
||
message: '已达最大轮次，使用已获取内容'
|
||
};
|
||
break;
|
||
}
|
||
|
||
// 继续下一轮
|
||
yield {
|
||
type: 'round_end',
|
||
round,
|
||
final: false,
|
||
message: '继续下一轮取材...'
|
||
};
|
||
}
|
||
|
||
// 4. 汇总上下文 - 智能分层策略
|
||
// 先构建AI请求的上下文组件（地图和意群列表）
|
||
let mapOverview = '';
|
||
let groupListOverview = '';
|
||
|
||
// 1. 地图概览（如果AI请求）
|
||
if (aiRequestedMapInFinalContext && window._multiHopLastMapText) {
|
||
mapOverview = `【📋 文档整体结构地图】\n${window._multiHopLastMapText}\n\n`;
|
||
console.log(`[StreamingMultiHop] AI请求包含地图，已添加地图概览 (${window._multiHopLastMapText.length}字)`);
|
||
}
|
||
|
||
// 2. 意群简要列表（如果AI请求）
|
||
if (aiRequestedGroupListInFinalContext && groups && groups.length > 0) {
|
||
const simplifiedList = groups.map(g => {
|
||
const charCount = g.charCount || 0;
|
||
const summary = g.summary || '无摘要';
|
||
const keywords = (g.keywords && g.keywords.length > 0) ? ` [${g.keywords.slice(0, 3).join('、')}]` : '';
|
||
return `【${g.groupId}】${charCount}字${keywords} - ${summary}`;
|
||
}).join('\n');
|
||
groupListOverview = `【📑 所有意群简要列表】(共${groups.length}个意群)\n${simplifiedList}\n\n`;
|
||
console.log(`[StreamingMultiHop] AI请求包含意群列表，已添加 ${groups.length} 个意群的简要信息`);
|
||
}
|
||
|
||
// 检查是否有任何有用内容：搜索片段 OR fetch的意群 OR 地图 OR 意群列表
|
||
const hasAnyContent = contextParts.length > 0 || mapOverview || groupListOverview;
|
||
|
||
if (!hasAnyContent) {
|
||
yield { type: 'warning', message: '未获取到任何上下文，使用后备策略' };
|
||
const fallback = buildFallbackSemanticContext(userQuestion, groups);
|
||
if (fallback) {
|
||
yield {
|
||
type: 'fallback',
|
||
reason: 'empty-context',
|
||
context: fallback.context
|
||
};
|
||
return fallback;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// 分层组织：地图概要(可选) + 搜索片段(最精确) + 重点意群(digest) + 背景意群(summary)
|
||
const searchFragments = []; // 搜索到的chunk完整文本
|
||
const summaryParts = []; // summary粒度的意群
|
||
const detailParts = []; // digest/full粒度的意群
|
||
|
||
// 分类contextParts
|
||
contextParts.forEach(part => {
|
||
if (part.startsWith('【向量搜索片段') ||
|
||
part.startsWith('【关键词搜索片段') ||
|
||
part.startsWith('【GREP片段') ||
|
||
part.startsWith('【正则搜索片段') ||
|
||
part.startsWith('【布尔搜索片段')) {
|
||
searchFragments.push(part);
|
||
}
|
||
});
|
||
|
||
// 分类detail中的意群
|
||
const granularityCount = { full: 0, digest: 0, summary: 0 };
|
||
detail.forEach(d => {
|
||
const data = fetched.get(d.groupId);
|
||
const part = `【${d.groupId} - ${d.granularity}】\n${data.text}`;
|
||
|
||
granularityCount[d.granularity] = (granularityCount[d.granularity] || 0) + 1;
|
||
|
||
if (d.granularity === 'summary') {
|
||
summaryParts.push(part);
|
||
} else {
|
||
detailParts.push(part);
|
||
}
|
||
});
|
||
|
||
// 构建分层上下文 - AI自主控制的组件顺序
|
||
let selectedContext = '';
|
||
const layers = [];
|
||
|
||
// 1. 地图概览（AI请求时）
|
||
if (mapOverview) {
|
||
layers.push(mapOverview);
|
||
}
|
||
|
||
// 2. 意群简要列表（AI请求时，提供全局视角）
|
||
if (groupListOverview) {
|
||
layers.push(groupListOverview);
|
||
}
|
||
|
||
// 3. 搜索片段（最精确的检索结果）
|
||
if (searchFragments.length > 0) {
|
||
layers.push(`【🎯 搜索片段】(${searchFragments.length}个精确匹配的chunk，最优先使用)\n${searchFragments.join('\n\n')}`);
|
||
}
|
||
|
||
// 4. 重点意群（AI fetch的详细内容）
|
||
if (detailParts.length > 0) {
|
||
layers.push(`【📖 重点意群】(${detailParts.length}个详细内容，提供上下文)\n${detailParts.join('\n\n')}`);
|
||
}
|
||
|
||
// 5. 背景意群（summary粒度）
|
||
if (summaryParts.length > 0) {
|
||
layers.push(`【📋 背景意群】(${summaryParts.length}个简要摘要，提供全局视角)\n${summaryParts.join('\n\n')}`);
|
||
}
|
||
|
||
selectedContext = layers.join('\n\n---\n\n');
|
||
|
||
// 统计最终给AI的总token数
|
||
const finalContextTokens = estimateTokens(selectedContext);
|
||
|
||
const stats = {
|
||
totalGroups: detail.length,
|
||
searchFragments: searchFragments.length,
|
||
focusGroups: detailParts.length,
|
||
backgroundGroups: summaryParts.length,
|
||
hasMap: aiRequestedMapInFinalContext,
|
||
hasGroupList: aiRequestedGroupListInFinalContext,
|
||
finalContextTokens // 最终上下文的token数
|
||
};
|
||
|
||
if (searchFragments.length > 0 || detailParts.length > 0) {
|
||
const msg = [];
|
||
if (searchFragments.length > 0) msg.push(`${searchFragments.length}个搜索片段`);
|
||
if (detailParts.length > 0) {
|
||
const parts = [];
|
||
if (granularityCount.full > 0) parts.push(`${granularityCount.full}个full`);
|
||
if (granularityCount.digest > 0) parts.push(`${granularityCount.digest}个digest`);
|
||
msg.push(`${detailParts.length}个重点意群(${parts.join('+') || 'mixed'})`);
|
||
}
|
||
if (summaryParts.length > 0) msg.push(`${summaryParts.length}个背景意群(summary)`);
|
||
|
||
yield {
|
||
type: 'info',
|
||
message: `三层上下文：${msg.join(' + ')}`
|
||
};
|
||
}
|
||
|
||
yield {
|
||
type: 'complete',
|
||
context: selectedContext,
|
||
summary: {
|
||
groups: detail.map(d => d.groupId),
|
||
granularity: 'mixed',
|
||
detail,
|
||
contextLength: selectedContext.length,
|
||
stats
|
||
}
|
||
};
|
||
|
||
return {
|
||
groups: detail.map(d => d.groupId),
|
||
granularity: 'mixed',
|
||
detail,
|
||
context: selectedContext,
|
||
stats
|
||
};
|
||
|
||
} catch (error) {
|
||
yield {
|
||
type: 'error',
|
||
phase: 'unknown',
|
||
message: error.message,
|
||
stack: error.stack
|
||
};
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// 后备策略（同步版本）
|
||
function buildFallbackSemanticContext(userQuestion, groups) {
|
||
try {
|
||
if (!Array.isArray(groups) || groups.length === 0) return null;
|
||
|
||
let picks = [];
|
||
try {
|
||
if (window.SemanticGrouper && typeof window.SemanticGrouper.quickMatch === 'function') {
|
||
picks = window.SemanticGrouper.quickMatch(String(userQuestion || ''), groups) || [];
|
||
}
|
||
} catch (_) {}
|
||
|
||
if (!picks || picks.length === 0) {
|
||
picks = groups.slice(0, Math.min(3, groups.length));
|
||
}
|
||
|
||
const unique = new Set();
|
||
const detail = [];
|
||
const parts = [];
|
||
|
||
picks.forEach(g => {
|
||
if (!g || unique.size >= 3 || unique.has(g.groupId)) return;
|
||
unique.add(g.groupId);
|
||
|
||
let fetched = null;
|
||
try {
|
||
if (window.SemanticTools && typeof window.SemanticTools.fetchGroupText === 'function') {
|
||
fetched = window.SemanticTools.fetchGroupText(g.groupId, 'digest');
|
||
}
|
||
} catch (_) {}
|
||
|
||
const text = (fetched && fetched.text) || g.digest || g.summary || g.fullText || '';
|
||
if (!text) return;
|
||
|
||
const gran = (fetched && fetched.granularity) || 'digest';
|
||
parts.push(`【${g.groupId}】\n关键词: ${(g.keywords || []).join('、')}\n内容(${gran}):\n${text}`);
|
||
detail.push({ groupId: g.groupId, granularity: gran });
|
||
});
|
||
|
||
if (parts.length === 0) return null;
|
||
|
||
return {
|
||
groups: Array.from(unique),
|
||
granularity: 'mixed',
|
||
detail,
|
||
context: parts.join('\n\n')
|
||
};
|
||
} catch (e) {
|
||
console.warn('[buildFallbackSemanticContext] 失败:', e);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// 导出
|
||
window.streamingMultiHopRetrieve = streamingMultiHopRetrieve;
|
||
|
||
console.log('[StreamingMultiHop] 流式多轮取材已加载');
|
||
|
||
})(window);
|