Skip to content

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.md
new file mode 100644
index 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.tsx
index 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.tsx
index 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 => (
<SessionTurnSection
key={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.ts
index 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.ts
index 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[]): SessionE
const 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[]): SessionE
const 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[]): SessionE
threadId,
lastTimestampByThreadId,
toolResponsesByTurnId,
+ toolResponseRequiredByTurnId,
approvalRequiredIdsByTurnId,
subAgentToolCallIds,
toolCallRequestsByTurnId,
@@ -151,7 +173,14 @@ export function buildSessionTimelineSegments(turns: SessionTurnView[]): SessionE
lastTimestampByThreadId.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[]): SessionE
startMs: 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.ts
index 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, numb
return [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.ts
index 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 | TurnDoneE
export 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[]): SessionTurn
groupsByTurnId.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.tsx
index 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.tsx
index 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.tsx
index 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.ts
index 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.ts
index 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);
+ });
});