@librechat/agents 3.7.22 → 3.8.1

package/dist/esm/graphs/Graph.mjs

@@ -12,13 +12,15 @@ import { shouldTraceToolNodeForLangfuse } from "../langfuseToolOutputTracing.mjs
 import { getToolContentCharLength, serializeToolContentBounded } from "../utils/toolContent.mjs";
 import { stampSyntheticProviderMessage } from "../messages/provenance.mjs";
 import { addBedrockTailCacheControl, addTailCacheControl, cloneMessage, resolveBedrockPromptCacheTtl, resolvePromptCacheTtl } from "../messages/cache.mjs";
+import { providerRequiresStrictAlternation } from "../llm/providerRegistry.mjs";
+import "../llm/providers.mjs";
+import { createToolHistoryPreparation } from "../messages/toolHistoryProjection.mjs";
 import { convertMessagesToContent, projectAnthropicArtifactContent, projectArtifactPayload } from "../messages/core.mjs";
 import { resolveMaxSeals } from "../llm/preempt.mjs";
-import { createLangfuseHandler, createLangfuseTraceMetadata, disposeLangfuseHandler, isLangfuseCallbackHandler } from "../langfuse.mjs";
 import { appendCallbacks, findCallback } from "../utils/callbacks.mjs";
+import { createLangfuseHandler, createLangfuseTraceMetadata, disposeLangfuseHandler, isLangfuseCallbackHandler } from "../langfuse.mjs";
 import { applyGraphRuntimeConfig } from "./applyGraphRuntimeConfig.mjs";
 import { apportionTokenCounts } from "../utils/tokens.mjs";
-import { providerRequiresStrictAlternation } from "../llm/providerRegistry.mjs";
 import { isAnthropicLike, isGoogleLike, isOpenAILike } from "../utils/llm.mjs";
 import { executeHooks } from "../hooks/executeHooks.mjs";
 import "../hooks/index.mjs";
@@ -27,15 +29,15 @@ import { initializeLangfuseTracing } from "../instrumentation.mjs";
 import { isThinkingEnabled } from "../llm/request.mjs";
 import { getMessageId } from "../messages/ids.mjs";
 import { createPruneMessages, projectToolMessagesForProvider, sanitizeOrphanToolBlocks } from "../messages/prune.mjs";
+import { emitAgentLog, safeDispatchCustomEvent } from "../utils/events.mjs";
 import { syncBudgetDerivedFields } from "../messages/budget.mjs";
 import { formatContentStrings } from "../messages/content.mjs";
-import { emitAgentLog, safeDispatchCustomEvent } from "../utils/events.mjs";
 import { compactSyntheticProviderContextMessage, ensureThinkingBlockInMessages, foldToolBlocksForToollessAgent, isSyntheticProviderContextMessage } from "../messages/format.mjs";
 import { makeIsDeferred } from "../messages/anthropicToolCache.mjs";
 import { extractToolDiscoveries } from "../messages/tools.mjs";
 import { coalesceAdjacentUserTurns } from "../messages/alternation.mjs";
 import { appendPredecessorHandoffCue } from "../messages/handoffCue.mjs";
-import { messagesStateReducer as messagesStateReducer$1 } from "../messages/reducer.mjs";
+import { createRemoveAllMessage, messagesStateReducer as messagesStateReducer$1 } from "../messages/reducer.mjs";
 import { resolveIntraTurnRetainTokens, splitAtRecencyBoundary } from "../messages/recency.mjs";
 import { getMessageCreationContentMetadata, splitAssistantTextContentByPhase } from "../messages/assistantPhase.mjs";
 import "../messages/index.mjs";
@@ -51,8 +53,7 @@ import { isGraphSubagentConfig, normalizeSubagentConfigEntries } from "../tools/
 import { DEFAULT_SUBAGENT_DESCRIPTION, SubagentExecutor } from "../tools/subagent/SubagentExecutor.mjs";
 import "../tools/subagent/index.mjs";
 import { getBlindRecoveryBudget, planContextOverflowRecovery, translateRecoveryBudget } from "../llm/contextOverflowRecovery.mjs";
-import "../llm/providers.mjs";
-import { prepareProviderRequest } from "../llm/prepareProviderRequest.mjs";
+import { prepareProviderRequest, usesNativeOpenAIResponses } from "../llm/prepareProviderRequest.mjs";
 import { getTruncationStopReason } from "../llm/truncation.mjs";
 import { initializeModel } from "../llm/init.mjs";
 import { attemptInvoke, getFallbackErrorContext, getFallbackOverflowCandidates, tryFallbackProviders } from "../llm/invoke.mjs";
@@ -65,6 +66,7 @@ import { ToolNode, toolsCondition } from "../tools/ToolNode.mjs";
 import { createContextPressureMeter } from "../llm/contextPressureMeter.mjs";
 import { prepareToolsForPromptCache } from "../llm/promptCacheTools.mjs";
 import { buildSubagentToolParams } from "../tools/SubagentTool.mjs";
+import { ManualSummarizationSkippedError } from "../summarization/shared.mjs";
 import { shouldTriggerSummarization } from "../summarization/index.mjs";
 import { createSummarizeNode } from "../summarization/node.mjs";
 import { createSchemaOnlyTools } from "../tools/schema.mjs";
@@ -574,6 +576,7 @@ var StandardGraph = class StandardGraph extends Graph {
 	preemptSealInFlight = false;
 	preemptIncomplete = false;
 	outputTruncatedIncomplete = false;
+	summarizeOnlyAgentId;
 	preemptHaltReason;
 	pendingPreemptReturn = /* @__PURE__ */ new Set();
 	preemptRestartPending = /* @__PURE__ */ new Set();
@@ -598,6 +601,7 @@ var StandardGraph = class StandardGraph extends Graph {
 		if (agents.length === 0) throw new Error("At least one agent configuration is required");
 		for (const agentConfig of agents) {
 			const agentContext = AgentContext.fromConfig(agentConfig, tokenCounter, indexTokenCountMap, toolExecution);
+			if (agentConfig.summarizeOnly === true) this.summarizeOnlyAgentId ??= agentContext.agentId;
 			if (calibrationRatio != null && calibrationRatio > 0) agentContext.calibrationRatio = calibrationRatio;
 			let restoredFadingTier;
 			if (fadingTiers != null && Object.prototype.hasOwnProperty.call(fadingTiers, agentConfig.agentId)) restoredFadingTier = fadingTiers[agentConfig.agentId];
@@ -605,7 +609,14 @@ var StandardGraph = class StandardGraph extends Graph {
 			if (isFadingTier(restoredFadingTier)) agentContext.fadingTier = { ...restoredFadingTier };
 			this.agentContexts.set(agentConfig.agentId, agentContext);
 		}
-		this.defaultAgentId = agents[0].agentId;
+		this.defaultAgentId = this.summarizeOnlyAgentId ?? agents[0].agentId;
+	}
+	propagateManualCompaction(result) {
+		if (this.summarizeOnlyAgentId == null || result.manualSummary == null || result.manualSummary.length === 0) return result;
+		return {
+			...result,
+			messages: [createRemoveAllMessage(), ...result.messages]
+		};
 	}
 	startFreshLangfuseExecution() {
 		this.langfuseTraceAnchor = {};
@@ -1279,6 +1290,32 @@ var StandardGraph = class StandardGraph extends Graph {
 			isDeferred: makeIsDeferred(agentContext.getEffectiveToolDefinitions())
 		});
 	}
+	async summarizeOnlyStep({ agentContext, agentId, messageCount, contextUsage, config }) {
+		if (agentContext.summarizeOnly !== true) return null;
+		const meta = {
+			runId: this.runId,
+			agentId
+		};
+		if (agentContext.claimManualSummarization()) {
+			if (agentContext.summarizationEnabled !== true) throw new ManualSummarizationSkippedError("disabled", "Compaction skipped: summarization is not enabled for this agent");
+			emitAgentLog(config, "info", "graph", "Manual summarization requested", {
+				totalMessages: messageCount,
+				summaryVersion: agentContext.summaryVersion + 1
+			}, meta);
+			agentContext.markSummarizationTriggered(messageCount);
+			return {
+				summarizationRequest: {
+					remainingContextTokens: contextUsage?.remainingContextTokens ?? 0,
+					agentId: agentId || agentContext.agentId,
+					reason: "manual"
+				},
+				manualSummary: ""
+			};
+		}
+		if (contextUsage != null) await safeDispatchCustomEvent("on_context_usage", contextUsage, config);
+		emitAgentLog(config, "debug", "graph", "Summarize-only run complete — ending without a model call", { summaryVersion: agentContext.summaryVersion }, meta);
+		return { messages: [] };
+	}
 	createCallModel(agentId = "default") {
 		return async (state, config) => {
 			const attemptBreaker = this.breakerAbort;
@@ -1292,13 +1329,6 @@ var StandardGraph = class StandardGraph extends Graph {
 			const { messages } = state;
 			const discoveredNames = extractToolDiscoveries(messages);
 			if (discoveredNames.length > 0) agentContext.markToolsAsDiscovered(discoveredNames);
-			const toolsForBinding = this.getPreparedToolsForBinding(agentContext);
-			let model = this.overrideModel ?? initializeModel({
-				tools: toolsForBinding,
-				provider: agentContext.provider,
-				clientOptions: agentContext.clientOptions
-			});
-			if (agentContext.systemRunnable) model = agentContext.systemRunnable.pipe(model).withConfig({ runName: AGENT_MODEL_CALL_RUN_NAME });
 			if (agentContext.tokenCalculationPromise) await agentContext.tokenCalculationPromise;
 			if (!config.signal) config.signal = this.signal;
 			this.config = config;
@@ -1365,6 +1395,14 @@ var StandardGraph = class StandardGraph extends Graph {
 					calibrationRatio: agentContext.calibrationRatio
 				};
 				syncBudgetDerivedFields(contextUsage);
+				const summarizeOnlyStep = await this.summarizeOnlyStep({
+					agentContext,
+					agentId,
+					messageCount: messages.length,
+					contextUsage,
+					config
+				});
+				if (summarizeOnlyStep != null) return summarizeOnlyStep;
 				if (agentContext.summarizationEnabled === true && Array.isArray(messagesToRefine) && messagesToRefine.length > 0) {
 					const shouldSkip = agentContext.summarizationExhausted || agentContext.shouldSkipSummarization(messages.length);
 					if (!shouldSkip && shouldTriggerSummarization({
@@ -1406,9 +1444,27 @@ var StandardGraph = class StandardGraph extends Graph {
 						agentId
 					});
 				}
+			} else {
+				const summarizeOnlyStep = await this.summarizeOnlyStep({
+					agentContext,
+					agentId,
+					messageCount: messages.length,
+					contextUsage: null,
+					config
+				});
+				if (summarizeOnlyStep != null) return summarizeOnlyStep;
 			}
+			const toolsForBinding = this.getPreparedToolsForBinding(agentContext);
+			let model = this.overrideModel ?? initializeModel({
+				tools: toolsForBinding,
+				provider: agentContext.provider,
+				clientOptions: agentContext.clientOptions
+			});
+			if (agentContext.systemRunnable) model = agentContext.systemRunnable.pipe(model).withConfig({ runName: AGENT_MODEL_CALL_RUN_NAME });
 			let finalMessages = messagesToUse;
+			const fallbackBaseMessages = messagesToUse;
 			const contextPressure = createContextPressureMeter({
+				provider: agentContext.provider,
 				tokenCounter: agentContext.tokenCounter,
 				tokenCountCache: agentContext.contextPressureTokenCounts,
 				sourceMessages: messages,
@@ -1419,13 +1475,14 @@ var StandardGraph = class StandardGraph extends Graph {
 				calibrationRatio: agentContext.calibrationRatio
 			});
 			const trackProviderMessageOrigins = contextPressure.trackProjection;
+			const toolHistory = createToolHistoryPreparation();
 			if (agentContext.useLegacyContent) {
 				const before = finalMessages;
 				finalMessages = trackProviderMessageOrigins(before, formatContentStrings(before));
 			}
 			const maxProviderToolResultChars = agentContext.maxToolResultChars ?? calculateMaxToolResultChars(agentContext.maxContextTokens);
 			const beforeToolInputProjection = finalMessages;
-			finalMessages = trackProviderMessageOrigins(beforeToolInputProjection, projectToolMessagesForProvider(beforeToolInputProjection, calculateMaxToolCallInputChars(agentContext.maxContextTokens)));
+			finalMessages = trackProviderMessageOrigins(beforeToolInputProjection, projectToolMessagesForProvider(beforeToolInputProjection, calculateMaxToolCallInputChars(agentContext.maxContextTokens), agentContext.provider));
 			const lastMessageX = finalMessages.length >= 2 ? finalMessages[finalMessages.length - 2] : null;
 			const lastMessageY = finalMessages.length >= 1 ? finalMessages[finalMessages.length - 1] : null;
 			const anthropicLike = isAnthropicLike(agentContext.provider, agentContext.clientOptions);
@@ -1455,21 +1512,26 @@ var StandardGraph = class StandardGraph extends Graph {
 				});
 				return error;
 			};
-			const applyProviderMessageTransforms = (candidate) => {
+			const applyProviderMessageTransforms = (candidate, serving) => {
+				const provider = serving?.provider ?? agentContext.provider;
+				const clientOptions = serving == null ? agentContext.clientOptions : serving.clientOptions;
+				const callConfig = serving == null ? config : serving.config;
+				const history = serving?.history ?? toolHistory;
+				const servingModel = serving?.model ?? this.overrideModel ?? model;
 				let transformed = candidate;
-				if (isThinkingEnabled(agentContext.provider, agentContext.clientOptions)) {
+				if (isThinkingEnabled(provider, clientOptions)) {
 					const before = transformed;
-					transformed = trackProviderMessageOrigins(before, ensureThinkingBlockInMessages(before, agentContext.provider, config, this.startIndex));
+					transformed = trackProviderMessageOrigins(before, ensureThinkingBlockInMessages(before, provider, callConfig, this.startIndex, history));
 				}
 				if (toolsForBinding == null || toolsForBinding.length === 0) {
 					const before = transformed;
-					transformed = trackProviderMessageOrigins(before, foldToolBlocksForToollessAgent(before, config));
+					transformed = trackProviderMessageOrigins(before, foldToolBlocksForToollessAgent(before, callConfig, usesNativeOpenAIResponses(servingModel, provider, callConfig), history));
 					if (agentContext.useLegacyContent) {
 						const beforeLegacyFormat = transformed;
 						transformed = trackProviderMessageOrigins(beforeLegacyFormat, formatContentStrings(beforeLegacyFormat));
 					}
 				}
-				if (isAnthropicLike(agentContext.provider, agentContext.clientOptions)) {
+				if (isAnthropicLike(provider, clientOptions)) {
 					const before = transformed;
 					transformed = trackProviderMessageOrigins(before, appendPredecessorHandoffCue(before, (message) => this.isRunProducedMessage(message)));
 				}
@@ -1478,7 +1540,7 @@ var StandardGraph = class StandardGraph extends Graph {
 			const toolOutputRegistry = this.getOrCreateToolOutputRegistry();
 			const providerRunId = config.configurable?.run_id;
 			const projectProviderReferences = (candidate) => trackProviderMessageOrigins(candidate, annotateMessagesForLLM(candidate, toolOutputRegistry, providerRunId));
-			const compactSyntheticProviderContext = (candidate) => {
+			const compactSyntheticProviderContext = (candidate, measure = measureProviderPayload) => {
 				const synthetic = [];
 				for (let i = 0; i < candidate.length; i++) {
 					const message = candidate[i];
@@ -1497,24 +1559,37 @@ var StandardGraph = class StandardGraph extends Graph {
 					return compacted;
 				};
 				let best = buildCandidate(0);
-				if (!measureProviderPayload(best).fits) return candidate;
+				if (!measure(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) {
+					if (measure(attempt).fits) {
 						best = attempt;
 						low = scale;
 					} else high = scale;
 				}
 				return best;
 			};
+			const projectServingArtifacts = (candidate, provider, clientOptions, maxChars) => {
+				if (!(candidate[candidate.length - 1] instanceof ToolMessage)) return candidate;
+				if (isAnthropicLike(provider, clientOptions)) return trackProviderMessageOrigins(candidate, projectAnthropicArtifactContent(candidate, maxChars));
+				if (isOpenAILike(provider) && provider !== "deepseek" || isGoogleLike(provider)) return trackProviderMessageOrigins(candidate, projectArtifactPayload(candidate, maxChars));
+				return candidate;
+			};
+			const applyServingTailCache = (candidate, provider, clientOptions, systemOwnsTail = false) => {
+				if (provider === "bedrock") {
+					const options = clientOptions;
+					return options?.promptCache === true ? trackProviderMessageOrigins(candidate, addBedrockTailCacheControl(candidate, resolveBedrockPromptCacheTtl(options.promptCacheTtl, options.model))) : candidate;
+				}
+				if (systemOwnsTail || provider !== "anthropic" && provider !== "openrouter") return candidate;
+				const options = clientOptions;
+				return options?.promptCache === true ? trackProviderMessageOrigins(candidate, addTailCacheControl(candidate, resolvePromptCacheTtl(options.promptCacheTtl))) : candidate;
+			};
 			let artifactBaseMessages;
 			if (lastMessageY instanceof ToolMessage) {
-				let artifactCandidate = finalMessages;
-				if (anthropicLike) artifactCandidate = trackProviderMessageOrigins(finalMessages, projectAnthropicArtifactContent(finalMessages, maxProviderToolResultChars));
-				else if (isOpenAILike(agentContext.provider) && agentContext.provider !== "deepseek" || isGoogleLike(agentContext.provider)) artifactCandidate = trackProviderMessageOrigins(finalMessages, projectArtifactPayload(finalMessages, maxProviderToolResultChars));
+				const artifactCandidate = projectServingArtifacts(finalMessages, agentContext.provider, agentContext.clientOptions, maxProviderToolResultChars);
 				if (artifactCandidate !== finalMessages) {
 					const projection = measureProviderPayload(artifactCandidate);
 					if (projection.fits) {
@@ -1581,16 +1656,8 @@ var StandardGraph = class StandardGraph extends Graph {
 					agentId
 				});
 			}
-			if ((anthropicPromptCacheEnabled || openRouterPromptCacheEnabled) && !agentContext.systemRunnable) {
-				const beforeCacheControl = finalMessages;
-				finalMessages = trackProviderMessageOrigins(beforeCacheControl, addTailCacheControl(beforeCacheControl, resolvePromptCacheTtl(anthropicPromptCacheEnabled ? agentContext.clientOptions?.promptCacheTtl : agentContext.clientOptions?.promptCacheTtl)));
-			} else if (bedrockPromptCacheEnabled) {
-				const bedrockOptions = agentContext.clientOptions;
-				const beforeCacheControl = finalMessages;
-				finalMessages = trackProviderMessageOrigins(beforeCacheControl, addBedrockTailCacheControl(beforeCacheControl, resolveBedrockPromptCacheTtl(bedrockOptions?.promptCacheTtl, bedrockOptions?.model)));
-			}
-			const fallbackBaseMessages = finalMessages;
-			const beforeFinalProviderProjection = fallbackBaseMessages;
+			finalMessages = applyServingTailCache(finalMessages, agentContext.provider, agentContext.clientOptions, agentContext.systemRunnable != null);
+			const beforeFinalProviderProjection = finalMessages;
 			const preparedRequest = prepareProviderRequest({
 				model: this.overrideModel ?? model,
 				messages: beforeFinalProviderProjection,
@@ -1598,6 +1665,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				context: this,
 				config,
 				maxToolResultChars: maxProviderToolResultChars,
+				toolHistory,
 				measure: (preparedMessages) => measureProviderPayload(trackProviderMessageOrigins(beforeFinalProviderProjection, preparedMessages))
 			});
 			finalMessages = preparedRequest.messages;
@@ -1643,7 +1711,9 @@ var StandardGraph = class StandardGraph extends Graph {
 					contextUsage.breakdown.messageCount = finalMessages.length;
 					contextUsage.remainingContextTokens = Math.max(0, finalProjection.availableMessageTokens - finalProjection.projectedMessageTokens);
 				}
-				syncBudgetDerivedFields(contextUsage);
+				contextUsage.breakdown.toolMessageTokens = finalProjection.toolMessageTokens;
+				contextUsage.breakdown.toolMessageTokenCounts = finalProjection.toolMessageTokenCounts;
+				syncBudgetDerivedFields(contextUsage, void 0, void 0, config, agentContext.provider, finalProjection.toolMessageUsageError);
 				await safeDispatchCustomEvent("on_context_usage", contextUsage, config);
 			}
 			const invokeStart = Date.now();
@@ -1731,6 +1801,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				const estimatedPromptTokens = getEstimatedPromptTokens(contextUsage);
 				const recencyTokenCounter = agentContext.contextPressureTokenCounts?.count ?? agentContext.tokenCounter;
 				const canSummarizeOverflow = agentContext.summarizationEnabled === true && splitAtRecencyBoundary(messages, {
+					provider: agentContext.provider,
 					turns: agentContext.summarizationConfig?.retainRecent?.turns ?? 2,
 					tokens: agentContext.summarizationConfig?.retainRecent?.tokens,
 					tokenCounter: recencyTokenCounter,
@@ -1799,32 +1870,68 @@ var StandardGraph = class StandardGraph extends Graph {
 							estimatedPromptTokens: getEstimatedPromptTokens(contextUsage),
 							maxContextTokens: agentContext.maxContextTokens
 						},
-						prepareProviderRequest: ({ model: fallbackModel, messages: fallbackMessages, provider: fallbackProvider, maxContextTokens: fallbackMaxContextTokens, config: fallbackConfig }) => {
+						prepareProviderRequest: ({ model: fallbackModel, messages: fallbackMessages, provider: fallbackProvider, clientOptions: fallbackClientOptions, maxContextTokens: fallbackMaxContextTokens, config: fallbackConfig }) => {
+							const fallbackToolHistory = createToolHistoryPreparation();
 							const fallbackToolResultChars = agentContext.maxToolResultChars ?? calculateMaxToolResultChars(fallbackMaxContextTokens ?? agentContext.maxContextTokens);
 							const primaryContextBudget = contextUsage?.contextBudget;
 							const fallbackContextBudget = fallbackMaxContextTokens == null ? primaryContextBudget : Math.min(primaryContextBudget ?? fallbackMaxContextTokens, fallbackMaxContextTokens);
-							const preparedFallbackRequest = prepareProviderRequest({
-								model: fallbackModel,
-								messages: fallbackMessages,
-								provider: fallbackProvider,
-								context: this,
-								config: fallbackConfig,
-								maxToolResultChars: fallbackToolResultChars,
-								measure: (preparedMessages) => measureProviderPayload(trackProviderMessageOrigins(fallbackMessages, preparedMessages), {
-									contextBudget: fallbackContextBudget,
-									forceRawRecount: true
-								})
-							});
-							const projection = preparedFallbackRequest.measurement ?? measureProviderPayload(preparedFallbackRequest.messages, {
+							const measureFallback = (candidate) => measureProviderPayload(candidate, {
 								contextBudget: fallbackContextBudget,
 								forceRawRecount: true
 							});
+							const source = agentContext.useLegacyContent ? trackProviderMessageOrigins(fallbackMessages, formatContentStrings(fallbackMessages)) : fallbackMessages;
+							const boundedSource = trackProviderMessageOrigins(source, projectToolMessagesForProvider(source, calculateMaxToolCallInputChars(fallbackMaxContextTokens), fallbackProvider));
+							const artifactSource = projectServingArtifacts(boundedSource, fallbackProvider, fallbackClientOptions, fallbackToolResultChars);
+							const transformFallback = (candidate) => applyProviderMessageTransforms(candidate, {
+								provider: fallbackProvider,
+								clientOptions: fallbackClientOptions,
+								model: fallbackModel,
+								config: fallbackConfig,
+								history: fallbackToolHistory
+							});
+							const prepareFallback = (candidate) => {
+								const cached = applyServingTailCache(isAnthropicLike(fallbackProvider, fallbackClientOptions) ? trackProviderMessageOrigins(candidate, sanitizeOrphanToolBlocks(candidate, (original, clone) => contextPressure.trackClone(original, clone))) : candidate, fallbackProvider, fallbackClientOptions);
+								let projection;
+								const request = prepareProviderRequest({
+									model: fallbackModel,
+									messages: cached,
+									provider: fallbackProvider,
+									context: this,
+									config: fallbackConfig,
+									maxToolResultChars: fallbackToolResultChars,
+									toolHistory: fallbackToolHistory,
+									measure: (prepared) => {
+										projection = measureFallback(trackProviderMessageOrigins(cached, prepared));
+										return projection;
+									}
+								});
+								if (projection == null) throw new Error("Fallback preparation did not measure its payload");
+								return {
+									request,
+									projection
+								};
+							};
+							let servingFallbackMessages = transformFallback(artifactSource);
+							let preparedFallbackRequest = prepareFallback(servingFallbackMessages);
+							let projection = preparedFallbackRequest.projection;
+							if (!projection.fits && artifactSource !== boundedSource) {
+								servingFallbackMessages = transformFallback(boundedSource);
+								preparedFallbackRequest = prepareFallback(servingFallbackMessages);
+								projection = preparedFallbackRequest.projection;
+							}
+							if (!projection.fits) {
+								const compacted = compactSyntheticProviderContext(servingFallbackMessages, (candidate) => prepareFallback(candidate).projection);
+								if (compacted !== servingFallbackMessages) {
+									preparedFallbackRequest = prepareFallback(compacted);
+									projection = preparedFallbackRequest.projection;
+								}
+							}
 							if (!projection.fits) throw createProviderPayloadOverflowError({
 								projection,
 								provider: fallbackProvider,
 								info: "Fallback provider message formatting exceeded the context budget before invocation."
 							});
-							return preparedFallbackRequest;
+							return preparedFallbackRequest.request;
 						}
 					}));
 				} catch (fallbackError) {
@@ -2161,8 +2268,11 @@ var StandardGraph = class StandardGraph extends Graph {
 		const invokeWithRunStepState = async (state, config, invoke) => {
 			this.config = config;
 			this.restoreRunStepResumeState(state.runStepState);
+			const result = await invoke();
+			const clearsManualSummary = this.summarizeOnlyAgentId == null && typeof state.manualSummary === "string" && state.manualSummary.length > 0;
 			return {
-				...await invoke(),
+				...result,
+				...clearsManualSummary ? { manualSummary: "" } : {},
 				runStepState: this.createRunStepResumeState()
 			};
 		};
@@ -2170,6 +2280,7 @@ var StandardGraph = class StandardGraph extends Graph {
 			this.config = config;
 			if (this.pendingPreemptReturn.delete(agentId)) return agentNode;
 			if (state.summarizationRequest != null) return summarizeNode;
+			if (this.summarizeOnlyAgentId != null) return END;
 			const decision = toolsCondition(state, toolNode, this.invokedToolIds);
 			if (decision === END) {
 				const { messages } = state;
@@ -2190,6 +2301,10 @@ var StandardGraph = class StandardGraph extends Graph {
 				reducer: (_, b) => b,
 				default: () => void 0
 			}),
+			manualSummary: Annotation({
+				reducer: (_, b) => b,
+				default: () => void 0
+			}),
 			runStepState: this.createRunStepStateAnnotation()
 		});
 		const readChargeCredits = () => this.streamLimitChargeCredits;
@@ -2280,7 +2395,7 @@ var StandardGraph = class StandardGraph extends Graph {
 	createWorkflow() {
 		this.hasCompiledCheckpointer = this.compileOptions?.checkpointer != null;
 		const agentNode = this.createAgentNode(this.defaultAgentId);
-		return new StateGraph(Annotation.Root({
+		const StateAnnotation = Annotation.Root({
 			messages: Annotation({
 				reducer: (a, b) => {
 					if (!this.messages.length && !this.hasRestoredCheckpointMessages) this.startIndex = a.length + b.length;
@@ -2290,8 +2405,14 @@ var StandardGraph = class StandardGraph extends Graph {
 				},
 				default: () => []
 			}),
+			manualSummary: Annotation({
+				reducer: (_, b) => b,
+				default: () => void 0
+			}),
 			runStepState: this.createRunStepStateAnnotation()
-		})).addNode(this.defaultAgentId, agentNode, { ends: [END] }).addEdge(START, this.defaultAgentId).compile({
+		});
+		const compactingAgentNode = async (state, config) => this.propagateManualCompaction(await agentNode.invoke(state, config));
+		return new StateGraph(StateAnnotation).addNode(this.defaultAgentId, this.summarizeOnlyAgentId != null ? compactingAgentNode : agentNode, { ends: [END] }).addEdge(START, this.defaultAgentId).compile({
 			...this.compileOptions,
 			name: STANDARD_GRAPH_RUN_NAME
 		});