@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/ToolCallContextGuard.js

@@ -11,10 +11,37 @@ const CONTEXT_SENSITIVE_PREFIXES = [
     'js_heap_',
     'script_',
     'captcha_',
+    'ai_hook_',
+    'instrumentation_',
+    'hook_preset_',
+    'ws_',
+    'evidence_',
 ];
+const MAX_CONSECUTIVE_REPEATS = 3;
+const REPEAT_GUARD_EXCLUDES = new Set([
+    'search_tools',
+    'route_tool',
+    'describe_tool',
+    'call_tool',
+    'activate_tools',
+    'deactivate_tools',
+    'activate_domain',
+]);
+const DOMAIN_ALTERNATIVES = new Map([
+    ['stealth', ['page_navigate', 'page_screenshot', 'stealth_verify']],
+    ['page', ['dom_get_structure', 'page_screenshot', 'console_get_logs']],
+    ['console', ['page_evaluate', 'page_screenshot']],
+    ['network', ['network_get_requests', 'page_navigate']],
+    ['captcha', ['captcha_wait', 'page_screenshot']],
+    ['ai_hook', ['manage_hooks', 'page_evaluate', 'ai_hook_inject']],
+    ['instrumentation', ['instrumentation_session_list', 'instrumentation_artifact_query']],
+    ['evidence', ['evidence_query_url', 'evidence_chain']],
+]);
 export class ToolCallContextGuard {
     getProvider;
     contextSensitiveCache = new Map();
+    lastToolName = null;
+    consecutiveCount = 0;
     constructor(getProvider) {
         this.getProvider = getProvider;
     }
@@ -26,7 +53,26 @@ export class ToolCallContextGuard {
         this.contextSensitiveCache.set(toolName, result);
         return result;
     }
+    recordCall(toolName) {
+        if (REPEAT_GUARD_EXCLUDES.has(toolName)) {
+            return 0;
+        }
+        if (toolName === this.lastToolName) {
+            this.consecutiveCount++;
+        }
+        else {
+            this.lastToolName = toolName;
+            this.consecutiveCount = 1;
+        }
+        return this.consecutiveCount;
+    }
+    isRepeatLoop() {
+        return this.consecutiveCount >= MAX_CONSECUTIVE_REPEATS;
+    }
     enrichResponse(toolName, response) {
+        if (this.isRepeatLoop() && !REPEAT_GUARD_EXCLUDES.has(toolName)) {
+            this.injectRepeatWarning(toolName, response);
+        }
         if (!this.isContextSensitive(toolName))
             return response;
         if (response.isError)
@@ -82,4 +128,43 @@ export class ToolCallContextGuard {
         }
         return raw.replace(/\}\s*$/, `,"_tabContext":${compactJson}}`);
     }
+    injectRepeatWarning(toolName, response) {
+        const prefix = toolName.split('_')[0] ?? '';
+        const alternatives = DOMAIN_ALTERNATIVES.get(prefix) ?? ['page_navigate', 'page_screenshot'];
+        const suggestions = alternatives.filter((t) => t !== toolName);
+        const warning = {
+            detected: true,
+            consecutiveCount: this.consecutiveCount,
+            message: `⚠ You have called "${toolName}" ${this.consecutiveCount} times in a row. ` +
+                `This is likely a loop — consider what you actually need to do next.`,
+            suggestedTools: suggestions,
+            hint: suggestions.length > 0
+                ? `Try calling ${suggestions[0]} instead.`
+                : 'Re-evaluate your task objective before making another tool call.',
+        };
+        const content = response.content;
+        if (!Array.isArray(content))
+            return;
+        const firstText = content.find((c) => typeof c === 'object' &&
+            c !== null &&
+            c.type === 'text' &&
+            typeof c.text === 'string');
+        if (firstText) {
+            const raw = firstText.text;
+            try {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                    parsed._repeatWarning = warning;
+                    firstText.text = JSON.stringify(parsed, null, 2);
+                    return;
+                }
+            }
+            catch {
+            }
+        }
+        content.push({
+            type: 'text',
+            text: JSON.stringify({ _repeatWarning: warning }, null, 2),
+        });
+    }
 }

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

@@ -1,6 +1,10 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-import { ToolSearchEngine } from './ToolSearch.js';
+import { type ToolSearchEngine } from './ToolSearch.js';
+import type { WorkflowRule, RoutedWorkflowMatch } from './ToolRouter.intent.js';
+import type { RoutingState } from './ToolRouter.probe.js';
+export type { WorkflowRule, RoutedWorkflowMatch };
+export type { RoutingState };
+import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
 export interface RouterRequest {
     task: string;
     context?: {
@@ -34,15 +38,27 @@ export interface RouterResponse {
         description: string;
     }>;
     workflowHint?: string;
+    routeMatch?: {
+        kind: WorkflowRouteMetadata['kind'];
+        id: string;
+        name: string;
+        description: string;
+        confidence: number;
+        matchedPattern: string;
+        requiredDomains: string[];
+        steps: Array<{
+            id: string;
+            toolName: string;
+            domain: string | null;
+            description: string;
+            prerequisites: string[];
+            parallel?: boolean;
+            isActive: boolean;
+        }>;
+    };
     autoActivated?: boolean;
     activatedNames?: string[];
     callToolHint?: string;
 }
-export declare function routeToolRequest(request: RouterRequest, ctx: MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
-export declare function buildCallToolCommand(toolName: string, schema: Tool['inputSchema']): string;
-export declare function generateExampleArgs(schema: Tool['inputSchema']): Record<string, unknown>;
-export declare function describeTool(toolName: string, ctx: MCPServerContext): {
-    name: string;
-    description: string;
-    inputSchema: Tool['inputSchema'];
-} | null;
+export declare function routeToolRequest(request: RouterRequest, ctx: import('./MCPServer.context.js').MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
+export { buildCallToolCommand, describeTool, generateExampleArgs, } from './ToolRouter.renderer.js';

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

@@ -0,0 +1,26 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
+export interface WorkflowRule {
+    patterns: RegExp[];
+    domain: string;
+    priority: number;
+    tools: string[];
+    hint: string;
+}
+export interface RoutedWorkflowMatch {
+    workflow: {
+        id: string;
+        name: string;
+        description: string;
+        route: WorkflowRouteMetadata;
+    };
+    confidence: number;
+    matchedPattern: string;
+}
+export declare const BROWSER_OR_NETWORK_TASK_PATTERN: RegExp;
+export declare const MAINTENANCE_TASK_PATTERN: RegExp;
+export declare function getEffectiveWorkflowRules(): WorkflowRule[];
+export declare function detectWorkflowIntent(query: string): WorkflowRule | null;
+export declare function matchWorkflowRoute(query: string, ctx: MCPServerContext): RoutedWorkflowMatch | null;
+export declare function isBrowserOrNetworkTask(task: string, workflow: WorkflowRule | null): boolean;
+export declare function isMaintenanceTask(task: string): boolean;

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

@@ -0,0 +1,77 @@
+import { getAllManifests } from './registry/index.js';
+export const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
+export const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
+let _cachedWorkflowRules = null;
+export 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].toSorted((a, b) => b.priority - a.priority);
+    return _cachedWorkflowRules;
+}
+export 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];
+}
+export function matchWorkflowRoute(query, ctx) {
+    let bestMatch = null;
+    for (const [workflowId, runtimeRecord] of ctx.extensionWorkflowRuntimeById.entries()) {
+        const route = runtimeRecord.route ?? runtimeRecord.workflow.route;
+        if (!route) {
+            continue;
+        }
+        const descriptor = ctx.extensionWorkflowsById.get(workflowId);
+        const name = descriptor?.displayName ?? runtimeRecord.workflow.displayName;
+        const description = descriptor?.description ?? runtimeRecord.workflow.description ?? 'Workflow route';
+        for (const pattern of route.triggerPatterns) {
+            if (!pattern.test(query)) {
+                continue;
+            }
+            const confidence = route.priority / 100;
+            if (!bestMatch || confidence > bestMatch.confidence) {
+                bestMatch = {
+                    workflow: {
+                        id: workflowId,
+                        name,
+                        description,
+                        route,
+                    },
+                    confidence,
+                    matchedPattern: pattern.source,
+                };
+            }
+            break;
+        }
+    }
+    return bestMatch;
+}
+export function isBrowserOrNetworkTask(task, workflow) {
+    return (workflow?.domain === 'browser' ||
+        workflow?.domain === 'network' ||
+        BROWSER_OR_NETWORK_TASK_PATTERN.test(task));
+}
+export function isMaintenanceTask(task) {
+    return MAINTENANCE_TASK_PATTERN.test(task);
+}