mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 14:08:21 +00:00
892 commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
39ecd5563c
|
✒️ fix: Bind Assistant Avatar Updates to Authorized Owners (#17391)
* ✒️ fix: Bind Assistant Avatar Updates to Authorized Owners
* test: Keep Avatar Regression Checks Lintable and Typed
* fix: Preserve Provider-Only Assistant Avatar References
* fix: Preserve Assistant Identity and Avatar Access Across Legacy References
* test: Align Legacy Avatar Authorization Projection
* fix: Initialize Managed Assistant References With the Provider Author
* fix: Require Verified Ownership Before Initializing Private Avatars
* fix: Commit Assistant Avatar Identity Before Owner-Aware Cleanup
* test: Seed Indexed Avatar Users With Unique Emails
* fix: Serialize Assistant Avatar Publication and Cleanup
---------
Co-authored-by: Lia <lia@librechat.ai>
|
||
|
|
babf6f908b
|
🧾 feat: Admin Config Write Report, Structured Issues and Deployment-Only Paths (#17395)
* 🧾 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 |
||
|
|
ba78cf5f5f
|
🫢 fix: Keep OAuth Credentials Out of Logs (#17409)
* 🫢 fix: Keep OAuth Credentials Out of Logs
* test: Match MCP OAuth SDK Fixture Types
* fix: Sanitize OAuth Failures Across Callback and Refresh Boundaries
* fix: Close OAuth Initiation Log Leaks and Preserve Vendor Recovery
---------
Co-authored-by: Lia <lia@librechat.ai>
|
||
|
|
f05f50460a
|
🔭 feat: Admin Config Read APIs (Resolved and Effective Config, Scope Catalog, Env Status) (#17383)
* 🔭 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`. |
||
|
|
5a472bfef2
|
🙅 fix: Deny HTTP Access to System MCP OAuth Flows (#17408)
Co-authored-by: Lia <lia@librechat.ai> |
||
|
|
4d061fdd46
|
🔄 fix: Judge Tenant Profiles on Their Own Base, Clear Config Caches on Principal Deletion, and Add a Config Reload Route (#17397)
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.
|
||
|
|
cba770daa8
|
⏪ fix: Normalize Preview Numbers in Linear Time (#17385)
Co-authored-by: Lia <lia@librechat.ai> |
||
|
|
db225c0919
|
🔐 feat: Admin Config Secrets v2 (MCP and Azure Credentials, Re-entry, Env Allowlist, Rebinding) (#17353)
* 🔐 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. |
||
|
|
76e3c6b134
|
🪜 fix: Base-First Config Precedence, Profile Lifecycle and Role Renames That Keep Their Profile (#17352)
* 🪜 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. |
||
|
|
0abbf3313d
|
🔐 fix: Apply Base Config Overrides Before Sign-In and Refuse Script Policy Links (#17351)
* 🔐 fix: Apply Base Config Overrides Before Sign-In and Refuse Script Policy Links Sign-in decisions made before the user is known now read librechat.yaml plus the `__base__` override of the request's tenant, or of the deployment outside a tenant, and fail closed (`resolvePreAuthAppConfig`). Registration, the first phase of password reset and the first email-domain check of the LDAP, OpenID, SAML and social strategies use it. The second check applies the account's role overrides with or without a tenant, and a new account is checked against the role it will be created with before anything is inserted. OpenID checks again when the admin claim or role sync changes the role. Password reset issues no link when the account's config cannot be read. The signed-out `GET /api/config` serves Base `registration.socialLogins` and the pre-login interface fields (`resolvePreLoginAppConfig`), falling back to librechat.yaml when overrides cannot be read. `turnstile` becomes a base-only section, so Turnstile comes only from librechat.yaml. Config reads that merge documents stay in one tenant partition (`tenantPartition`, Mongoose binding `tenantPartitionFilter`): the active tenant's documents, or the tenantless ones outside a tenant. The config store's Mongoose binding reads, writes, lists and restores role documents, `__base__` included, in that partition, and its `listActive` draws every document from it; group and user documents stay addressed by id. Only a `list` with `acrossTenants` reads every partition, which `listConfigTombstones` uses so the startup MCP tombstone report still names each tenant's documents. The tenant-isolation conformance suite gains single-partition cases. Privacy policy and terms of service `externalUrl` must be http(s), `mailto:`, `tel:`, relative or blank (`isSafeLinkUrl`). Admin writes of another scheme are refused, a librechat.yaml link is dropped with a warning at load, a stored one is dropped at merge, and every payload and the client remove one that reaches them. The admin config meta reports `features.preAuthBaseOverrides: true`. * 🧪 test: Layer a Required-Field Override Through interface.currency Instead of Turnstile Turnstile is set in librechat.yaml only now, so profile overrides of it are skipped and the layering scenario could no longer see a role's Turnstile options completed by a user's site key. The scenario now layers `interface.currency`, whose `code` and `rate` are both required: the role stores only the rate, the user only the code, and /api/config serves both. * 🛂 fix: Admit a First OpenID Login Under Its Claimed Role Before Creating the Account The admin-role claim and role sync are now decided before a first-login OpenID account is created, and createUserOnce admits the email under that role's config, read in parallel with the USER role's, before inserting anything. A login the claimed role refuses creates no account and no start balance. Admitted logins are unchanged: the account is still created as USER (now explicitly), moved into the claimed role, re-checked and audited as before, with the claims decided once. An account a concurrent first login created gets the claims decided again for its own role and tenant. |
||
|
|
f08868d21f
|
🧑✈️ feat: Enroll Machines Through Explicit Browser Approval (#17344)
* feat: add browser-approved machine enrollment * fix: preserve enrollment authority and durable admission invariants * test: verify in-document two-factor setup returns * test: exercise merged browser setup CLI against durable authorities --------- Co-authored-by: Lia <lia@librechat.ai> |
||
|
|
ff962fcaa2
|
📔 fix: Recover Subagent Content With Shared Chat Rendering (#17290)
* test: cover retained subagent chat history parity * feat: Define Task-Scoped Subagent Content Recovery Contract * style: Format Retained History Regression Tests * feat: Add Task-Scoped Subagent Public Content Recovery Foundation * feat: Render Subagent Turns With Standard Chat Content * fix: Bound Recovery Capture and Keep the New Writer Opt-In * feat: Recover Subagent Chat Content From Committed Task History * fix: Preserve Recovered Metadata and Shared Reader State * fix: Preserve Journal Retry Bytes, Unicode and Recovered Phases * fix: Catch Up Terminal Child Content Beyond Pinned Pages * fix: Bound Child Content Settlement and Restore Preparation Timing * fix: Preserve Retained Child History After Late Append Completion * fix: Reconcile Late Child Commits and Preserve Terminal Content * fix: Retain MCP Scope While Detached Children Execute * test: Assert Shared Task Ownership Across Request Adapters * fix: Preserve Subagent Recovery Across Flush and Deletion Races * test: Enforce Indexes in Subagent Deletion Regressions * fix: Respect Revoked Recovery When Cached Content Exists * fix: Honor Recovery Revocations and Hide Read-Only Approvals * test: Type Captured Tool Metadata in Approval Regressions * fix: Keep Recovery Fallbacks Read-Only * fix: Bound Subagent Recovery Work and Preserve Terminal Answers * fix: Reconcile Late Content Writes and Preserve Selected Outcomes * fix: Preserve Durable Outcomes Independently of Capture Completeness * fix: Reconcile Serialized Subagent Text Blocks Without Duplicate Outcomes * fix: Preserve Journal Cleanup Scope Before Conversation Erasure --------- Co-authored-by: Lia <lia@librechat.ai> |
||
|
|
8c51a3f9f8
|
🙈 feat: Let Config Profiles Hide librechat.yaml MCP Servers and Remove Their Fields (#17327)
* 🙈 feat: Let Config Profiles Hide librechat.yaml MCP Servers and Remove Their Fields Config profiles are the `__base__`, role, group and user documents written through `/api/admin/config`. A profile can tombstone `mcpServers.<name>`, and the merge then removes that server from the principal's resolved `mcpConfig`. * 🛡️ fix: Apply MCP Hiding to Server Instructions, Failed Removals and the Startup Audit - Server instructions bound for the model now leave out librechat.yaml servers hidden from the acting user, including one a model spec pins. `applyContextToAgent` passes the request user through `formatInstructionsForContext`, which drops the user's hidden set from the user-less catalog it reads. - A config-tier candidate that removes a librechat.yaml value (a field, or a key of a record such as `headers`) and fails inspection now stands as a failed config-source entry instead of falling back to the librechat.yaml base that still carries the removed value. A failed change that removes nothing still falls back, and an entry with no transport (fields written over a hidden server) keeps the documented librechat.yaml fallback. - The startup tombstone report reads every tenant's profiles in the system tenant scope, so it also runs from entry points without an outer system scope under strict tenant isolation, and names each profile's tenant. * 🗂️ fix: Project the Startup MCP Tombstone Report Query and Run It Alongside Connections * 🔑 fix: Keep Removed OAuth Headers Out of the MCP OAuth Callback * 📝 docs: Note That Removed OAuth Headers Stay Out of MCP Sign-In * 🔐 fix: Recheck the MCP OAuth Flow's Server Before Initiation Redirects OAuth initiation redirected to a flow's stored authorization URL, or started a new authorization from the flow's stored server URL, without resolving the server again, so a principal whose profile hid the server after the flow was created could still be sent to its authorization endpoint. The callback's active-server check and its OAuth header fallback lived in the CJS route. resolveMCPOAuthTarget (packages/api/src/mcp/oauth/target.ts) now owns both: it resolves the server in the principal's current config with a strict read, refuses a flow admitted for another server, a server the principal can no longer use, or a redefined one, and selects the headers the flow sends (the initiation snapshot, else the principal's config). Initiation calls it before either redirect (404 or 400); the callback calls it before the exchange and from the token-store fence. * 📝 docs: Note That a Hidden MCP Server Ends OAuth Sign-Ins Already Started * 🚩 feat: Publish the yamlMcpHide Admin Config Meta Flag Profiles can hide librechat.yaml MCP servers and a hidden server is an access boundary, so GET /api/admin/config/meta now reports features.yamlMcpHide for the admin panel to gate its hide UI on. The meta.spec probe checks the behaviour itself: the admin API stores an mcpServers.<name> tombstone, the merged config drops the server, the registry withholds it from principal lookups and checkout but not from app-level lookups, process-backed servers stay, and an unreadable principal config withholds every hideable server. * 🧪 test: Align MCP Tombstone Specs With the Portable Config Store The admin config handlers now write whole documents through writeConfigDocument, so the end-to-end tombstone spec wires it in place of the removed upsertConfig/patchConfigFields deps. A reset of a whole MCP record now also prunes the parents it leaves empty. |
||
|
|
4e0d9145e0
|
⚛️ feat: Atomic Admin Config Changes Endpoint (set, unset, tombstone, entry upsert/remove/rename) (#17328)
* 🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes Admin config writes went straight to MongoDB with dotted-path `$set`, `$unset`, `$pull` and `$addToSet`, and nothing checked `configVersion`. That caused six problems. * ⚛️ feat: Atomic Admin Config Changes Endpoint (set, unset, tombstone, entry upsert/remove/rename) Admin clients can change a principal's config overrides only one kind of change at a time: - PATCH `/fields` for sets, at most 100 entries; - POST `/fields/tombstone` for one tombstone; - DELETE `/fields` for one reset. * 🔁 fix: Reload librechat.yaml on Admin Config Writes Base-only sections such as `filters` and `messageFilter` live only in librechat.yaml, and an admin config write was how a running server picked up an edit to them. The coherent-cache change limited admin-write invalidation to the override and MCP caches, so the YAML base was never re-read after startup: the content-filter e2e suite, which activates filters by editing the YAML and writing a reload sentinel, saw `filters: undefined` from GET /base and every activation timed out. Admin config writes clear the YAML base config again, alongside the override and MCP caches, and the clear is broadcast with the others, so every instance reloads its YAML. The reload keeps the last good config on failure and republishes the tools derived from it, so the global tool cache is left for it to overwrite rather than emptied first. * 🧭 fix: Cap Dotted Field Path Depth and Hold Revision Preconditions on No-Op Writes A dotted fieldPath was split without the 32-segment cap that segments already had, so a deep path reached the recursive path writer and failed with a 500. Both spellings now share MAX_CONFIG_PATH_DEPTH and answer 400 CONFIG_PATH_INVALID / too_deep on PATCH, tombstone and DELETE /fields. Writes reduced to nothing (protected interface permissions, base-only or dedicated sections) answered 200 without checking expectedRevision. They now compare it with the stored document and answer 409 CONFIG_VERSION_CONFLICT with currentRevision on a mismatch, as the write itself would. * 📡 fix: Retry the Config Invalidation Subscription When Redis Comes Back A SUBSCRIBE that failed at startup (Redis unreachable, the client's retries spent) was only logged, and ioredis resubscribes only to channels it has joined, so the instance missed every other instance's config invalidation until it restarted. The subscription is now sent again each time the subscriber becomes ready until one succeeds; after that the client's own resubscribe takes over, and closing stops the retries. * 🧷 fix: Tighten Config Change Batches Around Array Entries, Cancelled Changes and MCP Tombstones - A tombstone with an index segment below a field configSchema does not define (an unknown key, or what an intersection or any holds) is refused as inside_array: the merge removes inherited values from objects only, so it was stored and reported applied while the element stayed visible. - unset joins set and rename in the merged-by-key position check: unset endpoints.custom.0.headers answers 400 indexed_merge_key_write, since the position can name another endpoint by the time the batch applies. upsertEntry and removeEntry address entries by key. - A batch whose changes cancel out (set interface.customWelcome, then unset interface) writes nothing: no empty document, revision bump, audit entry or invalidation. Its changes are reported as unchanged. - A whole-section mcpServers tombstone reports each librechat.yaml stdio server it leaves in place as ignored (process_mcp_server). - removeEntry no longer attributes the whole collection to itself, and existing issues of merged-by-key entries are matched by key rather than index, so removing an entry beside a legacy-invalid one (or shifting it) is no longer refused for that entry's issue. * 🪪 fix: Keep a Requested Priority on New Principals and Report Ignored MCP Renames POST …/changes discarded a broad manager's priority for a principal without a document when no change altered it: the batch answered written: false instead of creating the priority-only document PUT creates. An explicit priority on an absent principal now counts as a change. A rename under an MCP server librechat.yaml runs as a process persisted an override the runtime merge drops, but was not reported in ignored. It now is, like set and tombstone. An unset there stays unreported: it asks for the YAML value, which is what runs. * 🔁 fix: Drop YAML Reloads and Merges Overtaken by a Config Write Admin config writes clear the YAML base config on every instance, so a write is how a running server picks up an edit to librechat.yaml. Two races could undo that: - A base reload that read the old YAML before a write's clear cached it after the clear, and the base has no TTL, so the old base was served until the next write. - A request that read the old base before the clear, and was still resolving principals, cached its merge under the new override generation for the override TTL. The config service now keeps a base-config generation that `clearAppConfigCache` bumps. A reload publishes the base, the tools and the last good config only if its generation is still current, a read after a clear never joins a reload started before it, and the newer reload starts once the stale one settles so the loader's process-wide side effects end with the newest YAML. Merges capture the generation, base included, before they read the base config. Tests: - service.spec: a clear during a reload (stale success, stale failure, a read waiting on the newer reload) and a merge built on the pre-clear base. - invalidation.redis.spec: a write on one instance makes another reload librechat.yaml. - admin-config-reload.spec (api): every admin config write route, through the real router, handlers, database and config service, reloads librechat.yaml; a request with nothing to write does not. - invalidateConfigCaches.spec no longer asserts an order the parallel clears do not have. * 🧪 test: Reload librechat.yaml After a Committed Change Batch and Not After an Unwritten One * 🧮 fix: Validate Change Batches on Their End State and Report Base-Only Fields a Tombstone Keeps A batch's validation scope was built from every intermediate write, located in the state each change produced. A change a later one undid (set `balance.startBalance`, then restore `balance`) still widened the scope, so an issue the stored document already had there rejected an unrelated change, and an entry a later change moved (upsert one entry, then remove one before it) pointed its written index at a neighbour with a legacy issue. The written paths are now located in the batch's end state and kept only where that state differs from the stored document, with entries of merged-by-key arrays compared by key. A tombstone above a base-only field (`endpoints.agents`, `endpoints.agents.pullRequests`) is stored and hides the rest of the subtree, while the runtime merge puts back the provider, host, OAuth app and shared cache slots librechat.yaml sets. The response now lists those fields in `ignored` with reason `base_only_path`, as it already does for the stdio MCP servers a whole-section tombstone leaves in place. * 🧬 fix: Encode Config Keys in Objects Built in Another Realm The key encoder treated an object as plain only when its prototype was this realm's Object.prototype, and returned any other object unchanged, keys and all. Under Jest, structuredClone (which the secret pipeline uses) returns objects from the host realm, so the items of an array the pipeline had cloned, such as Azure groups or custom endpoints, reached the engine with their dotted keys raw. Node in production has one realm, but the encoding must not depend on prototype identity: a skipped object stores its dotted keys raw without an error. A plain object is now one whose prototype is null or a root Object.prototype from any realm. The encoding spec covers an object built in a vm context. * 🧪 test: Check Dotted Record Keys Reach the Store's Whole-Document Write dev's admin config route test asserted the keys on patchConfigFields, which the handlers no longer call; it now asserts them on the draft writeConfigDocument receives. * 🚩 feat: Publish the expectedRevision, prunesEmptyParents and awaitedInvalidation Config Flags GET /api/admin/config/meta now reports the three write-coherence behaviours this branch implements, so an admin client can drop the workarounds each one replaces: - expectedRevision: responses carry `revision`; PUT, PATCH /fields, POST /fields/tombstone and PATCH /active take `expectedRevision` in the body and both DELETE routes in the query. A mismatch answers 409 CONFIG_VERSION_CONFLICT with currentRevision, a malformed value 400 INVALID_EXPECTED_REVISION; unpinned writes re-read and re-apply up to 3 times. - prunesEmptyParents: a field delete or tombstone removes the objects it empties, stopping at arrays; shells-only documents count as empty for assign-only lifecycle calls. - awaitedInvalidation: writes answer after the config caches are cleared (broadcast with Redis), GET /base bypasses the merged-config cache, and a merge read before a clear is never cached. meta.spec probes each one against the behaviour: a stale and a malformed precondition on a PATCH, the store operations' unset and tombstone on nested objects and an array element, and a held invalidation, the GET /base read options and a merge raced by a clear. * 🔀 fix: Keep Config Keys Raw Where the Engine Stores Them, So Older Servers Read Them During Upgrades Servers before the key encoding (v0.8.9-rc1 among them) read every override key literally. The Mongoose binding encoded every write, so during a rolling upgrade the first write from an upgraded server turned a stored `gpt-4.1` or Bedrock inference profile into `gpt-4%2E1` for every server not yet upgraded, and an older server's restore of a deleted group or role config dropped the `keyEncoding` marker its schema lacks, after which upgraded servers read the encoded keys literally. The binding now sends keys raw first and encodes them only when the engine refuses a raw field name (DocumentDB, Cosmos, FerretDB or MongoDB 4.4 for `$` names): the refused write changed nothing, so it runs again encoded under the same revision precondition, and that process encodes later writes holding such keys directly. MongoDB 4.4+ stores dotted names (5.0+ also `$` names inside a value), so there an older server reads exactly what it wrote. A document whose raw keys spell escape sequences while none holds a raw `.`, `$` or NUL is still written encoded, since a raw read would decode it. A raw write clears the marker. Reads decode a marked document (raw keys an older server added beside encoded ones, or wrote under a marker it left, carry no escape sequence and read as stored) and an unmarked one unless some key holds a raw `.`, `$` or NUL, which no encoded document does; that reads an encoded document whose marker an older server dropped. Encoding stays in the binding for every engine that needs it (decision #15); the residual cases are in documentdb-compat.md. * ⏱️ fix: Remove Config Cache Writes a Clear Overtook in Flight With an asynchronous APP_CONFIG store (Redis or a custom Keyv store), a clear can bump the generation and finish its delete after a reload or merge checked the generation but before its `set` landed. The older value then repopulated `_BASE_` until the next write, or a merged config for the full override TTL. The base reload, the last-good restoration and the merge cache now check the generation again once their write lands and delete what they wrote if a clear overtook it. A deleted entry only costs the next read a reload or a merge; a newer base load cannot be removed this way, since it starts only after the stale one settles. * 🔐 fix: Require the Stored Web Search Key Again When a Change Batch Moves Its URL #17323 refuses a PUT, PATCH, tombstone or field delete that changes or removes a web search URL beside a stored API key unless the key is entered again, so a stored key cannot be sent to a destination it was not entered for. POST /changes skipped that check: a batch could set, reset or tombstone `webSearch.searxngInstanceUrl` (or replace `webSearch` without the key, which keeps the stored key) and point the stored key at another host. A batch is now judged on the document it would store, like PATCH: a URL that ends up beside a stored key it did not travel with answers 400 CONFIG_SECRET_REENTRY_REQUIRED and writes nothing, dry runs included. Only keys the request sent count as entered again; a secret a set kept from the stored document does not. * 🚩 feat: Publish the changesBatch Flag and the maxChangeOps Limit in Config Meta GET /api/admin/config/meta now reports `features.changesBatch: true` and `limits.maxChangeOps` (1000, from MAX_CONFIG_CHANGE_OPS), so the admin panel can gate its one-request save on the endpoint and size its batches from the server. The meta.spec probe checks the behaviour itself: an oversized batch answers TOO_MANY_OPS, a batch with one invalid op writes nothing, and a valid set plus tombstone lands as one write. |
||
|
|
0b4dc238b3
|
🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes (#17326)
* 🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes Admin config writes went straight to MongoDB with dotted-path `$set`, `$unset`, `$pull` and `$addToSet`, and nothing checked `configVersion`. That caused six problems. * 🔁 fix: Reload librechat.yaml on Admin Config Writes Base-only sections such as `filters` and `messageFilter` live only in librechat.yaml, and an admin config write was how a running server picked up an edit to them. The coherent-cache change limited admin-write invalidation to the override and MCP caches, so the YAML base was never re-read after startup: the content-filter e2e suite, which activates filters by editing the YAML and writing a reload sentinel, saw `filters: undefined` from GET /base and every activation timed out. Admin config writes clear the YAML base config again, alongside the override and MCP caches, and the clear is broadcast with the others, so every instance reloads its YAML. The reload keeps the last good config on failure and republishes the tools derived from it, so the global tool cache is left for it to overwrite rather than emptied first. * 🧭 fix: Cap Dotted Field Path Depth and Hold Revision Preconditions on No-Op Writes A dotted fieldPath was split without the 32-segment cap that segments already had, so a deep path reached the recursive path writer and failed with a 500. Both spellings now share MAX_CONFIG_PATH_DEPTH and answer 400 CONFIG_PATH_INVALID / too_deep on PATCH, tombstone and DELETE /fields. Writes reduced to nothing (protected interface permissions, base-only or dedicated sections) answered 200 without checking expectedRevision. They now compare it with the stored document and answer 409 CONFIG_VERSION_CONFLICT with currentRevision on a mismatch, as the write itself would. * 📡 fix: Retry the Config Invalidation Subscription When Redis Comes Back A SUBSCRIBE that failed at startup (Redis unreachable, the client's retries spent) was only logged, and ioredis resubscribes only to channels it has joined, so the instance missed every other instance's config invalidation until it restarted. The subscription is now sent again each time the subscriber becomes ready until one succeeds; after that the client's own resubscribe takes over, and closing stops the retries. * 🔁 fix: Drop YAML Reloads and Merges Overtaken by a Config Write Admin config writes clear the YAML base config on every instance, so a write is how a running server picks up an edit to librechat.yaml. Two races could undo that: - A base reload that read the old YAML before a write's clear cached it after the clear, and the base has no TTL, so the old base was served until the next write. - A request that read the old base before the clear, and was still resolving principals, cached its merge under the new override generation for the override TTL. The config service now keeps a base-config generation that `clearAppConfigCache` bumps. A reload publishes the base, the tools and the last good config only if its generation is still current, a read after a clear never joins a reload started before it, and the newer reload starts once the stale one settles so the loader's process-wide side effects end with the newest YAML. Merges capture the generation, base included, before they read the base config. Tests: - service.spec: a clear during a reload (stale success, stale failure, a read waiting on the newer reload) and a merge built on the pre-clear base. - invalidation.redis.spec: a write on one instance makes another reload librechat.yaml. - admin-config-reload.spec (api): every admin config write route, through the real router, handlers, database and config service, reloads librechat.yaml; a request with nothing to write does not. - invalidateConfigCaches.spec no longer asserts an order the parallel clears do not have. * 🧬 fix: Encode Config Keys in Objects Built in Another Realm The key encoder treated an object as plain only when its prototype was this realm's Object.prototype, and returned any other object unchanged, keys and all. Under Jest, structuredClone (which the secret pipeline uses) returns objects from the host realm, so the items of an array the pipeline had cloned, such as Azure groups or custom endpoints, reached the engine with their dotted keys raw. Node in production has one realm, but the encoding must not depend on prototype identity: a skipped object stores its dotted keys raw without an error. A plain object is now one whose prototype is null or a root Object.prototype from any realm. The encoding spec covers an object built in a vm context. * 🧪 test: Check Dotted Record Keys Reach the Store's Whole-Document Write dev's admin config route test asserted the keys on patchConfigFields, which the handlers no longer call; it now asserts them on the draft writeConfigDocument receives. * 🚩 feat: Publish the expectedRevision, prunesEmptyParents and awaitedInvalidation Config Flags GET /api/admin/config/meta now reports the three write-coherence behaviours this branch implements, so an admin client can drop the workarounds each one replaces: - expectedRevision: responses carry `revision`; PUT, PATCH /fields, POST /fields/tombstone and PATCH /active take `expectedRevision` in the body and both DELETE routes in the query. A mismatch answers 409 CONFIG_VERSION_CONFLICT with currentRevision, a malformed value 400 INVALID_EXPECTED_REVISION; unpinned writes re-read and re-apply up to 3 times. - prunesEmptyParents: a field delete or tombstone removes the objects it empties, stopping at arrays; shells-only documents count as empty for assign-only lifecycle calls. - awaitedInvalidation: writes answer after the config caches are cleared (broadcast with Redis), GET /base bypasses the merged-config cache, and a merge read before a clear is never cached. meta.spec probes each one against the behaviour: a stale and a malformed precondition on a PATCH, the store operations' unset and tombstone on nested objects and an array element, and a held invalidation, the GET /base read options and a merge raced by a clear. * 🔀 fix: Keep Config Keys Raw Where the Engine Stores Them, So Older Servers Read Them During Upgrades Servers before the key encoding (v0.8.9-rc1 among them) read every override key literally. The Mongoose binding encoded every write, so during a rolling upgrade the first write from an upgraded server turned a stored `gpt-4.1` or Bedrock inference profile into `gpt-4%2E1` for every server not yet upgraded, and an older server's restore of a deleted group or role config dropped the `keyEncoding` marker its schema lacks, after which upgraded servers read the encoded keys literally. The binding now sends keys raw first and encodes them only when the engine refuses a raw field name (DocumentDB, Cosmos, FerretDB or MongoDB 4.4 for `$` names): the refused write changed nothing, so it runs again encoded under the same revision precondition, and that process encodes later writes holding such keys directly. MongoDB 4.4+ stores dotted names (5.0+ also `$` names inside a value), so there an older server reads exactly what it wrote. A document whose raw keys spell escape sequences while none holds a raw `.`, `$` or NUL is still written encoded, since a raw read would decode it. A raw write clears the marker. Reads decode a marked document (raw keys an older server added beside encoded ones, or wrote under a marker it left, carry no escape sequence and read as stored) and an unmarked one unless some key holds a raw `.`, `$` or NUL, which no encoded document does; that reads an encoded document whose marker an older server dropped. Encoding stays in the binding for every engine that needs it (decision #15); the residual cases are in documentdb-compat.md. * ⏱️ fix: Remove Config Cache Writes a Clear Overtook in Flight With an asynchronous APP_CONFIG store (Redis or a custom Keyv store), a clear can bump the generation and finish its delete after a reload or merge checked the generation but before its `set` landed. The older value then repopulated `_BASE_` until the next write, or a merged config for the full override TTL. The base reload, the last-good restoration and the merge cache now check the generation again once their write lands and delete what they wrote if a clear overtook it. A deleted entry only costs the next read a reload or a merge; a newer base load cannot be removed this way, since it starts only after the stale one settles. |
||
|
|
9ea3c5647d
|
🔑 fix: Use Admin-Stored Web Search Credentials at Runtime (#17323)
* 🔑 fix: Use Admin-Stored Web Search Credentials at Runtime Use admin-stored (encrypted or literal) web search credentials as system credentials at runtime, add the Keenable key to the secret registry, bind a stored key to the layer that set its URL, and require re-entering the key when a write changes or removes that URL (checked atomically with a version precondition). * 🧹 fix: Keep Dotted-Key Write Guarantees on Version-Checked Web Search Writes A version-checked write the caller saw absent first creates an empty document. When the database then refuses the write (a key name it cannot store, answered 422 CONFIG_KEY_NOT_STORABLE), remove that document again so a refused write stores nothing, unless another write has changed it. Secret re-entry issues now carry `segments` like every other config issue. * 🚩 feat: Publish the webSearchStoredKeys Feature Flag in the Config Contract GET /api/admin/config/meta now reports `webSearchStoredKeys: true`, so an admin client can stop warning that only ${VAR} web search references work at runtime. meta.spec probes the behaviour behind it: an encrypted stored key reaches web search auth, the Keenable key is encrypted on write, and changing a URL beside a stored key requires entering the key again. * 🧪 test: Type the Refused-Write Driver Stub in the Config Methods Spec * 🧪 test: Expect the Write Precondition Arguments in the Admin Config Route Test The handler passes a session slot and an optional version precondition to patchConfigFields since the web search re-entry check; the route test added in #17322 asserted the earlier five-argument call. * 🧹 fix: Surface a Failed Cleanup of the Empty Config Document When a version-checked write the database refused cannot remove the empty document created for it, let that failure reach the handler (500) instead of logging it and answering 422 CONFIG_KEY_NOT_STORABLE, which promises that nothing was stored. * 📝 docs: State the Web Search Stored-Key Binding Rule Exactly in the webSearchStoredKeys Flag The flag's doc said a stored key goes only to a URL the same layer set. The merge rule keeps a stored key over an inherited ${VAR} or default URL, so the doc now names the exact rule: a stored key reaches a URL stored in config only when one layer set both, a later layer that changes, blanks or removes the URL drops the key, and a write that changes or removes the URL must enter the key again. * 🧹 refactor: Read the Secret Registry Through getConfigSecretRules Only The dev merge kept this branch's getConfigSecretFields and getConfigArraySecretFields beside dev's getConfigSecretRules, which returns the same registry data. Only the secret specs used the two extra accessors. They now read getConfigSecretRules().secretFields and .arraySecretFields, so the accessors and their exported ConfigSecretField and ArraySecretField interfaces (duplicates of AdminConfigSecretFieldRule and AdminConfigArraySecretFieldRule) are gone. |
||
|
|
2591a15c10
|
🔑 feat: Keep Dotted Record Keys in Admin Config Writes and Publish the Config Contract (#17322)
* 🔑 feat: Keep Dotted Record Keys in Admin Config Writes and Publish the Config Contract Keep dotted record keys in admin config write bodies behind a path-scoped sanitizer, reject $-prefixed and prototype keys after auth, report dotted_key issues with segments, and publish GET /api/admin/config/meta (features, rules, limits, versions) so clients can gate on backend capabilities. * 🧪 test: Expect Issue Segments in the Config Override e2e Scenario Override validation issues now carry `segments`; assert the full issue shape. |
||
|
|
b2aeb9c6a1
|
feat: add masked session replay lifecycle (#17194) | ||
|
|
8718338728
|
⏱️ fix: Bound Outbound Calls Made Inside a Request (#17263)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
* fix: Bound Outbound Calls Made Inside a Request RAG queries for file search and message context, OCR provider calls, action HTTP calls, the moderation check, the stored-image fetch for base64 providers, and Flux result polling had no timeout. A stalled upstream hung the chat turn, the upload or the tool call indefinitely, and Flux kept polling forever on statuses that never become Ready. Each now runs under a budget from a new librechat.yaml timeouts block with finite defaults (getOutboundTimeoutMs in @librechat/api). Action calls also receive the run's abort signal, so stopping a run closes the socket. * test: Cover a Stalled RAG Query in the Mock Harness * fix: Share One Flux Budget Across Submit and Polls, Bound the Vertex Token Exchange * refactor: Poll Flux Results Through pollUntilSettled * refactor: Leave Flux Polling for a Separate Migration * fix: Cap Configured Timeouts at the Node Timer Limit * fix: Bound the Action Token Refresh and the Whole Image Download * fix: Cap Every Outbound Budget by Wall-Clock Time Axios's timeout only fires on an idle socket, so a RAG, OCR, moderation, action or token response that keeps trickling bytes never ended. outboundRequestBudget pairs each timeout with an AbortSignal deadline, and action calls combine it with the run's own signal. * fix: Name the Budget That Ran Out and Give Actions Five Minutes The actions default rises to five minutes, since action endpoints are arbitrary third-party APIs and the old minute could cut off legitimately slow ones after an upgrade. A budget overrun now fails with an error naming the timeouts key and its value, whether it was the idle timeout or the wall-clock deadline, and logAxiosError logs it as a warning so operators know what to raise. A deadline cancellation is no longer read as a user stop, so an action that runs out of time reports a timeout instead of looking like a stopped run. * fix: Hold Outbound Deadlines Weakly So Finished Requests Leave No Timers * fix: Check the Budget Before Reading an Error Message * fix: Report a Wrapped Deadline as a Failure, Not a Stop * fix: Bound the OAuth Code Exchange and Keep the OCR Budget Hint When Protected * chore: Sort Imports in axios.ts After Rebase |
||
|
|
698ee25fea
|
🧯 fix: Close Abandoned Download and Speech Streams and Cap Speech Input (#17270)
* fix: Contain Download and Speech Stream Failures and Cap Speech Input The code output download piped the Code API stream with .pipe, which adds no error listener, so a body that failed mid-stream (a bad gzip body, a reset) became an uncaught exception and the process exited. pipeToResponse uses stream.pipeline, ending the response and destroying the upstream when the client leaves. Text-to-speech piped provider streams the same way and waited only for 'end', so a provider error was uncaught and a client disconnect left the chunk loop waiting. pipeSegment resolves on end and rejects on an error or a disconnect, which ends the loop. A speech request had no length cap, so one request could fan out into thousands of serial paid provider calls. speech.tts.maxInputChars bounds it (default 20,000 characters). * docs: Document the Speech Input Cap in the Example Config * fix: Reject a Speech Segment When the Client Already Left * fix: Tear Down Both Ends of a Failed Speech Segment and Cap Streamed Speech A failed provider segment now destroys the response as well as the source, so a half-written answer cannot hang the client, and a response-side error rejects the segment instead of going unhandled. Automatic playback reads a message only up to speech.tts.maxInputChars, so long messages cannot fan out past the cap either. The download scenario now checks the behavior .pipe lacked: leaving a code download closes the upstream connection right away. * fix: Keep a Late Response Write Error From Going Unhandled * test: Key Slow Code Downloads by File and Send a Browser User Agent * fix: Read Speech Up to the Cap Instead of Refusing It Manual speech now synthesizes the text up to speech.tts.maxInputChars, the same as automatic playback, through capSpeechInput, so the CJS service only passes the capped text along and the request keeps its existing error contract. A streamed message that reaches the cap exactly now finishes, and a segment that fails before any audio went out leaves the response open for the caller's HTTP error. * fix: Count Only Text Against the Speech Cap |
||
|
|
e57aa3aa5b
|
🙊 fix: Keep API Keys and Internal Errors Out of Logs and Responses (#17258)
* fix: Keep API Keys and Internal Errors Out of Logs and Responses The log redaction patterns did not cover the appid query parameter, so a failed Wolfram request logged its AppID with the axios request URL. appid now joins the redacted token and query names. OpenWeather returned a fetch error's message to the model verbatim, and node-fetch puts the full request URL, appid included, in that message. The tool now passes it through redactMessage, as ToolService does. The public startup config route and the unauthenticated password reset route sent raw error text on unexpected failures. Both now answer with a fixed message and keep the detail in the server log. * refactor: Format Tool Error Text in packages/api * fix: Redact appid Metadata Keys in Structured Logs |
||
|
|
54b887a1ec
|
🛰️ fix: Route Subagent Files Delivered After a Mid-Run Reload (#17212)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
* fix: Route Subagent Files Delivered After a Mid-Run Reload * test: Stub Stored Part Queries in the ContentParts Integration Suite * fix: Recover Stored Part Lookups That Fail Without a Reader * fix: Resolve Late Subagent Files With One Previewed Message Read * fix: Read Late Subagent Hints Again Until the File Is Saved * fix: Count Failed Reads Toward the Late Hint Poll Bound * fix: Let Unresolved Late Hint Reads Recover on Focus and Reconnect * fix: Resolve Late Subagent File Owners From the Stored Transcripts * fix: Ask for Late Subagent File Owners in Bounded Batches |
||
|
|
f7a56e843b
|
🖼️ fix: Render Files Saved by Tools Inside a Subagent Run (#17204)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
* fix: Render Files Saved by Tools Inside a Subagent Run * test: Cover Subagent Nested Tool Images After Reload * fix: Hoist Subagent Child-Run Files With Grouped Tool Calls * fix: Route Live Subagent Child Files Through the Part Attachment Map * fix: Keep Subagent Child File Routing Through Previews and Ownership Rules * test: Match Subagent Image Names Exactly * fix: Key Subagent Child Files by Their Owning Part * fix: Apply Attachment Scope Rules to Subagent Child Calls * fix: Carry Child Call Scope Through Previews and Live Progress * fix: Retain Live Subagent Progress Readers and Seen Child Calls * fix: Keep Live Progress Keys Retained Across Streamed Deltas * fix: Assign Subagent Child Files Once Per Message * fix: Route Late and Id-less Subagent Child Files * fix: Keep Seen Subagent Child Calls With Their Invocation * fix: Use Streamed Index and Call-Level Owner for Subagent Child Files * fix: Reserve Scoped Child Files From Unscoped Top-Level Calls * fix: Record Subagent Child Calls When Progress Is Written * fix: Keep Agent Scope on Remembered Subagent Child Calls * refactor: Share One Subagent Child Call Collector * fix: Derive Live Signature From Remembered Child Calls * fix: Keep Child Calls a Bounded Batch Evicts * fix: Bound Remembered Subagent Child Calls and Include Replay Segments * fix: Refresh Owners of Shown Files in the Bounded Call History * fix: Keep Remembered Call Order Stable Across Eviction Replays * fix: Scope Preview Hints to Attachments and Walk Nested Calls Iteratively * fix: Bound Wildcard Preview Hints and Own Live Calls by Their Run * fix: Own Stored Subagent Child Calls by Their Persisted Identity |
||
|
|
ab8dc9d3d2
|
🕶️ fix: Keep Temporary Chats Out of Langfuse (#17202)
* 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> |
||
|
|
73847f2db5
|
🔌 feat: Integrate Durable Skill Lifecycle Across Writers and Routes (#17043)
* feat: integrate durable Skill lifecycle across writers and routes * 🧪 test: Cover Skill Management Deletion End to End * fix: Queue superseded Skill blobs for durable cleanup * fix: Reject Skill file storage moves without new identity * 🧪 test: Cover Skill UI Delete and Cleanup Restart * 🧪 test: Assert Durable Cleanup for Replaced Skill Files * fix: release Skill names during account deletion marking * fix: use reserved Skill blob plans across writers * fix: hold superseded Skill blobs until sync commits * test: preserve account deletion retry coverage after restack * test: verify durable Skill cleanup after account erasure * fix: complete Skill cleanup leases and avoid historical metadata scans * fix: bound Skill cleanup manifest processing |
||
|
|
ec587c27aa
|
🗑️ feat: Expose Skill Deletion in Management API (#17005)
* feat: expose Skill deletion in management API
* fix: canonicalize deleted Skill IDs
* feat: gate machine Skill deletion until cleanup rollout
* Revert "feat: gate machine Skill deletion until cleanup rollout"
This reverts commit
|
||
|
|
a03d90e1dc
|
🧩 feat: Add Skill Creation and File Deletion to Management API (#16878)
* feat: complete Skill management CRUD * fix: make Skill file deletion retryable * fix: delete local Skill files by recorded owner * fix: narrow skill management CRUD and honor blob owners * fix: preserve request-scoped storage deletion ownership |
||
|
|
5fc4371c6a
|
🪦 refactor: Remove Dead Legacy API Modules and Root Tooling (#17114) | ||
|
|
9adabde72e
|
🗂️ feat: Audit MCP, Code Worker, Langfuse, Skill Credential, Passkey and Audit Log Access (#17054)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
* fix: Remove Group Dependents Before Deleting the Group * feat: Audit Code Worker Pairing and Langfuse Connection Changes * feat: Audit Skill Sync Credential Changes * feat: Audit Passkey Enrolment and Removal * feat: Audit Audit Log Reads and CSV Exports * feat: Audit Audit Log Retention Purges * feat: Audit MCP Server Create, Update and Delete * fix: Keep Purge Result When the Purge Audit Write Fails * test: Cover Admin Integration Audit Scenarios * fix: Tighten Admin Integration Audit Scope and Group Cleanup Order * fix: Run Security Fences Before Awaiting Audit Writes * fix: Move MCP Post-Commit Audit Ordering Into the Auditor and Audit Verify Reads * fix: Fail Closed When Recording Audit Log Access * fix: Audit Group Deletion Before the Cascade and Restore Dependents on Failure * fix: Restore Only Config Overrides When Group Deletion Fails * fix: Audit Worker Pairing and Export Before the Work and Append Failures * fix: Record Group Deletion as Pending Without Delaying Revocation * fix: Skip Config Restore When a Concurrent Delete Removed the Group * fix: Restore Group Config When the Existence Recheck Fails * fix: Keep Group Config Restricted When Delete State Is Unknown * fix: Record Worker Pairing and Revocation as Pending Until Confirmed * fix: Deliver the Pairing Code Before the Terminal Audit Write * test: Assert Pairing Code Delivery Precedes the Terminal Audit Write * fix: Send Revocation and Group Deletion Responses Before the Terminal Audit Write * fix: Snapshot Group Config Before the Destructive Cascade Step * refactor: Type the Group Config Snapshot Dependency Without Mongoose Shapes * fix: Fence Shared MCP Users Before the Deletion Audit and Correlate Audit Attempts * fix: Diff MCP Server Audits Against the Committed Config * fix: Read the Committed MCP Config at Commit Time for the Audit Diff * refactor: Start the Committed MCP Config Read Inside the Auditor * fix: Audit Langfuse Patches When Activation Fails and Surface Failed Group Config Restores * fix: Record Member Removals When Group Deletion Completes After a Failed Restore * test: Serve the Committed Config on the MCP Update Audit Reread * fix: Audit the Group Returned by the Compensating Deletion * fix: Keep Member Removal Audits Fail-Open During Group Deletion * fix: Retry ACL Cleanup After a Compensating Group Deletion * fix: Mark Unavailable Audit Detail and Order Member Removals After the Pending Deletion * fix: Guard Synchronous Committed-Config Read Failures in the MCP Auditor * fix: Return the Persisted MCP Config and Audit Commits That Outlive Cache Invalidation * style: Sort Imports in MCP Audit Files * style: Sort Imports After Restack * fix: Audit MCP Commits That Outlive Any Post-Write Step and Pend Audit Exports Until Complete * test: Provide the Fail-Closed Setting in the Code Route Mock * fix: Refresh MCP Read Caches When a Repository Step Fails After the Write * fix: Finish Audit Exports on Response Completion and Keep Error Details Out of Messages and Logs * fix: Watch Response Completion Before the Truncation Footer Write * fix: Skip Audit for No-op MCP Deletes and Close Remaining Post-Failure Audit Gaps * fix: Keep Causes Out of Structured Logs and Treat a Lost Compensating Delete as Not Found * fix: Mark Failed MCP Post-Commit Steps and Null Langfuse Activation in Audits |
||
|
|
76192bdfd0
|
🛂 feat: Audit Resource Sharing Changes and Fail Closed on Reversible Audit Writes (#17053)
* feat: Audit Resource ACL Changes and Fail Closed by Default * fix: Keep Non-Reversible Admin Audit Handlers Fail-Open * docs: Narrow AUDIT_LOG_FAIL_CLOSED Description * fix: Audit and Restore ACL and Insights Changes in One Pass * fix: Break Audit and Insights Permission Type Cycle * test: Cover Resource ACL Audit Scenarios * refactor: Audit Resource Permission Changes Before Writing * test: Align Concurrent Revoke Audit Expectation * fix: Skip Deleting ACL Entries That Were Not Audited * fix: Read ACL Snapshots Through the Write Session * fix: Never Block Revocations on Audit Outages and Normalize Principal Keys * fix: Let an Explicit Public Disable Win Over a Public Update * fix: Audit Duplicate ACL Rows as Combined Permissions * fix: Audit Permission Changes Under One Target and Dedupe Revokes * fix: Audit Capability Grants Before Writing Them * feat: Serialize Resource Permission Updates With a Per-Resource Lease * fix: Fence the Resource Lease Before Writes and Always Audit Grant Assignments * fix: Renew the Resource Lease Before Each ACL Write Phase * fix: Serialize System Grant Assignment and Revocation With a Per-Grant Lease * fix: Keep Leases Alive During Audits, Bound Lock Index Wait, Canonicalize Audit Target IDs * fix: Retry Deferred Revoke Audits Under the Lease and Audit Canonical Principal and Role IDs * test: Expect Role IDs in Permission Audit Metadata * fix: Read Mutation Snapshots From the Primary Outside Transactions * fix: Flush Deferred Audits Before Cache Invalidation, Keep Renewals Monotonic, Keep Role Case in Grant Lease Keys * refactor: Map the Busy Permission Error to Its Code in the API Package * style: Sort Lease Imports and Type the Renewal Spec Read * fix: Keep Success Audits After Commit, Report Downgrades as Revocations, Code Audit Outages * refactor: Move the Audit Outage Code to Its Own Module * fix: Translate Lock Failures, Lease Non-Transactional Sessions, and Code Grant Audit Outages * fix: Sanitize Lease Renewal Failures at the Permission Boundary * fix: Annotate the Unavailable Error Code for Isolated Declarations * fix: Keep the Admin Route Fail-Closed Opt-In and Document Lease Clock Skew Safety * fix: Translate Grant Lease Store Failures to a Retryable 503 * fix: Log Failed Grant Audit Writes With Safe Metadata Only * test: Detect Raw Error Arguments in the Grant Audit Log Spec * feat: Make Permission Lease Limits Configurable and Localize Retryable Sharing Failures * fix: Bound Lock Index Readiness by the Lease Wait and Carry the Resource ID in Every Audit Entry * test: Cover Lease Config Reaching the Leases and the Sharing Dialog Failure Messages * fix: Load App Config on the Sharing and Grant Routes and Log Failed Lease Releases * perf: Load App Config Only on the Grant Mutation Routes |
||
|
|
ccae5b988d
|
📜 feat: Audit Admin Role, Group, Config and IdP Role Mutations (#17052)
* feat: Extend the Audit Action Vocabulary to Admin, Sync and Credential Mutations * feat: Audit Admin Role, Group and Config Mutations Role deletion now removes the role's grants, ACL entries and config overrides before the role itself and returns ROLE_CLEANUP_FAILED instead of success when any of them fails, so a recreated role cannot inherit leftover privileges. * feat: Audit IdP and Startup Role Changes * fix: Keep the Startup Role Sync Running When Its Audit Verification Read Fails * test: Cover Admin Role Audit Trail End to End * fix: Audit a Remote Agent Role Sync Only After It Persists * fix: Restore Role Dependents When Role Deletion Fails Midway * fix: Restore Role Dependents Only When the Role Still Exists * style: Sort Role Admin Imports * fix: Keep the ACL Snapshot When Role Cleanup Fails Ambiguously * test: Read Role Audit Entries From the Audit Log Route * fix: Audit Only Real Membership Changes and Restore Deleted Role Config in Full * fix: Restore Deleted Role Grants in Full and Sanitize Audit Write Logging * fix: Audit and Report a Role Deletion Confirmed After a Lost Response * fix: Never Restore Dependents Onto a Recreated Role * fix: Snapshot Role Dependents Before Deleting and Detect Membership Changes Atomically * fix: Restore From the Data a Cascade Step Actually Removed * fix: Restore Only Config Overrides When a Role Delete Fails * fix: Log Only Safe Metadata When the Startup Audit Read Fails * fix: Audit Grants Removed by a Failed Role Delete * fix: Audit Removed Grants on Unverifiable Role Delete Exits * fix: Honor Fail-Closed Auditing in the Admin Config, Group and Role Routes * fix: Bind Role Deletion to the Captured Id and Audit Only Atomic Role and Config Changes * fix: Skip the Config Restore When the Targeted Role Is Gone * fix: Audit Initial Group Members and Skip No-Op Role Description Updates * fix: Record Role Deletion as Pending Before Cleanup and Append Its Outcome * fix: Audit Reassigned Role Members and Return the Persisted Config After a Tracked Toggle * fix: Keep a Committed Role Deletion Successful When Cascade Audit Writes Fail * fix: Decide Group Update Audits From the Atomic Write and Sanitize Permission Update Logs * fix: Audit Grants From a Snapshot, Fail on Member Lookup Errors and Chunk Member Audit Entries * fix: Audit Group Deletion Members and Previous Role Removal, Abort on Grant Snapshot Failure * fix: Invalidate Config Caches After Partial Secret Writes * fix: Retry Failed Cascade Restores, Report Changed Group Fields and Audit Every Reassigned Member * fix: Log Safe Metadata When Cache Invalidation Fails After a Partial Write * fix: Keep Error Messages Out of the Audit Write Failure Log * style: Sort Audit Log Spec Imports * fix: Sanitize Admin Handler Error Logs and Dispatch System Audit Writes Without Waiting |
||
|
|
20d2c0d43d
|
🧹 fix: Run the Full Erasure Cascade When an Admin Deletes a User (#17050)
* 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 |
||
|
|
219a48b55d
|
⏳ fix: Expire Dead-Lettered Trigger Deliveries and Clean Up Orphaned Image Uploads (#17049)
* fix: Expire Dead-Lettered Trigger Deliveries After a Review Window * fix: Delete Stored Image Uploads When Record Creation Fails * fix: Clean Up Stored Objects on Every Storage-Before-Record Upload Path * refactor: Resolve the Delete Strategy Lazily in Stored Upload Cleanup * test: Cover Dead Letter Expiry After the Review Window * fix: Carry Owner to Stored Upload Cleanup and Keep Batch Dead Letter Deadlines * refactor: Select the Stored Upload Cleanup Target in the API Package * fix: Check for a Committed Record Before Deleting an Upload and Keep Dead Letters Unless Configured * fix: Check the Persisted Record Id for Converted Assistants Images * fix: Arm a Dead Batch Root Deadline After Its Members Settle * fix: Settle Expired Dead Batches and Skip the Record Guard Before the File Write * fix: Skip the Record Guard for Pre-Write Failures and Build the Lookup in packages/api * fix: Build the Record Lookup Lazily in the Upload Service * fix: Pass the Dead-Letter Retention Window Through Experimental Startup * fix: Carry the Vector Copy Into Failed-Upload Cleanup * fix: Cover the Code Environment and Indeterminate Vector Copies in Upload Cleanup * fix: Give URL-Upload Cleanup a Request When the Caller Omits One * fix: Route Failed-Upload Cleanup Through Secondary-Storage Deletion * fix: Attempt Every Copy Independently When Cleaning Up a Failed Upload * fix: Track the Record Write in Every Upload Path Whose Retention Lookup Can Fail |
||
|
|
79b836d79f
|
📃 fix: Enforce Terms Acceptance on the Server and Mark Backfilled Consent (#17063)
* fix: Enforce Terms Acceptance on the Server When modalAcceptance Is On * fix: Mark Backfilled Terms Acceptance Timestamps * test: Cover Server-Enforced Terms Acceptance in the Mock Harness * fix: Gate Management Routes and Skill Sync and Resolve Terms Policy Fail-Closed * fix: Evict Cached Auth Documents When Terms Acceptance Is Reset * fix: Guard Skill Sync Behind Terms Acceptance for Every Skill List Route * fix: Move Terms Skill-Sync Guard Into the API Package and Evict All Users on Reset * fix: Batch Terms Reset Cache Eviction and Sign the Spec User In Fresh * fix: Let Stop Through the Terms Gate, Refresh Startup Config, and Wait Out Failed Eviction * refactor: Narrow the Terms Exemptions and Share One Refusal Path Across Clients * refactor: Compose the JWT Terms Gate Through an API Package Helper * style: Sort Imports for the Shared Terms Refusal Helper * test: Expose the Terms Gate Helper in the JWT Auth Spec Mock * test: Cover the Terms Refusal Code on Pre-Stream Upload Errors |
||
|
|
1994a4949d
|
🔏 fix: Encrypt Provider Keys With v3, Reject Plaintext in decryptV2 and Default to Strong Backup Codes (#17051)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
* fix: Write User Provider Keys With Random-IV v3 Format * fix: Reject Undelimited Input in decryptV2 Instead of Returning It * fix: Default 2FA Backup Codes to the Strong Format * fix: Limit Admin Secret Preview to the Last Four Characters * fix: Re-Derive Stored Secret Previews Under the Last-Four Policy * test: Build Legacy Credential Fixtures With the Server Key * fix: Load Request Config for User Key Writes and Mask Legacy Previews |
||
|
|
0bc344fcb9
|
🔑 feat: Let Users Connect Their Own Account for Pull Request Lookups (#16989)
* feat: Let Users Connect Their Own Account for Pull Request Lookups * fix: Refuse Cross-Tenant Pull Request Callbacks and Surface Key Failures * fix: Keep Pull Request Grants Through Outages and Remove Them on Disconnect A token endpoint server error is an outage even with an OAuth error body, so it no longer deletes the grant, and a refresh outage reaches the lookup as unavailable instead of falling back to no token. Disconnect removes every pr_oauth row of the user, whatever app or host is configured now. A grant that never expires extends its retention when used, and the flow, request and retention limits are configurable. The connection routes are built in packages/api, mounted behind the pre-auth tenant middleware in both servers, and answer failures with stable codes. * fix: Keep the Pull Request OAuth App Out of Overrides A role, group, user or tenant override can no longer change or remove pullRequests.oauth, so the connect capability and the callback see the operator's app. * fix: Read a User's Pull Request Token Only With the Feature On * fix: Report a Malformed Stored Pull Request Grant as a Failure * fix: Remove a User's Stored Tokens When an Administrator Deletes the User * fix: Answer No Pull Request for a Conversation Without a Lane When the User Token Fails * fix: Share One Grant Read Between Concurrent Callers and Report an Expired Grant Disconnected * fix: Remove a Pull Request Grant Only on a Definite Refusal and Past Its Retention * fix: Version Pull Request Grants and Coordinate Refresh, Refusal and Retention Through Them * fix: Invalidate a Refused User Token and Read It Only for a Lane That Needs It * fix: Finish a Pull Request Connection Under the User's Effective Config Behind the Login Limiter * fix: Type the Pull Request User Token for Isolated Declarations and Settle Retention Before Answering * fix: Bind a Pull Request Connection Flow to the Generation a Disconnect Replaces * fix: Start a Batch's User Token Read Only Within Its Deadline * fix: Fence Pull Request Token Reads Against a Disconnect and Report a Failed Retention Cleanup * fix: Fence Connection Status Like Token Reads and Keep a Newer Read Joinable * fix: Report a Pull Request Grant Without Its App and Name the Sign-In That Made It * fix: Read a User's Unexpired Pull Request Grants Newest First * fix: Mark the Connection Callback as an OAuth Navigation and Report a Failed Extension * fix: Name the Pull Request Sign-In Flow on Its Landing Page * fix: Remove a Pull Request Grant of a Replaced App When It Is Read * fix: Keep a Replaced App's Grant Untouched and Extend Retention From Each Day's Use * fix: Accept a Pull Request Grant Only Under the User's Current Connection Generation * fix: Renew the Connection Generation With a Grant Still in Use * fix: Restore the Previous Connection When a Sign-In Cannot Store Its Grant * fix: Decide a Sign-In by What Was Stored When a Write Does Not Answer * fix: Roll Back a Sign-In's Generation Along With a Grant It Must Remove * fix: Refresh an Access Token a Lookup Was Refused With Before Ending the Connection * fix: Undo a Sign-In Only for a Confirmed Fence, Not a Failed Check * fix: Read a User Token Again When the Connection Changes Under the Read * fix: Apply the Current Retention Again When Another Replica Changed the Grant First * test: Answer Each Concurrent Sign-In by Its Own Code * fix: Skip Retention Rewrites for Grants That Expire Without a Refresh Token * fix: Retry a Token Rejection That Loses to a Concurrent Grant Write * fix: Skip User Token Reads for Lanes Without a Commit and Reread Status After a Reconnect |
||
|
|
52a91b23fc
|
♻️ feat: Share Pull Request Lookups Across Replicas Through Redis (#16988)
* feat: Share Pull Request Lookups Across Replicas Through Redis * fix: Bound the Shared Pull Request Cache and Drop Commands at Their Deadline * fix: Pass the Cache Config to the Pull Request Store and Check It Before a Local Cooldown * fix: Keep Batch Lookups Apart by Cache and Sharing Policy * fix: Share Only Found Pull Requests and Rate Limits, Never Moving Them Backwards |
||
|
|
b24bfc0dd0
|
🦊 feat: Look Up GitLab Merge Requests Behind a Provider Setting (#16986)
* feat: Look Up GitLab Merge Requests Behind a Provider Setting * fix: Revalidate GitLab Merge Requests and Read a Full History Page |
||
|
|
b2bcbf9380
|
🧯 feat: Recover Conversations Whose Attachments Keep Failing (#16965)
* 🧯 feat: Recover Conversations Whose Attachments Keep Failing Once a branch carries a problem attachment, every turn resends it and fails the same way. A failed response whose branch carries files now offers "Retry without files" (re-asks the failed turn with no files as a new version) and, when earlier turns carry files, "Branch without files" (a copy up to the last good answer with every upload and code output left out, with the failed message restored to the composer). File-shaped errors say so in the card. The edit view shows a user message's files as removable chips; "Update & rerun" sends only the kept files and Save is disabled after a removal. Fork is offered on a failed turn and gains a "Leave out files" option, backed by a new `excludeFiles` fork option that drops `files`, `attachments` and the conversation's `files` from the copy. Bedrock rejects a request whose documents share a name, and history resends every earlier document, so repeated names are now numbered before formatting. * 🧯 fix: Cover Steered Files, Hand Off the Whole Failed Turn, Name Replayed Documents Once - Excluding files from a fork also strips attachments steered into a response (`content[].files` on steer parts), which replay like uploads, and the decision lives in `forkFileScope` in packages/api. - The recovery card counts steered attachments as files, and reads the specific code inside a generic `error` envelope, so a rate limit is not offered files as the fix. - "Branch without files" hands the failed turn to the copy's composer the way a message is put back for editing: text through the in-memory handoff, quotes, manual skills and the reasoning override through their compose-time atoms. - Document names are deduplicated over the formatted payload after the steer stamp, so replayed steer documents are numbered too. - Fork stays withheld on a failed response, whose copy would carry the error as an ordinary answer; the card's branch action copies up to the turn before. - Remove-file buttons are natively disabled while the editor is locked. * 🧯 fix: Keep Search Sources, Scope Root Retries, Skip Legacy Rate Limits - A fork without files keeps metadata-only attachments (search sources, file search results) and drops only file-backed ones; the recovery card likewise counts only file-backed attachments as files. - A turn sent at the root takes none of the conversation's file refs: its siblings' uploads (an edited first message, or one retried without its files) no longer come back through the unanchored-continuation fallback. - Rows that carry a legacy LangChain model, key or rate-limit code are not offered files as the fix. * 🧯 fix: Align File Exclusion With Replay's File Shapes, Skip Assistants, Verify the Copy - Shared `messageCarriesFiles` (with `isFileContentPart`, `hasContentPartFiles`, `isFileAttachment`) in data-provider names every shape historical replay reads a file by: uploads, file-backed attachments, attached `files` on any content part, and `image_file`, `file` or direct `file_id` locators. The fork drops all of them and the recovery card detects all of them. - Assistants conversations get no recovery actions: their upstream thread keeps every attachment, and those endpoints offer no fork either. - "Branch without files" checks the returned copy; a server that ignored `excludeFiles` gets an error toast instead of a false recovery. * 🧯 fix: Type Replay's Provider-Native File Locators for the Part Predicates |
||
|
|
4afd5e17f8
|
💓 feat: Keep Quiet Chat Streams Alive Behind Idle-Timeout Proxies (#16904)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
|
||
|
|
578572327a
|
🎚️ feat: Filter OpenRouter Reasoning Efforts by the Selected Model (#16808)
* feat: Filter OpenRouter Reasoning Efforts by the Selected Model * fix: Address Review Findings on OpenRouter Per-Model Reasoning Efforts * fix: Report Catalog Failures, Share Lookups and Honor Direct Endpoints for Reasoning Efforts * fix: Move Capabilities Handler Into packages/api and Harden Catalog Lookups * fix: Scope Reasoning Capabilities to One Endpoint and Gate Editors Until They Load * fix: Skip Catalog Reads for Explicit Definitions and Keep Staged Efforts While Loading * fix: Retry the Reasoning Capabilities Query on Focus and Reconnect After a Failure * fix: Remember Failed Catalog Lookups, Reject Locked Overrides Early and Keep Restored Efforts * fix: Hide Efforts Until the Catalog Is Known, Keep Unlisted Models Unknown and Accept Auto * fix: Mark OpenRouter Endpoints by Their Resolved Host so the Client Fetches Capabilities * fix: Share One OpenRouter Catalog Rule, Build the Catalog URL Safely and Make the Lifetime Configurable * fix: Forward Static Catalog Headers, Resolve Relative Next Links and Align Client Freshness * fix: Limit Capabilities to Exposed Models and Revalidate Against the Server Entry Expiry * fix: Hide Efforts After a Failed Refresh, Reject Malformed Pagination and Skip User-Scoped Catalogs * fix: Use Own-Property Lookups, Skip the Catalog for Auto and Revalidate From the Remaining Lifetime * fix: Treat Request Metadata Headers as Shared, Store Catalogs as Own Entries and Hide Efforts During Refresh * fix: Keep Configured Query Parameters Across Catalog Pages and Treat Expired Idle Data as Unknown * fix: Expose Only Configured Variants, Skip Identity Headers on Fixed Lists and Keep Staged Efforts |
||
|
|
1692814a30
|
🔌 feat: Enable Pull Requests by Default With a Token Fallback (#16876) | ||
|
|
caeb786e97
|
🔀 feat: Show the Conversation Pull Request in the Sidebar List (#16815)
* feat: Show the Conversation Pull Request in the Sidebar List Add a batch lookup route and a sidebar row mark: the state icon with the CI dot, opening the same card beside the row on hover. The row keeps the conversation's own title. * fix: Address Review Findings on the Sidebar Pull Request Batch and Row Mark Cap the whole batch with a configurable deadline, make the row mark a keyboard-reachable button that opens the card on focus, refresh rows when the window regains focus through the shared batch, and show a retryable failure state instead of treating a failed first lookup as no pull request. * fix: Send Sidebar Pull Request Batches One at a Time Queue every batch request behind the one before it, so an oversized list or an overlapping flush cannot multiply the server's configured lookup concurrency, and bound how long one request may hold the queue so a request that never answers cannot stop the rest. * fix: Keep the Batch Request Timeout Above the Server Deadline Default the client's request timeout to just past the longest batchTimeoutSeconds a deployment may configure, so a queued request never starts while the previous request's server-side lookups are still running. * fix: Keep Batch Lookups Inside the Concurrency Limit and Per-Entry Failures Per Entry Share one lookup limiter across every batch request so lookups that outlive a request's deadline keep their slot, answer a missing token only for the conversations that needed it, and point the row at its pull request description only while that text is in the page. * fix: Bound Batch Reads, Scope Concurrency Per Credential, and Gate the Sidebar on the Batch Version Start the batch deadline when the request arrives and bound the config and lane reads, count lookup slots per credential, advertise a batch route version and ask only a server that has it, take no row space for an absent mark, show a failed refresh over a cached empty answer, keep a malformed response from stalling the request queue, and repair the lane recording tests that still used a mock removed on dev. * fix: Move Capability Resolution Into the Package and Harden the Batch Route and Queue Resolve the pull request startup capabilities in packages/api so the route stays wiring only, bound the config and lane reads by the configured deadline, merge identical lanes before taking limiter slots, fall back to the single route when a replica has no batch route, and dispose the batch queue when the signed-in user changes. * fix: Abort the Batch Fallback With Its Request So the Queue Never Overlaps It Give the batch fetcher the request's abort signal and pass it to every single-route call, abort a request that times out or is disposed, and stop the fallback workers from starting more calls once it has. * fix: Forward the Abort Signal to the Batch POST Pass the request's abort signal through the batch fetcher, the data-provider call and Axios, so a batch request that times out or is disposed is cancelled instead of continuing beside the next one, and settle a request promptly when it is aborted. * fix: Close the Pull Request Lookup Follow-Ups and Cancel Abandoned Sidebar Rows |
||
|
|
abed1a29e3
|
🔀 feat: Show the Conversation Pull Request in the Chat Header (#16794)
* feat: Show the Conversation Pull Request in the Chat Header A header chip shows the pull request a code conversation opened: the agent picture with a CI status dot, the pull request icon and a truncated title. It opens a card with the number, added and removed lines, a link to GitHub, and state and checks badges. The chip renders nothing while loading, when there is no pull request, or when the first lookup fails. * feat: Place the Pull Request Chip Beside the Model Controls and Move It to the Overflow Menu on Small Screens On desktop the chip sits with the left header controls and its card opens to the right as an Ariakit hovercard that slides in from the left, on hover or keyboard focus. Small screens offer the same card from the header overflow menu through a dialog, following the dialog-item contract. * fix: Address Review Findings on Pull Request Polling, Badges and Tooltip Layering Advertise pullRequestsEnabled in the startup config and skip the lookup without it, keep polling a finished pull request while its checks run, render the card badges with the shared Chip, and portal the GitHub tooltip into the card's own layer. * fix: Address Second Round Review Findings on the Pull Request Dialog and Chip Scope the mobile dialog to the conversation it opened for and expose dialog semantics on its menu entry, only use the chat agent's avatar for the routed conversation, and make the hover tests move the pointer the way a browser does so they pass under NODE_ENV=development as CI runs them. |
||
|
|
ae44437e16
|
🗂️ feat: Record Lane Git State and Serve Conversation Pull Requests (#16793)
* feat: Record Lane Git State and Serve Conversation Pull Requests A conversation now stores the branch, head and repository its code lane last reported, written only by the server after a finished bash command and excluded from ordinary reads, generic saves, unset fields and imports. GET /api/convos/:conversationId/pull-request finds the pull request for that branch through an injected GitHub source with a bounded cache, answers null for an absence, and maps failures to stable codes without upstream text. The feature is off unless endpoints.agents.pullRequests is enabled with a token reference. * fix: Address Review Findings on Pull Request Lookup and Lane Writes Scope the lookup cache, shared in-flight request and rate limit cooldown to the credential, so one tenant's token never serves another. Ask for open pull requests on their own before falling back to the newest closed one, read every page of check runs up to a bound and never report an incomplete rollup as passing, order lane writes per conversation so an older write cannot land last, and name both required token permissions in the example config. * fix: Address Second Round Review Findings on Pull Request Lookup Clear the stored lane when the conversation moves to another workspace or leaves attached execution, so the previous workspace's pull request is never served. Fence the lane write on the time it was reported, so an older report from another replica cannot replace a newer one. Honor GitHub's reset window up to an hour instead of ten minutes, and expose the request timeout, whole lookup timeout and check run page limit as endpoints.agents.pullRequests settings with the previous values as defaults. * fix: Authorize Pull Request Repositories and Fence Lane Writes Require an administrator allowlist of repositories before the server token is used, since a worker reports its own repository. Match a pull request to the commit the conversation last ran at, so a reused branch name does not return another pull request. Fence the lane write on the workspace the command ran in, so a write queued before a move cannot bring the old lane back, and record a subagent thread's lane on the visible root conversation. Key the lookup cache and shared request by the recorded commit and the lookup policy, and document the worker flag in the example config. * fix: Order Lane Reports by a Database Sequence and Tighten Head Matching Replace wall clock ordering of lane reports with a per conversation counter reserved in the database when the command settles, so replica clock skew cannot reject a newer report. Treat a pull request whose head is behind the recorded commit as no match, and expose the candidate and comparison bounds of the history search as settings. Read the app config and the owner scoped lane together, inject the HTTP transport from the route instead of falling back to a global, skip a report identical to the last one written, and name the Contents permission that commit comparison needs. * fix: Queue Lane Reports by the Visible Conversation and Read Checks for the Current Head Order lane report reservations by the conversation the write lands on, so two subagent threads of one conversation share a chain, and write every report instead of skipping a repeat, since another recorder may have changed the lane in between. Read a pull request's detail before its check runs and use the head it reports, so line counts, mergeability and checks describe one commit. Treat an expired temporary chat as gone when reserving, writing and reading the lane, and make the shared cache capacity a setting. * fix: Fence Lane Reports by Attachment Epoch and Place Recorders Before Reporting Strip dotted descendants of lane fields from saves and imports, partition the pull request cache per credential, resolve the lane write target when the tool is created, and fence reports with a codeAttachmentEpoch that advances only on an owner move or detach. * fix: Fence Subagent Lane Reports by the Root Epoch and Cover Forks and Moved Heads Read the visible root's attachment epoch for a subagent report, gate lane recording on pullRequests.enabled, make the credential partition bound a config field, revalidate the detail head against the recorded commit, and find fork pull requests through the recorded commit. * fix: Keep the Credential Cache Bound Deployment Wide and Budget Head Revalidation Apply the largest configured credential bound to the shared cache, count cache hits as use, spend the comparison budget on a moved head, and fix the data-provider config default test. * fix: Cool Down Headerless Secondary Rate Limits A 403 whose message names a secondary rate limit now starts the credential cooldown for at least a minute instead of being cached as a ten second failure. |
||
|
|
cac13c42e7
|
🧷 fix: Finalize Stopped Compactions and Verify Their Anchor (#16551)
* 📴 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 |
||
|
|
edc96d549e
|
📴 fix: Persist Cancelled Compactions With Their Identity (#16436)
* 📴 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 |
||
|
|
3f442e4dbe
|
🪶 perf: Load Tool-Call Previews and Fetch Full Parts on Demand (#16753)
* 🧾 perf: Load Tool-Call Previews and Fetch Full Parts on Demand Long agent conversations shipped every tool output, argument string and subagent transcript on load, though the cards render collapsed: 12-18 MB of message JSON per chat, enough to crash iPhone Safari tabs. A client that adds ?toolPreviews=1 to the conversation load now receives bounded previews of settled tool calls (start and end of long outputs, JSON arguments and outputs kept valid with only their longest strings shortened, exit-status trailers kept whole, subagent transcripts omitted) with explicit markers and full lengths. Opening a card or a subagent panel fetches the stored part from a new owner-scoped endpoint, GET /api/messages/:conversationId/:messageId/parts/:partIndex, cached under its own React Query key. Clients that do not ask, exports and share links keep the full payload; bounds are configurable under toolCallPreviews in librechat.yaml, and a client-authored message that carries previews is refused rather than saved. * 🧾 fix: Validate Part Reads in Parallel and Preview Fork Responses The full-part read now starts beside conversation-access validation instead of after it, and keeps the active-job fallback the conversation read has, so a conversation still live before its first save can expand its previews. Fork, duplicate and shared-link fork responses honor the preview parameter, so they no longer seed the conversation cache with the full history. Background-task results whose structure cannot fit a valid JSON preview go whole, image cards keep their prompts, and the subagent panel offers a retry when its stored part fails to load. * 🧾 fix: Key Hydrated Parts by Preview Revision and Call Identity A fetched part is now cached under the preview's revision and replaces only the fields the server shortened, so a call whose stored output changes later (a harvested background result) is fetched again rather than rolled back. Part lookups carry the run-step and agent identity and refuse an ambiguous fallback, since provider tool-call ids can repeat within one response. A subagent that finished without final text has its transcript omitted like any other settled call, and JSON nested past a fixed depth falls back to a text preview; a call whose preview fails is sent whole instead of failing the conversation load. * 🧾 fix: Release Hydrated Parts With Their History and Bound JSON Work Full tool-call parts fetched for a conversation are removed when its message history is released or cleared, so they cannot outlive it under their own key. The structure-preserving JSON preview now bails out before cloning when the value has more nodes or strings than could ever fit, keeps a __proto__ key as ordinary data, and the part endpoint accepts any safe-integer index instead of an arbitrary ceiling. * 🧾 fix: Count Property Names Before Cloning a JSON Preview Property names are never shortened, so the pre-check now adds their length to its budget and falls back to the text preview before any cloning when they alone could not fit. * 🧾 fix: Preview Artifact and Branch Responses and Rehydrate Subagent Prompts Artifact edits and parallel-response branches merge the message the server returns into the conversation cache, so both requests now ask for previews and their routes honor it. The subagent panel reads the prompt from the stored arguments once they load, and the part endpoint no longer caps identifier length, so any previewed call can be fetched. * 🧾 fix: Preview Only Tool Calls That Can Be Fetched Back by Identity A call without an id has nothing but its position to name it, and the position can shift on the client, so it is left whole instead of being previewed. The part endpoint now requires a tool-call id, so an indexed lookup always confirms the call it returns. * 🧾 fix: Fetch Parts by Exact Identity and Preview Only Unique Ones The part endpoint now finds a call by its exact identity (provider id, run-step id, agent) instead of trusting the client's index, and the preview pass only shortens calls whose identity is unique in their message, so every preview names exactly one stored part. Legacy web-search failures that carry their error phrase mid-output go whole, since the collapsed card reads that phrase anywhere. * 🧾 fix: Bound the JSON Fit Walk Before Queueing and Normalize Empty Identities The structure check now counts an array's or object's children against the node budget before queueing them, so a very wide value is refused without building a work list its size. An empty run-step or agent id is treated as absent by the part lookup, matching how the preview pass and the client already treat it. * 🧾 fix: Key Fetched Parts to the Stored Version and Hydrate Search Details Each preview now carries `previewRevision`, when its message last changed, and the client keys fetched parts to that plus a fingerprint of the whole preview, so any change to the stored call is fetched again. The web-search details card asks for the stored call when it opens, so its query is never left shortened. * 🧾 fix: Cache Fetched Parts by Identity and Hold Copy Until Hydrated The part query key drops the client-side index, which only rides along in the request; the server locates the call by message and exact identity, so a shifted index serves the cached copy instead of downloading it again. Copy controls inside a previewed part are disabled until the stored content arrives, so a slow or failed fetch cannot export shortened text. * 🧾 fix: Shape Shared Forks With the Recipient's Bounds and Keep JSON Numbers Exact A shared-link fork resolves the share owner's config for its content checks, but the forked conversation belongs to the requester, so its preview bounds now come from the requester's tenant and role (prepareResultToolCallPreviews). A structure-preserving JSON preview now requires every number in the text to survive a parse and re-serialization as the same value; an integer past 2^53, an out-of-range exponent or an over-precise decimal falls back to the text preview (or the whole output for parsed-output tools) instead of showing a changed value. |
||
|
|
c23fbc8f77
|
🧬 fix: Default Subagents to Their Parent's Code Machine and Workspace (#16756)
* 🧬 fix: Default Subagents to Their Parent's Code Machine and Workspace
A subagent resolved its code machine from its own saved fields only, so
when a chat routed the parent to an allowlisted machine the subagent fell
back to its own default and whatever workspace the conversation had
selected there, or failed the parent's whole turn when none existed.
Subagents now inherit the parent's resolved attached machine when it is
their own default or on their allowlist where per-chat choice applies,
the principal can use it, the sealed decision already selected it, and no
selection names the subagent as an explicit owner. Inheritance is derived
per request from the sealed decision and current agent configuration and
fed to every routing site; it is never persisted, so existing chats and
older clients get it without a decision change. The composer mirrors it.
A subagent whose machine has no usable workspace is advertised to the
parent as unavailable instead of failing the turn; a locked decision
stays fatal.
* fix: Inherit Across Every Spawning Path, Graph Members and Deferred Code Tools
A subagent now inherits only when every agent that can spawn it, at any
depth, runs on the same machine; spawn cycles keep their own routes.
Subagent graph members inherit like explicit subagents. The deferred
execute_code loader passes inheritance to its fallback resolver. Subagent
reads and VIEW checks move to a packages/api loader shared by inheritance,
lazy descriptors and graph members. The composer lets a draft's subagent
follow its parent's machine before a workspace is picked, and keeps an
inheriting subagent's former selection without asking for a move.
* fix: Prune Spawn Back-Edges, Gate the Composer on an Inheritance Capability
Spawning parents follow the run's path semantics, so a back-edge the
descriptor tree prunes no longer blocks inheritance, and agents that spawn
each other follow their single outside parent machine when it routes them
all there. Only admitted subagents count toward the walk's node limit.
Graph members re-read and re-check VIEW when they initialize. The composer
echoes an inheriting subagent's former selection without gating on that
machine, and mirrors inheritance only when the API advertises
codeWorkspaceInheritanceVersion; approval modes keep intersecting every
machine an agent could use.
* fix: Settle Each Mutually Spawning Group on Its Own
Independent spawn cycles no longer merge into one group, so a pair under
one parent follows that parent even when another pair follows a different
machine. Also types the data-provider spec for its ES5 target.
* fix: Bound the Inheritance Walk, Normalize Parallel Roots, Move Subagent Availability to TS
The walk reads in batches no larger than the remaining node budget, stops
once the limit is reached, and runs through the run's subagent load limiter.
Roots are keyed by saved agent ID, so a parallel root such as id____1 can
never receive an inheritance entry. Resolving a lazy subagent's code route,
reporting it unavailable, and guarding its descriptor now live in
packages/api (resolveSubagentCodeAvailability, guardUnavailableSubagent).
* fix: Keep Missing Subagent Loads Parallel Near the Node Limit
Batches never shrink below eight IDs, so missing or unviewable subagents
near the limit still load in parallel under the injected limiter, and at
most a handful of reads land past the limit.
|
||
|
|
3c90cde7d8
|
🔗 feat: use LibreChat prompt groups as agent instructions (#16686)
* 🔗 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>
|