* feat: Retire Expired and Older Pauses and Reconcile the Held Pause With Sync Snapshots
* fix: Let an Expired Pause Retire the Held One It Ties
* fix: Hold a Pause the Sync Frame Buffers and Follow an Answer Whose Pause a Snapshot Released
* fix: Keep a Stale Buffered Pause Out of the Host Reducer
* fix: Retire a Released Pause When Its Generation Ends
* fix: Let Only the Pause a Sync Frame Stands for Reach the Host Reducer
* feat: Answer, Restore and Stop a Paused Generation From the Chat Core
* fix: Retire a Pause the Server Refused Once Its Probe Owns the Chat
* fix: Keep a Pause the Server Refused Over for Later Reads and Replays
* feat: Reattach to a Running Generation and Keep a Dropped One Stoppable
* fix: Keep a Continued Generation's Endpoint When the Host Selection Changes
* fix: End What a Dropped Generation Leaves When a Retry, a Stop or a Status Read Settles It
* test: Cover a Reattachment That Yields to a Turn the Host Starts While It Selects the Endpoint
* fix: Settle What a Reconnect Answers for and Let It Go Before a Store Is Told
* fix: Return a Failed Chat to Ready as One Write
* refactor: Move Subagent Progress State and Content Folding Into @librechat/chat
* refactor: Attach the Subagent Activity Feed Through the Chat Transport
* test: Tag the Subagent Activity Panel E2E Specs With Scenarios
* test: Pin Replay, Ready and Live Steer Ordering Across an Activity Reconnect
* fix: Stop the Subagent Activity Feed on Refusals and Bound Idle Reconnects
* fix: Keep Attaching the Subagent Feed While the Child Thread Is Still Reserved
* test: Read Steer Order the Same While the Child Turn Streams and Once It Settles
* refactor: Move Composer Attachment Components Into @librechat/chat
* test: Cover the Pasted Text Editor From Paste to Saved Edit
* test: Keep the Real Data Provider Enums in the ChatView Subagent Spec
* refactor: Build the Source Badge Styles at Render Time
* test: Reopen the Pasted Text Correction From Its Replacement Chip
* chore: Re-record the Attachment Design Suppressions on Dev
* test: Merge the SteerPart Package Mocks Into One Factory
* fix: Fence Auth User Cache Writes After Eviction and Evict Favorite Holders
An eviction now leaves a per-user fence in the auth user cache that outlives
every document read before it. The reader skips a cached document while its
user is fenced, and a lookup slower than one cache TTL is not cached, so a
request that read the user before a change can no longer repopulate the cache
afterwards, and a document the reverse index lost is hidden as well. Role and
user methods share one bulk eviction helper, and the terms reset only waits
out the TTL when an eviction failed.
Deleting an agent, deleting a user's agents and removing an agent from
favorites now evict the cached auth documents of the users whose favorites
changed.
* fix: Anchor Cached Auth Document Expiry to the Lookup Start
A stalled reverse-index write could land a stale document after the eviction
fence expired, with a fresh TTL. The document now carries an expiry two cache
TTLs after its lookup began; its Redis TTL is computed after the index write
and the reader refuses it past that expiry.
* refactor: Time the Auth User Lookup in the API Package
The lookup start that anchors a cached document's lifetime is now stamped by
timeAuthUserLookup in packages/api, so the OpenID JWT strategy only wires the
lookup through it.
* fix: Wait Out the Full Cached Document Lifetime After Failed Eviction
A document read just before a change can live two cache TTLs from its lookup,
so a credential change or terms reset whose eviction failed now waits that
long before reporting success.
* fix: Recheck Cached Auth Document Expiry After the Fence Read
A fence read that stalls can return after both the fence and the document
expired, so the reader checks the document's expiry again before serving it.
* feat: Stop the Turn in Flight From the Chat Core
* fix: Adopt the Conversation a Late Stream's Stop Names and Record a Replacement Before Its Rollback Notifies
* refactor: Move Tool Disclosure State and Leaf Part Components Into @librechat/chat
Disclosure contexts and atoms, tool intent labels, useRowHandoff and
useFollowScroll move to packages/chat/src/react/parts (exported from
@librechat/chat/react); CancelledIcon, InProgressCall, AuthorHeader, Stdout,
BareStatus and the row class constants move to
packages/chat/src/components/parts (exported from @librechat/chat/components).
Disclosure reads the package host, and ToolContentQuery is declared from
data-provider and react-query types. The AuthorHeader and useFollowScroll specs
move with their modules.
* test: Cover the Author Header That Resumes After a Steer
* test: Keep the Package Entry Intact When Mocking AuthorHeader
* refactor: Move Pure Part Helpers Into @librechat/chat
Tool output parsers (JSON fields, background handles, wakeups, background
tasks, command results) and the small routing, params and rerun helpers move
from client Content/ into packages/chat/src/core/parts, exported from the
package root. Client importers read them from @librechat/chat; parseJsonField
becomes a named export so the root barrel can carry it.
* test: Cover Wake-Up Turns Rendering as Task Cards
* fix: Point the API Background Spec at the Moved Parsers
* fix: Bound outbound HTTP calls that had no timeout
Add timeouts.toolsMs, speechMs and imageGenerationMs to the timeouts block and apply the
existing budgets to the RAG delete paths, built-in tool APIs, TTS/STT providers (TTS also
aborts when the client closes), Stable Diffusion, Firebase reads and Mailgun. Calls made
before app config exists (remote config, RAG health, service key URL, Google refresh) get a
fixed 10 second budget.
* fix: Honor configured budgets for RAG deletes and per-chunk TTS deadlines
* refactor: Share one budget helper between speech and image CJS callers
* test: Cover a stalled RAG delete with a mock scenario
* test: Wait for the RAG embed before stalling the delete
* test: Embed at upload so the stalled delete has a vector to remove
* fix: Close a started TTS response on a late chunk timeout and share the service budget helper
* fix: Fail startup when the remote config fetch times out
* feat: Add a Minimal Consumer Example for @librechat/chat
A Vite React page under packages/chat/example renders a themed chat from the package's public entries and the @librechat/client theme, with an in-memory transport standing in for the server. Its jsdom smoke test runs in the package's jest suite, the package typecheck covers it, and ESLint keeps it to public imports and semantic theme roles.
* fix: Let Enter Confirm an IME Composition in the Example Composer
* fix: Report a Failed Turn in the Example and Restore Its Text
* fix: Localize the Example Copy and Guard the Safari IME Enter
* fix: Drop a Rejected Turn, Load the Component CSS, and Keep the i18n Instance in the Example Build
* refactor: Replace the Example App With a Public-Entry Consumer Spec
The owner does not want an example app in the repository. packages/chat/test/consumer.spec.tsx keeps what it proved: a chat built only from @librechat/chat, /react, /components and @librechat/client, over an in-memory transport, streams a reply into the message list under the ClickHouse theme. It sits outside src because chat/boundary rejects self-imports there; jest maps the entry names to the sources and the package typecheck covers it. The example app, its Vite, Tailwind and PostCSS config, its lint block, script and dependency lines are removed.
* chore: Declare the Consumer Spec's i18next Dev Dependencies
* chore: Retest Against Current Dev
* feat: Reject Module-Load Use of Other Packages in the Chat Package
App specs mock whole packages (@librechat/client, librechat-data-provider), so a package module that calls into one or reads a member of one while it loads throws before any test runs. chat/boundary now reports a call, new, tagged template or member read through an external import at module scope in packages/chat/src outside specs; React and Jotai are exempt through a loadSafe option.
* fix: Count Immediately Invoked Functions and Computed Field Keys as Module Load
* fix: See Through Erased TypeScript Wrappers in the Module-Load Check
* fix: Count Destructuring, Spreads and Wrapped IIFEs as Module-Load Reads
* refactor: Judge Every Load-Time Reference to an External Import
The check now walks each external import's references once and reports any that runs on load outside an inert position, instead of listing the node types that read an import. Class heritage, in, instanceof and iteration are reported with no new visitor.
* fix: Follow Branches to Their Consumer and Skip Erased Heritage Types
* fix: Count Constructed Classes and Destructuring Assignments as Module Load
* fix: Count Constructors of Constructed Classes and Branch-Fed IIFEs as Module Load
* fix: Follow Const Aliases of External Imports in the Module-Load Check
* fix: Find Aliases Behind Wrappers and Branches
* fix: Track require Bindings, Skip Writes and Defer Generator Bodies in the Module-Load Check
* fix: Follow Assignment Aliases of External Imports
* fix: Collect require Bindings From Exported Declarations
* refactor: Cover Module-Load Failures With a Mocked-Dependency Load Spec
A packages/chat spec now loads the index, react and components entries with every package the sources import (React and Jotai aside) mocked to a module whose exports are missing, the way an app spec's factory mock leaves it, and asserts nothing throws. That covers aliases, require, invoked functions and the rest at runtime, so chat/boundary keeps only the plain case: a call, new, tagged template or member read through a direct import binding at module scope.
* chore: Retest Against Current Dev
* fix: Exempt Spec Support Files and Node Built-ins From the Module-Load Check
* refactor: Move Message Row and Timestamp into @librechat/chat
Add a MessagesHost the message list reads the viewer's clock format and row
slots from, registered by the app at load, and move MessageRow,
MessageTimestamp, the row width helper, the timestamp formatters and the
minute ticker into the package with their specs. The user attachments a row
shows reach it through the host's files slot until they move.
* test: Cover Message Rows on Chat and Shared Routes
* chore: Prepare the Chat Package for Message Components
Give packages/chat a lint-only Tailwind entry so the design rules resolve the
library's theme utilities, allow the app status selectors its components carry,
expose the active language from @librechat/client, and let the locale check
accept keys that resolve through plural forms.
* refactor: Move Message Row Leaves into @librechat/chat
Move the hover style helpers, SubRow, SiblingSwitch, the elapsed timer with its
duration labels, HeaderLabel and the system event header into
packages/chat/src/components/messages, export them from
@librechat/chat/components, and point the client at the package.
* test: Cover Message Row Leaves in the Mock Harness
* chore: Drop the Chat Lint Entry in Favor of components.json
* test: Run the Elapsed Spec Against the Package
* fix: Label Composer Thinking Levels and State the One-Shot Scope
* test: Cover Composer Thinking Labels and One-Shot Scope in E2E
* test: Cover Thinking Focus for Option Lists Without Auto
* test: Wait for the Thinking Popover's Open Focus Before Arrow Keys
* test: Match the High Effort Radio Exactly
* fix: Keep the Composer Thinking Level for the Rest of the Conversation
* fix: Keep a Queued Turn's Picked Level on the Turns Queued After It
* test: Name the Numeric Reasoning Control by Its Thinking Label
* fix: Name the Queued Turn's Level on the Thinking Button
* test: Dismiss the Thinking Tooltip Before Typing on a Phone
* fix: Respect Enforced Specs and Parameters Edits Over the Inherited Thinking Level
* test: Expect the Model Spec Enforcement Flag in Chat Settings
* fix: Keep a Queued Turn Off a Level Its Target No Longer Runs
* fix: Record the Target a Queued Turn's Level Belongs To
* refactor: Inherit the Thinking Level on the Server
* perf: Answer the Branch Level Lookup Without Tree Links When Nothing Was Picked
* fix: Respect the Thinking Switch and Held Queue Rows Over the Inherited Level
* fix: Read the Branch Level Once and Inherit Only on Fresh Turns
* fix: Keep a Parameters Thinking Edit From Turning Thinking On
* fix: Withdraw a Staged Thinking Level When Thinking Is Switched Off
* fix: Scope the Thinking Switch Transition to the Conversation
* test: Drop the One-Shot Thinking Scenario the Conversation Level Replaces
* perf: Parallelize Serial Lookups on Agent Load, Discovery, Skills, and Schedules
* fix: Address Review Findings on Parallel Lookups
Stage same-level discovery results before collecting edges so a shared sibling is initialized once, bound resume snapshot fetches to small chunks so over-budget graphs stop early, and surface the first ordered image failure without waiting on later reads. Update the skill name test for bounded concurrency.
* test: Tag Existing Mock Specs as Acceptance Scenarios for Parallel Lookups
* feat: Make Parallel Lookup Bounds Configurable
Add a concurrency section to librechat.yaml for MCP catalog, skill name, skill file and resume agent lookups. Defaults equal the previous hard-coded values.
* style: Sort Imports for Configurable Lookup Bounds
* test: Match Model Spec Skill Resolution Args With App Config
* test: Close the Builder Drawer Before Chatting on Narrow Viewports
* fix: Surface Fatal Discovery Errors Without Awaiting Later Siblings
* fix: Reject Discovery on the First Fatal Load Regardless of Queue Order
* fix: Keep Image Encoding Fail-Fast With Parallel Reads
* fix: Reject Resume Snapshot Lookups Without Waiting on the Whole Chunk
* feat: Make Connected Agent Discovery Concurrency Configurable
openid-client's Passport Strategy replaces the authorization request's state with a random one
when the IdP's discovery metadata does not list S256 in code_challenge_methods_supported and the
request has no nonce. Azure Entra ID omits that field, so the admin callback could not find the
admin panel's PKCE challenge under pkce:<state> and issued an exchange code that any
code_verifier, or none, could redeem.
The admin strategy now adds a nonce in that case, so openid-client keeps the admin route's state
and checks the nonce against the ID token on the callback. The chat OpenID flow is unchanged.
* test: Pin the Chat Lifecycle as a State and Event Table
* feat: Count Chat Changes and Let a Host Replace the Message List
* fix: Run No Message Updater Once the Chat Is Disposed
* test: Keep a Host Write Through the Rollback of a Replaced Start
* feat: Bind the Core Chat to React With useCoreChat
* fix: Keep Untouched Rows and the Learned Conversation in useCoreChat Writes
setMessages kept every stored row only by value, recreating the ones its views left as they were, so the rollback of a replaced start treated the turn's own rows as host edits and kept them. A view that is still the one the stored row produced now keeps that row as is. New rows were also filed under chat.id, which stays 'new' after the server creates the conversation; Chat now exposes the conversation it runs under and setMessages uses it.
* fix: Keep the Turn Rows Above an Edited Turn Row When a Replaced Start Rolls Back
Rolling back a replaced start kept a turn row someone else had edited but removed the turn rows above it, so the kept response lost its parent and the message tree filed it as a second root. Undo now keeps every row the turn added on the path from a kept turn row to the rows before the turn.
* fix: Keep the Turn Rows Above Any Row a Replaced Start's Rollback Keeps
A row another writer appended under the turn's response survived the rollback of a replaced start while the turn rows above it went, leaving it without a parent. Undo now keeps the rows the write added on the path above every row it keeps, whoever wrote that row. Test fixtures that gave a pre-existing row the turn's user message as its parent now chain to each other.
* fix: Stop a Stream Event Once a Listener Disposed the Chat on Its Streaming Status
The first content frame or pause moves the chat to streaming and tells its listeners, and one that disposed the chat there still had the event delivered to the host's onEvent. The event now stops when that notification released the chat.
* fix: Publish a Turn's Terminal State as One Write
A store that reports each status or connection write let a listener start the next turn as the connection went idle, and the status and error written after it then overwrote that turn's submitted state. The terminal fields are now written together with the store's own reports held back, and listeners are told once they are all set.
* fix: Leave the Next Turn's State Alone When a Store Subscriber Starts It Mid-Publish
A store subscriber told the connection went idle can start the next turn while the finished one is still publishing, and the finished turn then wrote its ready or error status and error over the new turn's submitted state. Publishing stops writing those fields once another turn holds the chat.
* fix: Advance the Snapshot Version When a Host Store Moved Unheard
A version read taken by another consumer after a host store write, but before any subscription heard it, moved the counted baseline to the new list without moving the version, so the consumer that rendered the old list was never told. A host store list that differs from the counted one now counts as a change the version moves past.
* fix: Count a Cache Write No Subscription Heard by Its Write Time
With every listener unsubscribed, a reset followed by a write of the same array restored the counted write count, so the version stayed put while the content changed. The cache's write time moves on every write, so a changed one now counts as a change too.
* fix: Keep the Snapshot When the Terminal Write Settled for Reconciliation
* fix: Promote a Reconciled Compaction Snapshot to the Terminal Row
* fix: Anchor and Envelope the Reconciled Snapshot by Its Claim
* test: Cover the Abandoned Compaction Settling After Its Run in E2E
* fix: Withhold the Disconnect Snapshot of Any Durably Settled Turn
* fix: Promote Only a Same-Epoch Reconciled Snapshot and Settle Stopped Compactions
* fix: Plan the Disconnect Snapshot in packages/api and Check the Response Row Before Promoting
* fix: Read the Disconnect Snapshot Rows in the Response Conversation
* fix: Check the Anchor-Derived Error Row Before Promoting a Reconciled Snapshot
* fix: Log a Failed Disconnect Snapshot Plan Instead of Rejecting the Listener
* fix: Let a Reconciled Compaction Promote After an Earlier Live Snapshot
* refactor: Decide the Repeat Disconnect Write in the Snapshot Plan
* refactor: Report Failed Snapshot Row Reads Through the Plan
* fix: Stamp a Promoted Disconnect Snapshot and Read Its Rows Together
* fix: Derive the Compaction Error Row ID Through the Shared Helper
* fix: Plan a Saved Live Compaction Snapshot Again Once Its Turn Settles
* refactor: Queue Disconnect Snapshots and Settle Them in packages/api
* fix: Never Count the Compaction Anchor as Its Own Terminal Row
* fix: Settle Disconnect Snapshots Before Terminal Cleanup Releases the Turn
* refactor: Add the Core Chat Class With a Serial Job Executor and React Query State
* fix: Report an Attachment's HTTP Failure as a Disconnect and the Turn's Conversation on Finish
* fix: Report a Stream That Fails While It Is Read as a Disconnect
* fix: Keep an Attachment Failure a Disconnect When the Host Reducer Throws on It
* fix: Treat a Resumed Start as an Attachment and Drop a Replaced Start's Optimistic Rows
* fix: Undo the Whole Optimistic Write of a Start the Server Replaced
* fix: Give Each Optimistic Write One Rollback Record and Stop a Disposed Chat Writing State
A turn keeps its optimistic write on the active request, so a disposal before the start was sent undoes those rows as a replaced start already did, and a removed row is restored next to its surviving neighbors instead of at its old index. A disposed chat no longer moves the shared status or connection, so a listener that disposes on a rollback notice cannot leave the state reconnecting. A start that fails with ERR_INTERNET_DISCONNECTED is a disconnect like ERR_NETWORK, and the React Query state rechecks a host store that changed between a version read and its subscription.
* fix: Roll Back the Rows a Store Committed, Not the Rows the Chat Handed It
A React Query cache with structural sharing commits a changed row as a copy, so a replaced start compared its rollback record against objects the cache never held and kept the optimistic edit. The record now takes the list as the state reads it back after the write.
* fix: Record the Optimistic Rows a Store Committed Before Telling Subscribers
A listener that writes the shared state when the chat announces its optimistic write no longer lands in that write's rollback record, so a replaced start keeps the listener's rows. The record is taken before anyone is notified, and a store's report of the chat's own write waits for the chat's announcement instead of running inside the write.
* fix: Stop a Stream Event Once a Listener Disposed the Chat on Its Write
A listener that disposes the chat while an event's write is announced no longer lets that event move the shared status to streaming or reach onEvent after teardown.
* fix: Scope Optimistic Rollback to the Rows the Write Itself Changed
The rollback record kept the whole list the store committed, so a row a store subscriber appended while the write was committed was undone with the turn, and a subscriber that disposed the chat inside the write left the turn's rows behind because no record existed yet. The record now holds, by message id, only the rows the write added, replaced or removed, each under the identity the store committed it with; undo restores or drops those and leaves every other row. A dispose inside the write is undone once the record exists.
* fix: Leave a Turn Row a Store Subscriber Edited Inside the Write Out of Its Rollback
A store that notifies its subscribers synchronously can hand back one of the turn's rows already edited by a subscriber, and the rollback of a replaced start then deleted or overwrote that edit. The record now claims a committed row only when it is the written row or a structural copy of it.
* perf: Index Hot Lookups and Make Message Cursor Pagination Stable
Add narrow indexes for session refresh-token deletes, user-only tool call deletes, queued-turn delivery and reconciliation claims, agent code environment references, and updatedAt message pages. Add a TTL index to the KeyvMongo collection. getMessagesByCursor now sorts and pages on a unique (sortField, _id) tiebreaker with a millisecond-precise cursor while still accepting legacy cursors, and GET /api/messages caps pageSize in a TypeScript helper.
* fix: Keep the Message Id for the Cursor Under the Client Projection
* fix: Declare select on the Message Cursor Method Type
* feat: Make the Message Page Size Ceiling Configurable
* fix: Clamp the Default Message Page Size to the Configured Ceiling
* test: Cover Message Cursor Paging and Page Size Cap End to End
* fix: Continue Message Cursors Whose Sort Value Is Empty
* fix: Include Missing Sort Values When Paging Messages Descending
* perf: Resolve the Message Page Ceiling Beside the Ownership Read
* fix: Observe the Ownership Read While the Page Size Resolves
* style: Sort Imports in the Message Page Module
* refactor: Move Page Size Read Observation Into the API Package
* fix: Keep Missing and Empty Sort Values Distinct in the Message Cursor
* fix: Page Past Messages With a Missing Timestamp
* fix: Honor Documented Azure Model Assistants and fileConfig.stt Keys
Read the model-level Azure assistants flag from the group's models entry,
validate and merge fileConfig.stt, drop two never-read image tool env vars
from .env.example and fix the SharePoint scope example.
* test: Cover Model-Level Azure Assistants Through Config Overrides
The mock harness runs without CONFIG_REDERIVE_ENDPOINTS, so override
groups are never resolved there; cover the override path in the
resolution spec instead of e2e.
* fix: Return approved tool and generation error text instead of raw exceptions
* fix: Redact generation error text without the data-schemas helper
* fix: Redact credentials and emails from shown generation errors
* refactor: Move the Wolfram status policy into packages/api
* test: Fix the Wolfram probe constructor and jest summary match
* test: Match the jest pass count through color codes
* fix: Redact credentials a tool input error echoes from its arguments
* fix: Drop free-text fields from typed generation errors under a content policy
* fix: Keep only the code and numeric fields of typed errors under a content policy
* fix: Fence ACL Viewers and Surface Revocation Failures When Removing Shared MCP Servers
Account erasure and server deletion now enumerate users the view ACL names
directly or through a group, so viewers without a personal OAuth token are
fenced and disconnected too. Erasure runs the OAuth teardown in strict mode,
which clears local credentials and then fails when the provider refuses a
revocation, keeping the server as the retry anchor, and holds every user's
teardown fence until the server delete commits.
* test: Type the Revocation Failure Cleanup Fixtures
* fix: Renew Retained OAuth Teardown Fences Before Deleting the Server
A teardown lease lasts 15 minutes, so a large erasure could outlive the
first fences it holds. Leases can now be renewed by their owner, and
erasure renews every retained fence right before the delete, failing
without deleting when one lapsed and another writer took it.
* fix: Report Refused MCP Revocations Without Blocking Account Erasure
A provider that refuses revocation, combined with a viewer who signs in
again between attempts, could keep an erasure failing indefinitely. The
strict teardown now throws a coded MCPOAuthRevocationError after clearing
local state and handing over its fence; server removal collects those as
refusals, logs each user and token type whose grant may remain valid, and
proceeds. Local failures (token delete, fence, ACL) still fail closed.
* fix: Annotate the Revocation Error Code for Isolated Declarations
* perf: Bound client hygiene paths (lodash imports, timeouts, listener cleanup, upload concurrency)
* feat: Make client request timeouts configurable
* test: Cover the configured refresh deadline end to end
* feat: Rename client timeouts to client limits and expose upload concurrency
* fix: Keep the published refresh deadline for the next page load
* fix: Harden Timer Sweeps, SSE Writes, and Violation Counters
Guard SSE writes against ended or destroyed responses through one helper, catch and single-flight the job store and TTL cache cleanup timers, serialize in-process counter updates, cap the violation log, prune stale OAuth failure records, batch the active-job lookup, and count Redis keys with DBSIZE.
* refactor: Drop the redundant violation log entry copy
* refactor: Log single-flight sweep failures from the API package
* test: Cover active generation listing and client disconnect mid-stream
* refactor: Configure violation log retention and move title timeout into the API package
* feat: Configure OAuth failure retention through mcpSettings
* fix: Prune OAuth failures promptly under short retention
* fix: Mark the Escape that closes a Dropdown list as handled
A Headless UI dialog such as Settings closes on any Escape not already
handled, and the Dropdown list closed on Escape without marking it, so
one press closed the list and Settings together. The list now marks the
Escape it handles, so its container stays open until a second press.
* fix: Leave Escape to the container once the Dropdown list is closing
The list closes with a transition and Ariakit keeps it mounted until the
transition ends, so an Escape pressed right after a pick still reached
the list's handler and was marked handled, leaving Settings open.
The drawer collapsed on any Escape that reached the document, including
one a dialog above it had already handled, so a single press closed the
dialog and the drawer and the dialog could not return focus to its
trigger. The drawer now stands down when the Escape was already handled.
* refactor: Restyle Connected Accounts Settings Row
* test: Cover Connected Accounts States in Mock Scenarios
* test: Open Settings Through the Drawer on Mobile
useAdaptiveSSE and useResumableSSE now live in the chat package and own the
run, the stream id and how a stream re-attaches. The app supplies the services
a resumable stream runs on and the Assistants stream through a StreamHost,
mounted in Root beside the chat and steer hosts.
useChatHelpers now builds the pane contract from a ChatHost the app supplies:
its pane store, message query cache, turn builder, thread selection, abort
transport and settings. The stop path lives in its own module, its spec runs
in the package against a host with no app behind it, and the app mounts its
host in Root beside the steer host.
* refactor: Move the useChat Facade and ChatContext into @librechat/chat/react
The facade, ChatContext, the chat contract types and the resume request atom now
live in the chat package. The message cache subscription and the app's tool
outcome rules reach the facade through the contract, and useChatHelpers reads
its pane conversation through ChatSettings instead of the app store.
* fix: Key Cached Message Views on the Host's Tool Outcome Rules
Callers sized and layered Dropdown lists through ad hoc sizeClasses, while
DropdownPopup takes sameWidth, minWidth (capped to the room the list has)
and gutter. Dropdown now takes the same three, and the Settings dropdowns
move onto them and drop z-50 classes the dialog layer already overrides.
Dialog, DialogContent, DialogTitle and the other parts, and
DialogTemplate, are now exported beside their OG names as the same
components, so new code and the docs can use the plain names while the
existing call sites keep working unchanged.