@gt-fe/eap-runtime 0.0.18 → 0.0.20

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

@@ -18,6 +18,7 @@ import { randomUUID } from 'node:crypto';
 import { buildHitlWaitingTaskOutput, buildTurnGraphMessages, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, } from '../../session/persist-turn-messages.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';
 import { resolveExecutionContext } from '../../governance/governance-client.js';
 import { resolveSkillInputFromInvokeInput } from '../../registry/skill-io-guard.js';
 import { resolveAgentSystemPromptFromLoader } from '../../registry/graph-loader.js';
@@ -310,24 +311,17 @@ export class InvokeOrchestrator {
         };
         // 将 Graph 层面的 token 消耗记录到 Task（按节点明细逐个记录，便于审计）
         if (graphUsage.perNode && graphUsage.perNode.length > 0) {
-            for (const u of graphUsage.perNode) {
-                await this.taskService.recordTokenUsage(task.id, {
-                    nodeId: u.nodeId,
-                    model: u.model,
-                    inputTokens: u.inputTokens,
-                    outputTokens: u.outputTokens,
-                    costEstimate: 0,
-                });
-            }
+            await recordTaskTokenUsages(this.taskService, task.id, graphUsage.perNode);
         }
         else if (graphUsage.total > 0) {
-            await this.taskService.recordTokenUsage(task.id, {
-                nodeId: 'graph',
-                model: 'unknown',
-                inputTokens: graphUsage.input,
-                outputTokens: graphUsage.output,
-                costEstimate: 0,
-            });
+            await recordTaskTokenUsages(this.taskService, task.id, [
+                {
+                    nodeId: 'graph',
+                    model: 'unknown',
+                    inputTokens: graphUsage.input,
+                    outputTokens: graphUsage.output,
+                },
+            ]);
         }
         // ─── Step 7: 完成 Task (running → success) ───
         await this.taskService.updateStatus(task.id, 'success', graphResult.output);

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

@@ -22,6 +22,7 @@
 import { buildHitlWaitingTaskOutput, buildTurnGraphMessages, buildTurnTranscriptFromStreamEvents, extractStreamReasoning, extractStreamTextDelta, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, } from '../../session/persist-turn-messages.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';
 import { SSEEmitter } from '../../sse/sse-emitter.js';
 import { resolveExecutionContext } from '../../governance/governance-client.js';
 import { resolveSkillInputFromInvokeInput } from '../../registry/skill-io-guard.js';
@@ -303,6 +304,7 @@ export class StreamOrchestrator {
         catch (error) {
             const hitlPaused = unwrapHitlPaused(error);
             if (hitlPaused) {
+                await recordTaskTokenUsages(this.taskService, taskId, this.tokenStatsService.list(taskId));
                 await this.taskService.updateStatus(taskId, 'waiting_hitl', buildHitlWaitingTaskOutput({
                     threadId: hitlPaused.threadId,
                     question: hitlPaused.question,
@@ -370,6 +372,7 @@ export class StreamOrchestrator {
             taskId,
             duration,
         }));
+        await recordTaskTokenUsages(this.taskService, taskId, this.tokenStatsService.list(taskId));
         // Task 状态流转 → success
         await this.taskService.updateStatus(taskId, 'success');
         // ─── Step 8b: 持久化 transcript（与 invoke 同序）───

package/dist/checkpoint/checkpoint-ref-notify.js

@@ -3,6 +3,7 @@
  * 无 traceId 或 spanId 则跳过；回调失败不抛。
  * collector 不得写入持久化正文。
  */
+import { getExecutionTrace } from '../graph/execution-trace-context.js';
 function pickString(...values) {
     for (const value of values) {
         if (typeof value === 'string' && value.trim())
@@ -34,10 +35,10 @@ export async function notifyCheckpointRef(data, collectorOverride) {
         ? data.engineSnapshot.channel_values
         : {};
     const state = (data.state ?? {});
-    const collector = (collectorOverride ??
-        channels['traceCollector'] ??
-        state['traceCollector']);
-    const traceId = pickString(state['traceId'], channels['traceId']);
+    const store = getExecutionTrace();
+    // collector 是活对象，不从 Checkpoint 正文读（落盘已剥掉）。
+    const collector = (collectorOverride ?? store?.collector);
+    const traceId = pickString(store?.traceId, state['traceId'], channels['traceId']);
     const spanId = pickString(state['lastSpanId'], channels['lastSpanId']);
     if (!collector?.recordCheckpointRef || !traceId || !spanId)
         return;

package/dist/contracts/index.d.ts

@@ -7,5 +7,5 @@
  * - LLM 调用：由模型路由模块实现
  * - 存储接口：由各存储后端实现
  */
-export type { ITraceCollector, TraceEvent, TraceSession, } from './trace-collector.js';
+export type { ITraceCollector, CompleteNodeParams, TraceEvent, TraceSession, } from './trace-collector.js';
 export type { IPermissionChecker } from './permission-checker.js';

package/dist/contracts/trace-collector.d.ts

@@ -85,6 +85,8 @@ export interface ExecutionNodeEvent {
     type: 'start' | 'llm' | 'tool' | 'skill' | 'condition' | 'hitl' | 'end';
     /** 工具运行环境（type=tool） */
     toolRuntime?: 'local' | 'server' | 'both';
+    /** skill/tool 包版本；与 TraceClient RecordSpanParams.version 同义 */
+    version?: string;
     /** Agent 对外主键 */
     agentCode?: string;
     /** 输入数据 */
@@ -92,6 +94,19 @@ export interface ExecutionNodeEvent {
     /** 扩展元数据（如 skillId） */
     metadata?: Record<string, unknown>;
 }
+/**
+ * 完成执行节点参数。llm Span 的 model / token 与 stats.node_token_usage 同源。
+ */
+export interface CompleteNodeParams {
+    status: 'completed' | 'failed';
+    output?: unknown;
+    error?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    /** llm Span：实际模型标识；与 NodeTokenUsage.model 相同 */
+    model?: string;
+}
 /**
  * 链路事件
  *
@@ -176,14 +191,7 @@ export interface ITraceCollector {
      * @param nodeId - 节点 ID
      * @param params - 完成参数
      */
-    completeNode(nodeId: string, params: {
-        status: 'completed' | 'failed';
-        output?: unknown;
-        error?: string;
-        inputTokens?: number;
-        outputTokens?: number;
-        totalTokens?: number;
-    }): Promise<void>;
+    completeNode(nodeId: string, params: CompleteNodeParams): Promise<void>;
     /**
      * Checkpoint 已落盘后的引用回调。Hosting 适配 TraceClient.recordCheckpointRef。
      * Runtime 仅在同时有 traceId 与 spanId 时调用；不传 graph state 正文。

package/dist/graph/adapters/langgraph.adapter.d.ts

@@ -35,13 +35,6 @@ export declare class LangGraphAdapter implements IStateGraphEngine {
     private readonly conditionEvaluator;
     private readonly systemPromptBuilder;
     private readonly skillAuditRecorder;
-    /** 流式旁路：LLM token / Tool 执行事件在节点执行中实时入队 */
-    private streamSink;
-    private streamEventContext;
-    private streamChunkIndex;
-    private streamIteration;
-    private reasoningStartedThisTurn;
-    private streamedTextThisTurn;
     /**
      * @param checkpointSaver - 可选的 ICheckpointSaver
      * @param llmProvider - LLM 调用提供者，默认 EchoLLMProvider
@@ -56,7 +49,7 @@ export declare class LangGraphAdapter implements IStateGraphEngine {
     registerConditionEvaluator(name: string, fn: ConditionEvaluatorFn): void;
     /**
      * 节点旁路推送 RuntimeEvent（子图 Skill 生命周期、Tool 执行）。
-     * 无 streamSink 时为空操作（纯 invoke）。
+     * 无本次执行流式袋时为空操作（纯 invoke）。
      */
     emitStreamEvent(event: RuntimeEvent): void;
     /**
@@ -67,14 +60,14 @@ export declare class LangGraphAdapter implements IStateGraphEngine {
      * Tool 节点执行旁路：started → tool.called + tool.progress；
      * completed/error → 对应终态 + tool.progress。同一 toolCallId。
      * 读 SKILL.md / 技能包内文件：成功后再发 skill.loaded / skill.resource_read，同时保留 tool.*。
+     * 读 SKILL.md 另发 skill.started / skill.completed（与 Trace type=skill Span 对齐）；子图内不重复。
      */
     private emitToolExecutionEvents;
     /**
      * 解析 GraphDSL 并构建可执行图
      *
-     * **Request Isolation**: 每次调用都创建全新的 StateGraph 实例并编译，
-     * 确保并发请求之间无共享可变状态。Adapter 自身仅持有 readonly 配置（checkpointer、subGraphCompiler），
-     * 不缓存任何编译产物或运行时状态。
+     * **Request Isolation**: 每次调用都创建全新的 StateGraph 实例并编译。
+     * 一次执行的 collector / 流式袋跟这次调用走，不挂 Adapter 字段。
      *
      * 流程：
      * 1. 创建 StateGraph 实例（配置 channels）
@@ -89,7 +82,7 @@ export declare class LangGraphAdapter implements IStateGraphEngine {
      * 流式驱动图执行，逐步 yield RuntimeEvent
      *
      * - LangGraph `streamMode: "updates"`：节点完成后产出 response.chunk / stats 等
-     * - LLM token / Tool 执行事件：经 streamSink 在节点执行中实时旁路入队
+     * - LLM token / Tool 执行事件：经本次执行流式袋在节点执行中实时旁路入队
      * （当前 @langchain/langgraph@0.2 无 messages mode，故用 LLMNode.onChunk 模拟）
      */
     stream(graph: ExecutableGraph, state: GraphState): AsyncIterableIterator<RuntimeEvent>;

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

@@ -30,7 +30,9 @@ import { AppError, ErrorCodes } from '@gt-fe/eap-contracts';
 import { pickContextFields } from '../../token/context-window.js';
 import { isHitlDecision, lastAssistantHasUnansweredToolCalls } from '../hitl/hitl-handler.js';
 import { classifySkillRead } from './skill-read.js';
+import { skillEntryInvocationFromTool } from './skill-entry-span.js';
 import { withGraphSpan } from '../trace-span.js';
+import { executionTraceFromState, getExecutionStream, runWithExecutionTrace, } from '../execution-trace-context.js';
 /** 图未写 `config.maxIterations` 时的 recursionLimit。`agent ⇄ tools` 一圈约 2，50 ≈ 24 次工具往返。 */
 export const DEFAULT_GRAPH_RECURSION_LIMIT = 50;
 /**
@@ -68,13 +70,6 @@ export class LangGraphAdapter {
     conditionEvaluator;
     systemPromptBuilder;
     skillAuditRecorder;
-    /** 流式旁路：LLM token / Tool 执行事件在节点执行中实时入队 */
-    streamSink = null;
-    streamEventContext = {};
-    streamChunkIndex = 0;
-    streamIteration = 0;
-    reasoningStartedThisTurn = false;
-    streamedTextThisTurn = false;
     /**
      * @param checkpointSaver - 可选的 ICheckpointSaver
      * @param llmProvider - LLM 调用提供者，默认 EchoLLMProvider
@@ -140,43 +135,51 @@ export class LangGraphAdapter {
     }
     /**
      * 节点旁路推送 RuntimeEvent（子图 Skill 生命周期、Tool 执行）。
-     * 无 streamSink 时为空操作（纯 invoke）。
+     * 无本次执行流式袋时为空操作（纯 invoke）。
      */
     emitStreamEvent(event) {
-        if (!this.streamSink)
+        const stream = getExecutionStream();
+        if (!stream)
             return;
-        this.streamSink({
+        stream.sink({
             ...event,
-            taskId: event.taskId ?? this.streamEventContext.taskId,
-            correlationId: event.correlationId ?? this.streamEventContext.correlationId,
+            taskId: event.taskId ?? stream.eventContext.taskId,
+            correlationId: event.correlationId ?? stream.eventContext.correlationId,
         });
     }
     /**
      * 子图 LLM 可清零流式标志；结束后保留「已经 stream 过」以免父图 convertUpdates 再发一遍正文。
      */
     async runIsolatedLlmStreamFlags(work) {
-        const savedStreamed = this.streamedTextThisTurn;
-        const savedReasoning = this.reasoningStartedThisTurn;
-        this.reasoningStartedThisTurn = false;
-        this.streamedTextThisTurn = false;
+        const stream = getExecutionStream();
+        const savedStreamed = stream?.streamedTextThisTurn ?? false;
+        const savedReasoning = stream?.reasoningStartedThisTurn ?? false;
+        if (stream) {
+            stream.reasoningStartedThisTurn = false;
+            stream.streamedTextThisTurn = false;
+        }
         try {
             return await work();
         }
         finally {
-            this.streamedTextThisTurn = savedStreamed || this.streamedTextThisTurn;
-            this.reasoningStartedThisTurn = savedReasoning || this.reasoningStartedThisTurn;
+            if (stream) {
+                stream.streamedTextThisTurn = savedStreamed || stream.streamedTextThisTurn;
+                stream.reasoningStartedThisTurn = savedReasoning || stream.reasoningStartedThisTurn;
+            }
         }
     }
     /**
      * Tool 节点执行旁路：started → tool.called + tool.progress；
      * completed/error → 对应终态 + tool.progress。同一 toolCallId。
      * 读 SKILL.md / 技能包内文件：成功后再发 skill.loaded / skill.resource_read，同时保留 tool.*。
+     * 读 SKILL.md 另发 skill.started / skill.completed（与 Trace type=skill Span 对齐）；子图内不重复。
      */
     emitToolExecutionEvents(progress) {
-        if (!this.streamSink)
+        const stream = getExecutionStream();
+        if (!stream)
             return;
         const timestamp = new Date().toISOString();
-        const { taskId, correlationId } = this.streamEventContext;
+        const { taskId, correlationId } = stream.eventContext;
         const loc = {
             ...(progress.node ? { node: progress.node } : {}),
             ...(progress.skillId ? { skillId: progress.skillId } : {}),
@@ -184,19 +187,51 @@ export class LangGraphAdapter {
         const skillRead = classifySkillRead(progress.toolName, progress.arguments, progress.skillDirs);
         if (skillRead && progress.status === 'completed') {
             if (skillRead.kind === 'loaded') {
-                this.streamSink({
+                const skillId = skillRead.skillId || loc.skillId || skillRead.path;
+                stream.sink({
                     type: 'skill.loaded',
                     taskId,
                     correlationId,
                     timestamp,
                     payload: {
-                        skillId: skillRead.skillId || loc.skillId || skillRead.path,
+                        skillId,
                         path: skillRead.path,
                     },
                 });
+                const catalogSkill = skillEntryInvocationFromTool({
+                    toolName: progress.toolName,
+                    arguments: progress.arguments,
+                    skillDirs: progress.skillDirs,
+                    alreadyInSkillSpan: progress.inSkillSubgraph,
+                });
+                if (catalogSkill) {
+                    stream.sink({
+                        type: 'skill.started',
+                        taskId,
+                        correlationId,
+                        timestamp,
+                        payload: {
+                            skillId: catalogSkill.skillId,
+                            skillName: progress.skillName || catalogSkill.skillId,
+                            path: catalogSkill.path,
+                            ...(progress.skillSpace ? { skillSpace: progress.skillSpace } : {}),
+                            ...(progress.skillVersion ? { skillVersion: progress.skillVersion } : {}),
+                        },
+                    });
+                    stream.sink({
+                        type: 'skill.completed',
+                        taskId,
+                        correlationId,
+                        timestamp,
+                        payload: {
+                            skillId: catalogSkill.skillId,
+                            skillName: catalogSkill.skillId,
+                        },
+                    });
+                }
             }
             else {
-                this.streamSink({
+                stream.sink({
                     type: 'skill.resource_read',
                     taskId,
                     correlationId,
@@ -206,7 +241,7 @@ export class LangGraphAdapter {
             }
         }
         if (progress.status === 'started') {
-            this.streamSink({
+            stream.sink({
                 type: 'tool.called',
                 taskId,
                 correlationId,
@@ -215,12 +250,13 @@ export class LangGraphAdapter {
                     toolCallId: progress.toolCallId,
                     toolName: progress.toolName,
                     ...(progress.toolset ? { toolset: progress.toolset } : {}),
+                    ...(progress.toolVersion ? { toolVersion: progress.toolVersion } : {}),
                     arguments: progress.arguments ?? {},
                     ...loc,
                 },
             });
         }
-        this.streamSink({
+        stream.sink({
             type: 'tool.progress',
             taskId,
             correlationId,
@@ -228,7 +264,7 @@ export class LangGraphAdapter {
             payload: { ...progress },
         });
         if (progress.status === 'completed') {
-            this.streamSink({
+            stream.sink({
                 type: 'tool.result',
                 taskId,
                 correlationId,
@@ -244,7 +280,7 @@ export class LangGraphAdapter {
             });
         }
         else if (progress.status === 'error') {
-            this.streamSink({
+            stream.sink({
                 type: 'tool.error',
                 taskId,
                 correlationId,
@@ -263,9 +299,8 @@ export class LangGraphAdapter {
     /**
      * 解析 GraphDSL 并构建可执行图
      *
-     * **Request Isolation**: 每次调用都创建全新的 StateGraph 实例并编译，
-     * 确保并发请求之间无共享可变状态。Adapter 自身仅持有 readonly 配置（checkpointer、subGraphCompiler），
-     * 不缓存任何编译产物或运行时状态。
+     * **Request Isolation**: 每次调用都创建全新的 StateGraph 实例并编译。
+     * 一次执行的 collector / 流式袋跟这次调用走，不挂 Adapter 字段。
      *
      * 流程：
      * 1. 创建 StateGraph 实例（配置 channels）
@@ -410,7 +445,7 @@ export class LangGraphAdapter {
      * 流式驱动图执行，逐步 yield RuntimeEvent
      *
      * - LangGraph `streamMode: "updates"`：节点完成后产出 response.chunk / stats 等
-     * - LLM token / Tool 执行事件：经 streamSink 在节点执行中实时旁路入队
+     * - LLM token / Tool 执行事件：经本次执行流式袋在节点执行中实时旁路入队
      * （当前 @langchain/langgraph@0.2 无 messages mode，故用 LLMNode.onChunk 模拟）
      */
     async *stream(graph, state) {
@@ -434,13 +469,17 @@ export class LangGraphAdapter {
             });
             signal();
         };
-        this.streamSink = enqueue;
-        this.streamEventContext = { taskId: state.taskId, correlationId: state.correlationId };
-        this.streamChunkIndex = 0;
-        this.streamIteration = 0;
-        this.reasoningStartedThisTurn = false;
-        this.streamedTextThisTurn = false;
-        const producer = (async () => {
+        // 流式袋跟这次调用走，不挂 this：并行 stream 各写各的 queue。
+        const streamBag = {
+            sink: enqueue,
+            eventContext: { taskId: state.taskId, correlationId: state.correlationId },
+            chunkIndex: 0,
+            iteration: 0,
+            reasoningStartedThisTurn: false,
+            streamedTextThisTurn: false,
+        };
+        const traceCtx = executionTraceFromState(state);
+        const producer = runWithExecutionTrace({ ...traceCtx, stream: streamBag }, () => (async () => {
             try {
                 const streamIterator = await ref.compiled.stream(input, langGraphRunOptions(ref.dsl, {
                     configurable: {
@@ -453,7 +492,7 @@ export class LangGraphAdapter {
                     streamMode: 'updates',
                 }));
                 for await (const update of streamIterator) {
-                    for (const event of this.convertUpdatesToEvents(update, graph.id, () => this.streamChunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
+                    for (const event of this.convertUpdatesToEvents(update, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
                         enqueue(event);
                     }
                 }
@@ -463,11 +502,9 @@ export class LangGraphAdapter {
             }
             finally {
                 finished = true;
-                this.streamSink = null;
-                this.streamEventContext = {};
                 signal();
             }
-        })();
+        })());
         while (!finished || queue.length > 0) {
             if (queue.length === 0) {
                 await new Promise((resolve) => {
@@ -488,7 +525,9 @@ export class LangGraphAdapter {
         const ref = this.getCompiledRef(graph);
         const input = this.graphStateToLangGraphInput(state);
         const startTime = Date.now();
-        const result = await ref.compiled.invoke(input, langGraphRunOptions(ref.dsl, {
+        const traceCtx = executionTraceFromState(state);
+        // 只补 collector/traceId。子图套娃时外层 stream 袋经 ?? 保留。
+        const result = await runWithExecutionTrace(traceCtx, () => ref.compiled.invoke(input, langGraphRunOptions(ref.dsl, {
             configurable: {
                 thread_id: resolveCheckpointThreadId({
                     sessionId: typeof state.sessionId === 'string' ? state.sessionId : undefined,
@@ -496,7 +535,7 @@ export class LangGraphAdapter {
                     graphId: graph.id,
                 }),
             },
-        }));
+        })));
         const duration = Date.now() - startTime;
         const messages = Array.isArray(result['messages']) ? result['messages'] : [];
         const lastMessage = messages[messages.length - 1];
@@ -661,15 +700,16 @@ export class LangGraphAdapter {
                     },
                 });
             }
-            if (patch.skillRoute === 'clarify' && this.streamSink) {
+            const stream = getExecutionStream();
+            if (patch.skillRoute === 'clarify' && stream) {
                 const question = patch.messages.at(-1)?.content;
                 if (typeof question === 'string' && question.trim()) {
-                    this.streamSink({
+                    stream.sink({
                         type: 'response.chunk',
                         taskId: undefined,
                         correlationId: undefined,
                         timestamp: new Date().toISOString(),
-                        payload: { content: question, index: this.streamChunkIndex++, node: node.id },
+                        payload: { content: question, index: stream.chunkIndex++, node: node.id },
                     });
                 }
             }
@@ -892,38 +932,42 @@ export class LangGraphAdapter {
                     tools: disableTools ? undefined : (apiTools.length > 0 ? apiTools : baseConfig.tools),
                     toolChoice: disableTools ? 'none' : baseConfig.toolChoice,
                 };
-                // 流式旁路：有 streamSink 时启用 LLM token 推送；silent 节点不推给用户
-                const enableStream = Boolean(this.streamSink) && !silent;
-                this.reasoningStartedThisTurn = false;
-                this.streamedTextThisTurn = false;
+                // 流式旁路：有本次 stream 袋时启用 LLM token 推送；silent 节点不推给用户
+                const stream = getExecutionStream();
+                const enableStream = Boolean(stream) && !silent;
+                if (stream) {
+                    stream.reasoningStartedThisTurn = false;
+                    stream.streamedTextThisTurn = false;
+                }
                 const llmNode = new LLMNode(node.id, finalConfig, this.llmProvider, enableStream, enableStream
                     ? (text) => {
-                        if (!this.streamSink || !text)
+                        const live = getExecutionStream();
+                        if (!live || !text)
                             return;
                         const timestamp = new Date().toISOString();
-                        if (!this.reasoningStartedThisTurn) {
-                            this.reasoningStartedThisTurn = true;
-                            this.streamIteration += 1;
-                            this.streamSink({
+                        if (!live.reasoningStartedThisTurn) {
+                            live.reasoningStartedThisTurn = true;
+                            live.iteration += 1;
+                            live.sink({
                                 type: 'reasoning.started',
                                 taskId: undefined,
                                 correlationId: undefined,
                                 timestamp,
                                 payload: {
-                                    iterationCount: this.streamIteration,
+                                    iterationCount: live.iteration,
                                     model: finalConfig.model,
                                 },
                             });
                         }
-                        this.streamedTextThisTurn = true;
-                        this.streamSink({
+                        live.streamedTextThisTurn = true;
+                        live.sink({
                             type: 'response.chunk',
                             taskId: undefined,
                             correlationId: undefined,
                             timestamp,
                             payload: {
                                 content: text,
-                                index: this.streamChunkIndex++,
+                                index: live.chunkIndex++,
                                 node: node.id,
                             },
                         });
@@ -1229,6 +1273,7 @@ export class LangGraphAdapter {
      */
     *convertUpdatesToEvents(update, graphId, nextChunkIndex, silentNodeIds = new Set(), subgraphNodeIds = new Set()) {
         const timestamp = new Date().toISOString();
+        const streamedTextThisTurn = Boolean(getExecutionStream()?.streamedTextThisTurn);
         const entries = this.normalizeStreamUpdates(update);
         for (const { nodeId, data } of entries) {
             // LLM 节点 token 明细（写入 __llmTokenUsage）→ stats.node_token_usage
@@ -1266,8 +1311,8 @@ export class LangGraphAdapter {
                     }
                     const hasText = typeof msg.content === 'string' && msg.content.trim().length > 0;
                     if ((hasText || msg.reasoningContent) &&
-                        (!this.streamedTextThisTurn || msg.reasoningContent)) {
-                        if (this.streamedTextThisTurn && !msg.reasoningContent)
+                        (!streamedTextThisTurn || msg.reasoningContent)) {
+                        if (streamedTextThisTurn && !msg.reasoningContent)
                             continue;
                         yield {
                             type: 'response.chunk',
@@ -1275,7 +1320,7 @@ export class LangGraphAdapter {
                             correlationId: undefined,
                             timestamp,
                             payload: {
-                                content: this.streamedTextThisTurn ? '' : (msg.content ?? ''),
+                                content: streamedTextThisTurn ? '' : (msg.content ?? ''),
                                 index: nextChunkIndex(),
                                 node: nodeId,
                                 graphId,
@@ -1291,7 +1336,7 @@ export class LangGraphAdapter {
                     if (silentNodeIds.has(nodeId) || subgraphNodeIds.has(nodeId))
                         continue;
                     // 已通过 onChunk 推送过 token，避免整段重复
-                    if (this.streamedTextThisTurn) {
+                    if (streamedTextThisTurn) {
                         // token 已流过：仍补发一条带 reasoning 的标记 chunk（空 content），供落库回传
                         if (msg.reasoningContent) {
                             yield {

package/dist/graph/adapters/skill-entry-span.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 成功读 SKILL.md 时写 Trace `type=skill` Span。
+ *
+ * 假设：Skill 被调用 = 一次成功读取技能包入口（SKILL.md），
+ * 与子图激活走同一 collector.createNode({ type: 'skill' })。
+ * 声明版本在 createNode.version；skillSpace 只在 input。
+ * 子图已有 skillSpanId 时不记第二条。write_file / 包内附属读 / 失败读不是调用。
+ */
+import { type SkillDirRef, type SkillSpace } from './skill-read.js';
+export interface SkillTraceIdentity {
+    skillId: string;
+    skillName?: string;
+    skillVersion?: string;
+    skillSpace?: SkillSpace;
+}
+export declare function skillTraceIdentity(state: Record<string, unknown>, skillId: string, fallbackPath?: string): SkillTraceIdentity;
+export declare function skillSpanFields(identity: SkillTraceIdentity, extra?: {
+    path?: string;
+    source?: string;
+}): {
+    version?: string;
+    input: Record<string, unknown>;
+};
+export declare function skillEntryInvocationFromTool(input: {
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    skillDirs?: SkillDirRef[];
+    alreadyInSkillSpan?: boolean;
+}): {
+    skillId: string;
+    path: string;
+} | null;
+export declare function recordSkillEntrySpan(state: Record<string, unknown>, input: {
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    skillDirs?: SkillDirRef[];
+}): Promise<void>;