camel-ai 0.2.26__py3-none-any.whl → 0.2.27__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.26'
+__version__ = '0.2.27'
 
 __all__ = [
     '__version__',

camel/models/__init__.py

@@ -37,9 +37,11 @@ from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
 from .sglang_model import SGLangModel
+from .siliconflow_model import SiliconFlowModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
+from .volcano_model import VolcanoModel
 from .yi_model import YiModel
 from .zhipuai_model import ZhipuAIModel
 
@@ -76,4 +78,6 @@ __all__ = [
     'MoonshotModel',
     'AIMLModel',
     'BaseAudioModel',
+    'SiliconFlowModel',
+    'VolcanoModel',
 ]

camel/models/azure_openai_model.py

@@ -128,18 +128,23 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        response = self._client.chat.completions.create(
-            messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -152,18 +157,93 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
             messages=messages,
             model=self.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/models/model_factory.py

@@ -37,6 +37,7 @@ from camel.models.siliconflow_model import SiliconFlowModel
 from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
+from camel.models.volcano_model import VolcanoModel
 from camel.models.yi_model import YiModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType, UnifiedModelType
@@ -107,6 +108,8 @@ class ModelFactory:
             model_class = SiliconFlowModel
         elif model_platform.is_aiml:
             model_class = AIMLModel
+        elif model_platform.is_volcano:
+            model_class = VolcanoModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

camel/models/openai_compatible_model.py

@@ -86,18 +86,23 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, Stream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        response = self._client.chat.completions.create(
-            messages=messages,
-            model=self.model_type,
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -110,18 +115,93 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     @property
     def token_counter(self) -> BaseTokenCounter:

camel/models/volcano_model.py

@@ -0,0 +1,100 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import OPENAI_API_PARAMS
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class VolcanoModel(OpenAICompatibleModel):
+    r"""Volcano Engine API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into the API call. If
+            :obj:`None`, :obj:`{}` will be used. (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Volcano Engine service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Volcano Engine service.
+            (default: :obj:`https://ark.cn-beijing.volces.com/api/v3`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter`
+            will be used. (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", "VOLCANO_API_KEY"),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = {}
+
+        api_key = api_key or os.environ.get("VOLCANO_API_KEY")
+        url = (
+            url
+            or os.environ.get("VOLCANO_API_BASE_URL")
+            or "https://ark.cn-beijing.volces.com/api/v3"
+        )
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            # Use OpenAI token counter as an approximation
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration is valid for Volcano
+        model backends.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Volcano API.
+        """
+        # Using OpenAI API params as Volcano Engine API is OpenAI-compatible
+        for param in self.model_config_dict:
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Volcano model backend."
+                )

camel/toolkits/__init__.py

@@ -55,7 +55,7 @@ from .excel_toolkit import ExcelToolkit
 from .video_analysis_toolkit import VideoAnalysisToolkit
 from .image_analysis_toolkit import ImageAnalysisToolkit
 from .mcp_toolkit import MCPToolkit
-from .web_toolkit import WebToolkit
+from .browser_toolkit import BrowserToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
@@ -102,7 +102,7 @@ __all__ = [
     'ExcelToolkit',
     'VideoAnalysisToolkit',
     'ImageAnalysisToolkit',
-    'WebToolkit',
+    'BrowserToolkit',
     'FileWriteToolkit',
     'TerminalToolkit',
     'PubMedToolkit',

camel/toolkits/{web_toolkit.py → browser_toolkit.py}

@@ -92,7 +92,7 @@ ACTION_WITH_FEEDBACK_LIST = [
 ]
 
 
-# codes from magentic-one
+# Code from magentic-one
 class DOMRectangle(TypedDict):
     x: Union[int, float]
     y: Union[int, float]
@@ -127,21 +127,36 @@ class InteractiveRegion(TypedDict):
 
 
 def _get_str(d: Any, k: str) -> str:
+    r"""Safely retrieve a string value from a dictionary."""
+    if k not in d:
+        raise KeyError(f"Missing required key: '{k}'")
     val = d[k]
-    assert isinstance(val, str)
-    return val
+    if isinstance(val, str):
+        return val
+    raise TypeError(
+        f"Expected a string for key '{k}', " f"but got {type(val).__name__}"
+    )
 
 
 def _get_number(d: Any, k: str) -> Union[int, float]:
+    r"""Safely retrieve a number (int or float) from a dictionary"""
     val = d[k]
-    assert isinstance(val, int) or isinstance(val, float)
-    return val
+    if isinstance(val, (int, float)):
+        return val
+    raise TypeError(
+        f"Expected a number (int/float) for key "
+        f"'{k}', but got {type(val).__name__}"
+    )
 
 
 def _get_bool(d: Any, k: str) -> bool:
+    r"""Safely retrieve a boolean value from a dictionary."""
     val = d[k]
-    assert isinstance(val, bool)
-    return val
+    if isinstance(val, bool):
+        return val
+    raise TypeError(
+        f"Expected a boolean for key '{k}', " f"but got {type(val).__name__}"
+    )
 
 
 def _parse_json_output(text: str) -> Dict[str, Any]:
@@ -208,7 +223,8 @@ def _reload_image(image: Image.Image):
     return Image.open(buffer)
 
 
-def domrectangle_from_dict(rect: Dict[str, Any]) -> DOMRectangle:
+def dom_rectangle_from_dict(rect: Dict[str, Any]) -> DOMRectangle:
+    r"""Create a DOMRectangle object from a dictionary."""
     return DOMRectangle(
         x=_get_number(rect, "x"),
         y=_get_number(rect, "y"),
@@ -221,10 +237,11 @@ def domrectangle_from_dict(rect: Dict[str, Any]) -> DOMRectangle:
     )
 
 
-def interactiveregion_from_dict(region: Dict[str, Any]) -> InteractiveRegion:
+def interactive_region_from_dict(region: Dict[str, Any]) -> InteractiveRegion:
+    r"""Create an :class:`InteractiveRegion` object from a dictionary."""
     typed_rects: List[DOMRectangle] = []
     for rect in region["rects"]:
-        typed_rects.append(domrectangle_from_dict(rect))
+        typed_rects.append(dom_rectangle_from_dict(rect))
 
     return InteractiveRegion(
         tag_name=_get_str(region, "tag_name"),
@@ -235,7 +252,8 @@ def interactiveregion_from_dict(region: Dict[str, Any]) -> InteractiveRegion:
     )
 
 
-def visualviewport_from_dict(viewport: Dict[str, Any]) -> VisualViewport:
+def visual_viewport_from_dict(viewport: Dict[str, Any]) -> VisualViewport:
+    r"""Create a :class:`VisualViewport` object from a dictionary."""
     return VisualViewport(
         height=_get_number(viewport, "height"),
         width=_get_number(viewport, "width"),
@@ -252,7 +270,7 @@ def visualviewport_from_dict(viewport: Dict[str, Any]) -> VisualViewport:
 
 
 def add_set_of_mark(
-    screenshot: bytes | Image.Image | io.BufferedIOBase,
+    screenshot: Union[bytes, Image.Image, io.BufferedIOBase],
     ROIs: Dict[str, InteractiveRegion],
 ) -> Tuple[Image.Image, List[str], List[str], List[str]]:
     if isinstance(screenshot, Image.Image):
@@ -272,6 +290,18 @@ def add_set_of_mark(
 def _add_set_of_mark(
     screenshot: Image.Image, ROIs: Dict[str, InteractiveRegion]
 ) -> Tuple[Image.Image, List[str], List[str], List[str]]:
+    r"""Add a set of marks to the screenshot.
+
+    Args:
+        screenshot (Image.Image): The screenshot to add marks to.
+        ROIs (Dict[str, InteractiveRegion]): The regions to add marks to.
+
+    Returns:
+        Tuple[Image.Image, List[str], List[str], List[str]]: A tuple
+        containing the screenshot with marked ROIs, ROIs fully within the
+        images, ROIs located above the visible area, and ROIs located below
+        the visible area.
+    """
     visible_rects: List[str] = list()
     rects_above: List[str] = list()  # Scroll up to see
     rects_below: List[str] = list()  # Scroll down to see
@@ -284,22 +314,22 @@ def _add_set_of_mark(
     for r in ROIs:
         for rect in ROIs[r]["rects"]:
             # Empty rectangles
-            if not rect:
-                continue
-            if rect["width"] * rect["height"] == 0:
+            if not rect or rect["width"] == 0 or rect["height"] == 0:
                 continue
 
-            mid = (
-                (rect["right"] + rect["left"]) / 2.0,
-                (rect["top"] + rect["bottom"]) / 2.0,
-            )
+            # TODO: add scroll left and right?
+            horizontal_center = (rect["right"] + rect["left"]) / 2.0
+            vertical_center = (rect["top"] + rect["bottom"]) / 2.0
+            is_within_horizon = 0 <= horizontal_center < base.size[0]
+            is_above_viewport = vertical_center < 0
+            is_below_viewport = vertical_center >= base.size[1]
 
-            if 0 <= mid[0] and mid[0] < base.size[0]:
-                if mid[1] < 0:
+            if is_within_horizon:
+                if is_above_viewport:
                     rects_above.append(r)
-                elif mid[1] >= base.size[1]:
+                elif is_below_viewport:
                     rects_below.append(r)
-                else:
+                else:  # Fully visible
                     visible_rects.append(r)
                     _draw_roi(draw, int(r), fnt, rect)
 
@@ -314,9 +344,16 @@ def _draw_roi(
     font: ImageFont.FreeTypeFont | ImageFont.ImageFont,
     rect: DOMRectangle,
 ) -> None:
-    color = _color(idx)
-    luminance = color[0] * 0.3 + color[1] * 0.59 + color[2] * 0.11
-    text_color = (0, 0, 0, 255) if luminance > 90 else (255, 255, 255, 255)
+    r"""Draw a ROI on the image.
+
+    Args:
+        draw (ImageDraw.ImageDraw): The draw object.
+        idx (int): The index of the ROI.
+        font (ImageFont.FreeTypeFont | ImageFont.ImageFont): The font.
+        rect (DOMRectangle): The DOM rectangle.
+    """
+    color = _get_random_color(idx)
+    text_color = _get_text_color(color)
 
     roi = ((rect["left"], rect["top"]), (rect["right"], rect["bottom"]))
 
@@ -351,9 +388,36 @@ def _draw_roi(
     )
 
 
-def _color(identifier: int) -> Tuple[int, int, int, int]:
+def _get_text_color(
+    bg_color: Tuple[int, int, int, int],
+) -> Tuple[int, int, int, int]:
+    r"""Determine the ideal text color (black or white) for contrast.
+
+    Args:
+        bg_color: The background color (R, G, B, A).
+
+    Returns:
+        A tuple representing black or white color for text.
+    """
+    luminance = bg_color[0] * 0.3 + bg_color[1] * 0.59 + bg_color[2] * 0.11
+    return (0, 0, 0, 255) if luminance > 120 else (255, 255, 255, 255)
+
+
+def _get_random_color(identifier: int) -> Tuple[int, int, int, int]:
+    r"""Generate a consistent random RGBA color based on the identifier.
+
+    Args:
+        identifier: The ID used as a seed to ensure color consistency.
+
+    Returns:
+        A tuple representing (R, G, B, A) values.
+    """
     rnd = random.Random(int(identifier))
-    color = [rnd.randint(0, 255), rnd.randint(125, 255), rnd.randint(0, 50)]
+    r = rnd.randint(0, 255)
+    g = rnd.randint(125, 255)
+    b = rnd.randint(0, 50)
+    color = [r, g, b]
+    # TODO: check why shuffle is needed?
     rnd.shuffle(color)
     color.append(255)
     return cast(Tuple[int, int, int, int], tuple(color))
@@ -379,13 +443,11 @@ class BaseBrowser:
         self.playwright = sync_playwright().start()
         self.page_history: list = []  # stores the history of visited pages
 
-        # set the cache directory
-        self.cache_dir = "tmp/"
+        # Set the cache directory
+        self.cache_dir = "tmp/" if cache_dir is None else cache_dir
         os.makedirs(self.cache_dir, exist_ok=True)
-        if cache_dir is not None:
-            self.cache_dir = cache_dir
 
-        # load the page script
+        # Load the page script
         abs_dir_path = os.path.dirname(os.path.abspath(__file__))
         page_script_path = os.path.join(abs_dir_path, "page_script.js")
 
@@ -398,34 +460,35 @@ class BaseBrowser:
                 f"Page script file not found at path: {page_script_path}"
             )
 
-    def init(self):
+    def init(self) -> None:
         r"""Initialize the browser."""
-        self.browser = self.playwright.chromium.launch(
-            headless=self.headless
-        )  # Launch the browser, if headless is False, the browser will display
-        self.context = self.browser.new_context(
-            accept_downloads=True
-        )  # create a new context
-        self.page = self.context.new_page()  # create a new page
-
-    def clean_cache(self):
-        r"""delete the cache directory and its contents."""
+        # Launch the browser, if headless is False, the browser will display
+        self.browser = self.playwright.chromium.launch(headless=self.headless)
+        # Create a new context
+        self.context = self.browser.new_context(accept_downloads=True)
+        # Create a new page
+        self.page = self.context.new_page()
+
+    def clean_cache(self) -> None:
+        r"""Delete the cache directory and its contents."""
         if os.path.exists(self.cache_dir):
             shutil.rmtree(self.cache_dir)
 
-    def _wait_for_load(self, timeout: int = 20):
+    def _wait_for_load(self, timeout: int = 20) -> None:
         r"""Wait for a certain amount of time for the page to load."""
         timeout_ms = timeout * 1000
 
         self.page.wait_for_load_state("load", timeout=timeout_ms)
+
+        # TODO: check if this is needed
         time.sleep(2)
 
-    def click_blank_area(self):
+    def click_blank_area(self) -> None:
         r"""Click a blank area of the page to unfocus the current element."""
         self.page.mouse.click(0, 0)
         self._wait_for_load()
 
-    def visit_page(self, url: str):
+    def visit_page(self, url: str) -> None:
         r"""Visit a page with the given URL."""
 
         self.page.goto(url)
@@ -433,8 +496,8 @@ class BaseBrowser:
         self.page_url = url
 
     def ask_question_about_video(self, question: str) -> str:
-        r"""Ask a question about the video on the current page. It is suitable
-        to process youtube video.
+        r"""Ask a question about the video on the current page,
+        such as YouTube video.
 
         Args:
             question (str): The question to ask.
@@ -459,8 +522,9 @@ class BaseBrowser:
                 directory.
 
         Returns:
-            Tuple[Image.Image, str]: A tuple containing the screenshot image
-                and the path to the image file.
+            Tuple[Image.Image, str]: A tuple containing the screenshot
+            image and the path to the image file if saved, otherwise
+            :obj:`None`.
         """
 
         image_data = self.page.screenshot(timeout=60000)
@@ -468,12 +532,13 @@ class BaseBrowser:
 
         file_path = None
         if save_image:
-            # get url name to form a file name
+            # Get url name to form a file name
+            # TODO: Use a safer way for the url name
             url_name = self.page_url.split("/")[-1]
             for char in ['\\', '/', ':', '*', '?', '"', '<', '>', '|', '.']:
                 url_name = url_name.replace(char, "_")
 
-            # get formatted time: mmddhhmmss
+            # Get formatted time: mmddhhmmss
             timestamp = datetime.datetime.now().strftime("%m%d%H%M%S")
             file_path = os.path.join(
                 self.cache_dir, f"{url_name}_{timestamp}.png"
@@ -492,23 +557,18 @@ class BaseBrowser:
 
         Args:
             scroll_ratio (float): The ratio of viewport height to scroll each
-                step (default: 0.7).
+                step (default: 0.8).
 
         Returns:
             List[str]: A list of paths to the screenshot files.
         """
         screenshots = []
         scroll_height = self.page.evaluate("document.body.scrollHeight")
+        assert self.page.viewport_size is not None
         viewport_height = self.page.viewport_size["height"]
         current_scroll = 0
         screenshot_index = 1
 
-        url_name = self.page.url.split("/")[-1].replace(".", "_")
-        timestamp = datetime.datetime.now().strftime("%m%d%H%M%S")
-        base_file_path = os.path.join(
-            self.cache_dir, f"{url_name}_{timestamp}"
-        )
-
         max_height = scroll_height - viewport_height
         scroll_step = int(viewport_height * scroll_ratio)
 
@@ -520,14 +580,15 @@ class BaseBrowser:
                 f"{max_height}, step: {scroll_step}"
             )
 
-            file_path = f"{base_file_path}_{screenshot_index}.png"
             _, file_path = self.get_screenshot(save_image=True)
             screenshots.append(file_path)
 
             self.page.evaluate(f"window.scrollBy(0, {scroll_step})")
+            # Allow time for content to load
             time.sleep(0.5)
 
             current_scroll = self.page.evaluate("window.scrollY")
+            # Break if there is no significant scroll
             if abs(current_scroll - last_height) < viewport_height * 0.1:
                 break
 
@@ -547,12 +608,16 @@ class BaseBrowser:
         except Exception as e:
             logger.warning(f"Error evaluating page script: {e}")
 
-        return visualviewport_from_dict(
+        return visual_viewport_from_dict(
             self.page.evaluate("MultimodalWebSurfer.getVisualViewport();")
         )
 
-    def get_interactive_elements(self) -> List[Dict[str, Any]]:
-        # codes from magentic-one
+    def get_interactive_elements(self) -> Dict[str, InteractiveRegion]:
+        r"""Get the interactive elements of the current page.
+
+        Returns:
+            Dict[str, InteractiveRegion]: A dictionary of interactive elements.
+        """
         try:
             self.page.evaluate(self.page_script)
         except Exception as e:
@@ -565,12 +630,13 @@ class BaseBrowser:
 
         typed_results: Dict[str, InteractiveRegion] = {}
         for k in result:
-            typed_results[k] = interactiveregion_from_dict(result[k])
+            typed_results[k] = interactive_region_from_dict(result[k])
 
         return typed_results  # type: ignore[return-value]
 
     def get_som_screenshot(
-        self, save_image: bool = False
+        self,
+        save_image: bool = False,
     ) -> Tuple[Image.Image, Union[str, None]]:
         r"""Get a screenshot of the current viewport with interactive elements
         marked.
@@ -608,15 +674,19 @@ class BaseBrowser:
         return comp, file_path
 
     def scroll_up(self) -> None:
+        r"""Scroll up the page."""
         self.page.keyboard.press("PageUp")
 
     def scroll_down(self) -> None:
+        r"""Scroll down the page."""
         self.page.keyboard.press("PageDown")
 
     def get_url(self) -> str:
+        r"""Get the URL of the current page."""
         return self.page.url
 
-    def click_id(self, identifier: Union[str, int]):
+    def click_id(self, identifier: Union[str, int]) -> None:
+        r"""Click an element with the given identifier."""
         if isinstance(identifier, int):
             identifier = str(identifier)
         target = self.page.locator(f"[__elementId='{identifier}']")
@@ -649,7 +719,7 @@ class BaseBrowser:
 
         self._wait_for_load()
 
-    def extract_url_content(self):
+    def extract_url_content(self) -> str:
         r"""Extract the content of the current page."""
         content = self.page.content()
         return content
@@ -821,7 +891,6 @@ class BaseBrowser:
 
     def close(self):
         self.browser.close()
-        self.playwright.stop()
 
     # ruff: noqa: E501
     def show_interactive_elements(self):
@@ -846,7 +915,7 @@ class BaseBrowser:
         return markdown_content
 
 
-class WebToolkit(BaseToolkit):
+class BrowserToolkit(BaseToolkit):
     r"""A class for browsing the web and interacting with web pages.
 
     This class provides methods for browsing the web and interacting with web
@@ -862,7 +931,7 @@ class WebToolkit(BaseToolkit):
         planning_agent_model: Optional[BaseModelBackend] = None,
         output_language: str = "en",
     ):
-        r"""Initialize the WebToolkit instance.
+        r"""Initialize the BrowserToolkit instance.
 
         Args:
             headless (bool): Whether to run the browser in headless mode.
@@ -1026,9 +1095,7 @@ out the information you need. Sometimes they are extremely useful.
         """
 
         # get current state
-        som_screenshot, som_screenshot_path = self.browser.get_som_screenshot(
-            save_image=True
-        )
+        som_screenshot, _ = self.browser.get_som_screenshot(save_image=True)
         img = _reload_image(som_screenshot)
         message = BaseMessage.make_user_message(
             role_name='user', content=observe_prompt, image_list=[img]
@@ -1222,7 +1289,7 @@ Your output should be in json format, including the following fields:
             return False, replanned_schema
 
     @dependencies_required("playwright")
-    def browser_simulation(
+    def browse_url(
         self, task_prompt: str, start_url: str, round_limit: int = 12
     ) -> str:
         r"""A powerful toolkit which can simulate the browser interaction to solve the task which needs multi-step actions.
@@ -1303,4 +1370,4 @@ Your output should be in json format, including the following fields:
         return simulation_result
 
     def get_tools(self) -> List[FunctionTool]:
-        return [FunctionTool(self.browser_simulation)]
+        return [FunctionTool(self.browse_url)]

camel/toolkits/search_toolkit.py

@@ -704,6 +704,68 @@ class SearchToolkit(BaseToolkit):
         except Exception as e:
             return [{"error": f"An unexpected error occurred: {e!s}"}]
 
+    @api_keys_required([(None, 'BOCHA_API_KEY')])
+    def search_bocha(
+        self,
+        query: str,
+        freshness: str = "noLimit",
+        summary: bool = False,
+        count: int = 10,
+        page: int = 1,
+    ) -> Dict[str, Any]:
+        r"""Query the Bocha AI search API and return search results.
+
+        Args:
+            query (str): The search query.
+            freshness (str): Time frame filter for search results. Default
+                is "noLimit". Options include:
+                - 'noLimit': no limit (default).
+                - 'oneDay': past day.
+                - 'oneWeek': past week.
+                - 'oneMonth': past month.
+                - 'oneYear': past year.
+            summary (bool): Whether to include text summaries in results.
+                Default is False.
+            count (int): Number of results to return (1-50). Default is 10.
+            page (int): Page number of results. Default is 1.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing search results, including
+                web pages, images, and videos if available. The structure
+                follows the Bocha AI search API response format.
+        """
+        import json
+
+        BOCHA_API_KEY = os.getenv("BOCHA_API_KEY")
+
+        url = "https://api.bochaai.com/v1/web-search"
+        headers = {
+            "Authorization": f"Bearer {BOCHA_API_KEY}",
+            "Content-Type": "application/json",
+        }
+
+        payload = json.dumps(
+            {
+                "query": query,
+                "freshness": freshness,
+                "summary": summary,
+                "count": count,
+                "page": page,
+            }
+        )
+        try:
+            response = requests.post(url, headers=headers, data=payload)
+            if response.status_code != 200:
+                return {
+                    "error": (
+                        f"Bocha API failed with {response.status_code}: "
+                        f"{response.text}"
+                    )
+                }
+            return response.json()["data"]
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Bocha AI search failed: {e!s}"}
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.
@@ -720,4 +782,5 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.query_wolfram_alpha),
             FunctionTool(self.tavily_search),
             FunctionTool(self.search_brave),
+            FunctionTool(self.search_bocha),
         ]

camel/types/enums.py

@@ -249,6 +249,7 @@ class ModelType(UnifiedModelType, Enum):
                 self.is_siliconflow,
                 self.is_zhipuai,
                 self.is_aiml,
+                self.is_azure_openai,
             ]
         )
 
@@ -889,6 +890,7 @@ class ModelPlatformType(Enum):
     MOONSHOT = "moonshot"
     SILICONFLOW = "siliconflow"
     AIML = "aiml"
+    VOLCANO = "volcano"
 
     @property
     def is_openai(self) -> bool:
@@ -1011,6 +1013,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is AIML."""
         return self is ModelPlatformType.AIML
 
+    @property
+    def is_volcano(self) -> bool:
+        r"""Returns whether this platform is volcano."""
+        return self is ModelPlatformType.VOLCANO
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

{camel_ai-0.2.26.dist-info → camel_ai-0.2.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.26
+Version: 0.2.27
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.26.dist-info → camel_ai-0.2.27.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=vUQIqmv9Y3SKQSw2mOa58Ppfzinc5zLe5psIFxbYhSI,912
+camel/__init__.py,sha256=6XPf3TQFxgCHXxPaRb-Lda_NJ-gHT1IsrHIeYeMzGGA,912
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=9X09UmxI2JqQnhrFfnZ3B9EzFmVfdSWQcjLWTIXKXe0,4962
 camel/logger.py,sha256=j6mPsLJyKOn16o6Um57882mHsURQ8h-jia6Jd_34wRA,4239
@@ -134,11 +134,11 @@ camel/messages/conversion/sharegpt/__init__.py,sha256=oWUuHV5w85kxqhz_hoElLmCfzL
 camel/messages/conversion/sharegpt/function_call_formatter.py,sha256=cn7e7CfmxEVFlfOqhjhNuA8nuWvWD6hXYn-3okXNxxQ,1832
 camel/messages/conversion/sharegpt/hermes/__init__.py,sha256=mxuMSm-neaTgInIjYXuIVdC310E6jKJzM3IdtaJ4qY4,812
 camel/messages/conversion/sharegpt/hermes/hermes_function_formatter.py,sha256=-9TT8iOQ-ieKSKR_PmJSA5Bi0uBx-qR7WQ6vxuFkorM,4639
-camel/models/__init__.py,sha256=30gJOmde3TS-j5I4m0hrxI5BJDd2H3UA1hxQD9TQzGE,2637
+camel/models/__init__.py,sha256=iNZ1LcesJ3YaAbNRxHTA-sUaxfjn6gUQ-EQArll21KQ,2769
 camel/models/_utils.py,sha256=hob1ehnS5xZitMCdYToHVgaTB55JnaP4_DSWnTEfVsg,2045
 camel/models/aiml_model.py,sha256=4FW66DxmVMPWAJckh4UjMM6eD1QNyrAPAPtrpmWxzjc,6524
 camel/models/anthropic_model.py,sha256=8XAj9sVaN1X0hvrL9a-qsmkAFWoGe1Ozj5XZsXYe1UI,5894
-camel/models/azure_openai_model.py,sha256=WBxnR-UNnBw49zyLxqF_d-7VKWTjBPnNR_xMvhWrggI,7471
+camel/models/azure_openai_model.py,sha256=AblW2scYp12_odI1GG0ATHI8-Tn7d6SCsxHe7g66rWs,10386
 camel/models/base_audio_model.py,sha256=QkLqh0v-5kcE_jwFB5xAgvztAqB2Bot4_iG9sZdcl8A,2986
 camel/models/base_model.py,sha256=RolL8fRwVpfz8g9lpb_71h0mYTNl-U63f8KBy6hc3E0,10679
 camel/models/cohere_model.py,sha256=RAYHCyppDQxQ7BOR-e314AagB09vRxoScoHc-FtL6Bc,13355
@@ -149,14 +149,14 @@ camel/models/groq_model.py,sha256=FgXOHmIKAxGFASUmmk5tK49bPcXsr7diB3zRFGg9XDA,73
 camel/models/internlm_model.py,sha256=4nr5LXhxBfOjm-0i65pXyaS0_sT5oAXKXaUfkijAGmQ,5612
 camel/models/litellm_model.py,sha256=xi4kDd0FKuznKtox8ArsB39u40ueOhcb-CpWv4bcbXw,5544
 camel/models/mistral_model.py,sha256=OB948fRVnXikVIDO3PqxV0zb_qpwwta0DIW1bbX3SYI,11666
-camel/models/model_factory.py,sha256=1PgJdifxYYqQ9VnZRrEER7nKjz2X07uHwPMxg454Alk,6732
+camel/models/model_factory.py,sha256=GdjGCxslqe04oWvpfiOdPl0ZGzuGooeA9M8ppby6hFo,6863
 camel/models/model_manager.py,sha256=gfpL-WUxuTXgNeCkIVg8Y0zRvxMqRLX8JGt0XEAPQ8Y,9214
 camel/models/moonshot_model.py,sha256=DNZzDYz0AWU1q6pIvbPALqesejoawwuKzeP0_ZbjDSg,6149
 camel/models/nemotron_model.py,sha256=jJrW8tpTlEJDT1FjflB9krhgEQhD5KBeLmyUIcZvWPk,3886
 camel/models/nvidia_model.py,sha256=lqp1iPwVDq6zSQ9B0SyBZ48Z3J5WbXwPshwlhj1ogZ8,6711
 camel/models/ollama_model.py,sha256=byJ0YbMlilEFRKJZIot-MPUcojwMHLIaBES0a1SURtg,10604
 camel/models/openai_audio_models.py,sha256=fYpxFvxT8p93KVb5BYODTuI5wdNXV9pu_bvxfARgVYk,13193
-camel/models/openai_compatible_model.py,sha256=9fzV3EtcE5YFZ5-rYYMoWVmqjjcGfC7rDml5Ngoz6Fs,5299
+camel/models/openai_compatible_model.py,sha256=Nmps04Fo0ILmynE8wbKVzTrQ0VDyOrDR1ICD1nGrjd0,8142
 camel/models/openai_model.py,sha256=CbfD9yVtAltyqdFpjnLXncFnmaGPDZq8JhJDaSfG0pc,10186
 camel/models/qwen_model.py,sha256=_LeeB0yrXRMI-gZOEEOHg0bWNOJpuQHf2G7u40--3r8,7064
 camel/models/reka_model.py,sha256=15DscZf3lbqsIzm6kzjzDrhblBt1_0xlphT4isuQMu0,10146
@@ -166,6 +166,7 @@ camel/models/siliconflow_model.py,sha256=c5vk4zAhZVf8pDF1uh-iSa_v8d0QoPLuIN27Eem
 camel/models/stub_model.py,sha256=dygYoxemnWWaxEX21L8QyKe-c75ti2CK9HnTuyHL5vs,5160
 camel/models/togetherai_model.py,sha256=-YwZV1S1bkrX8jGguQI5dbtIHVuqhv96MoAcl33ptPo,6657
 camel/models/vllm_model.py,sha256=dzH4rYr2Se7cejk2hobblaW-s483uxPxb8976RQE8x0,6884
+camel/models/volcano_model.py,sha256=inYDiKOfGvq8o3XW4KVQIrXiZOhXQfB4HfCHGCWHPKs,3792
 camel/models/yi_model.py,sha256=V4sc9n8MAKVfjGO-NU0I8W4lGKdORSCbMV020SHT3R0,6180
 camel/models/zhipuai_model.py,sha256=o3uoTY30p1yUIklvoRMyr8JX39xZ5mLVKSTtUknW8nE,6517
 camel/models/reward/__init__.py,sha256=MqPN6wXh7Y1SoeNoFlYaMG6xHzLG0CYsv_3kB2atIQk,984
@@ -255,11 +256,12 @@ camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
 camel/terminators/response_terminator.py,sha256=n3G5KP6Oj7-7WlRN0yFcrtLpqAJKaKS0bmhrWlFfCgQ,4982
 camel/terminators/token_limit_terminator.py,sha256=YWv6ZR8R9yI2Qnf_3xES5bEE_O5bb2CxQ0EUXfMh34c,2118
-camel/toolkits/__init__.py,sha256=1MKp0Md0TtpI55l5EjX6vQg6nq7nUa996ARMLh2HEHc,3687
+camel/toolkits/__init__.py,sha256=SJ1Agk9YI_qH4gKX-pcvhl-m2t0Nori6R9Fs0gXReDs,3699
 camel/toolkits/arxiv_toolkit.py,sha256=d0Zn8LQGENhtlZ0BHlDr1pUV8xHOc6TOenAaKgbelu8,6279
 camel/toolkits/ask_news_toolkit.py,sha256=PAxio8I2eTau9TgOu1jyFC9fsHhvGb-aLIkroWPtwx4,23268
 camel/toolkits/audio_analysis_toolkit.py,sha256=LC0C6SEIwko8HqkT-C3ub6Ila2PfuIbKLBOEjrrF6BE,8552
 camel/toolkits/base.py,sha256=7WRovKrz380b25lYdwT-2FCXzS3dkllOjT53hmmCg_I,1999
+camel/toolkits/browser_toolkit.py,sha256=Pbw7CoiHPtbFQagmXvCUiVHihCXwaN6uUbwCAfC-jso,51016
 camel/toolkits/code_execution.py,sha256=seqTtjulBZXH4qd5m2YAXQaxyL2_n2ekmqsYB-wBxvw,4547
 camel/toolkits/dalle_toolkit.py,sha256=Usmw3JiJErLQgWSB1qKq_bOACNwbUTQPFc_EsVzTrGo,5115
 camel/toolkits/dappier_toolkit.py,sha256=_69IAmXE2QSbwGxnSEycaV2XrrkiM5wKI6heM7-4MfU,8175
@@ -285,7 +287,7 @@ camel/toolkits/page_script.js,sha256=gypbuQ_gn_oa3rQDoCN_q-kJ0jND1eSvY-30PufPZmQ
 camel/toolkits/pubmed_toolkit.py,sha256=vrd5GIhSYt9Z8EHaWkFb0x9i6_TP7pQZc7jlLHSol04,12180
 camel/toolkits/reddit_toolkit.py,sha256=cTqEq1CRaLq9XxUHkHCmd09tRzb5Mz_bUs2JV58ewrs,8012
 camel/toolkits/retrieval_toolkit.py,sha256=y_mQtknrSIDDXSyQb-4FY6ahV_mOxkBhDkA2eMIVnz0,3801
-camel/toolkits/search_toolkit.py,sha256=4yTYkook3E3Yb-EOaio2O6FBcvzIXlVVC4WOvNSaYcw,29881
+camel/toolkits/search_toolkit.py,sha256=KxJMB8tz37uyqlzHSK9X28hSZZMK793aOwkYT8jBnGc,32131
 camel/toolkits/semantic_scholar_toolkit.py,sha256=Kp-5rz99rkeUsUmk5ShQdNKJRGVs78hQvCNg-NQMFDk,11547
 camel/toolkits/slack_toolkit.py,sha256=n8cn3kZIc27B-2KMTRK6Nsdan37SwMqBiBi1PMtuUvQ,10744
 camel/toolkits/stripe_toolkit.py,sha256=1sCywkpo8mh4E_KwxFKLhAb-G5uZ47NXXQvcddThjqg,9781
@@ -295,7 +297,6 @@ camel/toolkits/twitter_toolkit.py,sha256=a2OLSJSW2wY7pOwOApb1qchZPXzH22Rbgm9Yd7-
 camel/toolkits/video_analysis_toolkit.py,sha256=lDAY6YP1zXykSxt8Qanf0WZR3l1p8c4akKPkaF5R3wU,15064
 camel/toolkits/video_download_toolkit.py,sha256=XjZICJTOG4dmKxfkHxYxmBMFESsOX51GvTeQXAQslMU,7104
 camel/toolkits/weather_toolkit.py,sha256=qHAMD56zqd5GWnEWiaA_0aBDwvgacdx0pAHScinY4GY,6965
-camel/toolkits/web_toolkit.py,sha256=DapiYYP95EFMVB1hU38a052nUPs4L5WdE25o_74h1Cw,48407
 camel/toolkits/whatsapp_toolkit.py,sha256=MBY92WLLptkXxnl4Ky5erGwI415XLFFGu9i2q6_b0oQ,5736
 camel/toolkits/zapier_toolkit.py,sha256=mgYxRGPw7_VZVj0xU9XwHewqFcV49eUjvuum_IHfuNs,6854
 camel/toolkits/open_api_specs/security_config.py,sha256=ZVnBa_zEifaE_ao2xsvV5majuJHpn2Tn7feMDOnj-eo,898
@@ -324,7 +325,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=VLWhAt857IFct3XepY5BNOIhyhDhfmODTezr9jhO_TI,2251
-camel/types/enums.py,sha256=h5UFYF6l2o1ITHClfAB79WU9GhbqFwHPTb3Lx3VYAgQ,34126
+camel/types/enums.py,sha256=b3KZqTbenkWSxC7QrgR_rYO1bV8tpcmTczwofOiByJA,34343
 camel/types/openai_types.py,sha256=8ZFzLe-zGmKNPfuVZFzxlxAX98lGf18gtrPhOgMmzus,2104
 camel/types/unified_model_type.py,sha256=GP5GYtA3RfvLsqnk1c4UcOaRKMFhjDgZrLr0ln6JFw8,4253
 camel/types/agents/__init__.py,sha256=cbvVkogPoZgcwZrgxLH6EtpGXk0kavF79nOic0Dc1vg,786
@@ -340,7 +341,7 @@ camel/verifiers/__init__.py,sha256=p6UEyvaOlwUQaFACGB4C07fL1xSnpTouElt19YRuneQ,9
 camel/verifiers/base.py,sha256=efWZV9g58IHzJ24U4zr109y34CaAi8tV9WZPMCzP3YI,12017
 camel/verifiers/models.py,sha256=hC6m_YxEX-mqi_tkCNZHZWLBWf04ZTyv5vfKR-BEyU4,2818
 camel/verifiers/python_verifier.py,sha256=bj-UGxeJTZzxVVa3a8IEQ1lNOpSaaW3JdGnUEoPeQD0,7519
-camel_ai-0.2.26.dist-info/METADATA,sha256=md1wlHHOxnVY3b-m7kkN8AbotAoAioTx8SshfLOm5BI,37992
-camel_ai-0.2.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.26.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.26.dist-info/RECORD,,
+camel_ai-0.2.27.dist-info/METADATA,sha256=B4jItSRHDPybZtfm-i0xxUq3z4HWUQ99OEdaRJ33Mfw,37992
+camel_ai-0.2.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.27.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.27.dist-info/RECORD,,