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 for Tool Call Events (#16290)

Marco Beretta0173047549c2
diff --git a/client/src/hooks/SSE/__tests__/steps.spec.ts b/client/src/hooks/SSE/__tests__/steps.spec.ts
index fd89253e74..247fd2385c 100644
--- a/client/src/hooks/SSE/__tests__/steps.spec.ts
+++ b/client/src/hooks/SSE/__tests__/steps.spec.ts
@@ -1,4 +1,4 @@
-import { StepTypes, ContentTypes } from 'librechat-data-provider';
+import { StepTypes, ContentTypes, ToolCallTypes } from 'librechat-data-provider';
import type {
Agents,
TMessage,
@@ -7,9 +7,13 @@ import type {
TMessageContentParts,
} from 'librechat-data-provider';
import {
+ applyToolCallCompleted,
calculateContentIndex,
applyReasoningDelta,
applySummarizeDelta,
+ applyToolCallDelta,
+ applyRunStepClosed,
+ applyToolCallsStep,
finalizeSummaries,
applyMessageDelta,
applySummaryStep,
@@ -43,6 +47,20 @@ const messageStep = (
...overrides,
});
+const toolStep = (
+ id: string,
+ index: number,
+ toolCalls: Agents.ToolCall[],
+ overrides: Partial<Agents.RunStep> = {},
+): Agents.RunStep => ({
+ id,
+ index,
+ runId: RUN_ID,
+ type: StepTypes.TOOL_CALLS,
+ stepDetails: { type: StepTypes.TOOL_CALLS, tool_calls: toolCalls as Agents.AgentToolCall[] },
+ ...overrides,
+});
+
const textDelta = (id: string, text: string): Agents.MessageDeltaEvent => ({
id,
delta: { content: [{ type: ContentTypes.TEXT, text }] },
@@ -53,8 +71,22 @@ const thinkDelta = (id: string, think: string): Agents.ReasoningDeltaEvent => ({
delta: { content: [{ type: ContentTypes.THINK, think }] },
});
+const argsDelta = (id: string, args: string): Agents.RunStepDeltaEvent => ({
+ id,
+ delta: { type: StepTypes.TOOL_CALLS, tool_calls: [{ args } as Agents.ToolCallChunk] },
+});
+
+const toolEnd = (id: string, toolCall: Partial<Agents.ToolCall>): Agents.ToolEndEvent => ({
+ id,
+ index: 0,
+ tool_call: { type: ToolCallTypes.TOOL_CALL, ...toolCall } as Agents.ToolCall,
+});
+
const typesOf = (message: TMessage) => (message.content ?? []).map((part) => part?.type);
+const toolCallAt = (message: TMessage, index: number) =>
+ (message.content?.[index] as Agents.ToolCallContent | undefined)?.tool_call;
+
/**
* The invariant every reducer keeps: each step's part sits at `step.index + offset`, whatever
* order the events arrived in.
@@ -331,6 +363,195 @@ describe('steps', () => {
});
});
+ describe('tool calls', () => {
+ const search = toolStep('step-tool', 1, [{ id: 'call-1', name: 'search', args: '' }]);
+
+ const runToolCall = (response: TMessage) => {
+ const opened = applyToolCallsStep(response, search, 0);
+ let message = opened.message;
+ for (const chunk of ['{"q":', '"cats"}']) {
+ message = applyToolCallDelta(
+ message,
+ search,
+ argsDelta(search.id, chunk),
+ opened.toolCallId ?? '',
+ 0,
+ ) as TMessage;
+ }
+ return {
+ toolCallId: opened.toolCallId,
+ message: applyToolCallCompleted(
+ message,
+ search,
+ toolEnd(search.id, { id: 'call-1', name: 'search', args: '{"q":"cats"}', output: '3' }),
+ 0,
+ ),
+ };
+ };
+
+ it('opens, streams args into, and completes the step part', () => {
+ const text = messageStep('step-text', 0);
+ const { message, toolCallId } = runToolCall(streamText(createResponse(), text, ['Hi']));
+
+ expect(toolCallId).toBe('call-1');
+ expect(toolCallAt(message, 1)).toMatchObject({
+ id: 'call-1',
+ name: 'search',
+ args: '{"q":"cats"}',
+ output: '3',
+ progress: 1,
+ stepId: search.id,
+ });
+ expectStepPositions(message, [
+ [text, ContentTypes.TEXT],
+ [search, ContentTypes.TOOL_CALL],
+ ]);
+ });
+
+ it('is idempotent when the completion is delivered twice', () => {
+ const { message } = runToolCall(createResponse());
+ const completedTwice = applyToolCallCompleted(
+ message,
+ search,
+ toolEnd(search.id, { id: 'call-1', name: 'search', args: '{"q":"cats"}', output: '3' }),
+ 0,
+ );
+
+ expect(completedTwice.content).toEqual(message.content);
+ });
+
+ it('keeps streamed args when an open step is announced again', () => {
+ const opened = applyToolCallsStep(createResponse(), search, 0).message;
+ const streamed = applyToolCallDelta(
+ opened,
+ search,
+ argsDelta(search.id, '{"q":'),
+ 'call-1',
+ 0,
+ ) as TMessage;
+
+ const reannounced = applyToolCallsStep(streamed, search, 0).message;
+
+ expect(reannounced.content).toEqual(streamed.content);
+ });
+
+ it('keeps streamed args when the completion omits them', () => {
+ const opened = applyToolCallsStep(createResponse(), search, 0).message;
+ const streamed = applyToolCallDelta(opened, search, argsDelta(search.id, '{}'), 'call-1', 0);
+ const completed = applyToolCallCompleted(
+ streamed as TMessage,
+ search,
+ toolEnd(search.id, { id: 'call-1', name: 'search', output: 'ok' }),
+ 0,
+ );
+
+ expect(toolCallAt(completed, 1)).toMatchObject({ args: '{}', output: 'ok' });
+ });
+
+ it('writes a completion into its step slot when the opening part is missing', () => {
+ const completed = applyToolCallCompleted(
+ createResponse(),
+ search,
+ toolEnd(search.id, { id: 'call-1', name: 'search', args: { q: 'cats' }, output: '3' }),
+ 0,
+ );
+
+ expect(completed.content?.[0]).toBeUndefined();
+ expect(toolCallAt(completed, 1)).toMatchObject({ id: 'call-1', progress: 1 });
+ });
+
+ it('attaches OAuth prompts carried on an args delta', () => {
+ const opened = applyToolCallsStep(createResponse(), search, 0).message;
+ const result = applyToolCallDelta(
+ opened,
+ search,
+ {
+ id: search.id,
+ delta: {
+ type: StepTypes.TOOL_CALLS,
+ tool_calls: [{ args: '' } as Agents.ToolCallChunk],
+ auth: 'https://auth.example.com',
+ expires_at: 123,
+ },
+ },
+ 'call-1',
+ 0,
+ );
+
+ expect(toolCallAt(result as TMessage, 1)).toMatchObject({
+ auth: 'https://auth.example.com',
+ expires_at: 123,
+ });
+ });
+
+ it('ignores deltas that are not tool-call deltas', () => {
+ expect(
+ applyToolCallDelta(
+ createResponse(),
+ search,
+ { id: search.id, delta: { type: StepTypes.MESSAGE_CREATION } },
+ 'call-1',
+ 0,
+ ),
+ ).toBeUndefined();
+ });
+
+ it('displaces a pending OAuth prompt when real content lands in its slot', () => {
+ const oauth = createResponse([
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: { id: 'oauth', name: 'oauth_mcp_github', args: '', type: 'tool_call' },
+ } as TMessageContentParts,
+ ]);
+
+ const result = streamText(oauth, messageStep('step-text', 0), ['resumed']);
+
+ expect(result.content).toEqual([{ type: ContentTypes.TEXT, text: 'resumed' }]);
+ });
+
+ it('stamps the terminal status on close, and only on tool calls', () => {
+ const { message } = runToolCall(createResponse());
+ const closed: Agents.RunStepClosedEvent = {
+ id: search.id,
+ index: 1,
+ type: StepTypes.TOOL_CALLS,
+ status: 'cancelled',
+ created_at: 1_000,
+ closed_at: 1_250,
+ };
+
+ const result = applyRunStepClosed(message, search, closed, 0);
+ const closedTwice = applyRunStepClosed(result as TMessage, search, closed, 0);
+
+ expect(toolCallAt(result as TMessage, 1)).toMatchObject({
+ runStepStatus: 'cancelled',
+ runStepDurationMs: 250,
+ });
+ expect(closedTwice?.content).toEqual(result?.content);
+ expect(applyRunStepClosed(createResponse(), search, closed, 0)).toBeUndefined();
+ expect(
+ applyRunStepClosed(
+ streamText(createResponse(), messageStep('step-text', 1), ['t']),
+ search,
+ closed,
+ 0,
+ ),
+ ).toBeUndefined();
+ });
+
+ it('records the last non-empty tool call id announced by a step', () => {
+ const parallel = toolStep('step-many', 0, [
+ { id: 'call-a', name: 'a', args: '' },
+ { id: '', name: 'b', args: '' },
+ ]);
+
+ expect(applyToolCallsStep(createResponse(), parallel, 0).toolCallId).toBe('call-a');
+ expect(
+ applyToolCallsStep(createResponse(), messageStep('step-text', 0), 0).toolCallId,
+ ).toBeUndefined();
+ });
+ });
+
describe('image parts', () => {
it('holds an image slot without letting text overwrite it', () => {
const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
diff --git a/client/src/hooks/SSE/steps/index.ts b/client/src/hooks/SSE/steps/index.ts
index d2ae7b2e9b..d3ee235e21 100644
--- a/client/src/hooks/SSE/steps/index.ts
+++ b/client/src/hooks/SSE/steps/index.ts
@@ -1,2 +1,3 @@
export * from './content';
export * from './text';
+export * from './tools';
diff --git a/client/src/hooks/SSE/steps/tools.ts b/client/src/hooks/SSE/steps/tools.ts
new file mode 100644
index 0000000000..815285da66
--- /dev/null
+++ b/client/src/hooks/SSE/steps/tools.ts
@@ -0,0 +1,160 @@
+import { StepTypes, ContentTypes, getRunStepDurationMs } from 'librechat-data-provider';
+import type { Agents, TMessage } from 'librechat-data-provider';
+import { getStepMetadata, updateContent } from './content';
+
+/** 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']);
+
+/**
+ * True when a completed tool call authored a skill file (`create_file` /
+ * `edit_file` targeting a `skills/...` path). Skills created or edited
+ * mid-chat must invalidate the cached skill queries, or the Skills panel
+ * and builder keep showing the pre-authoring catalog.
+ */
+export function isSkillAuthoringToolCall(toolCall?: Agents.ToolCall): boolean {
+ if (!toolCall?.name || !FILE_AUTHORING_TOOLS.has(toolCall.name)) {
+ return false;
+ }
+ const { args } = toolCall;
+ let filePath: unknown;
+ if (typeof args === 'object' && args !== null) {
+ filePath = (args as { file_path?: unknown }).file_path;
+ } else if (typeof args === 'string') {
+ try {
+ filePath = (JSON.parse(args) as { file_path?: unknown }).file_path;
+ } catch {
+ return false;
+ }
+ }
+ return typeof filePath === 'string' && filePath.startsWith(SKILL_FILE_PREFIX);
+}
+
+/**
+ * Opens the tool-call parts a `tool_calls` run step announces, all at the step's slot.
+ * AI SDK: `tool-input-start`.
+ *
+ * Returns the next message and the tool-call id to record for the step, so later argument deltas,
+ * which carry only the step id, can be attributed. The last non-empty id wins, matching a step
+ * that announces a single call.
+ */
+export function applyToolCallsStep(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ editPrefixOffset: number,
+): { message: TMessage; toolCallId?: string } {
+ if (runStep.stepDetails.type !== StepTypes.TOOL_CALLS) {
+ return { message };
+ }
+ const index = runStep.index + editPrefixOffset;
+ const metadata = getStepMetadata(runStep);
+ let next: TMessage = { ...message };
+ let toolCallId: string | undefined;
+ for (const toolCall of (runStep.stepDetails.tool_calls ?? []) as Agents.ToolCall[]) {
+ const id = toolCall.id ?? '';
+ if ('id' in toolCall && id) {
+ toolCallId = id;
+ }
+ next = updateContent(
+ next,
+ index,
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: { name: toolCall.name ?? '', args: toolCall.args, id, stepId: runStep.id },
+ },
+ false,
+ metadata,
+ );
+ }
+ return { message: next, toolCallId };
+}
+
+/**
+ * Appends streamed tool-call arguments (and any OAuth prompt) to the step's tool-call part.
+ * AI SDK: `tool-input-delta`. Returns `undefined` for a delta that is not a tool-call delta.
+ */
+export function applyToolCallDelta(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ delta: Agents.RunStepDeltaEvent,
+ toolCallId: string,
+ editPrefixOffset: number,
+): TMessage | undefined {
+ if (delta.delta.type !== StepTypes.TOOL_CALLS || !delta.delta.tool_calls) {
+ return undefined;
+ }
+ const index = runStep.index + editPrefixOffset;
+ const metadata = getStepMetadata(runStep);
+ let next: TMessage = { ...message };
+ for (const toolCallDelta of delta.delta.tool_calls) {
+ const contentPart: Agents.MessageContentComplex = {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: {
+ name: toolCallDelta.name ?? '',
+ args: toolCallDelta.args ?? '',
+ id: toolCallId,
+ stepId: delta.id,
+ },
+ };
+ if (delta.delta.auth != null) {
+ contentPart.tool_call.auth = delta.delta.auth;
+ contentPart.tool_call.expires_at = delta.delta.expires_at;
+ }
+ next = updateContent(next, index, contentPart, false, metadata);
+ }
+ return next;
+}
+
+/**
+ * Settles the step's tool-call part with its output, marking it complete.
+ * AI SDK: `tool-output-available`.
+ */
+export function applyToolCallCompleted(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ result: Agents.ToolEndEvent,
+ editPrefixOffset: number,
+): TMessage {
+ return updateContent(
+ { ...message },
+ runStep.index + editPrefixOffset,
+ { type: ContentTypes.TOOL_CALL, tool_call: { ...result.tool_call, stepId: result.id } },
+ true,
+ getStepMetadata(runStep),
+ );
+}
+
+/**
+ * Stamps a closed step's terminal status and duration on its tool-call part. Only tool calls
+ * render a running state, so any other part type (or an empty slot, as on a reconnect that
+ * missed the opening) returns `undefined` and is left alone.
+ */
+export function applyRunStepClosed(
+ message: TMessage,
+ runStep: Agents.RunStep,
+ closed: Agents.RunStepClosedEvent,
+ editPrefixOffset: number,
+): TMessage | undefined {
+ const index = runStep.index + editPrefixOffset;
+ const existing = message.content?.[index];
+ if (!existing || existing.type !== ContentTypes.TOOL_CALL) {
+ return undefined;
+ }
+ const existingToolCall = existing[ContentTypes.TOOL_CALL];
+ if (!existingToolCall) {
+ return undefined;
+ }
+ /** Spread conditionally so an unknowable duration leaves any value the server already stamped
+ * in place, rather than overwriting it with `undefined`. */
+ const durationMs = getRunStepDurationMs(closed);
+ const content = [...(message.content ?? [])];
+ content[index] = {
+ ...existing,
+ [ContentTypes.TOOL_CALL]: {
+ ...existingToolCall,
+ runStepStatus: closed.status,
+ ...(durationMs != null && { runStepDurationMs: durationMs }),
+ },
+ };
+ return { ...message, content };
+}
diff --git a/client/src/hooks/SSE/useStepHandler.ts b/client/src/hooks/SSE/useStepHandler.ts
index fbbc1ba8a0..fde08f6ee3 100644
--- a/client/src/hooks/SSE/useStepHandler.ts
+++ b/client/src/hooks/SSE/useStepHandler.ts
@@ -1,15 +1,7 @@
import { useCallback, useRef } from 'react';
import { useStore } from 'jotai';
import { useRecoilCallback } from 'recoil';
-import {
- Constants,
- StepTypes,
- StepEvents,
- ContentTypes,
- getRunStepDurationMs,
- getRunStepCloseMetadata,
- getToolTimingDurations,
-} from 'librechat-data-provider';
+import { Constants, StepTypes, StepEvents, ContentTypes } from 'librechat-data-provider';
import type {
Agents,
TMessage,
@@ -34,14 +26,17 @@ import {
} from '~/components/Chat/Subagents/state';
import {
applyReasoningDelta,
+ applyToolCallCompleted,
+ isSkillAuthoringToolCall,
+ applyToolCallDelta,
applySummarizeDelta,
+ applyRunStepClosed,
+ applyToolCallsStep,
applyMessageDelta,
finalizeSummaries,
applyAgentUpdate,
applySummaryStep,
- getStepMetadata,
getEditPrefix,
- updateContent,
} from './steps';
import {
sandboxStartingByToolCallId,
@@ -86,34 +81,6 @@ type TStepEvent =
| { event: StepEvents.ON_SANDBOX_STARTING; data: SandboxStartingEvent }
| { event: StepEvents.ON_PTC_TOOL_CALL; data: PtcToolCallEvent };
-/** 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']);
-
-/**
- * True when a completed tool call authored a skill file (`create_file` /
- * `edit_file` targeting a `skills/...` path). Skills created or edited
- * mid-chat must invalidate the cached skill queries, or the Skills panel
- * and builder keep showing the pre-authoring catalog.
- */
-function isSkillAuthoringToolCall(toolCall?: Agents.ToolCall): boolean {
- if (!toolCall?.name || !FILE_AUTHORING_TOOLS.has(toolCall.name)) {
- return false;
- }
- const { args } = toolCall;
- let filePath: unknown;
- if (typeof args === 'object' && args !== null) {
- filePath = (args as { file_path?: unknown }).file_path;
- } else if (typeof args === 'string') {
- try {
- filePath = (JSON.parse(args) as { file_path?: unknown }).file_path;
- } catch {
- return false;
- }
- }
- return typeof filePath === 'string' && filePath.startsWith(SKILL_FILE_PREFIX);
-}
-
export default function useStepHandler({
setMessages,
getMessages,
@@ -644,42 +611,14 @@ export default function useStepHandler({
}
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) {
- toolCallIdMap.current.set(runStep.id, toolCallId);
- }
-
- const contentPart: Agents.MessageContentComplex = {
- type: ContentTypes.TOOL_CALL,
- tool_call: {
- name: toolCall.name ?? '',
- args: toolCall.args,
- id: toolCallId,
- stepId: runStep.id,
- toolPreparationStartedAt:
- firstFragmentByCall.current.get(toolTimingKey(runStep.id, toolCallId)) ??
- (streamedCallCount <= 1
- ? firstFragmentByStep.current.get(runStep.id)
- : undefined),
- toolDispatchedAt: dispatchedByCall.current.get(
- toolTimingKey(runStep.id, toolCallId),
- ),
- },
- };
-
- updatedResponse = updateContent(
- updatedResponse,
- contentIndex,
- contentPart,
- false,
- getStepMetadata(runStep),
- );
- });
-
+ const { message: updatedResponse, toolCallId } = applyToolCallsStep(
+ response,
+ runStep,
+ editPrefixOffset,
+ );
+ if (toolCallId) {
+ toolCallIdMap.current.set(runStep.id, toolCallId);
+ }
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
@@ -886,50 +825,16 @@ export default function useStepHandler({
}
const response = messageMap.current.get(responseMessageId);
- if (
+ const updatedResponse =
response &&
- runStepDelta.delta.type === StepTypes.TOOL_CALLS &&
- runStepDelta.delta.tool_calls
- ) {
- let updatedResponse = { ...response };
-
- runStepDelta.delta.tool_calls.forEach((toolCallDelta) => {
- const toolCallId = toolCallDelta.id || toolCallIdMap.current.get(runStepDelta.id) || '';
-
- const contentPart: Agents.MessageContentComplex = {
- type: ContentTypes.TOOL_CALL,
- tool_call: {
- name: toolCallDelta.name ?? '',
- args: toolCallDelta.args ?? '',
- id: toolCallId,
- stepId: runStepDelta.id,
- toolPreparationStartedAt:
- firstFragmentByCall.current.get(toolTimingKey(runStepDelta.id, toolCallId)) ??
- (toolCallDelta.index === 0
- ? firstFragmentByStep.current.get(runStepDelta.id)
- : undefined),
- toolDispatchedAt: dispatchedByCall.current.get(
- toolTimingKey(runStepDelta.id, toolCallId),
- ),
- },
- };
-
- if (runStepDelta.delta.auth != null) {
- contentPart.tool_call.auth = runStepDelta.delta.auth;
- contentPart.tool_call.expires_at = runStepDelta.delta.expires_at;
- }
-
- // Use server's index, offset by the retained edit prefix
- const currentIndex = runStep.index + editPrefixOffset;
- updatedResponse = updateContent(
- updatedResponse,
- currentIndex,
- contentPart,
- false,
- getStepMetadata(runStep),
- );
- });
-
+ applyToolCallDelta(
+ response,
+ runStep,
+ runStepDelta,
+ toolCallIdMap.current.get(runStepDelta.id) ?? '',
+ editPrefixOffset,
+ );
+ if (updatedResponse) {
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
@@ -1005,23 +910,12 @@ export default function useStepHandler({
const response = messageMap.current.get(responseMessageId);
if (response) {
- let updatedResponse = { ...response };
-
- const contentPart: Agents.MessageContentComplex = {
- type: ContentTypes.TOOL_CALL,
- tool_call: { ...result.tool_call, stepId },
- };
-
- // Use server's index, offset by the retained edit prefix
- const currentIndex = runStep.index + editPrefixOffset;
- updatedResponse = updateContent(
- updatedResponse,
- currentIndex,
- contentPart,
- true,
- getStepMetadata(runStep),
+ const updatedResponse = applyToolCallCompleted(
+ response,
+ runStep,
+ result,
+ editPrefixOffset,
);
-
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
@@ -1052,58 +946,10 @@ export default function useStepHandler({
return;
}
- const currentIndex = runStep.index + editPrefixOffset;
- const existing = response.content?.[currentIndex];
- /**
- * Only tool calls render a running state, so only they need the
- * terminal status. Leaving other part types untouched keeps this from
- * disturbing text or reasoning content.
- */
- if (!existing || existing.type !== ContentTypes.TOOL_CALL) {
+ const updatedResponse = applyRunStepClosed(response, runStep, closed, editPrefixOffset);
+ if (!updatedResponse) {
return;
}
-
- const existingToolCall = existing[ContentTypes.TOOL_CALL];
- if (!existingToolCall) {
- return;
- }
-
- /** Spread conditionally so an unknowable duration leaves any value the
- * server already stamped in place, rather than overwriting it with
- * `undefined`. */
- const durationMs = getRunStepDurationMs(closed);
- const callId = existingToolCall.id ?? '';
- const key = toolTimingKey(closed.id, callId);
- const singleCallStep =
- runStep.stepDetails.type === StepTypes.TOOL_CALLS &&
- (runStep.stepDetails.tool_calls?.length ?? 0) <= 1;
- const observedAt = Math.min(
- firstFragmentByCall.current.get(key) ?? Infinity,
- existingToolCall.toolPreparationStartedAt ?? Infinity,
- singleCallStep ? (firstFragmentByStep.current.get(closed.id) ?? Infinity) : Infinity,
- );
- const timing = getToolTimingDurations({
- observedAt: Number.isFinite(observedAt) ? observedAt : undefined,
- dispatchedAt: existingToolCall.toolDispatchedAt ?? dispatchedByCall.current.get(key),
- completedAt: completedByCall.current.get(key),
- });
- firstFragmentByCall.current.delete(key);
- firstFragmentByStep.current.delete(closed.id);
- dispatchedByCall.current.delete(key);
- completedByCall.current.delete(key);
- const updatedContent = [...(response.content ?? [])];
- updatedContent[currentIndex] = {
- ...existing,
- [ContentTypes.TOOL_CALL]: {
- ...existingToolCall,
- runStepStatus: closed.status,
- ...getRunStepCloseMetadata(closed),
- ...(durationMs != null && { runStepDurationMs: durationMs }),
- ...timing,
- },
- };
-
- const updatedResponse = { ...response, content: updatedContent };
messageMap.current.set(responseMessageId, updatedResponse);
setMessages(
mergeResponseMessage(messages, updatedResponse, responseMessageId, {
diff --git a/e2e/specs/mock/scenarios/tool-steps.spec.ts b/e2e/specs/mock/scenarios/tool-steps.spec.ts
new file mode 100644
index 0000000000..09bd9e0963
--- /dev/null
+++ b/e2e/specs/mock/scenarios/tool-steps.spec.ts
@@ -0,0 +1,69 @@
+import { expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import {
+ sendMessageAndWaitForCompletion,
+ enableCodeInterpreter,
+ selectMockEndpoint,
+ MOCK_ENDPOINTS,
+ NEW_CHAT_PATH,
+ messagesView,
+} from '../helpers';
+
+/**
+ * A tool call is opened by its run step, grows through argument deltas and is
+ * settled by its completion, all folded into one part at the step's index by
+ * the tool reducers in `client/src/hooks/SSE/steps/tools.ts`.
+ */
+
+const FINAL_TEXT = 'E2E execute_code complete';
+const TOOL_OUTPUT = 'stdout: E2E code exec ok';
+
+const uniqueLabel = (prefix: string) =>
+ `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+/** The code-execution card's status toggle; a slow run appends its duration to the name. */
+const toolCard = (page: Page) =>
+ messagesView(page).getByRole('button', { name: /^Finished running/ });
+const toolOutput = (page: Page) => messagesView(page).getByText(TOOL_OUTPUT, { exact: true });
+
+/** 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 expectOneToolCardBeforeReply(page: Page, label: string) {
+ const reply = messagesView(page).getByText(`${FINAL_TEXT}: ${label}`, { exact: true });
+ await expect(reply).toBeVisible({ timeout: 30_000 });
+ await expect(reply).toHaveCount(1);
+ await expect(toolCard(page)).toHaveCount(1, { timeout: 30_000 });
+ await expect(toolOutput(page)).toHaveCount(1);
+ expect(await precedes(toolCard(page), reply)).toBe(true);
+ expect(await precedes(toolOutput(page), reply)).toBe(true);
+}
+
+test.describe('tool call steps', () => {
+ test('a tool call renders once, ahead of the reply that follows it, live and after reload @scenario:tool-call-renders-once-before-its-reply', async ({
+ page,
+ }) => {
+ test.setTimeout(120_000);
+ const label = uniqueLabel('tool');
+ await page.goto(NEW_CHAT_PATH, { timeout: 10_000 });
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+ await enableCodeInterpreter(page);
+
+ const response = await sendMessageAndWaitForCompletion(page, `E2E_EXECUTE_CODE:${label}`);
+ expect(response.ok()).toBeTruthy();
+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeHidden({
+ timeout: 30_000,
+ });
+ await expectOneToolCardBeforeReply(page, label);
+
+ await page.reload({ timeout: 10_000 });
+ await expectOneToolCardBeforeReply(page, label);
+ });
+});