diff --git a/client/src/components/Chat/Input/ChatForm.tsx b/client/src/components/Chat/Input/ChatForm.tsx
index 8c56e0371e..c738ef8451 100644
--- a/client/src/components/Chat/Input/ChatForm.tsx
+++ b/client/src/components/Chat/Input/ChatForm.tsx
@@ -266,6 +266,83 @@ const ChatForm = memo(function ChatForm({
stopGenerating,
});
+ /** Read at call time, not captured: a reclaim resolves into the callback from
+ * the render it was clicked in, so the closure's `conversationId` is the OLD
+ * chat — comparing it against itself would pass while `methods` (one form,
+ * reused across conversations) writes into the chat now on screen. */
+ const liveConversationIdRef = useRef(conversationId);
+ liveConversationIdRef.current = conversationId;
+ /** Same reason: attachments staged after the click must be seen. */
+ const liveFilesRef = useRef(files);
+ liveFilesRef.current = files;
+ /** Same reason: the run can pause on `ask_user_question` mid-reclaim. */
+ const liveAnswerModeRef = useRef(answerMode.active);
+ liveAnswerModeRef.current = answerMode.active;
+ /** A reclaim can resolve after this form unmounts (left the route, closed the
+ * pane). Its refs still hold the origin chat, so the restore would pass its
+ * checks and write into a dead form — reporting success and making the caller
+ * drop the steer, losing the text. Track mount so the restore refuses and the
+ * caller queues it instead. */
+ const composerMountedRef = useRef(true);
+ useEffect(
+ () => () => {
+ composerMountedRef.current = false;
+ },
+ [],
+ );
+
+ /** A draft is anything the user has staged, not just typed: `editToComposer`
+ * MERGES the steer's attachments into the composer's file map and its quotes
+ * and skill picks into their atoms, so restoring over staged context would
+ * glue the two submissions together. */
+ const hasStagedComposerContext = useRecoilCallback(
+ ({ snapshot }) =>
+ (convoId: string) =>
+ snapshot.getLoadable(store.pendingQuotesByConvoId(convoId)).getValue().length > 0 ||
+ snapshot.getLoadable(store.pendingManualSkillsByConvoId(convoId)).getValue().length > 0,
+ [],
+ );
+
+ /**
+ * `editToComposer` for a steer whose reclaim was a round-trip: by the time it
+ * resolves the composer may have moved on. Refuses (returning false, so the
+ * caller re-homes the words instead of dropping them) rather than overwrite a
+ * draft the user has since staged, or drop a steer into whatever chat they
+ * navigated to.
+ */
+ const restoreReclaimedSteer = useCallback(
+ (
+ text: string,
+ steerFiles: TMessage['files'],
+ context: QueuedMessageContext,
+ originConversationId: string,
+ ): boolean => {
+ if (!composerMountedRef.current) {
+ return false;
+ }
+ const liveConversationId = liveConversationIdRef.current;
+ if (originConversationId !== liveConversationId) {
+ return false;
+ }
+ /** Answer mode owns the composer: `onSubmit` hands its text to
+ * `answerMode.submitText` before any send/steer routing, so restoring
+ * here would turn the steer into the tool's answer on the next Enter. */
+ if (liveAnswerModeRef.current) {
+ return false;
+ }
+ if (
+ (methods.getValues('text') ?? '').trim().length > 0 ||
+ (liveFilesRef.current?.size ?? 0) > 0 ||
+ hasStagedComposerContext(liveConversationId)
+ ) {
+ return false;
+ }
+ editToComposer(text, steerFiles, context);
+ return true;
+ },
+ [methods, editToComposer, hasStagedComposerContext],
+ );
+
/** ⌘/Ctrl+Enter = the non-default during-run action, ⌥/Alt+Enter =
* interrupt & send — the counterpart of Enter's `submitDuringRun`. */
const handleDuringRunModifier = useCallback(
@@ -415,7 +492,13 @@ const ChatForm = memo(function ChatForm({
{/* Run-scoped: `enabled` alone is any primary composer on a steerable
endpoint, so a chip that outlives the run would strand a bubble. */}
- {steering.enabled && isSubmitting && }
+ {steering.enabled && isSubmitting && (
+
+ )}
)}
{/* WIP */}
diff --git a/client/src/components/Chat/Input/InFlightSteers.tsx b/client/src/components/Chat/Input/InFlightSteers.tsx
index 90f3374a5d..289e458431 100644
--- a/client/src/components/Chat/Input/InFlightSteers.tsx
+++ b/client/src/components/Chat/Input/InFlightSteers.tsx
@@ -1,16 +1,30 @@
import { memo, useRef, useMemo, useState, useEffect, useCallback } from 'react';
-import { X, Zap } from 'lucide-react';
-import { useRecoilValue } from 'recoil';
+import { useToastContext } from '@librechat/client';
+import { X, Zap, Clock, Pencil } from 'lucide-react';
+import { useRecoilValue, useRecoilCallback } from 'recoil';
import type { TFile, TMessage } from 'librechat-data-provider';
+import type { SteeringControls, QueuedMessageContext } from '~/hooks/Chat/useSteering';
import type { PendingSteer } from '~/store/families';
+import type { MenuEntry } from './SteerMenu';
import FilePreviewDialog from '~/components/Chat/Messages/Content/FilePreviewDialog';
import MarkdownLite from '~/components/Chat/Messages/Content/MarkdownLite';
import FileContainer from '~/components/Chat/Input/Files/FileContainer';
+import { useSteerCancel, useSteerReclaim, useLocalize } from '~/hooks';
import ImagePreview from '~/components/Chat/Input/Files/ImagePreview';
-import { useSteerCancel, useLocalize } from '~/hooks';
-import { cn } from '~/utils';
+import { RowMenu, useDefaultToggleEntry } from './SteerMenu';
+import { carriedSteerContext, cn } from '~/utils';
import store from '~/store';
+/** Restores a message's text into the composer, or refuses (false) when the
+ * composer is occupied / on another chat — see `restoreReclaimedSteer` in
+ * `ChatForm`. Shared by the in-flight cancel and the queued trash safety net. */
+export type RestoreToComposer = (
+ text: string,
+ files: TMessage['files'],
+ context: QueuedMessageContext,
+ originConversationId: string,
+) => boolean;
+
const splitFiles = (files?: TMessage['files']) => {
const images: NonNullable = [];
const others: NonNullable = [];
@@ -33,17 +47,26 @@ const splitFiles = (files?: TMessage['files']) => {
*
* `sending` is still awaiting its 202 ACK (no server id yet, so nothing to
* cancel); `pending` is acknowledged and waiting on the next tool-batch
- * boundary.
+ * boundary. Every control here reclaims the steer from the server queue first,
+ * so they are offered only once `pending` — while `sending` there is no id to
+ * reclaim with, and the words cannot be held back.
*/
const InFlightSteer = memo(function InFlightSteer({
steer,
+ steering,
conversationId,
+ onRestoreToComposer,
}: {
steer: PendingSteer;
+ steering: SteeringControls;
conversationId: string;
+ onRestoreToComposer: RestoreToComposer;
}) {
const localize = useLocalize();
+ const { showToast } = useToastContext();
const cancelSteer = useSteerCancel(conversationId);
+ const reclaimSteer = useSteerReclaim(conversationId);
+ const toggleEntry = useDefaultToggleEntry(steering);
const enableUserMsgMarkdown = useRecoilValue(store.enableUserMsgMarkdown);
const [selectedFile, setSelectedFile] = useState | null>(null);
const handlePreviewClose = useCallback((open: boolean) => {
@@ -55,6 +78,121 @@ const InFlightSteer = memo(function InFlightSteer({
const { images, others } = useMemo(() => splitFiles(steer.files), [steer.files]);
const sending = steer.status === 'sending';
+ /** Whether the words have already been re-homed by a terminal conversion (a
+ * run that ended/errored mid-reclaim queues the still-present chip). The
+ * queue action is safe either way — the conversion dedupes by id — but a
+ * composer restore would leave one copy queued and another in the draft. */
+ const hasSettled = useRecoilCallback(
+ ({ snapshot }) =>
+ (steerId: string) =>
+ snapshot
+ .getLoadable(store.appliedSteerIdsByConvoId(conversationId))
+ .getValue()
+ .includes(steerId),
+ [conversationId],
+ );
+
+ /**
+ * Takes the steer back off the server queue so its words can be re-homed.
+ * The chip is left alone until the answer is known: only `reclaimed` proves
+ * the words never entered the run, and the re-homing callers below own the
+ * removal from there.
+ */
+ const reclaim = useCallback(async (): Promise => {
+ const outcome = await reclaimSteer(steer);
+ if (outcome === 'reclaimed') {
+ return true;
+ }
+ showToast({
+ message: localize(
+ outcome === 'applied' ? 'com_ui_steer_already_applied' : 'com_ui_steer_cancel_failed',
+ ),
+ status: outcome === 'applied' ? 'info' : 'error',
+ });
+ return false;
+ }, [reclaimSteer, steer, showToast, localize]);
+
+ const entries: MenuEntry[] = [
+ {
+ key: 'edit',
+ label: localize('com_ui_edit_message'),
+ icon: ,
+ onClick: () => {
+ void reclaim().then((reclaimed) => {
+ if (!reclaimed) {
+ return;
+ }
+ if (hasSettled(steer.steerId)) {
+ /* The run ended while the reclaim was in flight and its terminal
+ * conversion already queued these words. */
+ showToast({ message: localize('com_ui_steer_run_ended_queued'), status: 'info' });
+ return;
+ }
+ const restored = onRestoreToComposer(
+ steer.text,
+ steer.files,
+ carriedSteerContext(steer),
+ conversationId,
+ );
+ if (restored) {
+ steering.removeSteer(steer.steerId);
+ return;
+ }
+ /* The composer moved on while the reclaim was in flight. The words
+ * are already off the server, so queue them rather than overwrite a
+ * newer draft — neither text is the one to throw away. */
+ steering.queueReclaimedSteer(steer);
+ showToast({ message: localize('com_ui_steer_edit_queued'), status: 'info' });
+ });
+ },
+ },
+ {
+ key: 'queue',
+ label: localize('com_ui_convert_to_queue'),
+ icon: ,
+ onClick: () => {
+ void reclaim().then((reclaimed) => {
+ if (reclaimed) {
+ steering.queueReclaimedSteer(steer);
+ }
+ });
+ },
+ },
+ {
+ /* Non-destructive, but only when it is safe: cancel reliably first (the
+ * optimistic hook removes the chip and restores it if the server would
+ * still inject), then hand the words back to the composer ONLY on a
+ * `reclaimed` outcome. On `applied` (cancel lost the race) or `failed`
+ * the steer may still reach the run, so restoring would duplicate the
+ * text — in the response, or beside the restored bubble. The gated
+ * restore also refuses rather than clobber a draft typed meanwhile. */
+ key: 'cancel',
+ label: localize('com_ui_steer_cancel'),
+ icon: ,
+ onClick: () => {
+ void cancelSteer(steer).then((outcome) => {
+ if (outcome !== 'reclaimed') {
+ return;
+ }
+ const restored = onRestoreToComposer(
+ steer.text,
+ steer.files,
+ carriedSteerContext(steer),
+ conversationId,
+ );
+ if (!restored) {
+ /* Reclaimed, but the composer moved on (draft typed, answer mode,
+ * navigated). The chip is already gone, so queue the words as Edit
+ * does rather than drop them — never lost, just re-homed. */
+ steering.queueReclaimedSteer(steer);
+ showToast({ message: localize('com_ui_steer_edit_queued'), status: 'info' });
+ }
+ });
+ },
+ },
+ toggleEntry,
+ ];
+
return (
{!sending && (
- /* Hidden-at-rest only on hover-capable pointers: a hover-revealed
- * control is unreachable on touch until a first tap. */
-
+ /* One always-visible affordance: a label-less menu hidden until hover
+ * is undiscoverable, and edit/queue/cancel all live inside it now, so
+ * the menu shows at rest on every pointer (matching the always-on
+ * controls on the queued rows). */
+