@librechat/agents 3.2.33 → 3.2.35

package/dist/cjs/graphs/Graph.cjs

@@ -4,6 +4,7 @@ const require_callbacks = require("../utils/callbacks.cjs");
 const require_enum = require("../common/enum.cjs");
 require("../common/index.cjs");
 const require_instrumentation = require("../instrumentation.cjs");
+const require_tokens = require("../utils/tokens.cjs");
 const require_core = require("../messages/core.cjs");
 const require_ids = require("../messages/ids.cjs");
 const require_prune = require("../messages/prune.cjs");
@@ -48,6 +49,35 @@ let nanoid = require("nanoid");
 const { AGENT, TOOLS, SUMMARIZE } = require_enum.GraphNodeKeys;
 /** Minimum relative variance before calibrated toolSchemaTokens overrides current value. */
 const CALIBRATION_VARIANCE_THRESHOLD = .15;
+/**
+* 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));
+}
+/**
+* Re-derives the breakdown fields coupled to the calibrated budget math so
+* the snapshot stays internally consistent: the aggregate
+* `instructionTokens`/`availableForMessages` reflect the pruner's effective
+* (calibrated) overhead — component fields remain local estimates — and
+* `messageTokens` mirrors `contextBudget - instructions - remaining`.
+*/
+function syncBudgetDerivedFields(usage) {
+	const { breakdown, contextBudget, effectiveInstructionTokens } = usage;
+	if (effectiveInstructionTokens == null) return;
+	breakdown.instructionTokens = effectiveInstructionTokens;
+	if (contextBudget == null) return;
+	breakdown.availableForMessages = Math.max(0, contextBudget - effectiveInstructionTokens);
+	if (usage.remainingContextTokens == null) return;
+	breakdown.messageTokens = Math.max(0, contextBudget - effectiveInstructionTokens - usage.remainingContextTokens);
+}
 function getHandlerDispatchedEventKey(eventName, stepId) {
 	return `${eventName}:${stepId}`;
 }
@@ -435,11 +465,19 @@ var StandardGraph = class StandardGraph extends Graph {
 	agentContexts = /* @__PURE__ */ new Map();
 	/** Default agent ID to use */
 	defaultAgentId;
-	constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio }) {
+	/**
+	* 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;
+	constructor({ runId, signal, agents, langfuse, tokenCounter, indexTokenCountMap, calibrationRatio, subagentUsageSink }) {
 		super();
 		this.runId = runId;
 		this.signal = signal;
 		this.langfuse = langfuse;
+		this.subagentUsageSink = subagentUsageSink;
 		if (agents.length === 0) throw new Error("At least one agent configuration is required");
 		for (const agentConfig of agents) {
 			const agentContext = require_AgentContext.AgentContext.fromConfig(agentConfig, tokenCounter, indexTokenCountMap);
@@ -748,6 +786,7 @@ var StandardGraph = class StandardGraph extends Graph {
 			if (!config.signal) config.signal = this.signal;
 			this.config = config;
 			let messagesToUse = messages;
+			let contextUsage = null;
 			if (!agentContext.pruneMessages && agentContext.tokenCounter && agentContext.maxContextTokens != null) agentContext.pruneMessages = require_prune.createPruneMessages({
 				startIndex: agentContext.indexTokenCountMap[0] != null ? this.startIndex : 0,
 				provider: agentContext.provider,
@@ -768,7 +807,7 @@ var StandardGraph = class StandardGraph extends Graph {
 				}
 			});
 			if (agentContext.pruneMessages) {
-				const { context, indexTokenCountMap, messagesToRefine, prePruneContextTokens, remainingContextTokens, originalToolContent, calibrationRatio, resolvedInstructionOverhead } = agentContext.pruneMessages({
+				const { context, indexTokenCountMap, messagesToRefine, prePruneContextTokens, remainingContextTokens, originalToolContent, calibrationRatio, resolvedInstructionOverhead, contextBudget, effectiveInstructionTokens } = agentContext.pruneMessages({
 					messages,
 					usageMetadata: agentContext.currentUsage,
 					lastCallUsage: agentContext.lastCallUsage,
@@ -781,9 +820,36 @@ var StandardGraph = class StandardGraph extends Graph {
 					const nonToolOverhead = agentContext.instructionTokens - agentContext.toolSchemaTokens;
 					const calibratedToolTokens = Math.max(0, resolvedInstructionOverhead - nonToolOverhead);
 					const currentToolTokens = agentContext.toolSchemaTokens;
-					if ((currentToolTokens > 0 ? Math.abs(calibratedToolTokens - currentToolTokens) / currentToolTokens : 1) > CALIBRATION_VARIANCE_THRESHOLD) agentContext.toolSchemaTokens = calibratedToolTokens;
+					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 = {
+					runId: this.runId,
+					agentId,
+					breakdown: usageBreakdown,
+					contextBudget,
+					effectiveInstructionTokens,
+					prePruneContextTokens,
+					remainingContextTokens,
+					calibrationRatio: agentContext.calibrationRatio
+				};
+				syncBudgetDerivedFields(contextUsage);
 				if (agentContext.summarizationEnabled === true && Array.isArray(messagesToRefine) && messagesToRefine.length > 0) {
 					const shouldSkip = agentContext.shouldSkipSummarization(messages.length);
 					if (!shouldSkip && require_index$6.shouldTriggerSummarization({
@@ -850,6 +916,27 @@ 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;
+			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]);
+					}
+				}
+			}
 			if (agentContext.useLegacyContent) finalMessages = require_content.formatContentStrings(finalMessages);
 			const lastMessageX = finalMessages.length >= 2 ? finalMessages[finalMessages.length - 2] : null;
 			const lastMessageY = finalMessages.length >= 1 ? finalMessages[finalMessages.length - 1] : null;
@@ -927,6 +1014,36 @@ 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) {
+				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);
+					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)));
+				}
+				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();
 			const invokeMeta = {
 				runId: this.runId,
@@ -1118,6 +1235,7 @@ var StandardGraph = class StandardGraph extends Graph {
 					parentAgentId: agentContext.agentId,
 					langfuse: this.langfuse,
 					tokenCounter: agentContext.tokenCounter,
+					usageSink: this.subagentUsageSink,
 					maxDepth: effectiveSubagentDepth,
 					createChildGraph: (input) => {
 						const childGraph = new StandardGraph(input);