@librechat/agents 3.2.32 → 3.2.34

package/dist/esm/utils/truncation.mjs

@@ -1,128 +1,111 @@
+//#region src/utils/truncation.ts
 /**
- * Ingestion-time and pre-flight truncation utilities for tool results.
- *
- * Prevents oversized tool outputs from entering the message array and
- * consuming the entire context window.
- */
+* Ingestion-time and pre-flight truncation utilities for tool results.
+*
+* Prevents oversized tool outputs from entering the message array and
+* consuming the entire context window.
+*/
 /**
- * Absolute hard cap on tool result length (characters).
- * Even if the model has a 1M-token context, a single tool result
- * larger than this is almost certainly a bug (e.g., dumping a binary file).
- */
-const HARD_MAX_TOOL_RESULT_CHARS = 400_000;
+* Absolute hard cap on tool result length (characters).
+* Even if the model has a 1M-token context, a single tool result
+* larger than this is almost certainly a bug (e.g., dumping a binary file).
+*/
+const HARD_MAX_TOOL_RESULT_CHARS = 4e5;
 /**
- * Absolute hard cap on the aggregate size (characters) of all registered
- * tool outputs kept for `{{tool<i>turn<n>}}` substitution. Set at 5 MB
- * because the registry stores *raw, untruncated* tool output — full
- * fidelity for piping into downstream bash/jq — so the budget needs
- * enough headroom to keep a handful of large responses without
- * ballooning unbounded.
- */
-const HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = 5_000_000;
+* Absolute hard cap on the aggregate size (characters) of all registered
+* tool outputs kept for `{{tool<i>turn<n>}}` substitution. Set at 5 MB
+* because the registry stores *raw, untruncated* tool output — full
+* fidelity for piping into downstream bash/jq — so the budget needs
+* enough headroom to keep a handful of large responses without
+* ballooning unbounded.
+*/
+const HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = 5e6;
 /**
- * Computes the dynamic max tool result size based on the model's context window.
- * Uses 30% of the context window (in estimated characters, ~4 chars/token)
- * capped at HARD_MAX_TOOL_RESULT_CHARS.
- *
- * @param contextWindowTokens - The model's max context tokens (optional).
- * @returns Maximum allowed characters for a single tool result.
- */
+* Computes the dynamic max tool result size based on the model's context window.
+* Uses 30% of the context window (in estimated characters, ~4 chars/token)
+* capped at HARD_MAX_TOOL_RESULT_CHARS.
+*
+* @param contextWindowTokens - The model's max context tokens (optional).
+* @returns Maximum allowed characters for a single tool result.
+*/
 function calculateMaxToolResultChars(contextWindowTokens) {
-    if (contextWindowTokens == null || contextWindowTokens <= 0) {
-        return HARD_MAX_TOOL_RESULT_CHARS;
-    }
-    return Math.min(Math.floor(contextWindowTokens * 0.3) * 4, HARD_MAX_TOOL_RESULT_CHARS);
+	if (contextWindowTokens == null || contextWindowTokens <= 0) return HARD_MAX_TOOL_RESULT_CHARS;
+	return Math.min(Math.floor(contextWindowTokens * .3) * 4, HARD_MAX_TOOL_RESULT_CHARS);
 }
 /**
- * Computes the default aggregate size (characters) for the tool output
- * reference registry based on the per-output budget. Mirrors
- * `calculateMaxToolResultChars`'s shape: a multiple of the per-output
- * cap, clamped to `HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE`.
- *
- * @param maxOutputSize - Per-output maximum characters (e.g., the
- *   ToolNode's `maxToolResultChars`). When omitted or non-positive,
- *   falls back to the absolute total cap.
- * @returns Maximum total characters retained across the registry.
- */
+* Computes the default aggregate size (characters) for the tool output
+* reference registry based on the per-output budget. Mirrors
+* `calculateMaxToolResultChars`'s shape: a multiple of the per-output
+* cap, clamped to `HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE`.
+*
+* @param maxOutputSize - Per-output maximum characters (e.g., the
+*   ToolNode's `maxToolResultChars`). When omitted or non-positive,
+*   falls back to the absolute total cap.
+* @returns Maximum total characters retained across the registry.
+*/
 function calculateMaxTotalToolOutputSize(maxOutputSize) {
-    if (maxOutputSize == null || maxOutputSize <= 0) {
-        return HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;
-    }
-    return Math.min(maxOutputSize * 2, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE);
+	if (maxOutputSize == null || maxOutputSize <= 0) return HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;
+	return Math.min(maxOutputSize * 2, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE);
 }
 /**
- * Truncates a tool-call input (the arguments/payload of a tool_use block)
- * using head+tail strategy. Returns an object with `_truncated` (the
- * truncated string) and `_originalChars` (for diagnostics).
- *
- * Accepts any type — objects are JSON-serialized before truncation.
- *
- * @param input - The tool input (string, object, etc.).
- * @param maxChars - Maximum allowed characters.
- */
+* Truncates a tool-call input (the arguments/payload of a tool_use block)
+* using head+tail strategy. Returns an object with `_truncated` (the
+* truncated string) and `_originalChars` (for diagnostics).
+*
+* Accepts any type — objects are JSON-serialized before truncation.
+*
+* @param input - The tool input (string, object, etc.).
+* @param maxChars - Maximum allowed characters.
+*/
 function truncateToolInput(input, maxChars) {
-    const serialized = typeof input === 'string' ? input : JSON.stringify(input);
-    if (serialized.length <= maxChars) {
-        return { _truncated: serialized, _originalChars: serialized.length };
-    }
-    const indicator = `\n… [truncated: ${serialized.length} chars exceeded ${maxChars} limit] …\n`;
-    const available = maxChars - indicator.length;
-    if (available < 100) {
-        return {
-            _truncated: serialized.slice(0, maxChars) + indicator.trimEnd(),
-            _originalChars: serialized.length,
-        };
-    }
-    const headSize = Math.ceil(available * 0.7);
-    const tailSize = available - headSize;
-    return {
-        _truncated: serialized.slice(0, headSize) +
-            indicator +
-            serialized.slice(serialized.length - tailSize),
-        _originalChars: serialized.length,
-    };
+	const serialized = typeof input === "string" ? input : JSON.stringify(input);
+	if (serialized.length <= maxChars) return {
+		_truncated: serialized,
+		_originalChars: serialized.length
+	};
+	const indicator = `\n… [truncated: ${serialized.length} chars exceeded ${maxChars} limit] …\n`;
+	const available = maxChars - indicator.length;
+	if (available < 100) return {
+		_truncated: serialized.slice(0, maxChars) + indicator.trimEnd(),
+		_originalChars: serialized.length
+	};
+	const headSize = Math.ceil(available * .7);
+	const tailSize = available - headSize;
+	return {
+		_truncated: serialized.slice(0, headSize) + indicator + serialized.slice(serialized.length - tailSize),
+		_originalChars: serialized.length
+	};
 }
 /**
- * Truncates tool result content that exceeds `maxChars` using a head+tail
- * strategy. Keeps the beginning (structure/headers) and end (return value /
- * conclusion) of the content so the model retains both the opening context
- * and the final outcome.
- *
- * Head gets ~70% of the budget, tail gets ~30%. Falls back to head-only
- * when the budget is too small for a meaningful tail.
- *
- * @param content - The tool result string content.
- * @param maxChars - Maximum allowed characters.
- * @returns The (possibly truncated) content string.
- */
+* Truncates tool result content that exceeds `maxChars` using a head+tail
+* strategy. Keeps the beginning (structure/headers) and end (return value /
+* conclusion) of the content so the model retains both the opening context
+* and the final outcome.
+*
+* Head gets ~70% of the budget, tail gets ~30%. Falls back to head-only
+* when the budget is too small for a meaningful tail.
+*
+* @param content - The tool result string content.
+* @param maxChars - Maximum allowed characters.
+* @returns The (possibly truncated) content string.
+*/
 function truncateToolResultContent(content, maxChars) {
-    if (content.length <= maxChars) {
-        return content;
-    }
-    const indicator = `\n\n… [truncated: ${content.length} chars exceeded ${maxChars} limit] …\n\n`;
-    const available = maxChars - indicator.length;
-    if (available <= 0) {
-        return content.slice(0, maxChars);
-    }
-    // When budget is too small for a meaningful tail, fall back to head-only
-    if (available < 200) {
-        return content.slice(0, available) + indicator.trimEnd();
-    }
-    const headSize = Math.ceil(available * 0.7);
-    const tailSize = available - headSize;
-    // Try to break at newline boundaries for cleaner output
-    let headEnd = headSize;
-    const headNewline = content.lastIndexOf('\n', headSize);
-    if (headNewline > headSize - 200 && headNewline > 0) {
-        headEnd = headNewline;
-    }
-    let tailStart = content.length - tailSize;
-    const tailNewline = content.indexOf('\n', tailStart);
-    if (tailNewline > 0 && tailNewline < tailStart + 200) {
-        tailStart = tailNewline + 1;
-    }
-    return content.slice(0, headEnd) + indicator + content.slice(tailStart);
+	if (content.length <= maxChars) return content;
+	const indicator = `\n\n… [truncated: ${content.length} chars exceeded ${maxChars} limit] …\n\n`;
+	const available = maxChars - indicator.length;
+	if (available <= 0) return content.slice(0, maxChars);
+	if (available < 200) return content.slice(0, available) + indicator.trimEnd();
+	const headSize = Math.ceil(available * .7);
+	const tailSize = available - headSize;
+	let headEnd = headSize;
+	const headNewline = content.lastIndexOf("\n", headSize);
+	if (headNewline > headSize - 200 && headNewline > 0) headEnd = headNewline;
+	let tailStart = content.length - tailSize;
+	const tailNewline = content.indexOf("\n", tailStart);
+	if (tailNewline > 0 && tailNewline < tailStart + 200) tailStart = tailNewline + 1;
+	return content.slice(0, headEnd) + indicator + content.slice(tailStart);
 }
-
+//#endregion
 export { HARD_MAX_TOOL_RESULT_CHARS, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE, calculateMaxToolResultChars, calculateMaxTotalToolOutputSize, truncateToolInput, truncateToolResultContent };
-//# sourceMappingURL=truncation.mjs.map
+
+//# sourceMappingURL=truncation.mjs.map

package/dist/esm/utils/truncation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"truncation.mjs","sources":["../../../src/utils/truncation.ts"],"sourcesContent":["/**\n * Ingestion-time and pre-flight truncation utilities for tool results.\n *\n * Prevents oversized tool outputs from entering the message array and\n * consuming the entire context window.\n */\n\n/**\n * Absolute hard cap on tool result length (characters).\n * Even if the model has a 1M-token context, a single tool result\n * larger than this is almost certainly a bug (e.g., dumping a binary file).\n */\nexport const HARD_MAX_TOOL_RESULT_CHARS = 400_000;\n\n/**\n * Absolute hard cap on the aggregate size (characters) of all registered\n * tool outputs kept for `{{tool<i>turn<n>}}` substitution. Set at 5 MB\n * because the registry stores *raw, untruncated* tool output — full\n * fidelity for piping into downstream bash/jq — so the budget needs\n * enough headroom to keep a handful of large responses without\n * ballooning unbounded.\n */\nexport const HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = 5_000_000;\n\n/**\n * Computes the dynamic max tool result size based on the model's context window.\n * Uses 30% of the context window (in estimated characters, ~4 chars/token)\n * capped at HARD_MAX_TOOL_RESULT_CHARS.\n *\n * @param contextWindowTokens - The model's max context tokens (optional).\n * @returns Maximum allowed characters for a single tool result.\n */\nexport function calculateMaxToolResultChars(\n  contextWindowTokens?: number\n): number {\n  if (contextWindowTokens == null || contextWindowTokens <= 0) {\n    return HARD_MAX_TOOL_RESULT_CHARS;\n  }\n  return Math.min(\n    Math.floor(contextWindowTokens * 0.3) * 4,\n    HARD_MAX_TOOL_RESULT_CHARS\n  );\n}\n\n/**\n * Computes the default aggregate size (characters) for the tool output\n * reference registry based on the per-output budget. Mirrors\n * `calculateMaxToolResultChars`'s shape: a multiple of the per-output\n * cap, clamped to `HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE`.\n *\n * @param maxOutputSize - Per-output maximum characters (e.g., the\n *   ToolNode's `maxToolResultChars`). When omitted or non-positive,\n *   falls back to the absolute total cap.\n * @returns Maximum total characters retained across the registry.\n */\nexport function calculateMaxTotalToolOutputSize(\n  maxOutputSize?: number\n): number {\n  if (maxOutputSize == null || maxOutputSize <= 0) {\n    return HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;\n  }\n  return Math.min(maxOutputSize * 2, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE);\n}\n\n/**\n * Truncates a tool-call input (the arguments/payload of a tool_use block)\n * using head+tail strategy. Returns an object with `_truncated` (the\n * truncated string) and `_originalChars` (for diagnostics).\n *\n * Accepts any type — objects are JSON-serialized before truncation.\n *\n * @param input - The tool input (string, object, etc.).\n * @param maxChars - Maximum allowed characters.\n */\nexport function truncateToolInput(\n  input: unknown,\n  maxChars: number\n): { _truncated: string; _originalChars: number } {\n  const serialized = typeof input === 'string' ? input : JSON.stringify(input);\n  if (serialized.length <= maxChars) {\n    return { _truncated: serialized, _originalChars: serialized.length };\n  }\n  const indicator = `\\n… [truncated: ${serialized.length} chars exceeded ${maxChars} limit] …\\n`;\n  const available = maxChars - indicator.length;\n\n  if (available < 100) {\n    return {\n      _truncated: serialized.slice(0, maxChars) + indicator.trimEnd(),\n      _originalChars: serialized.length,\n    };\n  }\n\n  const headSize = Math.ceil(available * 0.7);\n  const tailSize = available - headSize;\n\n  return {\n    _truncated:\n      serialized.slice(0, headSize) +\n      indicator +\n      serialized.slice(serialized.length - tailSize),\n    _originalChars: serialized.length,\n  };\n}\n\n/**\n * Truncates tool result content that exceeds `maxChars` using a head+tail\n * strategy. Keeps the beginning (structure/headers) and end (return value /\n * conclusion) of the content so the model retains both the opening context\n * and the final outcome.\n *\n * Head gets ~70% of the budget, tail gets ~30%. Falls back to head-only\n * when the budget is too small for a meaningful tail.\n *\n * @param content - The tool result string content.\n * @param maxChars - Maximum allowed characters.\n * @returns The (possibly truncated) content string.\n */\nexport function truncateToolResultContent(\n  content: string,\n  maxChars: number\n): string {\n  if (content.length <= maxChars) {\n    return content;\n  }\n\n  const indicator = `\\n\\n… [truncated: ${content.length} chars exceeded ${maxChars} limit] …\\n\\n`;\n  const available = maxChars - indicator.length;\n  if (available <= 0) {\n    return content.slice(0, maxChars);\n  }\n\n  // When budget is too small for a meaningful tail, fall back to head-only\n  if (available < 200) {\n    return content.slice(0, available) + indicator.trimEnd();\n  }\n\n  const headSize = Math.ceil(available * 0.7);\n  const tailSize = available - headSize;\n\n  // Try to break at newline boundaries for cleaner output\n  let headEnd = headSize;\n  const headNewline = content.lastIndexOf('\\n', headSize);\n  if (headNewline > headSize - 200 && headNewline > 0) {\n    headEnd = headNewline;\n  }\n\n  let tailStart = content.length - tailSize;\n  const tailNewline = content.indexOf('\\n', tailStart);\n  if (tailNewline > 0 && tailNewline < tailStart + 200) {\n    tailStart = tailNewline + 1;\n  }\n\n  return content.slice(0, headEnd) + indicator + content.slice(tailStart);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"truncation.mjs","names":[],"sources":["../../../src/utils/truncation.ts"],"sourcesContent":["/**\n * Ingestion-time and pre-flight truncation utilities for tool results.\n *\n * Prevents oversized tool outputs from entering the message array and\n * consuming the entire context window.\n */\n\n/**\n * Absolute hard cap on tool result length (characters).\n * Even if the model has a 1M-token context, a single tool result\n * larger than this is almost certainly a bug (e.g., dumping a binary file).\n */\nexport const HARD_MAX_TOOL_RESULT_CHARS = 400_000;\n\n/**\n * Absolute hard cap on the aggregate size (characters) of all registered\n * tool outputs kept for `{{tool<i>turn<n>}}` substitution. Set at 5 MB\n * because the registry stores *raw, untruncated* tool output — full\n * fidelity for piping into downstream bash/jq — so the budget needs\n * enough headroom to keep a handful of large responses without\n * ballooning unbounded.\n */\nexport const HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = 5_000_000;\n\n/**\n * Computes the dynamic max tool result size based on the model's context window.\n * Uses 30% of the context window (in estimated characters, ~4 chars/token)\n * capped at HARD_MAX_TOOL_RESULT_CHARS.\n *\n * @param contextWindowTokens - The model's max context tokens (optional).\n * @returns Maximum allowed characters for a single tool result.\n */\nexport function calculateMaxToolResultChars(\n  contextWindowTokens?: number\n): number {\n  if (contextWindowTokens == null || contextWindowTokens <= 0) {\n    return HARD_MAX_TOOL_RESULT_CHARS;\n  }\n  return Math.min(\n    Math.floor(contextWindowTokens * 0.3) * 4,\n    HARD_MAX_TOOL_RESULT_CHARS\n  );\n}\n\n/**\n * Computes the default aggregate size (characters) for the tool output\n * reference registry based on the per-output budget. Mirrors\n * `calculateMaxToolResultChars`'s shape: a multiple of the per-output\n * cap, clamped to `HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE`.\n *\n * @param maxOutputSize - Per-output maximum characters (e.g., the\n *   ToolNode's `maxToolResultChars`). When omitted or non-positive,\n *   falls back to the absolute total cap.\n * @returns Maximum total characters retained across the registry.\n */\nexport function calculateMaxTotalToolOutputSize(\n  maxOutputSize?: number\n): number {\n  if (maxOutputSize == null || maxOutputSize <= 0) {\n    return HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE;\n  }\n  return Math.min(maxOutputSize * 2, HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE);\n}\n\n/**\n * Truncates a tool-call input (the arguments/payload of a tool_use block)\n * using head+tail strategy. Returns an object with `_truncated` (the\n * truncated string) and `_originalChars` (for diagnostics).\n *\n * Accepts any type — objects are JSON-serialized before truncation.\n *\n * @param input - The tool input (string, object, etc.).\n * @param maxChars - Maximum allowed characters.\n */\nexport function truncateToolInput(\n  input: unknown,\n  maxChars: number\n): { _truncated: string; _originalChars: number } {\n  const serialized = typeof input === 'string' ? input : JSON.stringify(input);\n  if (serialized.length <= maxChars) {\n    return { _truncated: serialized, _originalChars: serialized.length };\n  }\n  const indicator = `\\n… [truncated: ${serialized.length} chars exceeded ${maxChars} limit] …\\n`;\n  const available = maxChars - indicator.length;\n\n  if (available < 100) {\n    return {\n      _truncated: serialized.slice(0, maxChars) + indicator.trimEnd(),\n      _originalChars: serialized.length,\n    };\n  }\n\n  const headSize = Math.ceil(available * 0.7);\n  const tailSize = available - headSize;\n\n  return {\n    _truncated:\n      serialized.slice(0, headSize) +\n      indicator +\n      serialized.slice(serialized.length - tailSize),\n    _originalChars: serialized.length,\n  };\n}\n\n/**\n * Truncates tool result content that exceeds `maxChars` using a head+tail\n * strategy. Keeps the beginning (structure/headers) and end (return value /\n * conclusion) of the content so the model retains both the opening context\n * and the final outcome.\n *\n * Head gets ~70% of the budget, tail gets ~30%. Falls back to head-only\n * when the budget is too small for a meaningful tail.\n *\n * @param content - The tool result string content.\n * @param maxChars - Maximum allowed characters.\n * @returns The (possibly truncated) content string.\n */\nexport function truncateToolResultContent(\n  content: string,\n  maxChars: number\n): string {\n  if (content.length <= maxChars) {\n    return content;\n  }\n\n  const indicator = `\\n\\n… [truncated: ${content.length} chars exceeded ${maxChars} limit] …\\n\\n`;\n  const available = maxChars - indicator.length;\n  if (available <= 0) {\n    return content.slice(0, maxChars);\n  }\n\n  // When budget is too small for a meaningful tail, fall back to head-only\n  if (available < 200) {\n    return content.slice(0, available) + indicator.trimEnd();\n  }\n\n  const headSize = Math.ceil(available * 0.7);\n  const tailSize = available - headSize;\n\n  // Try to break at newline boundaries for cleaner output\n  let headEnd = headSize;\n  const headNewline = content.lastIndexOf('\\n', headSize);\n  if (headNewline > headSize - 200 && headNewline > 0) {\n    headEnd = headNewline;\n  }\n\n  let tailStart = content.length - tailSize;\n  const tailNewline = content.indexOf('\\n', tailStart);\n  if (tailNewline > 0 && tailNewline < tailStart + 200) {\n    tailStart = tailNewline + 1;\n  }\n\n  return content.slice(0, headEnd) + indicator + content.slice(tailStart);\n}\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,6BAA6B;;;;;;;;;AAU1C,MAAa,kCAAkC;;;;;;;;;AAU/C,SAAgB,4BACd,qBACQ;CACR,IAAI,uBAAuB,QAAQ,uBAAuB,GACxD,OAAO;CAET,OAAO,KAAK,IACV,KAAK,MAAM,sBAAsB,EAAG,IAAI,GACxC,0BACF;AACF;;;;;;;;;;;;AAaA,SAAgB,gCACd,eACQ;CACR,IAAI,iBAAiB,QAAQ,iBAAiB,GAC5C,OAAO;CAET,OAAO,KAAK,IAAI,gBAAgB,GAAG,+BAA+B;AACpE;;;;;;;;;;;AAYA,SAAgB,kBACd,OACA,UACgD;CAChD,MAAM,aAAa,OAAO,UAAU,WAAW,QAAQ,KAAK,UAAU,KAAK;CAC3E,IAAI,WAAW,UAAU,UACvB,OAAO;EAAE,YAAY;EAAY,gBAAgB,WAAW;CAAO;CAErE,MAAM,YAAY,mBAAmB,WAAW,OAAO,kBAAkB,SAAS;CAClF,MAAM,YAAY,WAAW,UAAU;CAEvC,IAAI,YAAY,KACd,OAAO;EACL,YAAY,WAAW,MAAM,GAAG,QAAQ,IAAI,UAAU,QAAQ;EAC9D,gBAAgB,WAAW;CAC7B;CAGF,MAAM,WAAW,KAAK,KAAK,YAAY,EAAG;CAC1C,MAAM,WAAW,YAAY;CAE7B,OAAO;EACL,YACE,WAAW,MAAM,GAAG,QAAQ,IAC5B,YACA,WAAW,MAAM,WAAW,SAAS,QAAQ;EAC/C,gBAAgB,WAAW;CAC7B;AACF;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,SACA,UACQ;CACR,IAAI,QAAQ,UAAU,UACpB,OAAO;CAGT,MAAM,YAAY,qBAAqB,QAAQ,OAAO,kBAAkB,SAAS;CACjF,MAAM,YAAY,WAAW,UAAU;CACvC,IAAI,aAAa,GACf,OAAO,QAAQ,MAAM,GAAG,QAAQ;CAIlC,IAAI,YAAY,KACd,OAAO,QAAQ,MAAM,GAAG,SAAS,IAAI,UAAU,QAAQ;CAGzD,MAAM,WAAW,KAAK,KAAK,YAAY,EAAG;CAC1C,MAAM,WAAW,YAAY;CAG7B,IAAI,UAAU;CACd,MAAM,cAAc,QAAQ,YAAY,MAAM,QAAQ;CACtD,IAAI,cAAc,WAAW,OAAO,cAAc,GAChD,UAAU;CAGZ,IAAI,YAAY,QAAQ,SAAS;CACjC,MAAM,cAAc,QAAQ,QAAQ,MAAM,SAAS;CACnD,IAAI,cAAc,KAAK,cAAc,YAAY,KAC/C,YAAY,cAAc;CAG5B,OAAO,QAAQ,MAAM,GAAG,OAAO,IAAI,YAAY,QAAQ,MAAM,SAAS;AACxE"}

package/dist/types/llm/bedrock/utils/index.d.ts

@@ -2,4 +2,4 @@
  * Bedrock Converse utility exports.
  */
 export { convertToConverseMessages, extractImageInfo, langchainReasoningBlockToBedrockReasoningBlock, concatenateLangchainReasoningBlocks, } from './message_inputs';
-export { convertConverseMessageToLangChainMessage, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';
+export { convertConverseMessageToLangChainMessage, createConverseToolUseStopChunk, handleConverseStreamContentBlockStart, handleConverseStreamContentBlockDelta, handleConverseStreamMetadata, bedrockReasoningBlockToLangchainReasoningBlock, bedrockReasoningDeltaToLangchainPartialReasoningBlock, } from './message_outputs';

package/dist/types/llm/bedrock/utils/message_outputs.d.ts

@@ -25,6 +25,15 @@ export declare function handleConverseStreamContentBlockDelta(contentBlockDelta:
  * Handle a content block start event from Bedrock Converse stream.
  */
 export declare function handleConverseStreamContentBlockStart(contentBlockStart: ContentBlockStartEvent): ChatGenerationChunk | null;
+/**
+ * Build the chunk emitted when a Converse `contentBlockStop` event closes a
+ * toolUse block. The Converse protocol guarantees a block's input is complete
+ * at `contentBlockStop`, so this chunk carries an explicit streamed tool-call
+ * seal for that block index. The empty `args` delta merges as a no-op into the
+ * accumulated tool call; id/name are omitted so the chunk matches the existing
+ * entry purely by index.
+ */
+export declare function createConverseToolUseStopChunk(contentBlockIndex: number): ChatGenerationChunk;
 /**
  * Handle a metadata event from Bedrock Converse stream.
  */

package/dist/types/llm/vertexai/index.d.ts

@@ -1,4 +1,5 @@
 import { ChatGoogle } from '@langchain/google-gauth';
+import { AIMessageChunk } from '@langchain/core/messages';
 import type { GeminiContent, GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
@@ -29,6 +30,15 @@ import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
  * overriding `_convertToUsageMetadata`.
  */
 export declare function repairStreamUsageMetadata(current: UsageMetadata | undefined, generationInfoUsage: UsageMetadata | undefined): UsageMetadata | undefined;
+/**
+ * The Gemini API delivers function calls as complete objects — never as
+ * partial arg deltas. `@langchain/google-common` pre-parses each streamed
+ * functionCall part into `tool_calls` (invalid args land in
+ * `invalid_tool_calls` instead), so a chunk whose tool-call chunks all parsed
+ * cleanly is sealed on arrival for eager tool execution. Anything that fails
+ * the parse check is left unstamped and falls back to the lazy path.
+ */
+export declare function sealCompleteStreamedToolCalls(message: AIMessageChunk): void;
 /**
  * Fixes thought signatures on functionCall parts in the formatted Gemini request.
  *

package/dist/types/tools/ToolNode.d.ts

@@ -350,6 +350,14 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      */
     private dispatchPostToolBatchAndInjectContext;
     private dispatchStepCompleted;
+    /**
+     * Emits the completed run step for a single host-reported result before
+     * the batch resolves. Mirrors the batch loop's output formatting exactly;
+     * callers gate on the no-hooks/no-HITL configuration, so the raw result
+     * content here is also the final content. Returns whether the event was
+     * actually dispatched so the caller can fall back to batch-time emission.
+     */
+    private dispatchEarlyToolCompletion;
     /**
      * Converts InjectedMessage instances to LangChain HumanMessage objects.
      * Both 'user' and 'system' roles become HumanMessage to avoid provider

package/dist/types/tools/search/tool.d.ts

@@ -1,3 +1,20 @@
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import type * as t from './types';
+import { DATE_RANGE } from './schema';
+import { createSearchAPI } from './search';
+/**
+ * Executes parallel searches and merges the results,
+ * deduplicating top stories by link
+ */
+export declare function executeParallelSearches({ searchAPI, query, date, country, safeSearch, images, videos, news, logger, }: {
+    searchAPI: ReturnType<typeof createSearchAPI>;
+    query: string;
+    date?: DATE_RANGE;
+    country?: string;
+    safeSearch: t.SearchToolConfig['safeSearch'];
+    images: boolean;
+    videos: boolean;
+    news: boolean;
+    logger: t.Logger;
+}): Promise<t.SearchResult>;
 export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicStructuredTool;

package/dist/types/tools/search/types.d.ts

@@ -116,6 +116,10 @@ export interface ScrapeResult {
 }
 export interface ProcessSourcesConfig {
     topResults?: number;
+    /** Max chars of scraped content stored per source and passed to the
+     * chunker/reranker. Defaults to 50,000; also configurable via the
+     * `SEARCH_MAX_CONTENT_LENGTH` env var. */
+    maxContentLength?: number;
     strategies?: string[];
     filterContent?: boolean;
     reranker?: BaseReranker;

package/dist/types/tools/streamedToolCallSeals.d.ts

@@ -1,7 +1,11 @@
 export declare const STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY = "lc_streamed_tool_call_adapter";
 export declare const STREAMED_TOOL_CALL_SEAL_METADATA_KEY = "lc_streamed_tool_call_seal";
 export declare const OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER = "openai_responses";
-export type StreamedToolCallAdapter = typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER;
+export declare const BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER = "bedrock_converse";
+export declare const GOOGLE_STREAMED_TOOL_CALL_ADAPTER = "google_genai";
+export declare const OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER = "openai_chat_sequential";
+export type StreamedToolCallAdapter = typeof OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER | typeof BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER | typeof GOOGLE_STREAMED_TOOL_CALL_ADAPTER | typeof OPENAI_CHAT_SEQUENTIAL_STREAMED_TOOL_CALL_ADAPTER;
+export declare function streamedToolCallAdapterAllowsSequentialSeal(metadata: Record<string, unknown> | undefined): boolean;
 export type StreamedToolCallSeal = {
     kind: 'single';
     id?: string;

package/dist/types/types/tools.d.ts

@@ -382,6 +382,16 @@ export type ToolExecuteBatchRequest = {
     resolve: (results: ToolExecuteResult[]) => void;
     /** Promise rejector - handler calls this on fatal error */
     reject: (error: Error) => void;
+    /**
+     * Optional per-call result channel. When present, the handler MAY invoke
+     * this as each tool call settles (before the final `resolve`) so the
+     * graph can emit that call's completion event without waiting for the
+     * slowest call in the batch. Purely an emission fast-path: the handler
+     * must still pass every result to `resolve`, which remains the
+     * authoritative batch outcome. Only provided when no post-tool hooks or
+     * human-in-the-loop flows could change a result after execution.
+     */
+    onResult?: (result: ToolExecuteResult) => void;
 };
 /**
  * A message injected into graph state by any tool execution handler.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.32",
+  "version": "3.2.34",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -114,8 +114,8 @@
   "scripts": {
     "prepare": "node husky-setup.js",
     "prepublishOnly": "npm run build",
-    "build": "NODE_ENV=production rollup -c && tsc -p tsconfig.build.json",
-    "build:dev": "rollup -c",
+    "build": "rm -rf ./dist && tsdown && tsc -p tsconfig.build.json",
+    "build:dev": "tsdown",
     "sort-imports": "node scripts/sort-imports.ts",
     "sort-imports:check": "node scripts/sort-imports.ts --check",
     "start": "node dist/esm/main.js",
@@ -264,11 +264,6 @@
     "@anthropic-ai/sandbox-runtime": "^0.0.54",
     "@anthropic-ai/vertex-sdk": "^0.12.0",
     "@eslint/compat": "^1.2.7",
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-commonjs": "^29.0.2",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^12.1.2",
     "@swc/core": "^1.6.13",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.13.1",
@@ -284,12 +279,11 @@
     "jest-util": "^30.2.0",
     "lint-staged": "^16.4.0",
     "prettier": "^3.6.2",
-    "rollup": "^4.59.0",
-    "rollup-plugin-cleandir": "^2.0.0",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "^4.2.0",
+    "tsdown": "^0.22.2",
     "tslib": "^2.6.3",
     "typescript": "^5.5.3",
     "winston": "^3.17.0"