@gt-fe/eap-runtime 0.0.18 → 0.0.20

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

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

package/dist/graph/trace-span.js

@@ -1,10 +1,10 @@
 /**
  * Graph 节点 Span 辅助：createNode / completeNode 失败不挡主路径。
  */
-import { resolveTraceId } from '../common/trace-id.js';
+import { resolveExecutionTrace, warnTraceSpanFailure, } from './execution-trace-context.js';
 export async function startGraphSpan(state, input) {
-    const collector = state['traceCollector'];
-    const traceId = resolveTraceId(state);
+    // collector 只从这次调用链取；state 只用来拼 parent/task 元数据。
+    const { collector, traceId } = resolveExecutionTrace(state);
     if (!collector || !traceId)
         return undefined;
     const parentNodeId = input.parentSpanId ??
@@ -27,19 +27,20 @@ export async function startGraphSpan(state, input) {
             },
         });
     }
-    catch {
+    catch (err) {
+        warnTraceSpanFailure('createNode', { type: input.type, name: input.name, traceId }, err);
         return undefined;
     }
 }
 export async function completeGraphSpan(state, spanId, params, collectorOverride) {
-    const collector = collectorOverride ?? state['traceCollector'];
+    const collector = collectorOverride ?? resolveExecutionTrace(state).collector;
     if (!collector?.completeNode || !spanId)
         return;
     try {
         await collector.completeNode(spanId, params);
     }
-    catch {
-        // Trace 失败不影响主路径
+    catch (err) {
+        warnTraceSpanFailure('completeNode', { spanId, traceId: resolveExecutionTrace(state).traceId }, err);
     }
 }
 export async function withGraphSpan(state, spec, run) {
@@ -56,6 +57,7 @@ export async function withGraphSpan(state, spec, run) {
             totalTokens: usage?.inputTokens != null || usage?.outputTokens != null
                 ? (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0)
                 : undefined,
+            ...(typeof usage?.model === 'string' && usage.model ? { model: usage.model } : {}),
         });
         return spanId ? { ...result, lastSpanId: spanId } : result;
     }

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export * from './memory/index.js';
 export * from './common/index.js';
 export * from './registry/index.js';
 export * from './providers/index.js';
-export type { ITraceCollector, TraceEvent, TraceSession, ExecutionFlowEvent, ExecutionNodeEvent, TraceLinkEvent, TraceLinkNodeEvent, } from './contracts/trace-collector.js';
+export type { ITraceCollector, CompleteNodeParams, TraceEvent, TraceSession, ExecutionFlowEvent, ExecutionNodeEvent, TraceLinkEvent, TraceLinkNodeEvent, } from './contracts/trace-collector.js';
 export type { ExecutionContext, CallerType, GovernancePermissionCheckParams, GovernancePermissionCheckResult, PermissionDenyReason, } from '@gt-fe/eap-contracts';
 export { HttpGovernanceClient, AllowAllGovernanceClient, resolveExecutionContext, assertToolPermission, assertSkillPermission, permissionMessage, PermissionDeniedError, GovernanceUnavailableError, } from './governance/index.js';
 export type { IGovernanceClient } from './governance/index.js';

package/dist/runtime/agent-runtime.js

@@ -17,6 +17,7 @@ import { AppError, ErrorCodes } from '@gt-fe/eap-contracts';
 import { resolveExecutionContext } from '../governance/governance-client.js';
 import { resolveAgentCode } from '../common/agent-code.js';
 import { resolveTraceId } from '../common/trace-id.js';
+import { collectStreamNodeTokenUsage, recordTaskTokenUsages, } from '../token/record-task-token-usage.js';
 import { resolveSkillInputFromInvokeInput } from '../registry/skill-io-guard.js';
 const HITL_TERMINAL_STATUSES = [
     'success',
@@ -286,6 +287,7 @@ export class AgentRuntime {
         let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
+        const nodeTokenUsages = [];
         try {
             for await (const runtimeEvent of this.deps.graphEngine.stream(graph, {
                 messages,
@@ -345,8 +347,10 @@ export class AgentRuntime {
                         assistantText += delta;
                     }
                 }
+                collectStreamNodeTokenUsage(runtimeEvent, nodeTokenUsages);
                 yield this.runtimeEventToSSE(runtimeEvent, correlationId, task.id);
             }
+            await recordTaskTokenUsages(this.deps.taskService, task.id, nodeTokenUsages);
             await this.deps.taskService.updateStatus(task.id, 'success');
             await persistTurnTranscript(this.deps.messageService, {
                 sessionId,
@@ -368,6 +372,7 @@ export class AgentRuntime {
         catch (err) {
             const hitlPaused = unwrapHitlPaused(err);
             if (hitlPaused) {
+                await recordTaskTokenUsages(this.deps.taskService, task.id, nodeTokenUsages);
                 await this.deps.taskService.updateStatus(task.id, 'waiting_hitl', buildHitlWaitingTaskOutput({
                     threadId: hitlPaused.threadId,
                     question: hitlPaused.question,
@@ -516,6 +521,7 @@ export class AgentRuntime {
         let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
+        const nodeTokenUsages = [];
         try {
             for await (const runtimeEvent of this.deps.graphEngine.stream(graph, continueState)) {
                 if (runtimeEvent.type === 'tool.called') {
@@ -555,8 +561,10 @@ export class AgentRuntime {
                         assistantText += delta;
                     }
                 }
+                collectStreamNodeTokenUsage(runtimeEvent, nodeTokenUsages);
                 yield this.runtimeEventToSSE(runtimeEvent, correlationId, taskId);
             }
+            await recordTaskTokenUsages(this.deps.taskService, taskId, nodeTokenUsages);
             await this.deps.taskService.updateStatus(taskId, 'success', assistantText || undefined);
             if (sessionId) {
                 await persistTurnTranscript(this.deps.messageService, {
@@ -580,6 +588,7 @@ export class AgentRuntime {
         catch (err) {
             const hitlPaused = unwrapHitlPaused(err);
             if (hitlPaused) {
+                await recordTaskTokenUsages(this.deps.taskService, taskId, nodeTokenUsages);
                 await this.deps.taskService.updateStatus(taskId, 'waiting_hitl', buildHitlWaitingTaskOutput({
                     threadId: hitlPaused.threadId,
                     question: hitlPaused.question,
@@ -676,6 +685,19 @@ export class AgentRuntime {
                 traceId,
                 traceCollector: this.deps.traceCollector,
             });
+            if (result.tokenUsage.perNode && result.tokenUsage.perNode.length > 0) {
+                await recordTaskTokenUsages(this.deps.taskService, task.id, result.tokenUsage.perNode);
+            }
+            else if (result.tokenUsage.total > 0) {
+                await recordTaskTokenUsages(this.deps.taskService, task.id, [
+                    {
+                        nodeId: 'graph',
+                        model: 'unknown',
+                        inputTokens: result.tokenUsage.input,
+                        outputTokens: result.tokenUsage.output,
+                    },
+                ]);
+            }
             await this.deps.taskService.updateStatus(task.id, 'success', result.output);
             if (this.deps.recordForkRelation) {
                 try {

package/dist/runtime/types.d.ts

@@ -24,7 +24,7 @@ export interface ExecuteParams {
     agentVersion?: string;
     /**
      * Hosting 已创建的 Trace id（Foundation `POST /traces` / TraceLinker.createTrace 的返回值）。
-     * 写入 GraphState 供 Skill/Tool span。
+     * 与装配期 `traceCollector` 同时存在时，invoke/stream 入口绑定到本次执行上下文供图内 span。
      */
     traceId?: string;
     config?: InvokeConfig;

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

@@ -6,7 +6,7 @@
  * @see contracts/trace-collector.ts
  * @see sse/sse-emitter.ts
  */
-import type { ExecutionFlowEvent, ExecutionNodeEvent, ITraceCollector, TraceEvent, TraceLinkEvent, TraceLinkNodeEvent, TraceSession } from '../contracts/trace-collector.js';
+import type { CompleteNodeParams, ExecutionFlowEvent, ExecutionNodeEvent, ITraceCollector, TraceEvent, TraceLinkEvent, TraceLinkNodeEvent, TraceSession } from '../contracts/trace-collector.js';
 /**
  * InMemoryTraceCollector — 内存 Trace 采集器（测试用）
  */
@@ -18,14 +18,7 @@ export declare class InMemoryTraceCollector implements ITraceCollector {
     getSession(sessionId: string): Promise<TraceSession | null>;
     createFlow(_event: ExecutionFlowEvent): Promise<string>;
     createNode(_event: ExecutionNodeEvent): Promise<string>;
-    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>;
     createLink(_event: TraceLinkEvent): Promise<string>;
     createLinkNode(_event: TraceLinkNodeEvent): Promise<string>;
     completeLinkNode(_nodeId: string, _params: {

package/dist/token/index.d.ts

@@ -6,6 +6,8 @@ export { TokenBudgetGuard, TokenBudgetExhaustedError, } from './token-budget-gua
 export { SessionBudgetChecker, SessionBudgetExhaustedError, } from './session-budget-checker.js';
 export type { NodeTokenUsage, TokenBreakdown, TaskTokenSummary, } from './token-stats.service.js';
 export { TokenStatsService } from './token-stats.service.js';
+export { recordTaskTokenUsages, tokenUsageFromNodePayload, collectStreamNodeTokenUsage, } from './record-task-token-usage.js';
+export type { TaskTokenUsageWriter } from './record-task-token-usage.js';
 export type { TokenDetailMode } from './token-detail-mode.js';
 export { contextWindowUsage, buildContextUsage, splitContextUsage, turnSectionChars, pickContextFields, type ContextWindowUsage, type ContextUsageParts, } from './context-window.js';
 export { TokenStatsEmitter } from './token-detail-mode.js';

package/dist/token/index.js

@@ -3,6 +3,7 @@ export { PostgresTokenBudgetRepository } from './pg-token-budget.repository.js';
 export { TokenBudgetGuard, TokenBudgetExhaustedError, } from './token-budget-guard.js';
 export { SessionBudgetChecker, SessionBudgetExhaustedError, } from './session-budget-checker.js';
 export { TokenStatsService } from './token-stats.service.js';
+export { recordTaskTokenUsages, tokenUsageFromNodePayload, collectStreamNodeTokenUsage, } from './record-task-token-usage.js';
 export { contextWindowUsage, buildContextUsage, splitContextUsage, turnSectionChars, pickContextFields, } from './context-window.js';
 export { TokenStatsEmitter } from './token-detail-mode.js';
 // 上下文窗口预算分配

package/dist/token/record-task-token-usage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Task.token_usage 写入：invoke / stream / HITL resume / fork 同一收口。
+ *
+ * 假设：一次 LLM 调用产生一条 TokenUsageRecord（nodeId + model + in/out）。
+ * 来源可以是 Graph.perNode，也可以是 SSE stats.node_token_usage，字段同一套。
+ * 写入失败只 warn，不挡 Task 终态 / HITL（与 Span 采集同一策略）。
+ */
+import type { RuntimeEvent } from '../graph/contracts/executable-graph.js';
+import type { TokenUsageRecord } from '../task/contracts/task-manager.contract.js';
+export interface TaskTokenUsageWriter {
+    recordTokenUsage(taskId: string, usage: TokenUsageRecord): Promise<void>;
+}
+export declare function tokenUsageFromNodePayload(payload: unknown): TokenUsageRecord | undefined;
+export declare function collectStreamNodeTokenUsage(event: Pick<RuntimeEvent, 'type' | 'payload'>, bucket: TokenUsageRecord[]): void;
+export declare function recordTaskTokenUsages(taskService: TaskTokenUsageWriter, taskId: string, usages: Array<{
+    nodeId: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costEstimate?: number;
+}>): Promise<void>;

package/dist/token/record-task-token-usage.js

@@ -0,0 +1,52 @@
+/**
+ * Task.token_usage 写入：invoke / stream / HITL resume / fork 同一收口。
+ *
+ * 假设：一次 LLM 调用产生一条 TokenUsageRecord（nodeId + model + in/out）。
+ * 来源可以是 Graph.perNode，也可以是 SSE stats.node_token_usage，字段同一套。
+ * 写入失败只 warn，不挡 Task 终态 / HITL（与 Span 采集同一策略）。
+ */
+import { emitRuntimeLog } from '../common/logger.js';
+export function tokenUsageFromNodePayload(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const record = payload;
+    const inputTokens = Number(record['inputTokens'] ?? 0);
+    const outputTokens = Number(record['outputTokens'] ?? 0);
+    if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens))
+        return undefined;
+    return {
+        nodeId: typeof record['nodeId'] === 'string' && record['nodeId'] ? record['nodeId'] : 'unknown',
+        model: typeof record['model'] === 'string' && record['model'] ? record['model'] : 'unknown',
+        inputTokens,
+        outputTokens,
+        costEstimate: Number(record['costEstimate'] ?? 0) || 0,
+    };
+}
+export function collectStreamNodeTokenUsage(event, bucket) {
+    if (event.type !== 'stats.node_token_usage')
+        return;
+    const usage = tokenUsageFromNodePayload(event.payload);
+    if (usage)
+        bucket.push(usage);
+}
+export async function recordTaskTokenUsages(taskService, taskId, usages) {
+    for (const usage of usages) {
+        try {
+            await taskService.recordTokenUsage(taskId, {
+                nodeId: usage.nodeId,
+                model: usage.model,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                costEstimate: usage.costEstimate ?? 0,
+            });
+        }
+        catch (err) {
+            emitRuntimeLog('warn', 'runtime.token', 'task token usage persist failed', {
+                event: 'runtime.token.persist_failed',
+                taskId,
+                nodeId: usage.nodeId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}

package/dist/token/token-stats.service.d.ts

@@ -67,6 +67,8 @@ export declare class TokenStatsService {
      * @param usage - 本次调用的 Token 消耗数据
      */
     record(taskId: string, usage: NodeTokenUsage): void;
+    /** 按记录顺序返回本 Task 的每次 LLM 用量（写入 Task.token_usage 用） */
+    list(taskId: string): NodeTokenUsage[];
     /**
      * 获取 Task 级聚合统计
      *

package/dist/token/token-stats.service.js

@@ -35,6 +35,10 @@ export class TokenStatsService {
             this.usageStore.set(taskId, [usage]);
         }
     }
+    /** 按记录顺序返回本 Task 的每次 LLM 用量（写入 Task.token_usage 用） */
+    list(taskId) {
+        return [...(this.usageStore.get(taskId) ?? [])];
+    }
     /**
      * 获取 Task 级聚合统计
      *

package/dist/tool/index.d.ts

@@ -1,5 +1,5 @@
 export type { AuthContext, ToolCallRequest, ToolCallResult, LLMToolCall, LLMToolCallResponse, IToolExecutor, McpListedTool, } from './tool-executor.interface.js';
-export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, } from './mcp-list.js';
+export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, toolsetCodeFromLoaded, toolTraceIdentity, } from './mcp-list.js';
 export { toLoadedToolMap, type LoadedToolDefinition, type LoadedToolMap, type LoadedToolManifestRef, } from './loaded-tool-definition.js';
 export { ToolOrchestrator } from './tool-orchestrator.js';
 export { HttpToolExecutor, type HttpToolExecutorOptions, } from './http-tool-executor.js';

package/dist/tool/index.js

@@ -1,4 +1,4 @@
-export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, } from './mcp-list.js';
+export { hydrateMcpTools, isMcpDiscoverStub, needsMcpHydration, parseListedTools, toolsetCodeFromLoaded, toolTraceIdentity, } from './mcp-list.js';
 export { toLoadedToolMap, } from './loaded-tool-definition.js';
 export { ToolOrchestrator } from './tool-orchestrator.js';
 export { HttpToolExecutor, } from './http-tool-executor.js';

package/dist/tool/mcp-list.d.ts

@@ -32,6 +32,18 @@ export declare function toolsetCodeFromLoaded(loaded: {
         id?: string;
     };
 } | undefined): string | undefined;
+/** Tool Span：工具集 code + 声明版本。与 Skill 的 skillSpace/version 同一假设。 */
+export declare function toolTraceIdentity(loaded: {
+    toolId?: string;
+    name?: string;
+    manifest?: {
+        id?: string;
+        version?: string;
+    };
+} | undefined, toolName: string): {
+    toolset?: string;
+    toolVersion?: string;
+};
 export interface HydrateMcpToolsAuth {
     authContext: AuthContext;
     correlationId?: string;

package/dist/tool/mcp-list.js

@@ -84,6 +84,21 @@ export function toolsetCodeFromLoaded(loaded) {
     }
     return undefined;
 }
+function declaredToolVersion(toolName, version) {
+    const raw = version?.trim();
+    if (!raw || raw === toolName)
+        return undefined;
+    return raw;
+}
+/** Tool Span：工具集 code + 声明版本。与 Skill 的 skillSpace/version 同一假设。 */
+export function toolTraceIdentity(loaded, toolName) {
+    const toolset = toolsetCodeFromLoaded(loaded);
+    const toolVersion = declaredToolVersion(toolName, loaded?.manifest?.version);
+    return {
+        ...(toolset ? { toolset } : {}),
+        ...(toolVersion ? { toolVersion } : {}),
+    };
+}
 /**
  * 将 MCP discover stub 替换为 tools/list 结果。
  * 无 stub 时原样返回（同一引用）。按 endpoint+user+agent 在执行器内缓存 list。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gt-fe/eap-runtime",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Enterprise Agent Platform — Runtime核心：Graph执行引擎、Task生命周期、Session管理、Checkpoint持久化",
   "type": "module",
   "main": "dist/index.js",