@yusufffararatt/dombridge-mcp 2.7.5

package/src/tools/get-network-trace.js

@@ -0,0 +1,471 @@
+/**
+ * Tool: get_network_trace
+ * Retrieves network API calls that match the selected DOM element
+ *
+ * Phase 2.4: Refactored from (args, extensionData) to (args, bridgeClient).
+ * All state reads go through bridgeClient property getters.
+ */
+
+import { StateValidator } from '../utils/state-validator.js';
+import { RateLimiter } from '../utils/rate-limiter.js';
+import { validatePrerequisites, formatHardGuard, suggestNextTools, formatWorkflowSuggestions } from '../utils/workflow-helper.js';
+import { enrichProfile } from '../profiles/profile-enricher.js';
+import { extractDomain, getSavedSsrPaths } from '../profiles/profile-manager.js';
+import { runScript } from '../utils/run-script.js';
+
+export const getNetworkTraceTool = {
+  name: 'get_network_trace',
+  description: `Retrieve network API calls (REST or WebSocket) that match the selected DOM element's data.
+
+WORKFLOW POSITION: 🟢 Second Step - Call after get_element
+
+PREREQUISITES:
+- ✅ get_element must be called first (or element selected manually)
+- Extension must have captured network activity
+
+TAB CONTEXT NOTE: Network trace is stored globally (not per-tab). It reflects
+the tab that last triggered element selection. If you called get_element({ tabId: N })
+and then switched context, call get_element again before get_network_trace to ensure
+the trace matches the correct tab's data.
+
+PARAMETERS:
+- minConfidence: Minimum confidence threshold (0.0-1.0). Default: 0.5 (REST), 0.1 (WebSocket — real-time data scores lower on fuzzy matching)
+- limit: Max results to show (default: 3 — top matches by confidence)
+- protocol: 'rest' (default) | 'ws' | 'all' — switch to WebSocket trace for real-time sites
+
+RETURNS: Top matching API calls with:
+- Confidence scores (how likely the API populates this element)
+- 🔍 Smart Analysis: Headers, GraphQL parsing for top matches
+- JSON paths to matched values (use paths to extract data via execute_js if needed)
+
+COMMON WORKFLOWS:
+1. get_element → get_network_trace               (REST APIs)
+2. get_element → get_network_trace(protocol:'ws') (WebSocket: Binance, Discord, trading apps)
+
+Use protocol:'ws' when dealing with real-time sites (stock prices, live chat, notifications).`,
+
+  inputSchema: {
+    type: 'object',
+    properties: {
+      minConfidence: {
+        type: 'number',
+        description: 'Minimum confidence score (0.0-1.0). Default: 0.5 (REST), 0.1 (WebSocket — real-time payloads score lower on fuzzy matching)',
+        default: 0.5
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results. Default: 3',
+        default: 3
+      },
+      protocol: {
+        type: 'string',
+        enum: ['rest', 'ws', 'all'],
+        description: "Protocol to trace. 'rest' = HTTP/XHR (default), 'ws' = WebSocket, 'all' = both",
+        default: 'rest'
+      },
+      verbose: {
+        type: 'boolean',
+        description: 'Return full detail: all data paths, request headers, GraphQL fields, response bodies (default: false)',
+        default: false
+      }
+    }
+  },
+
+  handler: async (args, bridgeClient) => {
+    // Hard guard: element must be selected first
+    const prereqValidation = validatePrerequisites('get_network_trace', bridgeClient);
+    if (!prereqValidation.valid) {
+      return formatHardGuard('get_network_trace', prereqValidation);
+    }
+
+    return await RateLimiter.executeWithRetry(
+      'get_network_trace',
+      async () => {
+        const protocol = args?.protocol || 'rest';
+        const callerTabId = args?.tabId;
+
+        // Tab-mismatch guard for both REST and WS:
+        // If the stored trace is for a different tab than the caller, refuse
+        // rather than leaking the previous tab's data. Caller can re-select
+        // an element on the right tab, or drop tabId to use the latest trace.
+        const traceTabId = protocol === 'ws'
+          ? bridgeClient.websocketTrace?.tabId
+          : bridgeClient.networkTrace?.tabId;
+        if (traceTabId && callerTabId && traceTabId !== callerTabId) {
+          return {
+            content: [{
+              type: 'text',
+              text: `⚠️  ${protocol === 'ws' ? 'WebSocket' : 'Network'} trace is for tab ${traceTabId}, but you targeted tab ${callerTabId}.\n` +
+                    `Re-select an element on tab ${callerTabId} or call without tabId to use the latest trace.\n\n` +
+                    `Call: \`get_element({ tabId: ${callerTabId}, ... })\` to refresh.`
+            }]
+          };
+        }
+
+        // WebSocket real-time data typically scores lower on fuzzy text matching
+        // because the payload is binary/structured (Socket.IO frames, protobuf).
+        // Lower default to surface useful matches; users can raise it for precision.
+        const defaultMinConfidence = protocol === 'ws' ? 0.1 : 0.5;
+        const minConfidence = (args?.minConfidence ?? defaultMinConfidence) * 100;
+        const limit = args?.limit || 3;
+        const verbose = args?.verbose || false;
+
+        // WebSocket trace path
+        if (protocol === 'ws') {
+          return formatWebSocketTrace(bridgeClient, minConfidence, limit, verbose);
+        }
+
+        // Validate network trace data (REST path)
+        const validation = StateValidator.validateNetworkTrace(bridgeClient);
+        if (!validation.valid) {
+          if (validation.error === 'No network trace available' || validation.error === 'Network trace has no matches') {
+            // Navigation detection: if stored element has a different pageUrl than current URL,
+            // the user navigated away. Attempt to re-resolve the selector on the new page.
+            const currentPageUrl = bridgeClient.activeTabUrl || '';
+            const elementPageUrl = bridgeClient.selectedElement?.pageUrl || '';
+            const navigated = elementPageUrl && currentPageUrl && elementPageUrl !== currentPageUrl;
+
+            if (navigated && bridgeClient.selectedElement?.cssSelector) {
+              try {
+                const reResolveResult = await runScript(
+                  `(function() {
+                    var el = document.querySelector(${JSON.stringify(bridgeClient.selectedElement.cssSelector)});
+                    if (!el) return { found: false, reason: 'selector_no_match' };
+                    return {
+                      found: true,
+                      tagName: el.tagName,
+                      textContent: (el.textContent || '').trim().substring(0, 200),
+                      attributes: (function() {
+                        var attrs = {};
+                        for (var i = 0; i < el.attributes.length; i++) {
+                          attrs[el.attributes[i].name] = el.attributes[i].value;
+                        }
+                        return attrs;
+                      })()
+                    };
+                  })()`,
+                  bridgeClient,
+                  5000
+                );
+
+                if (reResolveResult && reResolveResult.found) {
+                  return {
+                    content: [{
+                      type: 'text',
+                      text: `⚠️  Page navigation detected (from ${elementPageUrl} → ${currentPageUrl}).\n\n` +
+                        `The selector \`${bridgeClient.selectedElement.cssSelector}\` still matches an element on the new page:\n\n` +
+                        `- **Tag:** ${reResolveResult.tagName}\n` +
+                        `- **Text:** ${reResolveResult.textContent.substring(0, 100)}${reResolveResult.textContent.length > 100 ? '...' : ''}\n` +
+                        `- **Attributes:** ${Object.entries(reResolveResult.attributes || {}).slice(0, 5).map(([k, v]) => `${k}="${v}"`).join(', ')}\n\n` +
+                        `However, the network trace data was cleared during navigation.\n\n` +
+                        `**Next steps:**\n` +
+                        `1. \`get_element({ css: '${bridgeClient.selectedElement.cssSelector}' })\` — re-select on the new page\n` +
+                        `2. \`get_network_trace()\` — capture fresh network data\n` +
+                        `3. \`discover_apis()\` — list all API calls on the new page`
+                    }]
+                  };
+                } else {
+                  return {
+                    content: [{
+                      type: 'text',
+                      text: `⚠️  Page navigation detected (from ${elementPageUrl} → ${currentPageUrl}).\n\n` +
+                        `The previous selector \`${bridgeClient.selectedElement.cssSelector}\` no longer matches any element on the new page.\n\n` +
+                        `**Next steps:**\n` +
+                        `1. \`analyze_page()\` — understand the new page structure\n` +
+                        `2. \`get_element({ css: '...' })\` — select a new element\n` +
+                        `3. \`get_network_trace()\` — trace APIs on the new page`
+                    }]
+                  };
+                }
+              } catch (_) {
+                // Re-resolve failed — fall through to default message
+              }
+            }
+            // SSR fallback: check saved window.__*__PROPS paths
+            // SSR fallback: check saved window.__*__PROPS paths
+            const pageUrl = bridgeClient.selectedElement?.pageUrl || bridgeClient.activeTabUrl || '';
+            const domain = extractDomain(pageUrl);
+            const ssrPaths = domain ? getSavedSsrPaths(domain) : [];
+
+            let ssrHint = '';
+            if (ssrPaths.length > 0) {
+              ssrHint = `\n\n⚠️  SSR-detected site. Try extract_data() instead:\n`;
+              ssrHint += `- Window props: ${ssrPaths.map(p => p.key).join(', ')}`;
+            }
+
+            return {
+              content: [{
+                type: 'text',
+                text: `No matching API response found for the selected element.${ssrHint}\n\n` +
+                  `The page may be static/SSR-driven, the value may be cached, or the selected text may not appear verbatim in captured response bodies.\n\n` +
+                  `TRY:\n` +
+                  `- extract_data() — list window.__*__PROPS paths\n` +
+                  `- execute_js({ code: "window.__PATH__.fieldName" }) — extract value\n` +
+                  `- manage_site_profile({ action: 'save', dataSchema: {...} }) — persist schema`
+              }]
+            };
+          }
+          return StateValidator.formatValidationError(validation);
+        }
+
+        const trace = validation.data;
+        const elementPageUrl = bridgeClient.selectedElement?.pageUrl || '';
+        const currentPageUrl = bridgeClient.activeTabUrl || '';
+        const isStale = elementPageUrl && currentPageUrl && elementPageUrl !== currentPageUrl;
+        const filteredMatches = trace.matches
+          .filter(m => (m.matchInfo?.confidence || m.confidence || 0) >= minConfidence)
+          .slice(0, limit);
+
+        // Auto-save: yüksek güvenilirlikli match'leri profil'e kaydet
+        const pageUrl = bridgeClient.selectedElement?.pageUrl || bridgeClient.activeTabUrl || '';
+        const domain = extractDomain(pageUrl);
+        if (domain && filteredMatches.some(m => (m.matchInfo?.confidence ?? m.confidence ?? 0) >= 80)) {
+          enrichProfile(domain, 'get_network_trace', { matches: filteredMatches });
+        }
+
+        // Format output
+        let output = `## Network Trace\n\n`;
+        if (isStale) {
+          output += `⚠️  Selected element is from a different page (${elementPageUrl}).\n`;
+          output += `   Current tab: ${currentPageUrl}\n`;
+          output += `   Network trace data may not match. Re-select with \`get_element\` for accurate results.\n\n`;
+        }
+        const searchTerm = trace.elementValue != null ? trace.elementValue : null;
+        if (searchTerm != null) {
+          output += `Searched for: "${searchTerm}"\n`;
+        } else {
+          output += `⚠️  Element state cleared (page navigation detected).\n`;
+          output += `Call \`get_element({ selectorInfo: { css: 'YOUR_SELECTOR' } })\` to re-select an element for accurate matching.\n`;
+          output += `Showing all captured API calls sorted by confidence:\n`;
+        }
+        output += `Total matches: ${trace.totalMatches}\n`;
+        output += `Showing: ${filteredMatches.length} (confidence >= ${minConfidence}%)\n\n`;
+
+        if (filteredMatches.length === 0) {
+          output += `No matches found with confidence >= ${minConfidence}%\n\n`;
+          output += `TRY:\n`;
+          output += `- Lower minConfidence parameter\n`;
+          output += `- Check get_selected_element output for static data sources (SSR/Initial State)\n`;
+        } else {
+          output += `## 📡 API Details\n\n`;
+
+          filteredMatches.forEach((match, idx) => {
+            const confidence = match.matchInfo?.confidence || match.confidence || 0;
+            const isTopMatch = idx < 3 || confidence >= 90;
+            const method = match.method || 'GET';
+            const status = match.status || match.statusCode || '';
+            const url = match.url || match.requestUrl || '(URL not captured)';
+
+            output += `### [${idx + 1}] ${method}${status ? ` ${status}` : ''} (Confidence: ${confidence.toFixed(1)}%)\n`;
+            output += `🔗 URL: ${url}\n`;
+
+            const paths = match.dataPath || match.matchInfo?.paths || [];
+            if (Array.isArray(paths) && paths.length > 0) {
+              const pathStrings = paths.map(p =>
+                typeof p === 'string' ? p : (p.path || p.jsonPath || p.key || JSON.stringify(p))
+              );
+              output += `📍 Matches Path: ${pathStrings.join(', ')}\n`;
+            }
+
+            // GraphQL detection (summary: op name only; verbose: full fields)
+            const isGQL = isGraphQLRequest(match);
+            if (isGQL) {
+              const parsed = parseGraphQLRequest(match);
+              if (parsed) {
+                if (parsed.type === 'batch') {
+                  output += `⚛️  GraphQL: Batched (${parsed.queries.length} queries)\n`;
+                } else {
+                  output += `⚛️  GraphQL: ${parsed.operation} ${parsed.operationName || 'Anonymous'}`;
+                  if (verbose) {
+                    output += ` — Fields: ${parsed.fields.slice(0, 10).join(', ')}${parsed.fields.length > 10 ? '...' : ''}`;
+                  }
+                  output += `\n`;
+                }
+              }
+            }
+
+            // Headers (summary: content-type only for top match; verbose: auth headers too)
+            if (isTopMatch && match.requestHeaders) {
+              if (verbose) {
+                const critical = ['cookie', 'authorization', 'x-api-key', 'user-agent', 'x-csrf-token', 'content-type'];
+                const headersToShow = Object.entries(match.requestHeaders)
+                  .filter(([k]) => critical.includes(k.toLowerCase()));
+                if (headersToShow.length > 0) {
+                  output += `\n🔐 Headers:\n\`\`\`\n`;
+                  headersToShow.forEach(([k, v]) => output += `${k}: ${v}\n`);
+                  output += `\`\`\`\n`;
+                }
+              } else {
+                const ct = Object.entries(match.requestHeaders || {}).find(([k]) => k.toLowerCase() === 'content-type');
+                if (ct) output += `   Content-Type: ${ct[1]}\n`;
+              }
+            }
+            output += `\n---\n\n`;
+          });
+
+          // Add workflow suggestions
+          const suggestions = suggestNextTools('get_network_trace');
+          output += formatWorkflowSuggestions(suggestions);
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: output
+          }]
+        };
+      },
+      { maxRetries: 3 }
+    );
+  }
+};
+
+/**
+ * WebSocket Trace (Merged from get-websocket-trace.js)
+ * Use get_network_trace({ protocol: 'ws' }) to invoke.
+ */
+function formatWebSocketTrace(bridgeClient, minConfPercent, limit) {
+  const wsConnections = bridgeClient.websocketConnections;
+  const selectedElement = bridgeClient.selectedElement;
+
+  if (!wsConnections?.connections?.length) {
+    return {
+      content: [{
+        type: 'text',
+        text: 'No WebSocket data available\n\nThis page may not use WebSockets.\nTry get_network_trace() (REST) instead.'
+      }]
+    };
+  }
+
+  let elementValue = '';
+  if (selectedElement) {
+    const htmlMatch = selectedElement.outerHTML?.match(/>([^<]+)</);
+    if (htmlMatch) elementValue = htmlMatch[1].trim();
+    if (selectedElement.attributes) {
+      const dataVal = selectedElement.attributes['data-symbol-full'] ||
+        selectedElement.attributes['data-symbol-short'] ||
+        selectedElement.attributes['data-value'];
+      if (dataVal) elementValue = dataVal;
+    }
+  }
+
+  const matches = [];
+  for (const conn of wsConnections.connections) {
+    for (const msg of (conn.messages || [])) {
+      const msgData = typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data || '');
+      let confidence = 0;
+      let matchedValue = null;
+      const dataPaths = [];
+
+      if (elementValue && msgData.includes(elementValue)) {
+        confidence = 80;
+        matchedValue = elementValue;
+        if (msg.parsed && typeof msg.parsed === 'object') {
+          wsFindPaths(msg.parsed, elementValue, '', dataPaths);
+        }
+      }
+      if (!matchedValue && elementValue) {
+        const numbers = elementValue.match(/[\d.,]+/g);
+        if (numbers) {
+          for (const num of numbers) {
+            const cleaned = num.replace(/,/g, '').replace(/\./g, '');
+            if (cleaned.length > 3 && msgData.includes(cleaned)) {
+              confidence = 60; matchedValue = cleaned; break;
+            }
+          }
+        }
+      }
+      if (msg.direction === 'received') confidence += 10;
+
+      if (confidence >= minConfPercent) {
+        matches.push({
+          connectionUrl: conn.url, direction: msg.direction,
+          confidence, matchedValue, dataPath: dataPaths,
+          data: msgData.substring(0, 500), timestamp: msg.timestamp
+        });
+      }
+    }
+  }
+
+  matches.sort((a, b) => b.confidence - a.confidence);
+  const top = matches.slice(0, limit);
+
+  let output = `## WebSocket Trace\n\nSearched for: "${elementValue || 'N/A'}"\n`;
+  output += `Connections: ${wsConnections.totalConnections}, Messages: ${wsConnections.totalMessages}\n`;
+  output += `Matches: ${matches.length} (showing top ${top.length})\n\n`;
+
+  if (top.length === 0) {
+    output += `No matches found with confidence >= ${minConfPercent.toFixed(0)}%\nTry lowering minConfidence or use get_network_trace() for REST APIs.\n`;
+  } else {
+    top.forEach((m, idx) => {
+      const dir = m.direction === 'received' ? '[IN]' : '[OUT]';
+      output += `---\n[${idx + 1}] ${dir} Confidence: ${m.confidence.toFixed(0)}%\n`;
+      output += `URL: ${m.connectionUrl?.substring(0, 70)}...\n`;
+      if (m.matchedValue) output += `Matched: "${m.matchedValue}"\n`;
+      if (m.dataPath?.length > 0) output += `Path: ${m.dataPath.slice(0, 2).join(', ')}\n`;
+      output += `Data: ${m.data.substring(0, 200)}${m.data.length > 200 ? '...' : ''}\n\n`;
+    });
+  }
+
+  return { content: [{ type: 'text', text: output }] };
+}
+
+function wsFindPaths(obj, value, path, results, visited = new WeakSet()) {
+  if (!obj || typeof obj !== 'object' || visited.has(obj)) return;
+  visited.add(obj);
+  for (const [key, val] of Object.entries(obj)) {
+    const newPath = path ? `${path}.${key}` : key;
+    if (String(val) === String(value)) results.push(newPath);
+    else if (typeof val === 'object' && val !== null) wsFindPaths(val, value, newPath, results, visited);
+  }
+}
+
+/**
+ * GraphQL Helpers (Merged from analyze-graphql.js)
+ */
+
+function isGraphQLRequest(request) {
+  const url = request.url || '';
+  const method = request.method || '';
+  if (url.includes('/graphql') || url.includes('/api/graphql')) return true;
+  if (method === 'POST' && request.requestBody) {
+    try {
+      const body = typeof request.requestBody === 'string' ? JSON.parse(request.requestBody) : request.requestBody;
+      return !!(body.query || (Array.isArray(body) && body[0]?.query));
+    } catch { return false; }
+  }
+  return false;
+}
+
+function parseGraphQLRequest(request) {
+  try {
+    const body = typeof request.requestBody === 'string' ? JSON.parse(request.requestBody) : request.requestBody;
+    if (Array.isArray(body)) return { type: 'batch', queries: body.map(parseSingleQuery) };
+    return { type: 'single', ...parseSingleQuery(body) };
+  } catch { return null; }
+}
+
+function parseSingleQuery(body) {
+  const query = body.query || '';
+  const variables = body.variables || {};
+  const operationName = body.operationName || extractOperationName(query);
+  const operation = query.trim().startsWith('mutation') ? 'mutation' : 'query';
+  const fields = extractFields(query);
+  return { query, variables, operationName, operation, fields };
+}
+
+function extractOperationName(query) {
+  const match = query.match(/(?:query|mutation)\s+(\w+)/);
+  return match ? match[1] : null;
+}
+
+function extractFields(query) {
+  const fields = [];
+  const cleaned = query.replace(/#.*$/gm, '');
+  const fieldMatches = cleaned.matchAll(/\b([a-zA-Z_]\w*)\s*(?:\(|{|:)/g);
+  for (const match of fieldMatches) {
+    const field = match[1];
+    if (!['query', 'mutation', 'fragment', 'on', 'type'].includes(field)) fields.push(field);
+  }
+  return [...new Set(fields)];
+}

package/src/tools/index.js

@@ -0,0 +1,110 @@
+/**
+ * Tool Registry
+ * Tüm MCP toollarını merkezi olarak yönetir
+ *
+ * TOOL COUNT: 13
+ * REMOVED:  get_selected_element, select_element  → merged into get_element
+ *           get_websocket_trace                   → merged into get_network_trace(protocol:'ws')
+ *           load_site_profile, save_site_profile, check_site_changes → merged into manage_site_profile
+ * CHANGED:  get_network_trace  — default limit 10→3, +protocol param, path serialization fix
+ *           analyze_page       — +includeApis param, +verbose param, summary/verbose modes
+ *           discover_apis      — default limit 50→3, sorted by status, +verbose, +force params
+ *           debug_mcp_state    — description updated (troubleshooting only)
+ * ADDED:    quick_scan         — first-call orchestrator (r6/03)
+ *           paginate           — multi-page / infinite scroll navigation (r6/04)
+ *           manage_site_profile — unified profile CRUD (6 actions: load/save/check/delete/list/update)
+ */
+
+import { getElementTool } from './get-element.js';
+import { getNetworkTraceTool } from './get-network-trace.js';
+import { debugMcpStateTool } from './debug-mcp-state.js';
+import { executeJsTool } from './execute-js.js';
+import { executeActionTool } from './action_tools.js';
+import { captureScreenshotTool } from './screenshot_tools.js';
+import { discoverApisTool } from './discover-apis.js';
+import { analyzePageTool } from './analyze-page.js';
+import { extractDataTool } from './extract-data.js';
+import { exportSessionTool } from './export-session.js';
+import { manageSiteProfileTool } from './manage-site-profile.js';
+import { quickScanTool } from './quick-scan.js';
+import { paginateTool } from './paginate.js';
+import { withMetrics } from '../metrics/metrics-recorder.js';
+
+/**
+ * Tüm kullanılabilir toollar
+ *
+ * AUTONOMOUS WORKFLOW (no manual browser interaction):
+ *   analyze_page({ includeApis: true })
+ *   → get_element({ selectorInfo: { css: '...' } })
+ *   → get_network_trace()
+ *
+ * MANUAL WORKFLOW (user clicks element in browser):
+ *   get_element()
+ *   → get_network_trace()
+ *
+ * WEBSOCKET SITES (Binance, Discord, trading platforms):
+ *   get_element()
+ *   → get_network_trace({ protocol: 'ws' })
+ *
+ * PROFILE MANAGEMENT (replaces load/save/check_site_changes):
+ *   manage_site_profile({ action: 'list' })
+ *   manage_site_profile({ action: 'load', domain: 'x.com' })
+ *   manage_site_profile({ action: 'save', domain: 'x.com' })
+ *   manage_site_profile({ action: 'check', domain: 'x.com' })
+ *   manage_site_profile({ action: 'delete', domain: 'x.com' })
+ *   manage_site_profile({ action: 'update', domain: 'x.com', notes: '...' })
+ */
+export const allTools = [
+  // ── First Step ─────────────────────────────────────────────────────────────
+  { ...quickScanTool, handler: withMetrics('quick_scan', quickScanTool.handler) },
+  { ...analyzePageTool, handler: withMetrics('analyze_page', analyzePageTool.handler) },
+  { ...discoverApisTool, handler: withMetrics('discover_apis', discoverApisTool.handler) },
+  { ...extractDataTool, handler: withMetrics('extract_data', extractDataTool.handler) },
+  { ...exportSessionTool, handler: withMetrics('export_session', exportSessionTool.handler) },
+
+  // ── Unified Profile Management (replaces 3 old tools) ──────────────────────
+  { ...manageSiteProfileTool, handler: withMetrics('manage_site_profile', manageSiteProfileTool.handler) },
+
+  // ── Element Selection ───────────────────────────────────────────────────────
+  { ...getElementTool, handler: withMetrics('get_element', getElementTool.handler) },
+
+  // ── Data Tracing ───────────────────────────────────────────────────────────
+  { ...getNetworkTraceTool, handler: withMetrics('get_network_trace', getNetworkTraceTool.handler) },
+
+  // ── Execution ──────────────────────────────────────────────────────────────
+  { ...executeJsTool, handler: withMetrics('execute_js', executeJsTool.handler) },
+  { ...executeActionTool, handler: withMetrics('execute_action', executeActionTool.handler) },
+
+  // ── Navigation ─────────────────────────────────────────────────────────────
+  { ...paginateTool, handler: withMetrics('paginate', paginateTool.handler) },
+
+  // ── Visual & Debug ─────────────────────────────────────────────────────────
+  { ...captureScreenshotTool, handler: withMetrics('capture_screenshot', captureScreenshotTool.handler) },
+  { ...debugMcpStateTool, handler: withMetrics('debug_mcp_state', debugMcpStateTool.handler) },
+];
+
+/**
+ * Tool listesini MCP formatında döndür
+ */
+export const getToolsList = () => {
+  return allTools.map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+};
+
+/**
+ * İsme göre tool handler'ını bul
+ */
+export const getToolHandler = (toolName) => {
+  const tool = allTools.find(t => t.name === toolName);
+  return tool ? tool.handler : null;
+};
+
+/**
+ * Tool var mı kontrol et
+ */
+export const hasTool = (toolName) => {
+  return allTools.some(t => t.name === toolName);
+};