@librechat/agents 3.3.0 → 3.3.1

package/dist/cjs/utils/errors.cjs

@@ -1,41 +1,256 @@
+let _langchain_core_errors = require("@langchain/core/errors");
 //#region src/utils/errors.ts
 /**
-* Context overflow error detection utilities.
+* Context overflow error detection.
 *
-* Identifies provider-specific error messages that indicate the request
-* exceeded the model's context window. Used by the overflow recovery loop
-* to decide whether to retry with truncation/compaction vs. propagating
-* the error.
+* Providers disagree on how they report "your input is bigger than I can
+* take" — the class thrown, the HTTP status, whether numbers are reported,
+* and even whether it arrives as an HTTP error at all. Every pattern below
+* was captured from a live over-limit request (see
+* `src/scripts/context-overflow-probe.ts` and
+* `docs/context-overflow-signatures.md`); nothing here is guessed.
+*
+* Consumed by the graph's overflow recovery loop, which converts a detection
+* into a forced summarization pass instead of surfacing the error.
+*/
+/**
+* Fraction of the believed budget the prompt must reach before an ambiguous
+* provider error is read as overflow. Well above normal traffic, low enough to
+* catch the case the budget itself was miscalibrated.
 */
+const CONTEXT_PRESSURE_RATIO = .8;
 /**
-* Exact phrases that definitively indicate a context overflow error.
-* These are returned by various LLM providers when the prompt is too large.
+* Ordered most-specific first; the first match wins. Patterns that capture
+* both numbers come before the bare-phrase fallbacks for the same provider so
+* a recoverable error still yields the numbers when the provider reported
+* them.
 */
-const CONTEXT_OVERFLOW_PHRASES = [
-	"request_too_large",
-	"context length exceeded",
-	"maximum context length",
-	"prompt is too long",
-	"exceeds model context window",
-	"exceeds the model",
-	"too large for model",
-	"context_length_exceeded",
-	"max_tokens",
-	"token limit",
-	"input too long",
-	"payload too large",
-	"content_too_large"
+const OVERFLOW_PATTERNS = [
+	(
+	/** Anthropic, and Bedrock's passthrough of the same upstream. */
+	{
+		kind: "context_window",
+		re: /prompt is too long:\s*(\d+)\s*tokens\s*>\s*(\d+)\s*maximum/i,
+		requestedGroup: 1,
+		limitGroup: 2,
+		requestedIsPromptOnly: true
+	}),
+	(
+	/**
+	* OpenAI's own wording, which measures the messages and nothing else.
+	* Ordered ahead of the shared sentence below so the prompt-only reading is
+	* preferred when OpenAI is the one answering.
+	*/
+	{
+		kind: "context_window",
+		re: /maximum context length is\s*(\d+)\s*tokens\.\s*however,\s*your messages resulted in\s*(\d+)/i,
+		limitGroup: 1,
+		requestedGroup: 2,
+		requestedIsPromptOnly: true
+	}),
+	(
+	/**
+	* OpenRouter (`you requested about`) and DeepSeek (`you requested`). Their
+	* total folds in the completion allowance — both then break it down in
+	* parentheses, which `PROMPT_ONLY_BREAKDOWN_RE` recovers.
+	*/
+	{
+		kind: "context_window",
+		re: /maximum context length is\s*(\d+)\s*tokens\.\s*however,\s*you requested(?:\s*about)?\s*(\d+)/i,
+		limitGroup: 1,
+		requestedGroup: 2
+	}),
+	(
+	/**
+	* xAI. Says "prompt length" rather than "context length", and does not say
+	* whether the count it quotes includes the completion allowance — so it is
+	* not trusted as a prompt measurement.
+	*/
+	{
+		kind: "context_window",
+		re: /maximum prompt length is\s*(\d+)\s*(?:tokens\s*)?but the request contains\s*(\d+)\s*tokens/i,
+		limitGroup: 1,
+		requestedGroup: 2
+	}),
+	(
+	/** Mistral. */
+	{
+		kind: "context_window",
+		re: /prompt contains\s*(\d+)\s*tokens[^.]*?too large for model with\s*(\d+)\s*maximum context length/i,
+		requestedGroup: 1,
+		limitGroup: 2,
+		requestedIsPromptOnly: true
+	}),
+	(
+	/** Google Gemini / Vertex. Reports the ceiling only. */
+	{
+		kind: "context_window",
+		re: /input token count exceeds the maximum number of tokens allowed\s*\((\d+)\)/i,
+		limitGroup: 1
+	}),
+	(
+	/**
+	* OpenAI's token-bucket rejection. Numbers are validated by the caller:
+	* `Requested >= Limit` means no retry can ever succeed.
+	*/
+	{
+		kind: "request_too_large",
+		re: /request too large[\s\S]*?limit\s*(\d+),\s*requested\s*(\d+)/i,
+		limitGroup: 1,
+		requestedGroup: 2
+	}),
+	(
+	/** Bedrock (Llama upstream) and any provider naming the ceiling alone. */
+	{
+		kind: "context_window",
+		re: /(?:maximum context length|maximum prompt length) is\s*(\d+)\s*tokens/i,
+		limitGroup: 1
+	}),
+	(
+	/** Bedrock (Nova upstream). */
+	{
+		kind: "context_window",
+		re: /number of input tokens exceeds maximum length|input tokens exceeded/i
+	}),
+	(
+	/** Bedrock (Claude Sonnet upstream). */
+	{
+		kind: "context_window",
+		re: /\binput (?:is )?too long(?: for requested model)?\b/i
+	}),
+	(
+	/** OpenAI-compatible error code, and the phrases LangChain itself keys on. */
+	{
+		kind: "context_window",
+		re: /context[_ ]length[_ ]exceeded|input tokens exceed the configured limit|exceeds the context window|exceeds model context window/i
+	}),
+	(
+	/** Generic long-tail phrasings observed across OpenAI-compatible gateways. */
+	{
+		kind: "context_window",
+		re: /prompt is too long|too large for model|reduce the length of (?:the |your )?(?:messages|prompt)/i
+	}),
+	(
+	/**
+	* Vertex AI. Its gaxios path discards the API error document, so an
+	* over-limit prompt arrives as a bare status line with no reason —
+	* identical to every other 400 from the same endpoint. Only a corroborated
+	* near-budget prompt makes this readable as overflow.
+	*/
+	{
+		kind: "context_window",
+		re: /google request failed with status code 400(?!\s*:)/i,
+		requiresContextPressure: true
+	})
 ];
 /**
-* HTTP status codes and broader hints that suggest context overflow.
-* Used by the less-strict `isLikelyContextOverflowError`.
+* Errors that mention size or limits but are NOT recoverable by compaction.
+* Checked before the positive patterns.
+*
+* Note the deliberate precision: OpenAI's *recoverable* "Request too large"
+* body links to `platform.openai.com/account/rate-limits`, so a loose
+* /rate.?limit/ test would discard the very case this module exists to catch.
+* URLs are stripped from the haystack before matching, and genuine throttling
+* is matched on its own distinct phrasing.
+*/
+const NON_RECOVERABLE_RE = /rate limit reached|requests per (?:min|day)|\brpm\b|too many requests|insufficient[_ ]quota|quota exceeded|billing|payment required|invalid[_ ]api[_ ]key|authentication|unauthorized|permission denied|forbidden/i;
+/**
+* Output-cap complaints. `max_tokens` appears in both families, so these are
+* matched on the surrounding grammar rather than the bare parameter name.
+*/
+const OUTPUT_LIMIT_RE = /max_?(?:completion_?)?tokens\s*(?:must be|is too|cannot|exceeds|too large|greater than)|maximum number of output tokens|max_tokens.*less than or equal/i;
+/**
+* Recovers the input-only figure from providers that quote a combined total
+* and then break it down — OpenRouter's "(56811 of text input, 16 in the
+* output)" and DeepSeek's "(1179652 in the messages, 16 in the completion)".
+*/
+const PROMPT_ONLY_BREAKDOWN_RE = /\(\s*(\d+)\s*(?:of\s+text\s+input|in\s+the\s+messages|of\s+input|input\s+tokens)\b/i;
+/** Broader hints for the deliberately fuzzy `isLikelyContextOverflowError`. */
+const CONTEXT_OVERFLOW_HINT_RE = /413|payload too large|content_too_large|request entity too large|too many tokens|token count.*exceed|exceed.*token count/i;
+const MAX_CAUSE_DEPTH = 4;
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+/**
+* Flattens an error into a single searchable string.
+*
+* Necessary because providers bury the useful sentence at different depths:
+* Anthropic puts a JSON document in `message`, Mistral puts one in `body`,
+* LangChain's `ContextOverflowError` keeps the original API error under
+* `cause`, and the OpenAI SDK nests the body under `error`.
+*/
+function collectErrorText(error, depth = 0) {
+	if (error == null || depth > MAX_CAUSE_DEPTH) return "";
+	if (typeof error === "string") return error;
+	const record = asRecord(error);
+	if (record == null) return String(error);
+	const parts = [];
+	if (typeof record.message === "string") parts.push(record.message);
+	for (const reason of [
+		record.code,
+		record.type,
+		record.status,
+		record.reason
+	]) if (typeof reason === "string") parts.push(reason);
+	for (const nested of [
+		record.error,
+		record.cause,
+		record.body,
+		record.data,
+		record.response
+	]) {
+		if (nested == null) continue;
+		parts.push(typeof nested === "string" ? nested : collectErrorText(nested, depth + 1));
+	}
+	if (parts.length === 0) try {
+		/** Non-objects returned above, so this always yields a string. */
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+	return parts.join(" ");
+}
+/** Strips URLs so their path segments cannot trip the negative matchers. */
+function stripUrls(text) {
+	return text.replace(/https?:\/\/\S+/gi, " ");
+}
+function readNumber(match, group) {
+	if (group == null) return;
+	const parsed = Number(match[group]);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+/**
+* The provider's count of the prompt alone: its own breakdown when it gave
+* one, otherwise the quoted total but only for providers that quote the
+* prompt rather than the whole request. Returns undefined when the number on
+* offer includes the completion allowance, since treating that as a prompt
+* measurement would overstate how much the prompt has to shrink.
 */
-const CONTEXT_OVERFLOW_HINT_RE = /413|too large|too long|context.*exceed|exceed.*context|token.*limit|limit.*token|prompt.*size|size.*limit|maximum.*length|length.*maximum/i;
+function resolvePromptTokens(haystack, pattern, requestedTokens) {
+	const breakdown = haystack.match(PROMPT_ONLY_BREAKDOWN_RE);
+	if (breakdown != null) {
+		const parsed = Number(breakdown[1]);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return pattern.requestedIsPromptOnly === true ? requestedTokens : void 0;
+}
 /**
-* Patterns that should NOT be treated as context overflow even if they
-* contain words like "limit" or "too large".
+* True when the caller's own accounting says the failed prompt was close
+* enough to the budget that an otherwise ambiguous provider error is best
+* explained by overflow.
 */
-const FALSE_POSITIVE_RE = /rate.?limit|too many requests|quota|billing|auth|permission|forbidden/i;
+function hasContextPressure(context) {
+	const estimated = context?.estimatedPromptTokens;
+	const budget = context?.maxContextTokens;
+	if (estimated == null || budget == null || !Number.isFinite(estimated) || !Number.isFinite(budget) || budget <= 0) return false;
+	return estimated / budget >= CONTEXT_PRESSURE_RATIO;
+}
+function isLangChainOverflowError(error) {
+	if (_langchain_core_errors.ContextOverflowError.isInstance(error)) return true;
+	/** Duplicate `@langchain/core` copies break branding; the name survives. */
+	const record = asRecord(error);
+	return record?.name === "ContextOverflowError" || record?.lc_error_code === "CONTEXT_OVERFLOW";
+}
 /**
 * Extracts a human-readable error message from an unknown error value.
 */
@@ -43,12 +258,14 @@ function extractErrorMessage(error) {
 	if (error == null) return "";
 	if (typeof error === "string") return error;
 	if (error instanceof Error) return error.message;
-	if (typeof error === "object") {
-		const record = error;
-		if (typeof record.message === "string") return record.message;
-		if (typeof record.error === "string") return record.error;
-		if (typeof record.error === "object" && record.error != null && typeof record.error.message === "string") return record.error.message;
-	}
+	const record = asRecord(error);
+	if (record == null)
+ /** Functions and symbols serialize to nothing; describe them instead. */
+	return String(error);
+	if (typeof record.message === "string") return record.message;
+	if (typeof record.error === "string") return record.error;
+	const nested = asRecord(record.error);
+	if (typeof nested?.message === "string") return nested.message;
 	try {
 		return JSON.stringify(error);
 	} catch {
@@ -56,34 +273,82 @@ function extractErrorMessage(error) {
 	}
 }
 /**
-* Returns true if the error message definitively indicates a context
-* overflow / prompt-too-large error from the provider.
+* Classifies a provider error as a recoverable context overflow, returning
+* whatever the provider disclosed about the limit and the request size.
+*
+* Returns `null` for anything that compaction cannot fix — genuine
+* throttling, auth, quota, and output-token-cap errors all mention limits
+* and must not be mistaken for overflow.
+*
+* The reported numbers are the point of the return value: they let the
+* caller retarget the token budget to the provider's real ceiling instead of
+* retrying blindly against a configured value that was evidently wrong.
+*/
+function getContextOverflowInfo(error, context) {
+	const provider = context?.provider;
+	const haystack = stripUrls(collectErrorText(error));
+	if (haystack === "") return null;
+	if (OUTPUT_LIMIT_RE.test(haystack)) return null;
+	const langChainFlagged = isLangChainOverflowError(error);
+	if (!langChainFlagged && NON_RECOVERABLE_RE.test(haystack)) return null;
+	const underContextPressure = hasContextPressure(context);
+	for (const pattern of OVERFLOW_PATTERNS) {
+		const match = haystack.match(pattern.re);
+		if (match == null) continue;
+		if (pattern.requiresContextPressure === true && !underContextPressure) continue;
+		const limitTokens = readNumber(match, pattern.limitGroup);
+		const requestedTokens = readNumber(match, pattern.requestedGroup);
+		/**
+		* A token-bucket rejection is only unrecoverable-by-waiting when the
+		* request alone overruns the bucket. When it merely fills it, the account
+		* was busy and the request will fit once the window drains — so equality
+		* belongs on the retry side, not the compaction side. Losing conversation
+		* history to a temporarily busy account is the worse error.
+		*/
+		if (pattern.kind === "request_too_large" && limitTokens != null && requestedTokens != null && requestedTokens <= limitTokens) return null;
+		return {
+			kind: pattern.kind,
+			limitTokens,
+			requestedTokens,
+			promptTokens: resolvePromptTokens(haystack, pattern, requestedTokens),
+			source: "pattern",
+			provider
+		};
+	}
+	if (langChainFlagged) return {
+		kind: "context_window",
+		source: "langchain",
+		provider
+	};
+	return null;
+}
+/**
+* Returns true if the error definitively indicates a context overflow.
 *
-* This is the strict check: only matches known, unambiguous phrases.
-* Use this when you want high confidence before taking recovery action.
+* Accepts either a raw error or a pre-extracted message; passing the error
+* itself is preferred, since several providers report the decisive detail in
+* a nested body rather than in `message`.
 */
-function isContextOverflowError(errorMessage) {
-	if (!errorMessage) return false;
-	const lower = errorMessage.toLowerCase();
-	if (FALSE_POSITIVE_RE.test(lower)) return false;
-	return CONTEXT_OVERFLOW_PHRASES.some((phrase) => lower.includes(phrase));
+function isContextOverflowError(error, context) {
+	return getContextOverflowInfo(error, context) != null;
 }
 /**
-* Returns true if the error message likely indicates a context overflow.
-* Uses broader heuristic matching (regex) in addition to exact phrases.
+* Returns true if the error likely indicates a context overflow, adding
+* body-size and token-count heuristics on top of the definitive patterns.
 *
-* May produce false positives for unusual error messages. Use this when
-* the cost of a false positive (one extra retry) is acceptable.
+* May produce false positives on unusual messages. Use when the cost of
+* being wrong is one extra compaction pass.
 */
-function isLikelyContextOverflowError(errorMessage) {
-	if (!errorMessage) return false;
-	if (isContextOverflowError(errorMessage)) return true;
-	const lower = errorMessage.toLowerCase();
-	if (FALSE_POSITIVE_RE.test(lower)) return false;
-	return CONTEXT_OVERFLOW_HINT_RE.test(lower);
+function isLikelyContextOverflowError(error, context) {
+	if (isContextOverflowError(error, context)) return true;
+	const haystack = stripUrls(collectErrorText(error));
+	if (haystack === "" || OUTPUT_LIMIT_RE.test(haystack)) return false;
+	if (NON_RECOVERABLE_RE.test(haystack)) return false;
+	return CONTEXT_OVERFLOW_HINT_RE.test(haystack);
 }
 //#endregion
 exports.extractErrorMessage = extractErrorMessage;
+exports.getContextOverflowInfo = getContextOverflowInfo;
 exports.isContextOverflowError = isContextOverflowError;
 exports.isLikelyContextOverflowError = isLikelyContextOverflowError;
 

package/dist/cjs/utils/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":[],"sources":["../../../src/utils/errors.ts"],"sourcesContent":["/**\n * Context overflow error detection utilities.\n *\n * Identifies provider-specific error messages that indicate the request\n * exceeded the model's context window. Used by the overflow recovery loop\n * to decide whether to retry with truncation/compaction vs. propagating\n * the error.\n */\n\n/**\n * Exact phrases that definitively indicate a context overflow error.\n * These are returned by various LLM providers when the prompt is too large.\n */\nconst CONTEXT_OVERFLOW_PHRASES = [\n  'request_too_large',\n  'context length exceeded',\n  'maximum context length',\n  'prompt is too long',\n  'exceeds model context window',\n  'exceeds the model',\n  'too large for model',\n  'context_length_exceeded',\n  'max_tokens',\n  'token limit',\n  'input too long',\n  'payload too large',\n  'content_too_large',\n] as const;\n\n/**\n * HTTP status codes and broader hints that suggest context overflow.\n * Used by the less-strict `isLikelyContextOverflowError`.\n */\nconst CONTEXT_OVERFLOW_HINT_RE =\n  /413|too large|too long|context.*exceed|exceed.*context|token.*limit|limit.*token|prompt.*size|size.*limit|maximum.*length|length.*maximum/i;\n\n/**\n * Patterns that should NOT be treated as context overflow even if they\n * contain words like \"limit\" or \"too large\".\n */\nconst FALSE_POSITIVE_RE =\n  /rate.?limit|too many requests|quota|billing|auth|permission|forbidden/i;\n\n/**\n * Extracts a human-readable error message from an unknown error value.\n */\nexport function extractErrorMessage(error: unknown): string {\n  if (error == null) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  if (error instanceof Error) {\n    return error.message;\n  }\n  if (typeof error === 'object') {\n    const record = error as Record<string, unknown>;\n    if (typeof record.message === 'string') {\n      return record.message;\n    }\n    if (typeof record.error === 'string') {\n      return record.error;\n    }\n    if (\n      typeof record.error === 'object' &&\n      record.error != null &&\n      typeof (record.error as Record<string, unknown>).message === 'string'\n    ) {\n      return (record.error as Record<string, unknown>).message as string;\n    }\n  }\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\n/**\n * Returns true if the error message definitively indicates a context\n * overflow / prompt-too-large error from the provider.\n *\n * This is the strict check: only matches known, unambiguous phrases.\n * Use this when you want high confidence before taking recovery action.\n */\nexport function isContextOverflowError(errorMessage?: string): boolean {\n  if (!errorMessage) {\n    return false;\n  }\n  const lower = errorMessage.toLowerCase();\n  if (FALSE_POSITIVE_RE.test(lower)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_PHRASES.some((phrase) => lower.includes(phrase));\n}\n\n/**\n * Returns true if the error message likely indicates a context overflow.\n * Uses broader heuristic matching (regex) in addition to exact phrases.\n *\n * May produce false positives for unusual error messages. Use this when\n * the cost of a false positive (one extra retry) is acceptable.\n */\nexport function isLikelyContextOverflowError(errorMessage?: string): boolean {\n  if (!errorMessage) {\n    return false;\n  }\n  if (isContextOverflowError(errorMessage)) {\n    return true;\n  }\n  const lower = errorMessage.toLowerCase();\n  if (FALSE_POSITIVE_RE.test(lower)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_HINT_RE.test(lower);\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,2BAA2B;CAC/B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;AAMA,MAAM,2BACJ;;;;;AAMF,MAAM,oBACJ;;;;AAKF,SAAgB,oBAAoB,OAAwB;CAC1D,IAAI,SAAS,MACX,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,IAAI,iBAAiB,OACnB,OAAO,MAAM;CAEf,IAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,SAAS;EACf,IAAI,OAAO,OAAO,YAAY,UAC5B,OAAO,OAAO;EAEhB,IAAI,OAAO,OAAO,UAAU,UAC1B,OAAO,OAAO;EAEhB,IACE,OAAO,OAAO,UAAU,YACxB,OAAO,SAAS,QAChB,OAAQ,OAAO,MAAkC,YAAY,UAE7D,OAAQ,OAAO,MAAkC;CAErD;CACA,IAAI;EACF,OAAO,KAAK,UAAU,KAAK;CAC7B,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF;;;;;;;;AASA,SAAgB,uBAAuB,cAAgC;CACrE,IAAI,CAAC,cACH,OAAO;CAET,MAAM,QAAQ,aAAa,YAAY;CACvC,IAAI,kBAAkB,KAAK,KAAK,GAC9B,OAAO;CAET,OAAO,yBAAyB,MAAM,WAAW,MAAM,SAAS,MAAM,CAAC;AACzE;;;;;;;;AASA,SAAgB,6BAA6B,cAAgC;CAC3E,IAAI,CAAC,cACH,OAAO;CAET,IAAI,uBAAuB,YAAY,GACrC,OAAO;CAET,MAAM,QAAQ,aAAa,YAAY;CACvC,IAAI,kBAAkB,KAAK,KAAK,GAC9B,OAAO;CAET,OAAO,yBAAyB,KAAK,KAAK;AAC5C"}
+{"version":3,"file":"errors.cjs","names":["ContextOverflowError"],"sources":["../../../src/utils/errors.ts"],"sourcesContent":["/**\n * Context overflow error detection.\n *\n * Providers disagree on how they report \"your input is bigger than I can\n * take\" — the class thrown, the HTTP status, whether numbers are reported,\n * and even whether it arrives as an HTTP error at all. Every pattern below\n * was captured from a live over-limit request (see\n * `src/scripts/context-overflow-probe.ts` and\n * `docs/context-overflow-signatures.md`); nothing here is guessed.\n *\n * Consumed by the graph's overflow recovery loop, which converts a detection\n * into a forced summarization pass instead of surfacing the error.\n */\nimport { ContextOverflowError } from '@langchain/core/errors';\nimport type { Providers } from '@/common';\n\n/**\n * Why the request was rejected. Both kinds are fixed by shrinking the\n * prompt, which is what makes them recoverable; they are distinguished\n * because only `context_window` tells us the model's true window.\n */\nexport type ContextOverflowKind =\n  /** Input exceeded the model's context window. */\n  | 'context_window'\n  /**\n   * A single request exceeded a per-minute token allowance. Waiting cannot\n   * help — the request can never fit the bucket — so this is a payload\n   * problem wearing a 429, not throttling.\n   */\n  | 'request_too_large';\n\nexport interface ContextOverflowInfo {\n  kind: ContextOverflowKind;\n  /** Ceiling the provider reported, when it named one. */\n  limitTokens?: number;\n  /**\n   * Token count the provider attributed to the whole request. Several\n   * providers fold the requested completion allowance into this number, so it\n   * is not interchangeable with the prompt size.\n   */\n  requestedTokens?: number;\n  /**\n   * The prompt alone, counted by the provider — set only when the provider\n   * distinguished input from output, either by reporting an input-only figure\n   * or by breaking the total down. Callers comparing provider counts against\n   * their own prompt estimate must use this and not `requestedTokens`, whose\n   * completion component would inflate the comparison.\n   */\n  promptTokens?: number;\n  /** Which layer produced the verdict. Surfaced in logs and asserted in tests. */\n  source: 'langchain' | 'pattern';\n  provider?: Providers;\n}\n\ninterface OverflowPattern {\n  readonly kind: ContextOverflowKind;\n  readonly re: RegExp;\n  readonly limitGroup?: number;\n  readonly requestedGroup?: number;\n  /**\n   * Whether `requestedGroup` counts the prompt alone. Providers that report a\n   * combined input+completion total leave this false, and their number is\n   * never used as a prompt measurement.\n   */\n  readonly requestedIsPromptOnly?: boolean;\n  /**\n   * Marks a signature that is consistent with overflow but not exclusive to\n   * it, so it only counts when the caller can corroborate that the prompt was\n   * actually near the budget. Without corroboration the error propagates\n   * untouched rather than triggering a needless compaction.\n   */\n  readonly requiresContextPressure?: boolean;\n}\n\n/**\n * Fraction of the believed budget the prompt must reach before an ambiguous\n * provider error is read as overflow. Well above normal traffic, low enough to\n * catch the case the budget itself was miscalibrated.\n */\nconst CONTEXT_PRESSURE_RATIO = 0.8;\n\nexport interface ContextOverflowContext {\n  provider?: Providers;\n  /** Our own estimate of the prompt size for the call that failed. */\n  estimatedPromptTokens?: number;\n  /** The budget we believed applied when we built that prompt. */\n  maxContextTokens?: number;\n}\n\n/**\n * Ordered most-specific first; the first match wins. Patterns that capture\n * both numbers come before the bare-phrase fallbacks for the same provider so\n * a recoverable error still yields the numbers when the provider reported\n * them.\n */\nconst OVERFLOW_PATTERNS: readonly OverflowPattern[] = [\n  /** Anthropic, and Bedrock's passthrough of the same upstream. */\n  {\n    kind: 'context_window',\n    re: /prompt is too long:\\s*(\\d+)\\s*tokens\\s*>\\s*(\\d+)\\s*maximum/i,\n    requestedGroup: 1,\n    limitGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /**\n   * OpenAI's own wording, which measures the messages and nothing else.\n   * Ordered ahead of the shared sentence below so the prompt-only reading is\n   * preferred when OpenAI is the one answering.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum context length is\\s*(\\d+)\\s*tokens\\.\\s*however,\\s*your messages resulted in\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /**\n   * OpenRouter (`you requested about`) and DeepSeek (`you requested`). Their\n   * total folds in the completion allowance — both then break it down in\n   * parentheses, which `PROMPT_ONLY_BREAKDOWN_RE` recovers.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum context length is\\s*(\\d+)\\s*tokens\\.\\s*however,\\s*you requested(?:\\s*about)?\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /**\n   * xAI. Says \"prompt length\" rather than \"context length\", and does not say\n   * whether the count it quotes includes the completion allowance — so it is\n   * not trusted as a prompt measurement.\n   */\n  {\n    kind: 'context_window',\n    re: /maximum prompt length is\\s*(\\d+)\\s*(?:tokens\\s*)?but the request contains\\s*(\\d+)\\s*tokens/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /** Mistral. */\n  {\n    kind: 'context_window',\n    re: /prompt contains\\s*(\\d+)\\s*tokens[^.]*?too large for model with\\s*(\\d+)\\s*maximum context length/i,\n    requestedGroup: 1,\n    limitGroup: 2,\n    requestedIsPromptOnly: true,\n  },\n  /** Google Gemini / Vertex. Reports the ceiling only. */\n  {\n    kind: 'context_window',\n    re: /input token count exceeds the maximum number of tokens allowed\\s*\\((\\d+)\\)/i,\n    limitGroup: 1,\n  },\n  /**\n   * OpenAI's token-bucket rejection. Numbers are validated by the caller:\n   * `Requested >= Limit` means no retry can ever succeed.\n   */\n  {\n    kind: 'request_too_large',\n    re: /request too large[\\s\\S]*?limit\\s*(\\d+),\\s*requested\\s*(\\d+)/i,\n    limitGroup: 1,\n    requestedGroup: 2,\n  },\n  /** Bedrock (Llama upstream) and any provider naming the ceiling alone. */\n  {\n    kind: 'context_window',\n    re: /(?:maximum context length|maximum prompt length) is\\s*(\\d+)\\s*tokens/i,\n    limitGroup: 1,\n  },\n  /** Bedrock (Nova upstream). */\n  {\n    kind: 'context_window',\n    re: /number of input tokens exceeds maximum length|input tokens exceeded/i,\n  },\n  /** Bedrock (Claude Sonnet upstream). */\n  {\n    kind: 'context_window',\n    re: /\\binput (?:is )?too long(?: for requested model)?\\b/i,\n  },\n  /** OpenAI-compatible error code, and the phrases LangChain itself keys on. */\n  {\n    kind: 'context_window',\n    re: /context[_ ]length[_ ]exceeded|input tokens exceed the configured limit|exceeds the context window|exceeds model context window/i,\n  },\n  /** Generic long-tail phrasings observed across OpenAI-compatible gateways. */\n  {\n    kind: 'context_window',\n    re: /prompt is too long|too large for model|reduce the length of (?:the |your )?(?:messages|prompt)/i,\n  },\n  /**\n   * Vertex AI. Its gaxios path discards the API error document, so an\n   * over-limit prompt arrives as a bare status line with no reason —\n   * identical to every other 400 from the same endpoint. Only a corroborated\n   * near-budget prompt makes this readable as overflow.\n   */\n  {\n    kind: 'context_window',\n    re: /google request failed with status code 400(?!\\s*:)/i,\n    requiresContextPressure: true,\n  },\n] as const;\n\n/**\n * Errors that mention size or limits but are NOT recoverable by compaction.\n * Checked before the positive patterns.\n *\n * Note the deliberate precision: OpenAI's *recoverable* \"Request too large\"\n * body links to `platform.openai.com/account/rate-limits`, so a loose\n * /rate.?limit/ test would discard the very case this module exists to catch.\n * URLs are stripped from the haystack before matching, and genuine throttling\n * is matched on its own distinct phrasing.\n */\nconst NON_RECOVERABLE_RE =\n  /rate limit reached|requests per (?:min|day)|\\brpm\\b|too many requests|insufficient[_ ]quota|quota exceeded|billing|payment required|invalid[_ ]api[_ ]key|authentication|unauthorized|permission denied|forbidden/i;\n\n/**\n * Output-cap complaints. `max_tokens` appears in both families, so these are\n * matched on the surrounding grammar rather than the bare parameter name.\n */\nconst OUTPUT_LIMIT_RE =\n  /max_?(?:completion_?)?tokens\\s*(?:must be|is too|cannot|exceeds|too large|greater than)|maximum number of output tokens|max_tokens.*less than or equal/i;\n\n/**\n * Recovers the input-only figure from providers that quote a combined total\n * and then break it down — OpenRouter's \"(56811 of text input, 16 in the\n * output)\" and DeepSeek's \"(1179652 in the messages, 16 in the completion)\".\n */\nconst PROMPT_ONLY_BREAKDOWN_RE =\n  /\\(\\s*(\\d+)\\s*(?:of\\s+text\\s+input|in\\s+the\\s+messages|of\\s+input|input\\s+tokens)\\b/i;\n\n/** Broader hints for the deliberately fuzzy `isLikelyContextOverflowError`. */\nconst CONTEXT_OVERFLOW_HINT_RE =\n  /413|payload too large|content_too_large|request entity too large|too many tokens|token count.*exceed|exceed.*token count/i;\n\nconst MAX_CAUSE_DEPTH = 4;\n\ninterface NestedErrorShape {\n  message?: unknown;\n  code?: unknown;\n  type?: unknown;\n  status?: unknown;\n  reason?: unknown;\n  error?: unknown;\n  cause?: unknown;\n  body?: unknown;\n  response?: unknown;\n  /** gaxios-style clients (Vertex AI) put the API error document here. */\n  data?: unknown;\n}\n\nfunction asRecord(value: unknown): NestedErrorShape | undefined {\n  return typeof value === 'object' && value !== null\n    ? (value as NestedErrorShape)\n    : undefined;\n}\n\n/**\n * Flattens an error into a single searchable string.\n *\n * Necessary because providers bury the useful sentence at different depths:\n * Anthropic puts a JSON document in `message`, Mistral puts one in `body`,\n * LangChain's `ContextOverflowError` keeps the original API error under\n * `cause`, and the OpenAI SDK nests the body under `error`.\n */\nfunction collectErrorText(error: unknown, depth = 0): string {\n  if (error == null || depth > MAX_CAUSE_DEPTH) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  const record = asRecord(error);\n  if (record == null) {\n    return String(error);\n  }\n\n  const parts: string[] = [];\n  if (typeof record.message === 'string') {\n    parts.push(record.message);\n  }\n  for (const reason of [\n    record.code,\n    record.type,\n    record.status,\n    record.reason,\n  ]) {\n    if (typeof reason === 'string') {\n      parts.push(reason);\n    }\n  }\n  for (const nested of [\n    record.error,\n    record.cause,\n    record.body,\n    record.data,\n    record.response,\n  ]) {\n    if (nested == null) {\n      continue;\n    }\n    parts.push(\n      typeof nested === 'string' ? nested : collectErrorText(nested, depth + 1)\n    );\n  }\n  if (parts.length === 0) {\n    try {\n      /** Non-objects returned above, so this always yields a string. */\n      return JSON.stringify(error);\n    } catch {\n      return String(error);\n    }\n  }\n  return parts.join(' ');\n}\n\n/** Strips URLs so their path segments cannot trip the negative matchers. */\nfunction stripUrls(text: string): string {\n  return text.replace(/https?:\\/\\/\\S+/gi, ' ');\n}\n\nfunction readNumber(\n  match: RegExpMatchArray,\n  group?: number\n): number | undefined {\n  if (group == null) {\n    return undefined;\n  }\n  const parsed = Number(match[group]);\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;\n}\n\n/**\n * The provider's count of the prompt alone: its own breakdown when it gave\n * one, otherwise the quoted total but only for providers that quote the\n * prompt rather than the whole request. Returns undefined when the number on\n * offer includes the completion allowance, since treating that as a prompt\n * measurement would overstate how much the prompt has to shrink.\n */\nfunction resolvePromptTokens(\n  haystack: string,\n  pattern: OverflowPattern,\n  requestedTokens: number | undefined\n): number | undefined {\n  const breakdown = haystack.match(PROMPT_ONLY_BREAKDOWN_RE);\n  if (breakdown != null) {\n    const parsed = Number(breakdown[1]);\n    if (Number.isFinite(parsed) && parsed > 0) {\n      return parsed;\n    }\n  }\n  return pattern.requestedIsPromptOnly === true ? requestedTokens : undefined;\n}\n\n/**\n * True when the caller's own accounting says the failed prompt was close\n * enough to the budget that an otherwise ambiguous provider error is best\n * explained by overflow.\n */\nfunction hasContextPressure(context?: ContextOverflowContext): boolean {\n  const estimated = context?.estimatedPromptTokens;\n  const budget = context?.maxContextTokens;\n  if (\n    estimated == null ||\n    budget == null ||\n    !Number.isFinite(estimated) ||\n    !Number.isFinite(budget) ||\n    budget <= 0\n  ) {\n    return false;\n  }\n  return estimated / budget >= CONTEXT_PRESSURE_RATIO;\n}\n\nfunction isLangChainOverflowError(error: unknown): boolean {\n  if (ContextOverflowError.isInstance(error)) {\n    return true;\n  }\n  /** Duplicate `@langchain/core` copies break branding; the name survives. */\n  const record = asRecord(error) as\n    | { name?: unknown; lc_error_code?: unknown }\n    | undefined;\n  return (\n    record?.name === 'ContextOverflowError' ||\n    record?.lc_error_code === 'CONTEXT_OVERFLOW'\n  );\n}\n\n/**\n * Extracts a human-readable error message from an unknown error value.\n */\nexport function extractErrorMessage(error: unknown): string {\n  if (error == null) {\n    return '';\n  }\n  if (typeof error === 'string') {\n    return error;\n  }\n  if (error instanceof Error) {\n    return error.message;\n  }\n  const record = asRecord(error);\n  if (record == null) {\n    /** Functions and symbols serialize to nothing; describe them instead. */\n    return String(error);\n  }\n  if (typeof record.message === 'string') {\n    return record.message;\n  }\n  if (typeof record.error === 'string') {\n    return record.error;\n  }\n  const nested = asRecord(record.error);\n  if (typeof nested?.message === 'string') {\n    return nested.message;\n  }\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\n/**\n * Classifies a provider error as a recoverable context overflow, returning\n * whatever the provider disclosed about the limit and the request size.\n *\n * Returns `null` for anything that compaction cannot fix — genuine\n * throttling, auth, quota, and output-token-cap errors all mention limits\n * and must not be mistaken for overflow.\n *\n * The reported numbers are the point of the return value: they let the\n * caller retarget the token budget to the provider's real ceiling instead of\n * retrying blindly against a configured value that was evidently wrong.\n */\nexport function getContextOverflowInfo(\n  error: unknown,\n  context?: ContextOverflowContext\n): ContextOverflowInfo | null {\n  const provider = context?.provider;\n  const haystack = stripUrls(collectErrorText(error));\n  if (haystack === '') {\n    return null;\n  }\n\n  if (OUTPUT_LIMIT_RE.test(haystack)) {\n    return null;\n  }\n\n  const langChainFlagged = isLangChainOverflowError(error);\n  if (!langChainFlagged && NON_RECOVERABLE_RE.test(haystack)) {\n    return null;\n  }\n\n  const underContextPressure = hasContextPressure(context);\n\n  for (const pattern of OVERFLOW_PATTERNS) {\n    const match = haystack.match(pattern.re);\n    if (match == null) {\n      continue;\n    }\n    if (pattern.requiresContextPressure === true && !underContextPressure) {\n      continue;\n    }\n    const limitTokens = readNumber(match, pattern.limitGroup);\n    const requestedTokens = readNumber(match, pattern.requestedGroup);\n\n    /**\n     * A token-bucket rejection is only unrecoverable-by-waiting when the\n     * request alone overruns the bucket. When it merely fills it, the account\n     * was busy and the request will fit once the window drains — so equality\n     * belongs on the retry side, not the compaction side. Losing conversation\n     * history to a temporarily busy account is the worse error.\n     */\n    if (\n      pattern.kind === 'request_too_large' &&\n      limitTokens != null &&\n      requestedTokens != null &&\n      requestedTokens <= limitTokens\n    ) {\n      return null;\n    }\n\n    return {\n      kind: pattern.kind,\n      limitTokens,\n      requestedTokens,\n      promptTokens: resolvePromptTokens(haystack, pattern, requestedTokens),\n      source: 'pattern',\n      provider,\n    };\n  }\n\n  if (langChainFlagged) {\n    return { kind: 'context_window', source: 'langchain', provider };\n  }\n\n  return null;\n}\n\n/**\n * Returns true if the error definitively indicates a context overflow.\n *\n * Accepts either a raw error or a pre-extracted message; passing the error\n * itself is preferred, since several providers report the decisive detail in\n * a nested body rather than in `message`.\n */\nexport function isContextOverflowError(\n  error?: unknown,\n  context?: ContextOverflowContext\n): boolean {\n  return getContextOverflowInfo(error, context) != null;\n}\n\n/**\n * Returns true if the error likely indicates a context overflow, adding\n * body-size and token-count heuristics on top of the definitive patterns.\n *\n * May produce false positives on unusual messages. Use when the cost of\n * being wrong is one extra compaction pass.\n */\nexport function isLikelyContextOverflowError(\n  error?: unknown,\n  context?: ContextOverflowContext\n): boolean {\n  if (isContextOverflowError(error, context)) {\n    return true;\n  }\n  const haystack = stripUrls(collectErrorText(error));\n  if (haystack === '' || OUTPUT_LIMIT_RE.test(haystack)) {\n    return false;\n  }\n  if (NON_RECOVERABLE_RE.test(haystack)) {\n    return false;\n  }\n  return CONTEXT_OVERFLOW_HINT_RE.test(haystack);\n}\n"],"mappings":"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"}

package/dist/esm/agents/AgentContext.mjs

@@ -2,7 +2,7 @@ import { ANTHROPIC_TOOL_TOKEN_MULTIPLIER, DEFAULT_TOOL_TOKEN_MULTIPLIER } from "
 import "../common/enum.mjs";
 import "../common/index.mjs";
 import { apportionTokenCounts } from "../utils/tokens.mjs";
-import { createPruneMessages } from "../messages/prune.mjs";
+import { clampCalibrationRatio, createPruneMessages } from "../messages/prune.mjs";
 import { syncBudgetDerivedFields } from "../messages/budget.mjs";
 import { addCacheControlToStablePrefixMessages, addTailCacheControl, buildAnthropicCacheControl, buildBedrockCachePoint, cloneMessage, resolveBedrockPromptCacheTtl, resolvePromptCacheTtl } from "../messages/cache.mjs";
 import "../messages/index.mjs";
@@ -128,8 +128,20 @@ var AgentContext = class AgentContext {
 	calibrationRatio = 1;
 	/** Provider-observed instruction overhead from the pruner's best-variance turn. */
 	resolvedInstructionOverhead;
+	_pendingOriginalToolContent;
+	pendingOriginalToolContentChars = 0;
 	/** Pre-masking tool content keyed by message index, consumed by the summarize node. */
-	pendingOriginalToolContent;
+	get pendingOriginalToolContent() {
+		return this._pendingOriginalToolContent;
+	}
+	set pendingOriginalToolContent(value) {
+		this._pendingOriginalToolContent = value;
+		this.pendingOriginalToolContentChars = 0;
+		if (value != null) {
+			for (const content of value.values()) this.pendingOriginalToolContentChars += content.length;
+			this.enforcePendingOriginalContentCap();
+		}
+	}
 	/** Total instruction overhead: system message + tool schemas + pending summary. */
 	get instructionTokens() {
 		const summaryOverhead = this._summaryLocation === "user_message" ? this.summaryTokenCount : 0;
@@ -219,6 +231,25 @@ var AgentContext = class AgentContext {
 	*/
 	_lastSummarizationMsgCount = 0;
 	/**
+	* Forced compactions performed after a provider rejected a prompt as too
+	* large. Bounds the recovery loop so a model that keeps refusing cannot
+	* make the run compact indefinitely.
+	*/
+	_overflowRecoveryAttempts = 0;
+	/**
+	* Budget in force before the first overflow correction of the current run.
+	* Recorded so `reset()` can undo the correction for the next run without
+	* disturbing a `maxContextTokens` that no correction ever touched.
+	*/
+	_preOverflowMaxContextTokens;
+	/**
+	* Prompt size, normalized into the local counter's uncalibrated units, at
+	* the last overflow correction. Keeping both measurements in the same units
+	* lets a later overflow prove whether compaction changed anything even when
+	* the provider observation updated calibration between attempts.
+	*/
+	_lastOverflowPromptTokens;
+	/**
 	* Handoff context when this agent receives control via handoff.
 	* Contains source and parallel execution info for system message context.
 	*/
@@ -510,7 +541,7 @@ The following tools are available exclusively through the \`${programmaticTool.n
 	/**
 	* Reset context for a new run
 	*/
-	reset() {
+	reset(options) {
 		this.systemMessageTokens = 0;
 		this.dynamicInstructionTokens = 0;
 		this.toolSchemaTokens = 0;
@@ -528,11 +559,13 @@ The following tools are available exclusively through the \`${programmaticTool.n
 		this.currentTokenType = "text";
 		this.discoveredToolNames.clear();
 		this.handoffContext = void 0;
+		if (options?.preserveOriginalToolContent !== true) this.pendingOriginalToolContent = void 0;
 		this.summaryText = this._durableSummaryText;
 		this.summaryTokenCount = this._durableSummaryTokenCount;
 		this._lastSummarizationMsgCount = 0;
 		this.lastCallUsage = void 0;
 		this.totalTokensFresh = false;
+		this.restoreContextBudgetAfterOverflow();
 		if (this.tokenCounter) {
 			this.initializeSystemRunnable();
 			const baseTokenMap = { ...this.baseIndexTokenCountMap };
@@ -757,6 +790,87 @@ The following tools are available exclusively through the \`${programmaticTool.n
 	markSummarizationTriggered(msgCount) {
 		this._lastSummarizationMsgCount = msgCount;
 	}
+	get overflowRecoveryAttempts() {
+		return this._overflowRecoveryAttempts;
+	}
+	shouldSummarizeOverflow() {
+		return this.summarizationEnabled === true && (this.tokenCounter == null || this.maxContextTokens == null || this._overflowRecoveryAttempts > 0);
+	}
+	/** Preserves the earliest full tool output recorded for each message index. */
+	preserveOriginalToolContent(originalToolContent) {
+		if (originalToolContent == null || originalToolContent.size === 0) return;
+		if (this.pendingOriginalToolContent == null) this.pendingOriginalToolContent = /* @__PURE__ */ new Map();
+		for (const [index, content] of originalToolContent) if (!this.pendingOriginalToolContent.has(index)) {
+			this.pendingOriginalToolContent.set(index, content);
+			this.pendingOriginalToolContentChars += content.length;
+		}
+		this.enforcePendingOriginalContentCap();
+	}
+	enforcePendingOriginalContentCap() {
+		const pending = this._pendingOriginalToolContent;
+		if (pending == null) return;
+		while (this.pendingOriginalToolContentChars > 2e6 && pending.size > 0) {
+			const oldest = pending.keys().next();
+			if (oldest.done === true) break;
+			const removed = pending.get(oldest.value);
+			if (removed != null) this.pendingOriginalToolContentChars -= removed.length;
+			pending.delete(oldest.value);
+		}
+	}
+	/**
+	* Retargets the context budget after a provider rejected the prompt as too
+	* large, and clears the memoized pruner so the next call is planned against
+	* the corrected budget rather than the one that was evidently wrong.
+	*
+	* Also clears the "already summarized at this message count" guard: that
+	* guard exists to stop redundant summarization of an unchanged history, but
+	* here the history has not changed and compaction is exactly what is
+	* needed.
+	*/
+	applyContextBudgetCorrection(budgetTokens, promptTokens) {
+		if (this._overflowRecoveryAttempts === 0) this._preOverflowMaxContextTokens = this.maxContextTokens;
+		if (budgetTokens != null) this.maxContextTokens = budgetTokens;
+		this.pruneMessages = void 0;
+		this._lastSummarizationMsgCount = 0;
+		this._lastOverflowPromptTokens = promptTokens != null ? this.normalizePromptTokens(promptTokens) : promptTokens;
+		this._overflowRecoveryAttempts += 1;
+	}
+	/** Applies token calibration only when the observation came from this provider. */
+	applyObservedOverflowCalibration(provider, observedCalibrationRatio) {
+		if (provider !== this.provider || observedCalibrationRatio == null || observedCalibrationRatio <= 0) return;
+		this.calibrationRatio = clampCalibrationRatio(observedCalibrationRatio);
+	}
+	/**
+	* True when a previous correction failed to make the prompt any smaller —
+	* the signature of a state nothing can compact further (an emptied message
+	* list carrying its content in an injected summary, for example). Retrying
+	* from there resends a byte-identical prompt, so the caller should stop.
+	*/
+	overflowRecoveryStalled(currentPromptTokens) {
+		const previous = this._lastOverflowPromptTokens;
+		if (previous == null || currentPromptTokens == null || !Number.isFinite(currentPromptTokens)) return false;
+		return this.normalizePromptTokens(currentPromptTokens) >= previous;
+	}
+	normalizePromptTokens(promptTokens) {
+		if (this.calibrationRatio <= 0) return promptTokens;
+		const messageTokens = Math.max(0, promptTokens - this.instructionTokens);
+		return this.instructionTokens + messageTokens / this.calibrationRatio;
+	}
+	/**
+	* Undoes overflow corrections so a reused context starts the next run with
+	* the budget it was configured with and a fresh recovery allowance.
+	*
+	* Without this, a single overflow would permanently shrink the budget for
+	* every later turn, and two would exhaust the per-run allowance for the
+	* lifetime of the context.
+	*/
+	restoreContextBudgetAfterOverflow() {
+		if (this._overflowRecoveryAttempts === 0) return;
+		this.maxContextTokens = this._preOverflowMaxContextTokens;
+		this._preOverflowMaxContextTokens = void 0;
+		this._lastOverflowPromptTokens = void 0;
+		this._overflowRecoveryAttempts = 0;
+	}
 	clearSummary() {
 		if (this.summaryText != null) {
 			this.summaryText = void 0;