@oh-my-pi/pi-coding-agent 14.1.1 → 14.2.0

package/src/discovery/claude-plugins.ts

@@ -28,6 +28,58 @@ const PROVIDER_ID = "claude-plugins";
 const DISPLAY_NAME = "Claude Code Marketplace";
 const PRIORITY = 70; // Below claude.ts (80) so user .claude/ overrides win
 
+interface ClaudePluginManifest {
+	skills?: string;
+	"slash-commands"?: string;
+}
+
+interface ResolvedPluginDir {
+	dir: string;
+	warning?: string;
+}
+
+async function readPluginManifest(root: ClaudePluginRoot): Promise<ClaudePluginManifest | null> {
+	const manifestPath = path.join(root.path, ".claude-plugin", "plugin.json");
+	const raw = await readFile(manifestPath);
+	if (raw === null) return null;
+
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		return parsed as ClaudePluginManifest;
+	} catch {
+		return null;
+	}
+}
+
+function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
+	const relative = path.relative(rootPath, targetPath);
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function resolvePluginDir(
+	root: ClaudePluginRoot,
+	manifestKey: keyof ClaudePluginManifest,
+	fallback: string,
+): Promise<ResolvedPluginDir> {
+	const manifest = await readPluginManifest(root);
+	const fallbackDir = path.join(root.path, fallback);
+	const configured = manifest?.[manifestKey];
+	if (typeof configured !== "string" || !configured.trim()) {
+		return { dir: fallbackDir };
+	}
+
+	const resolved = path.resolve(root.path, configured.trim());
+	if (isWithinPluginRoot(root.path, resolved)) {
+		return { dir: resolved };
+	}
+
+	return {
+		dir: fallbackDir,
+		warning: `[claude-plugins] Ignoring ${String(manifestKey)} path outside plugin root for ${root.id}: ${configured}`,
+	};
+}
+
 // =============================================================================
 // Skills
 // =============================================================================
@@ -41,17 +93,18 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const skillsDir = path.join(root.path, "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(root, "skills", "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
 				level: root.scope,
 			});
-			return { root, result };
+			return { root, result, warning };
 		}),
 	);
 
-	for (const { root, result } of results) {
+	for (const { root, result, warning } of results) {
+		if (warning) warnings.push(warning);
 		for (const skill of result.items) {
 			if (root.plugin) skill.name = `${root.plugin}:${skill.name}`;
 			items.push(skill);
@@ -75,8 +128,8 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const commandsDir = path.join(root.path, "commands");
-			return loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
+			const { dir: commandsDir, warning } = await resolvePluginDir(root, "slash-commands", "commands");
+			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {
 					const cmdName = name.replace(/\.md$/, "");
@@ -89,10 +142,12 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 					};
 				},
 			});
+			return { result, warning };
 		}),
 	);
 
-	for (const result of results) {
+	for (const { result, warning } of results) {
+		if (warning) warnings.push(warning);
 		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}

package/src/discovery/codex.ts

@@ -30,9 +30,9 @@ import { toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
 import {
+	buildExtensionModuleItems,
 	createSourceMeta,
 	discoverExtensionModulePaths,
-	getExtensionNameFromPath,
 	loadFilesFromDir,
 	SOURCE_PATHS,
 	scanSkillsFromDir,
@@ -251,20 +251,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		discoverExtensionModulePaths(ctx, projectExtensionsDir),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings };
 }

package/src/discovery/gemini.ts

@@ -27,11 +27,11 @@ import { type Settings, settingsCapability } from "../capability/settings";
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import type { LoadContext, LoadResult } from "../capability/types";
 import {
+	buildExtensionModuleItems,
 	calculateDepth,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
-	getExtensionNameFromPath,
 	getProjectPath,
 	getUserPath,
 } from "./helpers";
@@ -238,20 +238,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		projectExtensionsDir ? discoverExtensionModulePaths(ctx, projectExtensionsDir) : Promise.resolve([]),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings: [] };
 }

package/src/discovery/helpers.ts

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, getConfigDirName, getProjectDir, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
-import { readDirEntries, readFile } from "../capability/fs";
+import type { ExtensionModule } from "../capability/extension-module";
+import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
@@ -581,6 +582,31 @@ export function getExtensionNameFromPath(extensionPath: string): string {
 	return base;
 }
 
+/**
+ * Build ExtensionModule items from discovered user/project paths.
+ * Shared across providers that expose extension modules via user + project dirs.
+ */
+export function buildExtensionModuleItems(
+	providerId: string,
+	userPaths: string[],
+	projectPaths: string[],
+): ExtensionModule[] {
+	return [
+		...userPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "user" as const,
+			_source: createSourceMeta(providerId, extPath, "user"),
+		})),
+		...projectPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "project" as const,
+			_source: createSourceMeta(providerId, extPath, "project"),
+		})),
+	];
+}
+
 // =============================================================================
 // Claude Code Plugin Cache Helpers
 // =============================================================================
@@ -896,6 +922,19 @@ export function clearClaudePluginRootsCache(): void {
 	}
 }
 
+/**
+ * Invalidate fs caches for installed-plugin registry files and reset the
+ * in-memory plugin roots cache. Used by MarketplaceManager clients after
+ * installing/uninstalling/enabling/disabling plugins.
+ */
+export function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void {
+	const home = os.homedir();
+	invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+	for (const p of extraPaths ?? []) invalidateFsCache(p);
+	clearClaudePluginRootsCache();
+}
+
 // ── Preloaded plugin roots (for sync consumers like LSP config) ─────────────
 // Populated at startup by preloadPluginRoots(). Read synchronously by
 // getPreloadedPluginRoots(). Safe degradation: empty array if not warmed.

package/src/discovery/opencode.ts

@@ -28,10 +28,10 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
 import {
+	buildExtensionModuleItems,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
-	getExtensionNameFromPath,
 	getProjectPath,
 	getUserPath,
 	loadFilesFromDir,
@@ -227,20 +227,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		projectPluginsDir ? discoverExtensionModulePaths(ctx, projectPluginsDir) : Promise.resolve([]),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings: [] };
 }

package/src/edit/apply-patch/index.ts

@@ -0,0 +1,87 @@
+/**
+ * Multi-file orchestrator for the Codex `apply_patch` envelope.
+ *
+ * Decoupled from tool-registration: takes raw patch text + options, parses
+ * it, and applies each hunk via the existing single-file `applyPatch` in
+ * `../modes/patch.ts`. A future OpenAI freeform/grammar tool variant can
+ * call this directly with the raw grammar output.
+ *
+ * Per spec §6.1, hunks are applied in order and NOT atomically — if hunk
+ * N fails, hunks `0..N-1` are already on disk. We surface that by
+ * returning the per-file results alongside the error when it happens.
+ */
+
+import { ApplyPatchError } from "../diff";
+import { type ApplyPatchOptions, type ApplyPatchResult, applyPatch, type PatchInput } from "../modes/patch";
+import { parseApplyPatch } from "./parser";
+
+export * from "./parser";
+
+export interface ApplyCodexPatchResult {
+	/** Single-file apply results in the order they were attempted. */
+	results: ApplyPatchResult[];
+	/** Affected file paths grouped by operation, for the §9.1 summary. */
+	affected: {
+		added: string[];
+		modified: string[];
+		deleted: string[];
+	};
+}
+
+/**
+ * Apply a full Codex `*** Begin Patch` envelope.
+ *
+ * Note: renames are reported under `modified` with the original path (spec
+ * §9.1), not as a delete + add.
+ */
+export async function applyCodexPatch(patchText: string, options: ApplyPatchOptions): Promise<ApplyCodexPatchResult> {
+	const hunks = parseApplyPatch(patchText);
+
+	if (hunks.length === 0) {
+		throw new ApplyPatchError("No files were modified.");
+	}
+
+	const results: ApplyPatchResult[] = [];
+	const affected = {
+		added: [] as string[],
+		modified: [] as string[],
+		deleted: [] as string[],
+	};
+
+	for (const hunk of hunks) {
+		const result = await applyPatch(hunk, options);
+		results.push(result);
+		recordAffected(affected, hunk, result);
+	}
+
+	return { results, affected };
+}
+
+function recordAffected(
+	affected: ApplyCodexPatchResult["affected"],
+	hunk: PatchInput,
+	_result: ApplyPatchResult,
+): void {
+	switch (hunk.op) {
+		case "create":
+			affected.added.push(hunk.path);
+			break;
+		case "delete":
+			affected.deleted.push(hunk.path);
+			break;
+		case "update":
+			affected.modified.push(hunk.path);
+			break;
+	}
+}
+
+/**
+ * Format the A/M/D summary described in spec §9.1.
+ */
+export function formatApplyCodexPatchSummary(affected: ApplyCodexPatchResult["affected"]): string {
+	const lines = ["Success. Updated the following files:"];
+	for (const p of affected.added) lines.push(`A ${p}`);
+	for (const p of affected.modified) lines.push(`M ${p}`);
+	for (const p of affected.deleted) lines.push(`D ${p}`);
+	return lines.join("\n");
+}

package/src/edit/apply-patch/parser.ts

@@ -0,0 +1,174 @@
+/**
+ * Parser for the Codex `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+
+import { ParseError } from "../diff";
+import type { PatchInput } from "../modes/patch";
+
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const ADD_FILE_MARKER = "*** Add File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+
+interface ParseApplyPatchOptions {
+	streaming?: boolean;
+}
+
+/**
+ * Parse a Codex `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export function parseApplyPatch(patchText: string): PatchInput[] {
+	return parseApplyPatchWithOptions(patchText, {});
+}
+
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export function parseApplyPatchStreaming(patchText: string): PatchInput[] {
+	return parseApplyPatchWithOptions(patchText, { streaming: true });
+}
+
+function parseApplyPatchWithOptions(patchText: string, options: ParseApplyPatchOptions): PatchInput[] {
+	const streaming = options.streaming === true;
+	let lines = patchText.trim().split("\n");
+
+	// Lenient heredoc strip: <<EOF / <<'EOF' / <<"EOF" ... EOF
+	if (lines.length >= 2) {
+		const first = lines[0];
+		const last = lines[lines.length - 1].trim();
+		const validOpeners = new Set(["<<EOF", "<<'EOF'", '<<"EOF"']);
+		if (validOpeners.has(first) && last === "EOF") {
+			lines = lines.slice(1, lines.length - 1);
+		}
+	}
+
+	if (lines.length === 0 || lines[0].trim() !== BEGIN_PATCH_MARKER) {
+		if (streaming) return [];
+		throw new ParseError("The first line of the patch must be '*** Begin Patch'");
+	}
+	const hasEndMarker = lines[lines.length - 1].trim() === END_PATCH_MARKER;
+	if (!hasEndMarker && !streaming) {
+		throw new ParseError("The last line of the patch must be '*** End Patch'");
+	}
+
+	const hunks: PatchInput[] = [];
+	let remaining = hasEndMarker ? lines.slice(1, lines.length - 1) : lines.slice(1);
+	// Line numbers are 1-based and include the `*** Begin Patch` line (= 1).
+	let lineNumber = 2;
+
+	while (remaining.length > 0) {
+		// Blank separator lines between hunks are ignored (spec §3.3).
+		if (remaining[0].trim() === "") {
+			remaining = remaining.slice(1);
+			lineNumber++;
+			continue;
+		}
+
+		const firstLine = remaining[0].trim();
+
+		if (firstLine.startsWith(ADD_FILE_MARKER)) {
+			const path = firstLine.slice(ADD_FILE_MARKER.length);
+			let contents = "";
+			let consumed = 1;
+
+			for (let i = 1; i < remaining.length; i++) {
+				const line = remaining[i];
+				if (line.startsWith("+")) {
+					contents += `${line.slice(1)}\n`;
+					consumed++;
+				} else {
+					break;
+				}
+			}
+
+			hunks.push({ path, op: "create", diff: contents });
+			remaining = remaining.slice(consumed);
+			lineNumber += consumed;
+			continue;
+		}
+
+		if (firstLine.startsWith(DELETE_FILE_MARKER)) {
+			const path = firstLine.slice(DELETE_FILE_MARKER.length);
+			hunks.push({ path, op: "delete" });
+			remaining = remaining.slice(1);
+			lineNumber++;
+			continue;
+		}
+
+		if (firstLine.startsWith(UPDATE_FILE_MARKER)) {
+			const path = firstLine.slice(UPDATE_FILE_MARKER.length);
+			remaining = remaining.slice(1);
+			lineNumber++;
+
+			let movePath: string | undefined;
+			if (remaining.length > 0 && remaining[0].startsWith(MOVE_TO_MARKER)) {
+				movePath = remaining[0].slice(MOVE_TO_MARKER.length);
+				remaining = remaining.slice(1);
+				lineNumber++;
+			}
+
+			// The body runs until the next file-op marker or end of input.
+			// `*** End of File` is a chunk-terminator and stays inside the body —
+			// the downstream unified-diff parser handles it.
+			const diffLines: string[] = [];
+			while (remaining.length > 0) {
+				const line = remaining[0];
+				if (
+					line.startsWith("*** Add File:") ||
+					line.startsWith("*** Delete File:") ||
+					line.startsWith("*** Update File:")
+				) {
+					break;
+				}
+				diffLines.push(line);
+				remaining = remaining.slice(1);
+				lineNumber++;
+			}
+
+			if (diffLines.length === 0) {
+				if (streaming) {
+					hunks.push({ path, op: "update", rename: movePath, diff: "" });
+					continue;
+				}
+				throw new ParseError(`Update file hunk for path '${path}' is empty`, lineNumber);
+			}
+
+			hunks.push({ path, op: "update", rename: movePath, diff: diffLines.join("\n") });
+			continue;
+		}
+
+		if (streaming) {
+			break;
+		}
+		throw new ParseError(
+			`'${firstLine}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`,
+			lineNumber,
+		);
+	}
+
+	return hunks;
+}

package/src/edit/diff.ts

@@ -4,11 +4,11 @@
  * Provides diff string generation and the replace-mode edit logic
  * used when not in patch mode.
  */
-import { isEnoent } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { resolveToCwd } from "../tools/path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, EditMatchError, findMatch } from "./modes/replace";
 import { adjustIndentation, normalizeToLF, stripBom } from "./normalize";
+import { readEditFileText } from "./read-file";
 
 export interface DiffResult {
 	diff: string;
@@ -275,17 +275,6 @@ function formatOccurrenceMatchError(
 	return `Found ${occurrences} occurrences${pathSuffix}${moreMsg}:\n\n${previews}\n\nAdd more context lines to disambiguate.`;
 }
 
-async function readFileTextForDiff(path: string, absolutePath: string): Promise<string> {
-	try {
-		return await Bun.file(absolutePath).text();
-	} catch (error) {
-		if (isEnoent(error)) {
-			throw new Error(`File not found: ${path}`);
-		}
-		throw error;
-	}
-}
-
 export function normalizeDiff(diff: string): string {
 	let lines = diff.split("\n");
 
@@ -761,12 +750,12 @@ export async function computeEditDiff(
 	if (oldText.length === 0) {
 		return { error: "oldText must not be empty." };
 	}
-	const absolutePath = resolveToCwd(path, cwd);
 
 	try {
+		const absolutePath = resolveToCwd(path, cwd);
 		let rawContent: string;
 		try {
-			rawContent = await readFileTextForDiff(path, absolutePath);
+			rawContent = await readEditFileText(absolutePath, path);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return { error: message || `Unable to read ${path}` };

package/src/edit/index.ts

@@ -8,6 +8,7 @@ import {
 	type WritethroughDeferredHandle,
 	writethroughNoop,
 } from "../lsp";
+import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import chunkEditDescription from "../prompts/tools/chunk-edit.md" with { type: "text" };
 import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
@@ -16,6 +17,13 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
+import {
+	type ApplyPatchParams,
+	applyPatchSchema,
+	expandApplyPatchToEntries,
+	isApplyPatchParams,
+} from "./modes/apply-patch";
+import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import {
 	type ChunkParams,
 	type ChunkToolEdit,
@@ -50,8 +58,10 @@ import {
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
+export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
+export * from "./modes/apply-patch";
 export * from "./modes/chunk";
 export * from "./modes/hashline";
 export * from "./modes/patch";
@@ -64,10 +74,11 @@ type TInput =
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
 	| typeof chunkEditParamsSchema
-	| typeof vimSchema;
+	| typeof vimSchema
+	| typeof applyPatchSchema;
 
 type VimParams = Static<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
@@ -265,6 +276,28 @@ export class EditTool implements AgentTool<TInput> {
 		return this.#getModeDefinition().parameters;
 	}
 
+	/**
+	 * When in `apply_patch` mode, expose the Codex Lark grammar so providers
+	 * that support OpenAI-style custom tools can emit a grammar-constrained
+	 * variant. Providers that don't support custom tools ignore this field
+	 * and fall back to emitting a JSON function tool from `parameters`.
+	 */
+	get customFormat(): { syntax: "lark"; definition: string } | undefined {
+		if (this.mode !== "apply_patch") return undefined;
+		return { syntax: "lark", definition: applyPatchGrammar };
+	}
+
+	/**
+	 * Wire-level tool name used when the custom-tool variant is active. GPT-5+
+	 * is trained on the literal name `apply_patch`; internally this is just a
+	 * mode of the `edit` tool. The agent-loop dispatcher matches both the
+	 * internal `name` and `customWireName`, so returned calls route correctly.
+	 */
+	get customWireName(): string | undefined {
+		if (this.mode !== "apply_patch") return undefined;
+		return "apply_patch";
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: EditParams,
@@ -346,6 +379,36 @@ export class EditTool implements AgentTool<TInput> {
 					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
+			apply_patch: {
+				description: () => prompt.render(applyPatchDescription),
+				parameters: applyPatchSchema,
+				invalidParamsMessage: "Invalid edit parameters for apply_patch mode.",
+				validate: isApplyPatchParams,
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
+					const perFile = entries.map((entry: PatchEditEntry) => ({
+						path: entry.path,
+						run: (br: LspBatchRequest | undefined) =>
+							executePatchSingle({
+								session: tool.session,
+								params: entry,
+								signal,
+								batchRequest: br,
+								allowFuzzy: tool.#allowFuzzy,
+								fuzzyThreshold: tool.#fuzzyThreshold,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(perFile, batchRequest, onUpdate);
+				},
+			},
 			hashline: {
 				description: () => prompt.render(hashlineDescription),
 				parameters: hashlineEditParamsSchema,