Skip to content

Commit 14e9c64

Browse files
maria-rcksclaude
andcommitted
fix(chat): harden thinking traces against review findings
Review of the first commit found real defects. Fixed here: - A reasoning block could reopen after being completed. Segment indexes now advance monotonically for reasoning, whose base key alternates when one provider item streams both a summary and a raw trace. - A reasoning delta with no turn id opened a block nothing could ever close. Every close path is turn-keyed, so those deltas are skipped. - A provider reporting a whole block through `item.completed` detail, with no deltas, produced nothing: the snapshot had no open segment to land in. - Reasoning no longer streams token by token even in token mode. The block is collapsed by default, so a command, an event-store write and a fan-out per token bought nothing on text longer than the answer. - The web "Thinking" label never animated: its shimmer needs an ancestor carrying the visible-animation state. - Mobile stacked a second "Thinking" row under the live one, and its settle effect never re-ran for a reasoning toggle. - Placeholder suppression is scoped to the live turn, so a block stranded by a killed server cannot silence the activity row for every later turn. - Both clients anchored scroll restoration to a key that matched no row. - Interactive markdown moved out of the disclosure's button, so Enter on a link inside a trace no longer collapses the row. - Web now formats the duration like every other elapsed label in the app. Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>
1 parent cba2e73 commit 14e9c64

6 files changed

Lines changed: 177 additions & 69 deletions

File tree

‎apps/mobile/src/features/threads/ThreadFeed.tsx‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2565,7 +2565,13 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
25652565
if (disclosureAnchorKeyRef.current !== null) {
25662566
settleDisclosureAfterLayout();
25672567
}
2568-
}, [expandedTurnIds, expandedWorkGroups, expandedWorkRows, settleDisclosureAfterLayout]);
2568+
}, [
2569+
expandedTurnIds,
2570+
expandedWorkGroups,
2571+
expandedWorkRows,
2572+
expandedReasoningMessageIds,
2573+
settleDisclosureAfterLayout,
2574+
]);
25692575

25702576
const handleItemSizeChanged = useCallback(() => {
25712577
if (disclosureAnchorKeyRef.current !== null) {
@@ -2650,7 +2656,9 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
26502656

26512657
const onToggleReasoning = useCallback(
26522658
(messageId: string) => {
2653-
suspendEndScrollMaintenanceForDisclosure(`reasoning:${messageId}`);
2659+
// The anchor must be the feed row id, which for a message row is the
2660+
// message id, or position restoration is skipped for every row.
2661+
suspendEndScrollMaintenanceForDisclosure(messageId);
26542662
setInteractionState((current) => {
26552663
const next = new Set(current.expandedReasoningMessageIds);
26562664
if (next.has(messageId)) {

‎apps/mobile/src/lib/threadActivity.ts‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1833,6 +1833,15 @@ export function deriveThreadFeedPresentation(
18331833
!result.some(
18341834
(row) =>
18351835
(row.type === "work-toggle" && row.shimmer) ||
1836+
// A live thinking block is the real version of this row, so it takes
1837+
// the slot instead of sitting under a second "Thinking". Scoped to the
1838+
// live turn: a block stranded by a killed server must not silence this
1839+
// row for every turn that follows.
1840+
(row.type === "message" &&
1841+
row.message.role === "reasoning" &&
1842+
row.message.streaming &&
1843+
row.message.turnId !== null &&
1844+
row.message.turnId === unsettledTurnId) ||
18361845
// A working spawn card is the live activity: its status line shows
18371846
// what the agents are doing, so a Thinking row under it would lie.
18381847
(row.type === "agent-spawn" &&

‎apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1500,6 +1500,81 @@ describe("ProviderRuntimeIngestion", () => {
15001500
expect(message?.text).toBe("**First**\n\n**Second**");
15011501
});
15021502

1503+
it("uses a reasoning item's detail when no reasoning deltas were streamed", async () => {
1504+
const harness = await createHarness();
1505+
const now = "2026-01-01T00:00:00.000Z";
1506+
1507+
harness.emit({
1508+
type: "item.completed",
1509+
eventId: asEventId("evt-reasoning-snapshot"),
1510+
provider: ProviderDriverKind.make("codex"),
1511+
createdAt: now,
1512+
threadId: asThreadId("thread-1"),
1513+
turnId: asTurnId("turn-snapshot"),
1514+
itemId: asItemId("item-snapshot"),
1515+
payload: {
1516+
itemType: "reasoning",
1517+
status: "completed",
1518+
detail: "reasoning reported in one piece",
1519+
},
1520+
});
1521+
1522+
const thread = await waitForThread(harness.readModel, (entry) =>
1523+
entry.messages.some(
1524+
(message: ProviderRuntimeTestMessage) => message.role === "reasoning" && !message.streaming,
1525+
),
1526+
);
1527+
const message = thread.messages.find(
1528+
(entry: ProviderRuntimeTestMessage) => entry.role === "reasoning",
1529+
);
1530+
expect(message?.text).toBe("reasoning reported in one piece");
1531+
});
1532+
1533+
it("keeps interleaved summary and raw reasoning in separate blocks", async () => {
1534+
const harness = await createHarness();
1535+
const now = "2026-01-01T00:00:00.000Z";
1536+
1537+
// Distinct timestamps: blocks are ordered by when the provider opened them.
1538+
for (const [tag, at, streamKind, delta] of [
1539+
["a", "2026-01-01T00:00:01.000Z", "reasoning_summary_text", "summary one"],
1540+
["b", "2026-01-01T00:00:02.000Z", "reasoning_text", "raw one"],
1541+
["c", "2026-01-01T00:00:03.000Z", "reasoning_summary_text", "summary two"],
1542+
] as const) {
1543+
harness.emit({
1544+
type: "content.delta",
1545+
eventId: asEventId(`evt-interleaved-${tag}`),
1546+
provider: ProviderDriverKind.make("codex"),
1547+
createdAt: at,
1548+
threadId: asThreadId("thread-1"),
1549+
turnId: asTurnId("turn-interleaved"),
1550+
itemId: asItemId("item-interleaved"),
1551+
payload: { streamKind, delta },
1552+
});
1553+
}
1554+
harness.emit({
1555+
type: "item.completed",
1556+
eventId: asEventId("evt-interleaved-completed"),
1557+
provider: ProviderDriverKind.make("codex"),
1558+
createdAt: now,
1559+
threadId: asThreadId("thread-1"),
1560+
turnId: asTurnId("turn-interleaved"),
1561+
itemId: asItemId("item-interleaved"),
1562+
payload: { itemType: "reasoning", status: "completed" },
1563+
});
1564+
1565+
const thread = await waitForThread(
1566+
harness.readModel,
1567+
(entry) =>
1568+
entry.messages.filter((message: ProviderRuntimeTestMessage) => message.role === "reasoning")
1569+
.length === 3,
1570+
);
1571+
const reasoning = thread.messages.filter(
1572+
(entry: ProviderRuntimeTestMessage) => entry.role === "reasoning",
1573+
);
1574+
expect(reasoning.map((entry) => entry.text)).toEqual(["summary one", "raw one", "summary two"]);
1575+
expect(new Set(reasoning.map((entry) => entry.id)).size).toBe(3);
1576+
});
1577+
15031578
it("closes the reasoning block when the assistant starts answering", async () => {
15041579
const harness = await createHarness();
15051580
const now = "2026-01-01T00:00:00.000Z";

‎apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts‎

Lines changed: 42 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1193,11 +1193,15 @@ const make = Effect.gen(function* () {
11931193
activeMessageId: assistantSegmentMessageId(input.baseKey, 0, role),
11941194
}),
11951195
onSome: (state) => {
1196-
const segmentIndex = state.baseKey === input.baseKey ? state.nextSegmentIndex : 0;
1196+
// Reasoning never resets the index on a new base key: one item can
1197+
// stream a summary and a raw trace, and summary -> raw -> summary
1198+
// would otherwise reuse the id of the first, finished block.
1199+
const reuseIndex = state.baseKey === input.baseKey || role === "reasoning";
1200+
const segmentIndex = reuseIndex ? state.nextSegmentIndex : 0;
11971201
const messageId = assistantSegmentMessageId(input.baseKey, segmentIndex, role);
11981202
return {
11991203
baseKey: input.baseKey,
1200-
nextSegmentIndex: state.baseKey === input.baseKey ? state.nextSegmentIndex + 1 : 1,
1204+
nextSegmentIndex: reuseIndex ? state.nextSegmentIndex + 1 : 1,
12011205
activeMessageId: messageId,
12021206
} satisfies AssistantSegmentState;
12031207
},
@@ -1245,13 +1249,9 @@ const make = Effect.gen(function* () {
12451249
event: ProviderRuntimeEvent;
12461250
baseKey: string;
12471251
createdAt: string;
1248-
turnId?: TurnId;
1252+
turnId: TurnId;
12491253
}) =>
12501254
Effect.gen(function* () {
1251-
if (!input.turnId) {
1252-
return assistantSegmentMessageId(input.baseKey, 0, "reasoning");
1253-
}
1254-
12551255
const state = yield* getAssistantSegmentStateForTurn(
12561256
input.threadId,
12571257
input.turnId,
@@ -1927,18 +1927,20 @@ const make = Effect.gen(function* () {
19271927
const proposedPlanDelta =
19281928
event.type === "turn.proposed.delta" ? event.payload.delta : undefined;
19291929

1930-
if (reasoningDelta && reasoningDelta.delta.length > 0) {
1931-
const turnId = toTurnId(event.turnId);
1930+
const reasoningTurnId = toTurnId(event.turnId);
1931+
// Every close path for a thinking block is keyed by turn. Without one the
1932+
// block could never be completed, and a row stuck mid-thought is worse
1933+
// than no row at all.
1934+
if (reasoningDelta && reasoningDelta.delta.length > 0 && reasoningTurnId) {
1935+
const turnId = reasoningTurnId;
19321936
const reasoningMessageId = yield* getOrCreateReasoningMessageId({
19331937
threadId: thread.id,
19341938
event,
19351939
baseKey: reasoningSegmentBaseKeyFromEvent(event, reasoningDelta.streamKind),
19361940
createdAt: now,
1937-
...(turnId ? { turnId } : {}),
1941+
turnId,
19381942
});
1939-
if (turnId) {
1940-
yield* rememberAssistantMessageId(thread.id, turnId, reasoningMessageId);
1941-
}
1943+
yield* rememberAssistantMessageId(thread.id, turnId, reasoningMessageId);
19421944

19431945
if (
19441946
Option.getOrElse(
@@ -1965,33 +1967,26 @@ const make = Effect.gen(function* () {
19651967
);
19661968
}
19671969

1970+
// Reasoning is never delivered token by token, even when the project
1971+
// asks for it: the block is collapsed by default, so a command, an
1972+
// event-store write and a fan-out per token would buy nothing. Traces
1973+
// are longer than the answers they precede.
19681974
const streamingMode = yield* resolveResponseStreamingMode(thread.projectId);
1969-
if (streamingMode !== "token") {
1970-
const spillChunk = yield* appendBufferedAssistantText(
1971-
reasoningMessageId,
1972-
delta,
1973-
streamingMode,
1974-
yield* Clock.currentTimeMillis,
1975-
);
1976-
if (spillChunk.length > 0) {
1977-
yield* orchestrationEngine.dispatch({
1978-
type: "thread.message.reasoning.delta",
1979-
commandId: yield* providerCommandId(event, "reasoning-delta-buffer-spill"),
1980-
threadId: thread.id,
1981-
messageId: reasoningMessageId,
1982-
delta: spillChunk,
1983-
...(turnId ? { turnId } : {}),
1984-
createdAt: yield* reasoningStartedAt(reasoningMessageId, now),
1985-
});
1986-
}
1987-
} else {
1975+
const reasoningMode = streamingMode === "token" ? "paragraph" : streamingMode;
1976+
const spillChunk = yield* appendBufferedAssistantText(
1977+
reasoningMessageId,
1978+
delta,
1979+
reasoningMode,
1980+
yield* Clock.currentTimeMillis,
1981+
);
1982+
if (spillChunk.length > 0) {
19881983
yield* orchestrationEngine.dispatch({
19891984
type: "thread.message.reasoning.delta",
1990-
commandId: yield* providerCommandId(event, "reasoning-delta"),
1985+
commandId: yield* providerCommandId(event, "reasoning-delta-buffer-spill"),
19911986
threadId: thread.id,
19921987
messageId: reasoningMessageId,
1993-
delta,
1994-
...(turnId ? { turnId } : {}),
1988+
delta: spillChunk,
1989+
turnId,
19951990
createdAt: yield* reasoningStartedAt(reasoningMessageId, now),
19961991
});
19971992
}
@@ -2154,6 +2149,18 @@ const make = Effect.gen(function* () {
21542149
(existingReasoningMessage === undefined || existingReasoningMessage.text.length === 0)
21552150
? event.payload.detail
21562151
: undefined;
2152+
2153+
// A provider can report a whole block at once without streaming it.
2154+
// Open a segment so the snapshot has somewhere to land.
2155+
if (Option.isNone(activeReasoningMessageId) && fallbackText !== undefined) {
2156+
yield* startAssistantSegmentForTurn({
2157+
threadId: thread.id,
2158+
turnId,
2159+
baseKey: reasoningSegmentBaseKeyFromEvent(event, "reasoning_text"),
2160+
role: "reasoning",
2161+
});
2162+
}
2163+
21572164
yield* finalizeActiveSegmentForTurn({
21582165
event,
21592166
threadId: thread.id,

‎apps/web/src/components/chat/MessagesTimeline.logic.ts‎

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -768,7 +768,15 @@ function attachTrailingToolGroupsToAssistant(
768768
let hasTrailingToolGroup = false;
769769
for (let index = messageIndex + 1; index < rows.length; index += 1) {
770770
const candidate = rows[index];
771-
if (!candidate || candidate.kind === "message") {
771+
if (!candidate) {
772+
break;
773+
}
774+
// A thinking block can follow the answer (the next one starts before its
775+
// tool call); it is not another message in the conversation.
776+
if (candidate.kind === "message" && candidate.message.role === "reasoning") {
777+
continue;
778+
}
779+
if (candidate.kind === "message") {
772780
break;
773781
}
774782
if (candidate.kind === "work-toggle" && candidate.turnId === turnId) {
@@ -1295,7 +1303,12 @@ export function deriveMessagesTimelineRows(input: {
12951303
// A live thinking block is the real version of the placeholder below, so it
12961304
// suppresses it rather than sitting under a second "Thinking" row.
12971305
const hasStreamingReasoningRow = nextRows.some(
1298-
(row) => row.kind === "message" && row.message.role === "reasoning" && row.message.streaming,
1306+
(row) =>
1307+
row.kind === "message" &&
1308+
row.message.role === "reasoning" &&
1309+
row.message.streaming &&
1310+
row.message.turnId !== null &&
1311+
row.message.turnId === unsettledTurnId,
12991312
);
13001313
if (input.isWorking && !hasStreamingReasoningRow && (!hasActivityRow || latestToolFailed)) {
13011314
nextRows.push({

‎apps/web/src/components/chat/MessagesTimeline.tsx‎

Lines changed: 26 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -645,7 +645,9 @@ export const MessagesTimeline = memo(function MessagesTimeline({
645645
);
646646
const onToggleReasoning = useCallback(
647647
(messageId: string, expanded: boolean) => {
648-
suspendEndScrollMaintenanceForDisclosure(`reasoning:${messageId}`, !expanded);
648+
// The anchor must be the timeline row id, which for a message row is the
649+
// message id, or position restoration is skipped for every row.
650+
suspendEndScrollMaintenanceForDisclosure(messageId, !expanded);
649651
setExpandedReasoningMessageIds((current) => {
650652
if (current.has(messageId) === expanded) return current;
651653
const next = new Set(current);
@@ -2173,36 +2175,34 @@ const ReasoningTimelineRow = memo(function ReasoningTimelineRow({
21732175
const toggle = useCallback(() => {
21742176
onToggleReasoning(message.id, !expanded);
21752177
}, [expanded, message.id, onToggleReasoning]);
2176-
const elapsed = streaming ? null : formatWorkingTimer(message.createdAt, message.updatedAt);
2178+
const elapsedMs = streaming
2179+
? null
2180+
: Date.parse(message.updatedAt) - Date.parse(message.createdAt);
2181+
const elapsed =
2182+
elapsedMs !== null && Number.isFinite(elapsedMs) && elapsedMs >= 0
2183+
? formatDuration(elapsedMs)
2184+
: null;
21772185
const label = streaming ? "Thinking" : elapsed ? `Thought for ${elapsed}` : "Thought";
21782186

21792187
return (
2180-
<div
2181-
className={cn(
2182-
"flex flex-col rounded-md px-0.5 py-0.5 transition-colors",
2183-
expanded && "mb-1",
2184-
"cursor-pointer hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70",
2185-
)}
2186-
role="button"
2187-
tabIndex={0}
2188-
aria-expanded={expanded}
2189-
onClick={toggle}
2190-
onKeyDown={(event: KeyboardEvent<HTMLDivElement>) => {
2191-
if (event.key === "Enter" || event.key === " ") {
2192-
event.preventDefault();
2193-
toggle();
2194-
}
2195-
}}
2196-
>
2197-
<div className="flex select-none items-center gap-1.5">
2188+
<div className={cn("flex flex-col", expanded && "mb-1")}>
2189+
<button
2190+
type="button"
2191+
aria-expanded={expanded}
2192+
onClick={toggle}
2193+
className="flex cursor-pointer select-none items-center gap-1.5 rounded-md px-0.5 py-0.5 text-start transition-colors hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"
2194+
>
21982195
<span className="flex size-6 shrink-0 items-center justify-center text-icon-muted">
21992196
<BrainIcon aria-hidden className="block size-4 shrink-0 stroke-[1.8] opacity-70" />
22002197
</span>
2201-
<div className="flex min-w-0 flex-1 items-center gap-1.5">
2202-
<p className="relative min-w-0 flex-1 truncate text-secondary-label text-sm leading-relaxed">
2198+
<span className="flex min-w-0 flex-1 items-center gap-1.5">
2199+
<span
2200+
ref={streaming ? observeVisibleAnimation : undefined}
2201+
className="relative min-w-0 flex-1 truncate text-secondary-label text-sm leading-relaxed"
2202+
>
22032203
{label}
22042204
{streaming ? <ActivityShimmerOverlay>{label}</ActivityShimmerOverlay> : null}
2205-
</p>
2205+
</span>
22062206
<span className="flex size-4 shrink-0 items-center justify-center" aria-hidden>
22072207
<ChevronRightIcon
22082208
className={cn(
@@ -2211,14 +2211,10 @@ const ReasoningTimelineRow = memo(function ReasoningTimelineRow({
22112211
)}
22122212
/>
22132213
</span>
2214-
</div>
2215-
</div>
2214+
</span>
2215+
</button>
22162216
{expanded ? (
2217-
<div
2218-
className="mt-1 ms-7 max-h-96 cursor-default overflow-auto rounded-md bg-muted/40 px-3 py-2 text-secondary-label select-text"
2219-
onClick={stopRowToggle}
2220-
onPointerDown={stopRowToggle}
2221-
>
2217+
<div className="mt-1 ms-7 max-h-96 overflow-auto rounded-md bg-muted/40 px-3 py-2 text-secondary-label select-text">
22222218
<ChatMarkdown
22232219
text={message.text}
22242220
cwd={ctx.markdownCwd}

0 commit comments

Comments
 (0)