@myagentroam/agent 0.11.33 → 0.11.34

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

@@ -1,470 +0,0 @@
-import { formatReadContextItem } from './read-context.js';
-import { markupAttributes, markupText } from '../../prompts/markup.js';
-import { AGENT_EXECUTION_POLICY } from '../../runtime/execution-policy.js';
-import { modelTokenBudgetBytes } from '../../runtime/token-budget.js';
-import { createReadStream } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
-import { TextDecoder } from 'node:util';
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-export const readToolDefinition = {
-    name: 'read',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'safe',
-    outputSchema: {
-        type: 'object',
-        required: ['content', 'data', 'truncated'],
-        properties: {
-            content: { type: 'string' },
-            truncated: { type: 'boolean' },
-            data: {
-                type: 'object',
-                required: ['mode', 'results', 'truncated'],
-                properties: {
-                    mode: { enum: ['batch'] },
-                    truncated: { type: 'boolean' },
-                    results: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            required: ['path'],
-                            properties: {
-                                path: { type: 'string' },
-                                content: { type: 'string' },
-                                text: { type: 'string' },
-                                startLine: { type: 'number' },
-                                endLine: { type: 'number' },
-                                nextOffset: { type: 'number' },
-                                eof: { type: 'boolean' },
-                                truncated: { type: 'boolean' },
-                                encoding: { enum: ['utf-8', 'utf-16le', 'utf-16be'] },
-                                newline: { enum: ['lf', 'crlf'] },
-                                error: {
-                                    type: 'object',
-                                    required: ['code', 'message'],
-                                    properties: { code: { type: 'string' }, message: { type: 'string' } }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    },
-    description: `Read one or more known text files/ranges. Strict UTF-8 with optional BOM is the default; BOM-declared UTF-16LE/UTF-16BE is supported. Invalid text returns an item error instead of replacement characters. Always pass reads; use one item for a single file and up to ${TOOL_EXECUTION_LIMITS.readMaxBatchItems} items for a batch. Batch only already-located, bounded ranges whose combined content is likely to fit the model-visible output budget; for exploration, locate relevant files, symbols, or headings first, then read the smallest useful ranges. Results retain input order and use <mar_read_result> or <mar_read_error>. Successful items use 1-based line numbers and include <metadata> with path, encoding, newline, exact visible range, eof, truncation, nextOffset, and whether previewComplete. Items fail independently and run with bounded concurrency. Each item returns at most ${TOOL_EXECUTION_LIMITS.readMaxLines} lines/${TOOL_EXECUTION_LIMITS.readMaxBytes} bytes; the structured call shares a ${TOOL_EXECUTION_LIMITS.readMaxBatchBytes}-byte budget, while ordinary model-visible content fairly shares the common tool-output budget across all items. Structured data.results items provide text as decoded source for the returned range, preserving line endings and excluding BOM; content is numbered display text. Large files support bounded range reads. If previewComplete is false and nextOffset is present, continue only the still-relevant item from nextOffset. An oversized single line instead returns a head/tail preview with no line continuation cursor; use exec to obtain exact source before editing omitted content. Relative paths use the workspace; absolute paths are allowed. Prefer exec with rg for search and read for known files.`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            reads: {
-                type: 'array',
-                minItems: 1,
-                maxItems: TOOL_EXECUTION_LIMITS.readMaxBatchItems,
-                description: 'Known files or ranges to read in one ordered batch.',
-                items: {
-                    type: 'object',
-                    properties: {
-                        path: { type: 'string', description: 'Relative workspace path or absolute file path.' },
-                        offset: {
-                            type: 'integer',
-                            minimum: 1,
-                            description: 'First 1-based line; defaults to 1.'
-                        },
-                        limit: {
-                            type: 'integer',
-                            minimum: 1,
-                            maximum: TOOL_EXECUTION_LIMITS.readMaxLines,
-                            description: `Maximum lines; defaults to ${TOOL_EXECUTION_LIMITS.readDefaultLines}.`
-                        }
-                    },
-                    required: ['path'],
-                    additionalProperties: false
-                }
-            }
-        },
-        required: ['reads'],
-        additionalProperties: false
-    }
-};
-export class ReadTool {
-    paths;
-    constructor(paths) {
-        this.paths = paths;
-    }
-    async execute(arguments_, signal) {
-        return this.#readBatch(parseReadInput(arguments_).reads, signal);
-    }
-    async #readBatch(reads, signal) {
-        const perItemBytes = Math.min(TOOL_EXECUTION_LIMITS.readMaxBytes, Math.floor(TOOL_EXECUTION_LIMITS.readMaxBatchBytes / reads.length));
-        const unique = new Map();
-        for (const item of reads)
-            unique.set(readKey(item), item);
-        const entries = [...unique.entries()];
-        const completed = new Map();
-        let cursor = 0;
-        const worker = async () => {
-            for (;;) {
-                const entry = entries[cursor++];
-                if (!entry)
-                    return;
-                const [key, item] = entry;
-                try {
-                    completed.set(key, await this.#readOne(item, perItemBytes, signal));
-                }
-                catch (error) {
-                    if (signal?.aborted)
-                        throw error;
-                    completed.set(key, readError(item.path, error));
-                }
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(TOOL_EXECUTION_LIMITS.readBatchConcurrency, entries.length) }, worker));
-        const results = reads.map((item) => completed.get(readKey(item)));
-        return {
-            mode: 'batch',
-            results,
-            truncated: results.some((result) => 'truncated' in result && result.truncated)
-        };
-    }
-    async #readOne(input, maxBytes, signal) {
-        signal?.throwIfAborted();
-        const path = await this.paths.resolve(input.path);
-        const stat = await lstat(path);
-        if (!stat.isFile())
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Path is not a regular file.');
-        const offset = Math.max(1, input.offset ?? 1);
-        const limit = Math.min(TOOL_EXECUTION_LIMITS.readMaxLines, Math.max(1, input.limit ?? TOOL_EXECUTION_LIMITS.readDefaultLines));
-        const detected = await detectEncoding(path);
-        const selected = [];
-        const sourceLines = [];
-        let outputBytes = 0;
-        let lineNumber = 0;
-        let hasMore = false;
-        let newline = 'lf';
-        let pending = '';
-        let stopped = false;
-        const decoder = new TextDecoder(detected.decoder, { fatal: true, ignoreBOM: true });
-        const stream = createReadStream(path, { start: detected.bomBytes, signal });
-        const consumeLine = (rawLine, hasLineFeed) => {
-            const source = rawLine + (hasLineFeed ? '\n' : '');
-            lineNumber++;
-            if (rawLine.endsWith('\r')) {
-                newline = 'crlf';
-                rawLine = rawLine.slice(0, -1);
-            }
-            if (lineNumber < offset)
-                return true;
-            if (selected.length >= limit) {
-                hasMore = true;
-                return false;
-            }
-            const formatted = `${lineNumber}\t${rawLine}`;
-            const formattedBytes = Buffer.byteLength(formatted);
-            const separatorBytes = selected.length === 0 ? 0 : 1;
-            if (outputBytes + separatorBytes + formattedBytes > maxBytes) {
-                if (selected.length === 0)
-                    throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'A single line exceeds the read result limit.');
-                hasMore = true;
-                return false;
-            }
-            selected.push(formatted);
-            sourceLines.push(source);
-            outputBytes += separatorBytes + formattedBytes;
-            return true;
-        };
-        const consumeDecoded = (value) => {
-            if (value.includes('\0'))
-                throw new MarAgentError('MAR_AGENT_FILE_ENCODING_INVALID', 'Text files cannot contain NUL characters; UTF-16 requires a BOM.');
-            pending += value;
-            for (;;) {
-                const delimiter = pending.indexOf('\n');
-                if (delimiter < 0)
-                    break;
-                const line = pending.slice(0, delimiter);
-                pending = pending.slice(delimiter + 1);
-                if (!consumeLine(line, true))
-                    return false;
-            }
-            if (lineNumber + 1 < offset && pending.length > 1)
-                pending = pending.endsWith('\r') ? '\r' : '';
-            else if (Buffer.byteLength(pending) > maxBytes)
-                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'A single line exceeds the read result limit.');
-            return true;
-        };
-        try {
-            for await (const chunk of stream) {
-                if (!consumeDecoded(decoder.decode(chunk, { stream: true }))) {
-                    stopped = true;
-                    break;
-                }
-            }
-            if (!stopped) {
-                consumeDecoded(decoder.decode());
-                if (pending.length > 0)
-                    consumeLine(pending, false);
-            }
-        }
-        catch (error) {
-            if (error instanceof TypeError)
-                throw new MarAgentError('MAR_AGENT_FILE_ENCODING_INVALID', 'File contains invalid text for its declared encoding.', { cause: error });
-            throw error;
-        }
-        finally {
-            stream.destroy();
-        }
-        const nextOffset = hasMore ? offset + selected.length : undefined;
-        return {
-            path: input.path,
-            content: selected.join('\n'),
-            text: sourceLines.join(''),
-            encoding: detected.encoding,
-            newline,
-            startLine: offset,
-            ...(selected.length ? { endLine: offset + selected.length - 1 } : {}),
-            eof: !hasMore,
-            truncated: hasMore,
-            ...(nextOffset === undefined ? {} : { nextOffset })
-        };
-    }
-}
-async function detectEncoding(path) {
-    const handle = await open(path, 'r');
-    try {
-        const header = Buffer.alloc(3);
-        const { bytesRead } = await handle.read(header, 0, header.length, 0);
-        if (bytesRead >= 3 && header[0] === 0xef && header[1] === 0xbb && header[2] === 0xbf)
-            return { encoding: 'utf-8', decoder: 'utf-8', bomBytes: 3 };
-        if (bytesRead >= 2 && header[0] === 0xff && header[1] === 0xfe)
-            return { encoding: 'utf-16le', decoder: 'utf-16le', bomBytes: 2 };
-        if (bytesRead >= 2 && header[0] === 0xfe && header[1] === 0xff)
-            return { encoding: 'utf-16be', decoder: 'utf-16be', bomBytes: 2 };
-        return { encoding: 'utf-8', decoder: 'utf-8', bomBytes: 0 };
-    }
-    finally {
-        await handle.close();
-    }
-}
-function parseReadInput(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalidReadInput('input', 'an object with a reads array');
-    const input = value;
-    if (!Array.isArray(input.reads) ||
-        input.reads.length === 0 ||
-        input.reads.length > TOOL_EXECUTION_LIMITS.readMaxBatchItems)
-        return invalidReadInput('reads', `an array of 1 to ${TOOL_EXECUTION_LIMITS.readMaxBatchItems} requests`);
-    if (Object.keys(input).some((key) => key !== 'reads'))
-        return invalidReadInput('input', 'only the reads field; put path/offset/limit inside reads');
-    return { reads: input.reads.map(parseReadRequest) };
-}
-function parseReadRequest(value, index) {
-    const field = `reads[${index}]`;
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalidReadInput(field, 'an object with path and optional offset/limit');
-    const input = value;
-    if (Object.keys(input).some((key) => !['path', 'offset', 'limit'].includes(key)))
-        return invalidReadInput(field, 'only path, offset and limit fields');
-    if (typeof input.path !== 'string' || input.path === '')
-        return invalidReadInput(`${field}.path`, 'a non-empty string');
-    if (input.offset !== undefined &&
-        input.offset !== null &&
-        (!Number.isInteger(input.offset) || input.offset < 1))
-        return invalidReadInput(`${field}.offset`, 'an integer >= 1');
-    if (input.limit !== undefined &&
-        input.limit !== null &&
-        (!Number.isInteger(input.limit) || input.limit < 1))
-        return invalidReadInput(`${field}.limit`, 'an integer >= 1');
-    return {
-        path: input.path,
-        ...(typeof input.offset === 'number' ? { offset: input.offset } : {}),
-        ...(typeof input.limit === 'number'
-            ? { limit: Math.min(input.limit, TOOL_EXECUTION_LIMITS.readMaxLines) }
-            : {})
-    };
-}
-function readKey(input) {
-    return JSON.stringify([
-        input.path,
-        input.offset ?? 1,
-        input.limit ?? TOOL_EXECUTION_LIMITS.readDefaultLines
-    ]);
-}
-function readError(path, error) {
-    if (error instanceof MarAgentError)
-        return { path, error: { code: error.code, message: error.publicMessage } };
-    const code = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string'
-        ? error.code
-        : 'MAR_AGENT_TOOL_FAILED';
-    return { path, error: { code, message: 'Unable to read file.' } };
-}
-function invalidReadInput(field, expected) {
-    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', `${field}: expected ${expected}.`);
-}
-function escapeAttribute(value) {
-    return markupAttributes({ value }).slice(8, -1);
-}
-function boundedUtf8Prefix(value, maximumBytes) {
-    if (Buffer.byteLength(value) <= maximumBytes)
-        return { value, truncated: false };
-    const marker = '…';
-    const contentBudget = Math.max(0, maximumBytes - Buffer.byteLength(marker));
-    let result = '';
-    let bytes = 0;
-    for (const character of value) {
-        const characterBytes = Buffer.byteLength(character);
-        if (bytes + characterBytes > contentBudget)
-            break;
-        result += character;
-        bytes += characterBytes;
-    }
-    return { value: `${result}${marker}`, truncated: true };
-}
-function oversizedLinePreview(value, retainedBytes, lineNumber) {
-    const bytes = Buffer.from(value, 'utf8');
-    if (retainedBytes >= bytes.length)
-        return { value, shownBytes: bytes.length, omittedBytes: 0 };
-    const headTarget = Math.floor(retainedBytes / 2);
-    const tailTarget = retainedBytes - headTarget;
-    let head = Math.min(headTarget, bytes.length);
-    while (head > 0 && isUtf8ContinuationByte(bytes[head]))
-        head--;
-    let tail = Math.max(head, bytes.length - tailTarget);
-    while (tail < bytes.length && isUtf8ContinuationByte(bytes[tail]))
-        tail++;
-    const shownBytes = head + bytes.length - tail;
-    const omittedBytes = bytes.length - shownBytes;
-    const marker = `...[${omittedBytes} bytes omitted from line ${lineNumber}]...`;
-    return {
-        value: `${bytes.toString('utf8', 0, head)}${marker}${bytes.toString('utf8', tail)}`,
-        shownBytes,
-        omittedBytes
-    };
-}
-function isUtf8ContinuationByte(value) {
-    return value !== undefined && (value & 0xc0) === 0x80;
-}
-function formatBatchReadResult(result, index, maximumBytes) {
-    const visiblePath = boundedUtf8Prefix(result.path, 128);
-    const path = escapeAttribute(visiblePath.value);
-    const pathTruncatedAttribute = visiblePath.truncated ? ' pathTruncated="true"' : '';
-    if ('error' in result) {
-        const message = boundedUtf8Prefix(result.error.message, 256);
-        const detailsTruncatedAttribute = message.truncated ? ' detailsTruncated="true"' : '';
-        const content = `<mar_read_error index="${index}" path="${path}"${pathTruncatedAttribute} code="${escapeAttribute(result.error.code)}"${detailsTruncatedAttribute}>\n  ${markupText('message', message.value)}\n</mar_read_error>`;
-        if (Buffer.byteLength(content) <= maximumBytes)
-            return { content, previewComplete: true };
-        return {
-            content: `<mar_read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">
-  <message>Model-visible error metadata exceeds this item's output share.</message>
-</mar_read_error>`,
-            previewComplete: false
-        };
-    }
-    const lines = result.content ? result.content.split('\n') : [];
-    const render = (visibleLines) => {
-        const previewComplete = visibleLines === lines.length;
-        const endLine = visibleLines === 0 ? undefined : result.startLine + Math.max(0, visibleLines - 1);
-        const metadata = {
-            path: visiblePath.value,
-            ...(visiblePath.truncated ? { pathTruncated: true } : {}),
-            encoding: result.encoding,
-            newline: result.newline,
-            startLine: result.startLine,
-            ...(endLine === undefined ? {} : { endLine }),
-            eof: previewComplete ? result.eof : false,
-            truncated: previewComplete ? result.truncated : true,
-            ...(previewComplete
-                ? result.nextOffset === undefined
-                    ? {}
-                    : { nextOffset: result.nextOffset }
-                : { nextOffset: result.startLine + visibleLines }),
-            previewComplete
-        };
-        return formatReadContextItem(index, metadata, lines.slice(0, visibleLines).join('\n'));
-    };
-    const full = render(lines.length);
-    if (Buffer.byteLength(full) <= maximumBytes)
-        return { content: full, previewComplete: true };
-    let low = 0;
-    let high = lines.length;
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
-        if (Buffer.byteLength(render(middle)) <= maximumBytes)
-            low = middle;
-        else
-            high = middle - 1;
-    }
-    const content = render(low);
-    if (low > 0 && Buffer.byteLength(content) <= maximumBytes)
-        return { content, previewComplete: low === lines.length };
-    if (lines.length > 0) {
-        const lineNumber = result.startLine;
-        const prefix = `${lineNumber}\t`;
-        const formattedLine = lines[0];
-        const sourceLine = formattedLine.startsWith(prefix)
-            ? formattedLine.slice(prefix.length)
-            : formattedLine;
-        const sourceLineBytes = Buffer.byteLength(sourceLine);
-        const renderOversizedLine = (retainedBytes) => {
-            const preview = oversizedLinePreview(sourceLine, retainedBytes, lineNumber);
-            const metadata = {
-                path: visiblePath.value,
-                ...(visiblePath.truncated ? { pathTruncated: true } : {}),
-                encoding: result.encoding,
-                newline: result.newline,
-                startLine: lineNumber,
-                endLine: lineNumber,
-                eof: false,
-                truncated: true,
-                previewComplete: false,
-                oversizedLine: {
-                    line: lineNumber,
-                    bytes: sourceLineBytes,
-                    shownBytes: preview.shownBytes,
-                    omittedBytes: preview.omittedBytes
-                }
-            };
-            return formatReadContextItem(index, metadata, `${prefix}${preview.value}`);
-        };
-        let minimum = renderOversizedLine(0);
-        if (Buffer.byteLength(minimum) <= maximumBytes) {
-            let retainedLow = 0;
-            let retainedHigh = sourceLineBytes;
-            while (retainedLow < retainedHigh) {
-                const middle = Math.ceil((retainedLow + retainedHigh) / 2);
-                const candidate = renderOversizedLine(middle);
-                if (Buffer.byteLength(candidate) <= maximumBytes) {
-                    retainedLow = middle;
-                    minimum = candidate;
-                }
-                else
-                    retainedHigh = middle - 1;
-            }
-            return { content: minimum, previewComplete: false };
-        }
-    }
-    return {
-        content: `<mar_read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">
-  <message>Model-visible read metadata exceeds this item's output share.</message>
-</mar_read_error>`,
-        previewComplete: false
-    };
-}
-export function formatBatchReadOutput(results) {
-    const blocks = [];
-    let bytes = 0;
-    let truncated = false;
-    const maximumBytes = modelTokenBudgetBytes(AGENT_EXECUTION_POLICY.modelToolOutputTokens);
-    for (const [index, result] of results.entries()) {
-        const separatorBytes = blocks.length === 0 ? 0 : 1;
-        const remainingItems = results.length - index;
-        const itemBudget = Math.floor((maximumBytes - bytes - separatorBytes) / remainingItems);
-        const block = formatBatchReadResult(result, index, itemBudget);
-        const blockBytes = Buffer.byteLength(block.content);
-        if (bytes + separatorBytes + blockBytes > maximumBytes)
-            break;
-        blocks.push(block.content);
-        bytes += separatorBytes + blockBytes;
-        if (!block.previewComplete)
-            truncated = true;
-    }
-    return { content: blocks.join('\n'), truncated };
-}

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

@@ -1,34 +0,0 @@
-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;
-        restrictPaths?: boolean;
-        workspaceWritable?: boolean;
-        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";
-        command: string;
-        cwd: string;
-    }[];
-    listCodeCells(sessionId: string): {
-        cellId: string;
-        status: "completed" | "failed" | "cancelled" | "running";
-        executionId: string;
-    }[];
-    disposeSessionResources(sessionId: string): Promise<void>;
-    dispose(): Promise<void>;
-}

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

@@ -1,132 +0,0 @@
-import { MarAgentError } from '../../error.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, formatExecResult } from './exec.js';
-import { ReadTool, formatBatchReadOutput, readToolDefinition } from './read.js';
-import { WorkspacePathResolver } from '../shared/path-resolver.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;
-    constructor(workspace, environment = process.env, shell, options = {}) {
-        const paths = new WorkspacePathResolver(workspace, {
-            ...(options.restrictPaths === undefined ? {} : { restrictPaths: options.restrictPaths }),
-            ...(options.workspaceWritable === undefined
-                ? {}
-                : { 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_, executionContext(context))
-            ],
-            [
-                'code_exec_wait',
-                (arguments_, context) => this.#code.wait(arguments_, executionContext(context))
-            ],
-            [
-                'read',
-                async (arguments_, context) => {
-                    const result = await read.execute(arguments_, context.signal);
-                    const formatted = formatBatchReadOutput(result.results);
-                    return {
-                        content: formatted.content,
-                        data: result,
-                        truncated: result.truncated || formatted.truncated
-                    };
-                }
-            ],
-            [
-                'view_image',
-                async (arguments_, context) => viewImage.execute(arguments_, context.signal)
-            ],
-            [
-                'apply_patch',
-                async (arguments_) => {
-                    const result = await patch.execute(applyPatchToolInput(arguments_));
-                    return { content: JSON.stringify(result), data: result };
-                }
-            ],
-            ...['exec', 'exec_wait'].map((name) => [
-                name,
-                async (arguments_, context) => {
-                    const result = await this.#exec.execute(execToolInput(name, arguments_), context.signal, {
-                        sessionId: context.sessionId,
-                        ...(context.executionId === undefined
-                            ? {}
-                            : { executionId: context.executionId }),
-                        ...(context.operation === undefined
-                            ? {}
-                            : {
-                                operationId: context.operation.operationId,
-                                ...(context.operation.ownerInstanceId === undefined
-                                    ? {}
-                                    : { ownerInstanceId: context.operation.ownerInstanceId })
-                            })
-                    }, context.waitInterrupt, context.onOutput);
-                    return formatExecResult(result);
-                }
-            ])
-        ]);
-    }
-    execute(call, context) {
-        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), 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);
-    }
-    listCodeCells(sessionId) {
-        return this.#code.listSessionResources(sessionId);
-    }
-    async disposeSessionResources(sessionId) {
-        await Promise.all([this.#exec.disposeSession(sessionId), this.#code.dispose(sessionId)]);
-    }
-    async dispose() {
-        await Promise.all([this.#exec.dispose(), this.#code.dispose()]);
-    }
-}

package/dist/agent-core/tools/local/view-image.d.ts

@@ -1,15 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolExecutionResult, ViewImageResult } from '../contracts.js';
-import { WorkspacePathResolver } from '../shared/path-resolver.js';
-export type { ViewImageResult } from '../contracts.js';
-export declare const viewImageToolDefinition: ClientToolDefinition;
-export declare class ViewImageTool {
-    private readonly paths;
-    constructor(paths: WorkspacePathResolver);
-    execute(arguments_: unknown, signal?: AbortSignal): Promise<ToolExecutionResult>;
-}
-/** Resolve Session-owned bytes without using the resource's public URL or original path. */
-export declare function viewResourceImage(arguments_: unknown, readResource: (resourceId: string) => Promise<{
-    dataBase64: string;
-} | undefined>, signal?: AbortSignal): Promise<ToolExecutionResult>;
-export declare function detectImageMime(data: Buffer): ViewImageResult['mimeType'];