@gt-fe/eap-runtime 0.0.33 → 0.0.35

package/dist/graph/adapters/subgraph-compiler.js

@@ -15,6 +15,7 @@ import { resolveExecutionTrace, warnTraceSpanFailure, } from '../execution-trace
 import { skillSpanFields, skillTraceIdentity } from './skill-entry-span.js';
 import { filterLoadedToolsForSkill, spokenName, } from '../../tool/system-prompt-builder.js';
 import { unwrapHitlPaused } from '../hitl/hitl-handler.js';
+import { exposureScopeId, exposedNamesForScope, mergeExposed } from '../../tool/mcp-tool-exposure.js';
 import { pickContextFields } from '../../token/context-window.js';
 import { assertSkillIoIfEnabled, coerceSkillInputFromMessages, } from '../../registry/skill-io-guard.js';
 import { isolatedSkillMessages, isolatedSkillOutput, } from './skill-isolate.js';
@@ -163,6 +164,15 @@ export class SubGraphCompiler {
                     skillIsolateContext: isolateContext || undefined,
                     executionContext: state['executionContext'],
                     loadedTools: scopedTools,
+                    exposedMcpTools: Array.isArray(state['exposedMcpTools'])
+                        ? state['exposedMcpTools']
+                        : undefined,
+                    exposedMcpScopeId: typeof state['exposedMcpScopeId'] === 'string'
+                        ? state['exposedMcpScopeId']
+                        : undefined,
+                    sentMcpToolNames: Array.isArray(state['sentMcpToolNames'])
+                        ? state['sentMcpToolNames']
+                        : undefined,
                     loadedSkills: state['loadedSkills'],
                     skillDefinitions: defs,
                     agentSystemPrompt: typeof state['agentSystemPrompt'] === 'string'
@@ -234,10 +244,25 @@ export class SubGraphCompiler {
                     undefined;
                 const parentNodeId = options?.parentNodeId
                     || (dsl.name ? `subgraph:${dsl.name}` : 'subgraph');
+                const parentScope = exposureScopeId({
+                    sessionId: state['sessionId'],
+                    taskId: state['taskId'],
+                });
+                const childScope = result.finalState?.exposedMcpScopeId;
+                const parentNames = exposedNamesForScope(state['exposedMcpTools'], state['exposedMcpScopeId'], parentScope);
+                const childNames = childScope === parentScope && Array.isArray(result.finalState?.exposedMcpTools)
+                    ? result.finalState.exposedMcpTools
+                    : [];
                 return {
                     messages: outputMessages,
                     currentNode: parentNodeId,
                     historyPath: [parentNodeId],
+                    ...(parentScope
+                        ? {
+                            exposedMcpTools: mergeExposed(parentNames, childNames),
+                            exposedMcpScopeId: parentScope,
+                        }
+                        : {}),
                     ...(nestedLastSpanId ? { lastSpanId: nestedLastSpanId } : {}),
                     ...(Array.isArray(perNode) && perNode.length > 0
                         ? {

package/dist/graph/contracts/executable-graph.d.ts

@@ -197,6 +197,15 @@ export interface GraphState {
     ragSources?: string[];
     /** GraphLoader 注入：toolName → 运行期 manifest 引用 */
     loadedTools?: import('../../tool/loaded-tool-definition.js').LoadedToolMap;
+    /**
+     * 本会话已点名、下一次模型调用要带完整参数的 MCP 工具名。
+     * 与 exposedMcpScopeId 一起用。有 sessionId 时按会话，否则按 taskId。新会话不沿用。
+     */
+    exposedMcpTools?: string[];
+    /** 与 exposedMcpTools 对应的 sessionId，没有 sessionId 时是 taskId。 */
+    exposedMcpScopeId?: string;
+    /** 上一轮实际发给模型的工具名。工具节点用它判断没点名的 MCP 调用。 */
+    sentMcpToolNames?: string[];
     /** GraphLoader 注入：已装配 Skill 列表 */
     loadedSkills?: import('../../tool/system-prompt-builder.js').LoadedSkillInfo[];
     /** GraphLoader 注入：skillId → 完整定义（子图解析 / prompt） */

package/dist/graph/execution-trace-context.d.ts

@@ -8,9 +8,12 @@ export interface ExecutionStreamBag {
         correlationId?: string;
     };
     chunkIndex: number;
+    /** 本轮 reasoning.chunk 序号，与 chunkIndex 分开从 0 计 */
+    reasoningChunkIndex: number;
     iteration: number;
     reasoningStartedThisTurn: boolean;
     streamedTextThisTurn: boolean;
+    graphId?: string;
 }
 export interface ExecutionRunContext {
     collector?: ITraceCollector;

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

@@ -107,6 +107,11 @@ export interface LLMChunk {
     /** thinking 增量；最终聚合后写入 assistant 消息 */
     reasoningContent?: string;
 }
+/** 流式旁路增量：思考与正文分字段，空字段不传 */
+export type LLMStreamDelta = {
+    content?: string;
+    reasoningContent?: string;
+};
 /**
  * ILLMProvider — LLM 调用提供者接口
  *
@@ -145,9 +150,9 @@ export declare class LLMNode {
      * @param config - LLM 节点配置
      * @param provider - LLM 调用提供者
      * @param streaming - 是否启用流式输出（默认 false）
-     * @param onChunk - 流式模式下每个文本片段回调（用于 SSE response.chunk）
+     * @param onChunk - 流式旁路：思考走 reasoningContent，正文走 content
      */
-    constructor(nodeId: string, config: LLMNodeConfig, provider: ILLMProvider, streaming?: boolean, onChunk?: (chunk: string) => void, interceptors?: Pick<ExecutionInterceptors, "beforeModel" | "afterModel"> | undefined);
+    constructor(nodeId: string, config: LLMNodeConfig, provider: ILLMProvider, streaming?: boolean, onChunk?: (delta: LLMStreamDelta) => void, interceptors?: Pick<ExecutionInterceptors, "beforeModel" | "afterModel"> | undefined);
     /**
      * execute — StateGraph 节点函数
      *

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

@@ -14,6 +14,7 @@ import { buildContextUsage, turnSectionChars } from '../../token/context-window.
 import { isAbortError } from '../../tool/timeout.js';
 import { emitRuntimeLog } from '../../common/logger.js';
 import { decideBeforeModel, } from '../../execution/interceptors.js';
+import { projectHistoryForModelTools } from '../../tool/mcp-tool-exposure.js';
 // ─────────────────────────────────────────────
 // Default retry config
 // ─────────────────────────────────────────────
@@ -52,7 +53,7 @@ export class LLMNode {
      * @param config - LLM 节点配置
      * @param provider - LLM 调用提供者
      * @param streaming - 是否启用流式输出（默认 false）
-     * @param onChunk - 流式模式下每个文本片段回调（用于 SSE response.chunk）
+     * @param onChunk - 流式旁路：思考走 reasoningContent，正文走 content
      */
     constructor(nodeId, config, provider, streaming = false, onChunk, interceptors) {
         this.interceptors = interceptors;
@@ -84,7 +85,8 @@ export class LLMNode {
         if (gate.action === 'deny') {
             throw new Error(gate.reason);
         }
-        const messagesForModel = gate.messages ?? messagesWithSystem;
+        const toolNames = new Set((this.config.tools ?? []).map((tool) => tool.function.name));
+        const messagesForModel = projectHistoryForModelTools(gate.messages ?? messagesWithSystem, toolNames);
         const startedAt = Date.now();
         // 带重试的 LLM 调用
         const response = await this.invokeWithRetry(messagesForModel);
@@ -247,8 +249,13 @@ export class LLMNode {
         let toolCalls;
         const iterator = this.provider.stream(messages, this.config);
         for await (const chunk of iterator) {
-            if (chunk.content && this.onChunk) {
-                this.onChunk(chunk.content);
+            const content = chunk.content || '';
+            const reasoningContent = chunk.reasoningContent || '';
+            if (this.onChunk && (content || reasoningContent)) {
+                this.onChunk({
+                    ...(content ? { content } : {}),
+                    ...(reasoningContent ? { reasoningContent } : {}),
+                });
             }
             chunks.push(chunk.content);
             if (chunk.reasoningContent) {

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

@@ -58,6 +58,10 @@ export interface ToolNodeProgress {
     toolVersion?: string;
     /** 本失败后是否还会再试。缺省 false */
     willRetry?: boolean;
+    /** 不发 tool.progress。tool_search 仍发 tool.result，供最终回复判断。 */
+    quiet?: boolean;
+    /** 只给模型。不进员工 SSE。未点名的调用用这个。 */
+    modelOnly?: boolean;
 }
 export declare class ToolNode {
     private readonly orchestrator;

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

@@ -17,6 +17,7 @@ import { isHitlDecision, unwrapHitlPaused } from '../hitl/hitl-handler.js';
 import { ToolConfirmationInterceptor } from '../../tool/tool-confirmation.js';
 import { resolveCheckpointThreadId } from '../../session/persist-turn-messages.js';
 import { mcpToolsetCode, toolTraceIdentity } from '../../tool/mcp-list.js';
+import { exposureScopeId, exposedNamesForScope, isUnloadedDeferredCall, mcpNamesToExpose, mergeExposed, partitionToolSearchCalls, runToolSearch, unloadedCallToolContent, } from '../../tool/mcp-tool-exposure.js';
 import { resolveExecutionTrace, warnTraceSpanFailure, } from '../execution-trace-context.js';
 import { emitRuntimeLog } from '../../common/logger.js';
 import { toolResultHasArtifacts } from '../../tool/inject-public-artifact-links.js';
@@ -36,6 +37,28 @@ function skillDirsFromState(state) {
         .filter((skill) => Boolean(skill.bundlePath))
         .map((skill) => ({ skillId: skill.skillId, bundlePath: skill.bundlePath }));
 }
+function exposureUpdate(state, searchCalls, businessNames, loadedTools, alreadyInTools) {
+    const scopeId = exposureScopeId({ sessionId: state['sessionId'], taskId: state['taskId'] });
+    const existing = exposedNamesForScope(state['exposedMcpTools'], state['exposedMcpScopeId'], scopeId);
+    const messagesById = new Map();
+    const searchExpose = [];
+    for (const call of searchCalls) {
+        const outcome = runToolSearch(call.arguments, loadedTools, alreadyInTools);
+        searchExpose.push(...outcome.expose);
+        messagesById.set(call.id, {
+            role: 'tool',
+            content: outcome.content,
+            toolCallId: call.id,
+            toolName: call.name,
+            success: true,
+        });
+    }
+    return {
+        messagesById,
+        exposedMcpTools: mergeExposed(existing, mcpNamesToExpose(loadedTools, searchExpose, businessNames)),
+        exposedMcpScopeId: scopeId,
+    };
+}
 export class ToolNode {
     orchestrator;
     injector;
@@ -83,6 +106,15 @@ export class ToolNode {
             return state;
         }
         const loadedTools = state['loadedTools'];
+        const partitioned = partitionToolSearchCalls(lastAssistantMessage.toolCalls, loadedTools);
+        const sentMcpToolNames = Array.isArray(state['sentMcpToolNames'])
+            ? state['sentMcpToolNames']
+            : undefined;
+        const blockedCalls = partitioned.deferActive
+            ? partitioned.business.filter((call) => isUnloadedDeferredCall(loadedTools?.[call.name], sentMcpToolNames))
+            : [];
+        const blockedIds = new Set(blockedCalls.map((call) => call.id));
+        const executableCalls = partitioned.business.filter((call) => !blockedIds.has(call.id));
         const skillDirs = skillDirsFromState(state);
         const jail = resolveJailFromState({
             agentDir: state['agentDir'],
@@ -92,13 +124,13 @@ export class ToolNode {
             skillDefinitions: state['skillDefinitions'],
         });
         const jailExtraRoots = jail.extraRoots ?? [];
-        const batchCalls = lastAssistantMessage.toolCalls.map((tc) => ({
+        const batchCalls = executableCalls.map((tc) => ({
             name: tc.name,
             arguments: tc.arguments,
         }));
         const boundSkill = typeof state['activatedSkill'] === 'string' ? state['activatedSkill'] : undefined;
         // 4. 转换为 ToolCallRequest[]（附带 manifest 路由字段）
-        const requests = lastAssistantMessage.toolCalls.map((tc) => {
+        const requests = executableCalls.map((tc) => {
             const loaded = loadedTools?.[tc.name];
             const toolsetCode = mcpToolsetCode(loaded);
             const correlationId = String(state['correlationId'] ?? tc.id);
@@ -170,6 +202,84 @@ export class ToolNode {
             ? state['hitlToolCallId']
             : undefined;
         const confirmationCount = requests.filter((req) => confirmationTools.has(req.toolName)).length;
+        // 点名先记进本轮返回值。HITL 抛出时这次返回作废，恢复后本节点会再跑一遍并带上这些名字。
+        const exposure = partitioned.deferActive
+            ? exposureUpdate(state, partitioned.search, partitioned.business.map((call) => call.name), loadedTools, sentMcpToolNames)
+            : undefined;
+        const blockedMessages = new Map();
+        const sideSpanIds = [];
+        const recordSideSpan = async (name, callId, input, output, notExecuted) => {
+            if (!traceCollector || !traceId)
+                return;
+            try {
+                const parentNodeId = typeof state['skillSpanId'] === 'string' && state['skillSpanId']
+                    ? state['skillSpanId']
+                    : undefined;
+                const spanId = await traceCollector.createNode({
+                    traceId,
+                    name,
+                    type: 'tool',
+                    parentNodeId,
+                    agentCode: agentCode || undefined,
+                    input,
+                    metadata: {
+                        toolCallId: callId,
+                        ...(notExecuted ? { notExecuted: true } : {}),
+                    },
+                });
+                sideSpanIds.push(spanId);
+                await traceCollector.completeNode(spanId, {
+                    status: notExecuted ? 'failed' : 'completed',
+                    output,
+                    ...(notExecuted ? { error: output } : {}),
+                });
+            }
+            catch (err) {
+                warnTraceSpanFailure('createNode', { type: 'tool', name, traceId, toolCallId: callId }, err);
+            }
+        };
+        for (const call of partitioned.search) {
+            const content = exposure?.messagesById.get(call.id)?.content ?? '';
+            emitProgress({
+                toolCallId: call.id,
+                toolName: call.name,
+                status: 'completed',
+                arguments: call.arguments,
+                content,
+                quiet: true,
+                modelOnly: true,
+            });
+            await recordSideSpan(call.name, call.id, call.arguments, content, false);
+        }
+        for (const call of blockedCalls) {
+            const content = unloadedCallToolContent(call.name);
+            blockedMessages.set(call.id, {
+                role: 'tool',
+                content,
+                toolCallId: call.id,
+                toolName: call.name,
+                success: false,
+            });
+            emitProgress({
+                toolCallId: call.id,
+                toolName: call.name,
+                status: 'started',
+                arguments: call.arguments,
+                quiet: true,
+                modelOnly: true,
+            });
+            emitProgress({
+                toolCallId: call.id,
+                toolName: call.name,
+                status: 'error',
+                arguments: call.arguments,
+                error: content,
+                content,
+                quiet: true,
+                modelOnly: true,
+            });
+            await recordSideSpan(call.name, call.id, call.arguments, content, true);
+        }
         // 5. 并行执行所有 Tool 调用（附 Trace span）
         const spanIds = await Promise.all(requests.map(async (req) => {
             const reusePausedSpan = Boolean(resumeToolSpanId) &&
@@ -443,11 +553,29 @@ export class ToolNode {
             ...('file' in result && result.file ? { file: result.file } : {}),
             ...('files' in result && result.files?.length ? { files: result.files } : {}),
         }));
-        const lastSpanId = [...spanIds].reverse().find((id) => Boolean(id));
+        const lastSpanId = [...spanIds, ...sideSpanIds].reverse().find((id) => Boolean(id));
+        const orderedMessages = (exposure && partitioned.intercept) || blockedMessages.size > 0
+            ? lastAssistantMessage.toolCalls.map((call) => {
+                const searched = exposure?.messagesById.get(call.id);
+                if (searched)
+                    return searched;
+                const blocked = blockedMessages.get(call.id);
+                if (blocked)
+                    return blocked;
+                const business = toolMessages.find((message) => message.toolCallId === call.id);
+                return business;
+            })
+            : toolMessages;
         return {
-            messages: toolMessages,
+            messages: orderedMessages,
             currentNode: nodeId,
             ...(lastSpanId ? { lastSpanId } : {}),
+            ...(exposure
+                ? {
+                    exposedMcpTools: exposure.exposedMcpTools,
+                    exposedMcpScopeId: exposure.exposedMcpScopeId,
+                }
+                : {}),
         };
     }
     // ─────────────────────────────────────────────

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

@@ -119,7 +119,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
-                throwIfGraphTimedOut();
+                throwIfGraphAborted();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -170,6 +170,7 @@ export class HttpLLMProvider {
             return result;
         }
         catch (err) {
+            const propagated = graphAbortOr(err);
             await this.writeTurn({
                 url,
                 messages,
@@ -180,10 +181,10 @@ export class HttpLLMProvider {
                     inputTokens: 0,
                     outputTokens: 0,
                     finishReason: 'error',
-                    error: err instanceof Error ? err.message : String(err),
+                    error: propagated instanceof Error ? propagated.message : String(propagated),
                 },
             });
-            throw err;
+            throw propagated;
         }
         finally {
             clearTimeout(timeout);
@@ -244,7 +245,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
-                throwIfGraphTimedOut();
+                throwIfGraphAborted();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -397,6 +398,7 @@ export class HttpLLMProvider {
             });
         }
         catch (err) {
+            const propagated = graphAbortOr(err);
             await this.writeTurn({
                 url,
                 messages,
@@ -411,10 +413,10 @@ export class HttpLLMProvider {
                     inputTokens,
                     outputTokens,
                     finishReason: 'error',
-                    error: err instanceof Error ? err.message : String(err),
+                    error: propagated instanceof Error ? propagated.message : String(propagated),
                 },
             });
-            throw err;
+            throw propagated;
         }
         finally {
             clearTimeout(timeout);
@@ -528,11 +530,26 @@ function linkGraphAbort(controller) {
     graphSignal.addEventListener('abort', onAbort, { once: true });
     return () => graphSignal.removeEventListener('abort', onAbort);
 }
-function throwIfGraphTimedOut() {
-    const reason = getExecutionTrace()?.abortSignal?.reason;
-    if (reason instanceof Error && /timed out/i.test(reason.message)) {
+/** 这一轮 signal 已 abort 就抛出 reason。超时和用户停止都走这里，不再只认 timed out。 */
+function throwIfGraphAborted() {
+    const reason = graphAbortReason();
+    if (reason)
         throw reason;
-    }
+}
+/** 流式 read 抛出的 DOMException 换成这一轮 signal 上的 reason。 */
+function graphAbortOr(err) {
+    return graphAbortReason() ?? err;
+}
+function graphAbortReason() {
+    const signal = getExecutionTrace()?.abortSignal;
+    if (!signal?.aborted)
+        return undefined;
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    const err = new Error(reason == null ? 'Task aborted' : String(reason));
+    err.name = 'AbortError';
+    return err;
 }
 function formatNetworkDetail(error, depth = 0) {
     if (depth > 5)

package/dist/registry/graph-loader.js

@@ -270,6 +270,15 @@ function resolveMcpServer(manifest) {
     }
     return undefined;
 }
+/** 门户把同一次注册的「用户确认」写在每个 tools[] 上。MCP 不展开这份清单，占位记录读这个值。 */
+function mcpToolsRequireConfirmation(manifest) {
+    const tools = manifest.tools;
+    if (!Array.isArray(tools))
+        return false;
+    return tools.some((tool) => Boolean(tool &&
+        typeof tool === 'object' &&
+        tool.requireConfirmation));
+}
 function mcpDiscoverStub(pre, options) {
     const m = pre.manifest;
     const server = resolveMcpServer(m);
@@ -306,7 +315,7 @@ function mcpDiscoverStub(pre, options) {
             dataScope: normalizeDataScope(m.permissions && typeof m.permissions === 'object' && !Array.isArray(m.permissions)
                 ? m.permissions.dataScope
                 : m.dataScope),
-            requireConfirmation: false,
+            requireConfirmation: mcpToolsRequireConfirmation(m),
             execution,
         },
     };

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

@@ -11,6 +11,7 @@ import type { ICheckpointSaver } from '../checkpoint/contracts/checkpoint-saver.
 import type { ITraceCollector } from '../contracts/trace-collector.js';
 import type { IStateGraphEngine } from '../graph/contracts/state-graph.contract.js';
 import type { TaskTimeoutManager } from '../task/task-timeout.js';
+import { type TaskAbortKind } from '../task/task-abort.js';
 import { HitlHandler } from '../graph/hitl/hitl-handler.js';
 import { type GraphLoader } from '../registry/graph-loader.js';
 import type { SessionContextService } from '../session/session-context.service.js';
@@ -88,6 +89,12 @@ export interface ConversationDetail {
 export declare class AgentRuntime {
     private readonly deps;
     constructor(deps: AgentRuntimeDeps);
+    /**
+     * 停止这一轮。超时和用户停止共用 timeoutManager 上的那条 AbortSignal。
+     * 计时器还没启动时先记下，startTimer 会返回已 abort 的 signal，且不调用 onTimeout。
+     * @returns 已 abort 或已记下。没有 timeoutManager 时返回 false。
+     */
+    abort(taskId: string, kind?: TaskAbortKind): boolean;
     /** 从 GraphLoader 解析 tool manifest 映射（invoke/stream/resume/fork 共用） */
     private resolveLoadedTools;
     /** 从预装重载 Skill 定义（HITL/Fork 时 ephemeral 字段可能丢失） */