@gt-fe/eap-runtime 0.0.20 → 0.0.22

package/dist/graph/nodes/rag/denoise.d.ts

@@ -0,0 +1,58 @@
+/**
+ * denoise — 降噪管线（design-v2 §6.3，M4）
+ *
+ * 数万 token 候选压成数百 token，LLM 只做判定与选择、绝不产出正文：
+ *   ① 近重去重（字符 n-gram Jaccard，纯函数，确定性优先）
+ *   ② 一次结构化 LLM 判定（主力模型，temp 0）→ DenoiseVerdict[]
+ *      { rawId, relevant, reason, keepSentences }——rawId 为复合键 sourceId:rawId
+ *      （rawId 仅源内唯一；payload 标签、verdict 匹配、filtered 项三处必须同用复合键，
+ *      裸 id 跨源碰撞会让两份文档共享同一 verdict：错滤另一源、按别家句子编号截正文）
+ *   ③ 代码按句子编号拼装原文（零改写：返回文本逐字出自原文句子）
+ *
+ * 防御策略（§6.5 误滤宁保守）：
+ *   verdict 调用或解析失败 / 文档缺 verdict 项 / keepSentences 无有效编号 → 整篇保留；
+ *   判定存活集为空 → react-loop 走 QUERY_REWRITE 重写兜底（本模块只报 verdictEmpty）。
+ */
+import type { ILLMProvider } from '../llm-node.js';
+import type { DenoiseVerdict, RagTokenUsage, RetrievalDoc } from './types.js';
+export declare const RAG_EMPTY_MARKER = "[rag] \u672A\u627E\u5230\u9AD8\u76F8\u5173\u7ED3\u679C";
+/** 格式化（降噪后的）文档集为最终上下文 */
+export declare function formatContext(query: string, docs: RetrievalDoc[]): string;
+export interface DenoiseInput {
+    query: string;
+    /** 融合后的候选文档集（可能数万 token） */
+    docs: RetrievalDoc[];
+    llmProvider: ILLMProvider;
+    /** 主力模型（与决策同款，不分档） */
+    model: string;
+    nodeId: string;
+    /** 近重判定阈值，缺省 0.8 */
+    nearDupThreshold?: number;
+    tokenUsage: RagTokenUsage[];
+}
+export interface DenoiseResult {
+    /** 存活文档（正文已按 keepSentences 截取） */
+    docs: RetrievalDoc[];
+    contextText: string;
+    /** 判定后存活集是否为空（react-loop 据此触发重写兜底） */
+    verdictEmpty: boolean;
+    /** 被滤文档与原因（空结果重写定向 / rag.denoise 事件用）；rawId 为复合键 sourceId:rawId（rewrite 归因整键匹配用） */
+    filtered: Array<{
+        rawId: string;
+        reason: string;
+    }>;
+}
+export declare function denoise(input: DenoiseInput): Promise<DenoiseResult>;
+export declare function rewriteQuery(input: {
+    query: string;
+    reasons: string[];
+    llmProvider: ILLMProvider;
+    model: string;
+    nodeId: string;
+    tokenUsage: RagTokenUsage[];
+}): Promise<string | undefined>;
+/** 确定性分句：按中英文句终符与换行切，句符随句保留（零改写：句子为原文子串） */
+export declare function splitSentences(content: string): string[];
+/** 解析判定输出：剥代码围栏、截取首尾方括号；解析失败返回 undefined（保守放行全部）。
+ *  rawId 不校验复合键形态——LLM 抄错（裸 id/截断）时 find 不中，该文档无 verdict 即整篇保留，仍走保守路径 */
+export declare function parseVerdicts(text: string): DenoiseVerdict[] | undefined;

package/dist/graph/nodes/rag/denoise.js

@@ -0,0 +1,220 @@
+/**
+ * denoise — 降噪管线（design-v2 §6.3，M4）
+ *
+ * 数万 token 候选压成数百 token，LLM 只做判定与选择、绝不产出正文：
+ *   ① 近重去重（字符 n-gram Jaccard，纯函数，确定性优先）
+ *   ② 一次结构化 LLM 判定（主力模型，temp 0）→ DenoiseVerdict[]
+ *      { rawId, relevant, reason, keepSentences }——rawId 为复合键 sourceId:rawId
+ *      （rawId 仅源内唯一；payload 标签、verdict 匹配、filtered 项三处必须同用复合键，
+ *      裸 id 跨源碰撞会让两份文档共享同一 verdict：错滤另一源、按别家句子编号截正文）
+ *   ③ 代码按句子编号拼装原文（零改写：返回文本逐字出自原文句子）
+ *
+ * 防御策略（§6.5 误滤宁保守）：
+ *   verdict 调用或解析失败 / 文档缺 verdict 项 / keepSentences 无有效编号 → 整篇保留；
+ *   判定存活集为空 → react-loop 走 QUERY_REWRITE 重写兜底（本模块只报 verdictEmpty）。
+ */
+import { DENOISE_VERDICT, QUERY_REWRITE } from './prompts.js';
+import { dedupNearDup } from './dedup.js';
+import { docTitle } from './tools.js';
+export const RAG_EMPTY_MARKER = '[rag] 未找到高相关结果';
+/** 格式化（降噪后的）文档集为最终上下文 */
+export function formatContext(query, docs) {
+    if (!docs.length) {
+        return `${RAG_EMPTY_MARKER}（query: ${query}）`;
+    }
+    const header = `[rag] 检索上下文（query: ${query}，共 ${docs.length} 条，已判定相关并压缩）`;
+    const blocks = docs.map((d, i) => {
+        return `【${i + 1}】来源：${d.sourceId} / ${docTitle(d)}\n${d.content}`;
+    });
+    return [header, ...blocks].join('\n\n');
+}
+export async function denoise(input) {
+    if (input.docs.length === 0) {
+        return {
+            docs: [],
+            contextText: `${RAG_EMPTY_MARKER}（query: ${input.query}）`,
+            verdictEmpty: true,
+            filtered: [],
+        };
+    }
+    // ① 近重去重（确定性，先砍掉不浪费 LLM token）
+    const candidates = dedupNearDup(input.docs, input.nearDupThreshold ?? 0.8);
+    if (candidates.length === 0) {
+        return {
+            docs: [],
+            contextText: `${RAG_EMPTY_MARKER}（query: ${input.query}）`,
+            verdictEmpty: true,
+            filtered: [],
+        };
+    }
+    // ② 一次结构化判定 + ③ 按编号拼装
+    const split = candidates.map((d) => splitSentencesWithSeps(d.content));
+    const sentences = split.map((s) => s.sentences);
+    const verdicts = await judgeVerdicts(input, candidates, sentences);
+    const kept = [];
+    const filtered = [];
+    candidates.forEach((doc, i) => {
+        // 匹配键必须是复合键 sourceId:rawId（与 payload 标签同构）：rawId 仅源内唯一
+        const key = `${doc.sourceId}:${doc.rawId}`;
+        const v = verdicts?.find((x) => x.rawId === key);
+        if (v && !v.relevant) {
+            filtered.push({ rawId: key, reason: v.reason });
+            return;
+        }
+        kept.push({ ...doc, content: pickSentences(split[i], v?.keepSentences) });
+    });
+    return {
+        docs: kept,
+        contextText: formatContext(input.query, kept),
+        verdictEmpty: kept.length === 0,
+        filtered,
+    };
+}
+// ─────────────────────────────────────────────
+// 空结果兜底：query 重写（react-loop 调用）
+// ─────────────────────────────────────────────
+export async function rewriteQuery(input) {
+    const reasonSummary = input.reasons.slice(0, 5).join('；');
+    const user = `原查询：${input.query}\n被滤原因摘要：${reasonSummary || '（检索无结果或未提供）'}`;
+    const config = { model: input.model, systemPrompt: QUERY_REWRITE, temperature: 0 };
+    // 调用层异常不穿透：重写失败回退原 query，不阻塞检索收束
+    let response;
+    try {
+        response = await invokeTracked(input.llmProvider, input.model, input.nodeId, input.tokenUsage, user, config);
+    }
+    catch (err) {
+        console.warn('[rag-denoise] query 重写调用失败，回退原 query', err);
+        return input.query;
+    }
+    const text = response.content
+        .trim()
+        .replace(/^["'「『]+/, '')
+        .replace(/["'」』]+$/, '')
+        .trim();
+    return text.length > 0 ? text : undefined;
+}
+// ─────────────────────────────────────────────
+// 内部：判定调用 / 分句 / 解析 / 选句
+// ─────────────────────────────────────────────
+async function judgeVerdicts(input, candidates, sentences) {
+    const payload = candidates
+        .map((d, i) => {
+        const numbered = sentences[i].map((s, j) => `  ${j + 1}. ${s}`).join('\n');
+        // 标签必须带复合键 sourceId:rawId：跨源同 rawId 时裸 id 标签无法区分
+        return `【${d.sourceId}:${d.rawId}】${docTitle(d)}\n${numbered}`;
+    })
+        .join('\n\n');
+    const user = `用户问题：${input.query}\n\n候选文档：\n${payload}`;
+    const config = {
+        model: input.model,
+        systemPrompt: DENOISE_VERDICT,
+        temperature: 0,
+    };
+    // 调用层异常不穿透：判定失败视同 verdicts 缺失 → 整篇保留（宁保守）
+    let response;
+    try {
+        response = await invokeTracked(input.llmProvider, input.model, input.nodeId, input.tokenUsage, user, config);
+    }
+    catch (err) {
+        console.warn('[rag-denoise] 判定调用失败，候选整篇保留', err);
+        return undefined;
+    }
+    return parseVerdicts(response.content);
+}
+/** 统一的带记账 LLM 调用（denoise/rewrite 与 decide 同一套记账口径） */
+async function invokeTracked(provider, model, nodeId, tokenUsage, user, config) {
+    const startedAt = Date.now();
+    const response = await provider.invoke([{ role: 'user', content: user }], config);
+    tokenUsage.push({
+        nodeId,
+        model: response.model || model,
+        inputTokens: response.inputTokens,
+        outputTokens: response.outputTokens,
+        durationMs: Date.now() - startedAt,
+    });
+    return response;
+}
+/** 确定性分句：按中英文句终符与换行切，句符随句保留（零改写：句子为原文子串） */
+export function splitSentences(content) {
+    return splitSentencesWithSeps(content).sentences;
+}
+/** 分句并记录句间分隔符（seps[i] = 第 i 句与第 i+1 句之间的原文空白/换行）。
+ *  拼装侧必须按 seps 还原句间空白：中文通常空串（行为不变），英文空格不还原则
+ *  多句 keep 后粘连成 "days.Ship"。
+ *  英文句点仅在后随空白时切（`3.14`、`e.g.` 等点后无空格不切）；`e.g. ` 后随空格
+ *  仍会误切——不做缩写白名单，宁误切不粘连（误切只损句子粒度，不损内容） */
+function splitSentencesWithSeps(content) {
+    const raw = content.split(/((?<=[。！？!?；;])\s*|(?<=\.)\s+|\n+)/);
+    const sentences = [];
+    const seps = [];
+    for (let i = 0; i < raw.length; i += 2) {
+        const text = (raw[i] ?? '').trim();
+        const sep = raw[i + 1] ?? '';
+        if (!text) {
+            // 空文本段只出现在首尾或相邻分隔符之间：句中空段把后随分隔符并入前句，空白不丢
+            if (seps.length > 0)
+                seps[seps.length - 1] += sep;
+            continue;
+        }
+        sentences.push(text);
+        seps.push(sep);
+    }
+    return sentences.length > 0 ? { sentences, seps } : { sentences: [content.trim()], seps: [] };
+}
+/** 解析判定输出：剥代码围栏、截取首尾方括号；解析失败返回 undefined（保守放行全部）。
+ *  rawId 不校验复合键形态——LLM 抄错（裸 id/截断）时 find 不中，该文档无 verdict 即整篇保留，仍走保守路径 */
+export function parseVerdicts(text) {
+    const stripped = text.replace(/```(?:json)?/g, '');
+    const start = stripped.indexOf('[');
+    const end = stripped.lastIndexOf(']');
+    if (start < 0 || end <= start)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(parsed))
+        return undefined;
+    const verdicts = parsed
+        .filter((x) => x !== null && typeof x === 'object')
+        .map((x) => {
+        const keep = Array.isArray(x['keepSentences'])
+            ? x['keepSentences'].filter((n) => typeof n === 'number')
+            : undefined;
+        return {
+            rawId: String(x['rawId'] ?? ''),
+            relevant: x['relevant'] !== false, // 缺省 true（宁保守）
+            reason: String(x['reason'] ?? ''),
+            ...(keep && keep.length > 0 ? { keepSentences: keep } : {}),
+        };
+    })
+        .filter((v) => v.rawId.length > 0);
+    return verdicts.length > 0 ? verdicts : undefined;
+}
+/** keepSentences 有效则按编号拼装原文句子，否则整篇（缺省/编号全无效 → 整篇，宁保守）。
+ *  prompt 未约束编号顺序与唯一性：编号是原文位置，不去重会复读、乱序拼装条件句主句对调，
+ *  拼装侧兜底去重 + 升序 */
+function pickSentences(split, keep) {
+    const { sentences, seps } = split;
+    let indices;
+    if (!keep || keep.length === 0) {
+        indices = sentences.map((_, i) => i);
+    }
+    else {
+        const picked = [...new Set(keep)]
+            .filter((n) => Number.isInteger(n) && n >= 1 && n <= sentences.length)
+            .sort((a, b) => a - b);
+        indices = picked.length > 0 ? picked.map((n) => n - 1) : sentences.map((_, i) => i);
+    }
+    let out = '';
+    indices.forEach((idx, order) => {
+        // 句间用前一句的原文分隔符还原（中文空串不变；英文空格保留）
+        if (order > 0)
+            out += seps[indices[order - 1]] ?? '';
+        out += sentences[idx];
+    });
+    return out;
+}

package/dist/graph/nodes/rag/fusion/fuse.d.ts

@@ -0,0 +1,11 @@
+/**
+ * fuse — 融合截断（纯函数）
+ *
+ * 各源只在源内取 topN（不跨源排序/比较分数），按源序并入、跨源去重、截断 totalK。
+ * 源间用量分配由 ReAct 决策动态决定（调哪个源/调几次/每次 topK），
+ * 静态配额已移除：异构源权重无语义，防单源灌水由调用级 topK 与 denoise 承担。
+ * @see design-v2 §6.2
+ */
+import type { RetrievalDoc } from '../types.js';
+export declare const DEFAULT_TOTAL_K = 10;
+export declare function fuse(perSource: Map<string, RetrievalDoc[]>, totalK?: number): RetrievalDoc[];

package/dist/graph/nodes/rag/fusion/fuse.js

@@ -0,0 +1,25 @@
+/**
+ * fuse — 融合截断（纯函数）
+ *
+ * 各源只在源内取 topN（不跨源排序/比较分数），按源序并入、跨源去重、截断 totalK。
+ * 源间用量分配由 ReAct 决策动态决定（调哪个源/调几次/每次 topK），
+ * 静态配额已移除：异构源权重无语义，防单源灌水由调用级 topK 与 denoise 承担。
+ * @see design-v2 §6.2
+ */
+export const DEFAULT_TOTAL_K = 10;
+export function fuse(perSource, totalK = DEFAULT_TOTAL_K) {
+    const seen = new Set(); // 跨源去重（sourceId:rawId）
+    const merged = [];
+    for (const [, docs] of perSource) {
+        for (const d of docs) {
+            if (merged.length >= totalK)
+                return merged;
+            const key = `${d.sourceId}:${d.rawId}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(d);
+        }
+    }
+    return merged; // 不排序：候选集不重叠，跨源排序无意义（§6 前提）
+}

package/dist/graph/nodes/rag/fusion/normalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 知识库工具结果归一化 — 字符串 content → RetrievalDoc[]
+ *
+ * 知识库是外部黑盒，最低契约（design-v2 §6.1）：
+ * 返回有序列表，每条至少有 content 和某种唯一 id；score 可选。
+ * 本层做防御性解析：JSON 数组 / 常见包裹字段 / 单条对象 / 纯文本逐级降级。
+ */
+import type { RetrievalDoc } from '../types.js';
+export declare function normalizeToolResult(content: string, toolName: string, sourceId?: string): RetrievalDoc[];

package/dist/graph/nodes/rag/fusion/normalize.js

@@ -0,0 +1,135 @@
+/**
+ * 知识库工具结果归一化 — 字符串 content → RetrievalDoc[]
+ *
+ * 知识库是外部黑盒，最低契约（design-v2 §6.1）：
+ * 返回有序列表，每条至少有 content 和某种唯一 id；score 可选。
+ * 本层做防御性解析：JSON 数组 / 常见包裹字段 / 单条对象 / 纯文本逐级降级。
+ */
+const LIST_WRAPPER_KEYS = ['items', 'results', 'rows', 'documents', 'data', 'list', 'references'];
+const CONTENT_KEYS = ['content', 'text', 'chunk', 'document', 'snippet', 'answer'];
+const ID_KEYS = ['id', 'chunkId', 'docId', 'rawId', 'documentId'];
+const META_KEYS = ['title', 'fileName', 'source', 'url', 'updatedAt', 'filePath', 'sourceTitle'];
+export function normalizeToolResult(content, toolName, sourceId = 'kb') {
+    if (!content.trim())
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return textFallback(content, toolName, sourceId);
+    }
+    const unwrapped = unwrapGatewayEnvelope(parsed);
+    const list = asDocList(unwrapped);
+    if (!list)
+        return textFallback(content, toolName, sourceId);
+    const docs = [];
+    list.forEach((item, idx) => {
+        const doc = toDoc(item, idx, toolName, sourceId);
+        if (doc)
+            docs.push(doc);
+    });
+    // 列表条目全缺正文（引用仅元数据）且一条 doc 未产出时，回退单条对象路径：
+    // 顶层 answer 等正文键还能命中，避免有效答案被误报空手；部分成功维持列表优先；
+    // 顶层数组形态无单条可回退，保持结构化空手语义
+    if (docs.length === 0 && !Array.isArray(unwrapped) && unwrapped && typeof unwrapped === 'object') {
+        const whole = toDoc(unwrapped, 0, toolName, sourceId);
+        if (whole)
+            return [whole];
+    }
+    // 空列表是合法的"检索无结果"（结构化空手），保持空返回；
+    // textFallback 只用于完全无法解析为列表的返回
+    return docs;
+}
+function asDocList(parsed) {
+    if (Array.isArray(parsed))
+        return parsed;
+    if (parsed && typeof parsed === 'object') {
+        for (const key of LIST_WRAPPER_KEYS) {
+            const v = parsed[key];
+            // 空列表包裹字段跳过继续找（如对话式 KB references 空但 answer 有值），
+            // 非空包裹字段优先成文档列表
+            if (Array.isArray(v) && v.length > 0)
+                return v;
+        }
+        return [parsed]; // 单条对象
+    }
+    return undefined;
+}
+/**
+ * gateway 包裹形解包：{code,success,result:{content:"[...]"}}（dev 直连 http 工具
+ * 无网关解包层，执行器把整个响应体当 content 回传）。仅当内层字符串以 '[' 开头
+ * 才尝试再解析——普通文本 content 走 textFallback 语义不受影响。
+ */
+function unwrapGatewayEnvelope(parsed) {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return parsed;
+    const obj = parsed;
+    const candidates = [
+        obj['result']?.['content'],
+        obj['content'],
+    ];
+    for (const c of candidates) {
+        if (typeof c !== 'string' || !c.trim())
+            continue;
+        if (c.trim().startsWith('[')) {
+            try {
+                const inner = JSON.parse(c);
+                if (Array.isArray(inner))
+                    return inner;
+            }
+            catch {
+                /* 落到下面的文本保留 */
+            }
+        }
+        // 包裹形里的纯文本 content：保真为单条文档（宁保留不丢弃）
+        return [{ content: c }];
+    }
+    return parsed;
+}
+function toDoc(item, idx, toolName, sourceId) {
+    if (typeof item === 'string') {
+        return item.trim()
+            ? { content: item, sourceId, rawId: `${toolName}#${idx}` }
+            : undefined;
+    }
+    if (!item || typeof item !== 'object')
+        return undefined;
+    const obj = item;
+    const content = firstString(obj, CONTENT_KEYS);
+    if (!content)
+        return undefined;
+    const rawId = firstString(obj, ID_KEYS) ?? `${toolName}#${idx}`;
+    const score = typeof obj['score'] === 'number' ? obj['score'] : undefined;
+    const metadata = {};
+    for (const key of META_KEYS) {
+        if (obj[key] !== undefined)
+            metadata[key] = obj[key];
+    }
+    return {
+        content,
+        sourceId,
+        rawId,
+        ...(score !== undefined ? { score } : {}),
+        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+    };
+}
+/** 非结构化返回：整段文本降级为单条结果，不静默丢弃 */
+function textFallback(content, toolName, sourceId) {
+    return [
+        {
+            content,
+            sourceId,
+            rawId: `${toolName}:raw`,
+            metadata: { note: '非结构化返回，整段作为单条结果' },
+        },
+    ];
+}
+function firstString(obj, keys) {
+    for (const key of keys) {
+        const v = obj[key];
+        if (typeof v === 'string' && v.trim())
+            return v;
+    }
+    return undefined;
+}

package/dist/graph/nodes/rag/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * RAG 检索子智能体节点 — 公共导出
+ *
+ * @see mt-docs/1-requirements/specs/agentic-rag/design-v2.md
+ */
+export { RagNode } from './rag-node.js';
+export { runReactLoop, type RagLoopInput, type RagLoopOutput } from './react-loop.js';
+export { buildRagTools, briefList, RAG_FINISH_TOOL_NAME, LOCAL_SEARCH_TOOL_NAME, KEYWORD_SEARCH_TOOL_NAME, type RagToolSet, } from './tools.js';
+export { normalizeToolResult } from './fusion/normalize.js';
+export { fuse, DEFAULT_TOTAL_K } from './fusion/fuse.js';
+export { dedupExact, dedupNearDup } from './dedup.js';
+export { denoise, rewriteQuery, splitSentences, parseVerdicts, formatContext, RAG_EMPTY_MARKER, type DenoiseInput, type DenoiseResult, } from './denoise.js';
+export { RAG_REACT, DENOISE_VERDICT, QUERY_REWRITE } from './prompts.js';
+export { InMemoryRetriever } from './retrievers/in-memory-retriever.js';
+export { RagSearchToolExecutor, ragSearchLoadedTool, RAG_SEARCH_TOOL_NAME, type RagSearchToolOptions, } from './rag-search-tool.js';
+export { HttpEmbedder, type HttpEmbedderOptions } from './retrievers/http-embedder.js';
+export { LocalSqliteRetriever, type LocalSqliteRetrieverOptions, } from './retrievers/local-sqlite-retriever.js';
+export type { RetrievalDoc, IRetriever, IEmbedder, VectorRow, KeywordRow, VectorEnginePort, RagNodeConfig, RagNodeDeps, RagTokenUsage, DenoiseVerdict, } from './types.js';

package/dist/graph/nodes/rag/index.js

@@ -0,0 +1,17 @@
+/**
+ * RAG 检索子智能体节点 — 公共导出
+ *
+ * @see mt-docs/1-requirements/specs/agentic-rag/design-v2.md
+ */
+export { RagNode } from './rag-node.js';
+export { runReactLoop } from './react-loop.js';
+export { buildRagTools, briefList, RAG_FINISH_TOOL_NAME, LOCAL_SEARCH_TOOL_NAME, KEYWORD_SEARCH_TOOL_NAME, } from './tools.js';
+export { normalizeToolResult } from './fusion/normalize.js';
+export { fuse, DEFAULT_TOTAL_K } from './fusion/fuse.js';
+export { dedupExact, dedupNearDup } from './dedup.js';
+export { denoise, rewriteQuery, splitSentences, parseVerdicts, formatContext, RAG_EMPTY_MARKER, } from './denoise.js';
+export { RAG_REACT, DENOISE_VERDICT, QUERY_REWRITE } from './prompts.js';
+export { InMemoryRetriever } from './retrievers/in-memory-retriever.js';
+export { RagSearchToolExecutor, ragSearchLoadedTool, RAG_SEARCH_TOOL_NAME, } from './rag-search-tool.js';
+export { HttpEmbedder } from './retrievers/http-embedder.js';
+export { LocalSqliteRetriever, } from './retrievers/local-sqlite-retriever.js';

package/dist/graph/nodes/rag/prompts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * RAG 三 Prompt — 一职一 prompt（design-v2 §5.5）
+ *
+ * 三个 prompt 均用同一主力模型（2026-08-19 决策不分档）；
+ * 判定/重写调用 temp 0。
+ */
+/** RAG_REACT — 循环决策：整定 / 检索 / 终止 */
+export declare const RAG_REACT = "\u4F60\u662F\u4F01\u4E1A\u77E5\u8BC6\u68C0\u7D22\u667A\u80FD\u4F53\uFF0C\u4E3A\u4E0B\u6E38\u667A\u80FD\u4F53\u68C0\u7D22\u8BC1\u636E\uFF0C\u4E0D\u76F4\u63A5\u56DE\u7B54\u7528\u6237\u95EE\u9898\u3002\n\n\u884C\u4E3A\u89C4\u5219\uFF1A\n- \u9996\u8F6E\u5148\u5224\u65AD\u68C0\u7D22\u4EFB\u52A1\u662F\u5426\u81EA\u5305\u542B\uFF1B\u6709\u6307\u4EE3/\u7701\u7565\u65F6\u5148\u7ED3\u5408\u5BF9\u8BDD\u5386\u53F2\u6539\u5199\u4E3A\u72EC\u7ACB\u68C0\u7D22\u67E5\u8BE2\n- \u590D\u6742\u95EE\u9898\u53EF\u62C6\u5B50\u67E5\u8BE2\uFF0C\u5355\u8F6E\u5E76\u884C\u8C03\u7528\u591A\u4E2A\u68C0\u7D22\u5DE5\u5177\uFF08\u5982\u540C\u65F6\u67E5\u77E5\u8BC6\u5E93\u4E0E\u672C\u5730\u6587\u4EF6\uFF09\n- \u6BCF\u8F6E\u62FF\u5230\u65B0\u7ED3\u679C\u540E\u5148\u8BC4\u4F30\uFF1A\u5DF2\u8986\u76D6\u54EA\u4E9B\u5B50\u95EE\u9898\u3001\u8FD8\u7F3A\u4EC0\u4E48\uFF1B\u53EA\u68C0\u7D22\u7F3A\u5931\u7684\u4FE1\u606F\uFF0C\u4E0D\u91CD\u590D\u68C0\u7D22\u5DF2\u8986\u76D6\u90E8\u5206\n- \u5355\u4E2A\u6765\u6E90\u5931\u8D25\u65F6\u6362\u5176\u4ED6\u6765\u6E90\u91CD\u8BD5\n- \u67D0\u6765\u6E90\u8FDE\u7EED\u8FD4\u56DE\u7A7A\u3001\u6216\u7ED3\u679C\u5168\u90E8\u88AB\u5224\u5B9A\u4E0D\u76F8\u5173\u88AB\u6EE4\u9664\u65F6\uFF0C\u4E0B\u4E00\u8F6E\u5FC5\u987B\u6539\u7528\u5176\u4ED6\u6570\u636E\u6E90\u5DE5\u5177\uFF08\u6216\u5E76\u884C\u591A\u6E90\uFF09\uFF0C\u7981\u6B62\u5BF9\u540C\u4E00\u6765\u6E90\u53CD\u590D\u6539\u5199\u91CD\u67E5\n\n\u7EC8\u6B62\uFF08\u8C03\u7528 rag_finish \u5373\u6536\u624B\uFF0C\u6EE1\u8DB3\u5176\u4E00\u5373\u53EF\uFF09\uFF1A\n- \u68C0\u7D22\u4EFB\u52A1\u7684\u5404\u5B50\u95EE\u9898\u5747\u6709\u9AD8\u76F8\u5173\u7247\u6BB5\u8986\u76D6\n- \u6700\u8FD1\u4E00\u8F6E\u65B0\u589E\u7ED3\u679C\u4E0E\u5DF2\u6709\u7ED3\u679C\u9AD8\u5EA6\u91CD\u590D\n- \u5DF2\u6536\u96C6\u8DB3\u591F\u7684\u9AD8\u76F8\u5173\u7247\u6BB5";
+/** DENOISE_VERDICT — 相关性判定 + 句子编号抽取（M4，CRAG grader 式结构化输出） */
+export declare const DENOISE_VERDICT = "\u4F60\u662F\u8BC4\u4F30\u68C0\u7D22\u6587\u6863\u4E0E\u7528\u6237\u95EE\u9898\u76F8\u5173\u6027\u7684\u5224\u5206\u5668\u3002\n\n\u8F93\u5165\u5305\u542B\u7528\u6237\u95EE\u9898\u548C\u82E5\u5E72\u5019\u9009\u6587\u6863\uFF08\u6BCF\u7BC7\u5E26\u590D\u5408\u6587\u6863 id\uFF0C\u6B63\u6587\u5DF2\u5206\u53E5\u5E76\u7F16\u53F7\uFF09\u3002\n\u9010\u7BC7\u5224\u65AD\uFF1A\u6587\u6863\u662F\u5426\u5305\u542B\u4E0E\u95EE\u9898\u76F8\u5173\u7684\u5173\u952E\u8BCD\u6216\u8BED\u4E49\u3002\n\n\u89C4\u5219\uFF1A\n- rawId \u662F\u590D\u5408 id\uFF08\u683C\u5F0F\"\u6E90id:\u6587\u6863id\"\uFF0C\u5982 kb:17\uFF09\uFF0C\u5FC5\u987B\u539F\u6837\u7167\u6284\u6587\u6863\u6807\u7B7E\u3010\u3011\u5185\u7684\u5B8C\u6574 id\uFF0C\u4E0D\u5F97\u53EA\u6284\u6587\u6863 id \u6216\u6539\u5199\u2014\u2014\u4E0D\u540C\u6765\u6E90\u7684\u6587\u6863 id \u53EF\u80FD\u76F8\u540C\uFF0C\u6284\u9519\u4F1A\u5224\u5230\u522B\u7684\u6587\u6863\u4E0A\n- \u4EC5\u5F53\u786E\u6709\u76F8\u5173\u5185\u5BB9\u624D\u5224 relevant=true\uFF1B\u62FF\u4E0D\u51C6\u65F6\u5224 true\uFF08\u8BEF\u6EE4\u4EE3\u4EF7\u5927\u4E8E\u8BEF\u7559\uFF0C\u5B81\u4FDD\u5B88\uFF09\n- relevant=true \u65F6\u7ED9\u51FA keepSentences\uFF1A\u53EA\u4FDD\u7559\u76F4\u63A5\u652F\u6491\u95EE\u9898\u7684\u53E5\u5B50\u7F16\u53F7\uFF0C\u65E0\u5173\u53E5\u5B50\u5254\u9664\uFF1B\u6574\u7BC7\u90FD\u76F8\u5173\u5219\u7701\u7565\u8BE5\u5B57\u6BB5\n- relevant=false \u65F6\u7ED9\u4E00\u53E5\u8BDD reason\uFF0C\u8BF4\u660E\u4E0D\u76F8\u5173\u7684\u4F9D\u636E\n\n\u53EA\u8F93\u51FA\u4E00\u4E2A JSON \u6570\u7EC4\uFF0C\u4E0D\u8981\u8F93\u51FA\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002\u6BCF\u7BC7\u6587\u6863\u4E00\u9879\uFF0C\u683C\u5F0F\uFF1A\n[{\"rawId\":\"...\",\"relevant\":true,\"reason\":\"...\",\"keepSentences\":[1,3]},{\"rawId\":\"...\",\"relevant\":false,\"reason\":\"...\"}]";
+/** QUERY_REWRITE — 空结果兜底重写（M4，CRAG rewriter 式） */
+export declare const QUERY_REWRITE = "\u4F60\u662F\u67E5\u8BE2\u6539\u5199\u5668\u3002\u539F\u68C0\u7D22\u67E5\u8BE2\u672A\u547D\u4E2D\u9AD8\u76F8\u5173\u5185\u5BB9\uFF0C\u8BF7\u6539\u5199\u4E3A\u66F4\u5229\u4E8E\u68C0\u7D22\u7684\u7248\u672C\u3002\n\n- \u63A8\u7406\u539F\u95EE\u9898\u7684\u5E95\u5C42\u8BED\u4E49\u610F\u56FE\uFF0C\u6362\u7528\u66F4\u53EF\u80FD\u547D\u4E2D\u7684\u5173\u952E\u8BCD\u4E0E\u8868\u8FF0\n- \u7ED3\u5408\u88AB\u6EE4\u539F\u56E0\u6458\u8981\u5B9A\u5411\u8C03\u6574\uFF08\u5982\u672F\u8BED\u4E0D\u51C6\u3001\u89D2\u5EA6\u504F\u5DEE\uFF09\n- \u53EA\u8F93\u51FA\u6539\u5199\u540E\u7684\u67E5\u8BE2\u672C\u8EAB\uFF1A\u4E00\u884C\u7EAF\u6587\u672C\uFF0C\u4E0D\u8981\u89E3\u91CA\u3001\u4E0D\u8981\u5F15\u53F7";

package/dist/graph/nodes/rag/prompts.js

@@ -0,0 +1,40 @@
+/**
+ * RAG 三 Prompt — 一职一 prompt（design-v2 §5.5）
+ *
+ * 三个 prompt 均用同一主力模型（2026-08-19 决策不分档）；
+ * 判定/重写调用 temp 0。
+ */
+/** RAG_REACT — 循环决策：整定 / 检索 / 终止 */
+export const RAG_REACT = `你是企业知识检索智能体，为下游智能体检索证据，不直接回答用户问题。
+
+行为规则：
+- 首轮先判断检索任务是否自包含；有指代/省略时先结合对话历史改写为独立检索查询
+- 复杂问题可拆子查询，单轮并行调用多个检索工具（如同时查知识库与本地文件）
+- 每轮拿到新结果后先评估：已覆盖哪些子问题、还缺什么；只检索缺失的信息，不重复检索已覆盖部分
+- 单个来源失败时换其他来源重试
+- 某来源连续返回空、或结果全部被判定不相关被滤除时，下一轮必须改用其他数据源工具（或并行多源），禁止对同一来源反复改写重查
+
+终止（调用 rag_finish 即收手，满足其一即可）：
+- 检索任务的各子问题均有高相关片段覆盖
+- 最近一轮新增结果与已有结果高度重复
+- 已收集足够的高相关片段`;
+/** DENOISE_VERDICT — 相关性判定 + 句子编号抽取（M4，CRAG grader 式结构化输出） */
+export const DENOISE_VERDICT = `你是评估检索文档与用户问题相关性的判分器。
+
+输入包含用户问题和若干候选文档（每篇带复合文档 id，正文已分句并编号）。
+逐篇判断：文档是否包含与问题相关的关键词或语义。
+
+规则：
+- rawId 是复合 id（格式"源id:文档id"，如 kb:17），必须原样照抄文档标签【】内的完整 id，不得只抄文档 id 或改写——不同来源的文档 id 可能相同，抄错会判到别的文档上
+- 仅当确有相关内容才判 relevant=true；拿不准时判 true（误滤代价大于误留，宁保守）
+- relevant=true 时给出 keepSentences：只保留直接支撑问题的句子编号，无关句子剔除；整篇都相关则省略该字段
+- relevant=false 时给一句话 reason，说明不相关的依据
+
+只输出一个 JSON 数组，不要输出任何其他文字。每篇文档一项，格式：
+[{"rawId":"...","relevant":true,"reason":"...","keepSentences":[1,3]},{"rawId":"...","relevant":false,"reason":"..."}]`;
+/** QUERY_REWRITE — 空结果兜底重写（M4，CRAG rewriter 式） */
+export const QUERY_REWRITE = `你是查询改写器。原检索查询未命中高相关内容，请改写为更利于检索的版本。
+
+- 推理原问题的底层语义意图，换用更可能命中的关键词与表述
+- 结合被滤原因摘要定向调整（如术语不准、角度偏差）
+- 只输出改写后的查询本身：一行纯文本，不要解释、不要引号`;

package/dist/graph/nodes/rag/rag-node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * RagNode — type:rag 节点壳（LangGraph 节点签名）
+ *
+ * 薄壳：从 state 取运行期上下文（ephemeral channels）→ 圈定工具表 →
+ * 调 react-loop 内核 → 以 runtime 节点惯用形态返回 partial state。
+ * 实例在编译期创建、跨请求复用，不放任何请求级状态。
+ *
+ * @see design-v2 §5.2 / §5.3
+ */
+import type { RagNodeConfig, RagNodeDeps } from './types.js';
+type LangGraphState = Record<string, unknown>;
+export declare class RagNode {
+    private readonly nodeId;
+    private readonly config;
+    private readonly deps;
+    constructor(nodeId: string, config: RagNodeConfig, deps: RagNodeDeps);
+    execute(state: LangGraphState): Promise<LangGraphState>;
+    /** 身份组装照 ToolNode 惯例：executionContext 优先，state 兜底 */
+    private buildAuthContext;
+}
+export {};