@langchain/anthropic 1.2.3 → 1.3.0-dev-1765432861398

package/dist/tools/bash.d.cts

@@ -0,0 +1,99 @@
+import { Bash20250124Command } from "./types.cjs";
+import * as zod195 from "zod";
+import * as zod_v4_core40 from "zod/v4/core";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+
+//#region src/tools/bash.d.ts
+/**
+ * Options for the bash tool.
+ */
+interface Bash20250124Options {
+  /**
+   * Optional execute function that handles bash command execution.
+   * This function receives the command input and should return the result
+   * (stdout and stderr combined, or an error message).
+   */
+  execute?: (args: Bash20250124Command) => string | Promise<string>;
+}
+/**
+ * Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables
+ * shell command execution in a persistent bash session.
+ *
+ * The bash tool provides Claude with:
+ * - **Persistent bash session**: Maintains state between commands
+ * - **Shell command execution**: Run any shell command
+ * - **Environment access**: Access to environment variables and working directory
+ * - **Command chaining**: Support for pipes, redirects, and scripting
+ *
+ * Available commands:
+ * - Execute a command: `{ command: "ls -la" }`
+ * - Restart the session: `{ restart: true }`
+ *
+ * @warning The bash tool provides direct system access. Implement safety measures
+ * such as running in isolated environments (Docker/VM), command filtering,
+ * and resource limits.
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ * import { execSync } from "child_process";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * const bash = tools.bash_20250124({
+ *   execute: async (args) => {
+ *     if (args.restart) {
+ *       // Reset session state
+ *       return "Bash session restarted";
+ *     }
+ *     try {
+ *       const output = execSync(args.command!, {
+ *         encoding: "utf-8",
+ *         timeout: 30000,
+ *       });
+ *       return output;
+ *     } catch (error) {
+ *       return `Error: ${error.message}`;
+ *     }
+ *   },
+ * });
+ *
+ * const llmWithBash = llm.bindTools([bash]);
+ * const response = await llmWithBash.invoke(
+ *   "List all Python files in the current directory"
+ * );
+ *
+ * // Outputs: "bash"
+ * console.log(response.tool_calls[0].name);
+ * // Outputs: "ls -la *.py 2>/dev/null || echo \"No Python files found in the current directory\"
+ * console.log(response.tool_calls[0].args.command);
+ * ```
+ *
+ * @example Multi-step automation
+ * ```typescript
+ * // Claude can chain commands in a persistent session:
+ * // 1. cd /tmp
+ * // 2. echo "Hello" > test.txt
+ * // 3. cat test.txt  // Works because we're still in /tmp
+ * ```
+ *
+ * @param options - Configuration options for the bash tool
+ * @param options.execute - Function that handles bash command execution
+ * @returns The bash tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool
+ */
+declare function bash_20250124(options?: Bash20250124Options): DynamicStructuredTool<zod195.ZodUnion<readonly [zod195.ZodObject<{
+  command: zod195.ZodString;
+}, zod_v4_core40.$strip>, zod195.ZodObject<{
+  restart: zod195.ZodLiteral<true>;
+}, zod_v4_core40.$strip>]>, {
+  command: string;
+} | {
+  restart: true;
+}, unknown, string>;
+//#endregion
+export { Bash20250124Options, bash_20250124 };
+//# sourceMappingURL=bash.d.cts.map

package/dist/tools/bash.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.cts","names":["zod_v4_core40","DynamicStructuredTool","Bash20250124Command","Bash20250124Options","Promise","bash_20250124","zod195","ZodString","$strip","ZodObject","ZodLiteral","ZodUnion"],"sources":["../../src/tools/bash.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type Bash20250124Command } from \"./types.js\";\n/**\n * Options for the bash tool.\n */\nexport interface Bash20250124Options {\n    /**\n     * Optional execute function that handles bash command execution.\n     * This function receives the command input and should return the result\n     * (stdout and stderr combined, or an error message).\n     */\n    execute?: (args: Bash20250124Command) => string | Promise<string>;\n}\n/**\n * Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables\n * shell command execution in a persistent bash session.\n *\n * The bash tool provides Claude with:\n * - **Persistent bash session**: Maintains state between commands\n * - **Shell command execution**: Run any shell command\n * - **Environment access**: Access to environment variables and working directory\n * - **Command chaining**: Support for pipes, redirects, and scripting\n *\n * Available commands:\n * - Execute a command: `{ command: \"ls -la\" }`\n * - Restart the session: `{ restart: true }`\n *\n * @warning The bash tool provides direct system access. Implement safety measures\n * such as running in isolated environments (Docker/VM), command filtering,\n * and resource limits.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import { execSync } from \"child_process\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const bash = tools.bash_20250124({\n *   execute: async (args) => {\n *     if (args.restart) {\n *       // Reset session state\n *       return \"Bash session restarted\";\n *     }\n *     try {\n *       const output = execSync(args.command!, {\n *         encoding: \"utf-8\",\n *         timeout: 30000,\n *       });\n *       return output;\n *     } catch (error) {\n *       return `Error: ${error.message}`;\n *     }\n *   },\n * });\n *\n * const llmWithBash = llm.bindTools([bash]);\n * const response = await llmWithBash.invoke(\n *   \"List all Python files in the current directory\"\n * );\n *\n * // Outputs: \"bash\"\n * console.log(response.tool_calls[0].name);\n * // Outputs: \"ls -la *.py 2>/dev/null || echo \\\"No Python files found in the current directory\\\"\n * console.log(response.tool_calls[0].args.command);\n * ```\n *\n * @example Multi-step automation\n * ```typescript\n * // Claude can chain commands in a persistent session:\n * // 1. cd /tmp\n * // 2. echo \"Hello\" > test.txt\n * // 3. cat test.txt  // Works because we're still in /tmp\n * ```\n *\n * @param options - Configuration options for the bash tool\n * @param options.execute - Function that handles bash command execution\n * @returns The bash tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool\n */\nexport declare function bash_20250124(options?: Bash20250124Options): DynamicStructuredTool<import(\"zod\").ZodUnion<readonly [import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    restart: import(\"zod\").ZodLiteral<true>;\n}, import(\"zod/v4/core\").$strip>]>, {\n    command: string;\n} | {\n    restart: true;\n}, unknown, string>;\n//# sourceMappingURL=bash.d.ts.map"],"mappings":";;;;;;;;;UAKiBG,mBAAAA;EAAAA;AA8EjB;;;;EAE+BG,OAF4GG,CAAAA,EAAAA,CAAAA,IAAAA,EAxEtHP,mBAwEsHO,EAAAA,GAAAA,MAAAA,GAxErFL,OAwEqFK,CAAAA,MAAAA,CAAAA;;;;;;AAAhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnEJ,aAAAA,WAAwBF,sBAAsBF,sBAEbK,MAAAA,CAFiDK,mBAE3EL,MAAAA,CAF4GG;WAAxEH,MAAAA,CACxCC;GAASP,aAAAA,CACXQ,MAAAA,GAEMF,MAAAA,CAFiBG;WAFoGH,MAAAA,CAGzHI;GAAUV,aAAAA,CACZQ,MAAAA"}

package/dist/tools/bash.d.ts

@@ -0,0 +1,99 @@
+import { Bash20250124Command } from "./types.js";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import * as zod195 from "zod";
+import * as zod_v4_core40 from "zod/v4/core";
+
+//#region src/tools/bash.d.ts
+/**
+ * Options for the bash tool.
+ */
+interface Bash20250124Options {
+  /**
+   * Optional execute function that handles bash command execution.
+   * This function receives the command input and should return the result
+   * (stdout and stderr combined, or an error message).
+   */
+  execute?: (args: Bash20250124Command) => string | Promise<string>;
+}
+/**
+ * Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables
+ * shell command execution in a persistent bash session.
+ *
+ * The bash tool provides Claude with:
+ * - **Persistent bash session**: Maintains state between commands
+ * - **Shell command execution**: Run any shell command
+ * - **Environment access**: Access to environment variables and working directory
+ * - **Command chaining**: Support for pipes, redirects, and scripting
+ *
+ * Available commands:
+ * - Execute a command: `{ command: "ls -la" }`
+ * - Restart the session: `{ restart: true }`
+ *
+ * @warning The bash tool provides direct system access. Implement safety measures
+ * such as running in isolated environments (Docker/VM), command filtering,
+ * and resource limits.
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ * import { execSync } from "child_process";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * const bash = tools.bash_20250124({
+ *   execute: async (args) => {
+ *     if (args.restart) {
+ *       // Reset session state
+ *       return "Bash session restarted";
+ *     }
+ *     try {
+ *       const output = execSync(args.command!, {
+ *         encoding: "utf-8",
+ *         timeout: 30000,
+ *       });
+ *       return output;
+ *     } catch (error) {
+ *       return `Error: ${error.message}`;
+ *     }
+ *   },
+ * });
+ *
+ * const llmWithBash = llm.bindTools([bash]);
+ * const response = await llmWithBash.invoke(
+ *   "List all Python files in the current directory"
+ * );
+ *
+ * // Outputs: "bash"
+ * console.log(response.tool_calls[0].name);
+ * // Outputs: "ls -la *.py 2>/dev/null || echo \"No Python files found in the current directory\"
+ * console.log(response.tool_calls[0].args.command);
+ * ```
+ *
+ * @example Multi-step automation
+ * ```typescript
+ * // Claude can chain commands in a persistent session:
+ * // 1. cd /tmp
+ * // 2. echo "Hello" > test.txt
+ * // 3. cat test.txt  // Works because we're still in /tmp
+ * ```
+ *
+ * @param options - Configuration options for the bash tool
+ * @param options.execute - Function that handles bash command execution
+ * @returns The bash tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool
+ */
+declare function bash_20250124(options?: Bash20250124Options): DynamicStructuredTool<zod195.ZodUnion<readonly [zod195.ZodObject<{
+  command: zod195.ZodString;
+}, zod_v4_core40.$strip>, zod195.ZodObject<{
+  restart: zod195.ZodLiteral<true>;
+}, zod_v4_core40.$strip>]>, {
+  command: string;
+} | {
+  restart: true;
+}, unknown, string>;
+//#endregion
+export { Bash20250124Options, bash_20250124 };
+//# sourceMappingURL=bash.d.ts.map

package/dist/tools/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","names":["zod_v4_core40","DynamicStructuredTool","Bash20250124Command","Bash20250124Options","Promise","bash_20250124","zod195","ZodString","$strip","ZodObject","ZodLiteral","ZodUnion"],"sources":["../../src/tools/bash.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type Bash20250124Command } from \"./types.js\";\n/**\n * Options for the bash tool.\n */\nexport interface Bash20250124Options {\n    /**\n     * Optional execute function that handles bash command execution.\n     * This function receives the command input and should return the result\n     * (stdout and stderr combined, or an error message).\n     */\n    execute?: (args: Bash20250124Command) => string | Promise<string>;\n}\n/**\n * Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables\n * shell command execution in a persistent bash session.\n *\n * The bash tool provides Claude with:\n * - **Persistent bash session**: Maintains state between commands\n * - **Shell command execution**: Run any shell command\n * - **Environment access**: Access to environment variables and working directory\n * - **Command chaining**: Support for pipes, redirects, and scripting\n *\n * Available commands:\n * - Execute a command: `{ command: \"ls -la\" }`\n * - Restart the session: `{ restart: true }`\n *\n * @warning The bash tool provides direct system access. Implement safety measures\n * such as running in isolated environments (Docker/VM), command filtering,\n * and resource limits.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import { execSync } from \"child_process\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const bash = tools.bash_20250124({\n *   execute: async (args) => {\n *     if (args.restart) {\n *       // Reset session state\n *       return \"Bash session restarted\";\n *     }\n *     try {\n *       const output = execSync(args.command!, {\n *         encoding: \"utf-8\",\n *         timeout: 30000,\n *       });\n *       return output;\n *     } catch (error) {\n *       return `Error: ${error.message}`;\n *     }\n *   },\n * });\n *\n * const llmWithBash = llm.bindTools([bash]);\n * const response = await llmWithBash.invoke(\n *   \"List all Python files in the current directory\"\n * );\n *\n * // Outputs: \"bash\"\n * console.log(response.tool_calls[0].name);\n * // Outputs: \"ls -la *.py 2>/dev/null || echo \\\"No Python files found in the current directory\\\"\n * console.log(response.tool_calls[0].args.command);\n * ```\n *\n * @example Multi-step automation\n * ```typescript\n * // Claude can chain commands in a persistent session:\n * // 1. cd /tmp\n * // 2. echo \"Hello\" > test.txt\n * // 3. cat test.txt  // Works because we're still in /tmp\n * ```\n *\n * @param options - Configuration options for the bash tool\n * @param options.execute - Function that handles bash command execution\n * @returns The bash tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool\n */\nexport declare function bash_20250124(options?: Bash20250124Options): DynamicStructuredTool<import(\"zod\").ZodUnion<readonly [import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    restart: import(\"zod\").ZodLiteral<true>;\n}, import(\"zod/v4/core\").$strip>]>, {\n    command: string;\n} | {\n    restart: true;\n}, unknown, string>;\n//# sourceMappingURL=bash.d.ts.map"],"mappings":";;;;;;;;;UAKiBG,mBAAAA;EAAAA;AA8EjB;;;;EAE+BG,OAF4GG,CAAAA,EAAAA,CAAAA,IAAAA,EAxEtHP,mBAwEsHO,EAAAA,GAAAA,MAAAA,GAxErFL,OAwEqFK,CAAAA,MAAAA,CAAAA;;;;;;AAAhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnEJ,aAAAA,WAAwBF,sBAAsBF,sBAEbK,MAAAA,CAFiDK,mBAE3EL,MAAAA,CAF4GG;WAAxEH,MAAAA,CACxCC;GAASP,aAAAA,CACXQ,MAAAA,GAEMF,MAAAA,CAFiBG;WAFoGH,MAAAA,CAGzHI;GAAUV,aAAAA,CACZQ,MAAAA"}

package/dist/tools/bash.js

@@ -0,0 +1,94 @@
+import { Bash20250124CommandSchema } from "./types.js";
+import { tool } from "@langchain/core/tools";
+
+//#region src/tools/bash.ts
+/**
+* Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables
+* shell command execution in a persistent bash session.
+*
+* The bash tool provides Claude with:
+* - **Persistent bash session**: Maintains state between commands
+* - **Shell command execution**: Run any shell command
+* - **Environment access**: Access to environment variables and working directory
+* - **Command chaining**: Support for pipes, redirects, and scripting
+*
+* Available commands:
+* - Execute a command: `{ command: "ls -la" }`
+* - Restart the session: `{ restart: true }`
+*
+* @warning The bash tool provides direct system access. Implement safety measures
+* such as running in isolated environments (Docker/VM), command filtering,
+* and resource limits.
+*
+* @example
+* ```typescript
+* import { ChatAnthropic, tools } from "@langchain/anthropic";
+* import { execSync } from "child_process";
+*
+* const llm = new ChatAnthropic({
+*   model: "claude-sonnet-4-5-20250929",
+* });
+*
+* const bash = tools.bash_20250124({
+*   execute: async (args) => {
+*     if (args.restart) {
+*       // Reset session state
+*       return "Bash session restarted";
+*     }
+*     try {
+*       const output = execSync(args.command!, {
+*         encoding: "utf-8",
+*         timeout: 30000,
+*       });
+*       return output;
+*     } catch (error) {
+*       return `Error: ${error.message}`;
+*     }
+*   },
+* });
+*
+* const llmWithBash = llm.bindTools([bash]);
+* const response = await llmWithBash.invoke(
+*   "List all Python files in the current directory"
+* );
+*
+* // Outputs: "bash"
+* console.log(response.tool_calls[0].name);
+* // Outputs: "ls -la *.py 2>/dev/null || echo \"No Python files found in the current directory\"
+* console.log(response.tool_calls[0].args.command);
+* ```
+*
+* @example Multi-step automation
+* ```typescript
+* // Claude can chain commands in a persistent session:
+* // 1. cd /tmp
+* // 2. echo "Hello" > test.txt
+* // 3. cat test.txt  // Works because we're still in /tmp
+* ```
+*
+* @param options - Configuration options for the bash tool
+* @param options.execute - Function that handles bash command execution
+* @returns The bash tool object that can be passed to `bindTools`
+*
+* @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool
+*/
+function bash_20250124(options) {
+	const name = "bash";
+	const bashTool = tool(options?.execute, {
+		name,
+		description: "A tool for executing bash commands",
+		schema: Bash20250124CommandSchema
+	});
+	bashTool.extras = {
+		...bashTool.extras ?? {},
+		providerToolDefinition: {
+			type: "bash_20250124",
+			name
+		}
+	};
+	return bashTool;
+}
+
+//#endregion
+export { bash_20250124 };
+//# sourceMappingURL=bash.js.map

package/dist/tools/bash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.js","names":["options?: Bash20250124Options"],"sources":["../../src/tools/bash.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport { tool } from \"@langchain/core/tools\";\nimport type { DynamicStructuredTool, ToolRuntime } from \"@langchain/core/tools\";\n\nimport {\n  Bash20250124CommandSchema,\n  type Bash20250124Command,\n} from \"./types.js\";\n\n/**\n * Options for the bash tool.\n */\nexport interface Bash20250124Options {\n  /**\n   * Optional execute function that handles bash command execution.\n   * This function receives the command input and should return the result\n   * (stdout and stderr combined, or an error message).\n   */\n  execute?: (args: Bash20250124Command) => string | Promise<string>;\n}\n\n/**\n * Creates an Anthropic bash tool for Claude 4 models and Claude 3.7 that enables\n * shell command execution in a persistent bash session.\n *\n * The bash tool provides Claude with:\n * - **Persistent bash session**: Maintains state between commands\n * - **Shell command execution**: Run any shell command\n * - **Environment access**: Access to environment variables and working directory\n * - **Command chaining**: Support for pipes, redirects, and scripting\n *\n * Available commands:\n * - Execute a command: `{ command: \"ls -la\" }`\n * - Restart the session: `{ restart: true }`\n *\n * @warning The bash tool provides direct system access. Implement safety measures\n * such as running in isolated environments (Docker/VM), command filtering,\n * and resource limits.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import { execSync } from \"child_process\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const bash = tools.bash_20250124({\n *   execute: async (args) => {\n *     if (args.restart) {\n *       // Reset session state\n *       return \"Bash session restarted\";\n *     }\n *     try {\n *       const output = execSync(args.command!, {\n *         encoding: \"utf-8\",\n *         timeout: 30000,\n *       });\n *       return output;\n *     } catch (error) {\n *       return `Error: ${error.message}`;\n *     }\n *   },\n * });\n *\n * const llmWithBash = llm.bindTools([bash]);\n * const response = await llmWithBash.invoke(\n *   \"List all Python files in the current directory\"\n * );\n *\n * // Outputs: \"bash\"\n * console.log(response.tool_calls[0].name);\n * // Outputs: \"ls -la *.py 2>/dev/null || echo \\\"No Python files found in the current directory\\\"\n * console.log(response.tool_calls[0].args.command);\n * ```\n *\n * @example Multi-step automation\n * ```typescript\n * // Claude can chain commands in a persistent session:\n * // 1. cd /tmp\n * // 2. echo \"Hello\" > test.txt\n * // 3. cat test.txt  // Works because we're still in /tmp\n * ```\n *\n * @param options - Configuration options for the bash tool\n * @param options.execute - Function that handles bash command execution\n * @returns The bash tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/bash-tool\n */\nexport function bash_20250124(options?: Bash20250124Options) {\n  const name = \"bash\";\n  const bashTool = tool(\n    options?.execute as (\n      input: unknown,\n      runtime: ToolRuntime<unknown, unknown>\n    ) => string | Promise<string>,\n    {\n      name,\n      description: \"A tool for executing bash commands\",\n      schema: Bash20250124CommandSchema,\n    }\n  );\n\n  bashTool.extras = {\n    ...(bashTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"bash_20250124\",\n      name,\n    } satisfies Anthropic.Beta.BetaToolBash20250124,\n  };\n\n  return bashTool as DynamicStructuredTool<\n    typeof Bash20250124CommandSchema,\n    Bash20250124Command,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,cAAcA,SAA+B;CAC3D,MAAM,OAAO;CACb,MAAM,WAAW,KACf,SAAS,SAIT;EACE;EACA,aAAa;EACb,QAAQ;CACT,EACF;CAED,SAAS,SAAS;EAChB,GAAI,SAAS,UAAU,CAAE;EACzB,wBAAwB;GACtB,MAAM;GACN;EACD;CACF;AAED,QAAO;AAMR"}

package/dist/tools/codeExecution.cjs

@@ -0,0 +1,70 @@
+
+//#region src/tools/codeExecution.ts
+/**
+* Creates a code execution tool that allows Claude to run Bash commands and manipulate files
+* in a secure, sandboxed environment. Claude can analyze data, create visualizations,
+* perform calculations, and process files.
+*
+* When this tool is provided, Claude automatically gains access to:
+* - **Bash commands**: Execute shell commands for system operations
+* - **File operations**: Create, view, and edit files directly
+*
+* @note This tool requires the beta header `code-execution-2025-08-25` in API requests.
+*
+* @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}
+* @param options - Configuration options for the code execution tool
+* @returns A code execution tool definition to be passed to the Anthropic API
+*
+* @example
+* ```typescript
+* import { ChatAnthropic, tools } from "@langchain/anthropic";
+*
+* const model = new ChatAnthropic({
+*   model: "claude-sonnet-4-5-20250929",
+* });
+*
+* // Basic usage - calculations and data analysis
+* const response = await model.invoke(
+*   "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+*
+* // File operations and visualization
+* const response2 = await model.invoke(
+*   "Create a matplotlib visualization of sales data and save it as chart.png",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+* ```
+*
+* @example Container reuse
+* ```typescript
+* // First request - creates a container
+* const response1 = await model.invoke(
+*   "Write a random number to /tmp/number.txt",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+*
+* // Extract container ID from response for reuse
+* const containerId = response1.response_metadata?.container?.id;
+*
+* // Second request - reuse container to access the file
+* const response2 = await model.invoke(
+*   "Read /tmp/number.txt and calculate its square",
+*   {
+*     tools: [tools.codeExecution_20250825()],
+*     // Pass container ID to reuse the same environment
+*   }
+* );
+* ```
+*/
+function codeExecution_20250825(options) {
+	return {
+		type: "code_execution_20250825",
+		name: "code_execution",
+		cache_control: options?.cacheControl
+	};
+}
+
+//#endregion
+exports.codeExecution_20250825 = codeExecution_20250825;
+//# sourceMappingURL=codeExecution.cjs.map

package/dist/tools/codeExecution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeExecution.cjs","names":["options?: CodeExecution20250825Options"],"sources":["../../src/tools/codeExecution.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport { type ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Options for the code execution tool.\n */\nexport interface CodeExecution20250825Options {\n  /**\n   * Create a cache control breakpoint at this content block.\n   */\n  cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;\n}\n\n/**\n * Creates a code execution tool that allows Claude to run Bash commands and manipulate files\n * in a secure, sandboxed environment. Claude can analyze data, create visualizations,\n * perform calculations, and process files.\n *\n * When this tool is provided, Claude automatically gains access to:\n * - **Bash commands**: Execute shell commands for system operations\n * - **File operations**: Create, view, and edit files directly\n *\n * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.\n *\n * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}\n * @param options - Configuration options for the code execution tool\n * @returns A code execution tool definition to be passed to the Anthropic API\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n *\n * const model = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * // Basic usage - calculations and data analysis\n * const response = await model.invoke(\n *   \"Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // File operations and visualization\n * const response2 = await model.invoke(\n *   \"Create a matplotlib visualization of sales data and save it as chart.png\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n * ```\n *\n * @example Container reuse\n * ```typescript\n * // First request - creates a container\n * const response1 = await model.invoke(\n *   \"Write a random number to /tmp/number.txt\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // Extract container ID from response for reuse\n * const containerId = response1.response_metadata?.container?.id;\n *\n * // Second request - reuse container to access the file\n * const response2 = await model.invoke(\n *   \"Read /tmp/number.txt and calculate its square\",\n *   {\n *     tools: [tools.codeExecution_20250825()],\n *     // Pass container ID to reuse the same environment\n *   }\n * );\n * ```\n */\nexport function codeExecution_20250825(\n  options?: CodeExecution20250825Options\n): ServerTool {\n  return {\n    type: \"code_execution_20250825\",\n    name: \"code_execution\",\n    cache_control: options?.cacheControl,\n  } satisfies Anthropic.Beta.BetaCodeExecutionTool20250825;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,uBACdA,SACY;AACZ,QAAO;EACL,MAAM;EACN,MAAM;EACN,eAAe,SAAS;CACzB;AACF"}

package/dist/tools/codeExecution.d.cts

@@ -0,0 +1,75 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/codeExecution.d.ts
+
+/**
+ * Options for the code execution tool.
+ */
+interface CodeExecution20250825Options {
+  /**
+   * Create a cache control breakpoint at this content block.
+   */
+  cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;
+}
+/**
+ * Creates a code execution tool that allows Claude to run Bash commands and manipulate files
+ * in a secure, sandboxed environment. Claude can analyze data, create visualizations,
+ * perform calculations, and process files.
+ *
+ * When this tool is provided, Claude automatically gains access to:
+ * - **Bash commands**: Execute shell commands for system operations
+ * - **File operations**: Create, view, and edit files directly
+ *
+ * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.
+ *
+ * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}
+ * @param options - Configuration options for the code execution tool
+ * @returns A code execution tool definition to be passed to the Anthropic API
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ *
+ * const model = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * // Basic usage - calculations and data analysis
+ * const response = await model.invoke(
+ *   "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ *
+ * // File operations and visualization
+ * const response2 = await model.invoke(
+ *   "Create a matplotlib visualization of sales data and save it as chart.png",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ * ```
+ *
+ * @example Container reuse
+ * ```typescript
+ * // First request - creates a container
+ * const response1 = await model.invoke(
+ *   "Write a random number to /tmp/number.txt",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ *
+ * // Extract container ID from response for reuse
+ * const containerId = response1.response_metadata?.container?.id;
+ *
+ * // Second request - reuse container to access the file
+ * const response2 = await model.invoke(
+ *   "Read /tmp/number.txt and calculate its square",
+ *   {
+ *     tools: [tools.codeExecution_20250825()],
+ *     // Pass container ID to reuse the same environment
+ *   }
+ * );
+ * ```
+ */
+declare function codeExecution_20250825(options?: CodeExecution20250825Options): ServerTool;
+//#endregion
+export { CodeExecution20250825Options, codeExecution_20250825 };
+//# sourceMappingURL=codeExecution.d.cts.map

package/dist/tools/codeExecution.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeExecution.d.cts","names":["Anthropic","ServerTool","CodeExecution20250825Options","Beta","BetaCacheControlEphemeral","codeExecution_20250825"],"sources":["../../src/tools/codeExecution.d.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport { type ServerTool } from \"@langchain/core/tools\";\n/**\n * Options for the code execution tool.\n */\nexport interface CodeExecution20250825Options {\n    /**\n     * Create a cache control breakpoint at this content block.\n     */\n    cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;\n}\n/**\n * Creates a code execution tool that allows Claude to run Bash commands and manipulate files\n * in a secure, sandboxed environment. Claude can analyze data, create visualizations,\n * perform calculations, and process files.\n *\n * When this tool is provided, Claude automatically gains access to:\n * - **Bash commands**: Execute shell commands for system operations\n * - **File operations**: Create, view, and edit files directly\n *\n * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.\n *\n * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}\n * @param options - Configuration options for the code execution tool\n * @returns A code execution tool definition to be passed to the Anthropic API\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n *\n * const model = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * // Basic usage - calculations and data analysis\n * const response = await model.invoke(\n *   \"Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // File operations and visualization\n * const response2 = await model.invoke(\n *   \"Create a matplotlib visualization of sales data and save it as chart.png\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n * ```\n *\n * @example Container reuse\n * ```typescript\n * // First request - creates a container\n * const response1 = await model.invoke(\n *   \"Write a random number to /tmp/number.txt\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // Extract container ID from response for reuse\n * const containerId = response1.response_metadata?.container?.id;\n *\n * // Second request - reuse container to access the file\n * const response2 = await model.invoke(\n *   \"Read /tmp/number.txt and calculate its square\",\n *   {\n *     tools: [tools.codeExecution_20250825()],\n *     // Pass container ID to reuse the same environment\n *   }\n * );\n * ```\n */\nexport declare function codeExecution_20250825(options?: CodeExecution20250825Options): ServerTool;\n//# sourceMappingURL=codeExecution.d.ts.map"],"mappings":";;;;;;;AAKA;AA+DwBK,UA/DPH,4BAAAA,CA+DwCA;;;;iBA3DtCF,SAAAA,CAAUG,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DVC,sBAAAA,WAAiCH,+BAA+BD"}

package/dist/tools/codeExecution.d.ts

@@ -0,0 +1,75 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { ServerTool } from "@langchain/core/tools";
+
+//#region src/tools/codeExecution.d.ts
+
+/**
+ * Options for the code execution tool.
+ */
+interface CodeExecution20250825Options {
+  /**
+   * Create a cache control breakpoint at this content block.
+   */
+  cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;
+}
+/**
+ * Creates a code execution tool that allows Claude to run Bash commands and manipulate files
+ * in a secure, sandboxed environment. Claude can analyze data, create visualizations,
+ * perform calculations, and process files.
+ *
+ * When this tool is provided, Claude automatically gains access to:
+ * - **Bash commands**: Execute shell commands for system operations
+ * - **File operations**: Create, view, and edit files directly
+ *
+ * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.
+ *
+ * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}
+ * @param options - Configuration options for the code execution tool
+ * @returns A code execution tool definition to be passed to the Anthropic API
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ *
+ * const model = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * // Basic usage - calculations and data analysis
+ * const response = await model.invoke(
+ *   "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ *
+ * // File operations and visualization
+ * const response2 = await model.invoke(
+ *   "Create a matplotlib visualization of sales data and save it as chart.png",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ * ```
+ *
+ * @example Container reuse
+ * ```typescript
+ * // First request - creates a container
+ * const response1 = await model.invoke(
+ *   "Write a random number to /tmp/number.txt",
+ *   { tools: [tools.codeExecution_20250825()] }
+ * );
+ *
+ * // Extract container ID from response for reuse
+ * const containerId = response1.response_metadata?.container?.id;
+ *
+ * // Second request - reuse container to access the file
+ * const response2 = await model.invoke(
+ *   "Read /tmp/number.txt and calculate its square",
+ *   {
+ *     tools: [tools.codeExecution_20250825()],
+ *     // Pass container ID to reuse the same environment
+ *   }
+ * );
+ * ```
+ */
+declare function codeExecution_20250825(options?: CodeExecution20250825Options): ServerTool;
+//#endregion
+export { CodeExecution20250825Options, codeExecution_20250825 };
+//# sourceMappingURL=codeExecution.d.ts.map

package/dist/tools/codeExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeExecution.d.ts","names":["Anthropic","ServerTool","CodeExecution20250825Options","Beta","BetaCacheControlEphemeral","codeExecution_20250825"],"sources":["../../src/tools/codeExecution.d.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport { type ServerTool } from \"@langchain/core/tools\";\n/**\n * Options for the code execution tool.\n */\nexport interface CodeExecution20250825Options {\n    /**\n     * Create a cache control breakpoint at this content block.\n     */\n    cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;\n}\n/**\n * Creates a code execution tool that allows Claude to run Bash commands and manipulate files\n * in a secure, sandboxed environment. Claude can analyze data, create visualizations,\n * perform calculations, and process files.\n *\n * When this tool is provided, Claude automatically gains access to:\n * - **Bash commands**: Execute shell commands for system operations\n * - **File operations**: Create, view, and edit files directly\n *\n * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.\n *\n * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}\n * @param options - Configuration options for the code execution tool\n * @returns A code execution tool definition to be passed to the Anthropic API\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n *\n * const model = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * // Basic usage - calculations and data analysis\n * const response = await model.invoke(\n *   \"Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // File operations and visualization\n * const response2 = await model.invoke(\n *   \"Create a matplotlib visualization of sales data and save it as chart.png\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n * ```\n *\n * @example Container reuse\n * ```typescript\n * // First request - creates a container\n * const response1 = await model.invoke(\n *   \"Write a random number to /tmp/number.txt\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // Extract container ID from response for reuse\n * const containerId = response1.response_metadata?.container?.id;\n *\n * // Second request - reuse container to access the file\n * const response2 = await model.invoke(\n *   \"Read /tmp/number.txt and calculate its square\",\n *   {\n *     tools: [tools.codeExecution_20250825()],\n *     // Pass container ID to reuse the same environment\n *   }\n * );\n * ```\n */\nexport declare function codeExecution_20250825(options?: CodeExecution20250825Options): ServerTool;\n//# sourceMappingURL=codeExecution.d.ts.map"],"mappings":";;;;;;;AAKA;AA+DwBK,UA/DPH,4BAAAA,CA+DwCA;;;;iBA3DtCF,SAAAA,CAAUG,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DVC,sBAAAA,WAAiCH,+BAA+BD"}

package/dist/tools/codeExecution.js

@@ -0,0 +1,69 @@
+//#region src/tools/codeExecution.ts
+/**
+* Creates a code execution tool that allows Claude to run Bash commands and manipulate files
+* in a secure, sandboxed environment. Claude can analyze data, create visualizations,
+* perform calculations, and process files.
+*
+* When this tool is provided, Claude automatically gains access to:
+* - **Bash commands**: Execute shell commands for system operations
+* - **File operations**: Create, view, and edit files directly
+*
+* @note This tool requires the beta header `code-execution-2025-08-25` in API requests.
+*
+* @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}
+* @param options - Configuration options for the code execution tool
+* @returns A code execution tool definition to be passed to the Anthropic API
+*
+* @example
+* ```typescript
+* import { ChatAnthropic, tools } from "@langchain/anthropic";
+*
+* const model = new ChatAnthropic({
+*   model: "claude-sonnet-4-5-20250929",
+* });
+*
+* // Basic usage - calculations and data analysis
+* const response = await model.invoke(
+*   "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+*
+* // File operations and visualization
+* const response2 = await model.invoke(
+*   "Create a matplotlib visualization of sales data and save it as chart.png",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+* ```
+*
+* @example Container reuse
+* ```typescript
+* // First request - creates a container
+* const response1 = await model.invoke(
+*   "Write a random number to /tmp/number.txt",
+*   { tools: [tools.codeExecution_20250825()] }
+* );
+*
+* // Extract container ID from response for reuse
+* const containerId = response1.response_metadata?.container?.id;
+*
+* // Second request - reuse container to access the file
+* const response2 = await model.invoke(
+*   "Read /tmp/number.txt and calculate its square",
+*   {
+*     tools: [tools.codeExecution_20250825()],
+*     // Pass container ID to reuse the same environment
+*   }
+* );
+* ```
+*/
+function codeExecution_20250825(options) {
+	return {
+		type: "code_execution_20250825",
+		name: "code_execution",
+		cache_control: options?.cacheControl
+	};
+}
+
+//#endregion
+export { codeExecution_20250825 };
+//# sourceMappingURL=codeExecution.js.map

package/dist/tools/codeExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeExecution.js","names":["options?: CodeExecution20250825Options"],"sources":["../../src/tools/codeExecution.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport { type ServerTool } from \"@langchain/core/tools\";\n\n/**\n * Options for the code execution tool.\n */\nexport interface CodeExecution20250825Options {\n  /**\n   * Create a cache control breakpoint at this content block.\n   */\n  cacheControl?: Anthropic.Beta.BetaCacheControlEphemeral;\n}\n\n/**\n * Creates a code execution tool that allows Claude to run Bash commands and manipulate files\n * in a secure, sandboxed environment. Claude can analyze data, create visualizations,\n * perform calculations, and process files.\n *\n * When this tool is provided, Claude automatically gains access to:\n * - **Bash commands**: Execute shell commands for system operations\n * - **File operations**: Create, view, and edit files directly\n *\n * @note This tool requires the beta header `code-execution-2025-08-25` in API requests.\n *\n * @see {@link https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/code-execution-tool | Anthropic Code Execution Documentation}\n * @param options - Configuration options for the code execution tool\n * @returns A code execution tool definition to be passed to the Anthropic API\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n *\n * const model = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * // Basic usage - calculations and data analysis\n * const response = await model.invoke(\n *   \"Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // File operations and visualization\n * const response2 = await model.invoke(\n *   \"Create a matplotlib visualization of sales data and save it as chart.png\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n * ```\n *\n * @example Container reuse\n * ```typescript\n * // First request - creates a container\n * const response1 = await model.invoke(\n *   \"Write a random number to /tmp/number.txt\",\n *   { tools: [tools.codeExecution_20250825()] }\n * );\n *\n * // Extract container ID from response for reuse\n * const containerId = response1.response_metadata?.container?.id;\n *\n * // Second request - reuse container to access the file\n * const response2 = await model.invoke(\n *   \"Read /tmp/number.txt and calculate its square\",\n *   {\n *     tools: [tools.codeExecution_20250825()],\n *     // Pass container ID to reuse the same environment\n *   }\n * );\n * ```\n */\nexport function codeExecution_20250825(\n  options?: CodeExecution20250825Options\n): ServerTool {\n  return {\n    type: \"code_execution_20250825\",\n    name: \"code_execution\",\n    cache_control: options?.cacheControl,\n  } satisfies Anthropic.Beta.BetaCodeExecutionTool20250825;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,uBACdA,SACY;AACZ,QAAO;EACL,MAAM;EACN,MAAM;EACN,eAAe,SAAS;CACzB;AACF"}