@namzu/sdk 38.2.1 → 40.0.0

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

@@ -0,0 +1,126 @@
+import type { EditInput } from './edit.js';
+/**
+ * The apply core `edit`'s tool definition calls at mutation time, pulled out
+ * on its own so a second caller — the step-context projection that replays a
+ * visible edit call to verify a claimed post-edit body — runs this exact
+ * code instead of a parallel implementation that could drift from it (most
+ * easily on the CRLF reconciliation below, which depends on the real file's
+ * line-ending mix).
+ *
+ * Pure by construction: no filesystem access, no `ToolContext`. Everything
+ * here is a function from strings to strings.
+ */
+export type NormalizedEditInput = {
+    operation: 'replace';
+    oldString: string;
+    newString: string;
+    replace_all: boolean;
+} | {
+    operation: 'insert';
+    insertLine: number | 'end';
+    newString: string;
+    replace_all: boolean;
+};
+/**
+ * Turn one call into the ordered list of operations it stands for.
+ *
+ * A list rather than a single operation because the batch shape is not a
+ * different kind of edit, only a longer one. Keeping ONE representation is
+ * what stops the two shapes diverging: everything below this function — the
+ * uniqueness check, the CRLF reconciliation, the identical-text refusal, the
+ * atomic write — sees a list of length one for a single edit and never learns
+ * which shape the caller used.
+ */
+export declare function normalizeEditInput(input: EditInput): {
+    success: true;
+    operations: NormalizedEditInput[];
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Apply every operation in order, or none of them.
+ *
+ * "Or none" is the whole reason this takes a list. Four related changes sent
+ * as four calls are four chances to stop halfway, and the file left behind
+ * after the third succeeded and the fourth did not is in a state no one wrote
+ * and no one is looking at. Here the fold runs entirely in memory and the
+ * caller writes once, so a failure anywhere leaves the file exactly as it was.
+ *
+ * Each operation matches against the content as the ones before it left it,
+ * not against the original. That is what lets a later edit target text an
+ * earlier one produced — and it is also why a failure names the INDEX: by the
+ * time hunk 3 fails, the string it was looking for may have been consumed by
+ * hunk 1, and "old_string not found" without a position sends the model to
+ * re-check the wrong hunk.
+ */
+export declare function applyEdit(content: string, operations: readonly NormalizedEditInput[]): {
+    success: true;
+    content: string;
+    replacements: number;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * What a bounded replay did, and what it cost.
+ *
+ * A union rather than a throw because all three outcomes are ordinary answers
+ * to a caller replaying somebody else's call: it applied, it would have built
+ * more than the caller has room for, or it no longer applies to the content it
+ * was handed. Only the first carries a body; the other two carry the charge so
+ * the caller can settle the room the attempt actually used.
+ */
+export type BoundedReplay = {
+    readonly outcome: 'replayed';
+    readonly content: string;
+    readonly charged: number;
+    readonly replacements: number;
+} | {
+    readonly outcome: 'refused';
+    readonly charged: number;
+} | {
+    readonly outcome: 'failed';
+    readonly charged: number;
+    readonly error: string;
+};
+/**
+ * The single door a caller outside this module uses.
+ *
+ * Runs a visible call's arguments through the same normalize-then-apply path
+ * `EditTool.execute` runs at mutation time, against a content string the
+ * caller already has in hand — never the filesystem — and under an
+ * `allowance`: the largest string the caller is willing to have built on its
+ * behalf.
+ *
+ * The allowance is honoured one OPERATION at a time. Each operation's
+ * post-image length is worked out exactly from the content it is about to be
+ * applied to, compared against the allowance, and only then applied — so
+ * nothing over the ceiling is ever materialised, and nothing under it is
+ * refused for a bound that guessed high. An earlier shape predicted the whole
+ * call up front, which meant folding operations after the first against a
+ * string it had never seen: a rename hunk at index 1 was charged one match per
+ * anchor-length window of the file, and batches that would have fitted were
+ * turned away for a number nothing had built.
+ *
+ * `charged` is the longest string this call actually materialised, which is
+ * the one the caller paid for holding. It is the post-image length exactly for
+ * the single-operation shape almost every call has; for a batch it is the
+ * largest intermediate the fold built rather than the body it ends on, because
+ * a batch that grows a file to twenty megabytes and then deletes every
+ * character has still built the twenty megabytes. An operation that is refused
+ * or fails is charged nothing — it built nothing — while the ones before it in
+ * the same batch are charged, having run.
+ */
+export declare function replayEditCallWithin(content: string, rawArguments: unknown, allowance: number): BoundedReplay;
+/**
+ * The same walk, entered with the operations already normalized.
+ *
+ * Separate from the entry point above so the equivalence with {@link applyEdit}
+ * can be exercised operation by operation — `replayOperationsWithin(c, [op], ∞)`
+ * is `applyOne(c, op)` plus its exact predicted length — rather than only in
+ * the aggregate, where a prediction that is wrong in two places by the same
+ * amount would pass.
+ */
+export declare function replayOperationsWithin(content: string, operations: readonly NormalizedEditInput[], allowance: number): BoundedReplay;
+//# sourceMappingURL=edit-apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edit-apply.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/edit-apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,mBAAmB,GAC5B;IACA,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;CACnB,GACD;IACA,SAAS,EAAE,QAAQ,CAAA;IACnB,UAAU,EAAE,MAAM,GAAG,KAAK,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;CACnB,CAAA;AAEJ;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,SAAS,GACd;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,mBAAmB,EAAE,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAuD1F;AAoCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,mBAAmB,EAAE,GACxC;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAiB9F;AA2HD;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACtB;IACA,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC5B,GACD;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACzD;IACA,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACrB,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,OAAO,EACrB,SAAS,EAAE,MAAM,GACf,aAAa,CAOf;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,SAAS,EAAE,MAAM,GACf,aAAa,CAyBf"}

package/dist/tools/builtins/edit-apply.js

@@ -0,0 +1,360 @@
+/**
+ * Turn one call into the ordered list of operations it stands for.
+ *
+ * A list rather than a single operation because the batch shape is not a
+ * different kind of edit, only a longer one. Keeping ONE representation is
+ * what stops the two shapes diverging: everything below this function — the
+ * uniqueness check, the CRLF reconciliation, the identical-text refusal, the
+ * atomic write — sees a list of length one for a single edit and never learns
+ * which shape the caller used.
+ */
+export function normalizeEditInput(input) {
+    if (input.edits !== undefined) {
+        return {
+            success: true,
+            operations: input.edits.map((edit) => ({
+                operation: 'replace',
+                oldString: edit.old_string,
+                newString: edit.new_string,
+                replace_all: edit.replace_all ?? false,
+            })),
+        };
+    }
+    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 {
+            success: true,
+            operations: [
+                {
+                    operation: 'insert',
+                    insertLine: insertLine.value,
+                    newString,
+                    replace_all: input.replace_all ?? false,
+                },
+            ],
+        };
+    }
+    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,
+        operations: [
+            {
+                operation: 'replace',
+                oldString,
+                newString,
+                replace_all: input.replace_all ?? false,
+            },
+        ],
+    };
+}
+/**
+ * Spellings of "the end of the file" a model reaches for.
+ *
+ * Liberal here and strict in the schema, which is the right way round: the
+ * schema makes `"end"` the only emittable string for a provider that
+ * constrains, and this catches the rest for one that does not. None of these
+ * is ambiguous — accepting them is not guessing at intent, it is declining to
+ * spend a round trip on a synonym.
+ */
+const END_ALIASES = new Set(['end', 'eof', 'append', 'last', 'end_of_file', 'end-of-file']);
+function normalizeInsertLine(value) {
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        // `"end"` is the only spelling the model-facing schema admits, so a
+        // constrained decoder cannot produce anything else. These aliases are
+        // for the providers that do not constrain: a model reading "appends to
+        // the file" reaches for the word it knows, and every one of these says
+        // the same unambiguous thing. Refusing them bought strictness and cost
+        // a full model round trip per occurrence — measured by a consuming host
+        // as the single largest source of tool-call waste in its runs.
+        if (END_ALIASES.has(normalized))
+            return { success: true, value: 'end' };
+        const parsed = Number(value);
+        if (Number.isInteger(parsed) && parsed >= 0)
+            return { success: true, value: parsed };
+        return {
+            success: false,
+            error: `insertLine must be a non-negative line number or "end" (also accepted: ${[...END_ALIASES].filter((a) => a !== 'end').join(', ')}). Received ${JSON.stringify(value)}.`,
+        };
+    }
+    return { success: true, value };
+}
+/**
+ * Apply every operation in order, or none of them.
+ *
+ * "Or none" is the whole reason this takes a list. Four related changes sent
+ * as four calls are four chances to stop halfway, and the file left behind
+ * after the third succeeded and the fourth did not is in a state no one wrote
+ * and no one is looking at. Here the fold runs entirely in memory and the
+ * caller writes once, so a failure anywhere leaves the file exactly as it was.
+ *
+ * Each operation matches against the content as the ones before it left it,
+ * not against the original. That is what lets a later edit target text an
+ * earlier one produced — and it is also why a failure names the INDEX: by the
+ * time hunk 3 fails, the string it was looking for may have been consumed by
+ * hunk 1, and "old_string not found" without a position sends the model to
+ * re-check the wrong hunk.
+ */
+export function applyEdit(content, operations) {
+    let current = content;
+    let replacements = 0;
+    for (const [index, operation] of operations.entries()) {
+        const result = applyOne(current, operation);
+        if (!result.success) {
+            return {
+                success: false,
+                error: framedError(result.error, index, operations.length),
+            };
+        }
+        current = result.content;
+        replacements += result.replacements;
+    }
+    return { success: true, content: current, replacements };
+}
+function applyOne(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/oldStr not found in file. Make sure the string matches exactly, including whitespace and indentation.',
+        };
+    }
+    if (replacement.replace_all) {
+        const parts = content.split(replacement.oldString);
+        const replacements = parts.length - 1;
+        return {
+            success: true,
+            content: parts.join(replacement.newString),
+            replacements,
+        };
+    }
+    // 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 lineNumber = content.slice(0, firstIndex).split('\n').length;
+        const secondLine = content.slice(0, secondIndex).split('\n').length;
+        return {
+            success: false,
+            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) +
+            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;
+}
+/** The batch framing an operation's own error is reported under. */
+function framedError(error, index, total) {
+    if (total === 1)
+        return error;
+    return `edits[${index}] of ${total}: ${error} Nothing was written — the whole batch is refused, so the file is exactly as it was.`;
+}
+/**
+ * The single door a caller outside this module uses.
+ *
+ * Runs a visible call's arguments through the same normalize-then-apply path
+ * `EditTool.execute` runs at mutation time, against a content string the
+ * caller already has in hand — never the filesystem — and under an
+ * `allowance`: the largest string the caller is willing to have built on its
+ * behalf.
+ *
+ * The allowance is honoured one OPERATION at a time. Each operation's
+ * post-image length is worked out exactly from the content it is about to be
+ * applied to, compared against the allowance, and only then applied — so
+ * nothing over the ceiling is ever materialised, and nothing under it is
+ * refused for a bound that guessed high. An earlier shape predicted the whole
+ * call up front, which meant folding operations after the first against a
+ * string it had never seen: a rename hunk at index 1 was charged one match per
+ * anchor-length window of the file, and batches that would have fitted were
+ * turned away for a number nothing had built.
+ *
+ * `charged` is the longest string this call actually materialised, which is
+ * the one the caller paid for holding. It is the post-image length exactly for
+ * the single-operation shape almost every call has; for a batch it is the
+ * largest intermediate the fold built rather than the body it ends on, because
+ * a batch that grows a file to twenty megabytes and then deletes every
+ * character has still built the twenty megabytes. An operation that is refused
+ * or fails is charged nothing — it built nothing — while the ones before it in
+ * the same batch are charged, having run.
+ */
+export function replayEditCallWithin(content, rawArguments, allowance) {
+    const normalized = normalizeEditInput(rawArguments);
+    // A shape this cannot normalize is one the tool itself would have refused.
+    // Reported as a failure rather than a throw, and charged nothing: no
+    // operation ran, so nothing was built.
+    if (!normalized.success)
+        return { outcome: 'failed', charged: 0, error: normalized.error };
+    return replayOperationsWithin(content, normalized.operations, allowance);
+}
+/**
+ * The same walk, entered with the operations already normalized.
+ *
+ * Separate from the entry point above so the equivalence with {@link applyEdit}
+ * can be exercised operation by operation — `replayOperationsWithin(c, [op], ∞)`
+ * is `applyOne(c, op)` plus its exact predicted length — rather than only in
+ * the aggregate, where a prediction that is wrong in two places by the same
+ * amount would pass.
+ */
+export function replayOperationsWithin(content, operations, allowance) {
+    let current = content;
+    let replacements = 0;
+    // The largest body this call has built so far, which is what it has cost
+    // the caller. Zero until an operation applies: a call refused at its first
+    // operation built nothing and owes nothing.
+    let charged = 0;
+    for (const [index, operation] of operations.entries()) {
+        const predicted = predictOne(current, operation, allowance);
+        if (predicted > allowance)
+            return { outcome: 'refused', charged };
+        const applied = applyOne(current, operation);
+        if (!applied.success) {
+            return {
+                outcome: 'failed',
+                charged,
+                error: framedError(applied.error, index, operations.length),
+            };
+        }
+        current = applied.content;
+        replacements += applied.replacements;
+        charged = Math.max(charged, current.length);
+    }
+    return { outcome: 'replayed', content: current, charged, replacements };
+}
+/**
+ * The exact length `applyOne` would produce, without producing it.
+ *
+ * Exact and not a bound, because the content it is measured against is the
+ * real one the operation is about to be applied to. The one place it stops
+ * short is the occurrence scan for `replace_all`: counting out every match of
+ * a one-character anchor in a large file is itself the work the allowance
+ * exists to avoid, so the scan stops as soon as one more match would carry the
+ * result past `allowance`. The number returned from a stopped scan is a lower
+ * bound on the real length and above the allowance, which is all a refusal
+ * needs.
+ *
+ * Here rather than in the caller because the prediction has to see the same
+ * line-ending reconciliation `applyOne` sees. An `old_string` written with LF
+ * against a CRLF file matches after normalization and not before, and a
+ * predictor blind to that would count zero occurrences for a replacement that
+ * was going to succeed.
+ *
+ * An operation that is not going to apply at all — an anchor that is missing,
+ * or matches twice where one match was required — gets a number that means
+ * nothing, and it is never used for anything but the comparison above: the
+ * apply immediately after this reports the real refusal.
+ */
+function predictOne(content, operation, allowance) {
+    if (operation.operation === 'insert') {
+        // `applyLineInsert` splits the inserted text into lines and joins it back
+        // with the rest, which costs the text itself plus the one separator that
+        // joins it to its neighbour — and a trailing newline in the text is
+        // consumed as that separator rather than added to it.
+        return (content.length + operation.newString.length + (operation.newString.endsWith('\n') ? 0 : 1));
+    }
+    const { oldString, newString, replace_all } = normalizeLineEndings(content, operation);
+    const growth = newString.length - oldString.length;
+    // A single replacement, because `applyOne` refuses a second match. The
+    // clamp is for an anchor longer than the whole content: that operation is
+    // about to fail, and a negative length would be a charge handing the caller
+    // back room it never had.
+    if (!replace_all)
+        return Math.max(content.length + growth, 0);
+    const room = Math.max(allowance - content.length, 0);
+    // One past what fits is already a refusal, so the scan never needs to see
+    // the match after that. A replacement no longer than its anchor cannot grow
+    // the string however often it matches, so there is nothing to stop for.
+    const cap = growth > 0 ? Math.floor(room / growth) + 1 : content.length;
+    return Math.max(content.length + countOccurrences(content, oldString, cap) * growth, 0);
+}
+/** Non-overlapping matches, up to `cap`, counted the way `split` counts them. */
+function countOccurrences(content, needle, cap) {
+    // `split('')` yields one part per character; scanning for it would never
+    // advance. Neither shape reaches here through the tool's schema, which
+    // requires a non-empty `old_string`.
+    if (needle.length === 0)
+        return Math.min(Math.max(content.length - 1, 0), cap);
+    let count = 0;
+    let index = content.indexOf(needle);
+    while (index !== -1 && count < cap) {
+        count += 1;
+        index = content.indexOf(needle, index + needle.length);
+    }
+    return count;
+}
+//# sourceMappingURL=edit-apply.js.map

package/dist/tools/builtins/edit-apply.js.map

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

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

@@ -1,9 +1,150 @@
-export declare const EditTool: import("../../types/tool/index.js").ToolDefinition<{
+import { z } from 'zod';
+/**
+ * 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.
+ */
+declare const inputSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    old_string: z.ZodOptional<z.ZodString>;
+    oldStr: z.ZodOptional<z.ZodString>;
+    new_string: z.ZodOptional<z.ZodString>;
+    newStr: z.ZodOptional<z.ZodString>;
+    insertLine: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+    edits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        old_string: z.ZodString;
+        new_string: z.ZodString;
+        replace_all: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }, {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
     path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
     newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}, {
+    path: string;
     old_string?: string | undefined;
     oldStr?: string | undefined;
     new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}>, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}>, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}>, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}, {
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
+    insertLine?: string | number | undefined;
+    replace_all?: boolean | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean | undefined;
+    }[] | undefined;
+}>;
+export type EditInput = z.infer<typeof inputSchema>;
+export declare const EditTool: import("../../types/tool/index.js").ToolDefinition<{
+    path: string;
+    old_string?: string | undefined;
+    oldStr?: string | undefined;
+    new_string?: string | undefined;
+    newStr?: string | undefined;
     insertLine?: string | number | undefined;
     replace_all?: boolean | undefined;
     edits?: {
@@ -12,4 +153,5 @@ export declare const EditTool: import("../../types/tool/index.js").ToolDefinitio
         replace_all?: boolean | undefined;
     }[] | undefined;
 }>;
+export {};
 //# 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":"AAoQA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;EAoJnB,CAAA"}
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../src/tools/builtins/edit.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Gf,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAkJnD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;EAsJnB,CAAA"}