@librechat/agents 3.4.7 → 3.5.0

package/dist/esm/summarization/node.mjs

@@ -16,24 +16,7 @@ import { getMaxOutputTokensKey } from "../llm/request.mjs";
 import { AIMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 //#region src/summarization/node.ts
 const SUMMARIZATION_PARAM_KEYS = new Set(["maxSummaryTokens"]);
-/**
-* Default number of recent user-led turns preserved verbatim during
-* compaction.  A turn begins at a HumanMessage and includes every
-* following AIMessage and ToolMessage up to the next HumanMessage.
-* The most recent turn is always retained regardless of this value;
-* the default of `2` additionally keeps the prior exchange so the
-* model has fresh context on what just happened.  Setting
-* `retainRecent.turns` to `0` reverts to the legacy "summarize every
-* message" behavior.
-*/
-/**
-* Token overhead of the XML wrapper + instruction text added around the
-* summary at injection time in AgentContext.buildSystemRunnable:
-* `<summary>\n${text}\n</summary>\n\nYour context window was compacted...`
-* ~33 tokens on Anthropic, ~24-27 on OpenAI.  Using 33 as a safe ceiling.
-*/
 const SUMMARY_WRAPPER_OVERHEAD_TOKENS = 33;
-/** Structured checkpoint prompt for fresh summarization (no prior summary). */
 const DEFAULT_SUMMARIZATION_PROMPT = `Hold on, before you continue I need you to write me a checkpoint of everything so far. Your context window is filling up and this checkpoint replaces the messages above, so capture everything you need to pick right back up.
 
 Don't second-guess or fact-check anything you did, your tool results reflect exactly what happened. If a tool result appears truncated, that's just a display artifact from context management: the tool executed fully. Just record what you did and what you observed. Only the checkpoint, don't respond to me or continue the conversation.
@@ -68,7 +51,6 @@ Rules:
 - Preserve exact identifiers, names, errors, and references verbatim
 - Short declarative sentences
 - Skip empty sections`;
-/** Prompt for re-compaction when a prior summary exists. */
 const DEFAULT_UPDATE_SUMMARIZATION_PROMPT = `Hold on again, update your checkpoint. Merge the new messages into your existing checkpoint and give me a single consolidated replacement.
 
 Keep it roughly the same length as your last checkpoint. Compress older details to make room for what's new, don't just append. Give recent actions more detail, compress older items to one-liners.
@@ -94,11 +76,6 @@ function separateParameters(parameters) {
 		maxSummaryTokens
 	};
 }
-/**
-* Generates a structural metadata summary without making an LLM call.
-* Used as a last-resort fallback when all summarization attempts fail.
-* Preserves tool names and message counts so the agent retains basic context.
-*/
 function generateMetadataStub(messages) {
 	const counts = {};
 	const toolNames = /* @__PURE__ */ new Set();
@@ -113,15 +90,8 @@ function generateMetadataStub(messages) {
 	if (toolNames.size > 0) lines.push(`[Tools used: ${Array.from(toolNames).join(", ")}]`);
 	return lines.join("\n");
 }
-/** Maximum number of tool failures to include in the enrichment section. */
 const MAX_TOOL_FAILURES = 8;
-/** Maximum chars per failure summary line. */
 const MAX_TOOL_FAILURE_CHARS = 240;
-/**
-* Extracts failed tool results from messages and formats them as a structured
-* section. LLMs often omit specific failure details (exit codes, error messages)
-* from their summaries, this mechanical enrichment guarantees they survive.
-*/
 function extractToolFailuresSection(messages) {
 	const failures = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -145,20 +115,9 @@ function extractToolFailuresSection(messages) {
 	if (failures.length > MAX_TOOL_FAILURES) lines.push(`- ...and ${failures.length - MAX_TOOL_FAILURES} more`);
 	return `\n\n## Tool Failures\n${lines.join("\n")}`;
 }
-/**
-* Appends mechanical enrichment sections to an LLM-generated summary.
-* Tool failures are appended verbatim because LLMs often omit specific
-* error details from their summaries.
-*/
 function enrichSummary(summaryText, messages) {
 	return summaryText + extractToolFailuresSection(messages);
 }
-/**
-* Restores pre-masking tool content onto the messages array using
-* `pendingOriginalToolContent` stored on AgentContext. Only allocates
-* a new array when there are entries to restore; otherwise returns the
-* input reference unchanged.
-*/
 function restoreOriginalToolContent(messages, originalToolContent, maxContextTokens) {
 	if (originalToolContent == null || originalToolContent.size === 0) return messages;
 	const restorable = [];
@@ -171,11 +130,6 @@ function restoreOriginalToolContent(messages, originalToolContent, maxContextTok
 		});
 	}
 	if (restorable.length === 0) return messages;
-	/**
-	* Restored originals improve checkpoint quality, but they still feed a
-	* provider call. Share one tool-result budget across every restoration so
-	* several previously masked results cannot overflow the summarizer.
-	*/
 	let remainingChars = calculateMaxToolResultChars(maxContextTokens);
 	const restored = [...messages];
 	for (let i = 0; i < restorable.length; i++) {
@@ -187,7 +141,6 @@ function restoreOriginalToolContent(messages, originalToolContent, maxContextTok
 	}
 	return restored;
 }
-/** Assembles the summarization model's client options from agent and config. */
 function buildSummarizationClientConfig(agentContext, summarizationConfig) {
 	const provider = summarizationConfig?.provider ?? agentContext.provider;
 	const modelName = summarizationConfig?.model;
@@ -214,54 +167,12 @@ function buildSummarizationClientConfig(agentContext, summarizationConfig) {
 		updatePromptText
 	};
 }
-/** Computes the token count for a summary, preferring provider output tokens when available. */
 function computeSummaryTokenCount(summaryText, summaryUsage, tokenCounter) {
 	const providerOutputTokens = Number(summaryUsage?.output_tokens) || 0;
 	if (providerOutputTokens > 0) return providerOutputTokens + SUMMARY_WRAPPER_OVERHEAD_TOKENS;
 	if (tokenCounter) return tokenCounter(new SystemMessage(summaryText)) + SUMMARY_WRAPPER_OVERHEAD_TOKENS;
 	return 0;
 }
-/**
-* Names the first retained message so the summary declares its own extent
-* rather than leaving the next run to infer coverage from where the block
-* happens to sit.
-*
-* Anchored to the retained side, not the covered side. One source message can
-* expand into several messages — a steer splits an assistant entry into
-* pre-steer, steer, and post-steer entries sharing its ID — and the recency
-* split lands on any human-type message, including the steer. Naming the last
-* *covered* message would then name a half-covered ID with no correct reading;
-* naming the first *retained* message makes that same message the anchor, so it
-* survives whole and everything before it is unambiguously covered.
-*
-* Synthetic entries are skipped, because they can sit *before* a resolvable
-* one. `formatAgentMessages` reconstructs skill bodies inside its payload loop
-* (see the `pendingSkillNames` block) and keeps processing payload entries
-* afterwards, so an unstamped skill body — which `messagesStateReducer` then
-* gives a UUID no payload entry carries — is followed by stamped messages.
-* Anchoring on the UUID would look resolvable at write time and degrade to
-* positional trimming on read, dropping the retained tail. Skipping it reaches
-* the stamped message behind it.
-*
-* `convertInjectedMessages` records `injected` on everything it builds, which is
-* what makes this decidable: `isMeta` and `source` are both optional on
-* `InjectedMessage`, so a bare entry carries no marker of its own, and an
-* injected `source: 'steer'` is otherwise indistinguishable from a replayed one.
-* The remaining `isMeta`/`source` checks cover the constructors that build
-* synthetic entries directly instead of going through that funnel — hook context
-* in `ToolNode` and `StandardGraph`, handoff cues, reconstructed skill bodies.
-*
-* `steer` is exempt from the `source` check because a replayed steer *is*
-* correlated with its payload entry; rejecting every marked `source` once
-* dropped exactly those retained steers. Injected steers are still caught, by
-* `injected`.
-*
-* Known limitation: a payload entry that omits `messageId` is never stamped, so
-* the reducer's UUID is recorded and cannot resolve on the next run. There is no
-* write-time fix — such an entry has no stable ID to name in the next payload
-* either — and the reader's positional fallback is what `main` already does, so
-* the anchor degrades rather than misleads.
-*/
 function isSyntheticContext(message) {
 	const { additional_kwargs: kwargs } = message;
 	if (kwargs.injected === true || kwargs.isMeta === true) return true;
@@ -277,7 +188,6 @@ function resolveSummaryCoverage(messagesToRetain) {
 		if (id != null && id !== "") return { retainedFromMessageId: id };
 	}
 }
-/** Constructs the SummaryContentBlock persisted in the run step and dispatched to events. */
 function buildSummaryBlock(params) {
 	return {
 		type: "summary",
@@ -297,12 +207,6 @@ function buildSummaryBlock(params) {
 		createdAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 }
-/**
-* Extracts an HTTP status code from a thrown LLM-provider error. Returns
-* `undefined` for non-object values (including `null` or `undefined`, both
-* valid `throw` targets in JS) so callers never dereference a nullish
-* value.
-*/
 function extractHttpStatus(err) {
 	if (err == null || typeof err !== "object") return;
 	const errRecord = err;
@@ -316,11 +220,6 @@ function extractHttpStatus(err) {
 		if (typeof nested === "number") return nested;
 	}
 }
-/**
-* Formats a provider-level error for logging. Returns both a human-readable
-* suffix (safe to include in the message string so it survives any host-side
-* formatter) and a structured metadata bag for rich log backends.
-*/
 function describeProviderError(err, provider, modelName) {
 	const providerLabel = `${provider}/${modelName ?? "(no-model)"}`;
 	const errMsg = err instanceof Error ? err.message : String(err);
@@ -340,17 +239,6 @@ function describeProviderError(err, provider, modelName) {
 		data
 	};
 }
-/**
-* Formats an exhausted-fallback error. `tryFallbackProviders` throws the
-* last fallback provider's error, which may be from any of the configured
-* fallbacks — not the primary — so we label the log with the list of
-* fallback providers attempted rather than mis-attributing to the primary.
-*
-* Entries in `fallbacks` are normally strongly typed, but we defend against
-* malformed runtime config (null/undefined entries, missing `provider`
-* field) so a recoverable summarization failure is never promoted to an
-* uncaught exception from inside the logging path.
-*/
 function describeFallbackError(err, fallbacks) {
 	const errMsg = err instanceof Error ? err.message : String(err);
 	const list = Array.isArray(fallbacks) ? fallbacks : [];
@@ -376,10 +264,6 @@ function describeFallbackError(err, fallbacks) {
 		data
 	};
 }
-/**
-* Runs the summarization LLM call with primary + fallback providers,
-* falling back to a metadata stub when all calls fail.
-*/
 async function executeSummarizationWithFallback(params) {
 	const { agentContext, messages, clientConfig, summarizeConfig, stepId, usePromptCache, log, graph } = params;
 	const priorSummaryText = agentContext.getSummaryText()?.trim() ?? "";
@@ -414,22 +298,7 @@ async function executeSummarizationWithFallback(params) {
 			...primaryDescribed.data,
 			messagesToRefineCount: messages.length
 		});
-		/**
-		* A tripped stream circuit breaker is a safety abort, not a
-		* summarization failure to recover from: retrying on fallback providers
-		* would spend more provider work after the limit fired, and degrading to
-		* the metadata stub would let the run continue (and periodic compaction
-		* commit the stub) despite the `StreamLimits` contract that a breach
-		* rejects the run. Rethrown so the summarize node fails the run with
-		* the actionable limit error, consistent with agent turns and subagents.
-		*/
 		if (primaryError instanceof StreamLimitExceededError) throw primaryError;
-		/** A parallel branch's trip aborts the composed summarization signal,
-		* and a provider can surface that as a generic abort error; entering
-		* fallback recovery or degrading to the metadata stub would continue
-		* work after the run-wide safety abort. Checked on BOTH channels: the
-		* graph's own breaker, and the composed config signal that carries a
-		* parent run's trip into subagent child graphs. */
 		{
 			const trippedReason = findStreamLimitAbortReason(graph?.getBreakerSignal?.(), summarizeConfig?.signal);
 			if (trippedReason != null) throw trippedReason;
@@ -474,7 +343,6 @@ async function executeSummarizationWithFallback(params) {
 		usedMetadataStub
 	};
 }
-/** Dispatches run step completion, ON_SUMMARIZE_COMPLETE, and rebuilds token map. */
 async function dispatchCompletionEvents(params) {
 	const { graph, runnableConfig, stepId, summaryBlock, agentContext, runStep, summaryUsage, agentId, messagesAfterCount } = params;
 	runStep.summary = summaryBlock;
@@ -512,9 +380,6 @@ async function dispatchCompletionEvents(params) {
 	}
 	agentContext.rebuildTokenMapAfterSummarization({});
 }
-/** Composes the run's breaker signal (when the adapter provides one) into a
-* summarization attempt's config, so breaches in sibling branches cancel
-* summaries too. */
 function withBreakerSignal(config, graph) {
 	const breakerSignal = graph?.getBreakerSignal?.();
 	if (breakerSignal == null) return config;
@@ -529,22 +394,11 @@ function withBreakerSignal(config, graph) {
 		signal: AbortSignal.any([existing, breakerSignal])
 	};
 }
-/** First stream-limit reason found on any of the given signals. Checked
-* alongside the graph's own breaker because a subagent child graph receives
-* a ROOT sibling's trip through its constructor/invocation signal — the
-* child's private breaker never fires for it. */
 function findStreamLimitAbortReason(...signals) {
 	for (const signal of signals) if (signal?.aborted === true && signal.reason instanceof StreamLimitExceededError) return signal.reason;
 }
 function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId }) {
 	return async (state, config) => {
-		/** The breaker signal is captured at node ENTRY, before dispatchRunStep,
-		* ON_SUMMARIZE_START, or PreCompact awaits: a sibling's trip plus a
-		* prompt next run can reset the controller during one of those awaits,
-		* and resolving the live accessor later would bind this summarization
-		* to the fresh controller. `Object.create` freezes the signal while
-		* DELEGATING every other adapter member — spreading would snapshot the
-		* charge-credit accessor pair and detach it from graph resets. */
 		const entryBreakerController = adapterGraph.getBreakerController?.();
 		const entryBreakerSignal = entryBreakerController?.signal ?? adapterGraph.getBreakerSignal?.();
 		const entryBreakerEpoch = adapterGraph.getBreakerEpoch?.();
@@ -554,22 +408,8 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 		});
 		const request = state.summarizationRequest;
 		if (request == null) return { summarizationRequest: void 0 };
-		/** Already-tripped-at-entry: a parallel sibling's breach failed the run
-		* before this node was scheduled — via this graph's own breaker or, in
-		* a subagent child graph, the parent trip on the invocation signal.
-		* Rethrow before dispatching steps, hooks, or the model call — an
-		* adapter that doesn't synchronously reject an aborted signal would
-		* otherwise spend summarization provider work on a failed run. */
 		const entryTripReason = findStreamLimitAbortReason(entryBreakerSignal, config?.signal);
 		if (entryTripReason != null) throw entryTripReason;
-		/**
-		* Overflow recovery routes through this node purely to get back to the
-		* agent node with a corrected budget, and deliberately spends no model
-		* call on its first attempt: re-pruning under the raised context pressure
-		* drives the pruner's tool-output compression and masking, which is
-		* cheaper than a summary and cannot lose message content. Summarization
-		* is also skipped outright when the caller never enabled it.
-		*/
 		if (request.reason === "overflow" && (request.allowSummarization !== true || agentContext.summarizationEnabled !== true)) {
 			emitAgentLog(config, "debug", "summarize", "Overflow recovery re-prune — compressing tool output without a summarization call", {
 				maxContextTokens: agentContext.maxContextTokens,
@@ -593,16 +433,6 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 			});
 			return { summarizationRequest: void 0 };
 		}
-		/**
-		* Capture the original-tool-content map locally before doing the
-		* split.  We need it in three places: to restore the head for
-		* summarizer quality, to leave intact on the skip path (state is
-		* unchanged), and — critically — to carry forward the tail-relevant
-		* entries on the summarize-fired path.  Clearing it eagerly here
-		* would lose the originals for masked tool messages that the
-		* recency window keeps in the tail; a future summarization could
-		* then only summarize the masked stub instead of the full payload.
-		*/
 		const originalPending = agentContext.pendingOriginalToolContent;
 		const restoredMessages = restoreOriginalToolContent(state.messages, originalPending, agentContext.maxContextTokens);
 		const runnableConfig = config ?? graph.config;
@@ -612,28 +442,8 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 			tokens: retainRecent?.tokens,
 			tokenCounter: agentContext.tokenCounter
 		});
-		/**
-		* Use the *masked* messages for the retained tail so that any
-		* truncation prune applied to oversized ToolMessage content stays
-		* truncated in live state.  The summarizer above reads the restored
-		* (full-content) head for summary quality, but reinjecting restored
-		* tool payloads into state would defeat masking and bloat the
-		* checkpoint, forcing more expensive re-pruning on later turns.
-		* `restoreOriginalToolContent` returns an array with identical
-		* length and structure to `state.messages` (replacements only at
-		* specific indices), so the same tailStartIndex slices both arrays
-		* at the same turn boundary.
-		*/
 		const messagesToRetain = state.messages.slice(tailStartIndex);
 		if (messagesToRefine.length === 0) {
-			/**
-			* Recency window covers the entire conversation — there is no
-			* older content to summarize.  Skipping prevents the model from
-			* destroying the user's most recent message (e.g. a large pasted
-			* payload on the first turn) by replacing it with a generic
-			* checkpoint summary.  Mark the trigger so the same unchanged
-			* state is not re-evaluated on the next prune cycle.
-			*/
 			emitAgentLog(config, "debug", "summarize", "Summarization skipped — recency window retains all messages", {
 				messagesRetained: messagesToRetain.length,
 				retainTurns: retainRecent?.turns ?? 2
@@ -710,36 +520,13 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 			metadata: {
 				...config.metadata,
 				agent_id: request.agentId,
-				/** Canonical agent-identity key, overwritten by every component
-				*  that stamps identity (graph model path, ToolNode, here) so the
-				*  closest stamper always wins via spread order — Langfuse scope
-				*  trust relies on it (see `isForeignScope`). */
 				agentId: request.agentId,
 				summarization_provider: clientConfig.provider,
 				summarization_model: clientConfig.modelName,
-				/**
-				* Per-call model attribution for usage consumers (the subagent
-				* usage-capture handler): the summarizer's model can differ from
-				* the agent's primary, and providers that emit no `ls_model_name`
-				* would otherwise be billed against the primary config's model.
-				* Omitted for self-summarize (no explicit model — the primary
-				* config fallback is then correct). `tryFallbackProviders`
-				* overrides this per fallback attempt; `INVOKED_PROVIDER` is
-				* stamped by `attemptInvoke` itself.
-				*/
 				...clientConfig.modelName != null && clientConfig.modelName !== "" ? { ["__invoked_model"]: clientConfig.modelName } : {},
-				/** Entry-captured breaker epoch: the wire consumer epoch-gates
-				* old-run summary chunks exactly like model-attempt chunks —
-				* without the stamp, a straggling summary from a failed run
-				* reads as current and could abort the next run's controller. */
 				...entryBreakerEpoch != null ? { [STREAM_LIMIT_EPOCH_KEY]: entryBreakerEpoch } : {}
 			}
 		} : void 0;
-		/** Rechecked after the pre-call awaits (dispatchRunStep,
-		* ON_SUMMARIZE_START, PreCompact): a sibling can trip the breaker while
-		* this node is paused in one of them, and a provider that doesn't
-		* synchronously reject an aborted signal would still start the
-		* summarization call. Mirrors the model node's pre-invoke recheck. */
 		{
 			const preCallTrip = findStreamLimitAbortReason(entryBreakerSignal, config?.signal);
 			if (preCallTrip != null) throw preCallTrip;
@@ -754,22 +541,9 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 			log,
 			graph
 		});
-		/**
-		* The metadata stub describes the history rather than summarizing it, so
-		* committing it means removing the head and keeping nothing of what it
-		* said. That trade is never worth making to paper over an overflow: the
-		* recovery would "succeed" only by destroying the conversation it was
-		* supposed to preserve. Leave state untouched and let the provider error
-		* surface instead.
-		*/
 		if (usedMetadataStub === true && request.reason === "overflow") {
 			log("warn", "Overflow summarization failed; keeping history rather than replacing it with a metadata stub");
 			agentContext.markSummarizationTriggered(state.messages.length);
-			/**
-			* The run step was already dispatched, so it has to be resolved here or
-			* consumers tracking step lifecycle keep an unfinished placeholder for
-			* the rest of the run.
-			*/
 			await graph.dispatchRunStepCompleted(stepId, {
 				type: "summary",
 				summary: placeholderSummary
@@ -827,26 +601,7 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 			agentId: request.agentId,
 			messagesAfterCount: messagesToRetain.length
 		});
-		/**
-		* `dispatchCompletionEvents` calls `rebuildTokenMapAfterSummarization({})`
-		* which resets the dedupe baseline to 0 — correct under the legacy
-		* "remove-all only" shape where no messages survived, but stale once
-		* the recency window keeps a tail.  Realign the baseline to the
-		* surviving tail length so a subsequent prune cycle on the unchanged
-		* tail short-circuits via `shouldSkipSummarization` instead of
-		* looping back into another summarize call.
-		*/
 		agentContext.markSummarizationTriggered(messagesToRetain.length);
-		/**
-		* Carry forward the original-content entries that correspond to the
-		* retained tail, reindexed for the post-removeAll state where tail
-		* messages start at index 0.  Without this, a future summarization
-		* that pulls these tail messages into its head would only see the
-		* masked stubs (since `setSummary` clears `pruneMessages`, and the
-		* fresh pruner at the next turn has no record of prior masks).
-		* Entries for indices < `tailStartIndex` belong to messages we just
-		* summarized — they are no longer reachable so they are dropped.
-		*/
 		if (originalPending != null && originalPending.size > 0) {
 			const tailPending = /* @__PURE__ */ new Map();
 			for (const [idx, content] of originalPending) if (idx >= tailStartIndex) tailPending.set(idx - tailStartIndex, content);
@@ -858,7 +613,6 @@ function createSummarizeNode({ agentContext, graph: adapterGraph, generateStepId
 		};
 	};
 }
-/** Extracts text from an LLM response, skipping reasoning/thinking blocks. */
 function extractResponseText(response) {
 	const { content } = response;
 	if (typeof content === "string") return content.trim();
@@ -881,29 +635,10 @@ function buildSummarizationInstruction(promptText, updatePromptText, priorSummar
 	if (priorSummaryText) parts.push(`\n\n<previous-summary>\n${priorSummaryText}\n</previous-summary>`);
 	return parts.join("");
 }
-/** Creates an `onChunk` callback that dispatches `ON_SUMMARIZE_DELTA` events for streaming. */
 function createSummarizationChunkHandler({ stepId, config, provider, reasoningKey = "reasoning_content", graph }) {
 	if (stepId == null || stepId === "" || !config) return;
 	const limitMetadata = config.metadata;
 	return (chunk, attemptMetadata) => {
-		/**
-		* Charged as `producer` so it PAIRS with the run's registered stream
-		* handler: inside a live run the provider callbacks route each chunk
-		* through the graph's `on_chat_model_stream` consumer too, and two
-		* same-side consumer claims would charge the chunk twice — halving an
-		* opt-in event cap. Standalone callers (tests, custom hosts, runs with
-		* no registered handler) still get single-sided enforcement from this
-		* one claim. Summarization deliberately passes NO `context` to
-		* `attemptInvoke`, whose onChunk branch would otherwise add a second
-		* producer claim. A breach trips the run's shared breaker (the
-		* ENTRY-captured controller when the adapter provides one) before
-		* rethrowing: this producer claim wins the race, so the wire consumer's
-		* breaker-aborting catch never fires for the same chunk — without the
-		* trip here, sibling model calls, tools, and subagents would keep
-		* consuming quota while the summary branch rejects.
-		* `executeSummarizationWithFallback` then rethrows past fallbacks and
-		* the metadata stub, failing the run like any other breach.
-		*/
 		if (graph != null) try {
 			enforceStreamLimitsForWireChunk({
 				graph,
@@ -946,12 +681,6 @@ function traceConfig(config, stage) {
 		}
 	};
 }
-/**
-* Cache-friendly compaction: sends raw conversation messages with the
-* summarization instruction appended as the final HumanMessage.
-* Providers with prompt caching get a cache hit on the system prompt +
-* tool definitions prefix.
-*/
 async function summarizeWithCacheHit({ model, messages, promptText, updatePromptText, priorSummaryText, config, stepId, provider, reasoningKey, graph, usePromptCache, promptCacheTtl, log }) {
 	const instruction = buildSummarizationInstruction(promptText, updatePromptText, priorSummaryText);
 	const fullMessages = [...messages, new HumanMessage(instruction)];
@@ -966,8 +695,6 @@ async function summarizeWithCacheHit({ model, messages, promptText, updatePrompt
 			reasoningKey,
 			graph
 		}),
-		/** Accounting lease only (summarization passes no `context` so its
-		* producer claim never stacks with the onChunk handler's). */
 		streamLimitState: graph
 	}, withBreakerSignal(traceConfig(config, "cache_hit_compaction"), graph))).messages?.[0];
 	const text = responseMsg ? extractResponseText(responseMsg) : "";