@librechat/agents 3.3.3 → 3.3.4

package/dist/cjs/graphs/Graph.cjs

@@ -5,15 +5,17 @@ const require_langfuseToolOutputTracing = require("../langfuseToolOutputTracing.
 const require_callbacks = require("../utils/callbacks.cjs");
 const require_enum = require("../common/enum.cjs");
 require("../common/index.cjs");
+const require_truncation = require("../utils/truncation.cjs");
+const require_toolContent = require("../utils/toolContent.cjs");
 const require_tokens = require("../utils/tokens.cjs");
 const require_instrumentation = require("../instrumentation.cjs");
+const require_cache = require("../messages/cache.cjs");
 const require_core = require("../messages/core.cjs");
 const require_ids = require("../messages/ids.cjs");
 const require_prune = require("../messages/prune.cjs");
 const require_budget = require("../messages/budget.cjs");
 const require_events = require("../utils/events.cjs");
 const require_format = require("../messages/format.cjs");
-const require_cache = require("../messages/cache.cjs");
 const require_anthropicToolCache = require("../messages/anthropicToolCache.cjs");
 const require_content = require("../messages/content.cjs");
 const require_tools = require("../messages/tools.cjs");
@@ -27,10 +29,10 @@ const require_toolOutputReferences = require("../tools/toolOutputReferences.cjs"
 const require_events$1 = require("../events.cjs");
 const require_run = require("../utils/run.cjs");
 require("../utils/index.cjs");
-const require_contextOverflowRecovery = require("../llm/contextOverflowRecovery.cjs");
 const require_toolCache = require("../llm/bedrock/toolCache.cjs");
 const require_init = require("../llm/init.cjs");
 const require_invoke = require("../llm/invoke.cjs");
+const require_contextOverflowRecovery = require("../llm/contextOverflowRecovery.cjs");
 const require_toolCache$1 = require("../llm/openrouter/toolCache.cjs");
 const require_LocalCodingTools = require("../tools/local/LocalCodingTools.cjs");
 const require_CloudflareSandboxTools = require("../tools/cloudflare/CloudflareSandboxTools.cjs");
@@ -51,6 +53,7 @@ let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_langgraph = require("@langchain/langgraph");
 let _langchain_core_tools = require("@langchain/core/tools");
 let nanoid = require("nanoid");
+let _langchain_core_errors = require("@langchain/core/errors");
 //#region src/graphs/Graph.ts
 const { AGENT, TOOLS, SUMMARIZE } = require_enum.GraphNodeKeys;
 /** Minimum relative variance before calibrated toolSchemaTokens overrides current value. */
@@ -62,19 +65,6 @@ function createToolHandlerRegistry(source) {
 	registry.register("on_tool_execute", toolHandler);
 	return registry;
 }
-/**
-* Start index of the span post-prune formatters can mutate in place: the
-* trailing tool batch plus its owning AI message (artifact formatting touches
-* every tool result after the last AI tool call; Bedrock rewrites the AI
-* message before a trailing tool result). Capped so the usage-snapshot
-* recount stays constant-cost.
-*/
-function trailingMutationStart(messages) {
-	const MAX_SPAN = 16;
-	let index = messages.length - 1;
-	while (index >= 0 && messages[index]?.getType() === "tool" && messages.length - index < MAX_SPAN) index--;
-	return Math.max(0, Math.min(index, messages.length - 2));
-}
 function getHandlerDispatchedEventKey(eventName, stepId) {
 	return `${eventName}:${stepId}`;
 }
@@ -901,6 +891,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				provider: agentContext.provider,
 				tokenCounter: agentContext.tokenCounter,
 				maxTokens: agentContext.maxContextTokens,
+				maxToolResultChars: agentContext.maxToolResultChars,
 				thinkingEnabled: require_request.isThinkingEnabled(agentContext.provider, agentContext.clientOptions),
 				indexTokenCountMap: agentContext.indexTokenCountMap,
 				contextPruningConfig: agentContext.contextPruningConfig,
@@ -1010,28 +1001,73 @@ var StandardGraph = class StandardGraph extends Graph {
 				}
 			}
 			let finalMessages = messagesToUse;
-			/** Tail snapshot for the dispatch-time usage delta: in-place
-			*  formatters (artifact appends, Bedrock content rewrites, legacy
-			*  string conversion) mutate without changing length or identity —
-			*  capture before they run. Legacy string conversion can also touch
-			*  messages before the tail, so those convertible indices are
-			*  tracked separately (none exist in the common case). */
-			const tailStart = trailingMutationStart(messagesToUse);
-			let preFormatTailTokens = null;
-			let legacyIndices = null;
-			let preFormatLegacyTokens = 0;
+			/**
+			* 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) {
-				preFormatTailTokens = 0;
-				for (const message of messagesToUse.slice(tailStart)) preFormatTailTokens += agentContext.tokenCounter(message);
-				if (agentContext.useLegacyContent) {
-					legacyIndices = [];
-					for (let i = 0; i < tailStart; i++) if (require_content.isLegacyConvertible(messagesToUse[i])) {
-						legacyIndices.push(i);
-						preFormatLegacyTokens += agentContext.tokenCounter(messagesToUse[i]);
+				const sourceIndices = /* @__PURE__ */ new WeakMap();
+				for (let i = 0; i < messages.length; i++) sourceIndices.set(messages[i], i);
+				providerMessageBaseline = messagesToUse.map((message, index) => {
+					const rawTokens = agentContext.tokenCounter(message);
+					const sourceIndex = sourceIndices.get(message);
+					const indexedTokens = sourceIndex != null ? agentContext.indexTokenCountMap[sourceIndex] : void 0;
+					const accountingWeight = indexedTokens != null && Number.isFinite(indexedTokens) && indexedTokens >= 0 ? indexedTokens : rawTokens;
+					if (!providerMessageOrigins.has(message)) providerMessageOrigins.set(message, index);
+					return {
+						rawTokens,
+						accountingWeight
+					};
+				});
+			}
+			const getProviderMessageOriginKey = (message) => {
+				const type = message.getType();
+				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) {
+					for (let i = 0; i < after.length; i++) {
+						const origin = providerMessageOrigins.get(before[i]);
+						if (origin != null && !providerMessageOrigins.has(after[i]) && before[i].getType() === after[i].getType() && !require_format.isSyntheticProviderContextMessage(after[i])) providerMessageOrigins.set(after[i], origin);
 					}
+					return after;
+				}
+				const keyedOrigins = /* @__PURE__ */ new Map();
+				for (const message of before) {
+					const origin = providerMessageOrigins.get(message);
+					const key = getProviderMessageOriginKey(message);
+					if (origin == null || key == null) continue;
+					keyedOrigins.set(key, keyedOrigins.has(key) ? null : origin);
+				}
+				for (const message of after) {
+					if (providerMessageOrigins.has(message) || require_format.isSyntheticProviderContextMessage(message)) continue;
+					const key = getProviderMessageOriginKey(message);
+					const origin = key != null ? keyedOrigins.get(key) : void 0;
+					if (origin != null) providerMessageOrigins.set(message, origin);
 				}
+				return after;
+			};
+			if (agentContext.useLegacyContent) {
+				const before = finalMessages;
+				finalMessages = trackProviderMessageOrigins(before, require_content.formatContentStrings(before));
 			}
-			if (agentContext.useLegacyContent) finalMessages = require_content.formatContentStrings(finalMessages);
+			const maxProviderToolResultChars = agentContext.maxToolResultChars ?? require_truncation.calculateMaxToolResultChars(agentContext.maxContextTokens);
+			const beforeToolStreamProjection = finalMessages;
+			finalMessages = trackProviderMessageOrigins(beforeToolStreamProjection, require_core.projectToolStreamContentForProvider(beforeToolStreamProjection));
+			const beforeToolInputProjection = finalMessages;
+			finalMessages = trackProviderMessageOrigins(beforeToolInputProjection, require_prune.projectToolCallInputs(beforeToolInputProjection, require_prune.calculateMaxToolCallInputChars(agentContext.maxContextTokens)));
 			const lastMessageX = finalMessages.length >= 2 ? finalMessages[finalMessages.length - 2] : null;
 			const lastMessageY = finalMessages.length >= 1 ? finalMessages[finalMessages.length - 1] : null;
 			const anthropicLike = require_llm.isAnthropicLike(agentContext.provider, agentContext.clientOptions);
@@ -1042,34 +1078,186 @@ var StandardGraph = class StandardGraph extends Graph {
 					text: trimmed
 				}] : "";
 			}
+			const localProviderOverflowMeasurements = /* @__PURE__ */ new WeakMap();
+			const measureProviderPayload = (candidate, contextBudgetOverride, forceRawRecount = false) => {
+				const contextBudget = contextBudgetOverride ?? contextUsage?.contextBudget;
+				const effectiveInstructionTokens = contextUsage?.effectiveInstructionTokens ?? (forceRawRecount ? agentContext.instructionTokens : void 0);
+				if (agentContext.tokenCounter == null || contextBudget == null || effectiveInstructionTokens == null) return { fits: true };
+				const availableMessageTokens = Math.max(0, contextBudget - effectiveInstructionTokens);
+				let usageRatio = agentContext.calibrationRatio > 0 ? agentContext.calibrationRatio : 1;
+				if (contextUsage?.calibrationRatio != null && contextUsage.calibrationRatio > 0) usageRatio = contextUsage.calibrationRatio;
+				if (forceRawRecount) usageRatio = Math.max(1, usageRatio);
+				const baselineRemaining = contextUsage?.remainingContextTokens;
+				const accountedMessageTokens = !forceRawRecount && providerMessageBaseline != null && baselineRemaining != null && Number.isFinite(baselineRemaining) ? availableMessageTokens - Math.min(availableMessageTokens, Math.max(0, baselineRemaining)) : void 0;
+				let projectedMessageTokens;
+				if (accountedMessageTokens != null && providerMessageBaseline != null) {
+					const replyPrimerTokens = Math.round(3 * usageRatio);
+					const rawWeights = {};
+					let totalWeight = 0;
+					for (let i = 0; i < providerMessageBaseline.length; i++) {
+						const weight = providerMessageBaseline[i].accountingWeight;
+						rawWeights[i] = weight;
+						totalWeight += weight;
+					}
+					const attributableTokens = totalWeight > 0 ? Math.min(Math.max(0, accountedMessageTokens - replyPrimerTokens), Math.round(totalWeight * usageRatio)) : 0;
+					const apportionedTokens = totalWeight > 0 ? require_tokens.apportionTokenCounts(rawWeights, attributableTokens / totalWeight, attributableTokens) : {};
+					const attributedByOrigin = providerMessageBaseline.map((_, origin) => apportionedTokens[origin] || 0);
+					projectedMessageTokens = Math.max(replyPrimerTokens, accountedMessageTokens - attributableTokens);
+					let newRawTokens = 0;
+					const usedOrigins = /* @__PURE__ */ new Set();
+					for (const message of candidate) {
+						const rawTokens = agentContext.tokenCounter(message);
+						const origin = providerMessageOrigins.get(message);
+						if (origin == null || usedOrigins.has(origin)) {
+							newRawTokens += rawTokens;
+							continue;
+						}
+						usedOrigins.add(origin);
+						projectedMessageTokens += Math.max(0, attributedByOrigin[origin] + Math.round((rawTokens - providerMessageBaseline[origin].rawTokens) * usageRatio));
+					}
+					projectedMessageTokens += Math.round(newRawTokens * usageRatio);
+				} else {
+					let rawTokens = 3;
+					for (const message of candidate) rawTokens += agentContext.tokenCounter(message);
+					projectedMessageTokens = Math.round(rawTokens * usageRatio);
+				}
+				return {
+					fits: projectedMessageTokens <= availableMessageTokens,
+					projectedMessageTokens,
+					availableMessageTokens,
+					contextBudget,
+					effectiveInstructionTokens
+				};
+			};
+			const createProviderPayloadOverflowError = ({ projection, provider, info }) => {
+				const error = new _langchain_core_errors.ContextOverflowError(JSON.stringify({
+					type: "final_context_overflow",
+					info,
+					provider,
+					projectedMessageTokens: projection.projectedMessageTokens,
+					availableMessageTokens: projection.availableMessageTokens
+				}));
+				if (projection.projectedMessageTokens != null && projection.contextBudget != null && projection.effectiveInstructionTokens != null) localProviderOverflowMeasurements.set(error, {
+					contextBudget: projection.contextBudget,
+					estimatedPromptTokens: projection.projectedMessageTokens + projection.effectiveInstructionTokens
+				});
+				return error;
+			};
+			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));
+					if (agentContext.useLegacyContent) {
+						const beforeLegacyFormat = transformed;
+						transformed = trackProviderMessageOrigins(beforeLegacyFormat, require_content.formatContentStrings(beforeLegacyFormat));
+					}
+				}
+				return transformed;
+			};
+			const toolOutputRegistry = this.getOrCreateToolOutputRegistry();
+			const providerRunId = config.configurable?.run_id;
+			const projectProviderReferences = (candidate) => trackProviderMessageOrigins(candidate, require_toolOutputReferences.annotateMessagesForLLM(candidate, toolOutputRegistry, providerRunId));
+			const compactSyntheticProviderContext = (candidate) => {
+				const synthetic = [];
+				for (let i = 0; i < candidate.length; i++) {
+					const message = candidate[i];
+					if (!(message instanceof _langchain_core_messages.HumanMessage) || !require_format.isSyntheticProviderContextMessage(message)) continue;
+					const content = message.content;
+					synthetic.push({
+						index: i,
+						message,
+						chars: require_toolContent.getToolContentCharLength(content)
+					});
+				}
+				if (synthetic.length === 0) return candidate;
+				const buildCandidate = (scale) => {
+					const compacted = [...candidate];
+					for (const { index, message, chars } of synthetic) {
+						const content = require_toolContent.compactToolContent(message.content, Math.floor(chars * scale)).content;
+						compacted[index] = new _langchain_core_messages.HumanMessage({
+							content,
+							id: message.id,
+							name: message.name,
+							additional_kwargs: message.additional_kwargs,
+							response_metadata: message.response_metadata
+						});
+					}
+					return compacted;
+				};
+				let best = buildCandidate(0);
+				if (!measureProviderPayload(best).fits) return candidate;
+				let low = 0;
+				let high = 1;
+				for (let i = 0; i < 12; i++) {
+					const scale = (low + high) / 2;
+					const attempt = buildCandidate(scale);
+					if (measureProviderPayload(attempt).fits) {
+						best = attempt;
+						low = scale;
+					} else high = scale;
+				}
+				return best;
+			};
+			let artifactBaseMessages;
 			if (lastMessageY instanceof _langchain_core_messages.ToolMessage) {
-				if (anthropicLike) require_core.formatAnthropicArtifactContent(finalMessages);
-				else if (require_llm.isOpenAILike(agentContext.provider) && agentContext.provider !== "deepseek" || require_llm.isGoogleLike(agentContext.provider)) require_core.formatArtifactPayload(finalMessages);
+				let artifactCandidate = finalMessages;
+				if (anthropicLike) artifactCandidate = trackProviderMessageOrigins(finalMessages, require_core.projectAnthropicArtifactContent(finalMessages, maxProviderToolResultChars));
+				else if (require_llm.isOpenAILike(agentContext.provider) && agentContext.provider !== "deepseek" || require_llm.isGoogleLike(agentContext.provider)) artifactCandidate = trackProviderMessageOrigins(finalMessages, require_core.projectArtifactPayload(finalMessages, maxProviderToolResultChars));
+				if (artifactCandidate !== finalMessages) {
+					const projection = measureProviderPayload(artifactCandidate);
+					if (projection.fits) {
+						artifactBaseMessages = finalMessages;
+						finalMessages = artifactCandidate;
+					} else require_events.emitAgentLog(config, "warn", "graph", "Artifact payload omitted because it exceeds the remaining context budget", {
+						projectedMessageTokens: projection.projectedMessageTokens,
+						availableMessageTokens: projection.availableMessageTokens
+					}, {
+						runId: this.runId,
+						agentId
+					});
+				}
 			}
-			if (require_request.isThinkingEnabled(agentContext.provider, agentContext.clientOptions))
- /**
-			* Pass `this.startIndex` so the function can distinguish CURRENT-run
-			* AI messages (the agent's own iterations — possibly without a
-			* leading thinking block, which Claude is allowed to skip) from
-			* historical context that genuinely needs the
-			* `[Previous agent context]` placeholder. Without this signal the
-			* function would convert the agent's own in-run tool_use messages,
-			* polluting the next iteration's prompt with a placeholder the
-			* model treats as suspicious injected content.
-			*/
-			finalMessages = require_format.ensureThinkingBlockInMessages(finalMessages, agentContext.provider, config, this.startIndex);
-			/**
-			* A destination that binds no tools is invoked without a tool schema, but
-			* in a multi-agent graph it can still inherit a prior agent's toolUse/
-			* toolResult history. Bedrock's Converse API (and other tool-schema-strict
-			* providers) reject such a request when no top-level toolConfig is sent.
-			* Fold that historical tool content into plain text so the tool-less agent
-			* receives valid, context-preserving messages. Handoff tools count as
-			* bound tools, so a tool-less router mid-handoff is not affected.
-			*/
-			if (toolsForBinding == null || toolsForBinding.length === 0) {
-				finalMessages = require_format.foldToolBlocksForToollessAgent(finalMessages, config);
-				if (agentContext.useLegacyContent) finalMessages = require_content.formatContentStrings(finalMessages);
+			finalMessages = projectProviderReferences(applyProviderMessageTransforms(finalMessages));
+			let finalProjection = measureProviderPayload(finalMessages);
+			if (artifactBaseMessages != null) {
+				if (!finalProjection.fits) {
+					finalMessages = projectProviderReferences(applyProviderMessageTransforms(artifactBaseMessages));
+					finalProjection = measureProviderPayload(finalMessages);
+					require_events.emitAgentLog(config, "warn", "graph", "Artifact payload omitted after final provider formatting exceeded the remaining context budget", {
+						projectedMessageTokens: finalProjection.projectedMessageTokens,
+						availableMessageTokens: finalProjection.availableMessageTokens
+					}, {
+						runId: this.runId,
+						agentId
+					});
+				}
+			}
+			if (!finalProjection.fits) {
+				const compacted = compactSyntheticProviderContext(finalMessages);
+				if (compacted !== finalMessages) {
+					finalMessages = compacted;
+					finalProjection = measureProviderPayload(finalMessages);
+					require_events.emitAgentLog(config, finalProjection.fits ? "warn" : "error", "graph", finalProjection.fits ? "Synthetic provider context compacted to fit the final payload budget" : "Final provider payload still exceeds budget after synthetic context compaction", {
+						projectedMessageTokens: finalProjection.projectedMessageTokens,
+						availableMessageTokens: finalProjection.availableMessageTokens
+					}, {
+						runId: this.runId,
+						agentId
+					});
+				}
 			}
 			const anthropicPromptCacheEnabled = agentContext.provider === "anthropic" && agentContext.clientOptions?.promptCache === true;
 			const openRouterPromptCacheEnabled = agentContext.provider === "openrouter" && agentContext.clientOptions?.promptCache === true;
@@ -1077,7 +1265,11 @@ var StandardGraph = class StandardGraph extends Graph {
 			const providerPromptCacheEnabled = anthropicPromptCacheEnabled || openRouterPromptCacheEnabled || bedrockPromptCacheEnabled;
 			if (anthropicLike && (!agentContext.pruneMessages || finalMessages !== messagesToUse || providerPromptCacheEnabled)) {
 				const beforeSanitize = finalMessages.length;
-				finalMessages = require_prune.sanitizeOrphanToolBlocks(finalMessages);
+				const beforeSanitizeMessages = finalMessages;
+				finalMessages = trackProviderMessageOrigins(beforeSanitizeMessages, require_prune.sanitizeOrphanToolBlocks(beforeSanitizeMessages, (source, clone) => {
+					const origin = providerMessageOrigins.get(source);
+					if (origin != null) providerMessageOrigins.set(clone, origin);
+				}));
 				if (finalMessages.length !== beforeSanitize) require_events.emitAgentLog(config, "warn", "sanitize", "Orphan tool blocks removed", {
 					before: beforeSanitize,
 					after: finalMessages.length,
@@ -1087,11 +1279,34 @@ var StandardGraph = class StandardGraph extends Graph {
 					agentId
 				});
 			}
-			if ((anthropicPromptCacheEnabled || openRouterPromptCacheEnabled) && !agentContext.systemRunnable) finalMessages = require_cache.addTailCacheControl(finalMessages, require_cache.resolvePromptCacheTtl(anthropicPromptCacheEnabled ? agentContext.clientOptions?.promptCacheTtl : agentContext.clientOptions?.promptCacheTtl));
-			else if (bedrockPromptCacheEnabled) {
+			if ((anthropicPromptCacheEnabled || openRouterPromptCacheEnabled) && !agentContext.systemRunnable) {
+				const beforeCacheControl = finalMessages;
+				finalMessages = trackProviderMessageOrigins(beforeCacheControl, require_cache.addTailCacheControl(beforeCacheControl, require_cache.resolvePromptCacheTtl(anthropicPromptCacheEnabled ? agentContext.clientOptions?.promptCacheTtl : agentContext.clientOptions?.promptCacheTtl)));
+			} else if (bedrockPromptCacheEnabled) {
 				const bedrockOptions = agentContext.clientOptions;
-				finalMessages = require_cache.addBedrockTailCacheControl(finalMessages, require_cache.resolveBedrockPromptCacheTtl(bedrockOptions?.promptCacheTtl, bedrockOptions?.model));
+				const beforeCacheControl = finalMessages;
+				finalMessages = trackProviderMessageOrigins(beforeCacheControl, require_cache.addBedrockTailCacheControl(beforeCacheControl, require_cache.resolveBedrockPromptCacheTtl(bedrockOptions?.promptCacheTtl, bedrockOptions?.model)));
 			}
+			const fallbackBaseMessages = finalMessages;
+			const beforeFinalProviderProjection = fallbackBaseMessages;
+			finalMessages = trackProviderMessageOrigins(beforeFinalProviderProjection, require_invoke.projectMessagesForProvider({
+				model: this.overrideModel ?? model,
+				messages: beforeFinalProviderProjection,
+				provider: agentContext.provider,
+				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,
+				provider: agentContext.provider,
+				info: "Provider message formatting exceeded the context budget and no safe synthetic-context compaction could make it fit."
+			}) : void 0;
 			if (agentContext.lastStreamCall != null && agentContext.streamBuffer != null) {
 				const timeSinceLastCall = Date.now() - agentContext.lastStreamCall;
 				if (timeSinceLastCall < agentContext.streamBuffer) await require_run.sleep(Math.ceil((agentContext.streamBuffer - timeSinceLastCall) / 1e3) * 1e3);
@@ -1125,28 +1340,9 @@ var StandardGraph = class StandardGraph extends Graph {
 			}
 			/** Past the empty-prompt guard — a model call is now guaranteed */
 			if (contextUsage != null) {
-				const usageRatio = contextUsage.calibrationRatio != null && contextUsage.calibrationRatio > 0 ? contextUsage.calibrationRatio : 1;
-				if (agentContext.tokenCounter != null && finalMessages.length !== messagesToUse.length) {
-					/** Post-prune formatting restructured the payload (e.g. thinking
-					*  placeholder collapse, orphan drops) — recount so the gauge
-					*  reflects what is actually sent */
-					let rawTokens = 0;
-					for (const message of finalMessages) rawTokens += agentContext.tokenCounter(message);
+				if (finalProjection.projectedMessageTokens != null && finalProjection.availableMessageTokens != null) {
 					contextUsage.breakdown.messageCount = finalMessages.length;
-					if (contextUsage.contextBudget != null && contextUsage.effectiveInstructionTokens != null) contextUsage.remainingContextTokens = Math.max(0, contextUsage.contextBudget - contextUsage.effectiveInstructionTokens - Math.round(rawTokens * usageRatio));
-				} else if (preFormatTailTokens != null && agentContext.tokenCounter != null && contextUsage.remainingContextTokens != null) {
-					/** Same-length formatting can still mutate in place — the trailing
-					*  tool batch (artifacts, Bedrock rewrites) and any legacy-converted
-					*  messages before it — adjust remaining by the calibrated delta */
-					let postFormatTailTokens = 0;
-					for (const message of finalMessages.slice(tailStart)) postFormatTailTokens += agentContext.tokenCounter(message);
-					let formatDelta = postFormatTailTokens - preFormatTailTokens;
-					if (legacyIndices != null && legacyIndices.length > 0) {
-						let postFormatLegacyTokens = 0;
-						for (const index of legacyIndices) postFormatLegacyTokens += agentContext.tokenCounter(finalMessages[index]);
-						formatDelta += postFormatLegacyTokens - preFormatLegacyTokens;
-					}
-					if (formatDelta !== 0) contextUsage.remainingContextTokens = Math.max(0, Math.min(contextUsage.contextBudget ?? Number.MAX_SAFE_INTEGER, contextUsage.remainingContextTokens - Math.round(formatDelta * usageRatio)));
+					contextUsage.remainingContextTokens = Math.max(0, finalProjection.availableMessageTokens - finalProjection.projectedMessageTokens);
 				}
 				require_budget.syncBudgetDerivedFields(contextUsage);
 				/** Awaited so async host handlers receive the pre-invoke snapshot
@@ -1194,6 +1390,7 @@ var StandardGraph = class StandardGraph extends Graph {
 			}
 			const metadata = config.metadata;
 			try {
+				if (preInvokeContextOverflowError != null) throw preInvokeContextOverflowError;
 				result = await require_langfuseRuntimeScope.withLangfuseRuntimeScope(require_langfuseRuntimeScope.resolveLangfuseRuntimeScope({
 					runLangfuse: this.langfuse,
 					langfuseOverlay: agentContext.langfuse
@@ -1223,31 +1420,37 @@ var StandardGraph = class StandardGraph extends Graph {
 				* keeps the original error and one round trip instead of three.
 				*/
 				const estimatedPromptTokens = getEstimatedPromptTokens(contextUsage);
-				/**
-				* A previous correction that left the prompt no smaller proves this
-				* state has nothing left to compact — an emptied message list whose
-				* content rides along in an injected summary, for instance. Measuring
-				* that beats trying to predict every such configuration.
-				*/
-				const recoveryStalled = agentContext.overflowRecoveryStalled(estimatedPromptTokens);
 				const canSummarizeOverflow = agentContext.summarizationEnabled === true && require_recency.splitAtRecencyBoundary(messages, {
 					turns: agentContext.summarizationConfig?.retainRecent?.turns ?? 2,
 					tokens: agentContext.summarizationConfig?.retainRecent?.tokens,
 					tokenCounter: agentContext.tokenCounter
 				}).head.length > 0;
+				const getLocalProviderOverflowMeasurement = (error) => typeof error === "object" && error !== null ? localProviderOverflowMeasurements.get(error) : void 0;
+				const getRecoveryPromptEstimate = (error, fallbackContext) => {
+					const resolvedFallbackContext = fallbackContext ?? require_invoke.getFallbackErrorContext(error);
+					return getLocalProviderOverflowMeasurement(error)?.estimatedPromptTokens ?? (resolvedFallbackContext == null ? estimatedPromptTokens : void 0);
+				};
 				const planRecovery = (error, attributedFallbackContext) => {
-					if (recoveryStalled) return null;
 					/**
 					* 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,
 						provider: fallbackContext?.provider ?? agentContext.provider,
-						maxContextTokens: fallbackContext?.maxContextTokens ?? agentContext.maxContextTokens,
-						estimatedPromptTokens,
+						maxContextTokens: localMeasurement?.contextBudget ?? fallbackContext?.maxContextTokens ?? agentContext.maxContextTokens,
+						estimatedPromptTokens: recoveryPromptEstimate,
 						calibrationRatio: agentContext.calibrationRatio,
 						instructionTokens: agentContext.instructionTokens,
 						canSummarize: agentContext.summarizationEnabled === true,
@@ -1257,20 +1460,23 @@ var StandardGraph = class StandardGraph extends Graph {
 					if (recovery == null) return null;
 					const translatedRecovery = fallbackContext != null ? {
 						...recovery,
-						budgetTokens: minDefined(require_contextOverflowRecovery.getBlindRecoveryBudget(agentContext.maxContextTokens), require_contextOverflowRecovery.translateRecoveryBudget(recovery.budgetTokens, recovery.observedCalibrationRatio ?? 5, agentContext.calibrationRatio)),
+						budgetTokens: minDefined(require_contextOverflowRecovery.getBlindRecoveryBudget(agentContext.maxContextTokens), localMeasurement != null ? recovery.budgetTokens : require_contextOverflowRecovery.translateRecoveryBudget(recovery.budgetTokens, recovery.observedCalibrationRatio ?? 5, agentContext.calibrationRatio)),
 						observedCalibrationRatio: void 0
 					} : recovery;
 					return canSummarizeOverflow || agentContext.tokenCounter != null && translatedRecovery.budgetTokens != null ? translatedRecovery : null;
 				};
 				const recovery = planRecovery(primaryError);
-				if (recovery != null) return this.beginOverflowRecovery({
-					recovery,
-					agentContext,
-					agentId,
-					config,
-					originalToolContent: prunedOriginalToolContent,
-					estimatedPromptTokens
-				});
+				if (recovery != null) {
+					const recoveryPromptEstimate = getRecoveryPromptEstimate(primaryError);
+					return this.beginOverflowRecovery({
+						recovery,
+						agentContext,
+						agentId,
+						config,
+						originalToolContent: prunedOriginalToolContent,
+						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
@@ -1284,7 +1490,7 @@ var StandardGraph = class StandardGraph extends Graph {
 					}), () => require_invoke.tryFallbackProviders({
 						fallbacks,
 						tools: agentContext.tools,
-						messages: finalMessages,
+						messages: fallbackBaseMessages,
 						config: invokeConfig,
 						primaryError,
 						context: this,
@@ -1297,16 +1503,40 @@ var StandardGraph = class StandardGraph extends Graph {
 							provider: agentContext.provider,
 							estimatedPromptTokens: getEstimatedPromptTokens(contextUsage),
 							maxContextTokens: agentContext.maxContextTokens
+						},
+						prepareProviderMessages: ({ model: fallbackModel, messages: fallbackMessages, provider: fallbackProvider, maxContextTokens: fallbackMaxContextTokens, config: fallbackConfig }) => {
+							const projectedFallbackMessages = trackProviderMessageOrigins(fallbackMessages, require_invoke.projectMessagesForProvider({
+								model: fallbackModel,
+								messages: fallbackMessages,
+								provider: fallbackProvider,
+								maxToolResultChars: agentContext.maxToolResultChars ?? require_truncation.calculateMaxToolResultChars(fallbackMaxContextTokens ?? agentContext.maxContextTokens),
+								callOptions: fallbackConfig
+							}));
+							const primaryContextBudget = contextUsage?.contextBudget;
+							const projection = measureProviderPayload(projectedFallbackMessages, fallbackMaxContextTokens == null ? primaryContextBudget : Math.min(primaryContextBudget ?? fallbackMaxContextTokens, fallbackMaxContextTokens), true);
+							if (!projection.fits) throw createProviderPayloadOverflowError({
+								projection,
+								provider: fallbackProvider,
+								info: "Fallback provider message formatting exceeded the context budget before invocation."
+							});
+							return projectedFallbackMessages;
 						}
 					}));
 				} catch (fallbackError) {
 					const overflowCandidates = require_invoke.getFallbackOverflowCandidates(fallbackError);
 					let fallbackRecovery = null;
+					let fallbackRecoveryPromptEstimate;
 					for (const candidate of overflowCandidates) {
 						fallbackRecovery = planRecovery(candidate.error, candidate.context);
-						if (fallbackRecovery != null) break;
+						if (fallbackRecovery != null) {
+							fallbackRecoveryPromptEstimate = getRecoveryPromptEstimate(candidate.error, candidate.context);
+							break;
+						}
+					}
+					if (overflowCandidates.length === 0) {
+						fallbackRecovery = planRecovery(fallbackError);
+						fallbackRecoveryPromptEstimate = getRecoveryPromptEstimate(fallbackError);
 					}
-					if (overflowCandidates.length === 0) fallbackRecovery = planRecovery(fallbackError);
 					if (fallbackRecovery == null) throw fallbackError;
 					return this.beginOverflowRecovery({
 						recovery: fallbackRecovery,
@@ -1314,7 +1544,7 @@ var StandardGraph = class StandardGraph extends Graph {
 						agentId,
 						config,
 						originalToolContent: prunedOriginalToolContent,
-						estimatedPromptTokens
+						estimatedPromptTokens: fallbackRecoveryPromptEstimate
 					});
 				}
 			} finally {
@@ -1690,13 +1920,16 @@ var StandardGraph = class StandardGraph extends Graph {
 		const stepId = graph.toolCallStepIds.get(data.id) ?? "";
 		if (!stepId) return false;
 		const { name, input: args, error } = data;
+		const eventValueLimit = require_truncation.calculateMaxToolResultChars();
+		const errorOutputPrefix = "Error processing tool";
+		const errorDetail = error?.message != null ? `: ${require_toolContent.serializeToolContentBounded(error.message, Math.max(0, eventValueLimit - 21 - 2))}` : "";
 		const runStep = graph.getRunStep(stepId);
 		if (!runStep) return false;
 		const tool_call = {
 			id: data.id,
 			name: name || "",
-			args: typeof args === "string" ? args : JSON.stringify(args),
-			output: `Error processing tool${error?.message != null ? `: ${error.message}` : ""}`,
+			args: require_toolContent.serializeToolContentBounded(args, eventValueLimit),
+			output: `${errorOutputPrefix}${errorDetail}`,
 			progress: 1
 		};
 		const handler = graph.handlerRegistry?.getHandler("on_run_step_completed");