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({ - 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(null); - const publish = useCallback((restore: RestoreToComposer | null) => { - restoreRef.current = restore; - }, []); - const restore = useCallback( - (text, files, context, originConversationId) => - restoreRef.current?.(text, files, context, originConversationId) ?? false, - [], - ); - const rewakeRef = useRef(null); - const publishRewake = useCallback((rewake: RewakeDrain | null) => { - rewakeRef.current = rewake; - }, []); - const rewakeDrain = useCallback((conversationId) => { - rewakeRef.current?.(conversationId); - }, []); - const value = useMemo( - () => ({ publish, restore, publishRewake, rewakeDrain }), - [publish, restore, publishRewake, rewakeDrain], - ); - return ( - {children} - ); -} - -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(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([]), -); - -/** - * 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([])); +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, - keep: ReadonlySet = 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, - keep: ReadonlySet = 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( - `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([]), -); - -/** 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([]), -); - -/** 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([]), -); - -/** 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) => - 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([])); - -/** 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([])); - -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(false), -); - -export const detachedRunByConvoId = atomFamily((_conversationId: string) => - atom(null), -); - -export const stopRequestedByConvoId = atomFamily((_conversationId: string) => - atom(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 = (family: { - getParams(): Iterable; - 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(); - -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(); + +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 +> = atomFamily((_conversationId: string) => atom(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 = atomFamily( + (_conversationId: string) => atom([]), +); + +/** + * 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 = atomFamily((_conversationId: string) => + atom([]), +); + +/** 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, + keep: ReadonlySet = 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, + keep: ReadonlySet = 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 = PrimitiveAtom> = ReturnType< - typeof atomFamily ->; +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 = PrimitiveAtom, + Param = string, +> = ReturnType>; 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; + +/** + * 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 = atomFamily( + (_conversationId: string) => atom([]), +); + +/** 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 = atomFamily( + (_conversationId: string) => atom([]), +); + +/** Enqueue callbacks that can still race newer GET/cancellation evidence. + * Entries retire as soon as that one callback settles. */ +export const pendingQueuedTurnEnqueueIdsByConvoId: Family = atomFamily( + (_conversationId: string) => atom([]), +); + +/** 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): 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, PaneKey> = atomFamily( + (_index: string | number) => atom([]), +); + +/** One-shot run-termination signal for a pane, written by the SSE final/error handlers and + * consumed by `useQueueDrain`. */ +export const runEndByIndex: Family = 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 = atomFamily((_conversationId: string) => + atom([]), +); + +export const pendingRunEndByConvoId: Family = 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, + PaneKey +> = atomFamily((_index: string | number) => atom(false)); + +export const detachedRunByConvoId: Family = atomFamily( + (_conversationId: string) => atom(null), +); + +export const stopRequestedByConvoId: Family = atomFamily( + (_conversationId: string) => atom(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 = (family: { + getParams(): Iterable; + 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 + | 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], void> +> = atomFamily((conversationId: string) => + atomWithStorage( + `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({ + 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(null); + const publish = useCallback((restore: RestoreToComposer | null) => { + restoreRef.current = restore; + }, []); + const restore = useCallback( + (text, files, context, originConversationId) => + restoreRef.current?.(text, files, context, originConversationId) ?? false, + [], + ); + const rewakeRef = useRef(null); + const publishRewake = useCallback((rewake: RewakeDrain | null) => { + rewakeRef.current = rewake; + }, []); + const rewakeDrain = useCallback((conversationId) => { + rewakeRef.current?.(conversationId); + }, []); + const value = useMemo( + () => ({ publish, restore, publishRewake, rewakeDrain }), + [publish, restore, publishRewake, rewakeDrain], + ); + return ( + {children} + ); +} + +export function useComposerRestoreHost(): ComposerRestoreHost { + return useContext(ComposerRestoreContext); +}