* ✍️ feat: Authorize a Schedule Again in the Same Step That Edits It
Editing a schedule ended its grant, and the edit form had no way to make it again:
the owner saved, then had to open the authorization dialog and confirm. The edit
form now carries the same section as the create form, starting from the grant the
schedule has, and the edit writes the new grant with it.
* 🚧 fix: Fence an Edit's New Grant on the Grant It Was Decided Against
An edit that carries an authorization writes the grant with the schedule, fenced on
the schedule's edit generation. Consent writes do not move that generation, so the
edit could undo a revocation, or drop a pin or mark a run added, made after the new
grant was decided. The write now names the grant it replaces and is refused unless
that is still what is stored, untouched.
* ✅ test: Expect the Lifetime the Edit Form Now Starts At
* 🔂 fix: Check the Grant an Edit Replaces on the Decision's Final Read
The decision reads the stored grant twice and compared the owner's expected revision
with the first read only. A revocation landing between the two was then taken as the
grant to replace, and the edit's fenced write matched it. The final read is now held
to the same revision.
* 🪪 feat: Authorize a Schedule in the Same Step That Creates It
Where consent is on, a new schedule was created unauthorized and stayed exempt until
its owner edited it or the operator's deadline passed. The create form now asks what the
schedule may use, from the offer for its agent, and the schedule is created with its
grant in one write. A schedule created without a choice is marked as needing
authorization from the start.
The grant dialog's tool list and choice are split out so the form shows the same thing.
* 🔁 fix: Read the Offer Again When a Create's Authorization Is Turned Down
The create form kept the offer it first read. Once the server refused a choice made
from it, every retry sent the same refused digest. The form now reads the offer again,
keeps the ticks that still apply, and holds the create until the new offer is in.
* 🧭 fix: Check Readiness at Creation for the Tools the Owner Allowed
A schedule being created has no stored grant, so its readiness check covered every
MCP tool the agents select, including servers the owner left out. The grant is now
validated first and handed to the check, which covers what it allows.
An OpenAPI Action that needs its owner to sign in published the sign-in
prompt into the remote agent API response and waited for it, as MCP servers
did before #18058. The Action tool now receives whether anyone can sign in
for the run, derived from the execution context at tool loading, and refuses
to prompt when nobody can. A stored access token and a working refresh token
are unaffected.
#18377 made `delegated` the default of endpoints.agents.remoteApi.integrations.mode, so
on upgrade a run started with a personal API key lost its MCP tools until the operator
declared servers and the key's owner granted them. That is a surprise for deployments
that never asked for grants.
The default is `owner` again: a key run uses the MCP servers its owner can, as before
grants existed. `delegated` stays available as an opt-in. The config loader's warning now
fires only for an operator who sets `delegated` and declares no server to grant.
* ✨ feat: Support Model Spec Handoff Targets
* fix: Preserve Effective Config and Transcript Identity for Preset Handoffs
* test: Provide Query Client for Search Transcript Handoff Fixture
* fix: Match the Subagent Icon Display Contract
* 🦪 fix: Keep Model Discovery Credentials Out of Logs
* fix: Preserve Model Lists When Shared Token Cache Fails
* test: Seed Shared Token Cache With a Typed Fixture
* test: Expect Safe Model Discovery Error Metadata
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🗝️ feat: Store an API Key's MCP Grants on the Key, One per Agent
* 🧬 refactor: Let the Consent Service and Enforcement Act for Any Grant Subject
* 🗝️ feat: Check an API Key Run's MCP Calls Against the Key's Grant for the Agent
* 🗝️ feat: Put Remote API Runs Under Their Key's Grant, Behind a Config Switch
* 🩹 fix: Export the Key Grant Storage the Server Wiring Loads
* 🔌 feat: Let an Owner Grant an API Key Its MCP Access From Settings
* 🗝️ fix: Decide Key Grant Access, Mode and Kind of Key in the TypeScript Host
The agent-access check and the grant-mode lookup lived in the legacy route and service
files. The host now builds the check from an injected agent reader and permission
reader, and the key handlers resolve the mode from an injected configuration reader.
Each authorized call read the owner three times and their configuration twice. The host
now reads both once per call and shares them between the access check, the limits and
the offer; nothing is kept between calls.
A background worker rebuilds its request from the admitted record, which names the key
but not its kind, so a key issued to an integration lost its exemption and its channel
runs were refused. The host asks the key store when the request carries no key itself.
* 🔌 fix: Say When a Key Grant's Agent List Is Loading, Failed or Empty
The key grant dialog turned a failed or pending agent list into an empty picker with an
instruction to choose from it. It now shows a spinner while the list loads, an error
with a retry when it could not be read and nothing is cached, and a plain statement when
the owner has no agent the key could run.
* 🧪 test: Hold the Pin Fences on an API Key's Per-Agent Grants
* 🔌 fix: Offer a Key Grant for the Agents the Key Can Run, and Only for Personal Keys
The grant dialog's picker read the app's agent catalog, which lists agents the owner can
view. Running an agent with a key follows another rule: the agent is shared with the
owner for remote use, or is theirs to share. An agent shared only for remote use could be
run but not granted. A new list, GET /api/api-keys/agents, applies that rule to all
agents, and the picker reads it.
A key issued to an integration holds no grants but showed the MCP access button. The key
list now marks such a key, and the button is not shown for it.
* 🙋 feat: Let a Schedule's Owner Approve a Tool Before Each Use
* 🧪 test: Drive a Real Run Through a Schedule's Approval Pause and Resume
* 🙋 fix: Keep a Stored Ask-First Choice When a Run Can No Longer Pause
Where pausing became unavailable, the dialog hid the ask-first boxes and renewed the
grant without them, so a tool the owner approved each time started running unattended.
The dialog now starts from the stored choice either way and always sends it. Where a run
cannot pause it shows only the stored questions, with a note that those tools are refused
for now, and the owner can keep or drop them but add none. The server keeps the stored
questions for tools still allowed when a confirmation says nothing about asking, and
refuses only a new question where a run cannot pause.
* 🙋 fix: Say Why a Schedule Asks for Approval in the Reader's Language
The approval card showed an English sentence sent by the server as the request's
description. The server now sends a code, and the card maps it to a localized string.
Any other description is shown as sent.
* 🙋 fix: Never Offer Always Allow for a Tool a Schedule Asks About Each Use
Where the endpoint enables Always allow, a schedule's approval card offered it for a tool
the owner approves on each use. Choosing it stored a conversation allow the schedule
still overrode at the next use. The offer and the recheck at resume now take a predicate
for anything beyond the policy that asks on every use, and the schedule's grant supplies
it, so such a tool is neither offered nor stored.
* 🙋 fix: Let the Owner Ask First About as Many Tools as They Can Allow
The confirmation accepted up to 25,600 allowed tools per server but only 256 to ask
about, so a large grant could not be confirmed with every tool set to ask first.
* 🙋 fix: Keep a Tool Asking First When the Owner Allows Its Changed Definition
The dialog derived the ask-first boxes from the ticked tools. A tool whose definition
changed starts unticked, so its stored question was dropped, and ticking the tool again
confirmed it as unattended. The ask-first selection is now kept apart from the ticks,
starts from the stored grant, and is narrowed to the ticked tools only when the
confirmation is sent. The owner's edits to it hold only for the grant they were made
against, so a question added to a grant confirmed elsewhere is not dropped unseen.
* 📜 fix: Read a Child Thread's Messages a Page at a Time
The child messages route read a thread's whole stored history, and a
card previewing a running child triggers that read without anyone
asking. Every read is now one page (50 rows or 2 MiB, newest first)
with a cursor for the page before it, the followed pane keeps the pages
it has read and offers the earlier ones, and a client or server that
predates paging still gets a list.
* 📜 fix: Start a New Follower From Its Own Newest Page
A follower recreated over rows another one left in the cache kept them
without knowing where they began, so the earlier-messages control was
gone. It now places its first page itself and takes that page's
cursor.
* 🪪 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
* 🧭 refactor: Build One Execution Context Where a Run Enters
Each consumer of a scheduled run's identity (the host token resolver, the
scheduled MCP authority and the resource-bearer host) read the trigger body
and the restored job for itself, and the remote agent API carried a separate
`unattended` flag through tool loading.
The entry point now builds one frozen ExecutionContext: the chat controller
from the verified schedule trigger, the resume host from the saved job, and
the remote controllers from the run envelope. The initializer and tool
loading receive it as an argument. The schedule consumers project their
identity from it, and `unattended` is derived from it at the tool-loading
boundary. No client or model input sets any field.
* 🧭 refactor: Decide Whether a Run Is Unattended in Its Execution Context
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.
* fix: prevent Action writes from expanding MCP access
* fix: fence MCP grant snapshots before Action token cleanup
* fix: reject Action writes after concurrent agent deletion
* fix: enforce MCP grant provenance across saves and server replacement
* test: expect reserved MCP names after server replacement
* 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: Keep runtime MIME state out of file inspection
* fix: Preserve attachment-free inspection admission
---------
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.