@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -1,70 +1,53 @@
 import { logger } from '../utils/logger.js';
 import { asTextResponse } from './domains/shared/response.js';
-import { getTierIndex } from './ToolCatalog.js';
-import { DYNAMIC_BOOST_ENABLED, DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST, } from '../constants.js';
-import { analyzeSearchResultTiers, silentBoostToTierWithRetry, backfillIsActive, validateBoostGuardrails, } from './MCPServer.search.dynamicBoost.js';
+import { SEARCH_AUTO_ACTIVATE_DOMAINS, ACTIVATION_TTL_MINUTES, } from '../constants.js';
+import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
 import { getSearchEngine, getActiveToolNames, } from './MCPServer.search.helpers.js';
+import { describeTool, generateExampleArgs } from './ToolRouter.js';
 export async function handleSearchTools(ctx, args) {
     const query = args.query;
     const topK = args.top_k ?? 10;
     const engine = getSearchEngine(ctx);
     const activeNames = getActiveToolNames(ctx);
     let results = engine.search(query, topK, activeNames);
-    let preBoostResults = null;
-    let boostMetadata = null;
-    if (DYNAMIC_BOOST_ENABLED && results.length > 0) {
-        const analysis = analyzeSearchResultTiers(ctx, results, activeNames, {
-            scoreThreshold: 0.6,
-            minCandidates: 3,
-        });
-        if (analysis.targetTier) {
-            const guardrail = validateBoostGuardrails(ctx.currentTier, analysis.targetTier);
-            if (!guardrail.allowed) {
-                logger.info(`[dynamic-boost] Boost blocked by guardrail: ${guardrail.reason}`);
+    let autoActivatedDomains = null;
+    if (SEARCH_AUTO_ACTIVATE_DOMAINS && results.length > 0) {
+        const inactiveDomains = new Set();
+        for (const result of results) {
+            if (!activeNames.has(result.name) && result.domain) {
+                inactiveDomains.add(result.domain);
             }
-            else {
-                const actualTargetTier = guardrail.adjustedTier ?? analysis.targetTier;
-                const targetIdx = getTierIndex(actualTargetTier);
-                const currentIdx = getTierIndex(ctx.currentTier);
-                if (targetIdx > currentIdx) {
-                    try {
-                        let finalResults = results;
-                        if (DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST) {
-                            preBoostResults = [...results];
-                        }
-                        const { success, attempts } = await silentBoostToTierWithRetry(ctx, actualTargetTier, { maxAttempts: 3, initialDelay: 30, exponentialBackoff: true });
-                        if (success) {
-                            const fromTier = ctx.currentTier;
-                            const newActiveNames = getActiveToolNames(ctx);
-                            backfillIsActive(results, newActiveNames);
-                            if (DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST) {
-                                finalResults = engine.search(query, topK, newActiveNames);
-                                backfillIsActive(finalResults, newActiveNames);
-                                results = finalResults;
-                            }
-                            boostMetadata = {
-                                from: fromTier,
-                                to: actualTargetTier,
-                                reason: guardrail.adjustedTier
-                                    ? `adjusted from ${analysis.targetTier}: ${guardrail.reason}`
-                                    : `${analysis.considered.length} candidates, tier distribution: ${JSON.stringify(analysis.tierCounts)}`,
-                                reSearched: DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST,
-                            };
-                            logger.info(`[dynamic-boost] Boosted ${boostMetadata.from} → ${boostMetadata.to} ` +
-                                `(${attempts} attempt(s), reSearched=${boostMetadata.reSearched})`);
-                        }
-                        else {
-                            logger.warn(`[dynamic-boost] Failed to boost to ${actualTargetTier} after ${attempts} attempt(s)`);
-                        }
-                    }
-                    catch (error) {
-                        logger.error('[dynamic-boost] Unexpected error during boost:', error);
-                    }
+        }
+        const domainsToActivate = [];
+        for (const domain of inactiveDomains) {
+            if (!ctx.enabledDomains.has(domain)) {
+                domainsToActivate.push(domain);
+            }
+        }
+        if (domainsToActivate.length > 0) {
+            autoActivatedDomains = [];
+            for (const domain of domainsToActivate) {
+                try {
+                    await handleActivateDomain(ctx, {
+                        domain,
+                        ttlMinutes: ACTIVATION_TTL_MINUTES,
+                    });
+                    autoActivatedDomains.push(domain);
+                    logger.info(`[search-auto-activate] Activated domain "${domain}" with TTL=${ACTIVATION_TTL_MINUTES}min`);
+                }
+                catch (error) {
+                    logger.warn(`[search-auto-activate] Failed to activate domain "${domain}":`, error);
                 }
             }
+            if (autoActivatedDomains.length > 0) {
+                const newActiveNames = getActiveToolNames(ctx);
+                results = engine.search(query, topK, newActiveNames);
+            }
         }
     }
     const topResult = results[0];
+    const topTool = topResult ? describeTool(topResult.name, ctx) : null;
+    const topExampleArgs = topTool ? generateExampleArgs(topTool.inputSchema) : undefined;
     const searchNextActions = [];
     if (topResult) {
         if (!topResult.isActive) {
@@ -81,16 +64,18 @@ export async function handleSearchTools(ctx, args) {
             searchNextActions.push({
                 step: 2,
                 action: 'call',
-                command: `Call ${topResult.name} with appropriate arguments`,
-                description: `Use describe_tool("${topResult.name}") to see required parameters`,
+                command: topResult.name,
+                exampleArgs: topExampleArgs,
+                description: `Call ${topResult.name}. Use describe_tool("${topResult.name}") only if you need the full schema.`,
             });
         }
         else {
             searchNextActions.push({
                 step: 1,
                 action: 'call',
-                command: `Call ${topResult.name} directly (already active)`,
-                description: `Use describe_tool("${topResult.name}") to see required parameters`,
+                command: topResult.name,
+                exampleArgs: topExampleArgs,
+                description: `Call ${topResult.name} directly. Use describe_tool("${topResult.name}") only if you need the full schema.`,
             });
         }
     }
@@ -102,14 +87,8 @@ export async function handleSearchTools(ctx, args) {
         hint: 'For guided tool discovery with workflow detection, use route_tool instead. ' +
             'Use activate_tools to enable specific tools, activate_domain for entire domains.',
     };
-    if (boostMetadata) {
-        response.dynamicBoost = boostMetadata;
-        if (!boostMetadata.reSearched) {
-            response.boostHint = 'Tier was upgraded. Re-run search_tools to see updated rankings with newly available tools.';
-        }
-    }
-    if (DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST && preBoostResults !== null) {
-        response.preBoostResults = preBoostResults;
+    if (autoActivatedDomains && autoActivatedDomains.length > 0) {
+        response.autoActivatedDomains = autoActivatedDomains;
     }
     return asTextResponse(JSON.stringify(response, null, 2));
 }

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

@@ -1,15 +1,11 @@
 import { allTools, } from './ToolCatalog.js';
 import { ToolSearchEngine } from './ToolSearch.js';
 import { ALL_REGISTRATIONS } from './registry/index.js';
-import { SEARCH_WORKFLOW_BOOST_TIERS, SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER, } from '../constants.js';
+import { SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER, } from '../constants.js';
 export function getActiveToolNames(ctx) {
     const names = new Set(ctx.selectedTools.map((t) => t.name));
-    for (const name of ctx.boostedToolNames)
-        names.add(name);
     for (const name of ctx.activatedToolNames)
         names.add(name);
-    for (const name of ctx.boostedExtensionToolNames)
-        names.add(name);
     return names;
 }
 export function getExtensionDomainMap(ctx) {
@@ -37,7 +33,6 @@ export function buildSearchSignature(ctx) {
     }
     extParts.sort();
     return [
-        ctx.currentTier,
         ctx.extensionWorkflowRuntimeById.size,
         extParts.join('|'),
     ].join('::');
@@ -54,14 +49,12 @@ export function getSearchEngine(ctx) {
     for (const record of ctx.extensionToolsByName.values()) {
         toolScoreMultipliers.set(record.name, 1.12);
     }
-    if (SEARCH_WORKFLOW_BOOST_TIERS.has(ctx.currentTier)) {
-        domainScoreMultipliers.set('workflow', SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER);
-    }
     if (ctx.extensionWorkflowRuntimeById.size > 0) {
+        domainScoreMultipliers.set('workflow', SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER);
         toolScoreMultipliers.set('run_extension_workflow', 1.35);
         toolScoreMultipliers.set('list_extension_workflows', 1.25);
     }
-    const engine = new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers);
+    const engine = new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers, ctx.config.search);
     searchEngineCache.set(ctx, { signature, engine });
     return engine;
 }
@@ -78,13 +71,9 @@ export function buildDomainDescription(ctx) {
         .sort((a, b) => b[1] - a[1])
         .map(([domain, count]) => `${domain} (${count})`)
         .join(' | ');
-    const extensionCount = ctx.extensionToolsByName.size;
-    const workflowBias = SEARCH_WORKFLOW_BOOST_TIERS.has(ctx.currentTier)
-        ? ` ${ctx.currentTier}-tier sessions boost ranking for workflow-domain results.`
-        : '';
     return `Search ${totalTools} tools across ${Object.keys(groups).length} capability domains. ` +
-        `This includes built-in tools plus any loaded plugin/workflow tools (${extensionCount} currently loaded). ` +
+        `This includes built-in tools plus any loaded plugin/workflow tools (${ctx.extensionToolsByName.size} currently loaded). ` +
         `In search-tier sessions, call this before assuming a capability is unavailable. ` +
-        `Use activate_tools for exact matches, activate_domain for an entire domain, and boost_profile for manual tier upgrades.${workflowBias} ` +
+        `Use activate_tools for exact matches, activate_domain for an entire domain. ` +
         `Domains: ${parts}.`;
 }

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

@@ -9,7 +9,7 @@ import { handleSearchTools } from './MCPServer.search.handlers.search.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';
+import { handleCallTool } from './MCPServer.search.handlers.call.js';
 export function registerSearchMetaTools(ctx) {
     ctx.server.registerTool('search_tools', {
         description: buildDomainDescription(ctx),
@@ -66,7 +66,8 @@ export function registerSearchMetaTools(ctx) {
         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.',
+            'Activated tools appear in the tool list immediately. ' +
+            'If tools do not appear after activation, use call_tool to invoke them directly.',
         inputSchema: {
             names: z.array(z.string()).describe('Array of tool names to activate (from search_tools results)'),
         },
@@ -100,6 +101,7 @@ export function registerSearchMetaTools(ctx) {
             `Use extensions_reload first to include external plugin/workflow domains.`,
         inputSchema: {
             domain: z.string().describe('Domain name to activate (e.g. "debugger", "network")'),
+            ttlMinutes: z.number().optional().describe('Auto-deactivate after N minutes (default: 30, set 0 for no expiry)'),
         },
     }, async (args) => {
         try {
@@ -110,27 +112,21 @@ export function registerSearchMetaTools(ctx) {
             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 () => {
+    ctx.server.registerTool('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: {
+            name: z.string().describe('The tool name to execute (from search_tools or describe_tool results)'),
+            args: z.record(z.string(), z.unknown()).optional().describe('Arguments object to pass to the tool'),
+        },
+    }, async (args) => {
         try {
-            return await handleExtensionsReload(ctx);
+            return await handleCallTool(ctx, args);
         }
         catch (error) {
-            logger.error('extensions_reload failed', error);
+            logger.error('call_tool failed', error);
             return asErrorResponse(error);
         }
     });

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

@@ -1,8 +1,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) {
@@ -33,69 +31,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

@@ -76,11 +76,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 +91,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;

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, ALL_DOMAINS, ALL_REGISTRATIONS, } 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);
 }
@@ -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 = [...ALL_REGISTRATIONS]
+        .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 = [...ALL_REGISTRATIONS].find(r => r.tool.name === 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/ToolRouter.d.ts

@@ -18,6 +18,7 @@ export interface RouterResponse {
         score: number;
         isActive: boolean;
         activationCommand?: string;
+        callCommand?: string;
     }>;
     nextActions: Array<{
         step: number;
@@ -29,8 +30,12 @@ export interface RouterResponse {
     }>;
     workflowHint?: string;
     autoActivated?: boolean;
+    activatedNames?: string[];
+    callToolHint?: string;
 }
 export declare function routeToolRequest(request: RouterRequest, ctx: MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
+export declare function buildCallToolCommand(toolName: string, schema: Tool['inputSchema']): string;
+export declare function generateExampleArgs(schema: Tool['inputSchema']): Record<string, unknown>;
 export declare function describeTool(toolName: string, ctx: MCPServerContext): {
     name: string;
     description: string;