@librechat/agents 3.2.39 → 3.2.42

package/dist/types/messages/cache.d.ts

@@ -47,6 +47,23 @@ type BedrockCachePoint = {
  * legacy default), `'1h'` adds the extended-cache `ttl`.
  */
 export declare function buildBedrockCachePoint(ttl?: PromptCacheTtl): BedrockCachePoint;
+/**
+ * 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. This is a capability gate (the key is rejected
+ * outright), distinct from the TTL value which Bedrock downgrades gracefully.
+ *
+ * @see https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
+ * @see https://github.com/danny-avila/LibreChat/issues/13838
+ */
+export declare function supportsBedrockToolCache(model: string | undefined | null): boolean;
 /**
  * Clones a message with new content. For LangChain BaseMessage instances,
  * constructs a proper class instance so that `instanceof` checks are preserved

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

@@ -4,12 +4,12 @@ export declare const ReadFileToolDescription = "Read the contents of a file. Ret
 export declare const ReadFileToolSchema: {
     readonly type: "object";
     readonly properties: {
-        readonly file_path: {
+        readonly path: {
             readonly type: "string";
             readonly description: "Path to the file. For skill files: \"{skillName}/{path}\" (e.g. \"pdf-analyzer/src/utils.py\"). For code execution output: the path as returned by the execution tool.";
         };
     };
-    readonly required: readonly ["file_path"];
+    readonly required: readonly ["path"];
 };
 export declare const ReadFileToolDefinition: {
     readonly name: Constants.READ_FILE;
@@ -17,12 +17,12 @@ export declare const ReadFileToolDefinition: {
     readonly parameters: {
         readonly type: "object";
         readonly properties: {
-            readonly file_path: {
+            readonly path: {
                 readonly type: "string";
                 readonly description: "Path to the file. For skill files: \"{skillName}/{path}\" (e.g. \"pdf-analyzer/src/utils.py\"). For code execution output: the path as returned by the execution tool.";
             };
         };
-        readonly required: readonly ["file_path"];
+        readonly required: readonly ["path"];
     };
     readonly responseFormat: "content_and_artifact";
 };

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

@@ -8,6 +8,50 @@ type SpawnResult = {
 };
 export declare function getCloudflareWorkspaceRoot(config?: t.CloudflareSandboxExecutionConfig): string;
 export declare function resolveCloudflareSandbox(config: t.CloudflareSandboxExecutionConfig): Promise<t.CloudflareSandboxRuntime>;
+/**
+ * Client-side backstop timeout for a `sandbox.exec()` await: a few seconds beyond
+ * the exec's own `timeout` option, so a stalled exec that never honors `timeout`
+ * still can't outlast this.
+ */
+export declare function clientExecTimeoutMs(timeoutMs: number): number;
+/**
+ * Bound a `sandbox.exec()` await with a CLIENT-SIDE timeout.
+ *
+ * The native Cloudflare Sandbox Durable Object `exec()` is effectively
+ * uncancellable from the host: `ExecOptions` has no `signal` (so
+ * `supportsExecSignal` is false for the native transport), and its `timeout`
+ * option is not reliably enforced when the container/RPC itself stalls — while
+ * the in-sandbox `timeout(1)` wrapper only bounds a command that is actually
+ * running. So a stalled exec (an unresponsive/cold container) otherwise hangs
+ * until the host's run-level abort, burning the whole run budget on one tool
+ * call. This race guarantees the host await settles within `timeoutMs`
+ * regardless of the transport.
+ *
+ * On timeout the underlying `exec` promise may keep running in the DO (a
+ * native-DO exec cannot be truly cancelled), so its late settlement is swallowed
+ * to avoid an unhandled rejection.
+ */
+export declare function withClientTimeout<T>(exec: Promise<T>, timeoutMs: number, label: string, options?: {
+    /**
+     * Detach the backstop timer from the event loop. Use ONLY when something else
+     * already settles the caller (e.g. the spawn path, where spawnLocalProcess's
+     * own timer resolves the child). The awaited direct-exec paths must leave it
+     * REF'd so the timeout is guaranteed to fire even if nothing else is pending.
+     */
+    unref?: boolean;
+    /** Invoked when the client timeout fires — e.g. abort a signal-aware exec. */
+    onTimeout?: () => void;
+}): Promise<T>;
+/**
+ * Run `sandbox.exec()` bounded by a client-side timeout, and — for signal-aware
+ * transports (e.g. the HTTP bridge, `supportsExecSignal === true`) — abort the
+ * underlying exec when the timeout fires instead of merely abandoning it. The
+ * native DO transport ignores `signal`, so it only gets the timeout. Leaves the
+ * backstop timer ref'd (this is an awaited direct-exec path).
+ */
+export declare function execWithClientTimeout(sandbox: t.CloudflareSandboxRuntime, command: string, options: t.CloudflareSandboxExecOptions, timeoutMs: number, label: string, runOptions?: {
+    unref?: boolean;
+}): Promise<t.CloudflareSandboxExecResult>;
 export declare function createCloudflareWorkspaceFS(config: t.CloudflareSandboxExecutionConfig): WorkspaceFS;
 export declare function createCloudflareLocalExecutionConfig(config: t.CloudflareSandboxExecutionConfig): t.LocalExecutionConfig;
 export declare function validateCloudflareBashCommand(command: string, args: readonly string[], config: t.CloudflareSandboxExecutionConfig): Promise<void>;

package/package.json

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

package/src/agents/AgentContext.ts

@@ -846,6 +846,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;
   }
 

package/src/graphs/Graph.ts

@@ -28,6 +28,7 @@ import {
   syncBudgetDerivedFields,
   addTailCacheControl,
   resolvePromptCacheTtl,
+  supportsBedrockToolCache,
   getMessageId,
   makeIsDeferred,
   partitionAndMarkAnthropicToolCache,
@@ -1442,11 +1443,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 +1799,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 &&
         (

package/src/hooks/__tests__/createWorkspacePolicyHook.test.ts

@@ -51,7 +51,7 @@ describe('createWorkspacePolicyHook', () => {
     const hook = createWorkspacePolicyHook({ root: workspace });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: 'src/x.ts' })
+      makeInput('read_file', { path: 'src/x.ts' })
     );
     expect(out.decision).toBe('allow');
   });
@@ -60,7 +60,7 @@ describe('createWorkspacePolicyHook', () => {
     const hook = createWorkspacePolicyHook({ root: workspace });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: join(workspace, 'src/x.ts') })
+      makeInput('read_file', { path: join(workspace, 'src/x.ts') })
     );
     expect(out.decision).toBe('allow');
   });
@@ -72,7 +72,7 @@ describe('createWorkspacePolicyHook', () => {
     });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: join(extra, 'lib/y.ts') })
+      makeInput('read_file', { path: join(extra, 'lib/y.ts') })
     );
     expect(out.decision).toBe('allow');
   });
@@ -81,7 +81,7 @@ describe('createWorkspacePolicyHook', () => {
     const hook = createWorkspacePolicyHook({ root: workspace });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: '/etc/passwd' })
+      makeInput('read_file', { path: '/etc/passwd' })
     );
     expect(out.decision).toBe('ask');
     expect(out.reason).toContain('/etc/passwd');
@@ -93,7 +93,7 @@ describe('createWorkspacePolicyHook', () => {
     const out = await call(
       hook,
       makeInput('write_file', {
-        file_path: '/etc/foo',
+        path: '/etc/foo',
         content: 'malicious',
       })
     );
@@ -107,7 +107,7 @@ describe('createWorkspacePolicyHook', () => {
     });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: '/etc/passwd' })
+      makeInput('read_file', { path: '/etc/passwd' })
     );
     expect(out.decision).toBe('deny');
     expect(out.reason).toContain('/etc/passwd');
@@ -121,7 +121,7 @@ describe('createWorkspacePolicyHook', () => {
     const out = await call(
       hook,
       makeInput('edit_file', {
-        file_path: '/etc/foo',
+        path: '/etc/foo',
         old_text: 'a',
         new_text: 'b',
       })
@@ -136,7 +136,7 @@ describe('createWorkspacePolicyHook', () => {
     });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: '/etc/passwd' })
+      makeInput('read_file', { path: '/etc/passwd' })
     );
     expect(out.decision).toBe('allow');
   });
@@ -184,7 +184,7 @@ describe('createWorkspacePolicyHook', () => {
     });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: '/somewhere/else.ts' })
+      makeInput('read_file', { path: '/somewhere/else.ts' })
     );
     expect(out.reason).toBe('read_file blocked from /somewhere/else.ts');
   });
@@ -212,7 +212,7 @@ describe('createWorkspacePolicyHook', () => {
     const hook = createWorkspacePolicyHook({ root: '.' });
     const out = await call(
       hook,
-      makeInput('read_file', { file_path: resolve('.', 'src/x.ts') })
+      makeInput('read_file', { path: resolve('.', 'src/x.ts') })
     );
     expect(out.decision).toBe('allow');
   });
@@ -228,7 +228,7 @@ describe('createWorkspacePolicyHook', () => {
       });
       const out = await call(
         hook,
-        makeInput('read_file', { file_path: 'escape' })
+        makeInput('read_file', { path: 'escape' })
       );
       expect(out.decision).toBe('deny');
       expect(out.reason).toContain('escape');
@@ -245,7 +245,7 @@ describe('createWorkspacePolicyHook', () => {
       });
       const out = await call(
         hook,
-        makeInput('read_file', { file_path: join(altMount, 'file.ts') })
+        makeInput('read_file', { path: join(altMount, 'file.ts') })
       );
       expect(out.decision).toBe('allow');
     });

package/src/hooks/createWorkspacePolicyHook.ts

@@ -166,13 +166,14 @@ function extractCompileCheckPaths(input: Record<string, unknown>): string[] {
   return out;
 }
 
+// All built-in coding tools take their file/dir target in `path`.
+const extractPath: PathExtractor = (i) =>
+  typeof i.path === 'string' && i.path !== '' ? [i.path] : [];
+
 const DEFAULT_EXTRACTORS: Record<string, PathExtractor> = {
-  [Constants.READ_FILE]: (i) =>
-    typeof i.file_path === 'string' ? [i.file_path] : [],
-  [Constants.WRITE_FILE]: (i) =>
-    typeof i.file_path === 'string' ? [i.file_path] : [],
-  [Constants.EDIT_FILE]: (i) =>
-    typeof i.file_path === 'string' ? [i.file_path] : [],
+  [Constants.READ_FILE]: extractPath,
+  [Constants.WRITE_FILE]: extractPath,
+  [Constants.EDIT_FILE]: extractPath,
   [Constants.GREP_SEARCH]: (i) =>
     typeof i.path === 'string' && i.path !== '' ? [i.path] : [],
   [Constants.GLOB_SEARCH]: (i) =>

package/src/llm/bedrock/index.ts

@@ -39,7 +39,11 @@ import {
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,
 } from './utils';
-import { resolvePromptCacheTtl, type PromptCacheTtl } from '@/messages/cache';
+import {
+  resolvePromptCacheTtl,
+  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,7 +180,7 @@ 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,

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,7 @@ import {
   buildAnthropicCacheControl,
   buildBedrockCachePoint,
   resolvePromptCacheTtl,
+  supportsBedrockToolCache,
   DEFAULT_PROMPT_CACHE_TTL,
 } from './cache';
 import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
@@ -895,6 +896,36 @@ 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('stripAnthropicCacheControl', () => {
   it('removes cache_control fields from content blocks', () => {
     const messages: TestMsg[] = [

package/src/messages/cache.ts

@@ -79,6 +79,31 @@ export function buildBedrockCachePoint(
   return ttl === '1h' ? { type: 'default', ttl: '1h' } : { type: 'default' };
 }
 
+/**
+ * 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. This is a capability gate (the key is rejected
+ * outright), distinct from the TTL value which Bedrock downgrades gracefully.
+ *
+ * @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 {
+  if (typeof model !== 'string') {
+    return false;
+  }
+  return /claude|anthropic/i.test(model);
+}
+
 /**
  * Deep clones a message's content to prevent mutation of the original.
  */

package/src/tools/ReadFile.ts

@@ -22,13 +22,13 @@ CONSTRAINTS:
 export const ReadFileToolSchema = {
   type: 'object',
   properties: {
-    file_path: {
+    path: {
       type: 'string',
       description:
         'Path to the file. For skill files: "{skillName}/{path}" (e.g. "pdf-analyzer/src/utils.py"). For code execution output: the path as returned by the execution tool.',
     },
   },
-  required: ['file_path'],
+  required: ['path'],
 } as const;
 
 export const ReadFileToolDefinition = {