Skip to content

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

📦 refactor: Move Steer Queue and Composer State into the Chat Package (#17155)

Marco Berettae693deddb0bf
diff --git a/client/src/Providers/ComposerRestoreContext.tsx b/client/src/Providers/ComposerRestoreContext.tsx
index fdab9589ae..07bd5164f9 100644
--- a/client/src/Providers/ComposerRestoreContext.tsx
+++ b/client/src/Providers/ComposerRestoreContext.tsx
@@ -1,81 +1,2 @@
-import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
-import type { TMessage } from 'librechat-data-provider';
-import type { ReactNode } from 'react';
-import type { QueuedMessageContext } from '~/hooks/Chat/useSteering';
-
-/** Restores a message's text, attachments and compose-time context into the
- * composer, or refuses (false) when the composer is occupied, unmounted, or
- * showing another chat. A refusal means the caller must re-home the words
- * somewhere else rather than drop them. */
-export type RestoreToComposer = (
- text: string,
- files: TMessage['files'],
- context: QueuedMessageContext,
- originConversationId: string,
-) => boolean;
-
-/** Re-posts a conversation's spent run-end signal so its queue drain wakes. */
-export type RewakeDrain = (conversationId: string) => void;
-
-interface ComposerRestoreHost {
- /** The composer publishes its guarded restore here while it is mounted. */
- publish: (restore: RestoreToComposer | null) => void;
- /** Resolved at call time: a recovery round-trip can settle long after the
- * composer that started it has gone. */
- restore: RestoreToComposer;
- /** The composer publishes its drain wake-up here while it is mounted. */
- publishRewake: (rewake: RewakeDrain | null) => void;
- /** Resolved at call time like `restore`; a no-op with no composer mounted,
- * which leaves a queued row for the next run end or an explicit send. */
- rewakeDrain: RewakeDrain;
-}
-
-const refuse: RestoreToComposer = () => false;
-
-const ComposerRestoreContext = createContext<ComposerRestoreHost>({
- publish: () => {},
- restore: refuse,
- publishRewake: () => {},
- rewakeDrain: () => {},
-});
-
-/**
- * Lets surfaces outside the composer hand a message back to it: into the
- * draft, or into the queue with the drain woken to pick it up.
- *
- * The composer is a sibling of the message list, not its ancestor, so a
- * pending steer cancelled from the thread cannot reach the restore the queue
- * rail gets as a prop. The pane's host holds the reference instead, and both
- * sides read it here: the thread never reaches into composer state, and a
- * restore that resolves after the composer unmounted refuses rather than
- * writing into a dead form.
- */
-export function ComposerRestoreProvider({ children }: { children?: ReactNode }) {
- const restoreRef = useRef<RestoreToComposer | null>(null);
- const publish = useCallback((restore: RestoreToComposer | null) => {
- restoreRef.current = restore;
- }, []);
- const restore = useCallback<RestoreToComposer>(
- (text, files, context, originConversationId) =>
- restoreRef.current?.(text, files, context, originConversationId) ?? false,
- [],
- );
- const rewakeRef = useRef<RewakeDrain | null>(null);
- const publishRewake = useCallback((rewake: RewakeDrain | null) => {
- rewakeRef.current = rewake;
- }, []);
- const rewakeDrain = useCallback<RewakeDrain>((conversationId) => {
- rewakeRef.current?.(conversationId);
- }, []);
- const value = useMemo(
- () => ({ publish, restore, publishRewake, rewakeDrain }),
- [publish, restore, publishRewake, rewakeDrain],
- );
- return (
- <ComposerRestoreContext.Provider value={value}>{children}</ComposerRestoreContext.Provider>
- );
-}
-
-export function useComposerRestoreHost(): ComposerRestoreHost {
- return useContext(ComposerRestoreContext);
-}
+export { ComposerRestoreProvider, useComposerRestoreHost } from '@librechat/chat/react';
+export type { RestoreToComposer, RewakeDrain, ComposerRestoreHost } from '@librechat/chat/react';
diff --git a/client/src/components/Chat/Input/Composer/state.ts b/client/src/components/Chat/Input/Composer/state.ts
index 7fe26ac389..2c7ab707dd 100644
--- a/client/src/components/Chat/Input/Composer/state.ts
+++ b/client/src/components/Chat/Input/Composer/state.ts
@@ -1,83 +1,14 @@
import { atom } from 'jotai';
import { atomFamily } from 'jotai/utils';
-import { Constants } from 'librechat-data-provider';
-import type { TMessage } from 'librechat-data-provider';
-import type { createStore } from 'jotai';
-/** Unsaved split panes share the sentinel conversation id, so include the pane
- * index until a durable id exists. Saved conversations keep their stable id. */
-export const getReasoningStateKey = (
- conversationId: string | null | undefined,
- index: string | number,
-) =>
- conversationId == null || conversationId === '' || conversationId === Constants.NEW_CONVO
- ? `${Constants.NEW_CONVO}:${index}`
- : conversationId;
-
-/** One-shot reasoning selection owned by the composer for its next full turn. */
-export const pendingReasoningOverrideFamily = atomFamily((_conversationId: string) =>
- atom<TMessage['reasoningOverride']>(undefined),
-);
-
-/**
- * Per-conversation queue of skill names the user invoked manually via the
- * `$` popover for the next submission. Structured channel that the submit
- * pipeline (`useChatFunctions.ask`) drains and pins onto the user message's
- * `manualSkills` field (also echoed at the top of the payload for the
- * runtime resolver), then resets to `[]`. Compose-time chips above the
- * textarea read this atom directly so users see (and can dismiss) their
- * current selection before hitting send.
- */
-export const pendingManualSkillsByConvoId = atomFamily((_conversationId: string) =>
- atom<string[]>([]),
-);
-
-/**
- * Per-conversation queue of verbatim excerpts the user quoted via the
- * "Add to chat" selection popup for the next submission. The submit pipeline
- * (`useChatFunctions.ask`) drains this onto the user message's `quotes` field
- * (which the backend merges into the model-facing text and persists for the
- * `MessageQuotes` UI), then resets to `[]`. Compose-time chips above the
- * textarea read this atom directly so users can see and dismiss each quote
- * before sending.
- */
-export const pendingQuotesByConvoId = atomFamily((_conversationId: string) => atom<string[]>([]));
+export {
+ getReasoningStateKey,
+ pendingQuotesByConvoId,
+ pendingManualSkillsByConvoId,
+ clearPendingComposerContext,
+ pendingReasoningOverrideFamily,
+ clearPendingReasoningOverrides,
+} from '@librechat/chat/react';
/** Landing-page lift is composer-owned UI state, scoped to its split pane. */
export const composerLiftFamily = atomFamily((_index: number) => atom(0));
-
-/** Release every staged reasoning selection except the `keep` keys. A selection
- * survives navigation by design, so members of conversations no longer on
- * screen still hold one; clearing only the mounted panes would carry them
- * across a sign-out. */
-export const clearPendingReasoningOverrides = (
- jotaiStore: ReturnType<typeof createStore>,
- keep: ReadonlySet<string> = new Set(),
-) => {
- for (const key of Array.from(pendingReasoningOverrideFamily.getParams())) {
- if (keep.has(key)) {
- continue;
- }
- jotaiStore.set(pendingReasoningOverrideFamily(key), undefined);
- pendingReasoningOverrideFamily.remove(key);
- }
-};
-
-/** Release every staged quote and manual skill pick except under the `keep`
- * keys. Like a reasoning selection, they survive navigation, so conversations
- * no longer on screen still hold some; clearing only the mounted panes would
- * carry them across a sign-out. */
-export const clearPendingComposerContext = (
- jotaiStore: ReturnType<typeof createStore>,
- keep: ReadonlySet<string> = new Set(),
-) => {
- for (const family of [pendingQuotesByConvoId, pendingManualSkillsByConvoId]) {
- for (const key of Array.from(family.getParams())) {
- if (keep.has(key)) {
- continue;
- }
- jotaiStore.set(family(key), []);
- family.remove(key);
- }
- }
-};
diff --git a/client/src/components/Chat/Steering/recovery.ts b/client/src/components/Chat/Steering/recovery.ts
index 22d70a071f..0cf3a81130 100644
--- a/client/src/components/Chat/Steering/recovery.ts
+++ b/client/src/components/Chat/Steering/recovery.ts
@@ -1,43 +1,3 @@
-import { atomFamily, atomWithStorage, createJSONStorage } from 'jotai/utils';
-import type { RecoveryDispositions } from '@librechat/chat';
-
export { blockRecovery, canRestoreRecovery, recoveryDisposition } from '@librechat/chat';
+export { recoveryDispositionsFamily } from '@librechat/chat/react';
export type { RecoveryDisposition, RecoveryDispositions } from '@librechat/chat';
-
-/** Receipt-scoped safety decisions survive remounts and reloads in this tab.
- * No message content is stored. A crashed cancellation stays held, not sendable. */
-export const recoveryDispositionsFamily = atomFamily((conversationId: string) =>
- atomWithStorage<RecoveryDispositions>(
- `steer-recovery:${conversationId}`,
- {},
- createJSONStorage(
- () => ({
- getItem(key) {
- try {
- return sessionStorage.getItem(key);
- } catch {
- return null;
- }
- },
- setItem(key, value) {
- try {
- sessionStorage.setItem(key, value);
- } catch {
- /* Keep the in-memory safety decision. */
- }
- },
- removeItem(key) {
- try {
- sessionStorage.removeItem(key);
- } catch {
- /* Storage may be disabled. */
- }
- },
- }),
- {
- reviver: (_key, value) => (value === 'cancelling' ? 'blocked' : value),
- },
- ),
- { getOnInit: true },
- ),
-);
diff --git a/client/src/hooks/Chat/queue.ts b/client/src/hooks/Chat/queue.ts
index f45f614419..4370cc9190 100644
--- a/client/src/hooks/Chat/queue.ts
+++ b/client/src/hooks/Chat/queue.ts
@@ -1,17 +1,16 @@
-import { atom } from 'jotai';
-import { isStoppedRun } from '@librechat/chat';
-import { atomFamily, RESET } from 'jotai/utils';
-import type {
- RunEnd,
- StoppedRun,
- DetachedRun,
- QueuedMessage,
- DrainAfterAbort,
- SettledQueuedTurnReceipt,
-} from '@librechat/chat';
-import type { PrimitiveAtom, Getter } from 'jotai';
-
export { isStoppedRun, resolveDetachedRunEnd } from '@librechat/chat';
+export {
+ runEndByIndex,
+ resetQueueFamilies,
+ isDetachedRunManual,
+ detachedRunByConvoId,
+ drainAfterAbortByIndex,
+ pendingRunEndByConvoId,
+ stopRequestedByConvoId,
+ queuedMessagesByConvoId,
+ settledQueuedTurnReceiptsByConvoId,
+ pendingQueuedTurnEnqueueIdsByConvoId,
+} from '@librechat/chat/react';
export type {
RunEnd,
StoppedRun,
@@ -22,117 +21,3 @@ export type {
QueuedMessageOrigin,
SettledQueuedTurnReceipt,
} from '@librechat/chat';
-
-/**
- * Per-conversation client-side queue of follow-up messages. Drained one per
- * run completion by `useQueueDrain` (each dequeued message starts a normal
- * turn whose own final event drains the next).
- */
-export const queuedMessagesByConvoId = atomFamily((_conversationId: string) =>
- atom<QueuedMessage[]>([]),
-);
-
-/** Monotonic client knowledge of terminal server queue receipts. Admission
- * records preserve boundary multiplicity by request identity. Other terminal
- * records exist only while their original enqueue callback is outstanding. */
-export const settledQueuedTurnReceiptsByConvoId = atomFamily((_conversationId: string) =>
- atom<SettledQueuedTurnReceipt[]>([]),
-);
-
-/** Enqueue callbacks that can still race newer GET/cancellation evidence.
- * Entries retire as soon as that one callback settles. */
-export const pendingQueuedTurnEnqueueIdsByConvoId = atomFamily((_conversationId: string) =>
- atom<string[]>([]),
-);
-
-/** The oldest terminal epoch in a queue of them, behind the nullable one-shot API stream writers
- * use: writing a signal appends it, writing `null` consumes only the visible (oldest) one, and
- * `RESET` clears them all. */
-const runEndQueue = (signals: PrimitiveAtom<RunEnd[]>) =>
- atom(
- (get) => get(signals)[0] ?? null,
- (_get, set, value: RunEnd | null | typeof RESET) => {
- if (value === RESET) {
- set(signals, []);
- return;
- }
- if (value == null) {
- set(signals, (prev) => prev.slice(1));
- return;
- }
- set(signals, (prev) => [...prev, value]);
- },
- );
-
-/** A pane can receive A's terminal frame after the user has navigated to and
- * started B. Keep each terminal epoch until the queue drain has either parked
- * or consumed it; a single replaceable slot loses A when B finishes first. */
-const runEndsByIndex = atomFamily((_index: string | number) => atom<RunEnd[]>([]));
-
-/** One-shot run-termination signal for a pane, written by the SSE final/error handlers and
- * consumed by `useQueueDrain`. */
-export const runEndByIndex = atomFamily((index: string | number) =>
- runEndQueue(runEndsByIndex(index)),
-);
-
-/** Foreign terminal epochs are moved off the shared pane immediately. This
- * per-conversation carrier is queued for the same reason as the pane carrier:
- * successive epochs cannot overwrite one another while the chat is hidden. */
-const pendingRunEndsByConvoId = atomFamily((_conversationId: string) => atom<RunEnd[]>([]));
-
-export const pendingRunEndByConvoId = atomFamily((conversationId: string) =>
- runEndQueue(pendingRunEndsByConvoId(conversationId)),
-);
-
-/**
- * One-shot override armed by "interrupt & send": the next `aborted` run-end
- * for the exact conversation generation drains the queue exactly once (a
- * plain Stop press leaves queued chips for manual send). `false` remains the
- * clear value used by stream reconciliation paths.
- */
-export const drainAfterAbortByIndex = atomFamily((_index: string | number) =>
- atom<DrainAfterAbort | false>(false),
-);
-
-export const detachedRunByConvoId = atomFamily((_conversationId: string) =>
- atom<DetachedRun | null>(null),
-);
-
-export const stopRequestedByConvoId = atomFamily((_conversationId: string) =>
- atom<StoppedRun | null>(null),
-);
-
-/** Whether a detached run's end must be left for a manual send instead of read from history, which
- * retires its marker: the user stopped it, and a stopped response persists like a completed one
- * (a stopped compaction even settles with `unfinished: false`). */
-export function isDetachedRunManual(
- get: Getter,
- conversationId: string,
- run: DetachedRun,
-): boolean {
- return isStoppedRun(get(stopRequestedByConvoId(conversationId)), run.generationCreatedAt);
-}
-
-const clearFamily = <Param>(family: {
- getParams(): Iterable<Param>;
- remove(param: Param): void;
-}) => {
- for (const param of [...family.getParams()]) {
- family.remove(param);
- }
-};
-
-/** Drops every per-key queue atom, so the next read of any key starts from its default. Isolates
- * tests that share the default store. */
-export function resetQueueFamilies(): void {
- clearFamily(queuedMessagesByConvoId);
- clearFamily(settledQueuedTurnReceiptsByConvoId);
- clearFamily(pendingQueuedTurnEnqueueIdsByConvoId);
- clearFamily(pendingRunEndsByConvoId);
- clearFamily(pendingRunEndByConvoId);
- clearFamily(drainAfterAbortByIndex);
- clearFamily(runEndsByIndex);
- clearFamily(runEndByIndex);
- clearFamily(detachedRunByConvoId);
- clearFamily(stopRequestedByConvoId);
-}
diff --git a/client/src/utils/composerFiles.ts b/client/src/utils/composerFiles.ts
index 87f7867cc8..0bb3f58c1e 100644
--- a/client/src/utils/composerFiles.ts
+++ b/client/src/utils/composerFiles.ts
@@ -1,53 +1 @@
-/**
- * Composer attachments a during-run submit has already consumed.
- *
- * Taking files into a steer or a queued message clears them from the composer,
- * but an upload for one of them can still have async callbacks in flight
- * (`loadImage`'s `onload`, HEIC conversion progress, the resize pass). Those
- * callbacks write the file back with a `set`, which resurrects an attachment
- * the message already owns: it reappears in the composer and rides the user's
- * NEXT message too.
- *
- * Held outside React state because the decision is synchronous and crosses two
- * hooks that never share an instance: `useSteering` consumes, `useUpdateFiles`
- * writes. Ids are per-upload UUIDs (or a library file's own id), so an upload
- * the user starts AFTER the submit is never confused with a consumed one.
- */
-
-/** Bounded so a long session cannot grow the set without limit; far beyond the
- * handful of callbacks that can still be in flight for one submit. */
-const TAKEN_LIMIT = 200;
-
-const takenFileIds = new Set<string>();
-
-export function markComposerFilesTaken(fileIds: readonly string[]): void {
- for (const id of fileIds) {
- if (id.length === 0) {
- continue;
- }
- takenFileIds.delete(id);
- takenFileIds.add(id);
- }
- while (takenFileIds.size > TAKEN_LIMIT) {
- const oldest = takenFileIds.values().next();
- if (oldest.done === true) {
- return;
- }
- takenFileIds.delete(oldest.value);
- }
-}
-
-/** Whether a write for this id is a late callback for an already-consumed
- * attachment, rather than part of an attachment the composer still holds. */
-export function isComposerFileTaken(id: string): boolean {
- return takenFileIds.has(id);
-}
-
-/**
- * Forgets a consumed id, so the SAME file can be attached again on purpose.
- * Re-attaching a library file reuses its server id, and a permanent mark would
- * make that attachment silently impossible for the rest of the session.
- */
-export function releaseComposerFile(id: string): void {
- takenFileIds.delete(id);
-}
+export { markComposerFilesTaken, isComposerFileTaken, releaseComposerFile } from '@librechat/chat';
diff --git a/packages/chat/src/core/composer.ts b/packages/chat/src/core/composer.ts
new file mode 100644
index 0000000000..87f7867cc8
--- /dev/null
+++ b/packages/chat/src/core/composer.ts
@@ -0,0 +1,53 @@
+/**
+ * Composer attachments a during-run submit has already consumed.
+ *
+ * Taking files into a steer or a queued message clears them from the composer,
+ * but an upload for one of them can still have async callbacks in flight
+ * (`loadImage`'s `onload`, HEIC conversion progress, the resize pass). Those
+ * callbacks write the file back with a `set`, which resurrects an attachment
+ * the message already owns: it reappears in the composer and rides the user's
+ * NEXT message too.
+ *
+ * Held outside React state because the decision is synchronous and crosses two
+ * hooks that never share an instance: `useSteering` consumes, `useUpdateFiles`
+ * writes. Ids are per-upload UUIDs (or a library file's own id), so an upload
+ * the user starts AFTER the submit is never confused with a consumed one.
+ */
+
+/** Bounded so a long session cannot grow the set without limit; far beyond the
+ * handful of callbacks that can still be in flight for one submit. */
+const TAKEN_LIMIT = 200;
+
+const takenFileIds = new Set<string>();
+
+export function markComposerFilesTaken(fileIds: readonly string[]): void {
+ for (const id of fileIds) {
+ if (id.length === 0) {
+ continue;
+ }
+ takenFileIds.delete(id);
+ takenFileIds.add(id);
+ }
+ while (takenFileIds.size > TAKEN_LIMIT) {
+ const oldest = takenFileIds.values().next();
+ if (oldest.done === true) {
+ return;
+ }
+ takenFileIds.delete(oldest.value);
+ }
+}
+
+/** Whether a write for this id is a late callback for an already-consumed
+ * attachment, rather than part of an attachment the composer still holds. */
+export function isComposerFileTaken(id: string): boolean {
+ return takenFileIds.has(id);
+}
+
+/**
+ * Forgets a consumed id, so the SAME file can be attached again on purpose.
+ * Re-attaching a library file reuses its server id, and a permanent mark would
+ * make that attachment silently impossible for the rest of the session.
+ */
+export function releaseComposerFile(id: string): void {
+ takenFileIds.delete(id);
+}
diff --git a/packages/chat/src/core/index.ts b/packages/chat/src/core/index.ts
index 0644676ea7..fe752ab853 100644
--- a/packages/chat/src/core/index.ts
+++ b/packages/chat/src/core/index.ts
@@ -6,6 +6,7 @@ export * from './steps';
export * from './steer';
export * from './types';
export * from './files';
+export * from './composer';
export * from './reducer';
export * from './protocol';
export * from './transport';
diff --git a/packages/chat/src/react.ts b/packages/chat/src/react.ts
index 519f454981..64bce9b510 100644
--- a/packages/chat/src/react.ts
+++ b/packages/chat/src/react.ts
@@ -27,3 +27,26 @@ export {
activeGenerationProtocolVersionByConvoId,
} from './react/steer/atoms';
export type { RevealedQueuedTurn } from './react/steer/atoms';
+export {
+ runEndByIndex,
+ resetQueueFamilies,
+ isDetachedRunManual,
+ detachedRunByConvoId,
+ drainAfterAbortByIndex,
+ pendingRunEndByConvoId,
+ stopRequestedByConvoId,
+ queuedMessagesByConvoId,
+ settledQueuedTurnReceiptsByConvoId,
+ pendingQueuedTurnEnqueueIdsByConvoId,
+} from './react/steer/queue';
+export { recoveryDispositionsFamily } from './react/steer/recovery';
+export { ComposerRestoreProvider, useComposerRestoreHost } from './react/steer/restore';
+export type { RestoreToComposer, RewakeDrain, ComposerRestoreHost } from './react/steer/restore';
+export {
+ getReasoningStateKey,
+ pendingQuotesByConvoId,
+ pendingManualSkillsByConvoId,
+ clearPendingComposerContext,
+ pendingReasoningOverrideFamily,
+ clearPendingReasoningOverrides,
+} from './react/composer';
diff --git a/packages/chat/src/react/composer.ts b/packages/chat/src/react/composer.ts
new file mode 100644
index 0000000000..315a06eef3
--- /dev/null
+++ b/packages/chat/src/react/composer.ts
@@ -0,0 +1,84 @@
+import { atom } from 'jotai';
+import { atomFamily } from 'jotai/utils';
+import { Constants } from 'librechat-data-provider';
+import type { TMessage } from 'librechat-data-provider';
+import type { PrimitiveAtom, createStore } from 'jotai';
+import type { Family } from './steer/family';
+
+/** Unsaved split panes share the sentinel conversation id, so include the pane
+ * index until a durable id exists. Saved conversations keep their stable id. */
+export const getReasoningStateKey = (
+ conversationId: string | null | undefined,
+ index: string | number,
+): string =>
+ conversationId == null || conversationId === '' || conversationId === Constants.NEW_CONVO
+ ? `${Constants.NEW_CONVO}:${index}`
+ : conversationId;
+
+/** One-shot reasoning selection owned by the composer for its next full turn. */
+export const pendingReasoningOverrideFamily: Family<
+ TMessage['reasoningOverride'],
+ PrimitiveAtom<TMessage['reasoningOverride']>
+> = atomFamily((_conversationId: string) => atom<TMessage['reasoningOverride']>(undefined));
+
+/**
+ * Per-conversation queue of skill names the user invoked manually via the
+ * `$` popover for the next submission. Structured channel that the submit
+ * pipeline (`useChatFunctions.ask`) drains and pins onto the user message's
+ * `manualSkills` field (also echoed at the top of the payload for the
+ * runtime resolver), then resets to `[]`. Compose-time chips above the
+ * textarea read this atom directly so users see (and can dismiss) their
+ * current selection before hitting send.
+ */
+export const pendingManualSkillsByConvoId: Family<string[]> = atomFamily(
+ (_conversationId: string) => atom<string[]>([]),
+);
+
+/**
+ * Per-conversation queue of verbatim excerpts the user quoted via the
+ * "Add to chat" selection popup for the next submission. The submit pipeline
+ * (`useChatFunctions.ask`) drains this onto the user message's `quotes` field
+ * (which the backend merges into the model-facing text and persists for the
+ * `MessageQuotes` UI), then resets to `[]`. Compose-time chips above the
+ * textarea read this atom directly so users can see and dismiss each quote
+ * before sending.
+ */
+export const pendingQuotesByConvoId: Family<string[]> = atomFamily((_conversationId: string) =>
+ atom<string[]>([]),
+);
+
+/** Release every staged reasoning selection except the `keep` keys. A selection
+ * survives navigation by design, so members of conversations no longer on
+ * screen still hold one; clearing only the mounted panes would carry them
+ * across a sign-out. */
+export const clearPendingReasoningOverrides = (
+ jotaiStore: ReturnType<typeof createStore>,
+ keep: ReadonlySet<string> = new Set(),
+): void => {
+ for (const key of Array.from(pendingReasoningOverrideFamily.getParams())) {
+ if (keep.has(key)) {
+ continue;
+ }
+ jotaiStore.set(pendingReasoningOverrideFamily(key), undefined);
+ pendingReasoningOverrideFamily.remove(key);
+ }
+};
+
+/** Release every staged quote and manual skill pick except under the `keep`
+ * keys. Like a reasoning selection, they survive navigation, so conversations
+ * no longer on screen still hold some; clearing only the mounted panes would
+ * carry them across a sign-out. */
+export const clearPendingComposerContext = (
+ jotaiStore: ReturnType<typeof createStore>,
+ keep: ReadonlySet<string> = new Set(),
+): void => {
+ for (const family of [pendingQuotesByConvoId, pendingManualSkillsByConvoId]) {
+ for (const key of Array.from(family.getParams())) {
+ if (keep.has(key)) {
+ continue;
+ }
+ jotaiStore.set(family(key), []);
+ family.remove(key);
+ }
+ }
+};
diff --git a/client/src/hooks/Chat/__tests__/queue.spec.ts b/packages/chat/src/react/steer/__tests__/queue.spec.ts
similarity index 98%
rename from client/src/hooks/Chat/__tests__/queue.spec.ts
rename to packages/chat/src/react/steer/__tests__/queue.spec.ts
index 912032406a..c209d27471 100644
--- a/client/src/hooks/Chat/__tests__/queue.spec.ts
+++ b/packages/chat/src/react/steer/__tests__/queue.spec.ts
@@ -1,15 +1,14 @@
import { createStore } from 'jotai';
import { ContentTypes } from 'librechat-data-provider';
import type { TMessage } from 'librechat-data-provider';
-import type { DetachedRun } from '../queue';
+import type { DetachedRun } from '../../../core/steer/types';
import {
settledQueuedTurnReceiptsByConvoId,
queuedMessagesByConvoId,
stopRequestedByConvoId,
- resolveDetachedRunEnd,
isDetachedRunManual,
- isStoppedRun,
} from '../queue';
+import { resolveDetachedRunEnd, isStoppedRun } from '../../../core/steer/queue';
const CONVO_ID = 'convo-detached';
const USER_ID = 'user-1';
diff --git a/client/src/components/Chat/Steering/recovery.spec.ts b/packages/chat/src/react/steer/__tests__/recovery.spec.ts
similarity index 95%
rename from client/src/components/Chat/Steering/recovery.spec.ts
rename to packages/chat/src/react/steer/__tests__/recovery.spec.ts
index d9783ec56a..b90ceacb76 100644
--- a/client/src/components/Chat/Steering/recovery.spec.ts
+++ b/packages/chat/src/react/steer/__tests__/recovery.spec.ts
@@ -1,10 +1,11 @@
+/** @jest-environment jsdom */
import { createStore } from 'jotai';
import {
blockRecovery,
canRestoreRecovery,
recoveryDisposition,
- recoveryDispositionsFamily,
-} from './recovery';
+} from '../../../core/steer/recovery';
+import { recoveryDispositionsFamily } from '../recovery';
const item = { recoverySteerId: 'source' };
diff --git a/packages/chat/src/react/steer/atoms.ts b/packages/chat/src/react/steer/atoms.ts
index 7bd750b3c7..f692bd7b79 100644
--- a/packages/chat/src/react/steer/atoms.ts
+++ b/packages/chat/src/react/steer/atoms.ts
@@ -4,11 +4,7 @@ import type { TMessage } from 'librechat-data-provider';
import type { Atom, PrimitiveAtom } from 'jotai';
import type { GenerationProtocolVersion } from '../../core/protocol';
import type { PendingSteer } from '../../core/steer/types';
-
-/** One atom per key, created on first read; `getParams`/`remove` let tests and teardown drop them. */
-type Family<Value, AtomType extends Atom<Value> = PrimitiveAtom<Value>> = ReturnType<
- typeof atomFamily<string, AtomType>
->;
+import type { Family } from './family';
/**
* Set synchronously before a bubble's arm request and cleared on settlement.
diff --git a/packages/chat/src/react/steer/family.ts b/packages/chat/src/react/steer/family.ts
new file mode 100644
index 0000000000..49957d09e4
--- /dev/null
+++ b/packages/chat/src/react/steer/family.ts
@@ -0,0 +1,9 @@
+import type { Atom, PrimitiveAtom } from 'jotai';
+import type { atomFamily } from 'jotai/utils';
+
+/** One atom per key, created on first read; `getParams`/`remove` let tests and teardown drop them. */
+export type Family<
+ Value,
+ AtomType extends Atom<Value> = PrimitiveAtom<Value>,
+ Param = string,
+> = ReturnType<typeof atomFamily<Param, AtomType>>;
diff --git a/packages/chat/src/react/steer/queue.ts b/packages/chat/src/react/steer/queue.ts
new file mode 100644
index 0000000000..ecf8ae950e
--- /dev/null
+++ b/packages/chat/src/react/steer/queue.ts
@@ -0,0 +1,139 @@
+import { atom } from 'jotai';
+import { atomFamily, RESET } from 'jotai/utils';
+import type { Getter, PrimitiveAtom, WritableAtom } from 'jotai';
+import type {
+ RunEnd,
+ StoppedRun,
+ DetachedRun,
+ QueuedMessage,
+ DrainAfterAbort,
+ SettledQueuedTurnReceipt,
+} from '../../core/steer/types';
+import type { Family } from './family';
+import { isStoppedRun } from '../../core/steer/queue';
+
+/** A chat pane, keyed by its index (`0` for the main chat). */
+type PaneKey = string | number;
+
+/** Reads the oldest queued run end; writes append one, `null` consumes it, `RESET` clears all. */
+type RunEndQueue = WritableAtom<RunEnd | null, [RunEnd | null | typeof RESET], void>;
+
+/**
+ * Per-conversation client-side queue of follow-up messages. Drained one per
+ * run completion by `useQueueDrain` (each dequeued message starts a normal
+ * turn whose own final event drains the next).
+ */
+export const queuedMessagesByConvoId: Family<QueuedMessage[]> = atomFamily(
+ (_conversationId: string) => atom<QueuedMessage[]>([]),
+);
+
+/** Monotonic client knowledge of terminal server queue receipts. Admission
+ * records preserve boundary multiplicity by request identity. Other terminal
+ * records exist only while their original enqueue callback is outstanding. */
+export const settledQueuedTurnReceiptsByConvoId: Family<SettledQueuedTurnReceipt[]> = atomFamily(
+ (_conversationId: string) => atom<SettledQueuedTurnReceipt[]>([]),
+);
+
+/** Enqueue callbacks that can still race newer GET/cancellation evidence.
+ * Entries retire as soon as that one callback settles. */
+export const pendingQueuedTurnEnqueueIdsByConvoId: Family<string[]> = atomFamily(
+ (_conversationId: string) => atom<string[]>([]),
+);
+
+/** The oldest terminal epoch in a queue of them, behind the nullable one-shot API stream writers
+ * use: writing a signal appends it, writing `null` consumes only the visible (oldest) one, and
+ * `RESET` clears them all. */
+const runEndQueue = (signals: PrimitiveAtom<RunEnd[]>): RunEndQueue =>
+ atom(
+ (get) => get(signals)[0] ?? null,
+ (_get, set, value: RunEnd | null | typeof RESET) => {
+ if (value === RESET) {
+ set(signals, []);
+ return;
+ }
+ if (value == null) {
+ set(signals, (prev) => prev.slice(1));
+ return;
+ }
+ set(signals, (prev) => [...prev, value]);
+ },
+ );
+
+/** A pane can receive A's terminal frame after the user has navigated to and
+ * started B. Keep each terminal epoch until the queue drain has either parked
+ * or consumed it; a single replaceable slot loses A when B finishes first. */
+const runEndsByIndex: Family<RunEnd[], PrimitiveAtom<RunEnd[]>, PaneKey> = atomFamily(
+ (_index: string | number) => atom<RunEnd[]>([]),
+);
+
+/** One-shot run-termination signal for a pane, written by the SSE final/error handlers and
+ * consumed by `useQueueDrain`. */
+export const runEndByIndex: Family<RunEnd | null, RunEndQueue, PaneKey> = atomFamily(
+ (index: string | number) => runEndQueue(runEndsByIndex(index)),
+);
+
+/** Foreign terminal epochs are moved off the shared pane immediately. This
+ * per-conversation carrier is queued for the same reason as the pane carrier:
+ * successive epochs cannot overwrite one another while the chat is hidden. */
+const pendingRunEndsByConvoId: Family<RunEnd[]> = atomFamily((_conversationId: string) =>
+ atom<RunEnd[]>([]),
+);
+
+export const pendingRunEndByConvoId: Family<RunEnd | null, RunEndQueue> = atomFamily(
+ (conversationId: string) => runEndQueue(pendingRunEndsByConvoId(conversationId)),
+);
+
+/**
+ * One-shot override armed by "interrupt & send": the next `aborted` run-end
+ * for the exact conversation generation drains the queue exactly once (a
+ * plain Stop press leaves queued chips for manual send). `false` remains the
+ * clear value used by stream reconciliation paths.
+ */
+export const drainAfterAbortByIndex: Family<
+ DrainAfterAbort | false,
+ PrimitiveAtom<DrainAfterAbort | false>,
+ PaneKey
+> = atomFamily((_index: string | number) => atom<DrainAfterAbort | false>(false));
+
+export const detachedRunByConvoId: Family<DetachedRun | null> = atomFamily(
+ (_conversationId: string) => atom<DetachedRun | null>(null),
+);
+
+export const stopRequestedByConvoId: Family<StoppedRun | null> = atomFamily(
+ (_conversationId: string) => atom<StoppedRun | null>(null),
+);
+
+/** Whether a detached run's end must be left for a manual send instead of read from history, which
+ * retires its marker: the user stopped it, and a stopped response persists like a completed one
+ * (a stopped compaction even settles with `unfinished: false`). */
+export function isDetachedRunManual(
+ get: Getter,
+ conversationId: string,
+ run: DetachedRun,
+): boolean {
+ return isStoppedRun(get(stopRequestedByConvoId(conversationId)), run.generationCreatedAt);
+}
+
+const clearFamily = <Param>(family: {
+ getParams(): Iterable<Param>;
+ remove(param: Param): void;
+}) => {
+ for (const param of [...family.getParams()]) {
+ family.remove(param);
+ }
+};
+
+/** Drops every per-key queue atom, so the next read of any key starts from its default. Isolates
+ * tests that share the default store. */
+export function resetQueueFamilies(): void {
+ clearFamily(queuedMessagesByConvoId);
+ clearFamily(settledQueuedTurnReceiptsByConvoId);
+ clearFamily(pendingQueuedTurnEnqueueIdsByConvoId);
+ clearFamily(pendingRunEndsByConvoId);
+ clearFamily(pendingRunEndByConvoId);
+ clearFamily(drainAfterAbortByIndex);
+ clearFamily(runEndsByIndex);
+ clearFamily(runEndByIndex);
+ clearFamily(detachedRunByConvoId);
+ clearFamily(stopRequestedByConvoId);
+}
diff --git a/packages/chat/src/react/steer/recovery.ts b/packages/chat/src/react/steer/recovery.ts
new file mode 100644
index 0000000000..be4938eb05
--- /dev/null
+++ b/packages/chat/src/react/steer/recovery.ts
@@ -0,0 +1,51 @@
+import { atomFamily, atomWithStorage, createJSONStorage } from 'jotai/utils';
+import type { WritableAtom } from 'jotai';
+import type { RESET } from 'jotai/utils';
+import type { RecoveryDispositions } from '../../core/steer/recovery';
+import type { Family } from './family';
+
+type SetStateActionWithReset<Value> =
+ | Value
+ | typeof RESET
+ | ((prev: Value) => Value | typeof RESET);
+
+/** Receipt-scoped safety decisions survive remounts and reloads in this tab.
+ * No message content is stored. A crashed cancellation stays held, not sendable. */
+export const recoveryDispositionsFamily: Family<
+ RecoveryDispositions,
+ WritableAtom<RecoveryDispositions, [SetStateActionWithReset<RecoveryDispositions>], void>
+> = atomFamily((conversationId: string) =>
+ atomWithStorage<RecoveryDispositions>(
+ `steer-recovery:${conversationId}`,
+ {},
+ createJSONStorage(
+ () => ({
+ getItem(key) {
+ try {
+ return sessionStorage.getItem(key);
+ } catch {
+ return null;
+ }
+ },
+ setItem(key, value) {
+ try {
+ sessionStorage.setItem(key, value);
+ } catch {
+ /* Keep the in-memory safety decision. */
+ }
+ },
+ removeItem(key) {
+ try {
+ sessionStorage.removeItem(key);
+ } catch {
+ /* Storage may be disabled. */
+ }
+ },
+ }),
+ {
+ reviver: (_key, value) => (value === 'cancelling' ? 'blocked' : value),
+ },
+ ),
+ { getOnInit: true },
+ ),
+);
diff --git a/packages/chat/src/react/steer/restore.tsx b/packages/chat/src/react/steer/restore.tsx
new file mode 100644
index 0000000000..291d44b2ef
--- /dev/null
+++ b/packages/chat/src/react/steer/restore.tsx
@@ -0,0 +1,81 @@
+import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
+import type { TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import type { QueuedMessageContext } from '../../core/steer/types';
+
+/** Restores a message's text, attachments and compose-time context into the
+ * composer, or refuses (false) when the composer is occupied, unmounted, or
+ * showing another chat. A refusal means the caller must re-home the words
+ * somewhere else rather than drop them. */
+export type RestoreToComposer = (
+ text: string,
+ files: TMessage['files'],
+ context: QueuedMessageContext,
+ originConversationId: string,
+) => boolean;
+
+/** Re-posts a conversation's spent run-end signal so its queue drain wakes. */
+export type RewakeDrain = (conversationId: string) => void;
+
+export interface ComposerRestoreHost {
+ /** The composer publishes its guarded restore here while it is mounted. */
+ publish: (restore: RestoreToComposer | null) => void;
+ /** Resolved at call time: a recovery round-trip can settle long after the
+ * composer that started it has gone. */
+ restore: RestoreToComposer;
+ /** The composer publishes its drain wake-up here while it is mounted. */
+ publishRewake: (rewake: RewakeDrain | null) => void;
+ /** Resolved at call time like `restore`; a no-op with no composer mounted,
+ * which leaves a queued row for the next run end or an explicit send. */
+ rewakeDrain: RewakeDrain;
+}
+
+const refuse: RestoreToComposer = () => false;
+
+const ComposerRestoreContext = createContext<ComposerRestoreHost>({
+ publish: () => {},
+ restore: refuse,
+ publishRewake: () => {},
+ rewakeDrain: () => {},
+});
+
+/**
+ * Lets surfaces outside the composer hand a message back to it: into the
+ * draft, or into the queue with the drain woken to pick it up.
+ *
+ * The composer is a sibling of the message list, not its ancestor, so a
+ * pending steer cancelled from the thread cannot reach the restore the queue
+ * rail gets as a prop. The pane's host holds the reference instead, and both
+ * sides read it here: the thread never reaches into composer state, and a
+ * restore that resolves after the composer unmounted refuses rather than
+ * writing into a dead form.
+ */
+export function ComposerRestoreProvider({ children }: { children?: ReactNode }): ReactNode {
+ const restoreRef = useRef<RestoreToComposer | null>(null);
+ const publish = useCallback((restore: RestoreToComposer | null) => {
+ restoreRef.current = restore;
+ }, []);
+ const restore = useCallback<RestoreToComposer>(
+ (text, files, context, originConversationId) =>
+ restoreRef.current?.(text, files, context, originConversationId) ?? false,
+ [],
+ );
+ const rewakeRef = useRef<RewakeDrain | null>(null);
+ const publishRewake = useCallback((rewake: RewakeDrain | null) => {
+ rewakeRef.current = rewake;
+ }, []);
+ const rewakeDrain = useCallback<RewakeDrain>((conversationId) => {
+ rewakeRef.current?.(conversationId);
+ }, []);
+ const value = useMemo(
+ () => ({ publish, restore, publishRewake, rewakeDrain }),
+ [publish, restore, publishRewake, rewakeDrain],
+ );
+ return (
+ <ComposerRestoreContext.Provider value={value}>{children}</ComposerRestoreContext.Provider>
+ );
+}
+
+export function useComposerRestoreHost(): ComposerRestoreHost {
+ return useContext(ComposerRestoreContext);
+}