* 🗳️ feat: Let a Schedule's Owner Choose Which MCP Tools It May Use
An enrolled scheduled chat could call an MCP tool only when an operator had
listed it in config as read-only, pinned to a hash of its definition. Whether
a tool is safe to run with nobody watching is the owner's call, and read-only
is a poor proxy for it.
The consent offer now lists every MCP tool the agent graph selects on servers
whose recipient the operator declared. The owner ticks servers and tools, and
the grant stores only those. A tool is allowed at run time when the grant
lists it for the calling agent and that agent still selects it; anything else
is refused. Selecting another tool later no longer invalidates the grant.
The operator `mcpConsent.readOnlyPolicy` list is retired: the loader warns
when it is still configured. The stored grant keeps its shape.
* 🗳️ fix: Check the Server Box Only When Every Tool Is Allowed
The shared Checkbox has no partly-selected appearance, so a server with some
tools ticked showed its "allow all" box as checked.
* 🧪 test: Check the Live Catalog at the Manager Boundary Without the Retired Pin
* 🧭 fix: Check Readiness Against What the Owner Allowed, Not What the Agents Select
* 🧭 fix: Turn Away a Tool the Owner Left Out Without Failing the Run
* 🧭 fix: Load Only the MCP Tools the Owner Allowed in a Scheduled Run
* 🪪 feat: State a Turn's Shape in Its Created Frame So an Observer Applies It as Its Sender Does
* 🪪 test: Give the Request Controller Specs the Turn Helper Their Mocks Left Out
* 🪪 fix: Name the Reply an Edited or Continued Turn Starts From, and Build on It, Not the List's Tail
* 🪪 fix: Put a Plain Turn's Reply Last in the List, Where Its First Step Builds
* 🧵 feat: Open a Background Subagent's Thread as a Conversation in the Panel
* 🧵 test: Keep the Subagents Host Spec and Add the Follow Cases Beside It
* 🧵 fix: Give the Followed Thread Its Panel Gutter and Assert It in the Browser Specs
* 🧵 test: Do Not Wait on a History Fold That Closed Before It Was Clicked
* 🧵 test: Draw a Steer the Child Took Before the Panel Opened Where It Was Taken
* 🧵 fix: Fall Back to the Durable View Only on a Confirmed Missing Stream or History
* ↩️ feat: Show Guidance a Followed Subagent Has Not Taken Yet, With Its Withdraw
A subagent child thread is reachable only through the parent the requester
owns: /api/messages/<threadId> answers 404 by design, and the durable thread
view sends a bounded projection, not messages. A chat pane pointed at a child
thread therefore had nothing to load.
GET /api/convos/:parent/subagents/:thread/messages returns the thread's rows
with the conversation route's projection and tool-call previews, after the
thread view's parent, lineage and tenant check. An event thread's input is
the raw payload of an external event, so its row is sent with empty text, as
the thread view already does. A second route reads the full tool call behind
a preview, reusing the conversation route's reader.
* 🗓️ feat: Align Balance Resets to Fixed Calendar Boundaries
Add balance.refillAnchor, an ISO timestamp with a fixed offset that periods align to: a refill or reset is due at the first anchor-plus-whole-intervals boundary after the last one, so every user resets at the same moment (e.g. each Monday at 00:00 UTC, or the 1st of each month). Omitted, periods keep running from each user's last refill. The gauge names the reset date for anchored periods.
* 🧭 fix: Clear a Removed Reset Anchor During Admission and Shape Balance Responses in TS
A policy built without a record now always carries refillAnchor, null when unset, so removing the setting clears a stored anchor instead of looping admission until its retry bound throws. Balance response shaping moves to toBalanceResponse in packages/api; the CJS controller delegates to it.
* feat: Add Gemini Hydrogen Model Support
* fix: Restore Google History For Reachable Agents
* fix: Preserve Mixed Google Signature History
* refactor: Inject Google billing configuration at application boundary
* fix: Preserve Call Signatures From Unsupported Google Output
* chore: Use Released Agents SDK 4.2.5
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🧽 fix: Replace an Abandoned Summary Attempt's Text When Its Retry Streams
Summary deltas append to the in-flight summary part. Once the agents SDK
streams them while the provider is still responding, an attempt that is
then abandoned (a retry, a fallback provider) has already put text in the
part, and the next attempt's deltas would follow it until the completion
event replaced the lot.
A delta may now carry `reset`: the part's content is replaced instead of
extended, and a reset with no content empties it. The part keeps its slot
and stays in flight. Deltas without the field behave as before, so this
is inert until the SDK sends it.
* 🦿 chore: Bump Agents SDK to 4.2.3
4.2.3 dispatches each summary delta while the provider is still responding
and marks the first delta after an abandoned attempt `reset`, which the
chat reducer now honors. It also stops sending reasoning as summary text,
which is where the `incoming.content is not iterable` handler errors
during compaction came from.
The release changed only the SDK's own dev dependencies and overrides, so
the lockfile moves the package's version, URL and integrity and nothing
else.
* 🫀 feat: Let a Job Owner Keep a Silent Run Alive
A generation job's idle clock advances only with emitted chunks, so a run that
works without output for 20 minutes is reaped while it is still alive.
touchJob refreshes the idle clock and the storage lifetimes an append would
have extended, fenced on the generation epoch and limited to the replica that
owns the runtime.
* 🧶 refactor: Share One Fold From Child Frames to Content Parts
readSubagentContent folded public child frames into content parts inline.
The fold is now a synchronous function a second caller can use, so a frame
can be folded and published without yielding in between.
* 🏷️ feat: Mark the Generation Job of a Background Subagent Task
Job metadata gains subagentTaskId and subagentParentConversationId, set only
by the subagent task store. A marked job is a child-thread job, so it stays
out of the active chat list, and isBackgroundChildJob tells it apart from an
event-bound child, whose job the chat controller owns.
* 🧵 feat: Run a Background Child as a Resumable Generation Job
createChildGenerationHost opens a generation job keyed by the child thread id
and feeds it the child's public step frames. Text deltas that queue behind a
slow write merge instead of dropping, the terminal state is claimed before the
caller persists and the final event is published only afterwards, and no
stream failure can fail the child: the run and its result carry on without a
live view.
* 🪢 feat: Stream a Background Child Through Its Own Generation Job
The subagent task store takes a childGenerations dependency. Once a child's
thread and input row are durable it opens a job keyed by the thread id, feeds
it each public frame, refreshes its idle clock on every lease renewal, and
settles it around its own persistence, so a reader sees the final event only
after the result row exists. A cancel, a failure and a job aborted from
outside all end both the child and its stream.
endpoints.agents.subagentActivity.generationJobs turns it off. A stream that
cannot be opened or written never fails the child.
* 🔌 feat: Give the Server's Task Store Its Child Stream
The host wiring builds the child generation host from the generation job
manager and hands it to the subagent task store, so a background child's
stream is reachable in the running server.
* 🚧 fix: Refuse Chat Abort and Steer on a Background Child's Job
The chat abort route saves a user row and a partial response and upserts the
conversation, and the steer route queues text only the chat controller drains.
Both authorized on the job's owner alone, so either could act on a background
child's job and write a chat-shaped history into a view-only thread, or accept
a steer nothing would ever apply. Both now answer 409 for a job the subagent
task store owns; the child is stopped and steered through its control
endpoint.
* 🧹 fix: Evict a Finished Job Before a Live One at Capacity
The in-memory job store made room by deleting its oldest job whatever its
status, so a full store could end a run somebody was still waiting on. It now
takes the oldest finished job first. Also covers a job manager that shuts down
while a background child runs: the child still persists its cancellation.
* 🛰️ test: Read a Background Child's Stream From Another Replica
Against real Redis: a second replica resumes with everything the child has
streamed, receives only newer deltas live, then the final event; a child that
streams past the manager's 5,000-event early buffer before anyone attaches
still resumes whole on both replicas; and the owner's touch keeps a silent
child's job alive.
* 🧽 chore: Sort Imports in the Child Stream Files
* 🧪 test: Expect the Child Stream Lever in the Activity Defaults
* 📜 feat: Store What a Background Child Streamed as Standard Content (#18173)
A child's result row carried its text and a bounded activity projection, not
the content parts every agent message stores, so a reader had to rebuild the
child's output from the projection. The row now also carries what the child
streamed, on completion, failure and cancellation, in the standard shape.
endpoints.agents.subagentActivity.generationContentBytes bounds it (4 MiB by
default, 0 stores none). Content over the bound is left off, so the row always
fits and keeps its text and projection as before.
* 🛟 fix: Keep a Stalled or Failing Child Stream From Touching Its Child
Four ways the stream could still reach the run it only observes. A frame that
could not be copied threw into the child's own progress report. A job store
that never answered held the child's start behind job creation and its result
behind the terminal claim. And a stream that had stopped being written was
never ended, so its job read as a live child for twenty minutes after the
child finished.
Frames are now copied defensively, opening and settling are bounded, a job
that arrives after its child stopped waiting is ended, and a detached stream
is still touched and still settled with its full final event.
* 🧯 fix: Let a Child Stream Observe Its Run Without Ever Stopping It
Review round 1.
A failed Redis append retires the job's runtime by aborting its controller,
and the child stream forwarded every abort of that controller to the task
store as a cancellation. A stream-store outage therefore stopped the child's
model and tool work. The stream no longer signals the child at all: deletion,
shutdown and the control endpoint already stop a child through the task
store, and an aborted, reaped or retired job now only ends the live view.
The in-memory store's capacity eviction preferred any terminal job, including
one that still owed persistence, a host action, a schedule reconciliation or
a provider drain. Those are no longer treated as finished.
The chat abort route's refusal for a background child's job moves out of the
CJS route into createBackgroundChildAbortGuard, registered ahead of it.
* ♻️ fix: Replace a Dead Background Child's Job on Its Thread
A background child's job outlives an owner that crashed, or a settlement that
could not reach the store, for up to twenty minutes. A continuation of the
thread in that window was refused its own stream, because the dead job still
read as live. The caller of open holds the thread's lease, so a background
child's job still marked live there has lost its owner: it is replaced and its
readers are told to refetch. A live job that is not a background child's, such
as an event-bound child paused for approval, is still never replaced.
* 🧱 fix: Fail the Abort Guard Closed and Budget Content Against the Whole Row
Review round 2.
The abort guard passed the request on when its job lookup failed, so a
retried lookup in the route could run the chat-shaped abort on a child the
guard never saw. A failed lookup now ends the request at the error boundary.
A child's streamed content was checked against its own limit only. A result
row also carries the text and the transcript, so content that passed the
limit could push the document past MongoDB's 16 MiB and turn a successful
child into a failed one. The content is now the optional field: it is left
off whenever the row's large fields together would exceed the budget.
Also accounts for the guard's job read in the two abort route specs that
sequence it, and gives the limiter spec's api mock the guard.
* 🪶 refactor: Settle a Child Stream Once and Fold a Frame It Cannot Copy
The task store settles a child's stream on its outcome path and again in its
cleanup. The second call made another terminal claim that could only lose;
the stream now remembers that it claimed and only persists. A frame that
cannot be copied is still folded from the original, so the stored content
stays whole when the stream detaches over it.
* 🧪 test: Cover the Child Stream's Failure Branches and the Content Fold
The change-risk report showed the stream's fail-open branches untested: a
terminal claim that lands after its wait, a claim or a final publish that
throws, the settle timeout, the backlog limit, and a rejected touch. Each now
has a case. The shared content fold gets direct cases for a closed step, a
commentary phase and an applied steer.
Add theme-selected welcome backdrops and focus the composer when the welcome greeting settles. Preserve popup and touch-device focus behavior, with acceptance coverage for themes, focus, and composer layout.
- perf: Stop Shipping the Node Crypto Polyfill to the Browser
- perf: Keep the Query Devtools Out of the Boot Chunks
- perf: Load Side Panel Tabs When They Open
- perf: Keep the RE2 Engine Out of the Browser Bundle
- perf: Load KaTeX and highlight.js Only for Math and Code
- test: Cover Code That Loads on First Need
- fix: Apply Loaded Math and Highlighting Whatever the Load Trigger Matched
- test: Assert Rendered Formulas Without Assuming Display Math
- fix: Retry a Failed Math and Highlighting Load While Mounted
- fix: Always Load Highlighting Where the Language Is Guessed
- fix: Register the PII Sizer Wherever Config Loads
- fix: Load Preview Math From the Filled-In Prompt and Keep Dollar Signs Literal
- test: Register the PII Sizer Where the Filter Harness Validates Config
- test: Preserve Side Panel Layout During Lazy Loading
* 🎚️ fix: Resolve Parameters for Bare Bedrock Claude Model IDs
A Bedrock model listed by a bare Claude ID, the form used when the model ID
maps to an inference profile, carries no `anthropic.` segment. `getModelKey`
read the provider only from the first two dot-separated segments, so the
settings key became `bedrock-<model>` and matched nothing: the Parameters
panel, the agent builder's model parameters and the composer's reasoning
control all came up empty.
Key a provider-less Bedrock ID that contains `claude` as Anthropic, the same
family test `bedrockInputParser` already applies. Provider-qualified IDs and
bare IDs of other families are keyed as before.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* fix: Preserve Stored Bedrock Agent Request Fields
* test: Validate Bedrock Agent Request Round Trips
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
Co-authored-by: Lia <lia@librechat.ai>
* 🔑 fix: Replay a Request Rejected for a Superseded Bearer Instead of Refreshing Again
A burst of requests leaves with one bearer. The first 401 starts a refresh and the
rest share it only while it is in flight: a 401 delivered after the refresh settled
found no recovery running and started a second one, although the session had already
recovered and the response described a bearer that was no longer in use.
Compare the bearer the rejected request carried with the current one. When it has
been replaced and no recovery is running, replay the request with the current
bearer. A replay that is rejected again carries the current bearer, so it takes the
ordinary refresh path. The fetch transport follows the same rule.
This is what failed "recovers from an expired bearer during app bootstrap without
redirect looping": 9 of the 21 bootstrap 401s were delivered after the first
recovery finished, so the test counted a third refresh and a second recovery cycle.
* 🔊 test: Play Decodable Audio and Hold the Reply's Button in the Read-Aloud Replay Scenario
The fixture answered the speech request with four bytes the MP3 parser rejects, so
every playback failed. A failed playback cancels its request, and the audio is
cached only once the response has been read to the end, so the replay was served
from memory only when the response finished before the decoder gave up. When the
decoder won, the replay issued the second request the scenario forbids.
The test also located the button by its name. While a message is read aloud its
button is named "Stop", so the locator resolved to the user message's read-aloud
button: the wait for playback to end passed at once, and the second click could
land on a different message.
Serve a third of a second of silent MPEG frames so playback succeeds and ends on
its own, and locate the reply's button by its test id so the wait and the replay
address the same control.
* 📅 test: Wait for the Schedule Save to Land Before Reloading
The edit scenario clicked Save and reloaded the page in the next step. A reload
discards requests still in flight, so when it won the race the PATCH was cancelled
before the server answered and the edited schedule never appeared. Await the PATCH
response, and require it to succeed, before reloading.
* 🔗 fix: Grant a Legacy Shared Link's Permissions Once When Its First Views Race
The share page requests a link's config and its messages together, and each request
migrates a legacy link on the way in. Both find no grant and both write one. The
grant is an upsert matched on the principal and resource, which no unique index
covers, so the two writes inserted two rows: a second public entry, a second owner
entry, or both.
`grantPermission` now accepts the `_id` to give the entry if the grant creates it.
The migration derives that id from the link and the principal, so the second insert
collides on `_id` and is replayed as an update of the first entry. It holds across
processes because the database enforces it. Grants that pass no id are unchanged.
"manages a shared-link snapshot and preserves legacy public links through runtime
migration" asserts one public entry and saw two.
* 🔑 fix: Refresh When a Replayed Fetch Is Rejected With the Current Bearer
The fetch transport replayed a request whose bearer had been superseded and
returned whatever came back. A second 401 there means the current bearer is not
accepted either, which is the case the refresh exists for, and the axios path
already handles it that way. Replay first, then fall through to the ordinary
recovery when the replay is rejected too.
* 🔗 refactor: Derive a Unique Grant's Entry Id in the Data Layer
`AccessControlService.grantPermission` took the entry's `_id` as a Mongoose
`ObjectId`, which put a storage type in an exported `packages/api` signature. The
service now takes `uniqueEntry: true`, and `grantPermission` in data-schemas
derives the id from the principal and resource it already matches on. A caller can
no longer pass an id that names a different grant.
* fix: Advance Slack Account Linking in Place
* fix: Narrow Slack Reply Transport Contract
* fix: Make Slack Link Reply Updates Monotonic
* fix: Clear Invalidated Slack Link Cards After Delayed Writes
* fix: allow members to connect agents to installed Slack workspaces
* fix: clarify Slack destination assignment actions
* fix: align Slack assignment status with destination heading
* fix: explain Slack agent assignments in terms of the connected bot
* fix: separate Slack connection setup, management and confirmation
* fix: name replaced agents only when the member can view them
* perf: avoid redundant Slack assignment identity lookups
* fix: Allow Admins to Remove Disconnected Slack Workspaces
* fix: Use Workspace Status Chips and One Confirmation Action
* fix: Confirm Workspace Removal in a Stacked Dialog
* fix: Align Confirmation Cancel Action to the Left
* 💬 feat: Configure Slack Connections in the Agent Builder
* fix: Bound Channel Credentials to One Activation Attempt
* fix: Scope Channel Completion to Its Dialog Lifetime
* 🧷 fix: Promote Unapplied Steers to Durable Queued Turns at Run End
A steer the server accepted (202) but the run never applied was handed back
in FINAL as `pendingSteers` and re-owned by the browser as a tab-local queued
message. A reload, closed tab, or a predecessor race before the drain lost it.
At terminal publication, a normally completed run now promotes such steers
into server-owned agent queued turns (parent: the ended response, epoch: the
ended generation's createdAt, chained behind any turn already queued against
that epoch). The job store hands the parked copy over atomically
(`promoteSteerLeftover`: parked item removed, receipt settled `recovered`), so
status recovery, lost-ACK retries and legacy recovery starts cannot queue the
same words again. FINAL reports the receipts in `promotedSteers`; the client
adopts them as server rows instead of converting the steer locally.
Promotion is opt-in per steer (`promoteLeftover`, sent only by clients that
adopt receipts and only for steers with no tab-only context), so older
clients keep the legacy path unchanged, and older servers simply never
report `promotedSteers`.
* 🔒 fix: Settle a Promoted Steer's Hand-Off at Admission, Not Only at FINAL
The job-store hand-off of a promoted steer now returns an outcome and stamps
the receipt with the owning queued turn, so it is idempotent for that turn.
The queued-turn resolver repeats it before admitting a promoted turn: it
completes a hand-off a crash interrupted, and cancels the turn when the
parked copy was discarded or recovered elsewhere, so the words never run
twice. At FINAL, a row whose hand-off was refused and whose retirement cannot
be confirmed is withheld from `pendingSteers` and left for that admission
check. The conservative reconcile frame keeps `promotedSteers`, and the
client adopts it there before sweeping local chips.
* 🔏 fix: Give Promoted Steers Durable Ownership, Their Run's Queue Lineage and Approval Mode
A turn promoted from an unapplied steer now records its source on its own
row: the steer's ids, the generation that accepted it, and a mark set only
once the job store handed the parked copy to that row. Admission runs a
promoted turn on that mark or on a hand-off the job store confirms now;
without proof (the store's evidence expired, or the host cannot ask) the
turn is held for review instead of running.
- Hand-off replies that are lost no longer cancel the row. The row stays as
the client's handle and its admission settles ownership, so a committed
hand-off can no longer leave the steer with no runnable copy.
- A replayed promotion never hands the parked copy to a row that was
cancelled or failed.
- Promoted turns join the queue lineage of the generation that accepted
the steer, so a sibling still queued behind that run no longer strands
them with a predecessor mismatch.
- The steer request carries the sender's code approval mode onto the
promoted turn; an unreadable mode keeps the steer on the client path.
- A steer whose quotes its owner stripped stays on the client path.
- The queued-turn receipt names the promoted steer by both ids, and the
receipt list retires a pane's local copies even when it missed FINAL.
* 🚧 fix: Fence Promoted Turns to Workers That Prove Steer Ownership
A promoted row without an approval mode was published under the v1 queued
turn capability, so during a rolling deploy a worker that predates the
ownership check could claim it and run an unsettled row while the parked
steer was still recoverable elsewhere.
Promoted rows now publish under a new agent_queued_turn_v3 capability and a
v3 delivery identity, always reserved before insertion. A replica that
projects an older version can neither publish the reserved delivery nor
claim it, and enqueue refuses a promoted row without a reservation.
* 🪦 fix: Keep a Dead Promoted Turn Answering for Words It Held
A pane that learns of a promoted steer from the receipt list dropped the
mapping for every dead row. A row quarantined as ADMISSION_INDETERMINATE can
still settle as admitted, and a row that died after it was proven the sole
owner of the words is their only surface, so in both cases the pane kept a
chip whose recovery could never run.
The receipt now says whether the turn owned its steer's words, and a dead
receipt keeps answering for them when it did or when its admission is
indeterminate. A replayed promotion applies the same rule to a settled row.
* 🧾 fix: Find Promoted Turns by the Steer a Pane Holds, Join Root Lineages, Redact Hand-off Errors
- A promoted turn's request id is now derived from the client steer id, and a
pane asks for the receipts of the steers it still holds a local copy of
(recovery rows and failed chips). A promoted turn that already ran is only
listed when asked for by name, so a pane that missed FINAL now finds it
and retires its copy. A client steer id too long to key a queued turn is
not promoted.
- The lineage lookup includes a generation admitted from a root queued turn,
which has a parent and no epoch. The promoted turn joins that lineage
without an epoch instead of opening a second one.
- A failed hand-off at admission reports a fixed message. The job store's
own error text stays out of the dead-letter record a client can read, and
promotion logs carry safe error metadata instead of error text.
* 🔢 fix: Ask for Held Steers First Under the Receipt Lookup Limit
The receipt list answers for at most 100 request ids, and a pane's server
rows were listed ahead of the steers it still holds, so a full server queue
could push every held steer out of the request. A promoted turn that had
already run was then never found.
Held steers now come first. An active server row is listed whether or not
it is asked for, while a settled promoted turn is found only by name.