Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🧮 refactor: Pure Step Reducer Behind useStepHandler (#16289)

Marco Berettabe1178d1dc7b
diff --git a/client/src/hooks/SSE/__tests__/steps.spec.ts b/client/src/hooks/SSE/__tests__/steps.spec.ts
new file mode 100644
index 0000000000..fd89253e74
--- /dev/null
+++ b/client/src/hooks/SSE/__tests__/steps.spec.ts
@@ -0,0 +1,456 @@
+import { StepTypes, ContentTypes } from 'librechat-data-provider';
+import type {
+ Agents,
+ TMessage,
+ EventSubmission,
+ SummaryContentPart,
+ TMessageContentParts,
+} from 'librechat-data-provider';
+import {
+ calculateContentIndex,
+ applyReasoningDelta,
+ applySummarizeDelta,
+ finalizeSummaries,
+ applyMessageDelta,
+ applySummaryStep,
+ applyAgentUpdate,
+ getEditPrefix,
+ updateContent,
+} from '../steps';
+
+const RUN_ID = 'response-1';
+
+const createResponse = (content: TMessageContentParts[] = []): TMessage =>
+ ({
+ messageId: RUN_ID,
+ conversationId: 'convo-1',
+ parentMessageId: 'user-1',
+ isCreatedByUser: false,
+ text: '',
+ content,
+ }) as TMessage;
+
+const messageStep = (
+ id: string,
+ index: number,
+ overrides: Partial<Agents.RunStep> = {},
+): Agents.RunStep => ({
+ id,
+ index,
+ runId: RUN_ID,
+ type: StepTypes.MESSAGE_CREATION,
+ stepDetails: { type: StepTypes.MESSAGE_CREATION, message_creation: { message_id: id } },
+ ...overrides,
+});
+
+const textDelta = (id: string, text: string): Agents.MessageDeltaEvent => ({
+ id,
+ delta: { content: [{ type: ContentTypes.TEXT, text }] },
+});
+
+const thinkDelta = (id: string, think: string): Agents.ReasoningDeltaEvent => ({
+ id,
+ delta: { content: [{ type: ContentTypes.THINK, think }] },
+});
+
+const typesOf = (message: TMessage) => (message.content ?? []).map((part) => part?.type);
+
+/**
+ * The invariant every reducer keeps: each step's part sits at `step.index + offset`, whatever
+ * order the events arrived in.
+ */
+const expectStepPositions = (
+ message: TMessage,
+ steps: Array<[Agents.RunStep, ContentTypes]>,
+ offset = 0,
+) => {
+ for (const [step, type] of steps) {
+ expect(message.content?.[step.index + offset]?.type).toBe(type);
+ }
+};
+
+const streamText = (message: TMessage, step: Agents.RunStep, chunks: string[], offset = 0) =>
+ chunks.reduce(
+ (current, chunk) => applyMessageDelta(current, step, textDelta(step.id, chunk), offset).message,
+ message,
+ );
+
+describe('steps', () => {
+ describe('text deltas', () => {
+ it('appends a recorded sequence of chunks into the step slot', () => {
+ const step = messageStep('step-text', 0);
+ const result = streamText(createResponse(), step, ['Hel', 'lo', ', world']);
+
+ expect(result.content).toEqual([{ type: ContentTypes.TEXT, text: 'Hello, world' }]);
+ expectStepPositions(result, [[step, ContentTypes.TEXT]]);
+ });
+
+ it('applies every part of a multi-part delta in order', () => {
+ const step = messageStep('step-text', 0);
+ const result = applyMessageDelta(
+ createResponse(),
+ step,
+ {
+ id: step.id,
+ delta: {
+ content: [
+ { type: ContentTypes.TEXT, text: 'a' },
+ null as unknown as Agents.MessageContentComplex,
+ { type: ContentTypes.TEXT, text: 'b' },
+ ],
+ },
+ },
+ 0,
+ );
+
+ expect(result.updated).toBe(true);
+ expect(result.message.content).toEqual([{ type: ContentTypes.TEXT, text: 'ab' }]);
+ });
+
+ it('reports no update and returns the same message for an empty delta', () => {
+ const response = createResponse();
+ const result = applyMessageDelta(
+ response,
+ messageStep('step-text', 0),
+ { id: 'step-text', delta: {} },
+ 0,
+ );
+
+ expect(result).toEqual({ message: response, updated: false, foldedEditPrefix: false });
+ expect(result.message).toBe(response);
+ });
+
+ it('stamps the step phase on text parts', () => {
+ const step = messageStep('step-final', 0, {
+ stepDetails: {
+ type: StepTypes.MESSAGE_CREATION,
+ message_creation: { message_id: 'm', phase: 'final_answer' },
+ },
+ });
+ const result = streamText(createResponse(), step, ['done']);
+
+ expect(result.content?.[0]).toEqual({
+ type: ContentTypes.TEXT,
+ text: 'done',
+ phase: 'final_answer',
+ });
+ });
+
+ it('streams into a message step that carries no message_creation details', () => {
+ const step = messageStep('step-bare', 0, {
+ stepDetails: { type: StepTypes.MESSAGE_CREATION } as Agents.StepDetails,
+ });
+ const result = streamText(createResponse(), step, ['still streams']);
+
+ expect(result.content).toEqual([{ type: ContentTypes.TEXT, text: 'still streams' }]);
+ });
+
+ it('keeps slots in place when a later step streams before an earlier one', () => {
+ const first = messageStep('step-a', 0);
+ const second = messageStep('step-b', 2);
+ let result = streamText(createResponse(), second, ['second']);
+ expect(result.content?.[0]).toBeUndefined();
+ expect(result.content?.[1]).toBeUndefined();
+
+ result = streamText(result, first, ['first']);
+
+ expectStepPositions(result, [
+ [first, ContentTypes.TEXT],
+ [second, ContentTypes.TEXT],
+ ]);
+ expect(result.content?.[1]).toBeUndefined();
+ expect(result.content).toHaveLength(3);
+ });
+
+ it('does not dedupe a redelivered chunk; the transport owns delivery', () => {
+ const step = messageStep('step-text', 0);
+ const result = streamText(createResponse(), step, ['once', 'once']);
+
+ expect(result.content).toEqual([{ type: ContentTypes.TEXT, text: 'onceonce' }]);
+ });
+
+ it('never overwrites a slot holding a different part type', () => {
+ const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+ const opened = createResponse([
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: { id: 'call-1', name: 'search', args: '', type: 'tool_call' },
+ } as TMessageContentParts,
+ ]);
+
+ const result = streamText(opened, messageStep('step-text', 0), ['collide']);
+
+ expect(result).toBe(opened);
+ expect(typesOf(result)).toEqual([ContentTypes.TOOL_CALL]);
+ expect(warn).toHaveBeenCalledWith('Content type mismatch', expect.any(Object));
+ warn.mockRestore();
+ });
+
+ it('propagates agent and group metadata without mutating the previous part', () => {
+ const step = messageStep('step-text', 0, { agentId: 'agent-a', groupId: 2 });
+ const before = streamText(createResponse(), messageStep('step-text', 0), ['a']);
+ const previousPart = before.content?.[0];
+
+ const result = streamText(before, step, ['b']);
+
+ expect(result.content?.[0]).toMatchObject({ text: 'ab', agentId: 'agent-a', groupId: 2 });
+ expect(previousPart).toEqual({ type: ContentTypes.TEXT, text: 'a' });
+ });
+ });
+
+ describe('reasoning deltas', () => {
+ it('streams reasoning then text into consecutive slots', () => {
+ const think = messageStep('step-think', 0);
+ const text = messageStep('step-text', 1);
+ let result = createResponse();
+ for (const chunk of ['Let me ', 'think']) {
+ result = applyReasoningDelta(result, think, thinkDelta(think.id, chunk), 0).message;
+ }
+ result = streamText(result, text, ['Answer']);
+
+ expect(result.content?.[0]).toMatchObject({
+ type: ContentTypes.THINK,
+ think: 'Let me think',
+ reasoning_label_step_id: think.id,
+ });
+ expectStepPositions(result, [
+ [think, ContentTypes.THINK],
+ [text, ContentTypes.TEXT],
+ ]);
+ });
+
+ it('resets the label domain when a different step reuses a THINK slot', () => {
+ const labelled = createResponse([
+ {
+ type: ContentTypes.THINK,
+ think: 'old',
+ reasoning_label: 'Planning',
+ reasoning_label_revision: 3,
+ reasoning_label_step_id: 'step-old',
+ } as TMessageContentParts,
+ ]);
+
+ const result = applyReasoningDelta(
+ labelled,
+ messageStep('step-new', 0),
+ thinkDelta('step-new', ' more'),
+ 0,
+ ).message;
+
+ expect(result.content?.[0]).toStrictEqual({
+ type: ContentTypes.THINK,
+ think: 'old more',
+ reasoning_label_step_id: 'step-new',
+ });
+ });
+
+ it('stamps a THINK slot streamed on the message channel once it exists', () => {
+ const step = messageStep('step-think', 0);
+ const delta = (think: string): Agents.MessageDeltaEvent => ({
+ id: step.id,
+ delta: { content: [{ type: ContentTypes.THINK, think }] },
+ });
+ const first = applyMessageDelta(createResponse(), step, delta('h'), 0).message;
+ const second = applyMessageDelta(first, step, delta('m'), 0).message;
+
+ expect(first.content?.[0]).toEqual({ type: ContentTypes.THINK, think: 'h' });
+ expect(second.content?.[0]).toEqual({
+ type: ContentTypes.THINK,
+ think: 'hm',
+ reasoning_label_step_id: step.id,
+ });
+ });
+ });
+
+ describe('edit prefix', () => {
+ const prefix = [
+ { type: ContentTypes.TEXT, text: 'kept' },
+ { type: ContentTypes.TEXT, text: 'kept tail' },
+ ] as TMessageContentParts[];
+ const submission = (overrides: Partial<EventSubmission> = {}) =>
+ ({
+ editedContent: { index: 1, text: 'kept tail', type: ContentTypes.TEXT },
+ editPrefixLength: 2,
+ initialResponse: createResponse(prefix),
+ ...overrides,
+ }) as EventSubmission;
+
+ it('offsets by the captured prefix length, not the live content length', () => {
+ expect(getEditPrefix(submission()).editPrefixOffset).toBe(2);
+ expect(
+ getEditPrefix(
+ submission({ editPrefixLength: undefined, initialResponse: createResponse() }),
+ ).editPrefixOffset,
+ ).toBe(0);
+ });
+
+ it('drops the offset once a resume sync cleared the prefix', () => {
+ expect(getEditPrefix(submission({ editPrefixCleared: true }))).toEqual({
+ initialContent: [],
+ editPrefixOffset: 0,
+ });
+ expect(getEditPrefix({ initialResponse: createResponse() } as EventSubmission)).toEqual({
+ initialContent: [],
+ editPrefixOffset: 0,
+ });
+ });
+
+ it('folds the first continued text into the last prefix part and reports it', () => {
+ const step = messageStep('step-text', 0);
+ const result = applyMessageDelta(createResponse(prefix), step, textDelta(step.id, '!'), 2);
+
+ expect(result.foldedEditPrefix).toBe(true);
+ expect(result.message.content).toEqual([
+ { type: ContentTypes.TEXT, text: 'kept' },
+ { type: ContentTypes.TEXT, text: 'kept tail!' },
+ ]);
+ });
+
+ it('does not fold across a phase boundary', () => {
+ expect(calculateContentIndex(0, 2, ContentTypes.TEXT, prefix, 'final_answer')).toBe(2);
+ expect(calculateContentIndex(0, 2, ContentTypes.TEXT, prefix)).toBe(1);
+ expect(calculateContentIndex(0, 2, ContentTypes.TOOL_CALL, prefix)).toBe(2);
+ });
+
+ it('places later steps after the prefix', () => {
+ const think = messageStep('step-think', 1);
+ const result = applyReasoningDelta(
+ createResponse(prefix),
+ think,
+ thinkDelta(think.id, 'next'),
+ 2,
+ ).message;
+
+ expect(typesOf(result)).toEqual([
+ ContentTypes.TEXT,
+ ContentTypes.TEXT,
+ undefined,
+ ContentTypes.THINK,
+ ]);
+ expectStepPositions(result, [[think, ContentTypes.THINK]], 2);
+ });
+ });
+
+ describe('image parts', () => {
+ it('holds an image slot without letting text overwrite it', () => {
+ const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+ const image = createResponse([
+ { type: ContentTypes.IMAGE_URL, image_url: { url: 'https://x/y.png' } },
+ ] as TMessageContentParts[]);
+
+ const result = updateContent(image, 0, {
+ type: ContentTypes.IMAGE_URL,
+ image_url: 'https://x/y.png',
+ } as Agents.MessageContentComplex);
+ const collided = streamText(result, messageStep('step-text', 0), ['no']);
+
+ expect(result.content?.[0]).toEqual(image.content?.[0]);
+ expect(collided).toBe(result);
+ warn.mockRestore();
+ });
+ });
+
+ describe('agent updates', () => {
+ it('writes the handoff marker at its index with default group metadata', () => {
+ const event: Agents.AgentUpdate = {
+ type: ContentTypes.AGENT_UPDATE,
+ agent_update: { index: 1, runId: RUN_ID, agentId: 'agent-b' },
+ };
+
+ const result = applyAgentUpdate(createResponse(), event, 0);
+
+ expect(result.content?.[1]).toEqual({
+ type: ContentTypes.AGENT_UPDATE,
+ agent_update: event.agent_update,
+ agentId: 'agent-b',
+ groupId: 1,
+ });
+ expect(applyAgentUpdate(result, event, 0).content).toEqual(result.content);
+ });
+ });
+
+ describe('summaries', () => {
+ const summarize = messageStep('step-summary', 1, {
+ summary: {
+ type: ContentTypes.SUMMARY,
+ content: [],
+ model: 'model-a',
+ provider: 'provider-a',
+ } as SummaryContentPart,
+ });
+ const summaryDelta = (text: string): Agents.SummarizeDeltaEvent => ({
+ id: summarize.id,
+ delta: {
+ summary: {
+ type: ContentTypes.SUMMARY,
+ content: [{ type: ContentTypes.TEXT, text }],
+ } as SummaryContentPart,
+ },
+ });
+
+ const streamSummary = () => {
+ let message = applySummaryStep(createResponse(), summarize, 0);
+ for (const chunk of ['Earlier, ', 'we talked.']) {
+ message = applySummarizeDelta(message, summarize, summaryDelta(chunk), 0);
+ }
+ return message;
+ };
+
+ it('opens, streams, and settles a summary in its step slot', () => {
+ const streamed = streamSummary();
+ expect(streamed.content?.[1]).toMatchObject({
+ type: ContentTypes.SUMMARY,
+ summarizing: true,
+ content: [
+ { type: ContentTypes.TEXT, text: 'Earlier, ' },
+ { type: ContentTypes.TEXT, text: 'we talked.' },
+ ],
+ });
+
+ const settled = finalizeSummaries(
+ streamed,
+ {
+ id: summarize.id,
+ agentId: 'a',
+ summary: { type: ContentTypes.SUMMARY, content: [] } as SummaryContentPart,
+ },
+ 1,
+ );
+
+ expect(settled?.content?.[1]).toMatchObject({ summarizing: false });
+ expectStepPositions(settled as TMessage, [[summarize, ContentTypes.SUMMARY]]);
+ expect(
+ finalizeSummaries(settled as TMessage, { id: summarize.id, agentId: 'a' }, 1),
+ ).toBeUndefined();
+ });
+
+ it('keeps a failed round in its slot instead of splicing it out', () => {
+ const text = messageStep('step-text', 2);
+ const streamed = streamText(streamSummary(), text, ['after']);
+
+ const failed = finalizeSummaries(
+ streamed,
+ { id: summarize.id, agentId: 'a', error: 'boom' },
+ 1,
+ ) as TMessage;
+
+ expect(failed.content?.[1]).toMatchObject({ summarizing: false, failed: true });
+ expectStepPositions(failed, [
+ [summarize, ContentTypes.SUMMARY],
+ [text, ContentTypes.TEXT],
+ ]);
+ });
+
+ it('finalizes only the owning slot when the step is known', () => {
+ const newer = messageStep('step-summary-2', 3, { summary: summarize.summary });
+ const both = applySummaryStep(streamSummary(), newer, 0);
+
+ const scoped = finalizeSummaries(both, { id: summarize.id, agentId: 'a' }, 1) as TMessage;
+ const global = finalizeSummaries(both, { id: 'unknown', agentId: 'a' }, -1) as TMessage;
+
+ expect(scoped.content?.[1]).toMatchObject({ summarizing: false });
+ expect(scoped.content?.[3]).toMatchObject({ summarizing: true });
+ expect(global.content?.[3]).toMatchObject({ summarizing: false });
+ });
+ });
+});
diff --git a/client/src/hooks/SSE/steps/content.ts b/client/src/hooks/SSE/steps/content.ts
new file mode 100644
index 0000000000..25415d5ad3
--- /dev/null
+++ b/client/src/hooks/SSE/steps/content.ts
@@ -0,0 +1,354 @@
+import { Constants, ContentTypes, ToolCallTypes, getNonEmptyValue } from 'librechat-data-provider';
+import type {
+ Agents,
+ TMessage,
+ PartMetadata,
+ ContentMetadata,
+ EventSubmission,
+ SummaryContentPart,
+ TMessageContentParts,
+} from 'librechat-data-provider';
+import { isAskUserQuestionPart, isAnsweredAskUserQuestionPart } from '~/utils/approval';
+
+/**
+ * Pure content-part primitives behind `useStepHandler`.
+ *
+ * Invariant every function here keeps: a part's position in `message.content` is its step index
+ * (plus the retained edit prefix). Parts are written in place, never spliced, so a slot that
+ * arrives early leaves holes rather than shifting later parts.
+ *
+ * AI SDK mapping, for orientation only: `message.content` is `UIMessage.parts`, and the part
+ * types map as `text` to `text`, `think` to `reasoning`, `tool_call` to `tool-<name>`,
+ * `image_file`/`image_url` to `file`, and `summary`/`agent_update` to `data-*` parts.
+ */
+
+export type TextPhase = 'commentary' | 'final_answer';
+
+type MessageDeltaUpdate = {
+ type: ContentTypes.TEXT;
+ text: string;
+ tool_call_ids?: string[];
+ phase?: TextPhase;
+};
+
+type ReasoningDeltaUpdate = { type: ContentTypes.THINK; think: string };
+
+type AllContentTypes =
+ | ContentTypes.TEXT
+ | ContentTypes.THINK
+ | ContentTypes.TOOL_CALL
+ | ContentTypes.IMAGE_FILE
+ | ContentTypes.IMAGE_URL
+ | ContentTypes.SUMMARY
+ | ContentTypes.ERROR;
+
+export const isOAuthToolCallName = (name?: string) =>
+ typeof name === 'string' && name.startsWith(`oauth${Constants.mcp_delimiter}`);
+
+const isOAuthToolCallContent = (part?: Partial<TMessageContentParts>) => {
+ if (part?.type !== ContentTypes.TOOL_CALL || !('tool_call' in part)) {
+ return false;
+ }
+ const { tool_call: toolCall } = part;
+ const name = toolCall != null && 'name' in toolCall ? toolCall.name : undefined;
+ return isOAuthToolCallName(name);
+};
+
+/**
+ * Index offset for an edited resubmission: the server indexes only the NEW content, so incoming
+ * indices shift past the prefix the client kept.
+ *
+ * Reads the length CAPTURED when the submission was built rather than the live
+ * `initialResponse.content` array, because a resume sync REPLACES that array with the server's
+ * completion-local snapshot, whose length describes the new generation, not the retained prefix.
+ *
+ * `editPrefixCleared` means that sync also replaced the RENDERED content: the prefix is gone from
+ * the message and server indices are already absolute, so any offset would write past the end.
+ *
+ * `initialContent` stays the live array: it seeds a response that is not in the map yet, and
+ * post-sync the seeding path correctly falls back to the rendered content instead.
+ */
+export function getEditPrefix(submission: EventSubmission): {
+ initialContent: TMessageContentParts[];
+ editPrefixOffset: number;
+} {
+ if (submission?.editedContent == null || submission?.editPrefixCleared === true) {
+ return { initialContent: [], editPrefixOffset: 0 };
+ }
+ const initialContent = submission?.initialResponse?.content ?? [];
+ return {
+ initialContent,
+ editPrefixOffset: submission?.editPrefixLength ?? initialContent.length,
+ };
+}
+
+/**
+ * Content index for a server step index. Takes the edit-prefix OFFSET rather than the prefix
+ * array: after a resume sync the live array no longer describes the retained prefix, so deriving
+ * the offset from its length would disagree with the offset every other event path applies.
+ */
+export function calculateContentIndex(
+ serverIndex: number,
+ editPrefixOffset: number,
+ incomingContentType: string,
+ existingContent?: TMessageContentParts[],
+ incomingPhase?: TextPhase,
+): number {
+ /** Only apply -1 adjustment for TEXT or THINK types when they match existing content */
+ if (
+ editPrefixOffset > 0 &&
+ (incomingContentType === ContentTypes.TEXT || incomingContentType === ContentTypes.THINK)
+ ) {
+ const targetIndex = serverIndex + editPrefixOffset - 1;
+ const existingPart = existingContent?.[targetIndex];
+ const existingType = existingPart?.type;
+ const existingPhase = existingPart?.type === ContentTypes.TEXT ? existingPart.phase : undefined;
+ /** Match final assembly: phased and legacy/unphased text cannot share
+ * a content part because the phase controls client grouping. */
+ const phaseCompatible =
+ incomingContentType !== ContentTypes.TEXT ||
+ (incomingPhase ?? null) === (existingPhase ?? null);
+ if (existingType === incomingContentType && phaseCompatible) {
+ return targetIndex;
+ }
+ }
+ return serverIndex + editPrefixOffset;
+}
+
+/** True when a delta at `contentIndex` folded into the last part of the retained edit prefix. */
+export function foldsEditPrefix(
+ serverIndex: number,
+ editPrefixOffset: number,
+ contentIndex: number,
+): boolean {
+ return serverIndex === 0 && editPrefixOffset > 0 && contentIndex === editPrefixOffset - 1;
+}
+
+/** Extract metadata from a run step for parallel content rendering. */
+export function getStepMetadata(runStep: Agents.RunStep | undefined): ContentMetadata | undefined {
+ if (!runStep?.agentId && runStep?.groupId == null) {
+ return undefined;
+ }
+ return {
+ agentId: runStep.agentId,
+ /** Only set when explicitly provided by the server: sequential handoffs have agentId but no
+ * groupId, parallel execution has both. */
+ groupId: runStep.groupId,
+ };
+}
+
+/** Starts a fresh label-revision domain when a different reasoning step
+ * reuses or folds into an existing THINK slot. The step id is stamped before
+ * the first generated title so compacted resume snapshots can still correlate
+ * later label events by identity rather than relying only on a sparse index. */
+export function prepareReasoningPartForStep(
+ message: TMessage,
+ index: number,
+ stepId: string,
+): TMessage {
+ const current = message.content?.[index];
+ if (current?.type !== ContentTypes.THINK || current.reasoning_label_step_id === stepId) {
+ return message;
+ }
+ const nextPart = { ...current };
+ delete nextPart.reasoning_label;
+ delete nextPart.reasoning_label_attempts;
+ delete nextPart.reasoning_label_submitted_chars;
+ delete nextPart.reasoning_label_revision;
+ delete nextPart.reasoning_label_status;
+ nextPart.reasoning_label_step_id = stepId;
+ const nextContent = [...(message.content ?? [])];
+ nextContent[index] = nextPart;
+ return { ...message, content: nextContent };
+}
+
+/**
+ * Writes one incoming part into `message.content[index]` and returns the next message. Text and
+ * reasoning append, tool calls merge (args concatenate until they arrive as an object), summaries
+ * concatenate their content, and a part of a different type never overwrites an occupied slot.
+ * Returns the input message unchanged when the part is rejected.
+ */
+export function updateContent(
+ message: TMessage,
+ index: number,
+ contentPart: Agents.MessageContentComplex,
+ finalUpdate = false,
+ metadata?: ContentMetadata,
+): TMessage {
+ const contentType = contentPart.type ?? '';
+ if (!contentType) {
+ console.warn('No content type found in content part');
+ return message;
+ }
+
+ const incomingOAuthToolCall =
+ contentType === ContentTypes.TOOL_CALL &&
+ 'tool_call' in contentPart &&
+ isOAuthToolCallName(contentPart.tool_call?.name);
+
+ let updatedContent = [...(message.content || [])] as Array<
+ Partial<TMessageContentParts> | undefined
+ >;
+
+ const oauthPromptOccupiesSlot = isOAuthToolCallContent(updatedContent[index]);
+ if (!incomingOAuthToolCall && oauthPromptOccupiesSlot) {
+ updatedContent = updatedContent.filter((part) => !isOAuthToolCallContent(part));
+ }
+
+ /**
+ * The synthetic ask-user-question card is pause-scoped UI appended at the end
+ * of the content, exactly the ABSOLUTE index the resumed segment streams
+ * into. Once real content arrives for that slot the pause is over: displace
+ * the card (same displacement pattern as the OAuth prompt above) instead of
+ * dropping the incoming part as a type mismatch. Covers the streaming
+ * handler's own in-flight message copy, reconnecting tabs, and other devices:
+ * the store-level strip on answer submit can't reach those.
+ */
+ if (isAskUserQuestionPart(updatedContent[index])) {
+ updatedContent[index] = undefined;
+ } else if (updatedContent.some(isAnsweredAskUserQuestionPart)) {
+ /**
+ * An ALREADY-ANSWERED card the resumed segment streams around rather than
+ * into: the first event after the resume re-renders the ask tool_call at
+ * ITS OWN index, so the slot test above never fires and this handler's
+ * cached copy, which still holds the card the answer-submit stripped from
+ * the store, gets written back, reopening the popover with its options
+ * locked. Only cards the user actually answered are dropped, so an event
+ * racing a still-live pause can't take its card down. Preserve sparse
+ * absolute indices: compacting holes can move an older tool call into a
+ * text slot until the terminal snapshot repairs the rendered order.
+ */
+ updatedContent = updatedContent.map((part) =>
+ isAnsweredAskUserQuestionPart(part) ? undefined : part,
+ );
+ }
+
+ if (!updatedContent[index] && contentType !== ContentTypes.TOOL_CALL) {
+ updatedContent[index] = { type: contentPart.type as AllContentTypes };
+ }
+
+ /** Prevent overwriting an existing content part with a different type */
+ const existingType = (updatedContent[index]?.type as string | undefined) ?? '';
+ if (
+ existingType &&
+ existingType !== contentType &&
+ !contentType.startsWith(existingType) &&
+ !existingType.startsWith(contentType)
+ ) {
+ console.warn('Content type mismatch', { existingType, contentType, index });
+ return message;
+ }
+
+ if (
+ contentType.startsWith(ContentTypes.TEXT) &&
+ ContentTypes.TEXT in contentPart &&
+ typeof contentPart.text === 'string'
+ ) {
+ const currentContent = updatedContent[index] as MessageDeltaUpdate;
+ const incomingContent = contentPart as MessageDeltaUpdate;
+ const phase = incomingContent.phase ?? currentContent.phase;
+ const update: MessageDeltaUpdate = {
+ type: ContentTypes.TEXT,
+ text: (currentContent.text || '') + incomingContent.text,
+ ...(phase != null && { phase }),
+ };
+
+ if ('tool_call_ids' in contentPart && contentPart.tool_call_ids != null) {
+ update.tool_call_ids = contentPart.tool_call_ids;
+ }
+ updatedContent[index] = update;
+ } else if (
+ contentType.startsWith(ContentTypes.AGENT_UPDATE) &&
+ ContentTypes.AGENT_UPDATE in contentPart &&
+ contentPart.agent_update
+ ) {
+ const update: Agents.AgentUpdate = {
+ type: ContentTypes.AGENT_UPDATE,
+ agent_update: contentPart.agent_update,
+ };
+
+ updatedContent[index] = update;
+ } else if (
+ contentType.startsWith(ContentTypes.THINK) &&
+ ContentTypes.THINK in contentPart &&
+ typeof contentPart.think === 'string'
+ ) {
+ const currentContent = updatedContent[index] as ReasoningDeltaUpdate;
+ const update: ReasoningDeltaUpdate = {
+ ...currentContent,
+ type: ContentTypes.THINK,
+ think: (currentContent.think || '') + contentPart.think,
+ };
+
+ updatedContent[index] = update;
+ } else if (contentType === ContentTypes.IMAGE_URL && 'image_url' in contentPart) {
+ const currentContent = updatedContent[index] as {
+ type: ContentTypes.IMAGE_URL;
+ image_url: string;
+ };
+ updatedContent[index] = {
+ ...currentContent,
+ };
+ } else if (contentType === ContentTypes.SUMMARY) {
+ const currentSummary = updatedContent[index] as SummaryContentPart | undefined;
+ const incoming = contentPart as SummaryContentPart;
+ updatedContent[index] = {
+ ...incoming,
+ content: [...(currentSummary?.content ?? []), ...(incoming.content ?? [])],
+ };
+ } else if (contentType === ContentTypes.TOOL_CALL && 'tool_call' in contentPart) {
+ const existingContent = updatedContent[index] as Agents.ToolCallContent | undefined;
+ const existingToolCall = existingContent?.tool_call;
+ const toolCallArgs = (contentPart.tool_call as Agents.ToolCall).args;
+ /** When args are a valid object, they are likely already invoked */
+ let args =
+ finalUpdate || typeof existingToolCall?.args === 'object' || typeof toolCallArgs === 'object'
+ ? contentPart.tool_call.args
+ : (existingToolCall?.args ?? '') + (toolCallArgs ?? '');
+ /** Preserve previously streamed args when final update omits them */
+ if (finalUpdate && args == null && existingToolCall?.args != null) {
+ args = existingToolCall.args;
+ }
+
+ const id = getNonEmptyValue([contentPart.tool_call.id, existingToolCall?.id]) ?? '';
+ const name = getNonEmptyValue([contentPart.tool_call.name, existingToolCall?.name]) ?? '';
+
+ const newToolCall: Agents.ToolCall & PartMetadata = {
+ id,
+ name,
+ args,
+ stepId: getNonEmptyValue([contentPart.tool_call.stepId, existingToolCall?.stepId]),
+ type: ToolCallTypes.TOOL_CALL,
+ auth: contentPart.tool_call.auth,
+ expires_at: contentPart.tool_call.expires_at,
+ };
+
+ if (finalUpdate) {
+ newToolCall.progress = 1;
+ newToolCall.output = contentPart.tool_call.output;
+ if (
+ 'inputValidationError' in contentPart.tool_call &&
+ contentPart.tool_call.inputValidationError === true
+ ) {
+ Object.assign(newToolCall, { inputValidationError: true });
+ }
+ }
+
+ updatedContent[index] = {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: newToolCall,
+ };
+ }
+
+ /** Metadata goes on last so no branch above overwrites it. The part is copied rather than
+ * mutated: an untouched slot still holds the caller's object. */
+ if (metadata?.agentId != null || metadata?.groupId != null) {
+ updatedContent[index] = {
+ ...updatedContent[index],
+ ...(metadata.agentId != null && { agentId: metadata.agentId }),
+ ...(metadata.groupId != null && { groupId: metadata.groupId }),
+ } as Partial<TMessageContentParts>;
+ }
+
+ return { ...message, content: updatedContent as TMessageContentParts[] };
+}
diff --git a/client/src/hooks/SSE/steps/index.ts b/client/src/hooks/SSE/steps/index.ts
new file mode 100644
index 0000000000..d2ae7b2e9b
--- /dev/null
+++ b/client/src/hooks/SSE/steps/index.ts
@@ -0,0 +1,2 @@
+export * from './content';
+export * from './text';
diff --git a/client/src/hooks/SSE/steps/text.ts b/client/src/hooks/SSE/steps/text.ts
new file mode 100644
index 0000000000..24bf5aedc5
--- /dev/null
+++ b/client/src/hooks/SSE/steps/text.ts
@@ -0,0 +1,207 @@
+import { StepTypes, ContentTypes } from 'librechat-data-provider';
+import type {
+ Agents,
+ TMessage,
+ ContentMetadata,
+ SummaryContentPart,
+} from 'librechat-data-provider';
+import type { TextPhase } from './content';
+import {
+ prepareReasoningPartForStep,
+ calculateContentIndex,
+ getStepMetadata,
+ foldsEditPrefix,
+ updateContent,
+} from './content';
+
+/** Result of folding one message or reasoning delta into a response. */
+export type DeltaResult = {
+ message: TMessage;
+ /** False when the delta carried no parts, so nothing should be written. */
+ updated: boolean;
+ /** True when a part folded into the last part of the retained edit prefix. */
+ foldedEditPrefix: boolean;
+};
+
+const toParts = (
+ content: Agents.MessageContentComplex | Agents.MessageContentComplex[],
+): Agents.MessageContentComplex[] => (Array.isArray(content) ? content : [content]);
+
+/**
+ * Folds a message delta (text, or think parts on providers that stream reasoning through the
+ * message channel) into the response. A delta may carry several parts, such as Google server-side
+ * tool chunks, and every entry is applied in order or streamed text is silently dropped.
+ * AI SDK: `text-delta`.
+ */
+export function applyMessageDelta(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ delta: Agents.MessageDeltaEvent,
+ editPrefixOffset: number,
+): DeltaResult {
+ const result: DeltaResult = { message, updated: false, foldedEditPrefix: false };
+ if (!delta.delta.content) {
+ return result;
+ }
+ const phase =
+ runStep.stepDetails.type === StepTypes.MESSAGE_CREATION
+ ? (runStep.stepDetails.message_creation as { phase?: TextPhase } | undefined)?.phase
+ : undefined;
+ const metadata = getStepMetadata(runStep);
+ for (const contentPart of toParts(delta.delta.content)) {
+ if (contentPart == null) {
+ continue;
+ }
+ const phasedContentPart =
+ contentPart.type === ContentTypes.TEXT && (phase === 'commentary' || phase === 'final_answer')
+ ? { ...contentPart, phase }
+ : contentPart;
+ const index = calculateContentIndex(
+ runStep.index,
+ editPrefixOffset,
+ phasedContentPart.type || '',
+ result.message.content,
+ phase,
+ );
+ if (foldsEditPrefix(runStep.index, editPrefixOffset, index)) {
+ result.foldedEditPrefix = true;
+ }
+ if (phasedContentPart.type === ContentTypes.THINK) {
+ result.message = prepareReasoningPartForStep(result.message, index, delta.id);
+ }
+ result.message = updateContent(result.message, index, phasedContentPart, false, metadata);
+ result.updated = true;
+ }
+ return result;
+}
+
+/**
+ * Folds a reasoning delta into the response. Same multi-part contract as
+ * {@link applyMessageDelta}. AI SDK: `reasoning-delta`.
+ */
+export function applyReasoningDelta(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ delta: Agents.ReasoningDeltaEvent,
+ editPrefixOffset: number,
+): DeltaResult {
+ const result: DeltaResult = { message, updated: false, foldedEditPrefix: false };
+ if (delta.delta.content == null) {
+ return result;
+ }
+ const metadata = getStepMetadata(runStep);
+ for (const contentPart of toParts(delta.delta.content)) {
+ if (contentPart == null) {
+ continue;
+ }
+ const index = calculateContentIndex(
+ runStep.index,
+ editPrefixOffset,
+ contentPart.type || '',
+ result.message.content,
+ );
+ if (foldsEditPrefix(runStep.index, editPrefixOffset, index)) {
+ result.foldedEditPrefix = true;
+ }
+ result.message = prepareReasoningPartForStep(result.message, index, delta.id);
+ result.message = updateContent(result.message, index, contentPart, false, metadata);
+ result.updated = true;
+ }
+ return result;
+}
+
+/**
+ * Writes an agent handoff marker at its own index. Agent updates carry their own agent id and
+ * default to group 1 when they have one.
+ */
+export function applyAgentUpdate(
+ message: TMessage,
+ event: Agents.AgentUpdate,
+ editPrefixOffset: number,
+): TMessage {
+ const { agent_update } = event;
+ const metadata: ContentMetadata | undefined = agent_update.agentId
+ ? { agentId: agent_update.agentId, groupId: 1 }
+ : undefined;
+ return updateContent(message, agent_update.index + editPrefixOffset, event, false, metadata);
+}
+
+/** Opens an in-flight summary part at a summarize step's slot. */
+export function applySummaryStep(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ editPrefixOffset: number,
+): TMessage {
+ if (runStep.summary == null) {
+ return message;
+ }
+ const summaryPart: SummaryContentPart = {
+ type: ContentTypes.SUMMARY,
+ content: [],
+ summarizing: true,
+ model: runStep.summary.model,
+ provider: runStep.summary.provider,
+ };
+ return updateContent(
+ { ...message },
+ runStep.index + editPrefixOffset,
+ summaryPart,
+ false,
+ getStepMetadata(runStep),
+ );
+}
+
+/** Appends a summary delta to its step's in-flight summary part. */
+export function applySummarizeDelta(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ delta: Agents.SummarizeDeltaEvent,
+ editPrefixOffset: number,
+): TMessage {
+ const contentPart: SummaryContentPart = { ...delta.delta.summary, summarizing: true };
+ return updateContent(
+ message,
+ runStep.index + editPrefixOffset,
+ contentPart,
+ false,
+ getStepMetadata(runStep),
+ );
+}
+
+/**
+ * Settles in-flight summary parts. Scoped to `completeIndex` when the owning step is known: a
+ * global scan would finalize a NEWER round's in-flight part when summarize cycles run
+ * back-to-back. A negative index finalizes every in-flight part.
+ *
+ * Failed rounds keep their slot, flagged `failed`, rather than being spliced out: removing a part
+ * shifts every later part under the index-keyed renderer and breaks the position invariant.
+ *
+ * Returns `undefined` when no part was in flight.
+ */
+export function finalizeSummaries(
+ message: TMessage,
+ event: Agents.SummarizeCompleteEvent,
+ completeIndex: number,
+): TMessage | undefined {
+ if (!Array.isArray(message.content)) {
+ return undefined;
+ }
+ let didFinalize = false;
+ const content = message.content.map((part, index) => {
+ if (part?.type !== ContentTypes.SUMMARY || !(part as SummaryContentPart).summarizing) {
+ return part;
+ }
+ if (completeIndex >= 0 && index !== completeIndex) {
+ return part;
+ }
+ didFinalize = true;
+ if (!event.error && event.summary) {
+ return { ...event.summary, summarizing: false } as SummaryContentPart;
+ }
+ if (event.error) {
+ return { ...part, summarizing: false, failed: true } as SummaryContentPart;
+ }
+ return { ...part, summarizing: false } as SummaryContentPart;
+ });
+ return didFinalize ? { ...message, content } : undefined;
+}
diff --git a/client/src/hooks/SSE/useStepHandler.ts b/client/src/hooks/SSE/useStepHandler.ts
index 4fd07ffc7c..fbbc1ba8a0 100644
--- a/client/src/hooks/SSE/useStepHandler.ts
+++ b/client/src/hooks/SSE/useStepHandler.ts
@@ -6,8 +6,6 @@ import {
StepTypes,
StepEvents,
ContentTypes,
- ToolCallTypes,
- getNonEmptyValue,
getRunStepDurationMs,
getRunStepCloseMetadata,
getToolTimingDurations,
@@ -15,10 +13,7 @@ import {
import type {
Agents,
TMessage,
- PartMetadata,
- ContentMetadata,
EventSubmission,
- SummaryContentPart,
TMessageContentParts,
SubagentUpdateEvent,
SandboxStartingEvent,
@@ -37,13 +32,23 @@ import {
takeRegisteredSubagentProgressKeys,
subagentProgressKey,
} from '~/components/Chat/Subagents/state';
+import {
+ applyReasoningDelta,
+ applySummarizeDelta,
+ applyMessageDelta,
+ finalizeSummaries,
+ applyAgentUpdate,
+ applySummaryStep,
+ getStepMetadata,
+ getEditPrefix,
+ updateContent,
+} from './steps';
import {
sandboxStartingByToolCallId,
ptcTraceByToolCallId,
PTC_TRACE_MAX_ENTRIES,
ptcTraceKey,
} from '~/store';
-import { isAskUserQuestionPart, isAnsweredAskUserQuestionPart } from '~/utils/approval';
import { MESSAGE_UPDATE_INTERVAL } from '~/common';
type TUseStepHandler = {
@@ -81,45 +86,6 @@ type TStepEvent =
| { event: StepEvents.ON_SANDBOX_STARTING; data: SandboxStartingEvent }
| { event: StepEvents.ON_PTC_TOOL_CALL; data: PtcToolCallEvent };
-type MessageDeltaUpdate = {
- type: ContentTypes.TEXT;
- text: string;
- tool_call_ids?: string[];
- phase?: 'commentary' | 'final_answer';
-};
-
-type ReasoningDeltaUpdate = { type: ContentTypes.THINK; think: string };
-
-/** Starts a fresh label-revision domain when a different reasoning step
- * reuses or folds into an existing THINK slot. The step id is stamped before
- * the first generated title so compacted resume snapshots can still correlate
- * later label events by identity rather than relying only on a sparse index. */
-function prepareReasoningPartForStep(message: TMessage, index: number, stepId: string): TMessage {
- const current = message.content?.[index];
- if (current?.type !== ContentTypes.THINK || current.reasoning_label_step_id === stepId) {
- return message;
- }
- const nextPart = { ...current };
- delete nextPart.reasoning_label;
- delete nextPart.reasoning_label_attempts;
- delete nextPart.reasoning_label_submitted_chars;
- delete nextPart.reasoning_label_revision;
- delete nextPart.reasoning_label_status;
- nextPart.reasoning_label_step_id = stepId;
- const nextContent = [...(message.content ?? [])];
- nextContent[index] = nextPart;
- return { ...message, content: nextContent };
-}
-
-type AllContentTypes =
- | ContentTypes.TEXT
- | ContentTypes.THINK
- | ContentTypes.TOOL_CALL
- | ContentTypes.IMAGE_FILE
- | ContentTypes.IMAGE_URL
- | ContentTypes.SUMMARY
- | ContentTypes.ERROR;
-
/** Mirrors `SKILL_FILE_PREFIX` in `@librechat/api` file-authoring handlers. */
const SKILL_FILE_PREFIX = 'skills/';
const FILE_AUTHORING_TOOLS = new Set(['create_file', 'edit_file']);
@@ -148,18 +114,6 @@ function isSkillAuthoringToolCall(toolCall?: Agents.ToolCall): boolean {
return typeof filePath === 'string' && filePath.startsWith(SKILL_FILE_PREFIX);
}
-const isOAuthToolCallName = (name?: string) =>
- typeof name === 'string' && name.startsWith(`oauth${Constants.mcp_delimiter}`);
-
-const isOAuthToolCallContent = (part?: Partial<TMessageContentParts>) => {
- if (part?.type !== ContentTypes.TOOL_CALL || !('tool_call' in part)) {
- return false;
- }
- const { tool_call: toolCall } = part;
- const name = toolCall != null && 'name' in toolCall ? toolCall.name : undefined;
- return isOAuthToolCallName(name);
-};
-
export default function useStepHandler({
setMessages,
getMessages,
@@ -214,7 +168,7 @@ export default function useStepHandler({
);
/** Both content parts and ticker lines are aggregated incrementally
- * into the atom as each `ON_SUBAGENT_UPDATE` arrives — we never
+ * into the atom as each `ON_SUBAGENT_UPDATE` arrives; we never
* retain the raw event array, so no rolling window is needed. A
* talkative subagent can emit thousands of deltas without growing
* memory past what the structural output requires. */
@@ -300,13 +254,13 @@ export default function useStepHandler({
/**
* Resets all accumulated subagent state. Kept for conversation-switch
- * cleanup (see top-level hook usage) but NOT called from `clearStepMaps` —
+ * cleanup (see top-level hook usage) but NOT called from `clearStepMaps`:
* the collapsed SubagentCall ticker and its panel read from these atoms to
* render the child's content parts, and we want that history to remain
* visible after the stream ends so the user can reopen the panel for
* auditability. The atoms are bounded by aggregated structure and
* per-conversation (one atom per subagent spawn), so growth is proportional
- * to messages — the same growth profile as the rest of the conversation
+ * to messages: the same growth profile as the rest of the conversation
* state.
*/
const resetSubagentAtoms = useCallback((): void => {
@@ -364,7 +318,7 @@ export default function useStepHandler({
* Folds one `on_ptc_tool_call` envelope into its program's trace: the
* `running` event appends a row, the settling event updates that row in
* place by `call_id`. Order follows the sandbox's dispatch order, which is
- * what the code reads like — a round trip can settle out of order.
+ * what the code reads like; a round trip can settle out of order.
*/
const applyPtcToolCall = useRecoilCallback(
({ set }) =>
@@ -394,8 +348,8 @@ export default function useStepHandler({
return { entries: next, dropped: previous.dropped };
}
- /** A settle whose row is gone — evicted by the cap, or pruned across
- * a resume gap — must not reappear at the tail out of order. */
+ /** A settle whose row is gone, evicted by the cap, or pruned across
+ * a resume gap, must not reappear at the tail out of order. */
if (status !== 'running') {
return previous;
}
@@ -427,15 +381,15 @@ export default function useStepHandler({
/**
* Settles rows still marked `running` after a stream gap as `interrupted`.
- * Inner calls carry no durable state — they are not content parts, so the
+ * Inner calls carry no durable state: they are not content parts, so the
* resume snapshot cannot rebuild them and a settling event lost in the gap
- * is never replayed — which means such a row would otherwise spin forever.
+ * is never replayed, and that means such a row would otherwise spin forever.
*
* Marked, not removed: a call can also still be executing across the
* reconnect, and its settling event then arrives normally on the restored
* live stream. That event updates this row in place, so the call reports its
- * real outcome. Deleting the row would strand it — a settle whose row is
- * gone is dropped rather than re-appended out of order — and the call would
+ * real outcome. Deleting the row would strand it: a settle whose row is
+ * gone is dropped rather than re-appended out of order, and the call would
* vanish from the trace despite having run. Settled rows are untouched.
*/
const prunePtcTraces = useRecoilCallback(
@@ -459,259 +413,6 @@ export default function useStepHandler({
[],
);
- /**
- * Calculate content index for a run step.
- *
- * Takes the edit-prefix OFFSET rather than the prefix array: after a resume
- * sync the live array no longer describes the retained prefix, so deriving
- * the offset here from its length would disagree with the offset every
- * other event path applies.
- */
- const calculateContentIndex = useCallback(
- (
- serverIndex: number,
- editPrefixOffset: number,
- incomingContentType: string,
- existingContent?: TMessageContentParts[],
- incomingPhase?: 'commentary' | 'final_answer',
- ): number => {
- /** Only apply -1 adjustment for TEXT or THINK types when they match existing content */
- if (
- editPrefixOffset > 0 &&
- (incomingContentType === ContentTypes.TEXT || incomingContentType === ContentTypes.THINK)
- ) {
- const targetIndex = serverIndex + editPrefixOffset - 1;
- const existingPart = existingContent?.[targetIndex];
- const existingType = existingPart?.type;
- const existingPhase =
- existingPart?.type === ContentTypes.TEXT ? existingPart.phase : undefined;
- /** Match final assembly: phased and legacy/unphased text cannot share
- * a content part because the phase controls client grouping. */
- const phaseCompatible =
- incomingContentType !== ContentTypes.TEXT ||
- (incomingPhase ?? null) === (existingPhase ?? null);
- if (existingType === incomingContentType && phaseCompatible) {
- return targetIndex;
- }
- }
- return serverIndex + editPrefixOffset;
- },
- [],
- );
-
- /** Metadata to propagate onto content parts for parallel rendering - uses ContentMetadata from data-provider */
-
- const updateContent = (
- message: TMessage,
- index: number,
- contentPart: Agents.MessageContentComplex,
- finalUpdate = false,
- metadata?: ContentMetadata,
- ) => {
- const contentType = contentPart.type ?? '';
- if (!contentType) {
- console.warn('No content type found in content part');
- return message;
- }
-
- const incomingOAuthToolCall =
- contentType === ContentTypes.TOOL_CALL &&
- 'tool_call' in contentPart &&
- isOAuthToolCallName(contentPart.tool_call?.name);
-
- let updatedContent = [...(message.content || [])] as Array<
- Partial<TMessageContentParts> | undefined
- >;
-
- const oauthPromptOccupiesSlot = isOAuthToolCallContent(updatedContent[index]);
- if (!incomingOAuthToolCall && oauthPromptOccupiesSlot) {
- updatedContent = updatedContent.filter((part) => !isOAuthToolCallContent(part));
- }
-
- /**
- * The synthetic ask-user-question card is pause-scoped UI appended at the end
- * of the content — exactly the ABSOLUTE index the resumed segment streams
- * into. Once real content arrives for that slot the pause is over: displace
- * the card (same displacement pattern as the OAuth prompt above) instead of
- * dropping the incoming part as a type mismatch. Covers the streaming
- * handler's own in-flight message copy, reconnecting tabs, and other devices
- * — the store-level strip on answer submit can't reach those.
- */
- if (isAskUserQuestionPart(updatedContent[index])) {
- updatedContent[index] = undefined;
- } else if (updatedContent.some(isAnsweredAskUserQuestionPart)) {
- /**
- * An ALREADY-ANSWERED card the resumed segment streams around rather than
- * into: the first event after the resume re-renders the ask tool_call at
- * ITS OWN index, so the slot test above never fires and this handler's
- * cached copy — which still holds the card the answer-submit stripped from
- * the store — gets written back, reopening the popover with its options
- * locked. Only cards the user actually answered are dropped, so an event
- * racing a still-live pause can't take its card down. Preserve sparse
- * absolute indices: compacting holes can move an older tool call into a
- * text slot until the terminal snapshot repairs the rendered order.
- */
- updatedContent = updatedContent.map((part) =>
- isAnsweredAskUserQuestionPart(part) ? undefined : part,
- );
- }
-
- if (!updatedContent[index] && contentType !== ContentTypes.TOOL_CALL) {
- updatedContent[index] = { type: contentPart.type as AllContentTypes };
- }
-
- /** Prevent overwriting an existing content part with a different type */
- const existingType = (updatedContent[index]?.type as string | undefined) ?? '';
- if (
- existingType &&
- existingType !== contentType &&
- !contentType.startsWith(existingType) &&
- !existingType.startsWith(contentType)
- ) {
- console.warn('Content type mismatch', { existingType, contentType, index });
- return message;
- }
-
- if (
- contentType.startsWith(ContentTypes.TEXT) &&
- ContentTypes.TEXT in contentPart &&
- typeof contentPart.text === 'string'
- ) {
- const currentContent = updatedContent[index] as MessageDeltaUpdate;
- const incomingContent = contentPart as MessageDeltaUpdate;
- const phase = incomingContent.phase ?? currentContent.phase;
- const update: MessageDeltaUpdate = {
- type: ContentTypes.TEXT,
- text: (currentContent.text || '') + incomingContent.text,
- ...(phase != null && { phase }),
- };
-
- if ('tool_call_ids' in contentPart && contentPart.tool_call_ids != null) {
- update.tool_call_ids = contentPart.tool_call_ids;
- }
- updatedContent[index] = update;
- } else if (
- contentType.startsWith(ContentTypes.AGENT_UPDATE) &&
- ContentTypes.AGENT_UPDATE in contentPart &&
- contentPart.agent_update
- ) {
- const update: Agents.AgentUpdate = {
- type: ContentTypes.AGENT_UPDATE,
- agent_update: contentPart.agent_update,
- };
-
- updatedContent[index] = update;
- } else if (
- contentType.startsWith(ContentTypes.THINK) &&
- ContentTypes.THINK in contentPart &&
- typeof contentPart.think === 'string'
- ) {
- const currentContent = updatedContent[index] as ReasoningDeltaUpdate;
- const update: ReasoningDeltaUpdate = {
- ...currentContent,
- type: ContentTypes.THINK,
- think: (currentContent.think || '') + contentPart.think,
- };
-
- updatedContent[index] = update;
- } else if (contentType === ContentTypes.IMAGE_URL && 'image_url' in contentPart) {
- const currentContent = updatedContent[index] as {
- type: ContentTypes.IMAGE_URL;
- image_url: string;
- };
- updatedContent[index] = {
- ...currentContent,
- };
- } else if (contentType === ContentTypes.SUMMARY) {
- const currentSummary = updatedContent[index] as SummaryContentPart | undefined;
- const incoming = contentPart as SummaryContentPart;
- updatedContent[index] = {
- ...incoming,
- content: [...(currentSummary?.content ?? []), ...(incoming.content ?? [])],
- };
- } else if (contentType === ContentTypes.TOOL_CALL && 'tool_call' in contentPart) {
- const existingContent = updatedContent[index] as Agents.ToolCallContent | undefined;
- const existingToolCall = existingContent?.tool_call as
- | (Agents.ToolCall & PartMetadata)
- | undefined;
- const toolCallArgs = (contentPart.tool_call as Agents.ToolCall).args;
- /** When args are a valid object, they are likely already invoked */
- let args =
- finalUpdate ||
- typeof existingToolCall?.args === 'object' ||
- typeof toolCallArgs === 'object'
- ? contentPart.tool_call.args
- : (existingToolCall?.args ?? '') + (toolCallArgs ?? '');
- /** Preserve previously streamed args when final update omits them */
- if (finalUpdate && args == null && existingToolCall?.args != null) {
- args = existingToolCall.args;
- }
-
- const id = getNonEmptyValue([contentPart.tool_call.id, existingToolCall?.id]) ?? '';
- const name = getNonEmptyValue([contentPart.tool_call.name, existingToolCall?.name]) ?? '';
-
- const newToolCall: Agents.ToolCall & PartMetadata = {
- id,
- name,
- args,
- stepId: getNonEmptyValue([contentPart.tool_call.stepId, existingToolCall?.stepId]),
- type: ToolCallTypes.TOOL_CALL,
- auth: contentPart.tool_call.auth,
- expires_at: contentPart.tool_call.expires_at,
- toolPreparationStartedAt:
- contentPart.tool_call.toolPreparationStartedAt ??
- existingToolCall?.toolPreparationStartedAt,
- toolDispatchedAt:
- contentPart.tool_call.toolDispatchedAt ?? existingToolCall?.toolDispatchedAt,
- };
-
- if (finalUpdate) {
- newToolCall.progress = 1;
- newToolCall.output = contentPart.tool_call.output;
- if (
- 'inputValidationError' in contentPart.tool_call &&
- contentPart.tool_call.inputValidationError === true
- ) {
- Object.assign(newToolCall, { inputValidationError: true });
- }
- }
-
- updatedContent[index] = {
- type: ContentTypes.TOOL_CALL,
- tool_call: newToolCall,
- };
- }
-
- // Apply metadata to the content part for parallel rendering
- // This must happen AFTER all content updates to avoid being overwritten
- if (metadata?.agentId != null || metadata?.groupId != null) {
- const part = updatedContent[index] as TMessageContentParts & ContentMetadata;
- if (metadata.agentId != null) {
- part.agentId = metadata.agentId;
- }
- if (metadata.groupId != null) {
- part.groupId = metadata.groupId;
- }
- }
-
- return { ...message, content: updatedContent as TMessageContentParts[] };
- };
-
- /** Extract metadata from runStep for parallel content rendering */
- const getStepMetadata = (runStep: Agents.RunStep | undefined): ContentMetadata | undefined => {
- if (!runStep?.agentId && runStep?.groupId == null) {
- return undefined;
- }
- const metadata = {
- agentId: runStep.agentId,
- // Only set groupId when explicitly provided by the server
- // Sequential handoffs have agentId but no groupId
- // Parallel execution has both agentId AND groupId
- groupId: runStep.groupId,
- };
- return metadata;
- };
-
const stepHandler = useCallback(
(stepEvent: TStepEvent, submission: EventSubmission) => {
const submissionMessages = submission.messages ?? [];
@@ -829,7 +530,7 @@ export default function useStepHandler({
};
/**
* Per-token deltas fold into `messageMap` immediately (authoritative), but
- * the cache write — and the buildTree + message-tree walk it triggers —
+ * the cache write, and the buildTree + message-tree walk it triggers,
* flushes at most once per frame. Non-delta events keep writing
* synchronously from `messageMap`, so a trailing flush after them merges
* the same authoritative state; `clearStepMaps` cancels the flush at run
@@ -873,34 +574,9 @@ export default function useStepHandler({
lastAnnouncementTimeRef.current = currentTime;
}
- /**
- * Index offset for an edited resubmission: the server indexes only the
- * NEW content, so incoming indices shift past the prefix the client
- * kept.
- *
- * Reads the length CAPTURED when the submission was built rather than
- * the live `initialResponse.content` array, because a resume sync
- * REPLACES that array with the server's completion-local snapshot —
- * whose length describes the new generation, not the retained prefix.
- * They are equal until a reconnect, so the non-resumed path is
- * unaffected.
- *
- * `editPrefixCleared` means that sync also replaced the RENDERED
- * content: the prefix is gone from the message and server indices are
- * already absolute, so any offset would write past the end. Activity
- * labels honor the same flag — both must agree, or a batch's tool
- * cards and its header land in different index spaces.
- *
- * `initialContent` stays the live array: it seeds a response that is
- * not in the map yet, and post-sync the seeding path correctly falls
- * back to the rendered content instead.
- */
- let initialContent: TMessageContentParts[] = [];
- let editPrefixOffset = 0;
- if (submission?.editedContent != null && submission?.editPrefixCleared !== true) {
- initialContent = submission?.initialResponse?.content ?? initialContent;
- editPrefixOffset = submission?.editPrefixLength ?? initialContent.length;
- }
+ /** Activity labels honor the same `editPrefixCleared` flag `getEditPrefix` reads, so a
+ * batch's tool cards and its header land in one index space. */
+ const { initialContent, editPrefixOffset } = getEditPrefix(submission);
if (stepEvent.event === StepEvents.ON_RUN_STEP) {
const runStep = stepEvent.data;
@@ -916,9 +592,6 @@ export default function useStepHandler({
stepMap.current.set(runStep.id, runStep);
- // Calculate content index - use server index, offset by the retained edit prefix
- const contentIndex = runStep.index + editPrefixOffset;
-
let response = messageMap.current.get(responseMessageId);
if (!response) {
@@ -970,10 +643,10 @@ export default function useStepHandler({
setMessages([...updatedMessages, response]);
}
- // Store tool call IDs if present
if (runStep.stepDetails.type === StepTypes.TOOL_CALLS) {
const streamedCallCount = runStep.stepDetails.tool_calls?.length ?? 0;
let updatedResponse = { ...response };
+ const contentIndex = runStep.index + editPrefixOffset;
((runStep.stepDetails.tool_calls ?? []) as Agents.ToolCall[]).forEach((toolCall) => {
const toolCallId = toolCall.id ?? '';
if ('id' in toolCall && toolCallId) {
@@ -998,7 +671,6 @@ export default function useStepHandler({
},
};
- // Use the pre-calculated contentIndex which handles parallel agent indexing
updatedResponse = updateContent(
updatedResponse,
contentIndex,
@@ -1017,23 +689,11 @@ export default function useStepHandler({
}
if (runStep.summary != null) {
- const summaryPart: SummaryContentPart = {
- type: ContentTypes.SUMMARY,
- content: [],
- summarizing: true,
- model: runStep.summary.model,
- provider: runStep.summary.provider,
- };
-
- let updatedResponse = { ...(messageMap.current.get(responseMessageId) ?? response) };
- updatedResponse = updateContent(
- updatedResponse,
- contentIndex,
- summaryPart,
- false,
- getStepMetadata(runStep),
+ const updatedResponse = applySummaryStep(
+ messageMap.current.get(responseMessageId) ?? response,
+ runStep,
+ editPrefixOffset,
);
-
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
@@ -1063,19 +723,7 @@ export default function useStepHandler({
const response = messageMap.current.get(responseMessageId);
if (response) {
- // Agent updates don't need index adjustment
- const currentIndex = agent_update.index + editPrefixOffset;
- // Agent updates carry their own agentId - use default groupId if agentId is present
- const agentUpdateMeta: ContentMetadata | undefined = agent_update.agentId
- ? { agentId: agent_update.agentId, groupId: 1 }
- : undefined;
- const updatedResponse = updateContent(
- response,
- currentIndex,
- stepEvent.data,
- false,
- agentUpdateMeta,
- );
+ const updatedResponse = applyAgentUpdate(response, stepEvent.data, editPrefixOffset);
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
@@ -1100,65 +748,13 @@ export default function useStepHandler({
}
const response = messageMap.current.get(responseMessageId);
- if (response && messageDelta.delta.content) {
- /** A delta may carry several parts (e.g. Google server-side tool
- * chunks) — every entry must be applied, in order, or streamed
- * text is silently dropped. */
- const contentParts = Array.isArray(messageDelta.delta.content)
- ? messageDelta.delta.content
- : [messageDelta.delta.content];
-
- let updatedResponse = response;
- let hasUpdate = false;
- for (const contentPart of contentParts) {
- if (contentPart == null) {
- continue;
- }
- const messageCreation =
- runStep.stepDetails.type === StepTypes.MESSAGE_CREATION
- ? (runStep.stepDetails.message_creation as {
- phase?: 'commentary' | 'final_answer';
- })
- : undefined;
- const phase = messageCreation?.phase;
- const phasedContentPart =
- contentPart.type === ContentTypes.TEXT &&
- (phase === 'commentary' || phase === 'final_answer')
- ? { ...contentPart, phase }
- : contentPart;
- const currentIndex = calculateContentIndex(
- runStep.index,
- editPrefixOffset,
- phasedContentPart.type || '',
- updatedResponse.content,
- phase,
- );
- if (
- submission != null &&
- runStep.index === 0 &&
- editPrefixOffset > 0 &&
- currentIndex === editPrefixOffset - 1
- ) {
- submission.editPrefixFirstPartFolded = true;
- }
- if (phasedContentPart.type === ContentTypes.THINK) {
- updatedResponse = prepareReasoningPartForStep(
- updatedResponse,
- currentIndex,
- messageDelta.id,
- );
- }
- updatedResponse = updateContent(
- updatedResponse,
- currentIndex,
- phasedContentPart,
- false,
- getStepMetadata(runStep),
- );
- hasUpdate = true;
+ if (response) {
+ const result = applyMessageDelta(response, runStep, messageDelta, editPrefixOffset);
+ if (result.foldedEditPrefix && submission != null) {
+ submission.editPrefixFirstPartFolded = true;
}
- if (hasUpdate) {
- messageMap.current.set(responseMessageId, updatedResponse);
+ if (result.updated) {
+ messageMap.current.set(responseMessageId, result.message);
scheduleCoalescedMessagesFlush(responseMessageId);
}
}
@@ -1179,49 +775,13 @@ export default function useStepHandler({
}
const response = messageMap.current.get(responseMessageId);
- if (response && reasoningDelta.delta.content != null) {
- /** Same multi-part contract as message deltas: Google server-side
- * tool chunks emit several think entries in one delta. */
- const contentParts = Array.isArray(reasoningDelta.delta.content)
- ? reasoningDelta.delta.content
- : [reasoningDelta.delta.content];
-
- let updatedResponse = response;
- let hasUpdate = false;
- for (const contentPart of contentParts) {
- if (contentPart == null) {
- continue;
- }
- const currentIndex = calculateContentIndex(
- runStep.index,
- editPrefixOffset,
- contentPart.type || '',
- updatedResponse.content,
- );
- if (
- submission != null &&
- runStep.index === 0 &&
- editPrefixOffset > 0 &&
- currentIndex === editPrefixOffset - 1
- ) {
- submission.editPrefixFirstPartFolded = true;
- }
- updatedResponse = prepareReasoningPartForStep(
- updatedResponse,
- currentIndex,
- reasoningDelta.id,
- );
- updatedResponse = updateContent(
- updatedResponse,
- currentIndex,
- contentPart,
- false,
- getStepMetadata(runStep),
- );
- hasUpdate = true;
+ if (response) {
+ const result = applyReasoningDelta(response, runStep, reasoningDelta, editPrefixOffset);
+ if (result.foldedEditPrefix && submission != null) {
+ submission.editPrefixFirstPartFolded = true;
}
- if (hasUpdate) {
- messageMap.current.set(responseMessageId, updatedResponse);
+ if (result.updated) {
+ messageMap.current.set(responseMessageId, result.message);
scheduleCoalescedMessagesFlush(responseMessageId);
}
}
@@ -1480,7 +1040,7 @@ export default function useStepHandler({
/**
* A closure for a step this client never saw opened is not an error
- * worth surfacing — it happens on reconnect, where the replay may
+ * worth surfacing; it happens on reconnect, where the replay may
* start after the step was created.
*/
if (!runStep || !responseMessageId) {
@@ -1598,18 +1158,11 @@ export default function useStepHandler({
const response = messageMap.current.get(responseMessageId);
if (response) {
- const contentPart: SummaryContentPart = {
- ...deltaData.delta.summary,
- summarizing: true,
- };
-
- const contentIndex = runStep.index + editPrefixOffset;
- const updatedResponse = updateContent(
+ const updatedResponse = applySummarizeDelta(
response,
- contentIndex,
- contentPart,
- false,
- getStepMetadata(runStep),
+ runStep,
+ deltaData,
+ editPrefixOffset,
);
messageMap.current.set(responseMessageId, updatedResponse);
if (summarizeDeltaRaf.current == null) {
@@ -1632,53 +1185,19 @@ export default function useStepHandler({
}
const targetMessage = messageMap.current.get(completeMessageId);
- if (!targetMessage || !Array.isArray(targetMessage.content)) {
+ if (!targetMessage) {
return;
}
- /**
- * Scoped to the owning step's slot when the step is known: a global
- * scan finalizes a NEWER round's in-flight part when summarize
- * cycles run back-to-back (tiny context windows re-trigger
- * summarization every graph step). Unknown step falls back to
- * finalizing every in-flight part.
- */
+ /** Scoped to the owning step's slot when the step is known; see `finalizeSummaries`. */
const completeIndex =
completeRunStep != null ? completeRunStep.index + editPrefixOffset : -1;
- let didFinalize = false;
- const updatedContent = targetMessage.content.map((part, index) => {
- if (part?.type !== ContentTypes.SUMMARY || !(part as SummaryContentPart).summarizing) {
- return part;
- }
- if (completeIndex >= 0 && index !== completeIndex) {
- return part;
- }
- didFinalize = true;
- if (!completeData.error && completeData.summary) {
- return { ...completeData.summary, summarizing: false } as SummaryContentPart;
- }
- /**
- * Failed rounds keep their slot. Splicing the part out shifts every
- * later part under the index-keyed renderer (remounting rows and
- * collapsing whatever the user expanded mid-stream) and breaks the
- * content-position == step-index invariant that `updateContent`
- * writes rely on. Flipping the flag alone hides an empty row
- * (`Summary` renders null without text) and matches the persisted
- * message, which retains the part server-side. An errored round
- * carries `failed` so partial deltas that already streamed in are
- * not presented as a completed summary.
- */
- if (completeData.error) {
- return { ...part, summarizing: false, failed: true } as SummaryContentPart;
- }
- return { ...part, summarizing: false } as SummaryContentPart;
- });
- if (didFinalize) {
+ const finalized = finalizeSummaries(targetMessage, completeData, completeIndex);
+ if (finalized) {
announcePolite({
message: completeData.error ? 'summarize_failed' : 'summarize_completed',
isStatus: true,
});
- const finalized = { ...targetMessage, content: updatedContent };
const currentMessages = submission.isRegenerate ? messages : getMessages() || [];
messageMap.current.set(completeMessageId, finalized);
setMessages(mergeResponseMessage(currentMessages, finalized, completeMessageId));
@@ -1693,7 +1212,6 @@ export default function useStepHandler({
lastAnnouncementTimeRef,
announcePolite,
setMessages,
- calculateContentIndex,
getCurrentMessages,
applySubagentUpdate,
onSubagentIndexChange,
@@ -1719,8 +1237,8 @@ export default function useStepHandler({
}, []);
/** Applies a queued delta flush synchronously (then cancels the frame).
- * For boundaries that READ the cache or synthesize from it — abort's
- * partial-response capture, error cards, pending-action application — the
+ * For boundaries that READ the cache or synthesize from it (abort's
+ * partial-response capture, error cards, pending-action application), the
* queued tokens must land first or the stopped/errored message loses them. */
const flushPendingDeltas = useCallback(() => {
if (messageDeltaRaf.current != null) {
@@ -1754,15 +1272,15 @@ export default function useStepHandler({
pendingSubagentBuffer.current.clear();
closeParentSubagentStreams();
/** Unlike subagent atoms below, sandbox-starting flags are transient
- * status with no audit value — reset them at this boundary so an
+ * status with no audit value; reset them at this boundary so an
* interrupted cold boot can't leak a stale "starting" label onto a
* later tool call that reuses the same id (e.g. `call_0`). */
resetSandboxAtoms();
- /** Intentionally NOT calling `resetSubagentAtoms()` here — users need
+ /** Intentionally NOT calling `resetSubagentAtoms()` here: users need
* to be able to reopen the SubagentCall dialog after completion to
* audit what the child did. `resetSubagentAtoms` is returned below
* so callers can wipe atoms on conversation-switch (see
- * `useEventHandlers`) — that's the correct cleanup boundary:
+ * `useEventHandlers`); that's the correct cleanup boundary:
* persisted `subagent_content` takes over for historical messages
* once the conversation is saved, and we prevent unbounded
* atomFamily growth across multi-conversation sessions. */
diff --git a/e2e/specs/mock/scenarios/step-reducer.spec.ts b/e2e/specs/mock/scenarios/step-reducer.spec.ts
new file mode 100644
index 0000000000..d0746792d9
--- /dev/null
+++ b/e2e/specs/mock/scenarios/step-reducer.spec.ts
@@ -0,0 +1,83 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import {
+ sendMessageAndWaitForCompletion,
+ selectMockEndpoint,
+ MOCK_ENDPOINTS,
+ NEW_CHAT_PATH,
+ messagesView,
+ thinkPrompt,
+ replyText,
+} from '../helpers';
+
+/**
+ * Streamed content parts are folded into the response by the step reducers in
+ * `client/src/hooks/SSE/steps`, each at its step's index. These scenarios pin
+ * what that looks like on screen, live and after the persisted copy reloads.
+ */
+
+const uniqueLabel = (prefix: string) =>
+ `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+const lastAssistant = (page: Page) => messagesView(page).locator('.message-render').last();
+
+/** True when `first` sits before `second` in document order. */
+async function precedes(first: Locator, second: Locator): Promise<boolean> {
+ const handle = await second.elementHandle();
+ return first.evaluate(
+ (node, other) =>
+ other != null && (node.compareDocumentPosition(other) & Node.DOCUMENT_POSITION_FOLLOWING) > 0,
+ handle,
+ );
+}
+
+async function expectReasoningBeforeReply(page: Page, label: string) {
+ const assistant = lastAssistant(page);
+ const thoughts = assistant.getByText('Thoughts', { exact: true }).first();
+ const reply = assistant.getByText(replyText(label), { exact: true });
+ await expect(thoughts).toBeVisible({ timeout: 30_000 });
+ await expect(reply).toBeVisible({ timeout: 30_000 });
+ await expect(reply).toHaveCount(1);
+ expect(await precedes(thoughts, reply)).toBe(true);
+}
+
+test.describe('step reducer', () => {
+ test('streamed reasoning renders ahead of its reply text, live and after reload @scenario:reasoning-renders-before-its-reply-text', async ({
+ page,
+ }) => {
+ test.setTimeout(60_000);
+ const label = uniqueLabel('think');
+ await page.goto(NEW_CHAT_PATH, { timeout: 10_000 });
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+
+ const response = await sendMessageAndWaitForCompletion(page, thinkPrompt(label));
+ expect(response.ok()).toBeTruthy();
+ await expectReasoningBeforeReply(page, label);
+
+ await page.reload({ timeout: 10_000 });
+ await expectReasoningBeforeReply(page, label);
+ });
+
+ test('a manual compaction streams its summary into the conversation and keeps it after reload @scenario:manual-compaction-summary-survives-reload', async ({
+ page,
+ }) => {
+ test.setTimeout(120_000);
+ const label = uniqueLabel('compact');
+ await page.goto(NEW_CHAT_PATH, { timeout: 10_000 });
+ await sendMessageAndWaitForCompletion(page, `tell me about ${label}`);
+
+ await page.getByTestId('token-usage').click();
+ await page.getByRole('button', { name: 'Compact context' }).click();
+
+ const compacted = messagesView(page).getByText('You compacted the context', { exact: true });
+ await expect(compacted).toBeVisible({ timeout: 60_000 });
+ await expect(compacted).toHaveCount(1);
+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeHidden({
+ timeout: 30_000,
+ });
+
+ await page.reload({ timeout: 10_000 });
+ await expect(compacted).toBeVisible({ timeout: 30_000 });
+ await expect(compacted).toHaveCount(1);
+ });
+});