@librechat/agents 3.4.7 → 3.5.1

package/dist/cjs/graphs/Graph.cjs

@@ -74,7 +74,6 @@ const EMPTY_PREEMPT_BOUNDARY = {
 	messages: [],
 	preventContinuation: false
 };
-/** Minimum relative variance before calibrated toolSchemaTokens overrides current value. */
 const CALIBRATION_VARIANCE_THRESHOLD = .15;
 function createChildHandlerRegistry(source) {
 	const toolHandler = source?.getHandler("on_tool_execute");
@@ -173,21 +172,10 @@ function clearCurrentDeltaStepMarkers({ graph, metadata }) {
 		graph.reasoningStepHasDeltas.delete(stepId);
 	}
 }
-/**
-* The completion allowance the caller configured, under whichever key the
-* provider's client uses. Providers count it against the same ceiling as the
-* prompt, so overflow recovery has to reserve it when the error did not
-* itemize the total.
-*/
 function getConfiguredCompletionTokens(clientOptions) {
 	const options = clientOptions;
 	for (const value of [options?.maxTokens, options?.maxOutputTokens]) if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
 }
-/**
-* Our own estimate of the prompt that was actually sent, derived from the
-* pre-invoke usage snapshot. Used to corroborate ambiguous provider errors
-* and to measure how far our token accounting sits from the provider's.
-*/
 function getEstimatedPromptTokens(contextUsage) {
 	const budget = contextUsage?.contextBudget;
 	const remaining = contextUsage?.remainingContextTokens;
@@ -281,7 +269,6 @@ function getDispatchableFinalReasoningContent({ agentContext, responseReasoningC
 }
 var Graph = class {
 	restoreCheckpointMessages(_messages, _pendingMessages) {}
-	/** Returns a snapshot of deferred tools discovered by this graph. */
 	getDiscoveredTools(_agentId) {
 		return [];
 	}
@@ -294,122 +281,33 @@ var Graph = class {
 	stepKeyIds = /* @__PURE__ */ new Map();
 	contentIndexMap = /* @__PURE__ */ new Map();
 	toolCallStepIds = /* @__PURE__ */ new Map();
-	/** Step ID -> tool call IDs whose completions have not yet arrived. */
 	pendingToolCallsByStep = /* @__PURE__ */ new Map();
-	/**
-	* Step ID -> latest producer completion time seen for that step. Parallel
-	* calls sharing a step can settle out of producer order when their host
-	* handlers differ in latency, so the call that happens to drain the set is
-	* not necessarily the one that finished last.
-	*/
 	latestCompletionByStep = /* @__PURE__ */ new Map();
-	/** Agent key ('' for single-agent) -> currently open MESSAGE_CREATION step ID. */
 	openMessageStepByAgent = /* @__PURE__ */ new Map();
-	/**
-	* Step IDs dispatched through the handler registry during this run.
-	* Event echo suppression is tracked separately so repeated deltas for
-	* the same step are scoped to the active custom event dispatch.
-	*/
 	handlerDispatchedStepIds = /* @__PURE__ */ new Set();
 	reasoningStepHasDeltas = /* @__PURE__ */ new Set();
 	handlerDispatchedEventCounts = /* @__PURE__ */ new Map();
 	signal;
-	/**
-	* The abort signal the CALLER handed to the current `processStream` call,
-	* assigned unconditionally — including back to `undefined` — on every call.
-	*
-	* Kept separate from {@link signal} on purpose. That field is construction
-	* state with its own consumers (model-call config, subagent parentSignal),
-	* so adopting a per-call signal into it would leak one call's controller
-	* into the next — `clearHeavyState()` is skipped on HITL interrupts, so a
-	* host that aborts a finished request's controller would poison the resumed
-	* run's model calls and boundary drains with an already-aborted signal.
-	* Boundary dispatch composes the two instead; see
-	* `StandardGraph.dispatchPreemptBoundary`.
-	*/
 	callerSignal;
-	/** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
 	invokedToolIds;
 	handlerRegistry;
-	/** Host registry retained only for forwarding tools from nested child graphs. */
 	parentToolHandlerRegistry;
-	/**
-	* True when event-driven tool execution can be routed through callbacks even
-	* though this graph intentionally does not own the full handler registry.
-	* Self-spawned subagent graphs use this shape: their callback forwarder sends
-	* `ON_TOOL_EXECUTE` to the parent's handler, while child run-step events stay
-	* wrapped as `ON_SUBAGENT_UPDATE` instead of leaking as parent events.
-	*/
 	eventToolExecutionAvailable = false;
 	hookRegistry;
-	/**
-	* Run-scoped HITL configuration. When `humanInTheLoop?.enabled` is
-	* `true`, `ToolNode` raises a real `interrupt()` for `PreToolUse`
-	* `ask` decisions instead of treating them as a synchronous deny.
-	* Threaded from `RunConfig.humanInTheLoop`.
-	*/
 	humanInTheLoop;
-	/**
-	* Run-scoped config for the tool output reference registry. Threaded
-	* from `RunConfig.toolOutputReferences` down into every ToolNode this
-	* graph compiles.
-	*/
 	toolOutputReferences;
-	/**
-	* Run-scoped Langfuse defaults. Per-agent config wins when present.
-	*/
 	langfuse;
-	/**
-	* Run-scoped opt-in for eager event-driven tool execution. The stream
-	* handler may prestart eligible event-driven tools; ToolNode later
-	* consumes the settled promises while preserving final ToolMessage order.
-	*/
 	eagerEventToolExecution;
 	codeSessionToolNames;
-	/**
-	* Run-scoped names of tools whose in-process body may raise a LangGraph
-	* `interrupt()` (e.g. `ask_user_question`). Threaded from
-	* `RunConfig.interruptingToolNames` into every ToolNode this graph
-	* compiles so a mid-batch interrupt cannot double-execute non-idempotent
-	* siblings on resume. See {@link t.ToolNodeOptions.interruptingToolNames}.
-	*/
 	interruptingToolNames;
 	eagerEventToolExecutions = /* @__PURE__ */ new Map();
 	eagerEventToolUsageCount = /* @__PURE__ */ new Map();
 	eagerEventToolUsageCountsByAgentId = /* @__PURE__ */ new Map();
 	eagerEventToolCallChunks = /* @__PURE__ */ new Map();
-	/**
-	* Per-run eager prestart circuit breaker, shared by reference with every
-	* ToolNode this graph compiles. When a prestarted execution's args turn
-	* out to differ from the final request, ToolNode records the tool name
-	* here and the stream handler stops prestarting that tool for the rest of
-	* the run — the retry then executes normally instead of re-diverging in a
-	* loop (LibreChat#14371).
-	*/
 	eagerEventToolSuppressions = /* @__PURE__ */ new Set();
-	/**
-	* Run-scoped execution backend for built-in code tools. Defaults to the
-	* remote Code API sandbox when unset.
-	*/
 	toolExecution;
-	/**
-	* Shared registry instance used by every ToolNode compiled from this
-	* graph. Lazily constructed on first access so multi-agent graphs
-	* produce one registry per run (not one per agent), letting cross-
-	* agent `{{tool<i>turn<n>}}` substitutions resolve.
-	*/
 	_toolOutputRegistry;
-	/**
-	* Tool session contexts for automatic state persistence across tool invocations.
-	* Keyed by tool name (e.g., Constants.EXECUTE_CODE).
-	* Currently supports code execution session tracking (session_id, files).
-	*/
 	sessions = /* @__PURE__ */ new Map();
-	/**
-	* Clears heavy references to allow GC to reclaim memory held by
-	* LangGraph's internal config / AsyncLocalStorage RunTree chain.
-	* Call after a run completes and content has been extracted.
-	*/
 	clearHeavyState() {
 		this.config = void 0;
 		this.signal = void 0;
@@ -441,14 +339,6 @@ var Graph = class {
 		this.eagerEventToolSuppressions.clear();
 		this.toolExecution = void 0;
 		this.handlerDispatchedEventCounts.clear();
-		/**
-		* ToolNodes compiled from this graph captured the registry
-		* instance at construction time, so simply dropping the Graph's
-		* own reference would leave their captured reference — and every
-		* stored `tool<i>turn<n>` entry, plus up to `maxTotalSize` of raw
-		* output — alive across subsequent `processStream()` calls. Wipe
-		* the registry's contents first so subsequent runs start fresh.
-		*/
 		this._toolOutputRegistry?.clear();
 		this._toolOutputRegistry = void 0;
 		for (const node of this._compiledToolNodes) node.clearDirectPathTurns();
@@ -468,18 +358,10 @@ var Graph = class {
 		this.eagerEventToolUsageCount.clear();
 		for (const usageCount of this.eagerEventToolUsageCountsByAgentId.values()) usageCount.clear();
 	}
-	/**
-	* Tracks a tool call whose completion must arrive before its step can be
-	* considered finished. Registered wherever `toolCallStepIds` gains entries,
-	* except cross-process subagent resume restoration, where pending state
-	* cannot be faithfully rebuilt and closes fall back to completions/sweep.
-	*/
 	registerPendingToolCall(toolCallId, stepId) {
 		if (!toolCallId || !stepId) return;
 		this.getPendingToolCallSet(stepId).add(toolCallId);
 	}
-	/** Lazily creates a step's pending-completions set; callers registering a
-	*  batch hoist this lookup out of their per-call loop. */
 	getPendingToolCallSet(stepId) {
 		let pending = this.pendingToolCallsByStep.get(stepId);
 		if (!pending) {
@@ -504,12 +386,6 @@ var Graph = class {
 		const key = getHandlerDispatchedEventKey(eventName, stepId);
 		return (this.handlerDispatchedEventCounts.get(key) ?? 0) > 0;
 	}
-	/**
-	* Subclass hook to register a freshly compiled ToolNode so
-	* `clearHeavyState` can flush its per-Run direct-path turn cache
-	* at end-of-Run. Internal — called from `initializeTools` in the
-	* concrete graph subclasses.
-	*/
 	registerCompiledToolNode(node) {
 		this._compiledToolNodes.add(node);
 	}
@@ -580,19 +456,6 @@ var Graph = class {
 		for (const toolName of state.eagerToolSuppressions) this.eagerEventToolSuppressions.add(toolName);
 		if (state.toolOutputReferences != null && registry != null) registry.restoreState(runId, state.toolOutputReferences);
 	}
-	/**
-	* Returns the shared `ToolOutputReferenceRegistry` for this run,
-	* constructing it on first access. Returns `undefined` when the
-	* feature is disabled. All ToolNodes compiled from this graph share
-	* this single instance so cross-agent `{{…}}` references resolve.
-	*
-	* @internal Public so `attemptInvoke` can read it through the typed
-	* `InvokeContext` and project ToolMessages into LLM-facing annotated
-	* copies right before each provider call (see
-	* `annotateMessagesForLLM`). Host code should not call this directly
-	* — registry mutations outside the ToolNode lifecycle break the
-	* partitioning, eviction, and turn-counter invariants.
-	*/
 	getOrCreateToolOutputRegistry() {
 		if (this.toolOutputReferences?.enabled !== true) return;
 		if (this._toolOutputRegistry == null) this._toolOutputRegistry = new require_toolOutputReferences.ToolOutputReferenceRegistry({
@@ -601,25 +464,7 @@ var Graph = class {
 		});
 		return this._toolOutputRegistry;
 	}
-	/**
-	* Single per-Run file checkpointer shared across every ToolNode the
-	* graph compiles. Lazily constructed when
-	* `toolExecution.local.fileCheckpointing === true` or
-	* `toolExecution.cloudflare.fileCheckpointing === true` so
-	* multi-agent graphs see ONE snapshot store, not one-per-agent.
-	* Returns undefined when checkpointing is disabled or a supported
-	* coding-tool engine isn't selected. Exposed via
-	* `Run.getFileCheckpointer()` / `Run.rewindFiles()`.
-	*/
 	_fileCheckpointer;
-	/**
-	* ToolNodes compiled into this Graph's workflow. Tracked so
-	* `clearHeavyState()` can flush their per-Run direct-path turn
-	* cache (`directPathTurns`) at end-of-Run — that map intentionally
-	* survives `run()` re-entry (resume-stable per Codex P2 #30) but
-	* would otherwise grow linearly with tool calls and could collide
-	* across Runs if a provider reuses call ids (Codex P2 #33).
-	*/
 	_compiledToolNodes = /* @__PURE__ */ new Set();
 	_subagentExecutors = /* @__PURE__ */ new Set();
 	getOrCreateFileCheckpointer() {
@@ -641,158 +486,45 @@ var StandardGraph = class StandardGraph extends Graph {
 	subagentModelOverride;
 	graphFactory;
 	supportsMultiAgentChildren;
-	/** Optional compile options passed into workflow.compile() */
 	compileOptions;
-	/** Whether the workflow was actually compiled with a checkpointer. */
 	hasCompiledCheckpointer = false;
 	messages = [];
-	/** Whether a rebuilt resume seeded the message baseline from its checkpoint. */
 	hasRestoredCheckpointMessages = false;
-	/** Cached run messages preserved before clearHeavyState() so getRunMessages() works after cleanup. */
 	cachedRunMessages;
-	/** Per-agent discovery snapshots preserved before contexts are reset on cleanup. */
 	cachedDiscoveredTools;
-	/** Ids of AI turns the agent node returned THIS run; see isRunProducedMessage. */
 	runProducedAiMessageIds = /* @__PURE__ */ new Set();
-	/** Checkpoint scope whose messages match index-keyed tool snapshots. */
 	originalToolContentCheckpointScope;
 	runId;
-	/**
-	* Identity used to stamp Langfuse runtime scopes and handlers (see
-	* `LangfuseRuntimeContext.runId`). Carries an opaque per-instance
-	* component: public run ids are unrestricted and may repeat across
-	* concurrently executing runs (retries, duplicate submissions,
-	* tenant-local message ids), and equal stamps would let those runs adopt
-	* each other's scopes. One graph instance = one execution's stamp, shared
-	* by the stream handler and every graph-level scope of that execution.
-	*/
 	langfuseScopeRunId;
-	/**
-	* Boundary between historical messages (loaded from conversation state)
-	* and messages produced during the current run.  Set once in the state
-	* reducer when messages first arrive.  Used by `getRunMessages()` and
-	* multi-agent message filtering — NOT for pruner token counting (the
-	* pruner maintains its own `lastTurnStartIndex` in its closure).
-	*/
 	startIndex = 0;
 	signal;
-	/** Map of agent contexts by agent ID */
 	agentContexts = /* @__PURE__ */ new Map();
-	/** Default agent ID to use */
 	defaultAgentId;
-	/**
-	* Host sink for model usage emitted inside subagent child runs. Threaded
-	* into each `SubagentExecutor` this graph creates (and from there into
-	* child graphs, so nested subagents report too). See
-	* {@link t.StandardGraphInput.subagentUsageSink}.
-	*/
 	subagentUsageSink;
-	/** See {@link t.StandardGraphInput.subagentScope}. */
 	subagentScope;
-	/** See {@link t.StandardGraphInput.subagentExecutionContext}. */
 	subagentExecutionContext;
-	/** See {@link t.StandardGraphInput.preemption}. */
 	preemption;
-	/**
-	* Stream circuit breakers, resolved once from
-	* {@link t.StandardGraphInput.streamLimits}. The stream handler enforces
-	* these on every streamed chunk event.
-	*/
 	streamLimits;
-	/**
-	* Cumulative streamed argument bytes per in-flight tool call, keyed by
-	* generation key + chunk index (see `resolveGenerationKey`). Per-run
-	* accumulation state, cleared by both reset paths.
-	*/
 	streamedToolCallArgTallies = /* @__PURE__ */ new Map();
-	/** Streamed chunk events per model generation, keyed by generation key. */
 	streamDeltaEventCounts = /* @__PURE__ */ new Map();
-	/** Per-chunk-object, per-generation charge balances (lazily created; see
-	* `StreamLimitState`). Reinitialized by both reset paths: a model may
-	* retain and re-yield one mutable chunk object, whose nested map would
-	* otherwise grow by one attempt-stamped entry per model call for the
-	* graph's lifetime. */
 	streamLimitChargeCredits;
-	/** Run-scoped breaker abort: composed into every model invocation and
-	* every SubagentExecutor child signal, and tripped when a stream circuit
-	* breaker fires anywhere in the run, so parallel agent nodes' in-flight
-	* provider calls and subagents stop consuming quota while the rejection
-	* propagates. Recreated by both reset paths — the abort is one-way within
-	* a run, and a reused graph must start its next run unaborted. */
 	breakerAbort = new AbortController();
-	/** Incremented whenever `breakerAbort` is replaced. Stamped into each
-	* model attempt's metadata ({@link STREAM_LIMIT_EPOCH_KEY}) so the stream
-	* handler's consumer-side trip binds to the run that produced the event
-	* rather than whichever controller is live when a straggling chunk is
-	* finally handled. */
 	breakerEpoch = 0;
-	/** Immutable snapshot of the run's breaker identity (epoch + controller),
-	* replaced as ONE object whenever `resetValues` installs a fresh
-	* controller. Sites that pause across awaits capture it at entry and
-	* revalidate by REFERENCE afterwards — a single identity comparison
-	* proves no reset happened while suspended, where separate epoch and
-	* controller reads could interleave with one. */
 	runScope = Object.freeze({
 		epoch: 0,
 		controller: this.breakerAbort
 	});
-	/** Generation keys of model attempts still in flight (see
-	* `StreamLimitState.activeStreamLimitGenerations`). Lazily created by the
-	* attempt lease; spans resets on purpose. */
 	activeStreamLimitGenerations;
-	/** The stream-limit error behind an already-fired breaker, whether this
-	* graph's own controller tripped or a parent run's breaker arrived through
-	* the composed constructor signal (child graphs own separate controllers).
-	* Providers can translate either abort into a generic error, and recovery
-	* paths must not run in that state. */
 	resolveTrippedBreakerReason(breakerSignal = this.breakerAbort.signal) {
 		if (breakerSignal.aborted && breakerSignal.reason instanceof require_streamLimits.StreamLimitExceededError) return breakerSignal.reason;
 		if (this.signal?.aborted === true && this.signal.reason instanceof require_streamLimits.StreamLimitExceededError) return this.signal.reason;
 	}
-	/**
-	* Seals charged against `preemption.maxSeals`. Per-turn: cleared by both
-	* reset paths so a fresh turn gets a fresh budget, while a HITL resume —
-	* which skips `resetValues` — keeps what it had left.
-	*/
 	preemptSealBudgetUsed = 0;
-	/**
-	* Seals honored over the graph's lifetime. Reported by
-	* {@link getPreemptStats}, so it deliberately SURVIVES `clearHeavyState()`
-	* — a host reads it after `processStream` returns, which is strictly after
-	* cleanup runs.
-	*/
 	preemptSealCount = 0;
-	/** Boundaries that produced nothing to inject, so the turn stopped early. */
 	preemptEmptyBoundaries = 0;
-	/**
-	* Set between claiming a seal and resolving its boundary. `MultiAgentGraph`
-	* fans parallel agents through this one instance against a single host
-	* request, so without a one-at-a-time gate several streams would each seal
-	* for the same queued message and every loser would take the
-	* nothing-to-inject path and cut its answer short.
-	*/
 	preemptSealInFlight = false;
-	/**
-	* True when a seal ended the turn without a resume. The assistant turn is
-	* real and kept, but it is not the answer the model intended to finish —
-	* hosts persist it as unfinished rather than complete.
-	*/
 	preemptIncomplete = false;
-	/**
-	* `stopReason` from a `PreemptBoundary` hook that halted the turn.
-	*
-	* Clearing the registry halt is what keeps the sealed turn alive, but the
-	* registry held the only copy of the reason — so it is captured here first.
-	* Without it `getHaltReason()` returns undefined and a host records a
-	* hook-halted turn as an ordinary completion.
-	*/
 	preemptHaltReason;
-	/**
-	* Agent IDs whose next superstep must return to the agent node. Keyed by
-	* agent because `MultiAgentGraph` routes every parallel agent through this
-	* same instance, and a single field would let one agent's boundary resume
-	* another's turn.
-	*/
 	pendingPreemptReturn = /* @__PURE__ */ new Set();
 	constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, subagentUsageSink, subagentScope, subagentExecutionContext, preemption, streamLimits }, dependencies) {
 		super();
@@ -830,12 +562,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			this.contentIndexMap = require_graph.resetIfNotEmpty(this.contentIndexMap, /* @__PURE__ */ new Map());
 		}
 		this.stepKeyIds = require_graph.resetIfNotEmpty(this.stepKeyIds, /* @__PURE__ */ new Map());
-		/**
-		* Clear in-place instead of replacing with a new Map to preserve the
-		* shared reference held by ToolNode (passed at construction time).
-		* Using resetIfNotEmpty would create a new Map, leaving ToolNode with
-		* a stale reference on 2nd+ processStream calls.
-		*/
 		this.toolCallStepIds.clear();
 		this.pendingToolCallsByStep.clear();
 		this.latestCompletionByStep.clear();
@@ -845,22 +571,9 @@ var StandardGraph = class StandardGraph extends Graph {
 		this.clearEagerEventToolUsageCounts();
 		this.eagerEventToolCallChunks.clear();
 		this.eagerEventToolSuppressions.clear();
-		/** Grace sweep instead of a clear: producer loops of straggling
-		* attempts use these maps directly and sit outside the consumer-only
-		* epoch gate — clearing would hand a cancellation-ignoring provider a
-		* fresh allowance at every run start. Entries from the epoch that is
-		* ending survive exactly one reset so those stragglers stay on their
-		* original budgets; older entries are removed. */
 		require_streamLimits.sweepStaleStreamLimitEntries(this.streamedToolCallArgTallies, this.breakerEpoch, this.activeStreamLimitGenerations);
 		require_streamLimits.sweepStaleStreamLimitEntries(this.streamDeltaEventCounts, this.breakerEpoch, this.activeStreamLimitGenerations);
 		this.streamLimitChargeCredits = void 0;
-		/** Run-start is the only safe replacement point for the breaker:
-		* end-of-run cleanup must leave it in place so straggling parallel
-		* children from the failed run cannot start on a fresh signal.
-		* Replaced UNCONDITIONALLY here — a run that failed on an ordinary
-		* error leaves the controller un-aborted, and stragglers still settling
-		* hold their entry-time capture of it; a late stream-limit trip on that
-		* old controller must not cancel the run starting now. */
 		this.breakerAbort = new AbortController();
 		this.breakerEpoch += 1;
 		this.runScope = Object.freeze({
@@ -882,7 +595,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		for (const context of this.agentContexts.values()) context.reset({ preserveOriginalToolContent });
 		this.originalToolContentCheckpointScope = hasScopedCheckpoint ? checkpointScope : void 0;
 	}
-	/** Seeds the sidecar message view that checkpoint restoration bypasses. */
 	restoreCheckpointMessages(messages, pendingMessages) {
 		if (this.messages.length > 0) return;
 		this.messages = pendingMessages == null ? [...messages] : require_reducer.messagesStateReducer(messages, pendingMessages);
@@ -897,96 +609,28 @@ var StandardGraph = class StandardGraph extends Graph {
 		this.messages = [];
 		this.overrideModel = void 0;
 		this.subagentModelOverride = void 0;
-		/** Stream-limit accounting (argument tallies, event counts, charge
-		* credits) deliberately SURVIVES cleanup: this runs in `processStream`'s
-		* finally, which an ordinary parallel-branch failure reaches while
-		* sibling attempts are still unwinding on the retained breaker — a
-		* cancellation-ignoring provider's late chunks would otherwise recreate
-		* their budgets from zero and stream another full allowance. The maps
-		* are bounded by in-flight call sizes and `resetValues` clears them at
-		* the next run start, where the epoch bump already drops stamped
-		* straggler events before accounting. */
-		/** Deliberately NOT recreating a tripped breakerAbort here: this runs in
-		* `processStream`'s cleanup, which a rejected parallel batch reaches
-		* while sibling subagents can still be pre-invoke — a fresh controller
-		* would hand them an un-aborted signal and let provider requests start
-		* after the run already failed. `resetValues` recreates it when the next
-		* run begins. */
-		/**
-		* Turn state only. The reported totals must outlive cleanup — this runs
-		* in `processStream`'s `finally`, and the host reads `getPreemptStats()`
-		* after that returns.
-		*/
 		this.resetPreemptTurnState();
 		const preserveOriginalToolContent = this.hasCompiledCheckpointer && this.originalToolContentCheckpointScope != null;
 		for (const context of this.agentContexts.values()) context.reset({ preserveOriginalToolContent });
 	}
-	/**
-	* Per-turn seal budget and routing markers. Cleared by both reset paths so
-	* a new turn starts with a full budget and no stale resume marker.
-	*
-	* The REPORTED counters are deliberately not touched here — see
-	* {@link resetPreemptTotals}.
-	*/
 	resetPreemptTurnState() {
 		this.preemptSealBudgetUsed = 0;
 		this.preemptSealInFlight = false;
 		this.pendingPreemptReturn.clear();
 	}
-	/**
-	* Lifetime seal totals, cleared only when a genuinely new run starts.
-	* `clearHeavyState()` must NOT call this: it runs in `processStream`'s
-	* `finally`, so zeroing here would make {@link getPreemptStats} and
-	* `preemptIncomplete` unreadable for every caller of the method that just
-	* produced them.
-	*/
 	resetPreemptTotals() {
 		this.preemptSealCount = 0;
 		this.preemptEmptyBoundaries = 0;
 		this.preemptIncomplete = false;
 		this.preemptHaltReason = void 0;
 	}
-	/**
-	* True when the host has requested a cooperative seal AND this graph may
-	* honor it. Read once per streamed chunk, so it stays property reads plus
-	* one host callback — no I/O, no allocation.
-	*
-	* Non-mutating: a true result only means a seal is worth evaluating. The
-	* budget is taken by {@link claimPreemptSeal} once the accumulated chunk is
-	* known to be safe, so a chunk that cannot seal never spends budget.
-	*
-	* Subagent scopes never seal: a steer targets the top-level conversation,
-	* and a child run must finish so its parent sees a complete result.
-	*/
-	/** Internal seal preconditions only — no host callback, no side effects. */
 	canClaimPreemptSeal() {
-		/**
-		* Resolved and required here with the same rule `dispatchPreemptBoundary`
-		* uses. Without it a direct `StandardGraph` consumer that supplies no
-		* `runId` could claim a seal on the strength of a global matcher, then hit
-		* the boundary's own null-runId guard and get nothing back — truncating
-		* the answer for a drain that provably could not run.
-		*/
 		const runId = this.config?.configurable?.run_id ?? this.runId;
 		return !this.subagentScope && this.preemption != null && !this.preemptSealInFlight && this.preemptSealBudgetUsed < require_preempt.resolveMaxSeals(this.preemption.maxSeals) && runId != null && this.hookRegistry?.hasDispatchableHookFor("PreemptBoundary", runId) === true;
 	}
 	shouldPreemptStream() {
 		return this.canClaimPreemptSeal() && this.preemption?.shouldPreempt() === true;
 	}
-	/**
-	* Takes the seal slot, or returns false if another stream already holds it.
-	*
-	* Assumes the caller already polled `shouldPreemptStream()` for THIS chunk,
-	* and deliberately does not poll the host again — `StreamPreemption`
-	* documents `shouldPreempt` as once per chunk, and a host that consumes a
-	* pending flag on read would lose the request to a second call.
-	*
-	* The guard and both mutations remain one synchronous body, which is what
-	* makes this safe under a parallel `MultiAgentGraph`: several agents share
-	* one graph and can each see the poll as true, but no `await` can split the
-	* claim, so only one takes the slot. The loser keeps streaming normally
-	* rather than sealing for a message it would never receive.
-	*/
 	claimPreemptSeal() {
 		if (!this.canClaimPreemptSeal()) return false;
 		this.preemptSealInFlight = true;
@@ -994,7 +638,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		this.preemptSealCount += 1;
 		return true;
 	}
-	/** Releases the seal slot once its boundary has resolved, win or lose. */
 	releasePreemptSeal() {
 		this.preemptSealInFlight = false;
 	}
@@ -1008,13 +651,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		const index = this.contentIndexMap.get(stepId);
 		if (index !== void 0) return this.contentData[index];
 	}
-	/**
-	* Derives the same lane key `dispatchRunStep` stamps as `runStep.agentId`.
-	* The multi-agent check gates the lookup because `getAgentContext` signals
-	* a miss by throwing: single-agent graphs key every step under `''`, so
-	* resolving the context could only ever produce a thrown-and-discarded
-	* Error on a per-model-call path.
-	*/
 	getStepAgentKey(metadata) {
 		if (!metadata || !this.isMultiAgentGraph()) return "";
 		try {
@@ -1023,72 +659,25 @@ var StandardGraph = class StandardGraph extends Graph {
 		} catch (_e) {}
 		return "";
 	}
-	/**
-	* O(1) reverse lookup: both dispatch funnels key the open-message map by
-	* `runStep.agentId ?? ''`, so the entry is addressable without scanning.
-	*/
 	untrackRunStep(runStep) {
 		this.pendingToolCallsByStep.delete(runStep.id);
 		this.latestCompletionByStep.delete(runStep.id);
 		const agentKey = runStep.agentId ?? "";
 		if (this.openMessageStepByAgent.get(agentKey) === runStep.id) this.openMessageStepByAgent.delete(agentKey);
 	}
-	/**
-	* Shared step accounting for both dispatch funnels: a successor step in
-	* the same agent lane marks the previous message step as finished — its
-	* CLOSED event must precede the successor's ON_RUN_STEP so hosts observe
-	* a consistent open-step timeline — then the step is registered in the
-	* content maps and tracked as the lane's open message step when
-	* applicable.
-	*/
 	async trackDispatchedRunStep(runStep, metadata, trackAsOpenMessageStep = true) {
 		const agentKey = runStep.agentId ?? "";
 		const openMessageStepId = this.openMessageStepByAgent.get(agentKey);
-		/**
-		* Reserve the content index and register the step SYNCHRONOUSLY, before
-		* awaiting the predecessor's closure. Parallel agent lanes dispatch
-		* successors concurrently: if both yielded here first, they would push
-		* with the same `contentData.length` and `contentIndexMap` would resolve
-		* one step id to the other lane's entry, so later deltas and completions
-		* would mutate the wrong agent's step. Assigning the index at push time
-		* also supersedes whatever the caller computed before this await point.
-		*/
 		runStep.index = this.contentData.length;
 		this.contentData.push(runStep);
 		this.contentIndexMap.set(runStep.id, runStep.index);
 		if (trackAsOpenMessageStep && runStep.type === "message_creation") this.openMessageStepByAgent.set(agentKey, runStep.id);
 		else this.openMessageStepByAgent.delete(agentKey);
-		/**
-		* Awaited after registration but before the caller dispatches this step's
-		* ON_RUN_STEP, so the predecessor's CLOSED event still precedes the
-		* successor's start event.
-		*/
-		if (openMessageStepId != null && openMessageStepId !== runStep.id)
- /**
-		* Isolated: this step is already registered in `contentData`, so a
-		* predecessor delivery failure rejecting here would abort the caller
-		* before it publishes this step's ON_RUN_STEP — leaving the sweep to
-		* emit a terminal event for a step that never announced a start.
-		*/
-		try {
+		if (openMessageStepId != null && openMessageStepId !== runStep.id) try {
 			await this.closeRunStep(openMessageStepId, "completed", { metadata });
 		} catch (_e) {}
-		/**
-		* Stamped last, after the predecessor's closure has been delivered and
-		* immediately before the caller publishes this step's ON_RUN_STEP.
-		* `created_at` documents when the step was dispatched, so it must not
-		* absorb the latency of an arbitrarily slow predecessor handler.
-		*/
 		runStep.created_at = Date.now();
 	}
-	/**
-	* Closes a run step: stamps its terminal status + timestamp on the stored
-	* `RunStep` and emits `ON_RUN_STEP_CLOSED`. First close wins — later calls
-	* are no-ops — except a `restamp` close, which lets a `completed`
-	* TOOL_CALLS step refresh `completed_at` when a late-registered parallel
-	* tool call finishes after the step already closed (the eager-execution
-	* race). `cancelled`/`failed` are immutable once stamped.
-	*/
 	async closeRunStep(stepId, status, options) {
 		if (!stepId) return false;
 		const runStep = this.getRunStep(stepId);
@@ -1128,12 +717,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		}
 		return true;
 	}
-	/**
-	* Observes one `ON_RUN_STEP_COMPLETED` for a step and closes the step when
-	* no registered tool calls remain pending. Steps without pending tracking
-	* (summaries, cross-process resume) close on their first completion; the
-	* terminal-status guard in `closeRunStep` absorbs duplicate echoes.
-	*/
 	async recordStepCompletion(stepId, options) {
 		if (!stepId) return;
 		const { toolCallId, metadata, at } = options ?? {};
@@ -1157,12 +740,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			at: closeAt
 		});
 	}
-	/**
-	* Closes the tracked open MESSAGE_CREATION step for the event's agent lane.
-	* Fires on every model end, so the empty-map check short-circuits ahead of
-	* resolving the lane key — a turn whose message step already closed through
-	* successor-close does no work here.
-	*/
 	async closeOpenMessageStep(metadata, at) {
 		if (this.openMessageStepByAgent.size === 0) return;
 		const agentKey = this.getStepAgentKey(metadata);
@@ -1173,23 +750,10 @@ var StandardGraph = class StandardGraph extends Graph {
 			at
 		});
 	}
-	/**
-	* End-of-run sweep: closes every step that never reached a terminal
-	* status. Dual-dispatches like any other close — the custom-event channel
-	* is usually already torn down here and `safeDispatchCustomEvent` reports
-	* that quietly, but callback-only subscribers still receive the terminal
-	* signal whenever it is alive.
-	*/
 	async closeUnfinishedRunSteps(status, at) {
 		const closedAt = at ?? Date.now();
 		for (const runStep of this.contentData) {
 			if (runStep.status != null && runStep.status !== "in_progress") continue;
-			/**
-			* Isolated per step: one host handler throwing must not strand the
-			* remaining steps `in_progress` with no terminal event. The step is
-			* stamped before dispatch either way, so a thrown handler still leaves
-			* consistent state behind.
-			*/
 			try {
 				await this.closeRunStep(runStep.id, status, { at: closedAt });
 			} catch (_e) {}
@@ -1273,9 +837,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		return keyList.some((key) => key === void 0);
 	}
 	getRunMessages() {
-		/** Runtime-honest widening: a disposed-but-cached graph (HITL
-		* resume/reconnect through a WeakRef cache) can carry null here despite
-		* the field type. */
 		const messages = this.messages;
 		if (messages == null) return this.cachedRunMessages;
 		if (messages.length === 0 && this.cachedRunMessages != null) return this.cachedRunMessages;
@@ -1292,16 +853,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		if (discoveredTools.size === 0 && this.cachedDiscoveredTools != null) for (const snapshot of this.cachedDiscoveredTools.values()) for (const toolName of snapshot) discoveredTools.add(toolName);
 		return Array.from(discoveredTools);
 	}
-	/**
-	* True when THIS RUN produced `message` — the provenance the handoff cue
-	* gate needs. Tracked as an id set rather than inferred from `startIndex`
-	* arithmetic: summarization's remove-all compaction rewrites the live
-	* array and leaves `startIndex` stale, so index-based run/host
-	* discrimination silently breaks right after a mid-run summarize. Ids
-	* survive compaction (retained messages keep theirs), host-supplied
-	* prefill messages are never in the set, and membership is O(1) per
-	* model call.
-	*/
 	isRunProducedMessage(message) {
 		const id = message.id;
 		return typeof id === "string" && id !== "" && this.runProducedAiMessageIds.has(id);
@@ -1321,18 +872,12 @@ var StandardGraph = class StandardGraph extends Graph {
 		const context = this.agentContexts.get(this.defaultAgentId);
 		return (context?.tools?.length ?? 0) + (context?.toolDefinitions?.length ?? 0) + (context?.graphTools?.length ?? 0);
 	}
-	/**
-	* Get all run steps, optionally filtered by agent ID
-	*/
 	getRunSteps(agentId) {
 		const contentData = this.contentData;
 		if (contentData == null) return [];
 		if (agentId == null || agentId === "") return [...contentData];
 		return contentData.filter((step) => step.agentId === agentId);
 	}
-	/**
-	* Get run steps grouped by agent ID
-	*/
 	getRunStepsByAgent() {
 		const stepsByAgent = /* @__PURE__ */ new Map();
 		for (const step of this.contentData) {
@@ -1343,18 +888,11 @@ var StandardGraph = class StandardGraph extends Graph {
 		}
 		return stepsByAgent;
 	}
-	/**
-	* Get agent IDs that participated in this run
-	*/
 	getActiveAgentIds() {
 		const agentIds = /* @__PURE__ */ new Set();
 		for (const step of this.contentData) if (step.agentId != null && step.agentId !== "") agentIds.add(step.agentId);
 		return Array.from(agentIds);
 	}
-	/**
-	* Maps contentPart indices to agent IDs for post-run analysis
-	* Returns a map where key is the contentPart index and value is the agentId
-	*/
 	getContentPartAgentMap() {
 		const contentPartAgentMap = /* @__PURE__ */ new Map();
 		for (const step of this.contentData) if (step.agentId != null && step.agentId !== "" && Number.isFinite(step.index)) contentPartAgentMap.set(step.index, step.agentId);
@@ -1454,7 +992,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			toolCalls
 		});
 	}
-	/** Explicitly overrides the model used by isolated descendant subagent graphs. */
 	setSubagentModelOverride(model) {
 		this.subagentModelOverride = model;
 	}
@@ -1470,23 +1007,8 @@ var StandardGraph = class StandardGraph extends Graph {
 		this.signal.removeEventListener("abort", client.abortHandler);
 		client.abortHandler = void 0;
 	}
-	/**
-	* Applies a context-overflow recovery plan and hands control to the
-	* summarize node, which compacts and then routes straight back here for a
-	* retry against the corrected budget.
-	*
-	* Returning the detour rather than rethrowing is the whole point: the
-	* caller never sees the provider's rejection, only a slightly longer turn.
-	*/
 	beginOverflowRecovery({ recovery, agentContext, agentId, config, originalToolContent, estimatedPromptTokens }) {
 		const previousBudget = agentContext.maxContextTokens;
-		/**
-		* Deterministic compaction first. Re-pruning against the corrected budget
-		* raises context pressure, which is what drives the pruner's tool-output
-		* truncation and observation masking — no model call, no cost, and no
-		* message content lost. A summarization call is held back until that has
-		* been tried and the provider rejected the prompt again.
-		*/
 		const allowSummarization = agentContext.shouldSummarizeOverflow();
 		agentContext.preserveOriginalToolContent(originalToolContent);
 		agentContext.applyContextBudgetCorrection(recovery.budgetTokens, estimatedPromptTokens);
@@ -1515,37 +1037,13 @@ var StandardGraph = class StandardGraph extends Graph {
 	}
 	createCallModel(agentId = "default") {
 		return async (state, config) => {
-			/** Captured at node ENTRY, before any host-facing await (context-usage
-			* dispatch, hooks): a sibling's trip can fail the run and a prompt
-			* next run can reset the controller while this node is paused in one
-			* of those awaits, and a later capture would bind this attempt to the
-			* fresh controller. Trips and reason reads below stay on this
-			* capture. */
 			const attemptBreaker = this.breakerAbort;
 			const attemptBreakerEpoch = this.breakerEpoch;
-			/** Already-tripped-at-entry: a parallel sibling's breach has failed
-			* the run before this node was scheduled. Rethrow before hooks or the
-			* provider call — a custom provider that doesn't synchronously reject
-			* an aborted signal would otherwise start another model request on a
-			* failed run. */
 			const entryTripReason = this.resolveTrippedBreakerReason(attemptBreaker.signal);
 			if (entryTripReason != null) throw entryTripReason;
 			const agentContext = this.agentContexts.get(agentId);
 			if (!agentContext) throw new Error(`Agent context not found for agentId: ${agentId}`);
 			if (!config) throw new Error("No config provided");
-			/**
-			* A `PreemptBoundary` hook halted this run and the sealed commit is
-			* already in state. Enforced at every model node's ENTRY because that
-			* is the only site that covers all of `MultiAgentGraph`'s onward
-			* routing at once — static direct edges, Command fan-out, fan-in
-			* wrappers, and parallel siblings' subsequent inner-loop turns — none
-			* of which consult the halt (the registry signal was deliberately
-			* cleared to keep the stream-cancel from destroying the sealed turn).
-			* Declining the model call turns every routed-to successor into a
-			* no-op, so the outer workflow drains to END without new turns or tool
-			* side effects. Reset per turn in `resetPreemptTotals`, so the next
-			* `processStream` call starts clean.
-			*/
 			if (this.preemptHaltReason != null) return { messages: [] };
 			const { messages } = state;
 			const discoveredNames = require_tools.extractToolDiscoveries(messages);
@@ -1554,19 +1052,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				tools: agentContext.getToolsForBinding(),
 				toolExecution: this.toolExecution
 			});
-			/**
-			* Anthropic prompt-cache breakpoint on the tool definitions.
-			*
-			* Without this, the (often static) tool inventory shows up as
-			* fresh input on every turn — measured at ~28k tokens/turn for
-			* the local engine's coding-tool bundle, dominating per-turn
-			* cost even when message-level caching is on.
-			*
-			* Strategy: partition tools into [static, deferred] and stamp
-			* `cache_control: ephemeral` on the last static tool.
-			* Discovered deferred tools that arrive across turns sit *after*
-			* the breakpoint and don't invalidate the prefix.
-			*/
 			let toolsForBinding = rawToolsForBinding;
 			if (agentContext.provider === "anthropic" && agentContext.clientOptions?.promptCache === true) toolsForBinding = require_anthropicToolCache.partitionAndMarkAnthropicToolCache(rawToolsForBinding, require_anthropicToolCache.makeIsDeferred(agentContext.toolDefinitions), require_cache.resolvePromptCacheTtl(agentContext.clientOptions?.promptCacheTtl)) ?? rawToolsForBinding;
 			else if (agentContext.provider === "openrouter" && agentContext.clientOptions?.promptCache === true) toolsForBinding = require_toolCache$1.partitionAndMarkOpenRouterToolCache(rawToolsForBinding, require_anthropicToolCache.makeIsDeferred(agentContext.toolDefinitions), require_cache.resolvePromptCacheTtl(agentContext.clientOptions?.promptCacheTtl)) ?? rawToolsForBinding;
@@ -1585,11 +1070,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			this.config = config;
 			let messagesToUse = messages;
 			let contextUsage = null;
-			/**
-			* Held outside the prune block so overflow recovery — which detours to
-			* the summarize node from the invoke catch below — can preserve the
-			* same masking record the configured trigger preserves.
-			*/
 			let prunedOriginalToolContent;
 			if (!agentContext.pruneMessages && agentContext.tokenCounter && agentContext.maxContextTokens != null) agentContext.pruneMessages = require_prune.createPruneMessages({
 				startIndex: agentContext.indexTokenCountMap[0] != null ? this.startIndex : 0,
@@ -1619,14 +1099,6 @@ var StandardGraph = class StandardGraph extends Graph {
 					totalTokensFresh: agentContext.totalTokensFresh
 				});
 				prunedOriginalToolContent = newOriginalToolContent;
-				/**
-				* Masking rewrites tool content in `state.messages` in place, so this
-				* map is the only surviving copy of the full output. Persist it on
-				* every prune, not just when a summary is about to be written — the
-				* pruner closure that produced it is discarded on the next reset, and
-				* with it any chance of a later summary restoring the real content.
-				* AgentContext bounds what accumulates.
-				*/
 				agentContext.preserveOriginalToolContent(newOriginalToolContent);
 				agentContext.indexTokenCountMap = indexTokenCountMap;
 				if (calibrationRatio != null && calibrationRatio > 0) agentContext.calibrationRatio = calibrationRatio;
@@ -1637,21 +1109,10 @@ var StandardGraph = class StandardGraph extends Graph {
 					const currentToolTokens = agentContext.toolSchemaTokens;
 					if ((currentToolTokens > 0 ? Math.abs(calibratedToolTokens - currentToolTokens) / currentToolTokens : 1) > CALIBRATION_VARIANCE_THRESHOLD) {
 						agentContext.toolSchemaTokens = calibratedToolTokens;
-						/** Largest-remainder apportionment keeps the per-tool breakdown
-						*  summing exactly to the calibrated aggregate */
 						if (agentContext.toolTokenCounts != null && currentToolTokens > 0) agentContext.toolTokenCounts = require_tokens.apportionTokenCounts(agentContext.toolTokenCounts, calibratedToolTokens / currentToolTokens, calibratedToolTokens);
 					}
 				}
 				messagesToUse = context;
-				/** Dispatched right before the model invoke — a summarization
-				*  detour returns from this node without an LLM call, and the
-				*  post-summary retry produces its own snapshot.
-				*
-				*  The breakdown describes the post-prune prompt: counts from the
-				*  kept context, message tokens derived from the same calibrated
-				*  budget math as `remainingContextTokens` (the index map is keyed
-				*  by pre-prune state indices, so summing it over `context` would
-				*  missum); `prePruneContextTokens` carries the pre-prune metric. */
 				const usageBreakdown = agentContext.getTokenBudgetBreakdown(messages);
 				usageBreakdown.messageCount = context.length;
 				contextUsage = {
@@ -1706,13 +1167,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				}
 			}
 			let finalMessages = messagesToUse;
-			/**
-			* Keep the pruner's provider-grounded aggregate as the authoritative
-			* baseline, then attribute it across retained messages. Provider
-			* transforms can shrink one message while expanding or adding another;
-			* per-origin accounting prevents that unrelated shrink from canceling
-			* the expansion. Raw counts are frozen before in-place formatters run.
-			*/
 			let providerMessageBaseline;
 			const providerMessageOrigins = /* @__PURE__ */ new WeakMap();
 			if (contextUsage != null && agentContext.tokenCounter != null) {
@@ -1735,11 +1189,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				if (message instanceof _langchain_core_messages.ToolMessage && typeof message.tool_call_id === "string" && message.tool_call_id.length > 0) return `tool:call:${message.tool_call_id}`;
 				if (typeof message.id === "string" && message.id.length > 0) return `${type}:id:${message.id}`;
 			};
-			/**
-			* Provider projections clone messages. Preserve their baseline origin
-			* without writing tracking metadata onto the wire. Synthetic fold
-			* messages intentionally remain unattributed and are charged in full.
-			*/
 			const trackProviderMessageOrigins = (before, after) => {
 				if (providerMessageBaseline == null || before === after) return after;
 				if (before.length === after.length) {
@@ -1851,17 +1300,9 @@ var StandardGraph = class StandardGraph extends Graph {
 			const applyProviderMessageTransforms = (candidate) => {
 				let transformed = candidate;
 				if (require_request.isThinkingEnabled(agentContext.provider, agentContext.clientOptions)) {
-					/**
-					* Current-run AI messages may validly omit a thinking block. The
-					* boundary prevents them from being mistaken for foreign history.
-					*/
 					const before = transformed;
 					transformed = trackProviderMessageOrigins(before, require_format.ensureThinkingBlockInMessages(before, agentContext.provider, config, this.startIndex));
 				}
-				/**
-				* Tool-less destinations cannot send inherited tool blocks without a
-				* tool schema, so fold those interactions into provider-valid content.
-				*/
 				if (toolsForBinding == null || toolsForBinding.length === 0) {
 					const before = transformed;
 					transformed = trackProviderMessageOrigins(before, require_format.foldToolBlocksForToollessAgent(before, config));
@@ -1870,15 +1311,6 @@ var StandardGraph = class StandardGraph extends Graph {
 						transformed = trackProviderMessageOrigins(beforeLegacyFormat, require_content.formatContentStrings(beforeLegacyFormat));
 					}
 				}
-				/**
-				* Applied HERE for the primary so the cue is part of the MEASURED
-				* payload — the pre-invoke projection and overflow guard run on this
-				* stage's output, and a post-measure append could push a just-fits
-				* prompt over budget unreported (#346 round 2). The attemptInvoke
-				* funnel re-keys per SERVING provider: it strips this cue for a
-				* tolerant fallback and adds it for a Claude fallback behind a
-				* tolerant primary.
-				*/
 				if (require_llm.isAnthropicLike(agentContext.provider, agentContext.clientOptions)) {
 					const before = transformed;
 					transformed = trackProviderMessageOrigins(before, require_handoffCue.appendPredecessorHandoffCue(before, (message) => this.isRunProducedMessage(message)));
@@ -1977,42 +1409,7 @@ var StandardGraph = class StandardGraph extends Graph {
 					});
 				}
 			}
-			/**
-			* Mistral rejects consecutive user turns outright; Bedrock's Converse
-			* API documents strict user/assistant alternation across its model
-			* families, with enforcement varying by family (Claude on Converse
-			* currently tolerates the shape — verified live — but the payload is
-			* normalized for all of them rather than betting on leniency). Four
-			* sites can emit them — the `PostToolBatch` and `PreemptBoundary` hook
-			* boundaries (a consolidated context message followed by one
-			* `HumanMessage` per injected entry), a queue drain carrying more than
-			* one steer, and `run.ts`'s pre-stream context push onto a payload that
-			* already ends on a user turn.
-			*
-			* Normalized here, at the last provider-facing hop, rather than at any
-			* one boundary: the boundaries must keep per-message identity, because
-			* `additional_kwargs.source`/`skillName` drive steer rendering and the
-			* trailing-steer anchor downstream. Graph state and the host's
-			* persisted messages are untouched — this shapes only what goes on the
-			* wire, for the providers that actually care.
-			*
-			* Runs AFTER synthetic-context compaction: that pass can rewrite or
-			* drop messages, so coalescing has to see its output, and it is the
-			* last shaping step before the cache breakpoint is chosen.
-			*/
 			if (require_alternation.strictAlternationProviders.has(agentContext.provider)) {
-				/**
-				* Wrapped like every other provider transform: the merged message is
-				* a NEW object, and without re-attachment the final pre-invoke
-				* measurement would drop both source turns' calibrated shares and
-				* recharge the merge at full raw estimate — enough to flip a
-				* just-fits payload (the synthetic-context compaction above binary
-				* searches to exactly that) into a spurious pre-invoke overflow. The
-				* merge keeps the first source's id, so the keyed branch re-attaches
-				* that origin; the absorbed turn's tokens are charged as new raw
-				* growth, which only ever under-estimates by less than the old
-				* behavior over-estimated.
-				*/
 				const beforeCoalesce = finalMessages;
 				finalMessages = trackProviderMessageOrigins(beforeCoalesce, require_alternation.coalesceAdjacentUserTurns(beforeCoalesce));
 			}
@@ -2053,11 +1450,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				maxToolResultChars: maxProviderToolResultChars,
 				callOptions: config
 			}));
-			/**
-			* Prompt-cache placement and orphan sanitization are provider-wire
-			* transforms too. Re-measure after both so no content added after the
-			* earlier artifact/synthetic compaction decision can bypass the guard.
-			*/
 			finalProjection = measureProviderPayload(finalMessages);
 			const preInvokeContextOverflowError = !finalProjection.fits ? createProviderPayloadOverflowError({
 				projection: finalProjection,
@@ -2095,15 +1487,12 @@ var StandardGraph = class StandardGraph extends Graph {
 					info: `Message pruning removed all messages as none fit in the context window. ${guidance}\n${breakdown}`
 				}));
 			}
-			/** Past the empty-prompt guard — a model call is now guaranteed */
 			if (contextUsage != null) {
 				if (finalProjection.projectedMessageTokens != null && finalProjection.availableMessageTokens != null) {
 					contextUsage.breakdown.messageCount = finalMessages.length;
 					contextUsage.remainingContextTokens = Math.max(0, finalProjection.availableMessageTokens - finalProjection.projectedMessageTokens);
 				}
 				require_budget.syncBudgetDerivedFields(contextUsage);
-				/** Awaited so async host handlers receive the pre-invoke snapshot
-				*  before any model deltas are emitted */
 				await require_events.safeDispatchCustomEvent("on_context_usage", contextUsage, config);
 			}
 			const invokeStart = Date.now();
@@ -2125,17 +1514,10 @@ var StandardGraph = class StandardGraph extends Graph {
 			let langfuseHandler;
 			let invokeConfig = {
 				...config,
-				/** The run-scoped breaker composed in, so a stream-limit trip in one
-				* parallel agent node also cancels sibling nodes' in-flight model
-				* calls, not only their subagents. */
 				signal: require_misc.composeAbortSignals(config.signal, attemptBreaker.signal),
 				metadata: {
 					...config.metadata ?? {},
 					...traceMetadata,
-					/** Canonical agent identity, stamped OUTSIDE trace-metadata
-					*  filtering: `createLangfuseTraceMetadata` drops values over its
-					*  length cap, but scope trust (`isForeignScope`) needs the id
-					*  verbatim regardless of length. */
 					agentId,
 					[require_streamLimits.STREAM_LIMIT_EPOCH_KEY]: attemptBreakerEpoch
 				}
@@ -2160,10 +1542,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			const metadata = config.metadata;
 			try {
 				if (preInvokeContextOverflowError != null) throw preInvokeContextOverflowError;
-				/** Rechecked after the pre-invoke awaits (context-usage dispatch,
-				* hooks): 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 request. */
 				{
 					const preInvokeTrip = this.resolveTrippedBreakerReason(attemptBreaker.signal);
 					if (preInvokeTrip != null) throw preInvokeTrip;
@@ -2184,42 +1562,14 @@ var StandardGraph = class StandardGraph extends Graph {
 					graph: this,
 					metadata
 				});
-				/**
-				* A tripped stream circuit breaker is a deliberate abort, not a
-				* provider failure: entering overflow recovery or the fallback chain
-				* would spend more provider work after the safety limit fired, and a
-				* succeeding fallback would resolve a run the public contract says
-				* must reject. Rethrow before any recovery path.
-				*/
 				if (primaryError instanceof require_streamLimits.StreamLimitExceededError) {
-					/** Tripped before rethrowing so parallel agent nodes' in-flight
-					* model calls and subagents stop while the rejection propagates. */
 					attemptBreaker.abort(primaryError);
 					throw primaryError;
 				}
-				/** A sibling that tripped the shared breaker aborts this branch's
-				* composed signal, and some providers surface that as a generic
-				* abort error; entering overflow planning or the fallback chain
-				* would start new provider work after the run-wide breaker fired.
-				* Rethrow the breaker's own stream-limit reason instead. */
 				{
 					const trippedReason = this.resolveTrippedBreakerReason(attemptBreaker.signal);
 					if (trippedReason != null) throw trippedReason;
 				}
-				/**
-				* A context overflow is a deterministic consequence of the payload,
-				* not a provider being unavailable — so it is answered by compacting
-				* and retrying rather than by re-sending the same oversized prompt
-				* down the fallback chain. Fallbacks still run for every other
-				* failure, and for an overflow whose recovery budget is spent.
-				*/
-				/**
-				* Compaction has to have something to work with. Without a token
-				* counter there is no pruner, and with summarization disabled the
-				* summarize node deliberately no-ops — so in that combination the
-				* retry would resend a byte-identical prompt. Skipping the detour
-				* keeps the original error and one round trip instead of three.
-				*/
 				const estimatedPromptTokens = getEstimatedPromptTokens(contextUsage);
 				const canSummarizeOverflow = agentContext.summarizationEnabled === true && require_recency.splitAtRecencyBoundary(messages, {
 					turns: agentContext.summarizationConfig?.retainRecent?.turns ?? 2,
@@ -2232,20 +1582,9 @@ var StandardGraph = class StandardGraph extends Graph {
 					return getLocalProviderOverflowMeasurement(error)?.estimatedPromptTokens ?? (resolvedFallbackContext == null ? estimatedPromptTokens : void 0);
 				};
 				const planRecovery = (error, attributedFallbackContext) => {
-					/**
-					* When the rejection came from a fallback, plan against *that*
-					* client: its window and output allowance are why it was configured
-					* as an alternative in the first place.
-					*/
 					const fallbackContext = attributedFallbackContext ?? require_invoke.getFallbackErrorContext(error);
 					const localMeasurement = getLocalProviderOverflowMeasurement(error);
 					const recoveryPromptEstimate = getRecoveryPromptEstimate(error, fallbackContext);
-					/**
-					* A previous correction that left the rejected prompt no smaller
-					* proves this state has nothing left to compact. Use the fallback
-					* projection when one exists so unlike provider formats are never
-					* compared through the primary's cheaper pre-projection estimate.
-					*/
 					if (agentContext.overflowRecoveryStalled(recoveryPromptEstimate)) return null;
 					const recovery = require_contextOverflowRecovery.planContextOverflowRecovery({
 						error,
@@ -2278,12 +1617,6 @@ var StandardGraph = class StandardGraph extends Graph {
 						estimatedPromptTokens: recoveryPromptEstimate
 					});
 				}
-				/**
-				* A fallback can reject the same prompt as too large even when the
-				* primary failed for an unrelated reason — a fallback with a smaller
-				* window is the obvious case. Planning against the exhausted-chain
-				* error keeps that path recoverable instead of surfacing it.
-				*/
 				try {
 					result = await require_langfuseRuntimeScope.withLangfuseRuntimeScope(require_langfuseRuntimeScope.resolveLangfuseRuntimeScope({
 						runLangfuse: this.langfuse,
@@ -2297,11 +1630,6 @@ var StandardGraph = class StandardGraph extends Graph {
 						config: invokeConfig,
 						primaryError,
 						context: this,
-						/**
-						* Lets the chain recognise a fallback overflow whose signature
-						* carries no reason of its own (Vertex AI's bare 400) and
-						* surface it rather than a later unrelated failure.
-						*/
 						overflowContext: {
 							provider: agentContext.provider,
 							estimatedPromptTokens: getEstimatedPromptTokens(contextUsage),
@@ -2309,16 +1637,6 @@ var StandardGraph = class StandardGraph extends Graph {
 						},
 						prepareProviderMessages: ({ model: fallbackModel, messages: fallbackMessages, provider: fallbackProvider, maxContextTokens: fallbackMaxContextTokens, config: fallbackConfig }) => {
 							const fallbackToolResultChars = agentContext.maxToolResultChars ?? require_truncation.calculateMaxToolResultChars(fallbackMaxContextTokens ?? agentContext.maxContextTokens);
-							/**
-							* Serving-provider cue shaping BEFORE the fallback payload
-							* is measured: a Claude fallback behind a tolerant primary
-							* gains the cue inside the guarded projection (a prompt
-							* within the cue's cost of the fallback budget must take
-							* the recovery path, not ship oversized), and a tolerant
-							* fallback behind an Anthropic primary sheds the baked cue
-							* before it is measured against the tighter budget. The
-							* attemptInvoke funnel pass then finds nothing to change.
-							*/
 							const cueShapedFallbackMessages = trackProviderMessageOrigins(fallbackMessages, require_llm.isAnthropicLike(fallbackProvider, { model: require_invoke.resolveServingModelId(fallbackModel) }) ? require_handoffCue.appendPredecessorHandoffCue(fallbackMessages, (m) => this.isRunProducedMessage(m)) : require_handoffCue.removePredecessorHandoffCue(fallbackMessages));
 							const projectedFallbackMessages = trackProviderMessageOrigins(cueShapedFallbackMessages, require_invoke.projectMessagesForProvider({
 								model: fallbackModel,
@@ -2339,14 +1657,10 @@ var StandardGraph = class StandardGraph extends Graph {
 					}));
 				} catch (fallbackError) {
 					if (fallbackError instanceof require_streamLimits.StreamLimitExceededError) {
-						/** Same treatment as the primary path: a fallback stream that
-						* trips the breaker must stop parallel agent nodes' model calls
-						* and subagents before the rejection propagates. */
 						attemptBreaker.abort(fallbackError);
 						throw fallbackError;
 					}
 					{
-						/** Same sibling-abort translation guard as the primary catch. */
 						const trippedReason = this.resolveTrippedBreakerReason(attemptBreaker.signal);
 						if (trippedReason != null) throw trippedReason;
 					}
@@ -2378,31 +1692,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				await require_langfuse.disposeLangfuseHandler(langfuseHandler);
 			}
 			if (!result) throw new Error("No result after model invocation");
-			/**
-			* Fallback: populate toolCallStepIds in the graph execution context.
-			*
-			* When model.stream() is available (the common case), attemptInvoke
-			* processes all chunks through a local ChatModelStreamHandler which
-			* creates run steps and populates toolCallStepIds before returning.
-			* The code below is a fallback for the rare case where model.stream
-			* is unavailable and model.invoke() was used instead.
-			*
-			* Text content is dispatched FIRST so that MESSAGE_CREATION is the
-			* current step when handleToolCalls runs. handleToolCalls then creates
-			* TOOL_CALLS on top of it. The dedup in getMessageId and
-			* toolCallStepIds.has makes this safe when attemptInvoke already
-			* handled everything — both paths become no-ops.
-			*/
 			const responseMessage = result.messages?.[0];
-			/**
-			* Provenance for the handoff-cue gate: recorded at the node, where the
-			* produced turn is unambiguous. The public ChatModel contract does not
-			* require implementations to set message ids — the reducer would
-			* assign one AFTER this node returns, which is too late for the set —
-			* so an id is assigned here first, the same way the reducer does it
-			* (`v4()`, mirrored into `lc_kwargs`), and the reducer's
-			* keep-existing-id rule makes the state message match.
-			*/
 			if (responseMessage?.getType() === "ai") {
 				if (typeof responseMessage.id !== "string" || responseMessage.id === "") {
 					responseMessage.id = (0, uuid.v4)();
@@ -2449,11 +1739,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				}
 				await require_handlers.handleToolCalls(toolCalls, metadata, this);
 			}
-			/**
-			* When streaming events are unavailable, ChatModelStreamHandler never
-			* fires. Dispatch final reasoning/text content here. getMessageId makes
-			* this a no-op when the streaming path already handled the same step.
-			*/
 			if (!hasToolCalls && responseMessage != null) {
 				if (dispatchableFinalReasoningContent != null && await dispatchReasoningContent({
 					graph: this,
@@ -2474,13 +1759,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			}
 			const invokeElapsed = ((Date.now() - invokeStart) / 1e3).toFixed(2);
 			agentContext.currentUsage = this.getUsageMetadata(result.messages?.[0]);
-			/**
-			* Synthetic usage from a sealed turn is an estimate derived from the
-			* host's own counter, so feeding it to calibration would teach a ratio
-			* of exactly 1.0 — self-consistent by construction, and wrong for any
-			* provider whose real ratio differs. It still flows to `currentUsage`
-			* for host billing; it just does not get to move the EMA.
-			*/
 			const estimatedUsage = (result.messages?.[0])?.response_metadata.estimated_usage === true;
 			if (agentContext.currentUsage) {
 				if (!estimatedUsage) agentContext.updateLastCallUsage(agentContext.currentUsage);
@@ -2497,28 +1775,9 @@ var StandardGraph = class StandardGraph extends Graph {
 			}, invokeMeta, { force: true });
 			if (responseMessage?.response_metadata.preempted === true) {
 				const { messages: injected, preventContinuation } = await this.dispatchPreemptBoundary(agentId, config);
-				/**
-				* Release before branching: the slot is held only for the duration of
-				* the drain, and an early return below must not strand it.
-				*/
 				this.releasePreemptSeal();
 				if (preventContinuation) {
-					/**
-					* A hook halted at the boundary. Commit the sealed turn and anything
-					* it injected, but do NOT self-loop: `preventContinuation` promises
-					* no further model turn, and the run-loop poll in `processStream`
-					* only sees the halt AFTER the next call would already have started
-					* — direct graph consumers never poll it at all. A trailing injected
-					* HumanMessage carries no tool calls, so `toolsCondition` routes it
-					* to END.
-					*/
 					this.preemptIncomplete = true;
-					/**
-					* A halting boundary that ALSO injected nothing is still an empty
-					* boundary by the `getPreemptStats().emptyBoundaries` contract —
-					* hosts use the counter for truncated-seal telemetry, and both
-					* paths end the turn with nothing to resume from.
-					*/
 					if (injected.length === 0) this.preemptEmptyBoundaries += 1;
 					this.cleanupSignalListener();
 					return injected.length > 0 ? { messages: [...result.messages ?? [], ...injected] } : result;
@@ -2528,12 +1787,6 @@ var StandardGraph = class StandardGraph extends Graph {
 					this.cleanupSignalListener();
 					return { messages: [...result.messages ?? [], ...injected] };
 				}
-				/**
-				* Nothing to inject — the host cancelled or already drained. Do NOT
-				* self-loop: a trailing model turn with no new input is dropped by
-				* some Gemini models and read as prefill by Anthropic. Do NOT pretend
-				* the turn completed either; the answer really was cut short.
-				*/
 				this.preemptEmptyBoundaries += 1;
 				this.preemptIncomplete = true;
 			}
@@ -2541,19 +1794,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			return result;
 		};
 	}
-	/**
-	* Fires `PreemptBoundary` after a sealed turn and returns whatever the
-	* hooks asked to inject, converted through the same `convertInjectedMessages`
-	* the tool boundary uses so the two sites cannot emit different shapes.
-	*
-	* Never throws: a drain that fails or times out costs the injection, not the
-	* run. The caller treats an empty result as "nothing to resume with".
-	*
-	* `preventContinuation` is surfaced alongside the messages rather than left
-	* to the registry halt signal, which `processStream` only polls between
-	* stream events — by then the self-loop it was meant to prevent has already
-	* issued another model call, and a direct graph consumer never polls it.
-	*/
 	async dispatchPreemptBoundary(agentId, config) {
 		if (this.hookRegistry == null) return EMPTY_PREEMPT_BOUNDARY;
 		const configurable = config?.configurable;
@@ -2571,62 +1811,15 @@ var StandardGraph = class StandardGraph extends Graph {
 			},
 			sessionId: runId,
 			timeoutMs: require_constants.PREEMPT_BOUNDARY_HOOK_TIMEOUT_MS,
-			/**
-			* The host's own abort signal(s), deliberately NOT `config.signal` —
-			* inside a node the latter is LangGraph's composed signal, which also
-			* fires when an unrelated sibling in the same superstep throws.
-			* Cancellation already returns control in milliseconds without this;
-			* what it buys is that a drain does not keep running after the run it
-			* belongs to died.
-			*
-			* Composed because the host can cancel through either channel: the
-			* construction signal, or the per-call `callerConfig.signal` — the only
-			* one a multi-agent run has, since `MultiAgentGraphConfig` exposes no
-			* construction signal. When both exist they may be different
-			* controllers, and a drain must stop when EITHER fires.
-			*/
 			signal: require_misc.composeAbortSignals(this.signal, this.callerSignal)
 		}).catch(() => void 0);
 		if (result == null) return EMPTY_PREEMPT_BOUNDARY;
-		/**
-		* `executeHooks` raises a registry halt whenever a hook returns
-		* `preventContinuation`. That halt has exactly one consumer — the poll in
-		* `Run.processStream` — and its `break` cancels the stream iterator, which
-		* aborts Pregel. The abort lands BEFORE the outer reducer commits
-		* `StandardGraph.messages`, so honoring the halt here would destroy the
-		* sealed assistant turn: the run returns empty content and the host
-		* persists nothing. Measured deterministically — the commit is several
-		* stream events downstream of the point the halt becomes observable.
-		*
-		* The `preventContinuation` branch in `createCallModel` already enforces
-		* the contract locally by declining to self-loop, and a sealed chunk
-		* provably carries no tool calls, so the turn routes to END after exactly
-		* one model call either way. Clearing the halt therefore costs nothing it
-		* was buying and saves the content the seal exists to preserve.
-		*
-		* Scoped to a halt this event raised, so a halt from an earlier hook in
-		* the same run — `haltRun` is first-write-wins — is left alone.
-		*/
 		const halt = this.hookRegistry.getHaltSignal(runId);
 		if (result.preventContinuation === true && halt?.source === "PreemptBoundary") {
 			this.preemptHaltReason = halt.reason;
 			this.hookRegistry.clearHaltSignal(runId);
 		}
 		const injected = [];
-		/**
-		* `PreemptBoundaryHookOutput` is `BaseHookOutput`, so `additionalContext`
-		* is part of the contract here just as it is at the tool boundary. It has
-		* to be materialized BEFORE the emptiness test, or a hook that returns
-		* context alone would read as "nothing to resume with" and cut the answer
-		* short. Same system-flavored `HumanMessage` convention `ToolNode` uses —
-		* Anthropic and Google reject a mid-conversation `SystemMessage`.
-		*/
-		/**
-		* Whitespace-only entries are dropped for the same reason empty
-		* `injectedMessages` are: `executeHooks` keeps them because their raw
-		* length is nonzero, but a blank turn is not something to resume from —
-		* it costs a model call and strict providers reject it outright.
-		*/
 		const contexts = result.additionalContexts.filter((context) => context.trim() !== "");
 		if (contexts.length > 0) injected.push(new _langchain_core_messages.HumanMessage({
 			content: contexts.join("\n\n"),
@@ -2650,16 +1843,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		const getConfig = () => this.config;
 		const agentContext = this.agentContexts.get(agentId);
 		if (!agentContext) throw new Error(`Agent context not found for agentId: ${agentId}`);
-		/**
-		* Depth countdown across graph boundaries: the parent's `maxSubagentDepth`
-		* becomes this executor's `maxDepth`. When the child graph is constructed,
-		* `buildChildInputs()` decrements `maxSubagentDepth` on the child's
-		* `AgentInputs` (only when `allowNested: true`; otherwise subagentConfigs
-		* are stripped entirely). The child graph's own `createAgentNode()` then
-		* reads the decremented value here and creates a narrower executor —
-		* recursion is bounded even though each graph has its own separate
-		* executor instance.
-		*/
 		const effectiveSubagentDepth = agentContext.maxSubagentDepth ?? 1;
 		if (agentContext.subagentConfigs != null && agentContext.subagentConfigs.length > 0 && effectiveSubagentDepth > 0) {
 			const executableConfigs = require_childGraphConfig.normalizeSubagentConfigEntries(agentContext.subagentConfigs, agentContext);
@@ -2692,9 +1875,6 @@ var StandardGraph = class StandardGraph extends Graph {
 					parentSignal: this.signal,
 					breakerScope: { controller: () => this.breakerAbort },
 					hookRegistry: this.hookRegistry,
-					/** Lazy — Run wires the registry onto the graph AFTER
-					*  `createWorkflow()` runs, so a direct capture here would be
-					*  `undefined` at construction time. */
 					parentHandlerRegistry: getParentHandlerRegistry,
 					parentRunId: this.runId ?? "",
 					parentAgentId: agentContext.agentId,
@@ -2718,17 +1898,11 @@ var StandardGraph = class StandardGraph extends Graph {
 					const description = typeof input.description === "string" && input.description.trim().length > 0 ? input.description : require_SubagentExecutor.DEFAULT_SUBAGENT_DESCRIPTION;
 					const subagentType = typeof input.subagent_type === "string" ? input.subagent_type : "";
 					const threadId = config.configurable?.thread_id;
-					/** Surface the parent call id so child checkpoints, interrupts, and
-					* update events remain correlated across replay and resume. */
 					const toolRuntime = config;
 					const toolCall = toolRuntime.toolCall;
 					let parentToolCallId;
 					if (typeof toolRuntime.toolCallId === "string" && toolRuntime.toolCallId !== "") parentToolCallId = toolRuntime.toolCallId;
 					else if (typeof toolCall?.id === "string" && toolCall.id !== "") parentToolCallId = toolCall.id;
-					/** The parent tool batch's entry-captured scope (stamped by
-					* ToolNode before PreToolUse hooks) — binds this child to the
-					* run that dispatched it, not to whatever controller a reset
-					* installed while the hooks were awaited. */
 					const batchScope = config.configurable?.[require_streamLimits.RUN_BREAKER_SCOPE_CONFIG_KEY];
 					return (await executor.execute({
 						description,
@@ -2737,12 +1911,6 @@ var StandardGraph = class StandardGraph extends Graph {
 						signal: config.signal,
 						parentToolCallId,
 						breaker: batchScope?.controller,
-						/**
-						* Forward the parent's `configurable` so host-set fields
-						* (`requestBody`, `user`, etc.) propagate into the child
-						* workflow. The executor scrubs run-identity fields before
-						* forwarding — see `SubagentExecuteParams.parentConfigurable`.
-						*/
 						parentConfigurable: config.configurable
 					})).content;
 				}, require_SubagentTool.buildSubagentToolParams(executableConfigs));
@@ -2754,13 +1922,6 @@ var StandardGraph = class StandardGraph extends Graph {
 				};
 				if (!agentContext.graphTools) agentContext.graphTools = [];
 				agentContext.graphTools.push(subagentTool);
-				/**
-				* Refresh toolSchemaTokens to include the subagent tool's schema.
-				* `calculateInstructionTokens()` was kicked off in `fromConfig()`
-				* before graphTools was populated, so its result did not count this
-				* tool. Without this retrigger, token-budget/pruning logic
-				* underestimates prompt overhead.
-				*/
 				if (agentContext.tokenCounter) {
 					const { tokenCounter, baseIndexTokenCountMap } = agentContext;
 					agentContext.tokenCalculationPromise = agentContext.calculateInstructionTokens(tokenCounter).then(() => {
@@ -2776,11 +1937,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		const summarizeNode = `${SUMMARIZE}${agentId}`;
 		const routeMessage = (state, config) => {
 			this.config = config;
-			/**
-			* A sealed turn that injected messages resumes in the SAME pregel run:
-			* back to the agent node as a new superstep, so the model continues in
-			* one assistant message instead of restarting the graph.
-			*/
 			if (this.pendingPreemptReturn.delete(agentId)) return agentNode;
 			if (state.summarizationRequest != null) return summarizeNode;
 			return require_ToolNode.toolsCondition(state, toolNode, this.invokedToolIds);
@@ -2819,51 +1975,26 @@ var StandardGraph = class StandardGraph extends Graph {
 				runId: this.runId,
 				isMultiAgent: this.isMultiAgentGraph(),
 				hookRegistry: this.hookRegistry,
-				/**
-				* Live references (both maps are cleared in place, never
-				* replaced), so summarization streams share the run's event
-				* budget accounting under their own generation key.
-				*/
 				streamLimits: this.streamLimits,
 				streamDeltaEventCounts: this.streamDeltaEventCounts,
 				streamedToolCallArgTallies: this.streamedToolCallArgTallies,
-				/** Accessor pair, not a value copy: unlike the two maps above,
-				* the credit map is REPLACED by graph resets rather than cleared
-				* in place, and the guards' lazy `??=` must install onto the
-				* graph — a copy held here would survive resets and grow one
-				* attempt-stamped entry per compaction for a retained reused
-				* chunk object. */
 				get streamLimitChargeCredits() {
 					return readChargeCredits();
 				},
 				set streamLimitChargeCredits(value) {
 					writeChargeCredits(value);
 				},
-				/** Live epoch, so summary tallies are creation-tagged and the
-				* resetValues grace sweep treats them like model-attempt
-				* entries. */
 				get breakerEpoch() {
 					return readBreakerEpoch();
 				},
-				/** Accessor pair like the charge credits: summary attempts
-				* lease their generations on the GRAPH's active set, and the
-				* lazy `??=` in the lease helper must install there. */
 				get activeStreamLimitGenerations() {
 					return readActiveGenerations();
 				},
 				set activeStreamLimitGenerations(value) {
 					writeActiveGenerations(value);
 				},
-				/** Read per attempt: a sibling branch tripping the run breaker
-				* must also cancel in-flight summarization model calls. */
 				getBreakerSignal: () => this.breakerAbort.signal,
-				/** The node captures this at entry so its own chunk handler's
-				* breach trips the run that STARTED the summarization, not a
-				* controller installed by a later reset. */
 				getBreakerController: () => this.breakerAbort,
-				/** Captured at node entry and stamped into the summary attempt
-				* metadata, so the wire consumer epoch-gates old-run summary
-				* chunks exactly like model-attempt chunks. */
 				getBreakerEpoch: () => this.breakerEpoch,
 				dispatchRunStep: async (runStep, nodeConfig) => {
 					const resolvedConfig = nodeConfig ?? this.config;
@@ -2921,21 +2052,9 @@ var StandardGraph = class StandardGraph extends Graph {
 			default: () => []
 		}) })).addNode(this.defaultAgentId, agentNode, { ends: [_langchain_langgraph.END] }).addEdge(_langchain_langgraph.START, this.defaultAgentId).compile(this.compileOptions);
 	}
-	/**
-	* Indicates if this is a multi-agent graph.
-	* Override in MultiAgentGraph to return true.
-	* Used to conditionally include agentId in RunStep for frontend rendering.
-	*/
 	isMultiAgentGraph() {
 		return false;
 	}
-	/**
-	* Get the parallel group ID for an agent, if any.
-	* Override in MultiAgentGraph to provide actual group IDs.
-	* Group IDs are incrementing numbers (1, 2, 3...) reflecting execution order.
-	* @param _agentId - The agent ID to look up
-	* @returns undefined for StandardGraph (no parallel groups), or group number for MultiAgentGraph
-	*/
 	getParallelGroupIdForAgent(_agentId) {}
 	resolveParallelGroupId(agentId, metadata) {
 		if (metadata == null || !Object.prototype.hasOwnProperty.call(metadata, "__handoff_group_id")) return this.getParallelGroupIdForAgent(agentId);
@@ -2944,9 +2063,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		if (typeof runtimeGroupId === "number" && Number.isSafeInteger(runtimeGroupId) && runtimeGroupId > 0) return runtimeGroupId;
 		return this.getParallelGroupIdForAgent(agentId);
 	}
-	/**
-	* Dispatches a run step to the client, returns the step ID
-	*/
 	async dispatchRunStep(stepKey, stepDetails, metadata) {
 		if (!this.config) throw new Error("No config provided");
 		const [stepId, stepIndex] = this.generateStepId(stepKey);
@@ -2971,12 +2087,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		};
 		const runId = this.runId ?? "";
 		if (runId) runStep.runId = runId;
-		/**
-		* `agentId`/`groupId` are multi-agent-only, and `getAgentContext` signals a
-		* miss by throwing — so for a single-agent graph the lookup could only ever
-		* build and discard an Error while producing the same undefined fields.
-		* The constant-time check gates it out of the per-step dispatch path.
-		*/
 		if (metadata && this.isMultiAgentGraph()) try {
 			const agentContext = this.getAgentContext(metadata);
 			if (agentContext.agentId) {
@@ -2999,20 +2109,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		}
 		return stepId;
 	}
-	/**
-	* Static version of handleToolCallError to avoid creating strong references
-	* that prevent garbage collection.
-	*
-	* Returns whether the error completion event was actually dispatched. A
-	* tool can error before this graph instance has a run step for the call —
-	* on a resume pass the interrupted batch re-executes IMMEDIATELY on graph
-	* re-entry, before any step replay has registered `toolCallStepIds` (a
-	* fast-failing tool, e.g. a schema-validation reject, loses that race).
-	* That is a caller-recoverable condition, not an invariant violation: the
-	* ToolNode falls back to its normal completion dispatch for the error
-	* ToolMessage when this returns `false`, so throwing here would only
-	* replace a recoverable miss with a lost completion event and a scary log.
-	*/
 	static async handleToolCallErrorStatic(graph, data, metadata) {
 		if (!data.id) {
 			console.warn("No Tool ID provided for Tool Error");
@@ -3050,10 +2146,6 @@ var StandardGraph = class StandardGraph extends Graph {
 		});
 		return true;
 	}
-	/**
-	* Instance method that delegates to the static method
-	* Kept for backward compatibility
-	*/
 	async handleToolCallError(data, metadata) {
 		return StandardGraph.handleToolCallErrorStatic(this, data, metadata);
 	}