@myagentroam/agent 0.9.141 → 0.9.143

package/dist/{tools → agent-core/tools/local}/read.d.ts

@@ -1,5 +1,6 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+export type { ReadEventData } from '../contracts.js';
 export declare const readToolDefinition: ClientToolDefinition;
 export interface ReadRequest {
     path: string;
@@ -30,22 +31,13 @@ export interface BatchReadResult {
     results: Array<ReadResult | ReadErrorResult>;
     truncated: boolean;
 }
-export interface ReadEventData {
-    mode: 'batch';
-    results: Array<{
-        path: string;
-        startLine?: number;
-        endLine?: number;
-        error?: {
-            code: string;
-            message: string;
-        };
-    }>;
-    truncated: boolean;
-}
 export declare class ReadTool {
     #private;
     private readonly paths;
     constructor(paths: WorkspacePathResolver);
     execute(arguments_: unknown, signal?: AbortSignal): Promise<BatchReadResult>;
 }
+export declare function formatBatchReadOutput(results: Array<ReadResult | ReadErrorResult>): {
+    content: string;
+    truncated: boolean;
+};

package/dist/{tools → agent-core/tools/local}/read.js

@@ -1,8 +1,10 @@
+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';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const readToolDefinition = {
     name: 'read',
     allowedCallers: ['direct', 'programmatic'],
@@ -293,3 +295,184 @@ function readError(path, error) {
 function invalidReadInput() {
     throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Read input is invalid.');
 }
+function escapeAttribute(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;');
+}
+function escapeText(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;');
+}
+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 = `<read_error index="${index}" path="${path}"${pathTruncatedAttribute} code="${escapeAttribute(result.error.code)}"${detailsTruncatedAttribute}>${escapeText(message.value)}</read_error>`;
+        if (Buffer.byteLength(content) <= maximumBytes)
+            return { content, previewComplete: true };
+        return {
+            content: `<read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">Model-visible error metadata exceeds this item's output share.</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 [
+            `<read_result index="${index}" path="${path}"${pathTruncatedAttribute}>`,
+            lines.slice(0, visibleLines).join('\n'),
+            `<read_metadata>${JSON.stringify(metadata)}</read_metadata>`,
+            '</read_result>'
+        ]
+            .filter(Boolean)
+            .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 [
+                `<read_result index="${index}" path="${path}"${pathTruncatedAttribute}>`,
+                `${prefix}${preview.value}`,
+                `<read_metadata>${JSON.stringify(metadata)}</read_metadata>`,
+                '</read_result>'
+            ].join('\n');
+        };
+        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: `<read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">Model-visible read metadata exceeds this item's output share.</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/{tools/local-registry.d.ts → agent-core/tools/local/registry.d.ts}

@@ -1,7 +1,7 @@
-import type { CodeModeEngineFactory } from './code-mode/engine.js';
-import type { LocalProcessExecutor } from '../host/local-process-executor.js';
-import type { ToolCall, ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
-import { type WorkspacePathMount } from './shared/path-resolver.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';
 export declare class LocalToolRegistry {
     #private;
     constructor(workspace: string, environment?: NodeJS.ProcessEnv, shell?: string, web?: {
@@ -26,7 +26,7 @@ export declare class LocalToolRegistry {
     }[];
     listCodeCells(sessionId: string): {
         cellId: string;
-        status: "completed" | "cancelled" | "running" | "failed";
+        status: "completed" | "failed" | "cancelled" | "running";
         executionId: string;
     }[];
     disposeSessionResources(sessionId: string): Promise<void>;

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

@@ -0,0 +1,101 @@
+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 { executeWebFetch } from './web-fetch.js';
+import { executeWebSearch } from './web-search.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+import { ViewImageTool } from './view-image.js';
+export class LocalToolRegistry {
+    #exec;
+    #code;
+    #handlers;
+    constructor(workspace, environment = process.env, shell, web = {}) {
+        const paths = new WorkspacePathResolver(workspace, {
+            ...(web.restrictPaths === undefined ? {} : { restrictPaths: web.restrictPaths }),
+            ...(web.workspaceWritable === undefined ? {} : { rootWritable: web.workspaceWritable }),
+            ...(web.pathMounts === undefined ? {} : { mounts: web.pathMounts })
+        });
+        const read = new ReadTool(paths);
+        const viewImage = new ViewImageTool(paths);
+        const patch = new ApplyPatchTool(paths);
+        this.#exec = new ExecTool(paths, undefined, undefined, environment, shell, web.processExecutor);
+        this.#code = new CodeModeTool(paths, environment, web.processExecutor, web.codeModeEngineFactory);
+        this.#handlers = new Map([
+            ['code_exec', (arguments_, context) => this.#code.start(arguments_, context)],
+            ['code_exec_wait', (arguments_, context) => this.#code.wait(arguments_, 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,
+                        executionId: context.executionId
+                    });
+                    return { content: JSON.stringify(result), data: result, truncated: result.truncated };
+                }
+            ]),
+            ...(web.webSearch
+                ? [
+                    [
+                        'web_search',
+                        async (arguments_, context) => {
+                            return executeWebSearch(arguments_, context.signal, (input, signal) => web.webSearch(input, signal));
+                        }
+                    ]
+                ]
+                : []),
+            ...(web.webFetch === false
+                ? []
+                : [
+                    [
+                        'web_fetch',
+                        async (arguments_, context) => {
+                            return executeWebFetch(arguments_, context.signal, web.allowUntrustedTls === true);
+                        }
+                    ]
+                ])
+        ]);
+    }
+    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(call.arguments, context);
+    }
+    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/{tools → agent-core/tools/local}/view-image.d.ts

@@ -1,13 +1,8 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { ToolExecutionResult } from '../sdk/types.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
+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 interface ViewImageResult {
-    path: string;
-    mimeType: 'image/png' | 'image/jpeg' | 'image/webp';
-    bytes: number;
-    sha256: string;
-}
 export declare class ViewImageTool {
     private readonly paths;
     constructor(paths: WorkspacePathResolver);

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { open } from 'node:fs/promises';
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const viewImageToolDefinition = {
     name: 'view_image',
     allowedCallers: ['direct', 'programmatic'],

package/dist/agent-core/tools/local/web-fetch.d.ts

@@ -0,0 +1,4 @@
+import type { ToolExecutionResult } from '../contracts.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+export declare const webFetchToolDefinition: ClientToolDefinition;
+export declare function executeWebFetch(input: unknown, signal: AbortSignal, allowUntrustedTls?: boolean): Promise<ToolExecutionResult>;

package/dist/agent-core/tools/local/web-fetch.js

@@ -0,0 +1,85 @@
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { MarAgentError } from '../../error.js';
+export const webFetchToolDefinition = {
+    name: 'web_fetch',
+    allowedCallers: ['direct', 'programmatic'],
+    parallelSafety: 'safe',
+    description: 'Fetch a specific HTTP or HTTPS URL, including explicitly permitted intranet URLs.',
+    inputSchema: {
+        type: 'object',
+        properties: { url: { type: 'string' } },
+        required: ['url'],
+        additionalProperties: false
+    }
+};
+export async function executeWebFetch(input, signal, allowUntrustedTls = false) {
+    const value = input;
+    if (typeof value?.url !== 'string')
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'URL is required.');
+    let url;
+    try {
+        url = new URL(value.url);
+    }
+    catch {
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'URL is invalid.');
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Only HTTP and HTTPS URLs are supported.');
+    return fetchWebUrl(url, signal, allowUntrustedTls);
+}
+async function fetchWebUrl(url, signal, allowUntrustedTls, redirects = 0) {
+    if (redirects > 5)
+        throw new MarAgentError('MAR_AGENT_WEB_FETCH_FAILED', 'Too many redirects.');
+    return new Promise((resolve, reject) => {
+        const request = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, {
+            signal,
+            headers: {
+                accept: 'text/html,application/json,text/plain;q=0.9,*/*;q=0.1',
+                'accept-encoding': 'identity',
+                'user-agent': 'MyAgentRoam/0.9'
+            },
+            ...(url.protocol === 'https:' ? { rejectUnauthorized: !allowUntrustedTls } : {})
+        }, (response) => {
+            const status = response.statusCode ?? 0;
+            if (status >= 300 && status < 400 && response.headers.location) {
+                response.resume();
+                void fetchWebUrl(new URL(response.headers.location, url), signal, allowUntrustedTls, redirects + 1).then(resolve, reject);
+                return;
+            }
+            if (status < 200 || status >= 300) {
+                response.resume();
+                reject(new MarAgentError('MAR_AGENT_WEB_FETCH_FAILED', `HTTP ${status}.`));
+                return;
+            }
+            const contentType = String(response.headers['content-type'] ?? 'text/plain').toLowerCase();
+            if (!/^(text\/|application\/(json|xml|xhtml\+xml))/u.test(contentType)) {
+                response.resume();
+                reject(new MarAgentError('MAR_AGENT_WEB_FETCH_UNSUPPORTED_CONTENT', 'Response is not readable text.'));
+                return;
+            }
+            const chunks = [];
+            let bytes = 0;
+            let truncated = false;
+            response.on('data', (chunk) => {
+                if (bytes >= 1_000_000) {
+                    truncated = true;
+                    return;
+                }
+                const remaining = 1_000_000 - bytes;
+                chunks.push(chunk.subarray(0, remaining));
+                bytes += Math.min(chunk.length, remaining);
+                if (chunk.length > remaining)
+                    truncated = true;
+            });
+            response.on('end', () => resolve({
+                content: Buffer.concat(chunks).toString('utf8'),
+                data: { url: url.href, status },
+                truncated
+            }));
+            response.on('error', reject);
+        });
+        request.on('error', reject);
+        request.end();
+    });
+}

package/dist/agent-core/tools/local/web-search.d.ts

@@ -0,0 +1,7 @@
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ToolExecutionResult } from '../contracts.js';
+export declare const webSearchToolDefinition: ClientToolDefinition;
+export declare function executeWebSearch(input: unknown, signal: AbortSignal, search: (input: {
+    query: string;
+    maxResults: number;
+}, signal: AbortSignal) => Promise<ToolExecutionResult>): Promise<ToolExecutionResult>;

package/dist/agent-core/tools/local/web-search.js

@@ -0,0 +1,34 @@
+import { MarAgentError } from '../../error.js';
+export const webSearchToolDefinition = {
+    name: 'web_search',
+    allowedCallers: ['direct', 'programmatic'],
+    parallelSafety: 'safe',
+    description: 'Search the web for current information. Use web_fetch to open a specific result.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query.' },
+            maxResults: { type: 'integer', minimum: 1, maximum: 10, default: 8 }
+        },
+        required: ['query'],
+        additionalProperties: false
+    }
+};
+export async function executeWebSearch(input, signal, search) {
+    const value = input;
+    if (typeof value?.query !== 'string' || value.query.trim().length === 0)
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Search query is required.');
+    try {
+        return await search({
+            query: value.query.trim(),
+            maxResults: typeof value.maxResults === 'number'
+                ? Math.min(10, Math.max(1, Math.trunc(value.maxResults)))
+                : 8
+        }, signal);
+    }
+    catch (error) {
+        if (error instanceof MarAgentError)
+            throw error;
+        throw new MarAgentError('MAR_AGENT_WEB_SEARCH_FAILED', 'Web search failed.', { cause: error });
+    }
+}

package/dist/{tools/local-workspace-tools.js → agent-core/tools/local/workspace-tools.js}

@@ -1,7 +1,7 @@
 import { ApplyPatchTool } from './apply-patch.js';
 import { ExecTool } from './exec.js';
 import { ReadTool } from './read.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
 /** @deprecated Use the individual tool modules or LocalAgentHost. */
 export class LocalWorkspaceTools {
     #read;

package/dist/{sdk/mcp-catalog.d.ts → agent-core/tools/mcp/catalog.d.ts}

@@ -1,5 +1,4 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { McpToolCatalog } from './types.js';
+import type { ClientToolDefinition, McpToolCatalog } from '../contracts.js';
 export declare const MCP_DEFINITION_LIMITS: Readonly<{
     depth: 64;
     nodes: 32768;

package/dist/{sdk/mcp-catalog.js → agent-core/tools/mcp/catalog.js}

@@ -1,4 +1,4 @@
-import { MarAgentError } from '../error.js';
+import { MarAgentError } from '../../error.js';
 export const MCP_DEFINITION_LIMITS = Object.freeze({
     depth: 64,
     nodes: 32768,

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

@@ -0,0 +1,4 @@
+import type { ModelMessage } from '../../model/contracts.js';
+import type { DeferredMcpRegistry } from './tool-search.js';
+export declare function discoveredMcpToolNames(messages: readonly ModelMessage[]): string[];
+export declare function rebindMcpToolSearchOutputs(messages: readonly ModelMessage[], registry: DeferredMcpRegistry): void;

package/dist/agent-core/tools/mcp/history.js

@@ -0,0 +1,33 @@
+import { providerToolCallId, providerToolName } from '../../runtime/context/projection.js';
+export function discoveredMcpToolNames(messages) {
+    const calls = toolSearchCallIds(messages);
+    const names = new Set();
+    for (const message of messages)
+        for (const tool of calls.has(message.callId ?? '') ? (message.toolSearchTools ?? []) : [])
+            if (tool.name.startsWith('mcp__'))
+                names.add(tool.name);
+    return [...names];
+}
+export function rebindMcpToolSearchOutputs(messages, registry) {
+    const calls = toolSearchCallIds(messages);
+    for (const message of messages) {
+        if (!message.toolSearchTools)
+            continue;
+        if (!calls.has(message.callId ?? '')) {
+            delete message.toolSearchTools;
+            continue;
+        }
+        const definitions = registry.restoredDefinitions(message.toolSearchTools.map((tool) => tool.name));
+        message.toolSearchTools = definitions;
+    }
+}
+function toolSearchCallIds(messages) {
+    return new Set(messages
+        .filter((message) => (message.role === 'tool_call' &&
+        message.name === 'tool_search' &&
+        typeof message.callId === 'string') ||
+        (message.role === 'provider' &&
+            providerToolName(message) === 'tool_search' &&
+            providerToolCallId(message) !== undefined))
+        .map((message) => message.role === 'provider' ? providerToolCallId(message) : message.callId));
+}

package/dist/{tools → agent-core/tools/mcp}/tool-search.d.ts

@@ -1,6 +1,6 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import type { McpCatalogTool, McpToolCatalog, ToolExecutionResult } from '../sdk/types.js';
-import type { ToolRuntimeContext } from './runtime-context.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { McpCatalogTool, McpToolCatalog, ToolExecutionResult } from '../contracts.js';
+import type { ToolRuntimeContext } from '../runtime-context.js';
 export declare const TOOL_SEARCH_LIMITS: Readonly<{
     defaultLimit: 5;
     maximumLimit: 20;

package/dist/{tools → agent-core/tools/mcp}/tool-search.js

@@ -1,7 +1,7 @@
-import { MarAgentError } from '../error.js';
-import { assertMcpToolCatalog } from '../sdk/mcp-catalog.js';
-import { countModelTokens } from '../runtime/token-budget.js';
-import { projectCodeModeSearchResult, projectCodeModeTools } from './code-mode.js';
+import { MarAgentError } from '../../error.js';
+import { countModelTokens } from '../../runtime/token-budget.js';
+import { projectCodeModeSearchResult, projectCodeModeTools } from '../code-mode/index.js';
+import { assertMcpToolCatalog } from './catalog.js';
 export const TOOL_SEARCH_LIMITS = Object.freeze({
     defaultLimit: 5,
     maximumLimit: 20,

package/dist/agent-core/tools/output-projection.d.ts

@@ -0,0 +1,14 @@
+import type { SubagentTaskSnapshot } from '../subagent/contracts.js';
+import type { ApplyPatchResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ReadEventData, ViewImageResult } from './contracts.js';
+import type { ToolRuntimeImage } from './runtime-context.js';
+export declare function currentExecutionImages(modelInputImages: readonly {
+    readonly mimeType: string;
+    readonly dataBase64: string;
+}[] | undefined, toolImages: readonly ToolRuntimeImage[]): ToolRuntimeImage[];
+export declare function boundedModelToolOutput(toolName: string, value: string, data: unknown): {
+    content: string;
+    truncated: boolean;
+};
+/** Project only known, validated tool result shapes into public structured events. */
+export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | undefined;
+export declare function structuredToolArtifacts(value: readonly MarAgentToolArtifact[] | undefined): readonly MarAgentToolArtifact[] | undefined;