@jshookmcp/jshook 0.2.0 → 0.2.2

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

@@ -2,14 +2,16 @@ import { logger } from '../utils/logger.js';
 import { asTextResponse } from './domains/shared/response.js';
 import { getToolsByDomains } from './ToolCatalog.js';
 import { createToolHandlerMap } from './ToolHandlerMap.js';
-import { ALL_DOMAINS } from './registry/index.js';
+import { getAllDomains } from './registry/index.js';
 import { getActiveToolNames } from './MCPServer.search.helpers.js';
+import { startDomainTtl } from './MCPServer.activation.ttl.js';
+import { ACTIVATION_TTL_MINUTES } from '../constants.js';
 export async function handleActivateDomain(ctx, args) {
     const domain = typeof args.domain === 'string' ? args.domain : '';
     if (!domain) {
         return asTextResponse(JSON.stringify({ success: false, error: 'domain must be a non-empty string' }));
     }
-    const validDomains = new Set(ALL_DOMAINS);
+    const validDomains = new Set(getAllDomains());
     for (const record of ctx.extensionToolsByName.values()) {
         validDomains.add(record.domain);
     }
@@ -19,6 +21,7 @@ export async function handleActivateDomain(ctx, args) {
             error: `Unknown domain "${domain}". Valid: ${[...validDomains].join(', ')}`,
         }));
     }
+    const ttlMinutes = typeof args.ttlMinutes === 'number' ? args.ttlMinutes : ACTIVATION_TTL_MINUTES;
     const domainTools = [
         ...getToolsByDomains([domain]),
         ...[...ctx.extensionToolsByName.values()]
@@ -49,9 +52,12 @@ export async function handleActivateDomain(ctx, args) {
         for (const name of activated) {
             const extRecord = ctx.extensionToolsByName.get(name);
             if (extRecord?.handler) {
-                ctx.router.addHandlers({ [name]: extRecord.handler });
+                ctx.router.addHandlers({
+                    [name]: extRecord.handler,
+                });
             }
         }
+        startDomainTtl(ctx, domain, ttlMinutes, activated);
         try {
             await ctx.server.sendToolListChanged();
         }
@@ -59,12 +65,16 @@ export async function handleActivateDomain(ctx, args) {
             logger.warn('sendToolListChanged failed:', e);
         }
     }
-    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools`);
+    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools, ttl=${ttlMinutes}min`);
     return asTextResponse(JSON.stringify({
         success: true,
         domain,
         activated: activated.length,
         activatedTools: activated,
         totalDomainTools: domainTools.length,
+        ttlMinutes: ttlMinutes > 0 ? ttlMinutes : 'no expiry',
+        hint: activated.length > 0
+            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
+            : undefined,
     }));
 }

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

@@ -1,6 +1,19 @@
 import { asTextResponse } from './domains/shared/response.js';
-import { routeToolRequest, describeTool } from './ToolRouter.js';
+import { buildCallToolCommand, routeToolRequest, describeTool } from './ToolRouter.js';
+import { activateToolNames } from './MCPServer.search.handlers.activate.js';
+import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
 import { getSearchEngine } from './MCPServer.search.helpers.js';
+import { ACTIVATION_TTL_MINUTES } from '../constants.js';
+function populateCallCommands(response) {
+    return {
+        ...response,
+        recommendations: response.recommendations.map((recommendation) => ({
+            ...recommendation,
+            callCommand: recommendation.callCommand ??
+                buildCallToolCommand(recommendation.name, recommendation.inputSchema),
+        })),
+    };
+}
 export async function handleRouteTool(ctx, args) {
     const task = args.task;
     const context = args.context;
@@ -8,7 +21,55 @@ export async function handleRouteTool(ctx, args) {
         return asTextResponse(JSON.stringify({ success: false, error: 'task must be a non-empty string' }));
     }
     const engine = getSearchEngine(ctx);
-    const response = await routeToolRequest({ task, context }, ctx, engine);
+    const autoActivate = context?.autoActivate !== false;
+    let response = populateCallCommands(await routeToolRequest({ task, context }, ctx, engine));
+    if (autoActivate) {
+        const inactiveRecs = response.recommendations.filter((recommendation) => !recommendation.isActive);
+        if (inactiveRecs.length > 0) {
+            const domainsToActivate = new Set();
+            const toolsWithoutDomain = [];
+            for (const rec of inactiveRecs) {
+                if (rec.domain && !ctx.enabledDomains.has(rec.domain)) {
+                    domainsToActivate.add(rec.domain);
+                }
+                else if (!rec.domain) {
+                    toolsWithoutDomain.push(rec.name);
+                }
+            }
+            let activated = false;
+            for (const domain of domainsToActivate) {
+                try {
+                    await handleActivateDomain(ctx, {
+                        domain,
+                        ttlMinutes: ACTIVATION_TTL_MINUTES,
+                    });
+                    activated = true;
+                }
+                catch {
+                }
+            }
+            const remainingInactive = inactiveRecs
+                .filter((rec) => !domainsToActivate.has(rec.domain ?? ''))
+                .map((rec) => rec.name);
+            if (remainingInactive.length > 0 || toolsWithoutDomain.length > 0) {
+                const names = [...new Set([...remainingInactive, ...toolsWithoutDomain])];
+                const activation = await activateToolNames(ctx, names);
+                if (activation.activated.length > 0) {
+                    activated = true;
+                }
+            }
+            if (activated) {
+                response = populateCallCommands(await routeToolRequest({ task, context: { ...context, autoActivate: false } }, ctx, engine));
+                response.autoActivated = true;
+                response.activatedNames = inactiveRecs
+                    .map((r) => r.name)
+                    .filter((name) => ctx.activatedToolNames.has(name));
+                response.callToolHint =
+                    'Tools were auto-activated but may not appear in your tool list. ' +
+                        'Use call_tool({ name: "<tool_name>", args: {...} }) to invoke them directly.';
+            }
+        }
+    }
     return asTextResponse(JSON.stringify(response, null, 2));
 }
 export async function handleDescribeTool(ctx, args) {

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

@@ -1,96 +1,81 @@
 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 { getSearchEngine, getActiveToolNames, } from './MCPServer.search.helpers.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 results = await engine.search(query, topK, activeNames);
+    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 = await 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) {
             const activateNames = results
-                .filter(r => !r.isActive)
+                .filter((r) => !r.isActive)
                 .slice(0, 3)
-                .map(r => r.name);
+                .map((r) => r.name);
             searchNextActions.push({
                 step: 1,
                 action: 'activate_tools',
-                command: `activate_tools with names: [${activateNames.map(n => `"${n}"`).join(', ')}]`,
+                command: `activate_tools with names: [${activateNames.map((n) => `"${n}"`).join(', ')}]`,
                 description: `Activate top ${activateNames.length} result(s)`,
             });
             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,11 @@ 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;
+        response.callToolHint =
+            'Tools were auto-activated but may not appear in your tool list. ' +
+                'Use call_tool({ name: "<tool_name>", args: {...} }) to invoke them directly.';
     }
     return asTextResponse(JSON.stringify(response, null, 2));
 }

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

@@ -4,7 +4,7 @@ import { ToolSearchEngine } from './ToolSearch.js';
 export declare function getActiveToolNames(ctx: MCPServerContext): Set<string>;
 export declare function getExtensionDomainMap(ctx: MCPServerContext): Map<string, string>;
 export declare function getCombinedTools(ctx: MCPServerContext): typeof allTools;
-export declare function getToolByName(ctx: MCPServerContext): Map<string, typeof allTools[number]>;
+export declare function getToolByName(ctx: MCPServerContext): Map<string, (typeof allTools)[number]>;
 export declare function buildSearchSignature(ctx: MCPServerContext): string;
 export declare function getSearchEngine(ctx: MCPServerContext): ToolSearchEngine;
 export declare function buildDomainDescription(ctx: MCPServerContext): string;

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

@@ -1,15 +1,11 @@
-import { allTools, } from './ToolCatalog.js';
+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 { getAllRegistrations } from './registry/index.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) {
@@ -36,11 +32,7 @@ export function buildSearchSignature(ctx) {
         extParts.push(`${name}:${record.domain}`);
     }
     extParts.sort();
-    return [
-        ctx.currentTier,
-        ctx.extensionWorkflowRuntimeById.size,
-        extParts.join('|'),
-    ].join('::');
+    return [ctx.extensionWorkflowRuntimeById.size, extParts.join('|')].join('::');
 }
 export function getSearchEngine(ctx) {
     const signature = buildSearchSignature(ctx);
@@ -54,37 +46,31 @@ 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;
 }
 export function buildDomainDescription(ctx) {
     const groups = {};
-    for (const r of ALL_REGISTRATIONS) {
+    for (const r of getAllRegistrations()) {
         groups[r.domain] = (groups[r.domain] ?? 0) + 1;
     }
     for (const record of ctx.extensionToolsByName.values()) {
         groups[record.domain] = (groups[record.domain] ?? 0) + 1;
     }
-    const totalTools = ALL_REGISTRATIONS.length + ctx.extensionToolsByName.size;
+    const totalTools = getAllRegistrations().length + ctx.extensionToolsByName.size;
     const parts = Object.entries(groups)
         .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). ` +
+    return (`Search ${totalTools} tools across ${Object.keys(groups).length} capability domains. ` +
+        `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} ` +
-        `Domains: ${parts}.`;
+        `Use activate_tools for exact matches, activate_domain for an entire domain. ` +
+        `Domains: ${parts}.`);
 }