@jshookmcp/jshook 0.1.7 → 0.1.9

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

@@ -0,0 +1,36 @@
+import { type ToolProfile } from './ToolCatalog.js';
+import type { MCPServerContext } from './MCPServer.context.js';
+import { type DynamicBoostStrategy } from '../constants.js';
+export interface SearchResult {
+    name: string;
+    domain: string | null;
+    score: number;
+    isActive: boolean;
+}
+export interface AnalyzeOptions {
+    scoreThreshold?: number;
+    minCandidates?: number;
+    strategy?: DynamicBoostStrategy;
+}
+export interface RetryOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    exponentialBackoff?: boolean;
+}
+export interface TierAnalysis {
+    targetTier: ToolProfile | null;
+    tierCounts: Record<ToolProfile, number>;
+    considered: string[];
+}
+export declare function analyzeSearchResultTiers(ctx: MCPServerContext, results: SearchResult[], activeNames: Set<string>, opts?: AnalyzeOptions): TierAnalysis;
+export interface GuardrailResult {
+    allowed: boolean;
+    reason?: string;
+    adjustedTier?: ToolProfile;
+}
+export declare function validateBoostGuardrails(currentTier: ToolProfile, targetTier: ToolProfile): GuardrailResult;
+export declare function silentBoostToTierWithRetry(ctx: MCPServerContext, targetTier: ToolProfile, opts?: RetryOptions): Promise<{
+    success: boolean;
+    attempts: number;
+}>;
+export declare function backfillIsActive(results: SearchResult[], activeNames: Set<string>): SearchResult[];

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

@@ -0,0 +1,163 @@
+import { logger } from '../utils/logger.js';
+import { getToolMinimalTier, getTierIndex, TIER_ORDER, } from './ToolCatalog.js';
+import { boostProfile } from './MCPServer.boost.js';
+import { DYNAMIC_BOOST_STRATEGY, DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL, DYNAMIC_BOOST_MAX_JUMP, } from '../constants.js';
+export function analyzeSearchResultTiers(ctx, results, activeNames, opts) {
+    if (results.length === 0) {
+        return { targetTier: null, tierCounts: {}, considered: [] };
+    }
+    const scoreThreshold = opts?.scoreThreshold ?? 0.6;
+    const minCandidates = opts?.minCandidates ?? 3;
+    const strategy = opts?.strategy ?? DYNAMIC_BOOST_STRATEGY;
+    const inactive = results.filter((r) => !activeNames.has(r.name));
+    if (inactive.length === 0) {
+        return { targetTier: null, tierCounts: {}, considered: [] };
+    }
+    const topScore = inactive[0]?.score ?? 0;
+    const threshold = topScore * scoreThreshold;
+    const candidates = inactive.filter((r, idx) => r.score >= threshold || idx < minCandidates);
+    const tierCounts = { search: 0, workflow: 0, full: 0 };
+    const tierScores = { search: 0, workflow: 0, full: 0 };
+    const tierIndices = [];
+    const considered = [];
+    for (const tool of candidates) {
+        const extRecord = ctx.extensionToolsByName.get(tool.name);
+        if (extRecord?.boostTier) {
+            const boostTier = extRecord.boostTier;
+            const idx = getTierIndex(boostTier);
+            if (idx >= 0) {
+                tierIndices.push(idx);
+                tierCounts[boostTier] = (tierCounts[boostTier] ?? 0) + 1;
+                tierScores[boostTier] = (tierScores[boostTier] ?? 0) + tool.score;
+                considered.push(tool.name);
+                continue;
+            }
+        }
+        const tier = getToolMinimalTier(tool.name);
+        if (tier) {
+            const idx = getTierIndex(tier);
+            if (idx >= 0) {
+                tierIndices.push(idx);
+                tierCounts[tier] = (tierCounts[tier] ?? 0) + 1;
+                tierScores[tier] = (tierScores[tier] ?? 0) + tool.score;
+                considered.push(tool.name);
+            }
+        }
+    }
+    if (tierIndices.length === 0) {
+        return { targetTier: null, tierCounts: tierCounts, considered };
+    }
+    let maxTierIndex;
+    switch (strategy) {
+        case 'top1':
+            maxTierIndex = tierIndices[0] ?? 0;
+            break;
+        case 'majority':
+            const totalCandidates = tierIndices.length;
+            const majorityThreshold = totalCandidates / 2;
+            let bestTierIndex = -1;
+            let maxCount = 0;
+            for (const [tier, count] of Object.entries(tierCounts)) {
+                if (count > maxCount && count >= majorityThreshold) {
+                    maxCount = count;
+                    bestTierIndex = getTierIndex(tier);
+                }
+            }
+            maxTierIndex = bestTierIndex >= 0 ? bestTierIndex : Math.min(...tierIndices);
+            break;
+        case 'weighted':
+            let bestWeightedTierIdx = -1;
+            let maxWeightedScore = -Infinity;
+            for (const [tier, weightedScore] of Object.entries(tierScores)) {
+                if (weightedScore > maxWeightedScore) {
+                    maxWeightedScore = weightedScore;
+                    bestWeightedTierIdx = getTierIndex(tier);
+                }
+            }
+            maxTierIndex = bestWeightedTierIdx >= 0 ? bestWeightedTierIdx : Math.min(...tierIndices);
+            break;
+        case 'max':
+        default:
+            maxTierIndex = Math.max(...tierIndices);
+            break;
+    }
+    const targetTier = TIER_ORDER[maxTierIndex];
+    return {
+        targetTier: targetTier ?? null,
+        tierCounts: tierCounts,
+        considered,
+    };
+}
+export function validateBoostGuardrails(currentTier, targetTier) {
+    const currentIdx = getTierIndex(currentTier);
+    const targetIdx = getTierIndex(targetTier);
+    if (targetIdx <= currentIdx) {
+        return { allowed: true };
+    }
+    const tierJump = targetIdx - currentIdx;
+    if (tierJump > DYNAMIC_BOOST_MAX_JUMP) {
+        const adjustedIdx = currentIdx + DYNAMIC_BOOST_MAX_JUMP;
+        const adjustedTier = TIER_ORDER[adjustedIdx];
+        if (!adjustedTier) {
+            return {
+                allowed: false,
+                reason: `Max tier jump (${DYNAMIC_BOOST_MAX_JUMP}) exceeded, and could not determine adjusted tier`,
+            };
+        }
+        logger.info(`[boost-guardrail] Tier jump ${tierJump} exceeds max ${DYNAMIC_BOOST_MAX_JUMP}. Adjusting from ${targetTier} to ${adjustedTier}`);
+        return {
+            allowed: true,
+            reason: `Tier jump limited from ${tierJump} to ${DYNAMIC_BOOST_MAX_JUMP}`,
+            adjustedTier,
+        };
+    }
+    if (DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL && currentTier === 'search' && targetTier === 'full') {
+        logger.info(`[boost-guardrail] Blocked direct search->full jump. Adjusting to workflow tier instead`);
+        return {
+            allowed: true,
+            reason: 'Direct search->full upgrade blocked by guardrail, adjusting to workflow',
+            adjustedTier: 'workflow',
+        };
+    }
+    return { allowed: true };
+}
+export async function silentBoostToTierWithRetry(ctx, targetTier, opts) {
+    const maxAttempts = opts?.maxAttempts ?? 3;
+    const initialDelay = opts?.initialDelay ?? 30;
+    const exponentialBackoff = opts?.exponentialBackoff ?? true;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            logger.info(`[silent-boost] Attempt ${attempt}/${maxAttempts}: boosting to ${targetTier}`);
+            const result = await boostProfile(ctx, targetTier);
+            if (result.success) {
+                logger.info(`[silent-boost] Successfully boosted to ${targetTier} on attempt ${attempt}`);
+                return { success: true, attempts: attempt };
+            }
+            logger.warn(`[silent-boost] Boost returned failure on attempt ${attempt}:`, result.error);
+            return { success: false, attempts: attempt };
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            logger.warn(`[silent-boost] Attempt ${attempt} failed with error:`, lastError.message);
+            if (attempt < maxAttempts) {
+                const delay = exponentialBackoff
+                    ? initialDelay * Math.pow(2, attempt - 1)
+                    : initialDelay;
+                logger.info(`[silent-boost] Retrying after ${delay}ms...`);
+                await sleep(delay);
+            }
+        }
+    }
+    logger.error(`[silent-boost] All ${maxAttempts} attempts failed. Last error:`, lastError?.message);
+    return { success: false, attempts: maxAttempts };
+}
+export function backfillIsActive(results, activeNames) {
+    for (const result of results) {
+        result.isActive = activeNames.has(result.name);
+    }
+    return results;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/server/MCPServer.search.handlers.activate.d.ts

@@ -0,0 +1,4 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleActivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
+export declare function handleDeactivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

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

@@ -0,0 +1,110 @@
+import { logger } from '../utils/logger.js';
+import { asTextResponse } from './domains/shared/response.js';
+import { getToolDomain } from './ToolCatalog.js';
+import { createToolHandlerMap } from './ToolHandlerMap.js';
+import { validateToolNameArray } from './MCPServer.search.validation.js';
+import { getActiveToolNames, getToolByName, } from './MCPServer.search.helpers.js';
+export async function handleActivateTools(ctx, args) {
+    const { names, error } = validateToolNameArray(args);
+    if (error) {
+        return asTextResponse(JSON.stringify({ success: false, error }));
+    }
+    const activeNames = getActiveToolNames(ctx);
+    const activated = [];
+    const alreadyActive = [];
+    const notFound = [];
+    for (const name of names) {
+        if (activeNames.has(name)) {
+            alreadyActive.push(name);
+            continue;
+        }
+        const toolDef = getToolByName(ctx).get(name);
+        if (!toolDef) {
+            notFound.push(name);
+            continue;
+        }
+        const registeredTool = ctx.registerSingleTool(toolDef);
+        ctx.activatedToolNames.add(name);
+        ctx.activatedRegisteredTools.set(name, registeredTool);
+        const extensionRecord = ctx.extensionToolsByName.get(name);
+        if (extensionRecord) {
+            extensionRecord.registeredTool = registeredTool;
+        }
+        const domain = getToolDomain(name) ?? ctx.extensionToolsByName.get(name)?.domain;
+        if (domain) {
+            ctx.enabledDomains.add(domain);
+        }
+        if (extensionRecord?.handler) {
+            ctx.router.addHandlers({ [name]: extensionRecord.handler });
+        }
+        else {
+            const newToolNames = new Set([name]);
+            const newHandlers = createToolHandlerMap(ctx.handlerDeps, newToolNames);
+            ctx.router.addHandlers(newHandlers);
+        }
+        activated.push(name);
+        activeNames.add(name);
+    }
+    if (activated.length > 0) {
+        try {
+            await ctx.server.sendToolListChanged();
+        }
+        catch (e) {
+            logger.warn('sendToolListChanged failed:', e);
+        }
+    }
+    logger.info(`activate_tools: activated ${activated.length}, already_active ${alreadyActive.length}, not_found ${notFound.length}`);
+    return asTextResponse(JSON.stringify({
+        success: true,
+        activated,
+        alreadyActive,
+        notFound,
+        totalActive: activeNames.size,
+    }));
+}
+export async function handleDeactivateTools(ctx, args) {
+    const { names, error } = validateToolNameArray(args);
+    if (error) {
+        return asTextResponse(JSON.stringify({ success: false, error }));
+    }
+    const deactivated = [];
+    const notActivated = [];
+    for (const name of names) {
+        if (!ctx.activatedToolNames.has(name)) {
+            notActivated.push(name);
+            continue;
+        }
+        const registeredTool = ctx.activatedRegisteredTools.get(name);
+        if (registeredTool) {
+            try {
+                registeredTool.remove();
+            }
+            catch (e) {
+                logger.warn(`Failed to remove activated tool "${name}":`, e);
+            }
+        }
+        ctx.router.removeHandler(name);
+        ctx.activatedToolNames.delete(name);
+        ctx.activatedRegisteredTools.delete(name);
+        const extensionRecord = ctx.extensionToolsByName.get(name);
+        if (extensionRecord) {
+            extensionRecord.registeredTool = undefined;
+        }
+        deactivated.push(name);
+    }
+    if (deactivated.length > 0) {
+        try {
+            await ctx.server.sendToolListChanged();
+        }
+        catch (e) {
+            logger.warn('sendToolListChanged failed:', e);
+        }
+    }
+    logger.info(`deactivate_tools: deactivated ${deactivated.length}, not_activated ${notActivated.length}`);
+    return asTextResponse(JSON.stringify({
+        success: true,
+        deactivated,
+        notActivated,
+        hint: 'Deactivated tools are no longer available. Search again to find alternatives.',
+    }));
+}

package/dist/src/server/MCPServer.search.handlers.domain.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleActivateDomain(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

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

@@ -0,0 +1,70 @@
+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 { getActiveToolNames } from './MCPServer.search.helpers.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);
+    for (const record of ctx.extensionToolsByName.values()) {
+        validDomains.add(record.domain);
+    }
+    if (!validDomains.has(domain)) {
+        return asTextResponse(JSON.stringify({
+            success: false,
+            error: `Unknown domain "${domain}". Valid: ${[...validDomains].join(', ')}`,
+        }));
+    }
+    const domainTools = [
+        ...getToolsByDomains([domain]),
+        ...[...ctx.extensionToolsByName.values()]
+            .filter((record) => record.domain === domain)
+            .map((record) => record.tool),
+    ];
+    const activeNames = getActiveToolNames(ctx);
+    const activated = [];
+    ctx.enabledDomains.add(domain);
+    for (const toolDef of domainTools) {
+        if (activeNames.has(toolDef.name))
+            continue;
+        const registeredTool = ctx.registerSingleTool(toolDef);
+        ctx.activatedToolNames.add(toolDef.name);
+        ctx.activatedRegisteredTools.set(toolDef.name, registeredTool);
+        const extensionRecord = ctx.extensionToolsByName.get(toolDef.name);
+        if (extensionRecord) {
+            extensionRecord.registeredTool = registeredTool;
+        }
+        activated.push(toolDef.name);
+    }
+    if (activated.length > 0) {
+        const builtinNames = new Set(activated.filter((n) => !ctx.extensionToolsByName.has(n)));
+        if (builtinNames.size > 0) {
+            const newHandlers = createToolHandlerMap(ctx.handlerDeps, builtinNames);
+            ctx.router.addHandlers(newHandlers);
+        }
+        for (const name of activated) {
+            const extRecord = ctx.extensionToolsByName.get(name);
+            if (extRecord?.handler) {
+                ctx.router.addHandlers({ [name]: extRecord.handler });
+            }
+        }
+        try {
+            await ctx.server.sendToolListChanged();
+        }
+        catch (e) {
+            logger.warn('sendToolListChanged failed:', e);
+        }
+    }
+    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools`);
+    return asTextResponse(JSON.stringify({
+        success: true,
+        domain,
+        activated: activated.length,
+        activatedTools: activated,
+        totalDomainTools: domainTools.length,
+    }));
+}

package/dist/src/server/MCPServer.search.handlers.extensions.d.ts

@@ -0,0 +1,4 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleExtensionsReload(ctx: MCPServerContext): Promise<ToolResponse>;
+export declare function handleExtensionsList(ctx: MCPServerContext): Promise<ToolResponse>;

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

@@ -0,0 +1,9 @@
+import { asTextResponse } from './domains/shared/response.js';
+export async function handleExtensionsReload(ctx) {
+    const result = await ctx.reloadExtensions();
+    return asTextResponse(JSON.stringify(result, null, 2));
+}
+export async function handleExtensionsList(ctx) {
+    const result = ctx.listExtensions();
+    return asTextResponse(JSON.stringify(result, null, 2));
+}

package/dist/src/server/MCPServer.search.handlers.route.d.ts

@@ -0,0 +1,4 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleRouteTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
+export declare function handleDescribeTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

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

@@ -0,0 +1,24 @@
+import { asTextResponse } from './domains/shared/response.js';
+import { routeToolRequest, describeTool } from './ToolRouter.js';
+import { getSearchEngine } from './MCPServer.search.helpers.js';
+export async function handleRouteTool(ctx, args) {
+    const task = args.task;
+    const context = args.context;
+    if (!task || typeof task !== 'string') {
+        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);
+    return asTextResponse(JSON.stringify(response, null, 2));
+}
+export async function handleDescribeTool(ctx, args) {
+    const name = args.name;
+    if (!name || typeof name !== 'string') {
+        return asTextResponse(JSON.stringify({ success: false, error: 'name must be a non-empty string' }));
+    }
+    const toolInfo = describeTool(name, ctx);
+    if (!toolInfo) {
+        return asTextResponse(JSON.stringify({ success: false, error: `Tool not found: ${name}` }));
+    }
+    return asTextResponse(JSON.stringify({ success: true, tool: toolInfo }, null, 2));
+}

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

@@ -0,0 +1,3 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleSearchTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

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

@@ -0,0 +1,115 @@
+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';
+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}`);
+            }
+            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 topResult = results[0];
+    const searchNextActions = [];
+    if (topResult) {
+        if (!topResult.isActive) {
+            const activateNames = results
+                .filter(r => !r.isActive)
+                .slice(0, 3)
+                .map(r => r.name);
+            searchNextActions.push({
+                step: 1,
+                action: 'activate_tools',
+                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`,
+            });
+        }
+        else {
+            searchNextActions.push({
+                step: 1,
+                action: 'call',
+                command: `Call ${topResult.name} directly (already active)`,
+                description: `Use describe_tool("${topResult.name}") to see required parameters`,
+            });
+        }
+    }
+    const response = {
+        query,
+        resultCount: results.length,
+        results,
+        nextActions: searchNextActions,
+        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;
+    }
+    return asTextResponse(JSON.stringify(response, null, 2));
+}

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

@@ -0,0 +1,10 @@
+import { allTools } from './ToolCatalog.js';
+import type { MCPServerContext } from './MCPServer.context.js';
+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 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

@@ -0,0 +1,90 @@
+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';
+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) {
+    const map = new Map();
+    for (const record of ctx.extensionToolsByName.values()) {
+        map.set(record.name, record.domain);
+    }
+    return map;
+}
+export function getCombinedTools(ctx) {
+    const tools = new Map(allTools.map((tool) => [tool.name, tool]));
+    for (const record of ctx.extensionToolsByName.values()) {
+        tools.set(record.name, record.tool);
+    }
+    return [...tools.values()];
+}
+export function getToolByName(ctx) {
+    return new Map(getCombinedTools(ctx).map((tool) => [tool.name, tool]));
+}
+const searchEngineCache = new WeakMap();
+export function buildSearchSignature(ctx) {
+    const extParts = [];
+    for (const [name, record] of ctx.extensionToolsByName) {
+        extParts.push(`${name}:${record.domain}`);
+    }
+    extParts.sort();
+    return [
+        ctx.currentTier,
+        ctx.extensionWorkflowRuntimeById.size,
+        extParts.join('|'),
+    ].join('::');
+}
+export function getSearchEngine(ctx) {
+    const signature = buildSearchSignature(ctx);
+    const cached = searchEngineCache.get(ctx);
+    if (cached && cached.signature === signature)
+        return cached.engine;
+    const tools = getCombinedTools(ctx);
+    const extensionDomains = getExtensionDomainMap(ctx);
+    const domainScoreMultipliers = new Map();
+    const toolScoreMultipliers = new Map();
+    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) {
+        toolScoreMultipliers.set('run_extension_workflow', 1.35);
+        toolScoreMultipliers.set('list_extension_workflows', 1.25);
+    }
+    const engine = new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers);
+    searchEngineCache.set(ctx, { signature, engine });
+    return engine;
+}
+export function buildDomainDescription(ctx) {
+    const groups = {};
+    for (const r of ALL_REGISTRATIONS) {
+        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 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). ` +
+        `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}.`;
+}