@myagentroam/agent 0.11.33 → 0.11.34

package/dist/agent-core/tools/execution-limits.d.ts

@@ -1,69 +0,0 @@
-export declare const TOOL_EXECUTION_LIMITS: Readonly<{
-    readDefaultLines: 200;
-    readMaxLines: 2000;
-    readMaxBytes: 1048576;
-    readMaxBatchItems: 16;
-    readBatchConcurrency: 4;
-    readMaxBatchBytes: 4194304;
-    viewImageMaxBytes: 3145728;
-    viewImageMaxSourceBytes: 20971520;
-    viewImageMaxPixels: 16777216;
-    execMaxTimeoutMs: 3600000;
-    execDefaultYieldMs: 10000;
-    execMaxYieldMs: 30000;
-    execMaxPollYieldMs: 300000;
-    execTerminationGraceMs: 1000;
-    execDefaultMaxOutputBytes: 1000000;
-    execProgressMaxOutputBytes: 8192;
-    execProgressIntervalMs: 100;
-    maxProcesses: 64;
-    execMaxCompletedResults: 16;
-    execCompletedRetentionMs: 300000;
-    codeMaxInputBytes: 1048576;
-    codeMaxOutputBytes: 1048576;
-    codeMaxFrameBytes: 33554432;
-    codeMaxTransportBytes: 67108864;
-    codeMaxCalls: 128;
-    codeMaxConcurrentCells: 64;
-    codeDefaultYieldMs: 30000;
-    codeDefaultWaitYieldMs: 10000;
-    codeMaxYieldMs: 30000;
-    codeMaxWaitYieldMs: 300000;
-    codeMaxOutputTokens: 10000;
-    codeCompletedRetentionMs: 600000;
-    codeMaxCompletedResults: 32;
-    codeStateMaxEntries: 128;
-    codeStateMaxMutations: 128;
-    codeStateMaxKeyBytes: 256;
-    codeStateMaxValueBytes: 65536;
-    codeStateMaxTotalBytes: 1048576;
-    codeSleepMaxMs: 30000;
-    codeHeapMegabytes: 128;
-    codeMemoryBytes: 33554432;
-    codeStackBytes: 524288;
-    codeTimeoutMs: 120000;
-    patchMaxBytes: 4194304;
-    patchMaxFiles: 100;
-    patchMaxFileBytes: 8388608;
-    patchMaxTotalBytes: 33554432;
-    agentWaitMinWaitMs: 0;
-    agentWaitWaitFloorMs: 10000;
-    agentWaitDefaultWaitMs: 30000;
-    agentWaitMaxWaitMs: 300000;
-    agentWaitMaxAgents: 8;
-    sleepMaxDurationMs: 1800000;
-    subagentDescriptionMaxCharacters: 80;
-    subagentPromptMaxBytes: 131072;
-    subagentMessageMaxBytes: 131072;
-    subagentReasoningEffortMaxCharacters: 64;
-    subagentSummaryMaxBytes: 16384;
-    subagentUpdateMaxBytes: 32768;
-    subagentRunningLatestMessageMaxCharacters: 2000;
-    subagentEvidenceMaxItems: 64;
-    subagentVerificationMaxItems: 16;
-    subagentChangedFilesMaxItems: 200;
-    questionMaxTextCharacters: 1000;
-    questionMaxOptionCharacters: 500;
-    todoMaxItems: 100;
-    todoMaxTextCharacters: 1000;
-}>;

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

@@ -1,69 +0,0 @@
-export const TOOL_EXECUTION_LIMITS = Object.freeze({
-    readDefaultLines: 200,
-    readMaxLines: 2_000,
-    readMaxBytes: 1_048_576,
-    readMaxBatchItems: 16,
-    readBatchConcurrency: 4,
-    readMaxBatchBytes: 4_194_304,
-    viewImageMaxBytes: 3_145_728,
-    viewImageMaxSourceBytes: 20_971_520,
-    viewImageMaxPixels: 16_777_216,
-    execMaxTimeoutMs: 3_600_000,
-    execDefaultYieldMs: 10_000,
-    execMaxYieldMs: 30_000,
-    execMaxPollYieldMs: 300_000,
-    execTerminationGraceMs: 1_000,
-    execDefaultMaxOutputBytes: 1_000_000,
-    execProgressMaxOutputBytes: 8_192,
-    execProgressIntervalMs: 100,
-    maxProcesses: 64,
-    execMaxCompletedResults: 16,
-    execCompletedRetentionMs: 300_000,
-    codeMaxInputBytes: 1_048_576,
-    codeMaxOutputBytes: 1_048_576,
-    codeMaxFrameBytes: 33_554_432,
-    codeMaxTransportBytes: 67_108_864,
-    codeMaxCalls: 128,
-    codeMaxConcurrentCells: 64,
-    codeDefaultYieldMs: 30_000,
-    codeDefaultWaitYieldMs: 10_000,
-    codeMaxYieldMs: 30_000,
-    codeMaxWaitYieldMs: 300_000,
-    codeMaxOutputTokens: 10_000,
-    codeCompletedRetentionMs: 600_000,
-    codeMaxCompletedResults: 32,
-    codeStateMaxEntries: 128,
-    codeStateMaxMutations: 128,
-    codeStateMaxKeyBytes: 256,
-    codeStateMaxValueBytes: 65_536,
-    codeStateMaxTotalBytes: 1_048_576,
-    codeSleepMaxMs: 30_000,
-    codeHeapMegabytes: 128,
-    codeMemoryBytes: 33_554_432,
-    codeStackBytes: 524_288,
-    codeTimeoutMs: 120_000, // Cumulative synchronous guest execution, not cell wall time.
-    patchMaxBytes: 4_194_304,
-    patchMaxFiles: 100,
-    patchMaxFileBytes: 8_388_608,
-    patchMaxTotalBytes: 33_554_432,
-    agentWaitMinWaitMs: 0,
-    agentWaitWaitFloorMs: 10_000,
-    agentWaitDefaultWaitMs: 30_000,
-    agentWaitMaxWaitMs: 300_000,
-    agentWaitMaxAgents: 8,
-    sleepMaxDurationMs: 1_800_000,
-    subagentDescriptionMaxCharacters: 80,
-    subagentPromptMaxBytes: 131_072,
-    subagentMessageMaxBytes: 131_072,
-    subagentReasoningEffortMaxCharacters: 64,
-    subagentSummaryMaxBytes: 16_384,
-    subagentUpdateMaxBytes: 32_768,
-    subagentRunningLatestMessageMaxCharacters: 2_000,
-    subagentEvidenceMaxItems: 64,
-    subagentVerificationMaxItems: 16,
-    subagentChangedFilesMaxItems: 200,
-    questionMaxTextCharacters: 1_000,
-    questionMaxOptionCharacters: 500,
-    todoMaxItems: 100,
-    todoMaxTextCharacters: 1_000
-});

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

@@ -1,46 +0,0 @@
-import type { ModelEvent } from '../model/contracts.js';
-import type { EventPayload } from '../runtime/events.js';
-import type { ClientToolDefinition, McpToolCallContext, ToolExecutionContext, ToolExecutionResult } from './contracts.js';
-import type { ToolRuntimeContext, ToolRuntimeImage } from './runtime-context.js';
-import { type createSessionToolScheduler } from './scheduler.js';
-import type { ToolCall } from './contracts.js';
-export type ClientToolCall = Extract<ModelEvent, {
-    type: 'client_tool.call';
-}>;
-export type ExecutedToolCall = {
-    call: ClientToolCall;
-    content: string;
-    images?: ToolExecutionResult['images'];
-    sourceImages?: ToolExecutionResult['images'];
-    observations?: ToolExecutionResult['observations'];
-    calls?: ToolExecutionResult['calls'];
-} & ({
-    failed: false;
-    output: ToolExecutionResult;
-} | {
-    failed: true;
-    error: unknown;
-});
-/** One immutable model round's catalog; execution resources remain owned by the SDK/Host. */
-export interface RoundToolScope {
-    readonly context: Omit<ToolRuntimeContext, 'codeMode' | 'expectedMcpTool' | 'searchMcpTools' | 'recentImages'>;
-    readonly tools: readonly ClientToolDefinition[];
-    readonly expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
-    readonly extensionToolNames: ReadonlySet<string>;
-    readonly schedule: ReturnType<typeof createSessionToolScheduler>;
-    readonly assertLive: () => void;
-    readonly assertExecutionLive: () => void;
-    readonly emit: (event: EventPayload, assertLive?: () => void) => Promise<void>;
-    readonly searchMcpTools: NonNullable<ToolRuntimeContext['searchMcpTools']>;
-    readonly recentImages: () => Promise<ToolRuntimeImage[]>;
-    readonly captureCodeContext: () => Omit<ToolRuntimeContext, 'signal' | 'codeMode' | 'expectedMcpTool' | 'searchMcpTools'>;
-    readonly codeModeContext: (call: ToolCall & {
-        readonly callId: string;
-    }) => Promise<Omit<NonNullable<ToolExecutionContext['codeMode']>, 'invoke'>>;
-}
-/** Shared raw context construction for physical tools and native calls in a real model round. */
-export declare function createRoundToolRuntimeContext(scope: RoundToolScope, call: ToolCall & {
-    readonly callId: string;
-}, signal: AbortSignal): Promise<ToolRuntimeContext>;
-/** Complete every call in model order even if individual execution fails. */
-export declare function executeRoundTools(calls: readonly ClientToolCall[], scope: RoundToolScope): Promise<ExecutedToolCall[]>;

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

@@ -1,191 +0,0 @@
-import { MarAgentError, describeMarAgentError } from '../error.js';
-import { toolEventSummary } from '../runtime/event-projection.js';
-import { allowsToolCaller } from './callers.js';
-import { CodeCellExecutionError } from './code-mode/cells.js';
-import { createCodeToolDispatch } from './code-mode/dispatch.js';
-import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
-import { publishModelResources } from '../runtime/resource-publication.js';
-import { executeRegisteredTool } from './runtime.js';
-import { failedToolResultExtensions } from './result-extensions.js';
-import { permissionStopFromError } from './permissions.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) {
-    scope.assertLive();
-    signal.throwIfAborted();
-    const codeMode = await scope.codeModeContext(call);
-    const recentImages = scope.extensionToolNames.has(call.name) ||
-        call.name === 'code_exec' ||
-        call.name === 'code_exec_wait'
-        ? await scope.recentImages()
-        : undefined;
-    scope.assertLive();
-    signal.throwIfAborted();
-    const assertSessionLive = scope.assertLive;
-    const assertExecutionLive = scope.assertExecutionLive;
-    const emitCodeEvent = scope.emit;
-    const retainSession = codeMode.retainSession?.bind(codeMode);
-    let retained = 0;
-    const assertDispatchLive = () => {
-        assertSessionLive();
-        if (retained === 0)
-            assertExecutionLive();
-    };
-    return {
-        ...scope.context,
-        ...(scope.expectations.get(call.name)
-            ? { expectedMcpTool: scope.expectations.get(call.name) }
-            : {}),
-        searchMcpTools: scope.searchMcpTools,
-        signal,
-        codeMode: {
-            ...codeMode,
-            ...(retainSession === undefined
-                ? {}
-                : {
-                    retainSession: async () => {
-                        assertDispatchLive();
-                        const release = await retainSession();
-                        retained++;
-                        let released = false;
-                        return async () => {
-                            if (released)
-                                return;
-                            released = true;
-                            retained--;
-                            await release();
-                        };
-                    }
-                }),
-            invoke: createCodeToolDispatch({
-                context: {
-                    ...scope.captureCodeContext(),
-                    ...(recentImages === undefined ? {} : { recentImages })
-                },
-                tools: scope.tools,
-                expectations: scope.expectations,
-                parentCallId: call.callId,
-                schedule: scope.schedule,
-                assertLive: assertDispatchLive,
-                emit: (event) => emitCodeEvent(event, assertDispatchLive)
-            })
-        },
-        ...(scope.extensionToolNames.has(call.name) && recentImages !== undefined
-            ? { recentImages }
-            : {})
-    };
-}
-/** Complete every call in model order even if individual execution fails. */
-export async function executeRoundTools(calls, scope) {
-    const executeCall = async (call, signal = scope.context.signal, caller = 'direct', parentCallId) => {
-        await scope.emit({
-            type: 'tool.started',
-            toolName: call.name,
-            callId: call.callId,
-            ...(parentCallId === undefined ? {} : { parentCallId }),
-            input: call.arguments
-        });
-        try {
-            if (call.argumentError)
-                throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
-            if (!scope.tools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
-                throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
-            const context = await createRoundToolRuntimeContext(scope, call, signal);
-            const runTool = () => {
-                signal.throwIfAborted();
-                return executeRegisteredTool(call.name, call.arguments, call.callId, context);
-            };
-            const rawOutput = call.name === 'code_exec' || call.name === 'code_exec_wait'
-                ? await runTool()
-                : await scope.schedule(scope.tools.find((tool) => tool.name === call.name), runTool);
-            const publishedImages = await publishModelResources(scope.context.host, rawOutput.images, {
-                sessionId: scope.context.sessionId,
-                executionId: scope.context.executionId
-            }, scope.context.imageStore);
-            const output = publishedImages === rawOutput.images
-                ? rawOutput
-                : {
-                    ...rawOutput,
-                    ...(publishedImages === undefined ? {} : { images: publishedImages })
-                };
-            const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
-            const eventSummary = toolEventSummary(output.content);
-            const structuredData = structuredToolEventData(call.name, output.data);
-            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 }),
-                summary: eventSummary.summary,
-                truncated: output.truncated === true || modelOutput.truncated || eventSummary.truncated,
-                ...(artifacts === undefined ? {} : { artifacts }),
-                ...(structuredData === undefined ? {} : { data: structuredData })
-            });
-            return {
-                call,
-                output,
-                content: modelOutput.content,
-                ...(rawOutput.images?.length ? { sourceImages: rawOutput.images } : {}),
-                ...(output.calls
-                    ? { calls: output.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
-                    : {}),
-                ...(output.observations ? { observations: output.observations } : {}),
-                ...(output.images?.length ? { images: output.images } : {}),
-                failed: false
-            };
-        }
-        catch (error) {
-            const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
-            const partialResult = error instanceof CodeCellExecutionError ? error.result : undefined;
-            const publishedPartialImages = await publishModelResources(scope.context.host, partialResult?.images, { sessionId: scope.context.sessionId, executionId: scope.context.executionId }, scope.context.imageStore);
-            const partial = partialResult !== undefined && publishedPartialImages !== partialResult.images
-                ? { ...partialResult, images: publishedPartialImages }
-                : partialResult;
-            const failureData = structuredToolFailureData(call.name, error);
-            const eventData = failureData ??
-                (partial?.data === undefined
-                    ? undefined
-                    : 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 }),
-                code: diagnostic.code,
-                message: diagnostic.message,
-                ...(permissionStopFromError(error)
-                    ? { permissionStop: permissionStopFromError(error) }
-                    : {}),
-                ...(eventData === undefined ? {} : { data: eventData })
-            });
-            return {
-                call,
-                content: partial === undefined
-                    ? boundedModelToolOutput(call.name, JSON.stringify({
-                        error: diagnostic.code,
-                        message: diagnostic.message,
-                        ...(permissionStopFromError(error)
-                            ? { permissionStop: permissionStopFromError(error) }
-                            : {}),
-                        ...(failureData === undefined ? {} : { data: failureData }),
-                        ...(error instanceof MarAgentError && error.retryable ? { retryable: true } : {})
-                    }), failureData).content
-                    : boundedModelToolOutput(call.name, partial.content, partial.data).content,
-                ...(partial?.images?.length ? { images: partial.images } : {}),
-                ...(partialResult?.images?.length ? { sourceImages: partialResult.images } : {}),
-                failed: true,
-                ...(partial?.calls
-                    ? { calls: partial.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
-                    : {}),
-                ...(partial?.observations ? { observations: partial.observations } : {}),
-                error
-            };
-        }
-    };
-    return scheduleToolCallBatch(calls, scope.tools, executeCall);
-}

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

@@ -1,177 +0,0 @@
-import { isAbsolute, resolve } from 'node:path';
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-import { sourcePreview } from '../input-diagnostics/source-preview.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: ';
-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 = sourcePreview(source, column);
-        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;
-}

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

@@ -1,19 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ApplyPatchResult } from '../contracts.js';
-import { WorkspacePathResolver } from '../shared/path-resolver.js';
-export type { ApplyPatchFileResult, ApplyPatchResult } from '../contracts.js';
-export declare const applyPatchToolDefinition: ClientToolDefinition;
-export declare function applyPatchToolInput(input: unknown): string;
-interface PatchFileOperations {
-    rename(source: string, target: string): Promise<void>;
-    rm(path: string, options?: {
-        force?: boolean;
-        recursive?: boolean;
-    }): Promise<void>;
-}
-export declare class ApplyPatchTool {
-    #private;
-    private readonly paths;
-    constructor(paths: WorkspacePathResolver, operations?: Partial<PatchFileOperations>);
-    execute(patch: string): Promise<ApplyPatchResult>;
-}