@myagentroam/agent 0.10.17 → 0.10.19

package/dist/agent-core/tools/code-mode/index.js

@@ -27,10 +27,11 @@ export const codeModeToolDefinition = {
 - Single-tool cells are valid. Keep loops and retries bounded, and do not blindly replay operations with side effects.
 - Evaluates source in a fresh restricted ECMAScript runtime with top-level await and Promise.all. It is not Node.js or a browser. JavaScript globals do not survive between cells; bounded JSON state is available through state.
 - Accepts JavaScript source text. When exposed as a freeform tool, send the source directly; when exposed with a JSON input schema, put the source in its code field. Do not add another JSON wrapper, quoted string, or markdown code fence inside the source.
+- Keep embedded commands, patches and source in JSON-escaped double-quoted strings when they contain backticks or literal \${...}; JavaScript template literals would interpolate them before the tool runs. Do not paste Python literals such as None into JavaScript expressions.
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.
 
 Tool calls:
-- tools.NAME(input) returns a Promise. Use the existing tool input schema; freeform tools such as apply_patch accept a raw string, not a JSON wrapper.
+- tools.NAME(input) returns a Promise. Use the existing tool input schema; freeform tools such as apply_patch accept a raw string, not a JSON wrapper. For parameterless tools prefer tools.NAME({}); tools.NAME() is accepted only for explicitly closed empty-object schemas.
 - Results use the MAR envelope: { content?: string, data?: unknown, images?: Array<{mimeType:string,dataBase64:string}>, truncated?: boolean }. Redundant JSON content is omitted when it exactly renders data; independent text remains in content. Prefer data for programmatic results: result.data.results[0].text for read source text and result.data.exitCode/result.data.stdout for exec. content, when present, is rendered text, not raw file bytes. Use only fields documented by that tool; do not invent success or ok flags.
 - Tool errors reject with code/message and may be caught. A failed cell preserves already emitted output alongside its status and error; completed tool effects are not rolled back. Inspect it before retrying completed work. Await every call; unawaited calls fail the cell. Use Promise.all for independent calls and sequential await for dependencies. Runtime preserves safe/serial barriers and Host checks.
 - skill, tool_search, question, code_exec, code_exec_wait and direct-only tools cannot be called here. Load Skills directly and read their instructions before the next tool call. Use direct tool_search before a later code cell for deferred tools; the current cell's tools do not change.

package/dist/agent-core/tools/code-mode/quickjs-engine.js

@@ -224,10 +224,13 @@ export async function createCodeModeEngine(options) {
                     return guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state is too large.');
             };
             const tools = vm.newObject();
+            const parameterlessTools = new Set(input.catalog.filter(isParameterlessTool).map((tool) => tool.name));
             let toolCallSequence = 0;
             for (const name of input.tools) {
                 method(tools, name, (args = vm.undefined) => {
-                    const parsed = jsonValue(args, true);
+                    const parsed = vm.typeof(args) === 'undefined' && parameterlessTools.has(name)
+                        ? { value: {} }
+                        : jsonValue(args, true);
                     if (parsed.error)
                         return parsed;
                     const operationId = ++toolCallSequence;
@@ -704,19 +707,64 @@ function compilerSourceLocation(error, source) {
     const lines = source.split('\n');
     const line = error.lineNumber - 1;
     if (line > lines.length)
-        return ` (code-mode.js:${source.split(/\r\n|[\r\n\u2028\u2029]/u).length}, end of input)`;
+        return compilerCaret(source, source, true);
     const column = Number(typeof error.stack === 'string'
         ? error.stack.match(/^\s*at code-mode\.js:\d+:(\d+)(?:\n|$)/u)?.[1]
         : undefined);
-    if (!Number.isSafeInteger(column) || column < 1)
-        return '';
+    if (!Number.isSafeInteger(column) ||
+        column < 1 ||
+        column > Array.from(lines[line - 1]).length + 1) {
+        // Without a valid column, intra-LF-line separators make the original source line ambiguous.
+        if (/[\r\u2028\u2029]/u.test(lines[line - 1].replace(/\r$/u, '')))
+            return '';
+        const preceding = line > 1 ? lines.slice(0, line - 1).join('\n') + '\n' : '';
+        return ` (code-mode.js:${preceding.split(/\r\n|[\r\n\u2028\u2029]/u).length})`;
+    }
     const prefix = [
         ...lines.slice(0, line - 1),
         Array.from(lines[line - 1])
             .slice(0, column - 1)
             .join('')
     ].join('\n');
-    return ` (code-mode.js:${prefix.split(/\r\n|[\r\n\u2028\u2029]/u).length})`;
+    return compilerCaret(source, prefix);
+}
+function compilerCaret(source, prefix, endOfInput = false) {
+    const segments = prefix.split(/\r\n|[\r\n\u2028\u2029]/u);
+    const line = segments.length;
+    const column = Array.from(segments.at(-1)).length + 1;
+    const character = source.slice(prefix.length)[Symbol.iterator]().next().value;
+    // Source may contain credentials, commands or private code. Show only a punctuation token.
+    const token = endOfInput
+        ? '<end of input>'
+        : character === undefined || /[\r\n\u2028\u2029]/u.test(character)
+            ? '<end of line>'
+            : /^[{}[\]():;,.=+*/?!<>|&%\-]$/u.test(character)
+                ? character
+                : '<character omitted>';
+    const preview = '<source omitted>';
+    return ` (code-mode.js:${line}${endOfInput ? ', end of input' : ''})\nSyntax location: line ${line}, column ${column}\n${line} | ${preview}${token}\n${' '.repeat(String(line).length)} | ${' '.repeat(preview.length)}^`;
+}
+function isParameterlessTool(tool) {
+    const schema = tool.inputSchema;
+    return (tool.inputMode === 'json' &&
+        schema?.type === 'object' &&
+        schema.additionalProperties === false &&
+        schema.properties !== null &&
+        typeof schema.properties === 'object' &&
+        !Array.isArray(schema.properties) &&
+        Object.keys(schema.properties).length === 0 &&
+        (schema.required === undefined ||
+            (Array.isArray(schema.required) && schema.required.length === 0)) &&
+        Object.keys(schema).every((key) => [
+            'type',
+            'properties',
+            'additionalProperties',
+            'required',
+            'title',
+            'description',
+            '$schema',
+            '$comment'
+        ].includes(key)));
 }
 function diagnostic(code, message) {
     return Object.assign(new Error(message), { code });

package/dist/agent-core/tools/local/apply-patch-parser.d.ts

@@ -0,0 +1,25 @@
+export type PatchHunk = {
+    changeContext?: string;
+    oldLines: string[];
+    patchLines: Array<{
+        kind: 'context' | 'addition' | 'deletion';
+        value: string;
+    }>;
+    addedLines: number;
+    deletedLines: number;
+    anchor: boolean;
+};
+export type PatchChange = {
+    kind: 'add';
+    path: string;
+    lines: string[];
+} | {
+    kind: 'delete';
+    path: string;
+} | {
+    kind: 'update';
+    path: string;
+    targetPath?: string;
+    hunks: PatchHunk[];
+};
+export declare function parsePatch(patch: string): PatchChange[];

package/dist/agent-core/tools/local/apply-patch-parser.js

@@ -0,0 +1,228 @@
+import { isAbsolute, resolve } from 'node:path';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+const beginMarker = '*** Begin Patch';
+const endMarker = '*** End Patch';
+const addHeader = '*** Add File: ';
+const updateHeader = '*** Update File: ';
+const deleteHeader = '*** Delete File: ';
+const moveHeader = '*** Move to: ';
+const syntaxTokens = [
+    `${beginMarker} ***`,
+    `${endMarker} ***`,
+    addHeader,
+    updateHeader,
+    deleteHeader,
+    moveHeader,
+    '@@ ',
+    '+',
+    '-',
+    ' '
+];
+export function parsePatch(patch) {
+    if (typeof patch !== 'string')
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Patch must be a string.');
+    if (Buffer.byteLength(patch) > TOOL_EXECUTION_LIMITS.patchMaxBytes)
+        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the input byte limit.');
+    return new FreeformPatchParser(patch).parse();
+}
+class FreeformPatchParser {
+    #lines;
+    #lineOffsets = [];
+    #claimed = new Set();
+    #index = 1;
+    constructor(patch) {
+        const sourceLines = patch.split('\n');
+        let offset = 0;
+        this.#lines = sourceLines.map((line, index) => {
+            this.#lineOffsets.push(offset);
+            offset += line.length + 1;
+            return index < sourceLines.length - 1 && line.endsWith('\r') ? line.slice(0, -1) : line;
+        });
+        if (patch.endsWith('\n'))
+            this.#lines.pop();
+    }
+    parse() {
+        for (const [index, line] of this.#lines.entries()) {
+            const column = line.indexOf('\r');
+            if (column !== -1)
+                this.#fail('Patch contains unsupported bare carriage returns.', index, column);
+        }
+        this.#marker(0, beginMarker, 'first');
+        this.#marker(this.#lines.length - 1, endMarker, 'last');
+        if (this.#lines.length < 3)
+            this.#fail('Patch must contain at least one operation.', 1);
+        const changes = [];
+        while (this.#index < this.#lines.length - 1) {
+            const headerIndex = this.#index++;
+            const header = this.#lines[headerIndex];
+            if (header.startsWith(addHeader)) {
+                const path = this.#path(headerIndex, addHeader);
+                const lines = [];
+                while (this.#hasBodyLine()) {
+                    const index = this.#index++;
+                    const line = this.#lines[index];
+                    if (!line.startsWith('+'))
+                        this.#fail('Added file lines must start with +.', index);
+                    lines.push(line.slice(1));
+                }
+                changes.push({ kind: 'add', path, lines });
+            }
+            else if (header.startsWith(deleteHeader)) {
+                changes.push({ kind: 'delete', path: this.#path(headerIndex, deleteHeader) });
+            }
+            else if (header.startsWith(updateHeader)) {
+                const path = this.#path(headerIndex, updateHeader);
+                let targetPath;
+                if (this.#lines[this.#index]?.startsWith(moveHeader)) {
+                    targetPath = this.#path(this.#index++, moveHeader);
+                }
+                const hunks = [];
+                while (this.#index < this.#lines.length - 1 && this.#lines[this.#index].startsWith('@@'))
+                    hunks.push(this.#hunk());
+                if (!hunks.length && !targetPath)
+                    this.#fail('Update operations must contain hunks or move a file.', headerIndex);
+                changes.push({ kind: 'update', path, ...(targetPath ? { targetPath } : {}), hunks });
+            }
+            else {
+                this.#fail("Expected an operation header: '*** Add File: <path>', '*** Update File: <path>', or '*** Delete File: <path>'.", headerIndex, Math.max(...[addHeader, updateHeader, deleteHeader].map((prefix) => commonPrefixLength(header, prefix))));
+            }
+            if (changes.length > TOOL_EXECUTION_LIMITS.patchMaxFiles)
+                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the file limit.');
+        }
+        if (!changes.some((change) => change.kind !== 'update' || change.targetPath || change.hunks.some((hunk) => !hunk.anchor)))
+            this.#fail('Patch must change or move at least one file. No additions, deletions, or moves were supplied; context-only hunks only validate existing lines. Use read to inspect a file, or supply -old/+new lines to edit it.', 1);
+        return changes;
+    }
+    #marker(index, marker, position) {
+        const line = this.#lines[index];
+        const trimmed = line.trim();
+        if (trimmed === marker || trimmed === `${marker} ***`)
+            return;
+        const leading = line.length - line.trimStart().length;
+        const expected = trimmed.startsWith(`${marker} ***`) ? `${marker} ***` : marker;
+        this.#fail(`Expected ${position} line to be '${marker}' (optional trailing ' ***').`, index, leading + commonPrefixLength(trimmed, expected));
+    }
+    #path(index, prefix) {
+        const path = this.#lines[index].slice(prefix.length);
+        if (!path || path.trim() !== path) {
+            const column = path.trimStart() !== path ? prefix.length : prefix.length + path.trimEnd().length;
+            this.#fail('Patch paths must be non-empty and unpadded.', index, column);
+        }
+        const key = isAbsolute(path) ? resolve(path) : resolve('/', path);
+        if (this.#claimed.has(key))
+            this.#fail('Patch contains duplicate or overlapping paths.', index, prefix.length);
+        this.#claimed.add(key);
+        return path;
+    }
+    #hasBodyLine() {
+        return this.#index < this.#lines.length - 1 && !this.#lines[this.#index].startsWith('*** ');
+    }
+    #hunk() {
+        const index = this.#index++;
+        const header = this.#lines[index];
+        let changeContext;
+        if (header !== '@@') {
+            if (!header.startsWith('@@ '))
+                this.#fail('Patch change context headers must use @@ or @@ <context>.', index, 2);
+            changeContext = header.slice(3);
+            if (!changeContext.trim())
+                this.#fail('Patch change context must be non-empty.', index, 3);
+        }
+        const oldLines = [];
+        const patchLines = [];
+        let addedLines = 0;
+        let deletedLines = 0;
+        while (this.#hasBodyLine() && !this.#lines[this.#index].startsWith('@@')) {
+            const lineIndex = this.#index++;
+            const line = this.#lines[lineIndex];
+            const value = line.slice(1);
+            if (line.startsWith(' ')) {
+                oldLines.push(value);
+                patchLines.push({ kind: 'context', value });
+            }
+            else if (line.startsWith('+')) {
+                patchLines.push({ kind: 'addition', value });
+                addedLines++;
+            }
+            else if (line.startsWith('-')) {
+                oldLines.push(value);
+                patchLines.push({ kind: 'deletion', value });
+                deletedLines++;
+            }
+            else
+                this.#fail('Patch hunk lines must start with space, +, or -.', lineIndex);
+        }
+        if (!oldLines.length)
+            this.#fail('Insertion hunks require context.', index);
+        return {
+            ...(changeContext === undefined ? {} : { changeContext }),
+            oldLines,
+            patchLines,
+            addedLines,
+            deletedLines,
+            anchor: !addedLines && !deletedLines
+        };
+    }
+    #fail(message, index, characterOffset = 0) {
+        const source = this.#lines[index];
+        const line = index + 1;
+        const column = characterCount(source.slice(0, characterOffset)) + 1;
+        const offset = this.#lineOffsets[index] + characterOffset;
+        const preview = syntaxPreview(source, characterOffset);
+        const gutter = String(line);
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', `Patch syntax error at line ${line}, column ${column}: ${message}\n${gutter} | ${preview.text}\n${' '.repeat(gutter.length)} | ${' '.repeat(preview.caret)}^`, { details: { line, column, offset } });
+    }
+}
+function commonPrefixLength(actual, expected) {
+    let index = 0;
+    while (index < actual.length && index < expected.length && actual[index] === expected[index])
+        index++;
+    return index;
+}
+function characterCount(value) {
+    let count = 0;
+    for (const _character of value)
+        count++;
+    return count;
+}
+function syntaxPreview(source, characterOffset) {
+    // Only grammar tokens and one offending character are public; paths and file bodies are not.
+    const trimmed = source.trimStart();
+    const leading = source.length - trimmed.length;
+    const tokenLength = Math.max(...syntaxTokens.map((token) => commonPrefixLength(trimmed, token)));
+    const token = trimmed.slice(0, tokenLength);
+    if (characterOffset < leading) {
+        const before = characterOffset > 40 ? '… ' : displaySyntax(source.slice(0, characterOffset));
+        return {
+            text: `${before}${displayCharacter(source[characterOffset])}<content omitted>`,
+            caret: before.length
+        };
+    }
+    const prefix = leading > 40 ? '… ' : displaySyntax(source.slice(0, leading));
+    const syntaxEnd = leading + tokenLength;
+    if (characterOffset < syntaxEnd) {
+        return {
+            text: `${prefix}${token}${source.length > syntaxEnd ? '<content omitted>' : ''}`,
+            caret: prefix.length + characterOffset - leading
+        };
+    }
+    const gap = characterOffset > syntaxEnd ? '<content omitted>' : '';
+    const character = source.slice(characterOffset)[Symbol.iterator]().next().value;
+    const before = `${prefix}${token}${gap}`;
+    return {
+        text: `${before}${character === undefined ? '<end of line>' : displayCharacter(character)}${character !== undefined && source.length > characterOffset + character.length ? '<content omitted>' : ''}`,
+        caret: before.length
+    };
+}
+function displayCharacter(character) {
+    const point = character.codePointAt(0);
+    if (point >= 0x7f)
+        return `\\u{${point.toString(16)}}`;
+    return JSON.stringify(character).slice(1, -1);
+}
+function displaySyntax(value) {
+    return [...value]
+        .map((character) => (character === '\t' ? '    ' : displayCharacter(character)))
+        .join('');
+}

package/dist/agent-core/tools/local/apply-patch.js

@@ -1,15 +1,16 @@
 import { randomUUID } from 'node:crypto';
 import { chmod, lstat, mkdir, readFile, rename, rm, rmdir, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, parse, resolve } from 'node:path';
+import { dirname, parse, resolve } from 'node:path';
 import { TextDecoder } from 'node:util';
 import { MarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 import { captureFileChange, reserveFileChangePaths } from '../result-extensions.js';
+import { parsePatch } from './apply-patch-parser.js';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch, each marker on its own line. Surrounding marker whitespace and an optional trailing *** are accepted; incomplete markers or extra text are rejected. Add File content lines, including blank lines, must start with +. Syntax errors include line/column and a bounded caret diagnostic with file content omitted. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
         type: 'object',
@@ -306,121 +307,6 @@ export class ApplyPatchTool {
             await captureFileChange(mutation.path, mutation.original, mutation.content);
     }
 }
-function parsePatch(patch) {
-    if (typeof patch !== 'string')
-        invalid('Patch must be a string.');
-    if (Buffer.byteLength(patch) > TOOL_EXECUTION_LIMITS.patchMaxBytes)
-        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the input byte limit.');
-    const normalized = patch.replaceAll('\r\n', '\n');
-    if (normalized.includes('\r'))
-        invalid('Patch contains unsupported bare carriage returns.');
-    const value = normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
-    if (!value.startsWith('*** Begin Patch\n') || !value.endsWith('\n*** End Patch'))
-        invalid('Patch envelope is invalid.');
-    const body = value.slice('*** Begin Patch\n'.length, -'\n*** End Patch'.length);
-    if (!body)
-        invalid('Patch must contain at least one operation.');
-    const lines = body.split('\n');
-    const changes = [];
-    const claimed = new Set();
-    let index = 0;
-    const claim = (path) => {
-        if (!path || path.trim() !== path)
-            invalid('Patch paths must be non-empty and unpadded.');
-        const key = isAbsolute(path) ? resolve(path) : resolve('/', path);
-        if (claimed.has(key))
-            invalid('Patch contains duplicate or overlapping paths.');
-        claimed.add(key);
-    };
-    while (index < lines.length) {
-        const header = lines[index++];
-        if (header.startsWith('*** Add File: ')) {
-            const path = header.slice('*** Add File: '.length);
-            claim(path);
-            const content = [];
-            while (index < lines.length && !lines[index].startsWith('*** ')) {
-                const line = lines[index++];
-                if (!line.startsWith('+'))
-                    invalid('Added file lines must start with +.');
-                content.push(line.slice(1));
-            }
-            changes.push({ kind: 'add', path, lines: content });
-        }
-        else if (header.startsWith('*** Delete File: ')) {
-            const path = header.slice('*** Delete File: '.length);
-            claim(path);
-            changes.push({ kind: 'delete', path });
-        }
-        else if (header.startsWith('*** Update File: ')) {
-            const path = header.slice('*** Update File: '.length);
-            claim(path);
-            let targetPath;
-            if (lines[index]?.startsWith('*** Move to: ')) {
-                targetPath = lines[index++].slice('*** Move to: '.length);
-                claim(targetPath);
-            }
-            const hunks = [];
-            while (index < lines.length && lines[index].startsWith('@@')) {
-                const hunkHeader = lines[index++];
-                let changeContext;
-                if (hunkHeader !== '@@') {
-                    if (!hunkHeader.startsWith('@@ '))
-                        invalid('Patch change context headers must use @@ or @@ <context>.');
-                    changeContext = hunkHeader.slice(3);
-                    if (!changeContext.trim())
-                        invalid('Patch change context must be non-empty.');
-                }
-                const oldLines = [];
-                const patchLines = [];
-                let addedLines = 0;
-                let deletedLines = 0;
-                while (index < lines.length &&
-                    !lines[index].startsWith('@@') &&
-                    !lines[index].startsWith('*** ')) {
-                    const line = lines[index++];
-                    if (line.startsWith(' ')) {
-                        const value = line.slice(1);
-                        oldLines.push(value);
-                        patchLines.push({ kind: 'context', value });
-                    }
-                    else if (line.startsWith('+')) {
-                        const value = line.slice(1);
-                        patchLines.push({ kind: 'addition', value });
-                        addedLines++;
-                    }
-                    else if (line.startsWith('-')) {
-                        const value = line.slice(1);
-                        oldLines.push(value);
-                        patchLines.push({ kind: 'deletion', value });
-                        deletedLines++;
-                    }
-                    else
-                        invalid('Patch hunk lines must start with space, +, or -.');
-                }
-                if (!oldLines.length)
-                    invalid('Insertion hunks require context.');
-                hunks.push({
-                    ...(changeContext === undefined ? {} : { changeContext }),
-                    oldLines,
-                    patchLines,
-                    addedLines,
-                    deletedLines,
-                    anchor: !addedLines && !deletedLines
-                });
-            }
-            if (!hunks.length && !targetPath)
-                invalid('Update operations must contain hunks or move a file.');
-            changes.push({ kind: 'update', path, ...(targetPath ? { targetPath } : {}), hunks });
-        }
-        else
-            invalid('Patch operation is unsupported.');
-        if (changes.length > TOOL_EXECUTION_LIMITS.patchMaxFiles)
-            throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the file limit.');
-    }
-    if (!changes.some((change) => change.kind !== 'update' || change.targetPath || change.hunks.some((hunk) => !hunk.anchor)))
-        invalid('Patch must change or move at least one file.');
-    return changes;
-}
 function applyHunks(original, hunks, path) {
     let text;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.10.17",
+  "version": "0.10.19",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",