LibreChat/client/src/components/Chat/Input/ChatForm.tsx
lia-by-librechat[bot] d55dbc3bd8
🔱 feat: Simplify Steering Controls to Three Modes (#16759)
* 🔱 feat: Simplify Steering Controls to Three Modes

* Preserve Admitted Artifacts During Interrupts

* Preserve Result Admission Across Interrupts

* Gate Interrupt for Provider-Hosted Tools

* Match Interrupt Hints to Availability

---------

Co-authored-by: Lia <lia@librechat.ai>
2026-10-05 06:46:59 -04:00

1197 lines
47 KiB
TypeScript

import { memo, useRef, useMemo, useEffect, useState, useCallback } from 'react';
import { useWatch } from 'react-hook-form';
import { useNavigate } from 'react-router-dom';
import { useRecoilState, useRecoilValue } from 'recoil';
import {
composerSurfaceClasses,
composerSurfaceShadow,
TextareaAutosize,
useRemScale,
} from '@librechat/client';
import {
Constants,
Permissions,
PermissionTypes,
isAgentsEndpoint,
isAssistantsEndpoint,
} from 'librechat-data-provider';
import type { TChatProject, TMessage, TConversation } from 'librechat-data-provider';
import type { SetterOrUpdater } from 'recoil';
import type { ExtendedFile, FileSetter, ConvoGenerator, TAskFunction } from '~/common';
import type { QueuedMessageContext } from '~/hooks/Chat/useSteering';
import {
cn,
getModelSpec,
hasIncompleteFiles,
removeFocusRings,
getComposerDraftId,
getPendingDraftId,
clearAllDrafts,
getFilesDraftCached,
isPastedTextFileMarked,
} from '~/utils';
import {
useTextarea,
useAutoSave,
useLocalize,
useRequiresKey,
useHandleKeyUp,
useQueryParams,
useSubmitMessage,
useFocusChatEffect,
useCodeWorkspace,
} from '~/hooks';
import {
useChatContext,
useChatFormContext,
useAddedChatContext,
useAssistantsMapContext,
useComposerRestoreHost,
BadgeRowProvider,
} from '~/Providers';
import {
PendingToolApprovalButton,
PendingToolApprovalPanel,
} from '~/components/Chat/approval/Review';
import useComposerRestore from '~/hooks/Input/useComposerRestore';
import { useChatSettings } from '~/Providers/ChatSettingsContext';
import usePastedTextEdit from '~/hooks/Files/usePastedTextEdit';
import useAskAnswerMode from '~/hooks/Input/useAskAnswerMode';
import AskUserQuestionPopover from './AskUserQuestionPopover';
import useComposerItems from '~/hooks/Input/useComposerItems';
import useAttachTarget from '~/hooks/Input/useAttachTarget';
import Hints, { composerHintId } from './Composer/Hints';
import PastedTextDialog from './Files/PastedTextDialog';
import DuringRunSendButton from './DuringRunSendButton';
import ProjectLandingChip from '../ProjectLandingChip';
import useHasAccess from '~/hooks/Roles/useHasAccess';
import useDictation from '~/hooks/Input/useDictation';
import { useGetStartupConfig } from '~/data-provider';
import CodeWorkspaceMenu from './CodeWorkspaceMenu';
import useSteering from '~/hooks/Chat/useSteering';
import CodeApprovalMenu from './CodeApprovalMenu';
import TextareaHeader from './TextareaHeader';
import PromptsCommand from './PromptsCommand';
import { submitFromComposer } from './submit';
import SkillsCommand from './SkillsCommand';
import AutoPlayAudio from './AutoPlayAudio';
import Waveform from './Composer/Waveform';
import { mainTextareaId } from '~/common';
import CollapseChat from './CollapseChat';
import QuoteButton from './QuoteButton';
import ToolDialogs from './ToolDialogs';
import StopButton from './StopButton';
import SendButton from './SendButton';
import Queue from './Composer/Queue';
import Tray from './Composer/Tray';
import Bar from './Composer/Bar';
import Mention from './Mention';
import store from '~/store';
export function toRestoredComposerFile(
file: NonNullable<TMessage['files']>[number],
): ExtendedFile | null {
if (!file.file_id) {
return null;
}
return {
file_id: file.file_id,
filename: file.filename,
filepath: file.filepath,
type: file.type ?? '',
height: file.height,
width: file.width,
size: file.bytes ?? 0,
progress: 1,
attached: true,
llmDeliveryPath: file.llmDeliveryPath,
};
}
interface ChatFormProps {
index: number;
placeholder?: string;
project?: TChatProject;
/** The host is reconciling the requested route with its conversation record. */
routePending: boolean;
/** Owned by ChatView: which layout the composer sits in — the welcome screen
* floats or bottoms it out, a conversation ends the page with it. */
isLandingPage: boolean;
/** Owned by the host: the persisted preference for whether Enter sends the
* message (vs. queues a newline). The composer only consumes it. */
enterToSend: boolean;
/** Owned by the host: the Auto Send Text preference dictation consumes. */
autoSendText: number;
/** Owned by the host: whether the shell has loaded the speech settings yet;
* dictation stays off until it has. */
speechSettingsInitialized: boolean;
/** Owned by the host: the app-level preference for where the welcome-screen
* composer sits. The chat feature only consumes it. */
centerFormOnLanding: boolean;
/** Owned by ChatView: whether a footer bar renders under this band. It is an
* absolutely positioned bar in a zero-height wrapper, so the clearance here
* is the only thing keeping it off the composer. True on the welcome screen,
* which always carries one, and in a conversation whose deployment
* configured footer content of its own. */
footerBelow: boolean;
/** From ChatContext: individual values so memo can compare them */
files: Map<string, ExtendedFile>;
setFiles: FileSetter;
conversation: TConversation | null;
setConversation: SetterOrUpdater<TConversation | null>;
isSubmitting: boolean;
setFilesLoading: React.Dispatch<React.SetStateAction<boolean>>;
newConversation: ConvoGenerator;
handleStopGenerating: (e: React.MouseEvent<HTMLButtonElement>) => void;
stopGenerating: () => void;
}
/** Targets that own focus themselves: form fields and links, popup disclosures
* (Ariakit and Radix both emit `aria-haspopup`), and popup content, which React
* bubbles through portals. */
const focusOwningTargetSelector = [
'a',
'input',
'select',
'textarea',
'label',
'[aria-haspopup]:not([aria-haspopup="false"])',
'[role="combobox"]',
'[role="menu"]',
'[role="listbox"]',
'[role="dialog"]',
'[role="alertdialog"]',
].join(', ');
/** Matches the composer's one-line height; scaled so it tracks its rem padding. */
const INITIAL_TEXTAREA_HEIGHT = 44;
const ChatForm = memo(function ChatForm({
index,
placeholder,
project,
routePending,
isLandingPage,
enterToSend,
autoSendText,
speechSettingsInitialized,
footerBelow,
centerFormOnLanding,
files,
setFiles,
conversation,
setConversation,
isSubmitting,
setFilesLoading,
newConversation,
handleStopGenerating,
stopGenerating,
}: ChatFormProps) {
const submitButtonRef = useRef<HTMLButtonElement>(null);
const textAreaRef = useRef<HTMLTextAreaElement>(null);
/** The palette anchors to the whole composer, not to its own button, so it
* spans the composer width and sits flush above it. */
const composerBoxRef = useRef<HTMLDivElement>(null);
useFocusChatEffect(textAreaRef);
const localize = useLocalize();
const remScale = useRemScale();
const [isCollapsed, setIsCollapsed] = useState(false);
const [, setIsScrollable] = useState(false);
const [visualRowCount, setVisualRowCount] = useState(1);
const [isTextAreaFocused, setIsTextAreaFocused] = useState(false);
/** Last measured row count, so an unchanged measurement never schedules a
* render at all rather than relying on a state-equality bailout. */
const measuredRowCountRef = useRef(1);
const SpeechToText = useRecoilValue(store.speechToText);
const TextToSpeech = useRecoilValue(store.textToSpeech);
const chatDirection = useRecoilValue(store.chatDirection);
const automaticPlayback = useRecoilValue(store.automaticPlayback);
const maximizeChatSpace = useRecoilValue(store.maximizeChatSpace);
const { isTemporary } = useChatSettings();
const [showStopButton, setShowStopButton] = useRecoilState(store.showStopButtonByIndex(index));
const plusPopoverAtom = useMemo(() => store.showPlusPopoverFamily(index), [index]);
const mentionPopoverAtom = useMemo(() => store.showMentionPopoverFamily(index), [index]);
const { requiresKey } = useRequiresKey();
const methods = useChatFormContext();
const {
generateConversation,
conversation: addedConvo,
setConversation: setAddedConvo,
} = useAddedChatContext();
const assistantMap = useAssistantsMapContext();
const { data: startupConfig } = useGetStartupConfig();
const endpoint = useMemo(
() => conversation?.endpointType ?? conversation?.endpoint,
[conversation?.endpointType, conversation?.endpoint],
);
const modelSpec = useMemo(
() => getModelSpec({ specName: conversation?.spec, startupConfig }),
[conversation?.spec, startupConfig],
);
const filesLoading = useMemo(() => hasIncompleteFiles(files), [files]);
/** Agents and assistants carry their own tool configuration, so the composer's
* ephemeral tool controls only apply elsewhere, and a spec can suppress them
* outright. Same gate the old `showEphemeralBadges` prop applied. */
const showTools = useMemo(
() =>
!!endpoint &&
modelSpec?.hideBadgeRow !== true &&
!isAgentsEndpoint(endpoint) &&
!isAssistantsEndpoint(endpoint),
[endpoint, modelSpec?.hideBadgeRow],
);
const conversationId = useMemo(
() => conversation?.conversationId ?? Constants.NEW_CONVO,
[conversation?.conversationId],
);
const isNewConversation = conversationId === '' || conversationId === Constants.NEW_CONVO;
/**
* The quote feature merges excerpts server-side in `BaseClient.sendMessage`,
* which the Assistants endpoints bypass, so hide the UI there rather than
* letting users queue quotes the assistant never receives.
*/
const quotesEnabled = useMemo(() => !isAssistantsEndpoint(endpoint), [endpoint]);
const isRTL = useMemo(
() => (chatDirection != null ? chatDirection?.toLowerCase() === 'rtl' : false),
[chatDirection],
);
const invalidAssistant = useMemo(
() =>
isAssistantsEndpoint(endpoint) &&
(!(conversation?.assistant_id ?? '') ||
!assistantMap?.[endpoint ?? '']?.[conversation?.assistant_id ?? '']),
[conversation?.assistant_id, endpoint, assistantMap],
);
const disableInputs = useMemo(
() => requiresKey || invalidAssistant,
[requiresKey, invalidAssistant],
);
/** Skipped on touchscreens so a tap does not raise the keyboard. */
const focusTextArea = useCallback(() => {
if (window.matchMedia?.('(pointer: coarse)').matches) {
return;
}
textAreaRef.current?.focus();
}, []);
/** The surface returns focus to the textarea after any click (send, stop, badge
* toggles), except when the target owns focus itself or opens a popup. Ariakit
* records `document.activeElement` at open time as a menu's disclosure, so
* refocusing the textarea behind a menu button made the textarea the disclosure
* and the menu could never close on textarea interaction (#15624). */
const handleContainerClick = useCallback(
(event: React.MouseEvent<HTMLDivElement>) => {
const owner =
event.target instanceof Element ? event.target.closest(focusOwningTargetSelector) : null;
if (owner && !owner.contains(event.currentTarget)) {
return;
}
focusTextArea();
},
[focusTextArea],
);
/** Actions that consume the composer from inside a popup (the during-run
* hovercard) sit in exempted popup content, so they restore focus themselves. */
const consumeComposer = useCallback(() => {
methods.reset();
focusTextArea();
}, [methods, focusTextArea]);
const handleFocusOrClick = useCallback(() => {
if (isCollapsed) {
setIsCollapsed(false);
}
}, [isCollapsed]);
const handleTextareaFocus = useCallback(() => {
handleFocusOrClick();
setIsTextAreaFocused(true);
}, [handleFocusOrClick]);
const handleTextareaBlur = useCallback(() => {
setIsTextAreaFocused(false);
}, []);
const answerMode = useAskAnswerMode(conversationId);
const answerPlaceholder = answerMode.batchMode
? localize('com_ui_answer_questions_above')
: (answerMode.otherLabel ?? localize('com_ui_something_else'));
/** The composer is not a plain chat composer: it either IS this pause's
* answer box, or is locked behind the batch card that owns the answer. A
* collapsed batch is neither, it hands the composer back to the thread. */
const composerReserved = answerMode.composerAnswers || answerMode.composerLocked;
const { consumeDraft, preserveText, settleText } = useAutoSave({
index,
files,
setFiles,
textAreaRef,
conversationId,
isSubmitting,
// While a question pause is live the composer is the answer box: drafts
// swap to the answer's own key, and the conversation draft is restored
// when the question resolves.
draftId: answerMode.draftId,
});
const {
isPreparing: isPreparingFromUrl,
settingsError: urlSettingsError,
clearSettingsError,
} = useQueryParams({
textAreaRef,
routePending,
onBeforePrompt: preserveText,
onPromptSettled: settleText,
});
const pastedTextEdit = usePastedTextEdit({ index, files, setFiles, textAreaRef });
/** Provenance, not the filename, decides which chips are pastes: a user can deliberately
* upload a `pasted-text.txt`. Restored provenance comes from the files draft; marks made
* this session are read live from the registry, so new pastes need no recompute. */
const pastedTextFileIds = useMemo(() => {
const draftId = getComposerDraftId(index, conversationId, isSubmitting);
const draftIds = getFilesDraftCached(draftId).pastedTextIds ?? [];
return new Set<string>(draftIds);
}, [index, conversationId, isSubmitting]);
const isPastedTextFile = useCallback(
(file: ExtendedFile) =>
pastedTextFileIds.has(file.file_id) ||
(file.temp_file_id != null && pastedTextFileIds.has(file.temp_file_id)) ||
isPastedTextFileMarked(file.file_id) ||
isPastedTextFileMarked(file.temp_file_id),
[pastedTextFileIds],
);
/** The chip's actions hide while a replacement upload or inline move is in flight, so the
* same original cannot be acted on twice. */
const { isActionPending } = pastedTextEdit;
const isPasteActionPending = useCallback(
(file: ExtendedFile) => isActionPending(file.file_id),
[isActionPending],
);
const { submitMessage, submitPrompt } = useSubmitMessage();
const codeWorkspace = useCodeWorkspace(conversation, addedConvo);
/** Queued/steered sends carry their FULL submission context: explicit
* (possibly empty) overrides stop `ask` from vacuuming quotes or skill
* picks the user has staged in the composer for their NEXT message. */
const sendNow = useCallback(
(text: string, overrideFiles?: TMessage['files'], context?: QueuedMessageContext) =>
submitMessage({
text,
overrideFiles,
overrideQuotes: context?.quotes ?? [],
overrideManualSkills: context?.manualSkills ?? [],
overrideReasoning: context?.reasoningOverride ?? null,
overrideClientRequestId: context?.clientRequestId,
overrideRecoverySteerId: context?.recoverySteerId,
overrideExpectedPredecessorCreatedAt: context?.expectedPredecessorCreatedAt,
overrideQueuedMessageOrigin: context?.queuedMessageOrigin,
}),
[submitMessage],
);
const navigate = useNavigate();
/** A queued message becomes the first message of a fresh chat through the same
* `prompt` + `submit` query contract that deep links already use. */
const startQueuedInNewChat = useCallback(
(text: string) => navigate(`/c/new?${new URLSearchParams({ prompt: text, submit: 'true' })}`),
[navigate],
);
const { restoreReclaimedSteer, canRestoreToComposer } = useComposerRestore({
index,
conversationId,
methods,
files,
setFiles,
textAreaRef,
answerModeActive: composerReserved,
});
/* Surfaces outside the composer (a steer cancelled from the thread) re-home
their words through the same guarded restore the queue rail gets as a
prop. Published while this composer is mounted; a recovery that resolves
after it has gone finds nothing and falls back to the queue. */
const { publish: publishComposerRestore, publishRewake } = useComposerRestoreHost();
useEffect(() => {
publishComposerRestore(restoreReclaimedSteer);
return () => publishComposerRestore(null);
}, [publishComposerRestore, restoreReclaimedSteer]);
const steering = useSteering({
consumeDraft,
addedConversation: addedConvo,
index,
conversationId,
conversation,
isSubmitting,
answerModeActive: composerReserved,
composerDisabled: isPreparingFromUrl,
files,
setFiles,
filesLoading,
sendNow,
stopGenerating,
});
/* A steer retried from the thread can land in the queue after the run it
belonged to has ended and spent its one-shot drain signal; the thread
reaches the drain through the same host as the restore above. */
const { rewakeDrain: steeringRewakeDrain } = steering;
useEffect(() => {
publishRewake(steeringRewakeDrain);
return () => publishRewake(null);
}, [publishRewake, steeringRewakeDrain]);
/** Ctrl/Cmd+Enter selects the alternate; both interrupt chords use the same mode. */
const handleDuringRunModifier = useCallback(
(kind: 'other' | 'interrupt' | 'preempt') => {
const text = methods.getValues('text');
let consumed = false;
if (kind === 'interrupt') {
consumed = steering.interruptSteer(text);
} else if (kind === 'preempt') {
consumed = steering.interruptSteer(text);
} else if (steering.effectiveAction !== 'queue') {
consumed = steering.queueFromComposer(text);
} else {
consumed = steering.steerFromComposer(text);
}
if (consumed) {
methods.reset();
}
},
[methods, steering],
);
const handleKeyUp = useHandleKeyUp({
index,
textAreaRef,
});
const {
isNotAppendable,
handlePaste,
handleKeyDown,
handleCompositionStart,
handleCompositionEnd,
} = useTextarea({
textAreaRef,
submitButtonRef,
setIsScrollable,
/* Only picks the missing-key placeholder; preparation and answer holds live on the textarea. */
disabled: disableInputs,
// The composer IS the free-form answer box while a question pause is live.
placeholder: composerReserved ? answerPlaceholder : placeholder,
// Enter stays live during a run when it can steer/queue instead of send.
allowSubmitWhileGenerating: steering.duringRunActive || answerMode.composerAnswers,
onDuringRunModifier: steering.duringRunActive ? handleDuringRunModifier : undefined,
answerModeActive: answerMode.composerAnswers,
enterToSend,
});
/** Attachments stand in for text only on the normal send path. Answer mode
* hands the composer text straight to the paused run, which answers with
* values and cannot consume files, so an empty draft must stay unsubmittable
* there rather than enabling a button whose submit is silently dropped. */
const submittableFileCount = composerReserved ? 0 : files.size;
const { ref, ...registerProps } = methods.register('text', {
required: submittableFileCount === 0,
onChange: useCallback(
(e: React.ChangeEvent<HTMLTextAreaElement>) =>
methods.setValue('text', e.target.value, { shouldValidate: true }),
[methods],
),
});
const textValue = useWatch({ control: methods.control, name: 'text' });
/** The composer commits once per keystroke for the row count and the send
* button; a second commit for a row count that did not move (or that no
* layout engine can measure, where `lineHeight` is not a number) doubles the
* cost of the app's busiest surface for nothing. */
useEffect(() => {
const textarea = textAreaRef.current;
if (!textarea) {
return;
}
const lineHeight = parseFloat(window.getComputedStyle(textarea).lineHeight);
if (!(lineHeight > 0)) {
return;
}
const nextRowCount = Math.floor(textarea.scrollHeight / lineHeight);
if (nextRowCount === measuredRowCountRef.current) {
return;
}
measuredRowCountRef.current = nextRowCount;
setVisualRowCount(nextRowCount);
}, [textValue, remScale]);
const isMoreThanThreeRows = visualRowCount > 3;
const composerItems = useComposerItems(conversationId, quotesEnabled);
const attachTarget = useAttachTarget(conversation, disableInputs);
const hasPromptsAccess = useHasAccess({
permissionType: PermissionTypes.PROMPTS,
permission: Permissions.USE,
});
const slashCommandEnabled = useRecoilValue(store.slashCommand);
const atCommandEnabled = useRecoilValue(store.atCommand);
const idleActions = useMemo(
() => ({
prompts: hasPromptsAccess && slashCommandEnabled,
mentions: atCommandEnabled,
attach: attachTarget.canAttach,
}),
[hasPromptsAccess, slashCommandEnabled, atCommandEnabled, attachTarget.canAttach],
);
const { submitText: submitAnswerText } = answerMode;
const dictationAnswerModeActive = answerMode.composerAnswers;
const speechDisabled =
!speechSettingsInitialized ||
disableInputs ||
isNotAppendable ||
answerMode.composerLocked ||
isPreparingFromUrl;
/** The same gate `onSubmit` applies: while a question pause is live the
* composer IS the answer box, so a dictated turn has to answer it rather
* than start a turn the paused run would drop. */
const dictationAsk = useCallback<TAskFunction>(
(props) => {
if (dictationAnswerModeActive && submitAnswerText(props.text)) {
return;
}
return submitMessage({ text: props.text });
},
[dictationAnswerModeActive, submitAnswerText, submitMessage],
);
const dictation = useDictation({
ask: dictationAsk,
duringRunSubmit: steering.duringRunActive ? steering.submitDuringRun : undefined,
methods,
/* Answer mode leaves the run submitting while handing the composer over,
which is exactly when speech must still reach it: the send button is
enabled on the same terms. */
isSubmitting: (isSubmitting && !dictationAnswerModeActive) || answerMode.composerLocked,
filesLoading,
/* A dictated question answer is cleared by answer mode only after the
resume succeeds. A transient failure must leave the transcript intact. */
deferComposerReset: dictationAnswerModeActive,
disabled: speechDisabled,
autoSendText,
speechToText: SpeechToText,
index,
});
/** The waveform stands in for the placeholder until words arrive, and is
* then the only thing drawn on that line. */
const listening = dictation.active && (textValue?.trim() ?? '') === '';
const uploadingCount = useMemo(() => {
let count = 0;
for (const file of files.values()) {
if (file.progress < 1) {
count++;
}
}
return count;
}, [files]);
/* The abort is generation-scoped and inert until the start POST installs the
epoch; assistants abort through their own path and need no epoch. */
const canStop = steering.canControlGeneration || isAssistantsEndpoint(endpoint);
/** One button slot while a run is generating: with composer text the send
* button takes over (Enter steers/queues; hover reveals all actions);
* clearing the text restores Stop. */
/* Memoized for `memo(Bar)`: an inline element is a new identity every render,
and this component re-renders on every keystroke. */
const duringRunSlot = useMemo(() => {
const sendOwnsSlot = steering.duringRunActive && (textValue?.trim() ?? '') !== '';
/* Stays mounted (hidden) behind the during-run send button: the stop
shortcut resolves against the focused form, so a half-typed steer would
otherwise leave it reaching into another pane or doing nothing. */
const stopButton = showStopButton ? (
<StopButton
stop={handleStopGenerating}
setShowStopButton={setShowStopButton}
canStop={canStop}
hidden={sendOwnsSlot && !isPreparingFromUrl}
/>
) : null;
if (sendOwnsSlot) {
return (
<>
<DuringRunSendButton
ref={submitButtonRef}
control={methods.control}
steering={steering}
isNewConversation={isNewConversation}
getText={() => methods.getValues('text')}
onConsumed={consumeComposer}
disabled={filesLoading || isPreparingFromUrl}
enterToSend={enterToSend}
/>
{stopButton}
</>
);
}
return stopButton;
}, [
consumeComposer,
isNewConversation,
isPreparingFromUrl,
steering,
textValue,
methods,
submitButtonRef,
filesLoading,
showStopButton,
setShowStopButton,
handleStopGenerating,
canStop,
enterToSend,
]);
/* Memoized for `memo(Bar)`: an inline element is a new identity every render,
and this component re-renders on every keystroke. */
/* Gated on the slot having something to show rather than on `showStopButton`:
that flag only flips once the start POST installs the generation epoch, and
until then Enter already queues while this slot still offered the ordinary
send button, disabled. The slot decides for itself between the during-run
control, Stop, and nothing, so an empty one falls through to send. */
const actionSlot = useMemo(
() =>
isSubmitting && !answerMode.composerAnswers && duringRunSlot != null
? duringRunSlot
: endpoint && (
<SendButton
ref={submitButtonRef}
control={methods.control}
fileCount={submittableFileCount}
disabled={
filesLoading ||
isPreparingFromUrl ||
disableInputs ||
!codeWorkspace.canSubmit ||
isNotAppendable ||
answerMode.composerLocked ||
(isSubmitting && !answerMode.composerAnswers)
}
/>
),
[
codeWorkspace.canSubmit,
isPreparingFromUrl,
endpoint,
duringRunSlot,
filesLoading,
disableInputs,
isNotAppendable,
isSubmitting,
answerMode.composerAnswers,
answerMode.composerLocked,
submittableFileCount,
methods.control,
],
);
const baseClasses = useMemo(
() =>
cn(
'md:py-3.5 m-0 w-full resize-none py-3.25 placeholder:text-text-tertiary bg-transparent [&:has(textarea:focus)]:shadow-[0_2px_6px_rgba(0,0,0,.05)]',
isCollapsed ? 'max-h-[3.25rem]' : 'max-h-[45vh] md:max-h-[55vh]',
'px-5',
),
[isCollapsed],
);
/* From `sm` up the band leaves room under itself for the disclaimer, which only
the landing page carries — doubled while the centred landing composer floats,
and dropped back the moment a submission starts the thread. A started
conversation has nothing beneath it, so it keeps only enough to clear the
surface's own shadow. Below `sm` the composer runs to the viewport floor in
every state. */
const landingClearance =
centerFormOnLanding && !isSubmitting ? 'transition-all duration-200 sm:mb-28' : 'sm:mb-10';
let bottomClearance = 'sm:mb-4';
if (isLandingPage) {
bottomClearance = landingClearance;
} else if (footerBelow) {
/* A conversation that carries a configured footer keeps the band that bar
needs, exactly as the welcome screen does. */
bottomClearance = 'sm:mb-10';
}
/** Answer mode, then during-run steering or queueing (a run in flight, or a
* queued follow-up about to start), then an ordinary send: the same route
* for typed, dictated, and shortcut-bound submissions. */
const submitComposerText = useCallback(
(data: { text: string }): false | void =>
submitFromComposer(
{
answerMode,
steering,
submitMessage: (message) => {
const result = submitMessage(message);
if (result !== false) {
clearAllDrafts(getPendingDraftId(index));
}
return result;
},
reset: () => methods.reset(),
},
data,
),
[answerMode, steering, submitMessage, methods, index],
);
return (
<form
onSubmit={methods.handleSubmit((data) => {
if (!isPreparingFromUrl && submitComposerText(data) !== false) {
clearSettingsError();
}
})}
className={cn(
/* `margin-bottom` is animated as well as `max-width`: it is what carries
the composer between the landing clearance and the conversation one,
and the landing page keeps the same form node when a conversation
opens, so the band travels instead of jumping. The centred landing
composer overrides both with its own `transition-all`, and a reader who
asked for less motion gets the new position outright — this one is a
slide across the page rather than decoration. */
'mx-auto flex w-full flex-row gap-3 transition-[max-width,margin-bottom] duration-300 motion-reduce:transition-none sm:px-2',
maximizeChatSpace ? 'max-w-full' : 'md:max-w-3xl xl:max-w-4xl',
bottomClearance,
)}
>
{/* `min-w-0`: a flex item's automatic minimum size is its content's
min-content width, and one long unbroken word in a queued message
propagates all the way up here: the composer stretched past the
thread and its chips ran off the side. Zeroing it lets the width come
from the form, so the chips inside truncate instead. */}
<div className="relative flex h-full min-w-0 flex-1 items-stretch md:flex-col">
{/* Primary composer owns the selection popup so split-view doesn't double it. */}
{index === 0 && quotesEnabled && <QuoteButton conversationId={conversationId} />}
<div className="relative flex w-full flex-col">
{steering.enabled && (
<Queue
steering={steering}
conversationId={conversationId}
onRestoreToComposer={restoreReclaimedSteer}
canRestoreToComposer={canRestoreToComposer}
onStartNewChat={startQueuedInNewChat}
/>
)}
{(project || codeWorkspace.visible) && (
<div
data-testid="composer-context-rail"
className={cn(
'mx-4 -mb-3 flex min-w-0 flex-wrap items-center gap-1 rounded-t-2xl',
'border-border-light bg-surface-secondary border px-2 pt-1 pb-4',
isRTL && 'flex-row-reverse',
)}
>
{project ? <ProjectLandingChip project={project} /> : null}
{codeWorkspace.visible ? (
<div className="min-w-0 px-1 pt-1">
<CodeWorkspaceMenu
setConversation={setConversation}
workspace={codeWorkspace}
disabled={disableInputs || isSubmitting}
/>
</div>
) : null}
</div>
)}
<div className={cn('flex w-full items-center', isRTL && 'flex-row-reverse')}>
<Mention
index={index}
popoverAtom={plusPopoverAtom}
newConversation={generateConversation}
textAreaRef={textAreaRef}
commandChar="+"
placeholder="com_ui_add_model_preset"
includeAssistants={false}
/>
<Mention
index={index}
popoverAtom={mentionPopoverAtom}
newConversation={newConversation}
textAreaRef={textAreaRef}
/>
<PromptsCommand index={index} textAreaRef={textAreaRef} submitPrompt={submitPrompt} />
{index === 0 && (
<AskUserQuestionPopover conversationId={conversationId} textAreaRef={textAreaRef} />
)}
{index === 0 && conversationId != null && (
<PendingToolApprovalPanel conversationId={conversationId} />
)}
<SkillsCommand
index={index}
textAreaRef={textAreaRef}
conversationId={conversationId}
agentId={conversation?.agent_id}
/>
<div
ref={composerBoxRef}
data-testid="composer-surface"
onClick={handleContainerClick}
className={cn(
/* The surface runs to the viewport floor below `sm`, where it is
squared off at the bottom (`rounded-t-theme-surface-lg`) and no disclaimer
follows it — so the action row is the last thing in it, with no
band of padding under the buttons. */
'rounded-t-theme-surface-lg sm:rounded-theme-surface-lg relative flex w-full grow flex-col overflow-hidden',
composerSurfaceClasses(),
isTextAreaFocused ? composerSurfaceShadow.focused : composerSurfaceShadow.blurred,
/* Temporary-chat accent is a ChatForm-only override, not part of
the shared composer-surface decision. Semantic `series-6`, the
same categorical slot the purple tool badge uses, so the accent
follows the theme instead of the raw `violet-800/60` edge that
composited to 1.48:1 on the high contrast dark canvas.
Held at half alpha in the standard palettes, where series-6 is
a saturated purple in both modes and a full-strength edge reads as
a warning rather than a quiet mode hint. The contrast modes take
it opaque, because that is the only way it clears the 3:1
non-text floor there. */
isTemporary && 'border-series-6/50 bg-series-6/10 high-contrast:border-series-6',
)}
>
<TextareaHeader addedConvo={addedConvo} setAddedConvo={setAddedConvo} />
<Tray
items={composerItems}
focusComposer={focusTextArea}
conversation={conversation}
files={files}
setFiles={setFiles}
setFilesLoading={setFilesLoading}
isRTL={isRTL}
index={index}
isPastedTextFile={isPastedTextFile}
isPasteActionPending={isPasteActionPending}
onEditPastedText={pastedTextEdit.openEditor}
onMovePastedTextInline={pastedTextEdit.moveInline}
/>
<PastedTextDialog
edit={pastedTextEdit.editing}
onClose={pastedTextEdit.closeEditor}
onSave={pastedTextEdit.saveEdit}
/>
{endpoint && (
<div className={cn('flex', isRTL ? 'flex-row-reverse' : 'flex-row')}>
<div
className={cn(
'relative flex-1',
listening &&
'[&_textarea]:caret-transparent [&_textarea]:placeholder:text-transparent',
/* Locked behind a question: the placeholder is a notice, not text. */
answerMode.composerLocked && '[&_textarea]:select-none',
)}
style={
isCollapsed
? {
WebkitMaskImage:
'linear-gradient(to bottom, black 60%, transparent 90%)',
maskImage: 'linear-gradient(to bottom, black 60%, transparent 90%)',
}
: undefined
}
>
<TextareaAutosize
{...registerProps}
ref={(e) => {
ref(e);
(
textAreaRef as React.MutableRefObject<HTMLTextAreaElement | null>
).current = e;
}}
disabled={
disableInputs ||
isNotAppendable ||
answerMode.composerLocked ||
isPreparingFromUrl
}
onPaste={handlePaste}
onKeyDown={(e) => {
// Answer mode consumes option-navigation keys from the
// empty composer; everything else follows the normal path.
if (answerMode.handleComposerKeyDown(e)) {
return;
}
handleKeyDown(e);
}}
onKeyUp={handleKeyUp}
onCompositionStart={handleCompositionStart}
onCompositionEnd={handleCompositionEnd}
id={mainTextareaId}
tabIndex={0}
data-testid="text-input"
rows={1}
onFocus={handleTextareaFocus}
onBlur={handleTextareaBlur}
aria-label={localize('com_ui_message_input')}
aria-describedby={cn(
composerHintId(index),
(codeWorkspace.state === 'choose' || codeWorkspace.state === 'missing') &&
`code-workspace-hint-${index}`,
)}
onClick={handleFocusOrClick}
style={{ height: INITIAL_TEXTAREA_HEIGHT * remScale, overflowY: 'auto' }}
className={cn(
baseClasses,
removeFocusRings,
'scrollbar-hover transition-[max-height] duration-200 disabled:cursor-not-allowed',
)}
/>
{listening && (
/* Stands in for the placeholder: same inset, same line, so
it reads as the input listening rather than as a widget
bolted on. Once words arrive the transcript takes over. */
<Waveform
active={dictation.active}
className={cn('pointer-events-none absolute inset-x-5 inset-y-2')}
/>
)}
{/* Sits over the fade scrim in the corner of the input
rather than in its own column beside it, so a long draft
does not push an orphaned control off to the side. */}
<div className="absolute right-2 bottom-1 z-10">
<CollapseChat
isCollapsed={isCollapsed}
isScrollable={isMoreThanThreeRows}
setIsCollapsed={setIsCollapsed}
/>
</div>
</div>
</div>
)}
{(isPreparingFromUrl || urlSettingsError) && (
<p role="status" className="text-text-secondary px-5 pb-2 text-sm">
{localize(urlSettingsError ? 'com_ui_url_settings_failed' : 'com_ui_sending')}
</p>
)}
{(codeWorkspace.state === 'choose' || codeWorkspace.state === 'missing') && (
<p
id={`code-workspace-hint-${index}`}
role="status"
className="text-text-secondary px-5 pb-2 text-sm"
>
{localize('com_error_code_workspace_required')}
</p>
)}
{/* The composer is what keeps MCP connection and authorization state
current wherever its ephemeral tools apply; the Agent Builder's
tool library reads the same cache, so without this a server it
lists reads as unknown and offers to connect instead of toggling. */}
<BadgeRowProvider
conversationId={conversationId}
specName={conversation?.spec}
isSubmitting={isSubmitting}
observeToolAuthorization={showTools}
>
<Bar
index={index}
isRTL={isRTL}
disabled={disableInputs}
agentId={conversation?.agent_id}
/* The RAW endpoint, not the effective type above: the attach
destinations resolve the provider from its name, so a
custom endpoint reduced to `custom` loses the uploads its
provider actually takes (OpenRouter's video and audio).
`endpointType` beside it carries the resolved type. */
endpoint={conversation?.endpoint}
endpointType={attachTarget.endpointType}
endpointFileConfig={attachTarget.endpointFileConfig}
useResponsesApi={attachTarget.useResponsesApi}
conversationId={conversationId}
conversation={conversation}
files={files}
setFiles={setFiles}
setFilesLoading={setFilesLoading}
canAttach={attachTarget.canAttach}
anchorRef={composerBoxRef}
showTools={showTools}
isSubmitting={isSubmitting}
showSpeech={SpeechToText}
speechDisabled={speechDisabled}
dictation={dictation}
approvalSlot={
<div className={cn('flex items-center gap-1.5', isRTL && 'flex-row-reverse')}>
<CodeApprovalMenu
conversation={conversation}
addedConversation={addedConvo}
setConversation={setConversation}
disabled={disableInputs}
/>
{index === 0 && conversationId != null && (
<PendingToolApprovalButton conversationId={conversationId} />
)}
</div>
}
actionSlot={actionSlot}
hasAddedConversation={addedConvo != null}
/>
<ToolDialogs />
</BadgeRowProvider>
{TextToSpeech && automaticPlayback && <AutoPlayAudio index={index} />}
</div>
</div>
{/* Sibling of the composer row, not a child: inside that flex-row it
would lay out as a narrow column beside the box. */}
<Hints
index={index}
enterToSend={enterToSend}
hasText={(textValue?.trim() ?? '') !== ''}
isSubmitting={isSubmitting}
duringRunActive={steering.duringRunActive}
canControlGeneration={steering.canControlGeneration}
duringRunAction={steering.effectiveAction}
/* A staged reasoning choice forces the message to queue, and the
send-now chord then queues too; do not advertise it. */
canSteer={steering.canSteer && steering.pendingReasoningOverride == null}
answerModeActive={answerMode.active}
uploadingCount={uploadingCount}
idleActions={idleActions}
/>
</div>
</div>
</form>
);
});
ChatForm.displayName = 'ChatForm';
/**
* Wrapper that subscribes to ChatContext and passes stable individual values
* to the memo'd ChatForm. This prevents ChatForm from re-rendering on every
* streaming chunk: it only re-renders when the specific values it uses change.
*/
function ChatFormWrapper({
index = 0,
placeholder,
project,
routePending = false,
isLandingPage,
/** Defaults to the atom's own default (`atomWithLocalStorage('enterToSend',
* true)`) so call sites that predate this prop, mainly tests, keep their
* prior behavior without passing it explicitly. */
enterToSend = true,
/** Same reason, from `atomWithLocalStorage('autoSendText', -1)`. */
autoSendText = -1,
/** Same reason, from the `speechSettingsInitialized` atom's `false`. */
speechSettingsInitialized = false,
footerBelow,
centerFormOnLanding,
}: {
index?: number;
placeholder?: string;
project?: TChatProject;
routePending?: boolean;
enterToSend?: boolean;
autoSendText?: number;
speechSettingsInitialized?: boolean;
isLandingPage: boolean;
footerBelow: boolean;
centerFormOnLanding: boolean;
}) {
const {
files,
setFiles,
conversation,
setConversation,
isSubmitting,
setFilesLoading,
newConversation,
handleStopGenerating,
stopGenerating,
} = useChatContext();
/**
* Stabilize conversation reference: only update when rendering-relevant fields change,
* not on every metadata update (e.g., title generation during streaming).
*/
const hasMessages = (conversation?.messages?.length ?? 0) > 0;
const stableConversation = useMemo(
() => conversation,
// eslint-disable-next-line react-hooks/exhaustive-deps
[
conversation?.conversationId,
conversation?.endpoint,
conversation?.endpointType,
conversation?.agent_id,
conversation?.assistant_id,
conversation?.spec,
conversation?.useResponsesApi,
conversation?.model,
conversation?.maxContextTokens,
conversation?.codeApprovalMode,
conversation?.codeEnvironmentMode,
conversation?.codeWorkspaces,
/** The composer's reasoning control reads its configured value off this
* object. Leaving these out held the old level on screen after a
* Parameters-panel edit, while the next send already used the new one. */
conversation?.reasoning_effort,
conversation?.effort,
conversation?.thinkingLevel,
conversation?.thinkingBudget,
/** The attach picker resolves the upload route from it, and a Responses
* routing policy can send web-search turns to a different route. */
conversation?.web_search,
hasMessages,
],
);
/** Stabilize function refs so they never trigger ChatForm re-renders */
const handleStopRef = useRef(handleStopGenerating);
handleStopRef.current = handleStopGenerating;
const stableHandleStop = useCallback(
(e: React.MouseEvent<HTMLButtonElement>) => handleStopRef.current(e),
[],
);
const newConvoRef = useRef(newConversation);
newConvoRef.current = newConversation;
const stableNewConversation: ConvoGenerator = useCallback(
(...args: Parameters<ConvoGenerator>): ReturnType<ConvoGenerator> =>
newConvoRef.current(...args),
[],
);
const stopRef = useRef(stopGenerating);
stopRef.current = stopGenerating;
const stableStop = useCallback(() => {
void stopRef.current();
}, []);
return (
<ChatForm
index={index}
enterToSend={enterToSend}
autoSendText={autoSendText}
speechSettingsInitialized={speechSettingsInitialized}
placeholder={placeholder}
project={project}
routePending={routePending}
isLandingPage={isLandingPage}
footerBelow={footerBelow}
centerFormOnLanding={centerFormOnLanding}
files={files}
setFiles={setFiles}
conversation={stableConversation}
setConversation={setConversation}
isSubmitting={isSubmitting}
setFilesLoading={setFilesLoading}
newConversation={stableNewConversation}
handleStopGenerating={stableHandleStop}
stopGenerating={stableStop}
/>
);
}
ChatFormWrapper.displayName = 'ChatFormWrapper';
export default ChatFormWrapper;