@gt-fe/eap-runtime 0.0.20 → 0.0.22

package/dist/session/persist-turn-messages.js

@@ -32,6 +32,7 @@ export async function persistAssistantTurnMessage(messageService, params) {
         reasoning: params.reasoningContent
             ? { reasoningContent: params.reasoningContent }
             : null,
+        durationMs: params.durationMs ?? null,
     });
 }
 /**
@@ -92,6 +93,114 @@ export function extractStreamTextDelta(eventType, payload) {
     const text = p.chunk ?? p.delta ?? p.content;
     return typeof text === 'string' ? text : '';
 }
+export function createStreamAssistantBuckets() {
+    return { order: [], text: new Map() };
+}
+function streamNodeId(payload) {
+    if (!payload || typeof payload !== 'object')
+        return '_';
+    const p = payload;
+    const n = p.node ?? p.nodeId;
+    return typeof n === 'string' && n.trim() ? n : '_';
+}
+export function applyStreamTextDelta(buckets, eventType, payload) {
+    const delta = extractStreamTextDelta(eventType, payload);
+    if (!delta)
+        return;
+    const node = streamNodeId(payload);
+    if (eventType === 'response.final' && delta.trim()) {
+        if (!buckets.text.has(node))
+            buckets.order.push(node);
+        buckets.text.set(node, delta);
+        return;
+    }
+    if (!buckets.text.has(node))
+        buckets.order.push(node);
+    buckets.text.set(node, (buckets.text.get(node) ?? '') + delta);
+}
+export function streamAssistantTexts(buckets) {
+    return buckets.order
+        .map((nodeId) => ({ nodeId, text: buckets.text.get(nodeId) ?? '' }))
+        .filter((row) => row.text.length > 0);
+}
+/** 最后一个有文本的节点（有汇合节点时通常是它） */
+export function lastStreamAssistantText(buckets) {
+    const rows = streamAssistantTexts(buckets);
+    return rows.at(-1)?.text ?? '';
+}
+/** 用户可见兜底输出：各节点文本都保留，避免无汇合时只剩后出现的一路 */
+export function visibleStreamAssistantText(buckets) {
+    const rows = streamAssistantTexts(buckets);
+    if (rows.length <= 1)
+        return rows[0]?.text ?? '';
+    return rows.map((row) => row.text).join('\n\n');
+}
+/** `finishPoints` 里的实际节点 id；`__end__` / `__start__` 不算。空则 Session 不按结束节点筛选。 */
+export function namedFinishPoints(finishPoints) {
+    return (finishPoints ?? []).filter((id) => id.trim() && id !== '__end__' && id !== '__start__');
+}
+/**
+ * Session 里的助手正文。
+ * - `finishPoints` 只含一个实际节点 id（DAG `merge`）：只留该节点
+ * - 没有实际节点 id，或含多个：全部保留，由调用方拼成一条消息（规划执行的计划+结果）
+ * 不把 planner 写进 finishPoints：那会变成 LangGraph 终止点，计划跑完图就结束。
+ */
+export function sessionVisibleAssistantTexts(texts, finishPoints) {
+    const nonempty = texts.filter((row) => row.text.trim().length > 0);
+    const named = namedFinishPoints(finishPoints);
+    if (named.length !== 1)
+        return nonempty;
+    const hit = nonempty.filter((row) => row.nodeId === named[0]);
+    if (hit.length > 0)
+        return hit;
+    const last = nonempty.at(-1);
+    return last ? [last] : [];
+}
+/** 可写入 Session 的纯文本助手；带 tool_calls 的行不算，避免把调用行拼进正文。 */
+function isTextAssistant(message) {
+    if (message.role !== 'assistant')
+        return false;
+    if (message.toolCalls && message.toolCalls.length > 0)
+        return false;
+    return Boolean(message.content?.trim());
+}
+/** Session 只收成对的 tool 结果；code 节点没有 toolCallId，留在 Checkpoint。 */
+function isSessionToolMessage(message) {
+    if (message.role !== 'tool')
+        return false;
+    return Boolean(message.toolCallId?.trim());
+}
+function sessionGraphMessages(messages) {
+    return messages.filter((message) => message.role !== 'tool' || isSessionToolMessage(message));
+}
+/**
+ * invoke 路径图增量。tool_calls / tool 行原样保留，纯文本助手收成一条放在末尾（与 stream 落库顺序一致）。
+ * GraphMessage 无 nodeId：`finishPoints` 只含一个实际节点 id 时取最后一条纯文本，不是按 id 筛选（官方 DAG 的 `merge` 在末尾）。
+ * 没有实际节点 id 或仅为 `__end__` 时把多段正文用空行拼进这一条。
+ * 无 toolCallId 的 tool 行不进 Session（code 节点结果）。
+ */
+export function sessionVisibleGraphMessages(messages, finishPoints) {
+    const eligible = sessionGraphMessages(messages);
+    const texts = eligible.filter(isTextAssistant);
+    if (texts.length === 0)
+        return eligible;
+    const named = namedFinishPoints(finishPoints);
+    const visible = named.length === 1 ? [texts.at(-1)] : texts;
+    const keep = visible.at(-1);
+    const joined = visible.map((message) => message.content).join('\n\n');
+    const out = [];
+    for (const message of eligible) {
+        if (isTextAssistant(message))
+            continue;
+        out.push(message);
+    }
+    out.push({
+        ...keep,
+        content: joined,
+        ...(keep.reasoningContent ? { reasoningContent: keep.reasoningContent } : {}),
+    });
+    return out;
+}
 /**
  * 从流式事件抽取 assistant reasoning。
  * 子图在 skill.completed 上回传（父图不再为 subgraph 节点发空 response.chunk）。
@@ -108,6 +217,33 @@ export function extractStreamReasoning(eventType, payload) {
     const value = payload.reasoningContent;
     return typeof value === 'string' && value ? value : undefined;
 }
+/** 落盘 / 回填历史只收终态：result，或不会再试的 error。willRetry 的 error 只给直播 UI。 */
+export function isTerminalToolStreamEvent(eventType, payload) {
+    if (eventType === 'tool.result')
+        return true;
+    if (eventType !== 'tool.error')
+        return false;
+    if (!payload || typeof payload !== 'object')
+        return true;
+    return payload.willRetry !== true;
+}
+export function appendTerminalToolResult(eventType, payload, bucket) {
+    if (!isTerminalToolStreamEvent(eventType, payload))
+        return;
+    if (eventType !== 'tool.result' && eventType !== 'tool.error')
+        return;
+    if (!payload || typeof payload !== 'object')
+        return;
+    const p = payload;
+    if (!p.toolCallId || !p.toolName)
+        return;
+    bucket.push({
+        toolCallId: p.toolCallId,
+        toolName: p.toolName,
+        content: p.content ?? p.error,
+        success: eventType === 'tool.result' && p.success !== false,
+    });
+}
 /** 历史 MessageRecord → GraphMessage（保留 tool 元数据与 reasoning） */
 export function messageRecordsToGraphMessages(records) {
     return records.map((m) => {
@@ -220,8 +356,10 @@ export function extractHitlThreadId(output) {
     return undefined;
 }
 /**
- * Checkpoint thread_id 契约：HITL/多轮优先且应唯一等于 sessionId；
+ * Checkpoint 父图 thread_id：HITL/多轮优先且应唯一等于 sessionId；
  * 无 session 时退到 `task-${taskId}`。勿用 correlationId 作为 Checkpoint key。
+ * 子图槽位再经 `checkpointStorageThreadId`（`thread_id#父节点id`），
+ * 与 LangGraph put / 子图内 HITL interrupt 同一把钥匙。
  *
  * 注意：session 级 thread + 全量 Session 历史同时注入会导致 messages 双重 append。
  * 组装本轮 Graph 输入请用 {@link buildTurnGraphMessages}（有 Checkpoint 历史则只追加 user）。
@@ -243,7 +381,11 @@ export function buildTurnTranscriptFromStreamEvents(params) {
     const out = [];
     const pending = params.pendingToolCalls ?? [];
     const results = params.toolResults ?? [];
-    const text = params.assistantText ?? '';
+    const visible = sessionVisibleAssistantTexts((params.assistantTexts ?? []).map((row) => ({ nodeId: row.nodeId, text: row.text })), params.finishPoints);
+    const texts = visible.map((row) => row.text).filter((text) => text.trim().length > 0);
+    if (texts.length === 0 && (params.assistantText ?? '').trim()) {
+        texts.push(params.assistantText ?? '');
+    }
     if (pending.length > 0) {
         out.push({
             role: 'assistant',
@@ -267,10 +409,19 @@ export function buildTurnTranscriptFromStreamEvents(params) {
             success: tr.success,
         });
     }
-    if (text.trim() || (params.persistEmptyAssistant && out.length === 0)) {
+    if (texts.length > 0) {
+        out.push({
+            role: 'assistant',
+            content: texts.join('\n\n'),
+            ...(params.assistantReasoningContent
+                ? { reasoningContent: params.assistantReasoningContent }
+                : {}),
+        });
+    }
+    else if (params.persistEmptyAssistant && out.length === 0) {
         out.push({
             role: 'assistant',
-            content: text,
+            content: '',
             ...(params.assistantReasoningContent
                 ? { reasoningContent: params.assistantReasoningContent }
                 : {}),
@@ -299,14 +450,17 @@ export async function persistTurnTranscript(messageService, params) {
                 toolCalls: m.toolCalls,
                 tokenCount: isToolCallOnly ? 0 : params.assistantTokenCount,
                 reasoningContent: m.reasoningContent,
+                durationMs: isToolCallOnly ? null : params.assistantDurationMs,
             });
         }
         else if (m.role === 'tool') {
+            if (!m.toolCallId?.trim())
+                continue;
             await persistToolTurnMessage(messageService, {
                 sessionId: params.sessionId,
                 taskId: params.taskId,
                 correlationId: params.correlationId,
-                toolCallId: m.toolCallId ?? 'unknown',
+                toolCallId: m.toolCallId,
                 toolName: m.toolName ?? 'unknown',
                 content: m.content,
                 success: m.success !== false,
@@ -320,6 +474,7 @@ export async function persistTurnTranscript(messageService, params) {
             correlationId: params.correlationId,
             content: params.fallbackAssistantContent,
             tokenCount: params.assistantTokenCount,
+            durationMs: params.assistantDurationMs,
         });
     }
 }

package/dist/sse/events/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * SSE 事件 Payload 类型 — 统一导出
  *
- * 定义 SSE 事件的 Payload 接口和 SSEEventType 联合类型。
+ * 定义 SSE 事件的 Payload 接口和 SSEEventType 联合类型（含 RAG 节点旁路观测事件）。
  *
  * 命名规范：
  * - 格式：{domain}.{action}
@@ -28,6 +28,7 @@ export * from './plan-events.js';
 export * from './response-events.js';
 export * from './stats-events.js';
 export * from './connection-events.js';
+export * from './rag-events.js';
 /**
  * 事件层级
  */
@@ -39,12 +40,12 @@ export declare const CORE_SSE_EVENTS: readonly ["session.created", "task.started
 /**
  * 可选事件类型（Agent 按需支持）
  */
-export declare const OPTIONAL_SSE_EVENTS: readonly ["skill.matched", "skill.unmatched", "skill.started", "skill.completed", "skill.failed", "skill.loaded", "skill.resource_read", "reasoning.step", "tool.progress", "file.created", "file.updated", "code.executed", "collaboration.handed_off", "collaboration.subtask.started", "collaboration.subtask.completed", "plan.created", "plan.step.started", "plan.step.completed", "response.max_iterations_reached", "stats.node_token_usage"];
+export declare const OPTIONAL_SSE_EVENTS: readonly ["skill.matched", "skill.unmatched", "skill.started", "skill.completed", "skill.failed", "skill.loaded", "skill.resource_read", "reasoning.step", "tool.progress", "file.created", "file.updated", "code.executed", "collaboration.handed_off", "collaboration.subtask.started", "collaboration.subtask.completed", "plan.created", "plan.step.started", "plan.step.completed", "response.max_iterations_reached", "stats.node_token_usage", "session.compression.started", "session.compression.completed", "rag.round", "rag.search", "rag.denoise", "rag.rewrite", "rag.finish"];
 /**
  * SSEEventType — SSE 事件类型字符串联合类型
  */
-export type SSEEventType = 'session.created' | 'task.started' | 'task.completed' | 'task.error' | 'reasoning.started' | 'response.chunk' | 'tool.called' | 'tool.result' | 'tool.error' | 'hitl.waited' | 'hitl.resumed' | 'response.final' | 'stats.token_usage' | 'connection.heartbeat' | 'skill.matched' | 'skill.unmatched' | 'skill.started' | 'skill.completed' | 'skill.failed' | 'skill.loaded' | 'skill.resource_read' | 'reasoning.step' | 'tool.progress' | 'file.created' | 'file.updated' | 'code.executed' | 'collaboration.handed_off' | 'collaboration.subtask.started' | 'collaboration.subtask.completed' | 'plan.created' | 'plan.step.started' | 'plan.step.completed' | 'response.max_iterations_reached' | 'stats.node_token_usage';
-import type { SessionCreatedPayload, TaskStartedPayload, TaskCompletedPayload, TaskErrorPayload } from './session-events.js';
+export type SSEEventType = 'session.created' | 'task.started' | 'task.completed' | 'task.error' | 'reasoning.started' | 'response.chunk' | 'tool.called' | 'tool.result' | 'tool.error' | 'hitl.waited' | 'hitl.resumed' | 'response.final' | 'stats.token_usage' | 'connection.heartbeat' | 'skill.matched' | 'skill.unmatched' | 'skill.started' | 'skill.completed' | 'skill.failed' | 'skill.loaded' | 'skill.resource_read' | 'reasoning.step' | 'tool.progress' | 'file.created' | 'file.updated' | 'code.executed' | 'collaboration.handed_off' | 'collaboration.subtask.started' | 'collaboration.subtask.completed' | 'plan.created' | 'plan.step.started' | 'plan.step.completed' | 'response.max_iterations_reached' | 'stats.node_token_usage' | 'session.compression.started' | 'session.compression.completed' | 'rag.round' | 'rag.search' | 'rag.denoise' | 'rag.rewrite' | 'rag.finish';
+import type { SessionCreatedPayload, TaskStartedPayload, TaskCompletedPayload, TaskErrorPayload, SessionCompressionStartedPayload, SessionCompressionCompletedPayload } from './session-events.js';
 import type { SkillMatchedPayload, SkillUnmatchedPayload, SkillStartedPayload, SkillCompletedPayload, SkillFailedPayload, SkillLoadedPayload, SkillResourceReadPayload } from './skill-events.js';
 import type { ReasoningStartedPayload, ReasoningStepPayload, ResponseChunkPayload } from './reasoning-events.js';
 import type { ToolCalledPayload, ToolResultPayload, ToolProgressPayload, ToolErrorPayload } from './tool-events.js';
@@ -56,6 +57,7 @@ import type { PlanCreatedPayload, PlanStepStartedPayload, PlanStepCompletedPaylo
 import type { ResponseFinalPayload, ResponseMaxIterationsReachedPayload } from './response-events.js';
 import type { StatsTokenUsagePayload, StatsNodeTokenUsagePayload } from './stats-events.js';
 import type { ConnectionHeartbeatPayload } from './connection-events.js';
+import type { RagRoundPayload, RagSearchPayload, RagDenoisePayload, RagRewritePayload, RagFinishPayload } from './rag-events.js';
 /**
  * SSEEventPayloadMap — 事件类型名称到 Payload 类型的完整映射
  */
@@ -94,6 +96,13 @@ export interface SSEEventPayloadMap {
     'plan.step.completed': PlanStepCompletedPayload;
     'response.max_iterations_reached': ResponseMaxIterationsReachedPayload;
     'stats.node_token_usage': StatsNodeTokenUsagePayload;
+    'session.compression.started': SessionCompressionStartedPayload;
+    'session.compression.completed': SessionCompressionCompletedPayload;
+    'rag.round': RagRoundPayload;
+    'rag.search': RagSearchPayload;
+    'rag.denoise': RagDenoisePayload;
+    'rag.rewrite': RagRewritePayload;
+    'rag.finish': RagFinishPayload;
 }
 /**
  * 判断事件是否为核心事件

package/dist/sse/events/index.js

@@ -1,7 +1,7 @@
 /**
  * SSE 事件 Payload 类型 — 统一导出
  *
- * 定义 SSE 事件的 Payload 接口和 SSEEventType 联合类型。
+ * 定义 SSE 事件的 Payload 接口和 SSEEventType 联合类型（含 RAG 节点旁路观测事件）。
  *
  * 命名规范：
  * - 格式：{domain}.{action}
@@ -31,6 +31,7 @@ export * from './plan-events.js';
 export * from './response-events.js';
 export * from './stats-events.js';
 export * from './connection-events.js';
+export * from './rag-events.js';
 /**
  * 核心事件类型（所有 Agent 必须支持）
  */
@@ -74,6 +75,13 @@ export const OPTIONAL_SSE_EVENTS = [
     'plan.step.completed',
     'response.max_iterations_reached',
     'stats.node_token_usage',
+    'session.compression.started',
+    'session.compression.completed',
+    'rag.round',
+    'rag.search',
+    'rag.denoise',
+    'rag.rewrite',
+    'rag.finish',
 ];
 // ─────────────────────────────────────────────
 // 工具函数

package/dist/sse/events/rag-events.d.ts

@@ -0,0 +1,63 @@
+/**
+ * RAG 节点 SSE 事件 Payload — rag.* 五事件（可选事件层）
+ *
+ * rag 循环发生在节点黑盒内部（不经 ToolNode、不成图超步），这些事件把
+ * 内部过程经 streamSink 旁路推给外部观测，弥补"循环内调用不可见"的缺口。
+ *
+ * @see mt-docs/1-requirements/specs/agentic-rag/design-v2.md §2.2（事件输出）
+ */
+export interface RagRoundPayload {
+    nodeId: string;
+    /** 决策轮次（从 1 起） */
+    round: number;
+    /** 本轮 LLM 点名的工具（name + arguments） */
+    toolCalls: Array<{
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+}
+export interface RagSearchPayload {
+    nodeId: string;
+    /** local = 内置 local_search 直连；keyword = 内置 keyword_search 直连（FTS5）；kb = 注册工具经 ToolOrchestrator */
+    kind: 'local' | 'keyword' | 'kb';
+    query?: string;
+    toolName?: string;
+    topK?: number;
+    /** 命中条数（归一化后） */
+    hits: number;
+    success: boolean;
+    error?: string;
+    durationMs: number;
+    /**
+     * 实际生效的本地检索范围摘要（仅 local/keyword：与传给 IRetriever 的 scope 同源），
+     * 形如 `dirs=2[共享资料,月报] files=3`（目录取末段名）；'closed'=会话勾选显式关闭本地源；
+     * 缺省 = 未圈定（本地不限）或 kb 路径（ragScope 只约束本地检索源，kb 侧看 toolName）。
+     * 会话级勾选数据源 id（ragSources）在节点入口已折算进 scope/工具表，不单独透出。
+     */
+    scope?: string;
+}
+export interface RagDenoisePayload {
+    nodeId: string;
+    /** 判定候选数（近重去重后） */
+    candidates: number;
+    /** 存活条数 */
+    kept: number;
+    /** 被滤文档与原因 */
+    filtered: Array<{
+        rawId: string;
+        reason: string;
+    }>;
+}
+export interface RagRewritePayload {
+    nodeId: string;
+    from: string;
+    to: string;
+}
+export interface RagFinishPayload {
+    nodeId: string;
+    rounds: number;
+    /** 空手标识（全失败/全被滤，含重查后仍空） */
+    empty: boolean;
+    /** 最终上下文条数 */
+    docs: number;
+}

package/dist/sse/events/rag-events.js

@@ -0,0 +1,9 @@
+/**
+ * RAG 节点 SSE 事件 Payload — rag.* 五事件（可选事件层）
+ *
+ * rag 循环发生在节点黑盒内部（不经 ToolNode、不成图超步），这些事件把
+ * 内部过程经 streamSink 旁路推给外部观测，弥补"循环内调用不可见"的缺口。
+ *
+ * @see mt-docs/1-requirements/specs/agentic-rag/design-v2.md §2.2（事件输出）
+ */
+export {};

package/dist/sse/events/session-events.d.ts

@@ -7,6 +7,10 @@
  * - task.completed
  * - task.error
  *
+ * 可选事件：
+ * - session.compression.started
+ * - session.compression.completed
+ *
  * @see design.md §1.6 SSE事件协议定义
  */
 /** 会话创建或恢复 */
@@ -41,3 +45,37 @@ export interface TaskErrorPayload {
     /** 是否可恢复 */
     recoverable: boolean;
 }
+/** 触发压缩的原因：上下文窗占用，或轮次上限 */
+export type SessionCompressionReason = 'window' | 'max_rounds';
+/** session.compression.started — 即将摘要压缩历史；摘要 LLM 调用之前发出 */
+export interface SessionCompressionStartedPayload {
+    sessionId: string;
+    taskId?: string;
+    reason: SessionCompressionReason;
+    originalMessageCount: number;
+    /** 上一轮 llm_turns 的 prompt 占用 */
+    used?: number;
+    /** 模型上下文窗 */
+    window?: number;
+    /** round(used/window×100)；无窗口则省略 */
+    percent?: number;
+    /** 触发阈值：floor(window×0.7) 或 maxRounds */
+    threshold?: number;
+    /** 客户端可直接展示，例如 `Context 80% full. Compacting...` */
+    displayMessage: string;
+}
+/** session.compression.completed — 压缩结束（成功或失败都发） */
+export interface SessionCompressionCompletedPayload {
+    sessionId: string;
+    taskId?: string;
+    reason: SessionCompressionReason;
+    success: boolean;
+    originalMessageCount: number;
+    compressedMessageCount: number;
+    used?: number;
+    window?: number;
+    percent?: number;
+    persisted: boolean;
+    error?: string;
+    displayMessage: string;
+}

package/dist/sse/events/session-events.js

@@ -7,6 +7,10 @@
  * - task.completed
  * - task.error
  *
+ * 可选事件：
+ * - session.compression.started
+ * - session.compression.completed
+ *
  * @see design.md §1.6 SSE事件协议定义
  */
 export {};

package/dist/token/index.d.ts

@@ -6,9 +6,10 @@ 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 { recordTaskTokenUsages, tokenUsageFromNodePayload, collectStreamNodeTokenUsage, tokenUsagesFromLlmChannel, } from './record-task-token-usage.js';
 export type { TaskTokenUsageWriter } from './record-task-token-usage.js';
 export type { TokenDetailMode } from './token-detail-mode.js';
+export { resolveTokenDetail, shouldEmitTokenSse } from './token-detail.js';
 export { contextWindowUsage, buildContextUsage, splitContextUsage, turnSectionChars, pickContextFields, type ContextWindowUsage, type ContextUsageParts, } from './context-window.js';
 export { TokenStatsEmitter } from './token-detail-mode.js';
 export { ContextWindowBudget, createContextBudget, type ContextWindowBudgetConfig, type ContextSource, type SourceAllocation, type BudgetAllocation, DEFAULT_CONTEXT_BUDGET_CONFIG, } from './context-window-budget.js';

package/dist/token/index.js

@@ -3,7 +3,8 @@ 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 { recordTaskTokenUsages, tokenUsageFromNodePayload, collectStreamNodeTokenUsage, tokenUsagesFromLlmChannel, } from './record-task-token-usage.js';
+export { resolveTokenDetail, shouldEmitTokenSse } from './token-detail.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

@@ -12,6 +12,31 @@ export interface TaskTokenUsageWriter {
 }
 export declare function tokenUsageFromNodePayload(payload: unknown): TokenUsageRecord | undefined;
 export declare function collectStreamNodeTokenUsage(event: Pick<RuntimeEvent, 'type' | 'payload'>, bucket: TokenUsageRecord[]): void;
+/** Graph `__llmTokenUsage` channel → Task.token_usage 行（invoke / fork 抛错后从 Checkpoint 读）。 */
+export declare function tokenUsagesFromLlmChannel(state: unknown): TokenUsageRecord[];
+/** 本轮 LLM 用量汇总，供 stats.token_usage 与 assistantTokenCount。 */
+export declare function summarizeTokenUsages(usages: Array<{
+    nodeId: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costEstimate?: number;
+}>): {
+    total: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    byNode: Record<string, {
+        input: number;
+        output: number;
+    }>;
+    byModel: Record<string, {
+        input: number;
+        output: number;
+    }>;
+    costEstimate: number;
+};
 export declare function recordTaskTokenUsages(taskService: TaskTokenUsageWriter, taskId: string, usages: Array<{
     nodeId: string;
     model: string;

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

@@ -29,6 +29,50 @@ export function collectStreamNodeTokenUsage(event, bucket) {
     if (usage)
         bucket.push(usage);
 }
+/** Graph `__llmTokenUsage` channel → Task.token_usage 行（invoke / fork 抛错后从 Checkpoint 读）。 */
+export function tokenUsagesFromLlmChannel(state) {
+    if (!state || typeof state !== 'object' || Array.isArray(state))
+        return [];
+    const raw = state['__llmTokenUsage'];
+    if (!Array.isArray(raw))
+        return [];
+    const rows = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const rec = item;
+        if (typeof rec['nodeId'] !== 'string' &&
+            typeof rec['model'] !== 'string' &&
+            rec['inputTokens'] == null &&
+            rec['outputTokens'] == null) {
+            continue;
+        }
+        const usage = tokenUsageFromNodePayload(item);
+        if (usage)
+            rows.push(usage);
+    }
+    return rows;
+}
+/** 本轮 LLM 用量汇总，供 stats.token_usage 与 assistantTokenCount。 */
+export function summarizeTokenUsages(usages) {
+    const byNode = {};
+    const byModel = {};
+    let input = 0;
+    let output = 0;
+    let costEstimate = 0;
+    for (const usage of usages) {
+        input += usage.inputTokens;
+        output += usage.outputTokens;
+        costEstimate += usage.costEstimate ?? 0;
+        const node = byNode[usage.nodeId] ?? (byNode[usage.nodeId] = { input: 0, output: 0 });
+        node.input += usage.inputTokens;
+        node.output += usage.outputTokens;
+        const model = byModel[usage.model] ?? (byModel[usage.model] = { input: 0, output: 0 });
+        model.input += usage.inputTokens;
+        model.output += usage.outputTokens;
+    }
+    return { total: { input, output, total: input + output }, byNode, byModel, costEstimate };
+}
 export async function recordTaskTokenUsages(taskService, taskId, usages) {
     for (const usage of usages) {
         try {

package/dist/token/token-detail-mode.d.ts

@@ -4,7 +4,7 @@
  * 通过 tokenDetail 参数控制 Token 消耗的 SSE 输出行为：
  * - none: 不输出任何 Token 统计事件
  * - summary: 仅 Task 结束时输出 stats.token_usage 汇总
- * - detail: 每次 LLM 调用输出 stats.node_token + 结束时汇总
+ * - detail: 每次 LLM 调用输出 stats.node_token_usage + 结束时汇总
  *
  * `eap dev` 默认 detail；线上默认 summary。
  *
@@ -21,7 +21,7 @@ import { TokenStatsService } from './token-stats.service.js';
  * |---------|----------------------------------------------|-------------------|
  * | none    | 不输出任何 Token 统计事件                     | 生产环境前端       |
  * | summary | 仅 Task 结束时输出 stats.token_usage 汇总    | 生产环境后台/API   |
- * | detail  | 每次 LLM 调用输出 stats.node_token + 汇总    | 本地开发调试       |
+ * | detail  | 每次 LLM 调用输出 stats.node_token_usage + 汇总 | 本地开发调试       |
  */
 export type TokenDetailMode = 'none' | 'summary' | 'detail';
 /**
@@ -46,10 +46,10 @@ export declare class TokenStatsEmitter {
     private readonly mode;
     constructor(statsService: TokenStatsService, sseEmitter: ISSEEmitter | null, mode: TokenDetailMode);
     /**
-     * 记录 Token 消耗并按模式决定是否立即发射 stats.node_token 事件
+     * 记录 Token 消耗并按模式决定是否立即发射 stats.node_token_usage 事件
      *
      * - 始终调用 statsService.record() 记录数据
-     * - mode='detail': 立即 emit stats.node_token SSE 事件
+     * - mode='detail': 立即 emit stats.node_token_usage SSE 事件
      * - mode='none' / 'summary': 不 emit per-call 事件
      *
      * @param taskId - 所属 Task ID

package/dist/token/token-detail-mode.js

@@ -4,7 +4,7 @@
  * 通过 tokenDetail 参数控制 Token 消耗的 SSE 输出行为：
  * - none: 不输出任何 Token 统计事件
  * - summary: 仅 Task 结束时输出 stats.token_usage 汇总
- * - detail: 每次 LLM 调用输出 stats.node_token + 结束时汇总
+ * - detail: 每次 LLM 调用输出 stats.node_token_usage + 结束时汇总
  *
  * `eap dev` 默认 detail；线上默认 summary。
  *
@@ -40,10 +40,10 @@ export class TokenStatsEmitter {
         this.mode = mode;
     }
     /**
-     * 记录 Token 消耗并按模式决定是否立即发射 stats.node_token 事件
+     * 记录 Token 消耗并按模式决定是否立即发射 stats.node_token_usage 事件
      *
      * - 始终调用 statsService.record() 记录数据
-     * - mode='detail': 立即 emit stats.node_token SSE 事件
+     * - mode='detail': 立即 emit stats.node_token_usage SSE 事件
      * - mode='none' / 'summary': 不 emit per-call 事件
      *
      * @param taskId - 所属 Task ID
@@ -56,7 +56,7 @@ export class TokenStatsEmitter {
         // detail 模式: 立即发射 per-call 事件
         if (this.mode === 'detail' && this.sseEmitter) {
             const event = {
-                type: 'stats.node_token',
+                type: 'stats.node_token_usage',
                 data: {
                     nodeId: usage.nodeId,
                     model: usage.model,

package/dist/token/token-detail.d.ts

@@ -0,0 +1,8 @@
+/**
+ * tokenDetail：控制发给客户端的 Token SSE，不影响 Task.token_usage 落盘。
+ * 未设时保持现状：发 node + summary。
+ */
+import type { TokenDetailLevel } from '@gt-fe/eap-contracts';
+export type TokenDetailMode = TokenDetailLevel;
+export declare function resolveTokenDetail(explicit?: TokenDetailLevel, env?: NodeJS.ProcessEnv): TokenDetailMode;
+export declare function shouldEmitTokenSse(mode: TokenDetailMode, eventType: string): boolean;

package/dist/token/token-detail.js

@@ -0,0 +1,22 @@
+/**
+ * tokenDetail：控制发给客户端的 Token SSE，不影响 Task.token_usage 落盘。
+ * 未设时保持现状：发 node + summary。
+ */
+export function resolveTokenDetail(explicit, env = process.env) {
+    if (explicit === 'none' || explicit === 'summary' || explicit === 'detail')
+        return explicit;
+    const raw = env.EAP_RUNTIME_TOKEN_DETAIL;
+    if (raw === 'none' || raw === 'summary' || raw === 'detail')
+        return raw;
+    return 'detail';
+}
+export function shouldEmitTokenSse(mode, eventType) {
+    if (eventType !== 'stats.node_token_usage' && eventType !== 'stats.token_usage') {
+        return true;
+    }
+    if (mode === 'none')
+        return false;
+    if (mode === 'summary')
+        return eventType === 'stats.token_usage';
+    return true;
+}