@anthropic-field/core 0.1.0

package/dist/src/tools/tool-names.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const GLOB_TOOL_NAME = "glob";
+export declare const WRITE_TODOS_TOOL_NAME = "write_todos";
+export declare const WRITE_FILE_TOOL_NAME = "write_file";
+export declare const WEB_SEARCH_TOOL_NAME = "google_web_search";
+export declare const WEB_FETCH_TOOL_NAME = "web_fetch";
+export declare const EDIT_TOOL_NAME = "replace";
+export declare const SHELL_TOOL_NAME = "run_shell_command";
+export declare const GREP_TOOL_NAME = "search_file_content";
+export declare const READ_MANY_FILES_TOOL_NAME = "read_many_files";
+export declare const READ_FILE_TOOL_NAME = "read_file";
+export declare const LS_TOOL_NAME = "list_directory";
+export declare const MEMORY_TOOL_NAME = "save_memory";
+export declare const GET_INTERNAL_DOCS_TOOL_NAME = "get_internal_docs";
+export declare const ACTIVATE_SKILL_TOOL_NAME = "activate_skill";
+export declare const EDIT_TOOL_NAMES: Set<string>;
+export declare const ASK_USER_TOOL_NAME = "ask_user";
+export declare const ASK_USER_DISPLAY_NAME = "Ask User";
+/** Prefix used for tools discovered via the toolDiscoveryCommand. */
+export declare const DISCOVERED_TOOL_PREFIX = "discovered_tool_";
+/**
+ * List of all built-in tool names.
+ */
+export declare const ALL_BUILTIN_TOOL_NAMES: readonly ["glob", "write_todos", "write_file", "google_web_search", "web_fetch", "replace", "run_shell_command", "search_file_content", "read_many_files", "read_file", "list_directory", "save_memory", "activate_skill", "ask_user"];
+/**
+ * Read-only tools available in Plan Mode.
+ * This list is used to dynamically generate the Plan Mode prompt,
+ * filtered by what tools are actually enabled in the current configuration.
+ */
+export declare const PLAN_MODE_TOOLS: readonly ["glob", "search_file_content", "read_file", "list_directory", "google_web_search", "ask_user"];
+/**
+ * Validates if a tool name is syntactically valid.
+ * Checks against built-in tools, discovered tools, and MCP naming conventions.
+ */
+export declare function isValidToolName(name: string, options?: {
+    allowWildcards?: boolean;
+}): boolean;

package/dist/src/tools/tool-names.js

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Centralized constants for tool names.
+// This prevents circular dependencies that can occur when other modules (like agents)
+// need to reference a tool's name without importing the tool's implementation.
+export const GLOB_TOOL_NAME = 'glob';
+export const WRITE_TODOS_TOOL_NAME = 'write_todos';
+export const WRITE_FILE_TOOL_NAME = 'write_file';
+export const WEB_SEARCH_TOOL_NAME = 'google_web_search';
+export const WEB_FETCH_TOOL_NAME = 'web_fetch';
+export const EDIT_TOOL_NAME = 'replace';
+export const SHELL_TOOL_NAME = 'run_shell_command';
+export const GREP_TOOL_NAME = 'search_file_content';
+export const READ_MANY_FILES_TOOL_NAME = 'read_many_files';
+export const READ_FILE_TOOL_NAME = 'read_file';
+export const LS_TOOL_NAME = 'list_directory';
+export const MEMORY_TOOL_NAME = 'save_memory';
+export const GET_INTERNAL_DOCS_TOOL_NAME = 'get_internal_docs';
+export const ACTIVATE_SKILL_TOOL_NAME = 'activate_skill';
+export const EDIT_TOOL_NAMES = new Set([EDIT_TOOL_NAME, WRITE_FILE_TOOL_NAME]);
+export const ASK_USER_TOOL_NAME = 'ask_user';
+export const ASK_USER_DISPLAY_NAME = 'Ask User';
+/** Prefix used for tools discovered via the toolDiscoveryCommand. */
+export const DISCOVERED_TOOL_PREFIX = 'discovered_tool_';
+/**
+ * List of all built-in tool names.
+ */
+export const ALL_BUILTIN_TOOL_NAMES = [
+    GLOB_TOOL_NAME,
+    WRITE_TODOS_TOOL_NAME,
+    WRITE_FILE_TOOL_NAME,
+    WEB_SEARCH_TOOL_NAME,
+    WEB_FETCH_TOOL_NAME,
+    EDIT_TOOL_NAME,
+    SHELL_TOOL_NAME,
+    GREP_TOOL_NAME,
+    READ_MANY_FILES_TOOL_NAME,
+    READ_FILE_TOOL_NAME,
+    LS_TOOL_NAME,
+    MEMORY_TOOL_NAME,
+    ACTIVATE_SKILL_TOOL_NAME,
+    ASK_USER_TOOL_NAME,
+];
+/**
+ * Read-only tools available in Plan Mode.
+ * This list is used to dynamically generate the Plan Mode prompt,
+ * filtered by what tools are actually enabled in the current configuration.
+ */
+export const PLAN_MODE_TOOLS = [
+    GLOB_TOOL_NAME,
+    GREP_TOOL_NAME,
+    READ_FILE_TOOL_NAME,
+    LS_TOOL_NAME,
+    WEB_SEARCH_TOOL_NAME,
+    ASK_USER_TOOL_NAME,
+];
+/**
+ * Validates if a tool name is syntactically valid.
+ * Checks against built-in tools, discovered tools, and MCP naming conventions.
+ */
+export function isValidToolName(name, options = {}) {
+    // Built-in tools
+    if (ALL_BUILTIN_TOOL_NAMES.includes(name)) {
+        return true;
+    }
+    // Discovered tools
+    if (name.startsWith(DISCOVERED_TOOL_PREFIX)) {
+        return true;
+    }
+    // Policy wildcards
+    if (options.allowWildcards && name === '*') {
+        return true;
+    }
+    // MCP tools (format: server__tool)
+    if (name.includes('__')) {
+        const parts = name.split('__');
+        if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {
+            return false;
+        }
+        const server = parts[0];
+        const tool = parts[1];
+        if (tool === '*') {
+            return !!options.allowWildcards;
+        }
+        // Basic slug validation for server and tool names
+        const slugRegex = /^[a-z0-9-_]+$/i;
+        return slugRegex.test(server) && slugRegex.test(tool);
+    }
+    return false;
+}
+//# sourceMappingURL=tool-names.js.map

package/dist/src/tools/tool-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-names.js","sourceRoot":"","sources":["../../../src/tools/tool-names.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/tool-registry.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FunctionDeclaration } from '@google/genai';
+import type { AnyDeclarativeTool, ToolResult, ToolInvocation } from './tools.js';
+import { BaseDeclarativeTool } from './tools.js';
+import type { Config } from '../config/config.js';
+import type { MessageBus } from '../confirmation-bus/message-bus.js';
+type ToolParams = Record<string, unknown>;
+export declare class DiscoveredTool extends BaseDeclarativeTool<ToolParams, ToolResult> {
+    private readonly config;
+    readonly parameterSchema: Record<string, unknown>;
+    private readonly originalName;
+    constructor(config: Config, originalName: string, prefixedName: string, description: string, parameterSchema: Record<string, unknown>, messageBus: MessageBus);
+    protected createInvocation(params: ToolParams, messageBus: MessageBus, _toolName?: string, _displayName?: string): ToolInvocation<ToolParams, ToolResult>;
+}
+export declare class ToolRegistry {
+    private allKnownTools;
+    private config;
+    private messageBus;
+    constructor(config: Config, messageBus: MessageBus);
+    getMessageBus(): MessageBus;
+    /**
+     * Registers a tool definition.
+     *
+     * Note that excluded tools are still registered to allow for enabling them
+     * later in the session.
+     *
+     * @param tool - The tool object containing schema and execution logic.
+     */
+    registerTool(tool: AnyDeclarativeTool): void;
+    /**
+     * Unregisters a tool definition by name.
+     *
+     * @param name - The name of the tool to unregister.
+     */
+    unregisterTool(name: string): void;
+    /**
+     * Sorts tools as:
+     * 1. Built in tools.
+     * 2. Discovered tools.
+     * 3. MCP tools ordered by server name.
+     *
+     * This is a stable sort in that tries preserve existing order.
+     */
+    sortTools(): void;
+    private removeDiscoveredTools;
+    /**
+     * Removes all tools from a specific MCP server.
+     * @param serverName The name of the server to remove tools from.
+     */
+    removeMcpToolsByServer(serverName: string): void;
+    /**
+     * Discovers tools from project (if available and configured).
+     * Can be called multiple times to update discovered tools.
+     * This will discover tools from the command line and from MCP servers.
+     */
+    discoverAllTools(): Promise<void>;
+    private discoverAndRegisterToolsFromCommand;
+    /**
+     * @returns All the tools that are not excluded.
+     */
+    private getActiveTools;
+    /**
+     * @param tool
+     * @param excludeTools (optional, helps performance for repeated calls)
+     * @returns Whether or not the `tool` is not excluded.
+     */
+    private isActiveTool;
+    /**
+     * Retrieves the list of tool schemas (FunctionDeclaration array).
+     * Extracts the declarations from the ToolListUnion structure.
+     * Includes discovered (vs registered) tools if configured.
+     * @returns An array of FunctionDeclarations.
+     */
+    getFunctionDeclarations(): FunctionDeclaration[];
+    /**
+     * Retrieves a filtered list of tool schemas based on a list of tool names.
+     * @param toolNames - An array of tool names to include.
+     * @returns An array of FunctionDeclarations for the specified tools.
+     */
+    getFunctionDeclarationsFiltered(toolNames: string[]): FunctionDeclaration[];
+    /**
+     * Returns an array of all registered and discovered tool names which are not
+     * excluded via configuration.
+     */
+    getAllToolNames(): string[];
+    /**
+     * Returns an array of all registered and discovered tool instances.
+     */
+    getAllTools(): AnyDeclarativeTool[];
+    /**
+     * Returns an array of tools registered from a specific MCP server.
+     */
+    getToolsByServer(serverName: string): AnyDeclarativeTool[];
+    /**
+     * Get the definition of a specific tool.
+     */
+    getTool(name: string): AnyDeclarativeTool | undefined;
+}
+export {};

package/dist/src/tools/tool-registry.js

@@ -0,0 +1,429 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Kind, BaseDeclarativeTool, BaseToolInvocation } from './tools.js';
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+import { DiscoveredMCPTool } from './mcp-tool.js';
+import { parse } from 'shell-quote';
+import { ToolErrorType } from './tool-error.js';
+import { safeJsonStringify } from '../utils/safeJsonStringify.js';
+import { debugLogger } from '../utils/debugLogger.js';
+import { coreEvents } from '../utils/events.js';
+import { DISCOVERED_TOOL_PREFIX } from './tool-names.js';
+class DiscoveredToolInvocation extends BaseToolInvocation {
+    config;
+    originalToolName;
+    constructor(config, originalToolName, prefixedToolName, params, messageBus) {
+        super(params, messageBus, prefixedToolName);
+        this.config = config;
+        this.originalToolName = originalToolName;
+    }
+    getDescription() {
+        return safeJsonStringify(this.params);
+    }
+    async execute(_signal, _updateOutput) {
+        const callCommand = this.config.getToolCallCommand();
+        const child = spawn(callCommand, [this.originalToolName]);
+        child.stdin.write(JSON.stringify(this.params));
+        child.stdin.end();
+        let stdout = '';
+        let stderr = '';
+        let error = null;
+        let code = null;
+        let signal = null;
+        await new Promise((resolve) => {
+            const onStdout = (data) => {
+                stdout += data?.toString();
+            };
+            const onStderr = (data) => {
+                stderr += data?.toString();
+            };
+            const onError = (err) => {
+                error = err;
+            };
+            const onClose = (_code, _signal) => {
+                code = _code;
+                signal = _signal;
+                cleanup();
+                resolve();
+            };
+            const cleanup = () => {
+                child.stdout.removeListener('data', onStdout);
+                child.stderr.removeListener('data', onStderr);
+                child.removeListener('error', onError);
+                child.removeListener('close', onClose);
+                if (child.connected) {
+                    child.disconnect();
+                }
+            };
+            child.stdout.on('data', onStdout);
+            child.stderr.on('data', onStderr);
+            child.on('error', onError);
+            child.on('close', onClose);
+        });
+        // if there is any error, non-zero exit code, signal, or stderr, return error details instead of stdout
+        if (error || code !== 0 || signal || stderr) {
+            const llmContent = [
+                `Stdout: ${stdout || '(empty)'}`,
+                `Stderr: ${stderr || '(empty)'}`,
+                `Error: ${error ?? '(none)'}`,
+                `Exit Code: ${code ?? '(none)'}`,
+                `Signal: ${signal ?? '(none)'}`,
+            ].join('\n');
+            return {
+                llmContent,
+                returnDisplay: llmContent,
+                error: {
+                    message: llmContent,
+                    type: ToolErrorType.DISCOVERED_TOOL_EXECUTION_ERROR,
+                },
+            };
+        }
+        return {
+            llmContent: stdout,
+            returnDisplay: stdout,
+        };
+    }
+}
+export class DiscoveredTool extends BaseDeclarativeTool {
+    config;
+    parameterSchema;
+    originalName;
+    constructor(config, originalName, prefixedName, description, parameterSchema, messageBus) {
+        const discoveryCmd = config.getToolDiscoveryCommand();
+        const callCommand = config.getToolCallCommand();
+        const fullDescription = description +
+            `
+
+This tool was discovered from the project by executing the command \`${discoveryCmd}\` on project root.
+When called, this tool will execute the command \`${callCommand} ${originalName}\` on project root.
+Tool discovery and call commands can be configured in project or user settings.
+
+When called, the tool call command is executed as a subprocess.
+On success, tool output is returned as a json string.
+Otherwise, the following information is returned:
+
+Stdout: Output on stdout stream. Can be \`(empty)\` or partial.
+Stderr: Output on stderr stream. Can be \`(empty)\` or partial.
+Error: Error or \`(none)\` if no error was reported for the subprocess.
+Exit Code: Exit code or \`(none)\` if terminated by signal.
+Signal: Signal number or \`(none)\` if no signal was received.
+`;
+        super(prefixedName, prefixedName, fullDescription, Kind.Other, parameterSchema, messageBus, false, // isOutputMarkdown
+        false);
+        this.config = config;
+        this.parameterSchema = parameterSchema;
+        this.originalName = originalName;
+    }
+    createInvocation(params, messageBus, _toolName, _displayName) {
+        return new DiscoveredToolInvocation(this.config, this.originalName, _toolName ?? this.name, params, messageBus);
+    }
+}
+export class ToolRegistry {
+    // The tools keyed by tool name as seen by the LLM.
+    // This includes tools which are currently not active, use `getActiveTools`
+    // and `isActive` to get only the active tools.
+    allKnownTools = new Map();
+    config;
+    messageBus;
+    constructor(config, messageBus) {
+        this.config = config;
+        this.messageBus = messageBus;
+    }
+    getMessageBus() {
+        return this.messageBus;
+    }
+    /**
+     * Registers a tool definition.
+     *
+     * Note that excluded tools are still registered to allow for enabling them
+     * later in the session.
+     *
+     * @param tool - The tool object containing schema and execution logic.
+     */
+    registerTool(tool) {
+        if (this.allKnownTools.has(tool.name)) {
+            if (tool instanceof DiscoveredMCPTool) {
+                tool = tool.asFullyQualifiedTool();
+            }
+            else {
+                // Decide on behavior: throw error, log warning, or allow overwrite
+                debugLogger.warn(`Tool with name "${tool.name}" is already registered. Overwriting.`);
+            }
+        }
+        this.allKnownTools.set(tool.name, tool);
+    }
+    /**
+     * Unregisters a tool definition by name.
+     *
+     * @param name - The name of the tool to unregister.
+     */
+    unregisterTool(name) {
+        this.allKnownTools.delete(name);
+    }
+    /**
+     * Sorts tools as:
+     * 1. Built in tools.
+     * 2. Discovered tools.
+     * 3. MCP tools ordered by server name.
+     *
+     * This is a stable sort in that tries preserve existing order.
+     */
+    sortTools() {
+        const getPriority = (tool) => {
+            if (tool instanceof DiscoveredMCPTool)
+                return 2;
+            if (tool instanceof DiscoveredTool)
+                return 1;
+            return 0; // Built-in
+        };
+        this.allKnownTools = new Map(Array.from(this.allKnownTools.entries()).sort((a, b) => {
+            const toolA = a[1];
+            const toolB = b[1];
+            const priorityA = getPriority(toolA);
+            const priorityB = getPriority(toolB);
+            if (priorityA !== priorityB) {
+                return priorityA - priorityB;
+            }
+            if (priorityA === 2) {
+                const serverA = toolA.serverName;
+                const serverB = toolB.serverName;
+                return serverA.localeCompare(serverB);
+            }
+            return 0;
+        }));
+    }
+    removeDiscoveredTools() {
+        for (const tool of this.allKnownTools.values()) {
+            if (tool instanceof DiscoveredTool || tool instanceof DiscoveredMCPTool) {
+                this.allKnownTools.delete(tool.name);
+            }
+        }
+    }
+    /**
+     * Removes all tools from a specific MCP server.
+     * @param serverName The name of the server to remove tools from.
+     */
+    removeMcpToolsByServer(serverName) {
+        for (const [name, tool] of this.allKnownTools.entries()) {
+            if (tool instanceof DiscoveredMCPTool && tool.serverName === serverName) {
+                this.allKnownTools.delete(name);
+            }
+        }
+    }
+    /**
+     * Discovers tools from project (if available and configured).
+     * Can be called multiple times to update discovered tools.
+     * This will discover tools from the command line and from MCP servers.
+     */
+    async discoverAllTools() {
+        // remove any previously discovered tools
+        this.removeDiscoveredTools();
+        await this.discoverAndRegisterToolsFromCommand();
+    }
+    async discoverAndRegisterToolsFromCommand() {
+        const discoveryCmd = this.config.getToolDiscoveryCommand();
+        if (!discoveryCmd) {
+            return;
+        }
+        try {
+            const cmdParts = parse(discoveryCmd);
+            if (cmdParts.length === 0) {
+                throw new Error('Tool discovery command is empty or contains only whitespace.');
+            }
+            const proc = spawn(cmdParts[0], cmdParts.slice(1));
+            let stdout = '';
+            const stdoutDecoder = new StringDecoder('utf8');
+            let stderr = '';
+            const stderrDecoder = new StringDecoder('utf8');
+            let sizeLimitExceeded = false;
+            const MAX_STDOUT_SIZE = 10 * 1024 * 1024; // 10MB limit
+            const MAX_STDERR_SIZE = 10 * 1024 * 1024; // 10MB limit
+            let stdoutByteLength = 0;
+            let stderrByteLength = 0;
+            proc.stdout.on('data', (data) => {
+                if (sizeLimitExceeded)
+                    return;
+                if (stdoutByteLength + data.length > MAX_STDOUT_SIZE) {
+                    sizeLimitExceeded = true;
+                    proc.kill();
+                    return;
+                }
+                stdoutByteLength += data.length;
+                stdout += stdoutDecoder.write(data);
+            });
+            proc.stderr.on('data', (data) => {
+                if (sizeLimitExceeded)
+                    return;
+                if (stderrByteLength + data.length > MAX_STDERR_SIZE) {
+                    sizeLimitExceeded = true;
+                    proc.kill();
+                    return;
+                }
+                stderrByteLength += data.length;
+                stderr += stderrDecoder.write(data);
+            });
+            await new Promise((resolve, reject) => {
+                proc.on('error', reject);
+                proc.on('close', (code) => {
+                    stdout += stdoutDecoder.end();
+                    stderr += stderrDecoder.end();
+                    if (sizeLimitExceeded) {
+                        return reject(new Error(`Tool discovery command output exceeded size limit of ${MAX_STDOUT_SIZE} bytes.`));
+                    }
+                    if (code !== 0) {
+                        coreEvents.emitFeedback('error', `Tool discovery command failed with code ${code}.`, stderr);
+                        return reject(new Error(`Tool discovery command failed with exit code ${code}`));
+                    }
+                    resolve();
+                });
+            });
+            // execute discovery command and extract function declarations (w/ or w/o "tool" wrappers)
+            const functions = [];
+            const discoveredItems = JSON.parse(stdout.trim());
+            if (!discoveredItems || !Array.isArray(discoveredItems)) {
+                throw new Error('Tool discovery command did not return a JSON array of tools.');
+            }
+            for (const tool of discoveredItems) {
+                if (tool && typeof tool === 'object') {
+                    if (Array.isArray(tool['function_declarations'])) {
+                        functions.push(...tool['function_declarations']);
+                    }
+                    else if (Array.isArray(tool['functionDeclarations'])) {
+                        functions.push(...tool['functionDeclarations']);
+                    }
+                    else if (tool['name']) {
+                        functions.push(tool);
+                    }
+                }
+            }
+            // register each function as a tool
+            for (const func of functions) {
+                if (!func.name) {
+                    debugLogger.warn('Discovered a tool with no name. Skipping.');
+                    continue;
+                }
+                const parameters = func.parametersJsonSchema &&
+                    typeof func.parametersJsonSchema === 'object' &&
+                    !Array.isArray(func.parametersJsonSchema)
+                    ? func.parametersJsonSchema
+                    : {};
+                this.registerTool(new DiscoveredTool(this.config, func.name, DISCOVERED_TOOL_PREFIX + func.name, func.description ?? '', parameters, this.messageBus));
+            }
+        }
+        catch (e) {
+            debugLogger.error(`Tool discovery command "${discoveryCmd}" failed:`, e);
+            throw e;
+        }
+    }
+    /**
+     * @returns All the tools that are not excluded.
+     */
+    getActiveTools() {
+        const excludedTools = this.config.getExcludeTools() ?? new Set([]);
+        const activeTools = [];
+        for (const tool of this.allKnownTools.values()) {
+            if (this.isActiveTool(tool, excludedTools)) {
+                activeTools.push(tool);
+            }
+        }
+        return activeTools;
+    }
+    /**
+     * @param tool
+     * @param excludeTools (optional, helps performance for repeated calls)
+     * @returns Whether or not the `tool` is not excluded.
+     */
+    isActiveTool(tool, excludeTools) {
+        excludeTools ??= this.config.getExcludeTools() ?? new Set([]);
+        const normalizedClassName = tool.constructor.name.replace(/^_+/, '');
+        const possibleNames = [tool.name, normalizedClassName];
+        if (tool instanceof DiscoveredMCPTool) {
+            // Check both the unqualified and qualified name for MCP tools.
+            if (tool.name.startsWith(tool.getFullyQualifiedPrefix())) {
+                possibleNames.push(tool.name.substring(tool.getFullyQualifiedPrefix().length));
+            }
+            else {
+                possibleNames.push(`${tool.getFullyQualifiedPrefix()}${tool.name}`);
+            }
+        }
+        return !possibleNames.some((name) => excludeTools.has(name));
+    }
+    /**
+     * Retrieves the list of tool schemas (FunctionDeclaration array).
+     * Extracts the declarations from the ToolListUnion structure.
+     * Includes discovered (vs registered) tools if configured.
+     * @returns An array of FunctionDeclarations.
+     */
+    getFunctionDeclarations() {
+        const declarations = [];
+        this.getActiveTools().forEach((tool) => {
+            declarations.push(tool.schema);
+        });
+        return declarations;
+    }
+    /**
+     * Retrieves a filtered list of tool schemas based on a list of tool names.
+     * @param toolNames - An array of tool names to include.
+     * @returns An array of FunctionDeclarations for the specified tools.
+     */
+    getFunctionDeclarationsFiltered(toolNames) {
+        const declarations = [];
+        for (const name of toolNames) {
+            const tool = this.getTool(name);
+            if (tool) {
+                declarations.push(tool.schema);
+            }
+        }
+        return declarations;
+    }
+    /**
+     * Returns an array of all registered and discovered tool names which are not
+     * excluded via configuration.
+     */
+    getAllToolNames() {
+        return this.getActiveTools().map((tool) => tool.name);
+    }
+    /**
+     * Returns an array of all registered and discovered tool instances.
+     */
+    getAllTools() {
+        return this.getActiveTools().sort((a, b) => a.displayName.localeCompare(b.displayName));
+    }
+    /**
+     * Returns an array of tools registered from a specific MCP server.
+     */
+    getToolsByServer(serverName) {
+        const serverTools = [];
+        for (const tool of this.getActiveTools()) {
+            if (tool?.serverName === serverName) {
+                serverTools.push(tool);
+            }
+        }
+        return serverTools.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Get the definition of a specific tool.
+     */
+    getTool(name) {
+        let tool = this.allKnownTools.get(name);
+        if (!tool && name.includes('__')) {
+            for (const t of this.allKnownTools.values()) {
+                if (t instanceof DiscoveredMCPTool) {
+                    if (t.getFullyQualifiedName() === name) {
+                        tool = t;
+                        break;
+                    }
+                }
+            }
+        }
+        if (tool && this.isActiveTool(tool)) {
+            return tool;
+        }
+        return;
+    }
+}
+//# sourceMappingURL=tool-registry.js.map