@ottocode/sdk 0.1.275 → 0.1.276

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.275",
+	"version": "0.1.276",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/core/src/tools/builtin/fs/copy-into.ts

@@ -2,7 +2,12 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
 import DESCRIPTION from './copy-into.txt' with { type: 'text' };
-import { buildWriteArtifact, isAbsoluteLike, resolveSafePath } from './util.ts';
+import {
+	buildMutationMetadata,
+	buildWriteArtifact,
+	isAbsoluteLike,
+	resolveSafePath,
+} from './util.ts';
 import {
 	convertToLineEnding,
 	detectLineEnding,
@@ -199,6 +204,7 @@ export function buildCopyIntoTool(projectRoot: string): {
 		inputSchema: copyIntoSchema,
 		async execute(input: CopyIntoInput): Promise<
 			ToolResponse<{
+				operation: 'copy_into';
 				sourcePath: string;
 				targetPath: string;
 				sourceRange: string;
@@ -206,6 +212,10 @@ export function buildCopyIntoTool(projectRoot: string): {
 				mode: string;
 				linesCopied: number;
 				bytes: number;
+				bytesWritten: number;
+				changed: boolean;
+				sha256: string;
+				summary: { files: number; additions: number; deletions: number };
 				artifact: unknown;
 			}>
 		> {
@@ -271,6 +281,7 @@ export function buildCopyIntoTool(projectRoot: string): {
 
 				await writeFile(targetAbs, nextContent, 'utf-8');
 				await rememberFileWrite(projectRoot, targetAbs);
+				const metadata = buildMutationMetadata(targetContent, nextContent);
 				const artifact = await buildWriteArtifact(
 					input.targetPath,
 					true,
@@ -279,13 +290,18 @@ export function buildCopyIntoTool(projectRoot: string): {
 				);
 				return {
 					ok: true,
+					operation: 'copy_into',
 					sourcePath: input.sourcePath,
 					targetPath: input.targetPath,
 					sourceRange: `${input.startLine}-${sourceRange.endLine}`,
 					targetRange: applied.targetRange,
 					mode: input.mode ?? 'insert_before',
 					linesCopied: sourceRange.copied.length,
-					bytes: nextContent.length,
+					bytes: metadata.bytesWritten,
+					bytesWritten: metadata.bytesWritten,
+					changed: metadata.changed,
+					sha256: metadata.sha256,
+					summary: metadata.summary,
 					artifact,
 				};
 			} catch (error: unknown) {

package/src/core/src/tools/builtin/fs/edit.ts

@@ -2,7 +2,12 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
 import DESCRIPTION from './edit.txt' with { type: 'text' };
-import { buildWriteArtifact, isAbsoluteLike, resolveSafePath } from './util.ts';
+import {
+	buildMutationMetadata,
+	buildWriteArtifact,
+	isAbsoluteLike,
+	resolveSafePath,
+} from './util.ts';
 import { applyStringEdit } from './edit-shared.ts';
 import { assertFreshRead, rememberFileWrite } from './read-tracker.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
@@ -42,8 +47,13 @@ export function buildEditTool(projectRoot: string): {
 		}): Promise<
 			ToolResponse<{
 				path: string;
+				operation: 'edit';
 				occurrences: number;
 				bytes: number;
+				bytesWritten: number;
+				changed: boolean;
+				sha256: string;
+				summary: { files: number; additions: number; deletions: number };
 				artifact: unknown;
 			}>
 		> {
@@ -89,6 +99,7 @@ export function buildEditTool(projectRoot: string): {
 
 				await writeFile(abs, updated.content, 'utf-8');
 				await rememberFileWrite(projectRoot, abs);
+				const metadata = buildMutationMetadata(original, updated.content);
 				const artifact = await buildWriteArtifact(
 					path,
 					true,
@@ -98,8 +109,13 @@ export function buildEditTool(projectRoot: string): {
 				return {
 					ok: true,
 					path,
+					operation: 'edit',
 					occurrences: updated.occurrences,
-					bytes: updated.content.length,
+					bytes: metadata.bytesWritten,
+					bytesWritten: metadata.bytesWritten,
+					changed: metadata.changed,
+					sha256: metadata.sha256,
+					summary: metadata.summary,
 					artifact,
 				};
 			} catch (error: unknown) {

package/src/core/src/tools/builtin/fs/multiedit.ts

@@ -2,7 +2,12 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
 import DESCRIPTION from './multiedit.txt' with { type: 'text' };
-import { buildWriteArtifact, isAbsoluteLike, resolveSafePath } from './util.ts';
+import {
+	buildMutationMetadata,
+	buildWriteArtifact,
+	isAbsoluteLike,
+	resolveSafePath,
+} from './util.ts';
 import { applyStringEdit } from './edit-shared.ts';
 import { assertFreshRead, rememberFileWrite } from './read-tracker.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
@@ -39,8 +44,13 @@ export function buildMultiEditTool(projectRoot: string): {
 		async execute({ path, edits }: z.infer<typeof multiEditSchema>): Promise<
 			ToolResponse<{
 				path: string;
+				operation: 'multiedit';
 				editsApplied: number;
 				bytes: number;
+				bytesWritten: number;
+				changed: boolean;
+				sha256: string;
+				summary: { files: number; additions: number; deletions: number };
 				artifact: unknown;
 			}>
 		> {
@@ -97,6 +107,7 @@ export function buildMultiEditTool(projectRoot: string): {
 
 				await writeFile(abs, nextContent, 'utf-8');
 				await rememberFileWrite(projectRoot, abs);
+				const metadata = buildMutationMetadata(original, nextContent);
 				const artifact = await buildWriteArtifact(
 					path,
 					true,
@@ -106,8 +117,13 @@ export function buildMultiEditTool(projectRoot: string): {
 				return {
 					ok: true,
 					path,
+					operation: 'multiedit',
 					editsApplied: edits.length,
-					bytes: nextContent.length,
+					bytes: metadata.bytesWritten,
+					bytesWritten: metadata.bytesWritten,
+					changed: metadata.changed,
+					sha256: metadata.sha256,
+					summary: metadata.summary,
 					artifact,
 				};
 			} catch (error: unknown) {

package/src/core/src/tools/builtin/fs/util.ts

@@ -1,5 +1,6 @@
-import { createTwoFilesPatch } from 'diff';
+import { createHash } from 'node:crypto';
 import { resolve as resolvePath } from 'node:path';
+import { createTwoFilesPatch, diffLines } from 'diff';
 
 function normalizeForComparison(value: string) {
 	const withForwardSlashes = value.replace(/\\/g, '/');
@@ -36,6 +37,17 @@ export function isAbsoluteLike(p: string): boolean {
 	return p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
 }
 
+export function buildMutationMetadata(oldText: string, newText: string) {
+	const bytesWritten = Buffer.byteLength(newText, 'utf-8');
+	const { additions, deletions } = summarizeTextChanges(oldText, newText);
+	return {
+		bytesWritten,
+		changed: oldText !== newText,
+		sha256: createHash('sha256').update(newText).digest('hex'),
+		summary: { files: 1, additions, deletions },
+	} as const;
+}
+
 export async function buildWriteArtifact(
 	relPath: string,
 	existed: boolean,
@@ -67,7 +79,7 @@ export async function buildWriteArtifact(
 		lines.push('*** End Patch');
 		patch = lines.join('\n');
 	}
-	const { additions, deletions } = summarizePatchCounts(patch);
+	const { additions, deletions } = summarizeTextChanges(oldText, newText);
 	return {
 		kind: 'file_diff',
 		patch,
@@ -75,21 +87,26 @@ export async function buildWriteArtifact(
 	} as const;
 }
 
-export function summarizePatchCounts(patch: string): {
+function countDiffLines(value: string): number {
+	if (value.length === 0) return 0;
+	const lines = value.split('\n');
+	if (value.endsWith('\n')) lines.pop();
+	return lines.length;
+}
+
+export function summarizeTextChanges(
+	oldText: string,
+	newText: string,
+): {
 	additions: number;
 	deletions: number;
 } {
-	let adds = 0;
-	let dels = 0;
-	for (const line of String(patch || '').split('\n')) {
-		if (
-			line.startsWith('+++') ||
-			line.startsWith('---') ||
-			line.startsWith('diff ')
-		)
-			continue;
-		if (line.startsWith('+')) adds += 1;
-		else if (line.startsWith('-')) dels += 1;
+	let additions = 0;
+	let deletions = 0;
+	for (const part of diffLines(String(oldText ?? ''), String(newText ?? ''))) {
+		const lineCount = countDiffLines(part.value);
+		if (part.added) additions += lineCount;
+		else if (part.removed) deletions += lineCount;
 	}
-	return { additions: adds, deletions: dels };
+	return { additions, deletions };
 }

package/src/core/src/tools/builtin/fs/write.ts

@@ -3,6 +3,7 @@ import { z } from 'zod/v3';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import {
+	buildMutationMetadata,
 	buildWriteArtifact,
 	resolveSafePath,
 	expandTilde,
@@ -38,7 +39,13 @@ export function buildWriteTool(projectRoot: string): {
 		}): Promise<
 			ToolResponse<{
 				path: string;
+				operation: 'write';
 				bytes: number;
+				bytesWritten: number;
+				created: boolean;
+				changed: boolean;
+				sha256: string;
+				summary: { files: number; additions: number; deletions: number };
 				artifact: unknown;
 			}>
 		> {
@@ -81,6 +88,7 @@ export function buildWriteTool(projectRoot: string): {
 				} catch {}
 				await writeFile(abs, content);
 				await rememberFileWrite(projectRoot, abs);
+				const metadata = buildMutationMetadata(oldText, content);
 				const artifact = await buildWriteArtifact(
 					req,
 					existed,
@@ -90,7 +98,13 @@ export function buildWriteTool(projectRoot: string): {
 				return {
 					ok: true,
 					path: req,
-					bytes: content.length,
+					operation: 'write',
+					bytes: metadata.bytesWritten,
+					bytesWritten: metadata.bytesWritten,
+					created: !existed,
+					changed: metadata.changed,
+					sha256: metadata.sha256,
+					summary: metadata.summary,
 					artifact,
 				};
 			} catch (error: unknown) {

package/src/core/src/tools/builtin/patch/apply.ts

@@ -8,6 +8,9 @@ import type {
 	PatchAddOperation,
 	PatchApplicationResult,
 	PatchDeleteOperation,
+	PatchLineDeleteOperation,
+	PatchLineInsertOperation,
+	PatchLineReplaceOperation,
 	PatchOperation,
 	PatchUpdateOperation,
 	RejectedPatch,
@@ -161,6 +164,174 @@ async function applyUpdateOperation(
 	return makeAppliedRecord('update', operation.filePath, appliedHunks);
 }
 
+function resolveLineRange(
+	filePath: string,
+	lineCount: number,
+	startLine: number,
+	endLine: number | 'end',
+) {
+	const resolvedEndLine = endLine === 'end' ? lineCount : endLine;
+	if (startLine > lineCount) {
+		throw new Error(
+			`Line range ${startLine}-${resolvedEndLine} is outside ${filePath} (${lineCount} lines).`,
+		);
+	}
+	if (resolvedEndLine > lineCount) {
+		throw new Error(
+			`Line range ${startLine}-${resolvedEndLine} is outside ${filePath} (${lineCount} lines).`,
+		);
+	}
+	if (resolvedEndLine < startLine) {
+		throw new Error('Line range end must be greater than or equal to start.');
+	}
+	return {
+		startIndex: startLine - 1,
+		endIndexExclusive: resolvedEndLine,
+		resolvedEndLine,
+	};
+}
+
+async function readUpdateTarget(projectRoot: string, filePath: string) {
+	const target = resolveProjectPath(projectRoot, filePath);
+	let original: string;
+	try {
+		original = await readFile(target, 'utf-8');
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+			throw new Error(`File not found: ${filePath}`);
+		}
+		throw error;
+	}
+	return { target, ...splitLines(original) };
+}
+
+async function applyLineDeleteOperation(
+	projectRoot: string,
+	operation: PatchLineDeleteOperation,
+): Promise<AppliedPatchOperation> {
+	const { target, lines, newline } = await readUpdateTarget(
+		projectRoot,
+		operation.filePath,
+	);
+	const { startIndex, endIndexExclusive, resolvedEndLine } = resolveLineRange(
+		operation.filePath,
+		lines.length,
+		operation.startLine,
+		operation.endLine,
+	);
+	const removed = lines.slice(startIndex, endIndexExclusive);
+	const workingLines = [...lines];
+	workingLines.splice(startIndex, removed.length);
+	ensureTrailingNewline(workingLines);
+	await writeFile(target, joinLines(workingLines, newline), 'utf-8');
+
+	const appliedHunk: AppliedPatchHunk = {
+		header: {
+			oldStart: operation.startLine,
+			oldLines: removed.length,
+			newStart: operation.startLine,
+			newLines: 0,
+			context: `lines ${operation.startLine}-${resolvedEndLine}`,
+		},
+		lines: removed.map((line) => ({ kind: 'remove', content: line })),
+		oldStart: operation.startLine,
+		oldLines: removed.length,
+		newStart: operation.startLine,
+		newLines: 0,
+		additions: 0,
+		deletions: removed.length,
+	};
+
+	return makeAppliedRecord('update', operation.filePath, [appliedHunk]);
+}
+
+async function applyLineReplaceOperation(
+	projectRoot: string,
+	operation: PatchLineReplaceOperation,
+): Promise<AppliedPatchOperation> {
+	const { target, lines, newline } = await readUpdateTarget(
+		projectRoot,
+		operation.filePath,
+	);
+	const { startIndex, endIndexExclusive, resolvedEndLine } = resolveLineRange(
+		operation.filePath,
+		lines.length,
+		operation.startLine,
+		operation.endLine,
+	);
+	const removed = lines.slice(startIndex, endIndexExclusive);
+	const added = [...operation.lines];
+	const workingLines = [...lines];
+	workingLines.splice(startIndex, removed.length, ...added);
+	ensureTrailingNewline(workingLines);
+	await writeFile(target, joinLines(workingLines, newline), 'utf-8');
+
+	const appliedHunk: AppliedPatchHunk = {
+		header: {
+			oldStart: operation.startLine,
+			oldLines: removed.length,
+			newStart: operation.startLine,
+			newLines: added.length,
+			context: `lines ${operation.startLine}-${resolvedEndLine}`,
+		},
+		lines: [
+			...removed.map((line) => ({ kind: 'remove' as const, content: line })),
+			...added.map((line) => ({ kind: 'add' as const, content: line })),
+		],
+		oldStart: operation.startLine,
+		oldLines: removed.length,
+		newStart: operation.startLine,
+		newLines: added.length,
+		additions: added.length,
+		deletions: removed.length,
+	};
+
+	return makeAppliedRecord('update', operation.filePath, [appliedHunk]);
+}
+
+async function applyLineInsertOperation(
+	projectRoot: string,
+	operation: PatchLineInsertOperation,
+): Promise<AppliedPatchOperation> {
+	const { target, lines, newline } = await readUpdateTarget(
+		projectRoot,
+		operation.filePath,
+	);
+	const insertIndex =
+		operation.position === 'before' ? operation.line - 1 : operation.line;
+	if (insertIndex < 0 || insertIndex > lines.length) {
+		throw new Error(
+			`Insert ${operation.position} line ${operation.line} is outside ${operation.filePath} (${lines.length} lines).`,
+		);
+	}
+	const added = [...operation.lines];
+	const workingLines = [...lines];
+	workingLines.splice(insertIndex, 0, ...added);
+	ensureTrailingNewline(workingLines);
+	await writeFile(target, joinLines(workingLines, newline), 'utf-8');
+
+	const oldStart = insertIndex;
+	const newStart = insertIndex + 1;
+	const appliedHunk: AppliedPatchHunk = {
+		header: {
+			oldStart,
+			oldLines: 0,
+			newStart,
+			newLines: added.length,
+			context: `${operation.position} line ${operation.line}`,
+		},
+		lines: added.map((line) => ({ kind: 'add', content: line })),
+		oldStart,
+		oldLines: 0,
+		newStart,
+		newLines: added.length,
+		additions: added.length,
+		deletions: 0,
+	};
+
+	return makeAppliedRecord('update', operation.filePath, [appliedHunk]);
+}
+
 export async function applyPatchOperations(
 	projectRoot: string,
 	operations: PatchOperation[],
@@ -175,6 +346,12 @@ export async function applyPatchOperations(
 				applied.push(await applyAddOperation(projectRoot, operation));
 			} else if (operation.kind === 'delete') {
 				applied.push(await applyDeleteOperation(projectRoot, operation));
+			} else if (operation.kind === 'line-delete') {
+				applied.push(await applyLineDeleteOperation(projectRoot, operation));
+			} else if (operation.kind === 'line-replace') {
+				applied.push(await applyLineReplaceOperation(projectRoot, operation));
+			} else if (operation.kind === 'line-insert') {
+				applied.push(await applyLineInsertOperation(projectRoot, operation));
 			} else {
 				applied.push(
 					await applyUpdateOperation(

package/src/core/src/tools/builtin/patch/constants.ts

@@ -4,5 +4,11 @@ export const PATCH_ADD_PREFIX = '*** Add File:';
 export const PATCH_UPDATE_PREFIX = '*** Update File:';
 export const PATCH_DELETE_PREFIX = '*** Delete File:';
 export const PATCH_REPLACE_PREFIX = '*** Replace in:';
+export const PATCH_DELETE_LINES_PREFIX = '*** Delete Lines in:';
+export const PATCH_REPLACE_LINES_PREFIX = '*** Replace Lines in:';
+export const PATCH_INSERT_BEFORE_PREFIX = '*** Insert Before in:';
+export const PATCH_INSERT_AFTER_PREFIX = '*** Insert After in:';
 export const PATCH_FIND_MARKER = '*** Find:';
 export const PATCH_WITH_MARKER = '*** With:';
+export const PATCH_LINES_MARKER = '*** Lines:';
+export const PATCH_LINE_MARKER = '*** Line:';

package/src/core/src/tools/builtin/patch/parse-enveloped.ts

@@ -2,8 +2,14 @@ import {
 	PATCH_ADD_PREFIX,
 	PATCH_BEGIN_MARKER,
 	PATCH_DELETE_PREFIX,
+	PATCH_DELETE_LINES_PREFIX,
 	PATCH_END_MARKER,
 	PATCH_FIND_MARKER,
+	PATCH_INSERT_AFTER_PREFIX,
+	PATCH_INSERT_BEFORE_PREFIX,
+	PATCH_LINE_MARKER,
+	PATCH_LINES_MARKER,
+	PATCH_REPLACE_LINES_PREFIX,
 	PATCH_REPLACE_PREFIX,
 	PATCH_UPDATE_PREFIX,
 	PATCH_WITH_MARKER,
@@ -20,6 +26,9 @@ import type {
 	PatchDeleteOperation,
 	PatchHunk,
 	PatchHunkLine,
+	PatchLineDeleteOperation,
+	PatchLineInsertOperation,
+	PatchLineReplaceOperation,
 	PatchOperation,
 	PatchUpdateOperation,
 } from './types.ts';
@@ -35,6 +44,62 @@ function parseDirectivePath(line: string, prefix: string): string {
 	return filePath;
 }
 
+function parsePositiveLineNumber(value: string, label: string): number {
+	const trimmed = value.trim();
+	if (!/^\d+$/.test(trimmed)) {
+		throw new Error(`${label} must be a positive integer.`);
+	}
+	const line = Number.parseInt(trimmed, 10);
+	if (line < 1) {
+		throw new Error(`${label} must be a positive integer.`);
+	}
+	return line;
+}
+
+function parseLineRange(value: string): {
+	startLine: number;
+	endLine: number | 'end';
+} {
+	const trimmed = value.trim();
+	const match = /^(\d+)(?:\s*-\s*(\d+|end|eof|\$))?$/i.exec(trimmed);
+	if (!match) {
+		throw new Error(
+			'Line ranges must use "start" or "start-end" with 1-indexed positive integers.',
+		);
+	}
+
+	const startLine = parsePositiveLineNumber(match[1], 'Line range start');
+	const endLineToken = match[2];
+	if (!endLineToken) return { startLine, endLine: startLine };
+	const endLine = /^(end|eof|\$)$/i.test(endLineToken)
+		? 'end'
+		: parsePositiveLineNumber(endLineToken, 'Line range end');
+	if (typeof endLine === 'number' && endLine < startLine) {
+		throw new Error('Line range end must be greater than or equal to start.');
+	}
+	return { startLine, endLine };
+}
+
+type LineDeleteBuilder = Partial<PatchLineDeleteOperation> & {
+	kind: 'line-delete';
+	filePath: string;
+};
+
+type LineReplaceBuilder = Partial<PatchLineReplaceOperation> & {
+	kind: 'line-replace';
+	filePath: string;
+	lines: string[];
+	phase: 'range' | 'with';
+};
+
+type LineInsertBuilder = Partial<PatchLineInsertOperation> & {
+	kind: 'line-insert';
+	filePath: string;
+	position: 'before' | 'after';
+	lines: string[];
+	phase: 'line' | 'with';
+};
+
 export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 	const normalized = patch.replace(/\r\n/g, '\n');
 	const lines = normalized.split('\n');
@@ -47,6 +112,9 @@ export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 				kind: 'update';
 				currentHunk: PatchHunk | null;
 		  })
+		| LineDeleteBuilder
+		| LineReplaceBuilder
+		| LineInsertBuilder
 		| ReplaceBuilder;
 
 	let builder: Builder | null = null;
@@ -80,6 +148,54 @@ export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 				filePath: builder.filePath,
 				lines: [...builder.lines],
 			});
+		} else if (builder.kind === 'line-delete') {
+			if (!builder.startLine || !builder.endLine) {
+				throw new Error(
+					`Delete Lines in ${builder.filePath}: missing required *** Lines: directive.`,
+				);
+			}
+			operations.push({
+				kind: 'line-delete',
+				filePath: builder.filePath,
+				startLine: builder.startLine,
+				endLine: builder.endLine,
+			});
+		} else if (builder.kind === 'line-replace') {
+			if (!builder.startLine || !builder.endLine) {
+				throw new Error(
+					`Replace Lines in ${builder.filePath}: missing required *** Lines: directive.`,
+				);
+			}
+			if (builder.phase !== 'with') {
+				throw new Error(
+					`Replace Lines in ${builder.filePath}: missing required *** With: directive.`,
+				);
+			}
+			operations.push({
+				kind: 'line-replace',
+				filePath: builder.filePath,
+				startLine: builder.startLine,
+				endLine: builder.endLine,
+				lines: [...builder.lines],
+			});
+		} else if (builder.kind === 'line-insert') {
+			if (!builder.line) {
+				throw new Error(
+					`Insert ${builder.position} in ${builder.filePath}: missing required *** Line: directive.`,
+				);
+			}
+			if (builder.phase !== 'with') {
+				throw new Error(
+					`Insert ${builder.position} in ${builder.filePath}: missing required *** With: directive.`,
+				);
+			}
+			operations.push({
+				kind: 'line-insert',
+				filePath: builder.filePath,
+				position: builder.position,
+				line: builder.line,
+				lines: [...builder.lines],
+			});
 		} else {
 			operations.push({ kind: 'delete', filePath: builder.filePath });
 		}
@@ -154,6 +270,50 @@ export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 			continue;
 		}
 
+		if (line.startsWith(PATCH_DELETE_LINES_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'line-delete',
+				filePath: parseDirectivePath(line, PATCH_DELETE_LINES_PREFIX),
+			};
+			continue;
+		}
+
+		if (line.startsWith(PATCH_REPLACE_LINES_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'line-replace',
+				filePath: parseDirectivePath(line, PATCH_REPLACE_LINES_PREFIX),
+				lines: [],
+				phase: 'range',
+			};
+			continue;
+		}
+
+		if (line.startsWith(PATCH_INSERT_BEFORE_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'line-insert',
+				filePath: parseDirectivePath(line, PATCH_INSERT_BEFORE_PREFIX),
+				position: 'before',
+				lines: [],
+				phase: 'line',
+			};
+			continue;
+		}
+
+		if (line.startsWith(PATCH_INSERT_AFTER_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'line-insert',
+				filePath: parseDirectivePath(line, PATCH_INSERT_AFTER_PREFIX),
+				position: 'after',
+				lines: [],
+				phase: 'line',
+			};
+			continue;
+		}
+
 		if (builder && builder.kind === 'replace') {
 			if (line.startsWith(PATCH_FIND_MARKER)) {
 				flushReplacePair(builder);
@@ -188,6 +348,74 @@ export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 			throw new Error(`Unexpected content in patch: "${line}"`);
 		}
 
+		if (builder.kind === 'line-delete') {
+			if (line.startsWith(PATCH_LINES_MARKER)) {
+				const range = parseLineRange(line.slice(PATCH_LINES_MARKER.length));
+				builder.startLine = range.startLine;
+				builder.endLine = range.endLine;
+				continue;
+			}
+			if (line.trim() !== '') {
+				throw new Error(
+					`Delete Lines in ${builder.filePath}: expected *** Lines: directive, got "${line}"`,
+				);
+			}
+			continue;
+		}
+
+		if (builder.kind === 'line-replace') {
+			if (builder.phase === 'with') {
+				builder.lines.push(line);
+				continue;
+			}
+			if (line.startsWith(PATCH_LINES_MARKER)) {
+				const range = parseLineRange(line.slice(PATCH_LINES_MARKER.length));
+				builder.startLine = range.startLine;
+				builder.endLine = range.endLine;
+				continue;
+			}
+			if (line.startsWith(PATCH_WITH_MARKER)) {
+				if (!builder.startLine || !builder.endLine) {
+					throw new Error(
+						`Replace Lines in ${builder.filePath}: *** With: must follow *** Lines:.`,
+					);
+				}
+				builder.phase = 'with';
+				continue;
+			}
+			if (line.trim() === '') continue;
+			throw new Error(
+				`Replace Lines in ${builder.filePath}: expected *** Lines: or *** With: directive, got "${line}"`,
+			);
+		}
+
+		if (builder.kind === 'line-insert') {
+			if (builder.phase === 'with') {
+				builder.lines.push(line);
+				continue;
+			}
+			if (line.startsWith(PATCH_LINE_MARKER)) {
+				builder.line = parsePositiveLineNumber(
+					line.slice(PATCH_LINE_MARKER.length),
+					'Insert line',
+				);
+				continue;
+			}
+			if (line.startsWith(PATCH_WITH_MARKER)) {
+				if (!builder.line) {
+					throw new Error(
+						`Insert ${builder.position} in ${builder.filePath}: *** With: must follow *** Line:.`,
+					);
+				}
+				builder.phase = 'with';
+				continue;
+			}
+			if (line.trim() === '') continue;
+			throw new Error(
+				`Insert ${builder.position} in ${builder.filePath}: expected *** Line: or *** With: directive, got "${line}"`,
+			);
+		}
+
 		if (builder.kind === 'add') {
 			builder.lines.push(line.startsWith('+') ? line.slice(1) : line);
 			continue;

package/src/core/src/tools/builtin/patch/types.ts

@@ -1,4 +1,10 @@
-export type PatchOperationKind = 'add' | 'update' | 'delete';
+export type AppliedPatchOperationKind = 'add' | 'update' | 'delete';
+
+export type PatchOperationKind =
+	| AppliedPatchOperationKind
+	| 'line-delete'
+	| 'line-replace'
+	| 'line-insert';
 
 export interface PatchHunkLine {
 	kind: 'context' | 'add' | 'remove';
@@ -35,10 +41,36 @@ export interface PatchUpdateOperation {
 	hunks: PatchHunk[];
 }
 
+export interface PatchLineDeleteOperation {
+	kind: 'line-delete';
+	filePath: string;
+	startLine: number;
+	endLine: number | 'end';
+}
+
+export interface PatchLineReplaceOperation {
+	kind: 'line-replace';
+	filePath: string;
+	startLine: number;
+	endLine: number | 'end';
+	lines: string[];
+}
+
+export interface PatchLineInsertOperation {
+	kind: 'line-insert';
+	filePath: string;
+	position: 'before' | 'after';
+	line: number;
+	lines: string[];
+}
+
 export type PatchOperation =
 	| PatchAddOperation
 	| PatchDeleteOperation
-	| PatchUpdateOperation;
+	| PatchUpdateOperation
+	| PatchLineDeleteOperation
+	| PatchLineReplaceOperation
+	| PatchLineInsertOperation;
 
 export interface AppliedPatchHunk {
 	header: PatchHunkHeader;
@@ -52,7 +84,7 @@ export interface AppliedPatchHunk {
 }
 
 export interface AppliedPatchOperation {
-	kind: PatchOperationKind;
+	kind: AppliedPatchOperationKind;
 	filePath: string;
 	stats: {
 		additions: number;

package/src/core/src/tools/builtin/patch.ts

@@ -41,10 +41,6 @@ function serializeRejected(rejected: RejectedPatch[]) {
 						newStart: hunk.header.newStart,
 						newLines: hunk.header.newLines,
 						context: hunk.header.context,
-						lines: hunk.lines.map((line) => ({
-							kind: line.kind,
-							content: line.content,
-						})),
 					}))
 				: undefined,
 	}));
@@ -83,7 +79,10 @@ export function buildApplyPatchTool(projectRoot: string): {
 			fuzzyMatch?: boolean;
 		}): Promise<
 			ToolResponse<{
+				operation: 'apply_patch';
 				output: string;
+				changed: boolean;
+				summary: { files: number; additions: number; deletions: number };
 				changes: unknown[];
 				artifact: unknown;
 				rejected?: unknown[];
@@ -142,7 +141,10 @@ export function buildApplyPatchTool(projectRoot: string): {
 
 				return {
 					ok: true,
+					operation: 'apply_patch',
 					output: output.join('; '),
+					changed: result.operations.length > 0,
+					summary: result.summary,
 					changes,
 					artifact: {
 						kind: 'file_diff',

package/src/core/src/tools/builtin/patch.txt

@@ -20,6 +20,46 @@ You can include multiple `*** Find:` / `*** With:` pairs under one `*** Replace
 
 ---
 
+## Line-number mode: Delete / Replace / Insert
+
+Use line-number directives for large removals or replacements after reading the
+target file. Lines are 1-indexed and ranges are inclusive. `end`, `eof`, and `$`
+can be used as a range end.
+
+```text
+*** Begin Patch
+*** Delete Lines in: path/to/file.ts
+*** Lines: 120-184
+*** End Patch
+```
+
+```text
+*** Begin Patch
+*** Replace Lines in: path/to/file.ts
+*** Lines: 120-184
+*** With:
+new replacement block
+*** End Patch
+```
+
+```text
+*** Begin Patch
+*** Insert Before in: path/to/file.ts
+*** Line: 120
+*** With:
+new block before line 120
+*** Insert After in: path/to/file.ts
+*** Line: 200
+*** With:
+new block after line 200
+*** End Patch
+```
+
+Line-number mode is concise but fragile if the file changes after you read it.
+Prefer text/context patches for small edits.
+
+---
+
 ## Standard mode: Add / Update / Delete
 
 ```text
@@ -48,9 +88,9 @@ For multiple edits in the same file, use **one** `*** Update File:` block with m
 - File uses tabs → patch uses tabs.
 - File uses 2 spaces → patch uses 2 spaces (not 4, not tabs).
 
-**4. Include Sufficient Context.** Minimum 2 context lines before AND after each change (3+ for YAML). A single context line is fragile — it may match multiple locations.
+**4. Include Sufficient Context.** Minimum 2 context lines before AND after each change (3+ for YAML). A single context line is fragile — it may match multiple locations. For line-number mode, verify the exact line numbers from the latest `read` output instead.
 
-**5. Markers Required.** Every patch MUST start with `*** Begin Patch` and end with `*** End Patch`. Use `*** Update File:`, `*** Add File:`, or `*** Delete File:`.
+**5. Markers Required.** Every patch MUST start with `*** Begin Patch` and end with `*** End Patch`. Use `*** Update File:`, `*** Add File:`, `*** Delete File:`, or a line-number directive.
 
 **6. One `apply_patch` Call Per File.** For multiple edits in the same file, use multiple `@@` hunks in ONE call. Never make separate `apply_patch` calls for the same file in one turn.
 

package/src/providers/src/openai-oauth-client.ts

@@ -14,12 +14,18 @@ const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
 const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 const TOKEN_REFRESH_MAX_RETRIES = 2;
 const TOKEN_REFRESH_RETRY_DELAY_MS = 1000;
+const CODEX_INSTALLATION_ID = crypto.randomUUID();
+const CODEX_REQUEST_TIMEOUT_MS = 120_000;
+const CODEX_STREAM_IDLE_TIMEOUT_MS = 120_000;
 
 type OpenAIOAuthSessionState = {
 	responseId?: string;
 	model?: string;
 	status?: string;
 	incompleteReason?: string;
+	turnState?: string;
+	installationId?: string;
+	windowId?: string;
 };
 
 const openAIOAuthSessionState = new Map<string, OpenAIOAuthSessionState>();
@@ -83,6 +89,27 @@ function shouldUsePreviousResponseId() {
 	return process.env.OTTO_OPENAI_OAUTH_PREVIOUS_RESPONSE_ID === '1';
 }
 
+function parsePositiveIntegerEnv(name: string, fallback: number) {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function getCodexRequestTimeoutMs() {
+	return parsePositiveIntegerEnv(
+		'OTTO_OPENAI_OAUTH_REQUEST_TIMEOUT_MS',
+		CODEX_REQUEST_TIMEOUT_MS,
+	);
+}
+
+function getCodexStreamIdleTimeoutMs() {
+	return parsePositiveIntegerEnv(
+		'OTTO_OPENAI_OAUTH_STREAM_IDLE_TIMEOUT_MS',
+		CODEX_STREAM_IDLE_TIMEOUT_MS,
+	);
+}
+
 export function clearOpenAIOAuthSessionState(sessionId?: string) {
 	if (sessionId) {
 		openAIOAuthSessionState.delete(sessionId);
@@ -171,6 +198,17 @@ function writeSessionState(sessionId: string, next: OpenAIOAuthSessionState) {
 	openAIOAuthSessionState.set(sessionId, next);
 }
 
+function mergeSessionState(sessionId: string, next: OpenAIOAuthSessionState) {
+	writeSessionState(sessionId, {
+		...readSessionState(sessionId),
+		...next,
+	});
+}
+
+function getCodexWindowId(sessionId: string) {
+	return `${sessionId}:0`;
+}
+
 function rewriteRequestBody(
 	body: string,
 	sessionId?: string,
@@ -178,8 +216,25 @@ function rewriteRequestBody(
 	try {
 		const parsed = JSON.parse(body) as Record<string, unknown>;
 		const model = typeof parsed.model === 'string' ? parsed.model : undefined;
+		let changed = stripStatelessResponseInputIds(parsed);
 		if (!sessionId) {
-			return { body, model };
+			return { body: changed ? JSON.stringify(parsed) : body, model };
+		}
+
+		const clientMetadata =
+			parsed.client_metadata && typeof parsed.client_metadata === 'object'
+				? (parsed.client_metadata as Record<string, unknown>)
+				: {};
+		if (clientMetadata['x-codex-installation-id'] !== CODEX_INSTALLATION_ID) {
+			parsed.client_metadata = {
+				...clientMetadata,
+				'x-codex-installation-id': CODEX_INSTALLATION_ID,
+			};
+			changed = true;
+		}
+		if (typeof parsed.prompt_cache_key !== 'string') {
+			parsed.prompt_cache_key = sessionId;
+			changed = true;
 		}
 
 		const prior = readSessionState(sessionId);
@@ -192,9 +247,10 @@ function rewriteRequestBody(
 				logOpenAIOAuth(
 					`not injecting previous_response_id=${prior.responseId} for session=${sessionId} model=${model ?? 'unknown'} because Codex HTTP backend rejects it; enable OTTO_OPENAI_OAUTH_PREVIOUS_RESPONSE_ID=1 only for validation`,
 				);
-				return { body, model };
+				return { body: changed ? JSON.stringify(parsed) : body, model };
 			}
 			parsed.previous_response_id = prior.responseId;
+			changed = true;
 			logOpenAIOAuth(
 				`injecting previous_response_id=${prior.responseId} for session=${sessionId} model=${model ?? 'unknown'}`,
 			);
@@ -205,12 +261,41 @@ function rewriteRequestBody(
 			};
 		}
 
-		return { body, model };
+		return { body: changed ? JSON.stringify(parsed) : body, model };
 	} catch {
 		return { body };
 	}
 }
 
+function stripStatelessResponseInputIds(
+	parsed: Record<string, unknown>,
+): boolean {
+	if (parsed.store === true || !Array.isArray(parsed.input)) {
+		return false;
+	}
+
+	let changed = false;
+	const input = parsed.input.map((item) => {
+		if (!item || typeof item !== 'object' || Array.isArray(item)) {
+			return item;
+		}
+		if (!('id' in item)) {
+			return item;
+		}
+
+		const next = { ...(item as Record<string, unknown>) };
+		delete next.id;
+		changed = true;
+		return next;
+	});
+
+	if (changed) {
+		parsed.input = input;
+	}
+
+	return changed;
+}
+
 function previewText(value: unknown, maxLength = 240): string | undefined {
 	if (typeof value !== 'string') return undefined;
 	const normalized = value.replace(/\s+/g, ' ').trim();
@@ -283,6 +368,9 @@ function trackResponseEvent(data: string, sessionId?: string) {
 				model: responseModel ?? prior?.model,
 				status: responseStatus ?? type,
 				incompleteReason,
+				turnState: prior?.turnState,
+				installationId: prior?.installationId,
+				windowId: prior?.windowId,
 			});
 			logOpenAIOAuth(
 				`tracked response event type=${type ?? 'unknown'} responseId=${responseId} session=${sessionId} status=${responseStatus ?? 'unknown'} incompleteReason=${incompleteReason ?? 'none'}`,
@@ -304,9 +392,29 @@ function trackResponsesStream(
 	const decoder = new TextDecoder();
 	const encoder = new TextEncoder();
 	let buffer = '';
+	let timeout: Timer | undefined;
+	const idleTimeoutMs = getCodexStreamIdleTimeoutMs();
+	const clearIdleTimeout = () => {
+		if (timeout) clearTimeout(timeout);
+		timeout = undefined;
+	};
+	const resetIdleTimeout = (controller: TransformStreamDefaultController) => {
+		clearIdleTimeout();
+		timeout = setTimeout(() => {
+			controller.error(
+				new Error(
+					`OpenAI OAuth Codex stream idle timeout after ${idleTimeoutMs}ms`,
+				),
+			);
+		}, idleTimeoutMs);
+	};
 
 	const transform = new TransformStream<Uint8Array, Uint8Array>({
+		start(controller) {
+			resetIdleTimeout(controller);
+		},
 		transform(chunk, controller) {
+			resetIdleTimeout(controller);
 			buffer += decoder.decode(chunk, { stream: true }).replace(/\r\n/g, '\n');
 			let boundary = buffer.indexOf('\n\n');
 			while (boundary !== -1) {
@@ -329,6 +437,7 @@ function trackResponsesStream(
 			}
 		},
 		flush(controller) {
+			clearIdleTimeout();
 			buffer += decoder.decode().replace(/\r\n/g, '\n');
 			if (buffer.length > 0) {
 				controller.enqueue(encoder.encode(buffer));
@@ -343,6 +452,72 @@ function trackResponsesStream(
 	});
 }
 
+async function fetchWithCodexRequestTimeout(
+	url: string,
+	init: RequestInit,
+	args: {
+		enabled: boolean;
+		sessionId?: string;
+		model?: string;
+		requestStartedAt: number;
+	},
+) {
+	if (!args.enabled) {
+		return fetch(url, {
+			...init,
+			// @ts-expect-error Bun-specific fetch option
+			timeout: false,
+		});
+	}
+
+	const timeoutMs = getCodexRequestTimeoutMs();
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort(
+			new Error(
+				`OpenAI OAuth Codex request timeout before response after ${timeoutMs}ms`,
+			),
+		);
+	}, timeoutMs);
+	let abortedByParent = false;
+	const parentSignal = init.signal;
+	const abortFromParent = () => {
+		abortedByParent = true;
+		controller.abort(parentSignal?.reason);
+	};
+	if (parentSignal) {
+		if (parentSignal.aborted) {
+			abortFromParent();
+		} else {
+			parentSignal.addEventListener('abort', abortFromParent, { once: true });
+		}
+	}
+
+	try {
+		return await fetch(url, {
+			...init,
+			signal: controller.signal,
+			// @ts-expect-error Bun-specific fetch option
+			timeout: false,
+		});
+	} catch (error) {
+		if (!abortedByParent && controller.signal.aborted) {
+			loggerWarn('[openai-oauth] request timed out before response', {
+				sessionId: args.sessionId,
+				model: args.model,
+				timeoutMs,
+				durationMs: Date.now() - args.requestStartedAt,
+			});
+		}
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		if (parentSignal) {
+			parentSignal.removeEventListener('abort', abortFromParent);
+		}
+	}
+}
+
 function buildHeaders(
 	init: RequestInit | undefined,
 	accessToken: string,
@@ -350,10 +525,15 @@ function buildHeaders(
 	sessionId?: string,
 ): Headers {
 	const headers = new Headers(init?.headers);
+	const prior = readSessionState(sessionId);
+	const windowId = sessionId
+		? (prior?.windowId ?? getCodexWindowId(sessionId))
+		: undefined;
 	headers.delete('Authorization');
 	headers.delete('authorization');
 	headers.set('authorization', `Bearer ${accessToken}`);
 	headers.set('originator', 'otto');
+	headers.set('x-codex-installation-id', CODEX_INSTALLATION_ID);
 	headers.set(
 		'User-Agent',
 		`otto/1.0 (${os.platform()} ${os.release()}; ${os.arch()})`,
@@ -363,10 +543,30 @@ function buildHeaders(
 	}
 	if (sessionId) {
 		headers.set('session_id', sessionId);
+		headers.set('thread_id', sessionId);
+		headers.set('x-codex-window-id', windowId ?? getCodexWindowId(sessionId));
+		if (prior?.turnState) {
+			headers.set('x-codex-turn-state', prior.turnState);
+		}
 	}
 	return headers;
 }
 
+function trackCodexResponseHeaders(response: Response, sessionId?: string) {
+	if (!sessionId) return;
+	const turnState = response.headers.get('x-codex-turn-state') ?? undefined;
+	if (!turnState) return;
+	const windowId = getCodexWindowId(sessionId);
+	mergeSessionState(sessionId, {
+		turnState,
+		installationId: CODEX_INSTALLATION_ID,
+		windowId,
+	});
+	logOpenAIOAuth(
+		`tracked x-codex-turn-state for session=${sessionId} window=${windowId}`,
+	);
+}
+
 export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 	let currentOAuth = config.oauth;
 
@@ -403,6 +603,9 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 					model: requestModel,
 					status: prior?.status,
 					incompleteReason: prior?.incompleteReason,
+					turnState: prior?.turnState,
+					installationId: prior?.installationId,
+					windowId: prior?.windowId,
 				});
 			}
 		}
@@ -425,12 +628,19 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 
 		let response: Response;
 		try {
-			response = await fetch(targetUrl, {
-				...requestInit,
-				headers,
-				// @ts-expect-error Bun-specific fetch option
-				timeout: false,
-			});
+			response = await fetchWithCodexRequestTimeout(
+				targetUrl,
+				{
+					...requestInit,
+					headers,
+				},
+				{
+					enabled: isResponsesRequest,
+					sessionId: config.sessionId,
+					model: requestModel,
+					requestStartedAt,
+				},
+			);
 		} catch (error) {
 			loggerWarn('[openai-oauth] request failed before response', {
 				sessionId: config.sessionId,
@@ -453,6 +663,9 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 			bodyCharsApprox: requestBodySize,
 			model: requestModel,
 		});
+		if (isResponsesRequest) {
+			trackCodexResponseHeaders(response, config.sessionId);
+		}
 		if (!response.ok && response.status !== 401) {
 			loggerWarn('[openai-oauth] non-OK response', {
 				sessionId: config.sessionId,
@@ -499,12 +712,22 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 				);
 
 				const retryStartedAt = Date.now();
-				const retryResponse = await fetch(targetUrl, {
-					...requestInit,
-					headers: retryHeaders,
-					// @ts-expect-error Bun-specific fetch option
-					timeout: false,
-				});
+				const retryResponse = await fetchWithCodexRequestTimeout(
+					targetUrl,
+					{
+						...requestInit,
+						headers: retryHeaders,
+					},
+					{
+						enabled: isResponsesRequest,
+						sessionId: config.sessionId,
+						model: requestModel,
+						requestStartedAt: retryStartedAt,
+					},
+				);
+				if (isResponsesRequest) {
+					trackCodexResponseHeaders(retryResponse, config.sessionId);
+				}
 				loggerDebug('[openai-oauth] retry response received', {
 					sessionId: config.sessionId,
 					target: isResponsesRequest ? 'codex.responses' : 'other',