@gt-fe/eap-runtime 0.0.33 → 0.0.35

package/dist/api/handlers/invoke.handler.d.ts

@@ -81,7 +81,6 @@ export declare class InvokeOrchestrator {
     execute(req: InvokeRequest, userId: string): Promise<InvokeResponse>;
     private buildResponse;
     private buildErrorResponse;
-    private isTimeoutError;
     private persistInvokeUsages;
 }
 /** @deprecated 请直接从 `graph/hitl/hitl-handler` 导入；此处保留 re-export 兼容旧测试引用 */

package/dist/api/handlers/invoke.handler.js

@@ -26,6 +26,7 @@ import { AppError, ErrorCodes } from '@gt-fe/eap-contracts';
 import { classifyRuntimeError } from '../../utils/http-error.js';
 import { DEFAULT_GRAPH_TIMEOUT_MS } from '../../common/types.js';
 import { resolveTaskTimeoutMs } from '../../task/resolve-task-timeout.js';
+import { taskAbortKindOf } from '../../task/task-abort.js';
 import { runWithExecutionTrace } from '../../graph/execution-trace-context.js';
 import { resolveAgentDisplayNameFromLoader, resolveAgentSystemPromptFromLoader, } from '../../registry/graph-loader.js';
 import { toLoadedToolMap } from '../../tool/loaded-tool-definition.js';
@@ -313,8 +314,8 @@ export class InvokeOrchestrator {
                     status: 'token_exhausted',
                 });
             }
-            // ─── 错误处理：Timeout ───
-            if (this.isTimeoutError(error)) {
+            const abortKind = taskAbortKindOf(error, abortSignal);
+            if (abortKind === 'timeout') {
                 await this.taskService.tryUpdateStatus(task.id, 'running', 'timeout');
                 return this.buildResponse(traceId, {
                     taskId: task.id,
@@ -325,6 +326,25 @@ export class InvokeOrchestrator {
                     status: 'timeout',
                 });
             }
+            if (abortKind === 'cancelled') {
+                const moved = await this.taskService.tryUpdateStatus(task.id, 'running', 'cancelled');
+                if (!moved) {
+                    await this.taskService.tryUpdateStatus(task.id, 'waiting_hitl', 'cancelled');
+                }
+                // @gt-fe/eap-contracts 的 InvokeStatus 还没有 cancelled。这次不改包，响应体仍写 cancelled。
+                return {
+                    code: 'runtime.task.cancelled',
+                    data: {
+                        taskId: task.id,
+                        sessionId,
+                        output: 'Task cancelled',
+                        tokenUsage,
+                        duration: Date.now() - startTime,
+                        status: 'cancelled',
+                    },
+                    traceId,
+                };
+            }
             // ─── 错误处理：通用错误 ───
             const classified = classifyRuntimeError(error);
             const fuse = classified.code === ErrorCodes.GRAPH_MAX_ITERATIONS ? classified : undefined;
@@ -432,9 +452,6 @@ export class InvokeOrchestrator {
         }
         return { code: 'runtime.graph.execution_error', data, traceId };
     }
-    isTimeoutError(error) {
-        return error instanceof Error && /timed out/i.test(error.message);
-    }
     async persistInvokeUsages(taskId, sessionId) {
         if (!this.checkpointSaver)
             return [];

package/dist/api/handlers/stream.handler.d.ts

@@ -98,5 +98,4 @@ export declare class StreamOrchestrator {
      * 发射错误事件并关闭连接
      */
     private emitErrorAndClose;
-    private isTimeoutError;
 }

package/dist/api/handlers/stream.handler.js

@@ -19,8 +19,9 @@
  * @see design.md §1.5 /stream 内部执行逻辑
  * @see requirements.md Requirement 11 AC2
  */
-import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, extractStreamReasoning, applyStreamTextDelta, createStreamAssistantBuckets, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, appendTerminalToolResult, } from '../../session/persist-turn-messages.js';
+import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, applyStreamReasoningEvent, applyStreamTextDelta, createStreamAssistantBuckets, createStreamReasoningState, resolvedStreamReasoning, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, appendTerminalToolResult, } from '../../session/persist-turn-messages.js';
 import { collectPublicArtifactLinks, collectPublicArtifactLinksFromEvent, injectPublicArtifactLinks, mergeArtifactLinks, } from '../../tool/inject-public-artifact-links.js';
+import { correctEmployeeVisibleReply, employeeStreamClose, takeEmployeeVisibleEvents, } from '../../tool/mcp-tool-exposure.js';
 import { SessionBudgetExhaustedError } from '../../token/session-budget-checker.js';
 import { TokenBudgetExhaustedError } from '../../token/token-budget-guard.js';
 import { recordTaskTokenUsages } from '../../token/record-task-token-usage.js';
@@ -42,6 +43,7 @@ import { buildHitlWaitedPayload } from '../../graph/hitl/hitl-handler.js';
 import { resolveTraceId } from '../../common/trace-id.js';
 import { DEFAULT_GRAPH_TIMEOUT_MS } from '../../common/types.js';
 import { resolveTaskTimeoutMs } from '../../task/resolve-task-timeout.js';
+import { taskAbortKindOf } from '../../task/task-abort.js';
 import { runWithExecutionTrace } from '../../graph/execution-trace-context.js';
 // ─────────────────────────────────────────────
 // Placeholder Graph DSL (Agent Registry 接入前)
@@ -266,8 +268,8 @@ export class StreamOrchestrator {
         });
         const skillInput = resolveSkillInputFromInvokeInput(req.input);
         const assistantBuckets = createStreamAssistantBuckets();
+        const reasoningState = createStreamReasoningState();
         let toolCallReasoningContent;
-        let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
         const artifactLinks = [];
@@ -325,18 +327,16 @@ export class StreamOrchestrator {
                             arguments: p.arguments ?? {},
                         });
                     }
-                    if (typeof p.reasoningContent === 'string' && p.reasoningContent) {
-                        toolCallReasoningContent = p.reasoningContent;
-                    }
+                    toolCallReasoningContent = resolvedStreamReasoning(reasoningState);
                 }
                 appendTerminalToolResult(runtimeEvent.type, runtimeEvent.payload, toolResults);
                 collectPublicArtifactLinksFromEvent(runtimeEvent.type, runtimeEvent.payload, artifactLinks);
-                const streamedReasoning = extractStreamReasoning(runtimeEvent.type, runtimeEvent.payload);
-                if (streamedReasoning)
-                    assistantReasoningContent = streamedReasoning;
+                applyStreamReasoningEvent(reasoningState, runtimeEvent.type, runtimeEvent.payload);
                 applyStreamTextDelta(assistantBuckets, runtimeEvent.type, runtimeEvent.payload);
-                if (shouldEmitTokenSse(tokenDetail, runtimeEvent.type)) {
-                    emitter.emit(this.runtimeEventToSSE(runtimeEvent, correlationId, taskId));
+                for (const visibleEvent of takeEmployeeVisibleEvents(runtimeEvent.type, runtimeEvent.payload)) {
+                    if (shouldEmitTokenSse(tokenDetail, visibleEvent.type)) {
+                        emitter.emit(this.runtimeEventToSSE({ ...runtimeEvent, type: visibleEvent.type, payload: visibleEvent.payload }, correlationId, taskId));
+                    }
                 }
             }
         }
@@ -369,13 +369,21 @@ export class StreamOrchestrator {
                 this.emitErrorAndClose(emitter, correlationId, taskId, error);
                 return;
             }
-            // ─── 错误处理：Timeout ───
-            if (this.isTimeoutError(error)) {
+            const abortKind = taskAbortKindOf(error, abortSignal);
+            if (abortKind === 'timeout' || abortKind === 'cancelled') {
                 await recordTaskTokenUsages(this.taskService, taskId, this.tokenStatsService.list(taskId));
-                await this.taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+                if (abortKind === 'timeout') {
+                    await this.taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+                }
+                else {
+                    const moved = await this.taskService.tryUpdateStatus(taskId, 'running', 'cancelled');
+                    if (!moved) {
+                        await this.taskService.tryUpdateStatus(taskId, 'waiting_hitl', 'cancelled');
+                    }
+                }
                 emitter.emit(this.buildSSEEvent('task.error', correlationId, taskId, {
-                    code: ErrorCodes.TASK_TIMEOUT,
-                    message: 'Task execution timed out',
+                    code: abortKind === 'timeout' ? ErrorCodes.TASK_TIMEOUT : 'runtime.task.cancelled',
+                    message: abortKind === 'timeout' ? 'Task execution timed out' : 'Task cancelled',
                     recoverable: false,
                 }));
                 emitter.close();
@@ -393,12 +401,14 @@ export class StreamOrchestrator {
         }
         // ─── Step 7: 发送结束事件序列 ───
         const tokenStats = this.tokenStatsService.getTaskStats(taskId);
-        const visible = visibleStreamAssistantText(assistantBuckets);
+        const rawVisible = visibleStreamAssistantText(assistantBuckets);
+        const visible = correctEmployeeVisibleReply(rawVisible, toolResults);
         const links = mergeArtifactLinks(artifactLinks, collectPublicArtifactLinks(toolResults));
         const { injected, suffix } = injectPublicArtifactLinks(visible, links);
-        if (suffix) {
+        const close = employeeStreamClose({ raw: rawVisible, tools: toolResults, suffix });
+        for (const content of close.chunks) {
             emitter.emit(this.buildSSEEvent('response.chunk', correlationId, taskId, {
-                content: suffix,
+                content,
                 format: 'text',
             }));
         }
@@ -437,11 +447,11 @@ export class StreamOrchestrator {
             messages: buildTurnTranscriptFromStreamEvents({
                 pendingToolCalls,
                 toolResults,
-                assistantTexts: suffix ? undefined : streamAssistantTexts(assistantBuckets),
+                assistantTexts: close.persistCorrected ? undefined : streamAssistantTexts(assistantBuckets),
                 assistantText: injected,
                 finishPoints: graph.finishPoints,
                 toolCallReasoningContent,
-                assistantReasoningContent,
+                assistantReasoningContent: resolvedStreamReasoning(reasoningState),
             }),
             assistantTokenCount: tokenStats.total.output ?? 0,
             assistantDurationMs: duration,
@@ -489,7 +499,4 @@ export class StreamOrchestrator {
         }));
         emitter.close();
     }
-    isTimeoutError(error) {
-        return error instanceof Error && /timed out/i.test(error.message);
-    }
 }

package/dist/common/types.d.ts

@@ -58,11 +58,12 @@ export interface RuntimeRunContext {
 /**
  * Task 执行状态（Runtime 内部使用）
  *
- * 状态流转：pending → running → success | failed | timeout | token_exhausted | waiting_hitl
+ * 状态流转：pending → running → success | failed | timeout | token_exhausted | cancelled | waiting_hitl
  *
- * waiting_hitl：等待人工介入确认，可通过 HITL API 恢复为 running
+ * waiting_hitl：等待人工介入确认，可通过 HITL API 恢复为 running。
+ * cancelled：调用方停止这一轮（Hosting `POST /tasks/:id/cancel`），不是超时。
  */
-export type TaskStatus = 'pending' | 'running' | 'waiting_hitl' | 'success' | 'failed' | 'timeout' | 'token_exhausted';
+export type TaskStatus = 'pending' | 'running' | 'waiting_hitl' | 'success' | 'failed' | 'timeout' | 'token_exhausted' | 'cancelled';
 /**
  * Runtime 执行上下文绑定状态（非平台 Session 生命周期）
  *

package/dist/graph/adapters/langgraph.adapter.js

@@ -23,7 +23,8 @@ import { ToolResultInjector } from '../../tool/tool-result-injector.js';
 import { fileArtifactFromToolOutput } from '../../tool/file-artifact.js';
 import { EchoLLMProvider } from '../../providers/echo-llm-provider.js';
 import { ConditionEvaluator } from '../condition-evaluator.js';
-import { SystemPromptBuilder, buildSkillCatalog, buildToolCatalog, loadedToolsToApiTools, resolveLlmPromptInputs, spokenName } from '../../tool/system-prompt-builder.js';
+import { SystemPromptBuilder, buildSkillCatalog, resolveLlmPromptInputs, spokenName } from '../../tool/system-prompt-builder.js';
+import { correctEmployeeVisibleReply, lastAssistantTextSinceLastUser, exposureScopeId, exposedNamesForScope, forcedToolName, holdEmployeeTextForUnnamedMcp, resolveModelToolSurface, shouldDropUnsettledEmployeeText, toolFactsSinceLastUser, } from '../../tool/mcp-tool-exposure.js';
 import { resolveJailFromState, resolveJailRoots } from '../../tool/harness-primitives.js';
 import os from 'node:os';
 import { bindSelectedSkill } from '../nodes/skill-bind-node.js';
@@ -39,6 +40,81 @@ import { recordSkillEntrySpan, skillEntryInvocationFromTool } from './skill-entr
 import { llmSpanInput, llmSpanOutputFromResult, withGraphSpan } from '../trace-span.js';
 import { executionTraceFromState, getExecutionStream, getExecutionTrace, runWithExecutionTrace, } from '../execution-trace-context.js';
 import { isRetryableToolFailure, resolveToolRetryConfig, sleepToolRetry, toolRetryDelayMs, } from '../../tool/tool-retry.js';
+function emitReasoningStartedIfNeeded(live, model, timestamp) {
+    if (live.reasoningStartedThisTurn)
+        return;
+    live.reasoningStartedThisTurn = true;
+    live.iteration += 1;
+    live.sink({
+        type: 'reasoning.started',
+        taskId: undefined,
+        correlationId: undefined,
+        timestamp,
+        payload: {
+            iterationCount: live.iteration,
+            model,
+        },
+    });
+}
+function nodeGraphExtra(live, nodeId) {
+    return {
+        node: nodeId,
+        ...(live.graphId ? { graphId: live.graphId } : {}),
+    };
+}
+function emitLlmStreamDelta(live, nodeId, model, delta) {
+    const timestamp = new Date().toISOString();
+    const extra = nodeGraphExtra(live, nodeId);
+    if (delta.reasoningContent) {
+        emitReasoningStartedIfNeeded(live, model, timestamp);
+        live.sink({
+            type: 'reasoning.chunk',
+            taskId: undefined,
+            correlationId: undefined,
+            timestamp,
+            payload: {
+                content: delta.reasoningContent,
+                index: live.reasoningChunkIndex++,
+                ...extra,
+            },
+        });
+    }
+    if (delta.content) {
+        emitReasoningStartedIfNeeded(live, model, timestamp);
+        live.streamedTextThisTurn = true;
+        live.sink({
+            type: 'response.chunk',
+            taskId: undefined,
+            correlationId: undefined,
+            timestamp,
+            payload: {
+                content: delta.content,
+                index: live.chunkIndex++,
+                ...extra,
+            },
+        });
+    }
+}
+function emitReasoningCompletedIfAny(live, nodeId, next) {
+    if (!live)
+        return;
+    const added = Array.isArray(next.messages) ? next.messages[0] : undefined;
+    const reasoning = added && typeof added === 'object' && typeof added.reasoningContent === 'string'
+        ? added.reasoningContent
+        : '';
+    if (!reasoning)
+        return;
+    live.sink({
+        type: 'reasoning.completed',
+        taskId: undefined,
+        correlationId: undefined,
+        timestamp: new Date().toISOString(),
+        payload: {
+            content: reasoning,
+            ...nodeGraphExtra(live, nodeId),
+        },
+    });
+}
 /**
  * 传给 LangGraph 的 `recursionLimit`：一轮调度（superstep）+1。
  * 同一步里并行的多个节点只 +1。ReAct 的 llm 再 tool 大约 +2。
@@ -342,7 +418,7 @@ export class LangGraphAdapter {
                 });
             }
         }
-        if (progress.status === 'started') {
+        if (progress.status === 'started' && (!progress.quiet || progress.modelOnly)) {
             stream.sink({
                 type: 'tool.called',
                 taskId,
@@ -354,19 +430,22 @@ export class LangGraphAdapter {
                     ...(progress.toolset ? { toolset: progress.toolset } : {}),
                     ...(progress.toolVersion ? { toolVersion: progress.toolVersion } : {}),
                     arguments: progress.arguments ?? {},
+                    ...(progress.modelOnly ? { modelOnly: true } : {}),
                     ...loc,
                 },
             });
         }
         // resolvedPath / skillDirs 只给上面 classifySkillFile；inSkillSubgraph 只给 skill.started 去重。不进对话流。
-        const { resolvedPath: _resolvedPath, skillDirs: _skillDirs, inSkillSubgraph: _inSkillSubgraph, ...progressView } = progress;
-        stream.sink({
-            type: 'tool.progress',
-            taskId,
-            correlationId,
-            timestamp,
-            payload: progressView,
-        });
+        const { resolvedPath: _resolvedPath, skillDirs: _skillDirs, inSkillSubgraph: _inSkillSubgraph, modelOnly: _modelOnly, ...progressView } = progress;
+        if (!progress.quiet) {
+            stream.sink({
+                type: 'tool.progress',
+                taskId,
+                correlationId,
+                timestamp,
+                payload: progressView,
+            });
+        }
         if (progress.status === 'completed') {
             stream.sink({
                 type: 'tool.result',
@@ -381,6 +460,7 @@ export class LangGraphAdapter {
                     success: true,
                     ...(progress.file ? { file: progress.file } : {}),
                     ...(progress.files?.length ? { files: progress.files } : {}),
+                    ...(progress.modelOnly ? { modelOnly: true } : {}),
                     ...loc,
                 },
             });
@@ -397,6 +477,7 @@ export class LangGraphAdapter {
                     ...(progress.toolset ? { toolset: progress.toolset } : {}),
                     error: progress.error ?? 'Unknown error',
                     willRetry: progress.willRetry === true,
+                    ...(progress.modelOnly ? { modelOnly: true } : {}),
                     ...(progress.content ? { content: progress.content } : {}),
                     ...(progress.file ? { file: progress.file } : {}),
                     ...(progress.files?.length ? { files: progress.files } : {}),
@@ -470,6 +551,9 @@ export class LangGraphAdapter {
                 checkpointNs: ephemeral(undefined),
                 skillIsolateContext: ephemeral(undefined),
                 loadedTools: ephemeral(undefined),
+                exposedMcpTools: ephemeral(undefined),
+                exposedMcpScopeId: ephemeral(undefined),
+                sentMcpToolNames: ephemeral(undefined),
                 loadedSkills: ephemeral(undefined),
                 skillDefinitions: ephemeral(undefined),
                 skillInput: ephemeral(undefined),
@@ -596,15 +680,25 @@ export class LangGraphAdapter {
             sink: enqueue,
             eventContext: { taskId: state.taskId, correlationId: state.correlationId },
             chunkIndex: 0,
+            reasoningChunkIndex: 0,
             iteration: 0,
             reasoningStartedThisTurn: false,
             streamedTextThisTurn: false,
+            graphId: graph.id,
         };
         const traceCtx = executionTraceFromState(state);
         const graphSignal = graphAbortSignal(state);
+        let graphIterator;
+        const stopGraphIterator = () => {
+            const iterator = graphIterator;
+            if (!iterator?.return)
+                return;
+            void iterator.return().catch(() => undefined);
+        };
         const onGraphAbort = () => {
             failure = graphSignal ? abortReason(graphSignal) : new Error('aborted');
             finished = true;
+            stopGraphIterator();
             signal();
         };
         graphSignal?.addEventListener('abort', onGraphAbort, { once: true });
@@ -619,9 +713,19 @@ export class LangGraphAdapter {
                 const streamIterator = await withGraphAbort(Promise.resolve(ref.compiled.stream(input, langGraphRunOptions({
                     configurable: this.checkpointConfigurable(state, graph),
                     streamMode: 'updates',
+                    ...(graphSignal ? { signal: graphSignal } : {}),
                 }))), graphSignal);
-                for await (const update of streamIterator) {
-                    for (const event of this.convertUpdatesToEvents(update, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
+                const iterator = streamIterator[Symbol.asyncIterator]();
+                graphIterator = iterator;
+                while (true) {
+                    if (graphSignal?.aborted) {
+                        failure = failure ?? abortReason(graphSignal);
+                        break;
+                    }
+                    const next = await iterator.next();
+                    if (next.done)
+                        break;
+                    for (const event of this.convertUpdatesToEvents(next.value, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
                         enqueue(event);
                     }
                 }
@@ -667,6 +771,7 @@ export class LangGraphAdapter {
                 abortDeadlineMs,
             }, () => ref.compiled.invoke(input, langGraphRunOptions({
                 configurable: this.checkpointConfigurable(state, graph),
+                ...(abortSignal ? { signal: abortSignal } : {}),
             }))), abortSignal);
         }
         catch (error) {
@@ -674,10 +779,8 @@ export class LangGraphAdapter {
         }
         const duration = Date.now() - startTime;
         const messages = Array.isArray(result['messages']) ? result['messages'] : [];
-        const lastMessage = messages[messages.length - 1];
-        const output = typeof lastMessage === 'object' && lastMessage !== null && 'content' in lastMessage
-            ? String(lastMessage.content)
-            : '';
+        const rawOutput = lastAssistantTextSinceLastUser(messages);
+        const output = correctEmployeeVisibleReply(rawOutput, toolFactsSinceLastUser(messages));
         // ── Token 累计：从 __llmTokenUsage 数组累加器读取每轮 LLM 明细 + 汇总
         //    数组由 channel reducer 自动累加（每次 LLM 节点追加一条）。
         const llmUsageArray = Array.isArray(result['__llmTokenUsage'])
@@ -702,6 +805,12 @@ export class LangGraphAdapter {
                     : state.messages,
                 userId: state.userId,
                 loadedTools: state.loadedTools ?? result.loadedTools,
+                exposedMcpTools: Array.isArray(result['exposedMcpTools'])
+                    ? result['exposedMcpTools']
+                    : state.exposedMcpTools,
+                exposedMcpScopeId: typeof result['exposedMcpScopeId'] === 'string'
+                    ? result['exposedMcpScopeId']
+                    : state.exposedMcpScopeId,
                 forceToolServer: state.forceToolServer ?? result.forceToolServer,
                 executionContext: state.executionContext ?? result.executionContext,
             },
@@ -1082,7 +1191,6 @@ export class LangGraphAdapter {
                 console.log(`[LLM-DEBUG] node=${node.id} loadedTools=${toolNames.length}:`, toolNames);
             }
             const catalog = includeSkillCatalog ? buildSkillCatalog(skillDefs) : undefined;
-            const toolCatalog = disableTools ? undefined : buildToolCatalog(loadedTools);
             const jail = resolveJailFromState({
                 agentDir: state['agentDir'],
                 userId,
@@ -1107,11 +1215,18 @@ export class LangGraphAdapter {
                 agentSystemPrompt: state['agentSystemPrompt'],
                 nodePrompt: resolvedPrompt,
             });
+            const surface = resolveModelToolSurface({
+                loadedTools,
+                disableTools,
+                exposedNames: exposedNamesForScope(state['exposedMcpTools'], state['exposedMcpScopeId'], exposureScopeId({ sessionId: state['sessionId'], taskId: state['taskId'] })),
+                forcedName: forcedToolName(baseConfig.toolChoice),
+            });
+            const sentMcpToolNames = surface.apiTools.map((tool) => tool.function.name);
             const assembled = this.systemPromptBuilder.build({
                 agentPrompt: promptInputs.agentPrompt,
                 nodePrompt: promptInputs.nodePrompt,
                 skillCatalog: catalog,
-                toolCatalog,
+                mcpToolIndex: surface.mcpToolIndex,
                 agentName,
                 agentCode,
                 userId,
@@ -1120,7 +1235,10 @@ export class LangGraphAdapter {
                 jailRoots,
                 skillDirs,
             });
-            const apiTools = disableTools ? [] : loadedToolsToApiTools(loadedTools);
+            const apiTools = surface.apiTools;
+            const sentTools = disableTools
+                ? undefined
+                : (apiTools.length > 0 ? apiTools : baseConfig.tools);
             const finalConfig = {
                 ...baseConfig,
                 systemPrompt: assembled.text,
@@ -1132,7 +1250,7 @@ export class LangGraphAdapter {
                     agentCode,
                     correlationId: typeof state['correlationId'] === 'string' ? state['correlationId'] : undefined,
                 },
-                tools: disableTools ? undefined : (apiTools.length > 0 ? apiTools : baseConfig.tools),
+                tools: sentTools,
                 toolChoice: disableTools ? 'none' : baseConfig.toolChoice,
             };
             // 流式旁路：有本次 stream 袋时启用 LLM token 推送；silent 节点不推给用户
@@ -1141,49 +1259,30 @@ export class LangGraphAdapter {
             if (stream) {
                 stream.reasoningStartedThisTurn = false;
                 stream.streamedTextThisTurn = false;
+                stream.reasoningChunkIndex = 0;
             }
+            const holdEmployeeText = holdEmployeeTextForUnnamedMcp(loadedTools, sentMcpToolNames);
+            const heldDeltas = [];
             const llmNode = new LLMNode(node.id, finalConfig, this.llmProvider, enableStream, enableStream
-                ? (text) => {
+                ? (delta) => {
                     const live = getExecutionStream();
-                    if (!live || !text)
+                    if (!live)
+                        return;
+                    if (holdEmployeeText) {
+                        heldDeltas.push(delta);
                         return;
-                    const timestamp = new Date().toISOString();
-                    if (!live.reasoningStartedThisTurn) {
-                        live.reasoningStartedThisTurn = true;
-                        live.iteration += 1;
-                        live.sink({
-                            type: 'reasoning.started',
-                            taskId: undefined,
-                            correlationId: undefined,
-                            timestamp,
-                            payload: {
-                                iterationCount: live.iteration,
-                                model: finalConfig.model,
-                            },
-                        });
                     }
-                    live.streamedTextThisTurn = true;
-                    live.sink({
-                        type: 'response.chunk',
-                        taskId: undefined,
-                        correlationId: undefined,
-                        timestamp,
-                        payload: {
-                            content: text,
-                            index: live.chunkIndex++,
-                            node: node.id,
-                        },
-                    });
+                    emitLlmStreamDelta(live, node.id, finalConfig.model, delta);
                 }
                 : undefined, this.interceptors);
-            const toolsForSpan = disableTools || !loadedTools
-                ? undefined
-                : Object.values(loadedTools).map((t) => ({
-                    name: t.name,
-                    ...(t.manifest.description?.trim()
-                        ? { description: t.manifest.description.trim() }
+            const toolsForSpan = sentTools && sentTools.length > 0
+                ? sentTools.map((tool) => ({
+                    name: tool.function.name,
+                    ...(tool.function.description?.trim()
+                        ? { description: tool.function.description.trim() }
                         : {}),
-                }));
+                }))
+                : undefined;
             // 组装后再 createNode：input 必须是发给模型的 system/tools/messages；completeNode 不能补 input。
             return withGraphSpan(state, {
                 name: node.id,
@@ -1197,9 +1296,31 @@ export class LangGraphAdapter {
                 },
             }, async () => {
                 const next = await llmNode.execute(state);
+                let dropEmployeeText = false;
+                if (enableStream && holdEmployeeText) {
+                    const added = Array.isArray(next.messages) ? next.messages[0] : undefined;
+                    const calls = added && typeof added === 'object' && Array.isArray(added.toolCalls)
+                        ? added.toolCalls
+                        : [];
+                    dropEmployeeText = shouldDropUnsettledEmployeeText(calls, loadedTools, sentMcpToolNames);
+                    const live = getExecutionStream();
+                    if (dropEmployeeText) {
+                        // 挡住 updates 再把这段正文补发成 response.chunk。
+                        if (live)
+                            live.streamedTextThisTurn = true;
+                    }
+                    else if (live) {
+                        for (const delta of heldDeltas)
+                            emitLlmStreamDelta(live, node.id, finalConfig.model, delta);
+                    }
+                }
+                if (enableStream && !dropEmployeeText) {
+                    emitReasoningCompletedIfAny(getExecutionStream(), node.id, next);
+                }
                 const hydratedUpdate = loadedTools && loadedTools !== loadedToolsBase ? { loadedTools } : {};
+                const sentUpdate = { sentMcpToolNames };
                 if (!silent)
-                    return { ...next, ...hydratedUpdate };
+                    return { ...next, ...hydratedUpdate, ...sentUpdate };
                 const added = Array.isArray(next.messages) ? next.messages[0] : undefined;
                 const raw = added && typeof added === 'object' && typeof added.content === 'string'
                     ? added.content
@@ -1209,6 +1330,7 @@ export class LangGraphAdapter {
                     messages: [],
                     silentOutput: raw,
                     ...hydratedUpdate,
+                    ...sentUpdate,
                 };
             }, { outputFrom: llmSpanOutputFromResult });
         };
@@ -1542,23 +1664,17 @@ export class LangGraphAdapter {
                         continue;
                     }
                     const hasText = typeof msg.content === 'string' && msg.content.trim().length > 0;
-                    if ((hasText || msg.reasoningContent) &&
-                        (!streamedTextThisTurn || msg.reasoningContent)) {
-                        if (streamedTextThisTurn && !msg.reasoningContent)
-                            continue;
+                    if (hasText && !streamedTextThisTurn) {
                         yield {
                             type: 'response.chunk',
                             taskId: undefined,
                             correlationId: undefined,
                             timestamp,
                             payload: {
-                                content: streamedTextThisTurn ? '' : (msg.content ?? ''),
+                                content: msg.content ?? '',
                                 index: nextChunkIndex(),
                                 node: nodeId,
                                 graphId,
-                                ...(msg.reasoningContent
-                                    ? { reasoningContent: msg.reasoningContent }
-                                    : {}),
                             },
                         };
                     }
@@ -1569,26 +1685,8 @@ export class LangGraphAdapter {
                         continue;
                     if (subgraphNodeIds.has(nodeId) && streamedTextThisTurn)
                         continue;
-                    // 已通过 onChunk 推送过 token，避免整段重复
-                    if (streamedTextThisTurn) {
-                        // token 已流过：仍补发一条带 reasoning 的标记 chunk（空 content），供落库回传
-                        if (msg.reasoningContent) {
-                            yield {
-                                type: 'response.chunk',
-                                taskId: undefined,
-                                correlationId: undefined,
-                                timestamp,
-                                payload: {
-                                    content: '',
-                                    index: nextChunkIndex(),
-                                    node: nodeId,
-                                    graphId,
-                                    reasoningContent: msg.reasoningContent,
-                                },
-                            };
-                        }
+                    if (streamedTextThisTurn)
                         continue;
-                    }
                     yield {
                         type: 'response.chunk',
                         taskId: undefined,
@@ -1599,9 +1697,6 @@ export class LangGraphAdapter {
                             index: nextChunkIndex(),
                             node: nodeId,
                             graphId,
-                            ...(msg.reasoningContent
-                                ? { reasoningContent: msg.reasoningContent }
-                                : {}),
                         },
                     };
                     continue;