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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🧩 refactor: Resolve Tool-Card State Once (#14934)
Danny Aviladf294fa4740d
diff --git a/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx b/client/src/components/Chat/Messages/Content/CodeAnalyze.tsxindex dd80e95d78..26176ba410 100644--- a/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx+++ b/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx@@ -1,6 +1,7 @@import { useState, useEffect } from 'react';import { useRecoilValue } from 'recoil';import { Terminal } from 'lucide-react';+import type { ToolCallPhase } from '~/utils/toolCallPhase';import { useProgress, useLocalize } from '~/hooks';import ProgressText from './ProgressText';import MarkdownLite from './MarkdownLite';@@ -46,14 +47,22 @@ export default function CodeAnalyze({return acc;}, '');+ /**+ * The legacy assistants-endpoint card: it never receives run-step metadata,+ * so it genuinely has only these two states and maps them directly rather+ * than through `resolveToolCallPhase`, which needs signals this card has no+ * access to. The announcement and the icon below read this same value.+ */+ const phase: ToolCallPhase = progress < 1 ? 'running' : 'completed';+return (<><span className="sr-only" aria-live="polite" aria-atomic="true">- {progress < 1 ? localize('com_ui_analyzing') : localize('com_ui_analyzing_finished')}+ {phase === 'running' ? localize('com_ui_analyzing') : localize('com_ui_analyzing_finished')}</span><div className="my-1 flex items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={handleToggleCode}inProgressText={localize('com_ui_analyzing')}finishedText={localize('com_ui_analyzing_finished')}@@ -61,7 +70,10 @@ export default function CodeAnalyze({isExpanded={showCode}icon={<Terminal- className={cn('size-4 shrink-0 text-text-secondary', progress < 1 && 'animate-pulse')}+ className={cn(+ 'size-4 shrink-0 text-text-secondary',+ phase === 'running' && 'animate-pulse',+ )}aria-hidden="true"/>}diff --git a/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx b/client/src/components/Chat/Messages/Content/Parts/BashCall.tsxindex f839e76bbf..570e370370 100644--- a/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx@@ -49,20 +49,15 @@ export default function BashCall({const isWritingCommand = !command || !areToolCallArgsComplete(args);const sandboxStarting = useRecoilValue(sandboxStartingByToolCallId(toolCallId ?? ''));- const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =- useToolCallState(initialProgress, isSubmitting, output, !!command, onExpand, runStepStatus);-- const highlighted = useLazyHighlight(command || undefined, 'bash');- const { ref: commandPaneRef, onScroll: onCommandPaneScroll } = useFollowScroll<HTMLDivElement>(- highlighted ?? command,- progress < 1 && !cancelled,- showCode,- );const outputHasError = useMemo(() => ERROR_PATTERNS.test(output), [output]);/** A backgrounded call's persisted output stays the dispatch handle until* the detached run settles and patches it; render a background state* instead of the handle JSON. Completion arrives live as the status marker- * attachment (also covers stdout-only runs) or as harvested files. */+ * attachment (also covers stdout-only runs) or as harvested files.+ *+ * Resolved before the phase, which folds `backgroundFailed` in: the+ * detached task's outcome is this card's outcome, and the dispatch step's+ * own output cannot express it. */const backgroundHandle = useMemo(() => parseBackgroundHandle(output), [output]);const { fileAttachments, backgroundStatus } = useMemo(() => splitBackgroundAttachments(attachments, toolCallId),@@ -77,6 +72,23 @@ export default function BashCall({): null;+ const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput: !!command,+ onExpand,+ runStepStatus,+ extraError: backgroundFailed,+ });++ const highlighted = useLazyHighlight(command || undefined, 'bash');+ const { ref: commandPaneRef, onScroll: onCommandPaneScroll } = useFollowScroll<HTMLDivElement>(+ highlighted ?? command,+ phase === 'running',+ showCode,+ );+const [isCopied, setIsCopied] = useState(false);const timerRef = useRef<ReturnType<typeof setTimeout>>();useEffect(() => () => clearTimeout(timerRef.current), []);@@ -110,11 +122,11 @@ export default function BashCall({<><div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={toggleCode}inProgressText={inProgressText}finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (backgroundFinishedText ?? intent ?? localize('com_ui_command_finished'))}@@ -127,23 +139,17 @@ export default function BashCall({durationMs={backgroundHandle == null && backgrounded !== true ? runStepDurationMs : undefined}- errorSuffix={- (hasError && !cancelled) || backgroundFailed- ? localize('com_ui_tool_failed')- : undefined- }icon={<LangIconlang="bash"className={cn('size-4 shrink-0 text-text-secondary',- progress < 1 && !cancelled && !hasError && 'animate-pulse',+ phase === 'running' && 'animate-pulse',)}/>}hasInput={!!command || hasOutput}isExpanded={showCode}- error={cancelled}/></div><div style={expandStyle}>diff --git a/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx b/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsxindex 1ce61a3442..d2d776384a 100644--- a/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx@@ -87,20 +87,15 @@ export default function ExecuteCode({const intent = useToolCallIntent(args);const sandboxStarting = useRecoilValue(sandboxStartingByToolCallId(toolCallId ?? ''));- const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =- useToolCallState(initialProgress, isSubmitting, output, !!code, onExpand, runStepStatus);-- const highlighted = useLazyHighlight(code, lang);- const { ref: codePaneRef, onScroll: onCodePaneScroll } = useFollowScroll<HTMLPreElement>(- highlighted ?? code ?? '',- progress < 1 && !cancelled,- showCode,- );const outputHasError = useMemo(() => ERROR_PATTERNS.test(output), [output]);/** A backgrounded call's persisted output stays the dispatch handle until* the detached run settles and patches it; render a background state* instead of the handle JSON. Completion arrives live as the status marker- * attachment (also covers stdout-only runs) or as harvested files. */+ * attachment (also covers stdout-only runs) or as harvested files.+ *+ * Resolved before the phase, which folds `backgroundFailed` in: the+ * detached task's outcome is this card's outcome, and the dispatch step's+ * own output cannot express it. */const backgroundHandle = useMemo(() => parseBackgroundHandle(output), [output]);const { fileAttachments, backgroundStatus } = useMemo(() => splitBackgroundAttachments(attachments, toolCallId),@@ -115,18 +110,35 @@ export default function ExecuteCode({): null;+ const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput: !!code,+ onExpand,+ runStepStatus,+ extraError: backgroundFailed,+ });++ const highlighted = useLazyHighlight(code, lang);+ const { ref: codePaneRef, onScroll: onCodePaneScroll } = useFollowScroll<HTMLPreElement>(+ highlighted ?? code ?? '',+ phase === 'running',+ showCode,+ );+return (<><div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={toggleCode}inProgressText={intent ??(sandboxStarting ? localize('com_ui_sandbox_starting') : localize('com_ui_analyzing'))}finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (backgroundFinishedText ?? intent ?? localize('com_ui_analyzing_finished'))}@@ -139,23 +151,17 @@ export default function ExecuteCode({durationMs={backgroundHandle == null && backgrounded !== true ? runStepDurationMs : undefined}- errorSuffix={- (hasError && !cancelled) || backgroundFailed- ? localize('com_ui_tool_failed')- : undefined- }icon={<SquareTerminalclassName={cn('size-4 shrink-0 text-text-secondary',- progress < 1 && !cancelled && !hasError && 'animate-pulse',+ phase === 'running' && 'animate-pulse',)}aria-hidden="true"/>}hasInput={!!code?.length}isExpanded={showCode}- error={cancelled}/></div><div style={expandStyle}>diff --git a/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx b/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsxindex 6b788e9c60..90d20a2e90 100644--- a/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx@@ -152,20 +152,19 @@ export default function FileAuthoringCall({previewLang = fileLang;}- const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError } =- useToolCallState(- initialProgress,- isSubmitting,- output,- !!filePath || !!preview,- onExpand,- runStepStatus,- );+ const { showCode, toggleCode, expandStyle, expandRef, phase } = useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput: !!filePath || !!preview,+ onExpand,+ runStepStatus,+ });const highlighted = useLazyHighlight(preview || undefined, previewLang);const { ref: previewPaneRef, onScroll: onPreviewPaneScroll } = useFollowScroll<HTMLPreElement>(highlighted ?? preview,- progress < 1 && !cancelled,+ phase === 'running',showCode,);const Icon = isCreate && !overwrote ? FilePlus2 : FilePenLine;@@ -179,7 +178,7 @@ export default function FileAuthoringCall({<><div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={toggleCode}inProgressText={intent ??@@ -188,24 +187,22 @@ export default function FileAuthoringCall({})}finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (intent ?? localize(finishedKey, { 0: fileName }))}durationMs={runStepDurationMs}- errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}icon={<IconclassName={cn('size-4 shrink-0 text-text-secondary',- progress < 1 && !cancelled && !hasError && 'animate-pulse',+ phase === 'running' && 'animate-pulse',)}aria-hidden="true"/>}hasInput={!!filePath || !!preview}isExpanded={showCode}- error={cancelled}/></div><div style={expandStyle}>@@ -226,7 +223,7 @@ export default function FileAuthoringCall({<preclassName={cn('max-h-[300px] overflow-auto whitespace-pre-wrap break-words border-t border-border-light px-3 py-2.5 font-mono text-xs',- hasError ? 'text-status-error' : 'text-text-primary',+ phase === 'failed' ? 'text-status-error' : 'text-text-primary',)}>{output}diff --git a/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx b/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsxindex 2e93348d1a..6d8440e1e0 100644--- a/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx@@ -89,8 +89,14 @@ export default function ReadFileCall({const fileName = filePath.split('/').pop() || filePath;const lang = useMemo(() => langFromPath(filePath), [filePath]);- const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =- useToolCallState(initialProgress, isSubmitting, output, !!filePath, onExpand, runStepStatus);+ const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput: !!filePath,+ onExpand,+ runStepStatus,+ });const highlighted = useLazyHighlight(hasOutput ? output : undefined, lang);@@ -98,28 +104,26 @@ export default function ReadFileCall({<><div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={toggleCode}inProgressText={intent ?? localize('com_ui_reading_file', { 0: fileName })}finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (intent ?? localize('com_ui_read_file', { 0: fileName }))}durationMs={runStepDurationMs}- errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}icon={<FileTextclassName={cn('size-4 shrink-0 text-text-secondary',- progress < 1 && !cancelled && !hasError && 'animate-pulse',+ phase === 'running' && 'animate-pulse',)}aria-hidden="true"/>}hasInput={!!filePath || hasOutput}isExpanded={showCode}- error={cancelled}/></div><div style={expandStyle}>diff --git a/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx b/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsxindex cd73e73223..55d1e8be0b 100644--- a/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx@@ -35,35 +35,39 @@ export default function SkillCall({const skillName = useMemo(() => parseJsonField(args, 'skillName'), [args]);const intent = useToolCallIntent(args);- const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =- useToolCallState(initialProgress, isSubmitting, output, !!skillName, onExpand, runStepStatus);+ const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput: !!skillName,+ onExpand,+ runStepStatus,+ });return (<><div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={toggleCode}inProgressText={intent ?? localize('com_ui_skill_running', { 0: skillName })}finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (intent ?? localize('com_ui_skill_finished', { 0: skillName }))}durationMs={runStepDurationMs}- errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}icon={<ScrollTextclassName={cn('size-4 shrink-0 text-text-secondary',- progress < 1 && !cancelled && !hasError && 'animate-pulse',+ phase === 'running' && 'animate-pulse',)}aria-hidden="true"/>}hasInput={!!skillName || hasOutput}isExpanded={showCode}- error={cancelled}/></div><div style={expandStyle}>diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsxindex 701159aa84..7775c80e02 100644--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx@@ -33,20 +33,20 @@ jest.mock('~/hooks', () => ({jest.mock('~/components/Chat/Messages/Content/ProgressText', () => ({__esModule: true,+ /** Mirrors the real component's contract: one `phase` drives both the+ * label and the failure suffix. */default: ({- progress,+ phase,inProgressText,finishedText,- errorSuffix,}: {- progress: number;+ phase: 'running' | 'completed' | 'cancelled' | 'failed';inProgressText: string;finishedText: string;- errorSuffix?: string;}) => (<div data-testid="progress-text">- {progress < 1 ? inProgressText : finishedText}- {errorSuffix != null ? ` — ${errorSuffix}` : ''}+ {phase === 'running' ? inProgressText : finishedText}+ {phase === 'failed' ? ' — tool failed' : ''}</div>),}));diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsxindex ddfed3b06e..db8266c33a 100644--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx@@ -26,14 +26,16 @@ jest.mock('~/utils', () => ({jest.mock('~/components/Chat/Messages/Content/ProgressText', () => ({__esModule: true,default: ({- progress,+ phase,inProgressText,finishedText,}: {- progress: number;+ phase: 'running' | 'completed' | 'cancelled' | 'failed';inProgressText: string;finishedText: string;- }) => <div data-testid="progress-text">{progress < 1 ? inProgressText : finishedText}</div>,+ }) => (+ <div data-testid="progress-text">{phase === 'running' ? inProgressText : finishedText}</div>+ ),}));jest.mock('../CodeWindowHeader', () => ({@@ -64,14 +66,14 @@ jest.mock('../useLazyHighlight', () => {jest.mock('../useToolCallState', () => ({__esModule: true,- default: (initialProgress: number) => ({+ /** Mirrors the real hook: options object in, a single `phase` out. */+ default: ({ initialProgress }: { initialProgress: number }) => ({showCode: true,toggleCode: jest.fn(),expandStyle: {},expandRef: { current: null },progress: initialProgress,- cancelled: false,- hasError: false,+ phase: initialProgress < 1 ? 'running' : 'completed',}),}));diff --git a/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts b/client/src/components/Chat/Messages/Content/Parts/useToolCallState.tsindex 47483c33a4..18e0aae1cf 100644--- a/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts+++ b/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts@@ -1,7 +1,9 @@import { useState, useEffect, useCallback } from 'react';import { useRecoilValue } from 'recoil';import type { PartMetadata } from 'librechat-data-provider';+import type { ToolCallPhase } from '~/utils/toolCallPhase';import { isError } from '~/components/Chat/Messages/Content/ToolOutput';+import { resolveToolCallPhase } from '~/utils/toolCallPhase';import { useProgress, useExpandCollapse } from '~/hooks';import store from '~/store';@@ -10,24 +12,44 @@ interface ToolCallState {toggleCode: () => void;expandStyle: React.CSSProperties;expandRef: React.RefObject<HTMLDivElement>;- progress: number;- cancelled: boolean;- hasError: boolean;+ /**+ * The card's settled state, resolved once. Label, announcement, icon and+ * animation all read this — deriving any of them separately is what let+ * them disagree.+ */+ phase: ToolCallPhase;hasOutput: boolean;hasContent: boolean;}-export default function useToolCallState(- initialProgress: number,- isSubmitting: boolean,- output: string,- hasInput: boolean,- onExpand?: () => void,- runStepStatus?: PartMetadata['runStepStatus'],-): ToolCallState {+export interface UseToolCallStateInput {+ initialProgress: number;+ isSubmitting: boolean;+ output: string;+ hasInput: boolean;+ onExpand?: () => void;+ runStepStatus?: PartMetadata['runStepStatus'];+ /**+ * A failure this call's own output cannot express — currently a+ * backgrounded task that settled as `error`, where the dispatch step's+ * output is the handle rather than the task's result. Folded into the+ * phase so those cards resolve their state through the same path as+ * every other card instead of patching the result afterwards.+ */+ extraError?: boolean;+}++export default function useToolCallState({+ initialProgress,+ isSubmitting,+ output,+ hasInput,+ onExpand,+ runStepStatus,+ extraError = false,+}: UseToolCallStateInput): ToolCallState {const autoExpand = useRecoilValue(store.autoExpandTools);const hasOutput = output.length > 0;- const hasError = (hasOutput && isError(output)) || runStepStatus === 'failed';const hasContent = hasInput || hasOutput;const [showCode, setShowCode] = useState(() => autoExpand && hasContent);@@ -41,12 +63,13 @@ export default function useToolCallState(const isClosed = runStepStatus != null;/**- * Both halves are load-bearing: passing 1 in stops `useProgress` scheduling- * its 200ms interval, and masking the result makes the terminal value- * observable on the same render rather than after the hook settles.+ * Passing 1 in for a closed step stops `useProgress` scheduling its 200ms+ * interval, which it keeps alive for any input below 1. The result no+ * longer needs masking: the phase treats an explicit close as terminal+ * outright, so a step that closes while the hook is still settling through+ * 0.99 can no longer read as in-flight.*/const rawProgress = useProgress(isClosed ? 1 : initialProgress);- const progress = isClosed ? 1 : rawProgress;const toggleCode = useCallback(() => {setShowCode((prev) => {const next = !prev;@@ -56,28 +79,26 @@ export default function useToolCallState(return next;});}, [onExpand]);+/**- * The step's own terminal status wins when the run emitted one; the- * `isSubmitting` heuristic is a whole-message inference that cannot tell- * which step stopped. Kept as the fallback for messages saved before- * `on_run_step_closed` and endpoints that do not emit it.- *- * The status is authoritative on its own terms — it is deliberately not- * gated on `hasError`, so that parsing the output text can never demote a- * step the run reported as stopped back into an in-flight state.+ * One resolution; everything the card shows is a read of this value. The+ * two progress inputs are deliberately distinct — see `resolveToolCallPhase`+ * for why the cancellation inference must not read the animated one.*/- const cancelled = isClosed- ? runStepStatus === 'cancelled'- : !isSubmitting && rawProgress < 1 && !hasError;+ const phase = resolveToolCallPhase({+ runStepStatus,+ displayProgress: rawProgress,+ reportedProgress: initialProgress,+ isSubmitting,+ hasError: (hasOutput && isError(output)) || extraError,+ });return {showCode,toggleCode,expandStyle,expandRef,- progress,- cancelled,- hasError,+ phase,hasOutput,hasContent,};diff --git a/client/src/components/Chat/Messages/Content/ProgressText.tsx b/client/src/components/Chat/Messages/Content/ProgressText.tsxindex 5ff5a79ba8..323d715ea9 100644--- a/client/src/components/Chat/Messages/Content/ProgressText.tsx+++ b/client/src/components/Chat/Messages/Content/ProgressText.tsx@@ -3,6 +3,7 @@ import { Button } from '@librechat/client';import { useTranslation } from 'react-i18next';import * as Popover from '@radix-ui/react-popover';import { isReportableRunStepDuration } from 'librechat-data-provider';+import type { ToolCallPhase } from '~/utils/toolCallPhase';import { cn, getRunStepDurationLabels } from '~/utils';import CancelledIcon from './CancelledIcon';import { useLocalize } from '~/hooks';@@ -39,73 +40,60 @@ const Wrapper = ({ popover, children }: { popover: boolean; children: React.Reac};export default function ProgressText({- progress,+ phase,onClick,inProgressText,finishedText,authText,icon: iconProp,subtitle,- errorSuffix,durationMs,hasInput = true,popover = false,isExpanded = false,- error = false,}: {- progress: number;+ /**+ * The card's settled state, resolved once by the caller via+ * `resolveToolCallPhase`. Replaces the former `error` + `errorSuffix`+ * pair, which encoded three terminal states in two booleans — `error`+ * meant cancelled, a present `errorSuffix` meant failed, and every+ * consumer had to reconstruct the distinction. That shape is what let a+ * duration render beside "failed" and a live region announce "completed"+ * over a visibly failed card.+ */+ phase: ToolCallPhase;onClick?: () => void;inProgressText: string;finishedText: string;authText?: string;icon?: React.ReactNode;subtitle?: string;- errorSuffix?: string;/** Wall-clock duration of the run step, from `PartMetadata.runStepDurationMs`. */durationMs?: number;hasInput?: boolean;popover?: boolean;isExpanded?: boolean;- error?: boolean;}) {const localize = useLocalize();/** For locale-aware decimal formatting of the sub-10s duration value. */const { i18n } = useTranslation();- const getText = () => {- if (error) {- return finishedText;- }- if (progress < 1) {- return authText ?? inProgressText;- }- return finishedText;- };-- const getIcon = () => {- if (error && !errorSuffix) {- return <CancelledIcon />;- }- return iconProp ?? null;- };+ const isRunning = phase === 'running';- const text = getText();- const icon = getIcon();- const showShimmer = progress < 1 && !error;+ /** Every branch below reads `phase`, so the label, the icon, the shimmer,+ * the failure suffix and the duration cannot disagree about what state+ * the card is in. */+ const text = isRunning ? (authText ?? inProgressText) : finishedText;+ const icon = phase === 'cancelled' ? <CancelledIcon /> : (iconProp ?? null);+ const showShimmer = isRunning;+ const errorSuffix = phase === 'failed' ? localize('com_ui_tool_failed') : undefined;/*** Shown only on a settled, successful card. While the step is still running* the number would be stale the instant it rendered, and on a cancelled or* failed card "how long it took" is not the fact the reader needs — that- * slot already carries the cancelled icon or the error suffix.- *- * Both terminal-failure channels must be checked: at every call site- * `error` carries cancellation while failure arrives as `errorSuffix`- * alone, so gating on `error` by itself would print a duration beside- * "failed". Gating here on the component's own props rather than on a- * separate caller-supplied flag keeps this consistent with the label- * beside it by construction; the callers only forward the number.+ * slot already carries the cancelled icon or the failure suffix.*/const duration =- progress >= 1 && !error && !errorSuffix && isReportableRunStepDuration(durationMs)+ phase === 'completed' && isReportableRunStepDuration(durationMs)? getRunStepDurationLabels(durationMs, i18n.language): undefined;diff --git a/client/src/components/Chat/Messages/Content/RetrievalCall.tsx b/client/src/components/Chat/Messages/Content/RetrievalCall.tsxindex 9cbd74580c..73a1d67d20 100644--- a/client/src/components/Chat/Messages/Content/RetrievalCall.tsx+++ b/client/src/components/Chat/Messages/Content/RetrievalCall.tsx@@ -6,6 +6,7 @@ import { FileText, FileSpreadsheet, FileCode, FileImage, File } from 'lucide-reaimport type { TAttachment, TFile, PartMetadata } from 'librechat-data-provider';import { useLocalize, useProgress, useExpandCollapse } from '~/hooks';import { ToolIcon, OutputRenderer, isError } from './ToolOutput';+import { resolveToolCallPhase } from '~/utils/toolCallPhase';import FilePreviewDialog from './FilePreviewDialog';import { sortPagesByRelevance, cn } from '~/utils';import { useToolCallIntent } from './Parts/intent';@@ -350,25 +351,25 @@ export default function RetrievalCall({* mounted would otherwise render as still in progress for that window.*/const rawProgress = useProgress(isClosed ? 1 : initialProgress);- const progress = isClosed ? 1 : rawProgress;const localize = useLocalize();/** Model-authored live label (injected when file_search is opted into* describe_intent); persists as the settled label. The sr-only live* region below deliberately keeps its stable generic value. */const intent = useToolCallIntent(args);- const errorState = (typeof output === 'string' && isError(output)) || runStepStatus === 'failed';/**- * The step's own terminal status wins when the run emitted one; the- * `isSubmitting` heuristic is a whole-message inference that cannot tell- * which step stopped. Authoritative on its own terms — not gated on- * `errorState`, so output parsing cannot demote a stopped step back into an- * in-flight state. Fallback retained for messages saved before- * `on_run_step_closed` and endpoints that do not emit it.+ * One resolution, read by the label, the live region and the icon alike.+ * It also unifies two inputs that had drifted apart: the cancellation+ * inference read `initialProgress` while the label read the animated+ * `rawProgress`.*/- const cancelled = isClosed- ? runStepStatus === 'cancelled'- : !isSubmitting && initialProgress < 1 && !errorState;+ const phase = resolveToolCallPhase({+ runStepStatus,+ displayProgress: rawProgress,+ reportedProgress: initialProgress,+ isSubmitting,+ hasError: typeof output === 'string' && isError(output),+ });const hasOutput = !!output && !isError(output);const autoExpand = useRecoilValue(store.autoExpandTools);const [showOutput, setShowOutput] = useState(() => autoExpand && hasOutput);@@ -446,16 +447,16 @@ export default function RetrievalCall({<div className="my-1"><span className="sr-only" aria-live="polite" aria-atomic="true">{(() => {- if (progress < 1 && !cancelled) {+ if (phase === 'running') {return localize('com_ui_searching_files');}- if (cancelled) {+ if (phase === 'cancelled') {return localize('com_ui_cancelled');}- /** Announced before the success string: a terminal step that errored- * must not reach the live region as "retrieved files", which would- * tell a screen-reader user the opposite of what the card shows. */- if (errorState) {+ /** A terminal step that errored must not reach the live region as+ * "retrieved files", which would tell a screen-reader user the+ * opposite of what the card shows. */+ if (phase === 'failed') {return localize('com_ui_failed');}return intent ?? localize('com_ui_retrieved_files');@@ -463,24 +464,20 @@ export default function RetrievalCall({</span><div className="relative my-1 flex h-5 shrink-0 items-center gap-2.5"><ProgressText- progress={progress}+ phase={phase}onClick={hasOutput ? handleToggleOutput : undefined}inProgressText={intent ?? localize('com_ui_searching_files')}/** A cancelled step must not read "Retrieved files" beside a* cancellation icon while the live region says "Cancelled". */finishedText={- cancelled+ phase === 'cancelled'? localize('com_ui_cancelled'): (intent ?? localize('com_ui_retrieved_files'))}durationMs={runStepDurationMs}- errorSuffix={errorState && !cancelled ? localize('com_ui_tool_failed') : undefined}- icon={- <ToolIcon type="file_search" isAnimating={progress < 1 && !cancelled && !errorState} />- }+ icon={<ToolIcon type="file_search" isAnimating={phase === 'running'} />}hasInput={hasOutput}isExpanded={showOutput}- error={cancelled}/></div><div style={expandStyle}>diff --git a/client/src/components/Chat/Messages/Content/ToolCall.tsx b/client/src/components/Chat/Messages/Content/ToolCall.tsxindex cdd5096692..25f0d3d3cc 100644--- a/client/src/components/Chat/Messages/Content/ToolCall.tsx+++ b/client/src/components/Chat/Messages/Content/ToolCall.tsx@@ -13,6 +13,7 @@ import type { TAttachment, PartMetadata } from 'librechat-data-provider';import { useLocalize, useProgress, useExpandCollapse, useLazyCollapseBody } from '~/hooks';import { ToolIcon, getToolIconType, isError } from './ToolOutput';import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';+import { resolveToolCallPhase } from '~/utils/toolCallPhase';import { useToolCallIntent } from './Parts/intent';import { AttachmentGroup } from './Parts';import ToolCallInfo from './ToolCallInfo';@@ -156,10 +157,6 @@ export default function ToolCall({* in-flight state.*/const isClosed = runStepStatus != null;- const cancelled = isClosed- ? runStepStatus === 'cancelled'- : !isSubmitting && initialProgress < 1 && !hasError;- const errorState = hasError;const args = useMemo(() => {if (typeof _args === 'string') {@@ -191,8 +188,19 @@ export default function ToolCall({* observable on the same render rather than after the hook settles.*/const rawProgress = useProgress(isClosed ? 1 : initialProgress);- const progress = isClosed ? 1 : rawProgress;- const showCancelled = cancelled || (errorState && !output);+ /**+ * One resolution, read by the label, the live region, the icon and the+ * shimmer alike. It also unifies two inputs that had drifted apart: the+ * cancellation inference read `initialProgress` while the label read the+ * animated `rawProgress`.+ */+ const phase = resolveToolCallPhase({+ runStepStatus,+ displayProgress: rawProgress,+ reportedProgress: initialProgress,+ isSubmitting,+ hasError,+ });const handleToggleInfo = useCallback(() => {mountBody();@@ -221,7 +229,7 @@ export default function ToolCall({const intent = useToolCallIntent(_args);const getFinishedText = () => {- if (cancelled) {+ if (phase === 'cancelled') {return localize('com_ui_cancelled');}/**@@ -229,7 +237,7 @@ export default function ToolCall({* errored must not reach the live region as "completed", which would tell* a screen-reader user the opposite of what the card shows.*/- if (errorState) {+ if (phase === 'failed') {return function_name? `${localize('com_ui_failed')}: ${function_name}`: localize('com_ui_failed');@@ -258,7 +266,7 @@ export default function ToolCall({announced once via getFinishedText. */}<span className="sr-only" aria-live="polite" aria-atomic="true">{(() => {- if (progress < 1 && !showCancelled) {+ if (phase === 'running') {return function_name? localize('com_assistants_running_var', { 0: function_name }): localize('com_assistants_running_action');@@ -272,7 +280,7 @@ export default function ToolCall({data-tool-call-id={toolCallId}><ProgressText- progress={progress}+ phase={phase}onClick={handleToggleInfo}inProgressText={intent ??@@ -281,22 +289,18 @@ export default function ToolCall({: localize('com_assistants_running_action'))}authText={- !showCancelled && authDomain.length > 0 ? localize('com_ui_requires_auth') : undefined+ phase === 'running' && authDomain.length > 0+ ? localize('com_ui_requires_auth')+ : undefined}finishedText={getFinishedText()}subtitle={subtitle}durationMs={runStepDurationMs}- errorSuffix={errorState && !cancelled ? localize('com_ui_tool_failed') : undefined}icon={- <ToolIcon- type={toolIconType}- iconUrl={mcpIconUrl}- isAnimating={progress < 1 && !showCancelled && !errorState}- />+ <ToolIcon type={toolIconType} iconUrl={mcpIconUrl} isAnimating={phase === 'running'} />}hasInput={hasInfo}isExpanded={showInfo}- error={showCancelled}/></div><div@@ -312,7 +316,7 @@ export default function ToolCall({)}</div></div>- {auth != null && auth && progress < 1 && !showCancelled && (+ {auth != null && auth && phase === 'running' && (<div className="flex w-full flex-col gap-2.5"><div className="mb-1 mt-2"><Buttondiff --git a/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsxindex 56ce5a9b3b..3ef9fd2a5c 100644--- a/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx@@ -28,7 +28,7 @@ jest.mock('../CancelledIcon', () => ({}));const defaults = {- progress: 1,+ phase: 'completed' as const,inProgressText: 'Running foo',finishedText: 'Completed foo',};@@ -52,25 +52,25 @@ describe('ProgressText duration', () => {* is still the in-progress one.*/it('does not render while the step is still running', () => {- renderProgressText({ progress: 0.4, durationMs: 3500 });+ renderProgressText({ phase: 'running', durationMs: 3500 });expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();});/*** On a cancelled or failed card the slot already carries the cancelled icon- * or the error suffix, and "how long it took" is not the fact the reader- * needs. The two states arrive through different props — `error` carries- * cancellation, `errorSuffix` alone carries failure — so both are pinned- * separately; gating on `error` alone rendered a duration beside "failed"- * (Codex round 1 on #14892).+ * or the failure suffix, and "how long it took" is not the fact the reader+ * needs. Both terminal-failure states are pinned: they used to arrive+ * through two different props (`error` for cancellation, `errorSuffix` for+ * failure), and gating on one of them alone rendered a duration beside+ * "failed" (Codex round 1 on #14892). They are now one value.*/it('does not render on a cancelled card', () => {- renderProgressText({ error: true, durationMs: 3500 });+ renderProgressText({ phase: 'cancelled', durationMs: 3500 });expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();});- it('does not render on a failed card, where failure arrives as errorSuffix alone', () => {- renderProgressText({ errorSuffix: 'failed', durationMs: 3500 });+ it('does not render on a failed card', () => {+ renderProgressText({ phase: 'failed', durationMs: 3500 });expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();expect(screen.queryByText('took 3.5 seconds')).not.toBeInTheDocument();});diff --git a/client/src/utils/__tests__/toolCallPhase.spec.ts b/client/src/utils/__tests__/toolCallPhase.spec.tsnew file mode 100644index 0000000000..d82522c69d--- /dev/null+++ b/client/src/utils/__tests__/toolCallPhase.spec.ts@@ -0,0 +1,153 @@+import type { ToolCallPhaseInput } from '../toolCallPhase';+import { resolveToolCallPhase } from '../toolCallPhase';++const resolve = (overrides: Partial<ToolCallPhaseInput> = {}) =>+ resolveToolCallPhase({+ displayProgress: 1,+ reportedProgress: 1,+ isSubmitting: false,+ hasError: false,+ ...overrides,+ });++describe('resolveToolCallPhase', () => {+ describe('with an explicit run-step status', () => {+ it('reports a completed close as completed', () => {+ expect(resolve({ runStepStatus: 'completed' })).toBe('completed');+ });++ it('reports a failed close as failed', () => {+ expect(resolve({ runStepStatus: 'failed' })).toBe('failed');+ });++ it('reports a cancelled close as cancelled', () => {+ expect(resolve({ runStepStatus: 'cancelled' })).toBe('cancelled');+ });++ /**+ * The status is authoritative on its own terms. Gating it on output+ * parsing let a step the run reported as stopped be demoted back into an+ * in-flight state.+ */+ it('never returns running for a closed step, whatever progress says', () => {+ expect(+ resolve({ runStepStatus: 'completed', displayProgress: 0.4, reportedProgress: 0.4 }),+ ).toBe('completed');+ expect(+ resolve({+ runStepStatus: 'cancelled',+ displayProgress: 0.1,+ reportedProgress: 0.1,+ isSubmitting: true,+ }),+ ).toBe('cancelled');+ });++ /** Explicit cancellation outranks a failure-shaped result. */+ it('keeps a cancelled close cancelled even when the output parses as an error', () => {+ expect(resolve({ runStepStatus: 'cancelled', hasError: true })).toBe('cancelled');+ });++ /** A completed close whose result reads as a failure is still a failure —+ * the card must not present an error as a clean success. */+ it('reports a completed close with error output as failed', () => {+ expect(resolve({ runStepStatus: 'completed', hasError: true })).toBe('failed');+ });+ });++ describe('under the legacy heuristic', () => {+ it('reports an in-flight call as running', () => {+ expect(resolve({ displayProgress: 0.4, reportedProgress: 0.4, isSubmitting: true })).toBe(+ 'running',+ );+ });++ it('reports a settled call as completed', () => {+ expect(resolve({ displayProgress: 1, reportedProgress: 1, isSubmitting: true })).toBe(+ 'completed',+ );+ });++ /** Unfinished progress with the message no longer streaming is the only+ * signal the pre-`on_run_step_closed` path had for a stop. */+ it('infers cancellation from an unfinished call once submission ends', () => {+ expect(resolve({ displayProgress: 0.4, reportedProgress: 0.4, isSubmitting: false })).toBe(+ 'cancelled',+ );+ });++ /**+ * The precedence inverts here, deliberately: the cancellation inference+ * ("not submitting and not finished") is also satisfied by a genuine+ * failure, so applying the explicit-close ordering relabelled real+ * failures as user stops on historical messages.+ */+ it('lets failure outrank the cancellation inference', () => {+ expect(+ resolve({+ displayProgress: 0.4,+ reportedProgress: 0.4,+ isSubmitting: false,+ hasError: true,+ }),+ ).toBe('failed');+ });++ it('reports a failure even while the message is still streaming', () => {+ expect(+ resolve({+ displayProgress: 0.4,+ reportedProgress: 0.4,+ isSubmitting: true,+ hasError: true,+ }),+ ).toBe('failed');+ });+ });++ describe('the useProgress settle window', () => {+ /**+ * `useProgress` holds below 1 for ~200ms after a call reports completion+ * (it emits `0.99`, then `1` on a timeout). Inferring cancellation from+ * that animated value labelled — and announced — a successful call as+ * "Cancelled" whenever submission ended inside the window+ * (Codex round 1 on #14934).+ */+ it('does not call a reported-complete call cancelled while the animation settles', () => {+ expect(resolve({ displayProgress: 0.99, reportedProgress: 1, isSubmitting: false })).toBe(+ 'running',+ );+ });++ /** The inference still fires for a call that genuinely never finished. */+ it('still infers cancellation when the stream itself never reported completion', () => {+ expect(resolve({ displayProgress: 0.99, reportedProgress: 0.4, isSubmitting: false })).toBe(+ 'cancelled',+ );+ });++ /** Once the animation catches up the card settles, without a cancelled+ * frame in between. */+ it('settles to completed once the animation catches up', () => {+ expect(resolve({ displayProgress: 1, reportedProgress: 1, isSubmitting: false })).toBe(+ 'completed',+ );+ });+ });++ /**+ * The two precedence rules are opposites and have been collapsed into one+ * another twice under review. Pinned side by side so a future edit cannot+ * quietly unify them.+ */+ it('applies opposite precedence for an explicit close and the heuristic', () => {+ const withError = {+ hasError: true,+ displayProgress: 0.4,+ reportedProgress: 0.4,+ isSubmitting: false,+ };+ expect(resolve({ ...withError, runStepStatus: 'cancelled' })).toBe('cancelled');+ expect(resolve(withError)).toBe('failed');+ });+});diff --git a/client/src/utils/index.ts b/client/src/utils/index.tsindex 332852028f..77d93e4fec 100644--- a/client/src/utils/index.ts+++ b/client/src/utils/index.ts@@ -45,6 +45,7 @@ export * from './approval';export * from './steer';export * from './activityLabels';export * from './runStepDuration';+export * from './toolCallPhase';export * from './documentTitle';export * from './reasoningLabels';export * from './numbers';diff --git a/client/src/utils/toolCallPhase.ts b/client/src/utils/toolCallPhase.tsnew file mode 100644index 0000000000..df43424456--- /dev/null+++ b/client/src/utils/toolCallPhase.ts@@ -0,0 +1,88 @@+import type { PartMetadata } from 'librechat-data-provider';++/**+ * The settled state of one tool call, as every part of its card should read+ * it: the visible label, the `aria-live` announcement, the icon, the shimmer,+ * and whether a duration is worth showing.+ *+ * Before this existed each card derived those independently — the label from+ * one expression, the announcement from another, the animation from a third —+ * and a change to one kept missing the others. Thirteen of the seventeen+ * review findings on #14873 were instances of that drift, and #14892 added a+ * fourteenth. One value, read everywhere, is what stops it: two presentations+ * of the same card can no longer disagree about what happened.+ */+export type ToolCallPhase = 'running' | 'completed' | 'cancelled' | 'failed';++export interface ToolCallPhaseInput {+ /**+ * The run's own terminal verdict from `on_run_step_closed`. Absent on parts+ * saved before the event existed and on endpoints that never emit it, which+ * is what the heuristic below is for.+ */+ runStepStatus?: PartMetadata['runStepStatus'];+ /**+ * The animated value from `useProgress` — what the card is showing right+ * now. Drives `running` vs `completed` so the label and shimmer follow the+ * animation rather than snapping.+ */+ displayProgress: number;+ /**+ * The progress the stream actually reported, before display animation.+ * Kept separate because `useProgress` holds below 1 for ~200ms after a call+ * reports completion (it emits `0.99`, then `1` on a timeout), and the+ * cancellation inference must not read that lag as an unfinished call.+ */+ reportedProgress: number;+ /** Whether the whole message is still streaming — a message-level fact. */+ isSubmitting: boolean;+ /**+ * Whether this call's own result reads as a failure: parsed error output,+ * or a card-specific signal such as a backgrounded task settling as `error`.+ */+ hasError: boolean;+}++/**+ * Resolve a tool call's phase from every signal that bears on it.+ *+ * The precedence rules encoded here were each established by a specific+ * review finding, and each is load-bearing:+ *+ * - **An explicit status is authoritative and never gated on output parsing.**+ * Reading the result text can otherwise demote a step the run reported as+ * stopped back into an in-flight state.+ * - **Explicit cancellation outranks a failure-shaped result.** A step the+ * user stopped is cancelled even if its partial output parses as an error.+ * - **Under the legacy heuristic the opposite holds: failure outranks+ * cancellation**, because that inference reads "not submitting and not+ * finished" as a stop, which a genuine failure also satisfies. Applying the+ * explicit-close precedence there relabelled real failures as user stops.+ * - **A closed step is never `running`**, whatever progress says.+ * - **Cancellation is inferred from reported progress, never from the+ * animation.** `useProgress` lags a completed call by ~200ms; reading that+ * lag would label — and announce — a successful call as cancelled whenever+ * submission ended inside the window.+ */+export function resolveToolCallPhase({+ runStepStatus,+ displayProgress,+ reportedProgress,+ isSubmitting,+ hasError,+}: ToolCallPhaseInput): ToolCallPhase {+ if (runStepStatus != null) {+ if (runStepStatus === 'cancelled') {+ return 'cancelled';+ }+ return runStepStatus === 'failed' || hasError ? 'failed' : 'completed';+ }++ if (hasError) {+ return 'failed';+ }+ if (!isSubmitting && reportedProgress < 1) {+ return 'cancelled';+ }+ return displayProgress < 1 ? 'running' : 'completed';+}