@librechat/agents 3.1.77-dev.1 → 3.1.78-dev.0

package/dist/cjs/messages/anthropicToolCache.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Anthropic prompt-caching helper for the `tools[]` request field.
+ *
+ * Anthropic accepts `cache_control: { type: 'ephemeral' }` on individual
+ * tool definitions. Whichever tool carries the marker becomes the end of
+ * a cached prefix: `tools[0..N]` (everything up to and including the
+ * marked tool) is cached and rebated on subsequent matching requests.
+ *
+ * For agents that mix static and deferred (lazily-discovered) tools, the
+ * winning configuration is:
+ *
+ *   1. Stable-partition tools so all *static* (non-deferred) tools come
+ *      first and discovered-deferred tools come last.
+ *   2. Stamp `cache_control` on the LAST static tool.
+ *
+ * That way, the cached prefix covers exactly the static tool inventory.
+ * Discovered tools that show up later (or vary turn-to-turn as new ones
+ * get discovered) never invalidate the prefix because they sit *after*
+ * the breakpoint.
+ *
+ * LangChain's Anthropic adapter passes the marker through via
+ * `tool.extras.cache_control` (`AnthropicToolExtrasSchema`), so we set
+ * it as an `extras` field on a fresh wrapper around the tool — never
+ * mutating the original tool instance, since callers may share them
+ * across runs.
+ */
+/**
+ * Returns a callable that reports whether a given tool *name* is deferred
+ * according to the supplied registry of tool definitions. Tools without
+ * a registry entry are treated as non-deferred (i.e. static), matching
+ * the host-supplied `graphTools` semantics elsewhere in the SDK.
+ */
+function makeIsDeferred(toolDefinitions) {
+    if (toolDefinitions == null || toolDefinitions.length === 0) {
+        return () => false;
+    }
+    const deferred = new Set();
+    for (const def of toolDefinitions) {
+        if (def.defer_loading === true)
+            deferred.add(def.name);
+    }
+    if (deferred.size === 0)
+        return () => false;
+    return (name) => deferred.has(name);
+}
+/**
+ * Stable-partition `tools` into [static..., deferred...] and stamp the
+ * Anthropic `cache_control: ephemeral` marker on the last static tool.
+ *
+ * If `tools` is undefined or empty, or no entry has a usable `.name`,
+ * returns the input unchanged. If there are no static tools at all,
+ * also returns unchanged (nothing to cache).
+ *
+ * The original tool instances are never mutated. The marked entry is a
+ * shallow wrapper that preserves the prototype chain so downstream
+ * `instanceof` checks still pass. `extras` is merged so any existing
+ * `providerToolDefinition` / other extras the host attached are kept.
+ */
+function partitionAndMarkAnthropicToolCache(tools, isDeferred) {
+    if (tools == null || tools.length === 0)
+        return tools;
+    // Use unknown[] internally to avoid GraphTools' union-array variance
+    // (each member is one of three array types). We cast back to
+    // GraphTools when returning.
+    const staticTools = [];
+    const deferredTools = [];
+    for (const tool of tools) {
+        const name = tool.name;
+        if (typeof name === 'string' && isDeferred(name)) {
+            deferredTools.push(tool);
+        }
+        else {
+            staticTools.push(tool);
+        }
+    }
+    if (staticTools.length === 0) {
+        return tools;
+    }
+    const last = staticTools[staticTools.length - 1];
+    // Already marked? Don't double-clone.
+    if (last.extras != null &&
+        'cache_control' in last.extras &&
+        last.extras.cache_control != null) {
+        if (deferredTools.length === 0)
+            return tools;
+        return [...staticTools, ...deferredTools];
+    }
+    const wrapped = Object.assign(Object.create(Object.getPrototypeOf(last) ?? Object.prototype), last, {
+        extras: {
+            ...(last.extras ?? {}),
+            cache_control: { type: 'ephemeral' },
+        },
+    });
+    staticTools[staticTools.length - 1] = wrapped;
+    return [...staticTools, ...deferredTools];
+}
+
+exports.makeIsDeferred = makeIsDeferred;
+exports.partitionAndMarkAnthropicToolCache = partitionAndMarkAnthropicToolCache;
+//# sourceMappingURL=anthropicToolCache.cjs.map

package/dist/cjs/messages/anthropicToolCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropicToolCache.cjs","sources":["../../../src/messages/anthropicToolCache.ts"],"sourcesContent":["/**\n * Anthropic prompt-caching helper for the `tools[]` request field.\n *\n * Anthropic accepts `cache_control: { type: 'ephemeral' }` on individual\n * tool definitions. Whichever tool carries the marker becomes the end of\n * a cached prefix: `tools[0..N]` (everything up to and including the\n * marked tool) is cached and rebated on subsequent matching requests.\n *\n * For agents that mix static and deferred (lazily-discovered) tools, the\n * winning configuration is:\n *\n *   1. Stable-partition tools so all *static* (non-deferred) tools come\n *      first and discovered-deferred tools come last.\n *   2. Stamp `cache_control` on the LAST static tool.\n *\n * That way, the cached prefix covers exactly the static tool inventory.\n * Discovered tools that show up later (or vary turn-to-turn as new ones\n * get discovered) never invalidate the prefix because they sit *after*\n * the breakpoint.\n *\n * LangChain's Anthropic adapter passes the marker through via\n * `tool.extras.cache_control` (`AnthropicToolExtrasSchema`), so we set\n * it as an `extras` field on a fresh wrapper around the tool — never\n * mutating the original tool instance, since callers may share them\n * across runs.\n */\n\nimport type { GraphTools } from '@/types';\n\n/**\n * Returns a callable that reports whether a given tool *name* is deferred\n * according to the supplied registry of tool definitions. Tools without\n * a registry entry are treated as non-deferred (i.e. static), matching\n * the host-supplied `graphTools` semantics elsewhere in the SDK.\n */\nexport function makeIsDeferred(\n  toolDefinitions:\n    | ReadonlyArray<{ name: string; defer_loading?: boolean }>\n    | undefined\n): (toolName: string) => boolean {\n  if (toolDefinitions == null || toolDefinitions.length === 0) {\n    return () => false;\n  }\n  const deferred = new Set<string>();\n  for (const def of toolDefinitions) {\n    if (def.defer_loading === true) deferred.add(def.name);\n  }\n  if (deferred.size === 0) return () => false;\n  return (name) => deferred.has(name);\n}\n\n/**\n * Stable-partition `tools` into [static..., deferred...] and stamp the\n * Anthropic `cache_control: ephemeral` marker on the last static tool.\n *\n * If `tools` is undefined or empty, or no entry has a usable `.name`,\n * returns the input unchanged. If there are no static tools at all,\n * also returns unchanged (nothing to cache).\n *\n * The original tool instances are never mutated. The marked entry is a\n * shallow wrapper that preserves the prototype chain so downstream\n * `instanceof` checks still pass. `extras` is merged so any existing\n * `providerToolDefinition` / other extras the host attached are kept.\n */\nexport function partitionAndMarkAnthropicToolCache(\n  tools: GraphTools | undefined,\n  isDeferred: (toolName: string) => boolean\n): GraphTools | undefined {\n  if (tools == null || tools.length === 0) return tools;\n\n  // Use unknown[] internally to avoid GraphTools' union-array variance\n  // (each member is one of three array types). We cast back to\n  // GraphTools when returning.\n  const staticTools: unknown[] = [];\n  const deferredTools: unknown[] = [];\n\n  for (const tool of tools) {\n    const name = (tool as { name?: unknown }).name;\n    if (typeof name === 'string' && isDeferred(name)) {\n      deferredTools.push(tool);\n    } else {\n      staticTools.push(tool);\n    }\n  }\n\n  if (staticTools.length === 0) {\n    return tools;\n  }\n\n  const last = staticTools[staticTools.length - 1] as {\n    extras?: Record<string, unknown>;\n  };\n  // Already marked? Don't double-clone.\n  if (\n    last.extras != null &&\n    'cache_control' in last.extras &&\n    (last.extras as { cache_control?: unknown }).cache_control != null\n  ) {\n    if (deferredTools.length === 0) return tools;\n    return [...staticTools, ...deferredTools] as GraphTools;\n  }\n\n  const wrapped = Object.assign(\n    Object.create(Object.getPrototypeOf(last) ?? Object.prototype),\n    last,\n    {\n      extras: {\n        ...((last.extras as Record<string, unknown> | undefined) ?? {}),\n        cache_control: { type: 'ephemeral' as const },\n      },\n    }\n  );\n\n  staticTools[staticTools.length - 1] = wrapped;\n  return [...staticTools, ...deferredTools] as GraphTools;\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AAIH;;;;;AAKG;AACG,SAAU,cAAc,CAC5B,eAEa,EAAA;IAEb,IAAI,eAAe,IAAI,IAAI,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE;AAC3D,QAAA,OAAO,MAAM,KAAK;IACpB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU;AAClC,IAAA,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE;AACjC,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,IAAI;AAAE,YAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;IACxD;AACA,IAAA,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC;AAAE,QAAA,OAAO,MAAM,KAAK;IAC3C,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;AACrC;AAEA;;;;;;;;;;;;AAYG;AACG,SAAU,kCAAkC,CAChD,KAA6B,EAC7B,UAAyC,EAAA;IAEzC,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;AAAE,QAAA,OAAO,KAAK;;;;IAKrD,MAAM,WAAW,GAAc,EAAE;IACjC,MAAM,aAAa,GAAc,EAAE;AAEnC,IAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACxB,QAAA,MAAM,IAAI,GAAI,IAA2B,CAAC,IAAI;QAC9C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE;AAChD,YAAA,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B;aAAO;AACL,YAAA,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;QACxB;IACF;AAEA,IAAA,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;AAC5B,QAAA,OAAO,KAAK;IACd;IAEA,MAAM,IAAI,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAE9C;;AAED,IAAA,IACE,IAAI,CAAC,MAAM,IAAI,IAAI;QACnB,eAAe,IAAI,IAAI,CAAC,MAAM;AAC7B,QAAA,IAAI,CAAC,MAAsC,CAAC,aAAa,IAAI,IAAI,EAClE;AACA,QAAA,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC;AAAE,YAAA,OAAO,KAAK;AAC5C,QAAA,OAAO,CAAC,GAAG,WAAW,EAAE,GAAG,aAAa,CAAe;IACzD;IAEA,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAC3B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,EAC9D,IAAI,EACJ;AACE,QAAA,MAAM,EAAE;AACN,YAAA,IAAK,IAAI,CAAC,MAA8C,IAAI,EAAE,CAAC;AAC/D,YAAA,aAAa,EAAE,EAAE,IAAI,EAAE,WAAoB,EAAE;AAC9C,SAAA;AACF,KAAA,CACF;IAED,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,OAAO;AAC7C,IAAA,OAAO,CAAC,GAAG,WAAW,EAAE,GAAG,aAAa,CAAe;AACzD;;;;;"}

package/dist/cjs/messages/prune.cjs

@@ -29,6 +29,31 @@ const PRESSURE_BANDS = [
 const MASKED_RESULT_MAX_CHARS = 300;
 /** Hard cap for the originalToolContent store (~2 MB estimated from char length). */
 const ORIGINAL_CONTENT_MAX_CHARS = 2_000_000;
+/**
+ * Evicts oldest entries from `map` (in Map-iteration / insertion order) until
+ * the cumulative char length of remaining values fits within
+ * `ORIGINAL_CONTENT_MAX_CHARS`.  Used by the recency-window carry-over merge
+ * path in Graph.ts to bound long-running session memory: the pruner enforces
+ * the cap inside its own `originalToolContent` map, but a key-wise union with
+ * recency carry-over bypasses that cap unless re-applied here.
+ */
+function enforceOriginalContentCap(map) {
+    let total = 0;
+    for (const v of map.values()) {
+        total += v.length;
+    }
+    while (total > ORIGINAL_CONTENT_MAX_CHARS && map.size > 0) {
+        const oldest = map.keys().next();
+        if (oldest.done === true) {
+            break;
+        }
+        const removed = map.get(oldest.value);
+        if (removed != null) {
+            total -= removed.length;
+        }
+        map.delete(oldest.value);
+    }
+}
 /** Minimum cumulative calibration ratio — provider can't count fewer tokens
  *  than our raw estimate (within reason). Prevents divide-by-zero edge cases. */
 const CALIBRATION_RATIO_MIN = 0.5;
@@ -1506,9 +1531,11 @@ function createPruneMessages(factoryParams) {
 }
 
 exports.DEFAULT_RESERVE_RATIO = DEFAULT_RESERVE_RATIO;
+exports.ORIGINAL_CONTENT_MAX_CHARS = ORIGINAL_CONTENT_MAX_CHARS;
 exports.calculateTotalTokens = calculateTotalTokens;
 exports.checkValidNumber = checkValidNumber;
 exports.createPruneMessages = createPruneMessages;
+exports.enforceOriginalContentCap = enforceOriginalContentCap;
 exports.getMessagesWithinTokenLimit = getMessagesWithinTokenLimit;
 exports.maskConsumedToolResults = maskConsumedToolResults;
 exports.preFlightTruncateToolCallInputs = preFlightTruncateToolCallInputs;