* 🗝️ 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.
* 🪪 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
* 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: 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.
* perf: Validate Agent Models Against Their Own Endpoint Catalog
* perf: Share In-Flight Model List Fetches
* test: Cover Agent Model Validation Across Endpoints
* test: Check Agent Model Catalog Parity With the Real Loaders
Bound model-facing Flux images to the 5 MiB base64 budget for standard and finetuned generation. Preserve original image data for attachment storage under the existing resolution policy.
Fixes#6954.
* fix: Accept Content-Array Outputs in Responses function_call_output
The Open Responses spec allows function_call_output.output to be a string or
an array of input_text, input_image and input_file parts, but request
validation refused anything that was not a string. Validate the array parts
and convert them with the same part mapping the message path uses, so the
replayed tool result keeps its text and images in order.
* fix: Inspect Tool-Output Media Against File Policies
Image URLs and file names in a function_call_output content array reached the
model without the file-policy fragments the same parts get in a message.
Collect those fragments for both item types in packages/api and call that
from the Responses controller.
* test: Cover Content-Array Tool Outputs in the Responses API
* perf: Serve JWT Bearer User Lookups From the Auth User Cache
* perf: Batch Agent Permission Reads on the File Access Path
* perf: Remember a Loaded Google Service Key Across Endpoint Config Reads
* perf: Run Independent Startup, Tool, Skill and Erasure Reads Concurrently
* fix: Drop JWT User Cache Writes That Race a User Mutation
Confirm each cache write with a second read and evict when the user changed,
so an in-flight lookup cannot repopulate an entry a credential change just
evicted. The cache mode now arrives through the loader dependencies.
* refactor: Move Agent Skill Access Reads Into packages/api
The chat-completions and Responses controllers call loadSkillAccess instead of
orchestrating the three reads in CJS. The preview route spec mocks the batched
file access helper the middleware now calls.
* test: Cover Agent File Access, JWT Bursts and Remote Skill Reads End to End
* fix: Serve a Cached JWT User Only While Its updatedAt Is Current
A cache hit now reads the stored updatedAt and deletion fence instead of the
fence alone, so a document cached from a read that raced a user mutation is
never served, even when the write landed after that mutation's eviction.
* refactor: Move Startup Migration Checks Into packages/api
* refactor: Inject the Startup Migration Checks Instead of Mongoose Models
* fix: Serve Cached OpenID Users Only While Their updatedAt Is Current
Moves the freshness check into getCurrentCachedAuthUserDoc and uses it on the
OpenID bearer path as well as the local JWT one, so a document cached from a
read that raced a credential or role change is never served there either.
Fixesberry-13/LibreChat#432
* fix: Compare Authorization Fields on Every Auth Cache Hit
updatedAt has millisecond resolution, so the freshness read also compares the
token retirement stamps, role, tenant and two-factor state.
* fix: Annotate the Auth Freshness Projection for Isolated Declarations
* perf: Reuse the OpenID Cache Freshness Read for Deletion Admission
A cache hit already proved the deletion fence is clear, so only users read from
the database take the separate fence query.
* refactor: Keep the OpenID Cache Freshness and Fence Decisions in packages/api
* test: Exercise JWT Cache Freshness Against Real User Methods in MongoDB
* fix: Stamp the JWT User Lookup So the Cache Write Fence Applies
* fix: Reload a Google Service Key File When It Changes or Disappears
The availability check remembers a loaded key only while the file's mtime and
size are unchanged, and fetches URL sources every time as before.
* fix: Recheck a Service Key File After a Permission Change
* fix: Keep the Snapshot When the Terminal Write Settled for Reconciliation
* fix: Promote a Reconciled Compaction Snapshot to the Terminal Row
* fix: Anchor and Envelope the Reconciled Snapshot by Its Claim
* test: Cover the Abandoned Compaction Settling After Its Run in E2E
* fix: Withhold the Disconnect Snapshot of Any Durably Settled Turn
* fix: Promote Only a Same-Epoch Reconciled Snapshot and Settle Stopped Compactions
* fix: Plan the Disconnect Snapshot in packages/api and Check the Response Row Before Promoting
* fix: Read the Disconnect Snapshot Rows in the Response Conversation
* fix: Check the Anchor-Derived Error Row Before Promoting a Reconciled Snapshot
* fix: Log a Failed Disconnect Snapshot Plan Instead of Rejecting the Listener
* fix: Let a Reconciled Compaction Promote After an Earlier Live Snapshot
* refactor: Decide the Repeat Disconnect Write in the Snapshot Plan
* refactor: Report Failed Snapshot Row Reads Through the Plan
* fix: Stamp a Promoted Disconnect Snapshot and Read Its Rows Together
* fix: Derive the Compaction Error Row ID Through the Shared Helper
* fix: Plan a Saved Live Compaction Snapshot Again Once Its Turn Settles
* refactor: Queue Disconnect Snapshots and Settle Them in packages/api
* fix: Never Count the Compaction Anchor as Its Own Terminal Row
* fix: Settle Disconnect Snapshots Before Terminal Cleanup Releases the Turn
* fix: Return approved tool and generation error text instead of raw exceptions
* fix: Redact generation error text without the data-schemas helper
* fix: Redact credentials and emails from shown generation errors
* refactor: Move the Wolfram status policy into packages/api
* test: Fix the Wolfram probe constructor and jest summary match
* test: Match the jest pass count through color codes
* fix: Redact credentials a tool input error echoes from its arguments
* fix: Drop free-text fields from typed generation errors under a content policy
* fix: Keep only the code and numeric fields of typed errors under a content policy
* fix: Harden Timer Sweeps, SSE Writes, and Violation Counters
Guard SSE writes against ended or destroyed responses through one helper, catch and single-flight the job store and TTL cache cleanup timers, serialize in-process counter updates, cap the violation log, prune stale OAuth failure records, batch the active-job lookup, and count Redis keys with DBSIZE.
* refactor: Drop the redundant violation log entry copy
* refactor: Log single-flight sweep failures from the API package
* test: Cover active generation listing and client disconnect mid-stream
* refactor: Configure violation log retention and move title timeout into the API package
* feat: Configure OAuth failure retention through mcpSettings
* fix: Prune OAuth failures promptly under short retention
* fix: Price 1-Hour Prompt Cache Writes at the 1-Hour Rate
* test: Cover 1-Hour Cache Write Pricing End to End
* test: Price Cache Scenario on the Configured Mock Model
* fix: Accept a 1-Hour Cache Write Rate in Endpoint Token Configs
* fix: Keep Temporary Chats Out of Langfuse
* fix: Gate Forced-Ephemeral and Open Responses Turns From Langfuse
* fix: Treat Legacy and Chat Completion Temporary Turns as Untraced
---------
Co-authored-by: Joel Hirzel <joel.hirzel@eps.ch>
* refactor: Remove Unused Agent Helpers and Superseded Wrappers
* refactor: Remove Dead Auth, Middleware, Protection and Prompt Helpers
* refactor: Remove Dead MCP, File, Skill and Endpoint Code
* refactor: Remove Dead Stream, Telemetry, Utility and Type Exports
* chore: Drop Unused packages/api Dependencies From bun.lock
* refactor: Keep Published Compatibility and Deprecated packages/api Exports
* fix: Run the Erasure Cascade in Admin User Deletion
* refactor: Share Generation Stop Logic Between Self-Service and Admin Deletion
* refactor: Move Admin Erasure Dependency Assembly Into packages/api
* fix: Bind getCleanupJob When Waiting for Generation Persistence
* test: Pin the Deletion Fence Before Admin Generation Stop
* fix: Resolve the Erasure Target Config Fail Closed
* fix: Carry the Target Profile Into Admin Erasure Storage Cleanup
* fix: Keep the Erasure Target Contract Storage Neutral and Reuse the Loaded Identity
* fix: Refuse New Generations Once Account Deletion Has Begun
* fix: Enforce Account Deletion Admission Once in createJob and Narrow the Erasure File Type
* fix: Install the Admission Guard in Every Entrypoint and Purge Refused Jobs
* fix: Guarantee Refused Job Purge and Sanitize Admission Failures
* fix: Route Remote Admission Through createJob and Keep Refusal Cleanup Sanitized
* fix: Log Admission Cleanup Failures With Safe Error Metadata
* refactor: Check Account Deletion Before Creating a Generation and Drain Twice
* refactor: Order Admission Against the Deletion Marker Without a Grace Period
* fix: Sanitize Post-Commit Admission Retirement Failures
* fix: Wire Shared-Server MCP OAuth Cleanup Into Admin Erasure
* fix: Scope Admin Erasure Lookups to the Target Tenant and Await Shared-Link Cleanup
* fix: Resolve the Erasure Target Config Under the Target Tenant
* fix: Run Admin Erasure OAuth Fencing in the Target Tenant
* fix: Match the Split OAuth Invalidate and Disconnect Hooks in Admin Erasure
* refactor: Inject the Tenant Executor Into the Erasure Resolver
* 📴 fix: Stamp Legacy Failure Parts When Settling a Compaction Row
* 📴 fix: Redirect the Collision Error Row to the Live Response Id
* 📴 fix: Withhold the Anchor-Colliding Error Row and Keep Pending Rows Fallbacks
* 📴 fix: Scope the Settled-Job Guard to Compactions and Copy Stamped Parts
* test: Cover the Underscore-Leaf Compaction Failure and Abandoned Replies in E2E
* test: Fail the Underscore-Leaf Compaction Through the Blank Summarizer
* refactor: Return the Final Error Row Id From the Settlement
* 📴 fix: Finalize Compaction Snapshots and Move Abort Policy Into packages/api
* 🔕 fix: Inspect Every Part When Finalizing and Reuse the Loaded Row
* 📴 fix: Settle Finalized Compaction Rows and Verify Their Anchor
* 📴 fix: Withhold the Unanchored Abort Final and Settle Marked Snapshots
* 📴 fix: Consolidate the Compaction Abort Policy Into One Injected Operation
* 📴 fix: Settle the Live Compaction Row Past an Anchor-Shaped Collision
* 📴 fix: Lift the Failed-Turn Settlement Into the Compaction Module
* 📴 fix: Keep a Removed Round's Failure and Guard Settled Jobs From Snapshots
* ⚡ perf: Read Only the Anchor Id in the Abort Existence Check
* 📴 fix: Withhold the Abort Final Only When a Row Needed Writing
* test: Cover Stopped Compaction Finalization and the Missing Anchor in E2E
* fix: Withhold a Stopped Compaction That Carries No Anchor Id
* fix: Settle Stopped Compactions, Announce Finalized Rows, and Own the Abort Read in packages/api
* test: Accept the Model Spec Query on the Stopped Reply Conversation URL
* fix: Report the Anchor Read Failure Beside a Withheld Compaction Abort
* fix: Synthesize a Compaction Failure Only for a Round After the Latest Outcome
* fix: Skip the Anchor Read When a Stopped Turn Writes No Row
* fix: Decide the Disconnect Snapshot Gate in packages/api
The last-subscriber partial save now asks resolveDisconnectSnapshotMode for
the settled-job decision instead of branching on the job record in the CJS
controller.
* fix: Leave an Already Settled Compaction Row to the Path That Settled It
* 📴 fix: Persist Cancelled Compactions With Their Identity
* 🧪 test: Build the Cancelled-Compaction Leaf on a Real Conversation
* 🧪 test: Assert the Withheld Controls on the Live Cancelled Compaction
* 📴 fix: Keep Live Disconnect Compaction Rows Free of a Synthesized Failure
* 🧪 test: Cover the Compaction Flag in the Redis Job Round Trip
* 📴 fix: Keep a Stopped Compaction Honest and Its Anchor Untouched
* 🔗 feat(agents): use LibreChat prompt groups as agent instructions
Agents can link a prompt group revision or Production as their instructions. The link resolves at the start of each turn through a cached resolver. The cache clears on promote and delete. Editors without VIEW on the group see a restricted placeholder.
* fix: remove duplicate logger import from agent initialization tests
* fix: honor prompt management capabilities for linked agent instructions
* test: seed prompt manager capabilities in authorization fixtures
* fix: clear acknowledged linked prompt edits before version restore
* test: adapt merged chain coverage to prompt-aware payload helper
---------
Co-authored-by: Lia <lia@librechat.ai>
* fix: persist approval provenance in the resume claim and publish the pre-claim paths from any unapplied abort
The claim CAS now records the provenance it replaces. An abort that lands
before the resumed provider crosses its start CAS publishes those paths, so
schedule deletion, account deletion and user stops no longer label
model-authored chunks as user-submitted.
* test: add approval provenance scenario on the shared approval e2e helpers
* test: seed an earlier started segment before the unapplied abort case
* fix: label abort provenance by the published content and persist the same selection
A path the approval claim added is user-authored only once its tool call
carries output in the abort content, so an abort between the provider
start CAS and the resumed tool keeps the pre-claim labels, and an ask
answer stamped by the abort route keeps its own. AbortResult.jobData
carries the selection so the persisted row matches the final event.
* fix: keep claimed non-tool provenance paths on an abort
Only tool-call paths wait for their resumed call to complete; a steer the
claim already found in the seed content needs no decision to apply.
* fix: count a completed tool call with an empty output as applied in abort provenance
* fix: check abort provenance on the unfiltered content and remap it onto the published parts
* test: type the abort provenance overrides with the job store field names
* test: assert the preserved paths when an unanswered ask aborts
* feat: Remember Tool Approvals Per Conversation
Adds an opt-in "Always allow" choice to the tool approval card. When
endpoints.agents.toolApproval.allowAlways is true, the server marks eligible
paused calls with allow_always; approving with scope "session" stores that
exact tool name on the conversation, and later runs in the same conversation
fold the stored names into the policy as exact-name allow entries.
The server enforces every step: the resume route rejects a session scope the
pause did not offer, eligibility is rechecked against the live policy before
storing, the list is written only through an owner-scoped bounded method, and
generic saves and imports cannot set or clear it. Admin deny and ask rules and
programmatic hooks still win, stored names are ignored under dontAsk or when
the flag is off, and native code tools stay under the code approval picker.
The flag defaults to false, so existing deployments keep prompting.
* fix: Share the Effective Approval Policy and Persist Allows After Resume Fences
Offering, resume re-check, scheduled admission and createRun now read one
policy from buildEffectiveToolApprovalPolicy: endpoint rules healed against
MCP alias spellings, then the conversation's remembered tools. A call held by
a healed ask rule is no longer offered "Always allow", and a scheduled fire
whose known tools are all remembered is no longer rejected as pause capable.
The remembered-tools cap and name length cap move to
toolApproval.allowAlwaysMaxTools and allowAlwaysMaxToolNameLength (defaults
64 and 256). The card stops offering the choice for new tools once the cap is
reached instead of silently approving once.
The resume route stores remembered tools only after the schedule and project
context fences pass; a storage failure still approves the call once.
* fix: Offer Always Allow Only When It Will Hold
Offer allow_always only when storing the name would auto-approve the next
identical call on the run's own path: every MCP spelling of the tool passes
the healed static policy and no programmatic or plugin approval hook can
apply to it (the pause payload does not record which hook asked).
Remembered names now expand to every alias spelling of the same tool, and a
deny or ask on any spelling keeps the tool ineligible. A table-driven spec
walks the invariant through the real hook wiring.
* fix: Recheck Approval Hooks Before Remembering a Resumed Approval
The resume-time eligibility recheck now applies the same programmatic and
plugin PreToolUse hook check as marking, with a hook context built from the
resume request and the live plugin hook source. A hook registered after the
pause turns the choice into a one-time approval: nothing is stored and the
resume continues.
Document that toolApproval.allowAlways should be enabled only once every
replica supports it, since older replicas ignore the choice.
* fix: Judge Always Allow Offers Against the Run's Live Aliases and Active Cap
* fix: Charge Only New Tool Names Against the Remembered Approval Cap
* fix: Recheck Remembered Approvals Against the Paused Run's Aliases
* chore: Sort Imports in Agent Run After Rebase
A conditional generation create that loses its predecessor fence is an expected admission outcome: the store rejects before replacing anything, an automatic continuation defers without consuming an attempt, and a client restores its queued turn. Sibling background-tool wake-ups for one conversation race this fence by design, which logged every lost race as an initialization error with a stack.
Route the controller's initialization-failure log through a typed packages/api helper that logs a predecessor mismatch as a concise warning with the stream, conversation, continuation flag, and whether the current generation is active, and keeps every other failure at error level as redacted text.