@myagentroam/agent 0.9.158 → 0.9.160

package/dist/agent-core/tools/local/exec.js

@@ -3,6 +3,7 @@ import { StringDecoder } from 'node:string_decoder';
 import { MarAgentError } from '../../error.js';
 import { directLocalProcessExecutor, signalProcessTree } from '../../host/local-process-executor.js';
 import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
+import { validateCoreProcessInput } from '../../extensions/processes.js';
 export const execToolDefinition = {
     name: 'exec',
     allowedCallers: ['direct', 'programmatic'],
@@ -144,7 +145,9 @@ export class ExecTool {
                     this.#removeCompleted(input.processId);
                 return { ...completed.result, cached: true };
             }
-            if (!process || (owner !== undefined && process.ownerSessionId !== owner.sessionId))
+            if (!process ||
+                process.native ||
+                (owner !== undefined && process.ownerSessionId !== owner.sessionId))
                 throw new MarAgentError('MAR_AGENT_PROCESS_NOT_FOUND', 'Managed process was not found.');
             if (input.action === 'poll' && input.yieldMs)
                 await waitForProcessChange(process, Math.min(Math.max(input.yieldMs, 0), TOOL_EXECUTION_LIMITS.execMaxPollYieldMs), signal);
@@ -160,36 +163,63 @@ export class ExecTool {
             }
             return result;
         }
+        const { id, managed } = await this.#startManaged(async () => {
+            const cwd = await this.paths.resolveWithDisplay(input.cwd ?? '.');
+            return {
+                command: input.command,
+                cwd: cwd.physicalPath,
+                shell: this.shell ?? true,
+                environment: this.environment,
+                displayCwd: cwd.displayPath,
+                detached: process.platform !== 'win32',
+                ...(owner === undefined ? {} : { owner }),
+                ...(signal === undefined ? {} : { signal })
+            };
+        }, owner?.sessionId, false);
+        managed.timer = setTimeout(() => {
+            void this.#terminate(managed, true).then(() => this.#retainCompleted(id, managed));
+        }, Math.min(input.timeoutMs ?? TOOL_EXECUTION_LIMITS.execDefaultTimeoutMs, TOOL_EXECUTION_LIMITS.execMaxTimeoutMs));
+        managed.timer.unref();
+        await waitForExitOrDelay(managed.settled, Math.min(input.yieldMs ?? TOOL_EXECUTION_LIMITS.execDefaultYieldMs, TOOL_EXECUTION_LIMITS.execMaxYieldMs), signal);
+        const result = this.#result(id, managed);
+        if (managed.status !== 'running')
+            this.#retainCompleted(id, managed);
+        return result;
+    }
+    async #startManaged(request, ownerSessionId, native) {
         if (this.#processes.size + this.#startingProcesses.size >= this.maxProcesses)
             throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', `The Local Host shared managed-process limit (${this.maxProcesses}) was reached.`);
         let resolveStarting;
         const starting = {
-            ...(owner === undefined ? {} : { ownerSessionId: owner.sessionId }),
+            ...(ownerSessionId === undefined ? {} : { ownerSessionId }),
             settled: new Promise((resolve) => (resolveStarting = resolve)),
             resolveSettled: () => resolveStarting()
         };
         this.#startingProcesses.add(starting);
-        const id = randomUUID();
-        let child;
-        let managed;
         try {
-            const cwd = await this.paths.resolveWithDisplay(input.cwd ?? '.');
-            child = await this.processExecutor.spawn({
-                command: input.command,
-                cwd: cwd.physicalPath,
-                shell: this.shell ?? true,
-                environment: this.environment,
-                detached: process.platform !== 'win32',
-                ...(owner === undefined ? {} : { owner }),
-                ...(signal === undefined ? {} : { signal })
-            });
+            const { displayCwd, ...input } = await request();
+            input.signal?.throwIfAborted();
+            let child;
+            try {
+                child = await this.processExecutor.spawn(input);
+            }
+            catch (error) {
+                input.signal?.throwIfAborted();
+                if (!native || error instanceof MarAgentError)
+                    throw error;
+                throw new MarAgentError('MAR_AGENT_PROCESS_START_FAILED', 'Native process executor failed to start.', {
+                    details: { reasonCode: error?.code ?? 'UNKNOWN' }
+                });
+            }
+            const id = randomUUID();
             let resolveExited;
             let resolveSettled;
-            managed = {
+            const managed = {
                 child,
-                ...(owner === undefined ? {} : { ownerSessionId: owner.sessionId }),
+                native,
+                ...(ownerSessionId === undefined ? {} : { ownerSessionId }),
                 command: input.command,
-                cwd: cwd.displayPath,
+                cwd: displayCwd ?? input.cwd,
                 stdout: createOutputBuffer(),
                 stderr: createOutputBuffer(),
                 stdoutHistory: createOutputBuffer(),
@@ -199,65 +229,199 @@ export class ExecTool {
                 settled: new Promise((resolve) => (resolveSettled = resolve)),
                 resolveExited,
                 resolveSettled,
-                exitObserved: child.exitCode !== null,
+                exitObserved: child.exitCode !== null || child.signalCode != null,
+                ...(child.exitCode === null ? {} : { exitCode: child.exitCode }),
+                ...(child.signalCode == null ? {} : { exitSignal: child.signalCode }),
                 finalized: false,
                 waiters: new Set()
             };
             this.#processes.set(id, managed);
+            if (native) {
+                // Keep unread bytes in the Readable buffer: Node otherwise resumes unused stdio at exit.
+                const readable = () => { };
+                child.stdout.on('readable', readable);
+                child.stderr.on('readable', readable);
+                child.once('close', () => {
+                    child.stdout.removeListener('readable', readable);
+                    child.stderr.removeListener('readable', readable);
+                });
+            }
+            if (!native) {
+                const listen = (name) => child[name].on('data', (chunk) => {
+                    if (managed.finalized)
+                        return;
+                    const decoded = Buffer.from(managed[name].decoder.write(chunk));
+                    appendOutput(managed[name], decoded, this.maxOutputBytes, chunk.length);
+                    appendOutput(managed[name === 'stdout' ? 'stdoutHistory' : 'stderrHistory'], decoded, this.maxOutputBytes, chunk.length);
+                    notifyProcessChange(managed);
+                });
+                listen('stdout');
+                listen('stderr');
+            }
+            child.once('exit', (code, signal) => {
+                managed.exitObserved = true;
+                managed.exitCode = code;
+                managed.exitSignal = signal;
+                managed.resolveExited();
+                if (!native)
+                    void finalizeAfterOutputGrace(managed, this.maxOutputBytes).then(() => this.#retainCompleted(id, managed));
+            });
+            child.once('close', (code, signal) => {
+                managed.exitObserved = true;
+                managed.exitSignal = signal;
+                managed.resolveExited();
+                finalizeManagedProcess(managed, this.maxOutputBytes, code);
+                if (native)
+                    this.#processes.delete(id);
+                else
+                    this.#retainCompleted(id, managed);
+            });
+            child.once('error', (error) => {
+                if (managed.finalized)
+                    return;
+                if (native) {
+                    managed.failure = new MarAgentError('MAR_AGENT_PROCESS_START_FAILED', 'Native process failed to start.', {
+                        details: { reasonCode: error.code ?? 'UNKNOWN' }
+                    });
+                    managed.exitObserved = true;
+                    managed.resolveExited();
+                }
+                else {
+                    const message = Buffer.from(error.message);
+                    appendOutput(managed.stderr, message, this.maxOutputBytes);
+                    appendOutput(managed.stderrHistory, message, this.maxOutputBytes);
+                    notifyProcessChange(managed);
+                }
+            });
+            if (managed.exitObserved) {
+                managed.resolveExited();
+                if (child.stdout.closed && child.stderr.closed) {
+                    finalizeManagedProcess(managed, this.maxOutputBytes, child.exitCode);
+                    if (native)
+                        this.#processes.delete(id);
+                    else
+                        this.#retainCompleted(id, managed);
+                }
+            }
+            return { id, managed };
         }
         finally {
             this.#startingProcesses.delete(starting);
             starting.resolveSettled();
         }
-        child.stdout.on('data', (chunk) => {
-            if (managed.finalized)
-                return;
-            const decoded = Buffer.from(managed.stdout.decoder.write(chunk));
-            appendOutput(managed.stdout, decoded, this.maxOutputBytes, chunk.length);
-            appendOutput(managed.stdoutHistory, decoded, this.maxOutputBytes, chunk.length);
-            notifyProcessChange(managed);
+    }
+    async spawn(input, call) {
+        validateCoreProcessInput(input);
+        input = {
+            ...input,
+            ...(input.argv === undefined ? {} : { argv: [...input.argv] }),
+            ...(input.env === undefined ? {} : { env: { ...input.env } }),
+            ...(input.input instanceof Uint8Array ? { input: new Uint8Array(input.input) } : {})
+        };
+        const { id, managed } = await this.#startManaged(async () => {
+            const cwd = await this.paths.resolve(input.cwd ?? '.');
+            return {
+                command: input.executable,
+                args: [...(input.argv ?? [])],
+                cwd,
+                shell: false,
+                environment: { ...this.environment, ...input.env },
+                environmentKeys: Object.keys(input.env ?? {}),
+                ...(input.env === undefined ? {} : { environmentOverrides: input.env }),
+                detached: process.platform !== 'win32',
+                signal: call.signal,
+                owner: {
+                    sessionId: call.sessionId,
+                    operationId: call.operationId,
+                    ...(call.executionId ? { executionId: call.executionId } : {}),
+                    ...(call.ownerInstanceId ? { ownerInstanceId: call.ownerInstanceId } : {})
+                }
+            };
+        }, call.sessionId, true);
+        let cleanup;
+        const cancel = () => (cleanup ??= (async () => {
+            call.signal.removeEventListener('abort', abort);
+            await this.#terminate(managed, false);
+            destroyManagedStreams(managed);
+            this.#processes.delete(id);
+        })());
+        const abort = () => {
+            void cancel().catch(() => undefined);
+        };
+        call.signal.addEventListener('abort', abort, { once: true });
+        managed.child.once('close', () => call.signal.removeEventListener('abort', abort));
+        managed.child.stdin.on('error', (error) => {
+            if (error.code !== 'EPIPE' && !cleanup)
+                managed.failure = new MarAgentError('MAR_AGENT_PROCESS_IO_FAILED', 'Native process input failed.', {
+                    details: { reasonCode: error.code ?? 'UNKNOWN' }
+                });
         });
-        child.stderr.on('data', (chunk) => {
-            if (managed.finalized)
+        managed.child.stdin.end(input.input);
+        if (call.signal.aborted) {
+            await cancel();
+            call.signal.throwIfAborted();
+        }
+        const opened = new Promise((resolve, reject) => {
+            if (managed.child.pid) {
+                resolve();
                 return;
-            const decoded = Buffer.from(managed.stderr.decoder.write(chunk));
-            appendOutput(managed.stderr, decoded, this.maxOutputBytes, chunk.length);
-            appendOutput(managed.stderrHistory, decoded, this.maxOutputBytes, chunk.length);
-            notifyProcessChange(managed);
-        });
-        child.once('exit', (code) => {
-            managed.exitObserved = true;
-            managed.exitCode = code;
-            managed.resolveExited();
-            void finalizeAfterOutputGrace(managed, this.maxOutputBytes).then(() => this.#retainCompleted(id, managed));
-        });
-        child.once('close', (code) => {
-            managed.exitObserved = true;
-            managed.resolveExited();
-            finalizeManagedProcess(managed, this.maxOutputBytes, code);
-            this.#retainCompleted(id, managed);
-        });
-        child.once('error', (error) => {
-            if (managed.finalized)
+            }
+            if (managed.failure) {
+                reject(managed.failure);
                 return;
-            const message = Buffer.from(error.message);
-            appendOutput(managed.stderr, message, this.maxOutputBytes);
-            appendOutput(managed.stderrHistory, message, this.maxOutputBytes);
-            notifyProcessChange(managed);
+            }
+            const spawned = () => {
+                managed.child.removeListener('error', failed);
+                resolve();
+            };
+            const failed = () => {
+                managed.child.removeListener('spawn', spawned);
+                reject(managed.failure);
+            };
+            managed.child.once('spawn', spawned);
+            managed.child.once('error', failed);
         });
-        managed.timer = setTimeout(() => {
-            void this.#terminate(managed, true).then(() => this.#retainCompleted(id, managed));
-        }, Math.min(input.timeoutMs ?? TOOL_EXECUTION_LIMITS.execDefaultTimeoutMs, TOOL_EXECUTION_LIMITS.execMaxTimeoutMs));
-        managed.timer.unref();
-        await waitForExitOrDelay(managed.settled, Math.min(input.yieldMs ?? TOOL_EXECUTION_LIMITS.execDefaultYieldMs, TOOL_EXECUTION_LIMITS.execMaxYieldMs), signal);
-        const result = this.#result(id, managed);
-        if (managed.status !== 'running')
-            this.#retainCompleted(id, managed);
-        return result;
+        try {
+            await opened;
+        }
+        catch (error) {
+            await cancel();
+            throw error;
+        }
+        const stream = (name) => ({
+            async *[Symbol.asyncIterator]() {
+                try {
+                    for await (const chunk of managed.child[name])
+                        yield new Uint8Array(chunk);
+                }
+                catch (error) {
+                    if (!cleanup && !call.signal.aborted)
+                        throw new MarAgentError('MAR_AGENT_PROCESS_IO_FAILED', 'Native process output failed.', {
+                            details: {
+                                stream: name,
+                                reasonCode: error.code ?? 'UNKNOWN'
+                            }
+                        });
+                }
+            }
+        });
+        return {
+            processId: id,
+            stdout: stream('stdout'),
+            stderr: stream('stderr'),
+            cancel,
+            wait: async () => {
+                await managed.exited;
+                call.signal.throwIfAborted();
+                if (managed.failure)
+                    throw managed.failure;
+                return { code: managed.exitCode ?? null, signal: managed.exitSignal ?? null };
+            }
+        };
     }
     listSessionResources(sessionId) {
         return [
-            ...[...this.#processes.entries()].flatMap(([processId, process]) => process.ownerSessionId === sessionId
+            ...[...this.#processes.entries()].flatMap(([processId, process]) => !process.native && process.ownerSessionId === sessionId
                 ? [{ processId, status: process.status, command: process.command, cwd: process.cwd }]
                 : []),
             ...[...this.#completed.entries()].flatMap(([processId, process]) => process.ownerSessionId === sessionId
@@ -292,7 +456,10 @@ export class ExecTool {
         this.#completed.delete(id);
     }
     #retainCompleted(id, process) {
-        if (process.status === 'running' || !process.finalized || this.#processes.get(id) !== process)
+        if (process.native ||
+            process.status === 'running' ||
+            !process.finalized ||
+            this.#processes.get(id) !== process)
             return;
         this.#processes.delete(id);
         const stdout = consumeOutput(process.stdoutHistory);
@@ -325,6 +492,8 @@ export class ExecTool {
             return managed.terminate;
         managed.terminate = (async () => {
             if (managed.exitObserved || managed.child.exitCode !== null) {
+                if (managed.native && !managed.finalized)
+                    await signalProcessTree(managed.child, 'SIGKILL');
                 if (managed.child.exitCode !== null)
                     managed.exitCode = managed.child.exitCode;
                 if (waitForOutputClose) {
@@ -345,6 +514,9 @@ export class ExecTool {
                 await signalProcessTree(managed.child, 'SIGKILL');
                 await managed.exited;
             }
+            // A parent may exit on TERM while descendants ignore it and keep the pipes alive.
+            if (managed.native)
+                await signalProcessTree(managed.child, 'SIGKILL');
             if (waitForOutputClose) {
                 const settled = await waitForExit(managed.settled, TOOL_EXECUTION_LIMITS.execTerminationGraceMs);
                 if (settled)

package/dist/agent-core/tools/local/registry.d.ts

@@ -1,9 +1,13 @@
+import { LocalFileAccess } from '../../host/local-file-access.js';
 import type { LocalProcessExecutor } from '../../host/local-process-executor.js';
 import type { CodeModeEngineFactory } from '../code-mode/engine.js';
 import type { ToolCall, ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
 import { type WorkspacePathMount } from '../shared/path-resolver.js';
+import type { CoreOperationContext } from '../../extensions/operation.js';
 export declare class LocalToolRegistry {
     #private;
+    readonly processes: import('../../extensions/processes.js').CoreProcessesBackend;
+    readonly files: LocalFileAccess;
     constructor(workspace: string, environment?: NodeJS.ProcessEnv, shell?: string, options?: {
         processExecutor?: LocalProcessExecutor;
         codeModeEngineFactory?: CodeModeEngineFactory;
@@ -12,6 +16,8 @@ export declare class LocalToolRegistry {
         pathMounts?: readonly WorkspacePathMount[];
     });
     execute(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    names(): readonly string[];
+    executeOperation(call: ToolCall, operation: CoreOperationContext): Promise<ToolExecutionResult>;
     listSessionResources(sessionId: string): {
         processId: string;
         status: "completed" | "cancelled" | "running";

package/dist/agent-core/tools/local/registry.js

@@ -1,11 +1,29 @@
 import { MarAgentError } from '../../error.js';
-import { ApplyPatchTool, applyPatchToolInput } from './apply-patch.js';
-import { CodeModeTool } from '../code-mode/index.js';
-import { ExecTool, execToolInput } from './exec.js';
-import { ReadTool, formatBatchReadOutput } from './read.js';
+import { LocalFileAccess } from '../../host/local-file-access.js';
+import { ApplyPatchTool, applyPatchToolInput, applyPatchToolDefinition } from './apply-patch.js';
+import { CodeModeTool, codeModeToolDefinition, codeExecWaitToolDefinition } from '../code-mode/index.js';
+import { normalizeToolInput } from '../input.js';
+import { ExecTool, execToolInput, execToolDefinition, execWaitToolDefinition } from './exec.js';
+import { ReadTool, formatBatchReadOutput, readToolDefinition } from './read.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
-import { ViewImageTool } from './view-image.js';
+import { ViewImageTool, viewImageToolDefinition } from './view-image.js';
+const definitions = [
+    readToolDefinition,
+    viewImageToolDefinition,
+    applyPatchToolDefinition,
+    execToolDefinition,
+    execWaitToolDefinition,
+    codeModeToolDefinition,
+    codeExecWaitToolDefinition
+];
+function executionContext(context) {
+    if (!context.executionId)
+        throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool requires a real Execution.');
+    return { ...context, executionId: context.executionId };
+}
 export class LocalToolRegistry {
+    processes;
+    files;
     #exec;
     #code;
     #handlers;
@@ -17,14 +35,22 @@ export class LocalToolRegistry {
                 : { rootWritable: options.workspaceWritable }),
             ...(options.pathMounts === undefined ? {} : { mounts: options.pathMounts })
         });
+        this.files = new LocalFileAccess(paths);
         const read = new ReadTool(paths);
         const viewImage = new ViewImageTool(paths);
         const patch = new ApplyPatchTool(paths);
         this.#exec = new ExecTool(paths, undefined, undefined, environment, shell, options.processExecutor);
+        this.processes = { spawn: (input, call) => this.#exec.spawn(input, call) };
         this.#code = new CodeModeTool(paths, environment, options.processExecutor, options.codeModeEngineFactory);
         this.#handlers = new Map([
-            ['code_exec', (arguments_, context) => this.#code.start(arguments_, context)],
-            ['code_exec_wait', (arguments_, context) => this.#code.wait(arguments_, context)],
+            [
+                'code_exec',
+                (arguments_, context) => this.#code.start(arguments_, executionContext(context))
+            ],
+            [
+                'code_exec_wait',
+                (arguments_, context) => this.#code.wait(arguments_, executionContext(context))
+            ],
             [
                 'read',
                 async (arguments_, context) => {
@@ -53,7 +79,17 @@ export class LocalToolRegistry {
                 async (arguments_, context) => {
                     const result = await this.#exec.execute(execToolInput(name, arguments_), context.signal, {
                         sessionId: context.sessionId,
-                        executionId: context.executionId
+                        ...(context.executionId === undefined
+                            ? {}
+                            : { executionId: context.executionId }),
+                        ...(context.operation === undefined
+                            ? {}
+                            : {
+                                operationId: context.operation.operationId,
+                                ...(context.operation.ownerInstanceId === undefined
+                                    ? {}
+                                    : { ownerInstanceId: context.operation.ownerInstanceId })
+                            })
                     });
                     return { content: JSON.stringify(result), data: result, truncated: result.truncated };
                 }
@@ -64,7 +100,22 @@ export class LocalToolRegistry {
         const handler = this.#handlers.get(call.name);
         if (!handler)
             throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable.');
-        return handler(call.arguments, context);
+        return handler(normalizeToolInput(call.arguments, definitions.find((tool) => tool.name === call.name).inputSchema), context);
+    }
+    names() {
+        return [...this.#handlers.keys()];
+    }
+    executeOperation(call, operation) {
+        const handler = this.#handlers.get(call.name);
+        if (!handler)
+            throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable.');
+        return handler(normalizeToolInput(call.arguments, definitions.find((tool) => tool.name === call.name).inputSchema), {
+            mode: 'run',
+            signal: operation.signal,
+            sessionId: operation.sessionId,
+            ...(operation.executionId === undefined ? {} : { executionId: operation.executionId }),
+            operation
+        });
     }
     listSessionResources(sessionId) {
         return this.#exec.listSessionResources(sessionId);

package/dist/agent-core/tools/local/view-image.js

@@ -27,17 +27,25 @@ export class ViewImageTool {
         const path = await this.paths.resolve(input.path);
         const handle = await open(path, 'r');
         try {
-            const stat = await handle.stat();
+            const stat = await handle.stat({ bigint: true });
             if (!stat.isFile())
                 throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Path is not a regular file.');
-            if (stat.size > TOOL_EXECUTION_LIMITS.viewImageMaxBytes)
+            if (stat.size > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxBytes))
                 throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxBytes}-byte limit.`);
             signal?.throwIfAborted();
             const data = await handle.readFile();
             signal?.throwIfAborted();
             if (data.byteLength > TOOL_EXECUTION_LIMITS.viewImageMaxBytes)
                 throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxBytes}-byte limit.`);
+            const after = await handle.stat({ bigint: true });
+            signal?.throwIfAborted();
+            if (stat.size !== after.size ||
+                after.size !== BigInt(data.byteLength) ||
+                stat.mtimeNs !== after.mtimeNs ||
+                stat.ctimeNs !== after.ctimeNs)
+                return incompleteImage();
             const mimeType = detectImageMime(data);
+            validateImageContainer(data, mimeType);
             const metadata = {
                 path: input.path,
                 mimeType,
@@ -80,3 +88,101 @@ export function detectImageMime(data) {
 function invalidInput() {
     throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'View image input is invalid.');
 }
+// Basic container checks catch partial writes without decoding or changing pixels.
+function validateImageContainer(data, mimeType) {
+    if (mimeType === 'image/jpeg') {
+        let offset = 2;
+        let inScan = false;
+        let hasScan = false;
+        while (offset < data.length) {
+            if (data[offset++] !== 0xff) {
+                if (!inScan)
+                    incompleteImage();
+                continue;
+            }
+            while (data[offset] === 0xff)
+                offset++;
+            if (offset >= data.length)
+                incompleteImage();
+            const marker = data[offset++];
+            if (marker === 0 || (marker >= 0xd0 && marker <= 0xd7)) {
+                if (!inScan)
+                    incompleteImage();
+                continue;
+            }
+            if (marker === 0xd9) {
+                if (!hasScan)
+                    incompleteImage();
+                return;
+            }
+            if (marker === 0xd8)
+                incompleteImage();
+            if (marker === 1)
+                continue;
+            if (data.length - offset < 2)
+                incompleteImage();
+            const length = data.readUInt16BE(offset);
+            if (length < 2 || offset + length > data.length)
+                incompleteImage();
+            offset += length;
+            if (marker === 0xda)
+                hasScan = true;
+            inScan = marker === 0xda || (inScan && marker === 0xdc);
+        }
+        incompleteImage();
+    }
+    if (mimeType === 'image/webp') {
+        const end = data.readUInt32LE(4) + 8;
+        if (end > data.length || end < 20)
+            incompleteImage();
+        let offset = 12;
+        let hasPixels = false;
+        while (offset < end) {
+            if (end - offset < 8)
+                incompleteImage();
+            const length = data.readUInt32LE(offset + 4);
+            const next = offset + 8 + length + (length % 2);
+            if (next > end)
+                incompleteImage();
+            const type = data.toString('ascii', offset, offset + 4);
+            if ((type === 'VP8 ' || type === 'VP8L' || type === 'ANMF') && length > 0)
+                hasPixels = true;
+            offset = next;
+        }
+        if (!hasPixels)
+            incompleteImage();
+        return;
+    }
+    let offset = 8;
+    let hasPixels = false;
+    while (offset < data.length) {
+        if (data.length - offset < 12)
+            incompleteImage();
+        const length = data.readUInt32BE(offset);
+        const next = offset + 12 + length;
+        if (next > data.length)
+            incompleteImage();
+        const type = data.toString('ascii', offset + 4, offset + 8);
+        if (offset === 8) {
+            if (type !== 'IHDR' ||
+                length !== 13 ||
+                data.readUInt32BE(offset + 8) === 0 ||
+                data.readUInt32BE(offset + 12) === 0)
+                incompleteImage();
+        }
+        else if (type === 'IHDR')
+            incompleteImage();
+        if (type === 'IDAT' && length > 0)
+            hasPixels = true;
+        if (type === 'IEND') {
+            if (length !== 0 || !hasPixels)
+                incompleteImage();
+            return;
+        }
+        offset = next;
+    }
+    incompleteImage();
+}
+function incompleteImage() {
+    throw new MarAgentError('MAR_AGENT_IMAGE_INCOMPLETE', 'Image file is incomplete, malformed, or changed while reading. Wait for the writer to finish and read it again.');
+}

package/dist/agent-core/tools/mcp/catalog.d.ts

@@ -8,5 +8,9 @@ export declare const MCP_DEFINITION_LIMITS: Readonly<{
     servers: 256;
 }>;
 /** Shared Host and Node publication boundary, not a provider-specific conversion. */
-export declare function assertMcpToolDefinition(value: unknown): asserts value is ClientToolDefinition;
-export declare function assertMcpToolCatalog(value: unknown): asserts value is McpToolCatalog;
+export declare function assertMcpToolDefinition(value: unknown, options?: {
+    nativeToolNames?: boolean;
+}): asserts value is ClientToolDefinition;
+export declare function assertMcpToolCatalog(value: unknown, options?: {
+    nativeToolNames?: boolean;
+}): asserts value is McpToolCatalog;