* feat: Attach or leave a workspace on a saved chat
A saved chat that recorded running without an attached environment could
never take one: `without_attached` is sealed for the life of the chat, and
the only transition was a move between attached environments. Switching an
existing chat to a coding agent therefore ended in a composer that could
send but never reach files or commands. A chat sealed to a machine that went
offline had the opposite dead end: Send stayed disabled with nothing on
offer but a reconnect hint, and the "Move the chat to continue without it"
copy promised a request the server rejected as `invalid`.
One transition mechanism now covers all three directions. `from` still
repeats the persisted decision, so a stale view cannot replace a decision it
has not seen, and only a decision the chat actually recorded can move:
- attach, from a recorded `without_attached` onto the environments its
agents use, with each target workspace revalidated on its worker;
- detach, an empty `to`, which clears the selections without polling the
machine the chat is leaving;
- move, unchanged, including its refusal to switch the workspace of an
environment the decision already covers.
The composer keeps the control visible while a chat runs without a
workspace, so that state is named and reversible, and offers "Continue
without workspace" whenever a sealed machine stops being usable. History is
untouched and no file is copied.
A send now also records the decision it was submitted under on its own
conversation. The server seals that pair for the rest of the chat, so a chat
that became saved mid-run held none while the stored one was already sealed:
the composer re-derived an agent default the seal refuses and reported
"Choose workspace" with Send disabled until the page was reloaded.
* 🎨 style: Format the Workspace Transition Hook Tests
* fix: Never seal a partial workspace decision, and gate the new directions
Two review findings on the transition mechanism.
A transition replaces the sealed decision whole, and the next turn resolves
every environment or none. The move path could not truncate before, because it
was offered only in `choose` state, which `aggregateState` reaches only when no
environment is unavailable, unsupported or missing: every environment was then
either carried over or selectable. Widening the gate to `!canSubmit` so an
unreachable machine could be left behind broke that invariant, and an
environment nothing can cover would have been dropped from a decision the
composer then sealed, blocking the next send and needing a second transition to
escape. A nonempty transition now requires every environment to be retained or
selectable; when one cannot be, only leaving attached execution is offered,
which is the escape.
The move protocol version becomes 2. Attach and detach travel on the same
owner-authorized endpoint as the move, so a client built against this change
would otherwise offer both to a deployment that only implements moves, where an
attach comes back `locked` and an empty target set `invalid`. The client already
compares the advertised number against the constant, so the bump is the gate.
`conversationMoves.enabled` still decides whether an owner may replace a sealed
decision at all.
* fix: Keep v1 moves working, and take the conversation updater from its owner
Two review findings on the previous head.
Bumping the move protocol wholesale made the client's exact-version check treat
a replica still advertising 1 as supporting nothing, so an attached chat whose
agent moved to another machine lost the relocation that replica already served
-- the previous head's own compatibility test pinned that regression. The
protocol is now two constants: version 1 is the move between attached
environments, version 2 adds attaching an environment to a chat that recorded
running without one and leaving attached execution behind. The server
advertises the highest it implements and the client keeps every lower
capability, so a v1 replica keeps its move while attach and detach wait for the
version that serves them. Where an environment cannot be covered and leaving is
not served either, no transition is offered and the composer reports the state.
Recording the submitted decision had made this hook a second Recoil writer of
the conversation atom, widening the surface that migration has to convert. The
host that owns the atom already holds its setter, so the hook receives it
instead of reaching through `~/store`.
* fix: Advertise attach and detach beside the move instead of above it
Raising the move protocol to 2 kept a client and server of the same build in
agreement, but not the two builds a rollout actually runs at once. The deployed
client compares the advertised number for equality against its own constant of
1, so a server advertising 2 tells every client already loaded in a browser that
moves are unsupported, and an attached chat whose agent changed machines loses
its relocation until that tab reloads.
The move version therefore stays 1, exactly as before this branch, and the two
new directions are advertised on their own field:
codeEnvironmentMoveVersion: 1 // move between attached environments
codeEnvironmentTransitionVersion: 2 // attach an environment, or leave one
Both come from `conversationMoves.enabled`, since all three are one owner
replacing one sealed decision. A client that predates this capability reads only
the move version and keeps working; a client that has it offers attach and
detach only where the second field appears, so it never sends a replica an
attach it refuses as `locked` or an empty target set it calls `invalid`.
* fix: Hold a send while a workspace decision is being replaced
Confirming an attach left Send enabled. The composer disables only the
workspace menu while the request is in flight, so a turn submitted right after
the confirmation started under the decision being replaced: it ran without the
workspace its owner had just chosen, and the replacement still landed, because
the stored decision the compare-and-swap expects was unchanged. The chat then
reported an environment its last turn never used, and nothing said so.
The server's own check has the same shape. It reads the conversation's
generation state, then revalidates each target workspace over the network, then
swaps; a turn that starts during that round trip is invisible to the check that
already ran. It now re-reads the generation state immediately before the swap,
leaving only the instant the compare-and-swap itself covers, which closes the
window for every client rather than just this one.
On the client the submission resolver refuses while a replacement is pending,
so the same signal disables the Send button and makes a programmatic send
return false. The workspace control stays reachable, so the state a chat is in
remains visible while it settles.
* fix: Fence Workspace Transitions and Reconcile Rejected Choices
Advance a private conversation revision after publishing an active generation and before reading its authoritative workspace decision. Transition CAS writes compare that revision, covering admission during the final idle-check window without expiring locks. Preserve tenant middleware and exclude private counter writes from chat activity and indexing.
Default existing undecided chats to no workspace, reconcile failed submissions from the server, scope pending guards to the affected chat, compare selection tuples without delimiter collisions, and opt attach/detach into deployment policy independently of existing moves. Retain legacy selection-only choices through first-send events.
* fix: Retain Failed Workspace Recovery and Skip Disabled Fences
Keep unconfirmed code-environment decisions in conversation-scoped Jotai state after authoritative reads fail, mutation observers reset, or navigation unmounts them. Expose a retry action and release submission only after a matching successful read. Ignore stale completions and reject mismatched conversation responses.
Reuse the owner-scoped conversation already loaded by each ingress when effective conversation moves are disabled. Retain the admitted revision fence for enabled moves, including move-only deployments. Cover failure/retry lifecycle and both policy branches at the helper and ingress levels.
* fix: Reuse the Atomic Admitted Snapshot Through Recovery
Return the admission revision and persisted decision from one Mongo findOneAndUpdate. Skip content indexing per internal query while retaining tenant middleware, private projection, and timestamps. Carry the returned snapshot through web and API initialization instead of validating against a stale pre-admission selection.
Keep first-send workspace choices in both the recovery preset and conversation template, and reconcile using the generated conversation ID from error or message data rather than requiring a saved submission snapshot. Cover single-query storage, indexing isolation, moved-machine validation, and first-send error recovery.
* fix: Reconcile Cancelled Turns and Keep Detach Reachable
Reconcile the submitted code decision before the local cancellation path finalizes streamed content or recovers a minimal submission. A cancel that beats the server rejection must not leave the attempted choice sealed locally; navigation must not update a different conversation.
Offer the authorized detach-only transition when a sealed conversation no longer has any attached agents, while ordinary chat stays sendable. Keep the selector visible for that transition and retain existing policy gates. Cover cancellation branches, no-attached-agent states, managed-only agents and the detach action.
* fix: Recover Workspace Transitions Across Navigation
* test: Verify Saved Workspace Transitions Against Current Dev
* test: Assert Explicit No-Workspace State in Native Journey
* test: Await Browser Settlement Before Switching Native Agents
* test: Settle URL Agent Selection Before Native Chat
* test: Wait for Worker Lease Expiry Before Offline Detach
---------
Co-authored-by: Lia <lia@librechat.ai>
Co-authored-by: Danny Avila <danny@librechat.ai>
* 📮 fix: Count Undelivered Background Results as Outstanding
* fix: Reconcile delivered tasks, discard exactly, and count pending subagent results
* fix: Settle manually claimed remote deliveries and keep pending controls while wake-ups drain
* fix: Report dead-lettered deliveries as failed and read subagent wake-ups from the durable store
* fix: List restored dead letters and retire deliveries on local durable claims
* 🐢 fix: Back Off Waiting Completion Wake-ups and Deliver Them When Ready
* fix: Signal every readiness path and make the completion wait cap configurable
* 🧷 fix: Wait for Long Dispatch Turns Before Giving Up Background Code Results
* fix: Mark held completion deliveries instead of pipeline expedite, and announce store-won approval expiry
* fix: Keep code tasks protected and wait without a fixed cutoff
* fix: Scope settle expedites to the resumed conversation and close the remaining signal gaps
* style: Format the settlement waiter
* fix: Announce a won approval expiry once and release subagent wake-up registrations
* fix: Outlast terminal persistence before giving up an unanchored code result
* fix: Anchor code results the moment their dispatch turn settles
* fix: Scope harvest epoch pinning to the owning stream
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🐢 fix: Back Off Waiting Completion Wake-ups and Deliver Them When Ready
* fix: Signal every readiness path and make the completion wait cap configurable
* fix: Mark held completion deliveries instead of pipeline expedite, and announce store-won approval expiry
* fix: Scope settle expedites to the resumed conversation and close the remaining signal gaps
* fix: Announce a won approval expiry once and release subagent wake-up registrations
* 🧪 ci: Count System Instructions in Mock Model Usage (#16350)
The e2e fake model reported input tokens for the chat messages alone, because the SDK hands a test override model the pruned messages without the systemRunnable pipe. Once #16301 gave every memory-enabled chat a system prompt, the calibrated context snapshot put used tokens below the instructions and the gauge dropped its Messages row. Count input over the complete prompt, as a real provider bills it.
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🔕 perf: Back Off Idle Durable Agent Recovery Polls
* 🎛️ style: Format Queued-Turn Recovery Test
* fix: Preserve Durable Recovery Wakeups and Discovery Invariants
---------
Co-authored-by: Lia <lia@librechat.ai>
* fix: preserve Insights with guarded ACL role updates
* test: settle ACL index builds before opening the transaction
* fix: replace ACL mask partitions with single-operator bit writes
* style: drop the now-unused RoleBits import
* fix: make ACL role replacement one atomic guarded write
* fix: export the permission write retry ceiling
* fix: retry ACL mutations per document and preserve atomic permissions
---------
Co-authored-by: Lia <lia@librechat.ai>
* ✒️ fix: Persist a Generated Title Before the Turn Ends
* 🧷 fix: Keep the Early Title Save From Rewriting Message References
* 🩹 fix: Carry the Recovered User Message Reference
* 🧵 fix: Reference Every Recovered Message Row
* 🪢 fix: Reference Paused and Resumed Response Rows
---------
Co-authored-by: Lia <lia@librechat.ai>
* ⚡ perf: Exclude Agent Version History From Default `getAgent` Reads
getAgent now defaults its projection to { versions: 0 }; loadAgent/loadAddedAgent
and canAccessAgentFromBody use getAgentWithVersionCount so the version count stays
exact without transferring the unbounded versions array on every chat request.
Callers that need history (v1 update/revert handlers) request it explicitly.
* fix: tighten agent version projection types
* fix: type projected agent version counts
* fix: type default agent projection
* style: format agent projection overload
* fix: expose projected agent return type
* ⏳ fix: Keep BYOM tools queued across capacity windows
* ⏳ fix: Configure the admission budget and refresh queued credentials
Addresses the Codex review on #16060:
- Add `limits.maxQueueWaitMs` to the code environment config schema so a
deployment can shorten or disable the five-minute admission budget from
`librechat.yaml`; omission keeps the merged behavior, `0` surfaces the
first capacity expiry to the model. Resolved through
`resolveAttachedWorkspaceQueueWaitMs` and passed by ToolService, matching
how `maxCommandTimeoutMs` already flows.
- Accept an auth-header supplier in `executeWorkspaceTool` and mint it per
admission attempt, so a call queued past the Code API token TTL presents
fresh credentials instead of failing permanently with 401. The attached
Bash tool and the workspace file operations now pass suppliers.
- Recheck the deadline after a clamped wait and throw the saved rejection
rather than opening an admission window that could still be admitted
once the budget is spent.
* fix: Complete workspace admission wiring and caller regressions
* fix: Share protected edit retry budgets and schema limits
---------
Co-authored-by: Lia <lia@librechat.ai>
The agent tool-resource branch of DELETE /files removed a file's association
from the agent and answered 200 without reaching processDeleteRequest, so the
bytes on disk and the RAG chunks of a file the caller owned survived the delete.
A replaced File Search document kept answering from its old chunks (#15930).
An attached file now goes through the full delete pass, but only when nothing
else holds it: a file the caller does not own, and a file any other
(agent, tool_resource) pair still references, are unlinked and left whole.
Nothing is unlinked until the destroy it depends on has succeeded.
- packages/api/src/files/deletion.ts: deleteAgentResourceFiles owns the
operation with its db methods and delete pass injected.
- packages/data-schemas: getSharedResourceFileIds answers the last-reference
question, excluding the pair being removed by the agent's _id.
- Local/crud.js: unlinkFile propagates non-ENOENT, so a file whose bytes
survive is no longer reported as deleted.
Co-authored-by: Mohammed Alshyakh <mohmedmm@users.noreply.github.com>
* fix: Resolve live OpenID bearer before the MCP early domain gate
* fix: Drop unread credentials from the MCP early domain gate
The early domain gate resolves the whole server config through
`processMCPEnv`, but decides from the URL alone. A credential placeholder in
any other field therefore raised `OpenIDReauthRequiredError` from a stale
request-time OpenID snapshot, before the connection path could refresh that
bearer, and the tool was dropped from the agent's toolset.
`buildMCPDomainValidationConfig` narrows the config to what the decision reads,
so the gate needs no live credential. A URL placeholder still fails closed, and
the argument is never mutated, so direct-bearer recovery keeps the placeholder
it knows how to refresh.
Replaces the per-tool `upstreamTokenProvider` call the gate would otherwise
make (1 + N per request per server) and covers every credential-bearing field,
not only `Authorization`.
Co-authored-by: Artyom Bogachenko <SpectralOne@users.noreply.github.com>
---------
Co-authored-by: Lia <lia@librechat.ai>
Co-authored-by: Artyom Bogachenko <SpectralOne@users.noreply.github.com>
* 🧼 fix: Strip Cache-Bust Query Before Local Vision Encode
Reused code-interpreter images persist filepath with a ?v= suffix.
prepareImagesLocal now strips it before disk encode, matching crud/share.
Co-authored-by: Zsanz3 <Zsanz3@users.noreply.github.com>
* 🧪 test: Isolate prepareImagesLocal query-strip coverage
Mock sharp and resize so the local vision-encode test does not load
the rest of the file-strategy graph.
Co-authored-by: Zsanz3 <Zsanz3@users.noreply.github.com>
* 🪒 fix: Strip Cache-Bust Suffixes From Every Local File Read
Reused code-interpreter outputs persist a `?v=<timestamp>` suffix on the file
document's filepath, and local storage resolves that field into a filesystem path.
prepareImagesLocal already handled it after the cherry-picked commits; getLocalFileStream
did not, so every download-stream consumer (the download route, provisioning, agent and
skill file reads) still hit ENOENT for a regenerated image.
Move the strip into one documented helper and call it from all three local read paths.
* 🧱 refactor: Move Cache-Bust Stripping Into the Storage Package
`/api` holds wiring, not behavior, so `stripCacheBust` moves out of a new CJS helper and
into `packages/api/src/storage/path.ts`, beside `resolveDownloadPath` — the function that
already decides what a stored filepath means to a download. Its doc comment now states why
the two differ: a remote strategy's query string can carry a presigned signature, so only
the local paths may strip.
The local storage modules keep just the call into it. Semantics are covered by the storage
package's own test; the `/api` specs pin the wiring.
Addresses the Codex P1 finding on 5f8dbf3cf.
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Zsanz3 <Zsanz3@users.noreply.github.com>
Co-authored-by: Lia <lia@librechat.ai>
* fix: Enable programmatic Bash in selected attached workspaces
* Centralize project PTC construction and preserve recognized capabilities
* Prevent stale list refreshes from restoring removed pins
* 🪂 feat: Opt-In Text Fallback for Files No Tool Can Read
An upload routed to tools (`llmDeliveryPath: none`) reaches nothing when the
agent handling the turn runs neither Run Code nor File Search, or runs one that
cannot read the type. With `fileConfig.endpoints.<endpoint>.textFallbackWithoutTools`
(also accepted at the top level and inherited from `default`), such a turn
delivers the text extracted at upload instead. The setting is off by default,
which keeps today's behavior.
- Upload: when the setting is on and an inferred `none` route finds no reading
tool, the built-in document parser or native text reader stores the text on
the file, best effort, under the extracted-text size cap and content policy.
- Turn: `resolveTurnLLMDeliveryPath` re-resolves each inferred route against
the tools the agent runs, and `applyTurnTextFallback` marks copies of the
records a turn loads, so endpoint filtering, limits, inspection, history
replay and steer media all see the text the turn delivers. The stored route
is never rewritten.
- Explicit destinations, records predating routing, and turns whose tools are
unknown are left as they are.
* 🧪 test: Resolve Custom Endpoint Fallback Under the Endpoint Name
Uploads route a custom endpoint agent by its saved provider, the endpoint name. initializeAgent marks turn copies before getProviderConfig swaps the provider for the backing client, and the endpoint keeps the name afterward, so the client and child encoders resolve the opt-in under the same endpoint. Cover both the initialization path and the post-initialization agent shape.
* ♻️ refactor: Share One Extracted-Text Storage Cap Across Uploads
The fallback defined its own copy of the 15 MiB cap context uploads already apply to extracted text. Export MAX_STORED_EXTRACTED_TEXT_BYTES from files/extract and use it in both places, documenting that it bounds what a MongoDB file document can hold rather than operator policy.
* 🧭 fix: Keep Fallback Text Wherever a Later Turn Can Deliver It
Extraction skipped uploads filed under a reading tool, so a handoff agent
without that tool, or the same agent after its tools or grants changed, had
no text to fall back to. Store fallback text for every inferred route on a
message attachment; files kept on an agent's tool resources never reach a
prompt and still skip it.
Turn marking only ran while the fallback was enabled, so a stored tool-routed
record whose type the endpoint now routes to text stayed marked `none` and
`extractFileContext` skipped it. applyTurnTextDelivery (renamed from
applyTurnTextFallback) now marks any stored `none` record with text that the
turn resolves to text, and returns early when no such record is loaded.
* 🚦 fix: Admit Every Attachment by the Route Its Turn Delivers
A record upload routed to tools that the current endpoint sends to the
provider stayed marked `none` on the turn copy, so admission skipped it while
BaseClient encoded its bytes, bypassing attachment count and size limits.
applyTurnDelivery (renamed from applyTurnTextDelivery) now gives every record
whose route upload inferred the route the turn resolves, before endpoint
filtering, limits and inspection, matching the run-file encoder.
hasInferredLLMDeliveryPath shares the inferred-route rule with the resolver.
Fallback extraction selected the document parser inside the CJS upload path.
resolveUploadFallbackText now takes the upload and picks parseDocument or
parseTextNative itself, with the extractors injectable, so process.js passes
request data only. Its tests run the real parser against the xlsx fixture and
the real native reader against temporary files.
* 🎚️ fix: Read Custom Endpoint Dialect From Config on Both Sides of Init
initializeAgent materializes turn routes before getProviderConfig swaps the
saved custom endpoint name in agent.provider for its backing client, so
routing read that name as a non-OpenAI dialect. Media a custom endpoint opted
into could then be materialized off the provider path, skipping admission,
while the finalized client still sent the bytes. resolveAgentDeliveryRouting
now reads the dialect with getCustomEndpointProvider, as upload does, which
holds before and after the swap.
The upload fallback plan now keys on the chosen-destination marker the turn
resolver reads, so an upload recorded as chosen, including every legacy
chooser upload, never pays for text a turn cannot deliver.
* 🛡️ fix: Apply Turn Routes Only While the Record Stays Admitted
Resolution while initializing and at delivery can disagree: delivery reads a
Responses API choice only the finished client config holds. Applying a route
that takes a record out of admission, off the model path or to text it never
stored, would then skip the limits for a file the client still sends.
applyTurnDelivery now applies a route only while the record stays model-bound;
admitting a record the turn leaves out cannot slip past a limit.
* 🕹️ feat: Run Declared Project Actions on Attached Workers (#15943)
* feat: use declared attached project actions
* Complete named action definitions and approval previews
* Sort named environment imports
* Sort native environment fixture imports
* 🔓 fix: Keep Code Approval Mode Selectable Mid-Run (#15938)
* 🔓 fix: Keep Code Approval Mode Selectable Mid-Run
The composer's code approval mode selector was disabled while a run streamed, and a mode picked during a run was reverted when the final or abort event merged the server conversation back. The selector now stays usable in flight and both merges retain a mid-run selection, which the next send carries.
* 🔓 fix: Retain Mid-Run Approval Mode Across Cache and Recovery
Stamp the live approval mode onto the submission conversation at send so the retention baseline matches what was read, keep a retained mode in the conversation query cache on final and cancel, and rebuild failed or aborted conversations from a preset that carries the mid-run pick.
* 🔓 fix: Scope Retained Approval Mode to the Submitted Conversation
Retention now requires the live conversation to be the one the run submitted, or the id the server assigned to a new chat, so navigating elsewhere mid-run cannot write that conversation's mode back. A single recovery helper rebuilds failed or aborted conversations from the retained preset and patches the detail cache for every recovery site.
* 🔓 refactor: Keep the Local Approval Mode on Every Server Merge
Replace per-path retention with one rule: a locally picked code approval mode is newer than any server copy of the same conversation, so the final and abort merges and the error recovery preset keep it. The selector writes the pick into the conversation's detail cache, which navigation rebuilds from, so the pick is conversation-scoped without reading the index-global atom from the SSE handlers.
* 🔓 fix: Prefer the Live Conversation When Caching the Final Merge
The final handler's detail-cache merge now takes the local approval mode from the open conversation when it is the one that finished, falling back to the cached record only for a conversation that is no longer on screen.
* 🔓 fix: Keep the Local Approval Mode Through Settled-Start Reconciliation
The resumable transport's settled-start reconciliation and replacement handoff wrote a fetched conversation straight into conversation state and the detail cache. Both now apply the same local-mode rule as the event handlers, treating a new chat's pending id as the settled conversation's own.
* 🔓 fix: Seed the Detail Record When a Mode Is Picked
A conversation that has its id but no detail record yet now gets one from the live conversation when a mode is picked, the same key the resumable transport seeds optimistically, so recovery and navigation find the pick. A chat with no id yet still keeps the pick in conversation state alone.
* ⬆️ chore: bump agents to 3.8.7 (#15947)
* 🧭 refactor: Settle Turn Delivery Routing Once in Agent Initialization
`initializeAgent` resolved the provider and its client options only after the
turn's files were loaded and admitted, and the two delivery readers each rebuilt
the attachment routing from the agent object at their own moment: `BaseClient`
took the custom-endpoint dialect from the already-swapped `agent.provider`, the
run-file encoder from whatever child config it was handed.
Move `getProviderConfig`/`getOptions` ahead of file discovery, where nothing in
between fed them, and settle one `deliveryRouting` value with every input final:
the file policy under the endpoint's own name, the dialect its config declares,
the Responses API decision the model call uses, and the transcription setting.
`InitializedAgent`, the child encoder and `BaseClient` consume that value;
`resolveTurnLLMDeliveryPath` is the one place a stored route is resolved again.
* fix: Preserve attachment reachability across handoffs and late steers
* test: Type the untrusted attachment reference fixture
---------
Co-authored-by: Ravi Kumar L <upman@users.noreply.github.com>
* feat: send video/audio to custom endpoints that opt in via supportedMimeTypes
The video and audio encoders only emitted OpenAI-format parts (video_url,
input_audio) for OpenRouter, and Google's media part for Google/Vertex. For
every other provider the file was validated and then silently dropped, so a
custom OpenAI-compatible endpoint (vLLM, LiteLLM, ...) never received the
attachment even though the wire format is identical to OpenRouter's.
Emit the OpenAI-format part for OpenAI-like providers when the endpoint's
fileConfig supportedMimeTypes explicitly allows the file's type. The inherited
default list does not count as opting in (isExplicitMimeConfig, keyed on
referential identity like the client's picker), so endpoints whose gateway
cannot handle media are unaffected.
* feat: let a configured custom endpoint pick and attach video/audio
The attach menu's Upload to Provider filter and the drag-drop viability check
only opened video/audio for Google and OpenRouter, or for a custom endpoint
with a fully permissive (.*) supportedMimeTypes. Honor any admin-configured
allowlist on a custom endpoint instead, so a finite list that includes
video/.* or audio/.* is enough, matching the server-side encoders.
* fix: canonicalize input_audio format from MIME type
The `input_audio.format` value was derived from the filename extension via
`filename.split('.').pop()`, which produces values providers reject:
- `clip.wave` (audio/wave) emitted `wave`, but the accepted format is `wav`
- a file with no extension (`recording`) emitted the whole filename, since
splitting a dotless string yields a single-element array, so the existing
non-empty guard never fired
- `clip.mpeg` (audio/mpeg) emitted `mpeg` rather than `mp3`
All of these pass MIME validation and then fail at the provider. Derive the
format from the MIME type instead, mirroring the canonicalization already in
STTService, and fall back to the filename extension only when it is itself a
supported format. Throws when neither source yields one rather than sending an
unsupported value.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
* fix: route opted-in custom endpoint media to the provider path
In unified upload mode an upload carries no tool resource, so its delivery path is
inferred by resolveDefaultLLMDeliveryPath. That resolver judged audio and video for any
named endpoint with isMediaSupportedProvider, which lists only Google, Vertex and
OpenRouter, so a custom endpoint that opted into media through supportedMimeTypes still
recorded video as none and audio as text, and the encoder branch was never reached.
The upload resolver already holds the endpoint's file config, so it now passes the
endpoint's supportedMimeTypes through, and an explicit match on an OpenAI-compatible or
custom endpoint counts as provider-capable, mirroring isConfiguredProviderMediaType on
the encoder side. The inherited default list is still not an opt-in, and known providers
whose encoders emit nothing for media are unchanged. BaseClient re-resolves per turn with
the same function, so the turn path follows.
* fix: scope the media opt-in to custom endpoints that run as OpenAI
The opt-in applied to the built-in openAI and azureOpenAI endpoints too, but the picker
and drag-drop only open media for custom endpoints, so that was a route the client could
not send to. It is now limited to endpoints that are not a known provider.
A custom endpoint may also declare provider: anthropic, in which case initialization runs
it as Anthropic and the encoders emit no media part for it. getCustomEndpointProvider
reads that declaration off the app config, the upload callers pass it as endpointProvider,
the agent encoder and BaseClient pass the agent's resolved provider, and an endpoint known
to run as something other than OpenAI keeps its previous route: video stays off the model
path and audio still reaches transcription.
* fix: reject unsupported provider audio during upload
---------
Co-authored-by: Renato Garita Figueiredo <renato.garitafigueiredo@uni-osnabrueck.de>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
* 💳 fix: Reserve Balance for In-Flight Requests
Admit each balance-checked request against the credits that other
in-flight requests have not already reserved, and hold its prompt cost
on the balance record until the turn settles. Apply a due auto-refill in
the same fenced write so one refill window credits exactly once.
- data-schemas: reserveBalance / releaseBalanceReservation replace
createAutoRefillTransaction; the write is a compare-and-swap on
tokenCredits, reservations and lastRefill (no pipeline updates)
- balance.reservations is select:false so existing reads never see it
- checkBalance returns a reservation handle; BaseClient and the
assistants controllers release it once the turn settles
- balance.reservationTtlMs bounds how long an unreleased reservation
counts (default 30 minutes)
* 🧮 refactor: Admit Reservations Without Contention and Record Refills Durably
- admission is a conditional $push/$inc against a reservedCredits total,
so concurrent admissions of a funded balance commit on their first write
- expired reservations are pruned per element with their credits
- auto-refill is fenced on every setting its decision reads and leaves a
pendingRefill ledger marker in the same write; any later read records the
transaction under the fixed id and clears the marker
- a missing record is created with $setOnInsert inside reserveBalance
- reservation lifecycle moves to packages/api (createBalanceReservations,
withBalanceReservations); BaseClient releases once usage is recorded
* 🪪 fix: Resolve Each User to One Balance Record
- balance records a creator inserts are keyed by the user id, so creators
racing on a missing record converge on one document; every balance read
and write resolves a user to their oldest record, so existing duplicates
stay inert
- upsertBalanceFields takes insert-only fields; the balance-config
middleware, schedules and lazy initialization pass the starting credit
through them so it never overwrites a record another writer created
- the auto-refill write is also fenced on reservedCredits
- the scheduled-chat balance pre-skip counts reserved credits as unavailable
* ⏳ fix: Count Only Unexpired Reservations in Scheduled Balance Checks
findBalanceByUser with includeReservedCredits now totals the reservations
that have not expired, so a reservation left by a crashed request stops
pre-skipping scheduled chats at its expiry instead of when a later
reservation write prunes it.
* 🔁 fix: Renew Balance Reservations While Their Request Runs
A reservation is renewed every half TTL until it is released, so only a
reservation whose process stopped expires. Pruning removes a reservation
only while it is still expired at the write, so one renewed after the
pruning read survives.
* 🛟 fix: Keep Reservations Alive Through Renewal Failures and Lost Acks
- renewal reschedules itself: every half TTL, capped to the timer range,
and a failed renewal retries within a tenth of that window
- an admission write that errors removes its possibly committed
reservation before rethrowing
* 🛑 fix: Hold a Stopped Turn's Reservation Until Its Charge Lands
- an aborted turn lets its reservations lapse after a minute (or the TTL)
instead of releasing them, so the Stop request's charge lands before the
credits are admitted again
- balance.reservationTtlMs has a 10 second minimum, enforced in the schema
and at runtime, so renewal stays bounded
* ↩️ revert: Release a Stopped Turn's Reservation When the Turn Settles
An aborted turn releases its reservations when it settles, the same as
every other exit, instead of holding them for a fixed lapse window that
refused funded requests after every Stop. The minimum reservation TTL
stays.
* ⏸️ fix: Hold Assistants Reservations Through Background Run Retries
An in-progress Assistants run continues in the background after the
handler responds; the turn's reservations now stay held until that run
settles (createBalanceReservations().holdUntil).
* 🔁 fix: Apply an Auto-Refill Once per Admission
A refill interval that is due again the moment it is applied, such as a zero
interval, let one admission refill repeatedly until the retry bound. Each
admission now applies at most one refill, as the previous check did.
* 🧹 fix: Prune Expired Reservations in One Write
An admission that found expired reservations issued one write per hold, so a
backlog left by a stopped process fanned out into as many concurrent writes.
The prune is now a single write fenced on every hold it removes; a hold renewed
after the read makes the write miss and the admission re-read.
* ⏱️ fix: Renew Reservations From Their Stored Expiry
The next renewal was scheduled half a TTL after the previous write settled,
and the first one half a TTL after the admission returned, so a slow write
could let a live hold expire before its renewal. Renewals are now scheduled
from the expiry the last write stored.
Expired holds are pruned as one bulk write of per-hold fenced updates, so a
hold that changed after the read is skipped while the rest are removed, and
the admission no longer spends a retry on the whole prune.
* 🔎 fix: Enforce WEB_SEARCH Role Permission on Agents
Squash of #15822 onto dev, preserving authorship:
- 🔎 fix: Enforce WEB_SEARCH Role Permission on Agents
- 🧪 test: Cover the Runtime Tool Loader's Web Search Gate
- 🔒 fix: Gate Web Search on the OpenAI-Compatible Embedder Surface
- 🩹 fix: Authorize Web Search by the Execution Context's User
- 📝 docs: Note the Grant Memo's One-Subject-Per-Request Assumption
- 🧹 fix: Deny Web Search Before an Endpoint Default Can Grant It
- 🙈 fix: Withhold the Web Search Model Parameter From a Denied Role
- 🧱 fix: Strip Provider-Native Search an Endpoint Re-Enables After Denial
- 🔌 fix: Close the OpenRouter Plugin Path and Stop Pruning Hidden Parameters
* 🧭 fix: Gate Provider-Native Web Search on the Built Config
The web search role gate ran before the provider builder and only when the
agent's stored `web_search` was not `false`, so an endpoint's `addParams`
re-enabled native search for a denied role, and every OpenAI-compatible and
Responses request read the role whether or not search was in play.
The gate now reads the builder's output: when it carries a native search tool
or OpenRouter's `web` plugin, the `WEB_SEARCH` grant is resolved and the search
stripped on denial. The routes that reach `initializeAgent` with `runtime` and
no `req` pass a lazy `resolveWebSearchGrant` that joins their request-memoized
grants, forwarded through agent discovery to handoffs and subagents. The
embedder surface wires it whenever `getRoleByName` is supplied, independent of
`appConfig`.
---------
Co-authored-by: TomasPalsson <tomas2212042710@gmail.com>
* 🪂 fix: Release Stalled MCP Catalog Recovery Without Dropping Refreshed Tokens
Passive catalog recovery could hang forever when discovery hit an expired
OAuth access token and the refreshed tokens' authorization-fence write
stalled. The shared flight, every request coalesced onto it, and their
process-wide catalog slots waited with it until capacity was exhausted.
- Stop discovery's OAuth token wait at its deadline or abort without
cancelling the shared token flow, so redeemed tokens still persist.
- Stop recovery waiting on a discovery once its budget plus
`mcpSettings.catalogRecovery.discoverySettleGraceMs` (default 10s) has
passed, releasing the flight, its joiners, and their slots with backoff.
- Add `waitUntilDeadline` for waits that must end without cancelling work.
* 🪂 test: Rediscover Once a Released Flight's Refresh Publishes
* 🪂 fix: Hold a Server's Recovery Until Its Released Discovery Settles
* 🪂 fix: Scope Released-Discovery Holds to Observed State Under a Process-Wide Limit
* 🪂 fix: Count Token Work a Discovery Hands Off at Its Deadline
* feat: add run-scoped file sharing for subagents
Delegate current-message files through authorized execution catalogs and publish selected immutable code-output versions through the existing file pipeline.
Requires the companion agents SDK context adapter before the dependency can be released and pinned.
* fix: preserve child tool artifacts and verify file-sharing lifecycle
Keep citations and other non-sandbox artifacts on their existing delivery path while retaining private code outputs and inspected images until publication.
Cover native and text delivery, nested and sibling authorization, concurrent runs, cancellation cleanup, and checkpoint recovery through the browser harness.
* test: align file-sharing fixtures and integration cleanup
* test: repair LibreOffice conversion fixtures
* test: verify deployment skill bytes across checkout formats
* fix: align subagent file budgets and refresh boundaries
* chore: update agents SDK to 3.8.6
* refactor: move code output processing into API workspace
* fix: enforce shared file budgets for parents and teams
* fix: declare the shared file encoder interface
* 📇 fix: Stop an MCP Credential Refresh From Fencing Its Own Catalog Recovery
Passive catalog recovery captures the tool-cache generation before discovering a
cold server and discards the catalog when the stored generation has moved by the
time discovery returns. A silent OAuth refresh inside that same discovery
publishes a rotation of its own and then clears this replica's recovery state,
so the tracker drops the flight as superseded and the generation check rejects
it: the server is listed with no tools, and a concurrent catalog request starts
a second discovery instead of joining the first.
The authorization fence now reaches discovery through recovery's own
dependencies, which report each generation a discovery's refresh publishes. The
tracker adopts that generation while the flight is still running, so the flight
stays current and its outcome carries the generation it produced; a rotation or
clear from any other writer afterwards still supersedes it, and a refresh that
completes after its discovery settled no longer touches that settled state.
* 🪢 fix: Keep a Recovery Flight Joinable Through Its Own Credential Publication
A refresh's authorization fence writes the new shared generation, clears local
recovery state, and only then reports what it wrote. A catalog request that read
the new generation during that span found the flight still keyed to the old
generation, or its slot vacated by the clear, and replaced it with a second
discovery; the original flight was then discarded.
Discovery now runs its publication through a tracker bracket. While a flight's
own publication is in progress the tracker holds any clear for that server and
lets requests for the same config join the flight; when it ends, the flight
adopts the generation it wrote, or applies the held clear if the publication
failed or the flight settled first. The flight is registered before its
discovery starts, so a publication can never precede its own registration.
* ⏳ fix: Bound and Count What a Recovery Flight Holds During Its Own Publication
A recovery flight held every clear for its key and admitted any request for its
server for as long as its own credential publication stayed open. A clear from
another writer collapsed into the fence's own clear and was dropped on adoption,
leaving a backoff or reauthorization decision in place after a teardown; a
publication stalled in an unbounded storage write kept every later request
joined to the stalled flight; and a joiner that had already read a foreign
generation could keep tools under an older adopted generation when the final
generation read failed.
An open publication now holds clears and admits joins only while its flight is
in flight and for at most one discovery budget, after which requests take over
as before. The fence clears local recovery once when it completes, so any other
held clear still applies after the flight adopts its generation, and every held
clear applies when the publication fails or the flight settles first. An outcome
under a generation the request never observed stands only when the final shared
generation read confirms it.
* 🧬 fix: Correlate Catalog Recovery Clears With the Generation Their Fence Wrote
Local catalog-recovery clears carried only a user and server, so the tracker
could not tell a flight's own credential publication from any other writer. It
counted clears and bounded its hold with a time window instead, which left a
request that joined before the window expired waiting on a stalled publication,
and let a late fence clear delete the flight that took over after the window.
The authorization fence now hands local recovery the generation it wrote, and a
clear spares state already recorded under that generation; a clear without one
still clears. A flight holds the clears it receives while its own publication is
open, adopts the generation that publication wrote, and then applies each held
clear against it, so its own clear is spared while a teardown or another
publication's clear still applies. Retry-intent cleanup inside the fence is
bounded by the same per-attempt timeout as the generation write, since a leftover
intent only advances the generation again, so the publication itself can no
longer hold its joiners open and no time window is needed.
* 🔏 fix: Confirm an Adopted Catalog Generation for Requests That Read None
A request whose pre-discovery generation reads both failed observed no
generation, so the confirmation rule exempted it. When that request's own
discovery refreshed credentials, adopted the generation its publication wrote,
and another replica rotated past it before a final read that also failed, the
catalog was served without ever being confirmed against shared state.
A flight's own result now records that its generation came from its own
publication, and that mark is never copied into retained state. An outcome
under a generation the request did not read needs final confirmation whenever
the request read a different generation or the generation was adopted; an outcome
whose generation the tracker merely carried over for a request that read nothing
keeps the existing fail-open behavior, so a cache outage still preserves retained
backoff and reauthorization state.
* 🧭 fix: Judge In-Flight Catalog Recovery by the Shared Generation, Not a Tagged Clear
A publication's local clear carries the generation it wrote, and the tracker
deleted any state recorded under a different one. Generations carry no order, so
a refresh that outlived its own flight could clear with an older generation and
delete a flight that had started under a newer rotation from another replica,
discarding a catalog that was still current.
A tagged clear now only signals that the shared generation advanced. A flight
still in flight under a known generation, or publishing its own credential
change, is left to the requests awaiting it, which already confirm their outcome
against the shared generation exactly as they do for a rotation from another
replica. Retained state and flights with no known generation are cleared unless
recorded under the clear's generation, and a clear without a generation still
clears unconditionally. The tracker no longer holds clears during a publication:
the refresh's own clear spares its flight directly, and the flight adopts the
generation it wrote when the publication completes.
The shared-discovery tests compared catalog maps through expect.objectContaining,
which does not compare Map contents; they now assert each request's catalog with
toEqual.
* 🧾 fix: Confirm a Catalog Flight That a Clear for Another Generation Spared
A tagged clear spares a flight still in flight, because an unordered generation
cannot say whether that flight predates the rotation. The spare was not recorded,
so when the request's final shared-generation read timed out, a flight that had
observed its own generation kept a catalog the clear may have superseded: an older
recovery whose refresh published after a replacement flight started could leave
that replacement serving tools no read ever confirmed.
A spared flight now records the generation each such clear carried and settles
against its final generation. A clear for its own generation, including its own
refresh's, changes nothing; any other marks the flight's result unconfirmed, keeps
it out of retained state, and requires every request awaiting it to confirm the
generation against the shared read before using its tools. A spared flight that
finishes with no known generation is discarded, as the clear would have done. A
tagged clear no longer spares retained state recorded under its generation.
* 🪢 fix: Recover a Failed MCP Server Once When Reinspections Overlap
A server stored as an inspection-failed stub is recovered by the first
request that inspects it successfully, but every request that read the
stub before that write inspected again and wrote again. Each later write
bumped `updatedAt` past the connection made after the earlier one, so the
connection was replaced and a caller still holding it listed no tools. A
request that reached `reinspectServer` after the write hit the
"not in a failed state" guard and reported the server as still
unreachable.
- Share one in-flight reinspection per stored entry and effective
allowlists in each process; DB entries are keyed per user and tenant.
- Replace the stub only while it is still the inspected stub: a new
optional `replaceStub` compare-and-set on the in-memory and Redis
aggregate-key stores (one Lua script), so replicas never overwrite a
recovery another replica stored.
- Resolve a reinspection that finds the server already recovered to the
stored config, and move the reinitialize decision into
`MCPServersRegistry.recoverServerConfig` so `reinitMCPServer` connects
with the recovered config instead of the stub it read.
- Pin the interleavings in `MCPReinitRecovery.integration.test.ts` against
a real in-process MCP server, and require every concurrent reinitialize
flow there to recover with a complete tool list.
* 🪢 fix: Key Shared Reinspections by the Stub They Inspect
A registry re-initialization can replace a failed stub while an older
reinspection of it is still running. The shared flight was keyed by
entry and allowlists only, so a request that read the newer stub joined
the older inspection and inherited its outcome without the newer config
ever being inspected.
`reinspectServer` now reads the entry before joining and keys the flight
by the stub's `updatedAt`. A flight whose compare-and-set loses to a
newer failed stub joins the inspection of that stub instead of reporting
the server unreachable, and a store that leaves the inspected stub in
place rejects rather than joining its own flight.
* 🪢 fix: Settle a Reinspection Against the Entry Stored After It
A reinspection that did not replace its stub only looked at storage when
its compare-and-set lost. Two paths reached a stale outcome:
- An inspection that failed rejected as unreachable even when another
request had already stored a recovery, for example after capturing the
stub before a slow allowlist resolution. Allowlists now resolve before
the entry is read, and a failed inspection settles against the stored
entry the same way a lost compare-and-set does.
- Returning a recovery that another replica stored left this replica's
process-local `getAllServerConfigs` memo serving the stub until its TTL.
Settling on a stored recovery now invalidates this replica's registry
read caches, as the writing path does.
* 🪢 fix: Decide Reinspection Outcomes From Current Shared State
The Redis aggregate-key store answers `get` from a process-local
snapshot that can lag another replica's write by its TTL. A replica
whose inspection failed read that snapshot while settling, still saw the
stub, and reported the server unreachable although Redis held another
replica's recovery. The same stale read also sent a replica into a
needless inspection of a server another replica had already recovered.
- Add an optional `getCurrent` to the repository interface, implemented
by the aggregate-key store as a read past its snapshot, and use it for
the reinspection's first read and for settling.
- Inspect a newer stub within the flight that found it instead of
joining another flight, so no flight ever waits on a second one.
* 🪢 fix: Join the Flight Already Inspecting a Newer Stub
A flight that lost to a newer failed stub inspected that stub itself even
when another request was already inspecting it. If that redundant
inspection failed transiently, the flight settled against the unchanged
newer stub and rejected its callers while the other flight went on to
store the recovery.
A flight now joins the flight for the newer stub, starting it when none
is pending, but only when the stub is strictly newer by `updatedAt`, so
every wait points forward and flights stay acyclic. A replacement that
is not newer, which only clock skew can produce, is still inspected
within the flight.
* 🪢 fix: Track Reinspection Waits Instead of Ordering Them by Clock
Joining only flights for strictly newer stubs kept waits acyclic by
relying on `updatedAt` order, which replicas with skewed clocks do not
guarantee. A replacement stored with an older timestamp was inspected
redundantly instead of joining the flight already inspecting it, and a
transient failure of that redundant inspection rejected callers the
other flight went on to recover.
Settling flights now record the flight they wait on and join any
in-flight reinspection for the stub they found, unless that flight
already waits on them directly or through others. Only a join that
would close a cycle falls back to inspecting within the settling flight.
* 🪢 refactor: Resolve the Reinitialize Config in packages/api
`reinitMCPServer` still decided in CJS what a failed-inspection config
recovers to and built the `unreachable` response itself. That decision
now lives in `resolveMCPReinitializeConfig` in packages/api, which takes
the registry as a dependency and returns either the config to connect
with or the typed result that ends the reinitialization. The CJS service
only passes request data in and returns that result.
A durable user connection captures the tool-cache publication generation before
resolving credentials, so a rotation from another replica fences the catalog it
publishes. A silent OAuth refresh performed while that same connection is being
built publishes a rotation of its own, and the build then fails the lease check
it just invalidated: the connection holding the newest credentials is torn down
and the tool call that triggered it errors with "Publication lease is no longer
current".
invalidateCachedTools now reports the generation it wrote, the authorization
publication carries it back to its caller, and a connection build adopts what
its own refresh published. A foreign rotation still moves the stored generation
past that value, so the fence keeps failing the build it was meant to fail.
* fix: Prefer storage keys for image encoding
* fix: Sanitize assistant image errors
* fix: Sanitize agent image storage errors
* fix: Move blob image encoding into API package
* fix: Complete image encoder TypeScript migration
* fix: Keep request-boundary error logs diagnosable
getSafeErrorMetadata reduces an error to { type: 'Error' } and an optional
status. That is the right bound where an error may echo submitted content, and
it stays in place at getS3FileStream, getAzureFileStream and
getFirebaseFileStream, where a signed URL reaches the log.
Applied at ResumableAgentController's initialization catch and the chatV1
generic branch it blinded the whole route: a missing key, an agent that fails to
load and a database error all logged as { type: 'Error' }, with no message,
name, code or stack.
getSafeErrorText keeps the error's own description and stack, reduces every URL
to its origin so an object path and signature cannot ride along, and strips
bearer credentials. It returns text so the two handlers log it inside the
message and pass no winston metadata, which is what stops an SDK error's own
enumerable properties (request.url, config, response.headers) from being
promoted onto the record.
---------
Co-authored-by: Danny Avila <danny@librechat.ai>
* 🪢 fix: Keep One Code File per Sandbox Destination
Codeapi mounts a by-ref input at the filename recorded on the stored
object (the file server's Content-Disposition) and only falls back to the
`name` sent in `/exec` when that header is absent. The `<stem>-<hash>`
alias `claimCodeDestination` handed to an older same-name file was
therefore remapped onto the bare name inside the sandbox, and the whole
request was rejected with "Conflicting input destinations" — on every
later turn, because nothing came back to collapse the pair. Any
conversation in which code rewrote an uploaded file in place, or the user
re-uploaded a file under its original name, lost code execution for good.
`primeFiles` now reserves each destination with `reserveCodeDestination`
in newest-content-first order and skips the files that lose, before the
freshness probe so a dropped file is never re-uploaded. This is the same
collapse `seedCodeFilesIntoSessions` and `ToolNode.updateCodeSession`
already apply. The spec stub mirrors the real directory-prefix rule so the
ancestor case is covered at this layer too.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* fix: preserve stored sandbox destinations during priming
* test: remove unused mock transport imports
* fix: recover unnamed legacy inputs and converted images safely
* fix: keep freshness decisions paired with mount destinations
* fix: align recovery destinations with upload and route boundaries
* style: format upload receipt regression fixture
* fix: distinguish stored paths from proposed recovery paths
* fix: preserve lazy provisioning destination priority and recovery names
* fix: reconcile recovery names with live code destinations
* fix: distinguish recoverable destinations from superseded scoped content
* fix: guard optional request user in recovery scope check
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: Danny Avila <danny@librechat.ai>