@jshookmcp/jshook 0.2.0 → 0.2.2

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

@@ -3,45 +3,16 @@ import type { Server } from 'node:http';
 import type { Socket } from 'node:net';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { Config } from '../types/index.js';
-import type { CodeCollector } from '../modules/collector/CodeCollector.js';
-import type { PageController } from '../modules/collector/PageController.js';
-import type { DOMInspector } from '../modules/collector/DOMInspector.js';
-import type { ScriptManager } from '../modules/debugger/ScriptManager.js';
-import type { DebuggerManager } from '../modules/debugger/DebuggerManager.js';
-import type { RuntimeInspector } from '../modules/debugger/RuntimeInspector.js';
-import type { ConsoleMonitor } from '../modules/monitor/ConsoleMonitor.js';
-import type { BrowserToolHandlers } from './domains/browser/index.js';
-import type { DebuggerToolHandlers } from './domains/debugger/index.js';
-import type { AdvancedToolHandlers } from './domains/network/index.js';
-import type { AIHookToolHandlers, HookPresetToolHandlers } from './domains/hooks/index.js';
-import type { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
-import type { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
-import type { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
-import type { ObfuscationDetector } from '../modules/detector/ObfuscationDetector.js';
-import type { LLMService } from '../services/LLMService.js';
-import type { CodeAnalyzer } from '../modules/analyzer/CodeAnalyzer.js';
-import type { CryptoDetector } from '../modules/crypto/CryptoDetector.js';
-import type { HookManager } from '../modules/hook/HookManager.js';
 import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
 import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
 import { DetailedDataManager } from '../utils/DetailedDataManager.js';
-import type { CoreAnalysisHandlers } from './domains/analysis/index.js';
-import type { CoreMaintenanceHandlers, ExtensionManagementHandlers } from './domains/maintenance/index.js';
-import type { ProcessToolHandlers } from './domains/process/index.js';
-import type { WorkflowHandlers } from './domains/workflow/index.js';
-import type { WasmToolHandlers } from './domains/wasm/index.js';
-import type { StreamingToolHandlers } from './domains/streaming/index.js';
-import type { EncodingToolHandlers } from './domains/encoding/index.js';
-import type { AntiDebugToolHandlers } from './domains/antidebug/index.js';
-import type { GraphQLToolHandlers } from './domains/graphql/index.js';
-import type { PlatformToolHandlers } from './domains/platform/index.js';
-import type { SourcemapToolHandlers } from './domains/sourcemap/index.js';
-import type { TransformToolHandlers } from './domains/transform/index.js';
 import type { ToolProfile } from './ToolCatalog.js';
 import { ToolExecutionRouter } from './ToolExecutionRouter.js';
 import { ToolCallContextGuard } from './ToolCallContextGuard.js';
 import type { ToolArgs } from './types.js';
+import type { DomainTtlEntry } from './MCPServer.activation.ttl.js';
 import type { MCPServerContext } from './MCPServer.context.js';
+import { type EventBus, type ServerEventMap } from './EventBus.js';
 import type { ToolHandlerDeps } from './registry/contracts.js';
 import type { ExtensionListResult, ExtensionPluginRecord, ExtensionPluginRuntimeRecord, ExtensionReloadResult, ExtensionToolRecord, ExtensionWorkflowRecord, ExtensionWorkflowRuntimeRecord } from './extensions/types.js';
 export declare class MCPServer implements MCPServerContext {
@@ -51,6 +22,7 @@ export declare class MCPServer implements MCPServerContext {
     readonly tokenBudget: TokenBudgetManager;
     readonly unifiedCache: UnifiedCacheManager;
     readonly detailedData: DetailedDataManager;
+    readonly eventBus: EventBus<ServerEventMap>;
     readonly selectedTools: Tool[];
     enabledDomains: Set<string>;
     readonly router: ToolExecutionRouter;
@@ -60,17 +32,11 @@ export declare class MCPServer implements MCPServerContext {
     private cacheAdaptersRegistered;
     private cacheRegistrationPromise?;
     readonly baseTier: ToolProfile;
-    currentTier: ToolProfile;
-    readonly boostHistory: ToolProfile[];
-    readonly boostedToolNames: Set<string>;
-    readonly boostedRegisteredTools: Map<string, RegisteredTool>;
-    boostTtlTimer: ReturnType<typeof setTimeout> | null;
-    boostTtlMinutes: number;
-    boostLock: Promise<void>;
     readonly activatedToolNames: Set<string>;
     readonly activatedRegisteredTools: Map<string, RegisteredTool>;
-    readonly absorbedFromActivated: Set<string>;
-    readonly boostedExtensionToolNames: Set<string>;
+    readonly domainTtlEntries: Map<string, DomainTtlEntry>;
+    readonly metaToolsByName: Map<string, import("./MCPServer.context.js").MetaToolInfo>;
+    clientSupportsListChanged: boolean;
     readonly extensionToolsByName: Map<string, ExtensionToolRecord>;
     readonly extensionPluginsById: Map<string, ExtensionPluginRecord>;
     readonly extensionPluginRuntimeById: Map<string, ExtensionPluginRuntimeRecord>;
@@ -79,45 +45,46 @@ export declare class MCPServer implements MCPServerContext {
     lastExtensionReloadAt?: string;
     httpServer?: Server;
     readonly httpSockets: Set<Socket>;
-    collector?: CodeCollector;
-    pageController?: PageController;
-    domInspector?: DOMInspector;
-    scriptManager?: ScriptManager;
-    debuggerManager?: DebuggerManager;
-    runtimeInspector?: RuntimeInspector;
-    consoleMonitor?: ConsoleMonitor;
-    llm?: LLMService;
-    browserHandlers?: BrowserToolHandlers;
-    debuggerHandlers?: DebuggerToolHandlers;
-    advancedHandlers?: AdvancedToolHandlers;
-    aiHookHandlers?: AIHookToolHandlers;
-    hookPresetHandlers?: HookPresetToolHandlers;
-    deobfuscator?: Deobfuscator;
-    advancedDeobfuscator?: AdvancedDeobfuscator;
-    astOptimizer?: ASTOptimizer;
-    obfuscationDetector?: ObfuscationDetector;
-    analyzer?: CodeAnalyzer;
-    cryptoDetector?: CryptoDetector;
-    hookManager?: HookManager;
-    coreAnalysisHandlers?: CoreAnalysisHandlers;
-    coreMaintenanceHandlers?: CoreMaintenanceHandlers;
-    extensionManagementHandlers?: ExtensionManagementHandlers;
-    processHandlers?: ProcessToolHandlers;
-    workflowHandlers?: WorkflowHandlers;
-    wasmHandlers?: WasmToolHandlers;
-    streamingHandlers?: StreamingToolHandlers;
-    encodingHandlers?: EncodingToolHandlers;
-    antidebugHandlers?: AntiDebugToolHandlers;
-    graphqlHandlers?: GraphQLToolHandlers;
-    platformHandlers?: PlatformToolHandlers;
-    sourcemapHandlers?: SourcemapToolHandlers;
-    transformHandlers?: TransformToolHandlers;
+    readonly domainInstanceMap: Map<string, unknown>;
+    getDomainInstance<T>(key: string): T | undefined;
+    setDomainInstance(key: string, value: unknown): void;
+    collector: import('../modules/collector/CodeCollector.js').CodeCollector | undefined;
+    pageController: import('../modules/collector/PageController.js').PageController | undefined;
+    domInspector: import('../modules/collector/DOMInspector.js').DOMInspector | undefined;
+    scriptManager: import('../modules/debugger/ScriptManager.js').ScriptManager | undefined;
+    debuggerManager: import('../modules/debugger/DebuggerManager.js').DebuggerManager | undefined;
+    runtimeInspector: import('../modules/debugger/RuntimeInspector.js').RuntimeInspector | undefined;
+    consoleMonitor: import('../modules/monitor/ConsoleMonitor.js').ConsoleMonitor | undefined;
+    llm: import('../services/LLMService.js').LLMService | undefined;
+    browserHandlers: import('./domains/browser/index.js').BrowserToolHandlers | undefined;
+    debuggerHandlers: import('./domains/debugger/index.js').DebuggerToolHandlers | undefined;
+    advancedHandlers: import('./domains/network/index.js').AdvancedToolHandlers | undefined;
+    aiHookHandlers: import('./domains/hooks/index.js').AIHookToolHandlers | undefined;
+    hookPresetHandlers: import('./domains/hooks/index.js').HookPresetToolHandlers | undefined;
+    deobfuscator: import('../modules/deobfuscator/Deobfuscator.js').Deobfuscator | undefined;
+    advancedDeobfuscator: import('../modules/deobfuscator/AdvancedDeobfuscator.js').AdvancedDeobfuscator | undefined;
+    astOptimizer: import('../modules/deobfuscator/ASTOptimizer.js').ASTOptimizer | undefined;
+    obfuscationDetector: import('../modules/detector/ObfuscationDetector.js').ObfuscationDetector | undefined;
+    analyzer: import('../modules/analyzer/CodeAnalyzer.js').CodeAnalyzer | undefined;
+    cryptoDetector: import('../modules/crypto/CryptoDetector.js').CryptoDetector | undefined;
+    hookManager: import('../modules/hook/HookManager.js').HookManager | undefined;
+    coreAnalysisHandlers: import('./domains/analysis/index.js').CoreAnalysisHandlers | undefined;
+    coreMaintenanceHandlers: import('./domains/maintenance/index.js').CoreMaintenanceHandlers | undefined;
+    extensionManagementHandlers: import('./domains/maintenance/index.js').ExtensionManagementHandlers | undefined;
+    processHandlers: import('./domains/process/index.js').ProcessToolHandlers | undefined;
+    workflowHandlers: import('./domains/workflow/index.js').WorkflowHandlers | undefined;
+    wasmHandlers: import('./domains/wasm/index.js').WasmToolHandlers | undefined;
+    streamingHandlers: import('./domains/streaming/index.js').StreamingToolHandlers | undefined;
+    encodingHandlers: import('./domains/encoding/index.js').EncodingToolHandlers | undefined;
+    antidebugHandlers: import('./domains/antidebug/index.js').AntiDebugToolHandlers | undefined;
+    graphqlHandlers: import('./domains/graphql/index.js').GraphQLToolHandlers | undefined;
+    platformHandlers: import('./domains/platform/index.js').PlatformToolHandlers | undefined;
+    sourcemapHandlers: import('./domains/sourcemap/index.js').SourcemapToolHandlers | undefined;
+    transformHandlers: import('./domains/transform/index.js').TransformToolHandlers | undefined;
+    coordinationHandlers: import('./domains/coordination/index.js').CoordinationHandlers | undefined;
     constructor(config: Config);
     resolveEnabledDomains(tools: Tool[]): Set<string>;
     registerSingleTool(toolDef: Tool): RegisteredTool;
-    boostProfile(target?: string, ttlMinutes?: number): Promise<Record<string, unknown>>;
-    unboostProfile(target?: string): Promise<Record<string, unknown>>;
-    switchToTier(targetTier: ToolProfile): Promise<void>;
     reloadExtensions(): Promise<ExtensionReloadResult>;
     listExtensions(): ExtensionListResult;
     registerCaches(): Promise<void>;

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

@@ -1,5 +1,6 @@
 import { logger } from '../utils/logger.js';
 import { getToolDomain } from './ToolCatalog.js';
+import { ToolError } from '../errors/ToolError.js';
 export function resolveEnabledDomains(tools) {
     const domains = new Set();
     for (const tool of tools) {
@@ -17,12 +18,12 @@ export function createDomainProxy(ctx, domain, label, factory) {
         get: (_target, prop) => {
             if (!ctx.enabledDomains.has(domain)) {
                 return () => {
-                    throw new Error(`${label} is unavailable: domain "${domain}" not enabled by current tool profile`);
+                    throw new ToolError('PREREQUISITE', `${label} is unavailable: domain "${domain}" not enabled by current tool profile`, { details: { domain, label } });
                 };
             }
             if (!instance) {
                 if (initializing) {
-                    throw new Error(`${label}: circular initialization detected for domain "${domain}"`);
+                    throw new ToolError('RUNTIME', `${label}: circular initialization detected for domain "${domain}"`, { details: { domain, label } });
                 }
                 initializing = true;
                 try {
@@ -33,7 +34,7 @@ export function createDomainProxy(ctx, domain, label, factory) {
                     initializing = false;
                 }
             }
-            const value = Reflect.get(instance, prop);
+            const value = instance[prop];
             return typeof value === 'function' ? value.bind(instance) : value;
         },
     });

package/dist/src/server/MCPServer.js

@@ -5,17 +5,19 @@ import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
 import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
 import { DetailedDataManager } from '../utils/DetailedDataManager.js';
 import { asErrorResponse } from './domains/shared/response.js';
+import { getToolDomain } from './ToolCatalog.js';
 import { ToolExecutionRouter } from './ToolExecutionRouter.js';
 import { ToolCallContextGuard } from './ToolCallContextGuard.js';
 import { createToolHandlerMap } from './ToolHandlerMap.js';
 import { resolveToolsForRegistration } from './MCPServer.registration.js';
 import { createDomainProxy, resolveEnabledDomains } from './MCPServer.domain.js';
-import { boostProfile as boostProfileImpl, refreshBoostTtl, switchToTier as switchToTierImpl, unboostProfile as unboostProfileImpl, } from './MCPServer.boost.js';
-import { closeServer, startHttpTransport, startStdioTransport, } from './MCPServer.transport.js';
-import { registerMetaTools, registerSingleTool as registerSingleToolImpl, } from './MCPServer.tools.js';
+import { refreshDomainTtlForTool } from './MCPServer.activation.ttl.js';
+import { closeServer, startHttpTransport, startStdioTransport } from './MCPServer.transport.js';
+import { registerSingleTool as registerSingleToolImpl } from './MCPServer.tools.js';
 import { registerSearchMetaTools } from './MCPServer.search.js';
-import { ALL_MANIFESTS } from './registry/index.js';
-import { listExtensions as listExtensionsImpl, reloadExtensions as reloadExtensionsImpl } from './extensions/ExtensionManager.js';
+import { createServerEventBus } from './EventBus.js';
+import { getAllManifests } from './registry/index.js';
+import { listExtensions as listExtensionsImpl, reloadExtensions as reloadExtensionsImpl, } from './extensions/ExtensionManager.js';
 export class MCPServer {
     config;
     server;
@@ -23,6 +25,7 @@ export class MCPServer {
     tokenBudget;
     unifiedCache;
     detailedData;
+    eventBus;
     selectedTools;
     enabledDomains;
     router;
@@ -32,17 +35,11 @@ export class MCPServer {
     cacheAdaptersRegistered = false;
     cacheRegistrationPromise;
     baseTier;
-    currentTier;
-    boostHistory = [];
-    boostedToolNames = new Set();
-    boostedRegisteredTools = new Map();
-    boostTtlTimer = null;
-    boostTtlMinutes = 0;
-    boostLock = Promise.resolve();
     activatedToolNames = new Set();
     activatedRegisteredTools = new Map();
-    absorbedFromActivated = new Set();
-    boostedExtensionToolNames = new Set();
+    domainTtlEntries = new Map();
+    metaToolsByName = new Map();
+    clientSupportsListChanged = true;
     extensionToolsByName = new Map();
     extensionPluginsById = new Map();
     extensionPluginRuntimeById = new Map();
@@ -51,80 +48,50 @@ export class MCPServer {
     lastExtensionReloadAt;
     httpServer;
     httpSockets = new Set();
-    collector;
-    pageController;
-    domInspector;
-    scriptManager;
-    debuggerManager;
-    runtimeInspector;
-    consoleMonitor;
-    llm;
-    browserHandlers;
-    debuggerHandlers;
-    advancedHandlers;
-    aiHookHandlers;
-    hookPresetHandlers;
-    deobfuscator;
-    advancedDeobfuscator;
-    astOptimizer;
-    obfuscationDetector;
-    analyzer;
-    cryptoDetector;
-    hookManager;
-    coreAnalysisHandlers;
-    coreMaintenanceHandlers;
-    extensionManagementHandlers;
-    processHandlers;
-    workflowHandlers;
-    wasmHandlers;
-    streamingHandlers;
-    encodingHandlers;
-    antidebugHandlers;
-    graphqlHandlers;
-    platformHandlers;
-    sourcemapHandlers;
-    transformHandlers;
+    domainInstanceMap = new Map();
+    getDomainInstance(key) {
+        return this.domainInstanceMap.get(key);
+    }
+    setDomainInstance(key, value) {
+        this.domainInstanceMap.set(key, value);
+    }
     constructor(config) {
         this.config = config;
         this.cache = new CacheManager(config.cache);
         this.tokenBudget = new TokenBudgetManager();
         this.unifiedCache = new UnifiedCacheManager();
         this.detailedData = new DetailedDataManager();
+        this.eventBus = createServerEventBus();
         this.tokenBudget.setExternalCleanup(() => this.detailedData.clear());
         const { tools, profile } = resolveToolsForRegistration();
         this.selectedTools = tools;
         this.baseTier = profile;
-        this.currentTier = profile;
         this.enabledDomains = this.resolveEnabledDomains(this.selectedTools);
         const depsEntries = [];
-        for (const m of ALL_MANIFESTS) {
+        const manifests = getAllManifests();
+        for (const m of manifests) {
             depsEntries.push([
                 m.depKey,
                 createDomainProxy(this, m.domain, `${m.domain}:${m.depKey}`, () => m.ensure(this)),
             ]);
         }
-        const hooksManifest = ALL_MANIFESTS.find(m => m.domain === 'hooks');
-        if (hooksManifest && !depsEntries.some(([k]) => k === 'hookPresetHandlers')) {
-            depsEntries.push([
-                'hookPresetHandlers',
-                createDomainProxy(this, 'hooks', 'hooks:hookPresetHandlers', () => {
-                    hooksManifest.ensure(this);
-                    return this.hookPresetHandlers;
-                }),
-            ]);
-        }
-        const maintenanceManifest = ALL_MANIFESTS.find(m => m.domain === 'maintenance');
-        if (maintenanceManifest && !depsEntries.some(([k]) => k === 'extensionManagementHandlers')) {
-            depsEntries.push([
-                'extensionManagementHandlers',
-                createDomainProxy(this, 'maintenance', 'maintenance:extensionManagementHandlers', () => {
-                    maintenanceManifest.ensure(this);
-                    return this.extensionManagementHandlers;
-                }),
-            ]);
+        for (const m of manifests) {
+            if (m.secondaryDepKeys) {
+                for (const key of m.secondaryDepKeys) {
+                    if (!depsEntries.some(([k]) => k === key)) {
+                        depsEntries.push([
+                            key,
+                            createDomainProxy(this, m.domain, `${m.domain}:${key}`, () => {
+                                m.ensure(this);
+                                return this[key];
+                            }),
+                        ]);
+                    }
+                }
+            }
         }
         this.handlerDeps = Object.fromEntries(depsEntries);
-        const selectedToolNames = new Set(this.selectedTools.map(t => t.name));
+        const selectedToolNames = new Set(this.selectedTools.map((t) => t.name));
         this.router = new ToolExecutionRouter(createToolHandlerMap(this.handlerDeps, selectedToolNames));
         this.contextGuard = new ToolCallContextGuard(() => {
             const bh = this.handlerDeps.browserHandlers;
@@ -142,15 +109,6 @@ export class MCPServer {
     registerSingleTool(toolDef) {
         return registerSingleToolImpl(this, toolDef);
     }
-    async boostProfile(target, ttlMinutes) {
-        return boostProfileImpl(this, target, ttlMinutes);
-    }
-    async unboostProfile(target) {
-        return unboostProfileImpl(this, target);
-    }
-    async switchToTier(targetTier) {
-        return switchToTierImpl(this, targetTier);
-    }
     async reloadExtensions() {
         return reloadExtensionsImpl(this);
     }
@@ -202,9 +160,15 @@ export class MCPServer {
             catch (trackingError) {
                 logger.warn('Token tracking failed, continuing without tracking this call:', trackingError);
             }
-            if (this.boostedToolNames.has(name)) {
-                refreshBoostTtl(this);
+            if (this.activatedToolNames.has(name)) {
+                refreshDomainTtlForTool(this, name);
             }
+            void this.eventBus.emit('tool:called', {
+                toolName: name,
+                domain: getToolDomain(name) ?? null,
+                timestamp: new Date().toISOString(),
+                success: true,
+            });
             return enriched;
         }
         catch (error) {
@@ -244,8 +208,38 @@ export class MCPServer {
         for (const toolDef of this.selectedTools) {
             this.registerSingleTool(toolDef);
         }
-        registerMetaTools(this);
         registerSearchMetaTools(this);
         logger.info(`Registered ${this.selectedTools.length} tools + meta tools with McpServer`);
     }
 }
+const DOMAIN_INSTANCE_KEYS = [
+    'collector', 'pageController', 'domInspector',
+    'scriptManager', 'debuggerManager', 'runtimeInspector',
+    'consoleMonitor', 'llm',
+    'browserHandlers', 'debuggerHandlers', 'advancedHandlers',
+    'aiHookHandlers', 'hookPresetHandlers',
+    'deobfuscator', 'advancedDeobfuscator', 'astOptimizer',
+    'obfuscationDetector', 'analyzer', 'cryptoDetector', 'hookManager',
+    'coreAnalysisHandlers', 'coreMaintenanceHandlers', 'extensionManagementHandlers',
+    'processHandlers', 'workflowHandlers', 'wasmHandlers',
+    'streamingHandlers', 'encodingHandlers', 'antidebugHandlers',
+    'graphqlHandlers', 'platformHandlers', 'sourcemapHandlers',
+    'transformHandlers', 'coordinationHandlers',
+];
+for (const key of DOMAIN_INSTANCE_KEYS) {
+    if (key === 'domainInstanceMap' || key === 'getDomainInstance' || key === 'setDomainInstance')
+        continue;
+    Object.defineProperty(MCPServer.prototype, key, {
+        get() {
+            return this.domainInstanceMap.get(key);
+        },
+        set(v) {
+            if (v === undefined)
+                this.domainInstanceMap.delete(key);
+            else
+                this.domainInstanceMap.set(key, v);
+        },
+        enumerable: true,
+        configurable: true,
+    });
+}

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

@@ -7,9 +7,7 @@ export function resolveToolsForRegistration() {
     if (explicitDomains && explicitDomains.length > 0) {
         const tools = getToolsByDomains(explicitDomains);
         logger.info(`Tool registration mode=domains [${explicitDomains.join(',')}], count=${tools.length}`);
-        const profile = explicitProfile === 'full' ||
-            explicitProfile === 'workflow' ||
-            explicitProfile === 'search'
+        const profile = explicitProfile === 'full' || explicitProfile === 'workflow' || explicitProfile === 'search'
             ? explicitProfile
             : 'search';
         return { tools, profile };

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

@@ -1,4 +1,12 @@
 import type { MCPServerContext } from './MCPServer.context.js';
 import type { ToolResponse } from './types.js';
+interface ActivationSummary {
+    activated: string[];
+    alreadyActive: string[];
+    notFound: string[];
+    totalActive: number;
+}
+export declare function activateToolNames(ctx: MCPServerContext, names: string[]): Promise<ActivationSummary>;
 export declare function handleActivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
 export declare function handleDeactivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
+export {};

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

@@ -2,18 +2,26 @@ 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 }));
+import { normalizeToolName, validateToolNameArray } from './MCPServer.search.validation.js';
+import { getActiveToolNames, getToolByName } from './MCPServer.search.helpers.js';
+async function notifyToolListChanged(ctx, changed) {
+    if (!changed) {
+        return;
+    }
+    try {
+        await ctx.server.sendToolListChanged();
+    }
+    catch (e) {
+        logger.warn('sendToolListChanged failed:', e);
     }
+}
+export async function activateToolNames(ctx, names) {
     const activeNames = getActiveToolNames(ctx);
     const activated = [];
     const alreadyActive = [];
     const notFound = [];
-    for (const name of names) {
+    for (const rawName of names) {
+        const name = normalizeToolName(rawName);
         if (activeNames.has(name)) {
             alreadyActive.push(name);
             continue;
@@ -35,7 +43,9 @@ export async function handleActivateTools(ctx, args) {
             ctx.enabledDomains.add(domain);
         }
         if (extensionRecord?.handler) {
-            ctx.router.addHandlers({ [name]: extensionRecord.handler });
+            ctx.router.addHandlers({
+                [name]: extensionRecord.handler,
+            });
         }
         else {
             const newToolNames = new Set([name]);
@@ -45,21 +55,27 @@ export async function handleActivateTools(ctx, args) {
         activated.push(name);
         activeNames.add(name);
     }
-    if (activated.length > 0) {
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed:', e);
-        }
-    }
+    await notifyToolListChanged(ctx, activated.length > 0);
     logger.info(`activate_tools: activated ${activated.length}, already_active ${alreadyActive.length}, not_found ${notFound.length}`);
-    return asTextResponse(JSON.stringify({
-        success: true,
+    return {
         activated,
         alreadyActive,
         notFound,
         totalActive: activeNames.size,
+    };
+}
+export async function handleActivateTools(ctx, args) {
+    const { names, error } = validateToolNameArray(args);
+    if (error) {
+        return asTextResponse(JSON.stringify({ success: false, error }));
+    }
+    const result = await activateToolNames(ctx, names);
+    return asTextResponse(JSON.stringify({
+        success: true,
+        ...result,
+        hint: result.activated.length > 0
+            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
+            : undefined,
     }));
 }
 export async function handleDeactivateTools(ctx, args) {
@@ -69,7 +85,8 @@ export async function handleDeactivateTools(ctx, args) {
     }
     const deactivated = [];
     const notActivated = [];
-    for (const name of names) {
+    for (const rawName of names) {
+        const name = normalizeToolName(rawName);
         if (!ctx.activatedToolNames.has(name)) {
             notActivated.push(name);
             continue;
@@ -92,14 +109,7 @@ export async function handleDeactivateTools(ctx, args) {
         }
         deactivated.push(name);
     }
-    if (deactivated.length > 0) {
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed:', e);
-        }
-    }
+    await notifyToolListChanged(ctx, deactivated.length > 0);
     logger.info(`deactivate_tools: deactivated ${deactivated.length}, not_activated ${notActivated.length}`);
     return asTextResponse(JSON.stringify({
         success: true,

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

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

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

@@ -0,0 +1,91 @@
+import { logger } from '../utils/logger.js';
+import { asTextResponse } from './domains/shared/response.js';
+import { normalizeToolName } from './MCPServer.search.validation.js';
+import { getToolByName, getSearchEngine } from './MCPServer.search.helpers.js';
+import { activateToolNames } from './MCPServer.search.handlers.activate.js';
+function buildCallToolMetadata(wasAutoActivated, activatedTools) {
+    return {
+        wasAutoActivated,
+        activatedTools,
+    };
+}
+function attachCallToolMetadata(response, metadata) {
+    return {
+        ...response,
+        content: response.content.map((item) => {
+            if (item.type !== 'text' || !('text' in item) || typeof item.text !== 'string') {
+                return item;
+            }
+            try {
+                const parsed = JSON.parse(item.text);
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    return item;
+                }
+                return {
+                    ...item,
+                    text: JSON.stringify({
+                        ...parsed,
+                        ...metadata,
+                    }, null, 2),
+                };
+            }
+            catch {
+                return item;
+            }
+        }),
+    };
+}
+export async function handleCallTool(ctx, args) {
+    const rawName = typeof args.name === 'string' ? args.name : '';
+    const defaultMetadata = buildCallToolMetadata(false, []);
+    if (!rawName) {
+        return asTextResponse(JSON.stringify({
+            success: false,
+            error: 'name must be a non-empty string',
+            ...defaultMetadata,
+        }));
+    }
+    const name = normalizeToolName(rawName);
+    const toolArgs = args.args && typeof args.args === 'object' && !Array.isArray(args.args)
+        ? args.args
+        : {};
+    let callMetadata = defaultMetadata;
+    if (!ctx.router.has(name)) {
+        const toolDef = getToolByName(ctx).get(name);
+        if (!toolDef) {
+            return asTextResponse(JSON.stringify({
+                success: false,
+                error: `Tool "${name}" not found in the catalogue. Use search_tools to discover available tools.`,
+                ...callMetadata,
+            }));
+        }
+        logger.info(`call_tool: auto-activating "${name}" (not in router)`);
+        const activation = await activateToolNames(ctx, [name]);
+        callMetadata = buildCallToolMetadata(true, activation.activated);
+        if (activation.activated.length === 0 && activation.alreadyActive.length === 0) {
+            return asTextResponse(JSON.stringify({
+                success: false,
+                error: `Tool "${name}" exists but could not be activated.`,
+                ...callMetadata,
+            }));
+        }
+    }
+    try {
+        const response = await ctx.executeToolWithTracking(name, toolArgs);
+        try {
+            const engine = getSearchEngine(ctx);
+            engine.recordToolCallFeedback(name, '');
+        }
+        catch { }
+        return attachCallToolMetadata(response, callMetadata);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`call_tool: execution of "${name}" failed`, error);
+        return asTextResponse(JSON.stringify({
+            success: false,
+            error: `Tool "${name}" failed: ${message}`,
+            ...callMetadata,
+        }));
+    }
+}