@gt-fe/eap-runtime 0.0.20 → 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 对齐）
  */
@@ -49,6 +51,8 @@ export interface ToolNodeProgress {
     skillVersion?: string;
     skillName?: string;
     toolVersion?: string;
+    /** 本失败后是否还会再试。缺省 false */
+    willRetry?: boolean;
 }
 export declare class ToolNode {
     private readonly orchestrator;
@@ -57,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 节点函数
      *
@@ -71,6 +88,7 @@ export declare class ToolNode {
      * 从 state 中提取 messages 数组
      */
     private extractMessages;
+    private executeSingleWithRetry;
     /**
      * 从 messages 中找到最后一条 assistant 消息
      */

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

@@ -9,6 +9,7 @@
  * @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';
@@ -17,6 +18,10 @@ import { ToolConfirmationInterceptor } from '../../tool/tool-confirmation.js';
 import { resolveCheckpointThreadId } from '../../session/persist-turn-messages.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 ?? {})
@@ -30,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 节点函数
@@ -100,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'];
@@ -120,8 +145,31 @@ export class ToolNode {
                 ...(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 {
@@ -153,17 +201,9 @@ 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 toolIdentity = toolTraceIdentity(loadedTools?.[req.toolName], req.toolName);
             const toolset = toolIdentity.toolset;
-            const resumingHitl = isHitlDecision(state['hitlChoice']);
             if (!resumingHitl) {
                 emitProgress({
                     toolCallId: req.toolCallId,
@@ -177,32 +217,73 @@ 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) {
@@ -274,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({
@@ -362,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/index.d.ts

@@ -19,6 +19,8 @@ export type { ITraceCollector, CompleteNodeParams, TraceEvent, TraceSession, Exe
 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;
 }

package/dist/providers/routing-llm-provider.js

@@ -11,9 +11,22 @@
  * - 支持任意 OpenAI 兼容 API（OpenAI / DeepSeek / 本地 Ollama 等）
  * - 连接配置由 Foundation 统一管理，Runtime 无感知
  */
-import { mergeModelCallParams } from '@gt-fe/eap-contracts';
+import { AppError, ErrorCodes, mergeModelCallParams } from '@gt-fe/eap-contracts';
 import { EchoLLMProvider } from './echo-llm-provider.js';
 import { DEFAULT_LLM_HTTP_TIMEOUT_MS, HttpLLMProvider } from './http-llm-provider.js';
+export const MODELS_INVOKE_STREAM_MESSAGE = 'EAP_RUNTIME_MODELS_INVOKE 实验口只支持同步 invoke（POST /models/invoke），不支持 stream。关掉该开关，或改走 Foundation /models/select + 本机 HTTP。';
+export function isFoundationModelsInvokeEnabled(env = process.env) {
+    const raw = env.EAP_RUNTIME_MODELS_INVOKE;
+    return raw === '1' || raw === 'true';
+}
+/** `/models/invoke` 无真流式；开了该开关时 RoutingLLMProvider.stream 必须失败。 */
+export function assertFoundationModelsInvokeAllowsStream(env = process.env) {
+    if (!isFoundationModelsInvokeEnabled(env))
+        return;
+    throw new AppError(ErrorCodes.GRAPH_EXECUTION_ERROR, MODELS_INVOKE_STREAM_MESSAGE, {
+        exposeMessage: true,
+    });
+}
 export class RoutingLLMProvider {
     foundationUrl;
     fallback;
@@ -29,6 +42,7 @@ export class RoutingLLMProvider {
         return provider.invoke(messages, this.withCallDefaults(config, selected));
     }
     async *stream(messages, config) {
+        assertFoundationModelsInvokeAllowsStream();
         const selected = await this.selectModel(config);
         const provider = this.createProviderForModel(selected);
         yield* provider.stream(messages, this.withCallDefaults(config, selected));
@@ -72,7 +86,13 @@ export class RoutingLLMProvider {
         }
         return { name: config.model ?? 'echo', provider: 'local', connection: null };
     }
+    useFoundationInvoke() {
+        return isFoundationModelsInvokeEnabled();
+    }
     createProviderForModel(selected) {
+        if (this.useFoundationInvoke()) {
+            return new FoundationModelsInvokeProvider(this.foundationUrl, selected.name, this.turnLog);
+        }
         // 优先使用 Foundation 返回的连接配置
         if (selected.connection) {
             return new HttpLLMProvider({
@@ -96,3 +116,48 @@ export class RoutingLLMProvider {
         return this.fallback;
     }
 }
+/**
+ * Foundation `/models/invoke` 实验口。默认关。
+ * 只实现同步 invoke；stream 拒绝（无真流式、无鉴权头）。
+ * Foundation 未提供该接口时不要开 EAP_RUNTIME_MODELS_INVOKE。
+ */
+class FoundationModelsInvokeProvider {
+    foundationUrl;
+    model;
+    turnLog;
+    constructor(foundationUrl, model, turnLog) {
+        this.foundationUrl = foundationUrl;
+        this.model = model;
+        this.turnLog = turnLog;
+    }
+    async invoke(messages, config) {
+        const res = await fetch(`${this.foundationUrl}/api/v1/models/invoke`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: config.model ?? this.model,
+                messages,
+                temperature: config.temperature,
+                maxTokens: config.maxTokens,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Foundation /models/invoke HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        const content = body.data?.content ?? body.content ?? '';
+        void this.turnLog;
+        return {
+            content,
+            inputTokens: body.data?.inputTokens ?? 0,
+            outputTokens: body.data?.outputTokens ?? 0,
+            model: body.data?.model ?? config.model ?? this.model,
+        };
+    }
+    async *stream(_messages, _config) {
+        assertFoundationModelsInvokeAllowsStream();
+        throw new AppError(ErrorCodes.GRAPH_EXECUTION_ERROR, MODELS_INVOKE_STREAM_MESSAGE, {
+            exposeMessage: true,
+        });
+    }
+}

package/dist/runtime/agent-runtime.d.ts

@@ -16,6 +16,7 @@ import type { SessionContextService } from '../session/session-context.service.j
 import type { MessageService } from '../session/message.service.js';
 import type { SessionService, SessionRecord, MessageRecord } from '../session/session.service.js';
 import { type ILlmTurnLog, type LlmTurnIndexEntry, type LlmTurnLogKind, type LlmTurnRecord } from '../debug/llm-turn-log.js';
+import { type SessionCompressionOptions } from '../session/apply-session-compression.js';
 import type { SSEEvent } from '../sse/contracts/sse-emitter.contract.js';
 import type { TaskService } from '../task/task.service.js';
 import type { ExecuteParams, ExecuteResult, ForkParams, ForkOverrides, ForkResult, HitlResponse, ResumeHitlResult, SeedSessionMessagesParams, SeedSessionMessagesResult } from './types.js';
@@ -46,6 +47,10 @@ export interface AgentRuntimeDeps {
      */
     traceCollector?: ITraceCollector;
     recordForkRelation?: RecordForkRelation;
+    /** 历史压缩；默认关。见 EAP_RUNTIME_COMPRESSION */
+    sessionCompression?: SessionCompressionOptions;
+    /** 长期记忆注入；默认关。见 EAP_RUNTIME_MEMORY */
+    sessionMemory?: import('../session/apply-session-memory.js').SessionMemoryOptions;
 }
 /** 一次对话详情：消息 + 每步 LLM 入参/响应。File / 内存 / Postgres 同一套结构。 */
 export interface ConversationDetail {