@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/ToolRouter.js

@@ -1,209 +0,0 @@
-import { logger } from '../utils/logger.js';
-import {} from './ToolSearch.js';
-import { ensureWorkflowsLoaded } from './extensions/ExtensionManager.js';
-import { getActiveToolNames } from './MCPServer.search.helpers.js';
-import { detectWorkflowIntent, matchWorkflowRoute, isBrowserOrNetworkTask, isMaintenanceTask, } from './ToolRouter.intent.js';
-import { getAvailableToolNames, getRoutingState, isToolActive, getToolDomainFromContext, getToolInputSchema, } from './ToolRouter.probe.js';
-import { getEffectivePrerequisites, buildWorkflowToolSequence, buildPresetRecommendations, buildWorkflowRouteRecommendation, buildRouteMatchMetadata, rerankResultsForContext, } from './ToolRouter.policy.js';
-import { buildCallToolCommand, generateExampleArgs } from './ToolRouter.renderer.js';
-export async function routeToolRequest(request, ctx, searchEngine) {
-    const { task, context = {} } = request;
-    const maxRecommendations = context.maxRecommendations || 5;
-    logger.info('[ToolRouter] Routing request', { task, context });
-    await ensureWorkflowsLoaded(ctx);
-    const workflow = detectWorkflowIntent(task);
-    const activeNames = getActiveToolNames(ctx);
-    const routingState = await getRoutingState(ctx);
-    const availableToolNames = getAvailableToolNames(ctx);
-    const routeMatch = matchWorkflowRoute(task, ctx);
-    let presetPlannedToolNames = null;
-    const searchResults = await searchEngine.search(task, maxRecommendations * 2, activeNames);
-    let finalResults = [];
-    if (routeMatch?.workflow.route.kind === 'preset') {
-        const presetTools = buildPresetRecommendations(routeMatch, routingState, ctx, availableToolNames);
-        presetPlannedToolNames = new Set(presetTools.map((tool) => tool.name));
-        const presetNames = new Set(presetTools.map((tool) => tool.name));
-        const otherResults = searchResults.filter((result) => !presetNames.has(result.name));
-        finalResults = [...presetTools, ...otherResults];
-    }
-    else if (routeMatch?.workflow.route.kind === 'workflow') {
-        const workflowResult = buildWorkflowRouteRecommendation(routeMatch, ctx);
-        const otherResults = searchResults.filter((result) => result.name !== workflowResult.name);
-        finalResults = [workflowResult, ...otherResults];
-    }
-    else if (workflow) {
-        const workflowSequence = buildWorkflowToolSequence(workflow, routingState, availableToolNames);
-        const workflowTools = workflowSequence.map((name, index) => ({
-            name,
-            domain: getToolDomainFromContext(name, ctx),
-            shortDescription: searchResults.find((r) => r.name === name)?.shortDescription ??
-                ctx.extensionToolsByName.get(name)?.tool.description ??
-                '',
-            score: workflow.priority - index * 0.01,
-            isActive: isToolActive(name, ctx),
-        }));
-        const workflowNames = new Set(workflowSequence);
-        const otherResults = searchResults.filter((result) => !workflowNames.has(result.name));
-        finalResults = [...workflowTools, ...otherResults];
-    }
-    else {
-        finalResults = [...searchResults];
-    }
-    const dedupedResults = [];
-    const seenNames = new Set();
-    for (const result of finalResults) {
-        if (seenNames.has(result.name)) {
-            continue;
-        }
-        seenNames.add(result.name);
-        dedupedResults.push(result);
-    }
-    finalResults = rerankResultsForContext(dedupedResults, task, workflow, routingState);
-    if (context.preferredDomain && finalResults.length > 0) {
-        const domainBoostFactor = 1.15;
-        finalResults = finalResults.map((result) => ({
-            ...result,
-            score: result.domain === context.preferredDomain ? result.score * domainBoostFactor : result.score,
-        }));
-        finalResults.sort((a, b) => b.score - a.score);
-    }
-    const recommendationLimit = Math.max(maxRecommendations, presetPlannedToolNames?.size ?? 0);
-    finalResults = finalResults.slice(0, recommendationLimit);
-    const routeMatchMetadata = routeMatch ? buildRouteMatchMetadata(routeMatch, ctx) : undefined;
-    const recommendations = finalResults.map((result) => {
-        const schema = getToolInputSchema(result.name, ctx);
-        const toolIsActive = isToolActive(result.name, ctx);
-        const recommendation = {
-            name: result.name,
-            domain: result.domain,
-            description: result.shortDescription,
-            inputSchema: schema || { type: 'object' },
-            score: result.score,
-            isActive: toolIsActive,
-            callCommand: buildCallToolCommand(result.name, schema || { type: 'object' }),
-        };
-        if (!toolIsActive) {
-            recommendation.activationCommand = `activate_tools with names: ["${result.name}"]`;
-        }
-        const prereqs = getEffectivePrerequisites()[result.name];
-        if (prereqs && prereqs.length > 0) {
-            recommendation.prerequisites = prereqs.map((p) => ({
-                condition: p.condition,
-                satisfied: p.check(routingState),
-                fix: p.fix,
-            }));
-        }
-        return recommendation;
-    });
-    const nextActions = [];
-    const presetRecommendations = presetPlannedToolNames
-        ? recommendations.filter((recommendation) => presetPlannedToolNames.has(recommendation.name))
-        : [];
-    const inactiveTools = (presetRecommendations.length > 0 ? presetRecommendations : recommendations).filter((recommendation) => !recommendation.isActive);
-    const activationCandidates = (() => {
-        if (presetRecommendations.length > 0 ||
-            !isBrowserOrNetworkTask(task, workflow) ||
-            isMaintenanceTask(task)) {
-            return inactiveTools;
-        }
-        const nonMaintenanceTools = inactiveTools.filter((tool) => tool.domain !== 'maintenance');
-        return nonMaintenanceTools.length > 0 ? nonMaintenanceTools : inactiveTools;
-    })();
-    if (routeMatchMetadata?.kind === 'preset' && presetRecommendations.length > 0) {
-        let stepNumber = 1;
-        if (activationCandidates.length > 0) {
-            nextActions.push({
-                step: stepNumber++,
-                action: 'activate',
-                toolName: activationCandidates.length === 1 ? activationCandidates[0].name : undefined,
-                command: `activate_tools with names: [${activationCandidates.map((tool) => `"${tool.name}"`).join(', ')}]`,
-                description: `Activate ${activationCandidates.length} preset tool${activationCandidates.length === 1 ? '' : 's'} for ${routeMatchMetadata.name}`,
-            });
-        }
-        const bootstrapRecommendations = recommendations.filter((recommendation) => recommendation.name === 'browser_launch' || recommendation.name === 'browser_attach');
-        for (const bootstrap of bootstrapRecommendations) {
-            nextActions.push({
-                step: stepNumber++,
-                action: 'call',
-                toolName: bootstrap.name,
-                command: bootstrap.name,
-                exampleArgs: generateExampleArgs(bootstrap.inputSchema),
-                description: bootstrap.description,
-            });
-        }
-        for (const step of routeMatchMetadata.steps) {
-            const recommendation = presetRecommendations.find((item) => item.name === step.toolName);
-            nextActions.push({
-                step: stepNumber++,
-                action: 'call',
-                toolName: step.toolName,
-                command: step.toolName,
-                exampleArgs: generateExampleArgs(recommendation?.inputSchema ??
-                    getToolInputSchema(step.toolName, ctx) ?? { type: 'object' }),
-                description: `${step.id}: ${step.description}`,
-            });
-        }
-    }
-    else if (routeMatchMetadata?.kind === 'workflow') {
-        const workflowRecommendation = recommendations.find((recommendation) => recommendation.name === 'run_extension_workflow');
-        let stepNumber = 1;
-        if (!workflowRecommendation.isActive) {
-            nextActions.push({
-                step: stepNumber++,
-                action: 'activate',
-                toolName: workflowRecommendation.name,
-                command: `activate_tools with names: ["${workflowRecommendation.name}"]`,
-                description: `Activate workflow runner for ${routeMatchMetadata.name}`,
-            });
-        }
-        nextActions.push({
-            step: stepNumber,
-            action: 'call',
-            toolName: 'run_extension_workflow',
-            command: 'run_extension_workflow',
-            exampleArgs: {
-                ...generateExampleArgs(workflowRecommendation.inputSchema),
-                workflowId: routeMatchMetadata.id,
-            },
-            description: `Execute routed workflow ${routeMatchMetadata.name}`,
-        });
-    }
-    else if (recommendations.length > 0 && recommendations[0]?.isActive) {
-        nextActions.push({
-            step: 1,
-            action: 'call',
-            toolName: recommendations[0].name,
-            command: recommendations[0].name,
-            exampleArgs: generateExampleArgs(recommendations[0].inputSchema),
-            description: `Call ${recommendations[0].name}. Use describe_tool("${recommendations[0].name}") only if you need the full schema.`,
-        });
-    }
-    else if (activationCandidates.length > 0) {
-        const topInactive = activationCandidates[0];
-        nextActions.push({
-            step: 1,
-            action: 'activate',
-            toolName: activationCandidates.length === 1 ? topInactive.name : undefined,
-            command: `activate_tools with names: [${activationCandidates.map((tool) => `"${tool.name}"`).join(', ')}]`,
-            description: `Activate ${activationCandidates.length} recommended tool${activationCandidates.length === 1 ? '' : 's'}`,
-        });
-        nextActions.push({
-            step: 2,
-            action: 'call',
-            toolName: topInactive.name,
-            command: topInactive.name,
-            exampleArgs: generateExampleArgs(topInactive.inputSchema),
-            description: `Call ${topInactive.name}. Use describe_tool("${topInactive.name}") only if you need the full schema.`,
-        });
-    }
-    return {
-        recommendations,
-        nextActions,
-        workflowHint: routeMatchMetadata
-            ? `${routeMatchMetadata.kind === 'preset' ? 'Preset' : 'Workflow'} ${routeMatchMetadata.name}: ${routeMatchMetadata.description}`
-            : workflow?.hint,
-        routeMatch: routeMatchMetadata,
-        autoActivated: false,
-    };
-}
-export { buildCallToolCommand, describeTool, generateExampleArgs, } from './ToolRouter.renderer.js';

package/dist/src/server/ToolRouter.policy.d.ts

@@ -1,22 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolSearchResult } from './ToolSearch.js';
-import type { WorkflowRule, RoutedWorkflowMatch } from './ToolRouter.intent.js';
-import type { RoutingState } from './ToolRouter.probe.js';
-import type { RouterResponse } from './ToolRouter.js';
-export interface PrerequisiteEntry {
-    condition: string;
-    check: (state: RoutingState) => boolean;
-    fix: string;
-}
-interface PlannedTool {
-    name: string;
-    description: string;
-}
-export declare function getEffectivePrerequisites(): Record<string, PrerequisiteEntry[]>;
-export declare function buildWorkflowToolSequence(workflow: WorkflowRule, state: RoutingState, availableToolNames: Set<string>): string[];
-export declare function buildPresetToolSequence(match: RoutedWorkflowMatch, state: RoutingState, availableToolNames: Set<string>): PlannedTool[];
-export declare function buildPresetRecommendations(match: RoutedWorkflowMatch, state: RoutingState, ctx: MCPServerContext, availableToolNames: Set<string>): ToolSearchResult[];
-export declare function buildWorkflowRouteRecommendation(match: RoutedWorkflowMatch, ctx: MCPServerContext): ToolSearchResult;
-export declare function buildRouteMatchMetadata(match: RoutedWorkflowMatch, ctx: MCPServerContext): NonNullable<RouterResponse['routeMatch']>;
-export declare function rerankResultsForContext(results: ToolSearchResult[], task: string, workflow: WorkflowRule | null, state: RoutingState): ToolSearchResult[];
-export {};

package/dist/src/server/ToolRouter.policy.js

@@ -1,163 +0,0 @@
-import { getToolDomain } from './ToolCatalog.js';
-import { getAllManifests } from './registry/index.js';
-import { isBrowserOrNetworkTask, isMaintenanceTask } from './ToolRouter.intent.js';
-import { isToolActive, getToolDomainFromContext } from './ToolRouter.probe.js';
-function buildPrerequisiteCheck(condition) {
-    if (condition.includes('Browser must be launched')) {
-        return (state) => state.hasActivePage;
-    }
-    if (condition.includes('Network monitoring must be enabled')) {
-        return (state) => state.networkEnabled;
-    }
-    if (condition.includes('Debugger must be enabled')) {
-        return (state) => state.hasActivePage;
-    }
-    if (condition.includes('Debugger must be attached')) {
-        return (state) => state.hasActivePage;
-    }
-    if (condition.includes('Page must be navigated')) {
-        return (state) => state.hasActivePage;
-    }
-    if (condition.includes('WebSocket monitoring')) {
-        return (state) => state.hasActivePage;
-    }
-    return () => false;
-}
-let _cachedPrerequisites = null;
-export function getEffectivePrerequisites() {
-    if (_cachedPrerequisites)
-        return _cachedPrerequisites;
-    const merged = {};
-    for (const m of getAllManifests()) {
-        if (m.prerequisites) {
-            for (const [toolName, entries] of Object.entries(m.prerequisites)) {
-                merged[toolName] = entries.map((e) => ({
-                    condition: e.condition,
-                    check: buildPrerequisiteCheck(e.condition),
-                    fix: e.fix,
-                }));
-            }
-        }
-    }
-    _cachedPrerequisites = merged;
-    return _cachedPrerequisites;
-}
-export function buildWorkflowToolSequence(workflow, state, availableToolNames) {
-    const sequence = [];
-    const pushIfAvailable = (toolName) => {
-        if (availableToolNames.has(toolName) && !sequence.includes(toolName)) {
-            sequence.push(toolName);
-        }
-    };
-    if ((workflow.domain === 'browser' || workflow.domain === 'network') && !state.hasActivePage) {
-        pushIfAvailable('browser_launch');
-        pushIfAvailable('browser_attach');
-    }
-    if (workflow.domain === 'network') {
-        if (state.hasActivePage && !state.networkEnabled) {
-            pushIfAvailable('network_enable');
-        }
-        if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0) {
-            pushIfAvailable('network_get_requests');
-        }
-    }
-    for (const toolName of workflow.tools) {
-        pushIfAvailable(toolName);
-    }
-    if (workflow.domain === 'network' && state.hasActivePage && state.networkEnabled) {
-        pushIfAvailable('network_get_requests');
-    }
-    return sequence;
-}
-export function buildPresetToolSequence(match, state, availableToolNames) {
-    const sequence = [];
-    const seen = new Set();
-    const requiresBrowserSession = match.workflow.route.requiredDomains.includes('browser') ||
-        match.workflow.route.requiredDomains.includes('network');
-    const pushIfAvailable = (toolName, description) => {
-        if (!availableToolNames.has(toolName) || seen.has(toolName)) {
-            return;
-        }
-        seen.add(toolName);
-        sequence.push({ name: toolName, description });
-    };
-    if (!state.hasActivePage && requiresBrowserSession) {
-        pushIfAvailable('browser_launch', 'Launch a browser session before executing the preset');
-        pushIfAvailable('browser_attach', 'Attach preset tooling to the active browser session before capture begins');
-    }
-    for (const step of match.workflow.route.steps) {
-        pushIfAvailable(step.toolName, step.description);
-    }
-    return sequence;
-}
-export function buildPresetRecommendations(match, state, ctx, availableToolNames) {
-    return buildPresetToolSequence(match, state, availableToolNames).map((plannedTool, index) => ({
-        name: plannedTool.name,
-        domain: getToolDomainFromContext(plannedTool.name, ctx),
-        shortDescription: plannedTool.description,
-        score: match.workflow.route.priority + match.confidence - index * 0.01,
-        isActive: isToolActive(plannedTool.name, ctx),
-    }));
-}
-export function buildWorkflowRouteRecommendation(match, ctx) {
-    return {
-        name: 'run_extension_workflow',
-        domain: getToolDomainFromContext('run_extension_workflow', ctx),
-        shortDescription: `Execute routed workflow ${match.workflow.name} (${match.workflow.id}) via run_extension_workflow`,
-        score: match.workflow.route.priority + match.confidence,
-        isActive: isToolActive('run_extension_workflow', ctx),
-    };
-}
-export function buildRouteMatchMetadata(match, ctx) {
-    return {
-        kind: match.workflow.route.kind,
-        id: match.workflow.id,
-        name: match.workflow.name,
-        description: match.workflow.description,
-        confidence: match.confidence,
-        matchedPattern: match.matchedPattern,
-        requiredDomains: [...match.workflow.route.requiredDomains],
-        steps: match.workflow.route.steps.map((step) => ({
-            id: step.id,
-            toolName: step.toolName,
-            domain: getToolDomain(step.toolName) ?? ctx.extensionToolsByName.get(step.toolName)?.domain ?? null,
-            description: step.description,
-            prerequisites: [...step.prerequisites],
-            parallel: step.parallel,
-            isActive: isToolActive(step.toolName, ctx),
-        })),
-    };
-}
-export function rerankResultsForContext(results, task, workflow, state) {
-    const browserOrNetworkTask = isBrowserOrNetworkTask(task, workflow);
-    const maintenanceTask = isMaintenanceTask(task);
-    const reranked = results.map((result) => {
-        let score = result.score;
-        if (browserOrNetworkTask && !maintenanceTask && result.domain === 'maintenance') {
-            score *= 0.1;
-        }
-        if (browserOrNetworkTask) {
-            if (!state.hasActivePage && result.name === 'browser_launch') {
-                score *= 1.4;
-            }
-            if (!state.hasActivePage && result.name === 'browser_attach') {
-                score *= 1.2;
-            }
-            if (state.hasActivePage && !state.networkEnabled && result.name === 'network_enable') {
-                score *= 1.35;
-            }
-            if (state.hasActivePage &&
-                state.networkEnabled &&
-                state.capturedRequestCount > 0 &&
-                result.name === 'network_get_requests') {
-                score *= 1.5;
-            }
-        }
-        return {
-            ...result,
-            score,
-        };
-    });
-    reranked.sort((a, b) => b.score - a.score);
-    return reranked;
-}

package/dist/src/server/ToolRouter.probe.d.ts

@@ -1,17 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-export interface RoutingState {
-    hasActivePage: boolean;
-    networkEnabled: boolean;
-    capturedRequestCount: number;
-}
-export declare function getAllToolsByName(): Map<string, Tool>;
-export declare function getToolInputSchema(toolName: string, ctx: MCPServerContext): Tool['inputSchema'] | undefined;
-export declare function getToolDescription(toolName: string, ctx: MCPServerContext): string;
-export declare function isToolActive(toolName: string, ctx: MCPServerContext): boolean;
-export declare function getAvailableToolNames(ctx: MCPServerContext): Set<string>;
-export declare function getToolDomainFromContext(toolName: string, ctx: MCPServerContext): string | null;
-export declare function probeActivePage(ctx: MCPServerContext): Promise<boolean>;
-export declare function probeNetworkEnabled(ctx: MCPServerContext): boolean;
-export declare function probeCapturedRequests(ctx: MCPServerContext): number;
-export declare function getRoutingState(ctx: MCPServerContext): Promise<RoutingState>;

package/dist/src/server/ToolRouter.probe.js

@@ -1,103 +0,0 @@
-import { allTools, getToolDomain } from './ToolCatalog.js';
-import { normalizeToolName } from './MCPServer.search.validation.js';
-let _allToolsByName = null;
-export function getAllToolsByName() {
-    if (!_allToolsByName)
-        _allToolsByName = new Map(allTools.map((t) => [t.name, t]));
-    return _allToolsByName;
-}
-export function getToolInputSchema(toolName, ctx) {
-    const canonicalName = normalizeToolName(toolName);
-    const builtInTool = getAllToolsByName().get(canonicalName);
-    if (builtInTool) {
-        return builtInTool.inputSchema;
-    }
-    const extTool = ctx.extensionToolsByName.get(canonicalName);
-    if (extTool) {
-        return extTool.tool.inputSchema;
-    }
-    const metaTool = ctx.metaToolsByName.get(canonicalName);
-    if (metaTool) {
-        return metaTool.inputSchema;
-    }
-    return undefined;
-}
-export function getToolDescription(toolName, ctx) {
-    const canonicalName = normalizeToolName(toolName);
-    const builtInTool = getAllToolsByName().get(canonicalName);
-    if (builtInTool?.description) {
-        return builtInTool.description.split('\n')[0] || 'No description available';
-    }
-    const extTool = ctx.extensionToolsByName.get(canonicalName);
-    if (extTool?.tool?.description) {
-        return extTool.tool.description.split('\n')[0] || 'No description available';
-    }
-    const metaTool = ctx.metaToolsByName.get(canonicalName);
-    if (metaTool?.description) {
-        return metaTool.description.split('\n')[0] || 'No description available';
-    }
-    return 'No description available';
-}
-export function isToolActive(toolName, ctx) {
-    const canonicalName = normalizeToolName(toolName);
-    const activeTools = new Set([
-        ...ctx.selectedTools.map((tool) => tool.name),
-        ...ctx.activatedToolNames,
-    ]);
-    return activeTools.has(canonicalName);
-}
-export function getAvailableToolNames(ctx) {
-    return new Set([...allTools.map((tool) => tool.name), ...ctx.extensionToolsByName.keys()]);
-}
-export function getToolDomainFromContext(toolName, ctx) {
-    return getToolDomain(toolName) ?? ctx.extensionToolsByName.get(toolName)?.domain ?? null;
-}
-export async function probeActivePage(ctx) {
-    if (!ctx.pageController || typeof ctx.pageController.getPage !== 'function')
-        return false;
-    try {
-        return Boolean(await ctx.pageController.getPage());
-    }
-    catch {
-        return false;
-    }
-}
-export function probeNetworkEnabled(ctx) {
-    if (!ctx.consoleMonitor)
-        return false;
-    try {
-        if (typeof ctx.consoleMonitor.getNetworkStatus === 'function') {
-            return Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
-        }
-        if (typeof ctx.consoleMonitor.isNetworkEnabled === 'function') {
-            return Boolean(ctx.consoleMonitor.isNetworkEnabled());
-        }
-    }
-    catch {
-    }
-    return false;
-}
-export function probeCapturedRequests(ctx) {
-    if (!ctx.consoleMonitor || typeof ctx.consoleMonitor.getNetworkRequests !== 'function')
-        return 0;
-    try {
-        const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
-        return Array.isArray(requests) ? requests.length : 0;
-    }
-    catch {
-        try {
-            const requests = ctx.consoleMonitor.getNetworkRequests();
-            return Array.isArray(requests) ? requests.length : 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-}
-export async function getRoutingState(ctx) {
-    return {
-        hasActivePage: await probeActivePage(ctx),
-        networkEnabled: probeNetworkEnabled(ctx),
-        capturedRequestCount: probeCapturedRequests(ctx),
-    };
-}

package/dist/src/server/ToolRouter.renderer.d.ts

@@ -1,9 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-export declare function generateExampleArgs(schema: Tool['inputSchema']): Record<string, unknown>;
-export declare function buildCallToolCommand(toolName: string, schema: Tool['inputSchema']): string;
-export declare function describeTool(toolName: string, ctx: MCPServerContext): {
-    name: string;
-    description: string;
-    inputSchema: Tool['inputSchema'];
-} | null;

package/dist/src/server/ToolRouter.renderer.js

@@ -1,52 +0,0 @@
-import { normalizeToolName } from './MCPServer.search.validation.js';
-import { getToolInputSchema, getToolDescription } from './ToolRouter.probe.js';
-export function generateExampleArgs(schema) {
-    if (schema?.type !== 'object' || !schema.properties) {
-        return {};
-    }
-    const example = {};
-    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-    for (const [key, prop] of Object.entries(schema.properties)) {
-        const propSchema = prop;
-        if (!required.has(key) && propSchema.default === undefined) {
-            continue;
-        }
-        if (propSchema.default !== undefined) {
-            example[key] = propSchema.default;
-        }
-        else if (propSchema.enum && Array.isArray(propSchema.enum) && propSchema.enum.length > 0) {
-            example[key] = propSchema.enum[0];
-        }
-        else if (propSchema.type === 'string') {
-            example[key] = `<${key}>`;
-        }
-        else if (propSchema.type === 'number' || propSchema.type === 'integer') {
-            example[key] = 0;
-        }
-        else if (propSchema.type === 'boolean') {
-            example[key] = false;
-        }
-        else if (propSchema.type === 'array') {
-            example[key] = [];
-        }
-        else if (propSchema.type === 'object') {
-            example[key] = {};
-        }
-    }
-    return example;
-}
-export function buildCallToolCommand(toolName, schema) {
-    return `call_tool({ name: "${toolName}", args: ${JSON.stringify(generateExampleArgs(schema))} })`;
-}
-export function describeTool(toolName, ctx) {
-    const canonicalName = normalizeToolName(toolName);
-    const schema = getToolInputSchema(canonicalName, ctx);
-    if (!schema) {
-        return null;
-    }
-    return {
-        name: canonicalName,
-        description: getToolDescription(canonicalName, ctx),
-        inputSchema: schema,
-    };
-}

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

@@ -1 +0,0 @@
-export { ToolSearchEngine, type ToolSearchResult } from './search/ToolSearchEngineImpl.js';

package/dist/src/server/ToolSearch.js

@@ -1 +0,0 @@
-export { ToolSearchEngine } from './search/ToolSearchEngineImpl.js';

package/dist/src/server/activation/ActivationController.d.ts

@@ -1,35 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { EventBus, ServerEventMap } from '../EventBus.js';
-import type { MCPServerContext } from '../MCPServer.context.js';
-import type { ActivationControllerOptions, EventRecord } from './types.js';
-import { PredictiveBooster } from './PredictiveBooster.js';
-import { AutoPruner } from './AutoPruner.js';
-export declare function getPlatformFilteredTools(tools: Tool[]): Tool[];
-export declare class ActivationController {
-    private readonly eventBus;
-    private readonly ctx;
-    private readonly cooldownMs;
-    private readonly boostRules;
-    private readonly unsubscribers;
-    private readonly lastBoostTime;
-    private readonly lastActivity;
-    private readonly eventHistory;
-    private readonly maxEventHistory;
-    private toolCallCount;
-    private readonly compoundEngine;
-    private readonly predictiveBooster;
-    private readonly autoPruner;
-    private disposed;
-    constructor(eventBus: EventBus<ServerEventMap>, ctx: MCPServerContext, options?: ActivationControllerOptions);
-    private subscribe;
-    private recordEvent;
-    private evaluateBoostRules;
-    private attemptBoost;
-    private evaluateCompoundConditions;
-    getLastActivity(domain: string): number | undefined;
-    getEventHistory(): readonly EventRecord[];
-    getLastBoostTime(domain: string): number | undefined;
-    getPredictiveBooster(): PredictiveBooster;
-    getAutoPruner(): AutoPruner;
-    dispose(): void;
-}