@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/server/MCPServer.search.js

@@ -1,382 +0,0 @@
-import { z } from 'zod';
-import { logger } from '../utils/logger.js';
-import { asErrorResponse, asTextResponse } from './domains/shared/response.js';
-import { allTools, getToolDomain, getToolsByDomains } from './ToolCatalog.js';
-import { createToolHandlerMap } from './ToolHandlerMap.js';
-import { ToolSearchEngine } from './ToolSearch.js';
-import { ALL_DOMAINS, ALL_REGISTRATIONS } from './registry/index.js';
-import { SEARCH_WORKFLOW_BOOST_TIERS, SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER, } from '../constants.js';
-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);
-    return names;
-}
-function getExtensionDomainMap(ctx) {
-    const map = new Map();
-    for (const record of ctx.extensionToolsByName.values()) {
-        map.set(record.name, record.domain);
-    }
-    return map;
-}
-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()];
-}
-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;
-}
-function getToolByName(ctx) {
-    return new Map(getCombinedTools(ctx).map((tool) => [tool.name, tool]));
-}
-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). ` +
-        `Search before attempting unfamiliar tasks, and prioritize plugin/workflow matches when they fit the task.${workflowBias} ` +
-        `Domains: ${parts}.`;
-}
-function validateToolNameArray(args) {
-    const raw = args.names;
-    if (!Array.isArray(raw) || raw.length === 0) {
-        return { names: [], error: 'names must be a non-empty array' };
-    }
-    const names = [];
-    for (const item of raw) {
-        if (typeof item !== 'string' || item.length === 0) {
-            return { names: [], error: 'invalid tool name: expected non-empty string' };
-        }
-        names.push(item);
-    }
-    return { names };
-}
-async function handleSearchTools(ctx, args) {
-    const query = args.query;
-    const topK = args.top_k ?? 10;
-    const engine = getSearchEngine(ctx);
-    const activeNames = getActiveToolNames(ctx);
-    const results = engine.search(query, topK, activeNames);
-    return asTextResponse(JSON.stringify({
-        query,
-        resultCount: results.length,
-        results,
-        hint: 'Use extensions_reload first to load plugin/workflow tools, then activate_tools for specific matches or activate_domain for an entire domain.',
-    }, null, 2));
-}
-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,
-    }));
-}
-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.',
-    }));
-}
-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,
-    }));
-}
-async function handleExtensionsReload(ctx) {
-    const result = await ctx.reloadExtensions();
-    return asTextResponse(JSON.stringify(result, null, 2));
-}
-async function handleExtensionsList(ctx) {
-    const result = ctx.listExtensions();
-    return asTextResponse(JSON.stringify(result, null, 2));
-}
-export function registerSearchMetaTools(ctx) {
-    ctx.server.registerTool('search_tools', {
-        description: buildDomainDescription(ctx),
-        inputSchema: {
-            query: z.string().describe('Search query: keywords, tool name, domain name, or description fragment'),
-            top_k: z.number().optional().describe('Max results to return (default: 10, max: 30)'),
-        },
-    }, async (args) => {
-        try {
-            return await handleSearchTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('search_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('activate_tools', {
-        description: 'Dynamically register specific tools by name. ' +
-            'Use after search_tools to enable exactly the tools you need. ' +
-            'Activated tools appear in the tool list immediately.',
-        inputSchema: {
-            names: z.array(z.string()).describe('Array of tool names to activate (from search_tools results)'),
-        },
-    }, async (args) => {
-        try {
-            return await handleActivateTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('activate_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('deactivate_tools', {
-        description: 'Remove previously activated tools to free context. ' +
-            'Only affects tools added via activate_tools, not base profile tools.',
-        inputSchema: {
-            names: z.array(z.string()).describe('Array of tool names to deactivate'),
-        },
-    }, async (args) => {
-        try {
-            return await handleDeactivateTools(ctx, args);
-        }
-        catch (error) {
-            logger.error('deactivate_tools failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('activate_domain', {
-        description: `Activate all tools in a domain at once. ` +
-            `Domains: ${[...ALL_DOMAINS].join(', ')}. ` +
-            `Use extensions_reload first to include external plugin/workflow domains.`,
-        inputSchema: {
-            domain: z.string().describe('Domain name to activate (e.g. "debugger", "network")'),
-        },
-    }, async (args) => {
-        try {
-            return await handleActivateDomain(ctx, args);
-        }
-        catch (error) {
-            logger.error('activate_domain failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('extensions_list', {
-        description: 'List dynamically loaded extensions from plugins/workflows directories. ' +
-            'Shows loaded plugins, extension workflows, extension tools, and active roots.',
-    }, async () => {
-        try {
-            return await handleExtensionsList(ctx);
-        }
-        catch (error) {
-            logger.error('extensions_list failed', error);
-            return asErrorResponse(error);
-        }
-    });
-    ctx.server.registerTool('extensions_reload', {
-        description: 'Reload external extensions from plugins/ and workflows/ (or MCP_PLUGIN_ROOTS/MCP_WORKFLOW_ROOTS). ' +
-            'Dynamically registers extension tools and refreshes tool list.',
-    }, async () => {
-        try {
-            return await handleExtensionsReload(ctx);
-        }
-        catch (error) {
-            logger.error('extensions_reload failed', error);
-            return asErrorResponse(error);
-        }
-    });
-}

package/dist/server/MCPServer.tools.js

@@ -1,102 +0,0 @@
-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) {
-        return toolErrorToResponse(error);
-    }
-    logger.error(`Tool execution failed: ${toolName}`, error);
-    return asErrorResponse(error);
-}
-export function registerSingleTool(ctx, toolDef) {
-    const shape = buildZodShape(toolDef.inputSchema);
-    const description = toolDef.description ?? toolDef.name;
-    if (Object.keys(shape).length > 0) {
-        return ctx.server.registerTool(toolDef.name, { description, inputSchema: shape }, async (args) => {
-            try {
-                return await ctx.executeToolWithTracking(toolDef.name, args);
-            }
-            catch (error) {
-                return handleToolError(toolDef.name, error);
-            }
-        });
-    }
-    return ctx.server.registerTool(toolDef.name, { description }, async () => {
-        try {
-            return await ctx.executeToolWithTracking(toolDef.name, {});
-        }
-        catch (error) {
-            return handleToolError(toolDef.name, error);
-        }
-    });
-}
-export function registerMetaTools(ctx) {
-    const searchCount = getToolsForProfile('search').length;
-    const minimalCount = getToolsForProfile('minimal').length;
-    const workflowCount = getToolsForProfile('workflow').length;
-    const fullCount = getToolsForProfile('full').length;
-    ctx.server.registerTool('boost_profile', {
-        description: 'Progressively upgrade the active tool tier. Four tiers: search → minimal → workflow → full. ' +
-            `search: maintenance only (${searchCount} tools) — use search_tools to discover and activate_tools to enable. ` +
-            `minimal: browser + maintenance (${minimalCount} tools). ` +
-            `workflow: + 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). ` +
-            '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: "minimal", "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 → min). ' +
-            '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 ("min" 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/server/ToolCallContextGuard.js

@@ -1,75 +0,0 @@
-import { logger } from '../utils/logger.js';
-const CONTEXT_SENSITIVE_PREFIXES = [
-    'page_',
-    'console_',
-    'debugger_',
-    'network_',
-    'dom_',
-    'stealth_',
-    'framework_',
-    'indexeddb_',
-    'js_heap_',
-    'script_',
-    'captcha_',
-];
-export class ToolCallContextGuard {
-    getProvider;
-    contextSensitiveCache = new Map();
-    constructor(getProvider) {
-        this.getProvider = getProvider;
-    }
-    isContextSensitive(toolName) {
-        const cached = this.contextSensitiveCache.get(toolName);
-        if (cached !== undefined)
-            return cached;
-        const result = CONTEXT_SENSITIVE_PREFIXES.some((p) => toolName.startsWith(p));
-        this.contextSensitiveCache.set(toolName, result);
-        return result;
-    }
-    enrichResponse(toolName, response) {
-        if (!this.isContextSensitive(toolName))
-            return response;
-        if (response.isError)
-            return response;
-        const provider = this.getProvider();
-        if (!provider)
-            return response;
-        const meta = provider.getContextMeta();
-        if (!meta.pageId && meta.tabIndex === null)
-            return response;
-        const content = response.content;
-        if (!Array.isArray(content))
-            return response;
-        const firstText = content.find((c) => typeof c === 'object' &&
-            c !== null &&
-            c.type === 'text' &&
-            typeof c.text === 'string');
-        if (!firstText)
-            return response;
-        const raw = firstText.text;
-        const trimmedStart = raw.trimStart();
-        if (trimmedStart.startsWith('{') && trimmedStart.trimEnd().endsWith('}')) {
-            try {
-                const parsed = JSON.parse(raw);
-                if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                    firstText.text = this.spliceTabContext(raw, meta);
-                    return response;
-                }
-            }
-            catch {
-                logger.debug(`[ContextGuard] Skipped non-JSON response enrichment for ${toolName}`);
-                return response;
-            }
-        }
-        return response;
-    }
-    spliceTabContext(raw, meta) {
-        const tabContext = { url: meta.url, title: meta.title, tabIndex: meta.tabIndex, pageId: meta.pageId };
-        if (/\n\}\s*$/.test(raw)) {
-            const prettyJson = JSON.stringify(tabContext, null, 2).replace(/\n/g, '\n  ');
-            return raw.replace(/\n\}\s*$/, `,\n  "_tabContext": ${prettyJson}\n}`);
-        }
-        const compactJson = JSON.stringify(tabContext);
-        return raw.replace(/\}\s*$/, `,"_tabContext":${compactJson}}`);
-    }
-}

package/dist/server/ToolCatalog.d.ts

@@ -1,13 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-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 function getTierIndex(profile: ToolProfile): number;
-export declare function parseToolDomains(raw: string | undefined): string[] | null;
-export declare function getToolsByDomains(domains: string[]): Tool[];
-export declare function getToolsForProfile(profile: ToolProfile): Tool[];
-export declare function getToolDomain(toolName: string): string | null;
-export declare function getProfileDomains(profile: ToolProfile): string[];

package/dist/server/ToolCatalog.js

@@ -1,74 +0,0 @@
-import { buildToolGroups, buildToolDomainMap, buildAllTools, buildProfileDomains, ALL_DOMAINS, } from './registry/index.js';
-let _toolGroups = null;
-let _toolDomainByName = null;
-let _profileDomains = null;
-let _allTools = null;
-function getToolGroups() {
-    if (!_toolGroups)
-        _toolGroups = buildToolGroups();
-    return _toolGroups;
-}
-function getToolDomainByName() {
-    if (!_toolDomainByName)
-        _toolDomainByName = buildToolDomainMap();
-    return _toolDomainByName;
-}
-function getProfileDomainsMap() {
-    if (!_profileDomains)
-        _profileDomains = buildProfileDomains();
-    return _profileDomains;
-}
-export const allTools = new Proxy([], {
-    get(_t, p) {
-        if (!_allTools)
-            _allTools = buildAllTools();
-        const real = _allTools;
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});
-export const TIER_ORDER = ['search', 'minimal', 'workflow', 'full'];
-export const TIER_DEFAULT_TTL = {
-    search: 0,
-    minimal: 0,
-    workflow: 60,
-    full: 30,
-};
-export function getTierIndex(profile) {
-    return TIER_ORDER.indexOf(profile);
-}
-function dedupeTools(tools) {
-    const map = new Map();
-    for (const tool of tools) {
-        map.set(tool.name, tool);
-    }
-    return Array.from(map.values());
-}
-export function parseToolDomains(raw) {
-    if (!raw?.trim()) {
-        return null;
-    }
-    const validDomains = ALL_DOMAINS;
-    const parsed = raw
-        .split(',')
-        .map((item) => item.trim().toLowerCase())
-        .filter(Boolean)
-        .filter((item) => validDomains.has(item));
-    return parsed.length > 0 ? (Array.from(new Set(parsed))) : null;
-}
-export function getToolsByDomains(domains) {
-    const tools = domains.flatMap((domain) => getToolGroups()[domain] ?? []);
-    return dedupeTools(tools);
-}
-export function getToolsForProfile(profile) {
-    const domains = getProfileDomainsMap()[profile];
-    if (!domains)
-        return [];
-    return getToolsByDomains(domains);
-}
-export function getToolDomain(toolName) {
-    return getToolDomainByName().get(toolName) ?? null;
-}
-export function getProfileDomains(profile) {
-    return getProfileDomainsMap()[profile] ?? [];
-}

package/dist/server/ToolSearch.d.ts

@@ -1,28 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export interface ToolSearchResult {
-    name: string;
-    domain: string | null;
-    shortDescription: string;
-    score: number;
-    isActive: boolean;
-}
-export declare class ToolSearchEngine {
-    private readonly docs;
-    private readonly invertedIndex;
-    private readonly sortedKeys;
-    private readonly avgDocLength;
-    private readonly docCount;
-    private readonly domainOverrides?;
-    private readonly domainScoreMultipliers?;
-    private readonly toolScoreMultipliers?;
-    constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>);
-    search(query: string, topK?: number, activeToolNames?: ReadonlySet<string>): ToolSearchResult[];
-    getDomainSummary(): Array<{
-        domain: string | null;
-        count: number;
-        tools: string[];
-    }>;
-    private scoreToken;
-    private findPrefixMatches;
-    private scorePostings;
-}