Skip to content

Commit 0c00607

Browse files
committed
fix(chat): release answer previews across streamed and async turns
1 parent 94df4cc commit 0c00607

6 files changed

Lines changed: 297 additions & 89 deletions

File tree

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

Lines changed: 128 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -276,91 +276,138 @@ function makeThread(
276276
}
277277

278278
describe("buildThreadFeed", () => {
279-
it("keeps a submitted answer visible until the same-turn assistant resumes", () => {
280-
const turnId = TurnId.make("answer-turn");
281-
const startedAt = "2026-04-01T00:00:00.000Z";
282-
const submittedAt = "2026-04-01T00:00:03.000Z";
283-
const latestTurn = { turnId, state: "running" as const, startedAt, completedAt: null };
284-
const thread = makeThread({
285-
id: ThreadId.make("answer-thread"),
286-
projectId: ProjectId.make("project-1"),
287-
title: "Answer visibility",
288-
messages: [
289-
{
290-
id: MessageId.make("assistant-question"),
291-
role: "assistant",
292-
text: "Choose a runtime.",
293-
turnId,
294-
streaming: true,
295-
createdAt: startedAt,
296-
updatedAt: startedAt,
297-
},
298-
],
299-
activities: [
300-
makeActivity({
301-
id: EventId.make("previous-tool"),
302-
kind: "tool.completed",
303-
tone: "tool",
304-
summary: "Read files",
305-
createdAt: "2026-04-01T00:00:01.000Z",
306-
turnId,
307-
}),
308-
makeActivity({
309-
id: EventId.make("answer"),
310-
kind: "user-input.answer-submitted",
311-
summary: "User input submitted",
312-
createdAt: submittedAt,
313-
turnId,
314-
payload: {
315-
requestId: "runtime-question",
316-
questionTextById: { runtime: "Which runtime?" },
317-
answers: { runtime: "Node.js" },
318-
attachmentsByQuestionId: {},
279+
it.each([false, true])(
280+
"keeps a submitted answer visible until its response turn resumes (async: %s)",
281+
(async) => {
282+
const turnId = TurnId.make("answer-turn");
283+
const questionTurnId = async ? TurnId.make("original-question-turn") : turnId;
284+
const startedAt = "2026-04-01T00:00:00.000Z";
285+
const submittedAt = "2026-04-01T00:00:03.000Z";
286+
const latestTurn = { turnId, state: "running" as const, startedAt, completedAt: null };
287+
const thread = makeThread({
288+
id: ThreadId.make("answer-thread"),
289+
projectId: ProjectId.make("project-1"),
290+
title: "Answer visibility",
291+
messages: [
292+
{
293+
id: MessageId.make("assistant-question"),
294+
role: "assistant",
295+
text: "Choose a runtime.",
296+
turnId,
297+
streaming: true,
298+
createdAt: startedAt,
299+
updatedAt: startedAt,
319300
},
320-
}),
321-
],
322-
});
323-
const feed = buildThreadFeed(thread);
324-
const present = (source: ReadonlyArray<ThreadFeedEntry>) =>
325-
deriveThreadFeedPresentation(source, latestTurn, new Set(), new Set(), startedAt);
326-
const answerIsVisible = (rows: ReadonlyArray<ThreadFeedEntry>) =>
327-
rows.some(
328-
(row) =>
329-
row.type === "activity-group" &&
330-
row.activities.some((activity) => activity.workEntry.questionAnswer),
301+
...(async
302+
? [
303+
{
304+
id: MessageId.make("async-answer:runtime-question"),
305+
role: "user" as const,
306+
text: "Node.js",
307+
turnId,
308+
streaming: false,
309+
createdAt: submittedAt,
310+
updatedAt: submittedAt,
311+
},
312+
]
313+
: []),
314+
],
315+
activities: [
316+
makeActivity({
317+
id: EventId.make("previous-tool"),
318+
kind: "tool.completed",
319+
tone: "tool",
320+
summary: "Read files",
321+
createdAt: "2026-04-01T00:00:01.000Z",
322+
turnId: questionTurnId,
323+
}),
324+
makeActivity({
325+
id: EventId.make("answer"),
326+
kind: "user-input.answer-submitted",
327+
summary: "User input submitted",
328+
createdAt: submittedAt,
329+
turnId: questionTurnId,
330+
payload: {
331+
requestId: "runtime-question",
332+
questionTextById: { runtime: "Which runtime?" },
333+
answers: { runtime: "Node.js" },
334+
attachmentsByQuestionId: {},
335+
},
336+
}),
337+
],
338+
});
339+
const feed = buildThreadFeed(thread);
340+
const present = (source: ReadonlyArray<ThreadFeedEntry>) =>
341+
deriveThreadFeedPresentation(source, latestTurn, new Set(), new Set(), startedAt);
342+
const answerIsVisible = (rows: ReadonlyArray<ThreadFeedEntry>) =>
343+
rows.some(
344+
(row) =>
345+
row.type === "activity-group" &&
346+
row.activities.some((activity) => activity.workEntry.questionAnswer),
347+
);
348+
expect(answerIsVisible(present(feed))).toBe(true);
349+
expect(feed.some((entry) => entry.type === "message" && entry.message.role === "user")).toBe(
350+
false,
331351
);
332-
expect(answerIsVisible(present(feed))).toBe(true);
333-
const updatedFeed = (messageTurnId: TurnId, text = "Using Node.js.") =>
334-
feed.map((entry) =>
335-
entry.type === "message"
336-
? {
337-
...entry,
338-
message: {
339-
...entry.message,
340-
text,
341-
turnId: messageTurnId,
342-
updatedAt: "2026-04-01T00:00:04.000Z",
343-
},
344-
}
345-
: entry,
352+
const answerGroup = feed.find(
353+
(entry) =>
354+
entry.type === "activity-group" &&
355+
entry.activities.some((activity) => activity.workEntry.questionAnswer),
346356
);
347-
expect(answerIsVisible(present(updatedFeed(TurnId.make("other-turn"))))).toBe(true);
348-
expect(answerIsVisible(present(updatedFeed(turnId, "")))).toBe(true);
349-
// Reuse the activity group to exercise presentation-cache invalidation.
350-
expect(answerIsVisible(present(updatedFeed(turnId)))).toBe(false);
351-
expect(answerIsVisible(deriveThreadFeedPresentation(feed, latestTurn, new Set()))).toBe(false);
352-
expect(
353-
answerIsVisible(
354-
deriveThreadFeedPresentation(
355-
feed,
356-
{ ...latestTurn, state: "completed", completedAt: "2026-04-01T00:00:05.000Z" },
357-
new Set(),
358-
new Set(),
359-
startedAt,
357+
expect(answerGroup).toMatchObject({ turnId });
358+
const updatedFeed = (messageTurnId: TurnId, text = "Using Node.js.") =>
359+
feed.map((entry) =>
360+
entry.type === "message"
361+
? {
362+
...entry,
363+
message: {
364+
...entry.message,
365+
text,
366+
turnId: messageTurnId,
367+
updatedAt: "2026-04-01T00:00:04.000Z",
368+
},
369+
}
370+
: entry,
371+
);
372+
expect(answerIsVisible(present(updatedFeed(TurnId.make("other-turn"))))).toBe(true);
373+
expect(answerIsVisible(present(updatedFeed(turnId, "")))).toBe(true);
374+
// Reuse the activity group to exercise presentation-cache invalidation.
375+
expect(answerIsVisible(present(updatedFeed(turnId)))).toBe(false);
376+
expect(
377+
answerIsVisible(
378+
present(
379+
buildThreadFeed({
380+
...thread,
381+
activities: [
382+
...thread.activities,
383+
makeActivity({
384+
id: EventId.make("resumed-tool"),
385+
kind: "tool.started",
386+
summary: "Running tool",
387+
createdAt: "2026-04-01T00:00:04.000Z",
388+
turnId,
389+
}),
390+
],
391+
}),
392+
),
360393
),
361-
),
362-
).toBe(false);
363-
});
394+
).toBe(false);
395+
expect(answerIsVisible(deriveThreadFeedPresentation(feed, latestTurn, new Set()))).toBe(
396+
false,
397+
);
398+
expect(
399+
answerIsVisible(
400+
deriveThreadFeedPresentation(
401+
feed,
402+
{ ...latestTurn, state: "completed", completedAt: "2026-04-01T00:00:05.000Z" },
403+
new Set(),
404+
new Set(),
405+
startedAt,
406+
),
407+
),
408+
).toBe(false);
409+
},
410+
);
364411

365412
it("folds question answers into tool history and only hides the matching async reply", () => {
366413
const createdAt = "2026-04-01T00:00:01.000Z";

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

Lines changed: 67 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -241,6 +241,10 @@ const messageEntriesCache = new WeakMap<
241241
Extract<RawThreadFeedEntry, { readonly type: "message" }>
242242
>();
243243
const activityGroupsCache = new WeakMap<ThreadFeedActivity, ThreadFeedActivityGroup>();
244+
const asyncAnswerEntriesCache = new WeakMap<
245+
ThreadFeedActivity,
246+
Extract<RawThreadFeedEntry, { readonly type: "activity" }>
247+
>();
244248
const presentedActivityGroupsCache = new WeakMap<
245249
ThreadFeedActivityGroup,
246250
{
@@ -2223,10 +2227,70 @@ export function buildThreadFeed(
22232227
: loadedMessages;
22242228
const oldestLoadedMessageCreatedAt =
22252229
options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;
2226-
const activityEntries = getThreadFeedActivityEntries(thread.activities).filter(
2227-
(entry) =>
2228-
oldestLoadedMessageCreatedAt === null || entry.createdAt >= oldestLoadedMessageCreatedAt,
2230+
const asyncAnswerMessages = new Map(
2231+
messages
2232+
.filter(
2233+
(message) =>
2234+
message.role === "user" && message.id.startsWith("async-answer:") && message.turnId,
2235+
)
2236+
.map((message) => [message.id as string, message]),
22292237
);
2238+
const latestProviderActivityAt = new Map<TurnId, string>();
2239+
if (asyncAnswerMessages.size > 0) {
2240+
for (const activity of thread.activities) {
2241+
if (
2242+
activity.turnId &&
2243+
(activity.kind.startsWith("tool.") || activity.kind.startsWith("task."))
2244+
) {
2245+
const previous = latestProviderActivityAt.get(activity.turnId);
2246+
if (!previous || activity.createdAt > previous)
2247+
latestProviderActivityAt.set(activity.turnId, activity.createdAt);
2248+
}
2249+
}
2250+
}
2251+
const activityEntries = getThreadFeedActivityEntries(thread.activities)
2252+
.map((entry) => {
2253+
const answer = entry.activity.workEntry.questionAnswer;
2254+
const message = answer
2255+
? asyncAnswerMessages.get(`async-answer:${answer.requestId}`)
2256+
: undefined;
2257+
if (!message?.turnId) return entry;
2258+
const resumedAt = latestProviderActivityAt.get(message.turnId);
2259+
const submittedAt =
2260+
resumedAt && resumedAt > message.createdAt ? undefined : message.createdAt;
2261+
const cached = asyncAnswerEntriesCache.get(entry.activity);
2262+
if (
2263+
cached &&
2264+
cached.turnId === message.turnId &&
2265+
cached.createdAt === message.createdAt &&
2266+
cached.activity.workEntry.questionAnswerSubmittedAt === submittedAt
2267+
)
2268+
return cached;
2269+
const workEntry = {
2270+
...entry.activity.workEntry,
2271+
turnId: message.turnId,
2272+
createdAt: message.createdAt,
2273+
};
2274+
if (submittedAt) workEntry.questionAnswerSubmittedAt = submittedAt;
2275+
else delete workEntry.questionAnswerSubmittedAt;
2276+
const relocated = {
2277+
...entry,
2278+
turnId: message.turnId,
2279+
createdAt: message.createdAt,
2280+
activity: {
2281+
...entry.activity,
2282+
turnId: message.turnId,
2283+
createdAt: message.createdAt,
2284+
workEntry,
2285+
},
2286+
};
2287+
asyncAnswerEntriesCache.set(entry.activity, relocated);
2288+
return relocated;
2289+
})
2290+
.filter(
2291+
(entry) =>
2292+
oldestLoadedMessageCreatedAt === null || entry.createdAt >= oldestLoadedMessageCreatedAt,
2293+
);
22302294
const foldedAnswerMessageIds = new Set(
22312295
activityEntries.flatMap((entry) =>
22322296
entry.activity.workEntry.questionAnswer

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

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2041,6 +2041,41 @@ describe("deriveMessagesTimelineRows", () => {
20412041
timelineEntries: [{ ...question, entry: resumedQuestion }, input.timelineEntries[1]!],
20422042
}).find((row) => row.kind === "work-live"),
20432043
).toMatchObject({ entry: { id: "tool" } });
2044+
const message: ChatMessage = {
2045+
id: MessageId.make("reply"),
2046+
role: "assistant",
2047+
text: "Checking",
2048+
createdAt,
2049+
updatedAt: createdAt,
2050+
turnId,
2051+
streaming: true,
2052+
};
2053+
const streamingInput = {
2054+
...input,
2055+
timelineEntries: [
2056+
{ kind: "message" as const, id: "reply", createdAt, message },
2057+
...input.timelineEntries,
2058+
],
2059+
};
2060+
const previous = deriveMessagesTimelineRowsWithState(streamingInput);
2061+
expect(new Set(previous.rows.map((row) => row.id)).size).toBe(previous.rows.length);
2062+
const nextInput = {
2063+
...streamingInput,
2064+
timelineEntries: [
2065+
{
2066+
kind: "message" as const,
2067+
id: "reply",
2068+
createdAt,
2069+
message: { ...message, text: "You chose stable", updatedAt: "2026-01-01T00:00:06Z" },
2070+
},
2071+
...input.timelineEntries,
2072+
],
2073+
};
2074+
const next = deriveMessagesTimelineRowsWithState(nextInput, previous);
2075+
expect(next.rows).toEqual(deriveMessagesTimelineRows(nextInput));
2076+
expect(next.rows.find((row) => row.kind === "work-live")).toMatchObject({
2077+
entry: { id: "tool" },
2078+
});
20442079
});
20452080

20462081
it("renders a single completed tool call directly", () => {

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

Lines changed: 23 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -971,9 +971,10 @@ export function deriveMessagesTimelineRows(input: {
971971
const groupId = workGroupId(activeWorkAnchor.id, activeWorkAnchor.entry);
972972
return {
973973
kind: "work-live" as const,
974-
id: latestToolKeepsActivityLive
975-
? LIVE_ACTIVITY_ROW_ID
976-
: `work-live:${workGroupIdentity(activeWorkAnchor.id, activeWorkAnchor.entry)}`,
974+
id:
975+
latestToolKeepsActivityLive && !submittedAnswer
976+
? LIVE_ACTIVITY_ROW_ID
977+
: `work-live:${workGroupIdentity(activeWorkAnchor.id, activeWorkAnchor.entry)}`,
977978
createdAt: activeWorkAnchor.createdAt,
978979
entry: (submittedAnswer ?? latestRunningToolEntry ?? latestVisibleToolEntry).entry,
979980
groupedEntries: visibleActiveToolEntries.map((entry) => entry.entry),
@@ -1318,6 +1319,25 @@ function replaceStreamingMessageRows(
13181319
replacements.set(previousEntry.message, entry.message);
13191320
}
13201321
if (replacements.size === 0) return previous.rows;
1322+
for (const row of previous.rows) {
1323+
const entries =
1324+
row.kind === "work" ? row.groupedEntries : row.kind === "work-live" ? [row.entry] : [];
1325+
for (const entry of entries) {
1326+
const submittedAt = entry.questionAnswerSubmittedAt;
1327+
if (
1328+
submittedAt &&
1329+
[...replacements].some(
1330+
([before, after]) =>
1331+
after.role === "assistant" &&
1332+
after.turnId === entry.turnId &&
1333+
after.text.trim().length > 0 &&
1334+
after.updatedAt > submittedAt &&
1335+
(before.updatedAt <= submittedAt || before.text.trim().length === 0),
1336+
)
1337+
)
1338+
return null;
1339+
}
1340+
}
13211341
return previous.rows.map((row) => {
13221342
if (row.kind !== "message" && row.kind !== "assistant-meta") return row;
13231343
const message = replacements.get(row.message);

0 commit comments

Comments
 (0)