* 🗜️ feat: Manual Context Compaction as a Summarize-Only Turn
Adds a user-triggered "Compact context" action that summarizes the active
branch on demand. The compaction is an ordinary agent turn: the client
submits it through the normal chat pipeline with `compact: true`, the
controller hangs it off the branch's leaf instead of creating a user
message, and the agent client runs the graph summarize-only (the SDK's new
`summarizeOnly` input), so the summary streams into the response
placeholder under the leaf exactly like the automatic detour's and is
persisted as the boundary every later turn starts from.
Nothing new is needed for job registration, billing, abort, persistence,
or the usage snapshot: the run emits the same summary step and post-summary
context snapshot the automatic path already emits, and the response message
carries the summary part plus the `summaryUsedTokens` baseline the gauge
reads. The controller validates the request (existing conversation, a real
leaf, summarization enabled, no edit/regenerate/continue combination) and
answers 409 when the leaf is already a bare summary.
Client-side the submission borrows the regenerate shape — no new user
bubble, the placeholder parents onto the leaf — while the wire payload
drops `isRegenerate` so the server never treats it as a regenerated user
turn. The action sits in the context-usage popover, gated by the same
`summarization.enabled` switch as the automatic detour.
* 🗜️ fix: Localize a Compaction That Cannot Run
A compaction the graph could not attempt (summarization disabled, the
instructions already exceeding the budget, or an explicit recency window
covering the whole conversation) rejects with the SDK's
`ManualSummarizationSkippedError`, which rendered as the generic admin
error. It now maps to a typed `compaction_skipped` payload with the reason,
and a run that ends with neither a summary nor a recorded error fails as
`compaction_failed`; the Error component localizes both. A run that already
recorded why it stopped keeps that error part instead of failing twice.
* 🗜️ fix: Anchor a Compaction on the Leaf Everywhere It Is Read
Review round 1.
- The client sent the leaf's parent as `parentMessageId`, which the
controller treats as the anchor, so the summary would have skipped the
latest reply and landed as its sibling. The leaf's own id is now both the
placeholder's parent and the server-side anchor.
- A compaction has no user message of its own, and every consumer of the
job's user-message slot now knows it: the error path parents its row on
the loaded anchor and never upserts the leaf, and the job records the
regenerate shape so a reconnecting client rebuilds the turn under the
leaf instead of recreating it as a user message.
- The controller no longer reads the anchor before the branch is loaded;
`BaseClient` validates it against the history it loads anyway and
answers 404 for a missing leaf or a typed `nothing_to_summarize` for a
finished compaction. That predicate is shared through the data provider
and ignores a summary still streaming or one that failed, so an
interrupted compaction can be retried.
- A compaction never consumes files staged in the composer, the action is
shown only when the server advertises `compactionEnabled`, and the
in-flight marker is feature-local Jotai state rather than a read of the
Recoil submission store.
* 🗜️ fix: Keep a Compaction Turn to Its Summary
Review round 2, plus the class it belongs to. A compaction submits no user
turn, so nothing that keys off one may run: the memory pass no longer runs
over the history (it would have spent a model call and could repeat memory
writes), and skill primes are no longer injected into the transcript the
run is about to summarize.
The client's in-flight marker is also reconciled on mount: a compaction
that finished while the view was away left the marker set, and the next
ordinary turn in that conversation would have shown as compacting.
* 🧹 chore: Sort Imports in the Compaction Hook Spec
* 🔧 chore: Update @librechat/agents dependency to version 3.8.1 in package-lock.json and package.json files
`createPayload` interpolated the endpoint name straight into the chat URL,
so a custom endpoint named `Company/API` produced
`/api/agents/chat/Company/API`. The slash reads as a path separator, the
request no longer matches the router's `/:endpoint`, and it falls through
to the catch-all handler, which answers `404 Endpoint not found`.
Encoding the name keeps it a single path segment. Express matches the
encoded segment and decodes it back, and the endpoint the server acts on
comes from the request body regardless, so nothing else has to change.
Closes#15270