* feat: Let Dropdown work inside dialogs and take the field list roles
Inside a dialog the list renders in place, so the dialog's focus trap and
aria-hidden pass no longer cut it off, and it layers above the dialog. A
field Dropdown's list now takes listMinWidth, listMaxHeight and the icon
size role, and is never narrower than its trigger.
* refactor: Move the code tool selects onto Dropdown and remove Select and Combobox
The four code tool settings selects were the last users of the Radix
Select, and Combobox, its only other consumer, had none. Their tests and
the nested popover scenarios now drive the Dropdown.
* refactor: Read the Pane Conversation Through ChatSettings and Drop the Orphan Abort Scroll Atom
* test: Cover Returning to a Running Chat Through the Router
- GET /resolved resolves a group or user profile in the partition its document belongs to, as
writes judge it: for an admin without a tenant reading a tenant's profile, that tenant's
librechat.yaml and __base__. GET /catalog resolves such a scope there too, instead of
answering 404, and GET /effective finds a user by id the way profiles are addressed and
resolves them in their own tenant: their role, groups and documents there.
- findPartitionUser becomes findPrincipalUser, which also returns the user's tenant.
- Admin role operations address the role of the caller's tenant partition: the role lookup
(getPartitionRole), listing, creation's name check, the members a rename migrates or a deletion
reassigns, the members listed and counted, and the ACL entries (deletePrincipalAclEntries) and
grants a deletion removes. A member added or removed by id must be a user of that partition.
- getRoleByName, which every request's permission checks read, reads the role of the caller's
partition too: outside a tenant and under the system context the platform-level one, never an
older tenant role of the same name. updateRoleByName without an id and updateAccessPermissions
for a role read without its _id write that role, so the legacy permission route changes the
platform role. The grants route checks a role exists with getPartitionRole.
- runInPartition moves a read into another partition only from outside a tenant, and rejects
leaving an active one.
- deleteGrantsForPrincipal and findGrantsForPrincipal without a tenantId reach only
platform-level grants, as moveGrantsToPrincipal does.
- updateRoleByName takes { id } to change one role document; renames, their rollback,
description updates and updateAccessPermissions write the document they read.
- The exported keyed rename helpers (applyConfigChange rename, renameConfigEntryTombstones)
refuse a new name no keyed path can address, as the admin routes do.
Move every local prompt group and native-revision read and write behind
one PromptStore (createPromptStore) and reduce the native adapter to
resolvePrompt, the contract the Langfuse adapter already has. The
service receives { store, sources } and dispatches resolution by group
source. Service behavior, errors (including unsupported), database
calls and result shapes are unchanged.
Co-authored-by: Rebase Probe <probe@example.com>
* chore: Update package dependencies across multiple modules
- Upgraded `@azure/identity` to version 4.14.0 in package.json files.
- Updated `multer` to version 2.5.0 and `nodemailer` to version 10.2.1.
- Incremented `undici` to version 7.30.1.
- Updated `@happy-dom/jest-environment` to version 21.0.4.
- Incremented `qs` to version 6.16.1 and `fast-uri` to version 3.1.9.
- Updated `serialize-javascript` to version 7.1.4.
- Updated `zod` to version 4.6.7 in multiple modules.
These updates ensure compatibility with the latest features and security improvements.
* chore: update bun.lock file
* fix: Close Gaps in the css-colors Triplet Check and the Disabled-Recipe Rule
The triplet check now reads angle channels, and the disabled-recipe rule accepts spelled recipes under the same or fewer enclosing variants, resolves cva and constant class strings, and handles spread strings, per-dim primitive coverage and implied selectors.
* fix: Read Recipe Markers Anywhere in the Variant Stack and Keep Object Spreads
* test: Cover Spelled-Out Disabled Recipes in the Design Lint Scenario
* fix: Keep Stateful Arbitrary Disabled Selectors Unrestored and Order Arbitrary Enclosing Variants
* fix: Order Enclosing Variants Whenever an Arbitrary Selector Is Present
* fix: Pin the Disabled Marker Position When Arbitrary Variants Enclose a Dim
* fix: Order Child Selector Variants Like Arbitrary Ones
* fix: Skip Unplaced Disabled Variants and Read Math Functions by Token
The disabled-recipe rule now skips utilities under arbitrary variants it cannot place instead of guessing how a recipe orders against them, and unwraps TypeScript assertions on spread and class-map recipes. css-colors classifies any innermost math function by its tokens, so rounding strategies and constants no longer hide an angle-led triplet.
* fix: Read Any Fixed Math Function as a css-colors Channel
A math function over numbers and angles is a fixed channel in any position, so unit cancellation (calc(90deg / 1deg)) needs no unit algebra, and trigonometric functions and sign are fixed whatever their arguments (atan2(1px, 1px), sign(90deg)).
* fix: Unwrap Constant Class Strings and Honor Class-Map Overrides
A const initializer under as const or satisfies is read like a plain string, and a class-map recipe entry no longer counts when a later spread or the same key can overwrite it.
* fix: Keep Angle Math Results and Disjoint Spreads Out of Overrides
An angle-valued math result stays an angle, so it reads only as a leading hue, and a later object-literal spread invalidates a class-map recipe only when it sets the same key.
* fix: Place Valued data-disabled Self Selectors in disabled-recipe
* feat: Branch Tool Fold Rails Into Each Row
Draw each open fold's rail as a trunk with a curved branch into every
row, measured from the rows themselves. Hovering a row lights the route
along the tree: out of the previous branch, along the trunk and into the
new one, at a steady pace. Layout changes under a still pointer (folding,
streaming, scrolling) re-hit-test instead of clearing the path.
* fix: Retrace the Fold Path When Its Row Moves Mid-Trip
A row that moved while the lit path was still traveling to it kept the
trip measured to its old position, so the path ran the old distance and
jumped the rest. Start a fresh trip from the path's current position
whenever the destination row moves.
* test: Cover the Tool Fold Tree With Scenario Specs
One tagged Playwright scenario per contract behavior: branches into each
row, the hover route from the header, nested folds, travel along the
tree, a click that unfolds the hovered row, reduced motion, right-to-left
mirroring and touch.
PromptService gains importSourceGroup, which finds or creates a source
pointer group, grants the PUBLIC viewer role and rolls the group back if
the grant fails. The Langfuse catalog sync calls it instead of four
storage callbacks and two Mongo error predicates, and the prompt service
is composed once in api/server/services/Prompts.js and passed to the
prompt routes, linked instructions, instructions prompt access and the
Langfuse sync runner.
Co-authored-by: Rebase Probe <probe@example.com>
* feat(prompts): sync Langfuse prompts into the catalog
* refactor(prompts): compose the Langfuse prompt sync runner outside the admin handler
Add createLangfusePromptSyncRunner, which binds the lock, the prompt-group
methods, the ACL grant and the Mongo error predicates once and returns a
runner that takes the per-request source, connection-bound listPrompts,
lock lease and page cap. The admin handler receives that runner as one
dependency instead of forwarding its parts, and its config method
signatures return a LangfuseAdminConfig interface in place of Mongoose
document types.
In api, api/cache/distributedLock.js creates the one DistributedLock for
the process and api/server/services/LangfusePromptSync.js composes the
runner once with it; the admin route imports the composed runner.
* fix(prompts): report incomplete Langfuse syncs and gate the sync action
- Refresh the prompt-group and effective-permission queries after a failed
sync too, because earlier imports can already be committed.
- Return `complete: false` when the page limit stops a sync before the last
upstream page, and show a warning instead of the success message.
- Show the Sync prompts action only to users with `manage:prompts`, the
capability the sync route requires. Resolve the Langfuse startup-config
capabilities in one batched lookup.
- Document that an interrupted import can leave a group without its initial
PUBLIC grant, and that a page in progress can outlast an expired lease.
---------
Co-authored-by: Rebase Probe <probe@example.com>
Reject edits, deletes, new revisions, promotion and revision deletes on
prompt groups whose source is not native with a read_only service error,
mapped to 403 "Externally managed prompts are read-only". The guard reads
the stored group, so the MANAGE_PROMPTS bypass is covered. Sharing,
usage counts and resolution are unchanged.
The client hides Edit and Delete for external groups, shows a read-only
detail view with a Langfuse notice and keeps Share.
The prompt service dispatches resolvePrompt by group.source. A read-only
Langfuse adapter fetches the text prompt on each use, with no cache, after
a resolver checks the deployment gate, the tenant, prompt sync, the
connection and the stored source identity. GET
/api/prompts/groups/:groupId/resolve returns resolved content for native
and Langfuse groups, with a per-user limit set by rateLimits.promptResolve
(default 60 per minute). Agent-instruction links stay native only.
* feat(prompts): add source identity to prompt groups
Add source, sourcePromptName, sourceProjectId and sourceDestination to
PromptGroup. productionId is required only for native groups. A unique
partial index on the source identity covers only groups that have
sourcePromptName, so native groups need no migration.
The create path drops client-supplied source fields, and the native
create upsert does not match langfuse groups. Records map a missing
source to native.
* fix(prompts): centralize sources and restrict native group matching
* feat(langfuse): test prompt listing and resolution from settings
Add a dry-run dialog in Settings > Langfuse that lists Langfuse prompts
and resolves one text prompt (production label or an exact version)
through the tenant's Langfuse connection. Nothing is written. A tenant
user's prompt reads never use the central env keys, even while
TENANT_ISOLATION_STRICT is off.
DevOps makes the feature available with LANGFUSE_PROMPT_SYNC_AVAILABLE
(timeout LANGFUSE_PROMPT_SYNC_TIMEOUT_MS). The tenant admin turns it on
with langfuse.promptSync.enabled.
Related: Linear AI-2271, ClickHouse/ai#4032
* fix(langfuse): isolate prompt credentials and expose prompt settings
Use stored credentials with deployment headers for prompt reads.
Show the settings tab when connection editing or prompt sync is available.
Keep connection controls and trace links under their existing gates.
Audit prompt-sync updates and reuse shared prompt response types.
* feat(api): add shared source-author and distributed-lock helpers
Lift makeSourceAuthorId out of the GitHub skill sync into
packages/api/src/utils/author.ts and add createDistributedLock in
packages/api/src/cache/lock.ts (Redis SET NX PX with owner-checked Lua
extend/release, in-process Map fallback without Redis). The skill sync
call site uses the shared helper; author ids are byte-identical.
* refactor(data-schemas): accept hex-string skill author in createSkill
CreateSkillInput.author takes a Types.ObjectId or a 24-hex string, and
createSkill builds the ObjectId once for both the uniqueness check and
the insert. The GitHub skill sync passes the makeSourceAuthorId string
as-is, so no Mongoose conversion remains at that call site in
packages/api.
* fix: validate skill authors and verify lock cleanup and ownership
---------
Co-authored-by: Rebase Probe <probe@example.com>
- A group a layer names that the config below does not serve (one a lower layer's tombstone of
a field inside it, or of its groupMap entry, left unable to resolve) gets no key from the
YAML-shaped group: a higher layer that re-supplies the field and a new instance or base URL
no longer sends librechat.yaml's key there.
- /changes and PATCH report unknown_spec_endpoint only where the write touches the spec, so
hiding, removing or unsetting the endpoint a profile's stored spec selects is no longer
refused; the merge leaves the spec out, as the single-field routes already allowed.
- Without CONFIG_REDERIVE_ENDPOINTS, a layer's Azure groups and its tombstones of them (whole,
keyed or inside a group) are listed as endpoint_rederive_off in each resolution layer, in GET
ignored and in the /changes report. With it, a keyed tombstone that leaves its group unable to
resolve is listed as azure_groups_unresolved. Keyed tombstones are located by entry key.
- The startup report lists documents whose only Azure override is a keyed group tombstone.
- Docs: hides never refused for the specs they take, the new ignored reasons.
* 🧬 feat: Re-Derive Azure Groups, Vertex AI, Custom Parameters and Spec Defaults for Config Profiles
AppService derives part of the served config from librechat.yaml at startup, and config
profiles merged into that output without deriving it again. Azure `groups` now merge by `group`
like `endpoints.custom` by `name`: a profile's partial group merges over the group of that
name, groups it does not name stay, indexed writes are refused, change batches take entry ops
on them, and groups that do not resolve over librechat.yaml and Base (or whose written `${VAR}`
is not set) answer `invalid_azure_groups`. Each merged group keeps the key below it unless the
profile supplies one, so the rebinding guard drops a key a partial item moves and a key a lower
layer dropped stays dropped; Azure re-entry compares groups merged the same way.
With `CONFIG_REDERIVE_ENDPOINTS=true` (opt-in for this release), a profile's Azure `groups`
resolve into what the Azure clients read (unconditional before, now behind the switch so stored
group overrides do not go live on upgrade), a profile's `endpoints.anthropic.vertex` derives
`vertexConfig` and the Anthropic models it serves where librechat.yaml configures Vertex AI, and
the Azure Assistants endpoint follows a profile's `assistants`. Startup logs the documents that
hold such overrides, the groups that would not resolve over librechat.yaml and Base, and the
Vertex AI overrides that never apply. Always on: Vertex AI's key file and region are base-only,
a profile may turn Vertex AI on only where librechat.yaml configures it, its settings may
reference only librechat.yaml's own Vertex AI variables (reads return them resolved), a
profile's `vertexConfig` is never applied and writes skip it (`derived_path`,
`rules.derivedPaths`), a model's own `deploymentName` resolves its `${VAR}` like the default one,
the region, project ID and the deployment name each model's requests send (the model name where
the client sends it as written) must stay in their URL host label or path segment, a `${VAR}`
there is a whole `${NAME}` reference only, the Anthropic client refuses any other deployment name
before building a request, and an invalid setup answers `invalid_vertex_config`. The rebinding
guard no longer binds the derived Vertex AI region, which is librechat.yaml's.
Custom endpoint `customParams` are expanded by `expandCustomEndpoint` into the served copy, so
`appConfig.config` stays librechat.yaml as written, and each endpoint a profile writes is
expanded again from its merged form (a changed `defaultParamsEndpoint`, OpenRouter defaults
for a profile's own endpoint); invalid definitions answer `invalid_param_definitions`. After
tenant scoping, `getAppConfig` derives `modelSelect`, `parameters` and `presets` again for the
specs a principal is served where nothing sets them, the agents `memory` capability follows
the merged memory config, and a model spec naming an unconfigured endpoint answers
`unknown_spec_endpoint`. Meta flags: `azureGroupMergeKey`, `customParamsExpansion`,
`specInterfaceRederive` and `endpointRederive`.
* 🪜 fix: Judge Re-Derived Config on What Every Profile Layer Leaves
Two re-derivations decided whether a profile had set a field from whether any layer ever set
it, so a lower profile's value tombstoned by a higher one still counted as set.
- Vertex AI (CONFIG_REDERIVE_ENDPOINTS=true): the marker that keeps a profile's
`endpoints.anthropic.models` over Vertex AI's is cleared by a later tombstone of those
models (or of `endpoints.anthropic` or `endpoints`), and such a tombstone derives Vertex AI
again, so the Anthropic endpoint serves Vertex AI's models instead of none. A tombstone of
librechat.yaml's own models does the same.
- Spec-dependent controls: `modelSelect`, `parameters` and `presets` are derived again where
their served value differs from the base config's, not only where the librechat.yaml-shaped
value does, so a control one profile sets and a higher one tombstones, or a tombstone of one
librechat.yaml leaves unset, follows the specs served instead of being dropped.
The memory capability, Azure Assistants, Azure groups and custom parameters already derive
from the merged result; tests now cover each set in one layer and tombstoned in a higher one,
and the reverse.
* 🧮 fix: Derive Each Config Part From What the Layers Leave
A tombstone of an object above a derived part's inputs, alone or followed by a layer that
recreates part of that object, left the part without what startup derives it to:
- An Azure endpoint recreated after a tombstone of `endpoints.azureOpenAI` or `endpoints` had
no groupMap, modelGroupMap or model lists, so its model lists fell back to the environment's
default Azure models, which requests could not map to a group. It now serves no group, with or
without CONFIG_REDERIVE_ENDPOINTS (completeAzureResolution).
- A tombstone of the whole `interface` left modelSelect, parameters and presets out, which the
client reads as off. They are derived from the specs served into a new interface.
- A tombstone of `endpoints.agents` or `endpoints` left no agents endpoint, while a tombstone of
its capabilities served the defaults. The agents endpoint startup derives is served there.
- A tombstone of a Vertex AI setting that leaves the setup unable to load kept the vertexConfig
derived below it. Vertex AI is off there, with a warning.
A table in service.spec.ts runs every derived part against every way a layer changes its inputs
(set, unset, a tombstone of the path and of each object above it, a layer recreating after such
a tombstone, Base on either side, tenant scoping, the switch off) through getAppConfig, and
compares each cell with what startup derives from the librechat.yaml the layers leave.
* 🧭 fix: Serve Only Model Specs Whose Endpoint the Layers Leave
A tombstone of `endpoints.custom` or `endpoints` in a higher profile (or the Base profile)
left the model specs of the custom endpoints it removes served, librechat.yaml's or a lower
profile's: the spec list pointed at endpoints /api/endpoints no longer offers, with the model
selector, parameters and presets still off for them. The write check only ran when the write
held `modelSpecs.list`, and the merge served stored specs as they were.
After the last layer, the merge now serves only the specs whose endpoint is a built-in endpoint
or a custom endpoint the YAML-shaped config the layers leave defines, the rule startup skips
librechat.yaml's specs by (deriveServedSpecs). A removed endpoint hides its specs until a layer
defines it again; where no spec is left, none is served (as with a tenant-hidden endpoint) and
the spec-dependent controls come back on. Tombstones of a built-in endpoint's settings keep its
specs, as startup does, and `addedEndpoints` stays as merged. A stored spec for an endpoint that
is not configured is left out on its own instead of being served; writes of one still answer
400 unknown_spec_endpoint.
The derived-part table in service.spec.ts gains the model specs served (with addedEndpoints and
the controls they decide) against tombstones of `endpoints.custom`, `endpoints`, and each of
`endpoints.openAI`, `azureOpenAI` and `anthropic`: by a profile, by Base under a profile, a lower
profile under a higher one, recreated above or by the same layer, with no spec left, and with
the switch off.
* 🧩 fix: Reconcile Re-Derived Config With Dev's Keyed Tombstones, Write Report and Read APIs
- Keyed tombstones of Azure groups (endpoints.azureOpenAI.groups["g"], now merged by key)
resolve the groups left again where the merge resolves them, and stay inert without
CONFIG_REDERIVE_ENDPOINTS.
- Keyed tombstones count as touching endpoints.custom, so served specs and custom parameters
are derived again after one.
- The served-spec derivation keeps modelSpecs while added endpoints remain, as the hidden
endpoint scoping does; hidden endpoint names leave addedEndpoints.
- Derived paths join the held paths every write skips, built on first use.
- Tests follow the merged behaviour: Azure groups merge by group, the agents endpoint is
derived again below a tombstone.
* 🧻 fix: Keep Lighthouse Session Cookies Out of Failure Logs
* ci: Use Lockfile-Pinned Chromium for Lighthouse
* ci: Align Lighthouse Browser Launch With Playwright
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🏷️ feat: Hide and Rename Custom Endpoints by Name in Config Profiles
Config profiles merge `endpoints.custom` over librechat.yaml entry by entry on `name`, but
could not take one entry away. A tombstone that named one, such as `endpoints.custom["Name"]`,
passed every check, was stored with a 200 and did nothing, because the merge removes object
paths only and stops at arrays; a tombstone at a position (`endpoints.custom.0.headers`) was
stored and did nothing either. Renaming a profile's own endpoint through PUT or PATCH lost its
stored key, since the `renames` hint covered MCP servers only.
POST `/fields/tombstone`, DELETE `/fields` and the `tombstone` and `unset` ops of a change
batch now take a keyed path, `endpoints.custom["<name>"]` or
`endpoints.custom["<name>"].<path>`, whose name is a JSON string compared as the merge folds
it. A tombstone hides the inherited endpoint, or one of its fields or record keys, for the
profile's principals and removes the profile's own entry or path; hiding an endpoint also hides
the model specs that select it, whether librechat.yaml or a lower profile defines it. An unset
resets the profile's own entry or path with the keyed tombstones at or below it, and writing an
entry clears the tombstone that hides it whole. Malformed keyed paths, keyed paths after arrays
not merged by key, the entry's name, its key, preview or destination fingerprint, keyed writes
and positional tombstones answer 400, and the store's keyed mutations refuse a location whose
stored tombstone would name another path. A `segments` target names keys as written on every
route, so a segment such as `custom["Name"]` never reaches an entry past these guards: a write
by it stores a key of that spelling and clears none of the entry's tombstones. A stored
tombstone reads as keyed only after an array merged by key, so an older one such as
`mcpServers.a["b"]` keeps hiding that server.
PUT and PATCH `renames` also take `{ path: 'endpoints.custom', previousName, name }`: the
renamed entry gets the stored ciphertext and preview, and the keyed tombstones of the old name
move to the new one, as they do for a batch `rename`. The carried key stays bound to its
destination (400 `CONFIG_SECRET_REENTRY_REQUIRED` when the renamed entry sends it elsewhere)
and keeps the destination fingerprint it was entered with; a hint that cannot apply answers 400
`CONFIG_RENAME_INVALID` with a reason. Removing the destination of a profile's own keyed entry
beside its stored key needs the key again, and removing an inherited one drops the inherited
key at merge and lists it in `ignored`.
The merge-key registry moves to its own module so mutations can match entries by identity
without an import cycle. Meta reports `keyedTombstones` and `renameHints`,
`rules.renameHintPaths` and `limits.maxEntryKeyLength`, and `docs/endpoint-overrides.md`
documents the contract.
* 🙈 fix: Scope Hidden Endpoint Allow-Lists and Refuse Duplicate Rename Sources
- A hidden custom endpoint leaves endpoints.agents.allowedProviders as it
leaves modelSpecs; scopeHiddenEndpointSpecs becomes
scopeHiddenEndpointReferences.
- modelSpecs collapses only when no spec and no added endpoint remain, so
unrelated addedEndpoints survive when the hidden endpoint owned every spec
(tenant scoping shares the helper).
- An addedEndpoints or allowedProviders list that names only hidden endpoints
is kept whole: an empty list allows every endpoint.
- Two endpoints.custom rename hints from one previousName answer
CONFIG_RENAME_INVALID duplicate_source; MCP hints may still duplicate a
server.
* 🔀 fix: Keep Keyed Tombstones Whole Across Dev's Patch Steps, Write Report and Resolved API
- PATCH resets (dev's request-ordered steps) still move a renamed entry's
keyed tombstones, in validation and in the stored state; lifted
tombstones come from one data-schemas helper for both paths.
- The write report of POST /fields/tombstone and DELETE /fields names a
keyed location by its keyed path, collection, key and entryPath, as a
change ref does, instead of the bare collection.
- resolveConfigLayers scopes the model specs and allow-lists of hidden
endpoints as getAppConfig does, so the resolved API keeps its parity.
- GET /meta reports maxEntryKeyLength beside dev's catalogModelsTtlMs.
* 🧾 feat: Admin Config Write Report, Structured Issues and Deployment-Only Paths
Admin config writes dropped what the API never stores (base-only sections, interface
permissions, dedicated sections) with a 200 and no word of it, stored values nothing reads
(boot-time and operator-only settings, overrides of MCP servers librechat.yaml runs as local
processes, tombstones inside arrays), answered most 4xx without a stable code, returned
validation issues without the bound or option that failed, and refused every admin write
once the terms-acceptance modal was on for an admin who had not accepted it, including the
write that turns it off.
PUT, PATCH /fields, POST /fields/tombstone and DELETE /fields now answer with `applied` and
`skipped` (with a reason per location); a whole `interface` PATCH keeps its UI fields;
base-only paths are skipped on every route. A new DEPLOYMENT_ONLY_CONFIG_PATHS list (rate
limits, CloudFront, permission leases, OpenAPI, skill deletion, the tool filters, the agents
and MCP boot settings, `cache`) is skipped on write, kept at librechat.yaml's value by the merge
and published in GET /meta. Writes and tombstones inside a librechat.yaml stdio MCP server
answer 400 PROCESS_MCP_SERVER_OVERRIDE, and a whole-section value leaves those servers out.
GET of a document lists what the merge leaves out of it (`ignored`, `ignoredBasis`).
Validation issues carry allowlisted `params`; each refused allowedAddresses entry is one issue
with a `reason`; agent recursion limits must be whole numbers of at least 1, and the runtime
ignores any other value. The config handlers' 4xx carry a `code`, the capability middleware adds
AUTH_REQUIRED/FORBIDDEN, and the admin config router opts out of the terms gate. PATCH checks a
section manager on every section it names, skipped entries included, as /changes does. New meta
flags: writeReport, issueParams, adminTermsExempt.
* 🧪 test: Expect Issue Params in the Whole-Document Override Validation Scenario
Validation issues now carry `params` (here the expected and received types), so the scenario that
asserts the exact issue list for a rejected PUT expects them too.
* 🧪 test: Cover Merged Read Codes, Tenant-Scoped Read Reports and Deployment-Only Resolution
* 🔭 feat: Admin Config Read APIs (Resolved and Effective Config, Scope Catalog, Env Status)
Admin clients could read one config document at a time, or the deployment's merged config,
but nothing showed what a profile or a user resolves to: a client had to re-implement the
merge (Base-first precedence, merge keys, tombstones, the interface permission filter,
base-only fields, runtime stops, secret rebinding, the env allowlist) to preview it, and had
no way to see why part of a profile is ignored. Endpoint, model and tool pickers came from the
end-user routes, called as the signed-in admin, so they showed the admin's own scope and keys
and needed a browser User-Agent.
The admin config API now has four read routes. GET /resolved/:principalType/:principalId and
GET /effective?userId= return librechat.yaml, the documents that merge over it in merge order,
each with the parts the merge does not apply and why, and the result, in librechat.yaml shape.
They come from resolveConfigLayers, which tracks the same fold the served merge runs and is
pinned to it by parity tests, and from the stored documents rather than the override cache.
GET /catalog lists the endpoints (with the reason one is not served), models (served,
configured and defaults), MCP servers and tools a scope serves, resolved for the scope rather
than the caller and never with a user's stored key; GET /env-status reports whether each env
name the config uses is set, never its value. Every read is filtered to the sections the caller
can read, redacted as reads redact, and scoped to the caller's tenant. The admin Langfuse routes
now say why a deployment offers no connection settings. Meta reports resolvedApi, catalogApi,
envStatus and limits.catalogModelsTtlMs.
* 🪞 fix: Report Duplicate Custom Endpoints from the Served Definition
When librechat.yaml defines a custom endpoint name twice, or both `Ollama` and `ollama`, the
catalog kept the first definition for a name's env names, reason and models, while
`loadCustomEndpointsConfig` serves the last servable one. An entry could pair the served config
of one definition with the env names of another.
`resolveServedCustomEndpoints` now holds the runtime rule (the last definition with a name, key,
base URL and models wins under its served name), and `loadCustomEndpointsConfig`,
`loadConfigModels` and the catalog all use it. A name with no servable definition is reported
from its last one.
* ⏱️ feat: Make the Admin Catalog Model-List Lifetime Configurable
`GET /api/admin/config/catalog` reused a scope's model lists for a fixed two minutes. The new
librechat.yaml field `endpoints.catalogModelsTtlMs` sets that lifetime (milliseconds, `0` to one
hour, two minutes by default); `0` resolves the lists on every read. It is a base-only path, so a
profile cannot change it and `GET /meta` reports one value, now read from the deployment's config
on each request as `limits.catalogModelsTtlMs`.
* fix: align image authorization and static serving paths
* test: type image HTTP fixtures and assert direct denials
* test: alias the production image static middleware import
* fix: preserve unambiguous stored avatar path references
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🪵 fix: Explain Failed Attachment Copies and Subagent Start-Up Failures
The attachments .gitignore and import failure warnings logged only a bare
error type: getSafeErrorMetadata reads `status`, which a workspace tool error
does not carry. They now log the request outcome, upstream status and the
worker's error code, never a body or host path. A worker that reports the
folder missing (one that predates LibreChat-AI/code-interpreter#360 on a
root registered by path alone) is reported to the user as needing an update.
A subagent that could not start was logged only as the SDK's `unknown`
resolution cause. The run now passes onSubagentResolutionFailure, which logs
the underlying cause chain (name, code, status, redacted message) and names
an MCP server that needs re-authentication. A detached child thread shows the
SDK's model-facing start-up message instead of a generic failure, and its
failure log carries the task id, resolution cause and a redacted error in
place of the raw stack.
* 🪵 fix: Log Only Trusted Error Text and Recognize the Legacy Missing-Path Reply
- Cause chains keep a message only for errors whose text LibreChat or the SDK
composes (MCP authentication errors, SubagentResolutionError,
CodeWorkspaceSelectionError); every other link logs name, code and status.
Child-thread failures log stack frames without the message line instead of
redacted error text.
- A retryable MCP refresh or rejection is logged as a sign-in failure a retry
may clear, not as one that needs re-authentication.
- A worker's missing attachments folder relayed by an older Code API as
INVALID_PATH "Workspace path does not exist" is also reported as
unsupported, through the shared isWorkspacePathMissing check.
* 🪵 fix: Log Frames Only From a Verified Stack and Keep OpenID Out of MCP
- Stack frames are read only after the stack's own name: message header, and
only when that header still matches the error, so a message line shaped
like a frame is never logged.
- OpenIDReauthRequiredError alone is no longer reported as an MCP sign-in
failure: model and endpoint headers raise it too.
* 🚦 ci: Throttle Codegraph E2E Votes to One Run per Window
A vote runs the whole mock suite on ten runners, about 154 job-minutes, and
every merge to dev started one: 2,227 job-minutes on 2026-10-22, queued beside
PR CI for the same runners.
With repo variable CODEGRAPH_E2E_VOTE_MIN_HOURS set to N > 0, the votes
workflow skips its push runs (in a concurrency group of their own) and the new
Codegraph E2E Vote Gate decides instead: a merge starts a vote on dev
(workflow_dispatch) once the newest started vote is N hours old, and an hourly
catch-up votes the newest merge no vote covers once the window opens. A merge
votes as before while the catch-up has not run for three hours or the history
cannot be read. Unset, empty or 0 keeps today's push-triggered votes and skips
the gate; CODEGRAPH_E2E_VOTES=off still stops both.
The decision is a pure function in .github/scripts/vote-gate.mjs, tested in
vote-gate.test.mjs and run beside the shard tests in playwright-mock.yml.
* 🚦 fix: Keep an Unfinished Handoff Run from Covering Its Merge
With the throttle on, a merge creates the votes workflow's push run, whose
vote job will be skipped, and the gate's push run at about the same time.
Until that handoff run completed, the gate read it as a queued trial: it
matched the merge on head_sha, so the merge started no vote and waited for a
later catch-up tick, and it also held the window as a started vote.
While throttled, a push run that has not completed is now read as a handoff:
it neither covers a merge nor holds the window. A finished push run that
voted still counts as before.
Profile writes are judged in the tenant partition the profile merges in. For a role, or a
caller inside a tenant, that is the caller's partition. For a group or user profile written by
an admin without a tenant, it is the stored document's tenant: PUT, PATCH and POST …/changes
validate on librechat.yaml as that tenant resolves it with that tenant's __base__ over it, use
the same Base for the recheck after commit and for key binding, tombstones and field deletes
judge re-entry on that tenant's librechat.yaml, and every route reports `ignored` over that
tenant's Base. Each attempt reads the document in that partition only, and a document that
moved partition while the write ran answers 409 CONFIG_VERSION_CONFLICT. The config store's
partition rules are unchanged; another tenant's Base is read in that tenant's context.
Deleting a group, role or user clears the config caches when it removes or restores the
principal's profile (`invalidatingConfigStore`), awaited before the response and broadcast with
Redis as config writes do; a call that rejects clears too, since it may have committed.
POST …/changes lets `unset` remove any part of a top-level section configSchema does not
define; the section's own `unknown_section` issue is no longer blamed on the removal, and every
other op there still answers 400 UNKNOWN_SECTION.
POST /api/admin/config/reload, for an admin without a tenant holding broad manage:configs (a
tenant admin gets 403, since the reload reaches every tenant), runs the config cache clear without
a write, loads librechat.yaml again on the answering instance, and once it loaded publishes the
clear over Redis so every other instance loads the file on its next read. It uses
ConfigCacheInvalidation.reload, which reports the clear, the load and the publish instead of only
logging a failure (writes keep `invalidate`, which leaves the load to the next read). It answers
200 `{ success: true, broadcast }`, `broadcast` false without Redis; 422 CONFIG_RELOAD_INVALID
with each schema issue's location when the loader refuses the file, keeping the last good config
and publishing nothing; 500 CONFIG_RELOAD_FAILED when a clear fails or the config cannot be built
from the file; and 503 CONFIG_RELOAD_BROADCAST_FAILED when this instance reloaded but the publish
failed, since an instance that misses the broadcast keeps its cached librechat.yaml, which never
expires. Every reload that runs is audited as `config.reloaded`, a failed one with outcome
`failure` and its code. The meta reports `features.reloadRoute`. Writes still reload the file.
The e2e content-filter helper uses the route instead of a sentinel profile.
docs/mcp-overrides.md describes the current timing: the awaited clear, the Redis broadcast, what
still waits for a TTL, that a process the clear misses keeps its old librechat.yaml, and hiding
as an access boundary at checkout.
* fix: Theme the Retry Action Radius and the Select Arrow
* fix: Keep the Select Indicator Visible in Forced Colors
* test: Cover the Select Arrow Following the Text Color
* fix: Hide the Scrollbar on the Web Search Source Rails
The three horizontal rails carried a class Tailwind 3 never generated, so they still draw a scrollbar. They now use the app's hide-scrollbar helper; the links inside stay focusable, so the rails stay reachable by keyboard and touch.
* fix: Keep the Source Tab Panel Off the Suppression Backlog
* test: Cover the Web Search Source Rails Scrollbar and Keyboard Reach
* test: Force the Source Rail to Overflow Before Reading Its Scrollbar
* 🫳 fix: Close the Mobile Drawer When Selecting the Current Chat
* test: Date the Current Chat in Populated Drawer History
---------
Co-authored-by: Lia <lia@librechat.ai>
* chore: Update dompurify to version 3.4.17 across all package files
- Bumped dompurify version from 3.4.16 to 3.4.17 in package.json, package-lock.json, and relevant sub-packages.
- Ensured consistency in dependency versions across the project.
* chore: Update ip-address package to version 10.7.4 in package.json and package-lock.json
- Bumped ip-address version from 10.5.1 to 10.7.4 in package.json.
- Updated package-lock.json to reflect the new version and integrity hash.
* 🗻 fix: Keep Long Chats Stationary Under the Mobile Drawer
* fix: Preserve Pane Stacking Below the Drawer
---------
Co-authored-by: Lia <lia@librechat.ai>
* 📎 feat: Copy Chat Attachments into Attached Workspaces
A chat on an attached workspace now copies the user's own attachments into
.librechat/attachments/ before the model runs, through the worker's
import_file operation, and tells the model where they are. A worker without
the operation, a deny file-write policy, or a copy that fails or runs past
its bound leaves a plain note saying the file is not on this machine and why.
* 🧭 fix: Scope Attachment Records by Tenant and Prime Late Subagents
Match the tenant when recording a workspace copy, require write_file so the
folder can always ignore itself, key copies by the live Code API route and
worker, keep a digest when a copy fails so it is not hashed again, stop
waiting on bookkeeping at the deadline, refuse to start on a cancelled turn,
prime lazily initialized subagents through one per-turn primer, and make the
budget configurable as endpoints.agents.workspaceAttachments.timeoutMs.
* 🙈 fix: Copy Attachments Only Where the Folder Ignores Itself
Gate every copy on .librechat/attachments/.gitignore ignoring the whole
folder: create it with *, and accept an existing one only when it already
ignores everything, otherwise report the file as unavailable with how to fix
it. Prime a lazily routed subagent against its own tool context with a
provisioning callback bound to it, and check for a cancelled turn before
arming the deadline timer.
* 🪢 fix: Recheck the Attachment Ignore Rule Each Turn and Share One Request Cap
Drop the process-wide ignore cache and check the folder once per turn, shared
by every agent, rejecting a truncated read. Cap workspace requests per turn
across agents (workspaceAttachments.concurrency, default 3), name converted
images for their stored type, log only safe error metadata, and keep the
bookkeeping write from advancing updatedAt.
* 🔀 chore: Take dev's File Methods Ahead of Merging dev
dev and this branch both add to the same lines of the file methods module.
Take dev's version here so the merge of dev that follows is clean; the next
commit adds recordFileWorkspaceImport back beside dev's new methods.
* 🧩 fix: Ignore Workspace Operations a Newer Worker Advertises
Bring recordFileWorkspaceImport back beside dev's new file methods after the
merge. Drop well-formed operation names this build does not know from a
worker's capabilities, globally and per workspace, instead of rejecting the
whole status, so workers can turn on new operations such as import_file by
default. Known names keep their strict checks, malformed lists are still
refused, and a worker offering only unknown operations offers no workspace
tools rather than failing.
* 🧷 fix: Close Only Scheduled MCP Authority at Request Cleanup
resolveScheduledMCPBearerConfig runs on every MCPManager.callTool, and it
threw ScheduledMCPBearerError('binding_mismatch') whenever the request
context had started cleanup, before checking whether the context was
scheduled at all. A detached subagent keeps its parent turn's MCP request
context; once the parent turn ended, every pooled MCP call from the child
threw that error, and with no scheduled identity bound the receipt
recorder fenced it as "Scheduled generation is no longer current."
Unscheduled contexts now return the declared config before the cleanup
check, as pooled calls did before #16699. A scheduled context still
denies after cleanup (scopes are never cleared), quiesce stays
unconditional, and request-scoped servers still refuse a closed context
at connection checkout.
* 🧪 test: Cover Pooled Connection Creation After Request Cleanup
The pooled-call integration test made its first call before cleanup, so
it only reached the resolver on connection reuse (MCPManager.callTool).
A detached child's first call to a server its parent never used, or a
call after idle eviction, creates the pooled connection instead
(UserConnectionManager -> MCPConnectionFactory). The new case cleans the
context first and then makes the first pooled call, so a cleanup check
added at either creation site now fails CI.
The resolver comment now says why the early return is safe for every
unscheduled context: request-scoped checkout refuses a closed context.
* 🔐 feat: Admin Config Secrets v2 (MCP and Azure Credentials, Re-entry, Env Allowlist, Rebinding)
The admin config API stored MCP server credentials and Azure group keys in plaintext, returned
them to config readers, let an admin who cannot read a stored credential send it to a host of
their choosing, and let override values reference any environment variable. MCP credentials
and Azure keys, in `groups` and in the `groupMap` the Azure clients read, are now encrypted
with masked previews, hidden from every read and decrypted once after the merge. A write that
keeps a stored MCP credential or web search key while changing where it is sent must enter it
again, judged by the value the written document holds. `${VAR}` references in overrides are
limited to an allowlist, named where a change batch leaves them, and the merge drops a
credential a layer moves to a new destination without entering it, listing it in write
responses only for sections the caller can read. A custom endpoint's key is bound to its base
URL, its provider and the destination options in addParams and dropParams (such as the
anthropicApiUrl the native Anthropic client sends to), matched across layers under the name the
merge folds (ollama is Ollama). A restated `${VAR}` counts as entered, so allowlisted names
are not bound to a destination. Azure's `${INSTANCE_NAME}` and `${DEPLOYMENT_NAME}` stay
templates in a group's `baseURL`, and a scheduled job's MCP consent no longer depends on the
masked previews that change when an admin rotates the key in place.
* ♻️ refactor: Move the MCP Key Re-entry Guard Out of the Binding Helpers to Break an Import Cycle
With #17351's OpenID provisioning on dev, the app config service reached itself through the
rebinding guard: app/service -> app/overrides -> app/rebinding -> mcp/registry/binding ->
mcp/errors (and mcp/types) -> mcp/oauth/obo -> utils/identity -> auth/openid -> auth/provision
-> app/resolve -> app/service. The binding helpers are pure diffs; only
requireApiKeyReentryForRebinding needs the MCP error class, so it moves to
mcp/registry/reentry.ts, and the helpers take MCPOptions from librechat-data-provider as
mcp/headers.ts does. No behaviour changes.
* 🧪 test: Drop a Base-Held Endpoint Key That a Lower-Priority Profile Moves
Base merges first since #17352, so a profile below Base's priority still
lands over it. The rebinding guard drops the key Base stores for a custom
endpoint whose baseURL the profile changes, and the PATCH response lists
it in `ignored`.
* 🔐 fix: Serve Admin Azure Group Keys and Keep Deployment Keys at Their Own Destinations
Azure groups a profile writes now take effect: the merge resolves a layer's
`endpoints.azureOpenAI.groups` as AppService resolves librechat.yaml's
(`resolveAzureGroups`, shared with `azureConfigSetup`) into the `groupMap`,
`modelGroupMap`, model list and assistant models the Azure clients read. A
layer's groups replace the groups below whole, as its array does; groups that
do not resolve stay unread with a warning. The rebinding guard judges the
resolved groups like any `groupMap` entry, and an Azure group's destination now
also covers a deployment name its base URL takes its host from and the
destination options of its `addParams`/`dropParams`.
A write that keeps a stored Azure group key (in `groups` or `groupMap`) while
changing where the group sends it answers 400 `CONFIG_SECRET_REENTRY_REQUIRED`
on PUT, PATCH, field deletes, tombstones and change batches, judged as the
document resolves over librechat.yaml and on each `groups` item as written.
OCR fills an empty key from `OCR_API_KEY` only for its default destination (no
base URL, or `${OCR_BASEURL}`), so a key the guard dropped for an override's
`${VAR}` base URL is not replaced by the deployment's. The env reference policy
includes the `${OCR_API_KEY}` loading fills in for an `ocr` section without a
key, so a client can write back what GET `/base` returned.
The custom endpoint guard no longer needs the layer's overrides to name an
entry: an entry changed some other way is judged as inherited (positional
tombstones inside the list are not applied by the merge, so none reached one).
A web search URL a layer points at a `${VAR}` other than librechat.yaml's
without entering its key is set back: web search sends the deployment's key,
or its client's environment default, to any `${VAR}` URL.
* 🔐 fix: Keep Azure Assistants Served, Opaque Keys as Entered and Batch Env Checks on the End State
Azure assistants: a profile's `groups` replace the groups below whole, so
groups with no model that supports assistants under librechat.yaml's
`assistants: true` left `assistants` on with an empty `assistantModels`, and
the Azure Assistants initializer picked `assistantModels[0]` (undefined).
`azureConfigSetup` refuses that combination at startup; the merge now turns
`assistants` off when none of the models it leaves supports them, with a
warning, judged on the merged result so a later layer whose groups serve
assistants keeps them on. The check is `lacksAzureAssistantModels`, shared
with `azureConfigSetup`.
Opaque credentials: every runtime reader of the OCR, speech, web search and
Langfuse keys uses the decrypted value as is (`resolveConfigSecret`,
`resolveStoredConfigSecret`, `decryptConfigSecret`), so a `${...}` inside a
key the write encrypts is part of the key. Those fields are marked `opaque`:
the write-time check skips a value the write encrypts there, and the runtime
pass keeps their ciphertext instead of blanking it. A whole `${VAR}`
reference there, which the field passes through and its reader resolves, is
still checked, and so is stored plaintext. Custom endpoint (`initializeCustom`),
Azure group (`mapModelToAzureConfig`) and MCP (`processMCPEnv`) credentials
are expanded by their clients once decrypted and stay checked; the Assistants
keys have no reader yet and stay checked too.
Change batches: env references are judged on the document the batch leaves,
as its other issues are. An issue counts only when the end state still holds
a disallowed reference (ciphertext by its plaintext) where the batch sent one,
at a location the batch changed, so a value a later op removes or replaces
(`set ocr.baseURL`, then `unset ocr`) is no longer refused, and a stored
reference the batch puts back where it was is left to merge time.
* 🔐 fix: Proxy-Bound OAuth Secrets, Consistent Azure Group State, Batch Issues by Entry Key and Loaded Web Search References
- The MCP proxy is part of the OAuth client secret's binding (user tier, admin re-entry and the
merge's rebinding guard share `getChangedOAuthSecretBindingFields`): the access token the
secret obtains travels through it.
- A tombstone of `endpoints.azureOpenAI.groups` resolves the groups to none in the merge (empty
`groupMap`, `modelGroupMap` and model lists, so the model list does not fall back to the
environment's defaults), and removes what they resolve to in `applyConfigTombstones`.
- The merged Azure model lists name only models a merged group serves
(`narrowAzureServedModels`), so an override's `assistantModels` no group serves no longer keeps
Azure assistants on.
- `/changes` env issues are held by entry identity (`toConfigIdentityPath`), followed through
renames and resolved on the batch's end state, so a removal or rename no longer shifts them.
- References loading librechat.yaml introduces (OCR's `${OCR_API_KEY}`, the web search defaults)
are allowed at the location they are loaded at, so GET /base's sections are accepted written
back, and nowhere else.
* 🔐 fix: Re-entry for Endpoint, OCR and Speech Keys, Own Keys Bound Over Base and User Key Destinations Kept
- The document that stores a custom endpoint, OCR or speech key can no longer
move its destination without the key: PUT, PATCH, field deletes, tombstones
and change batches answer CONFIG_SECRET_REENTRY_REQUIRED at the changed field
(getBoundKeyReentryIssues), judged by value as the document alone sends it.
- A profile's own key for an endpoint, MCP server, OCR or speech service, or
Azure groupMap group that Base defines is bound to that destination when it
is entered: the rebinding guard reports a fingerprint of where it goes, the
write stores it beside the key (<secret>Binding), and the guard keeps the key
there until a lower layer moves it. Reads and the merged config leave the
fingerprint out; kept keys carry it; client values are replaced.
- An inherited custom endpoint or MCP server that sends a credential each user
holds (user_provided, customUserVars, apiKey.source user, OpenID or Graph
token placeholders) keeps its destination: a layer's move is set back and
listed in ignored.
* 🪜 fix: Base-First Config Precedence, Profile Lifecycle and Role Renames That Keep Their Profile
Config documents merge in one total order (`compareConfigPrecedence`): Base (`role` /
`__base__`) first whatever its priority, then ascending priority, then role < group < user,
then document `_id`. The merge, `getApplicableConfigs` and `listAllConfigs` all use it, so a
tie no longer goes to the newest document whatever its type, and Base no longer outranks a
profile through its priority. A profile that writes fields of a librechat.yaml MCP server
therefore undoes a Base hide of that server for its principals. A write that creates a document
without a priority gives it its principal type's default (role 10, group 20, user 100, Base 0),
and a write that omits the priority keeps the stored one, so a broad PUT no longer resets a
profile to 10. Langfuse writes no longer pass a priority.
Profile writes (PUT, PATCH `/fields`, POST `/changes`) validate on librechat.yaml with the
active Base document resolved over it (`resolveRawConfig`, the fold the merge itself runs), so
a role write that is valid where it lands is accepted and one the merge would strip is refused.
Base still validates on librechat.yaml alone, an inactive Base is ignored, and `/changes` still
judges what librechat.yaml itself defines on the raw YAML.
`PATCH /api/admin/config/:principalType/:principalId/priority { priority, expectedRevision? }`
sets only the priority, for broad `manage:configs`, keeping overrides, tombstones and
`isActive`; it is audited as `operation: 'priority'`. A write that would create a principal's
first document (PUT, PATCH `/fields`, POST `/fields/tombstone`, POST `/changes` including a dry
run or a priority-only batch) answers 404 `PRINCIPAL_NOT_FOUND` unless the role (exact name),
group or user (lowercase ObjectId) exists in the caller's tenant partition, or at platform
level outside a tenant (`principalExists`). Each route checks inside its compare-and-swap
write, against the document the write replaces; the tombstone route now plans its write like
the others, so `AdminConfigDeps` no longer takes `tombstoneConfigField`. A PUT with
`expectedRevision: 'absent'` creates the profile even when it carries no overrides.
Renaming a role moves its config profile, system grants and ACL entries to the new name in the
caller's tenant partition. The profile moves through the store contract (`movePrincipal`: a
create-only copy, then removal at the copied revision). A profile already at the new name
answers 409 `ROLE_CONFIG_CONFLICT`, and any failed step rolls back the users, the role document
and every move (500 `ROLE_RENAME_FAILED`). Profiles, grants and ACL entries that renames made
before this change left at an old name are neither moved nor removed, and a role created under
that name still picks them up. The Base principal id is a reserved role name (400
`ROLE_NAME_RESERVED`), and a legacy role by that name never moves or deletes Base. The admin
config meta reports `deterministicPrecedence`, `priorityRoute`, `principalCheck` and
`roleRenameMovesProfile`.
* 🧪 test: Give the E2E Reload Sentinel a Role of Its Own
Admin config writes now answer 404 PRINCIPAL_NOT_FOUND for a principal that does not exist, so
the content-filter helpers' reload sentinel (a made-up user id) could no longer write and every
spec that reloads librechat.yaml failed. The sentinel is now a role the helper creates once (409
when it already exists) and deletes after its profile in cleanup; no user is a member, so its
empty profile changes no one's config.
* 🛟 fix: Keep a Moved Profile Whose Removal Cannot Be Confirmed, Validate on the Caller's Base and Restore Rolled-Back Descriptions
- `movePrincipal` no longer treats a failed read-back of the source, after its removal
failed, as the source still being there. It keeps the copy, which may be the only one
left, and rethrows the removal's failure instead of deleting the copy.
- Profile writes read the Base validation floor from the caller's tenant partition, so a
caller without a tenant validates on the platform-level Base and never on a tenant's.
- A role rename that rolls back gives a role stored without a description the schema
default back, instead of a `$set` of `undefined` that kept the new description.
* 🧭 fix: Scope Profile Priority Changes to the Caller's Tenant Partition
`setConfigPriority`, behind PATCH `/api/admin/config/:principalType/:principalId/priority`,
read and wrote through the unpartitioned config store. A platform-level admin without a
tenant runs in the default non-strict context, where the tenant-isolation plugin adds no
predicate, so the route could reorder a tenant's profile for the same principal, and answer
with it, when no platform-level profile existed.
It now runs on the partitioned operations that the role rename and the partitioned
`findConfigByPrincipal` use. The read is limited to the caller's partition: that tenant's
document, or without a tenant only a platform-level one (no tenant, `null` or `''`). The
write is pinned to the `_id` of the document that read returned. A tenantless caller
therefore gets 404 `CONFIG_NOT_FOUND` for a profile only a tenant holds. An
`expectedRevision` naming such a profile gets a revision conflict and changes nothing.
Tests: `config.spec.ts` (data-schemas) adds "setConfigPriority in the caller tenant
partition". It covers the platform profile changing alone, a profile that only a tenant holds
being neither changed nor returned, and only the active tenant's profile changing inside a
tenant. The tenant helpers are now shared with the rename suite.
`config.precedence.integration.spec.ts` adds the same check through the handler. With the old
wiring, a tenantless PATCH of a profile only tenant-a holds answers 200 and moves tenant-a's
profile to 40. With the fix it answers 404 and tenant-a keeps 10.
* 🧷 fix: Roll Back Only What a Rename Changed and Validate Profile Writes on the Base They Land Over
- Grant moves report what they changed (re-keyed grants, and superseded grants whose removal
was confirmed); the undo re-keys only grants still at the new name and re-creates a
superseded grant only while the new name still holds the grant that superseded it, so a
grant revoked during a rename is never resurrected.
- The Mongoose binding settles a create whose acknowledgement was lost by the `_id` it chose
(found at version 1: committed, returned), as the store contract now requires; a profile
move whose copy committed finishes instead of leaving an orphan copy. The memory engine and
the conformance suite cover it, plus a copy that cannot be withdrawn being logged.
- A rename rollback moves back only the profile it moved (by identity, edits included), puts
back only members still on the new name, and reverts the description only while it is still
the one the rename set.
- PUT, PATCH /fields and POST /changes read Base beside the profile on every attempt and read
it again once the write commits; a write that Base changed under is judged on that Base and
withdrawn (only at the revision it wrote) when it fails there.
- The priority route rereads a lost race's current revision in the caller's tenant partition.