camel-ai 0.2.75a3__py3-none-any.whl → 0.2.75a5__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.75a3'
+__version__ = '0.2.75a5'
 
 __all__ = [
     '__version__',

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py

@@ -674,12 +674,29 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 "total_tabs": 0,
             }
 
-    async def browser_type(self, *, ref: str, text: str) -> Dict[str, Any]:
-        r"""Types text into an input element on the page.
+    async def browser_type(
+        self,
+        *,
+        ref: Optional[str] = None,
+        text: Optional[str] = None,
+        inputs: Optional[List[Dict[str, str]]] = None,
+    ) -> Dict[str, Any]:
+        r"""Types text into one or more input elements on the page.
+
+        This method supports two modes:
+        1. Single input mode (backward compatible): Provide 'ref' and 'text'
+        2. Multiple inputs mode: Provide 'inputs' as a list of dictionaries
+           with 'ref' and 'text' keys
 
         Args:
-            ref (str): The `ref` ID of the input element, from a snapshot.
-            text (str): The text to type into the element.
+            ref (Optional[str]): The `ref` ID of the input element, from a
+                snapshot. Required when using single input mode.
+            text (Optional[str]): The text to type into the element. Required
+                when using single input mode.
+            inputs (Optional[List[Dict[str, str]]]): List of dictionaries,
+                each containing 'ref' and 'text' keys for typing into multiple
+                elements. Example: [{'ref': '1', 'text': 'username'},
+                {'ref': '2', 'text': 'password'}]
 
         Returns:
             Dict[str, Any]: A dictionary with the result of the action:
@@ -689,10 +706,23 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 - "tabs" (List[Dict]): Information about all open tabs.
                 - "current_tab" (int): Index of the active tab.
                 - "total_tabs" (int): Total number of open tabs.
+                - "details" (Dict[str, Any]): When using multiple inputs,
+                  contains success/error status for each ref.
         """
         try:
             ws_wrapper = await self._get_ws_wrapper()
-            result = await ws_wrapper.type(ref, text)
+
+            # Handle single input mode (backward compatibility)
+            if ref is not None and text is not None:
+                result = await ws_wrapper.type(ref, text)
+            # Handle multiple inputs mode
+            elif inputs is not None:
+                result = await ws_wrapper.type_multiple(inputs)
+            else:
+                raise ValueError(
+                    "Either provide 'ref' and 'text' for single input, "
+                    "or 'inputs' for multiple inputs"
+                )
 
             # Add tab information
             tab_info = await ws_wrapper.get_tab_info()

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

@@ -72,21 +72,19 @@ export class HybridBrowserSession {
         this.context = await this.browser.newContext(contextOptions);
       }
       
-      // Handle existing pages
       const pages = this.context.pages();
       if (pages.length > 0) {
-        // Map existing pages - for CDP, only use pages with about:blank URL
+        // Map existing pages - for CDP, find ONE available blank page
         let availablePageFound = false;
         for (const page of pages) {
           const pageUrl = page.url();
-          // In CDP mode, only consider pages with about:blank as available
-          if (pageUrl === 'about:blank') {
+          if (this.isBlankPageUrl(pageUrl)) {
             const tabId = this.generateTabId();
             this.registerNewPage(tabId, page);
-            if (!this.currentTabId) {
-              this.currentTabId = tabId;
-              availablePageFound = true;
-            }
+            this.currentTabId = tabId;
+            availablePageFound = true;
+            console.log(`[CDP] Registered blank page as initial tab: ${tabId}, URL: ${pageUrl}`);
+            break;  // Only register ONE page initially
           }
         }
         
@@ -157,8 +155,45 @@ export class HybridBrowserSession {
     return `${browserConfig.tabIdPrefix}${String(++this.tabCounter).padStart(browserConfig.tabCounterPadding, '0')}`;
   }
 
+  private isBlankPageUrl(url: string): boolean {
+    // Unified blank page detection logic used across the codebase
+    const browserConfig = this.configLoader.getBrowserConfig();
+    return (
+      // Standard about:blank variations (prefix match for query params)
+      url === 'about:blank' || 
+      url.startsWith('about:blank?') ||
+      // Configured blank page URLs (exact match for compatibility)
+      browserConfig.blankPageUrls.includes(url) ||
+      // Empty URL
+      url === '' ||
+      // Data URLs (often used for blank pages)
+      url.startsWith(browserConfig.dataUrlPrefix || 'data:')
+    );
+  }
+
   async getCurrentPage(): Promise<Page> {
     if (!this.currentTabId || !this.pages.has(this.currentTabId)) {
+      // In CDP mode, try to create a new page if none exists
+      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');
+        }
+      }
       throw new Error('No active page available');
     }
     return this.pages.get(this.currentTabId)!;
@@ -416,25 +451,67 @@ export class HybridBrowserSession {
 
   /**
    *  Simplified type implementation using Playwright's aria-ref selector
+   *  Supports both single and multiple input operations
    */
-  private async performType(page: Page, ref: string, text: string): Promise<{ success: boolean; error?: string }> {
+  private async performType(page: Page, ref: string | undefined, text: string | undefined, inputs?: Array<{ ref: string; text: string }>): Promise<{ success: boolean; error?: string; details?: Record<string, any> }> {
     try {
       // Ensure we have the latest snapshot
       await (page as any)._snapshotForAI();
       
-      // Use Playwright's aria-ref selector
-      const selector = `aria-ref=${ref}`;
-      const element = await page.locator(selector).first();
-      
-      const exists = await element.count() > 0;
-      if (!exists) {
-        return { success: false, error: `Element with ref ${ref} not found` };
+      // Handle multiple inputs if provided
+      if (inputs && inputs.length > 0) {
+        const results: Record<string, { success: boolean; error?: string }> = {};
+        
+        for (const input of inputs) {
+          const selector = `aria-ref=${input.ref}`;
+          const element = await page.locator(selector).first();
+          
+          const exists = await element.count() > 0;
+          if (!exists) {
+            results[input.ref] = { success: false, error: `Element with ref ${input.ref} not found` };
+            continue;
+          }
+          
+          try {
+            // Type text using Playwright's built-in fill method
+            await element.fill(input.text);
+            results[input.ref] = { success: true };
+          } catch (error) {
+            results[input.ref] = { success: false, error: `Type failed: ${error}` };
+          }
+        }
+        
+        // Check if all inputs were successful
+        const allSuccess = Object.values(results).every(r => r.success);
+        const errors = Object.entries(results)
+          .filter(([_, r]) => !r.success)
+          .map(([ref, r]) => `${ref}: ${r.error}`)
+          .join('; ');
+        
+        return {
+          success: allSuccess,
+          error: allSuccess ? undefined : `Some inputs failed: ${errors}`,
+          details: results
+        };
       }
       
-      // Type text using Playwright's built-in fill method
-      await element.fill(text);
+      // Handle single input (backward compatibility)
+      if (ref && text !== undefined) {
+        const selector = `aria-ref=${ref}`;
+        const element = await page.locator(selector).first();
+        
+        const exists = await element.count() > 0;
+        if (!exists) {
+          return { success: false, error: `Element with ref ${ref} not found` };
+        }
+        
+        // Type text using Playwright's built-in fill method
+        await element.fill(text);
+        
+        return { success: true };
+      }
       
-      return { success: true };
+      return { success: false, error: 'No valid input provided' };
     } catch (error) {
       return { success: false, error: `Type failed: ${error}` };
     }
@@ -572,6 +649,8 @@ export class HybridBrowserSession {
       //  No need to pre-fetch snapshot - each action method handles this
       
       let newTabId: string | undefined;
+      let customMessage: string | undefined;
+      let actionDetails: Record<string, any> | undefined;
       
       switch (action.type) {
         case 'click': {
@@ -596,12 +675,20 @@ export class HybridBrowserSession {
           elementSearchTime = Date.now() - elementSearchStart;
           const typeStart = Date.now();
 
-          const typeResult = await this.performType(page, action.ref, action.text);
+          const typeResult = await this.performType(page, action.ref, action.text, action.inputs);
           
           if (!typeResult.success) {
             throw new Error(`Type failed: ${typeResult.error}`);
           }
           
+          // Set custom message and details if multiple inputs were used
+          if (typeResult.details) {
+            const successCount = Object.values(typeResult.details).filter((r: any) => r.success).length;
+            const totalCount = Object.keys(typeResult.details).length;
+            customMessage = `Typed text into ${successCount}/${totalCount} elements`;
+            actionDetails = typeResult.details;
+          }
+          
           actionExecutionTime = Date.now() - typeStart;
           break;
         }
@@ -689,7 +776,7 @@ export class HybridBrowserSession {
       
       return {
         success: true,
-        message: `Action ${action.type} executed successfully`,
+        message: customMessage || `Action ${action.type} executed successfully`,
         timing: {
           total_time_ms: totalTime,
           element_search_time_ms: elementSearchTime,
@@ -699,6 +786,7 @@ export class HybridBrowserSession {
           network_idle_time_ms: stabilityResult.networkIdleTime,
         },
         ...(newTabId && { newTabId }), //  Include new tab ID if present
+        ...(actionDetails && { details: actionDetails }), // Include action details if present
       };
     } catch (error) {
       const totalTime = Date.now() - startTime;
@@ -740,16 +828,23 @@ export class HybridBrowserSession {
     
     try {
       // Get current page to check if it's blank
-      const currentPage = await this.getCurrentPage();
-      const currentUrl = currentPage.url();
+      let currentPage: Page;
+      let currentUrl: string;
+      
+      try {
+        currentPage = await this.getCurrentPage();
+        currentUrl = currentPage.url();
+      } catch (error: any) {
+        // If no active page is available, getCurrentPage() will create one in CDP mode
+        console.log('[visitPage] Failed to get current page:', error);
+        throw new Error(`No active page available: ${error?.message || error}`);
+      }
       
       //  Check if current page is blank or if this is the first navigation
       const browserConfig = this.configLoader.getBrowserConfig();
-      const isBlankPage = (
-        browserConfig.blankPageUrls.includes(currentUrl) ||
-        currentUrl === browserConfig.defaultStartUrl ||
-        currentUrl.startsWith(browserConfig.dataUrlPrefix) // data URLs are often used for blank pages
-      );
+      
+      // Use unified blank page detection
+      const isBlankPage = this.isBlankPageUrl(currentUrl) || currentUrl === browserConfig.defaultStartUrl;
       
       const shouldUseCurrentTab = isBlankPage || !this.hasNavigatedBefore;
       
@@ -804,7 +899,7 @@ export class HybridBrowserSession {
             const pageUrl = page.url();
             // Check if this page is not already tracked and is blank
             const isTracked = Array.from(this.pages.values()).includes(page);
-            if (!isTracked && pageUrl === 'about:blank') {
+            if (!isTracked && this.isBlankPageUrl(pageUrl)) {
               newPage = page;
               newTabId = this.generateTabId();
               this.registerNewPage(newTabId, newPage);

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

@@ -117,7 +117,7 @@ function getDefaultBrowserConfig(): BrowserConfig {
     consoleLogLimit: 1000,
     scrollPositionScale: 0.1,
     navigationDelay: 100,
-    blankPageUrls: ['about:blank', ''],
+    blankPageUrls: [],
     dataUrlPrefix: 'data:',
     domContentLoadedState: 'domcontentloaded',
     networkIdleState: 'networkidle',

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

@@ -69,35 +69,52 @@ 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.getPageSnapshot(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> {
@@ -179,7 +196,40 @@ export class HybridBrowserToolkit {
       // Use sharp for image processing
       const sharp = require('sharp');
       const page = await this.session.getCurrentPage();
-      const viewport = page.viewportSize() || { width: 1280, height: 720 };
+      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]) => {
@@ -198,18 +248,19 @@ export class HybridBrowserToolkit {
         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);
+        // 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, viewport.width - 40));
-        const textY = Math.max(14, Math.min(y + 14, viewport.height - 4));
+        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 ? {
@@ -223,7 +274,7 @@ export class HybridBrowserToolkit {
         };
         
         return `
-          <rect x="${x}" y="${y}" width="${width}" height="${height}" 
+          <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>
@@ -231,7 +282,7 @@ export class HybridBrowserToolkit {
       }).join('');
       
       const svgOverlay = `
-        <svg width="${viewport.width}" height="${viewport.height}" xmlns="http://www.w3.org/2000/svg">
+        <svg width="${screenshotWidth}" height="${screenshotHeight}" xmlns="http://www.w3.org/2000/svg">
           ${marks}
         </svg>
       `;
@@ -363,8 +414,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);
   }
 

camel/toolkits/hybrid_browser_toolkit/ts/src/types.ts

@@ -81,8 +81,9 @@ export interface ClickAction {
 
 export interface TypeAction {
   type: 'type';
-  ref: string;
-  text: string;
+  ref?: string;  // Optional for backward compatibility
+  text?: string; // Optional for backward compatibility
+  inputs?: Array<{ ref: string; text: string }>; // New field for multiple inputs
 }
 
 export interface SelectAction {

camel/toolkits/hybrid_browser_toolkit/ts/websocket-server.js

@@ -160,7 +160,14 @@ class WebSocketBrowserServer {
 
       case 'type':
         if (!this.toolkit) throw new Error('Toolkit not initialized');
-        return await this.toolkit.type(params.ref, params.text);
+        // Handle both single input and multiple inputs
+        if (params.inputs) {
+          // Multiple inputs mode - pass inputs array directly
+          return await this.toolkit.type(params.inputs);
+        } else {
+          // Single input mode - pass ref and text
+          return await this.toolkit.type(params.ref, params.text);
+        }
 
       case 'select':
         if (!this.toolkit) throw new Error('Toolkit not initialized');

camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py

@@ -396,6 +396,9 @@ class WebSocketBrowserWrapper:
         """Send a command to the WebSocket server and get response."""
         await self._ensure_connection()
 
+        # Process params to ensure refs have 'e' prefix
+        params = self._process_refs_in_params(params)
+
         message_id = str(uuid.uuid4())
         message = {'id': message_id, 'command': command, 'params': params}
 
@@ -503,6 +506,50 @@ class WebSocketBrowserWrapper:
 
         return ToolResult(text=response['text'], images=response['images'])
 
+    def _ensure_ref_prefix(self, ref: str) -> str:
+        """Ensure ref has 'e' prefix."""
+        if ref and not ref.startswith('e'):
+            return f'e{ref}'
+        return ref
+
+    def _process_refs_in_params(
+        self, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Process parameters to ensure all refs have 'e' prefix."""
+        if not params:
+            return params
+
+        # Create a copy to avoid modifying the original
+        processed = params.copy()
+
+        # Handle direct ref parameters
+        if 'ref' in processed:
+            processed['ref'] = self._ensure_ref_prefix(processed['ref'])
+
+        # Handle from_ref and to_ref for drag operations
+        if 'from_ref' in processed:
+            processed['from_ref'] = self._ensure_ref_prefix(
+                processed['from_ref']
+            )
+        if 'to_ref' in processed:
+            processed['to_ref'] = self._ensure_ref_prefix(processed['to_ref'])
+
+        # Handle inputs array for type_multiple
+        if 'inputs' in processed and isinstance(processed['inputs'], list):
+            processed_inputs = []
+            for input_item in processed['inputs']:
+                if isinstance(input_item, dict) and 'ref' in input_item:
+                    processed_input = input_item.copy()
+                    processed_input['ref'] = self._ensure_ref_prefix(
+                        input_item['ref']
+                    )
+                    processed_inputs.append(processed_input)
+                else:
+                    processed_inputs.append(input_item)
+            processed['inputs'] = processed_inputs
+
+        return processed
+
     @action_logger
     async def click(self, ref: str) -> Dict[str, Any]:
         """Click an element."""
@@ -515,6 +562,14 @@ class WebSocketBrowserWrapper:
         response = await self._send_command('type', {'ref': ref, 'text': text})
         return response
 
+    @action_logger
+    async def type_multiple(
+        self, inputs: List[Dict[str, str]]
+    ) -> Dict[str, Any]:
+        """Type text into multiple elements."""
+        response = await self._send_command('type', {'inputs': inputs})
+        return response
+
     @action_logger
     async def select(self, ref: str, value: str) -> Dict[str, Any]:
         """Select an option."""

camel/toolkits/openai_image_toolkit.py

@@ -14,9 +14,8 @@
 
 import base64
 import os
-import uuid
 from io import BytesIO
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Union
 
 from openai import OpenAI
 from PIL import Image
@@ -64,13 +63,15 @@ class OpenAIImageToolkit(BaseToolkit):
             Literal["auto", "low", "medium", "high", "standard", "hd"]
         ] = "standard",
         response_format: Optional[Literal["url", "b64_json"]] = "b64_json",
-        n: Optional[int] = 1,
         background: Optional[
             Literal["transparent", "opaque", "auto"]
         ] = "auto",
         style: Optional[Literal["vivid", "natural"]] = None,
         working_directory: Optional[str] = "image_save",
     ):
+        # NOTE: Some arguments are set in the constructor to prevent the agent
+        # from making invalid API calls with model-specific parameters. For
+        # example, the 'style' argument is only supported by 'dall-e-3'.
         r"""Initializes a new instance of the OpenAIImageToolkit class.
 
         Args:
@@ -94,8 +95,6 @@ class OpenAIImageToolkit(BaseToolkit):
                 (default: :obj:`"standard"`)
             response_format (Optional[Literal["url", "b64_json"]]):
                 The format of the response.(default: :obj:`"b64_json"`)
-            n (Optional[int]): The number of images to generate.
-                (default: :obj:`1`)
             background (Optional[Literal["transparent", "opaque", "auto"]]):
                 The background of the image.(default: :obj:`"auto"`)
             style (Optional[Literal["vivid", "natural"]]): The style of the
@@ -111,7 +110,6 @@ class OpenAIImageToolkit(BaseToolkit):
         self.size = size
         self.quality = quality
         self.response_format = response_format
-        self.n = n
         self.background = background
         self.style = style
         self.working_directory: str = working_directory or "image_save"
@@ -140,11 +138,12 @@ class OpenAIImageToolkit(BaseToolkit):
             )
             return None
 
-    def _build_base_params(self, prompt: str) -> dict:
+    def _build_base_params(self, prompt: str, n: Optional[int] = None) -> dict:
         r"""Build base parameters dict for OpenAI API calls.
 
         Args:
             prompt (str): The text prompt for the image operation.
+            n (Optional[int]): The number of images to generate.
 
         Returns:
             dict: Parameters dictionary with non-None values.
@@ -152,8 +151,8 @@ class OpenAIImageToolkit(BaseToolkit):
         params = {"prompt": prompt, "model": self.model}
 
         # basic parameters supported by all models
-        if self.n is not None:
-            params["n"] = self.n  # type: ignore[assignment]
+        if n is not None:
+            params["n"] = n  # type: ignore[assignment]
         if self.size is not None:
             params["size"] = self.size
 
@@ -184,13 +183,16 @@ class OpenAIImageToolkit(BaseToolkit):
         return params
 
     def _handle_api_response(
-        self, response, image_name: str, operation: str
+        self, response, image_name: Union[str, List[str]], operation: str
     ) -> str:
         r"""Handle API response from OpenAI image operations.
 
         Args:
             response: The response object from OpenAI API.
-            image_name (str): Name for the saved image file.
+            image_name (Union[str, List[str]]): Name(s) for the saved image
+                file(s). If str, the same name is used for all images (will
+                cause error for multiple images). If list, must have exactly
+                the same length as the number of images generated.
             operation (str): Operation type for success message ("generated").
 
         Returns:
@@ -201,6 +203,21 @@ class OpenAIImageToolkit(BaseToolkit):
             logger.error(error_msg)
             return error_msg
 
+        # Validate image_name parameter
+        if isinstance(image_name, list):
+            if len(image_name) != len(response.data):
+                error_msg = (
+                    f"Error: Number of image names"
+                    f" ({len(image_name)}) does not match number of "
+                    f"images generated({len(response.data)})"
+                )
+                logger.error(error_msg)
+                return error_msg
+            image_names = image_name
+        else:
+            # If string, use same name for all images
+            image_names = [image_name] * len(response.data)
+
         results = []
 
         for i, image_data in enumerate(response.data):
@@ -215,18 +232,27 @@ class OpenAIImageToolkit(BaseToolkit):
                 image_bytes = base64.b64decode(image_b64)
                 os.makedirs(self.working_directory, exist_ok=True)
 
-                # Add index to filename when multiple images
-                if len(response.data) > 1:
-                    filename = f"{image_name}_{i+1}_{uuid.uuid4().hex}.png"
-                else:
-                    filename = f"{image_name}_{uuid.uuid4().hex}.png"
+                filename = f"{image_names[i]}"
 
                 image_path = os.path.join(self.working_directory, filename)
 
-                with open(image_path, "wb") as f:
-                    f.write(image_bytes)
-
-                results.append(f"Image saved to {image_path}")
+                # Check if file already exists
+                if os.path.exists(image_path):
+                    error_msg = (
+                        f"Error: File '{image_path}' already exists. "
+                        "Please use a different image_name."
+                    )
+                    logger.error(error_msg)
+                    return error_msg
+
+                try:
+                    with open(image_path, "wb") as f:
+                        f.write(image_bytes)
+                    results.append(f"Image saved to {image_path}")
+                except Exception as e:
+                    error_msg = f"Error saving image to '{image_path}': {e!s}"
+                    logger.error(error_msg)
+                    return error_msg
             else:
                 error_msg = (
                     f"No valid image data (URL or base64) found in image {i+1}"
@@ -254,7 +280,8 @@ class OpenAIImageToolkit(BaseToolkit):
     def generate_image(
         self,
         prompt: str,
-        image_name: str = "image",
+        image_name: Union[str, List[str]] = "image.png",
+        n: int = 1,
     ) -> str:
         r"""Generate an image using OpenAI's Image Generation models.
         The generated image will be saved locally (for ``b64_json`` response
@@ -263,14 +290,18 @@ class OpenAIImageToolkit(BaseToolkit):
 
         Args:
             prompt (str): The text prompt to generate the image.
-            image_name (str): The name of the image to save.
-                (default: :obj:`"image"`)
+            image_name (Union[str, List[str]]): The name(s) of the image(s) to
+                save. The image name must end with `.png`. If str: same name
+                used for all images (causes error if n > 1). If list: must
+                match the number of images being generated (n parameter).
+                (default: :obj:`"image.png"`)
+            n (int): The number of images to generate. (default: :obj:`1`)
 
         Returns:
             str: the content of the model response or format of the response.
         """
         try:
-            params = self._build_base_params(prompt)
+            params = self._build_base_params(prompt, n)
             response = self.client.images.generate(**params)
             return self._handle_api_response(response, image_name, "generated")
         except Exception as e:

camel/types/enums.py

@@ -213,8 +213,7 @@ class ModelType(UnifiedModelType, Enum):
     MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
     MISTRAL_NEMO = "open-mistral-nemo"
     MISTRAL_PIXTRAL_12B = "pixtral-12b-2409"
-    MISTRAL_MEDIUM_3 = "mistral-medium-latest"
-    MAGISTRAL_MEDIUM = "magistral-medium-2506"
+    MISTRAL_MEDIUM_3_1 = "mistral-medium-2508"
     MISTRAL_SMALL_3_2 = "mistral-small-2506"
 
     # Reka models
@@ -663,8 +662,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_PIXTRAL_12B,
             ModelType.MISTRAL_8B,
             ModelType.MISTRAL_3B,
-            ModelType.MISTRAL_MEDIUM_3,
-            ModelType.MAGISTRAL_MEDIUM,
+            ModelType.MISTRAL_MEDIUM_3_1,
             ModelType.MISTRAL_SMALL_3_2,
         }
 
@@ -1225,7 +1223,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NETMIND_DEEPSEEK_R1,
             ModelType.NETMIND_DEEPSEEK_V3,
             ModelType.NOVITA_DEEPSEEK_V3_0324,
-            ModelType.MISTRAL_MEDIUM_3,
+            ModelType.MISTRAL_MEDIUM_3_1,
             ModelType.ERNIE_4_5_TURBO_128K,
             ModelType.DEEPSEEK_V3,
             ModelType.MOONSHOT_KIMI_K2,
@@ -1336,10 +1334,6 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.TOGETHER_LLAMA_4_SCOUT,
         }:
             return 10_000_000
-        elif self in {
-            ModelType.MAGISTRAL_MEDIUM,
-        }:
-            return 40_000
 
         else:
             logger.warning(

{camel_ai-0.2.75a3.dist-info → camel_ai-0.2.75a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.75a3
+Version: 0.2.75a5
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -91,6 +91,7 @@ Requires-Dist: playwright>=1.50.0; extra == 'all'
 Requires-Dist: prance<24,>=23.6.21.0; extra == 'all'
 Requires-Dist: praw<8,>=7.7.1; extra == 'all'
 Requires-Dist: pre-commit<4,>=3; extra == 'all'
+Requires-Dist: protobuf>=6.0.0; extra == 'all'
 Requires-Dist: psycopg[binary]<4,>=3.1.18; extra == 'all'
 Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'all'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'all'
@@ -128,7 +129,6 @@ Requires-Dist: sympy<2,>=1.13.3; extra == 'all'
 Requires-Dist: tabulate>=0.9.0; extra == 'all'
 Requires-Dist: tavily-python<0.6,>=0.5.0; extra == 'all'
 Requires-Dist: textblob<0.18,>=0.17.1; extra == 'all'
-Requires-Dist: traceroot==0.0.4a5; extra == 'all'
 Requires-Dist: transformers<5,>=4; extra == 'all'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'all'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'all'
@@ -193,7 +193,6 @@ Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'
 Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'dev-tools'
 Requires-Dist: langfuse>=2.60.5; extra == 'dev-tools'
 Requires-Dist: mcp>=1.3.0; extra == 'dev-tools'
-Requires-Dist: traceroot==0.0.4a5; extra == 'dev-tools'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'dev-tools'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'dev-tools'
 Requires-Dist: typer>=0.15.2; extra == 'dev-tools'
@@ -345,6 +344,7 @@ Requires-Dist: nebula3-python==3.8.2; extra == 'rag'
 Requires-Dist: neo4j<6,>=5.18.0; extra == 'rag'
 Requires-Dist: numpy<=2.2,>=1.2; extra == 'rag'
 Requires-Dist: pandasai<3,>=2.3.0; extra == 'rag'
+Requires-Dist: protobuf>=6.0.0; extra == 'rag'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'rag'
 Requires-Dist: pyobvector>=0.1.18; extra == 'rag'
 Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'rag'
@@ -366,6 +366,7 @@ Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
 Requires-Dist: nebula3-python==3.8.2; extra == 'storage'
 Requires-Dist: neo4j<6,>=5.18.0; extra == 'storage'
 Requires-Dist: pgvector<0.3,>=0.2.4; extra == 'storage'
+Requires-Dist: protobuf>=6.0.0; extra == 'storage'
 Requires-Dist: psycopg[binary]<4,>=3.1.18; extra == 'storage'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'storage'
 Requires-Dist: pyobvector>=0.1.18; extra == 'storage'

{camel_ai-0.2.75a3.dist-info → camel_ai-0.2.75a5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=700Qx-U389P5R9yaCb-KQVk4xdMQWzsrmTGUuos90kc,901
+camel/__init__.py,sha256=wTQgonEYCTyRP1M-YWHFakaFzw2aGRPRjVe8PVbM284,901
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=WgEwael_eT6D-lVAKHpKIpwXSTjvLbny5jbV1Ab8lnA,5760
@@ -358,7 +358,7 @@ camel/toolkits/note_taking_toolkit.py,sha256=FWnkKdPyTENzHDPSFKo9zOrhhONfJkFpRvn
 camel/toolkits/notion_mcp_toolkit.py,sha256=ie_6Z-7DqDhgTiwYX8L3X47rfWGwzgwQH_s2DaK1ckc,8362
 camel/toolkits/notion_toolkit.py,sha256=jmmVWk_WazRNWnx4r9DAvhFTAL-n_ige0tb32UHJ_ik,9752
 camel/toolkits/open_api_toolkit.py,sha256=Venfq8JwTMQfzRzzB7AYmYUMEX35hW0BjIv_ozFMiNk,23316
-camel/toolkits/openai_image_toolkit.py,sha256=RDCPYnEPWibFmAgyQNUck0UWKguD7fni93lpMBMh1UQ,11180
+camel/toolkits/openai_image_toolkit.py,sha256=6Hcadut2cwJrgh5RObtErYNzsl93gC28NoJTS-HvYw8,12930
 camel/toolkits/openbb_toolkit.py,sha256=8yBZL9E2iSgskosBQhD3pTP56oV6gerWpFjIJc_2UMo,28935
 camel/toolkits/origene_mcp_toolkit.py,sha256=og3H-F5kWRRIyOyhF7BR-ig_JIpZPKE0DCA1QJZw5BY,3354
 camel/toolkits/page_script.js,sha256=mXepZPnQNVLp_Wgb64lv7DMQIJYl_XIHJHLVt1OFZO4,13146
@@ -390,18 +390,18 @@ camel/toolkits/zapier_toolkit.py,sha256=A83y1UcfuopH7Fx82pORzypl1StbhBjB2HhyOqYa
 camel/toolkits/hybrid_browser_toolkit/__init__.py,sha256=vxjWhq7GjUKE5I9RGQU_GoikZJ-AVK4ertdvEqp9pd0,802
 camel/toolkits/hybrid_browser_toolkit/config_loader.py,sha256=yUmbmt-TWLbCyxGa63lVJ47KRdZsEJI6-2y3x0SfdBM,7040
 camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=gotOOlXJjfjv9Qnn89PLNhJ4_Rw_aMMU6gTJcG-uCf8,7938
-camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py,sha256=OXvXTRJMqS4tQqrOeNbK4EVv3meO8I8bfz_3azSJFZA,53547
-camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=UJFxHuGBJR3C9UmtWoC_F2bm_Uwnf9EurhkSseAqrBI,21888
+camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py,sha256=f1m0cBvQCM5XlgPKWLSUGAlTqRqlI1ZKYs3KcrLqJ-w,54919
+camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=Cx3DpZctlwNlSoNa4sa3DOky_nPUKId98jCq63uXNgc,23903
 camel/toolkits/hybrid_browser_toolkit/ts/package-lock.json,sha256=_-YE9S_C1XT59A6upQp9lLuZcC67cV9QlbwAsEKkfyw,156337
 camel/toolkits/hybrid_browser_toolkit/ts/package.json,sha256=pUQm0xwXR7ZyWNv6O2QtHW00agnfAoX9F_XGXZlAxl4,745
 camel/toolkits/hybrid_browser_toolkit/ts/tsconfig.json,sha256=SwpQnq4Q-rwRobF2iWrP96mgmgwaVPZEv-nii5QIYEU,523
-camel/toolkits/hybrid_browser_toolkit/ts/websocket-server.js,sha256=qj8Rr7bl17yciJ0ndB-rVsm25LxVUk3Mk_Kft_Z2p2o,9387
+camel/toolkits/hybrid_browser_toolkit/ts/websocket-server.js,sha256=NeBhFUQl6dOyDeeh0c8LZ7f3qZssMHIrqJSP1mZEeiE,9672
 camel/toolkits/hybrid_browser_toolkit/ts/src/browser-scripts.js,sha256=NNwM_H2xaDrlrdac0PJK1iUBwdiuQsg9qKaMhHAvZuI,3160
-camel/toolkits/hybrid_browser_toolkit/ts/src/browser-session.ts,sha256=e-epyloFdIOHWKXL-mTeeHxmRssMHs2E7mP9qRzFAgM,38704
-camel/toolkits/hybrid_browser_toolkit/ts/src/config-loader.ts,sha256=xt5dyj-6LK7T8IRSQ4sb4RBvD-xYPG68vWKqCET1QU4,6235
-camel/toolkits/hybrid_browser_toolkit/ts/src/hybrid-browser-toolkit.ts,sha256=RFfmwYWmHd9VJkXQPaONiqbqKp652c17T0YKo4RFYBY,19708
+camel/toolkits/hybrid_browser_toolkit/ts/src/browser-session.ts,sha256=fcqZoTJArx9UTBzjelZkX7zse5HwbqqwFjQeMbeRWQI,42893
+camel/toolkits/hybrid_browser_toolkit/ts/src/config-loader.ts,sha256=36o-N3YNTtLxdp5MfGHj4h7LowCx0o3oxKZKFBoFchA,6218
+camel/toolkits/hybrid_browser_toolkit/ts/src/hybrid-browser-toolkit.ts,sha256=oz5rs3u7vqWxssCYNWkqJu4JOmk7dRbf2SMIEputHEs,22149
 camel/toolkits/hybrid_browser_toolkit/ts/src/index.ts,sha256=uJGHmGs640iCrjllqXDXwDE4hGW1VJA2YL6BkFkzYNs,353
-camel/toolkits/hybrid_browser_toolkit/ts/src/types.ts,sha256=ZT_5P9tun4ZCasIlDSS2tBTtpiI2DfcD4kOIpmXjrDw,2801
+camel/toolkits/hybrid_browser_toolkit/ts/src/types.ts,sha256=NFOJKROXYDHSXxcr15LHm36rPfRpVS2hsIobXcZgTRU,2964
 camel/toolkits/hybrid_browser_toolkit_py/__init__.py,sha256=tPQloCw-Ayl1lPfyvzGJkMFa1ze3ilXJq_1Oz5jg5s4,796
 camel/toolkits/hybrid_browser_toolkit_py/actions.py,sha256=S77VLL9hOq5M2RdPQrIAgjxinwS2ETd6kH6m6vtub5o,20935
 camel/toolkits/hybrid_browser_toolkit_py/agent.py,sha256=0ifwhYUDJ5GLxfdpC5KquPaW1a0QBAutp2Y9y0YFujw,11685
@@ -437,7 +437,7 @@ camel/toolkits/open_api_specs/web_scraper/openapi.yaml,sha256=u_WalQ01e8W1D27VnZ
 camel/toolkits/open_api_specs/web_scraper/paths/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/web_scraper/paths/scraper.py,sha256=aWy1_ppV4NVVEZfnbN3tu9XA9yAPAC9bRStJ5JuXMRU,1117
 camel/types/__init__.py,sha256=EOmWlqS7aE5cB51_Vv7vHUexKeBbx9FSsfynl5vKjwo,2565
-camel/types/enums.py,sha256=5L4KfHVRDdIIlaMaU-Lv-P5de3AOHeh6EfZfQBveJz4,63964
+camel/types/enums.py,sha256=x76UYX53jaUF0-qgUa0KFwRufo8cekb4-QGirlfTKB0,63781
 camel/types/mcp_registries.py,sha256=dl4LgYtSaUhsqAKpz28k_SA9La11qxqBvDLaEuyzrFE,4971
 camel/types/openai_types.py,sha256=m7oWb8nWYWOAwBRY1mP9mS9RVufXeDVj-fGvHAhXuMU,2120
 camel/types/unified_model_type.py,sha256=U3NUZux7QuMIxPW2H0qDp9BOyDJFHAx6jUmDNw5_9KM,5912
@@ -466,7 +466,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.75a3.dist-info/METADATA,sha256=86OHr9M5A_cTjIAvHhESEpWG4t091n5rCO3QS5o7GQM,52289
-camel_ai-0.2.75a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.75a3.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.75a3.dist-info/RECORD,,
+camel_ai-0.2.75a5.dist-info/METADATA,sha256=R6EVTTS1N9_Tr6y_hwN4hC0ppiWl8z6XrXcmZEGmqcc,52328
+camel_ai-0.2.75a5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.75a5.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.75a5.dist-info/RECORD,,