@namzu/sdk 2.0.0 → 3.1.0

package/dist/tools/builtins/computer-use.d.ts

@@ -20,23 +20,23 @@ declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        x: number;
         y: number;
-    }, {
         x: number;
+    }, {
         y: number;
+        x: number;
     }>;
 }, "strip", z.ZodTypeAny, {
     type: "mouse_move";
     to: {
-        x: number;
         y: number;
+        x: number;
     };
 }, {
     type: "mouse_move";
     to: {
-        x: number;
         y: number;
+        x: number;
     };
 }>, z.ZodObject<{
     type: z.ZodLiteral<"mouse_click">;
@@ -44,24 +44,24 @@ declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        x: number;
         y: number;
-    }, {
         x: number;
+    }, {
         y: number;
+        x: number;
     }>;
     button: z.ZodEnum<["left", "right", "middle"]>;
 }, "strip", z.ZodTypeAny, {
     at: {
-        x: number;
         y: number;
+        x: number;
     };
     type: "mouse_click";
     button: "left" | "right" | "middle";
 }, {
     at: {
-        x: number;
         y: number;
+        x: number;
     };
     type: "mouse_click";
     button: "left" | "right" | "middle";
@@ -71,43 +71,43 @@ declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        x: number;
         y: number;
-    }, {
         x: number;
+    }, {
         y: number;
+        x: number;
     }>;
     to: z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        x: number;
         y: number;
-    }, {
         x: number;
+    }, {
         y: number;
+        x: number;
     }>;
     button: z.ZodEnum<["left", "right", "middle"]>;
 }, "strip", z.ZodTypeAny, {
     type: "mouse_drag";
     from: {
-        x: number;
         y: number;
+        x: number;
     };
     to: {
-        x: number;
         y: number;
+        x: number;
     };
     button: "left" | "right" | "middle";
 }, {
     type: "mouse_drag";
     from: {
-        x: number;
         y: number;
+        x: number;
     };
     to: {
-        x: number;
         y: number;
+        x: number;
     };
     button: "left" | "right" | "middle";
 }>, z.ZodObject<{
@@ -116,26 +116,26 @@ declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        x: number;
         y: number;
-    }, {
         x: number;
+    }, {
         y: number;
+        x: number;
     }>;
     direction: z.ZodEnum<["up", "down", "left", "right"]>;
     amount: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     at: {
-        x: number;
         y: number;
+        x: number;
     };
     type: "scroll";
     direction: "left" | "right" | "up" | "down";
     amount: number;
 }, {
     at: {
-        x: number;
         y: number;
+        x: number;
     };
     type: "scroll";
     direction: "left" | "right" | "up" | "down";
@@ -144,11 +144,11 @@ declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"type_text">;
     text: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "type_text";
     text: string;
-}, {
     type: "type_text";
+}, {
     text: string;
+    type: "type_text";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"key">;
     keys: z.ZodString;

package/dist/tools/builtins/computer-use.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computer-use.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/computer-use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAGX,eAAe,EAEf,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,2BAA2B,CAAA;AAG3E,eAAO,MAAM,sBAAsB,EAAG,cAAuB,CAAA;AAa7D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBhB,CAAA;AAEF,KAAK,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AA4E/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,cAAc,CAAC,WAAW,CAAC,CAwBxF"}
+{"version":3,"file":"computer-use.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/computer-use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAGX,eAAe,EAEf,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,2BAA2B,CAAA;AAG3E,eAAO,MAAM,sBAAsB,EAAG,cAAuB,CAAA;AAa7D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBhB,CAAA;AAEF,KAAK,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAkF/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,cAAc,CAAC,WAAW,CAAC,CAwBxF"}

package/dist/tools/builtins/computer-use.js

@@ -88,9 +88,15 @@ function resultToToolResult(result) {
     switch (result.type) {
         case 'screenshot': {
             const { data, mimeType, width, height } = result.result;
+            // `output` used to BE the base64 payload, which meant the model
+            // received 400 KB–2.7 MB of undecodable characters as text —
+            // roughly 100k–670k tokens — and could not see the screen at
+            // all. The image now travels as a content block; `output` keeps
+            // the short human/transcript-facing description.
             return {
                 success: true,
-                output: data.toString('base64'),
+                output: `Screenshot captured (${width}x${height}, ${mimeType}).`,
+                content: [{ type: 'image', data: data.toString('base64'), mediaType: mimeType }],
                 data: { mimeType, width, height, encoding: 'base64' },
             };
         }

package/dist/tools/builtins/computer-use.js.map

@@ -1 +1 @@
-{"version":3,"file":"computer-use.js","sourceRoot":"","sources":["../../../src/tools/builtins/computer-use.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"computer-use.js","sourceRoot":"","sources":["../../../src/tools/builtins/computer-use.ts"],"names":[],"mappings":"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"}

package/dist/tools/builtins/content-fingerprint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A short, stable fingerprint of a file body.
+ *
+ * Used to answer one question at mutation time: is the file still what the
+ * agent read? An `edit` is computed against a remembered body, and between
+ * the read and the write that body can move — a person editing in an
+ * editor, another process, a second agent run. The in-process mutation lock
+ * serializes this runtime's own writers and is blind to every one of those.
+ *
+ * Without this the drift is not merely undetected, it is actively
+ * misreported: an `old_string` that no longer matches comes back as "not
+ * found in file — make sure the string matches exactly", which tells the
+ * agent its input was wrong when the file changed underneath it. The agent
+ * then retries the same edit against the same moved file.
+ *
+ * Truncated deliberately. This distinguishes two bodies; it is not a
+ * security boundary, and a full digest per read costs bytes in a structure
+ * that lives for the whole run.
+ */
+export declare function fingerprintContent(content: string): string;
+/** What a mutation tool tells the agent when the file moved under it. */
+export declare function staleFileError(path: string): string;
+//# sourceMappingURL=content-fingerprint.d.ts.map

package/dist/tools/builtins/content-fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-fingerprint.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/content-fingerprint.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMnD"}

package/dist/tools/builtins/content-fingerprint.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+/**
+ * A short, stable fingerprint of a file body.
+ *
+ * Used to answer one question at mutation time: is the file still what the
+ * agent read? An `edit` is computed against a remembered body, and between
+ * the read and the write that body can move — a person editing in an
+ * editor, another process, a second agent run. The in-process mutation lock
+ * serializes this runtime's own writers and is blind to every one of those.
+ *
+ * Without this the drift is not merely undetected, it is actively
+ * misreported: an `old_string` that no longer matches comes back as "not
+ * found in file — make sure the string matches exactly", which tells the
+ * agent its input was wrong when the file changed underneath it. The agent
+ * then retries the same edit against the same moved file.
+ *
+ * Truncated deliberately. This distinguishes two bodies; it is not a
+ * security boundary, and a full digest per read costs bytes in a structure
+ * that lives for the whole run.
+ */
+export function fingerprintContent(content) {
+    return createHash('sha256').update(content, 'utf-8').digest('hex').slice(0, 16);
+}
+/** What a mutation tool tells the agent when the file moved under it. */
+export function staleFileError(path) {
+    return (`${path} changed on disk after you read it, so this edit was computed against a stale copy ` +
+        'and was not applied. Read the file again and redo the edit against its current contents. ' +
+        'Nothing was written.');
+}
+//# sourceMappingURL=content-fingerprint.js.map

package/dist/tools/builtins/content-fingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-fingerprint.js","sourceRoot":"","sources":["../../../src/tools/builtins/content-fingerprint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe;IACjD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AAChF,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,cAAc,CAAC,IAAY;IAC1C,OAAO,CACN,GAAG,IAAI,qFAAqF;QAC5F,2FAA2F;QAC3F,sBAAsB,CACtB,CAAA;AACF,CAAC"}

package/dist/tools/builtins/edit.d.ts

@@ -1,7 +1,10 @@
 export declare const EditTool: import("../../public-types.js").ToolDefinition<{
     path: string;
-    old_string: string;
-    new_string: string;
     replace_all: boolean;
+    newStr?: string | undefined;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    insertLine?: string | number | undefined;
 }>;
 //# sourceMappingURL=edit.d.ts.map

package/dist/tools/builtins/edit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/edit.ts"],"names":[],"mappings":"AAiEA,eAAO,MAAM,QAAQ;;;;;EAwEnB,CAAA"}
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/edit.ts"],"names":[],"mappings":"AA4HA,eAAO,MAAM,QAAQ;;;;;;;;EAiHnB,CAAA"}

package/dist/tools/builtins/edit.js

@@ -3,7 +3,21 @@ import { resolve } from 'node:path';
 import { z } from 'zod';
 import { defineTool } from '../defineTool.js';
 import { atomicWriteFile } from './atomic-write-file.js';
+import { fingerprintContent, staleFileError } from './content-fingerprint.js';
 import { withFileMutationLock } from './file-mutation-lock.js';
+/**
+ * Two schemas, on purpose.
+ *
+ * `inputSchema` is what a HOST may send, and it accepts the `oldStr`/`newStr`
+ * aliases and `insertLine` because hosts that expose replacement under those
+ * names are real. `modelInputSchema` below is what a MODEL is constrained to
+ * — one closed canonical shape — because giving a model four spellings of the
+ * same field is how it learns to guess between them.
+ *
+ * `.strict()` is what makes the accepted set closed. Without it zod's default
+ * is to STRIP an unknown key, so a hallucinated or misspelled field is
+ * silently dropped and the edit proceeds against an input nobody wrote.
+ */
 const inputSchema = z
     .object({
     path: z
@@ -13,16 +27,45 @@ const inputSchema = z
     old_string: z
         .string()
         .min(1)
-        .describe('The exact unique text to replace, without read-tool line-number prefixes. Must not be empty.'),
+        .optional()
+        .describe('The exact string to find and replace. Must be unique in the file.'),
+    oldStr: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Alias for old_string. Used by hosts that expose text replacement as oldStr/newStr.'),
     new_string: z
         .string()
-        .describe('The exact replacement text. May be empty to delete old_string. Keep this payload under 12000 characters.'),
+        .optional()
+        .describe('The replacement string. Self-budget this payload under 12000 characters before calling.'),
+    newStr: z
+        .string()
+        .optional()
+        .describe('Alias for new_string. Also used as inserted content when insertLine is provided. Self-budget this payload under 12000 characters before calling.'),
+    insertLine: z
+        .union([z.coerce.number().int().min(0), z.string().min(1)])
+        .optional()
+        .describe('Optional line insertion target. Inserts the replacement after this 1-indexed line; 0 inserts before the first line; "end" appends to the file.'),
     replace_all: z
         .boolean()
         .default(false)
-        .describe('Replace every occurrence instead of requiring one unique match.'),
+        .describe('Replace all occurrences instead of just the first unique match'),
+})
+    .strict()
+    .refine((value) => typeof value.new_string === 'string' || typeof value.newStr === 'string', {
+    message: 'Either new_string or newStr is required.',
 })
-    .strict();
+    .refine((value) => value.insertLine !== undefined ||
+    typeof value.old_string === 'string' ||
+    typeof value.oldStr === 'string', { message: 'Either old_string/oldStr or insertLine is required.' });
+/**
+ * What a capable provider constrains the model to emit: one shape, closed.
+ *
+ * The aliases above exist for hosts, not for models. A model offered
+ * `old_string` and `oldStr` as separate optional fields has to guess which
+ * one this deployment wants, and `additionalProperties: false` is what turns
+ * an invented field into a generation-time refusal rather than a silent drop.
+ */
 const modelInputSchema = {
     type: 'object',
     properties: {
@@ -48,7 +91,7 @@ const modelInputSchema = {
 };
 export const EditTool = defineTool({
     name: 'edit',
-    description: "Performs one targeted exact-string replacement in an existing file. Pass path + old_string + new_string; old_string must match exactly and be unique unless replace_all is true. Read the file immediately before editing, preserve whitespace and indentation, and never include the read tool's line-number prefix in old_string. To append or insert, replace a unique existing tail/marker with itself plus the new text; advance a deterministic marker such as {{CHUNK_001}} to {{CHUNK_002}} so replaying a completed edit cannot duplicate content. Prefer this tool over rewriting an existing file. Self-budget new_string under 12000 characters.",
+    description: 'Makes targeted edits to a file using exact string find-and-replace or line insertion. THIS IS THE PREFERRED WAY TO MODIFY AN EXISTING FILE — never reach for `write` to change a file that already exists, because `write` overwrites the whole body and discards earlier work on partial failure. `edit` keeps the rest of the file byte-for-byte intact and is recoverable: if a single edit fails (old_string/oldStr ambiguous, broader restructuring needed), follow up with another `edit` instead of re-emitting the entire file via `write`. The old_string/oldStr must be unique in the file unless replace_all is true. For insertions, pass insertLine plus new_string/newStr; use insertLine: "end" to extend a file at the end. Self-budget new_string/newStr under 12000 characters before emitting the tool call; use repeated bounded edits for long sections. Preserves file formatting and indentation.',
     inputSchema,
     modelInputSchema,
     enforceModelInput: true,
@@ -59,6 +102,9 @@ export const EditTool = defineTool({
     destructive: false,
     concurrencySafe: false,
     async execute(input, context) {
+        // Re-validated here rather than trusted from the registry: `execute` is
+        // reachable directly, and the closed contract is only closed if the
+        // check runs on the path a caller can actually take.
         const parsed = inputSchema.safeParse(input);
         if (!parsed.success) {
             return {
@@ -67,43 +113,76 @@ export const EditTool = defineTool({
                 error: `Invalid edit input: ${parsed.error.issues.map((issue) => issue.message).join('; ')}`,
             };
         }
-        const canonicalInput = parsed.data;
-        const replacement = {
-            oldString: canonicalInput.old_string,
-            newString: canonicalInput.new_string,
-            replaceAll: canonicalInput.replace_all,
-        };
-        if (replacement.oldString === replacement.newString) {
+        const normalized = normalizeEditInput(parsed.data);
+        if (!normalized.success) {
+            return { success: false, output: '', error: normalized.error };
+        }
+        if (normalized.operation.operation === 'replace' &&
+            normalized.operation.oldString === normalized.operation.newString) {
             return {
                 success: false,
                 output: '',
-                error: 'old_string and new_string are identical — no change needed.',
+                error: 'old_string/oldStr and new_string/newStr are identical — no change needed',
             };
         }
-        const filePath = resolve(context.workingDirectory, canonicalInput.path);
+        const filePath = resolve(context.workingDirectory, parsed.data.path);
+        // Read-modify-write is not atomic on its own: two edits to the same
+        // path interleave their reads, and the second write lands on content
+        // the first had already replaced — so one edit vanishes and the loser
+        // reports "old_string not found", blaming the model for a race. The
+        // key spans both branches because sandbox and local are distinct
+        // files even when the path string matches.
         const lockKey = `${context.sandbox ? 'sandbox' : 'local'}:${filePath}`;
         return withFileMutationLock(lockKey, async () => {
             if (context.sandbox) {
-                const buffer = await context.sandbox.readFile(canonicalInput.path);
-                const result = applyEdit(buffer.toString('utf-8'), replacement);
-                if (!result.success)
+                const buffer = await context.sandbox.readFile(parsed.data.path);
+                const result = applyEdit(buffer.toString('utf-8'), normalized.operation);
+                if (!result.success) {
                     return { success: false, output: '', error: result.error };
-                await context.sandbox.writeFile(canonicalInput.path, result.content);
+                }
+                await context.sandbox.writeFile(parsed.data.path, result.content);
                 return {
                     success: true,
-                    output: `Edited ${canonicalInput.path}: ${result.replacements} replacement(s) [sandboxed]`,
-                    data: {
-                        path: canonicalInput.path,
-                        replacements: result.replacements,
-                        sandboxed: true,
-                    },
+                    output: `Edited ${parsed.data.path}: ${result.replacements} replacement(s) [sandboxed]`,
+                    data: { path: parsed.data.path, replacements: result.replacements, sandboxed: true },
                 };
             }
             const content = await readFile(filePath, 'utf-8');
-            const result = applyEdit(content, replacement);
-            if (!result.success)
+            const result = applyEdit(content, normalized.operation);
+            if (!result.success) {
+                // The anchor did not match what is on disk. Two very different
+                // situations produce that, and the difference is the whole
+                // value of the fingerprint:
+                //
+                // The file is as the agent left it, and the anchor is simply
+                // wrong — "not found, match the whitespace exactly" is the
+                // right thing to say.
+                //
+                // Or the file moved after the read — a person in an editor,
+                // another process, a second agent — and the same message is a
+                // lie that sends the agent to re-check text that was never the
+                // problem, so it retries the identical edit against the same
+                // moved file.
+                //
+                // Deliberately NOT a gate on the successful path. An anchor
+                // that still matches uniquely is well defined however much
+                // changed elsewhere in the file, and refusing there would
+                // reject safe edits every time anyone touched an unrelated
+                // line.
+                const seen = context.fileReadTracker?.fingerprint?.(filePath);
+                if (seen !== undefined && seen !== fingerprintContent(content)) {
+                    return { success: false, output: '', error: staleFileError(filePath) };
+                }
                 return { success: false, output: '', error: result.error };
+            }
+            // Temp file, fsync, rename — a reader sees the old body or the new
+            // one, never a half-written one. A plain `writeFile` that fails
+            // partway leaves the user's source truncated.
             await atomicWriteFile(filePath, result.content);
+            // This runtime is now the last writer, so the next edit in the same
+            // turn compares against what we just wrote rather than the read
+            // before it.
+            context.fileReadTracker?.recordRead(filePath, result.content);
             return {
                 success: true,
                 output: `Edited ${filePath}: ${result.replacements} replacement(s)`,
@@ -112,62 +191,144 @@ export const EditTool = defineTool({
         });
     },
 });
-function normalizeLineEndings(content, input) {
-    const withoutCrlf = content.replaceAll('\r\n', '');
-    const usesOnlyCrlf = content.includes('\r\n') && !withoutCrlf.includes('\n');
-    if (usesOnlyCrlf) {
+function normalizeEditInput(input) {
+    const newString = input.new_string ?? input.newStr;
+    if (typeof newString !== 'string') {
+        return { success: false, error: 'Either new_string or newStr is required.' };
+    }
+    if (input.insertLine !== undefined) {
+        const insertLine = normalizeInsertLine(input.insertLine);
+        if (!insertLine.success)
+            return insertLine;
         return {
-            ...input,
-            oldString: content.includes(input.oldString)
-                ? input.oldString
-                : input.oldString.replaceAll('\r\n', '\n').replaceAll('\n', '\r\n'),
-            newString: input.newString.replaceAll('\r\n', '\n').replaceAll('\n', '\r\n'),
+            success: true,
+            operation: {
+                operation: 'insert',
+                insertLine: insertLine.value,
+                newString,
+                replace_all: input.replace_all,
+            },
         };
     }
-    const usesOnlyLf = content.includes('\n') && !content.includes('\r\n');
-    if (usesOnlyLf) {
+    const oldString = input.old_string ?? input.oldStr;
+    if (typeof oldString !== 'string') {
+        return { success: false, error: 'Either old_string/oldStr or insertLine is required.' };
+    }
+    return {
+        success: true,
+        operation: {
+            operation: 'replace',
+            oldString,
+            newString,
+            replace_all: input.replace_all,
+        },
+    };
+}
+function normalizeInsertLine(value) {
+    if (typeof value === 'string') {
+        if (value.trim().toLowerCase() === 'end')
+            return { success: true, value: 'end' };
+        const parsed = Number(value);
+        if (Number.isInteger(parsed) && parsed >= 0)
+            return { success: true, value: parsed };
         return {
-            ...input,
-            oldString: content.includes(input.oldString)
-                ? input.oldString
-                : input.oldString.replaceAll('\r\n', '\n'),
-            newString: input.newString.replaceAll('\r\n', '\n'),
+            success: false,
+            error: 'insertLine must be a non-negative line number or "end".',
         };
     }
-    return input;
+    return { success: true, value };
 }
-function applyEdit(content, rawInput) {
-    const input = normalizeLineEndings(content, rawInput);
-    if (!content.includes(input.oldString)) {
+function applyEdit(content, input) {
+    if (input.operation === 'insert') {
+        return applyLineInsert(content, input);
+    }
+    const replacement = normalizeLineEndings(content, input);
+    if (!content.includes(replacement.oldString)) {
         return {
             success: false,
-            error: 'old_string was not found. Read the file again and copy exact text without line-number prefixes.',
+            error: 'old_string/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation.',
         };
     }
-    if (input.replaceAll) {
-        const parts = content.split(input.oldString);
+    if (replacement.replace_all) {
+        const parts = content.split(replacement.oldString);
+        const replacements = parts.length - 1;
         return {
             success: true,
-            content: parts.join(input.newString),
-            replacements: parts.length - 1,
+            content: parts.join(replacement.newString),
+            replacements,
         };
     }
-    const firstIndex = content.indexOf(input.oldString);
-    const secondIndex = content.indexOf(input.oldString, firstIndex + input.oldString.length);
+    // Uniqueness check: old_string/oldStr must appear exactly once
+    const firstIndex = content.indexOf(replacement.oldString);
+    const secondIndex = content.indexOf(replacement.oldString, firstIndex + 1);
     if (secondIndex !== -1) {
-        const firstLine = content.slice(0, firstIndex).split('\n').length;
+        const lineNumber = content.slice(0, firstIndex).split('\n').length;
         const secondLine = content.slice(0, secondIndex).split('\n').length;
         return {
             success: false,
-            error: `old_string is not unique — found at lines ${firstLine} and ${secondLine}. Include more surrounding context, or use replace_all: true.`,
+            error: `old_string/oldStr is not unique — found at lines ${lineNumber} and ${secondLine}. Provide more surrounding context to make it unique, or use replace_all: true.`,
         };
     }
     return {
         success: true,
         content: content.slice(0, firstIndex) +
-            input.newString +
-            content.slice(firstIndex + input.oldString.length),
+            replacement.newString +
+            content.slice(firstIndex + replacement.oldString.length),
+        replacements: 1,
+    };
+}
+function applyLineInsert(content, input) {
+    const hasTrailingNewline = content.endsWith('\n');
+    const lines = content.split('\n');
+    if (hasTrailingNewline)
+        lines.pop();
+    const line = input.insertLine === 'end'
+        ? lines.length
+        : Math.min(Math.max(input.insertLine, 0), lines.length);
+    const inserted = input.newString.endsWith('\n')
+        ? input.newString.slice(0, -1).split('\n')
+        : input.newString.split('\n');
+    lines.splice(line, 0, ...inserted);
+    return {
+        success: true,
+        content: `${lines.join('\n')}${hasTrailingNewline ? '\n' : ''}`,
         replacements: 1,
     };
 }
+/**
+ * Reconcile the caller's line endings with the file's.
+ *
+ * A model reading a CRLF file and writing back LF (or the reverse) produces
+ * an `old_string` that is correct in every visible way and matches nothing.
+ * The failure reads as "your text is wrong" when the text is right and only
+ * the invisible half of each line break differs.
+ *
+ * Only applied when the file is CONSISTENT. A mixed-ending file has no
+ * single right answer, and rewriting boundaries there would corrupt the
+ * half that was already correct.
+ */
+function normalizeLineEndings(content, input) {
+    const withoutCrlf = content.replaceAll('\r\n', '');
+    const usesOnlyCrlf = content.includes('\r\n') && !withoutCrlf.includes('\n');
+    if (usesOnlyCrlf) {
+        return {
+            ...input,
+            oldString: content.includes(input.oldString)
+                ? input.oldString
+                : input.oldString.replaceAll('\r\n', '\n').replaceAll('\n', '\r\n'),
+            newString: input.newString.replaceAll('\r\n', '\n').replaceAll('\n', '\r\n'),
+        };
+    }
+    const usesOnlyLf = content.includes('\n') && !content.includes('\r\n');
+    if (usesOnlyLf) {
+        return {
+            ...input,
+            oldString: content.includes(input.oldString)
+                ? input.oldString
+                : input.oldString.replaceAll('\r\n', '\n'),
+            newString: input.newString.replaceAll('\r\n', '\n'),
+        };
+    }
+    return input;
+}
 //# sourceMappingURL=edit.js.map