@langchain/anthropic 1.2.3 → 1.3.0-dev-1765432861398

package/dist/tools/memory.d.cts

@@ -0,0 +1,92 @@
+import { MemoryTool20250818Options } from "./types.cjs";
+import * as zod0 from "zod";
+import * as zod_v4_core0 from "zod/v4/core";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+
+//#region src/tools/memory.d.ts
+
+/**
+ * Creates an Anthropic memory tool that can be used with ChatAnthropic.
+ *
+ * The memory tool enables Claude to store and retrieve information across conversations
+ * through a memory file directory. Claude can create, read, update, and delete files that
+ * persist between sessions, allowing it to build knowledge over time without keeping
+ * everything in the context window.
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, memory_20250818 } from "@langchain/anthropic";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929"
+ * });
+ *
+ * const memory = memory_20250818({
+ *   execute: async (args) => {
+ *     // handle memory command execution
+ *     // ...
+ *   },
+ * });
+ * const llmWithMemory = llm.bindTools([memory]);
+ *
+ * const response = await llmWithMemory.invoke("Remember that I like Python");
+ * ```
+ *
+ * @param options - Optional configuration for the memory tool (currently unused)
+ * @param options.execute - Optional execute function that handles memory command execution.
+ * @returns The memory tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool
+ */
+declare function memory_20250818(options?: MemoryTool20250818Options): DynamicStructuredTool<zod0.ZodDiscriminatedUnion<[zod0.ZodObject<{
+  command: zod0.ZodLiteral<"view">;
+  path: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"create">;
+  path: zod0.ZodString;
+  file_text: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"str_replace">;
+  path: zod0.ZodString;
+  old_str: zod0.ZodString;
+  new_str: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"insert">;
+  path: zod0.ZodString;
+  insert_line: zod0.ZodNumber;
+  insert_text: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"delete">;
+  path: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"rename">;
+  old_path: zod0.ZodString;
+  new_path: zod0.ZodString;
+}, zod_v4_core0.$strip>], "command">, {
+  command: "view";
+  path: string;
+} | {
+  command: "create";
+  path: string;
+  file_text: string;
+} | {
+  command: "str_replace";
+  path: string;
+  old_str: string;
+  new_str: string;
+} | {
+  command: "insert";
+  path: string;
+  insert_line: number;
+  insert_text: string;
+} | {
+  command: "delete";
+  path: string;
+} | {
+  command: "rename";
+  old_path: string;
+  new_path: string;
+}, unknown, string | Promise<string>>;
+//#endregion
+export { memory_20250818 };
+//# sourceMappingURL=memory.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.cts","names":["zod_v4_core0","DynamicStructuredTool","MemoryTool20250818Options","memory_20250818","zod0","ZodLiteral","ZodString","$strip","ZodObject","ZodNumber","ZodDiscriminatedUnion","Promise"],"sources":["../../src/tools/memory.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type MemoryTool20250818Options } from \"./types.js\";\n/**\n * Creates an Anthropic memory tool that can be used with ChatAnthropic.\n *\n * The memory tool enables Claude to store and retrieve information across conversations\n * through a memory file directory. Claude can create, read, update, and delete files that\n * persist between sessions, allowing it to build knowledge over time without keeping\n * everything in the context window.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, memory_20250818 } from \"@langchain/anthropic\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\"\n * });\n *\n * const memory = memory_20250818({\n *   execute: async (args) => {\n *     // handle memory command execution\n *     // ...\n *   },\n * });\n * const llmWithMemory = llm.bindTools([memory]);\n *\n * const response = await llmWithMemory.invoke(\"Remember that I like Python\");\n * ```\n *\n * @param options - Optional configuration for the memory tool (currently unused)\n * @param options.execute - Optional execute function that handles memory command execution.\n * @returns The memory tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool\n */\nexport declare function memory_20250818(options?: MemoryTool20250818Options): DynamicStructuredTool<import(\"zod\").ZodDiscriminatedUnion<[import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"view\">;\n    path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"create\">;\n    path: import(\"zod\").ZodString;\n    file_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"str_replace\">;\n    path: import(\"zod\").ZodString;\n    old_str: import(\"zod\").ZodString;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"insert\">;\n    path: import(\"zod\").ZodString;\n    insert_line: import(\"zod\").ZodNumber;\n    insert_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"delete\">;\n    path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"rename\">;\n    old_path: import(\"zod\").ZodString;\n    new_path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>], \"command\">, {\n    command: \"view\";\n    path: string;\n} | {\n    command: \"create\";\n    path: string;\n    file_text: string;\n} | {\n    command: \"str_replace\";\n    path: string;\n    old_str: string;\n    new_str: string;\n} | {\n    command: \"insert\";\n    path: string;\n    insert_line: number;\n    insert_text: string;\n} | {\n    command: \"delete\";\n    path: string;\n} | {\n    command: \"rename\";\n    old_path: string;\n    new_path: string;\n}, unknown, string | Promise<string>>;\n//# sourceMappingURL=memory.d.ts.map"],"mappings":";;;;;;;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuB4BM,iBAvBJH,eAAAA,CAuBIG,OAAAA,CAAAA,EAvBsBJ,yBAuBtBI,CAAAA,EAvBkDL,qBAuBlDK,CAH6BF,IAAAA,CApByDM,qBAuBtFJ,CAAAA,CApBGF,IAAAA,CAHwHI,SAuB3HF,CAAAA;EAASN,OAAAA,EAvBsCI,IAAAA,CAChDC,UAuBFE,CAAAA,MAAAA,CAAAA;EAAMH,IAJiBI,EAnBXJ,IAAAA,CACbE,SAkBwBE;CAASJ,EAlBxBJ,YAAAA,CACRO,MAAAA,CAHyFG,EAOnFN,IAAAA,CAJiBI,SAHkEE,CAAAA;EAgD7FC,OAAAA,EAhD2IP,IAAAA,CAIrIC,UA4CNM,CAAAA,QAAAA,CAAAA;EAhDyDV,IAAAA,EAIzCG,IAAAA,CACbE,SALsDL;EAAqB,SAAA,EAKlEG,IAAAA,CACJE,SANsE;GAM7DN,YAAAA,CACbO,MAAAA,GAKMH,IAAAA,CALiBI;WAJSJ,IAAAA,CAK9BC;QAAUD,IAAAA,CACbE;WAASF,IAAAA,CACNE;WAASF,IAAAA,CACTE;GAASN,YAAAA,CACXO,MAAAA,GAKMH,IAAAA,CALiBI;WALSJ,IAAAA,CAM9BC;QAAUD,IAAAA,CACbE;eAASF,IAAAA,CACFK;eAASL,IAAAA,CACTE;GAASN,YAAAA,CACfO,MAAAA,GAGMH,IAAAA,CAHiBI;WALSJ,IAAAA,CAM9BC;QAAUD,IAAAA,CACbE;GAASN,YAAAA,CACRO,MAAAA,GAIMH,IAAAA,CAJiBI;WAHSJ,IAAAA,CAI9BC;YAAUD,IAAAA,CACTE;YAASF,IAAAA,CACTE;GAASN,YAAAA,CACZO,MAAAA;;;;;;;;;;;;;;;;;;;;;;;;qBAwBJI"}

package/dist/tools/memory.d.ts

@@ -0,0 +1,92 @@
+import { MemoryTool20250818Options } from "./types.js";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import * as zod0 from "zod";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/tools/memory.d.ts
+
+/**
+ * Creates an Anthropic memory tool that can be used with ChatAnthropic.
+ *
+ * The memory tool enables Claude to store and retrieve information across conversations
+ * through a memory file directory. Claude can create, read, update, and delete files that
+ * persist between sessions, allowing it to build knowledge over time without keeping
+ * everything in the context window.
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, memory_20250818 } from "@langchain/anthropic";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929"
+ * });
+ *
+ * const memory = memory_20250818({
+ *   execute: async (args) => {
+ *     // handle memory command execution
+ *     // ...
+ *   },
+ * });
+ * const llmWithMemory = llm.bindTools([memory]);
+ *
+ * const response = await llmWithMemory.invoke("Remember that I like Python");
+ * ```
+ *
+ * @param options - Optional configuration for the memory tool (currently unused)
+ * @param options.execute - Optional execute function that handles memory command execution.
+ * @returns The memory tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool
+ */
+declare function memory_20250818(options?: MemoryTool20250818Options): DynamicStructuredTool<zod0.ZodDiscriminatedUnion<[zod0.ZodObject<{
+  command: zod0.ZodLiteral<"view">;
+  path: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"create">;
+  path: zod0.ZodString;
+  file_text: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"str_replace">;
+  path: zod0.ZodString;
+  old_str: zod0.ZodString;
+  new_str: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"insert">;
+  path: zod0.ZodString;
+  insert_line: zod0.ZodNumber;
+  insert_text: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"delete">;
+  path: zod0.ZodString;
+}, zod_v4_core0.$strip>, zod0.ZodObject<{
+  command: zod0.ZodLiteral<"rename">;
+  old_path: zod0.ZodString;
+  new_path: zod0.ZodString;
+}, zod_v4_core0.$strip>], "command">, {
+  command: "view";
+  path: string;
+} | {
+  command: "create";
+  path: string;
+  file_text: string;
+} | {
+  command: "str_replace";
+  path: string;
+  old_str: string;
+  new_str: string;
+} | {
+  command: "insert";
+  path: string;
+  insert_line: number;
+  insert_text: string;
+} | {
+  command: "delete";
+  path: string;
+} | {
+  command: "rename";
+  old_path: string;
+  new_path: string;
+}, unknown, string | Promise<string>>;
+//#endregion
+export { memory_20250818 };
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","names":["zod_v4_core0","DynamicStructuredTool","MemoryTool20250818Options","memory_20250818","zod0","ZodLiteral","ZodString","$strip","ZodObject","ZodNumber","ZodDiscriminatedUnion","Promise"],"sources":["../../src/tools/memory.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type MemoryTool20250818Options } from \"./types.js\";\n/**\n * Creates an Anthropic memory tool that can be used with ChatAnthropic.\n *\n * The memory tool enables Claude to store and retrieve information across conversations\n * through a memory file directory. Claude can create, read, update, and delete files that\n * persist between sessions, allowing it to build knowledge over time without keeping\n * everything in the context window.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, memory_20250818 } from \"@langchain/anthropic\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\"\n * });\n *\n * const memory = memory_20250818({\n *   execute: async (args) => {\n *     // handle memory command execution\n *     // ...\n *   },\n * });\n * const llmWithMemory = llm.bindTools([memory]);\n *\n * const response = await llmWithMemory.invoke(\"Remember that I like Python\");\n * ```\n *\n * @param options - Optional configuration for the memory tool (currently unused)\n * @param options.execute - Optional execute function that handles memory command execution.\n * @returns The memory tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool\n */\nexport declare function memory_20250818(options?: MemoryTool20250818Options): DynamicStructuredTool<import(\"zod\").ZodDiscriminatedUnion<[import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"view\">;\n    path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"create\">;\n    path: import(\"zod\").ZodString;\n    file_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"str_replace\">;\n    path: import(\"zod\").ZodString;\n    old_str: import(\"zod\").ZodString;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"insert\">;\n    path: import(\"zod\").ZodString;\n    insert_line: import(\"zod\").ZodNumber;\n    insert_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"delete\">;\n    path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"rename\">;\n    old_path: import(\"zod\").ZodString;\n    new_path: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>], \"command\">, {\n    command: \"view\";\n    path: string;\n} | {\n    command: \"create\";\n    path: string;\n    file_text: string;\n} | {\n    command: \"str_replace\";\n    path: string;\n    old_str: string;\n    new_str: string;\n} | {\n    command: \"insert\";\n    path: string;\n    insert_line: number;\n    insert_text: string;\n} | {\n    command: \"delete\";\n    path: string;\n} | {\n    command: \"rename\";\n    old_path: string;\n    new_path: string;\n}, unknown, string | Promise<string>>;\n//# sourceMappingURL=memory.d.ts.map"],"mappings":";;;;;;;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuB4BM,iBAvBJH,eAAAA,CAuBIG,OAAAA,CAAAA,EAvBsBJ,yBAuBtBI,CAAAA,EAvBkDL,qBAuBlDK,CAH6BF,IAAAA,CApByDM,qBAuBtFJ,CAAAA,CApBGF,IAAAA,CAHwHI,SAuB3HF,CAAAA;EAASN,OAAAA,EAvBsCI,IAAAA,CAChDC,UAuBFE,CAAAA,MAAAA,CAAAA;EAAMH,IAJiBI,EAnBXJ,IAAAA,CACbE,SAkBwBE;CAASJ,EAlBxBJ,YAAAA,CACRO,MAAAA,CAHyFG,EAOnFN,IAAAA,CAJiBI,SAHkEE,CAAAA;EAgD7FC,OAAAA,EAhD2IP,IAAAA,CAIrIC,UA4CNM,CAAAA,QAAAA,CAAAA;EAhDyDV,IAAAA,EAIzCG,IAAAA,CACbE,SALsDL;EAAqB,SAAA,EAKlEG,IAAAA,CACJE,SANsE;GAM7DN,YAAAA,CACbO,MAAAA,GAKMH,IAAAA,CALiBI;WAJSJ,IAAAA,CAK9BC;QAAUD,IAAAA,CACbE;WAASF,IAAAA,CACNE;WAASF,IAAAA,CACTE;GAASN,YAAAA,CACXO,MAAAA,GAKMH,IAAAA,CALiBI;WALSJ,IAAAA,CAM9BC;QAAUD,IAAAA,CACbE;eAASF,IAAAA,CACFK;eAASL,IAAAA,CACTE;GAASN,YAAAA,CACfO,MAAAA,GAGMH,IAAAA,CAHiBI;WALSJ,IAAAA,CAM9BC;QAAUD,IAAAA,CACbE;GAASN,YAAAA,CACRO,MAAAA,GAIMH,IAAAA,CAJiBI;WAHSJ,IAAAA,CAI9BC;YAAUD,IAAAA,CACTE;YAASF,IAAAA,CACTE;GAASN,YAAAA,CACZO,MAAAA;;;;;;;;;;;;;;;;;;;;;;;;qBAwBJI"}

package/dist/tools/memory.js

@@ -0,0 +1,55 @@
+import { Memory20250818CommandSchema } from "./types.js";
+import { tool } from "@langchain/core/tools";
+
+//#region src/tools/memory.ts
+/**
+* Creates an Anthropic memory tool that can be used with ChatAnthropic.
+*
+* The memory tool enables Claude to store and retrieve information across conversations
+* through a memory file directory. Claude can create, read, update, and delete files that
+* persist between sessions, allowing it to build knowledge over time without keeping
+* everything in the context window.
+*
+* @example
+* ```typescript
+* import { ChatAnthropic, memory_20250818 } from "@langchain/anthropic";
+*
+* const llm = new ChatAnthropic({
+*   model: "claude-sonnet-4-5-20250929"
+* });
+*
+* const memory = memory_20250818({
+*   execute: async (args) => {
+*     // handle memory command execution
+*     // ...
+*   },
+* });
+* const llmWithMemory = llm.bindTools([memory]);
+*
+* const response = await llmWithMemory.invoke("Remember that I like Python");
+* ```
+*
+* @param options - Optional configuration for the memory tool (currently unused)
+* @param options.execute - Optional execute function that handles memory command execution.
+* @returns The memory tool object that can be passed to `bindTools`
+*
+* @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool
+*/
+function memory_20250818(options) {
+	const memoryTool = tool(options?.execute, {
+		name: "memory",
+		schema: Memory20250818CommandSchema
+	});
+	memoryTool.extras = {
+		...memoryTool.extras ?? {},
+		providerToolDefinition: {
+			type: "memory_20250818",
+			name: "memory"
+		}
+	};
+	return memoryTool;
+}
+
+//#endregion
+export { memory_20250818 };
+//# sourceMappingURL=memory.js.map

package/dist/tools/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","names":["options?: MemoryTool20250818Options"],"sources":["../../src/tools/memory.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  Memory20250818CommandSchema,\n  type MemoryTool20250818Options,\n  type Memory20250818Command,\n} from \"./types.js\";\n\n/**\n * Creates an Anthropic memory tool that can be used with ChatAnthropic.\n *\n * The memory tool enables Claude to store and retrieve information across conversations\n * through a memory file directory. Claude can create, read, update, and delete files that\n * persist between sessions, allowing it to build knowledge over time without keeping\n * everything in the context window.\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, memory_20250818 } from \"@langchain/anthropic\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\"\n * });\n *\n * const memory = memory_20250818({\n *   execute: async (args) => {\n *     // handle memory command execution\n *     // ...\n *   },\n * });\n * const llmWithMemory = llm.bindTools([memory]);\n *\n * const response = await llmWithMemory.invoke(\"Remember that I like Python\");\n * ```\n *\n * @param options - Optional configuration for the memory tool (currently unused)\n * @param options.execute - Optional execute function that handles memory command execution.\n * @returns The memory tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/memory-tool\n */\nexport function memory_20250818(options?: MemoryTool20250818Options) {\n  const memoryTool = tool(\n    options?.execute as (\n      input: unknown,\n      runtime: ToolRuntime<unknown, unknown>\n    ) => string | Promise<string>,\n    {\n      name: \"memory\",\n      schema: Memory20250818CommandSchema,\n    }\n  );\n\n  memoryTool.extras = {\n    ...(memoryTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"memory_20250818\",\n      name: \"memory\",\n    } satisfies Anthropic.Beta.BetaMemoryTool20250818,\n  };\n\n  return memoryTool as DynamicStructuredTool<\n    typeof Memory20250818CommandSchema,\n    Memory20250818Command,\n    unknown,\n    string | Promise<string>\n  >;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,gBAAgBA,SAAqC;CACnE,MAAM,aAAa,KACjB,SAAS,SAIT;EACE,MAAM;EACN,QAAQ;CACT,EACF;CAED,WAAW,SAAS;EAClB,GAAI,WAAW,UAAU,CAAE;EAC3B,wBAAwB;GACtB,MAAM;GACN,MAAM;EACP;CACF;AAED,QAAO;AAMR"}

package/dist/tools/textEditor.cjs

@@ -0,0 +1,79 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_types = require('./types.cjs');
+const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+
+//#region src/tools/textEditor.ts
+/**
+* Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.
+*
+* The text editor tool enables Claude to view and modify text files, helping debug, fix,
+* and improve code or other text documents. Claude can directly interact with files,
+* providing hands-on assistance rather than just suggesting changes.
+*
+* Available commands:
+* - `view`: Examine file contents or list directory contents
+* - `str_replace`: Replace specific text in a file
+* - `create`: Create a new file with specified content
+* - `insert`: Insert text at a specific line number
+*
+* @example
+* ```typescript
+* import { ChatAnthropic, tools } from "@langchain/anthropic";
+* import * as fs from "fs";
+*
+* const llm = new ChatAnthropic({
+*   model: "claude-sonnet-4-5-20250929",
+* });
+*
+* const textEditor = tools.textEditor_20250728({
+*   execute: async (args) => {
+*     if (args.command === "view") {
+*       const content = fs.readFileSync(args.path, "utf-8");
+*       return content.split("\n").map((line, i) => `${i + 1}: ${line}`).join("\n");
+*     }
+*     if (args.command === "str_replace") {
+*       let content = fs.readFileSync(args.path, "utf-8");
+*       content = content.replace(args.old_str!, args.new_str!);
+*       fs.writeFileSync(args.path, content);
+*       return "Successfully replaced text.";
+*     }
+*     // Handle other commands...
+*     return "Command executed";
+*   },
+*   maxCharacters: 10000,
+* });
+*
+* const llmWithEditor = llm.bindTools([textEditor]);
+* const response = await llmWithEditor.invoke(
+*   "There's a syntax error in my primes.py file. Can you help me fix it?"
+* );
+* ```
+*
+* @param options - Configuration options for the text editor tool
+* @param options.execute - Function that handles text editor command execution
+* @param options.maxCharacters - Maximum characters to return when viewing files
+* @returns The text editor tool object that can be passed to `bindTools`
+*
+* @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool
+*/
+function textEditor_20250728(options) {
+	const name = "str_replace_based_edit_tool";
+	const textEditorTool = (0, __langchain_core_tools.tool)(options?.execute, {
+		name,
+		description: "A tool for editing text files",
+		schema: require_types.TextEditor20250728CommandSchema
+	});
+	textEditorTool.extras = {
+		...textEditorTool.extras ?? {},
+		providerToolDefinition: {
+			type: "text_editor_20250728",
+			name,
+			...options?.maxCharacters !== void 0 && { max_characters: options.maxCharacters }
+		}
+	};
+	return textEditorTool;
+}
+
+//#endregion
+exports.textEditor_20250728 = textEditor_20250728;
+//# sourceMappingURL=textEditor.cjs.map

package/dist/tools/textEditor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"textEditor.cjs","names":["options?: TextEditor20250728Options","TextEditor20250728CommandSchema"],"sources":["../../src/tools/textEditor.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  TextEditor20250728CommandSchema,\n  type TextEditor20250728Command,\n} from \"./types.js\";\n\n/**\n * Options for the text editor tool (Claude 4.x version).\n */\nexport interface TextEditor20250728Options {\n  /**\n   * Optional execute function that handles text editor command execution.\n   * This function receives the command input and should return the result.\n   */\n  execute?: (args: TextEditor20250728Command) => string | Promise<string>;\n  /**\n   * Optional maximum characters to return when viewing files.\n   * If the file content exceeds this limit, it will be truncated.\n   */\n  maxCharacters?: number;\n}\n\n/**\n * Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.\n *\n * The text editor tool enables Claude to view and modify text files, helping debug, fix,\n * and improve code or other text documents. Claude can directly interact with files,\n * providing hands-on assistance rather than just suggesting changes.\n *\n * Available commands:\n * - `view`: Examine file contents or list directory contents\n * - `str_replace`: Replace specific text in a file\n * - `create`: Create a new file with specified content\n * - `insert`: Insert text at a specific line number\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import * as fs from \"fs\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const textEditor = tools.textEditor_20250728({\n *   execute: async (args) => {\n *     if (args.command === \"view\") {\n *       const content = fs.readFileSync(args.path, \"utf-8\");\n *       return content.split(\"\\n\").map((line, i) => `${i + 1}: ${line}`).join(\"\\n\");\n *     }\n *     if (args.command === \"str_replace\") {\n *       let content = fs.readFileSync(args.path, \"utf-8\");\n *       content = content.replace(args.old_str!, args.new_str!);\n *       fs.writeFileSync(args.path, content);\n *       return \"Successfully replaced text.\";\n *     }\n *     // Handle other commands...\n *     return \"Command executed\";\n *   },\n *   maxCharacters: 10000,\n * });\n *\n * const llmWithEditor = llm.bindTools([textEditor]);\n * const response = await llmWithEditor.invoke(\n *   \"There's a syntax error in my primes.py file. Can you help me fix it?\"\n * );\n * ```\n *\n * @param options - Configuration options for the text editor tool\n * @param options.execute - Function that handles text editor command execution\n * @param options.maxCharacters - Maximum characters to return when viewing files\n * @returns The text editor tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool\n */\nexport function textEditor_20250728(options?: TextEditor20250728Options) {\n  const name = \"str_replace_based_edit_tool\";\n  const textEditorTool = 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 editing text files\",\n      schema: TextEditor20250728CommandSchema,\n    }\n  );\n\n  textEditorTool.extras = {\n    ...(textEditorTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"text_editor_20250728\",\n      name,\n      ...(options?.maxCharacters !== undefined && {\n        max_characters: options.maxCharacters,\n      }),\n    } satisfies Anthropic.Beta.Messages.BetaToolTextEditor20250728,\n  };\n\n  return textEditorTool as DynamicStructuredTool<\n    typeof TextEditor20250728CommandSchema,\n    TextEditor20250728Command,\n    unknown,\n    string | Promise<string>\n  >;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,SAAgB,oBAAoBA,SAAqC;CACvE,MAAM,OAAO;CACb,MAAM,kDACJ,SAAS,SAIT;EACE;EACA,aAAa;EACb,QAAQC;CACT,EACF;CAED,eAAe,SAAS;EACtB,GAAI,eAAe,UAAU,CAAE;EAC/B,wBAAwB;GACtB,MAAM;GACN;GACA,GAAI,SAAS,kBAAkB,UAAa,EAC1C,gBAAgB,QAAQ,cACzB;EACF;CACF;AAED,QAAO;AAMR"}

package/dist/tools/textEditor.d.cts

@@ -0,0 +1,114 @@
+import { TextEditor20250728Command } from "./types.cjs";
+import * as zod24 from "zod";
+import * as zod_v4_core5 from "zod/v4/core";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+
+//#region src/tools/textEditor.d.ts
+/**
+ * Options for the text editor tool (Claude 4.x version).
+ */
+interface TextEditor20250728Options {
+  /**
+   * Optional execute function that handles text editor command execution.
+   * This function receives the command input and should return the result.
+   */
+  execute?: (args: TextEditor20250728Command) => string | Promise<string>;
+  /**
+   * Optional maximum characters to return when viewing files.
+   * If the file content exceeds this limit, it will be truncated.
+   */
+  maxCharacters?: number;
+}
+/**
+ * Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.
+ *
+ * The text editor tool enables Claude to view and modify text files, helping debug, fix,
+ * and improve code or other text documents. Claude can directly interact with files,
+ * providing hands-on assistance rather than just suggesting changes.
+ *
+ * Available commands:
+ * - `view`: Examine file contents or list directory contents
+ * - `str_replace`: Replace specific text in a file
+ * - `create`: Create a new file with specified content
+ * - `insert`: Insert text at a specific line number
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ * import * as fs from "fs";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * const textEditor = tools.textEditor_20250728({
+ *   execute: async (args) => {
+ *     if (args.command === "view") {
+ *       const content = fs.readFileSync(args.path, "utf-8");
+ *       return content.split("\n").map((line, i) => `${i + 1}: ${line}`).join("\n");
+ *     }
+ *     if (args.command === "str_replace") {
+ *       let content = fs.readFileSync(args.path, "utf-8");
+ *       content = content.replace(args.old_str!, args.new_str!);
+ *       fs.writeFileSync(args.path, content);
+ *       return "Successfully replaced text.";
+ *     }
+ *     // Handle other commands...
+ *     return "Command executed";
+ *   },
+ *   maxCharacters: 10000,
+ * });
+ *
+ * const llmWithEditor = llm.bindTools([textEditor]);
+ * const response = await llmWithEditor.invoke(
+ *   "There's a syntax error in my primes.py file. Can you help me fix it?"
+ * );
+ * ```
+ *
+ * @param options - Configuration options for the text editor tool
+ * @param options.execute - Function that handles text editor command execution
+ * @param options.maxCharacters - Maximum characters to return when viewing files
+ * @returns The text editor tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool
+ */
+declare function textEditor_20250728(options?: TextEditor20250728Options): DynamicStructuredTool<zod24.ZodDiscriminatedUnion<[zod24.ZodObject<{
+  command: zod24.ZodLiteral<"view">;
+  path: zod24.ZodString;
+  view_range: zod24.ZodOptional<zod24.ZodTuple<[zod24.ZodNumber, zod24.ZodNumber], null>>;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"str_replace">;
+  path: zod24.ZodString;
+  old_str: zod24.ZodString;
+  new_str: zod24.ZodString;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"create">;
+  path: zod24.ZodString;
+  file_text: zod24.ZodString;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"insert">;
+  path: zod24.ZodString;
+  insert_line: zod24.ZodNumber;
+  new_str: zod24.ZodString;
+}, zod_v4_core5.$strip>], "command">, {
+  command: "view";
+  path: string;
+  view_range?: [number, number] | undefined;
+} | {
+  command: "str_replace";
+  path: string;
+  old_str: string;
+  new_str: string;
+} | {
+  command: "create";
+  path: string;
+  file_text: string;
+} | {
+  command: "insert";
+  path: string;
+  insert_line: number;
+  new_str: string;
+}, unknown, string | Promise<string>>;
+//#endregion
+export { TextEditor20250728Options, textEditor_20250728 };
+//# sourceMappingURL=textEditor.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textEditor.d.cts","names":["zod_v4_core5","DynamicStructuredTool","TextEditor20250728Command","TextEditor20250728Options","Promise","textEditor_20250728","zod24","ZodLiteral","ZodString","ZodNumber","ZodTuple","ZodOptional","$strip","ZodObject","ZodDiscriminatedUnion"],"sources":["../../src/tools/textEditor.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type TextEditor20250728Command } from \"./types.js\";\n/**\n * Options for the text editor tool (Claude 4.x version).\n */\nexport interface TextEditor20250728Options {\n    /**\n     * Optional execute function that handles text editor command execution.\n     * This function receives the command input and should return the result.\n     */\n    execute?: (args: TextEditor20250728Command) => string | Promise<string>;\n    /**\n     * Optional maximum characters to return when viewing files.\n     * If the file content exceeds this limit, it will be truncated.\n     */\n    maxCharacters?: number;\n}\n/**\n * Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.\n *\n * The text editor tool enables Claude to view and modify text files, helping debug, fix,\n * and improve code or other text documents. Claude can directly interact with files,\n * providing hands-on assistance rather than just suggesting changes.\n *\n * Available commands:\n * - `view`: Examine file contents or list directory contents\n * - `str_replace`: Replace specific text in a file\n * - `create`: Create a new file with specified content\n * - `insert`: Insert text at a specific line number\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import * as fs from \"fs\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const textEditor = tools.textEditor_20250728({\n *   execute: async (args) => {\n *     if (args.command === \"view\") {\n *       const content = fs.readFileSync(args.path, \"utf-8\");\n *       return content.split(\"\\n\").map((line, i) => `${i + 1}: ${line}`).join(\"\\n\");\n *     }\n *     if (args.command === \"str_replace\") {\n *       let content = fs.readFileSync(args.path, \"utf-8\");\n *       content = content.replace(args.old_str!, args.new_str!);\n *       fs.writeFileSync(args.path, content);\n *       return \"Successfully replaced text.\";\n *     }\n *     // Handle other commands...\n *     return \"Command executed\";\n *   },\n *   maxCharacters: 10000,\n * });\n *\n * const llmWithEditor = llm.bindTools([textEditor]);\n * const response = await llmWithEditor.invoke(\n *   \"There's a syntax error in my primes.py file. Can you help me fix it?\"\n * );\n * ```\n *\n * @param options - Configuration options for the text editor tool\n * @param options.execute - Function that handles text editor command execution\n * @param options.maxCharacters - Maximum characters to return when viewing files\n * @returns The text editor tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool\n */\nexport declare function textEditor_20250728(options?: TextEditor20250728Options): DynamicStructuredTool<import(\"zod\").ZodDiscriminatedUnion<[import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"view\">;\n    path: import(\"zod\").ZodString;\n    view_range: import(\"zod\").ZodOptional<import(\"zod\").ZodTuple<[import(\"zod\").ZodNumber, import(\"zod\").ZodNumber], null>>;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"str_replace\">;\n    path: import(\"zod\").ZodString;\n    old_str: import(\"zod\").ZodString;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"create\">;\n    path: import(\"zod\").ZodString;\n    file_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"insert\">;\n    path: import(\"zod\").ZodString;\n    insert_line: import(\"zod\").ZodNumber;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>], \"command\">, {\n    command: \"view\";\n    path: string;\n    view_range?: [number, number] | undefined;\n} | {\n    command: \"str_replace\";\n    path: string;\n    old_str: string;\n    new_str: string;\n} | {\n    command: \"create\";\n    path: string;\n    file_text: string;\n} | {\n    command: \"insert\";\n    path: string;\n    insert_line: number;\n    new_str: string;\n}, unknown, string | Promise<string>>;\n//# sourceMappingURL=textEditor.d.ts.map"],"mappings":";;;;;;;;;UAKiBG,yBAAAA;EAAAA;AAiEjB;;;EACqCG,OACbE,CAAAA,EAAAA,CAAAA,IAAAA,EA9DHN,yBA8DGM,EAAAA,GAAAA,MAAAA,GA9DoCJ,OA8DpCI,CAAAA,MAAAA,CAAAA;EAASF;;;;EACQN,aAChBY,CAAAA,EAAAA,MAAAA;;;;;;;;;;;;;;;;;;;;;;AAJ8E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA/EP,mBAAAA,WAA8BF,4BAA4BF,sBAazBK,KAAAA,CAb6DQ,uBAIvFR,KAAAA,CAJ4HO;WAA5EP,KAAAA,CACpDC;QAAUD,KAAAA,CACbE;cACwCF,KAAAA,CAAlCK,YAAoFL,KAAAA,CAA1DI,UADvBJ,KAAAA,CAC+CG,SAAAA,EAASH,KAAAA,CAAgBG,SAAAA;GAAhET,YAAAA,CAChBY,MAAAA,GAKMN,KAAAA,CALiBO;WAJoHP,KAAAA,CAKzIC;QAAUD,KAAAA,CACbE;WAASF,KAAAA,CACNE;WAASF,KAAAA,CACTE;GAASR,YAAAA,CACXY,MAAAA,GAIMN,KAAAA,CAJiBO;WALSP,KAAAA,CAM9BC;QAAUD,KAAAA,CACbE;aAASF,KAAAA,CACJE;GAASR,YAAAA,CACbY,MAAAA,GAKMN,KAAAA,CALiBO;WAJSP,KAAAA,CAK9BC;QAAUD,KAAAA,CACbE;eAASF,KAAAA,CACFG;WAASH,KAAAA,CACbE;GAASR,YAAAA,CACXY,MAAAA;;;;;;;;;;;;;;;;;;qBAkBJR"}

package/dist/tools/textEditor.d.ts

@@ -0,0 +1,114 @@
+import { TextEditor20250728Command } from "./types.js";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import * as zod24 from "zod";
+import * as zod_v4_core5 from "zod/v4/core";
+
+//#region src/tools/textEditor.d.ts
+/**
+ * Options for the text editor tool (Claude 4.x version).
+ */
+interface TextEditor20250728Options {
+  /**
+   * Optional execute function that handles text editor command execution.
+   * This function receives the command input and should return the result.
+   */
+  execute?: (args: TextEditor20250728Command) => string | Promise<string>;
+  /**
+   * Optional maximum characters to return when viewing files.
+   * If the file content exceeds this limit, it will be truncated.
+   */
+  maxCharacters?: number;
+}
+/**
+ * Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.
+ *
+ * The text editor tool enables Claude to view and modify text files, helping debug, fix,
+ * and improve code or other text documents. Claude can directly interact with files,
+ * providing hands-on assistance rather than just suggesting changes.
+ *
+ * Available commands:
+ * - `view`: Examine file contents or list directory contents
+ * - `str_replace`: Replace specific text in a file
+ * - `create`: Create a new file with specified content
+ * - `insert`: Insert text at a specific line number
+ *
+ * @example
+ * ```typescript
+ * import { ChatAnthropic, tools } from "@langchain/anthropic";
+ * import * as fs from "fs";
+ *
+ * const llm = new ChatAnthropic({
+ *   model: "claude-sonnet-4-5-20250929",
+ * });
+ *
+ * const textEditor = tools.textEditor_20250728({
+ *   execute: async (args) => {
+ *     if (args.command === "view") {
+ *       const content = fs.readFileSync(args.path, "utf-8");
+ *       return content.split("\n").map((line, i) => `${i + 1}: ${line}`).join("\n");
+ *     }
+ *     if (args.command === "str_replace") {
+ *       let content = fs.readFileSync(args.path, "utf-8");
+ *       content = content.replace(args.old_str!, args.new_str!);
+ *       fs.writeFileSync(args.path, content);
+ *       return "Successfully replaced text.";
+ *     }
+ *     // Handle other commands...
+ *     return "Command executed";
+ *   },
+ *   maxCharacters: 10000,
+ * });
+ *
+ * const llmWithEditor = llm.bindTools([textEditor]);
+ * const response = await llmWithEditor.invoke(
+ *   "There's a syntax error in my primes.py file. Can you help me fix it?"
+ * );
+ * ```
+ *
+ * @param options - Configuration options for the text editor tool
+ * @param options.execute - Function that handles text editor command execution
+ * @param options.maxCharacters - Maximum characters to return when viewing files
+ * @returns The text editor tool object that can be passed to `bindTools`
+ *
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool
+ */
+declare function textEditor_20250728(options?: TextEditor20250728Options): DynamicStructuredTool<zod24.ZodDiscriminatedUnion<[zod24.ZodObject<{
+  command: zod24.ZodLiteral<"view">;
+  path: zod24.ZodString;
+  view_range: zod24.ZodOptional<zod24.ZodTuple<[zod24.ZodNumber, zod24.ZodNumber], null>>;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"str_replace">;
+  path: zod24.ZodString;
+  old_str: zod24.ZodString;
+  new_str: zod24.ZodString;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"create">;
+  path: zod24.ZodString;
+  file_text: zod24.ZodString;
+}, zod_v4_core5.$strip>, zod24.ZodObject<{
+  command: zod24.ZodLiteral<"insert">;
+  path: zod24.ZodString;
+  insert_line: zod24.ZodNumber;
+  new_str: zod24.ZodString;
+}, zod_v4_core5.$strip>], "command">, {
+  command: "view";
+  path: string;
+  view_range?: [number, number] | undefined;
+} | {
+  command: "str_replace";
+  path: string;
+  old_str: string;
+  new_str: string;
+} | {
+  command: "create";
+  path: string;
+  file_text: string;
+} | {
+  command: "insert";
+  path: string;
+  insert_line: number;
+  new_str: string;
+}, unknown, string | Promise<string>>;
+//#endregion
+export { TextEditor20250728Options, textEditor_20250728 };
+//# sourceMappingURL=textEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textEditor.d.ts","names":["zod_v4_core5","DynamicStructuredTool","TextEditor20250728Command","TextEditor20250728Options","Promise","textEditor_20250728","zod24","ZodLiteral","ZodString","ZodNumber","ZodTuple","ZodOptional","$strip","ZodObject","ZodDiscriminatedUnion"],"sources":["../../src/tools/textEditor.d.ts"],"sourcesContent":["import type { DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { type TextEditor20250728Command } from \"./types.js\";\n/**\n * Options for the text editor tool (Claude 4.x version).\n */\nexport interface TextEditor20250728Options {\n    /**\n     * Optional execute function that handles text editor command execution.\n     * This function receives the command input and should return the result.\n     */\n    execute?: (args: TextEditor20250728Command) => string | Promise<string>;\n    /**\n     * Optional maximum characters to return when viewing files.\n     * If the file content exceeds this limit, it will be truncated.\n     */\n    maxCharacters?: number;\n}\n/**\n * Creates an Anthropic text editor tool for Claude 4.x models that can view and modify text files.\n *\n * The text editor tool enables Claude to view and modify text files, helping debug, fix,\n * and improve code or other text documents. Claude can directly interact with files,\n * providing hands-on assistance rather than just suggesting changes.\n *\n * Available commands:\n * - `view`: Examine file contents or list directory contents\n * - `str_replace`: Replace specific text in a file\n * - `create`: Create a new file with specified content\n * - `insert`: Insert text at a specific line number\n *\n * @example\n * ```typescript\n * import { ChatAnthropic, tools } from \"@langchain/anthropic\";\n * import * as fs from \"fs\";\n *\n * const llm = new ChatAnthropic({\n *   model: \"claude-sonnet-4-5-20250929\",\n * });\n *\n * const textEditor = tools.textEditor_20250728({\n *   execute: async (args) => {\n *     if (args.command === \"view\") {\n *       const content = fs.readFileSync(args.path, \"utf-8\");\n *       return content.split(\"\\n\").map((line, i) => `${i + 1}: ${line}`).join(\"\\n\");\n *     }\n *     if (args.command === \"str_replace\") {\n *       let content = fs.readFileSync(args.path, \"utf-8\");\n *       content = content.replace(args.old_str!, args.new_str!);\n *       fs.writeFileSync(args.path, content);\n *       return \"Successfully replaced text.\";\n *     }\n *     // Handle other commands...\n *     return \"Command executed\";\n *   },\n *   maxCharacters: 10000,\n * });\n *\n * const llmWithEditor = llm.bindTools([textEditor]);\n * const response = await llmWithEditor.invoke(\n *   \"There's a syntax error in my primes.py file. Can you help me fix it?\"\n * );\n * ```\n *\n * @param options - Configuration options for the text editor tool\n * @param options.execute - Function that handles text editor command execution\n * @param options.maxCharacters - Maximum characters to return when viewing files\n * @returns The text editor tool object that can be passed to `bindTools`\n *\n * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/text-editor-tool\n */\nexport declare function textEditor_20250728(options?: TextEditor20250728Options): DynamicStructuredTool<import(\"zod\").ZodDiscriminatedUnion<[import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"view\">;\n    path: import(\"zod\").ZodString;\n    view_range: import(\"zod\").ZodOptional<import(\"zod\").ZodTuple<[import(\"zod\").ZodNumber, import(\"zod\").ZodNumber], null>>;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"str_replace\">;\n    path: import(\"zod\").ZodString;\n    old_str: import(\"zod\").ZodString;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"create\">;\n    path: import(\"zod\").ZodString;\n    file_text: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>, import(\"zod\").ZodObject<{\n    command: import(\"zod\").ZodLiteral<\"insert\">;\n    path: import(\"zod\").ZodString;\n    insert_line: import(\"zod\").ZodNumber;\n    new_str: import(\"zod\").ZodString;\n}, import(\"zod/v4/core\").$strip>], \"command\">, {\n    command: \"view\";\n    path: string;\n    view_range?: [number, number] | undefined;\n} | {\n    command: \"str_replace\";\n    path: string;\n    old_str: string;\n    new_str: string;\n} | {\n    command: \"create\";\n    path: string;\n    file_text: string;\n} | {\n    command: \"insert\";\n    path: string;\n    insert_line: number;\n    new_str: string;\n}, unknown, string | Promise<string>>;\n//# sourceMappingURL=textEditor.d.ts.map"],"mappings":";;;;;;;;;UAKiBG,yBAAAA;EAAAA;AAiEjB;;;EACqCG,OACbE,CAAAA,EAAAA,CAAAA,IAAAA,EA9DHN,yBA8DGM,EAAAA,GAAAA,MAAAA,GA9DoCJ,OA8DpCI,CAAAA,MAAAA,CAAAA;EAASF;;;;EACQN,aAChBY,CAAAA,EAAAA,MAAAA;;;;;;;;;;;;;;;;;;;;;;AAJ8E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA/EP,mBAAAA,WAA8BF,4BAA4BF,sBAazBK,KAAAA,CAb6DQ,uBAIvFR,KAAAA,CAJ4HO;WAA5EP,KAAAA,CACpDC;QAAUD,KAAAA,CACbE;cACwCF,KAAAA,CAAlCK,YAAoFL,KAAAA,CAA1DI,UADvBJ,KAAAA,CAC+CG,SAAAA,EAASH,KAAAA,CAAgBG,SAAAA;GAAhET,YAAAA,CAChBY,MAAAA,GAKMN,KAAAA,CALiBO;WAJoHP,KAAAA,CAKzIC;QAAUD,KAAAA,CACbE;WAASF,KAAAA,CACNE;WAASF,KAAAA,CACTE;GAASR,YAAAA,CACXY,MAAAA,GAIMN,KAAAA,CAJiBO;WALSP,KAAAA,CAM9BC;QAAUD,KAAAA,CACbE;aAASF,KAAAA,CACJE;GAASR,YAAAA,CACbY,MAAAA,GAKMN,KAAAA,CALiBO;WAJSP,KAAAA,CAK9BC;QAAUD,KAAAA,CACbE;eAASF,KAAAA,CACFG;WAASH,KAAAA,CACbE;GAASR,YAAAA,CACXY,MAAAA;;;;;;;;;;;;;;;;;;qBAkBJR"}