@librechat/agents 3.2.41 → 3.2.43

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

@@ -26,6 +26,19 @@ export type ReaddirEntry = {
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
 };
+/**
+ * Thrown when a {@link WorkspaceFS} operation is abandoned by a client-side
+ * backstop timeout (a stalled remote/sandbox RPC that never returned). This is
+ * DISTINCT from "file not found": callers that catch generic FS failures as
+ * absence — e.g. a pre-read before an overwrite, or a `stat` before snapshotting
+ * — MUST rethrow this so a stalled read isn't mistaken for a missing file (which
+ * would otherwise overwrite an existing file or snapshot it as absent).
+ */
+export declare class WorkspaceClientTimeoutError extends Error {
+    readonly code = "WORKSPACE_CLIENT_TIMEOUT";
+    constructor(message: string);
+}
+export declare function isWorkspaceClientTimeoutError(error: unknown): error is WorkspaceClientTimeoutError;
 export interface WorkspaceFS {
     readFile(path: string, encoding: 'utf8'): Promise<string>;
     readFile(path: string): Promise<Buffer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.41",
+  "version": "3.2.43",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/agents/AgentContext.ts

@@ -14,6 +14,7 @@ import {
   buildAnthropicCacheControl,
   buildBedrockCachePoint,
   resolvePromptCacheTtl,
+  resolveBedrockPromptCacheTtl,
   cloneMessage,
   type PromptCacheTtl,
 } from '@/messages/cache';
@@ -846,6 +847,8 @@ export class AgentContext {
     const bedrockOptions = this.clientOptions as
       | t.BedrockAnthropicClientOptions
       | undefined;
+    // Nova accepts system/message cachePoints (only the tool checkpoint is
+    // Claude-only), so this is gated on promptCache alone.
     return bedrockOptions?.promptCache === true;
   }
 
@@ -867,14 +870,18 @@ export class AgentContext {
   }
 
   /**
-   * Resolved TTL for Bedrock prompt-cache checkpoints (default `'1h'`).
-   * Models that don't support the 1-hour TTL downgrade to 5m server-side.
+   * Resolved TTL for Bedrock prompt-cache checkpoints (default `'1h'` on Claude).
+   * Claude models downgrade an unsupported 1h to 5m server-side; non-Claude
+   * models (Nova) reject the extended TTL, so they are clamped to 5m.
    */
   private getBedrockPromptCacheTtl(): PromptCacheTtl {
     const bedrockOptions = this.clientOptions as
       | t.BedrockAnthropicClientOptions
       | undefined;
-    return resolvePromptCacheTtl(bedrockOptions?.promptCacheTtl);
+    return resolveBedrockPromptCacheTtl(
+      bedrockOptions?.promptCacheTtl,
+      (bedrockOptions as { model?: string } | undefined)?.model
+    );
   }
 
   private buildSystemMessage({

package/src/graphs/Graph.ts

@@ -28,6 +28,8 @@ import {
   syncBudgetDerivedFields,
   addTailCacheControl,
   resolvePromptCacheTtl,
+  resolveBedrockPromptCacheTtl,
+  supportsBedrockToolCache,
   getMessageId,
   makeIsDeferred,
   partitionAndMarkAnthropicToolCache,
@@ -1442,11 +1444,19 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             | undefined
         )?.promptCache === true
       ) {
-        toolsForBinding =
-          partitionAndMarkBedrockToolCache(
-            rawToolsForBinding,
-            makeIsDeferred(agentContext.toolDefinitions)
-          ) ?? rawToolsForBinding;
+        const bedrockModel = (
+          agentContext.clientOptions as { model?: string } | undefined
+        )?.model;
+        // An omitted model falls back to LangChain's default Claude model (which
+        // supports tool caching); only an explicit non-Claude model (e.g. Nova)
+        // skips tool marking so its stray marker never leaks into toolConfig.
+        if (bedrockModel == null || supportsBedrockToolCache(bedrockModel)) {
+          toolsForBinding =
+            partitionAndMarkBedrockToolCache(
+              rawToolsForBinding,
+              makeIsDeferred(agentContext.toolDefinitions)
+            ) ?? rawToolsForBinding;
+        }
       }
 
       let model =
@@ -1790,6 +1800,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             | t.ProviderOptionsMap[Providers.OPENROUTER]
             | undefined
         )?.promptCache === true;
+      // Message/system cache points work on all cache-capable Bedrock models,
+      // including Nova (verified live: HTTP 200 with cacheWriteInputTokens). Only
+      // the tool checkpoint is Claude-only, so this is gated on promptCache alone.
       const bedrockPromptCacheEnabled =
         agentContext.provider === Providers.BEDROCK &&
         (
@@ -1868,9 +1881,14 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         const bedrockOptions = agentContext.clientOptions as
           | t.BedrockAnthropicClientOptions
           | undefined;
+        // Non-Claude models (Nova) reject the extended 1h TTL, so resolve it
+        // against the model — message/system caching stays on, clamped to 5m.
         finalMessages = addBedrockTailCacheControl<BaseMessage>(
           finalMessages,
-          resolvePromptCacheTtl(bedrockOptions?.promptCacheTtl)
+          resolveBedrockPromptCacheTtl(
+            bedrockOptions?.promptCacheTtl,
+            (bedrockOptions as { model?: string } | undefined)?.model
+          )
         );
       }
 

package/src/llm/bedrock/index.ts

@@ -39,7 +39,11 @@ import {
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,
 } from './utils';
-import { resolvePromptCacheTtl, type PromptCacheTtl } from '@/messages/cache';
+import {
+  resolveBedrockPromptCacheTtl,
+  supportsBedrockToolCache,
+  type PromptCacheTtl,
+} from '@/messages/cache';
 import { insertBedrockToolCachePoint } from './toolCache';
 
 /**
@@ -134,12 +138,24 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
    */
   serviceTier?: ServiceTierType;
 
+  /**
+   * The configured model id, captured at construction so it survives the
+   * temporary `this.model` swap to an application-inference-profile ARN during
+   * generation. Used to gate the Bedrock tool cache point to Claude models
+   * (see {@link supportsBedrockToolCache}).
+   */
+  private readonly cacheModelId: string;
+
   constructor(fields?: CustomChatBedrockConverseInput) {
     super(fields);
     this.promptCache = fields?.promptCache;
     this.promptCacheTtl = fields?.promptCacheTtl;
     this.applicationInferenceProfile = fields?.applicationInferenceProfile;
     this.serviceTier = fields?.serviceTier;
+    // `super(fields)` initializes `this.model` to LangChain's default Claude
+    // model when `fields.model` is omitted, so fall back to it rather than ''
+    // (which would treat the default Claude model as tool-cache-unsupported).
+    this.cacheModelId = fields?.model ?? this.model;
   }
 
   static lc_name(): string {
@@ -164,11 +180,11 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
   } {
     const baseParams = super.invocationParams(options);
     const toolConfig =
-      this.promptCache === true
+      this.promptCache === true && supportsBedrockToolCache(this.cacheModelId)
         ? insertBedrockToolCachePoint(
           baseParams.toolConfig,
           true,
-          resolvePromptCacheTtl(this.promptCacheTtl)
+          resolveBedrockPromptCacheTtl(this.promptCacheTtl, this.cacheModelId)
         )
         : baseParams.toolConfig;
 

package/src/llm/bedrock/llm.spec.ts

@@ -375,6 +375,7 @@ describe('CustomChatBedrockConverse', () => {
     test('adds a Bedrock cache point for directly-bound tools', () => {
       const model = new CustomChatBedrockConverse({
         ...baseConstructorArgs,
+        model: 'anthropic.claude-3-haiku-20240307-v1:0',
         promptCache: true,
       });
 
@@ -400,6 +401,7 @@ describe('CustomChatBedrockConverse', () => {
     test('defaults the tool cache point to the 1h extended TTL', () => {
       const model = new CustomChatBedrockConverse({
         ...baseConstructorArgs,
+        model: 'anthropic.claude-3-haiku-20240307-v1:0',
         promptCache: true,
       });
 
@@ -430,6 +432,7 @@ describe('CustomChatBedrockConverse', () => {
     test('honors an explicit 5m promptCacheTtl on the tool cache point', () => {
       const model = new CustomChatBedrockConverse({
         ...baseConstructorArgs,
+        model: 'anthropic.claude-3-haiku-20240307-v1:0',
         promptCache: true,
         promptCacheTtl: '5m',
       });
@@ -461,6 +464,7 @@ describe('CustomChatBedrockConverse', () => {
     test('adds the Bedrock cache point before deferred tools', () => {
       const model = new CustomChatBedrockConverse({
         ...baseConstructorArgs,
+        model: 'anthropic.claude-3-haiku-20240307-v1:0',
         promptCache: true,
       });
       const tools = partitionAndMarkBedrockToolCache(
@@ -500,6 +504,7 @@ describe('CustomChatBedrockConverse', () => {
     test('does not fall back to caching when Graph marks all tools deferred', () => {
       const model = new CustomChatBedrockConverse({
         ...baseConstructorArgs,
+        model: 'anthropic.claude-3-haiku-20240307-v1:0',
         promptCache: true,
       });
       const tools = partitionAndMarkBedrockToolCache(
@@ -525,6 +530,98 @@ describe('CustomChatBedrockConverse', () => {
         '__lc_bedrock_skip_tool_cache'
       );
     });
+
+    test('does not add a tool cache point for Amazon Nova models', () => {
+      // Regression for danny-avila/LibreChat#13838: Nova rejects a cachePoint in
+      // toolConfig.tools ("Malformed input request: #/toolConfig/tools/0:
+      // extraneous key [cachePoint] is not permitted"). Only the tool checkpoint
+      // is Claude-only — Nova still caches system/messages — so promptCache: true
+      // on Nova must omit just the tool cache point.
+      const model = new CustomChatBedrockConverse({
+        ...baseConstructorArgs,
+        model: 'us.amazon.nova-pro-v1:0',
+        promptCache: true,
+      });
+
+      const params = model.invocationParams({
+        tools: [
+          {
+            type: 'function',
+            function: {
+              name: 'direct_tool',
+              description: 'Direct tool',
+              parameters: { type: 'object', properties: {} },
+            },
+          },
+        ],
+      });
+
+      expect(getBedrockToolNames(params.toolConfig?.tools)).toEqual([
+        'direct_tool',
+      ]);
+      expect(JSON.stringify(params.toolConfig?.tools ?? [])).not.toContain(
+        'cachePoint'
+      );
+    });
+
+    test('still adds a tool cache point for a Claude model behind an inference profile', () => {
+      // The configured Claude model id is captured at construction, so the gate
+      // survives the application-inference-profile ARN swap during generation.
+      const model = new CustomChatBedrockConverse({
+        ...baseConstructorArgs,
+        model: 'anthropic.claude-sonnet-4-5-20250929-v1:0',
+        applicationInferenceProfile:
+          'arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/test',
+        promptCache: true,
+      });
+
+      const params = model.invocationParams({
+        tools: [
+          {
+            type: 'function',
+            function: {
+              name: 'direct_tool',
+              description: 'Direct tool',
+              parameters: { type: 'object', properties: {} },
+            },
+          },
+        ],
+      });
+
+      expect(getBedrockToolNames(params.toolConfig?.tools)).toEqual([
+        'direct_tool',
+        'cachePoint',
+      ]);
+    });
+
+    test('still adds a tool cache point when model is omitted (default is Claude)', () => {
+      // When no model is provided, LangChain initializes this.model to a default
+      // Claude model, so the tool cache point must still apply.
+      const model = new CustomChatBedrockConverse({
+        ...baseConstructorArgs,
+        promptCache: true,
+      });
+
+      expect(model.model).toMatch(/claude/i);
+
+      const params = model.invocationParams({
+        tools: [
+          {
+            type: 'function',
+            function: {
+              name: 'direct_tool',
+              description: 'Direct tool',
+              parameters: { type: 'object', properties: {} },
+            },
+          },
+        ],
+      });
+
+      expect(getBedrockToolNames(params.toolConfig?.tools)).toEqual([
+        'direct_tool',
+        'cachePoint',
+      ]);
+    });
   });
 
   describe('contentBlockIndex cleanup', () => {

package/src/messages/cache.test.ts

@@ -19,6 +19,8 @@ import {
   buildAnthropicCacheControl,
   buildBedrockCachePoint,
   resolvePromptCacheTtl,
+  resolveBedrockPromptCacheTtl,
+  supportsBedrockToolCache,
   DEFAULT_PROMPT_CACHE_TTL,
 } from './cache';
 import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
@@ -895,6 +897,67 @@ describe('synthetic skill/meta messages are not cache-anchored', () => {
   });
 });
 
+describe('supportsBedrockToolCache', () => {
+  test('returns true for Claude model ids (incl. cross-region + profile)', () => {
+    expect(
+      supportsBedrockToolCache('anthropic.claude-3-5-sonnet-20241022-v2:0')
+    ).toBe(true);
+    expect(
+      supportsBedrockToolCache('us.anthropic.claude-sonnet-4-5-20250929-v1:0')
+    ).toBe(true);
+    expect(supportsBedrockToolCache('anthropic.claude-opus-4-6-v1')).toBe(true);
+  });
+
+  test('returns false for Nova and other non-Claude families (tool cache only)', () => {
+    // Nova accepts system/message cachePoints but rejects the tool checkpoint.
+    expect(supportsBedrockToolCache('us.amazon.nova-pro-v1:0')).toBe(false);
+    expect(supportsBedrockToolCache('amazon.nova-lite-v1:0')).toBe(false);
+    expect(supportsBedrockToolCache('meta.llama3-1-70b-instruct-v1:0')).toBe(
+      false
+    );
+    expect(supportsBedrockToolCache('mistral.mistral-large-2407-v1:0')).toBe(
+      false
+    );
+  });
+
+  test('returns false for empty / missing model', () => {
+    expect(supportsBedrockToolCache('')).toBe(false);
+    expect(supportsBedrockToolCache(undefined)).toBe(false);
+    expect(supportsBedrockToolCache(null)).toBe(false);
+  });
+});
+
+describe('resolveBedrockPromptCacheTtl', () => {
+  test('Claude: defaults to 1h and honors an explicit ttl', () => {
+    const claude = 'us.anthropic.claude-sonnet-4-5-20250929-v1:0';
+    expect(resolveBedrockPromptCacheTtl(undefined, claude)).toBe('1h');
+    expect(resolveBedrockPromptCacheTtl('1h', claude)).toBe('1h');
+    expect(resolveBedrockPromptCacheTtl('5m', claude)).toBe('5m');
+  });
+
+  test('Nova: clamps to 5m even when 1h is configured (extended TTL Anthropic-only)', () => {
+    const nova = 'us.amazon.nova-lite-v1:0';
+    expect(resolveBedrockPromptCacheTtl(undefined, nova)).toBe('5m');
+    expect(resolveBedrockPromptCacheTtl('1h', nova)).toBe('5m');
+    expect(resolveBedrockPromptCacheTtl('5m', nova)).toBe('5m');
+  });
+
+  test('other non-Claude families clamp to 5m', () => {
+    expect(
+      resolveBedrockPromptCacheTtl('1h', 'meta.llama3-1-70b-instruct-v1:0')
+    ).toBe('5m');
+    expect(
+      resolveBedrockPromptCacheTtl('1h', 'mistral.mistral-large-2407-v1:0')
+    ).toBe('5m');
+  });
+
+  test('omitted model defaults to Claude behavior (1h)', () => {
+    expect(resolveBedrockPromptCacheTtl(undefined, undefined)).toBe('1h');
+    expect(resolveBedrockPromptCacheTtl(undefined, null)).toBe('1h');
+    expect(resolveBedrockPromptCacheTtl('1h', undefined)).toBe('1h');
+  });
+});
+
 describe('stripAnthropicCacheControl', () => {
   it('removes cache_control fields from content blocks', () => {
     const messages: TestMsg[] = [

package/src/messages/cache.ts

@@ -79,6 +79,57 @@ export function buildBedrockCachePoint(
   return ttl === '1h' ? { type: 'default', ttl: '1h' } : { type: 'default' };
 }
 
+/**
+ * Whether a Bedrock model id is an Anthropic Claude model. Claude is the only
+ * Bedrock family that accepts the explicit cache features below; Amazon Nova and
+ * others reject them. Matches both the `anthropic.` and cross-region
+ * (`us.anthropic.`) / bare `claude` forms.
+ */
+function isBedrockAnthropicModel(model: string | undefined | null): boolean {
+  return typeof model === 'string' && /claude|anthropic/i.test(model);
+}
+
+/**
+ * A `cachePoint` under `toolConfig.tools` is only accepted on Anthropic Claude
+ * models. Amazon Nova rejects it outright — `Malformed input request:
+ * #/toolConfig/tools/0: extraneous key [cachePoint] is not permitted` — even
+ * though it accepts `cachePoint` in `system` and `messages` (verified live:
+ * Nova returns HTTP 200 with real `cacheWriteInputTokens` for both). Per the AWS
+ * prompt-caching docs the support table lists `tools` for Claude only.
+ *
+ * Gate ONLY the tool checkpoint on this, so a `promptCache: true` config on Nova
+ * keeps its valid message/system caching instead of either 400-ing (tool point)
+ * or losing caching entirely.
+ *
+ * @see https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
+ * @see https://github.com/danny-avila/LibreChat/issues/13838
+ */
+export function supportsBedrockToolCache(
+  model: string | undefined | null
+): boolean {
+  return isBedrockAnthropicModel(model);
+}
+
+/**
+ * Resolve the Bedrock `cachePoint` TTL for a model. The extended `1h` TTL is
+ * Anthropic-only: non-Claude models (e.g. Nova) hard-reject it with
+ * `Extended TTL prompt caching is only supported for Anthropic models`, so they
+ * are clamped to `5m` even when `1h` is configured (verified live). An omitted
+ * model defaults to a Claude model, and Claude downgrades an unsupported `1h` to
+ * `5m` server-side, so the `1h` default is safe for the Claude/undefined paths.
+ *
+ * @see https://github.com/danny-avila/LibreChat/issues/13838
+ */
+export function resolveBedrockPromptCacheTtl(
+  ttl: PromptCacheTtl | undefined,
+  model: string | undefined | null
+): PromptCacheTtl {
+  if (model != null && !isBedrockAnthropicModel(model)) {
+    return '5m';
+  }
+  return resolvePromptCacheTtl(ttl);
+}
+
 /**
  * Deep clones a message's content to prevent mutation of the original.
  */