@langchain/openai 1.1.3 → 1.2.0-dev-1765431816670

package/dist/tools/applyPatch.cjs

@@ -0,0 +1,116 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+const zod_v4 = require_rolldown_runtime.__toESM(require("zod/v4"));
+
+//#region src/tools/applyPatch.ts
+const ApplyPatchCreateFileOperationSchema = zod_v4.z.object({
+	type: zod_v4.z.literal("create_file"),
+	path: zod_v4.z.string(),
+	diff: zod_v4.z.string()
+});
+const ApplyPatchUpdateFileOperationSchema = zod_v4.z.object({
+	type: zod_v4.z.literal("update_file"),
+	path: zod_v4.z.string(),
+	diff: zod_v4.z.string()
+});
+const ApplyPatchDeleteFileOperationSchema = zod_v4.z.object({
+	type: zod_v4.z.literal("delete_file"),
+	path: zod_v4.z.string()
+});
+const ApplyPatchOperationSchema = zod_v4.z.discriminatedUnion("type", [
+	ApplyPatchCreateFileOperationSchema,
+	ApplyPatchUpdateFileOperationSchema,
+	ApplyPatchDeleteFileOperationSchema
+]);
+const TOOL_NAME = "apply_patch";
+/**
+* Creates an Apply Patch tool that allows models to propose structured diffs
+* that your integration applies. This enables iterative, multi-step code
+* editing workflows.
+*
+* **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase
+* using structured diffs. Instead of just suggesting edits, the model emits
+* patch operations that your application applies and then reports back on.
+*
+* **When to use**:
+* - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules
+* - **Bug fixes** – Have the model both diagnose issues and emit precise patches
+* - **Tests & docs generation** – Create new test files, fixtures, and documentation
+* - **Migrations & mechanical edits** – Apply repetitive, structured updates
+*
+* **How it works**:
+* The tool operates in a continuous loop:
+* 1. Model sends patch operations (`apply_patch_call` with operation type)
+* 2. Your code applies the patch to your working directory or repo
+* 3. You return success/failure status and optional output
+* 4. Repeat until the task is complete
+*
+* **Security Warning**: Applying patches can modify files in your codebase.
+* Always validate paths, implement backups, and consider sandboxing.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}
+*
+* @param options - Configuration options for the Apply Patch tool
+* @returns An Apply Patch tool that can be passed to `bindTools`
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+* import { applyDiff } from "@openai/agents";
+* import * as fs from "fs/promises";
+*
+* const model = new ChatOpenAI({ model: "gpt-5.1" });
+*
+* // With execute callback for automatic patch handling
+* const patchTool = tools.applyPatch({
+*   execute: async (operation) => {
+*     if (operation.type === "create_file") {
+*       const content = applyDiff("", operation.diff, "create");
+*       await fs.writeFile(operation.path, content);
+*       return `Created ${operation.path}`;
+*     }
+*     if (operation.type === "update_file") {
+*       const current = await fs.readFile(operation.path, "utf-8");
+*       const newContent = applyDiff(current, operation.diff);
+*       await fs.writeFile(operation.path, newContent);
+*       return `Updated ${operation.path}`;
+*     }
+*     if (operation.type === "delete_file") {
+*       await fs.unlink(operation.path);
+*       return `Deleted ${operation.path}`;
+*     }
+*     return "Unknown operation type";
+*   },
+* });
+*
+* const llmWithPatch = model.bindTools([patchTool]);
+* const response = await llmWithPatch.invoke(
+*   "Rename the fib() function to fibonacci() in lib/fib.py"
+* );
+* ```
+*
+* @remarks
+* - Only available through the Responses API (not Chat Completions)
+* - Designed for use with `gpt-5.1` model
+* - Operations include: `create_file`, `update_file`, `delete_file`
+* - Patches use V4A diff format for updates
+* - Always validate paths to prevent directory traversal attacks
+* - Consider backing up files before applying patches
+* - Implement "all-or-nothing" semantics if atomicity is required
+*/
+function applyPatch(options) {
+	const patchTool = (0, __langchain_core_tools.tool)(options.execute, {
+		name: TOOL_NAME,
+		description: "Apply structured diffs to create, update, or delete files in the codebase.",
+		schema: ApplyPatchOperationSchema
+	});
+	patchTool.extras = {
+		...patchTool.extras ?? {},
+		providerToolDefinition: { type: "apply_patch" }
+	};
+	return patchTool;
+}
+
+//#endregion
+exports.applyPatch = applyPatch;
+//# sourceMappingURL=applyPatch.cjs.map

package/dist/tools/applyPatch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyPatch.cjs","names":["z","options: ApplyPatchOptions"],"sources":["../../src/tools/applyPatch.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export operation types from OpenAI SDK for convenience.\n */\nexport type ApplyPatchCreateFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.CreateFile;\nexport type ApplyPatchUpdateFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.UpdateFile;\nexport type ApplyPatchDeleteFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.DeleteFile;\n\n/**\n * Union type of all apply patch operations from OpenAI SDK.\n */\nexport type ApplyPatchOperation = NonNullable<\n  OpenAIClient.Responses.ResponseApplyPatchToolCall[\"operation\"]\n>;\n\n// Zod schemas for apply patch operations\nexport const ApplyPatchCreateFileOperationSchema = z.object({\n  type: z.literal(\"create_file\"),\n  path: z.string(),\n  diff: z.string(),\n});\n\nexport const ApplyPatchUpdateFileOperationSchema = z.object({\n  type: z.literal(\"update_file\"),\n  path: z.string(),\n  diff: z.string(),\n});\n\nexport const ApplyPatchDeleteFileOperationSchema = z.object({\n  type: z.literal(\"delete_file\"),\n  path: z.string(),\n});\n\n// Discriminated union schema for all apply patch operations\nexport const ApplyPatchOperationSchema = z.discriminatedUnion(\"type\", [\n  ApplyPatchCreateFileOperationSchema,\n  ApplyPatchUpdateFileOperationSchema,\n  ApplyPatchDeleteFileOperationSchema,\n]);\n\n/**\n * Options for the Apply Patch tool.\n */\nexport interface ApplyPatchOptions {\n  /**\n   * Execute function that handles patch operations.\n   * This function receives the operation input and should return a string\n   * describing the result (success or failure message).\n   *\n   * The operation types are:\n   * - `create_file`: Create a new file at the specified path with the diff content\n   * - `update_file`: Modify an existing file using V4A diff format\n   * - `delete_file`: Remove a file at the specified path\n   *\n   * @example\n   * ```typescript\n   * execute: async (operation) => {\n   *   if (operation.type === \"create_file\") {\n   *     const content = applyDiff(\"\", operation.diff, \"create\");\n   *     await fs.writeFile(operation.path, content);\n   *     return `Created ${operation.path}`;\n   *   }\n   *   if (operation.type === \"update_file\") {\n   *     const current = await fs.readFile(operation.path, \"utf-8\");\n   *     const newContent = applyDiff(current, operation.diff);\n   *     await fs.writeFile(operation.path, newContent);\n   *     return `Updated ${operation.path}`;\n   *   }\n   *   if (operation.type === \"delete_file\") {\n   *     await fs.unlink(operation.path);\n   *     return `Deleted ${operation.path}`;\n   *   }\n   *   return \"Unknown operation type\";\n   * }\n   * ```\n   */\n  execute: (operation: ApplyPatchOperation) => string | Promise<string>;\n}\n\n/**\n * OpenAI Apply Patch tool type for the Responses API.\n */\nexport type ApplyPatchTool = OpenAIClient.Responses.ApplyPatchTool;\n\nconst TOOL_NAME = \"apply_patch\";\n\n/**\n * Creates an Apply Patch tool that allows models to propose structured diffs\n * that your integration applies. This enables iterative, multi-step code\n * editing workflows.\n *\n * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase\n * using structured diffs. Instead of just suggesting edits, the model emits\n * patch operations that your application applies and then reports back on.\n *\n * **When to use**:\n * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules\n * - **Bug fixes** – Have the model both diagnose issues and emit precise patches\n * - **Tests & docs generation** – Create new test files, fixtures, and documentation\n * - **Migrations & mechanical edits** – Apply repetitive, structured updates\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends patch operations (`apply_patch_call` with operation type)\n * 2. Your code applies the patch to your working directory or repo\n * 3. You return success/failure status and optional output\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Applying patches can modify files in your codebase.\n * Always validate paths, implement backups, and consider sandboxing.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}\n *\n * @param options - Configuration options for the Apply Patch tool\n * @returns An Apply Patch tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { applyDiff } from \"@openai/agents\";\n * import * as fs from \"fs/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic patch handling\n * const patchTool = tools.applyPatch({\n *   execute: async (operation) => {\n *     if (operation.type === \"create_file\") {\n *       const content = applyDiff(\"\", operation.diff, \"create\");\n *       await fs.writeFile(operation.path, content);\n *       return `Created ${operation.path}`;\n *     }\n *     if (operation.type === \"update_file\") {\n *       const current = await fs.readFile(operation.path, \"utf-8\");\n *       const newContent = applyDiff(current, operation.diff);\n *       await fs.writeFile(operation.path, newContent);\n *       return `Updated ${operation.path}`;\n *     }\n *     if (operation.type === \"delete_file\") {\n *       await fs.unlink(operation.path);\n *       return `Deleted ${operation.path}`;\n *     }\n *     return \"Unknown operation type\";\n *   },\n * });\n *\n * const llmWithPatch = model.bindTools([patchTool]);\n * const response = await llmWithPatch.invoke(\n *   \"Rename the fib() function to fibonacci() in lib/fib.py\"\n * );\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Operations include: `create_file`, `update_file`, `delete_file`\n * - Patches use V4A diff format for updates\n * - Always validate paths to prevent directory traversal attacks\n * - Consider backing up files before applying patches\n * - Implement \"all-or-nothing\" semantics if atomicity is required\n */\nexport function applyPatch(options: ApplyPatchOptions) {\n  const patchTool = tool(options.execute, {\n    name: TOOL_NAME,\n    description:\n      \"Apply structured diffs to create, update, or delete files in the codebase.\",\n    schema: ApplyPatchOperationSchema,\n  });\n\n  patchTool.extras = {\n    ...(patchTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"apply_patch\",\n    } satisfies ApplyPatchTool,\n  };\n\n  return patchTool as DynamicStructuredTool<\n    typeof ApplyPatchOperationSchema,\n    ApplyPatchOperation,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;;;AAsBA,MAAa,sCAAsCA,SAAE,OAAO;CAC1D,MAAMA,SAAE,QAAQ,cAAc;CAC9B,MAAMA,SAAE,QAAQ;CAChB,MAAMA,SAAE,QAAQ;AACjB,EAAC;AAEF,MAAa,sCAAsCA,SAAE,OAAO;CAC1D,MAAMA,SAAE,QAAQ,cAAc;CAC9B,MAAMA,SAAE,QAAQ;CAChB,MAAMA,SAAE,QAAQ;AACjB,EAAC;AAEF,MAAa,sCAAsCA,SAAE,OAAO;CAC1D,MAAMA,SAAE,QAAQ,cAAc;CAC9B,MAAMA,SAAE,QAAQ;AACjB,EAAC;AAGF,MAAa,4BAA4BA,SAAE,mBAAmB,QAAQ;CACpE;CACA;CACA;AACD,EAAC;AA8CF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ElB,SAAgB,WAAWC,SAA4B;CACrD,MAAM,6CAAiB,QAAQ,SAAS;EACtC,MAAM;EACN,aACE;EACF,QAAQ;CACT,EAAC;CAEF,UAAU,SAAS;EACjB,GAAI,UAAU,UAAU,CAAE;EAC1B,wBAAwB,EACtB,MAAM,cACP;CACF;AAED,QAAO;AAMR"}

package/dist/tools/applyPatch.d.cts

@@ -0,0 +1,148 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod/v4";
+
+//#region src/tools/applyPatch.d.ts
+
+/**
+ * Re-export operation types from OpenAI SDK for convenience.
+ */
+type ApplyPatchCreateFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.CreateFile;
+type ApplyPatchUpdateFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.UpdateFile;
+type ApplyPatchDeleteFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.DeleteFile;
+/**
+ * Union type of all apply patch operations from OpenAI SDK.
+ */
+type ApplyPatchOperation = NonNullable<OpenAI$1.Responses.ResponseApplyPatchToolCall["operation"]>;
+/**
+ * Options for the Apply Patch tool.
+ */
+interface ApplyPatchOptions {
+  /**
+   * Execute function that handles patch operations.
+   * This function receives the operation input and should return a string
+   * describing the result (success or failure message).
+   *
+   * The operation types are:
+   * - `create_file`: Create a new file at the specified path with the diff content
+   * - `update_file`: Modify an existing file using V4A diff format
+   * - `delete_file`: Remove a file at the specified path
+   *
+   * @example
+   * ```typescript
+   * execute: async (operation) => {
+   *   if (operation.type === "create_file") {
+   *     const content = applyDiff("", operation.diff, "create");
+   *     await fs.writeFile(operation.path, content);
+   *     return `Created ${operation.path}`;
+   *   }
+   *   if (operation.type === "update_file") {
+   *     const current = await fs.readFile(operation.path, "utf-8");
+   *     const newContent = applyDiff(current, operation.diff);
+   *     await fs.writeFile(operation.path, newContent);
+   *     return `Updated ${operation.path}`;
+   *   }
+   *   if (operation.type === "delete_file") {
+   *     await fs.unlink(operation.path);
+   *     return `Deleted ${operation.path}`;
+   *   }
+   *   return "Unknown operation type";
+   * }
+   * ```
+   */
+  execute: (operation: ApplyPatchOperation) => string | Promise<string>;
+}
+/**
+ * OpenAI Apply Patch tool type for the Responses API.
+ */
+type ApplyPatchTool = OpenAI$1.Responses.ApplyPatchTool;
+/**
+ * Creates an Apply Patch tool that allows models to propose structured diffs
+ * that your integration applies. This enables iterative, multi-step code
+ * editing workflows.
+ *
+ * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase
+ * using structured diffs. Instead of just suggesting edits, the model emits
+ * patch operations that your application applies and then reports back on.
+ *
+ * **When to use**:
+ * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules
+ * - **Bug fixes** – Have the model both diagnose issues and emit precise patches
+ * - **Tests & docs generation** – Create new test files, fixtures, and documentation
+ * - **Migrations & mechanical edits** – Apply repetitive, structured updates
+ *
+ * **How it works**:
+ * The tool operates in a continuous loop:
+ * 1. Model sends patch operations (`apply_patch_call` with operation type)
+ * 2. Your code applies the patch to your working directory or repo
+ * 3. You return success/failure status and optional output
+ * 4. Repeat until the task is complete
+ *
+ * **Security Warning**: Applying patches can modify files in your codebase.
+ * Always validate paths, implement backups, and consider sandboxing.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}
+ *
+ * @param options - Configuration options for the Apply Patch tool
+ * @returns An Apply Patch tool that can be passed to `bindTools`
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ * import { applyDiff } from "@openai/agents";
+ * import * as fs from "fs/promises";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-5.1" });
+ *
+ * // With execute callback for automatic patch handling
+ * const patchTool = tools.applyPatch({
+ *   execute: async (operation) => {
+ *     if (operation.type === "create_file") {
+ *       const content = applyDiff("", operation.diff, "create");
+ *       await fs.writeFile(operation.path, content);
+ *       return `Created ${operation.path}`;
+ *     }
+ *     if (operation.type === "update_file") {
+ *       const current = await fs.readFile(operation.path, "utf-8");
+ *       const newContent = applyDiff(current, operation.diff);
+ *       await fs.writeFile(operation.path, newContent);
+ *       return `Updated ${operation.path}`;
+ *     }
+ *     if (operation.type === "delete_file") {
+ *       await fs.unlink(operation.path);
+ *       return `Deleted ${operation.path}`;
+ *     }
+ *     return "Unknown operation type";
+ *   },
+ * });
+ *
+ * const llmWithPatch = model.bindTools([patchTool]);
+ * const response = await llmWithPatch.invoke(
+ *   "Rename the fib() function to fibonacci() in lib/fib.py"
+ * );
+ * ```
+ *
+ * @remarks
+ * - Only available through the Responses API (not Chat Completions)
+ * - Designed for use with `gpt-5.1` model
+ * - Operations include: `create_file`, `update_file`, `delete_file`
+ * - Patches use V4A diff format for updates
+ * - Always validate paths to prevent directory traversal attacks
+ * - Consider backing up files before applying patches
+ * - Implement "all-or-nothing" semantics if atomicity is required
+ */
+declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"create_file">;
+  path: z.ZodString;
+  diff: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"update_file">;
+  path: z.ZodString;
+  diff: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"delete_file">;
+  path: z.ZodString;
+}, z.core.$strip>]>, ApplyPatchOperation, unknown, string>;
+//#endregion
+export { ApplyPatchCreateFileOperation, ApplyPatchDeleteFileOperation, ApplyPatchOperation, ApplyPatchOptions, ApplyPatchTool, ApplyPatchUpdateFileOperation, applyPatch };
+//# sourceMappingURL=applyPatch.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyPatch.d.cts","names":["z","OpenAI","OpenAIClient","DynamicStructuredTool","ApplyPatchCreateFileOperation","Responses","ResponseApplyPatchToolCall","CreateFile","ApplyPatchUpdateFileOperation","UpdateFile","ApplyPatchDeleteFileOperation","DeleteFile","ApplyPatchOperation","NonNullable","ApplyPatchCreateFileOperationSchema","ZodLiteral","ZodString","core","$strip","ZodObject","ApplyPatchUpdateFileOperationSchema","ApplyPatchDeleteFileOperationSchema","ApplyPatchOperationSchema","ZodDiscriminatedUnion","ApplyPatchOptions","Promise","ApplyPatchTool","applyPatch"],"sources":["../../src/tools/applyPatch.d.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { type DynamicStructuredTool } from \"@langchain/core/tools\";\n/**\n * Re-export operation types from OpenAI SDK for convenience.\n */\nexport type ApplyPatchCreateFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.CreateFile;\nexport type ApplyPatchUpdateFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.UpdateFile;\nexport type ApplyPatchDeleteFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.DeleteFile;\n/**\n * Union type of all apply patch operations from OpenAI SDK.\n */\nexport type ApplyPatchOperation = NonNullable<OpenAIClient.Responses.ResponseApplyPatchToolCall[\"operation\"]>;\nexport declare const ApplyPatchCreateFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchUpdateFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchDeleteFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>]>;\n/**\n * Options for the Apply Patch tool.\n */\nexport interface ApplyPatchOptions {\n    /**\n     * Execute function that handles patch operations.\n     * This function receives the operation input and should return a string\n     * describing the result (success or failure message).\n     *\n     * The operation types are:\n     * - `create_file`: Create a new file at the specified path with the diff content\n     * - `update_file`: Modify an existing file using V4A diff format\n     * - `delete_file`: Remove a file at the specified path\n     *\n     * @example\n     * ```typescript\n     * execute: async (operation) => {\n     *   if (operation.type === \"create_file\") {\n     *     const content = applyDiff(\"\", operation.diff, \"create\");\n     *     await fs.writeFile(operation.path, content);\n     *     return `Created ${operation.path}`;\n     *   }\n     *   if (operation.type === \"update_file\") {\n     *     const current = await fs.readFile(operation.path, \"utf-8\");\n     *     const newContent = applyDiff(current, operation.diff);\n     *     await fs.writeFile(operation.path, newContent);\n     *     return `Updated ${operation.path}`;\n     *   }\n     *   if (operation.type === \"delete_file\") {\n     *     await fs.unlink(operation.path);\n     *     return `Deleted ${operation.path}`;\n     *   }\n     *   return \"Unknown operation type\";\n     * }\n     * ```\n     */\n    execute: (operation: ApplyPatchOperation) => string | Promise<string>;\n}\n/**\n * OpenAI Apply Patch tool type for the Responses API.\n */\nexport type ApplyPatchTool = OpenAIClient.Responses.ApplyPatchTool;\n/**\n * Creates an Apply Patch tool that allows models to propose structured diffs\n * that your integration applies. This enables iterative, multi-step code\n * editing workflows.\n *\n * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase\n * using structured diffs. Instead of just suggesting edits, the model emits\n * patch operations that your application applies and then reports back on.\n *\n * **When to use**:\n * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules\n * - **Bug fixes** – Have the model both diagnose issues and emit precise patches\n * - **Tests & docs generation** – Create new test files, fixtures, and documentation\n * - **Migrations & mechanical edits** – Apply repetitive, structured updates\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends patch operations (`apply_patch_call` with operation type)\n * 2. Your code applies the patch to your working directory or repo\n * 3. You return success/failure status and optional output\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Applying patches can modify files in your codebase.\n * Always validate paths, implement backups, and consider sandboxing.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}\n *\n * @param options - Configuration options for the Apply Patch tool\n * @returns An Apply Patch tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { applyDiff } from \"@openai/agents\";\n * import * as fs from \"fs/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic patch handling\n * const patchTool = tools.applyPatch({\n *   execute: async (operation) => {\n *     if (operation.type === \"create_file\") {\n *       const content = applyDiff(\"\", operation.diff, \"create\");\n *       await fs.writeFile(operation.path, content);\n *       return `Created ${operation.path}`;\n *     }\n *     if (operation.type === \"update_file\") {\n *       const current = await fs.readFile(operation.path, \"utf-8\");\n *       const newContent = applyDiff(current, operation.diff);\n *       await fs.writeFile(operation.path, newContent);\n *       return `Updated ${operation.path}`;\n *     }\n *     if (operation.type === \"delete_file\") {\n *       await fs.unlink(operation.path);\n *       return `Deleted ${operation.path}`;\n *     }\n *     return \"Unknown operation type\";\n *   },\n * });\n *\n * const llmWithPatch = model.bindTools([patchTool]);\n * const response = await llmWithPatch.invoke(\n *   \"Rename the fib() function to fibonacci() in lib/fib.py\"\n * );\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Operations include: `create_file`, `update_file`, `delete_file`\n * - Patches use V4A diff format for updates\n * - Always validate paths to prevent directory traversal attacks\n * - Consider backing up files before applying patches\n * - Implement \"all-or-nothing\" semantics if atomicity is required\n */\nexport declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<z.ZodDiscriminatedUnion<[z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>]>, ApplyPatchOperation, unknown, string>;\n//# sourceMappingURL=applyPatch.d.ts.map"],"mappings":";;;;;;;;AAMA;AACYQ,KADAJ,6BAAAA,GAAgCF,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BC,UACU;AAC5FG,KADAF,6BAAAA,GAAgCN,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BG,UACU;AAI5FG,KAJAF,6BAAAA,GAAgCR,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BK,UAIjD;AA8B7C;AAsCA;AA4EA;AAA4Ca,KAhJhCZ,mBAAAA,GAAsBC,WAgJUW,CAhJEtB,QAAAA,CAAaG,SAAAA,CAAUC,0BAgJzBkB,CAAAA,WAAAA,CAAAA,CAAAA;;;;UAlH3BA,iBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiCQZ,iCAAiCa;;;;;KAK9CC,cAAAA,GAAiBxB,QAAAA,CAAaG,SAAAA,CAAUqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4E5BC,UAAAA,UAAoBH,oBAAoBrB,sBAAsBH,CAAAA,CAAEuB,uBAAuBvB,CAAAA,CAAEmB;QACvGnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;QACFhB,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,SAASlB,CAAAA,CAAEmB;QACXnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;QACFhB,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,SAASlB,CAAAA,CAAEmB;QACXnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,WAAWN"}

package/dist/tools/applyPatch.d.ts

@@ -0,0 +1,148 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod/v4";
+
+//#region src/tools/applyPatch.d.ts
+
+/**
+ * Re-export operation types from OpenAI SDK for convenience.
+ */
+type ApplyPatchCreateFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.CreateFile;
+type ApplyPatchUpdateFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.UpdateFile;
+type ApplyPatchDeleteFileOperation = OpenAI$1.Responses.ResponseApplyPatchToolCall.DeleteFile;
+/**
+ * Union type of all apply patch operations from OpenAI SDK.
+ */
+type ApplyPatchOperation = NonNullable<OpenAI$1.Responses.ResponseApplyPatchToolCall["operation"]>;
+/**
+ * Options for the Apply Patch tool.
+ */
+interface ApplyPatchOptions {
+  /**
+   * Execute function that handles patch operations.
+   * This function receives the operation input and should return a string
+   * describing the result (success or failure message).
+   *
+   * The operation types are:
+   * - `create_file`: Create a new file at the specified path with the diff content
+   * - `update_file`: Modify an existing file using V4A diff format
+   * - `delete_file`: Remove a file at the specified path
+   *
+   * @example
+   * ```typescript
+   * execute: async (operation) => {
+   *   if (operation.type === "create_file") {
+   *     const content = applyDiff("", operation.diff, "create");
+   *     await fs.writeFile(operation.path, content);
+   *     return `Created ${operation.path}`;
+   *   }
+   *   if (operation.type === "update_file") {
+   *     const current = await fs.readFile(operation.path, "utf-8");
+   *     const newContent = applyDiff(current, operation.diff);
+   *     await fs.writeFile(operation.path, newContent);
+   *     return `Updated ${operation.path}`;
+   *   }
+   *   if (operation.type === "delete_file") {
+   *     await fs.unlink(operation.path);
+   *     return `Deleted ${operation.path}`;
+   *   }
+   *   return "Unknown operation type";
+   * }
+   * ```
+   */
+  execute: (operation: ApplyPatchOperation) => string | Promise<string>;
+}
+/**
+ * OpenAI Apply Patch tool type for the Responses API.
+ */
+type ApplyPatchTool = OpenAI$1.Responses.ApplyPatchTool;
+/**
+ * Creates an Apply Patch tool that allows models to propose structured diffs
+ * that your integration applies. This enables iterative, multi-step code
+ * editing workflows.
+ *
+ * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase
+ * using structured diffs. Instead of just suggesting edits, the model emits
+ * patch operations that your application applies and then reports back on.
+ *
+ * **When to use**:
+ * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules
+ * - **Bug fixes** – Have the model both diagnose issues and emit precise patches
+ * - **Tests & docs generation** – Create new test files, fixtures, and documentation
+ * - **Migrations & mechanical edits** – Apply repetitive, structured updates
+ *
+ * **How it works**:
+ * The tool operates in a continuous loop:
+ * 1. Model sends patch operations (`apply_patch_call` with operation type)
+ * 2. Your code applies the patch to your working directory or repo
+ * 3. You return success/failure status and optional output
+ * 4. Repeat until the task is complete
+ *
+ * **Security Warning**: Applying patches can modify files in your codebase.
+ * Always validate paths, implement backups, and consider sandboxing.
+ *
+ * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}
+ *
+ * @param options - Configuration options for the Apply Patch tool
+ * @returns An Apply Patch tool that can be passed to `bindTools`
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI, tools } from "@langchain/openai";
+ * import { applyDiff } from "@openai/agents";
+ * import * as fs from "fs/promises";
+ *
+ * const model = new ChatOpenAI({ model: "gpt-5.1" });
+ *
+ * // With execute callback for automatic patch handling
+ * const patchTool = tools.applyPatch({
+ *   execute: async (operation) => {
+ *     if (operation.type === "create_file") {
+ *       const content = applyDiff("", operation.diff, "create");
+ *       await fs.writeFile(operation.path, content);
+ *       return `Created ${operation.path}`;
+ *     }
+ *     if (operation.type === "update_file") {
+ *       const current = await fs.readFile(operation.path, "utf-8");
+ *       const newContent = applyDiff(current, operation.diff);
+ *       await fs.writeFile(operation.path, newContent);
+ *       return `Updated ${operation.path}`;
+ *     }
+ *     if (operation.type === "delete_file") {
+ *       await fs.unlink(operation.path);
+ *       return `Deleted ${operation.path}`;
+ *     }
+ *     return "Unknown operation type";
+ *   },
+ * });
+ *
+ * const llmWithPatch = model.bindTools([patchTool]);
+ * const response = await llmWithPatch.invoke(
+ *   "Rename the fib() function to fibonacci() in lib/fib.py"
+ * );
+ * ```
+ *
+ * @remarks
+ * - Only available through the Responses API (not Chat Completions)
+ * - Designed for use with `gpt-5.1` model
+ * - Operations include: `create_file`, `update_file`, `delete_file`
+ * - Patches use V4A diff format for updates
+ * - Always validate paths to prevent directory traversal attacks
+ * - Consider backing up files before applying patches
+ * - Implement "all-or-nothing" semantics if atomicity is required
+ */
+declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"create_file">;
+  path: z.ZodString;
+  diff: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"update_file">;
+  path: z.ZodString;
+  diff: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"delete_file">;
+  path: z.ZodString;
+}, z.core.$strip>]>, ApplyPatchOperation, unknown, string>;
+//#endregion
+export { ApplyPatchCreateFileOperation, ApplyPatchDeleteFileOperation, ApplyPatchOperation, ApplyPatchOptions, ApplyPatchTool, ApplyPatchUpdateFileOperation, applyPatch };
+//# sourceMappingURL=applyPatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyPatch.d.ts","names":["z","OpenAI","OpenAIClient","DynamicStructuredTool","ApplyPatchCreateFileOperation","Responses","ResponseApplyPatchToolCall","CreateFile","ApplyPatchUpdateFileOperation","UpdateFile","ApplyPatchDeleteFileOperation","DeleteFile","ApplyPatchOperation","NonNullable","ApplyPatchCreateFileOperationSchema","ZodLiteral","ZodString","core","$strip","ZodObject","ApplyPatchUpdateFileOperationSchema","ApplyPatchDeleteFileOperationSchema","ApplyPatchOperationSchema","ZodDiscriminatedUnion","ApplyPatchOptions","Promise","ApplyPatchTool","applyPatch"],"sources":["../../src/tools/applyPatch.d.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { type DynamicStructuredTool } from \"@langchain/core/tools\";\n/**\n * Re-export operation types from OpenAI SDK for convenience.\n */\nexport type ApplyPatchCreateFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.CreateFile;\nexport type ApplyPatchUpdateFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.UpdateFile;\nexport type ApplyPatchDeleteFileOperation = OpenAIClient.Responses.ResponseApplyPatchToolCall.DeleteFile;\n/**\n * Union type of all apply patch operations from OpenAI SDK.\n */\nexport type ApplyPatchOperation = NonNullable<OpenAIClient.Responses.ResponseApplyPatchToolCall[\"operation\"]>;\nexport declare const ApplyPatchCreateFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchUpdateFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchDeleteFileOperationSchema: z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>;\nexport declare const ApplyPatchOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>]>;\n/**\n * Options for the Apply Patch tool.\n */\nexport interface ApplyPatchOptions {\n    /**\n     * Execute function that handles patch operations.\n     * This function receives the operation input and should return a string\n     * describing the result (success or failure message).\n     *\n     * The operation types are:\n     * - `create_file`: Create a new file at the specified path with the diff content\n     * - `update_file`: Modify an existing file using V4A diff format\n     * - `delete_file`: Remove a file at the specified path\n     *\n     * @example\n     * ```typescript\n     * execute: async (operation) => {\n     *   if (operation.type === \"create_file\") {\n     *     const content = applyDiff(\"\", operation.diff, \"create\");\n     *     await fs.writeFile(operation.path, content);\n     *     return `Created ${operation.path}`;\n     *   }\n     *   if (operation.type === \"update_file\") {\n     *     const current = await fs.readFile(operation.path, \"utf-8\");\n     *     const newContent = applyDiff(current, operation.diff);\n     *     await fs.writeFile(operation.path, newContent);\n     *     return `Updated ${operation.path}`;\n     *   }\n     *   if (operation.type === \"delete_file\") {\n     *     await fs.unlink(operation.path);\n     *     return `Deleted ${operation.path}`;\n     *   }\n     *   return \"Unknown operation type\";\n     * }\n     * ```\n     */\n    execute: (operation: ApplyPatchOperation) => string | Promise<string>;\n}\n/**\n * OpenAI Apply Patch tool type for the Responses API.\n */\nexport type ApplyPatchTool = OpenAIClient.Responses.ApplyPatchTool;\n/**\n * Creates an Apply Patch tool that allows models to propose structured diffs\n * that your integration applies. This enables iterative, multi-step code\n * editing workflows.\n *\n * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase\n * using structured diffs. Instead of just suggesting edits, the model emits\n * patch operations that your application applies and then reports back on.\n *\n * **When to use**:\n * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules\n * - **Bug fixes** – Have the model both diagnose issues and emit precise patches\n * - **Tests & docs generation** – Create new test files, fixtures, and documentation\n * - **Migrations & mechanical edits** – Apply repetitive, structured updates\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends patch operations (`apply_patch_call` with operation type)\n * 2. Your code applies the patch to your working directory or repo\n * 3. You return success/failure status and optional output\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Applying patches can modify files in your codebase.\n * Always validate paths, implement backups, and consider sandboxing.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}\n *\n * @param options - Configuration options for the Apply Patch tool\n * @returns An Apply Patch tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { applyDiff } from \"@openai/agents\";\n * import * as fs from \"fs/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic patch handling\n * const patchTool = tools.applyPatch({\n *   execute: async (operation) => {\n *     if (operation.type === \"create_file\") {\n *       const content = applyDiff(\"\", operation.diff, \"create\");\n *       await fs.writeFile(operation.path, content);\n *       return `Created ${operation.path}`;\n *     }\n *     if (operation.type === \"update_file\") {\n *       const current = await fs.readFile(operation.path, \"utf-8\");\n *       const newContent = applyDiff(current, operation.diff);\n *       await fs.writeFile(operation.path, newContent);\n *       return `Updated ${operation.path}`;\n *     }\n *     if (operation.type === \"delete_file\") {\n *       await fs.unlink(operation.path);\n *       return `Deleted ${operation.path}`;\n *     }\n *     return \"Unknown operation type\";\n *   },\n * });\n *\n * const llmWithPatch = model.bindTools([patchTool]);\n * const response = await llmWithPatch.invoke(\n *   \"Rename the fib() function to fibonacci() in lib/fib.py\"\n * );\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Operations include: `create_file`, `update_file`, `delete_file`\n * - Patches use V4A diff format for updates\n * - Always validate paths to prevent directory traversal attacks\n * - Consider backing up files before applying patches\n * - Implement \"all-or-nothing\" semantics if atomicity is required\n */\nexport declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<z.ZodDiscriminatedUnion<[z.ZodObject<{\n    type: z.ZodLiteral<\"create_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"update_file\">;\n    path: z.ZodString;\n    diff: z.ZodString;\n}, z.core.$strip>, z.ZodObject<{\n    type: z.ZodLiteral<\"delete_file\">;\n    path: z.ZodString;\n}, z.core.$strip>]>, ApplyPatchOperation, unknown, string>;\n//# sourceMappingURL=applyPatch.d.ts.map"],"mappings":";;;;;;;;AAMA;AACYQ,KADAJ,6BAAAA,GAAgCF,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BC,UACAE;AAClFC,KADAF,6BAAAA,GAAgCN,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BG,UACAE;AAIlFC,KAJAF,6BAAAA,GAAgCR,QAAAA,CAAaG,SAAAA,CAAUC,0BAAAA,CAA2BK,UAIjD;AA8B7C;AAsCA;AA4EA;AAA4Ca,KAhJhCZ,mBAAAA,GAAsBC,WAgJUW,CAhJEtB,QAAAA,CAAaG,SAAAA,CAAUC,0BAgJzBkB,CAAAA,WAAAA,CAAAA,CAAAA;;;;UAlH3BA,iBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiCQZ,iCAAiCa;;;;;KAK9CC,cAAAA,GAAiBxB,QAAAA,CAAaG,SAAAA,CAAUqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4E5BC,UAAAA,UAAoBH,oBAAoBrB,sBAAsBH,CAAAA,CAAEuB,uBAAuBvB,CAAAA,CAAEmB;QACvGnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;QACFhB,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,SAASlB,CAAAA,CAAEmB;QACXnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;QACFhB,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,SAASlB,CAAAA,CAAEmB;QACXnB,CAAAA,CAAEe;QACFf,CAAAA,CAAEgB;GACThB,CAAAA,CAAEiB,IAAAA,CAAKC,WAAWN"}

package/dist/tools/applyPatch.js

@@ -0,0 +1,115 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod/v4";
+
+//#region src/tools/applyPatch.ts
+const ApplyPatchCreateFileOperationSchema = z.object({
+	type: z.literal("create_file"),
+	path: z.string(),
+	diff: z.string()
+});
+const ApplyPatchUpdateFileOperationSchema = z.object({
+	type: z.literal("update_file"),
+	path: z.string(),
+	diff: z.string()
+});
+const ApplyPatchDeleteFileOperationSchema = z.object({
+	type: z.literal("delete_file"),
+	path: z.string()
+});
+const ApplyPatchOperationSchema = z.discriminatedUnion("type", [
+	ApplyPatchCreateFileOperationSchema,
+	ApplyPatchUpdateFileOperationSchema,
+	ApplyPatchDeleteFileOperationSchema
+]);
+const TOOL_NAME = "apply_patch";
+/**
+* Creates an Apply Patch tool that allows models to propose structured diffs
+* that your integration applies. This enables iterative, multi-step code
+* editing workflows.
+*
+* **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase
+* using structured diffs. Instead of just suggesting edits, the model emits
+* patch operations that your application applies and then reports back on.
+*
+* **When to use**:
+* - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules
+* - **Bug fixes** – Have the model both diagnose issues and emit precise patches
+* - **Tests & docs generation** – Create new test files, fixtures, and documentation
+* - **Migrations & mechanical edits** – Apply repetitive, structured updates
+*
+* **How it works**:
+* The tool operates in a continuous loop:
+* 1. Model sends patch operations (`apply_patch_call` with operation type)
+* 2. Your code applies the patch to your working directory or repo
+* 3. You return success/failure status and optional output
+* 4. Repeat until the task is complete
+*
+* **Security Warning**: Applying patches can modify files in your codebase.
+* Always validate paths, implement backups, and consider sandboxing.
+*
+* @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}
+*
+* @param options - Configuration options for the Apply Patch tool
+* @returns An Apply Patch tool that can be passed to `bindTools`
+*
+* @example
+* ```typescript
+* import { ChatOpenAI, tools } from "@langchain/openai";
+* import { applyDiff } from "@openai/agents";
+* import * as fs from "fs/promises";
+*
+* const model = new ChatOpenAI({ model: "gpt-5.1" });
+*
+* // With execute callback for automatic patch handling
+* const patchTool = tools.applyPatch({
+*   execute: async (operation) => {
+*     if (operation.type === "create_file") {
+*       const content = applyDiff("", operation.diff, "create");
+*       await fs.writeFile(operation.path, content);
+*       return `Created ${operation.path}`;
+*     }
+*     if (operation.type === "update_file") {
+*       const current = await fs.readFile(operation.path, "utf-8");
+*       const newContent = applyDiff(current, operation.diff);
+*       await fs.writeFile(operation.path, newContent);
+*       return `Updated ${operation.path}`;
+*     }
+*     if (operation.type === "delete_file") {
+*       await fs.unlink(operation.path);
+*       return `Deleted ${operation.path}`;
+*     }
+*     return "Unknown operation type";
+*   },
+* });
+*
+* const llmWithPatch = model.bindTools([patchTool]);
+* const response = await llmWithPatch.invoke(
+*   "Rename the fib() function to fibonacci() in lib/fib.py"
+* );
+* ```
+*
+* @remarks
+* - Only available through the Responses API (not Chat Completions)
+* - Designed for use with `gpt-5.1` model
+* - Operations include: `create_file`, `update_file`, `delete_file`
+* - Patches use V4A diff format for updates
+* - Always validate paths to prevent directory traversal attacks
+* - Consider backing up files before applying patches
+* - Implement "all-or-nothing" semantics if atomicity is required
+*/
+function applyPatch(options) {
+	const patchTool = tool(options.execute, {
+		name: TOOL_NAME,
+		description: "Apply structured diffs to create, update, or delete files in the codebase.",
+		schema: ApplyPatchOperationSchema
+	});
+	patchTool.extras = {
+		...patchTool.extras ?? {},
+		providerToolDefinition: { type: "apply_patch" }
+	};
+	return patchTool;
+}
+
+//#endregion
+export { applyPatch };
+//# sourceMappingURL=applyPatch.js.map

package/dist/tools/applyPatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyPatch.js","names":["options: ApplyPatchOptions"],"sources":["../../src/tools/applyPatch.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport { OpenAI as OpenAIClient } from \"openai\";\nimport { tool, type DynamicStructuredTool } from \"@langchain/core/tools\";\n\n/**\n * Re-export operation types from OpenAI SDK for convenience.\n */\nexport type ApplyPatchCreateFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.CreateFile;\nexport type ApplyPatchUpdateFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.UpdateFile;\nexport type ApplyPatchDeleteFileOperation =\n  OpenAIClient.Responses.ResponseApplyPatchToolCall.DeleteFile;\n\n/**\n * Union type of all apply patch operations from OpenAI SDK.\n */\nexport type ApplyPatchOperation = NonNullable<\n  OpenAIClient.Responses.ResponseApplyPatchToolCall[\"operation\"]\n>;\n\n// Zod schemas for apply patch operations\nexport const ApplyPatchCreateFileOperationSchema = z.object({\n  type: z.literal(\"create_file\"),\n  path: z.string(),\n  diff: z.string(),\n});\n\nexport const ApplyPatchUpdateFileOperationSchema = z.object({\n  type: z.literal(\"update_file\"),\n  path: z.string(),\n  diff: z.string(),\n});\n\nexport const ApplyPatchDeleteFileOperationSchema = z.object({\n  type: z.literal(\"delete_file\"),\n  path: z.string(),\n});\n\n// Discriminated union schema for all apply patch operations\nexport const ApplyPatchOperationSchema = z.discriminatedUnion(\"type\", [\n  ApplyPatchCreateFileOperationSchema,\n  ApplyPatchUpdateFileOperationSchema,\n  ApplyPatchDeleteFileOperationSchema,\n]);\n\n/**\n * Options for the Apply Patch tool.\n */\nexport interface ApplyPatchOptions {\n  /**\n   * Execute function that handles patch operations.\n   * This function receives the operation input and should return a string\n   * describing the result (success or failure message).\n   *\n   * The operation types are:\n   * - `create_file`: Create a new file at the specified path with the diff content\n   * - `update_file`: Modify an existing file using V4A diff format\n   * - `delete_file`: Remove a file at the specified path\n   *\n   * @example\n   * ```typescript\n   * execute: async (operation) => {\n   *   if (operation.type === \"create_file\") {\n   *     const content = applyDiff(\"\", operation.diff, \"create\");\n   *     await fs.writeFile(operation.path, content);\n   *     return `Created ${operation.path}`;\n   *   }\n   *   if (operation.type === \"update_file\") {\n   *     const current = await fs.readFile(operation.path, \"utf-8\");\n   *     const newContent = applyDiff(current, operation.diff);\n   *     await fs.writeFile(operation.path, newContent);\n   *     return `Updated ${operation.path}`;\n   *   }\n   *   if (operation.type === \"delete_file\") {\n   *     await fs.unlink(operation.path);\n   *     return `Deleted ${operation.path}`;\n   *   }\n   *   return \"Unknown operation type\";\n   * }\n   * ```\n   */\n  execute: (operation: ApplyPatchOperation) => string | Promise<string>;\n}\n\n/**\n * OpenAI Apply Patch tool type for the Responses API.\n */\nexport type ApplyPatchTool = OpenAIClient.Responses.ApplyPatchTool;\n\nconst TOOL_NAME = \"apply_patch\";\n\n/**\n * Creates an Apply Patch tool that allows models to propose structured diffs\n * that your integration applies. This enables iterative, multi-step code\n * editing workflows.\n *\n * **Apply Patch** lets GPT-5.1 create, update, and delete files in your codebase\n * using structured diffs. Instead of just suggesting edits, the model emits\n * patch operations that your application applies and then reports back on.\n *\n * **When to use**:\n * - **Multi-file refactors** – Rename symbols, extract helpers, or reorganize modules\n * - **Bug fixes** – Have the model both diagnose issues and emit precise patches\n * - **Tests & docs generation** – Create new test files, fixtures, and documentation\n * - **Migrations & mechanical edits** – Apply repetitive, structured updates\n *\n * **How it works**:\n * The tool operates in a continuous loop:\n * 1. Model sends patch operations (`apply_patch_call` with operation type)\n * 2. Your code applies the patch to your working directory or repo\n * 3. You return success/failure status and optional output\n * 4. Repeat until the task is complete\n *\n * **Security Warning**: Applying patches can modify files in your codebase.\n * Always validate paths, implement backups, and consider sandboxing.\n *\n * @see {@link https://platform.openai.com/docs/guides/tools-apply-patch | OpenAI Apply Patch Documentation}\n *\n * @param options - Configuration options for the Apply Patch tool\n * @returns An Apply Patch tool that can be passed to `bindTools`\n *\n * @example\n * ```typescript\n * import { ChatOpenAI, tools } from \"@langchain/openai\";\n * import { applyDiff } from \"@openai/agents\";\n * import * as fs from \"fs/promises\";\n *\n * const model = new ChatOpenAI({ model: \"gpt-5.1\" });\n *\n * // With execute callback for automatic patch handling\n * const patchTool = tools.applyPatch({\n *   execute: async (operation) => {\n *     if (operation.type === \"create_file\") {\n *       const content = applyDiff(\"\", operation.diff, \"create\");\n *       await fs.writeFile(operation.path, content);\n *       return `Created ${operation.path}`;\n *     }\n *     if (operation.type === \"update_file\") {\n *       const current = await fs.readFile(operation.path, \"utf-8\");\n *       const newContent = applyDiff(current, operation.diff);\n *       await fs.writeFile(operation.path, newContent);\n *       return `Updated ${operation.path}`;\n *     }\n *     if (operation.type === \"delete_file\") {\n *       await fs.unlink(operation.path);\n *       return `Deleted ${operation.path}`;\n *     }\n *     return \"Unknown operation type\";\n *   },\n * });\n *\n * const llmWithPatch = model.bindTools([patchTool]);\n * const response = await llmWithPatch.invoke(\n *   \"Rename the fib() function to fibonacci() in lib/fib.py\"\n * );\n * ```\n *\n * @remarks\n * - Only available through the Responses API (not Chat Completions)\n * - Designed for use with `gpt-5.1` model\n * - Operations include: `create_file`, `update_file`, `delete_file`\n * - Patches use V4A diff format for updates\n * - Always validate paths to prevent directory traversal attacks\n * - Consider backing up files before applying patches\n * - Implement \"all-or-nothing\" semantics if atomicity is required\n */\nexport function applyPatch(options: ApplyPatchOptions) {\n  const patchTool = tool(options.execute, {\n    name: TOOL_NAME,\n    description:\n      \"Apply structured diffs to create, update, or delete files in the codebase.\",\n    schema: ApplyPatchOperationSchema,\n  });\n\n  patchTool.extras = {\n    ...(patchTool.extras ?? {}),\n    providerToolDefinition: {\n      type: \"apply_patch\",\n    } satisfies ApplyPatchTool,\n  };\n\n  return patchTool as DynamicStructuredTool<\n    typeof ApplyPatchOperationSchema,\n    ApplyPatchOperation,\n    unknown,\n    string\n  >;\n}\n"],"mappings":";;;;AAsBA,MAAa,sCAAsC,EAAE,OAAO;CAC1D,MAAM,EAAE,QAAQ,cAAc;CAC9B,MAAM,EAAE,QAAQ;CAChB,MAAM,EAAE,QAAQ;AACjB,EAAC;AAEF,MAAa,sCAAsC,EAAE,OAAO;CAC1D,MAAM,EAAE,QAAQ,cAAc;CAC9B,MAAM,EAAE,QAAQ;CAChB,MAAM,EAAE,QAAQ;AACjB,EAAC;AAEF,MAAa,sCAAsC,EAAE,OAAO;CAC1D,MAAM,EAAE,QAAQ,cAAc;CAC9B,MAAM,EAAE,QAAQ;AACjB,EAAC;AAGF,MAAa,4BAA4B,EAAE,mBAAmB,QAAQ;CACpE;CACA;CACA;AACD,EAAC;AA8CF,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ElB,SAAgB,WAAWA,SAA4B;CACrD,MAAM,YAAY,KAAK,QAAQ,SAAS;EACtC,MAAM;EACN,aACE;EACF,QAAQ;CACT,EAAC;CAEF,UAAU,SAAS;EACjB,GAAI,UAAU,UAAU,CAAE;EAC1B,wBAAwB,EACtB,MAAM,cACP;CACF;AAED,QAAO;AAMR"}