@yusufffararatt/dombridge-mcp 2.7.5

package/src/metrics/metrics-report.js

@@ -0,0 +1,146 @@
+/**
+ * CLI Report Generator
+ * Reads from MetricsDB and produces formatted tables/JSON for npm run metrics.
+ */
+export class MetricsReport {
+  constructor(metricsDB) {
+    this.db = metricsDB;
+  }
+
+  getOverview(days = 30) {
+    if (!this.db.available) return [];
+    const since = new Date(Date.now() - days * 86400000).toISOString();
+    const rows = this.db.db.prepare(`
+      SELECT tool,
+        COUNT(*) as total_calls,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
+        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as fail_count,
+        AVG(duration_ms) as avg_duration_ms,
+        MAX(duration_ms) as max_duration_ms
+      FROM tool_calls
+      WHERE timestamp >= ?
+      GROUP BY tool
+      ORDER BY fail_count DESC, total_calls DESC
+    `).all(since);
+
+    return rows.map(r => ({
+      tool: r.tool,
+      total: r.total_calls,
+      success: r.success_count,
+      fail: r.fail_count,
+      fail_rate: r.total_calls > 0 ? ((r.fail_count / r.total_calls) * 100).toFixed(1) + '%' : '0%',
+      avg_duration_ms: r.avg_duration_ms ? Math.round(r.avg_duration_ms) : null,
+      max_duration_ms: r.max_duration_ms,
+    }));
+  }
+
+  getToolDetail(toolName, days = 30) {
+    if (!this.db.available) return null;
+    const since = new Date(Date.now() - days * 86400000).toISOString();
+
+    const byAction = this.db.db.prepare(`
+      SELECT action, COUNT(*) as total,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
+        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as fail_count,
+        AVG(duration_ms) as avg_duration_ms
+      FROM tool_calls
+      WHERE tool = ? AND timestamp >= ? AND action IS NOT NULL
+      GROUP BY action
+      ORDER BY fail_count DESC
+    `).all(toolName, since);
+
+    const byDomain = this.db.db.prepare(`
+      SELECT domain, COUNT(*) as total,
+        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
+        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as fail_count
+      FROM tool_calls
+      WHERE tool = ? AND timestamp >= ?
+      GROUP BY domain
+      ORDER BY fail_count DESC
+    `).all(toolName, since);
+
+    const byResultType = this.db.db.prepare(`
+      SELECT result_type, COUNT(*) as count
+      FROM tool_calls
+      WHERE tool = ? AND timestamp >= ?
+      GROUP BY result_type
+      ORDER BY count DESC
+    `).all(toolName, since);
+
+    const topErrors = this.db.db.prepare(`
+      SELECT error_code, COUNT(*) as count
+      FROM tool_calls
+      WHERE tool = ? AND timestamp >= ? AND error_code IS NOT NULL
+      GROUP BY error_code
+      ORDER BY count DESC
+      LIMIT 10
+    `).all(toolName, since);
+
+    return {
+      tool: toolName,
+      actions: byAction.map(r => ({
+        action: r.action,
+        total: r.total,
+        success: r.success_count,
+        fail: r.fail_count,
+        fail_rate: r.total > 0 ? ((r.fail_count / r.total) * 100).toFixed(1) + '%' : '0%',
+        avg_duration_ms: r.avg_duration_ms ? Math.round(r.avg_duration_ms) : null,
+      })),
+      domains: byDomain.map(r => ({
+        domain: r.domain || '(none)',
+        total: r.total,
+        success: r.success_count,
+        fail: r.fail_count,
+        fail_rate: r.total > 0 ? ((r.fail_count / r.total) * 100).toFixed(1) + '%' : '0%',
+      })),
+      result_types: byResultType,
+      top_errors: topErrors,
+    };
+  }
+
+  getConnectionEvents(days = 7) {
+    if (!this.db.available) return { disconnections: 0, avg_downtime_ms: 0, max_downtime_ms: 0, total_retries: 0, events: [] };
+
+    const since = new Date(Date.now() - days * 86400000).toISOString();
+
+    const stats = this.db.db.prepare(`
+      SELECT
+        COUNT(CASE WHEN event_type = 'disconnected' THEN 1 END) as disconnections,
+        AVG(CASE WHEN event_type = 'reconnected' AND duration_ms IS NOT NULL THEN duration_ms END) as avg_downtime,
+        MAX(CASE WHEN event_type = 'reconnected' AND duration_ms IS NOT NULL THEN duration_ms END) as max_downtime,
+        SUM(CASE WHEN retry_count IS NOT NULL THEN retry_count ELSE 0 END) as total_retries
+      FROM connection_events
+      WHERE timestamp >= ?
+    `).get(since);
+
+    const recentEvents = this.db.db.prepare(`
+      SELECT * FROM connection_events
+      WHERE timestamp >= ?
+      ORDER BY timestamp DESC
+      LIMIT 20
+    `).all(since);
+
+    return {
+      disconnections: stats.disconnections || 0,
+      avg_downtime_ms: stats.avg_downtime ? Math.round(stats.avg_downtime) : 0,
+      max_downtime_ms: stats.max_downtime || 0,
+      total_retries: stats.total_retries || 0,
+      events: recentEvents,
+    };
+  }
+
+  getErrors(days = 30) {
+    if (!this.db.available) return [];
+    const since = new Date(Date.now() - days * 86400000).toISOString();
+
+    return this.db.db.prepare(`
+      SELECT error_code, tool, domain, COUNT(*) as count,
+        AVG(duration_ms) as avg_duration_ms
+      FROM tool_calls
+      WHERE timestamp >= ? AND error_code IS NOT NULL
+      GROUP BY error_code, tool, domain
+      ORDER BY count DESC
+      LIMIT 50
+    `).all(since);
+  }
+}

package/src/profiles/profile-db.js

@@ -0,0 +1,159 @@
+/**
+ * ProfileDB — SQLite-backed storage for site profiles.
+ *
+ * Pattern mirror: mcp-server/src/metrics/metrics-db.js
+ * - WAL mode for concurrent reads/writes
+ * - Graceful degradation if init fails
+ * - better-sqlite3 prepared statements
+ */
+import Database from 'better-sqlite3';
+import { mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+
+const CREATE_SITE_PROFILES = `
+CREATE TABLE IF NOT EXISTS site_profiles (
+  domain TEXT PRIMARY KEY,
+  framework TEXT,
+  page_type TEXT,
+  notes TEXT,
+  stable_selectors_json TEXT,
+  auth_info_json TEXT,
+  version INTEGER DEFAULT 1,
+  first_seen_at INTEGER,
+  last_seen_at INTEGER
+)`;
+
+const CREATE_ENDPOINTS = `
+CREATE TABLE IF NOT EXISTS endpoints (
+  id INTEGER PRIMARY KEY,
+  domain TEXT NOT NULL,
+  method TEXT NOT NULL,
+  url TEXT NOT NULL,
+  status INTEGER,
+  content_type TEXT,
+  first_seen_at INTEGER,
+  last_seen_at INTEGER,
+  hit_count INTEGER DEFAULT 1,
+  FOREIGN KEY (domain) REFERENCES site_profiles(domain) ON DELETE CASCADE,
+  UNIQUE(domain, method, url)
+)`;
+
+const CREATE_PATHS = `
+CREATE TABLE IF NOT EXISTS paths (
+  id INTEGER PRIMARY KEY,
+  domain TEXT NOT NULL,
+  path TEXT NOT NULL,
+  source_key TEXT,
+  example_value TEXT,
+  FOREIGN KEY (domain) REFERENCES site_profiles(domain) ON DELETE CASCADE
+)`;
+
+const CREATE_IDX_ENDPOINTS = `CREATE INDEX IF NOT EXISTS idx_endpoints_domain ON endpoints(domain)`;
+const CREATE_IDX_PATHS = `CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain)`;
+
+export class ProfileDB {
+    constructor(dbPath) {
+        const dir = dirname(dbPath);
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this._migrate();
+    }
+
+    _migrate() {
+        this.db.exec(CREATE_SITE_PROFILES);
+        this.db.exec(CREATE_ENDPOINTS);
+        this.db.exec(CREATE_PATHS);
+        this.db.exec(CREATE_IDX_ENDPOINTS);
+        this.db.exec(CREATE_IDX_PATHS);
+    }
+
+    close() {
+        this.db.close();
+    }
+
+    // ── Inspection helpers (used by tests) ─────────────────────────────
+    listTables() {
+        return this.db.prepare(
+            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+        ).all().map(row => row.name);
+    }
+
+    getTableInfo(table) {
+        return this.db.prepare(`PRAGMA table_info(${table})`).all();
+    }
+
+    getIndexList(table) {
+        return this.db.prepare(`PRAGMA index_list(${table})`).all();
+    }
+
+    // ── Profile CRUD ───────────────────────────────────────────────────
+    upsertProfile({ domain, framework, pageType, notes }) {
+        const now = Date.now();
+        this.db.prepare(`
+            INSERT INTO site_profiles (domain, framework, page_type, notes, version, first_seen_at, last_seen_at)
+            VALUES (?, ?, ?, ?, 1, ?, ?)
+            ON CONFLICT(domain) DO UPDATE SET
+                framework = COALESCE(excluded.framework, framework),
+                page_type = COALESCE(excluded.page_type, page_type),
+                notes     = excluded.notes,
+                version   = version + 1,
+                last_seen_at = excluded.last_seen_at
+        `).run(domain, framework ?? null, pageType ?? null, notes ?? '', now, now);
+    }
+
+    getProfile(domain) {
+        const row = this.db.prepare(
+            'SELECT * FROM site_profiles WHERE domain = ?'
+        ).get(domain);
+        return row || null;
+    }
+
+    deleteProfile(domain) {
+        this.db.prepare('DELETE FROM site_profiles WHERE domain = ?').run(domain);
+    }
+
+    // ── Endpoint CRUD ──────────────────────────────────────────────────
+    upsertEndpoint(domain, { method, url, status, contentType, firstSeenAt, lastSeenAt }) {
+        const now = Date.now();
+        this.db.prepare(`
+            INSERT INTO endpoints (domain, method, url, status, content_type, first_seen_at, last_seen_at, hit_count)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 1)
+            ON CONFLICT(domain, method, url) DO UPDATE SET
+                status        = COALESCE(excluded.status, status),
+                content_type  = COALESCE(excluded.content_type, content_type),
+                last_seen_at  = excluded.last_seen_at,
+                hit_count     = hit_count + 1
+        `).run(
+            domain,
+            (method || 'GET').toUpperCase(),
+            url,
+            status ?? null,
+            contentType ?? null,
+            firstSeenAt ?? now,
+            lastSeenAt ?? now
+        );
+    }
+
+    countEndpoints(domain) {
+        return this.db.prepare(
+            'SELECT COUNT(*) AS c FROM endpoints WHERE domain = ?'
+        ).get(domain).c;
+    }
+
+    // ── Path CRUD ──────────────────────────────────────────────────────
+    upsertPath(domain, { path, sourceKey, exampleValue }) {
+        this.db.prepare(`
+            INSERT INTO paths (domain, path, source_key, example_value)
+            VALUES (?, ?, ?, ?)
+        `).run(domain, path, sourceKey ?? null, exampleValue ?? null);
+    }
+
+    countPaths(domain) {
+        return this.db.prepare(
+            'SELECT COUNT(*) AS c FROM paths WHERE domain = ?'
+        ).get(domain).c;
+    }
+}

package/src/profiles/profile-enricher.js

@@ -0,0 +1,333 @@
+/**
+ * Profile Enricher
+ * Converts raw tool results into profile-friendly structured data.
+ */
+
+import { saveProfile } from './profile-manager.js';
+import { markFieldFresh } from '../utils/workflow-state.js';
+
+const AUTH_HEADER_PATTERN = /^(authorization|x-api-key|x-auth-token|x-access-token|bearer|cookie|set-cookie|x-csrf-token|x-session)$/i;
+const SENSITIVE_VALUE_PATTERN = /token|secret|password|credential|api[_-]?key|session[_-]?id|auth[_-]?token|bearer|private/i;
+const PRIORITY_SEGMENTS = ['price', 'amount', 'currency', 'title', 'name', 'slug', 'sku', 'stock', 'image', 'id', 'rating', 'pagination', 'page', 'next', 'results', 'items'];
+const MAX_SAMPLE_PATHS_PER_SOURCE = 8;
+const MAX_SAVED_KNOWN_PATHS = 10;
+const MAX_SAVED_ENDPOINTS = 10;
+
+function isoNow() {
+    return new Date().toISOString();
+}
+
+function sanitizeForProfile(data) {
+    if (!data || typeof data !== 'object') return data;
+    if (Array.isArray(data)) return data.map(sanitizeForProfile);
+
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (SENSITIVE_VALUE_PATTERN.test(key)) {
+            result[key] = '***';
+        } else if (Array.isArray(value)) {
+            result[key] = value.map(sanitizeForProfile);
+        } else if (typeof value === 'object' && value !== null) {
+            result[key] = sanitizeForProfile(value);
+        } else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function note(source, text, kind = 'summary') {
+    return {
+        source,
+        kind,
+        timestamp: isoNow(),
+        text
+    };
+}
+
+function scorePath(entry) {
+    const path = String(entry?.path || '').toLowerCase();
+    const priorityHits = PRIORITY_SEGMENTS.reduce((sum, segment) => sum + Number(path.includes(segment)), 0);
+    const exampleBonus = entry?.example ? 3 : 0;
+    const typeBonus = ['string', 'number', 'boolean'].includes(entry?.type) ? 2 : 0;
+    return priorityHits * 10 + exampleBonus + typeBonus - path.length / 200;
+}
+
+function scoreEndpoint(request) {
+    const url = String(request?.url || '').toLowerCase();
+    const contentType = String(request?.contentType || '').toLowerCase();
+    const priorityHits = PRIORITY_SEGMENTS.reduce((sum, segment) => sum + Number(url.includes(segment)), 0);
+    const jsonBonus = contentType.includes('json') ? 8 : 0;
+    const graphqlBonus = request?.graphql?.operationName ? 6 : 0;
+    const successBonus = request?.status >= 200 && request?.status < 300 ? 5 : 0;
+    const queryPenalty = (url.match(/[?&]/g) || []).length;
+    return priorityHits * 10 + jsonBonus + graphqlBonus + successBonus - queryPenalty - url.length / 300;
+}
+
+function pickImportantPaths(paths, sourceKey, originTool) {
+    return (paths || [])
+        .map((entry) => ({
+            path: entry.path,
+            type: entry.type || 'unknown',
+            example: entry.example ? String(entry.example).substring(0, 80) : null,
+            sourceKey,
+            originTool,
+            confidence: scorePath(entry)
+        }))
+        .sort((a, b) => (b.confidence || 0) - (a.confidence || 0))
+        .slice(0, MAX_SAMPLE_PATHS_PER_SOURCE);
+}
+
+function detectAuthInfoFromHeaders(requests) {
+    const authHeaders = requests
+        .flatMap((request) => Object.keys(request.requestHeaders || {}))
+        .filter((header) => AUTH_HEADER_PATTERN.test(header));
+
+    if (authHeaders.length === 0) return null;
+
+    const headerName = authHeaders[0];
+    const type = /cookie/i.test(headerName)
+        ? 'cookie'
+        : (/authorization/i.test(headerName) ? 'bearer' : 'apiKey');
+
+    return { type, headerName };
+}
+
+function inferPageCharacteristics(result) {
+    const ssrKeys = result.ssrData ? Object.keys(result.ssrData) : [];
+    const hasSSR = ssrKeys.length > 0;
+    const hasApiSignal = Array.isArray(result.dataContainers) && result.dataContainers.length > 0;
+
+    return {
+        type: hasSSR ? 'SSR' : (hasApiSignal ? 'SPA' : 'unknown'),
+        signals: ssrKeys,
+        forms: result.elements?.forms ?? 0,
+        inputs: result.elements?.inputs ?? 0,
+        buttons: result.elements?.buttons ?? 0,
+        links: result.elements?.links ?? 0,
+        domElements: result.domStats?.totalElements ?? null,
+        maxDepth: result.domStats?.maxDepth ?? null
+    };
+}
+
+function extractFromAnalyzePage(result) {
+    if (!result) return {};
+
+    const frameworks = Array.isArray(result.frameworks) ? result.frameworks : [];
+    const pageCharacteristics = inferPageCharacteristics(result);
+    const ssrKeys = pageCharacteristics.signals || [];
+    const dataContainers = Array.isArray(result.dataContainers) ? result.dataContainers : [];
+    const dataContainerHints = dataContainers.slice(0, 8).map((entry) => entry.selector);
+    const paginationPatterns = /paginat|load more|next/i.test(JSON.stringify(result.headings || []))
+        ? { type: 'dom-hint', source: 'analyze_page' }
+        : null;
+
+    const partial = {
+        framework: frameworks,
+        pageCharacteristics,
+        paginationPatterns,
+        profileMeta: {
+            lastAnalyzedAt: isoNow()
+        }
+    };
+
+    const textParts = [];
+    if (frameworks.length > 0) textParts.push(`frameworks=${frameworks.join(', ')}`);
+    textParts.push(`pageType=${pageCharacteristics.type}`);
+    if (ssrKeys.length > 0) textParts.push(`ssr=${ssrKeys.join(', ')}`);
+    if (dataContainerHints.length > 0) textParts.push(`containers=${dataContainerHints.slice(0, 3).join(', ')}`);
+
+    partial.autoNotes = [note('analyze_page', textParts.join(' | '))];
+    return partial;
+}
+
+function extractFromDiscoverApis(raw) {
+    const requests = raw?.requests || [];
+    if (requests.length === 0) return {};
+
+    const successful = requests
+        .filter((request) => request.status >= 200 && request.status < 300)
+        .sort((a, b) => scoreEndpoint(b) - scoreEndpoint(a))
+        .slice(0, MAX_SAVED_ENDPOINTS)
+        .map((request) => ({
+            url: request.url,
+            method: request.method || 'GET',
+            status: request.status,
+            contentType: request.contentType || null,
+            originTool: 'discover_apis',
+            originDescription: 'captured during API discovery',
+            lastSeenAt: request.timestamp ? new Date(request.timestamp).toISOString() : isoNow(),
+            operationName: request.graphql?.operationName || null,
+            operationType: request.graphql?.operationType || null
+        }));
+
+    const responseHeaderPatterns = requests
+        .map((request) => request.contentType)
+        .filter(Boolean)
+        .reduce((acc, contentType) => {
+            const base = contentType.split(';')[0].trim();
+            acc[base] = (acc[base] || 0) + 1;
+            return acc;
+        }, {});
+
+    const partial = {
+        apiEndpoints: successful,
+        responseHeaderPatterns,
+        authInfo: detectAuthInfoFromHeaders(requests),
+        profileMeta: {
+            lastDiscoveryAt: isoNow()
+        }
+    };
+
+    if (successful.length > 0) {
+        partial.autoNotes = [
+            note(
+                'discover_apis',
+                `${successful.length} endpoint(s) captured; top content types=${Object.keys(responseHeaderPatterns).slice(0, 3).join(', ') || 'unknown'}`
+            )
+        ];
+    }
+
+    return partial;
+}
+
+function extractFromExtractData(result) {
+    if (!result) return {};
+
+    if (!Array.isArray(result.sources) || result.sources.length === 0) {
+        return {
+            dataSchema: {
+                sources: [],
+                notes: 'No embedded SSR data. Site is API-driven — use discover_apis() + get_network_trace() to find data sources.'
+            },
+            apiEndpoints: Array.isArray(result.capturedEndpoints) ? result.capturedEndpoints : [],
+            lastUpdated: isoNow()
+        };
+    }
+
+    const knownPaths = [];
+    const sources = result.sources.map((source) => {
+        const topLevelKeys = Object.keys(source.schema || {}).filter((key) => !key.startsWith('__')).slice(0, 20);
+        const samplePaths = pickImportantPaths(source.leafPaths || [], source.key, 'extract_data');
+        knownPaths.push(...samplePaths);
+
+        return {
+            key: source.key,
+            type: source.type,
+            isArray: source.isArray || false,
+            arrayLength: source.arrayLength || null,
+            topLevelKeyCount: source.topLevelKeyCount || null,
+            topLevelKeys,
+            leafPathCount: Array.isArray(source.leafPaths) ? source.leafPaths.length : 0,
+            samplePaths,
+            capturedAt: isoNow()
+        };
+    });
+
+    const topKnownPaths = knownPaths
+        .sort((a, b) => (b.confidence || 0) - (a.confidence || 0))
+        .slice(0, MAX_SAVED_KNOWN_PATHS);
+
+    return {
+        dataSchema: { sources },
+        knownPaths: topKnownPaths,
+        autoNotes: [
+            note(
+                'extract_data',
+                `${sources.length} source(s) captured; saved top ${topKnownPaths.length} path(s); primary=${sources.slice(0, 3).map((source) => source.key).join(', ')}`
+            )
+        ]
+    };
+}
+
+function extractFromNetworkTrace(raw) {
+    const matches = (raw?.matches || []).filter((match) => {
+        const confidence = match.matchInfo?.confidence ?? match.confidence ?? 0;
+        return confidence >= 80;
+    });
+
+    if (matches.length === 0) return {};
+
+    const apiEndpoints = matches
+        .map((match) => ({
+            url: match.url || match.requestUrl,
+            method: match.method || 'GET',
+            status: match.status || match.statusCode || null,
+            confidence: match.matchInfo?.confidence ?? match.confidence ?? null,
+            dataPath: Array.isArray(match.matchInfo?.paths) ? match.matchInfo.paths[0] : match.dataPath || null,
+            originTool: 'get_network_trace',
+            originDescription: raw?.elementLabel
+                ? `matched selected element "${raw.elementLabel}"`
+                : 'high-confidence DOM/network match'
+        }))
+        .filter((endpoint) => endpoint.url);
+
+    const knownPaths = apiEndpoints
+        .filter((endpoint) => endpoint.dataPath)
+        .map((endpoint) => ({
+            path: endpoint.dataPath,
+            type: 'matched-response-path',
+            example: raw?.elementLabel || null,
+            sourceKey: endpoint.url,
+            originTool: 'get_network_trace',
+            confidence: endpoint.confidence ?? null
+        }));
+
+    const partial = {
+        apiEndpoints,
+        knownPaths,
+        authInfo: detectAuthInfoFromHeaders(matches),
+        autoNotes: [
+            note(
+                'get_network_trace',
+                `${apiEndpoints.length} high-confidence match(es); matched paths=${knownPaths.slice(0, 3).map((path) => path.path).join(', ') || 'none'}`
+            )
+        ]
+    };
+
+    return partial;
+}
+
+export function buildProfileEnrichment(toolName, rawResult) {
+    let partial = {};
+
+    switch (toolName) {
+        case 'analyze_page':
+            partial = extractFromAnalyzePage(rawResult);
+            break;
+        case 'discover_apis':
+            partial = extractFromDiscoverApis(rawResult);
+            break;
+        case 'extract_data':
+            partial = extractFromExtractData(rawResult);
+            break;
+        case 'get_network_trace':
+            partial = extractFromNetworkTrace(rawResult);
+            break;
+        case 'csp_detection':
+            partial = { cspStatus: rawResult?.level || 'strict' };
+            break;
+        default:
+            partial = {};
+    }
+
+    return sanitizeForProfile(partial);
+}
+
+export function enrichProfile(domain, toolName, rawResult) {
+    if (!domain || !toolName || !rawResult) return;
+
+    Promise.resolve().then(() => {
+        try {
+            const partial = buildProfileEnrichment(toolName, rawResult);
+            if (Object.keys(partial).length === 0) return;
+
+            saveProfile(domain, partial);
+            for (const field of Object.keys(partial)) {
+                markFieldFresh(domain, field);
+            }
+        } catch {
+            // Enrichment must not break tool execution.
+        }
+    });
+}