@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -1,317 +0,0 @@
-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 { processImage, readImageMetadata } from './image-processing.js';
-export const viewImageToolDefinition = {
-    name: 'view_image',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'safe',
-    description: 'View a PNG, JPEG, or WebP image by path or Session resourceId. Relative paths use the workspace; absolute paths are allowed. Use this tool instead of converting images through exec.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Relative workspace path or absolute image path.' },
-            resourceId: { type: 'string', description: 'Session image resource ID, instead of path.' },
-            region: {
-                type: 'object',
-                description: 'For close inspection of a specific area; coordinates use oriented source pixels.',
-                properties: {
-                    x: { type: 'integer', minimum: 0 },
-                    y: { type: 'integer', minimum: 0 },
-                    width: { type: 'integer', minimum: 1 },
-                    height: { type: 'integer', minimum: 1 }
-                },
-                required: ['x', 'y', 'width', 'height'],
-                additionalProperties: false
-            },
-            resize: {
-                type: 'object',
-                description: 'For a smaller overview; fit the image or cropped region within these dimensions without enlargement.',
-                properties: {
-                    maxWidth: { type: 'integer', minimum: 1 },
-                    maxHeight: { type: 'integer', minimum: 1 }
-                },
-                additionalProperties: false
-            }
-        },
-        additionalProperties: false
-    }
-};
-export class ViewImageTool {
-    paths;
-    constructor(paths) {
-        this.paths = paths;
-    }
-    async execute(arguments_, signal) {
-        const input = parseViewImageInput(arguments_);
-        if (input.path === undefined)
-            return invalidInput();
-        signal?.throwIfAborted();
-        const path = await this.paths.resolve(input.path);
-        const handle = await open(path, 'r');
-        try {
-            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 > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes))
-                throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', `Image exceeds the ${TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes}-byte source limit. Use an external image tool to reduce it first.`);
-            const hasTransform = input.region !== undefined || input.resize !== undefined;
-            if (!hasTransform && stat.size > BigInt(TOOL_EXECUTION_LIMITS.viewImageMaxBytes))
-                throw imageOutputLimit('Image exceeds 3 MiB. Use resize or region.');
-            signal?.throwIfAborted();
-            const data = Buffer.allocUnsafe(Number(stat.size));
-            let offset = 0;
-            while (offset < data.byteLength) {
-                signal?.throwIfAborted();
-                const { bytesRead } = await handle.read(data, offset, data.byteLength - offset, offset);
-                if (bytesRead === 0)
-                    incompleteImage();
-                offset += bytesRead;
-            }
-            signal?.throwIfAborted();
-            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();
-            return await renderViewImage(data, input, signal);
-        }
-        finally {
-            await handle.close();
-        }
-    }
-}
-/** Resolve Session-owned bytes without using the resource's public URL or original path. */
-export async function viewResourceImage(arguments_, readResource, signal) {
-    const input = parseViewImageInput(arguments_);
-    if (input.resourceId === undefined)
-        return invalidInput();
-    signal?.throwIfAborted();
-    const resource = await readResource(input.resourceId);
-    signal?.throwIfAborted();
-    if (!resource)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Image resource was not found in this Session.');
-    const data = Buffer.from(resource.dataBase64, 'base64');
-    if (data.length > TOOL_EXECUTION_LIMITS.viewImageMaxSourceBytes)
-        throw imageOutputLimit('Image exceeds the source limit.');
-    if (!input.region && !input.resize && data.length > TOOL_EXECUTION_LIMITS.viewImageMaxBytes)
-        throw imageOutputLimit('Image exceeds 3 MiB. Use resize or region.');
-    return renderViewImage(data, input, signal);
-}
-async function renderViewImage(data, input, signal) {
-    const mimeType = detectImageMime(data);
-    validateImageContainer(data, mimeType);
-    const sourceMetadata = await readImageMetadata(data, mimeType, signal);
-    if (input.region &&
-        (input.region.x > sourceMetadata.width ||
-            input.region.y > sourceMetadata.height ||
-            input.region.width > sourceMetadata.width - input.region.x ||
-            input.region.height > sourceMetadata.height - input.region.y))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Image region is outside the oriented source dimensions.');
-    const visual = input.region !== undefined || input.resize !== undefined
-        ? await processImage(data, sourceMetadata, input, signal)
-        : {
-            bytes: data,
-            width: sourceMetadata.width,
-            height: sourceMetadata.height,
-            mimeType
-        };
-    signal?.throwIfAborted();
-    const resultMetadata = {
-        ...(input.path ? { path: input.path } : { resourceId: input.resourceId }),
-        mimeType: visual.mimeType,
-        bytes: visual.bytes.byteLength,
-        width: visual.width,
-        height: visual.height,
-        ...('sourceWidth' in visual && visual.sourceWidth !== undefined
-            ? { sourceWidth: visual.sourceWidth, sourceHeight: visual.sourceHeight }
-            : {}),
-        ...('region' in visual && visual.region ? { region: visual.region } : {}),
-        sha256: createHash('sha256').update(visual.bytes).digest('hex')
-    };
-    return {
-        content: describeImageResult(resultMetadata),
-        data: resultMetadata,
-        images: [{ mimeType: visual.mimeType, dataBase64: visual.bytes.toString('base64') }]
-    };
-}
-function parseViewImageInput(value) {
-    if (!value || typeof value !== 'object')
-        return invalidInput();
-    const input = value;
-    if (Object.keys(input).some((key) => !['path', 'resourceId', 'region', 'resize'].includes(key)) ||
-        (input.path == null) === (input.resourceId == null) ||
-        (input.path != null && (typeof input.path !== 'string' || input.path.length === 0)) ||
-        (input.resourceId != null &&
-            (typeof input.resourceId !== 'string' || input.resourceId.length === 0)))
-        return invalidInput();
-    return {
-        ...(typeof input.path === 'string'
-            ? { path: input.path }
-            : { resourceId: input.resourceId }),
-        ...(input.region == null ? {} : { region: parseRegion(input.region) }),
-        ...(input.resize == null ? {} : { resize: parseResize(input.resize) })
-    };
-}
-function parseRegion(value) {
-    if (!isRecord(value) ||
-        Object.keys(value).some((key) => !['x', 'y', 'width', 'height'].includes(key)) ||
-        !Number.isSafeInteger(value.x) ||
-        value.x < 0 ||
-        !Number.isSafeInteger(value.y) ||
-        value.y < 0 ||
-        !isPositiveSafeInteger(value.width) ||
-        !isPositiveSafeInteger(value.height))
-        return invalidInput();
-    return {
-        x: value.x,
-        y: value.y,
-        width: value.width,
-        height: value.height
-    };
-}
-function parseResize(value) {
-    if (!isRecord(value) ||
-        (value.maxWidth == null && value.maxHeight == null) ||
-        Object.keys(value).some((key) => key !== 'maxWidth' && key !== 'maxHeight') ||
-        (value.maxWidth != null && !isPositiveSafeInteger(value.maxWidth)) ||
-        (value.maxHeight != null && !isPositiveSafeInteger(value.maxHeight)))
-        return invalidInput();
-    return {
-        ...(value.maxWidth == null ? {} : { maxWidth: value.maxWidth }),
-        ...(value.maxHeight == null ? {} : { maxHeight: value.maxHeight })
-    };
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isPositiveSafeInteger(value) {
-    return Number.isSafeInteger(value) && value > 0;
-}
-function describeImageResult(result) {
-    const details = [`${result.width}×${result.height} px`, result.mimeType, `${result.bytes} bytes`];
-    if (result.sourceWidth !== undefined && result.sourceHeight !== undefined)
-        details.push(`source ${result.sourceWidth}×${result.sourceHeight} px`);
-    if (result.region)
-        details.push(`region ${result.region.x},${result.region.y} ${result.region.width}×${result.region.height} px`);
-    return `Viewed image ${result.path ?? result.resourceId} (${details.join(', ')}).`;
-}
-function imageOutputLimit(message) {
-    return new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', message);
-}
-export function detectImageMime(data) {
-    if (data.length >= 8 &&
-        data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
-        return 'image/png';
-    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
-        return 'image/jpeg';
-    if (data.length >= 12 &&
-        data.subarray(0, 4).toString('ascii') === 'RIFF' &&
-        data.subarray(8, 12).toString('ascii') === 'WEBP')
-        return 'image/webp';
-    throw new MarAgentError('MAR_AGENT_IMAGE_FORMAT_UNSUPPORTED', 'Only PNG, JPEG, and WebP images are supported.');
-}
-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/local/workspace-tools.d.ts

@@ -1,12 +0,0 @@
-import { type ExecInput } from './exec.js';
-export type { ExecInput, ExecResult } from './exec.js';
-import { ReadTool } from './read.js';
-/** @deprecated Use the individual tool modules or LocalAgentHost. */
-export declare class LocalWorkspaceTools {
-    #private;
-    constructor(root: string, maxOutputBytes?: number);
-    read(input: Parameters<ReadTool['execute']>[0]): Promise<import("./read.js").BatchReadResult>;
-    applyPatch(patch: string): Promise<import("./apply-patch.js").ApplyPatchResult>;
-    exec(input: ExecInput): Promise<import("./exec.js").ExecResult>;
-    dispose(): Promise<void>;
-}

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

@@ -1,28 +0,0 @@
-import { ApplyPatchTool } from './apply-patch.js';
-import { ExecTool } from './exec.js';
-import { ReadTool } from './read.js';
-import { WorkspacePathResolver } from '../shared/path-resolver.js';
-/** @deprecated Use the individual tool modules or LocalAgentHost. */
-export class LocalWorkspaceTools {
-    #read;
-    #applyPatch;
-    #exec;
-    constructor(root, maxOutputBytes = 1_000_000) {
-        const paths = new WorkspacePathResolver(root);
-        this.#read = new ReadTool(paths);
-        this.#applyPatch = new ApplyPatchTool(paths);
-        this.#exec = new ExecTool(paths, maxOutputBytes);
-    }
-    read(input) {
-        return this.#read.execute(input);
-    }
-    applyPatch(patch) {
-        return this.#applyPatch.execute(patch);
-    }
-    exec(input) {
-        return this.#exec.execute(input);
-    }
-    dispose() {
-        return this.#exec.dispose();
-    }
-}

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

@@ -1,220 +0,0 @@
-import { MarAgentError } from '../../error.js';
-export const MCP_DEFINITION_LIMITS = Object.freeze({
-    depth: 64,
-    nodes: 32768,
-    definitionBytes: 256 * 1024,
-    catalogBytes: 16 * 1024 * 1024,
-    tools: 10000,
-    servers: 256
-});
-function invalid() {
-    throw new MarAgentError('MAR_AGENT_MCP_CATALOG_INVALID', 'MCP catalog contains invalid or oversized definitions.');
-}
-const record = (value) => value !== null &&
-    typeof value === 'object' &&
-    !Array.isArray(value) &&
-    [Object.prototype, null].includes(Object.getPrototypeOf(value));
-const text = (value, maximum) => typeof value === 'string' && value.length > 0 && value.length <= maximum;
-const onlyKeys = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
-/** Bound all JSON, including unknown extension keywords, before recursive lowering. */
-function assertJson(value) {
-    const stack = [{ value, depth: 0 }];
-    const seen = new Set();
-    let nodes = 0;
-    while (stack.length) {
-        const current = stack.pop();
-        if (current.exit) {
-            seen.delete(current.value);
-            continue;
-        }
-        if (++nodes > MCP_DEFINITION_LIMITS.nodes || current.depth > MCP_DEFINITION_LIMITS.depth)
-            invalid();
-        const item = current.value;
-        if (item === null ||
-            typeof item === 'string' ||
-            typeof item === 'boolean' ||
-            (typeof item === 'number' && Number.isFinite(item)))
-            continue;
-        if (!Array.isArray(item) && !record(item))
-            invalid();
-        if (seen.has(item))
-            invalid();
-        seen.add(item);
-        stack.push({ value: item, depth: current.depth, exit: true });
-        for (const child of Object.values(item))
-            stack.push({ value: child, depth: current.depth + 1 });
-    }
-}
-function assertSchema(schema) {
-    if (!record(schema) || schema.type !== 'object')
-        invalid();
-    assertJson(schema);
-    const stack = [schema];
-    const types = new Set(['null', 'boolean', 'object', 'array', 'number', 'integer', 'string']);
-    while (stack.length) {
-        const value = stack.pop();
-        if (typeof value === 'boolean')
-            continue;
-        if (!record(value))
-            invalid();
-        if (value.type !== undefined) {
-            const entries = Array.isArray(value.type) ? value.type : [value.type];
-            if (!entries.length ||
-                new Set(entries).size !== entries.length ||
-                entries.some((type) => typeof type !== 'string' || !types.has(type)))
-                invalid();
-        }
-        if (value.required !== undefined &&
-            (!Array.isArray(value.required) ||
-                value.required.some((name) => typeof name !== 'string') ||
-                new Set(value.required).size !== value.required.length))
-            invalid();
-        for (const key of [
-            'properties',
-            'patternProperties',
-            '$defs',
-            'definitions',
-            'dependentSchemas'
-        ]) {
-            const children = value[key];
-            if (children === undefined)
-                continue;
-            if (!record(children))
-                invalid();
-            stack.push(...Object.values(children));
-        }
-        for (const key of ['allOf', 'anyOf', 'oneOf', 'prefixItems']) {
-            const children = value[key];
-            if (children === undefined)
-                continue;
-            if (!Array.isArray(children) || !children.length)
-                invalid();
-            stack.push(...children);
-        }
-        for (const key of [
-            'additionalProperties',
-            'unevaluatedProperties',
-            'additionalItems',
-            'unevaluatedItems',
-            'contains',
-            'propertyNames',
-            'not',
-            'if',
-            'then',
-            'else',
-            'items'
-        ]) {
-            const child = value[key];
-            if (child !== undefined) {
-                if (key === 'items' && Array.isArray(child))
-                    stack.push(...child);
-                else
-                    stack.push(child);
-            }
-        }
-        for (const key of ['$ref', '$id', '$schema', 'title', 'description', 'format', 'pattern'])
-            if (value[key] !== undefined && typeof value[key] !== 'string')
-                invalid();
-        for (const key of ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'])
-            if (value[key] !== undefined &&
-                (typeof value[key] !== 'number' ||
-                    !Number.isFinite(value[key]) ||
-                    (key === 'multipleOf' && Number(value[key]) <= 0)))
-                invalid();
-        for (const key of [
-            'minLength',
-            'maxLength',
-            'minItems',
-            'maxItems',
-            'minProperties',
-            'maxProperties'
-        ])
-            if (value[key] !== undefined && (!Number.isSafeInteger(value[key]) || Number(value[key]) < 0))
-                invalid();
-        if (value.enum !== undefined && (!Array.isArray(value.enum) || !value.enum.length))
-            invalid();
-    }
-}
-/** Shared Host and Node publication boundary, not a provider-specific conversion. */
-export function assertMcpToolDefinition(value, options = {}) {
-    if (!record(value) ||
-        !text(value.name, 256) ||
-        (!options.nativeToolNames && !/^mcp__[A-Za-z0-9_-]+__[A-Za-z0-9_-]+$/u.test(value.name)) ||
-        typeof value.description !== 'string' ||
-        value.description.length > 65536 ||
-        (value.parallelSafety !== undefined &&
-            !['safe', 'serial'].includes(String(value.parallelSafety))) ||
-        (value.agentScope !== undefined &&
-            !['ROOT_AND_SUBAGENTS', 'ROOT_ONLY'].includes(String(value.agentScope))) ||
-        (value.allowedCallers !== undefined &&
-            (!Array.isArray(value.allowedCallers) ||
-                !value.allowedCallers.length ||
-                value.allowedCallers.some((caller) => caller !== 'direct' && caller !== 'programmatic'))) ||
-        (value.codeModeExposure !== undefined && value.codeModeExposure !== 'both') ||
-        (value.inputMode !== undefined && value.inputMode !== 'json'))
-        invalid();
-    assertJson(value);
-    assertSchema(value.inputSchema);
-    if (value.outputSchema !== undefined)
-        assertSchema(value.outputSchema);
-    if (Buffer.byteLength(JSON.stringify(value)) > MCP_DEFINITION_LIMITS.definitionBytes)
-        invalid();
-}
-export function assertMcpToolCatalog(value, options = {}) {
-    if (!record(value) ||
-        typeof value.revision !== 'string' ||
-        value.revision.length > 512 ||
-        !onlyKeys(value, ['revision', 'servers', 'tools']) ||
-        !Array.isArray(value.servers) ||
-        value.servers.length > MCP_DEFINITION_LIMITS.servers ||
-        !Array.isArray(value.tools) ||
-        value.tools.length > MCP_DEFINITION_LIMITS.tools)
-        invalid();
-    const servers = new Set();
-    for (const server of value.servers) {
-        if (!record(server) ||
-            !text(server.id, 512) ||
-            !text(server.name, 256) ||
-            servers.has(server.id) ||
-            !onlyKeys(server, ['id', 'name', 'description', 'instructions']) ||
-            (server.description !== undefined &&
-                (typeof server.description !== 'string' || server.description.length > 65536)) ||
-            (server.instructions !== undefined &&
-                (typeof server.instructions !== 'string' || server.instructions.length > 65536)))
-            invalid();
-        servers.add(server.id);
-    }
-    const names = new Set();
-    for (const tool of value.tools) {
-        if (!record(tool) ||
-            !text(tool.serverId, 512) ||
-            !servers.has(tool.serverId) ||
-            !onlyKeys(tool, [
-                'definition',
-                'serverId',
-                'rawName',
-                'sourceIdentity',
-                'definitionRevision',
-                'lifetime',
-                'exposure',
-                'annotations'
-            ]) ||
-            !text(tool.rawName, 256) ||
-            !text(tool.sourceIdentity, 512) ||
-            !text(tool.definitionRevision, 512) ||
-            !['session', 'execution'].includes(String(tool.lifetime)) ||
-            !['direct', 'deferred'].includes(String(tool.exposure)))
-            invalid();
-        assertMcpToolDefinition(tool.definition, options);
-        if (tool.annotations !== undefined) {
-            if (!record(tool.annotations))
-                invalid();
-            assertJson(tool.annotations);
-        }
-        if (names.has(tool.definition.name))
-            invalid();
-        names.add(tool.definition.name);
-    }
-    if (Buffer.byteLength(JSON.stringify(value)) > MCP_DEFINITION_LIMITS.catalogBytes)
-        invalid();
-}

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

@@ -1,4 +0,0 @@
-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/tool-search.d.ts

@@ -1,45 +0,0 @@
-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;
-    queryBytes: 4096;
-    catalogBytes: number;
-    maximumDefinitionTokens: 16384;
-    definitionWindowFraction: 0.25;
-    minimumContinuationTokens: 1024;
-}>;
-export declare const toolSearchToolDefinition: ClientToolDefinition;
-export declare function parseToolSearchInput(input: unknown): {
-    query: string;
-    limit: number;
-};
-/** Deferred discovery state reconstructed from the current post-GC model history. */
-export declare class DeferredMcpRegistry {
-    #private;
-    constructor(discoveredNames: readonly string[]);
-    restore(discoveredNames: readonly string[]): void;
-    update(catalog: McpToolCatalog, eligible: (tool: McpCatalogTool) => boolean, options?: {
-        nativeToolNames?: boolean;
-    }): void;
-    get hasDeferred(): boolean;
-    snapshot(): readonly string[];
-    expectedTool(name: string): {
-        sourceIdentity: string;
-        definitionRevision: string;
-    } | undefined;
-    restoredDefinitions(names: readonly string[]): readonly ClientToolDefinition[];
-    projectDirect(base: readonly ClientToolDefinition[]): ClientToolDefinition[];
-    project(base: readonly ClientToolDefinition[], selection?: readonly string[], executionSelection?: Set<string>): ClientToolDefinition[];
-    search(query: string, limit: number): McpCatalogTool[];
-    expose(input: unknown, context: {
-        signal: AbortSignal;
-        base: readonly ClientToolDefinition[];
-        window: number;
-        system: string;
-    }): Promise<ToolExecutionResult>;
-    assertBudget(base: readonly ClientToolDefinition[], window: number, system: string, selection?: readonly string[], executionSelection?: ReadonlySet<string>): void;
-    navigation(): string | undefined;
-}
-export declare function executeToolSearch(input: unknown, context: ToolRuntimeContext): Promise<ToolExecutionResult>;