@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/server/MCPServer.search.js

@@ -1,137 +1,184 @@
-import { z } from 'zod';
 import { logger } from '../utils/logger.js';
 import { asErrorResponse } from './domains/shared/response.js';
-import { ALL_DOMAINS } from './registry/index.js';
+import { getAllDomains } from './registry/index.js';
+import { buildZodShape } from './MCPServer.schema.js';
 export { buildSearchSignature, getSearchEngine } from './MCPServer.search.helpers.js';
 export { buildDomainDescription } from './MCPServer.search.helpers.js';
 import { buildDomainDescription } from './MCPServer.search.helpers.js';
 import { handleSearchTools } from './MCPServer.search.handlers.search.js';
-import { handleActivateTools, handleDeactivateTools } from './MCPServer.search.handlers.activate.js';
+import { handleActivateTools, handleDeactivateTools, } from './MCPServer.search.handlers.activate.js';
 import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
 import { handleRouteTool, handleDescribeTool } from './MCPServer.search.handlers.route.js';
-import { handleExtensionsReload, handleExtensionsList } from './MCPServer.search.handlers.extensions.js';
-export function registerSearchMetaTools(ctx) {
-    ctx.server.registerTool('search_tools', {
-        description: buildDomainDescription(ctx),
-        inputSchema: {
-            query: z.string().describe('Search query: keywords, tool name, domain name, or description fragment'),
-            top_k: z.number().optional().describe('Max results to return (default: 10, max: 30)'),
+import { handleCallTool } from './MCPServer.search.handlers.call.js';
+function buildMetaToolDefinitions(ctx) {
+    return [
+        {
+            name: 'search_tools',
+            description: buildDomainDescription(ctx),
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query: keywords, tool name, domain name, or description fragment',
+                    },
+                    top_k: { type: 'number', description: 'Max results to return (default: 10, max: 30)' },
+                },
+                required: ['query'],
+            },
+            handler: handleSearchTools,
+        },
+        {
+            name: 'route_tool',
+            description: 'One-stop tool router: accepts a natural language task description, returns recommended tools and next actions. ' +
+                'Automatically detects workflow patterns, recommends activation order, and provides example arguments. ' +
+                'Use this instead of search_tools when you want guided tool discovery with actionable next steps.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: {
+                        type: 'string',
+                        description: 'Natural language description of the task you want to accomplish',
+                    },
+                    context: {
+                        type: 'object',
+                        description: 'Optional context hints for routing',
+                        properties: {
+                            preferredDomain: {
+                                type: 'string',
+                                description: 'Domain preference (e.g., "browser", "network")',
+                            },
+                            autoActivate: {
+                                type: 'boolean',
+                                description: 'Whether to auto-activate recommended tools (default: true)',
+                            },
+                            maxRecommendations: {
+                                type: 'number',
+                                description: 'Maximum number of recommendations (default: 5)',
+                            },
+                        },
+                    },
+                },
+                required: ['task'],
+            },
+            handler: handleRouteTool,
         },
-    }, async (args) => {
-        try {
-            return await handleSearchTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('search_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('route_tool', {
-        description: 'One-stop tool router: accepts a natural language task description, returns recommended tools and next actions. ' +
-            'Automatically detects workflow patterns, recommends activation order, and provides example arguments. ' +
-            'Use this instead of search_tools when you want guided tool discovery with actionable next steps.',
-        inputSchema: {
-            task: z.string().describe('Natural language description of the task you want to accomplish'),
-            context: z.object({
-                preferredDomain: z.string().optional().describe('Domain preference (e.g., "browser", "network")'),
-                autoActivate: z.boolean().optional().describe('Whether to auto-activate recommended tools (default: true)'),
-                maxRecommendations: z.number().optional().describe('Maximum number of recommendations (default: 5)'),
-            }).optional().describe('Optional context hints for routing'),
+        {
+            name: 'describe_tool',
+            description: 'Get detailed information about a specific tool, including its input schema. ' +
+                'Use this to see the exact parameters a tool expects before calling it.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Tool name to describe' },
+                },
+                required: ['name'],
+            },
+            handler: handleDescribeTool,
         },
-    }, async (args) => {
-        try {
-            return await handleRouteTool(ctx, args);
-        }
-        catch (error) {
-            logger.error('route_tool failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('describe_tool', {
-        description: 'Get detailed information about a specific tool, including its input schema. ' +
-            'Use this to see the exact parameters a tool expects before calling it.',
-        inputSchema: {
-            name: z.string().describe('Tool name to describe'),
+        {
+            name: 'activate_tools',
+            description: 'Dynamically register specific tools by name, regardless of current base tier. ' +
+                'Use after search_tools to enable exactly the tools you need. ' +
+                'In search-tier sessions this is usually enough; you do not need boost_profile just to use a few exact tools. ' +
+                'Activated tools appear in the tool list immediately. ' +
+                'If tools do not appear after activation, use call_tool to invoke them directly.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    names: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Array of tool names to activate (from search_tools results)',
+                    },
+                },
+                required: ['names'],
+            },
+            handler: handleActivateTools,
         },
-    }, async (args) => {
-        try {
-            return await handleDescribeTool(ctx, args);
-        }
-        catch (error) {
-            logger.error('describe_tool failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('activate_tools', {
-        description: 'Dynamically register specific tools by name, regardless of current base tier. ' +
-            'Use after search_tools to enable exactly the tools you need. ' +
-            'In search-tier sessions this is usually enough; you do not need boost_profile just to use a few exact tools. ' +
-            'Activated tools appear in the tool list immediately.',
-        inputSchema: {
-            names: z.array(z.string()).describe('Array of tool names to activate (from search_tools results)'),
+        {
+            name: 'deactivate_tools',
+            description: 'Remove previously activated tools to free context. ' +
+                'Only affects tools added via activate_tools, not base profile tools.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    names: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Array of tool names to deactivate',
+                    },
+                },
+                required: ['names'],
+            },
+            handler: handleDeactivateTools,
         },
-    }, async (args) => {
-        try {
-            return await handleActivateTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('activate_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('deactivate_tools', {
-        description: 'Remove previously activated tools to free context. ' +
-            'Only affects tools added via activate_tools, not base profile tools.',
-        inputSchema: {
-            names: z.array(z.string()).describe('Array of tool names to deactivate'),
+        {
+            name: 'activate_domain',
+            description: `Activate all tools in a domain at once. ` +
+                `Domains: ${[...getAllDomains()].join(', ')}. ` +
+                `Use extensions_reload first to include external plugin/workflow domains.`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    domain: {
+                        type: 'string',
+                        description: 'Domain name to activate (e.g. "debugger", "network")',
+                    },
+                    ttlMinutes: {
+                        type: 'number',
+                        description: 'Auto-deactivate after N minutes (default: 30, set 0 for no expiry)',
+                    },
+                },
+                required: ['domain'],
+            },
+            handler: handleActivateDomain,
         },
-    }, async (args) => {
-        try {
-            return await handleDeactivateTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('deactivate_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('activate_domain', {
-        description: `Activate all tools in a domain at once. ` +
-            `Domains: ${[...ALL_DOMAINS].join(', ')}. ` +
-            `Use extensions_reload first to include external plugin/workflow domains.`,
-        inputSchema: {
-            domain: z.string().describe('Domain name to activate (e.g. "debugger", "network")'),
+        {
+            name: 'call_tool',
+            description: 'Execute any tool by name with auto-activation. ' +
+                'Use this when activate_tools/activate_domain registered a tool but it does not appear in your tool list ' +
+                '(common for clients that do not support tools/list_changed notifications). ' +
+                "Accepts the tool name and its arguments object; returns the tool's native response.",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'The tool name to execute (from search_tools or describe_tool results)',
+                    },
+                    args: {
+                        type: 'object',
+                        description: 'Arguments object to pass to the tool',
+                        additionalProperties: true,
+                    },
+                },
+                required: ['name'],
+            },
+            handler: handleCallTool,
         },
-    }, async (args) => {
-        try {
-            return await handleActivateDomain(ctx, args);
-        }
-        catch (error) {
-            logger.error('activate_domain failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('extensions_list', {
-        description: 'List dynamically loaded extensions from plugins/workflows directories. ' +
-            'Shows loaded plugins, extension workflows, extension tools, and active roots.',
-    }, async () => {
-        try {
-            return await handleExtensionsList(ctx);
-        }
-        catch (error) {
-            logger.error('extensions_list failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('extensions_reload', {
-        description: 'Reload external extensions from plugins/ and workflows/ (or MCP_PLUGIN_ROOTS/MCP_WORKFLOW_ROOTS). ' +
-            'Dynamically registers extension tools and refreshes tool list.',
-    }, async () => {
-        try {
-            return await handleExtensionsReload(ctx);
-        }
-        catch (error) {
-            logger.error('extensions_reload failed', error);
-            return asErrorResponse(error);
-        }
-    });
+    ];
+}
+export function registerSearchMetaTools(ctx) {
+    const defs = buildMetaToolDefinitions(ctx);
+    for (const def of defs) {
+        const shape = buildZodShape(def.inputSchema);
+        ctx.server.registerTool(def.name, {
+            description: def.description,
+            inputSchema: shape,
+        }, async (args) => {
+            try {
+                return await def.handler(ctx, args);
+            }
+            catch (error) {
+                logger.error(`${def.name} failed`, error);
+                return asErrorResponse(error);
+            }
+        });
+        ctx.metaToolsByName.set(def.name, {
+            name: def.name,
+            description: def.description.split('\n')[0] || def.description,
+            inputSchema: def.inputSchema,
+        });
+    }
 }

package/dist/src/server/MCPServer.search.validation.d.ts

@@ -1,3 +1,4 @@
+export declare function normalizeToolName(name: string): string;
 export declare function validateToolNameArray(args: Record<string, unknown>): {
     names: string[];
     error?: string;

package/dist/src/server/MCPServer.search.validation.js

@@ -1,3 +1,14 @@
+export function normalizeToolName(name) {
+    const trimmed = name.trim();
+    if (!trimmed.startsWith('mcp__')) {
+        return trimmed;
+    }
+    const parts = trimmed.split('__');
+    if (parts.length < 3) {
+        return trimmed;
+    }
+    return parts.slice(2).join('__');
+}
 export function validateToolNameArray(args) {
     const raw = args.names;
     if (!Array.isArray(raw)) {
@@ -5,10 +16,10 @@ export function validateToolNameArray(args) {
     }
     const names = [];
     for (const item of raw) {
-        if (typeof item !== 'string' || item.length === 0) {
+        if (typeof item !== 'string' || item.trim().length === 0) {
             return { names: [], error: 'invalid tool name: expected non-empty string' };
         }
-        names.push(item);
+        names.push(normalizeToolName(item));
     }
     return { names };
 }

package/dist/src/server/MCPServer.tools.d.ts

@@ -2,4 +2,3 @@ import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { MCPServerContext } from './MCPServer.context.js';
 export declare function registerSingleTool(ctx: MCPServerContext, toolDef: Tool): RegisteredTool;
-export declare function registerMetaTools(ctx: MCPServerContext): void;

package/dist/src/server/MCPServer.tools.js

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { logger } from '../utils/logger.js';
 import { asErrorResponse, toolErrorToResponse } from './domains/shared/response.js';
 import { ToolError } from '../errors/ToolError.js';
-import { getToolsForProfile } from './ToolCatalog.js';
 import { buildZodShape } from './MCPServer.schema.js';
 function handleToolError(toolName, error) {
     if (error instanceof ToolError) {
@@ -12,7 +11,10 @@ function handleToolError(toolName, error) {
     return asErrorResponse(error);
 }
 export function registerSingleTool(ctx, toolDef) {
-    const shape = buildZodShape(toolDef.inputSchema);
+    const rawSchema = toolDef.inputSchema;
+    const shape = rawSchema && typeof rawSchema === 'object'
+        ? buildZodShape(rawSchema)
+        : {};
     const description = toolDef.description ?? toolDef.name;
     if (Object.keys(shape).length > 0) {
         return ctx.server.registerTool(toolDef.name, { description, inputSchema: shape }, async (args) => {
@@ -33,69 +35,3 @@ export function registerSingleTool(ctx, toolDef) {
         }
     });
 }
-export function registerMetaTools(ctx) {
-    const searchCount = getToolsForProfile('search').length;
-    const workflowCount = getToolsForProfile('workflow').length;
-    const fullCount = getToolsForProfile('full').length;
-    ctx.server.registerTool('boost_profile', {
-        description: 'Optionally upgrade the active tool tier. Three tiers: search → workflow → full. ' +
-            `search: maintenance only (${searchCount} tools) — use search_tools to discover and activate_tools to enable. ` +
-            `workflow: + browser, core analysis, debugger, network, streaming, encoding, graphql, workflows (${workflowCount} tools) and higher ranking for workflow search results. ` +
-            `full: + hooks, process, wasm, antidebug, platform, sourcemap, transform (${fullCount} tools). ` +
-            'Not required after search_tools for single-tool activation, because activate_tools can register exact matches directly across tiers. ' +
-            'Workflow-domain search ranking is configurable via SEARCH_WORKFLOW_BOOST_TIERS / SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER. ' +
-            'Auto-expires after TTL (default per-tier: workflow=60min, full=30min). Call unboost_profile to downgrade.',
-        inputSchema: {
-            target: z.string().optional().describe('Target tier: "workflow" or "full" (default: next tier up)'),
-            ttlMinutes: z
-                .number()
-                .optional()
-                .describe('Auto-downgrade after N minutes (default: per-tier, set 0 to disable)'),
-        },
-    }, async (args) => {
-        try {
-            const target = args.target ?? undefined;
-            const ttlMinutes = args.ttlMinutes;
-            const result = await ctx.boostProfile(target, ttlMinutes);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('boost_profile failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('unboost_profile', {
-        description: 'Downgrade to the previous tool tier (full → workflow → search). ' +
-            'Removes tools added by the last boost. Set target to drop directly to a specific tier.',
-        inputSchema: {
-            target: z
-                .string()
-                .optional()
-                .describe('Drop directly to this tier ("search" or "workflow"). Default: previous tier.'),
-        },
-    }, async (args) => {
-        try {
-            const target = args.target ?? undefined;
-            const result = await ctx.unboostProfile(target);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('unboost_profile failed', error);
-            return asErrorResponse(error);
-        }
-    });
-}

package/dist/src/server/MCPServer.transport.js

@@ -3,11 +3,34 @@ import { randomUUID } from 'node:crypto';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { MCP_HTTP_REQUEST_TIMEOUT_MS, MCP_HTTP_HEADERS_TIMEOUT_MS, MCP_HTTP_KEEPALIVE_TIMEOUT_MS, MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS, } from '../constants.js';
-import { checkAuth, checkOrigin, checkRateLimit, readBodyWithLimit } from './http/HttpMiddleware.js';
+import { checkAuth, checkOrigin, checkRateLimit, readBodyWithLimit, } from './http/HttpMiddleware.js';
 import { logger } from '../utils/logger.js';
 export async function startStdioTransport(ctx) {
     const transport = new StdioServerTransport();
     await ctx.server.connect(transport);
+    let shuttingDown = false;
+    const gracefulExit = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info('stdin closed — parent process gone, shutting down...');
+        try {
+            await closeServer(ctx);
+        }
+        catch {
+        }
+        process.exit(0);
+    };
+    process.stdin.on('end', gracefulExit);
+    process.stdin.on('close', gracefulExit);
+    process.stdout.on('error', (err) => {
+        if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') {
+            logger.info(`stdout error (${err.code}) — shutting down`);
+            closeServer(ctx)
+                .catch(() => { })
+                .finally(() => process.exit(0));
+        }
+    });
     logger.success('MCP stdio server started');
 }
 export async function startHttpTransport(ctx) {
@@ -36,7 +59,7 @@ export async function startHttpTransport(ctx) {
         if (!checkRateLimit(req, res, authenticated))
             return;
         if (req.method === 'GET' || req.method === 'DELETE') {
-            transport.handleRequest(req, res);
+            void transport.handleRequest(req, res);
             return;
         }
         if (req.method === 'POST') {
@@ -76,11 +99,10 @@ function handleHealthCheck(ctx, res) {
     };
     if (verbose) {
         const budgetStats = ctx.tokenBudget.getStats();
-        body.tier = ctx.currentTier;
+        body.tier = ctx.baseTier;
         body.baseTier = ctx.baseTier;
         body.enabledDomains = [...ctx.enabledDomains];
         body.registeredTools = ctx.selectedTools.length;
-        body.boostedTools = ctx.boostedToolNames.size;
         body.activatedTools = ctx.activatedToolNames.size;
         body.tokenBudget = {
             usagePercentage: budgetStats.usagePercentage,
@@ -92,10 +114,10 @@ function handleHealthCheck(ctx, res) {
     res.end(JSON.stringify(body));
 }
 export async function closeServer(ctx) {
-    if (ctx.boostTtlTimer) {
-        clearTimeout(ctx.boostTtlTimer);
-        ctx.boostTtlTimer = null;
+    for (const [, entry] of ctx.domainTtlEntries) {
+        clearTimeout(entry.timer);
     }
+    ctx.domainTtlEntries.clear();
     ctx.detailedData.shutdown();
     if (ctx.httpServer) {
         const httpServer = ctx.httpServer;
@@ -135,9 +157,19 @@ export async function closeServer(ctx) {
     ctx.debuggerManager = undefined;
     ctx.scriptManager = undefined;
     if (ctx.collector) {
-        await ctx.collector.close();
+        try {
+            await ctx.collector.close();
+        }
+        catch (error) {
+            logger.warn('collector cleanup failed:', error);
+        }
         ctx.collector = undefined;
     }
-    await ctx.server.close();
+    try {
+        await ctx.server.close();
+    }
+    catch (error) {
+        logger.warn('MCP server close failed:', error);
+    }
     logger.success('MCP server closed');
 }

package/dist/src/server/ToolCallContextGuard.js

@@ -52,6 +52,8 @@ export class ToolCallContextGuard {
             try {
                 const parsed = JSON.parse(raw);
                 if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                    if ('_tabContext' in parsed)
+                        return response;
                     firstText.text = this.spliceTabContext(raw, meta);
                     return response;
                 }
@@ -64,7 +66,12 @@ export class ToolCallContextGuard {
         return response;
     }
     spliceTabContext(raw, meta) {
-        const tabContext = { url: meta.url, title: meta.title, tabIndex: meta.tabIndex, pageId: meta.pageId };
+        const tabContext = {
+            url: meta.url,
+            title: meta.title,
+            tabIndex: meta.tabIndex,
+            pageId: meta.pageId,
+        };
         if (/\n\}\s*$/.test(raw)) {
             const prettyJson = JSON.stringify(tabContext, null, 2).replace(/\n/g, '\n  ');
             return raw.replace(/\n\}\s*$/, `,\n  "_tabContext": ${prettyJson}\n}`);

package/dist/src/server/ToolCatalog.d.ts

@@ -3,8 +3,7 @@ import type { ToolProfileId } from './registry/contracts.js';
 export type ToolDomain = string;
 export type ToolProfile = ToolProfileId;
 export declare const allTools: Tool[];
-export declare const TIER_ORDER: readonly ToolProfile[];
-export declare const TIER_DEFAULT_TTL: Readonly<Record<ToolProfile, number>>;
+export declare const TIER_ORDER: readonly ["search", "workflow", "full"];
 export declare function getTierIndex(profile: ToolProfile): number;
 export declare function parseToolDomains(raw: string | undefined): string[] | null;
 export declare function getToolsByDomains(domains: string[]): Tool[];

package/dist/src/server/ToolCatalog.js

@@ -1,4 +1,4 @@
-import { buildToolGroups, buildToolDomainMap, buildAllTools, buildProfileDomains, ALL_DOMAINS, } from './registry/index.js';
+import { buildToolGroups, buildToolDomainMap, buildAllTools, buildProfileDomains, getAllDomains, getAllRegistrations, getRegistrationByName, } from './registry/index.js';
 let _toolGroups = null;
 let _toolDomainByName = null;
 let _profileDomains = null;
@@ -28,11 +28,6 @@ export const allTools = new Proxy([], {
     },
 });
 export const TIER_ORDER = ['search', 'workflow', 'full'];
-export const TIER_DEFAULT_TTL = {
-    search: 0,
-    workflow: 60,
-    full: 30,
-};
 export function getTierIndex(profile) {
     return TIER_ORDER.indexOf(profile);
 }
@@ -47,13 +42,13 @@ export function parseToolDomains(raw) {
     if (!raw?.trim()) {
         return null;
     }
-    const validDomains = ALL_DOMAINS;
+    const validDomains = getAllDomains();
     const parsed = raw
         .split(',')
         .map((item) => item.trim().toLowerCase())
         .filter(Boolean)
         .filter((item) => validDomains.has(item));
-    return parsed.length > 0 ? (Array.from(new Set(parsed))) : null;
+    return parsed.length > 0 ? Array.from(new Set(parsed)) : null;
 }
 export function getToolsByDomains(domains) {
     const tools = domains.flatMap((domain) => getToolGroups()[domain] ?? []);
@@ -63,7 +58,17 @@ export function getToolsForProfile(profile) {
     const domains = getProfileDomainsMap()[profile];
     if (!domains)
         return [];
-    return getToolsByDomains(domains);
+    const domainSet = new Set(domains);
+    const tools = [...getAllRegistrations()]
+        .filter((r) => {
+        if (!domainSet.has(r.domain))
+            return false;
+        if (r.profiles && !r.profiles.includes(profile))
+            return false;
+        return true;
+    })
+        .map((r) => r.tool);
+    return dedupeTools(tools);
 }
 export function getToolDomain(toolName) {
     return getToolDomainByName().get(toolName) ?? null;
@@ -72,6 +77,15 @@ export function getProfileDomains(profile) {
     return getProfileDomainsMap()[profile] ?? [];
 }
 export function getToolMinimalTier(toolName) {
+    const registration = getRegistrationByName(toolName);
+    if (registration?.profiles) {
+        for (const tier of TIER_ORDER) {
+            if (registration.profiles.includes(tier)) {
+                return tier;
+            }
+        }
+        return null;
+    }
     const domain = getToolDomain(toolName);
     if (!domain)
         return null;

package/dist/src/server/ToolExecutionRouter.js

@@ -1,3 +1,4 @@
+import { ToolError } from '../errors/ToolError.js';
 export class ToolExecutionRouter {
     handlers;
     constructor(handlers) {
@@ -20,7 +21,7 @@ export class ToolExecutionRouter {
     async execute(toolName, args) {
         const handler = this.handlers.get(toolName);
         if (!handler) {
-            throw new Error(`Unknown tool: ${toolName}`);
+            throw new ToolError('NOT_FOUND', `Unknown tool: ${toolName}`, { toolName });
         }
         return handler(args);
     }