camel-ai 0.2.73a4__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

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

@@ -30,6 +30,7 @@ export interface BrowserConfig {
   // Tab management
   tabIdPrefix: string;
   tabCounterPadding: number;
+  consoleLogLimit: number;
   
   // Scroll and positioning
   scrollPositionScale: number;
@@ -72,12 +73,14 @@ export interface BrowserConfig {
   // CDP connection options
   connectOverCdp: boolean;
   cdpUrl?: string;
+  cdpKeepCurrentPage: boolean;
 }
 
 export interface WebSocketConfig {
   browser_log_to_file: boolean;
   session_id?: string;
   viewport_limit: boolean;
+  fullVisualMode?: boolean;
 }
 
 // Default stealth configuration
@@ -113,9 +116,10 @@ function getDefaultBrowserConfig(): BrowserConfig {
     clickTimeout: 3000,
     tabIdPrefix: 'tab-',
     tabCounterPadding: 3,
+    consoleLogLimit: 1000,
     scrollPositionScale: 0.1,
     navigationDelay: 100,
-    blankPageUrls: ['about:blank', ''],
+    blankPageUrls: ['chrome://newtab/', 'edge://newtab/', 'chrome://new-tab-page/'],
     dataUrlPrefix: 'data:',
     domContentLoadedState: 'domcontentloaded',
     networkIdleState: 'networkidle',
@@ -136,7 +140,8 @@ function getDefaultBrowserConfig(): BrowserConfig {
       height: 720
     },
     connectOverCdp: false,
-    cdpUrl: undefined
+    cdpUrl: undefined,
+    cdpKeepCurrentPage: false
   };
 }
 
@@ -210,10 +215,12 @@ 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;
     if (config.cdpUrl !== undefined) browserConfig.cdpUrl = config.cdpUrl;
+    if (config.cdpKeepCurrentPage !== undefined) browserConfig.cdpKeepCurrentPage = config.cdpKeepCurrentPage;
 
     return new ConfigLoader(browserConfig, wsConfig);
   }

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

@@ -1,18 +1,23 @@
 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.session = new HybridBrowserSession(config); // Pass original config
     this.viewportLimit = this.configLoader.getWebSocketConfig().viewport_limit;
+    this.fullVisualMode = this.configLoader.getWebSocketConfig().fullVisualMode || false;
   }
 
   async openBrowser(startUrl?: string): Promise<ActionResult> {
@@ -21,22 +26,66 @@ export class HybridBrowserToolkit {
     try {
       await this.session.ensureBrowser();
       
-      const url = startUrl || this.config.defaultStartUrl || 'https://google.com/';
-      const result = await this.session.visitPage(url);
+      // Check if we should skip navigation in CDP keep-current-page mode
+      const browserConfig = this.configLoader.getBrowserConfig();
+      if (browserConfig.cdpUrl && browserConfig.cdpKeepCurrentPage && !startUrl) {
+        // In CDP keep-current-page mode without explicit URL, just ensure browser and return current page
+        const snapshotStart = Date.now();
+        const snapshot = await this.getSnapshotForAction(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        const page = await this.session.getCurrentPage();
+        const currentUrl = page ? await page.url() : 'unknown';
+        
+        const totalTime = Date.now() - startTime;
+        
+        return {
+          success: true,
+          message: `Browser opened in CDP keep-current-page mode (current page: ${currentUrl})`,
+          snapshot,
+          timing: {
+            total_time_ms: totalTime,
+            snapshot_time_ms: snapshotTime,
+          },
+        };
+      }
       
+      // For normal mode or CDP with cdpKeepCurrentPage=false: navigate to URL
+      if (!browserConfig.cdpUrl || !browserConfig.cdpKeepCurrentPage) {
+        const url = startUrl || this.config.defaultStartUrl || 'https://google.com/';
+        const result = await this.session.visitPage(url);
+        
+        const snapshotStart = Date.now();
+        const snapshot = await this.getSnapshotForAction(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        const totalTime = Date.now() - startTime;
+        
+        return {
+          success: true,
+          message: result.message,
+          snapshot,
+          timing: {
+            total_time_ms: totalTime,
+            page_load_time_ms: result.timing?.page_load_time_ms || 0,
+            snapshot_time_ms: snapshotTime,
+          },
+        };
+      }
+      
+      // Fallback: Just return current page snapshot without any navigation
       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;
       
       return {
         success: true,
-        message: `Browser opened and navigated to ${url}`,
+        message: `Browser opened without navigation`,
         snapshot,
         timing: {
           total_time_ms: totalTime,
-          ...result.timing,
           snapshot_time_ms: snapshotTime,
         },
       };
@@ -68,39 +117,57 @@ export class HybridBrowserToolkit {
   }
 
   async visitPage(url: string): Promise<any> {
-    const result = await this.session.visitPage(url);
-    
-    // Format response for Python layer compatibility
-    const response: any = {
-      result: result.message,
-      snapshot: '',
-    };
-    
-    if (result.success) {
-      const snapshotStart = Date.now();
-      response.snapshot = await this.getPageSnapshot(this.viewportLimit);
-      const snapshotTime = Date.now() - snapshotStart;
+    try {
+      // Ensure browser is initialized before visiting page
+      await this.session.ensureBrowser();
+      
+      const result = await this.session.visitPage(url);
+      
+      // Format response for Python layer compatibility
+      const response: any = {
+        result: result.message,
+        snapshot: '',
+      };
       
+      if (result.success) {
+        const snapshotStart = Date.now();
+        response.snapshot = await this.getSnapshotForAction(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        if (result.timing) {
+          result.timing.snapshot_time_ms = snapshotTime;
+        }
+      }
+      
+      // Include timing if available
       if (result.timing) {
-        result.timing.snapshot_time_ms = snapshotTime;
+        response.timing = result.timing;
       }
+      
+      // Include newTabId if present
+      if (result.newTabId) {
+        response.newTabId = result.newTabId;
+      }
+      
+      return response;
+    } catch (error) {
+      console.error('[visitPage] Error:', error);
+      return {
+        result: `Navigation to ${url} failed: ${error}`,
+        snapshot: '',
+        timing: {
+          total_time_ms: 0,
+          navigation_time_ms: 0,
+          dom_content_loaded_time_ms: 0,
+          network_idle_time_ms: 0,
+        }
+      };
     }
-    
-    // Include timing if available
-    if (result.timing) {
-      response.timing = result.timing;
-    }
-    
-    // Include newTabId if present
-    if (result.newTabId) {
-      response.newTabId = result.newTabId;
-    }
-    
-    return response;
   }
 
   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;
@@ -108,6 +175,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> {
@@ -116,35 +191,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;
-      
-      const base64Image = markedImageBuffer.toString('base64');
-      const dataUrl = `data:image/png;base64,${base64Image}`;
-      
-      const totalTime = Date.now() - startTime;
+      // Get page and snapshot data
+      const page = await this.session.getCurrentPage();
+      const snapshotResult = await this.session.getSnapshotForAI(true); // Include coordinates
       
-      // Count elements with coordinates
-      const elementsWithCoords = Object.values(snapshotResult.elements).filter(el => el.coordinates).length;
+      // Parse clickable elements from snapshot text
+      const clickableElements = this.parseClickableElements(snapshotResult.snapshot);
+      console.log(`[HybridBrowserToolkit] Found ${clickableElements.size} clickable elements`);
       
-      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,
-        },
-      };
+      // 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
+      );
+      
+      // 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 result;
     } catch (error) {
       const totalTime = Date.now() - startTime;
       return {
@@ -161,98 +235,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();
-      const viewport = page.viewportSize() || { width: 1280, height: 720 };
-      
-      // 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);
-        
-        // Use original coordinates for elements within viewport
-        // Clamp only to prevent marks from extending beyond screenshot bounds
-        const x = Math.max(0, coords.x);
-        const y = Math.max(0, coords.y);
-        const maxWidth = viewport.width - x;
-        const maxHeight = viewport.height - y;
-        const width = Math.min(coords.width, maxWidth);
-        const height = Math.min(coords.height, maxHeight);
-        
-        // Position text to be visible even if element is partially cut off
-        const textX = Math.max(2, Math.min(x + 2, viewport.width - 40));
-        const textY = Math.max(14, Math.min(y + 14, viewport.height - 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="${width}" height="${height}" 
-                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="${viewport.width}" height="${viewport.height}" 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
@@ -262,8 +244,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]);
@@ -274,73 +256,31 @@ 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);
     
-    // Format response for Python layer compatibility
     const response: any = {
       result: result.message,
       snapshot: '',
     };
     
     if (result.success) {
-      const snapshotStart = Date.now();
-      response.snapshot = await this.getPageSnapshot(this.viewportLimit);
-      const snapshotTime = Date.now() - snapshotStart;
-      
-      if (result.timing) {
-        result.timing.snapshot_time_ms = snapshotTime;
+      if (result.details?.diffSnapshot) {
+        response.snapshot = result.details.diffSnapshot;
+        
+        if (result.timing) {
+          result.timing.snapshot_time_ms = 0; // Diff snapshot time is included in action time
+        }
+      } else {
+        // Get full snapshot as usual
+        const snapshotStart = Date.now();
+        response.snapshot = await this.getPageSnapshot(this.viewportLimit);
+        const snapshotTime = Date.now() - snapshotStart;
+        
+        if (result.timing) {
+          result.timing.snapshot_time_ms = snapshotTime;
+        }
       }
     }
     
@@ -354,6 +294,14 @@ export class HybridBrowserToolkit {
       response.newTabId = result.newTabId;
     }
     
+    // Include details if present (excluding diffSnapshot as it's already in snapshot)
+    if (result.details) {
+      const { diffSnapshot, ...otherDetails } = result.details;
+      if (Object.keys(otherDetails).length > 0) {
+        response.details = otherDetails;
+      }
+    }
+    
     return response;
   }
 
@@ -362,8 +310,20 @@ export class HybridBrowserToolkit {
     return this.executeActionWithSnapshot(action);
   }
 
-  async type(ref: string, text: string): Promise<any> {
-    const action: BrowserAction = { type: 'type', ref, text };
+  async type(refOrInputs: string | Array<{ ref: string; text: string }>, text?: string): Promise<any> {
+    let action: BrowserAction;
+    
+    if (typeof refOrInputs === 'string') {
+      // Single input mode (backward compatibility)
+      if (text === undefined) {
+        throw new Error('Text parameter is required when ref is a string');
+      }
+      action = { type: 'type', ref: refOrInputs, text };
+    } else {
+      // Multiple inputs mode
+      action = { type: 'type', inputs: refOrInputs };
+    }
+    
     return this.executeActionWithSnapshot(action);
   }
 
@@ -382,6 +342,25 @@ export class HybridBrowserToolkit {
     return this.executeActionWithSnapshot(action);
   }
 
+  async mouseControl(control: 'click' | 'right_click'| 'dblclick', x: number, y: number): Promise<any> {
+    const action: BrowserAction = { type: 'mouse_control', control, x, y };
+    return this.executeActionWithSnapshot(action);
+  }
+
+  async mouseDrag(from_ref: string, to_ref: string): Promise<any> {
+    const action: BrowserAction = { type: 'mouse_drag', from_ref, to_ref };
+    return this.executeActionWithSnapshot(action);
+  }
+
+  async pressKeys(keys: string[]): Promise<any> {
+    const action: BrowserAction = { type: 'press_key', keys};
+    return this.executeActionWithSnapshot(action);
+  }
+
+  async batchKeyboardInput(operations: Array<{type: string, keys?: string[], text?: string, delay?: number}>, skipStabilityWait: boolean = true): Promise<any> {
+    return this.session.batchKeyboardInput(operations, skipStabilityWait);
+  }
+
   async back(): Promise<ActionResult> {
     const startTime = Date.now();
     
@@ -393,7 +372,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;
@@ -433,7 +412,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;
@@ -505,7 +484,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 {
@@ -519,4 +498,93 @@ export class HybridBrowserToolkit {
     return await this.session.getTabInfo();
   }
 
-}
+  async getConsoleView(): Promise<any> {
+    const currentLogs = await this.session.getCurrentLogs();
+    // Format logs
+    return currentLogs.map(item => ({
+      type: item.type(),
+      text: item.text(),
+    }));
+  }
+
+  async consoleExecute(code: string): Promise<any> {
+    const startTime = Date.now();
+    try {
+      const page = await this.session.getCurrentPage();
+      
+      // Wrap the code to capture console.log output
+      const wrappedCode = `
+        (function() {
+          const _logs = [];
+          const originalLog = console.log;
+          console.log = function(...args) {
+            _logs.push(args.map(arg => {
+              try {
+                return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
+              } catch (e) {
+                return String(arg);
+              }
+            }).join(' '));
+            originalLog.apply(console, args);
+          };
+          
+          let result;
+          try {
+            result = eval(${JSON.stringify(code)});
+          } catch (e) {
+            try {
+              result = (function() { ${code} })();
+            } catch (error) {
+              console.log = originalLog;
+              throw error;
+            }
+          }
+          
+          console.log = originalLog;
+          return { result, logs: _logs };
+        })()
+      `;
+      
+      const evalResult = await page.evaluate(wrappedCode) as { result: any; logs: string[] };
+      const { result, logs } = evalResult;
+
+      const snapshotStart = Date.now();
+      const snapshot = await this.getSnapshotForAction(this.viewportLimit);
+      const snapshotTime = Date.now() - snapshotStart;
+      const totalTime = Date.now() - startTime;
+
+      // Properly serialize the result
+      let resultStr: string;
+      try {
+        resultStr = JSON.stringify(result, null, 2);
+      } catch (e) {
+        // Fallback for non-serializable values
+        resultStr = String(result);
+      }
+
+      return {
+        result: `Console execution result: ${resultStr}`,
+        console_output: logs,
+        snapshot: snapshot,
+        timing: {
+          total_time_ms: totalTime,
+          snapshot_time_ms: snapshotTime,
+        },
+      };
+      
+    } catch (error) {
+      const totalTime = Date.now() - startTime;
+      return {
+        result: `Console execution failed: ${error}`,
+        console_output: [],
+        snapshot: '',
+        timing: {
+          total_time_ms: totalTime,
+          snapshot_time_ms: 0,
+        },
+      };
+    }
+  }
+
+}
+