The open-source agent harness - the runtime layer that turns an LLM into a working agent.
bugfix: fix tool call,turns and tokens count (#935)
harshil-20963f55e5620bd0
diff --git a/.changeset/all-turn-strip-metrics.md b/.changeset/all-turn-strip-metrics.mdnew file mode 100644index 000000000..9b9ceee33--- /dev/null+++ b/.changeset/all-turn-strip-metrics.md@@ -0,0 +1,5 @@+---+'@truefoundry/trueforge-ui': patch+---++Count all event turn.created rows (including MCP-auth resume turns) for the agent session detail strip Turns, Tokens, and Tool calls; keep transcript sections on renderable turns only. Stop overriding strip turn count from getSession metrics. Count pending human-wait tool calls (tool.response_required, e.g. ask-user) in strip Tool calls so they match Agent steps. Strip Tool calls counts only the main agent thread (sub-agent tool calls stay on the Sub-agents tile). Timeline/transcript turn bands fold non-renderable resume turns into the prior user turn (no phantom T2 / user markers). Compress idle between event-turns before folding display bands; aggregate cost/context/tooltip metrics per display band so MCP-auth resumes do not duplicate T1 chart keys or undercount tokens.diff --git a/packages/trueforge-ui/src/atoms/agent-details/AgentSessionEventTimelineChart.tsx b/packages/trueforge-ui/src/atoms/agent-details/AgentSessionEventTimelineChart.tsxindex 6a4490e40..3b870cf56 100644--- a/packages/trueforge-ui/src/atoms/agent-details/AgentSessionEventTimelineChart.tsx+++ b/packages/trueforge-ui/src/atoms/agent-details/AgentSessionEventTimelineChart.tsx@@ -42,6 +42,7 @@ import {type TimelineHoverTarget,type TimelineTurnBar,} from '../../utils/sessionEventTimelineChart.js';+import { aggregateSessionTurnBand } from '../../utils/sessionTurnViews.js';import { LightTooltip } from '../primitives/Tooltip.js';import {hasSessionEventTooltip,@@ -177,7 +178,10 @@ export function AgentSessionEventTimelineChart({}),[hiddenTypes, segments, turnGapMs, turnOrdinals],);- const markerGroups = useMemo(() => groupCoincidentTimelineMarkers(visibleSegments), [visibleSegments]);+ const markerGroups = useMemo(+ () => groupCoincidentTimelineMarkers(visibleSegments, { toleranceMs: MARKER_PX * msPerPx }),+ [msPerPx, visibleSegments],+ );const durationSegments = useMemo(() => visibleSegments.filter(segment => !segment.isMarker), [visibleSegments]);const turnBars = useMemo<TimelineTurnBar[]>(() =>@@ -536,7 +540,8 @@ export function AgentSessionEventTimelineChart({],);- const tooltipTurn = tooltipTarget?.type === TIMELINE_TYPE.turn ? turns[tooltipTarget.bar.turnIndex] : undefined;+ const tooltipTurnNumber = tooltipTarget?.type === TIMELINE_TYPE.turn ? tooltipTarget.bar.ordinal + 1 : undefined;+ const tooltipTurn = tooltipTurnNumber == null ? undefined : aggregateSessionTurnBand(turns, tooltipTurnNumber);const containerStyle = useMemo<CSSProperties>(() => ({ height: band + overheadPx }), [band, overheadPx]);const tooltipContent =tooltipTarget?.type === TIMELINE_TYPE.turn && tooltipTurn != null ? (diff --git a/packages/trueforge-ui/src/containers/AgentSessionTimelineContainer.tsx b/packages/trueforge-ui/src/containers/AgentSessionTimelineContainer.tsxindex 79421f582..13eeef889 100644--- a/packages/trueforge-ui/src/containers/AgentSessionTimelineContainer.tsx+++ b/packages/trueforge-ui/src/containers/AgentSessionTimelineContainer.tsx@@ -17,7 +17,7 @@ import { buildSessionMetrics } from '../utils/buildSessionMetrics.js';import { buildSessionTimelineSegments } from '../utils/buildSessionTimelineSegments.js';import { createCachedListEventsBridge } from '../utils/cachedListEventsBridge.js';import { getTurnInputSummary } from '../utils/sessionTimelineEvents.js';-import { buildSessionTurnViews, type SessionTurnView } from '../utils/sessionTurnViews.js';+import { aggregateSessionTurnBand, buildSessionTurnViews, type SessionTurnView } from '../utils/sessionTurnViews.js';import { AssistantMessageContainer } from './AssistantMessageContainer.js';import { ReadOnlySessionTurnRuntime } from './ReadOnlySessionTurnRuntime.js';import { UserMessageContainer } from './UserMessageContainer.js';@@ -141,7 +141,6 @@ export type AgentSessionTimelineContainerProps = {events: SessionEventItem[];contentMaxWidth?: string;sessionMetrics?: {- totalTurns: number;totalCostInUsd?: number;totalDurationMs: number;};@@ -164,12 +163,16 @@ export function AgentSessionTimelineContainer({const [loadFailed, setLoadFailed] = useState(false);const sectionRefs = useRef(new Map<number, HTMLElement>());- const turnViews = useMemo(() => buildSessionTurnViews(events), [events]);- const projectionEvents = useMemo(() => buildProjectionEvents(events, turnViews), [events, turnViews]);- const timelineSegments = useMemo(() => buildSessionTimelineSegments(turnViews), [turnViews]);+ const allTurnViews = useMemo(() => buildSessionTurnViews(events), [events]);+ const renderableTurnViews = useMemo(() => allTurnViews.filter(turn => turn.renderable), [allTurnViews]);+ const projectionEvents = useMemo(+ () => buildProjectionEvents(events, renderableTurnViews),+ [events, renderableTurnViews],+ );+ const timelineSegments = useMemo(() => buildSessionTimelineSegments(allTurnViews), [allTurnViews]);const sessionMetrics = useMemo(- () => buildSessionMetrics({ turns: turnViews, segments: timelineSegments, sessionMetrics: sessionMetricsHint }),- [sessionMetricsHint, timelineSegments, turnViews],+ () => buildSessionMetrics({ turns: allTurnViews, segments: timelineSegments, sessionMetrics: sessionMetricsHint }),+ [sessionMetricsHint, timelineSegments, allTurnViews],);const handleSelectTurn = useCallback((index: number) => {@@ -218,7 +221,7 @@ export function AgentSessionTimelineContainer({);}- if (messages.length === 0 && turnViews.length === 0) {+ if (messages.length === 0 && renderableTurnViews.length === 0) {return (<div className="flex flex-1 items-center justify-center px-6 text-sm text-text-secondary">This session has no messages yet.@@ -236,7 +239,7 @@ export function AgentSessionTimelineContainer({</div><div className="border-b border-border"><Suspense fallback={null}>- <AgentSessionEventTimeline turns={turnViews} segments={timelineSegments} onSelectTurn={handleSelectTurn} />+ <AgentSessionEventTimeline turns={allTurnViews} segments={timelineSegments} onSelectTurn={handleSelectTurn} /></Suspense></div><ThreadViewportShell@@ -245,10 +248,10 @@ export function AgentSessionTimelineContainer({{...(contentMaxWidth == null ? {} : { contentMaxWidth })}><div className="flex flex-col gap-4">- {turnViews.map(turn => (+ {renderableTurnViews.map(turn => (<SessionTurnSectionkey={turn.turnId}- turn={turn}+ turn={aggregateSessionTurnBand(allTurnViews, turn.turnNumber) ?? turn}messages={messagesForTurn(messages, turn)}AgentSessionTurnHeader={AgentSessionTurnHeader}onMount={node => {diff --git a/packages/trueforge-ui/src/utils/buildSessionMetrics.ts b/packages/trueforge-ui/src/utils/buildSessionMetrics.tsindex 8dc202785..543c13a17 100644--- a/packages/trueforge-ui/src/utils/buildSessionMetrics.ts+++ b/packages/trueforge-ui/src/utils/buildSessionMetrics.ts@@ -1,4 +1,4 @@-import { getSessionEventColor, type SessionEventTimelineSegment } from './sessionEventTimeline.js';+import { MAIN_THREAD_ID, getSessionEventColor, type SessionEventTimelineSegment } from './sessionEventTimeline.js';import type { SessionTurnView } from './sessionTurnViews.js';export type SessionMetricBarDatum = {@@ -23,8 +23,8 @@ export type SessionMetrics = {toolCallFrequency: SessionMetricBarDatum[];};+/** Optional getSession overrides for wall time and cost only — turn count always comes from events. */export type SessionMetricsHint = {- totalTurns: number;totalCostInUsd?: number;totalDurationMs: number;};@@ -59,16 +59,15 @@ export function buildSessionMetrics({let totalUncachedInputTokens = 0;let totalOutputTokens = 0;let totalCachedTokens = 0;- let contextTokens = 0;- const costPerTurn: SessionMetricBarDatum[] = [];- const contextByTurn: SessionMetricBarDatum[] = [];+ // Aggregate by display band so MCP-auth resumes don't emit duplicate T1 chart keys.+ const bandCostUsd = new Map<number, number>();+ const bandTokens = new Map<number, number>();for (const turn of turns) {- const label = `T${turn.turnNumber}`;derivedWallTimeMs += turn.durationMs ?? 0;if (!turnHasMetrics(turn)) {- costPerTurn.push({ label, value: 0, color: getSessionEventColor('tool_call') });- contextByTurn.push({ label, value: contextTokens, color: getSessionEventColor('model') });+ if (!bandCostUsd.has(turn.turnNumber)) bandCostUsd.set(turn.turnNumber, 0);+ if (!bandTokens.has(turn.turnNumber)) bandTokens.set(turn.turnNumber, 0);continue;}@@ -87,8 +86,21 @@ export function buildSessionMetrics({totalUncachedInputTokens += uncachedInputTokens;totalOutputTokens += outputTokens;totalCachedTokens += cachedTokens;- contextTokens += turnTotalTokens;- costPerTurn.push({ label, value: turnCostUsd ?? 0, color: getSessionEventColor('tool_call') });+ bandCostUsd.set(turn.turnNumber, (bandCostUsd.get(turn.turnNumber) ?? 0) + (turnCostUsd ?? 0));+ bandTokens.set(turn.turnNumber, (bandTokens.get(turn.turnNumber) ?? 0) + turnTotalTokens);+ }++ const costPerTurn: SessionMetricBarDatum[] = [];+ const contextByTurn: SessionMetricBarDatum[] = [];+ let contextTokens = 0;+ for (const turnNumber of [...bandTokens.keys()].sort((left, right) => left - right)) {+ const label = `T${turnNumber}`;+ contextTokens += bandTokens.get(turnNumber) ?? 0;+ costPerTurn.push({+ label,+ value: bandCostUsd.get(turnNumber) ?? 0,+ color: getSessionEventColor('tool_call'),+ });contextByTurn.push({ label, value: contextTokens, color: getSessionEventColor('model') });}@@ -101,13 +113,13 @@ export function buildSessionMetrics({const waitingTimeMs = segments.filter(segment => segment.type === 'waiting_on_human' || segment.type === 'approval').reduce((sum, segment) => sum + segmentDurationMs(segment), 0);- // Detail/list session metrics own wall time, cost, and turn count when present.+ // Detail session metrics may override wall time and cost; turn count is always from events.const wallTimeMs = sessionMetrics != null ? sessionMetrics.totalDurationMs : derivedWallTimeMs;const overheadTimeMs = Math.max(0, wallTimeMs - modelTimeMs - toolTimeMs - waitingTimeMs);const toolCallCounts = new Map<string, number>();for (const segment of segments) {- if (segment.type !== 'tool_call') continue;+ if (segment.type !== 'tool_call' || segment.threadId !== MAIN_THREAD_ID) continue;toolCallCounts.set(segment.description, (toolCallCounts.get(segment.description) ?? 0) + 1);}const toolCallFrequency = Array.from(toolCallCounts, ([label, value]) => ({@@ -120,7 +132,7 @@ export function buildSessionMetrics({sessionMetrics != null ? sessionMetrics.totalCostInUsd : hasDerivedCost ? derivedCostUsd : undefined;return {- totalTurns: sessionMetrics != null ? sessionMetrics.totalTurns : turns.length,+ totalTurns: turns.length,wallTimeMs,...(totalCostUsd == null ? {} : { totalCostUsd }),totalTokens,diff --git a/packages/trueforge-ui/src/utils/buildSessionTimelineSegments.ts b/packages/trueforge-ui/src/utils/buildSessionTimelineSegments.tsindex fe1a52fe8..756c55e4e 100644--- a/packages/trueforge-ui/src/utils/buildSessionTimelineSegments.ts+++ b/packages/trueforge-ui/src/utils/buildSessionTimelineSegments.ts@@ -33,14 +33,15 @@ type SubAgentToolCallRequest = {** The conversion runs in two passes because several bars need a later event* to determine their end:- * - tool calls span from the model event that requested them to `tool.response`;+ * - tool calls span from the model event that requested them to `tool.response`,+ * or to `tool.response_required` / turn end when still waiting on a human;* - sub-agent tracks span from `thread.created` to `thread.done`;* - approval-gated and sub-agent parent calls are excluded from ordinary tool* bars because they have dedicated visual representations.*- * The second pass emits one user marker per turn, then chronological event- * segments for each thread. Finally, real idle gaps between turns are removed- * so old sessions remain readable without changing durations inside a turn.+ * The second pass emits one user marker per renderable turn, then chronological+ * event segments for each thread. Finally, real idle gaps between turns are+ * removed so old sessions remain readable without changing durations inside a turn.*/export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionEventTimelineSegment[] {const originMs = parseTimestamp(turns[0]?.created.createdAt);@@ -49,6 +50,7 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionE// Correlation indexes built up front let the emission pass calculate complete// intervals without depending on the source event order.const toolResponsesByTurnId = new Map<string, Map<string, TimelineEvent>>();+ const toolResponseRequiredByTurnId = new Map<string, Map<string, TimelineEvent>>();const approvalRequiredIdsByTurnId = new Map<string, Set<string>>();const threadDoneEvents = new Map<string, TimelineEvent>();const subAgentToolCallIds = new Set<string>();@@ -68,6 +70,12 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionEconst responses = toolResponsesByTurnId.get(turn.turnId) ?? new Map();responses.set(toolCallId, event);toolResponsesByTurnId.set(turn.turnId, responses);+ } else if (event.type === 'tool.response_required') {+ const pending = toolResponseRequiredByTurnId.get(turn.turnId) ?? new Map();+ for (const toolCall of toolCallsOf(event)) {+ if (typeof toolCall.id === 'string') pending.set(toolCall.id, event);+ }+ toolResponseRequiredByTurnId.set(turn.turnId, pending);} else if (event.type === 'tool.approval_required') {const ids = approvalRequiredIdsByTurnId.get(turn.turnId) ?? new Set<string>();for (const toolCall of toolCallsOf(event)) {@@ -99,23 +107,36 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionEconst segments: SessionEventTimelineSegment[] = [];const emittedWaitingRequestIds = new Set<string>();+ // Only the last event-turn in a display band gets a "Turn completed" marker so+ // MCP-auth resumes don't plant a mid-band diamond on top of the next model bar.+ const lastTurnIdByNumber = new Map<number, string>();+ const displayTurnIndexByEventIndex = new Map<number, number>();+ for (const turn of turns) {+ lastTurnIdByNumber.set(turn.turnNumber, turn.turnId);+ displayTurnIndexByEventIndex.set(turn.eventTurnNumber - 1, turn.turnNumber - 1);+ }for (const turn of turns) {const createdMs = parseTimestamp(turn.created.createdAt);if (createdMs == null) continue;- const turnIndex = turn.turnNumber - 1;+ // Compress with unique event-turn indexes so MCP-auth idle between auth and+ // resume is removed; remap to the display band afterward.+ const turnIndex = turn.eventTurnNumber - 1;- segments.push({- id: `${turn.turnId}-user`,- type: 'user',- title: getTurnInputType(turn),- description: getTurnInputSummary(turn),- startMs: createdMs - originMs,- endMs: createdMs - originMs,- turnIndex,- threadId: MAIN_THREAD_ID,- isMarker: true,- });+ // Resume/MCP-auth turns have no user input; don't invent a user.message marker.+ if (turn.renderable) {+ segments.push({+ id: `${turn.turnId}-user`,+ type: 'user',+ title: getTurnInputType(turn),+ description: getTurnInputSummary(turn),+ startMs: createdMs - originMs,+ endMs: createdMs - originMs,+ turnIndex,+ threadId: MAIN_THREAD_ID,+ isMarker: true,+ });+ }// Model intervals are independent per thread. Using one global previous// timestamp would make concurrent sub-agent bars consume each other's time.@@ -141,6 +162,7 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionEthreadId,lastTimestampByThreadId,toolResponsesByTurnId,+ toolResponseRequiredByTurnId,approvalRequiredIdsByTurnId,subAgentToolCallIds,toolCallRequestsByTurnId,@@ -151,7 +173,14 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionElastTimestampByThreadId.set(threadId, eventMs);}- appendTerminalSegment({ turn, turnIndex, originMs, latestMs, segments });+ appendTerminalSegment({+ turn,+ turnIndex,+ originMs,+ latestMs,+ segments,+ emitDoneMarker: lastTurnIdByNumber.get(turn.turnNumber) === turn.turnId,+ });}return compressInterTurnGaps(@@ -160,7 +189,12 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionEstartMs: Math.max(0, segment.startMs),endMs: Math.max(0, segment.endMs),})),- ).sort((left, right) => left.startMs - right.startMs || left.endMs - right.endMs);+ )+ .map(segment => ({+ ...segment,+ turnIndex: displayTurnIndexByEventIndex.get(segment.turnIndex) ?? segment.turnIndex,+ }))+ .sort((left, right) => left.startMs - right.startMs || left.endMs - right.endMs);}/**@@ -179,6 +213,7 @@ function appendEventSegments({threadId,lastTimestampByThreadId,toolResponsesByTurnId,+ toolResponseRequiredByTurnId,approvalRequiredIdsByTurnId,subAgentToolCallIds,toolCallRequestsByTurnId,@@ -195,6 +230,7 @@ function appendEventSegments({threadId: string;lastTimestampByThreadId: Map<string, number>;toolResponsesByTurnId: Map<string, Map<string, TimelineEvent>>;+ toolResponseRequiredByTurnId: Map<string, Map<string, TimelineEvent>>;approvalRequiredIdsByTurnId: Map<string, Set<string>>;subAgentToolCallIds: Set<string>;toolCallRequestsByTurnId: Map<string, Map<string, SubAgentToolCallRequest>>;@@ -207,27 +243,35 @@ function appendEventSegments({const previousMs = lastTimestampByThreadId.get(threadId) ?? createdMs;const modelContent = extractText(event.content);const responses = toolResponsesByTurnId.get(turn.turnId);+ const pendingRequired = toolResponseRequiredByTurnId.get(turn.turnId);const approvalIds = approvalRequiredIdsByTurnId.get(turn.turnId);+ const turnDoneMs = parseTimestamp(terminalCompletedAt(turn.done?.state));// A model event can request several tools at once. Each tool gets its own// response-bounded interval; overlapping intervals are grouped later by// the chart-layout utility into one parallel-tool-call bar.+ // Pending human-wait tools (ask-user) still emit a bar so strip Tool calls+ // matches Agent steps even before tool.response arrives.for (const toolCall of toolCallsOf(event)) {const toolCallId = typeof toolCall.id === 'string' ? toolCall.id : undefined;// Skip parent create_sub_agent calls and approval-gated calls; they have their own segments.if (toolCallId == null || subAgentToolCallIds.has(toolCallId) || approvalIds?.has(toolCallId)) continue;const response = responses?.get(toolCallId);const responseMs = response == null ? null : parseTimestamp(eventCreatedAt(response));- if (responseMs == null || responseMs < eventMs) continue;+ const required = pendingRequired?.get(toolCallId);+ const requiredMs = required == null ? null : parseTimestamp(eventCreatedAt(required));+ const endMs = responseMs ?? requiredMs ?? turnDoneMs ?? eventMs;+ if (endMs < eventMs) continue;segments.push({id: `${eventId(event)}-${toolCallId}`,type: 'tool_call',title: 'tool.call',description: toolCallDescription(toolCall),startMs: eventMs - originMs,- endMs: responseMs - originMs,+ endMs: endMs - originMs,turnIndex,threadId,+ ...(responseMs == null && endMs <= eventMs ? { isMarker: true } : {}),});}@@ -331,6 +375,9 @@ function appendEventSegments({* Errors use the latest observed timestamp when the backend omitted* `completed_at`, ensuring failures remain visible instead of being dropped.* Running/paused turns have no terminal marker because they have not ended.+ * Intermediate `turn.done` markers are skipped when a later event-turn shares+ * the same display band (MCP-auth resume), so the diamond does not cover the+ * next model/tool bars.*/function appendTerminalSegment({turn,@@ -338,12 +385,14 @@ function appendTerminalSegment({originMs,latestMs,segments,+ emitDoneMarker,}: {turn: SessionTurnView;turnIndex: number;originMs: number;latestMs: number;segments: SessionEventTimelineSegment[];+ emitDoneMarker: boolean;}): void {const status = terminalStatus(turn.done?.state);if (status === 'error') {@@ -361,7 +410,7 @@ function appendTerminalSegment({});return;}- if (status !== 'done') return;+ if (status !== 'done' || !emitDoneMarker) return;const doneMs = parseTimestamp(terminalCompletedAt(turn.done?.state));if (doneMs == null) return;segments.push({diff --git a/packages/trueforge-ui/src/utils/sessionEventTimelineChart.ts b/packages/trueforge-ui/src/utils/sessionEventTimelineChart.tsindex a5f911b14..9dd1a1cf0 100644--- a/packages/trueforge-ui/src/utils/sessionEventTimelineChart.ts+++ b/packages/trueforge-ui/src/utils/sessionEventTimelineChart.ts@@ -88,21 +88,35 @@ export function getTimelineRange({ startMs, endMs }: TimelineGap): [number, numbreturn [startMs, endMs];}-/** Collapse point events at an identical chart timestamp into one marker and tooltip. */-export function groupCoincidentTimelineMarkers(segments: SessionEventTimelineSegment[]): TimelineMarkerGroup[] {- const groupsByTimestamp = new Map<number, SessionEventTimelineSegment[]>();- for (const segment of segments) {- if (!segment.isMarker) continue;- const group = groupsByTimestamp.get(segment.startMs);- if (group) group.push(segment);- else groupsByTimestamp.set(segment.startMs, [segment]);+/** Collapse point events that share (or nearly share) a chart timestamp into one marker and tooltip. */+export function groupCoincidentTimelineMarkers(+ segments: SessionEventTimelineSegment[],+ { toleranceMs = 0 }: { toleranceMs?: number } = {},+): TimelineMarkerGroup[] {+ const markers = segments+ .flatMap((segment, index) => (segment.isMarker ? [{ segment, index }] : []))+ .sort((left, right) => left.segment.startMs - right.segment.startMs || left.index - right.index)+ .map(({ segment }) => segment);++ const groups: TimelineMarkerGroup[] = [];+ for (const segment of markers) {+ const current = groups.at(-1);+ if (current != null && segment.startMs - current.startMs <= toleranceMs) {+ current.segments.push(segment);+ continue;+ }+ groups.push({+ id: segment.id,+ startMs: segment.startMs,+ endMs: segment.startMs,+ segments: [segment],+ });}- return Array.from(groupsByTimestamp, ([startMs, group]) => ({- id: `marker-group-${group.map(segment => segment.id).join('-')}`,- startMs,- endMs: startMs,- segments: group,- })).sort((left, right) => left.startMs - right.startMs);++ return groups.map(group => ({+ ...group,+ id: `marker-group-${group.segments.map(segment => segment.id).join('-')}`,+ }));}function timelineAxisUnit(totalMs: number): { divisorMs: number; suffix: string } {diff --git a/packages/trueforge-ui/src/utils/sessionTurnViews.ts b/packages/trueforge-ui/src/utils/sessionTurnViews.tsindex 5602cbe0b..abccf4a74 100644--- a/packages/trueforge-ui/src/utils/sessionTurnViews.ts+++ b/packages/trueforge-ui/src/utils/sessionTurnViews.ts@@ -6,7 +6,12 @@ type TurnEvent = Exclude<SessionEventItem['event'], TurnCreatedEvent | TurnDoneEexport type SessionTurnView = {turnId: string;+ /** Chronological index among every event turn (1..N). Unique; used for gap compression. */+ eventTurnNumber: number;+ /** Display band among renderable turns (1..R); MCP-auth resumes inherit the prior band. */turnNumber: number;+ /** True when the turn has user.message / tool_approval / tool_response input. */+ renderable: boolean;showHeader: boolean;created: TurnCreatedEvent;done?: TurnDoneEvent;@@ -113,23 +118,25 @@ export function buildSessionTurnViews(itemsAsc: SessionEventItem[]): SessionTurngroupsByTurnId.set(turnId, group);}- // Number only renderable turns so cards and the timeline share one index.+ // Include every turn.created (metrics need resume turns). Number timeline/transcript+ // bands by renderable turns only so MCP-auth resumes fold into the prior user turn.const groups = Array.from(groupsByTurnId.entries())- .flatMap(([turnId, group]) =>- group.created === undefined || !isRenderableTurn(group.created)- ? []- : [{ turnId, created: group.created, group }],- )+ .flatMap(([turnId, group]) => (group.created === undefined ? [] : [{ turnId, created: group.created, group }])).sort((left, right) => timestampMs(left.created.createdAt) - timestampMs(right.created.createdAt));+ let renderableTurnNumber = 0;return groups.map(({ turnId, created, group }, index) => {const done = group.done;+ const renderable = isRenderableTurn(created);+ if (renderable) renderableTurnNumber += 1;group.events.sort((left, right) => timestampMs(left.createdAt) - timestampMs(right.createdAt));return {turnId,- turnNumber: index + 1,- showHeader: true,+ eventTurnNumber: index + 1,+ turnNumber: Math.max(1, renderableTurnNumber),+ renderable,+ showHeader: renderable,created,...(done === undefined? {}@@ -142,3 +149,63 @@ export function buildSessionTurnViews(itemsAsc: SessionEventItem[]): SessionTurn};});}++/** Sum tokens/cost/duration for every event-turn that shares a display band. */+export function aggregateSessionTurnBand(+ turns: readonly SessionTurnView[],+ turnNumber: number,+): SessionTurnView | undefined {+ const band = turns.filter(turn => turn.turnNumber === turnNumber);+ const primary = band.find(turn => turn.renderable) ?? band[0];+ if (primary == null) return undefined;++ let totalTokens = 0;+ let inputTokens = 0;+ let outputTokens = 0;+ let cachedTokens = 0;+ let totalCostInUsd = 0;+ let durationMs = 0;+ let hasTokens = false;+ let hasInput = false;+ let hasOutput = false;+ let hasCached = false;+ let hasCost = false;+ let hasDuration = false;++ for (const turn of band) {+ if (turn.totalTokens != null) {+ totalTokens += turn.totalTokens;+ hasTokens = true;+ }+ if (turn.inputTokens != null) {+ inputTokens += turn.inputTokens;+ hasInput = true;+ }+ if (turn.outputTokens != null) {+ outputTokens += turn.outputTokens;+ hasOutput = true;+ }+ if (turn.cachedTokens != null) {+ cachedTokens += turn.cachedTokens;+ hasCached = true;+ }+ if (turn.totalCostInUsd != null) {+ totalCostInUsd += turn.totalCostInUsd;+ hasCost = true;+ }+ if (turn.durationMs != null) {+ durationMs += turn.durationMs;+ hasDuration = true;+ }+ }++ return {+ ...primary,+ ...(hasTokens ? { totalTokens } : {}),+ ...(hasInput ? { inputTokens } : {}),+ ...(hasOutput ? { outputTokens } : {}),+ ...(hasCached ? { cachedTokens } : {}),+ ...(hasCost ? { totalCostInUsd } : {}),+ ...(hasDuration ? { durationMs } : {}),+ };+}diff --git a/packages/trueforge-ui/test/atoms/AgentDetailsPage.test.tsx b/packages/trueforge-ui/test/atoms/AgentDetailsPage.test.tsxindex 52b90450a..bd998a7a5 100644--- a/packages/trueforge-ui/test/atoms/AgentDetailsPage.test.tsx+++ b/packages/trueforge-ui/test/atoms/AgentDetailsPage.test.tsx@@ -606,11 +606,11 @@ describe('AgentDetailsPage', () => {expect(screen.getByText('timeline-body')).toBeInTheDocument();});- it('passes getSession metrics into the selected session detail', async () => {+ it('passes getSession duration and cost into the selected session detail', async () => {renderPage({overrides: {AgentSessionTimelineContainer: ({ sessionMetrics }) => (- <div>{`${String(sessionMetrics?.totalTurns)} turns, ${String(sessionMetrics?.totalDurationMs)}ms, $${String(sessionMetrics?.totalCostInUsd)}`}</div>+ <div>{`${String(sessionMetrics?.totalDurationMs)}ms, $${String(sessionMetrics?.totalCostInUsd)}`}</div>),},});@@ -618,7 +618,7 @@ describe('AgentDetailsPage', () => {fireEvent.click(screen.getByRole('tab', { name: 'Sessions' }));fireEvent.click(await screen.findByText('Release notes draft'));- expect(await screen.findByText('4 turns, 90000ms, $1.25')).toBeInTheDocument();+ expect(await screen.findByText('90000ms, $1.25')).toBeInTheDocument();});it('shows the shared unavailable state without the optional server', () => {diff --git a/packages/trueforge-ui/test/atoms/AgentSessionEventTimeline.test.tsx b/packages/trueforge-ui/test/atoms/AgentSessionEventTimeline.test.tsxindex 3baa6b9a3..4db9901a7 100644--- a/packages/trueforge-ui/test/atoms/AgentSessionEventTimeline.test.tsx+++ b/packages/trueforge-ui/test/atoms/AgentSessionEventTimeline.test.tsx@@ -7,10 +7,12 @@ import { SlotsProvider } from '@/theme/SlotsProvider.js';import type { SessionEventTimelineSegment } from '@/utils/sessionEventTimeline.js';import type { SessionTurnView } from '@/utils/sessionTurnViews.js';-const turns = [+const turns: SessionTurnView[] = [{turnId: 't1',+ eventTurnNumber: 1,turnNumber: 1,+ renderable: true,showHeader: true,created: {type: 'turn.created',@@ -24,7 +26,7 @@ const turns = [},events: [],},-] as SessionTurnView[];+];const segments: SessionEventTimelineSegment[] = [{diff --git a/packages/trueforge-ui/test/atoms/AgentSessionEventTimelineChart.test.tsx b/packages/trueforge-ui/test/atoms/AgentSessionEventTimelineChart.test.tsxindex 2939c73a6..fa2272da7 100644--- a/packages/trueforge-ui/test/atoms/AgentSessionEventTimelineChart.test.tsx+++ b/packages/trueforge-ui/test/atoms/AgentSessionEventTimelineChart.test.tsx@@ -24,7 +24,9 @@ vi.mock('react-chartjs-2', () => ({const turns: SessionTurnView[] = [{turnId: 'turn-1',+ eventTurnNumber: 1,turnNumber: 1,+ renderable: true,showHeader: true,created: {type: 'turn.created',diff --git a/packages/trueforge-ui/test/utils/sessionAgentDetails.test.ts b/packages/trueforge-ui/test/utils/sessionAgentDetails.test.tsindex 691275f9d..d8c332c17 100644--- a/packages/trueforge-ui/test/utils/sessionAgentDetails.test.ts+++ b/packages/trueforge-ui/test/utils/sessionAgentDetails.test.ts@@ -126,6 +126,7 @@ describe('buildSessionTurnViews', () => {({turnId,turnNumber,+ renderable,showHeader,durationMs,totalTokens,@@ -136,6 +137,7 @@ describe('buildSessionTurnViews', () => {}) => ({turnId,turnNumber,+ renderable,showHeader,durationMs,totalTokens,@@ -149,6 +151,7 @@ describe('buildSessionTurnViews', () => {{turnId: 'turn-1',turnNumber: 1,+ renderable: true,showHeader: true,durationMs: 60_000,totalTokens: 122_000,@@ -161,6 +164,7 @@ describe('buildSessionTurnViews', () => {{turnId: 'turn-2',turnNumber: 2,+ renderable: true,showHeader: true,durationMs: 60_000,totalTokens: 122_000,@@ -268,19 +272,58 @@ describe('buildSessionTurnViews', () => {);});- it('skips turns that have no renderable user input', () => {+ it('keeps turns without renderable user input marked non-renderable', () => {+ const views = buildSessionTurnViews([+ createdItem({ turnId: 'hidden', createdAt: '2026-01-01T00:00:00.000Z' }),+ createdItem({+ turnId: 'shown',+ createdAt: '2026-01-01T00:00:01.000Z',+ input: [{ type: 'user.tool_approval', threadId: 'main', toolCallId: 'call-1', approval: { status: 'allow' } }],+ }),+ ]);+assert.deepEqual(- buildSessionTurnViews([- createdItem({ turnId: 'hidden', createdAt: '2026-01-01T00:00:00.000Z' }),- createdItem({- turnId: 'shown',- createdAt: '2026-01-01T00:00:01.000Z',- input: [- { type: 'user.tool_approval', threadId: 'main', toolCallId: 'call-1', approval: { status: 'allow' } },- ],- }),- ]).map(view => view.turnId),- ['shown'],+ views.map(view => ({+ turnId: view.turnId,+ turnNumber: view.turnNumber,+ renderable: view.renderable,+ showHeader: view.showHeader,+ })),+ [+ // Empty-input resume before any user turn still lands in band 1.+ { turnId: 'hidden', turnNumber: 1, renderable: false, showHeader: false },+ { turnId: 'shown', turnNumber: 1, renderable: true, showHeader: true },+ ],+ );+ });++ it('folds MCP-auth resume turns into the prior renderable turn number', () => {+ const views = buildSessionTurnViews([+ createdItem({+ turnId: 'user',+ createdAt: '2026-01-01T00:00:00.000Z',+ input: [{ type: 'user.message', content: 'hello' }],+ }),+ createdItem({ turnId: 'resume', createdAt: '2026-01-01T00:00:05.000Z' }),+ createdItem({+ turnId: 'next',+ createdAt: '2026-01-01T00:00:10.000Z',+ input: [{ type: 'user.message', content: 'again' }],+ }),+ ]);++ assert.deepEqual(+ views.map(view => ({+ turnId: view.turnId,+ eventTurnNumber: view.eventTurnNumber,+ turnNumber: view.turnNumber,+ renderable: view.renderable,+ })),+ [+ { turnId: 'user', eventTurnNumber: 1, turnNumber: 1, renderable: true },+ { turnId: 'resume', eventTurnNumber: 2, turnNumber: 1, renderable: false },+ { turnId: 'next', eventTurnNumber: 3, turnNumber: 2, renderable: true },+ ],);});});diff --git a/packages/trueforge-ui/test/utils/sessionEventTimeline.test.ts b/packages/trueforge-ui/test/utils/sessionEventTimeline.test.tsindex 79887eeb6..3994f38d0 100644--- a/packages/trueforge-ui/test/utils/sessionEventTimeline.test.ts+++ b/packages/trueforge-ui/test/utils/sessionEventTimeline.test.ts@@ -191,6 +191,144 @@ describe('buildSessionTimelineSegments', () => {assert.equal(groups[0]?.segments.length, 2);});+ it('excludes sub-agent thread tool calls from strip Tool calls', () => {+ const turns = buildSessionTurnViews([+ created({ turnId: 't1', createdAt: '2026-01-01T00:00:00.000Z' }),+ {+ turnId: 't1',+ event: {+ type: 'model.message',+ id: 'model-main',+ threadId: 'main',+ content: 'root',+ createdAt: '2026-01-01T00:00:01.000Z',+ toolCalls: [+ { id: 'call-main', type: 'function', function: { name: 'search', arguments: '{}' } },+ { id: 'call-sub', type: 'function', function: { name: 'create_sub_agent', arguments: '{}' } },+ ],+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'thread.created',+ id: 'thread-1',+ threadId: 'child',+ title: 'Researcher',+ createdAt: '2026-01-01T00:00:01.100Z',+ agentInfo: { type: 'dynamic', name: 'researcher', input: 'research' },+ parent: { threadId: 'main', toolCallId: 'call-sub' },+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'model.message',+ id: 'model-child',+ threadId: 'child',+ content: 'child work',+ createdAt: '2026-01-01T00:00:02.000Z',+ toolCalls: [+ { id: 'call-child-a', type: 'function', function: { name: 'child_search', arguments: '{}' } },+ { id: 'call-child-b', type: 'function', function: { name: 'child_fetch', arguments: '{}' } },+ ],+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'tool.response',+ id: 'resp-main',+ threadId: 'main',+ toolCallId: 'call-main',+ content: 'ok',+ createdAt: '2026-01-01T00:00:03.000Z',+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'tool.response',+ id: 'resp-child-a',+ threadId: 'child',+ toolCallId: 'call-child-a',+ content: 'a',+ createdAt: '2026-01-01T00:00:03.500Z',+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'tool.response',+ id: 'resp-child-b',+ threadId: 'child',+ toolCallId: 'call-child-b',+ content: 'b',+ createdAt: '2026-01-01T00:00:04.000Z',+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'thread.done',+ id: 'thread-done',+ threadId: 'child',+ title: 'Researcher',+ createdAt: '2026-01-01T00:00:04.500Z',+ state: { status: 'completed' },+ },+ },+ done({ turnId: 't1', createdAt: '2026-01-01T00:00:05.000Z' }),+ ]);++ const segments = buildSessionTimelineSegments(turns);+ assert.equal(segments.filter(segment => segment.type === 'tool_call').length, 3);+ assert.equal(buildSessionMetrics({ turns, segments }).toolCalls, 1);+ assert.equal(buildSessionMetrics({ turns, segments }).subAgents, 1);+ });++ it('counts pending ask-user tool calls waiting on tool.response_required', () => {+ const turns = buildSessionTurnViews([+ created({ turnId: 't1', createdAt: '2026-01-01T00:00:00.000Z' }),+ {+ turnId: 't1',+ event: {+ type: 'model.message',+ id: 'model-1',+ threadId: 'main',+ content: '',+ createdAt: '2026-01-01T00:00:01.000Z',+ toolCalls: [+ {+ id: 'call-ask',+ type: 'function',+ function: { name: 'ask_user_question', arguments: '{"question":"clarify?"}' },+ },+ ],+ },+ },+ {+ turnId: 't1',+ event: {+ type: 'tool.response_required',+ id: 'required-1',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:01.100Z',+ toolCalls: [{ id: 'call-ask', sourceEventId: 'model-1' }],+ },+ },+ done({ turnId: 't1', createdAt: '2026-01-01T00:00:01.200Z' }),+ ]);++ const segments = buildSessionTimelineSegments(turns);+ const toolCalls = segments.filter(segment => segment.type === 'tool_call');+ assert.equal(toolCalls.length, 1);+ assert.equal(toolCalls[0]?.description, 'ask_user_question');+ assert.equal(toolCalls[0]?.startMs, 1_000);+ assert.equal(toolCalls[0]?.endMs, 1_100);+ assert.equal(buildSessionMetrics({ turns, segments }).toolCalls, 1);+ });+it('labels deferred MCP meta-tool bars with the underlying tool name', () => {const turns = buildSessionTurnViews([created({ turnId: 't1', createdAt: '2026-01-01T00:00:00.000Z' }),@@ -438,6 +576,22 @@ describe('sessionEventTimelineChart helpers', () => {);});+ it('groups near-coincident markers within tolerance into one tooltip target', () => {+ assert.deepEqual(+ groupCoincidentTimelineMarkers(+ [marker('auth', 'waiting_on_human', 10), marker('done', 'system', 14), marker('later', 'user', 40)],+ { toleranceMs: 5 },+ ).map(group => ({+ startMs: group.startMs,+ ids: group.segments.map(segment => segment.id),+ })),+ [+ { startMs: 10, ids: ['auth', 'done'] },+ { startMs: 40, ids: ['later'] },+ ],+ );+ });+it('maps clean active-time ticks around fixed turn separators', () => {const gaps = [{ startMs: 42_000, endMs: 43_000 }];const ticks = buildTimelineAxisTicks({@@ -584,7 +738,7 @@ describe('buildSessionMetrics', () => {assert.equal(metrics.totalCostUsd, undefined);});- it('uses sessionMetrics exclusively for turns, duration, and cost', () => {+ it('uses sessionMetrics for duration and cost; turn count always from events', () => {const turns = buildSessionTurnViews([created({ turnId: 't1', createdAt: '2026-01-01T00:00:00.000Z' }),{@@ -615,11 +769,171 @@ describe('buildSessionMetrics', () => {const metrics = buildSessionMetrics({turns,segments: buildSessionTimelineSegments(turns),- sessionMetrics: { totalTurns: 3, totalDurationMs: 81_715, totalCostInUsd: 0.3106 },+ sessionMetrics: { totalDurationMs: 81_715, totalCostInUsd: 0.3106 },});- assert.equal(metrics.totalTurns, 3);+ assert.equal(metrics.totalTurns, 1);assert.equal(metrics.wallTimeMs, 81_715);assert.equal(metrics.totalCostUsd, 0.3106);assert.equal(metrics.totalTokens, 80);});++ it('counts turns and tool calls from non-renderable resume turns', () => {+ const turns = buildSessionTurnViews([+ created({+ turnId: 'auth',+ createdAt: '2026-01-01T00:00:00.000Z',+ }),+ {+ turnId: 'auth',+ event: {+ type: 'model.message',+ id: 'auth-model',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:01.000Z',+ content: '',+ toolCalls: [{ id: 'call-auth', type: 'function', function: { name: 'list_tools', arguments: '{}' } }],+ },+ },+ {+ turnId: 'auth',+ event: {+ type: 'tool.response',+ id: 'auth-resp',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:01.500Z',+ toolCallId: 'call-auth',+ content: 'ok',+ },+ },+ {+ turnId: 'auth',+ event: {+ type: 'turn.done',+ id: 'auth-done',+ state: {+ status: 'done',+ completedAt: '2026-01-01T00:00:02.000Z',+ output: null,+ requiredActions: [],+ metrics: {+ totalTokens: 100,+ totalCostInUsd: 0.01,+ totalInputTokens: 80,+ totalOutputTokens: 20,+ totalCacheReadTokens: 0,+ totalCacheWriteTokens: 0,+ totalReasoningTokens: 0,+ },+ },+ createdAt: '2026-01-01T00:00:02.000Z',+ threadId: null,+ },+ },+ {+ turnId: 'resume',+ event: {+ type: 'turn.created',+ id: 'resume-created',+ turnId: 'resume',+ previousTurnId: 'auth',+ state: { status: 'running' },+ createdAt: '2026-01-01T00:00:03.000Z',+ threadId: null,+ },+ },+ {+ turnId: 'resume',+ event: {+ type: 'model.message',+ id: 'resume-model',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:04.000Z',+ content: '',+ toolCalls: [+ { id: 'call-a', type: 'function', function: { name: 'exec', arguments: '{}' } },+ { id: 'call-b', type: 'function', function: { name: 'call_tool', arguments: '{}' } },+ ],+ },+ },+ {+ turnId: 'resume',+ event: {+ type: 'tool.response',+ id: 'resume-resp-a',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:05.000Z',+ toolCallId: 'call-a',+ content: 'a',+ },+ },+ {+ turnId: 'resume',+ event: {+ type: 'tool.response',+ id: 'resume-resp-b',+ threadId: 'main',+ createdAt: '2026-01-01T00:00:05.500Z',+ toolCallId: 'call-b',+ content: 'b',+ },+ },+ {+ turnId: 'resume',+ event: {+ type: 'turn.done',+ id: 'resume-done',+ state: {+ status: 'done',+ completedAt: '2026-01-01T00:00:06.000Z',+ output: null,+ requiredActions: [],+ metrics: {+ totalTokens: 900,+ totalCostInUsd: 0.09,+ totalInputTokens: 700,+ totalOutputTokens: 200,+ totalCacheReadTokens: 0,+ totalCacheWriteTokens: 0,+ totalReasoningTokens: 0,+ },+ },+ createdAt: '2026-01-01T00:00:06.000Z',+ threadId: null,+ },+ },+ ]);++ assert.equal(turns.length, 2);+ assert.equal(turns[0]?.renderable, true);+ assert.equal(turns[1]?.renderable, false);++ const segments = buildSessionTimelineSegments(turns);+ assert.equal(+ segments.filter(segment => segment.type === 'user').length,+ 1,+ 'non-renderable resume turns must not emit phantom user markers',+ );+ assert.equal(segments.filter(segment => segment.type === 'user')[0]?.turnIndex, 0);+ assert.ok(+ segments.every(segment => segment.turnIndex === 0),+ 'resume-turn activity stays on the same timeline band as the user turn',+ );+ assert.deepEqual(+ segments.filter(segment => segment.title === 'turn.done').map(segment => segment.id),+ ['resume-turn.done'],+ 'auth turn.done is omitted so it does not cover the resume model/tool bars',+ );+ // Auth's last bar ends at +1.5s; resume wall-clock starts later — compression removes the idle.+ const resumeModel = segments.find(segment => segment.id === 'resume-model');+ assert.equal(resumeModel?.startMs, 1_500);+ const metrics = buildSessionMetrics({ turns, segments });+ assert.equal(metrics.totalTurns, 2);+ assert.equal(metrics.toolCalls, 3);+ assert.equal(metrics.totalTokens, 1000);+ assert.deepEqual(+ metrics.costPerTurn.map(row => row.label),+ ['T1'],+ );+ assert.ok(Math.abs((metrics.costPerTurn[0]?.value ?? 0) - 0.1) < 1e-9);+ });});