@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/ToolRouter.js

@@ -1,247 +1,46 @@
 import { logger } from '../utils/logger.js';
-import { allTools, getToolDomain } from './ToolCatalog.js';
+import {} from './ToolSearch.js';
+import { ensureWorkflowsLoaded } from './extensions/ExtensionManager.js';
 import { getActiveToolNames } from './MCPServer.search.helpers.js';
-import { normalizeToolName } from './MCPServer.search.validation.js';
-import { ToolSearchEngine } from './ToolSearch.js';
-import { getAllManifests } from './registry/index.js';
-let _allToolsByName = null;
-function getAllToolsByName() {
-    if (!_allToolsByName)
-        _allToolsByName = new Map(allTools.map((t) => [t.name, t]));
-    return _allToolsByName;
-}
-let _cachedWorkflowRules = null;
-function getEffectiveWorkflowRules() {
-    if (_cachedWorkflowRules)
-        return _cachedWorkflowRules;
-    const rules = [];
-    for (const m of getAllManifests()) {
-        if (m.workflowRule) {
-            rules.push({
-                patterns: [...m.workflowRule.patterns],
-                domain: m.domain,
-                priority: m.workflowRule.priority,
-                tools: [...m.workflowRule.tools],
-                hint: m.workflowRule.hint,
-            });
-        }
-    }
-    _cachedWorkflowRules = rules.sort((a, b) => b.priority - a.priority);
-    return _cachedWorkflowRules;
-}
-const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
-const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
-let _cachedPrerequisites = null;
-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: () => false,
-                    fix: e.fix,
-                }));
-            }
-        }
-    }
-    _cachedPrerequisites = merged;
-    return _cachedPrerequisites;
-}
-function detectWorkflowIntent(query) {
-    const matches = [];
-    for (const rule of getEffectiveWorkflowRules()) {
-        for (const pattern of rule.patterns) {
-            if (pattern.test(query)) {
-                matches.push(rule);
-                break;
-            }
-        }
-    }
-    if (matches.length === 0)
-        return null;
-    matches.sort((a, b) => b.priority - a.priority);
-    return matches[0];
-}
-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;
-}
-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';
-}
-function isActive(toolName, ctx) {
-    const canonicalName = normalizeToolName(toolName);
-    const activeTools = new Set([
-        ...ctx.selectedTools.map((tool) => tool.name),
-        ...ctx.activatedToolNames,
-    ]);
-    return activeTools.has(canonicalName);
-}
-function getAvailableToolNames(ctx) {
-    return new Set([...allTools.map((tool) => tool.name), ...ctx.extensionToolsByName.keys()]);
-}
-async function probeActivePage(ctx) {
-    if (!ctx.pageController || typeof ctx.pageController.getPage !== 'function')
-        return false;
-    try {
-        return Boolean(await ctx.pageController.getPage());
-    }
-    catch {
-        return false;
-    }
-}
-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;
-}
-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;
-        }
-    }
-}
-async function getRoutingState(ctx) {
-    return {
-        hasActivePage: await probeActivePage(ctx),
-        networkEnabled: probeNetworkEnabled(ctx),
-        capturedRequestCount: probeCapturedRequests(ctx),
-    };
-}
-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;
-}
-function isBrowserOrNetworkTask(task, workflow) {
-    return (workflow?.domain === 'browser' ||
-        workflow?.domain === 'network' ||
-        BROWSER_OR_NETWORK_TASK_PATTERN.test(task));
-}
-function isMaintenanceTask(task) {
-    return MAINTENANCE_TASK_PATTERN.test(task);
-}
-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;
-}
+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 (workflow) {
+    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: getToolDomain(name) ?? ctx.extensionToolsByName.get(name)?.domain ?? null,
-            shortDescription: getToolDescription(name, ctx),
+            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: isActive(name, ctx),
+            isActive: isToolActive(name, ctx),
         }));
         const workflowNames = new Set(workflowSequence);
         const otherResults = searchResults.filter((result) => !workflowNames.has(result.name));
@@ -268,10 +67,12 @@ export async function routeToolRequest(request, ctx, searchEngine) {
         }));
         finalResults.sort((a, b) => b.score - a.score);
     }
-    finalResults = finalResults.slice(0, maxRecommendations);
+    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 = isActive(result.name, ctx);
+        const toolIsActive = isToolActive(result.name, ctx);
         const recommendation = {
             name: result.name,
             domain: result.domain,
@@ -295,15 +96,79 @@ export async function routeToolRequest(request, ctx, searchEngine) {
         return recommendation;
     });
     const nextActions = [];
-    const inactiveTools = recommendations.filter((recommendation) => !recommendation.isActive);
+    const presetRecommendations = presetPlannedToolNames
+        ? recommendations.filter((recommendation) => presetPlannedToolNames.has(recommendation.name))
+        : [];
+    const inactiveTools = (presetRecommendations.length > 0 ? presetRecommendations : recommendations).filter((recommendation) => !recommendation.isActive);
     const activationCandidates = (() => {
-        if (!isBrowserOrNetworkTask(task, workflow) || isMaintenanceTask(task)) {
+        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 (recommendations.length > 0 && recommendations[0]?.isActive) {
+    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',
@@ -334,57 +199,11 @@ export async function routeToolRequest(request, ctx, searchEngine) {
     return {
         recommendations,
         nextActions,
-        workflowHint: workflow?.hint,
+        workflowHint: routeMatchMetadata
+            ? `${routeMatchMetadata.kind === 'preset' ? 'Preset' : 'Workflow'} ${routeMatchMetadata.name}: ${routeMatchMetadata.description}`
+            : workflow?.hint,
+        routeMatch: routeMatchMetadata,
         autoActivated: false,
     };
 }
-export function buildCallToolCommand(toolName, schema) {
-    return `call_tool({ name: "${toolName}", args: ${JSON.stringify(generateExampleArgs(schema))} })`;
-}
-export function generateExampleArgs(schema) {
-    if (!schema || 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 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,
-    };
-}
+export { buildCallToolCommand, describeTool, generateExampleArgs, } from './ToolRouter.renderer.js';

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,17 @@
+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>;