@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/providers/openai-codex/websocket-events.ts

@@ -0,0 +1,210 @@
+import { WEBSOCKET_EVENT_QUEUE_CAPACITY, WEBSOCKET_IDLE_TIMEOUT_MS, WEBSOCKET_SEND_TIMEOUT_MS } from "./constants.js";
+import { ProviderProtocolError, extractWebSocketCloseError, extractWebSocketError } from "./errors.js";
+import { type StreamEventShape, type WebSocketLike } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export async function sendWebSocketRequest(
+	socket: WebSocketLike,
+	payload: string,
+	signal: AbortSignal | undefined,
+	timeoutMs = WEBSOCKET_SEND_TIMEOUT_MS,
+): Promise<void> {
+	if (signal?.aborted) throw new Error("Request was aborted");
+	await new Promise<void>((resolve, reject) => {
+		let settled = false;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const finish = (error?: Error) => {
+			if (settled) return;
+			settled = true;
+			if (timeout) clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+			if (error) reject(error);
+			else resolve();
+		};
+		const onAbort = () => finish(new Error("Request was aborted"));
+		timeout = setTimeout(
+			() => finish(new Error(`OpenAI Responses WebSocket send timed out after ${timeoutMs}ms`)),
+			Math.max(1, timeoutMs),
+		);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			socket.send(payload, (error?: Error) => {
+				if (error) {
+					finish(new Error(`Failed to send OpenAI Responses WebSocket request: ${error.message}`));
+					return;
+				}
+				finish();
+			});
+		} catch (error) {
+			finish(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+}
+
+export async function* parseWebSocket(socket: WebSocketLike, signal: AbortSignal | undefined): AsyncIterable<StreamEventShape> {
+	const queue: StreamEventShape[] = [];
+	let pending: (() => void) | null = null;
+	let done = false;
+	let failed: Error | null = null;
+	let closeError: Error | null = null;
+	let sawCompletion = false;
+	let pendingMessages = 0;
+	let messageChain = Promise.resolve();
+
+	const wake = () => {
+		if (!pending) return;
+		const resolve = pending;
+		pending = null;
+		resolve();
+	};
+
+	const onMessage = (event: unknown) => {
+		if (done) return;
+		if (queue.length + pendingMessages >= WEBSOCKET_EVENT_QUEUE_CAPACITY) {
+			failed = new ProviderProtocolError(
+				`OpenAI Responses WebSocket event queue exceeded ${WEBSOCKET_EVENT_QUEUE_CAPACITY} items`,
+			);
+			done = true;
+			wake();
+			return;
+		}
+		pendingMessages++;
+		messageChain = messageChain
+			.then(async () => {
+				if (!event || typeof event !== "object" || !("data" in event)) return;
+				if ((event as { isBinary?: unknown }).isBinary === true) {
+					failed = new ProviderProtocolError("Unexpected binary OpenAI Responses WebSocket event");
+					done = true;
+					return;
+				}
+				const data = (event as { data?: unknown }).data;
+				const text = typeof data === "string"
+					? data
+					: Buffer.isBuffer(data)
+						? data.toString("utf8")
+						: ArrayBuffer.isView(data)
+							? Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8")
+							: null;
+				if (text === null) {
+					failed = new ProviderProtocolError("Unsupported OpenAI Responses WebSocket message payload");
+					done = true;
+					return;
+				}
+				try {
+					const parsed = JSON.parse(text) as StreamEventShape;
+					const type = typeof parsed.type === "string" ? parsed.type : "";
+					if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+						sawCompletion = true;
+						closeError = null;
+						done = true;
+					}
+					if (queue.length >= WEBSOCKET_EVENT_QUEUE_CAPACITY) {
+						failed = new ProviderProtocolError(
+							`OpenAI Responses WebSocket event queue exceeded ${WEBSOCKET_EVENT_QUEUE_CAPACITY} items`,
+						);
+						done = true;
+						return;
+					}
+					queue.push(parsed);
+				} catch {
+					// Match Codex: malformed text frames are logged/ignored rather than
+					// tearing down an otherwise healthy response stream.
+				}
+			})
+			.catch((error: unknown) => {
+				failed = error instanceof Error ? error : new Error(String(error));
+				done = true;
+			})
+			.finally(() => {
+				pendingMessages--;
+				wake();
+			});
+	};
+
+	const onError = (event: unknown) => {
+		failed = extractWebSocketError(event);
+		done = true;
+		wake();
+	};
+
+	const onClose = (event: unknown) => {
+		if (sawCompletion) {
+			done = true;
+			wake();
+			return;
+		}
+		if (!closeError) {
+			closeError = extractWebSocketCloseError(event);
+		}
+		done = true;
+		wake();
+	};
+
+	const onAbort = () => {
+		failed = new Error("Request was aborted");
+		done = true;
+		wake();
+	};
+
+	socket.addEventListener("message", onMessage);
+	socket.addEventListener("error", onError);
+	socket.addEventListener("close", onClose);
+	signal?.addEventListener("abort", onAbort);
+
+	try {
+		while (true) {
+			if (signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+			if (queue.length > 0) {
+				yield queue.shift() as StreamEventShape;
+				continue;
+			}
+			if (done && pendingMessages === 0) break;
+			await new Promise<void>((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					pending = null;
+					reject(new Error(`OpenAI Responses WebSocket idle timeout after ${WEBSOCKET_IDLE_TIMEOUT_MS}ms`));
+				}, WEBSOCKET_IDLE_TIMEOUT_MS);
+				pending = () => {
+					clearTimeout(timeout);
+					resolve();
+				};
+			});
+		}
+
+		if (failed) throw failed;
+		if (closeError && !sawCompletion) throw closeError;
+		if (!sawCompletion) {
+			throw new Error("WebSocket stream closed before response.completed");
+		}
+	} finally {
+		socket.removeEventListener("message", onMessage);
+		socket.removeEventListener("error", onError);
+		socket.removeEventListener("close", onClose);
+		signal?.removeEventListener("abort", onAbort);
+	}
+}
+
+export async function* startWebSocketOutputOnFirstEvent(
+	events: AsyncIterable<StreamEventShape>,
+	onStart: () => void,
+): AsyncIterable<StreamEventShape> {
+	let started = false;
+	for await (const event of events) {
+		if (!started && event.type !== "error" && event.type !== "response.failed") {
+			started = true;
+			onStart();
+		}
+		yield event;
+	}
+}
+
+export async function* countWebSocketEvents(
+	events: AsyncIterable<StreamEventShape>,
+	onEvent: () => void,
+): AsyncIterable<StreamEventShape> {
+	for await (const event of events) {
+		onEvent();
+		yield event;
+	}
+}

package/src/providers/openai-codex/websocket-session.ts

@@ -0,0 +1,192 @@
+import { SESSION_WEBSOCKET_CACHE_TTL_MS } from "./constants.js";
+import { type AcquiredWebSocket, type SessionWebSocketCacheEntry, type WebSocketAcquireWaiter } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { connectWebSocket } from "./websocket-connection.js";
+import { closeWebSocketSilently, isWebSocketReusable } from "./websocket-socket.js";
+
+export const websocketSessionCache = new Map<string, SessionWebSocketCacheEntry>();
+
+const websocketConnectionPromises = new Map<string, Promise<SessionWebSocketCacheEntry>>();
+
+export const websocketHttpFallbackSessions = new Set<string>();
+
+export function closeProviderWebSocketSessions(sessionId?: string): void {
+	for (const cacheKey of websocketConnectionPromises.keys()) {
+		if (sessionId && !cacheKey.startsWith(`${sessionId}\n`)) continue;
+		websocketConnectionPromises.delete(cacheKey);
+	}
+	for (const [cacheKey, entry] of websocketSessionCache) {
+		if (sessionId && !cacheKey.startsWith(`${sessionId}\n`)) continue;
+		if (entry.idleTimer) clearTimeout(entry.idleTimer);
+		for (const waiter of entry.waiters.splice(0)) {
+			if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+			waiter.reject(new Error("WebSocket session closed"));
+		}
+		closeWebSocketSilently(entry.socket, 1000, "session_shutdown");
+		websocketSessionCache.delete(cacheKey);
+	}
+	if (sessionId) {
+		for (const fallbackKey of websocketHttpFallbackSessions) {
+			if (fallbackKey.startsWith(`${sessionId}\n`)) websocketHttpFallbackSessions.delete(fallbackKey);
+		}
+	} else {
+		websocketHttpFallbackSessions.clear();
+	}
+}
+
+function scheduleSessionWebSocketExpiry(cacheKey: string, entry: SessionWebSocketCacheEntry): void {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+	}
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy || entry.waiters.length > 0) return;
+		closeWebSocketSilently(entry.socket, 1000, "idle_timeout");
+		websocketSessionCache.delete(cacheKey);
+	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
+}
+
+function removeWebSocketWaiter(entry: SessionWebSocketCacheEntry, waiter: WebSocketAcquireWaiter): void {
+	const index = entry.waiters.indexOf(waiter);
+	if (index >= 0) entry.waiters.splice(index, 1);
+	if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+}
+
+function acquireCachedWebSocketEntry(
+	cacheKey: string,
+	entry: SessionWebSocketCacheEntry,
+	reused: boolean,
+): AcquiredWebSocket {
+	entry.busy = true;
+	let released = false;
+	const release = ({ keep } = {} as { keep?: boolean }) => {
+		if (released) return;
+		const reusable = keep !== false && isWebSocketReusable(entry.socket);
+		if (!reusable) {
+			released = true;
+			if (entry.idleTimer) clearTimeout(entry.idleTimer);
+			closeWebSocketSilently(entry.socket);
+			if (websocketSessionCache.get(cacheKey) === entry) {
+				websocketSessionCache.delete(cacheKey);
+			}
+			for (const waiter of entry.waiters.splice(0)) {
+				if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+				waiter.reject(new Error("WebSocket connection became unavailable"));
+			}
+			return;
+		}
+
+		while (entry.waiters.length > 0) {
+			const waiter = entry.waiters.shift()!;
+			if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+			if (waiter.signal?.aborted) {
+				waiter.reject(new Error("Request was aborted"));
+				continue;
+			}
+			released = true;
+			waiter.resolve(acquireCachedWebSocketEntry(cacheKey, entry, true));
+			return;
+		}
+
+		entry.busy = false;
+		released = true;
+		scheduleSessionWebSocketExpiry(cacheKey, entry);
+	};
+	return {
+		socket: entry.socket,
+		entry,
+		reused,
+		release,
+	};
+}
+
+async function waitForCachedWebSocket(
+	cacheKey: string,
+	entry: SessionWebSocketCacheEntry,
+	signal: AbortSignal | undefined,
+): Promise<AcquiredWebSocket> {
+	if (signal?.aborted) throw new Error("Request was aborted");
+	return new Promise<AcquiredWebSocket>((resolve, reject) => {
+		const waiter: WebSocketAcquireWaiter = {
+			resolve,
+			reject,
+			...(signal ? { signal } : {}),
+		};
+		if (signal) {
+			waiter.onAbort = () => {
+				removeWebSocketWaiter(entry, waiter);
+				reject(new Error("Request was aborted"));
+			};
+			signal.addEventListener("abort", waiter.onAbort, { once: true });
+		}
+		entry.waiters.push(waiter);
+	});
+}
+
+export async function acquireWebSocket(
+	url: string,
+	headers: Headers,
+	cacheKey: string | undefined,
+	sessionId: string | undefined,
+	signal: AbortSignal | undefined,
+	connectTimeoutMs: number,
+): Promise<AcquiredWebSocket> {
+	if (!cacheKey || !sessionId) {
+		const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+		return {
+			socket,
+			reused: false,
+			release: ({ keep } = {}) => {
+				if (keep === false) {
+					closeWebSocketSilently(socket);
+					return;
+				}
+				closeWebSocketSilently(socket);
+			},
+		};
+	}
+
+	const cached = websocketSessionCache.get(cacheKey);
+	if (cached) {
+		if (cached.idleTimer) {
+			clearTimeout(cached.idleTimer);
+			cached.idleTimer = undefined;
+		}
+
+		if (!cached.busy && isWebSocketReusable(cached.socket)) {
+			return acquireCachedWebSocketEntry(cacheKey, cached, true);
+		}
+
+		if (cached.busy) {
+			return waitForCachedWebSocket(cacheKey, cached, signal);
+		}
+
+		if (!isWebSocketReusable(cached.socket)) {
+			closeWebSocketSilently(cached.socket);
+			websocketSessionCache.delete(cacheKey);
+		}
+	}
+
+	let pendingConnection = websocketConnectionPromises.get(cacheKey);
+	if (!pendingConnection) {
+		let connectionPromise!: Promise<SessionWebSocketCacheEntry>;
+		connectionPromise = connectWebSocket(url, headers, signal, connectTimeoutMs)
+			.then((socket) => {
+				if (websocketConnectionPromises.get(cacheKey) !== connectionPromise) {
+					closeWebSocketSilently(socket, 1000, "session_shutdown");
+					throw new Error("WebSocket session closed");
+				}
+				const entry: SessionWebSocketCacheEntry = { socket, busy: false, waiters: [] };
+				websocketSessionCache.set(cacheKey, entry);
+				return entry;
+			})
+			.finally(() => {
+				if (websocketConnectionPromises.get(cacheKey) === connectionPromise) {
+					websocketConnectionPromises.delete(cacheKey);
+				}
+			});
+		websocketConnectionPromises.set(cacheKey, connectionPromise);
+		pendingConnection = connectionPromise;
+	}
+	const entry = await pendingConnection;
+	if (entry.busy) return waitForCachedWebSocket(cacheKey, entry, signal);
+	return acquireCachedWebSocketEntry(cacheKey, entry, false);
+}

package/src/providers/openai-codex/websocket-socket.ts

@@ -0,0 +1,18 @@
+import { type WebSocketLike } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+function getWebSocketReadyState(socket: WebSocketLike): number | undefined {
+	return typeof socket.readyState === "number" ? socket.readyState : undefined;
+}
+
+export function isWebSocketReusable(socket: WebSocketLike): boolean {
+	const readyState = getWebSocketReadyState(socket);
+	return readyState === undefined || readyState === 1;
+}
+
+export function closeWebSocketSilently(socket: WebSocketLike, code = 1000, reason = "done"): void {
+	try {
+		socket.close(code, reason);
+	} catch {
+		// ignore close errors
+	}
+}

package/src/providers/openai-codex/websocket-stream.ts

@@ -0,0 +1,151 @@
+import { type Api, type AssistantMessage, type AssistantMessageEventStream, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { type CitationSource, type WebSearchCitationSource } from "@oai404iao/pi-codex-runtime/internal/providers/responses/types";
+import { webSocketCacheKey } from "./cache-key.js";
+import { processCapturedResponsesStream } from "./captured-stream.js";
+import type { ProviderStreamEffects } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/stream-effects";
+import { WEBSOCKET_CONNECT_TIMEOUT_MS, WEBSOCKET_SEND_TIMEOUT_MS } from "./constants.js";
+import { buildCachedWebSocketRequestBody, prepareWebSocketRequestBodyForWire } from "./continuation.js";
+import { withWebSocketRequestMetadata } from "./request-metadata.js";
+import { isPreviousResponseNotFoundError, isRetryableEarlyWebSocketError } from "./retry.js";
+import { type ResponsesBody, type WebSocketRequestMetadata } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { countWebSocketEvents, parseWebSocket, sendWebSocketRequest, startWebSocketOutputOnFirstEvent } from "./websocket-events.js";
+import { acquireWebSocket } from "./websocket-session.js";
+
+export async function processWebSocketStream<TApi extends Api>(
+	url: string,
+	body: ResponsesBody,
+	headers: Headers,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	model: Model<TApi>,
+	onStart: () => void,
+	options: SimpleStreamOptions | undefined,
+	deps: ProviderStreamEffects,
+	cwd: string,
+	requestPrompt: string | undefined,
+	webSearchCitationSources: ReadonlyArray<WebSearchCitationSource>,
+	historicalCitationSources: ReadonlyArray<CitationSource>,
+	requestMetadata: WebSocketRequestMetadata,
+	profileHash?: string,
+	startupPrewarm?: Promise<void>,
+): Promise<void> {
+	let streamStarted = false;
+	let disableCachedContext = false;
+	let staleSocketRetried = false;
+	let missingPreviousResponseRetried = false;
+
+	while (true) {
+		if (startupPrewarm) {
+			await startupPrewarm;
+			startupPrewarm = undefined;
+		}
+		const cacheKey = webSocketCacheKey(
+			options?.sessionId,
+			model as Model<Api>,
+			url,
+			headers,
+			profileHash,
+		);
+		const { socket, entry, release, reused } = await acquireWebSocket(
+			url,
+			headers,
+			cacheKey,
+			options?.sessionId,
+			options?.signal,
+			WEBSOCKET_CONNECT_TIMEOUT_MS,
+		);
+		let keepConnection = true;
+		let released = false;
+		let eventCount = 0;
+		// Continuation is safe only when buildCachedWebSocketRequestBody proves
+		// that this request exactly extends the cached logical request.
+		const useCachedContext = true;
+		// ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
+		// WebSocket continuation still works via connection-scoped previous_response_id state.
+		const fullBody = withWebSocketRequestMetadata(body, requestMetadata);
+		const requestBody = useCachedContext && !disableCachedContext && entry
+			? buildCachedWebSocketRequestBody(entry, fullBody)
+			: fullBody;
+		const wireRequestBody = prepareWebSocketRequestBodyForWire(requestBody);
+
+		const releaseOnce = (releaseOptions?: { keep?: boolean }) => {
+			if (released) return;
+			released = true;
+			release(releaseOptions);
+		};
+
+		try {
+			await sendWebSocketRequest(
+				socket,
+				JSON.stringify({ type: "response.create", ...wireRequestBody }),
+				options?.signal,
+				WEBSOCKET_SEND_TIMEOUT_MS,
+			);
+			const startOutput = () => {
+				if (streamStarted) return;
+				onStart();
+				stream.push({ type: "start", partial: output });
+				streamStarted = true;
+			};
+			const continuationResult = await processCapturedResponsesStream(
+				startWebSocketOutputOnFirstEvent(
+					countWebSocketEvents(parseWebSocket(socket, options?.signal), () => {
+						eventCount++;
+					}),
+					startOutput,
+				),
+				output,
+				stream,
+				model,
+				options,
+				options?.sessionId,
+				deps,
+				cwd,
+				requestPrompt,
+				webSearchCitationSources,
+				historicalCitationSources,
+			);
+			if (options?.signal?.aborted) {
+				keepConnection = false;
+			} else if (entry && continuationResult.responseId) {
+				entry.continuation = {
+					lastRequestBody: fullBody,
+					lastResponseId: continuationResult.responseId,
+					lastResponseItems: continuationResult.responseItems,
+				};
+			} else if (entry) {
+				entry.continuation = undefined;
+			}
+			releaseOnce({ keep: keepConnection });
+			return;
+		} catch (error) {
+			if (entry) {
+				entry.continuation = undefined;
+			}
+			keepConnection = false;
+			releaseOnce({ keep: false });
+			// Pi's stock provider reuses session WebSockets. In practice the Codex
+			// backend sometimes cleanly closes an idle cached socket between turns;
+			// if that stale socket fails before any response event, retry once on a
+			// fresh WebSocket without changing request shape or falling back transports.
+			if (!staleSocketRetried && reused && eventCount === 0 && !options?.signal?.aborted && isRetryableEarlyWebSocketError(error)) {
+				staleSocketRetried = true;
+				continue;
+			}
+			if (
+				!missingPreviousResponseRetried
+				&& requestBody.previous_response_id
+				&& !streamStarted
+				&& !options?.signal?.aborted
+				&& isPreviousResponseNotFoundError(error)
+			) {
+				missingPreviousResponseRetried = true;
+				disableCachedContext = true;
+				continue;
+			}
+			throw error;
+		} finally {
+			releaseOnce({ keep: keepConnection });
+		}
+	}
+}

package/src/tools/apply-patch.ts

@@ -0,0 +1,84 @@
+import { applyPatch, resolvePatchPath, type ApplyPatchResult } from "../patch/apply.js";
+import { parseApplyPatch } from "../patch/parser.js";
+import { createApplyPatchRenderers } from "../patch/render.js";
+
+export interface ApplyPatchInput {
+	input: string;
+}
+
+export const applyPatchToolSchema = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		input: { type: "string", description: "Raw Codex patch text. File paths may be relative or absolute. Add File content lines start with +; Update File chunks use context, +, and - lines." },
+	},
+	required: ["input"],
+};
+
+export function applyPatchTargetPaths(input: string, cwd: string): string[] {
+	const parsed = parseApplyPatch(input);
+	const paths = new Set<string>();
+	for (const action of parsed.actions) {
+		paths.add(resolvePatchPath(action.path, { cwd }));
+		if (action.kind === "update" && action.moveTo) paths.add(resolvePatchPath(action.moveTo, { cwd }));
+	}
+	return [...paths].sort();
+}
+
+async function withMutationQueue(path: string, fn: () => Promise<void>): Promise<void> {
+	try {
+		const mod = await import("@earendil-works/pi-coding-agent");
+		const queue = (mod as { withFileMutationQueue?: (path: string, fn: () => Promise<void>) => Promise<void> }).withFileMutationQueue;
+		if (typeof queue === "function") return queue(path, fn);
+	} catch {
+		// Unit tests can run outside Pi without peer dependencies installed.
+	}
+	return fn();
+}
+
+export async function executeApplyPatchTool(params: ApplyPatchInput, cwd: string): Promise<{ content: Array<{ type: "text"; text: string }>; details: ApplyPatchResult }> {
+	if (!params || typeof params.input !== "string") throw new Error("apply_patch requires an input string.");
+	let targets: string[];
+	try {
+		targets = applyPatchTargetPaths(params.input, cwd);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`apply_patch verification failed: ${message}`);
+	}
+	let result: ApplyPatchResult | undefined;
+	const runAt = async (index: number): Promise<void> => {
+		if (index >= targets.length) {
+			result = await applyPatch(params.input, { cwd });
+			return;
+		}
+		await withMutationQueue(targets[index]!, () => runAt(index + 1));
+	};
+	await runAt(0);
+	if (!result) throw new Error("apply_patch did not produce a result.");
+	return {
+		content: [{ type: "text", text: result.summary }],
+		details: result,
+	};
+}
+
+export function createApplyPatchToolDefinition(options: { cwd?: string; deferRendering?: boolean } = {}) {
+	const definition: Record<string, unknown> = {
+		renderShell: "self",
+		name: "apply_patch",
+		label: "Apply Patch",
+		description: "Use apply_patch to edit files with the Codex patch format. A patch starts with *** Begin Patch, contains one or more Add, Update, or Delete file sections, and ends with *** End Patch.",
+		promptSnippet: "Apply Codex-style multi-file patches with contextual update hunks and explicit Add, Update, or Delete headers.",
+		promptGuidelines: [
+			"Use apply_patch for concise multi-file edits when a Codex-style patch is clearer than separate edit/write calls.",
+			"In apply_patch, paths may be relative to the current working directory or absolute; prefix every Add File content line with +; and use @@ class/function context plus surrounding lines when repeated code needs disambiguation.",
+			"Use *** End of File in apply_patch when a hunk must match the end of a file.",
+		],
+		parameters: applyPatchToolSchema,
+		async execute(_toolCallId: string, params: ApplyPatchInput, _signal: AbortSignal | undefined, _onUpdate: unknown, ctx: { cwd: string }) {
+			const cwd = ctx?.cwd ?? options.cwd ?? process.cwd();
+			return executeApplyPatchTool(params, cwd);
+		},
+	};
+	if (!options.deferRendering) Object.assign(definition, createApplyPatchRenderers());
+	return definition;
+}