@librechat/agents 3.1.70 → 3.1.71-dev.0

package/src/utils/__tests__/truncation.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from '@jest/globals';
+import {
+  HARD_MAX_TOOL_RESULT_CHARS,
+  HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE,
+  calculateMaxToolResultChars,
+  calculateMaxTotalToolOutputSize,
+} from '@/utils/truncation';
+
+describe('truncation helpers', () => {
+  describe('calculateMaxToolResultChars', () => {
+    it('returns the hard cap when context tokens are missing', () => {
+      expect(calculateMaxToolResultChars()).toBe(HARD_MAX_TOOL_RESULT_CHARS);
+      expect(calculateMaxToolResultChars(undefined)).toBe(
+        HARD_MAX_TOOL_RESULT_CHARS
+      );
+      expect(calculateMaxToolResultChars(0)).toBe(HARD_MAX_TOOL_RESULT_CHARS);
+      expect(calculateMaxToolResultChars(-100)).toBe(
+        HARD_MAX_TOOL_RESULT_CHARS
+      );
+    });
+
+    it('computes 30% of context-window characters for normal inputs', () => {
+      // 100k tokens * 0.3 = 30k tokens * 4 chars/token = 120k chars
+      expect(calculateMaxToolResultChars(100_000)).toBe(120_000);
+    });
+
+    it('clamps to the hard cap for large context windows', () => {
+      // 1M tokens * 0.3 * 4 = 1.2M chars, exceeds 400k cap
+      expect(calculateMaxToolResultChars(1_000_000)).toBe(
+        HARD_MAX_TOOL_RESULT_CHARS
+      );
+    });
+  });
+
+  describe('calculateMaxTotalToolOutputSize', () => {
+    it('returns the absolute hard cap when no per-output is provided', () => {
+      expect(calculateMaxTotalToolOutputSize()).toBe(
+        HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE
+      );
+      expect(calculateMaxTotalToolOutputSize(0)).toBe(
+        HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE
+      );
+      expect(calculateMaxTotalToolOutputSize(-1)).toBe(
+        HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE
+      );
+    });
+
+    it('doubles the per-output cap by default', () => {
+      expect(calculateMaxTotalToolOutputSize(100_000)).toBe(200_000);
+      expect(calculateMaxTotalToolOutputSize(1)).toBe(2);
+    });
+
+    it('clamps the doubled value to HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE', () => {
+      // 4M * 2 = 8M, exceeds 5M
+      expect(calculateMaxTotalToolOutputSize(4_000_000)).toBe(
+        HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE
+      );
+      // Right at the boundary: 2.5M * 2 = 5M (no clamp).
+      expect(calculateMaxTotalToolOutputSize(2_500_000)).toBe(5_000_000);
+      // Just past it: 2_500_001 * 2 = 5_000_002 -> clamped.
+      expect(calculateMaxTotalToolOutputSize(2_500_001)).toBe(
+        HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE
+      );
+    });
+  });
+});

package/src/utils/truncation.ts

@@ -12,6 +12,16 @@
  */
 export const HARD_MAX_TOOL_RESULT_CHARS = 400_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.
+ */
+export const HARD_MAX_TOTAL_TOOL_OUTPUT_SIZE = 5_000_000;
+
 /**
  * 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)
@@ -32,6 +42,26 @@ export function calculateMaxToolResultChars(
   );
 }
 
+/**
+ * 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.
+ */
+export function calculateMaxTotalToolOutputSize(
+  maxOutputSize?: number
+): number {
+  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