camel-ai 0.2.75a5__py3-none-any.whl → 0.2.76a0__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit/ts/src/browser-session.ts

@@ -59,14 +59,30 @@ export class HybridBrowserSession {
       const contexts = this.browser.contexts();
       if (contexts.length > 0) {
         this.context = contexts[0];
+        
+        // Apply stealth headers to existing context if configured
+        // Note: userAgent cannot be changed on an existing context
+        if (stealthConfig.enabled) {
+          if (stealthConfig.extraHTTPHeaders) {
+            await this.context.setExtraHTTPHeaders(stealthConfig.extraHTTPHeaders);
+          }
+          if (stealthConfig.userAgent) {
+            console.warn('[HybridBrowserSession] Cannot apply userAgent to existing context. Consider creating a new context if userAgent customization is required.');
+          }
+        }
       } else {
         const contextOptions: any = {
           viewport: browserConfig.viewport
         };
         
-        // Apply stealth headers if configured
-        if (stealthConfig.enabled && stealthConfig.extraHTTPHeaders) {
-          contextOptions.extraHTTPHeaders = stealthConfig.extraHTTPHeaders;
+        // Apply stealth headers and UA if configured
+        if (stealthConfig.enabled) {
+          if (stealthConfig.extraHTTPHeaders) {
+            contextOptions.extraHTTPHeaders = stealthConfig.extraHTTPHeaders;
+          }
+          if (stealthConfig.userAgent) {
+            contextOptions.userAgent = stealthConfig.userAgent;
+          }
         }
         
         this.context = await this.browser.newContext(contextOptions);
@@ -105,13 +121,18 @@ export class HybridBrowserSession {
       if (stealthConfig.enabled) {
         launchOptions.args = stealthConfig.args || [];
         
-        // Apply stealth user agent if configured
+        // Apply stealth user agent/headers if configured
         if (stealthConfig.userAgent) {
           launchOptions.userAgent = stealthConfig.userAgent;
         }
+        if (stealthConfig.extraHTTPHeaders) {
+          launchOptions.extraHTTPHeaders = stealthConfig.extraHTTPHeaders;
+        }
       }
 
       if (browserConfig.userDataDir) {
+        // Ensure viewport is honored in persistent context
+        launchOptions.viewport = browserConfig.viewport;
         this.context = await chromium.launchPersistentContext(
           browserConfig.userDataDir,
           launchOptions
@@ -129,9 +150,14 @@ export class HybridBrowserSession {
           viewport: browserConfig.viewport
         };
         
-        // Apply stealth headers if configured
-        if (stealthConfig.enabled && stealthConfig.extraHTTPHeaders) {
-          contextOptions.extraHTTPHeaders = stealthConfig.extraHTTPHeaders;
+        // Apply stealth headers and UA if configured
+        if (stealthConfig.enabled) {
+          if (stealthConfig.extraHTTPHeaders) {
+            contextOptions.extraHTTPHeaders = stealthConfig.extraHTTPHeaders;
+          }
+          if (stealthConfig.userAgent) {
+            contextOptions.userAgent = stealthConfig.userAgent;
+          }
         }
         
         this.context = await this.browser.newContext(contextOptions);
@@ -173,26 +199,10 @@ export class HybridBrowserSession {
 
   async getCurrentPage(): Promise<Page> {
     if (!this.currentTabId || !this.pages.has(this.currentTabId)) {
-      // In CDP mode, try to create a new page if none exists
+      // In CDP mode, we cannot create new pages
       const browserConfig = this.configLoader.getBrowserConfig();
-      if (browserConfig.connectOverCdp && this.context) {
-        console.log('[CDP] No active page found, attempting to create new page...');
-        try {
-          const newPage = await this.context.newPage();
-          const newTabId = this.generateTabId();
-          this.registerNewPage(newTabId, newPage);
-          this.currentTabId = newTabId;
-          
-          // Set page timeouts
-          newPage.setDefaultNavigationTimeout(browserConfig.navigationTimeout);
-          newPage.setDefaultTimeout(browserConfig.navigationTimeout);
-          
-          console.log(`[CDP] Created new page with tab ID: ${newTabId}`);
-          return newPage;
-        } catch (error) {
-          console.error('[CDP] Failed to create new page:', error);
-          throw new Error('No active page available and failed to create new page in CDP mode');
-        }
+      if (browserConfig.connectOverCdp) {
+        throw new Error('No active page available in CDP mode; frontend must pre-create blank tabs.');
       }
       throw new Error('No active page available');
     }
@@ -235,6 +245,36 @@ export class HybridBrowserSession {
     return this.getSnapshotForAINative(includeCoordinates, viewportLimit);
   }
 
+  private parseElementFromSnapshot(snapshotText: string, ref: string): { role?: string; text?: string } {
+    const lines = snapshotText.split('\n');
+    for (const line of lines) {
+      if (line.includes(`[ref=${ref}]`)) {
+        const typeMatch = line.match(/^\s*-?\s*([\w-]+)/);
+        const role = typeMatch ? typeMatch[1] : undefined;
+        const textMatch = line.match(/"([^"]*)"/);
+        const text = textMatch ? textMatch[1] : undefined;
+        return { role, text };
+      }
+    }
+    return {};
+  }
+
+  private buildSnapshotIndex(snapshotText: string): Map<string, { role?: string; text?: string }> {
+    const index = new Map<string, { role?: string; text?: string }>();
+    const refRe = /\[ref=([^\]]+)\]/i;
+    for (const line of snapshotText.split('\n')) {
+      const m = line.match(refRe);
+      if (!m) continue;
+      const ref = m[1];
+      const roleMatch = line.match(/^\s*-?\s*([a-z0-9_-]+)/i);
+      const role = roleMatch ? roleMatch[1].toLowerCase() : undefined;
+      const textMatch = line.match(/"([^"]*)"/);
+      const text = textMatch ? textMatch[1] : undefined;
+      index.set(ref, { role, text });
+    }
+    return index;
+  }
+
   private async getSnapshotForAINative(includeCoordinates = false, viewportLimit = false): Promise<SnapshotResult & { timing: DetailedTiming }> {
     const startTime = Date.now();
     const page = await this.getCurrentPage();
@@ -257,6 +297,17 @@ export class HybridBrowserSession {
       const mappingStart = Date.now();
       const playwrightMapping: Record<string, any> = {};
       
+      // Parse element info in a single pass
+      const snapshotIndex = this.buildSnapshotIndex(snapshotText);
+      for (const ref of refs) {
+        const elementInfo = snapshotIndex.get(ref) || {};
+        playwrightMapping[ref] = {
+          ref,
+          role: elementInfo.role || 'unknown',
+          text: elementInfo.text || '',
+        };
+      }
+      
       if (includeCoordinates) {
         // Get coordinates for each ref using aria-ref selector
         for (const ref of refs) {
@@ -270,8 +321,9 @@ export class HybridBrowserSession {
               const boundingBox = await element.boundingBox();
               
               if (boundingBox) {
+                // Add coordinates to existing element info
                 playwrightMapping[ref] = {
-                  ref,
+                  ...playwrightMapping[ref],
                   coordinates: {
                     x: Math.round(boundingBox.x),
                     y: Math.round(boundingBox.y),
@@ -388,7 +440,6 @@ export class HybridBrowserSession {
       
       if (shouldOpenNewTab) {
         //  Handle new tab opening
-        
         // If it's a link that doesn't naturally open in new tab, force it
         if (isNavigableLink && !naturallyOpensNewTab) {
           await element.evaluate((el, blankTarget) => {
@@ -803,6 +854,55 @@ export class HybridBrowserSession {
     }
   }
 
+  /**
+   * Wait for DOM to stop changing for a specified duration
+   */
+  private async waitForDOMStability(page: Page, maxWaitTime: number = 500): Promise<void> {
+    const startTime = Date.now();
+    const stabilityThreshold = 100; // Consider stable if no changes for 100ms
+    let lastChangeTime = Date.now();
+    
+    try {
+      // Monitor DOM changes
+      await page.evaluate(() => {
+        let changeCount = 0;
+        (window as any).__domStabilityCheck = { changeCount: 0, lastChange: Date.now() };
+        
+        const observer = new MutationObserver(() => {
+          (window as any).__domStabilityCheck.changeCount++;
+          (window as any).__domStabilityCheck.lastChange = Date.now();
+        });
+        
+        observer.observe(document.body, { 
+          childList: true, 
+          subtree: true,
+          attributes: true,
+          characterData: true
+        });
+        
+        (window as any).__domStabilityObserver = observer;
+      });
+      
+      // Wait until no changes for stabilityThreshold or timeout
+      await page.waitForFunction(
+        (threshold) => {
+          const check = (window as any).__domStabilityCheck;
+          return check && (Date.now() - check.lastChange) > threshold;
+        },
+        stabilityThreshold,
+        { timeout: Math.max(0, maxWaitTime) }
+      ).catch(() => {});
+    } finally {
+      // Cleanup
+      await page.evaluate(() => {
+        const observer = (window as any).__domStabilityObserver;
+        if (observer) observer.disconnect();
+        delete (window as any).__domStabilityObserver;
+        delete (window as any).__domStabilityCheck;
+      }).catch(() => {});
+    }
+  }
+
   private async waitForPageStability(page: Page): Promise<{ domContentLoadedTime: number; networkIdleTime: number }> {
     let domContentLoadedTime = 0;
     let networkIdleTime = 0;
@@ -1132,12 +1232,12 @@ export class HybridBrowserSession {
     const filtered: Record<string, SnapshotElement> = {};
     
     
-    // Apply viewport filtering with scroll position adjustment
-    const browserConfig = this.configLoader.getBrowserConfig();
-    const adjustedScrollPos = {
-      x: scrollPos.x * browserConfig.scrollPositionScale,
-      y: scrollPos.y * browserConfig.scrollPositionScale
-    };
+    // Apply viewport filtering
+    // boundingBox() returns viewport-relative coordinates, so we don't need to add scroll offsets
+    const viewportLeft = 0;
+    const viewportTop = 0;
+    const viewportRight = viewport.width;
+    const viewportBottom = viewport.height;
     
     for (const [ref, element] of Object.entries(elements)) {
       // If element has no coordinates, include it (fallback)
@@ -1148,14 +1248,9 @@ export class HybridBrowserSession {
       
       const { x, y, width, height } = element.coordinates;
       
-      // Calculate viewport bounds using adjusted scroll position
-      const viewportLeft = adjustedScrollPos.x;
-      const viewportTop = adjustedScrollPos.y;
-      const viewportRight = adjustedScrollPos.x + viewport.width;
-      const viewportBottom = adjustedScrollPos.y + viewport.height;
-      
       // Check if element is visible in current viewport
       // Element is visible if it overlaps with viewport bounds
+      // Since boundingBox() coords are viewport-relative, we compare directly
       const isVisible = (
         x < viewportRight &&              // Left edge is before viewport right
         y < viewportBottom &&             // Top edge is before viewport bottom  

camel/toolkits/hybrid_browser_toolkit/ts/src/config-loader.ts

@@ -79,6 +79,7 @@ export interface WebSocketConfig {
   browser_log_to_file: boolean;
   session_id?: string;
   viewport_limit: boolean;
+  fullVisualMode?: boolean;
 }
 
 // Default stealth configuration
@@ -212,6 +213,7 @@ export class ConfigLoader {
     if (config.browser_log_to_file !== undefined) wsConfig.browser_log_to_file = config.browser_log_to_file;
     if (config.session_id !== undefined) wsConfig.session_id = config.session_id;
     if (config.viewport_limit !== undefined) wsConfig.viewport_limit = config.viewport_limit;
+    if (config.fullVisualMode !== undefined) wsConfig.fullVisualMode = config.fullVisualMode;
     
     // CDP connection options
     if (config.connectOverCdp !== undefined) browserConfig.connectOverCdp = config.connectOverCdp;

camel/toolkits/hybrid_browser_toolkit/ts/src/hybrid-browser-toolkit.ts

@@ -2,18 +2,22 @@ import {HybridBrowserSession} from './browser-session';
 import {ActionResult, BrowserAction, BrowserToolkitConfig, SnapshotResult, TabInfo, VisualMarkResult} from './types';
 import {ConfigLoader} from './config-loader';
 import {ConsoleMessage} from 'playwright';
+import {SomScreenshotInjected} from './som-screenshot-injected';
+import {filterClickableByHierarchy} from './snapshot-parser';
 
 export class HybridBrowserToolkit {
   private session: HybridBrowserSession;
   private config: BrowserToolkitConfig;
   private configLoader: ConfigLoader;
   private viewportLimit: boolean;
+  private fullVisualMode: boolean;
 
   constructor(config: BrowserToolkitConfig = {}) {
     this.configLoader = ConfigLoader.fromPythonConfig(config);
     this.config = config; // Store original config for backward compatibility
     this.session = new HybridBrowserSession(this.configLoader.getBrowserConfig()); // Pass processed config
     this.viewportLimit = this.configLoader.getWebSocketConfig().viewport_limit;
+    this.fullVisualMode = this.configLoader.getWebSocketConfig().fullVisualMode || false;
   }
 
   async openBrowser(startUrl?: string): Promise<ActionResult> {
@@ -26,7 +30,7 @@ export class HybridBrowserToolkit {
       const result = await this.session.visitPage(url);
       
       const snapshotStart = Date.now();
-      const snapshot = await this.getPageSnapshot(this.viewportLimit);
+      const snapshot = await this.getSnapshotForAction(this.viewportLimit);
       const snapshotTime = Date.now() - snapshotStart;
       
       const totalTime = Date.now() - startTime;
@@ -83,7 +87,7 @@ export class HybridBrowserToolkit {
       
       if (result.success) {
         const snapshotStart = Date.now();
-        response.snapshot = await this.getPageSnapshot(this.viewportLimit);
+        response.snapshot = await this.getSnapshotForAction(this.viewportLimit);
         const snapshotTime = Date.now() - snapshotStart;
         
         if (result.timing) {
@@ -119,6 +123,7 @@ export class HybridBrowserToolkit {
 
   async getPageSnapshot(viewportLimit: boolean = false): Promise<string> {
     try {
+      // Always return real snapshot when explicitly called
       // If viewport limiting is enabled, we need coordinates for filtering
       const snapshotResult = await this.session.getSnapshotForAI(viewportLimit, viewportLimit);
       return snapshotResult.snapshot;
@@ -126,6 +131,14 @@ export class HybridBrowserToolkit {
       return `Error capturing snapshot: ${error}`;
     }
   }
+  
+  // Internal method for getting snapshot in actions (respects fullVisualMode)
+  private async getSnapshotForAction(viewportLimit: boolean = false): Promise<string> {
+    if (this.fullVisualMode) {
+      return 'full visual mode';
+    }
+    return this.getPageSnapshot(viewportLimit);
+  }
 
 
   async getSnapshotForAI(): Promise<SnapshotResult> {
@@ -134,35 +147,34 @@ export class HybridBrowserToolkit {
 
   async getSomScreenshot(): Promise<VisualMarkResult & { timing: any }> {
     const startTime = Date.now();
+    console.log('[HybridBrowserToolkit] Starting getSomScreenshot...');
     
     try {
-      const screenshotResult = await this.session.takeScreenshot();
-      const snapshotResult = await this.session.getSnapshotForAI(true); // Include coordinates for SOM_mark
-      
-      // Add visual marks using improved method
-      const markingStart = Date.now();
-      const markedImageBuffer = await this.addVisualMarksOptimized(screenshotResult.buffer, snapshotResult);
-      const markingTime = Date.now() - markingStart;
+      // Get page and snapshot data
+      const page = await this.session.getCurrentPage();
+      const snapshotResult = await this.session.getSnapshotForAI(true); // Include coordinates
       
-      const base64Image = markedImageBuffer.toString('base64');
-      const dataUrl = `data:image/png;base64,${base64Image}`;
+      // Parse clickable elements from snapshot text
+      const clickableElements = this.parseClickableElements(snapshotResult.snapshot);
+      console.log(`[HybridBrowserToolkit] Found ${clickableElements.size} clickable elements`);
       
-      const totalTime = Date.now() - startTime;
+      // Apply hierarchy-based filtering
+      const filteredElements = filterClickableByHierarchy(snapshotResult.snapshot, clickableElements);
+      console.log(`[HybridBrowserToolkit] After filtering: ${filteredElements.size} elements remain`);
+
+      // Use injected SOM-screenshot method without export path
+      const result = await SomScreenshotInjected.captureOptimized(
+        page,
+        snapshotResult,
+        filteredElements,
+        undefined  // No export path - don't generate files
+      );
       
-      // Count elements with coordinates
-      const elementsWithCoords = Object.values(snapshotResult.elements).filter(el => el.coordinates).length;
+      // Add snapshot timing info to result
+      result.timing.snapshot_time_ms = snapshotResult.timing.snapshot_time_ms;
+      result.timing.coordinate_enrichment_time_ms = snapshotResult.timing.coordinate_enrichment_time_ms;
       
-      return {
-        text: `Visual webpage screenshot captured with ${Object.keys(snapshotResult.elements).length} interactive elements (${elementsWithCoords} marked visually)`,
-        images: [dataUrl],
-        timing: {
-          total_time_ms: totalTime,
-          screenshot_time_ms: screenshotResult.timing.screenshot_time_ms,
-          snapshot_time_ms: snapshotResult.timing.snapshot_time_ms,
-          coordinate_enrichment_time_ms: snapshotResult.timing.coordinate_enrichment_time_ms,
-          visual_marking_time_ms: markingTime,
-        },
-      };
+      return result;
     } catch (error) {
       const totalTime = Date.now() - startTime;
       return {
@@ -179,132 +191,6 @@ export class HybridBrowserToolkit {
     }
   }
 
-  private async addVisualMarksOptimized(screenshotBuffer: Buffer, snapshotResult: SnapshotResult): Promise<Buffer> {
-    try {
-      
-      // Check if we have any elements with coordinates
-      const elementsWithCoords = Object.entries(snapshotResult.elements)
-        .filter(([ref, element]) => element.coordinates);
-      
-      if (elementsWithCoords.length === 0) {
-        return screenshotBuffer;
-      }
-      
-      // Parse clickable elements from snapshot text
-      const clickableElements = this.parseClickableElements(snapshotResult.snapshot);
-      
-      // Use sharp for image processing
-      const sharp = require('sharp');
-      const page = await this.session.getCurrentPage();
-      let viewport = page.viewportSize();
-      
-      // In CDP mode, viewportSize might be null, get it from window dimensions
-      if (!viewport) {
-        const windowSize = await page.evaluate(() => ({
-          width: window.innerWidth,
-          height: window.innerHeight
-        }));
-        viewport = windowSize;
-      }
-      
-      // Get device pixel ratio to handle high DPI screens
-      const dpr = await page.evaluate(() => window.devicePixelRatio) || 1;
-      
-      // Get actual screenshot dimensions
-      const metadata = await sharp(screenshotBuffer).metadata();
-      const screenshotWidth = metadata.width || viewport.width;
-      const screenshotHeight = metadata.height || viewport.height;
-      
-      // Calculate scaling factor between CSS pixels and screenshot pixels
-      const scaleX = screenshotWidth / viewport.width;
-      const scaleY = screenshotHeight / viewport.height;
-      
-      // Debug logging for CDP mode
-      if (process.env.HYBRID_BROWSER_DEBUG === '1') {
-        console.log('[CDP Debug] Viewport size:', viewport);
-        console.log('[CDP Debug] Device pixel ratio:', dpr);
-        console.log('[CDP Debug] Screenshot dimensions:', { width: screenshotWidth, height: screenshotHeight });
-        console.log('[CDP Debug] Scale factors:', { scaleX, scaleY });
-        console.log('[CDP Debug] Elements with coordinates:', elementsWithCoords.length);
-        elementsWithCoords.slice(0, 3).forEach(([ref, element]) => {
-          console.log(`[CDP Debug] Element ${ref}:`, element.coordinates);
-        });
-      }
-      
-      // Filter elements visible in viewport
-      const visibleElements = elementsWithCoords.filter(([ref, element]) => {
-        const coords = element.coordinates!;
-        return coords.x < viewport.width && 
-               coords.y < viewport.height && 
-               coords.x + coords.width > 0 && 
-               coords.y + coords.height > 0;
-      });
-      
-      // Remove overlapped elements (only keep topmost)
-      const nonOverlappedElements = this.removeOverlappedElements(visibleElements);
-      
-      // Create SVG overlay with all the marks
-      const marks = nonOverlappedElements.map(([ref, element]) => {
-        const coords = element.coordinates!;
-        const isClickable = clickableElements.has(ref);
-        
-        // Scale coordinates from CSS pixels to screenshot pixels
-        const x = Math.max(0, coords.x * scaleX);
-        const y = Math.max(0, coords.y * scaleY);
-        const width = coords.width * scaleX;
-        const height = coords.height * scaleY;
-        
-        // Clamp to screenshot bounds
-        const clampedWidth = Math.min(width, screenshotWidth - x);
-        const clampedHeight = Math.min(height, screenshotHeight - y);
-        
-        // Position text to be visible even if element is partially cut off
-        const textX = Math.max(2, Math.min(x + 2, screenshotWidth - 40));
-        const textY = Math.max(14, Math.min(y + 14, screenshotHeight - 4));
-        
-        // Different colors for clickable vs non-clickable elements
-        const colors = isClickable ? {
-          fill: 'rgba(0, 150, 255, 0.15)',  // Blue for clickable
-          stroke: '#0096FF',
-          textFill: '#0096FF'
-        } : {
-          fill: 'rgba(255, 107, 107, 0.1)',  // Red for non-clickable
-          stroke: '#FF6B6B', 
-          textFill: '#FF6B6B'
-        };
-        
-        return `
-          <rect x="${x}" y="${y}" width="${clampedWidth}" height="${clampedHeight}" 
-                fill="${colors.fill}" stroke="${colors.stroke}" stroke-width="2" rx="2"/>
-          <text x="${textX}" y="${textY}" font-family="Arial, sans-serif" 
-                font-size="12" fill="${colors.textFill}" font-weight="bold">${ref}</text>
-        `;
-      }).join('');
-      
-      const svgOverlay = `
-        <svg width="${screenshotWidth}" height="${screenshotHeight}" xmlns="http://www.w3.org/2000/svg">
-          ${marks}
-        </svg>
-      `;
-      
-      // Composite the overlay onto the screenshot
-      const markedImageBuffer = await sharp(screenshotBuffer)
-        .composite([{
-          input: Buffer.from(svgOverlay),
-          top: 0,
-          left: 0
-        }])
-        .png()
-        .toBuffer();
-      
-      return markedImageBuffer;
-      
-    } catch (error) {
-      // Error adding visual marks, falling back to original screenshot
-      // Return original screenshot if marking fails
-      return screenshotBuffer;
-    }
-  }
 
   /**
    * Parse clickable elements from snapshot text
@@ -314,8 +200,8 @@ export class HybridBrowserToolkit {
     const lines = snapshotText.split('\n');
     
     for (const line of lines) {
-      // Look for lines containing [cursor=pointer] and extract ref
-      if (line.includes('[cursor=pointer]')) {
+      // Look for lines containing [cursor=pointer] or [active] and extract ref
+      if (line.includes('[cursor=pointer]') || line.includes('[active]')) {
         const refMatch = line.match(/\[ref=([^\]]+)\]/);
         if (refMatch) {
           clickableElements.add(refMatch[1]);
@@ -326,56 +212,6 @@ export class HybridBrowserToolkit {
     return clickableElements;
   }
 
-  /**
-   * Remove overlapped elements, keeping only the topmost (last in DOM order)
-   */
-  private removeOverlappedElements(elements: Array<[string, any]>): Array<[string, any]> {
-    const result: Array<[string, any]> = [];
-    
-    for (let i = 0; i < elements.length; i++) {
-      const [refA, elementA] = elements[i];
-      const coordsA = elementA.coordinates!;
-      let isOverlapped = false;
-      
-      // Check if this element is completely overlapped by any later element
-      for (let j = i + 1; j < elements.length; j++) {
-        const [refB, elementB] = elements[j];
-        const coordsB = elementB.coordinates!;
-        
-        // Check if element A is completely covered by element B
-        if (this.isCompletelyOverlapped(coordsA, coordsB)) {
-          isOverlapped = true;
-          break;
-        }
-      }
-      
-      if (!isOverlapped) {
-        result.push(elements[i]);
-      }
-    }
-    
-    return result;
-  }
-
-  /**
-   * Check if element A is completely overlapped by element B
-   */
-  private isCompletelyOverlapped(
-    coordsA: { x: number; y: number; width: number; height: number },
-    coordsB: { x: number; y: number; width: number; height: number }
-  ): boolean {
-    // A is completely overlapped by B if:
-    // B's left edge is <= A's left edge AND
-    // B's top edge is <= A's top edge AND  
-    // B's right edge is >= A's right edge AND
-    // B's bottom edge is >= A's bottom edge
-    return (
-      coordsB.x <= coordsA.x &&
-      coordsB.y <= coordsA.y &&
-      coordsB.x + coordsB.width >= coordsA.x + coordsA.width &&
-      coordsB.y + coordsB.height >= coordsA.y + coordsA.height
-    );
-  }
 
   private async executeActionWithSnapshot(action: BrowserAction): Promise<any> {
     const result = await this.session.executeAction(action);
@@ -472,7 +308,7 @@ export class HybridBrowserToolkit {
       const navigationTime = Date.now() - navigationStart;
       
       const snapshotStart = Date.now();
-      const snapshot = await this.getPageSnapshot(this.viewportLimit);
+      const snapshot = await this.getSnapshotForAction(this.viewportLimit);
       const snapshotTime = Date.now() - snapshotStart;
       
       const totalTime = Date.now() - startTime;
@@ -512,7 +348,7 @@ export class HybridBrowserToolkit {
       const navigationTime = Date.now() - navigationStart;
       
       const snapshotStart = Date.now();
-      const snapshot = await this.getPageSnapshot(this.viewportLimit);
+      const snapshot = await this.getSnapshotForAction(this.viewportLimit);
       const snapshotTime = Date.now() - snapshotStart;
       
       const totalTime = Date.now() - startTime;
@@ -584,7 +420,7 @@ export class HybridBrowserToolkit {
       return {
         success: true,
         message: `Closed tab ${tabId}`,
-        snapshot: await this.getPageSnapshot(this.viewportLimit),
+        snapshot: await this.getSnapshotForAction(this.viewportLimit),
       };
     } else {
       return {
@@ -649,7 +485,7 @@ export class HybridBrowserToolkit {
       const { result, logs } = evalResult;
 
       const snapshotStart = Date.now();
-      const snapshot = await this.getPageSnapshot(this.viewportLimit);
+      const snapshot = await this.getSnapshotForAction(this.viewportLimit);
       const snapshotTime = Date.now() - snapshotStart;
       const totalTime = Date.now() - startTime;