@myagentroam/agent 0.10.7 → 0.10.8

package/dist/agent-core/session/tool-result-resources.js

@@ -0,0 +1,285 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { MarAgentError } from '../error.js';
+import { parseToolResultExtensions } from '../tools/result-extensions.js';
+const REF = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/u;
+const MAX_BYTES = 16 * 1024 * 1024;
+export async function writeToolResultResource(directory, text) {
+    const bytes = Buffer.from(text);
+    if (bytes.length > MAX_BYTES)
+        throw resourceError('LIMIT', 'Tool result resource exceeds its limit.');
+    const resourceRef = randomUUID();
+    const folder = join(directory, 'tool_results');
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    const temporary = join(folder, `.${resourceRef}.tmp`);
+    await writeFile(join(folder, `.${resourceRef}.pending`), '', {
+        flag: 'wx',
+        mode: 0o600,
+        flush: true
+    });
+    try {
+        await writeFile(temporary, bytes, { flag: 'wx', mode: 0o600, flush: true });
+        await rename(temporary, join(folder, `${resourceRef}.diff`));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return {
+        status: 'available',
+        resourceRef,
+        format: 'unified-diff',
+        byteSize: bytes.length,
+        sha256: createHash('sha256').update(bytes).digest('hex')
+    };
+}
+export function recordToolResources(record) {
+    if (!['tool.completed', 'tool.failed'].includes(record.type))
+        return [];
+    const payload = record.payload;
+    const sources = [
+        payload?.resultExtensions,
+        ...(Array.isArray(payload?.data?.calls)
+            ? payload.data.calls.map((call) => call.resultExtensions)
+            : [])
+    ];
+    return sources.flatMap((source) => (parseToolResultExtensions(source) ?? []).flatMap((extension) => extension.entries.flatMap((entry) => (entry.diff.status === 'available' ? [entry.diff] : []))));
+}
+/** A locator is only a hint: reads must verify its exact committed record identity. */
+export async function bindToolResultResources(directory, record, readRecord, degrade = false) {
+    for (const resource of recordToolResources(record)) {
+        try {
+            await bindToolResultResource(directory, record, resource, readRecord);
+        }
+        catch (error) {
+            if (!degrade)
+                throw error;
+            // Shared descriptors are downgraded before persistence and live publication, never the tool outcome.
+            const payload = record.payload;
+            for (const extensions of [
+                payload.resultExtensions,
+                ...(payload.data?.calls ?? []).map((call) => call.resultExtensions)
+            ]) {
+                for (const extension of extensions ?? [])
+                    for (const entry of extension.entries) {
+                        if (entry.diff.status === 'available' &&
+                            entry.diff.resourceRef === resource.resourceRef)
+                            entry.diff = { status: 'unavailable', reason: 'storage-failed' };
+                    }
+            }
+        }
+    }
+}
+async function bindToolResultResource(directory, record, resource, readRecord) {
+    const path = join(directory, 'tool_results', `${resource.resourceRef}.json`);
+    try {
+        await writeFile(path, JSON.stringify({ sequence: record.sequence, recordId: record.recordId }), { flag: 'wx', mode: 0o600, flush: true });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const info = await handle.stat();
+            if (!info.isFile() || info.size > 1024)
+                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+            const locator = JSON.parse(await handle.readFile('utf8'));
+            const existing = locator.sequence === record.sequence && locator.recordId === record.recordId
+                ? record
+                : Number.isSafeInteger(locator.sequence)
+                    ? await readRecord?.(locator.sequence)
+                    : undefined;
+            if (!existing ||
+                existing.recordId !== locator.recordId ||
+                !recordToolResources(existing).some((entry) => entry.resourceRef === resource.resourceRef && entry.sha256 === resource.sha256))
+                throw resourceError('CORRUPT', 'Tool resource locator conflicts with committed history.');
+        }
+        catch (cause) {
+            throw normalizedResourceError(cause);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+export function toolResultResourceFiles(records) {
+    return new Set(records.flatMap((record) => recordToolResources(record).flatMap((resource) => [
+        `${resource.resourceRef}.diff`,
+        `${resource.resourceRef}.json`
+    ])));
+}
+export async function copyToolResultResources(source, target, records) {
+    const copied = new Set();
+    for (const record of records) {
+        for (const resource of recordToolResources(record)) {
+            if (copied.has(resource.resourceRef))
+                continue;
+            copied.add(resource.resourceRef);
+            try {
+                const bytes = await readResourceBytes(source, resource);
+                const directory = join(target, 'tool_results');
+                await mkdir(directory, { recursive: true, mode: 0o700 });
+                await writeFile(join(directory, `${resource.resourceRef}.diff`), bytes, {
+                    flag: 'wx',
+                    mode: 0o600,
+                    flush: true
+                });
+            }
+            catch (error) {
+                if (error instanceof MarAgentError && error.code === 'MAR_AGENT_TOOL_RESOURCE_NOT_FOUND')
+                    continue;
+                throw error;
+            }
+        }
+        if (recordToolResources(record).length) {
+            await mkdir(join(target, 'tool_results'), { recursive: true, mode: 0o700 });
+            await bindToolResultResources(target, record, async (sequence) => records.find((item) => item.sequence === sequence));
+        }
+    }
+}
+export async function completeToolResultResources(directory, record) {
+    await Promise.all(recordToolResources(record).map((resource) => rm(join(directory, 'tool_results', `.${resource.resourceRef}.pending`), {
+        force: true
+    }).catch(() => undefined)));
+}
+export async function cleanupUnreferencedToolResources(directory, readRecords) {
+    const folder = join(directory, 'tool_results');
+    let names;
+    try {
+        names = await readdir(folder);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    const pending = names.filter((name) => name.startsWith('.') && name.endsWith('.pending') && REF.test(name.slice(1, -8)));
+    if (!pending.length)
+        return;
+    const retained = toolResultResourceFiles(await readRecords());
+    for (const marker of pending) {
+        const ref = marker.slice(1, -8);
+        for (const name of [`${ref}.diff`, `${ref}.json`, `.${ref}.tmp`]) {
+            if (retained.has(name))
+                continue;
+            const path = join(folder, name);
+            try {
+                if ((await lstat(path)).isFile())
+                    await rm(path);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        await rm(join(folder, marker), { force: true });
+    }
+}
+export async function readToolResultResource(directory, sessionId, input, readRecord) {
+    if (!REF.test(input.resourceRef) ||
+        (input.maxBytes !== undefined &&
+            (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 4 || input.maxBytes > 256 * 1024)))
+        throw resourceError('INPUT_INVALID', 'Invalid tool resource request.');
+    let locator;
+    try {
+        const file = join(directory, 'tool_results', `${input.resourceRef}.json`);
+        const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const info = await handle.stat();
+            if (!info.isFile() || info.size > 1024)
+                throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+            locator = JSON.parse(await handle.readFile('utf8'));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        throw normalizedResourceError(error);
+    }
+    if (!Number.isSafeInteger(locator.sequence) ||
+        locator.sequence < 1 ||
+        typeof locator.recordId !== 'string')
+        throw resourceError('CORRUPT', 'Invalid tool resource locator.');
+    const record = await readRecord(locator.sequence);
+    const resource = record?.recordId === locator.recordId
+        ? recordToolResources(record).find((entry) => entry.resourceRef === input.resourceRef)
+        : undefined;
+    if (!resource)
+        throw resourceError('NOT_FOUND', 'Tool resource is not part of this session history.');
+    let offset = 0;
+    if (input.cursor !== undefined) {
+        try {
+            if (input.cursor.length > 1024)
+                throw new Error('cursor');
+            const cursor = JSON.parse(Buffer.from(input.cursor, 'base64url').toString('utf8'));
+            if (cursor.sessionId !== sessionId ||
+                cursor.ref !== resource.resourceRef ||
+                cursor.sha256 !== resource.sha256 ||
+                !Number.isSafeInteger(cursor.offset) ||
+                cursor.offset < 0 ||
+                cursor.offset >= resource.byteSize)
+                throw new Error('cursor');
+            offset = cursor.offset;
+        }
+        catch {
+            throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor.');
+        }
+    }
+    const bytes = await readResourceBytes(directory, resource);
+    if (offset > 0 && (bytes[offset] & 0xc0) === 0x80)
+        throw resourceError('INPUT_INVALID', 'Invalid tool resource cursor boundary.');
+    let end = Math.min(bytes.length, offset + (input.maxBytes ?? 256 * 1024));
+    while (end < bytes.length && (bytes[end] & 0xc0) === 0x80)
+        end--;
+    if ((await readRecord(locator.sequence))?.recordId !== locator.recordId)
+        throw resourceError('NOT_FOUND', 'Tool resource history has changed.');
+    return {
+        type: 'file_changes',
+        version: 1,
+        format: resource.format,
+        resourceRef: resource.resourceRef,
+        byteSize: resource.byteSize,
+        sha256: resource.sha256,
+        content: bytes.subarray(offset, end).toString('utf8'),
+        ...(end < bytes.length
+            ? {
+                nextCursor: Buffer.from(JSON.stringify({
+                    sessionId,
+                    ref: resource.resourceRef,
+                    sha256: resource.sha256,
+                    offset: end
+                })).toString('base64url')
+            }
+            : {})
+    };
+}
+async function readResourceBytes(directory, resource) {
+    try {
+        const handle = await open(join(directory, 'tool_results', `${resource.resourceRef}.diff`), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.size !== resource.byteSize || stat.size > MAX_BYTES)
+                throw resourceError('CORRUPT', 'Tool resource size does not match its history.');
+            const bytes = await handle.readFile();
+            if (createHash('sha256').update(bytes).digest('hex') !== resource.sha256)
+                throw resourceError('CORRUPT', 'Tool resource checksum does not match its history.');
+            return bytes;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        throw normalizedResourceError(error);
+    }
+}
+function resourceError(suffix, message) {
+    return new MarAgentError(`MAR_AGENT_TOOL_RESOURCE_${suffix}`, message);
+}
+function normalizedResourceError(error) {
+    if (error instanceof MarAgentError)
+        return error;
+    return resourceError(error?.code === 'ENOENT' ? 'NOT_FOUND' : 'CORRUPT', 'Tool result resource is unavailable.');
+}

package/dist/agent-core/session/transaction-recovery.js

@@ -92,7 +92,7 @@ export async function recoverSessionStorageTransaction(directory, committedTrans
             await rename(backup, sidecar);
         }
     }
-    for (const folder of ['input_images', 'generated_images']) {
+    for (const folder of ['input_images', 'generated_images', 'tool_results']) {
         const path = join(directory, folder);
         let names;
         try {

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

@@ -4,6 +4,7 @@ import { AGENT_EXECUTION_POLICY } from '../../runtime/execution-policy.js';
 import { allowsToolCaller } from '../callers.js';
 import { boundedModelToolOutput, structuredToolEventData, structuredToolFailureData } from '../output-projection.js';
 import { executeRegisteredTool } from '../runtime.js';
+import { failedToolResultExtensions } from '../result-extensions.js';
 /** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */
 export function createCodeToolDispatch(input) {
     const definitions = new Map(input.tools.map((tool) => [tool.name, tool]));
@@ -33,6 +34,7 @@ export function createCodeToolDispatch(input) {
                 input.assertLive();
                 await input.emit({
                     type: 'tool.completed',
+                    ...(result.resultExtensions ? { resultExtensions: result.resultExtensions } : {}),
                     ...identity,
                     summary,
                     ...(data === undefined ? {} : { data }),
@@ -59,6 +61,9 @@ export function createCodeToolDispatch(input) {
                 const data = structuredToolFailureData(call.name, error);
                 await input.emit({
                     type: 'tool.failed',
+                    ...(failedToolResultExtensions(error)
+                        ? { resultExtensions: failedToolResultExtensions(error) }
+                        : {}),
                     ...identity,
                     code: diagnostic.code,
                     message: diagnostic.message,

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

@@ -16,6 +16,7 @@ import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { createToolCallScheduler } from '../scheduler.js';
 import { detectImageMime } from '../local/view-image.js';
 import { structuredToolFailureData } from '../output-projection.js';
+import { failedToolResultExtensions } from '../result-extensions.js';
 export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
@@ -474,15 +475,17 @@ export class CodeModeTool {
                     try {
                         if (frame.name === 'code_exec' || !available.has(frame.name))
                             throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'The requested nested tool is unavailable.');
-                        const output = await invoke({
+                        const rawOutput = await invoke({
                             name: frame.name,
                             arguments: frame.arguments,
                             callId: source.callId
                         });
+                        const { resultExtensions, ...output } = rawOutput;
                         toolResults.set(operationId, { source, outcome: 'completed', result: output });
                         recordCall({
                             ...source,
                             status: 'completed',
+                            ...(resultExtensions ? { resultExtensions } : {}),
                             result: {
                                 content: '',
                                 truncated: output.truncated === true,
@@ -516,6 +519,9 @@ export class CodeModeTool {
                         recordCall({
                             ...source,
                             status: 'failed',
+                            ...(failedToolResultExtensions(error)
+                                ? { resultExtensions: failedToolResultExtensions(error) }
+                                : {}),
                             error: { code: diagnostic.code, message: diagnostic.message }
                         });
                         toolResults.set(operationId, {

package/dist/agent-core/tools/code-mode/observations.d.ts

@@ -4,6 +4,7 @@ export interface CodeToolCallRecord {
     toolName: string;
     input: unknown;
     status: 'running' | 'completed' | 'failed';
+    resultExtensions?: readonly import('../result-extensions.js').ToolResultExtension[];
     result?: {
         content: string;
         data?: unknown;

package/dist/agent-core/tools/contracts.d.ts

@@ -95,6 +95,8 @@ export interface ToolExecutionResult {
         dataBase64: string;
     }[];
     artifacts?: readonly MarAgentToolArtifact[];
+    /** Host-facing evidence, excluded from model and programmatic guest results. */
+    resultExtensions?: readonly import('./result-extensions.js').ToolResultExtension[];
 }
 export interface CodeCellEventData {
     calls?: readonly import('./code-mode/observations.js').CodeToolCallRecord[];

package/dist/agent-core/tools/execution.js

@@ -5,6 +5,7 @@ import { CodeCellExecutionError } from './code-mode/cells.js';
 import { createCodeToolDispatch } from './code-mode/dispatch.js';
 import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
 import { executeRegisteredTool } from './runtime.js';
+import { failedToolResultExtensions } from './result-extensions.js';
 import { scheduleToolCallBatch } from './scheduler.js';
 /** Shared raw context construction for physical tools and native calls in a real model round. */
 export async function createRoundToolRuntimeContext(scope, call, signal) {
@@ -91,6 +92,7 @@ export async function executeRoundTools(calls, scope) {
             const artifacts = structuredToolArtifacts(output.artifacts);
             await scope.emit({
                 type: 'tool.completed',
+                ...(output.resultExtensions ? { resultExtensions: output.resultExtensions } : {}),
                 toolName: call.name,
                 callId: call.callId,
                 ...(parentCallId === undefined ? {} : { parentCallId }),
@@ -105,7 +107,9 @@ export async function executeRoundTools(calls, scope) {
                 call,
                 output,
                 content: modelOutput.content,
-                ...(output.calls ? { calls: output.calls } : {}),
+                ...(output.calls
+                    ? { calls: output.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
                 ...(output.observations ? { observations: output.observations } : {}),
                 ...(output.images?.length ? { images: output.images } : {}),
                 failed: false
@@ -121,6 +125,9 @@ export async function executeRoundTools(calls, scope) {
                     : structuredToolEventData(call.name, partial.data));
             await scope.emit({
                 type: 'tool.failed',
+                ...(failedToolResultExtensions(error)
+                    ? { resultExtensions: failedToolResultExtensions(error) }
+                    : {}),
                 toolName: call.name,
                 callId: call.callId,
                 ...(parentCallId === undefined ? {} : { parentCallId }),
@@ -140,7 +147,9 @@ export async function executeRoundTools(calls, scope) {
                     : boundedModelToolOutput(call.name, partial.content, partial.data).content,
                 ...(partial?.images?.length ? { images: partial.images } : {}),
                 failed: true,
-                ...(partial?.calls ? { calls: partial.calls } : {}),
+                ...(partial?.calls
+                    ? { calls: partial.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
                 ...(partial?.observations ? { observations: partial.observations } : {}),
                 error
             };

package/dist/agent-core/tools/file-change-diff.d.ts

@@ -0,0 +1,10 @@
+/** Bounded line comparison for immutable, per-operation file evidence. */
+export interface FileDiff {
+    text: string;
+    additions: number;
+    deletions: number;
+}
+export declare const MAX_FILE_DIFF_BYTES: number;
+export declare class FileDiffLimitError extends Error {
+}
+export declare function createFileDiff(path: string, before?: Buffer, after?: Buffer): FileDiff | undefined;

package/dist/agent-core/tools/file-change-diff.js

@@ -0,0 +1,139 @@
+const MAX_WORK = 2_000_000;
+export const MAX_FILE_DIFF_BYTES = 16 * 1024 * 1024;
+export class FileDiffLimitError extends Error {
+}
+export function createFileDiff(path, before, after) {
+    let oldText;
+    let newText;
+    try {
+        const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+        oldText = decoder.decode(before ?? Buffer.alloc(0));
+        newText = decoder.decode(after ?? Buffer.alloc(0));
+    }
+    catch {
+        return undefined;
+    }
+    if (oldText.includes('\0') || newText.includes('\0'))
+        return undefined;
+    const lines = (value) => value.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+    const a = lines(oldText);
+    const b = lines(newText);
+    if (a.length + b.length > 200_000)
+        throw new FileDiffLimitError();
+    const edits = compare(a, b);
+    if (!edits)
+        throw new FileDiffLimitError();
+    const output = [
+        `--- ${before === undefined ? '/dev/null' : JSON.stringify(`a/${path}`)}`,
+        `+++ ${after === undefined ? '/dev/null' : JSON.stringify(`b/${path}`)}`
+    ];
+    const positions = [];
+    const ranges = [];
+    let old = 1;
+    let next = 1;
+    let additions = 0;
+    let deletions = 0;
+    edits.forEach((edit, index) => {
+        positions.push({ old, next });
+        if (edit.kind !== '+')
+            old++;
+        if (edit.kind !== '-')
+            next++;
+        if (edit.kind === '+')
+            additions++;
+        if (edit.kind === '-')
+            deletions++;
+        if (edit.kind === ' ')
+            return;
+        const start = Math.max(0, index - 3);
+        const end = Math.min(edits.length, index + 4);
+        const last = ranges.at(-1);
+        if (last && start <= last.end)
+            last.end = end;
+        else
+            ranges.push({ start, end });
+    });
+    for (const range of ranges) {
+        const block = edits.slice(range.start, range.end);
+        const oldCount = block.filter((edit) => edit.kind !== '+').length;
+        const newCount = block.filter((edit) => edit.kind !== '-').length;
+        const position = positions[range.start];
+        output.push(`@@ -${position.old - (oldCount === 0 ? 1 : 0)},${oldCount} +${position.next - (newCount === 0 ? 1 : 0)},${newCount} @@`);
+        for (const edit of block) {
+            output.push(`${edit.kind}${edit.text.endsWith('\n') ? edit.text.slice(0, -1) : edit.text}`);
+            if (!edit.text.endsWith('\n'))
+                output.push('\');
+        }
+    }
+    const text = `${output.join('\n')}\n`;
+    if (Buffer.byteLength(text) > MAX_FILE_DIFF_BYTES)
+        throw new FileDiffLimitError();
+    return { text, additions, deletions };
+}
+function compare(a, b) {
+    let prefix = 0;
+    while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < a.length - prefix &&
+        suffix < b.length - prefix &&
+        a[a.length - suffix - 1] === b[b.length - suffix - 1])
+        suffix++;
+    const left = a.slice(prefix, a.length - suffix);
+    const right = b.slice(prefix, b.length - suffix);
+    if (!left.length || !right.length)
+        return [
+            ...a.slice(0, prefix).map((text) => ({ kind: ' ', text })),
+            ...left.map((text) => ({ kind: '-', text })),
+            ...right.map((text) => ({ kind: '+', text })),
+            ...a.slice(a.length - suffix).map((text) => ({ kind: ' ', text }))
+        ];
+    const trace = [];
+    const frontier = new Map([[1, 0]]);
+    let work = 0;
+    for (let distance = 0; distance <= left.length + right.length; distance++) {
+        trace.push(new Map(frontier));
+        for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+            if (++work > MAX_WORK)
+                return undefined;
+            const down = diagonal === -distance ||
+                (diagonal !== distance &&
+                    (frontier.get(diagonal - 1) ?? -1) < (frontier.get(diagonal + 1) ?? -1));
+            let x = down ? (frontier.get(diagonal + 1) ?? 0) : (frontier.get(diagonal - 1) ?? 0) + 1;
+            let y = x - diagonal;
+            while (x < left.length && y < right.length && left[x] === right[y]) {
+                if (++work > MAX_WORK)
+                    return undefined;
+                x++;
+                y++;
+            }
+            frontier.set(diagonal, x);
+            if (x < left.length || y < right.length)
+                continue;
+            const reversed = [];
+            for (let d = distance; d >= 0; d--) {
+                const previous = trace[d];
+                const k = x - y;
+                const previousK = k === -d || (k !== d && (previous.get(k - 1) ?? -1) < (previous.get(k + 1) ?? -1))
+                    ? k + 1
+                    : k - 1;
+                const previousX = previous.get(previousK) ?? 0;
+                const previousY = previousX - previousK;
+                while (x > previousX && y > previousY)
+                    (reversed.push({ kind: ' ', text: left[--x] }), y--);
+                if (d === 0)
+                    break;
+                if (x === previousX)
+                    reversed.push({ kind: '+', text: right[--y] });
+                else
+                    reversed.push({ kind: '-', text: left[--x] });
+            }
+            return [
+                ...a.slice(0, prefix).map((text) => ({ kind: ' ', text })),
+                ...reversed.reverse(),
+                ...a.slice(a.length - suffix).map((text) => ({ kind: ' ', text }))
+            ];
+        }
+    }
+    return undefined;
+}

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

@@ -4,6 +4,7 @@ import { dirname, isAbsolute, 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';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
@@ -70,6 +71,9 @@ export class ApplyPatchTool {
     }
     async execute(patch) {
         const changes = parsePatch(patch);
+        reserveFileChangePaths(changes.flatMap((change) => change.kind === 'update' && change.targetPath
+            ? [change.path, change.targetPath]
+            : [change.path]));
         const resolvedChanges = await this.#resolveChanges(changes);
         const results = [];
         let totalBytes = 0;
@@ -149,7 +153,7 @@ export class ApplyPatchTool {
             const targetStat = await optionalLstat(resolvedChange.target);
             if (targetStat && !targetStat.isFile())
                 invalid('Patch targets must be regular files.');
-            const content = Buffer.from(`${change.lines.join('\n')}\n`);
+            const content = Buffer.from(change.lines.length ? `${change.lines.join('\n')}\n` : '');
             const totalBytes = enforceContentLimits(content, currentTotalBytes);
             return {
                 mutations: [
@@ -158,7 +162,8 @@ export class ApplyPatchTool {
                         target: resolvedChange.target,
                         content,
                         ...(targetStat ? { mode: targetStat.mode & 0o7777 } : {}),
-                        expectedExisting: targetStat !== undefined
+                        expectedExisting: targetStat !== undefined,
+                        ...(targetStat ? { original: await readBoundedFile(resolvedChange.target) } : {})
                     }
                 ],
                 result: {
@@ -178,7 +183,9 @@ export class ApplyPatchTool {
         if (resolvedChange.kind === 'delete') {
             const { change } = resolvedChange;
             return {
-                mutations: [{ path: change.path, target: resolvedChange.source, expectedExisting: true }],
+                mutations: [
+                    { path: change.path, target: resolvedChange.source, expectedExisting: true, original }
+                ],
                 result: {
                     path: change.path,
                     operation: 'deleted',
@@ -204,13 +211,14 @@ export class ApplyPatchTool {
                 invalid('Patch targets must be regular files.');
             return {
                 mutations: [
-                    { path: change.path, target: resolvedChange.source, expectedExisting: true },
+                    { path: change.path, target: resolvedChange.source, expectedExisting: true, original },
                     {
                         path: moveChange.targetPath,
                         target: resolvedChange.target,
                         content,
                         mode: (targetStat ?? sourceStat).mode & 0o7777,
-                        expectedExisting: targetStat !== undefined
+                        expectedExisting: targetStat !== undefined,
+                        ...(targetStat ? { original: await readBoundedFile(resolvedChange.target) } : {})
                     }
                 ],
                 result: {
@@ -230,7 +238,8 @@ export class ApplyPatchTool {
                     target: resolvedChange.source,
                     content,
                     mode: sourceStat.mode & 0o7777,
-                    expectedExisting: true
+                    expectedExisting: true,
+                    original
                 }
             ],
             result: {
@@ -267,6 +276,8 @@ export class ApplyPatchTool {
                 const backup = `${mutation.target}.mar-patch-${randomUUID()}.bak`;
                 await this.#fileOperations.rename(mutation.target, backup);
                 backups.push({ target: mutation.target, backup });
+                if (mutation.original && !(await readBoundedFile(backup)).equals(mutation.original))
+                    throw new MarAgentError('MAR_AGENT_PATCH_CONFLICT', 'A patch target changed after preflight.');
             }
             for (const item of staged) {
                 await this.#fileOperations.rename(item.temporary, item.target);
@@ -291,6 +302,8 @@ export class ApplyPatchTool {
             throw error;
         }
         await Promise.all(backups.map((item) => this.#fileOperations.rm(item.backup, { force: true })));
+        for (const mutation of mutations)
+            await captureFileChange(mutation.path, mutation.original, mutation.content);
     }
 }
 function parsePatch(patch) {
@@ -331,8 +344,6 @@ function parsePatch(patch) {
                     invalid('Added file lines must start with +.');
                 content.push(line.slice(1));
             }
-            if (!content.length)
-                invalid('Added files must contain at least one patch line.');
             changes.push({ kind: 'add', path, lines: content });
         }
         else if (header.startsWith('*** Delete File: ')) {