@librechat/agents 3.4.7 → 3.5.0

package/dist/cjs/llm/init.cjs

@@ -6,15 +6,6 @@ const require_index$2 = require("./openai/index.cjs");
 const require_providers = require("./providers.cjs");
 let _langchain_google_vertexai = require("@langchain/google-vertexai");
 //#region src/llm/init.ts
-/**
-* Creates a chat model instance for a given provider, applies provider-specific
-* field assignments, and optionally binds tools.
-*
-* This is the single entry point for model creation across the codebase — used
-* by both the agent graph (main LLM) and the summarization node (compaction LLM).
-* An optional `override` model can be passed to skip construction entirely
-* (useful for cached/reused model instances or test fakes).
-*/
 function initializeModel({ provider, clientOptions, tools, override }) {
 	const model = override ?? new (require_providers.getChatModelClass(provider))(clientOptions ?? {});
 	if (require_llm.isOpenAILike(provider) && (model instanceof require_index$2.ChatOpenAI || model instanceof require_index$2.AzureChatOpenAI)) {

package/dist/cjs/llm/init.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"init.cjs","names":["getChatModelClass","isOpenAILike","ChatOpenAI","AzureChatOpenAI","ChatVertexAI"],"sources":["../../../src/llm/init.ts"],"sourcesContent":["import { ChatVertexAI } from '@langchain/google-vertexai';\nimport type { Runnable } from '@langchain/core/runnables';\nimport type * as t from '@/types';\nimport { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';\nimport { getChatModelClass } from '@/llm/providers';\nimport { isOpenAILike } from '@/utils';\nimport { Providers } from '@/common';\n\n/**\n * Creates a chat model instance for a given provider, applies provider-specific\n * field assignments, and optionally binds tools.\n *\n * This is the single entry point for model creation across the codebase — used\n * by both the agent graph (main LLM) and the summarization node (compaction LLM).\n * An optional `override` model can be passed to skip construction entirely\n * (useful for cached/reused model instances or test fakes).\n */\nexport function initializeModel({\n  provider,\n  clientOptions,\n  tools,\n  override,\n}: {\n  provider: Providers;\n  clientOptions?: t.ClientOptions;\n  tools?: t.GraphTools;\n  override?: t.ChatModelInstance;\n}): Runnable {\n  const model =\n    override ??\n    new (getChatModelClass(provider))(clientOptions ?? ({} as never));\n\n  if (\n    isOpenAILike(provider) &&\n    (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)\n  ) {\n    const opts = clientOptions as t.OpenAIClientOptions | undefined;\n    if (opts) {\n      model.temperature = opts.temperature as number;\n      model.topP = opts.topP as number;\n      model.frequencyPenalty = opts.frequencyPenalty as number;\n      model.presencePenalty = opts.presencePenalty as number;\n      model.n = opts.n as number;\n    }\n  } else if (provider === Providers.VERTEXAI && model instanceof ChatVertexAI) {\n    const opts = clientOptions as t.VertexAIClientOptions | undefined;\n    if (opts) {\n      model.temperature = opts.temperature as number;\n      model.topP = opts.topP as number;\n      model.topK = opts.topK as number;\n      model.topLogprobs = opts.topLogprobs as number;\n      model.frequencyPenalty = opts.frequencyPenalty as number;\n      model.presencePenalty = opts.presencePenalty as number;\n      model.maxOutputTokens = opts.maxOutputTokens as number;\n    }\n  }\n\n  if (!tools || tools.length === 0) {\n    return model as unknown as Runnable;\n  }\n\n  return (model as t.ModelWithTools).bindTools(tools);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,EAC9B,UACA,eACA,OACA,YAMW;CACX,MAAM,QACJ,YACA,KAAKA,kBAAAA,kBAAkB,QAAQ,GAAG,iBAAkB,CAAC,CAAW;CAElE,IACEC,YAAAA,aAAa,QAAQ,MACpB,iBAAiBC,gBAAAA,cAAc,iBAAiBC,gBAAAA,kBACjD;EACA,MAAM,OAAO;EACb,IAAI,MAAM;GACR,MAAM,cAAc,KAAK;GACzB,MAAM,OAAO,KAAK;GAClB,MAAM,mBAAmB,KAAK;GAC9B,MAAM,kBAAkB,KAAK;GAC7B,MAAM,IAAI,KAAK;EACjB;CACF,OAAO,IAAI,aAAA,cAAmC,iBAAiBC,2BAAAA,cAAc;EAC3E,MAAM,OAAO;EACb,IAAI,MAAM;GACR,MAAM,cAAc,KAAK;GACzB,MAAM,OAAO,KAAK;GAClB,MAAM,OAAO,KAAK;GAClB,MAAM,cAAc,KAAK;GACzB,MAAM,mBAAmB,KAAK;GAC9B,MAAM,kBAAkB,KAAK;GAC7B,MAAM,kBAAkB,KAAK;EAC/B;CACF;CAEA,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B,OAAO;CAGT,OAAQ,MAA2B,UAAU,KAAK;AACpD"}
+{"version":3,"file":"init.cjs","names":["getChatModelClass","isOpenAILike","ChatOpenAI","AzureChatOpenAI","ChatVertexAI"],"sources":["../../../src/llm/init.ts"],"mappings":";;;;;;;;AAiBA,SAAgB,gBAAgB,EAC9B,UACA,eACA,OACA,YAMW;CACX,MAAM,QACJ,YACA,KAAKA,kBAAAA,kBAAkB,QAAQ,GAAG,iBAAkB,CAAC,CAAW;CAElE,IACEC,YAAAA,aAAa,QAAQ,MACpB,iBAAiBC,gBAAAA,cAAc,iBAAiBC,gBAAAA,kBACjD;EACA,MAAM,OAAO;EACb,IAAI,MAAM;GACR,MAAM,cAAc,KAAK;GACzB,MAAM,OAAO,KAAK;GAClB,MAAM,mBAAmB,KAAK;GAC9B,MAAM,kBAAkB,KAAK;GAC7B,MAAM,IAAI,KAAK;EACjB;CACF,OAAO,IAAI,aAAA,cAAmC,iBAAiBC,2BAAAA,cAAc;EAC3E,MAAM,OAAO;EACb,IAAI,MAAM;GACR,MAAM,cAAc,KAAK;GACzB,MAAM,OAAO,KAAK;GAClB,MAAM,OAAO,KAAK;GAClB,MAAM,cAAc,KAAK;GACzB,MAAM,mBAAmB,KAAK;GAC9B,MAAM,kBAAkB,KAAK;GAC7B,MAAM,kBAAkB,KAAK;EAC/B;CACF;CAEA,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B,OAAO;CAGT,OAAQ,MAA2B,UAAU,KAAK;AACpD"}

package/dist/cjs/llm/invoke.cjs

@@ -21,7 +21,6 @@ let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_core_callbacks_manager = require("@langchain/core/callbacks/manager");
 let _langchain_core_utils_stream = require("@langchain/core/utils/stream");
 //#region src/llm/invoke.ts
-/** Unique per-model-attempt sequence; see the stamp in `attemptInvoke`. */
 let streamLimitAttemptSeq = 0;
 function usesNativeOpenAIResponses(model, provider, callOptions) {
 	if (!require_llm.isOpenAILike(provider)) return false;
@@ -54,11 +53,6 @@ function usesNativeOpenAIResponses(model, provider, callOptions) {
 	}
 	return false;
 }
-/**
-* Produces the exact provider-facing message representation before a model
-* adapter serializes it. This is shared by invocation and Graph's final budget
-* guard so structured tool output cannot grow after the payload was measured.
-*/
 function projectMessagesForProvider({ model, messages, provider, maxToolResultChars, callOptions }) {
 	const nativeOpenAIResponses = usesNativeOpenAIResponses(model, provider, callOptions);
 	const providerInputMessages = require_core.projectToolStreamContentForProvider(messages, nativeOpenAIResponses ? "native" : "fallback", maxToolResultChars);
@@ -69,16 +63,6 @@ function projectMessagesForProvider({ model, messages, provider, maxToolResultCh
 	if (provider === "bedrock") return require_cache.stripAnthropicCacheControl(require_core.projectComputerCallOutputsToText(require_core.projectCacheControlledToolOutputsToText(providerInputMessages, maxToolResultChars)));
 	return require_core.projectComputerCallOutputsToText(require_core.projectStructuredToolOutputsToText(require_core.projectSingleTextToolOutputsToText(require_cache.stripAnthropicCacheControl(require_cache.stripBedrockCacheControl(providerInputMessages)), maxToolResultChars), maxToolResultChars));
 }
-/**
-* The registered handler that owns content-part dispatch, if any.
-*
-* Detected by brand rather than by `instanceof`: a host that registers
-* `new ChatModelStreamHandler()` to opt out of sealing gets wrapped by
-* `createRunHandlers` on every `AgentSession` run, and by
-* `composeEventHandlers` on a key collision. Both wrappers forward to the same
-* dispatcher while failing an identity check, so an identity test would
-* silently revoke the opt-out documented on `StreamPreemption`.
-*/
 function getRegisteredDefaultChatStreamHandler(context) {
 	const handler = context?.handlerRegistry?.getHandler("on_chat_model_stream");
 	return require_stream.dispatchesChatModelStream(handler) ? handler : void 0;
@@ -117,10 +101,6 @@ function getStreamHandlingChunk({ current, next, provider }) {
 		additional_kwargs: removeReasoningDetails(next.additional_kwargs)
 	}));
 }
-/**
-* Best-effort output-token count for a sealed turn, used only when the
-* provider never got to send its usage chunk.
-*/
 function countSealedTokens(context, metadata, messages) {
 	try {
 		const counter = context?.getAgentContext(metadata).tokenCounter;
@@ -132,17 +112,6 @@ function countSealedTokens(context, metadata, messages) {
 		return;
 	}
 }
-/**
-* Instruction overhead the provider processed but that never appears in the
-* message array: `createCallModel` pipes the model through
-* `agentContext.systemRunnable` and binds tool schemas AFTER `messages` is
-* formed, so the system prompt, dynamic instructions, summary and tool
-* schemas are all billed yet invisible here.
-*
-* Read per-node via `getAgentContext(metadata)` rather than the graph-level
-* accessor, which is hardcoded to `defaultAgentId` and would report the wrong
-* agent's overhead in a `MultiAgentGraph`.
-*/
 function sealedInstructionOverhead(context, metadata) {
 	try {
 		const agentContext = context?.getAgentContext(metadata);
@@ -151,27 +120,6 @@ function sealedInstructionOverhead(context, metadata) {
 		return 0;
 	}
 }
-/**
-* Best-effort usage for a turn the provider never got to bill us for.
-*
-* The prompt matters as much as the completion: the provider processed the
-* ENTIRE prompt — messages plus instruction overhead — before we sealed, and
-* every resume re-sends it, so under-counting input hides the expensive half
-* of a preempted run.
-*
-* ESTIMATE, NOT MEASUREMENT. Messages are counted with the host's tokenizer
-* rather than the provider's, and `toolSchemaTokens` applies a heuristic
-* multiplier. It is also an over-count on the fallback path, where
-* `tryFallbackProviders` builds a bare model with no `systemRunnable` pipe so
-* the system prompt genuinely is not sent. Accepted rather than threaded
-* through a flag: only the fallback-plus-seal combination is affected, and an
-* over-count is safer than the previous fabricated `input_tokens: 0`.
-*
-* Marked `estimated_usage` so calibration can refuse to learn from it — a
-* ratio derived from the same counter that produced the estimate is
-* self-consistent by construction and would drag a provider's real
-* calibration toward 1.0.
-*/
 function synthesizeSealedUsage(context, chunk, prompt, metadata) {
 	if (chunk.usage_metadata != null) return;
 	const outputTokens = countSealedTokens(context, metadata, [chunk]);
@@ -200,37 +148,6 @@ function getMessageText(chunk) {
 	}
 	return text;
 }
-/**
-* Ends the real model run for a turn that was sealed mid-stream.
-*
-* Mandatory, not cosmetic. `@langchain/core`'s `_streamIterator` calls
-* `handleLLMEnd` after its try/catch with no `finally`, so breaking out of the
-* consumer's `for await` produces a *return* completion that fires neither
-* `handleLLMError` nor `handleLLMEnd`. The run would stay open in every
-* callback handler: the host records no usage — and since each seal re-sends
-* the whole prompt, N preemptions cost N unrecorded prompts — while LangSmith
-* and Langfuse hold a span that never closes.
-*
-* `runId` cannot be dictated from here (the bound runnable consumes
-* `config.runId` for its own run and hands the chat model a fresh one), but it
-* can be OBSERVED: the capture handler installed at the `model.stream` call
-* records it from `handleChatModelStart`, which fires before the first chunk.
-* Rebuilding the manager against that id closes the real run, and the host's
-* `on_chat_model_end` then arrives through the ordinary `streamEvents` path.
-*
-* Falls back to a custom-event dispatch if the id was never observed, so the
-* host still records usage even when the native close is unavailable.
-*/
-/**
-* Every callbacks source the real model run would compose beyond the per-call
-* config. `model` here is whatever `createCallModel` produced — with tools
-* that is `bindTools(...)`'s `RunnableBinding`, and a system runnable pipes a
-* `RunnableSequence` on top — while `clientOptions.callbacks` lives on the
-* chat model at the BOTTOM of that stack. Walks `bound` (bindings) and
-* `last`/`steps` (sequences), collecting each wrapper's own `callbacks` and
-* any binding-config callbacks along the way, since the binding merges its
-* config into the call before the chat model composes.
-*/
 function collectModelCallbackSources(model) {
 	const sources = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -244,12 +161,6 @@ function collectModelCallbackSources(model) {
 	}
 	return sources;
 }
-/**
-* The serving model's id, read through the same wrapper stack
-* `collectModelCallbackSources` walks — `bindTools` returns a
-* `RunnableBinding` and a system runnable pipes a `RunnableSequence`, and
-* neither exposes the chat model's `model` at the top level.
-*/
 function resolveServingModelId(model) {
 	const seen = /* @__PURE__ */ new Set();
 	let current = model;
@@ -265,17 +176,6 @@ async function endSealedModelRun(context, chunk, prompt, llmRunId, config, model
 	synthesizeSealedUsage(context, chunk, prompt, metadata);
 	if (llmRunId != null) try {
 		let callbackManager = await (0, _langchain_core_runnables.getCallbackManagerForConfig)(config);
-		/**
-		* The real model run composes the per-call config's callbacks WITH the
-		* model's own (`CallbackManager.configure(config.callbacks,
-		* this.callbacks, …)` in `@langchain/core`'s base chat model), so a
-		* handler supplied via `clientOptions.callbacks` received
-		* `handleChatModelStart` for this run. Rebuilding from the config alone
-		* would close the run for every handler EXCEPT those — leaving their
-		* span open forever. Composed the same way the real run composes:
-		* model callbacks appended non-inheritable, parent run id preserved by
-		* `copy`, tracers deduped by `configure`.
-		*/
 		for (const source of collectModelCallbackSources(model)) callbackManager = _langchain_core_callbacks_manager.CallbackManager.configure(callbackManager ?? void 0, source) ?? callbackManager;
 		if (callbackManager != null) {
 			const runManager = new _langchain_core_callbacks_manager.CallbackManagerForLLMRun(llmRunId, callbackManager.handlers, callbackManager.inheritableHandlers, callbackManager.tags, callbackManager.inheritableTags, callbackManager.metadata, callbackManager.inheritableMetadata, callbackManager.getParentRunId());
@@ -290,10 +190,6 @@ async function endSealedModelRun(context, chunk, prompt, llmRunId, config, model
 			return;
 		}
 	} catch (e) {
-		/**
-		* A sealed answer that reaches the user is worth more than a tidy
-		* trace. Fall through to the custom event rather than failing the run.
-		*/
 		console.warn("[attemptInvoke] Native close of the sealed model run failed; falling back to a custom event:", e instanceof Error ? e.message : e);
 	}
 	await require_events.safeDispatchCustomEvent("on_chat_model_end", { output: chunk }, config);
@@ -306,35 +202,16 @@ function appendStreamChunk({ current, next, provider }) {
 		provider
 	}));
 }
-/**
-* One model attempt. Stamps the attempt identity into callback metadata
-* (see the generation-key notes in `streamLimits.ts`), leases the attempt's
-* accounting for its LIFETIME, and releases both from `finally`: retention
-* must follow the attempt — a cancellation-ignoring straggler keeps its
-* original budget no matter how many runs start and reset while it drains.
-*/
 async function attemptInvoke(params, config) {
 	const stampedConfig = {
 		...config,
 		metadata: {
 			...config?.metadata ?? {},
 			["__invoked_provider"]: params.provider,
-			/**
-			* One `attemptInvoke` call is one model attempt; primary, fallback,
-			* and retry attempts within a node otherwise share the same langgraph
-			* metadata, so without a unique attempt stamp a fallback re-streaming
-			* a tool call from scratch would be charged the failed primary's
-			* partial bytes (or a same-named sibling fallback's) and could
-			* falsely trip the stream limits. The stamp rides the same metadata
-			* rebuild that already attributes the serving provider.
-			*/
 			[require_streamLimits.STREAM_LIMIT_ATTEMPT_KEY]: ++streamLimitAttemptSeq
 		}
 	};
 	const rawLeaseTarget = params.context ?? params.streamLimitState;
-	/** No lease when no guard can fire: the lease only protects accounting
-	* entries, and fully disabled guards must allocate no bookkeeping at
-	* all — per-attempt included. */
 	const leaseTarget = rawLeaseTarget != null && require_streamLimits.streamLimitAccountingEnabled(rawLeaseTarget) ? rawLeaseTarget : void 0;
 	const generationKey = leaseTarget != null ? require_streamLimits.resolveGenerationKey(stampedConfig.metadata) : void 0;
 	if (leaseTarget != null && generationKey != null) require_streamLimits.registerActiveStreamLimitGeneration(leaseTarget, generationKey);
@@ -345,13 +222,6 @@ async function attemptInvoke(params, config) {
 	}
 }
 async function attemptInvokeBody({ model, messages, provider, context, onChunk }, config) {
-	/**
-	* Pull the run-scoped tool output registry off the graph (when one
-	* exists) and project ToolMessages carrying ref metadata into a
-	* transient annotated copy. The original `messages` array stays
-	* untouched so the graph state never sees `[ref: …]` / `_ref`
-	* payload.
-	*/
 	const invocationMessages = projectMessagesForProvider({
 		model,
 		messages,
@@ -361,55 +231,10 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 	const registry = context?.getOrCreateToolOutputRegistry();
 	const runId = config.configurable?.run_id;
 	const annotated = require_toolOutputReferences.annotateMessagesForLLM(invocationMessages, registry, runId);
-	/**
-	* Keyed on the provider ACTUALLY serving this call, not the agent's primary.
-	* `createCallModel` normalizes for the primary, but `tryFallbackProviders`
-	* re-sends the same array — so an OpenAI primary that fails after a boundary
-	* injected two human turns would hand a Bedrock or Mistral fallback the
-	* consecutive user turns those APIs reject, and the recovery request would
-	* fail for a reason unrelated to the original failure.
-	*
-	* `attemptInvoke` is the single funnel for primary, fallback and
-	* summarization calls, so applying it here covers all three. Idempotent, so
-	* the primary simply re-runs a no-op over already-coalesced messages.
-	*/
-	/**
-	* Serving-provider re-keying for the predecessor handoff cue (#345). The
-	* PRIMARY's cue is baked in createCallModel's measured transform stage —
-	* appending after measurement could push a just-fits prompt over budget —
-	* so this funnel only corrects for fallbacks crossing provider families:
-	* a tolerant primary falling back to a Claude surface gains the cue here,
-	* and an Anthropic primary falling back to OpenAI/Mistral/Nova has the
-	* Claude-only synthetic turn stripped. Both helpers are identity on their
-	* no-op paths, so the primary's own pass re-runs for free.
-	*
-	* The serving model id is read through the wrapper stack (`bindTools`'
-	* binding, a system runnable's sequence) — a wrapper's top-level `.model`
-	* is undefined, and `isAnthropicLike` would otherwise default a wrapped
-	* Bedrock-Nova model to Claude. The context cast is widened deliberately:
-	* the type says every context is a full Graph, but summarization passes
-	* none and long-standing tests pass partial stubs.
-	*/
 	const isRunProduced = context?.isRunProducedMessage;
 	const cued = require_llm.isAnthropicLike(provider, { model: resolveServingModelId(model) }) ? require_handoffCue.appendPredecessorHandoffCue(annotated, isRunProduced == null ? void 0 : (message) => isRunProduced.call(context, message)) : require_handoffCue.removePredecessorHandoffCue(annotated);
 	const messagesForProvider = require_alternation.strictAlternationProviders.has(provider) ? require_alternation.coalesceAdjacentUserTurns(cued) : cued;
-	/**
-	* Stamp the provider that is ACTUALLY serving this invocation onto the
-	* callback metadata. `attemptInvoke` is the single funnel for primary,
-	* fallback, and summarization model calls, so consumers that need
-	* provider attribution per call (the subagent usage-capture handler)
-	* read this key instead of trusting static agent config — which is
-	* wrong for fallback-served calls — or `ls_provider` — which derived
-	* providers inherit from their base class.
-	*/
 	if (model.stream) {
-		/**
-		* Observed, not dictated. `handleChatModelStart` fires with the chat
-		* model's real run id before the first chunk, which is the only way to
-		* name the run a seal has to close — pinning `config.runId` does not
-		* survive the bound runnable. Installed only when preemption is
-		* configured, so a run that cannot seal carries no extra handler.
-		*/
 		let sealedRunId;
 		const streamConfig = context?.preemption == null ? config : {
 			...config,
@@ -421,11 +246,6 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 		let finalChunk;
 		let preempted = false;
 		const registeredStreamHandler = getRegisteredDefaultChatStreamHandler(context);
-		/** A sibling's trip aborts the composed signal, but an adapter that
-		* ignores cancellation keeps yielding — and text-only chunks with the
-		* event cap off never throw in enforcement, so nothing else would stop
-		* the drain. Checked on every yielded chunk in all three loops;
-		* throwing closes the iterator and tears down the provider stream. */
 		const throwIfBreakerTripped = () => {
 			const signal = config.signal;
 			if (signal?.aborted === true && signal.reason instanceof require_streamLimits.StreamLimitExceededError) throw signal.reason;
@@ -434,11 +254,6 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 			const attemptMetadata = config.metadata;
 			for await (const chunk of stream) {
 				throwIfBreakerTripped();
-				/** An onChunk consumer replaces the stream handler entirely, so
-				* stream limits are enforced here for every such caller — public
-				* package consumers get no other accounting. The internal
-				* summarization onChunk charges producer-side itself and passes no
-				* context, precisely so this claim and its own never stack. */
 				if (context != null) require_streamLimits.enforceStreamLimitsForWireChunk({
 					graph: context,
 					metadata: attemptMetadata,
@@ -462,18 +277,7 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 					provider
 				});
 				if (handlingChunk != null) await streamHandler.handle("on_chat_model_stream", { chunk: handlingChunk }, metadata, context);
-				else if (context != null)
- /**
-				* A replay-skipped chunk yields no handling chunk, and in this
-				* local branch no `streamEvents` consumer judges the wire event
-				* either — yet a cumulative OpenRouter replay can still carry
-				* `tool_call_chunks` or complete `tool_calls` that are appended
-				* below. Charge the full limits (event budget and argument bytes)
-				* directly so neither cap can be bypassed. Consumer side: the
-				* local handler.handle call above claims as consumer, and one
-				* reused chunk object can alternate between these two arms.
-				*/
-				require_streamLimits.enforceStreamLimitsForWireChunk({
+				else if (context != null) require_streamLimits.enforceStreamLimitsForWireChunk({
 					graph: context,
 					metadata,
 					chunk,
@@ -484,18 +288,6 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 					next: chunk,
 					provider
 				});
-				/**
-				* Only this loop may seal. The registered-handler branch below
-				* dispatches through `run.ts`'s decoupled `streamEvents` consumer,
-				* which can lag the accumulated chunk — sealing there would let the
-				* host index a content part the user has not been shown yet.
-				*/
-				/**
-				* Cheap poll first, shape check second, budget claim last. The claim
-				* is what makes this safe under a parallel `MultiAgentGraph`: several
-				* agents share one graph and can each see the poll as true, but only
-				* one can take the slot, and a chunk that cannot seal never spends it.
-				*/
 				if (context?.shouldPreemptStream() === true && require_preempt.canSealPreempt(finalChunk) && context.claimPreemptSeal()) {
 					preempted = true;
 					break;
@@ -503,23 +295,9 @@ async function attemptInvokeBody({ model, messages, provider, context, onChunk }
 			}
 		} else {
 			const metadata = config.metadata;
-			/**
-			* The original wire chunk still reaches the registered handler through
-			* `streamEvents` (where the late-reasoning skip discards it AFTER the
-			* event guard counts it), so this inline re-dispatch of the transformed
-			* chunk is marked to not consume a second event-budget slot. Allocated
-			* once per attempt, only when a transformation occurs.
-			*/
 			let redispatchMetadata;
 			for await (const chunk of stream) {
 				throwIfBreakerTripped();
-				/**
-				* Charged synchronously, ahead of the decoupled `streamEvents`
-				* reader that will echo this same chunk to the registered handler:
-				* a lagging reader would otherwise let an oversized complete call
-				* return to LangGraph and reach ToolNode before the queued handler
-				* throws. The chunk is marked so the echo skips accounting.
-				*/
 				if (context != null) require_streamLimits.enforceStreamLimitsForWireChunk({
 					graph: context,
 					metadata,
@@ -569,43 +347,22 @@ function attachFallbackErrorContext(error, fallbackContext) {
 	if (typeof error !== "object" || error === null) return;
 	fallbackErrorContexts.set(error, fallbackContext);
 }
-/** Reads back the fallback attribution attached by `tryFallbackProviders`. */
 function getFallbackErrorContext(error) {
 	if (typeof error !== "object" || error === null) return;
 	return fallbackErrorContexts.get(error);
 }
-/** Returns every fallback overflow retained from an exhausted provider chain. */
 function getFallbackOverflowCandidates(error) {
 	if (typeof error !== "object" || error === null) return [];
 	return [...fallbackOverflowCandidates.get(error) ?? []];
 }
-/**
-* Best-effort read of the configured model name from client options.
-* Providers disagree on the key (`model` vs `modelName`).
-*/
 function extractClientOptionsModel(clientOptions) {
 	const options = clientOptions;
 	if (typeof options?.model === "string" && options.model !== "") return options.model;
 	if (typeof options?.modelName === "string" && options.modelName !== "") return options.modelName;
 }
-/**
-* Attempts each fallback provider in order until one succeeds.
-*
-* When every fallback fails, a context overflow among them is thrown in
-* preference to whichever failure happened to come last. An overflow is the
-* one failure the caller can act on — it compacts and retries — and losing it
-* behind a later unrelated error would surface a dead end instead. Ordinary
-* failures still throw last-error-wins.
-*/
 async function tryFallbackProviders({ fallbacks, tools, messages, config, primaryError, context, onChunk, streamLimitState, overflowContext, prepareProviderMessages }) {
 	const isOverflow = (error, contextOverride = overflowContext) => require_errors.getContextOverflowInfo(error, contextOverride) != null;
 	let lastError = primaryError;
-	/**
-	* Tracked apart from the primary's overflow. A caller reaching this
-	* function with an overflowing primary has already failed to recover from
-	* it, so a fallback overflow — which may sit against a different window and
-	* output allowance — is the more useful of the two to surface.
-	*/
 	const overflowCandidates = [];
 	const primaryOverflowError = isOverflow(primaryError) ? primaryError : void 0;
 	for (const fb of fallbacks) try {
@@ -614,13 +371,6 @@ async function tryFallbackProviders({ fallbacks, tools, messages, config, primar
 			clientOptions: fb.clientOptions,
 			tools
 		});
-		/**
-		* Stamp the fallback's configured model onto callback metadata so
-		* per-call attribution (subagent usage capture) doesn't fall back to
-		* the PRIMARY config's model when the provider reports no
-		* `ls_model_name`. The serving provider is stamped uniformly by
-		* `attemptInvoke` (`INVOKED_PROVIDER`).
-		*/
 		const fbModelName = extractClientOptionsModel(fb.clientOptions);
 		const fbConfig = fbModelName == null ? config : {
 			...config,
@@ -637,10 +387,6 @@ async function tryFallbackProviders({ fallbacks, tools, messages, config, primar
 			maxContextTokens: fb.maxContextTokens,
 			config: fbConfig
 		}) ?? messages;
-		/** A sibling can trip the breaker while the preparation above is
-		* awaited — and the catch below only sees attempts that THROW, so a
-		* provider that ignores an aborted signal and succeeds would resolve
-		* a run that must reject. Check before every fallback invocation. */
 		if (config?.signal?.aborted === true && config.signal.reason instanceof require_streamLimits.StreamLimitExceededError) throw config.signal.reason;
 		return await attemptInvoke({
 			model: fbModel,
@@ -651,16 +397,7 @@ async function tryFallbackProviders({ fallbacks, tools, messages, config, primar
 			streamLimitState
 		}, fbConfig);
 	} catch (e) {
-		/**
-		* A tripped stream circuit breaker is a deliberate abort, not a
-		* provider failure. Continuing would try the remaining fallbacks and a
-		* succeeding one would resolve a run that must reject.
-		*/
 		if (e instanceof require_streamLimits.StreamLimitExceededError) throw e;
-		/** A parallel sibling's trip aborts this branch's composed signal, and
-		* a provider can surface that as a generic abort error; advancing to
-		* the next fallback would start new provider work after the safety
-		* abort. Rethrow the breaker's own reason instead. */
 		if (config?.signal?.aborted === true && config.signal.reason instanceof require_streamLimits.StreamLimitExceededError) throw config.signal.reason;
 		lastError = e;
 		if (isOverflow(e, {
@@ -681,12 +418,6 @@ async function tryFallbackProviders({ fallbacks, tools, messages, config, primar
 		}
 		continue;
 	}
-	/**
-	* Preference order: a fallback overflow, then the primary's overflow, then
-	* whichever failure came last. An overflow is the only one of the three a
-	* caller can act on, and the fallback's carries the client attribution that
-	* makes a correct retry budget possible.
-	*/
 	const preferred = overflowCandidates[0]?.error ?? primaryOverflowError ?? lastError;
 	if (overflowCandidates.length > 0 && typeof preferred === "object" && preferred !== null) fallbackOverflowCandidates.set(preferred, overflowCandidates);
 	if (preferred !== void 0) throw preferred;