@gt-fe/eap-runtime 0.0.19 → 0.0.21

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

@@ -9,11 +9,13 @@
  * @see design.md §1.4 ToolNode: LangGraph的ToolNode封装
  * @see requirements.md Requirement 8 AC1, AC3, AC5
  */
+import type { NodeRetryConfig } from '../contracts/executable-graph.js';
 import type { AuthContext } from '../../tool/tool-executor.interface.js';
 import type { ToolOrchestrator } from '../../tool/tool-orchestrator.js';
 import type { ToolResultInjector } from '../../tool/tool-result-injector.js';
 import type { SkillDirRef } from '../adapters/skill-read.js';
 import type { HitlHandler } from '../hitl/hitl-handler.js';
+import { type ExecutionInterceptors } from '../../execution/interceptors.js';
 /**
  * LangGraphState — LangGraph 内部状态（与 LLMNode 对齐）
  */
@@ -43,6 +45,14 @@ export interface ToolNodeProgress {
     node?: string;
     skillId?: string;
     skillDirs?: SkillDirRef[];
+    /** 已在 Skill 子图内（state.skillSpanId）；读 SKILL.md 不再发 skill.started */
+    inSkillSubgraph?: boolean;
+    skillSpace?: 'agent' | 'user' | 'local';
+    skillVersion?: string;
+    skillName?: string;
+    toolVersion?: string;
+    /** 本失败后是否还会再试。缺省 false */
+    willRetry?: boolean;
 }
 export declare class ToolNode {
     private readonly orchestrator;
@@ -51,7 +61,20 @@ export declare class ToolNode {
     private readonly onProgress?;
     private readonly hitlHandler?;
     private readonly nodeId?;
-    constructor(orchestrator: ToolOrchestrator, injector: ToolResultInjector, defaultAuthContext: AuthContext, onProgress?: ((data: ToolNodeProgress) => void) | undefined, hitlHandler?: HitlHandler | undefined, nodeId?: string | undefined);
+    private readonly interceptors?;
+    /** 图声明的 rag 检索面（config.retrievalSources，工具形态声明位）——随请求转递给 rag_search 装饰器 */
+    private readonly ragSourcesConfig?;
+    /** 图声明的融合总条数（config.totalK，工具形态声明位）——同路转递 */
+    private readonly ragTotalK?;
+    /** 节点 `retry`；未设则只试一次 */
+    private readonly retry?;
+    constructor(orchestrator: ToolOrchestrator, injector: ToolResultInjector, defaultAuthContext: AuthContext, onProgress?: ((data: ToolNodeProgress) => void) | undefined, hitlHandler?: HitlHandler | undefined, nodeId?: string | undefined, interceptors?: ExecutionInterceptors | undefined, 
+    /** 图声明的 rag 检索面（config.retrievalSources，工具形态声明位）——随请求转递给 rag_search 装饰器 */
+    ragSourcesConfig?: import("../nodes/rag/types.js").RagRetrievalSources | undefined, 
+    /** 图声明的融合总条数（config.totalK，工具形态声明位）——同路转递 */
+    ragTotalK?: number | undefined, 
+    /** 节点 `retry`；未设则只试一次 */
+    retry?: NodeRetryConfig | undefined);
     /**
      * execute — StateGraph 节点函数
      *
@@ -65,6 +88,7 @@ export declare class ToolNode {
      * 从 state 中提取 messages 数组
      */
     private extractMessages;
+    private executeSingleWithRetry;
     /**
      * 从 messages 中找到最后一条 assistant 消息
      */

package/dist/graph/nodes/tool-node.js

@@ -9,13 +9,19 @@
  * @see design.md §1.4 ToolNode: LangGraph的ToolNode封装
  * @see requirements.md Requirement 8 AC1, AC3, AC5
  */
+import { AppError, ErrorCodes } from '@gt-fe/eap-contracts';
 import { resolveJailFromState } from '../../tool/harness-primitives.js';
+import { recordSkillEntrySpan, skillEntryInvocationFromTool, skillTraceIdentity } from '../adapters/skill-entry-span.js';
 import { inferHarnessSkillDir } from '../../tool/skill-dir-infer.js';
 import { isHitlDecision, unwrapHitlPaused } from '../hitl/hitl-handler.js';
 import { ToolConfirmationInterceptor } from '../../tool/tool-confirmation.js';
 import { resolveCheckpointThreadId } from '../../session/persist-turn-messages.js';
-import { toolsetCodeFromLoaded } from '../../tool/mcp-list.js';
+import { toolTraceIdentity } from '../../tool/mcp-list.js';
 import { resolveExecutionTrace, warnTraceSpanFailure, } from '../execution-trace-context.js';
+import { emitRuntimeLog } from '../../common/logger.js';
+import { decideBeforeTool, } from '../../execution/interceptors.js';
+import { isRetryableToolFailure, resolveToolRetryConfig, sleepToolRetry, toolRetryDelayMs, } from '../../tool/tool-retry.js';
+import { assertIsolatedSkillAllowsHitl, isIsolatedSkillState } from '../adapters/skill-isolate.js';
 function skillDirsFromState(state) {
     const defs = state['skillDefinitions'];
     return Object.values(defs ?? {})
@@ -29,13 +35,27 @@ export class ToolNode {
     onProgress;
     hitlHandler;
     nodeId;
-    constructor(orchestrator, injector, defaultAuthContext, onProgress, hitlHandler, nodeId) {
+    interceptors;
+    ragSourcesConfig;
+    ragTotalK;
+    retry;
+    constructor(orchestrator, injector, defaultAuthContext, onProgress, hitlHandler, nodeId, interceptors, 
+    /** 图声明的 rag 检索面（config.retrievalSources，工具形态声明位）——随请求转递给 rag_search 装饰器 */
+    ragSourcesConfig, 
+    /** 图声明的融合总条数（config.totalK，工具形态声明位）——同路转递 */
+    ragTotalK, 
+    /** 节点 `retry`；未设则只试一次 */
+    retry) {
         this.orchestrator = orchestrator;
         this.injector = injector;
         this.defaultAuthContext = defaultAuthContext;
         this.onProgress = onProgress;
         this.hitlHandler = hitlHandler;
         this.nodeId = nodeId;
+        this.interceptors = interceptors;
+        this.ragSourcesConfig = ragSourcesConfig;
+        this.ragTotalK = ragTotalK;
+        this.retry = retry;
     }
     /**
      * execute — StateGraph 节点函数
@@ -99,6 +119,12 @@ export class ToolNode {
                 ...(jail.workdir ? { jailWorkdir: jail.workdir } : {}),
                 ...(jailExtraRoots.length > 0 ? { jailExtraRoots } : {}),
                 ...(skillDir ? { skillDir } : {}),
+                // rag 会话级控制与工具表快照（rag_search 装饰器消费；普通工具执行器忽略）
+                ...(state['ragSources'] ? { ragSources: state['ragSources'] } : {}),
+                ...(state['ragScope'] ? { ragScope: state['ragScope'] } : {}),
+                ...(this.ragSourcesConfig ? { ragSourcesConfig: this.ragSourcesConfig } : {}),
+                ...(this.ragTotalK !== undefined ? { ragTotalK: this.ragTotalK } : {}),
+                ...(loadedTools ? { loadedTools } : {}),
             };
         });
         const executionContext = state['executionContext'];
@@ -109,22 +135,48 @@ export class ToolNode {
         const skillId = typeof state['activatedSkill'] === 'string' && state['activatedSkill']
             ? state['activatedSkill']
             : undefined;
+        const inSkillSubgraph = typeof state['skillSpanId'] === 'string' && Boolean(state['skillSpanId']);
         const emitProgress = (data) => {
             this.onProgress?.({
                 ...data,
                 node: nodeId,
                 ...(skillId ? { skillId } : {}),
                 ...(skillDirs.length > 0 ? { skillDirs } : {}),
+                ...(inSkillSubgraph ? { inSkillSubgraph: true } : {}),
             });
         };
+        // require_confirmation 工具走 HITL 拦截：改为顺序执行，thread_id 与 Checkpoint 对齐
+        const confirmationTools = new Set(Object.entries(loadedTools ?? {})
+            .filter(([, def]) => Boolean(def?.manifest.requireConfirmation))
+            .map(([name]) => name));
+        const needsHitl = Boolean(this.hitlHandler) &&
+            (requests.some((req) => confirmationTools.has(req.toolName)) ||
+                Boolean(this.interceptors?.beforeTool));
+        const resumingHitl = isHitlDecision(state['hitlChoice']);
+        const resumeToolSpanId = resumingHitl && typeof state['toolSpanId'] === 'string' && state['toolSpanId']
+            ? state['toolSpanId']
+            : undefined;
+        const resumeToolCallId = typeof state['hitlToolCallId'] === 'string' && state['hitlToolCallId']
+            ? state['hitlToolCallId']
+            : undefined;
+        const confirmationCount = requests.filter((req) => confirmationTools.has(req.toolName)).length;
         // 5. 并行执行所有 Tool 调用（附 Trace span）
         const spanIds = await Promise.all(requests.map(async (req) => {
+            const reusePausedSpan = Boolean(resumeToolSpanId) &&
+                ((resumeToolCallId && req.toolCallId === resumeToolCallId) ||
+                    (!resumeToolCallId &&
+                        confirmationTools.has(req.toolName) &&
+                        confirmationCount === 1));
+            if (reusePausedSpan) {
+                return resumeToolSpanId ?? null;
+            }
             if (!traceCollector || !traceId)
                 return null;
             try {
                 const parentNodeId = typeof state['skillSpanId'] === 'string' && state['skillSpanId']
                     ? state['skillSpanId']
                     : undefined;
+                const identity = toolTraceIdentity(loadedTools?.[req.toolName], req.toolName);
                 return await traceCollector.createNode({
                     traceId,
                     name: req.toolName,
@@ -132,6 +184,7 @@ export class ToolNode {
                     parentNodeId,
                     toolRuntime: req.toolRuntime === 'both' ? 'both' : req.toolRuntime,
                     agentCode: agentCode || undefined,
+                    ...(identity.toolVersion ? { version: identity.toolVersion } : {}),
                     input: req.arguments,
                     metadata: {
                         toolCallId: req.toolCallId,
@@ -139,6 +192,7 @@ export class ToolNode {
                         taskId: req.taskId,
                         correlationId: req.correlationId,
                         skillId,
+                        ...(identity.toolset ? { toolset: identity.toolset } : {}),
                     },
                 });
             }
@@ -147,21 +201,15 @@ export class ToolNode {
                 return null;
             }
         }));
-        // 并行执行，但各自独立计时（避免共用 startedAt 导致时长不准/看起来像“写死”）
-        // require_confirmation 工具走 HITL 拦截：改为顺序执行，thread_id 与 Checkpoint 对齐
-        const confirmationTools = new Set(Object.entries(loadedTools ?? {})
-            .filter(([, def]) => Boolean(def?.manifest.requireConfirmation))
-            .map(([name]) => name));
-        const needsHitl = Boolean(this.hitlHandler) &&
-            requests.some((req) => confirmationTools.has(req.toolName));
         const runOne = async (req, i) => {
-            const toolset = toolsetCodeFromLoaded(loadedTools?.[req.toolName]);
-            const resumingHitl = isHitlDecision(state['hitlChoice']);
+            const toolIdentity = toolTraceIdentity(loadedTools?.[req.toolName], req.toolName);
+            const toolset = toolIdentity.toolset;
             if (!resumingHitl) {
                 emitProgress({
                     toolCallId: req.toolCallId,
                     toolName: req.toolName,
                     ...(toolset ? { toolset } : {}),
+                    ...(toolIdentity.toolVersion ? { toolVersion: toolIdentity.toolVersion } : {}),
                     status: 'started',
                     arguments: req.arguments,
                 });
@@ -169,43 +217,97 @@ export class ToolNode {
             const startedAt = Date.now();
             try {
                 let result;
-                if (needsHitl && this.hitlHandler && confirmationTools.has(req.toolName)) {
-                    const interceptor = new ToolConfirmationInterceptor(confirmationTools, this.hitlHandler, {
-                        execute: (r) => this.orchestrator.executeSingle(r, executionContext),
-                    });
-                    const graphState = this.toGraphState(state);
-                    const threadId = resolveCheckpointThreadId({
-                        sessionId: typeof state['sessionId'] === 'string' ? state['sessionId'] : undefined,
-                        taskId: req.taskId,
-                    });
-                    const confirmed = await interceptor.executeWithConfirmation(req, graphState, req.taskId ?? String(state['taskId'] ?? req.toolCallId), threadId, {
-                        toolSpanId: spanIds[i] ?? undefined,
-                        skillSpanId: typeof state['skillSpanId'] === 'string' ? state['skillSpanId'] : undefined,
-                    });
-                    result =
-                        confirmed ??
-                            {
-                                toolCallId: req.toolCallId,
-                                toolName: req.toolName,
-                                content: `用户拒绝执行工具 ${req.toolName}`,
-                                success: false,
-                                error: `用户拒绝执行工具 ${req.toolName}`,
-                                errorCode: 'hitl_rejected',
-                            };
+                const gate = await decideBeforeTool(this.interceptors?.beforeTool, req, executionContext);
+                if (gate.action === 'deny') {
+                    result = {
+                        toolCallId: req.toolCallId,
+                        toolName: req.toolName,
+                        content: '',
+                        success: false,
+                        error: gate.reason,
+                        errorCode: 'interceptor_denied',
+                    };
                 }
                 else {
-                    result = await this.orchestrator.executeSingle(req, executionContext);
+                    const askHitl = gate.action === 'ask' || (needsHitl && confirmationTools.has(req.toolName));
+                    if (askHitl && this.hitlHandler) {
+                        // 隔离子图未按独立 HITL 线程设计；interrupt 前拒绝，避免写错父 Checkpoint。
+                        if (!resumingHitl) {
+                            assertIsolatedSkillAllowsHitl(state);
+                        }
+                        const confirmSet = new Set(confirmationTools);
+                        if (gate.action === 'ask')
+                            confirmSet.add(req.toolName);
+                        const interceptor = new ToolConfirmationInterceptor(confirmSet, this.hitlHandler, {
+                            execute: (r) => this.orchestrator.executeSingle(r, executionContext),
+                        });
+                        const graphState = this.toGraphState(state);
+                        const threadId = resolveCheckpointThreadId({
+                            sessionId: typeof state['sessionId'] === 'string' ? state['sessionId'] : undefined,
+                            taskId: req.taskId,
+                        });
+                        const confirmed = await interceptor.executeWithConfirmation(req, graphState, req.taskId ?? String(state['taskId'] ?? req.toolCallId), threadId, {
+                            toolSpanId: spanIds[i] ?? undefined,
+                            skillSpanId: typeof state['skillSpanId'] === 'string' ? state['skillSpanId'] : undefined,
+                        });
+                        result =
+                            confirmed ??
+                                {
+                                    toolCallId: req.toolCallId,
+                                    toolName: req.toolName,
+                                    content: `用户拒绝执行工具 ${req.toolName}`,
+                                    success: false,
+                                    error: `用户拒绝执行工具 ${req.toolName}`,
+                                    errorCode: 'hitl_rejected',
+                                };
+                    }
+                    else if (gate.action === 'ask') {
+                        result = {
+                            toolCallId: req.toolCallId,
+                            toolName: req.toolName,
+                            content: '',
+                            success: false,
+                            error: '需要人工确认',
+                            errorCode: 'interceptor_ask',
+                        };
+                    }
+                    else {
+                        result = await this.executeSingleWithRetry(req, executionContext, emitProgress, toolset, toolIdentity);
+                    }
+                }
+                try {
+                    await this.interceptors?.afterTool?.(req, result);
+                }
+                catch (err) {
+                    emitRuntimeLog('warn', 'runtime.intercept', 'afterTool failed', {
+                        event: 'runtime.intercept.after_tool_failed',
+                        toolName: req.toolName,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
                 }
                 const executionTime = Date.now() - startedAt;
                 if (result.success) {
+                    const catalog = skillEntryInvocationFromTool({
+                        toolName: req.toolName,
+                        arguments: req.arguments,
+                        skillDirs,
+                        alreadyInSkillSpan: inSkillSubgraph,
+                    });
+                    const skillIdentity = catalog
+                        ? skillTraceIdentity(state, catalog.skillId, catalog.path)
+                        : undefined;
                     emitProgress({
                         toolCallId: result.toolCallId,
                         toolName: result.toolName,
                         ...(toolset ? { toolset } : {}),
+                        ...(toolIdentity.toolVersion ? { toolVersion: toolIdentity.toolVersion } : {}),
                         status: 'completed',
                         arguments: req.arguments,
                         content: result.content,
                         executionTime,
+                        ...(skillIdentity?.skillSpace ? { skillSpace: skillIdentity.skillSpace } : {}),
+                        ...(skillIdentity?.skillVersion ? { skillVersion: skillIdentity.skillVersion } : {}),
+                        ...(skillIdentity?.skillName ? { skillName: skillIdentity.skillName } : {}),
                     });
                 }
                 else {
@@ -213,6 +315,7 @@ export class ToolNode {
                         toolCallId: result.toolCallId,
                         toolName: result.toolName,
                         ...(toolset ? { toolset } : {}),
+                        ...(toolIdentity.toolVersion ? { toolVersion: toolIdentity.toolVersion } : {}),
                         status: 'error',
                         arguments: req.arguments,
                         error: result.error ?? 'unknown error',
@@ -232,6 +335,13 @@ export class ToolNode {
                         warnTraceSpanFailure('completeNode', { type: 'tool', name: req.toolName, traceId, spanId: nodeId }, err);
                     }
                 }
+                if (result.success) {
+                    await recordSkillEntrySpan(state, {
+                        toolName: req.toolName,
+                        arguments: req.arguments,
+                        skillDirs,
+                    });
+                }
                 return result;
             }
             catch (err) {
@@ -245,6 +355,23 @@ export class ToolNode {
                             (typeof state['skillSpanId'] === 'string' ? state['skillSpanId'] : undefined);
                     throw hitlPaused;
                 }
+                if (err instanceof AppError &&
+                    err.code === ErrorCodes.GRAPH_EXECUTION_ERROR &&
+                    isIsolatedSkillState(state)) {
+                    const failedSpanId = spanIds[i];
+                    if (traceCollector && failedSpanId) {
+                        try {
+                            await traceCollector.completeNode(failedSpanId, {
+                                status: 'failed',
+                                error: err.message,
+                            });
+                        }
+                        catch (completeErr) {
+                            warnTraceSpanFailure('completeNode', { type: 'tool', name: req.toolName, traceId, spanId: failedSpanId }, completeErr);
+                        }
+                    }
+                    throw err;
+                }
                 const executionTime = Date.now() - startedAt;
                 const message = err instanceof Error ? err.message : String(err);
                 emitProgress({
@@ -333,6 +460,37 @@ export class ToolNode {
             return { role: 'user', content: String(msg) };
         });
     }
+    async executeSingleWithRetry(req, executionContext, emitProgress, toolset, toolIdentity) {
+        const retry = resolveToolRetryConfig(this.retry);
+        const maxRetries = retry?.maxRetries ?? 0;
+        let last;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            last = await this.orchestrator.executeSingle(req, executionContext);
+            if (last.success)
+                return last;
+            const willRetry = attempt < maxRetries && isRetryableToolFailure(last);
+            if (!willRetry)
+                return last;
+            emitProgress({
+                toolCallId: req.toolCallId,
+                toolName: req.toolName,
+                ...(toolset ? { toolset } : {}),
+                ...(toolIdentity.toolVersion ? { toolVersion: toolIdentity.toolVersion } : {}),
+                status: 'error',
+                arguments: req.arguments,
+                error: last.error ?? 'unknown error',
+                willRetry: true,
+            });
+            await sleepToolRetry(toolRetryDelayMs(attempt, retry.backoff));
+        }
+        return last ?? {
+            toolCallId: req.toolCallId,
+            toolName: req.toolName,
+            content: '',
+            success: false,
+            error: 'unknown error',
+        };
+    }
     /**
      * 从 messages 中找到最后一条 assistant 消息
      */

package/dist/graph/skill-audit-recorder.d.ts

@@ -1,8 +1,8 @@
 /**
- * SkillAuditRecorder — Skill 调用台账（RT-6）
+ * SkillAuditRecorder — 进程内 Skill 调用记录（调试用）
  *
- * 记录每次 Skill（子图）激活的审计明细，供后续分析与看板使用。
- * Runtime 负责写入；Gateway 看不到 Skill 调用。
+ * 生产记录是 Trace 上的 skill Span（子图激活，或成功读 SKILL.md）。
+ * 本记录器默认内存、不对外查询；分析从 Span 聚合，不读这里。
  *
  * @see docs/status/module-status-and-backlog.md RT-6
  */
@@ -48,7 +48,7 @@ export interface SkillInvocationRecord {
 /**
  * ISkillAuditStore — Skill 审计存储接口
  *
- * 默认实现为内存存储；生产环境应接入 PG 或外部审计服务。
+ * 默认内存存储。生产不依赖本接口；Skill 调用记录以 Trace skill Span 为准。
  */
 export interface ISkillAuditStore {
     /** 写入审计记录 */

package/dist/graph/skill-audit-recorder.js

@@ -1,8 +1,8 @@
 /**
- * SkillAuditRecorder — Skill 调用台账（RT-6）
+ * SkillAuditRecorder — 进程内 Skill 调用记录（调试用）
  *
- * 记录每次 Skill（子图）激活的审计明细，供后续分析与看板使用。
- * Runtime 负责写入；Gateway 看不到 Skill 调用。
+ * 生产记录是 Trace 上的 skill Span（子图激活，或成功读 SKILL.md）。
+ * 本记录器默认内存、不对外查询；分析从 Span 聚合，不读这里。
  *
  * @see docs/status/module-status-and-backlog.md RT-6
  */

package/dist/graph/trace-span.d.ts

@@ -1,21 +1,14 @@
 /**
  * Graph 节点 Span 辅助：createNode / completeNode 失败不挡主路径。
  */
-import type { ITraceCollector, ExecutionNodeEvent } from '../contracts/trace-collector.js';
+import type { ITraceCollector, ExecutionNodeEvent, CompleteNodeParams } from '../contracts/trace-collector.js';
 export declare function startGraphSpan(state: Record<string, unknown>, input: {
     name: string;
     type: ExecutionNodeEvent['type'];
     parentSpanId?: string;
     extra?: Partial<Omit<ExecutionNodeEvent, 'traceId' | 'name' | 'type' | 'parentNodeId'>>;
 }): Promise<string | undefined>;
-export declare function completeGraphSpan(state: Record<string, unknown>, spanId: string | undefined, params: {
-    status: 'completed' | 'failed';
-    output?: unknown;
-    error?: string;
-    inputTokens?: number;
-    outputTokens?: number;
-    totalTokens?: number;
-}, collectorOverride?: ITraceCollector): Promise<void>;
+export declare function completeGraphSpan(state: Record<string, unknown>, spanId: string | undefined, params: CompleteNodeParams, collectorOverride?: ITraceCollector): Promise<void>;
 export declare function withGraphSpan(state: Record<string, unknown>, spec: {
     name: string;
     type: ExecutionNodeEvent['type'];

package/dist/graph/trace-span.js

@@ -57,6 +57,7 @@ export async function withGraphSpan(state, spec, run) {
             totalTokens: usage?.inputTokens != null || usage?.outputTokens != null
                 ? (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
                 : undefined,
+            ...(typeof usage?.model === 'string' && usage.model ? { model: usage.model } : {}),
         });
         return spanId ? { ...result, lastSpanId: spanId } : result;
     }

package/dist/index.d.ts

@@ -15,10 +15,12 @@ export * from './memory/index.js';
 export * from './common/index.js';
 export * from './registry/index.js';
 export * from './providers/index.js';
-export type { ITraceCollector, TraceEvent, TraceSession, ExecutionFlowEvent, ExecutionNodeEvent, TraceLinkEvent, TraceLinkNodeEvent, } from './contracts/trace-collector.js';
+export type { ITraceCollector, CompleteNodeParams, TraceEvent, TraceSession, ExecutionFlowEvent, ExecutionNodeEvent, TraceLinkEvent, TraceLinkNodeEvent, } from './contracts/trace-collector.js';
 export type { ExecutionContext, CallerType, GovernancePermissionCheckParams, GovernancePermissionCheckResult, PermissionDenyReason, } from '@gt-fe/eap-contracts';
 export { HttpGovernanceClient, AllowAllGovernanceClient, resolveExecutionContext, assertToolPermission, assertSkillPermission, permissionMessage, PermissionDeniedError, GovernanceUnavailableError, } from './governance/index.js';
 export type { IGovernanceClient } from './governance/index.js';
+export { decideBeforeModel, decideBeforeTool, } from './execution/index.js';
+export type { AfterModelInterceptor, AfterToolInterceptor, BeforeModelInput, BeforeModelInterceptor, BeforeToolInterceptor, ExecutionInterceptors, ModelInterceptorDecision, ToolInterceptorDecision, } from './execution/index.js';
 export { FileLlmTurnLog, InMemoryLlmTurnLog, createFileLlmTurnLogFromEnv, maskApiKey, resolveLlmTurnDir, } from './debug/llm-turn-log.js';
 export { PostgresLlmTurnLog } from './debug/pg-llm-turn-log.js';
 export type { ILlmTurnLog, LlmTurnRecord, LlmTurnIndexEntry, LlmTurnContext, LlmTurnLogKind, } from './debug/llm-turn-log.js';

package/dist/index.js

@@ -30,5 +30,6 @@ export * from './registry/index.js';
 // LLM Providers
 export * from './providers/index.js';
 export { HttpGovernanceClient, AllowAllGovernanceClient, resolveExecutionContext, assertToolPermission, assertSkillPermission, permissionMessage, PermissionDeniedError, GovernanceUnavailableError, } from './governance/index.js';
+export { decideBeforeModel, decideBeforeTool, } from './execution/index.js';
 export { FileLlmTurnLog, InMemoryLlmTurnLog, createFileLlmTurnLogFromEnv, maskApiKey, resolveLlmTurnDir, } from './debug/llm-turn-log.js';
 export { PostgresLlmTurnLog } from './debug/pg-llm-turn-log.js';

package/dist/memory/semantic-retrieval.service.d.ts

@@ -98,7 +98,7 @@ export type EmbeddingFunction = (text: string) => Promise<number[]>;
 export declare class SemanticRetrievalService {
     private readonly config;
     private readonly vectorStore?;
-    private readonly embedding;
+    private readonly embedding?;
     constructor(config?: Partial<RetrievalConfig>, vectorStore?: IVectorStore, embedding?: EmbeddingFunction);
     /**
      * 检索相关记忆

package/dist/memory/semantic-retrieval.service.js

@@ -20,21 +20,6 @@ export const DEFAULT_RETRIEVAL_CONFIG = {
     keywordWeight: 0.3,
     vectorWeight: 0.7,
 };
-/**
- * 默认 Embedding 函数（占位）
- *
- * 实际使用时应注入真实的 Embedding 函数（如 OpenAI Embedding）。
- */
-async function defaultEmbedding(text) {
-    // 简单的哈希向量（占位，实际应使用真实的 Embedding 模型）
-    const vector = new Array(128).fill(0);
-    for (let i = 0; i < text.length; i++) {
-        vector[i % 128] += text.charCodeAt(i) / 1000;
-    }
-    // 归一化
-    const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    return vector.map((v) => v / norm);
-}
 // ─────────────────────────────────────────────
 // 语义检索服务
 // ─────────────────────────────────────────────
@@ -48,7 +33,7 @@ export class SemanticRetrievalService {
     constructor(config, vectorStore, embedding) {
         this.config = { ...DEFAULT_RETRIEVAL_CONFIG, ...config };
         this.vectorStore = vectorStore;
-        this.embedding = embedding ?? defaultEmbedding;
+        this.embedding = embedding;
     }
     /**
      * 检索相关记忆
@@ -106,11 +91,9 @@ export class SemanticRetrievalService {
      * 基于向量相似度的检索。
      */
     async vectorRetrieve(query, memories) {
-        if (!this.vectorStore) {
-            // 如果没有向量存储，回退到关键词检索
+        if (!this.vectorStore || !this.embedding) {
             return this.keywordRetrieve(query, memories);
         }
-        // 生成查询向量
         const queryVector = await this.embedding(query);
         // 查询相似向量
         const vectorResults = await this.vectorStore.query(queryVector, this.config.limit, this.config.similarityThreshold);
@@ -183,12 +166,19 @@ export class SemanticRetrievalService {
             'under', 'again', 'further', 'then', 'once',
         ]);
         // 分词（简单按空格和标点分割）
-        const words = text
-            .toLowerCase()
-            .replace(/[^\w\u4e00-\u9fff]/g, ' ')
+        const cleaned = text.toLowerCase().replace(/[^\w\u4e00-\u9fff]/g, ' ');
+        const words = cleaned
             .split(/\s+/)
             .filter((word) => word.length > 1 && !stopWords.has(word));
-        return [...new Set(words)];
+        const grams = [];
+        for (const word of words) {
+            if (/[\u4e00-\u9fff]/.test(word) && word.length > 2) {
+                for (let i = 0; i < word.length - 1; i++) {
+                    grams.push(word.slice(i, i + 2));
+                }
+            }
+        }
+        return [...new Set([...words, ...grams])];
     }
 }
 // ─────────────────────────────────────────────

package/dist/providers/index.d.ts

@@ -1,6 +1,6 @@
 export { EchoLLMProvider, createDefaultLLMProvider } from './echo-llm-provider.js';
 export { HttpLLMProvider, DEFAULT_LLM_HTTP_TIMEOUT_MS, type HttpLLMProviderConfig } from './http-llm-provider.js';
-export { RoutingLLMProvider, type RoutingLLMProviderConfig } from './routing-llm-provider.js';
+export { RoutingLLMProvider, type RoutingLLMProviderConfig, assertFoundationModelsInvokeAllowsStream, isFoundationModelsInvokeEnabled, MODELS_INVOKE_STREAM_MESSAGE, } from './routing-llm-provider.js';
 export { resolveLlmModelName, canOverrideGraphModel } from './resolve-llm-model.js';
 export { createLocalLlmProvider, requireLocalLlmConnections, resolveLocalLlmConnection, parseLocalLlmConnectionRefs, hydrateLocalLlmConnections, LLM_CONNECTIONS_ENV, } from './local-llm-provider.js';
 export type { LocalLlmConnection, LocalLlmConnectionRef, LocalLlmConnectionRefs, LocalLlmConnections, } from './local-llm-provider.js';

package/dist/providers/index.js

@@ -1,5 +1,5 @@
 export { EchoLLMProvider, createDefaultLLMProvider } from './echo-llm-provider.js';
 export { HttpLLMProvider, DEFAULT_LLM_HTTP_TIMEOUT_MS } from './http-llm-provider.js';
-export { RoutingLLMProvider } from './routing-llm-provider.js';
+export { RoutingLLMProvider, assertFoundationModelsInvokeAllowsStream, isFoundationModelsInvokeEnabled, MODELS_INVOKE_STREAM_MESSAGE, } from './routing-llm-provider.js';
 export { resolveLlmModelName, canOverrideGraphModel } from './resolve-llm-model.js';
 export { createLocalLlmProvider, requireLocalLlmConnections, resolveLocalLlmConnection, parseLocalLlmConnectionRefs, hydrateLocalLlmConnections, LLM_CONNECTIONS_ENV, } from './local-llm-provider.js';

package/dist/providers/routing-llm-provider.d.ts

@@ -14,6 +14,10 @@
 import type { GraphMessage } from '../graph/contracts/executable-graph.js';
 import type { ILLMProvider, LLMNodeConfig, LLMResponse, LLMChunk } from '../graph/nodes/llm-node.js';
 import type { ILlmTurnLog } from '../debug/llm-turn-log.js';
+export declare const MODELS_INVOKE_STREAM_MESSAGE = "EAP_RUNTIME_MODELS_INVOKE \u5B9E\u9A8C\u53E3\u53EA\u652F\u6301\u540C\u6B65 invoke\uFF08POST /models/invoke\uFF09\uFF0C\u4E0D\u652F\u6301 stream\u3002\u5173\u6389\u8BE5\u5F00\u5173\uFF0C\u6216\u6539\u8D70 Foundation /models/select + \u672C\u673A HTTP\u3002";
+export declare function isFoundationModelsInvokeEnabled(env?: NodeJS.ProcessEnv): boolean;
+/** `/models/invoke` 无真流式；开了该开关时 RoutingLLMProvider.stream 必须失败。 */
+export declare function assertFoundationModelsInvokeAllowsStream(env?: NodeJS.ProcessEnv): void;
 export interface RoutingLLMProviderConfig {
     foundationUrl: string;
     fallbackProvider?: ILLMProvider;
@@ -28,5 +32,6 @@ export declare class RoutingLLMProvider implements ILLMProvider {
     stream(messages: GraphMessage[], config: LLMNodeConfig): AsyncIterableIterator<LLMChunk>;
     private withCallDefaults;
     private selectModel;
+    private useFoundationInvoke;
     private createProviderForModel;
 }