* feat: Derive the Chat Pane's Heading, Footers, Project and Read-Only State in @librechat/chat
* refactor: Lay Out the Chat View Through the Package ChatScreen
* feat: Add a Hint Variant to Button
* refactor: Move the Ask Question Popover Into the Chat Package
* fix: Keep the Ask Hint's Hover Ink
* fix: Return Focus to the Draft When the Ask Chevron Moves the Question
* test: Exercise the Real Composer Overlay Hook in the Ask Popover Spec
* refactor: Move the Prompts Popover Into the Chat Package
* test: Check Dialog Focus Without Querying the Hidden Composer
* fix: Keep the Search Typed After the Slash When the Prompts Popover Opens
* refactor: Move the Subagent Transcript Into @librechat/chat Behind a Subagents Host
SubagentActivity, its scroll surface, content, status and guidance history
move into @librechat/chat/components, and ScrollToBottom moves into the
package with them. A new SubagentsHost carries what still lives in the app:
the content-parts and steer renderers, the animated jump-to-latest control,
and the read of a shortened guidance receipt, which stays an app query. The
prompt preview reuses renderMarkdown with a new codeExecution flag, and the
task content scope becomes a plain package context.
* refactor: Draw Content Parts Through the Message Parts Host
renderContentParts moves from SubagentsHost onto MessagePartsHost as the one
content slot, typed as ContentPartsSlotProps: the transcript fields plus the
optional row fields message rows pass. The app fills it through a registered
renderer, so the host module does not import the content stack, and omitted
row fields keep an assistant reply's defaults.
* refactor: Let the Content Parts Slot Carry Sparse Content
Main message rows keep holes at streaming and parallel indexes, and part indexes depend on those positions, so the slot's content keeps undefined entries as ContentParts already accepts them.
* test: Exercise the Real App Renderers in the Host Registration Spec
The transcript host test now renders the app's ContentParts and SteerPart under the providers they read, so the registered content renderer and steer slot are proven against the real components; only the receipt request stays mocked.
The chat surface context, the durable task panel hook and the event subagent
activity group move into the package. The surface context and read hooks live
apart from the provider that binds the panel atoms, so the components entry
loads no module-scope atom. Share state and the inline agent avatar reach the
package through two new MessagePartsHost members, useShare and
renderAgentAvatar, which the app fills from ShareContext and renderAgentAvatar
with the same options as before.
* refactor: Move Subagent Authors Into @librechat/chat Behind a Message Icon Slot
* fix: Register the Message Parts Host From the App Entry
* test: Give the Consumer Spec's Messages Host the Icon Slot
* 🔎 fix: Keep Scoped Package Frames Out of the Log Email Redactor
The log redactor read node_modules/@scope/pkg/... as an address and replaced
whole stack frame locations with [REDACTED_EMAIL], in file, console and
OpenTelemetry output alike. An @ between path separators now names a scoped
package; addresses beside such frames are still masked.
* 🪪 feat: Name the Build and Loaded Config on OpenTelemetry Records
service.version now defaults to the image's BUILD_COMMIT ahead of the npm
package version. Each successful librechat.yaml load records a short digest
of the parsed file, which exported log records and request spans carry as
librechat.config.digest, and applies telemetry.stackTraceLimit to
Error.stackTraceLimit; unset keeps the process default.
* fix: Publish telemetry settings with the accepted base config
* fix: Initialize process settings before adopting cached config
* fix: Preserve runtime settings when cache writes are refused
* fix: Keep telemetry identity local and propagate Redis write errors
* fix: Partition merged config caches by the local base
* fix: Keep config cache failures recoverable
* test: Verify cache recovery contracts with typed fixtures
---------
Co-authored-by: Lia <lia@librechat.ai>
* refactor: Move Ask State, Approval and File Previews, and Diff View Into the Chat Package
* fix: Point the HITL Edits Spec at the Moved Approval Preview
* refactor: Add a Command Popover with a Host Windowed List Slot
* refactor: Move the Mention Popover Into the Chat Package
* test: Cover the Mention Popover Combobox in the Mock Harness
* style: Draw the Mention Popover Like the Prompts and Skills Popovers
* test: Walk to the Endpoint Row Before Drilling Into Its Models
* test: Drill Into a Plain Custom Endpoint in the Mention Scenario
* refactor: Share the Command Character Helper From the Chat Core
* refactor: Move the MessagesView Root Into @librechat/chat
* fix: Read Submitting State From the Chat Contract and Complete the Test Hosts
* test: Tell the Scroll Control Apart From the Rail's End Marker
* feat: Add a ChatPane Layout to @librechat/chat
* refactor: Lay Out the Chat View Through the Package ChatPane
* fix: Keep the Welcome Layout While a New Session Loads
* style: Sort the Chat View Imports
* refactor: Move the Fork and Feedback Actions into @librechat/chat
Fork reads the viewer's fork defaults and starts the fork through two new
MessagesHost members, keeping its toasts and rate-limit copy in the package; the
app supplies them from its settings atoms and the fork mutation, whose own
callbacks open the copy so a row that unmounts mid-request still lands there.
Feedback moves as is. @ariakit/react becomes a peer dependency of the package.
* test: Cover Fork and Feedback in the Mock Harness
* chore: Sort MessageRow Spec Imports
* fix: Resolve Fork Labels Per Call and Pin the Fork Toast Locator
* test: Give the Consumer Spec Messages Host the Fork Members
* fix: End an Answer's Claim Only When Its Generation Ends or a Newer Pause Replaces It
* fix: Match a Stop to the Answered Generation by Its Record When No Timestamp Names It
* fix: Date an Undated Answer by the Pause a Later Source Reports
- Let agents use Langfuse prompts by production label or pinned version,
with the existing permission and usage checks.
- Add a configuration switch, disabled by default. Preserve saved links
while disabled, without resolving them or falling back to inline text.
- Share source-specific production and exact selections across agent
links and the prompt service. Reject source mismatches.
- Add revision lists for the Agent Builder version picker. Resolve
Langfuse instructions on each initialization without caching.
- Improve disabled and unavailable states and test source changes,
revision loading, and permission failures.
* 🥐 chore: Standardize Bun-First Workspace Typechecks
* fix: Preserve Bun 1.4.3 Checker Compatibility
* chore: Pin Bun 1.4.4 for Local and CI Typechecks
---------
Co-authored-by: Lia <lia@librechat.ai>
* refactor: Move Composer Input Controls and Shortcut Helpers Into @librechat/chat
* test: Cover Interrupt Now on a Queued Composer Row
* test: Read the Moved Escalate Button in the Composer Color Guardrail
* refactor: Reuse the Core Draft Check for the Send Button
* fix: Point the Acceptance Harness at the Moved Composer Shortcuts
* perf: Serve JWT Bearer User Lookups From the Auth User Cache
* perf: Batch Agent Permission Reads on the File Access Path
* perf: Remember a Loaded Google Service Key Across Endpoint Config Reads
* perf: Run Independent Startup, Tool, Skill and Erasure Reads Concurrently
* fix: Drop JWT User Cache Writes That Race a User Mutation
Confirm each cache write with a second read and evict when the user changed,
so an in-flight lookup cannot repopulate an entry a credential change just
evicted. The cache mode now arrives through the loader dependencies.
* refactor: Move Agent Skill Access Reads Into packages/api
The chat-completions and Responses controllers call loadSkillAccess instead of
orchestrating the three reads in CJS. The preview route spec mocks the batched
file access helper the middleware now calls.
* test: Cover Agent File Access, JWT Bursts and Remote Skill Reads End to End
* fix: Serve a Cached JWT User Only While Its updatedAt Is Current
A cache hit now reads the stored updatedAt and deletion fence instead of the
fence alone, so a document cached from a read that raced a user mutation is
never served, even when the write landed after that mutation's eviction.
* refactor: Move Startup Migration Checks Into packages/api
* refactor: Inject the Startup Migration Checks Instead of Mongoose Models
* fix: Serve Cached OpenID Users Only While Their updatedAt Is Current
Moves the freshness check into getCurrentCachedAuthUserDoc and uses it on the
OpenID bearer path as well as the local JWT one, so a document cached from a
read that raced a credential or role change is never served there either.
Fixesberry-13/LibreChat#432
* fix: Compare Authorization Fields on Every Auth Cache Hit
updatedAt has millisecond resolution, so the freshness read also compares the
token retirement stamps, role, tenant and two-factor state.
* fix: Annotate the Auth Freshness Projection for Isolated Declarations
* perf: Reuse the OpenID Cache Freshness Read for Deletion Admission
A cache hit already proved the deletion fence is clear, so only users read from
the database take the separate fence query.
* refactor: Keep the OpenID Cache Freshness and Fence Decisions in packages/api
* test: Exercise JWT Cache Freshness Against Real User Methods in MongoDB
* fix: Stamp the JWT User Lookup So the Cache Write Fence Applies
* fix: Reload a Google Service Key File When It Changes or Disappears
The availability check remembers a loaded key only while the file's mtime and
size are unchanged, and fetches URL sources every time as before.
* fix: Recheck a Service Key File After a Permission Change
* refactor: Move resume-on-load and the stream steer state into the chat package
* refactor: Drop the useSessionEffects bridge now that resume on load lives in the chat package
* 🚤 fix: Keep Host Tool Loading Independent of Worker Status
* fix: Classify Workspace Tools at the Agent Boundary
---------
Co-authored-by: Lia <lia@librechat.ai>
splitMarkdown and editableParts move to packages/chat/src/core/parts and are
exported from the package root, so hasEditablePart is available to package
components. The micromark and mdast packages the splitter parses with become
peer and dev dependencies of @librechat/chat at the client's ranges, kept
external by the build, and the package jest config transforms them like the
client's does.
* 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.