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

camel/environments/single_step.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import asyncio
 import random
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -58,6 +59,7 @@ class SingleStepEnv:
         self,
         dataset: Union[StaticDataset, BaseGenerator],
         verifier: BaseVerifier,
+        timeout: Optional[float] = 180.0,
         **kwargs,
     ) -> None:
         r"""Initialize the SingleStepEnv.
@@ -67,12 +69,15 @@ class SingleStepEnv:
                 problems from.
             verifier (BaseVerifier): Verifier used to evaluate LLM responses
                 against ground-truth answers.
+            timeout (Optional[float], optional): The execution timeout in
+                seconds. (default: :obj:`180.0`)
             **kwargs: Optional metadata or configuration values.
 
         Notes:
             This class assumes all interactions are single-step: one question,
             one LLM response, one reward.
         """
+        self._timeout = timeout
         self.dataset = dataset
         self.verifier = verifier
         self._metadata = kwargs
@@ -279,6 +284,7 @@ class SingleStepEnv:
                 or if `reset()` has not been called.
             ValueError: If invalid action format, duplicate indices,
                 or out-of-bounds indices are detected.
+            asyncio.TimeoutError: If the step execution exceeds the timeout.
         """
 
         if not self._is_setup:
@@ -307,18 +313,34 @@ class SingleStepEnv:
                 f"total batch size ({self.current_batch_size})"
             )
 
-        indices = [act.index for act in actions]
         proposed_solutions = [act.llm_response for act in actions]
-        ground_truths: List[str] = []
-        for idx in indices:
-            ground_truths.append(self._states[idx].final_answer)
+        ground_truths: List[str] = [
+            self._states[idx].final_answer for idx in indices
+        ]
 
         try:
-            verification_results = await self.verifier.verify_batch(
-                solutions=proposed_solutions,
-                reference_answers=ground_truths,  # type: ignore [arg-type]
-                raise_on_error=True,
+            verification_results = await asyncio.wait_for(
+                self.verifier.verify_batch(
+                    solutions=proposed_solutions,
+                    reference_answers=ground_truths,  # type: ignore [arg-type]
+                    raise_on_error=True,
+                ),
+                timeout=self._timeout,
+            )
+        except asyncio.TimeoutError as e:
+            logger.error(
+                f"Step verification timed out after {self._timeout}s: {e}"
             )
+            # Return timeout verification results
+            verification_results = [
+                VerificationResult(
+                    result="",
+                    status=VerificationOutcome.TIMEOUT,
+                    error_message=f"Verification timed out "
+                    f"after {self._timeout}s",
+                )
+                for _ in range(len(proposed_solutions))
+            ]
         except Exception as e:
             logger.error(f"Verification failed: {e}")
             # Return failed verification results with status=FAILURE
@@ -331,9 +353,55 @@ class SingleStepEnv:
                 for _ in range(len(proposed_solutions))
             ]
 
-        total_rewards, rewards_dicts = await self._compute_reward_batch(
-            proposed_solutions, verification_results
-        )
+        # Track which solutions have been processed and which have timed out
+        total_rewards = [0.0] * len(proposed_solutions)
+        rewards_dicts = [{"correctness": 0.0}] * len(proposed_solutions)
+
+        try:
+            # First try to compute all rewards with a timeout
+            computed_rewards, computed_rewards_dicts = await asyncio.wait_for(
+                self._compute_reward_batch(
+                    proposed_solutions, verification_results
+                ),
+                timeout=self._timeout,
+            )
+            # If successful, use all the computed values
+            total_rewards = computed_rewards
+            rewards_dicts = computed_rewards_dicts
+        except asyncio.TimeoutError as e:
+            logger.error(
+                f"Reward computation timed out after {self._timeout}s: {e}"
+            )
+            # Try to compute rewards one by one to identify which ones time out
+            for i, (solution, result) in enumerate(
+                zip(proposed_solutions, verification_results)
+            ):
+                try:
+                    individual_rewards = await asyncio.wait_for(
+                        self._compute_custom_reward(solution, result),
+                        timeout=self._timeout,
+                    )
+                    # If successful, calculate the reward for this solution
+                    correctness_reward = (
+                        self.ACCURACY_REWARD if result.status else 0.0
+                    )
+                    rewards_dict = {
+                        "correctness": correctness_reward,
+                        **individual_rewards,
+                    }
+                    total_rewards[i] = sum(rewards_dict.values())
+                    rewards_dicts[i] = rewards_dict
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        f"Reward computation for solution {i} timed out"
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Error computing reward for solution {i}: {e}"
+                    )
+        except Exception as e:
+            logger.error(f"Reward computation failed: {e}")
+
         # Create and return step results in batch
         step_results = [
             StepResult(

camel/models/azure_openai_model.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Type, Union
 
 from openai import AsyncAzureOpenAI, AsyncStream, AzureOpenAI, Stream
 from pydantic import BaseModel
@@ -27,6 +27,8 @@ from camel.types import (
 )
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
+AzureADTokenProvider = Callable[[], str]
+
 
 class AzureOpenAIModel(BaseModelBackend):
     r"""Azure OpenAI API in a unified BaseModelBackend interface.
@@ -46,6 +48,12 @@ class AzureOpenAIModel(BaseModelBackend):
             (default: :obj:`None`)
         azure_deployment_name (Optional[str], optional): The deployment name
             you chose when you deployed an azure model. (default: :obj:`None`)
+        azure_ad_token (Optional[str], optional): Your Azure Active Directory
+            token, https://www.microsoft.com/en-us/security/business/
+            identity-access/microsoft-entra-id. (default: :obj:`None`)
+        azure_ad_token_provider (Optional[AzureADTokenProvider], optional): A
+            function that returns an Azure Active Directory token, will be
+            invoked on every request. (default: :obj:`None`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter`
             will be used. (default: :obj:`None`)
@@ -68,6 +76,8 @@ class AzureOpenAIModel(BaseModelBackend):
         token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
         azure_deployment_name: Optional[str] = None,
+        azure_ad_token_provider: Optional["AzureADTokenProvider"] = None,
+        azure_ad_token: Optional[str] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
@@ -79,15 +89,19 @@ class AzureOpenAIModel(BaseModelBackend):
         )
 
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
-        self.azure_deployment_name = azure_deployment_name or os.environ.get(
+        self._azure_deployment_name = azure_deployment_name or os.environ.get(
             "AZURE_DEPLOYMENT_NAME"
         )
+        self._azure_ad_token = azure_ad_token or os.environ.get(
+            "AZURE_AD_TOKEN"
+        )
+        self.azure_ad_token_provider = azure_ad_token_provider
         if self.api_version is None:
             raise ValueError(
                 "Must provide either the `api_version` argument "
                 "or `AZURE_API_VERSION` environment variable."
             )
-        if self.azure_deployment_name is None:
+        if self._azure_deployment_name is None:
             raise ValueError(
                 "Must provide either the `azure_deployment_name` argument "
                 "or `AZURE_DEPLOYMENT_NAME` environment variable."
@@ -95,18 +109,22 @@ class AzureOpenAIModel(BaseModelBackend):
 
         self._client = AzureOpenAI(
             azure_endpoint=str(self._url),
-            azure_deployment=self.azure_deployment_name,
+            azure_deployment=self._azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
+            azure_ad_token=self._azure_ad_token,
+            azure_ad_token_provider=self.azure_ad_token_provider,
             timeout=self._timeout,
             max_retries=3,
         )
 
         self._async_client = AsyncAzureOpenAI(
             azure_endpoint=str(self._url),
-            azure_deployment=self.azure_deployment_name,
+            azure_deployment=self._azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
+            azure_ad_token=self._azure_ad_token,
+            azure_ad_token_provider=self.azure_ad_token_provider,
             timeout=self._timeout,
             max_retries=3,
         )
@@ -193,7 +211,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.chat.completions.create(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -209,7 +227,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.chat.completions.create(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -232,7 +250,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return self._client.beta.chat.completions.parse(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 
@@ -255,7 +273,7 @@ class AzureOpenAIModel(BaseModelBackend):
 
         return await self._async_client.beta.chat.completions.parse(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self._azure_deployment_name,  # type:ignore[arg-type]
             **request_config,
         )
 

camel/models/ollama_model.py

@@ -16,10 +16,13 @@ import subprocess
 from typing import Any, Dict, Optional, Union
 
 from camel.configs import OLLAMA_API_PARAMS, OllamaConfig
+from camel.logger import get_logger
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import BaseTokenCounter
 
+logger = get_logger(__name__)
+
 
 class OllamaModel(OpenAICompatibleModel):
     r"""Ollama service interface.
@@ -60,20 +63,22 @@ class OllamaModel(OpenAICompatibleModel):
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OllamaConfig().as_dict()
-        url = url or os.environ.get("OLLAMA_BASE_URL")
+        self._url = url or os.environ.get("OLLAMA_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        self._model_type = model_type
+
+        if not self._url:
+            self._start_server()
+
         super().__init__(
-            model_type=model_type,
+            model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key=api_key,
-            url=url,
+            api_key="Not_Used",
+            url=self._url,
             token_counter=token_counter,
             timeout=timeout,
         )
 
-        if not self._url:
-            self._start_server()
-
     def _start_server(self) -> None:
         r"""Starts the Ollama server in a subprocess."""
         try:
@@ -83,12 +88,12 @@ class OllamaModel(OpenAICompatibleModel):
                 stderr=subprocess.PIPE,
             )
             self._url = "http://localhost:11434/v1"
-            print(
+            logger.info(
                 f"Ollama server started on {self._url} "
-                f"for {self.model_type} model."
+                f"for {self._model_type} model."
             )
         except Exception as e:
-            print(f"Failed to start Ollama server: {e}.")
+            logger.error(f"Failed to start Ollama server: {e}.")
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/models/vllm_model.py

@@ -16,10 +16,13 @@ import subprocess
 from typing import Any, Dict, Optional, Union
 
 from camel.configs import VLLM_API_PARAMS, VLLMConfig
+from camel.logger import get_logger
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.types import ModelType
 from camel.utils import BaseTokenCounter
 
+logger = get_logger(__name__)
+
 
 # flake8: noqa: E501
 class VLLMModel(OpenAICompatibleModel):
@@ -62,18 +65,21 @@ class VLLMModel(OpenAICompatibleModel):
     ) -> None:
         if model_config_dict is None:
             model_config_dict = VLLMConfig().as_dict()
-        url = url or os.environ.get("VLLM_BASE_URL")
+        self._url = url or os.environ.get("VLLM_BASE_URL")
         timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        self._model_type = model_type
+
+        if not self._url:
+            self._start_server()
+
         super().__init__(
-            model_type=model_type,
+            model_type=self._model_type,
             model_config_dict=model_config_dict,
-            api_key=api_key,
-            url=url,
+            api_key="Not_Used",
+            url=self._url,
             token_counter=token_counter,
             timeout=timeout,
         )
-        if not self._url:
-            self._start_server()
 
     def _start_server(self) -> None:
         r"""Starts the vllm server in a subprocess."""
@@ -84,12 +90,12 @@ class VLLMModel(OpenAICompatibleModel):
                 stderr=subprocess.PIPE,
             )
             self._url = "http://localhost:8000/v1"
-            print(
+            logger.info(
                 f"vllm server started on {self._url} "
-                f"for {self.model_type} model."
+                f"for {self._model_type} model."
             )
         except Exception as e:
-            print(f"Failed to start vllm server: {e}.")
+            logger.error(f"Failed to start vllm server: {e}.")
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/runtime/__init__.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .base import BaseRuntime
 from .configs import TaskConfig
+from .daytona_runtime import DaytonaRuntime
 from .docker_runtime import DockerRuntime
 from .llm_guard_runtime import LLMGuardRuntime
 from .remote_http_runtime import RemoteHttpRuntime
@@ -28,4 +29,5 @@ __all__ = [
     "LLMGuardRuntime",
     "TaskConfig",
     "UbuntuDockerRuntime",
+    "DaytonaRuntime",
 ]

camel/runtime/daytona_runtime.py

@@ -0,0 +1,248 @@
+# ========= 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 inspect
+import json
+import os
+from functools import wraps
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from camel.logger import get_logger
+from camel.runtime import BaseRuntime
+from camel.toolkits.function_tool import FunctionTool
+
+logger = get_logger(__name__)
+
+
+class DaytonaRuntime(BaseRuntime):
+    r"""A runtime that executes functions in a Daytona sandbox environment.
+    Requires the Daytona server to be running and an API key configured.
+
+    Args:
+        api_key (Optional[str]): The Daytona API key for authentication. If not
+            provided, it will try to use the DAYTONA_API_KEY environment
+            variable. (default: :obj: `None`)
+        api_url (Optional[str]): The URL of the Daytona server. If not
+            provided, it will try to use the DAYTONA_API_URL environment
+            variable. If none is provided, it will use "http://localhost:8000".
+            (default: :obj: `None`)
+        language (Optional[str]): The programming language for the sandbox.
+            (default: :obj: `"python"`)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = None,
+        language: Optional[str] = "python",
+    ):
+        from daytona_sdk import Daytona, DaytonaConfig
+
+        super().__init__()
+        self.api_key = api_key or os.environ.get('DAYTONA_API_KEY')
+        self.api_url = api_url or os.environ.get('DAYTONA_API_URL')
+        self.language = language
+        self.config = DaytonaConfig(api_key=self.api_key, api_url=self.api_url)
+        self.daytona = Daytona(self.config)
+        self.sandbox = None
+        self.entrypoint: Dict[str, str] = dict()
+
+    def build(self) -> "DaytonaRuntime":
+        r"""Create and start a Daytona sandbox.
+
+        Returns:
+            DaytonaRuntime: The current runtime.
+        """
+        from daytona_sdk import CreateSandboxParams
+
+        try:
+            params = CreateSandboxParams(language=self.language)
+            self.sandbox = self.daytona.create(params)
+            if self.sandbox is None:
+                raise RuntimeError("Failed to create sandbox.")
+            logger.info(f"Sandbox created with ID: {self.sandbox.id}")
+        except Exception as e:
+            logger.error(f"Failed to create sandbox: {e!s}")
+            raise RuntimeError(f"Daytona sandbox creation failed: {e!s}")
+        return self
+
+    def _cleanup(self):
+        r"""Clean up the sandbox when exiting."""
+        if self.sandbox:
+            try:
+                self.daytona.remove(self.sandbox)
+                logger.info(f"Sandbox {self.sandbox.id} removed")
+                self.sandbox = None
+            except Exception as e:
+                logger.error(f"Failed to remove sandbox: {e!s}")
+
+    def add(
+        self,
+        funcs: Union[FunctionTool, List[FunctionTool]],
+        entrypoint: str,
+        arguments: Optional[Dict[str, Any]] = None,
+    ) -> "DaytonaRuntime":
+        r"""Add a function or list of functions to the runtime.
+
+        Args:
+            funcs (Union[FunctionTool, List[FunctionTool]]): The function or
+                list of functions to add.
+            entrypoint (str): The entrypoint for the function.
+            arguments (Optional[Dict[str, Any]]): The arguments for the
+                function. (default: :obj: `None`)
+
+        Returns:
+            DaytonaRuntime: The current runtime.
+        """
+        if not isinstance(funcs, list):
+            funcs = [funcs]
+        if arguments is not None:
+            entrypoint += json.dumps(arguments, ensure_ascii=False)
+
+        def make_wrapper(inner_func, func_name, func_code):
+            r"""Creates a wrapper for a function to execute it in the
+            Daytona sandbox.
+
+            Args:
+                inner_func (Callable): The function to wrap.
+                func_name (str): The name of the function.
+                func_code (str): The source code of the function.
+
+            Returns:
+                Callable: A wrapped function that executes in the sandbox.
+            """
+
+            @wraps(inner_func)
+            def wrapper(*args, **kwargs):
+                if not self.sandbox:
+                    raise RuntimeError(
+                        "Sandbox not initialized. Call build() first."
+                    )
+
+                try:
+                    for key, value in kwargs.items():
+                        if isinstance(value, BaseModel):
+                            kwargs[key] = value.model_dump()
+                    args_str = json.dumps(args, ensure_ascii=True)
+                    kwargs_str = json.dumps(kwargs, ensure_ascii=True)
+                except (TypeError, ValueError) as e:
+                    logger.error(f"Failed to serialize arguments: {e!s}")
+                    return {"error": f"Argument serialization failed: {e!s}"}
+
+                # Upload function code to the sandbox
+                script_path = f"/home/daytona/{func_name}.py"
+                try:
+                    self.sandbox.fs.upload_file(
+                        script_path, func_code.encode()
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to upload function {func_name}: {e!s}"
+                    )
+                    return {"error": f"Upload failed: {e!s}"}
+
+                exec_code = (
+                    f"import sys\n"
+                    f"sys.path.append('/home/daytona')\n"
+                    f"import json\n"
+                    f"from {func_name} import {func_name}\n"
+                    f"args = json.loads('{args_str}')\n"
+                    f"kwargs = json.loads('{kwargs_str}')\n"
+                    f"result = {func_name}(*args, **kwargs)\n"
+                    f"print(json.dumps(result) if result is not "
+                    f"None else 'null')"
+                )
+
+                # Execute the function in the sandbox
+                try:
+                    response = self.sandbox.process.code_run(exec_code)
+                    return (
+                        json.loads(response.result)
+                        if response.result
+                        else None
+                    )
+                except json.JSONDecodeError as e:
+                    logger.error(
+                        f"Failed to decode JSON response for {func_name}"
+                    )
+                    return {"error": f"JSON decoding failed: {e!s}"}
+                except Exception as e:
+                    logger.error(
+                        f"Failed to execute function {func_name}: {e!s}"
+                    )
+                    return {"error": f"Execution failed: {e!s}"}
+
+            return wrapper
+
+        for func in funcs:
+            inner_func = func.func
+            func_name = func.get_function_name()
+            func_code = inspect.getsource(inner_func).strip()
+
+            func.func = make_wrapper(inner_func, func_name, func_code)
+            self.tools_map[func_name] = func
+            self.entrypoint[func_name] = entrypoint
+
+        return self
+
+    def info(self) -> str:
+        r"""Get information about the current sandbox.
+
+        Returns:
+            str: Information about the sandbox.
+
+        Raises:
+            RuntimeError: If the sandbox is not initialized.
+        """
+        if self.sandbox is None:
+            raise RuntimeError("Failed to create sandbox.")
+        info = self.sandbox.info()
+        return (
+            f"Sandbox {info.name}:\n"
+            f"State: {info.state}\n"
+            f"Resources: {info.resources.cpu} CPU, {info.resources.memory} RAM"
+        )
+
+    def __del__(self):
+        r"""Clean up the sandbox when the object is deleted."""
+        if hasattr(self, 'sandbox'):
+            self._cleanup()
+
+    def stop(self) -> "DaytonaRuntime":
+        r"""Stop and remove the sandbox.
+
+        Returns:
+            DaytonaRuntime: The current runtime.
+        """
+        self._cleanup()
+        return self
+
+    def reset(self) -> "DaytonaRuntime":
+        r"""Reset the sandbox by stopping and rebuilding it.
+
+        Returns:
+            DaytonaRuntime: The current runtime.
+        """
+        return self.stop().build()
+
+    @property
+    def docs(self) -> str:
+        r"""Get the URL for the Daytona API documentation.
+
+        Returns:
+            str: The URL for the API documentation.
+        """
+        return "https://www.daytona.io/docs/python-sdk/daytona/"

camel/toolkits/__init__.py

@@ -68,6 +68,7 @@ from .pyautogui_toolkit import PyAutoGUIToolkit
 from .openai_agent_toolkit import OpenAIAgentToolkit
 from .searxng_toolkit import SearxNGToolkit
 from .jina_reranker_toolkit import JinaRerankerToolkit
+from .klavis_toolkit import KlavisToolkit
 
 
 __all__ = [
@@ -124,4 +125,5 @@ __all__ = [
     'OpenAIAgentToolkit',
     'SearxNGToolkit',
     'JinaRerankerToolkit',
+    'KlavisToolkit',
 ]

camel/toolkits/klavis_toolkit.py

@@ -0,0 +1,228 @@
+# ========= 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, List, Optional
+
+import requests
+
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer, api_keys_required, dependencies_required
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class KlavisToolkit(BaseToolkit):
+    r"""A class representing a toolkit for interacting with Klavis API.
+
+    This class provides methods for interacting with Klavis MCP server
+    instances, retrieving server information, managing tools, and handling
+    authentication.
+
+    Attributes:
+        api_key (str): The API key for authenticating with Klavis API.
+        base_url (str): The base URL for Klavis API endpoints.
+        timeout (Optional[float]): The timeout value for API requests
+            in seconds. If None, no timeout is applied.
+            (default: :obj:`None`)
+    """
+
+    @dependencies_required("requests")
+    @api_keys_required(
+        [
+            (None, "KLAVIS_API_KEY"),
+        ]
+    )
+    def __init__(self, timeout: Optional[float] = None) -> None:
+        r"""Initialize the KlavisToolkit with API client. The API key is
+        retrieved from environment variables.
+        """
+        super().__init__(timeout=timeout)
+        self.api_key = os.environ.get("KLAVIS_API_KEY")
+        self.base_url = "https://api.klavis.ai"
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        payload: Optional[Dict[str, Any]] = None,
+        additional_headers: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        r"""Make an HTTP request to the Klavis API.
+
+        Args:
+            method (str): HTTP method (e.g., 'GET', 'POST', 'DELETE').
+            endpoint (str): API endpoint path.
+            payload (Optional[Dict[str, Any]]): JSON payload for POST
+                requests.
+            additional_headers (Optional[Dict[str, str]]): Additional
+                headers to include in the request.
+
+        Returns:
+            Dict[str, Any]: The JSON response from the API or an error
+                dict.
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            'accept': 'application/json',
+            'Authorization': f'Bearer {self.api_key}',
+        }
+        if additional_headers:
+            headers.update(additional_headers)
+
+        logger.debug(
+            f"Making {method} request to {url} with payload: {payload}"
+        )
+
+        try:
+            response = requests.request(
+                method,
+                url,
+                headers=headers,
+                json=payload,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request failed for {method} {endpoint}: {e!s}")
+            return {"error": f"Request failed: {e!s}"}
+        except ValueError:
+            logger.error(f"Response for {method} {endpoint} is not valid JSON")
+            return {"error": "Response is not valid JSON"}
+
+    def create_server_instance(
+        self, server_name: str, user_id: str, platform_name: str
+    ) -> Dict[str, Any]:
+        r"""Create a Server-Sent Events (SSE) URL for a specified MCP server.
+
+        Args:
+            server_name (str): The name of the target MCP server.
+            user_id (str): The ID for the user requesting the server URL.
+            platform_name (str): The name of the platform associated
+              with the user.
+
+        Returns:
+            Dict[str, Any]: Response containing the server instance details.
+        """
+        endpoint = "/mcp-server/instance/create"
+        payload = {
+            "serverName": server_name,
+            "userId": user_id,
+            "platformName": platform_name,
+        }
+        headers = {'Content-Type': 'application/json'}
+        return self._request(
+            'POST', endpoint, payload=payload, additional_headers=headers
+        )
+
+    def get_server_instance(self, instance_id: str) -> Dict[str, Any]:
+        r"""Get details of a specific server connection instance.
+
+        Args:
+            instance_id (str): The ID of the connection instance whose status
+                is being checked.
+
+        Returns:
+            Dict[str, Any]: Details about the server instance.
+        """
+        endpoint = f"/mcp-server/instance/get/{instance_id}"
+        return self._request('GET', endpoint)
+
+    def delete_auth_data(self, instance_id: str) -> Dict[str, Any]:
+        r"""Delete authentication metadata for a specific server
+        connection instance.
+
+        Args:
+            instance_id (str): The ID of the connection instance to
+              delete auth for.
+
+        Returns:
+            Dict[str, Any]: Status response for the operation.
+        """
+        endpoint = f"/mcp-server/instance/delete-auth/{instance_id}"
+        return self._request('DELETE', endpoint)
+
+    def delete_server_instance(self, instance_id: str) -> Dict[str, Any]:
+        r"""Completely removes a server connection instance.
+
+        Args:
+            instance_id (str): The ID of the connection instance to delete.
+
+        Returns:
+            Dict[str, Any]: Status response for the operation.
+        """
+        endpoint = f"/mcp-server/instance/delete/{instance_id}"
+        return self._request('DELETE', endpoint)
+
+    def get_server_tools(self, server_name: str) -> Dict[str, Any]:
+        r"""Get list of tool names for a specific MCP server.
+
+        Args:
+            server_name (str): The name of the target MCP server.
+
+        Returns:
+            Dict[str, Any]: List of tools available for the specified server.
+        """
+        endpoint = f"/mcp-server/tools/{server_name}"
+        return self._request('GET', endpoint)
+
+    def get_all_servers(self) -> Dict[str, Any]:
+        r"""Get all MCP servers with their basic information.
+
+        Returns:
+            Dict[str, Any]: Information about all available MCP servers.
+        """
+        endpoint = "/mcp-server/servers"
+        return self._request('GET', endpoint)
+
+    def set_auth_token(
+        self, instance_id: str, auth_token: str
+    ) -> Dict[str, Any]:
+        r"""Sets an authentication token for a specific instance.
+
+        Args:
+            instance_id (str): The ID for the connection instance.
+            auth_token (str): The authentication token to save.
+
+        Returns:
+            Dict[str, Any]: Status response for the operation.
+        """
+        endpoint = "/mcp-server/instance/set-auth-token"
+        payload = {"instanceId": instance_id, "authToken": auth_token}
+        headers = {'Content-Type': 'application/json'}
+        return self._request(
+            'POST', endpoint, payload=payload, additional_headers=headers
+        )
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the functions
+        in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects representing
+                the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.create_server_instance),
+            FunctionTool(self.get_server_instance),
+            FunctionTool(self.delete_auth_data),
+            FunctionTool(self.delete_server_instance),
+            FunctionTool(self.get_server_tools),
+            FunctionTool(self.get_all_servers),
+            FunctionTool(self.set_auth_token),
+        ]

camel/toolkits/mcp_toolkit.py

@@ -60,6 +60,8 @@ class MCPClient(BaseToolkit):
         timeout (Optional[float]): Connection timeout. (default: :obj:`'None'`)
         headers (Dict[str, str]): Headers for the HTTP request.
             (default: :obj:`'None'`)
+        strict (Optional[bool]): Whether to enforce strict mode for the
+            function call. (default: :obj:`False`)
     """
 
     def __init__(
@@ -69,6 +71,7 @@ class MCPClient(BaseToolkit):
         env: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         headers: Optional[Dict[str, str]] = None,
+        strict: Optional[bool] = False,
     ):
         from mcp import Tool
 
@@ -78,6 +81,7 @@ class MCPClient(BaseToolkit):
         self.args = args or []
         self.env = env or {}
         self.headers = headers or {}
+        self.strict = strict
 
         self._mcp_tools: List[Tool] = []
         self._session: Optional['ClientSession'] = None
@@ -317,13 +321,15 @@ class MCPClient(BaseToolkit):
             "additionalProperties": False,
         }
 
+        # Because certain parameters in MCP may include keywords that are not
+        # supported by OpenAI, it is essential to set "strict" to False.
         return {
             "type": "function",
             "function": {
                 "name": mcp_tool.name,
                 "description": mcp_tool.description
                 or "No description provided.",
-                "strict": True,
+                "strict": self.strict,
                 "parameters": parameters,
             },
         }
@@ -363,6 +369,8 @@ class MCPToolkit(BaseToolkit):
             instances to manage.
         config_path (Optional[str]): Path to a JSON configuration file
             defining MCP servers.
+        strict (Optional[bool]): Whether to enforce strict mode for the
+            function call. (default: :obj:`False`)
 
     Note:
         Either `servers` or `config_path` must be provided. If both are
@@ -397,6 +405,7 @@ class MCPToolkit(BaseToolkit):
         self,
         servers: Optional[List[MCPClient]] = None,
         config_path: Optional[str] = None,
+        strict: Optional[bool] = False,
     ):
         super().__init__()
 
@@ -409,16 +418,22 @@ class MCPToolkit(BaseToolkit):
         self.servers: List[MCPClient] = servers or []
 
         if config_path:
-            self.servers.extend(self._load_servers_from_config(config_path))
+            self.servers.extend(
+                self._load_servers_from_config(config_path, strict)
+            )
 
         self._exit_stack = AsyncExitStack()
         self._connected = False
 
-    def _load_servers_from_config(self, config_path: str) -> List[MCPClient]:
+    def _load_servers_from_config(
+        self, config_path: str, strict: Optional[bool] = False
+    ) -> List[MCPClient]:
         r"""Loads MCP server configurations from a JSON file.
 
         Args:
             config_path (str): Path to the JSON configuration file.
+            strict (bool): Whether to enforce strict mode for the
+                function call. (default: :obj:`False`)
 
         Returns:
             List[MCPClient]: List of configured MCPClient instances.
@@ -462,6 +477,7 @@ class MCPToolkit(BaseToolkit):
                 args=cfg.get("args", []),
                 env={**os.environ, **cfg.get("env", {})},
                 timeout=cfg.get("timeout", None),
+                strict=strict,
             )
             all_servers.append(server)
 

camel/types/enums.py

@@ -105,6 +105,7 @@ class ModelType(UnifiedModelType, Enum):
     TOGETHER_LLAMA_4_SCOUT = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
 
     # PPIO platform models support tool calling
+    PPIO_DEEPSEEK_PROVER_V2_671B = "deepseek/deepseek-prover-v2-671b"
     PPIO_DEEPSEEK_R1_TURBO = "deepseek/deepseek-r1-turbo"
     PPIO_DEEPSEEK_V3_TURBO = "deepseek/deepseek-v3-turbo"
     PPIO_DEEPSEEK_R1_COMMUNITY = "deepseek/deepseek-r1/community"
@@ -716,6 +717,7 @@ class ModelType(UnifiedModelType, Enum):
     @property
     def is_ppio(self) -> bool:
         return self in {
+            ModelType.PPIO_DEEPSEEK_PROVER_V2_671B,
             ModelType.PPIO_DEEPSEEK_R1_TURBO,
             ModelType.PPIO_DEEPSEEK_V3_TURBO,
             ModelType.PPIO_DEEPSEEK_R1_COMMUNITY,
@@ -928,6 +930,7 @@ class ModelType(UnifiedModelType, Enum):
         }:
             return 14_336
         elif self in {
+            ModelType.PPIO_DEEPSEEK_PROVER_V2_671B,
             ModelType.NOVITA_DOLPHIN_MIXTRAL_8X22B,
         }:
             return 16_000

camel/utils/commons.py

@@ -352,6 +352,8 @@ def api_keys_required(
                 key_way = "https://platform.lingyiwanwu.com/docs"
             elif env_var_name == 'ZHIPUAI_API_KEY':
                 key_way = "https://www.zhipuai.cn/"
+            elif env_var_name == 'KLAVIS_API_KEY':
+                key_way = "https://www.klavis.ai/docs"
 
             if missing_keys:
                 raise ValueError(

{camel_ai-0.2.50.dist-info → camel_ai-0.2.52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.50
+Version: 0.2.52
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -36,6 +36,7 @@ Requires-Dist: dappier<0.4,>=0.3.3; extra == 'all'
 Requires-Dist: datacommons-pandas<0.0.4,>=0.0.3; extra == 'all'
 Requires-Dist: datacommons<2,>=1.4.3; extra == 'all'
 Requires-Dist: datasets<4,>=3; extra == 'all'
+Requires-Dist: daytona-sdk==0.14.0; extra == 'all'
 Requires-Dist: diffusers<0.26,>=0.25.0; extra == 'all'
 Requires-Dist: discord-py<3,>=2.3.2; extra == 'all'
 Requires-Dist: docker<8,>=7.1.0; extra == 'all'
@@ -170,6 +171,7 @@ Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'dev'
 Requires-Dist: uv==0.6.5; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: agentops<0.4,>=0.3.21; extra == 'dev-tools'
+Requires-Dist: daytona-sdk==0.14.0; extra == 'dev-tools'
 Requires-Dist: docker<8,>=7.1.0; extra == 'dev-tools'
 Requires-Dist: e2b-code-interpreter<2,>=1.0.3; extra == 'dev-tools'
 Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'

{camel_ai-0.2.50.dist-info → camel_ai-0.2.52.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=m9QPqmOwrIW6yXBMb1giOGlXCTU-o0GmvPQqmONLr2w,912
+camel/__init__.py,sha256=4hOpc6x6mtK5OsacUZpZFBla8BA-4Ru7OKm_aTxLJso,912
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=9X09UmxI2JqQnhrFfnZ3B9EzFmVfdSWQcjLWTIXKXe0,4962
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -114,7 +114,7 @@ camel/embeddings/vlm_embedding.py,sha256=HZFdcz1YzkFPzMj45_jaCVmDQJyccoXN561aLWl
 camel/environments/__init__.py,sha256=fwk74TJO5OaOhL5Pmiz6s6h77B_-DGav5m_HbfS1oUQ,1053
 camel/environments/models.py,sha256=jVcCyU7xObKoWPnkshmPqyyKi3AOiMVVtUZA-tWEYUU,4194
 camel/environments/multi_step.py,sha256=HPIH2W-iWsmtDLeN1gjxo7LoAnMQQZzdmfjhmRoBAxg,8534
-camel/environments/single_step.py,sha256=TxEVoQVqyGgBbb3OiyOSTEyJh7NqsJmrUOndJLrFWH4,20055
+camel/environments/single_step.py,sha256=zrAXLOBGGKQFnGENasUnmFO_T-rjppGPK2CRBLGu7aQ,23019
 camel/environments/tic_tac_toe.py,sha256=axRDN9yUVH8PzACkD6zenWiQKFDaupGsQ7NmSvbJCIc,19080
 camel/extractors/__init__.py,sha256=lgtDl8zWvN826fJVKqRv05w556YZ-EdrHwdzKphywgA,1097
 camel/extractors/base.py,sha256=3jvuZpq27nlADDCX3GfubOpeb_zt-E9rzxF3x4lYm8s,10404
@@ -163,7 +163,7 @@ camel/models/_utils.py,sha256=hob1ehnS5xZitMCdYToHVgaTB55JnaP4_DSWnTEfVsg,2045
 camel/models/aiml_model.py,sha256=HO_jRvMN2WEVlZRc_UG-OoZ1hv8sEiO5j_7BBKuGlp0,3753
 camel/models/anthropic_model.py,sha256=0jilp8dBrk1JAP0dkw_YX21uL3_81ZGL0qmKZiAI2w0,4331
 camel/models/aws_bedrock_model.py,sha256=cpY66Wcwb-clNf0TCch9WI8au3_GGxHBYUd09rGQi_U,4353
-camel/models/azure_openai_model.py,sha256=psxSx1R9dCRw-jWy58lwhUjPFP01UrhCJ7sHeveu_fo,11057
+camel/models/azure_openai_model.py,sha256=-_c4SjYOA-BM6n01FuaaQ8m_QucG8_DbV_zFozaesDg,12067
 camel/models/base_audio_model.py,sha256=_VUWh1L3rh8mldNvM5R6jBOKtvmTeBKJyRxAdPJmPlY,3324
 camel/models/base_model.py,sha256=eDeUlgH8iS0Stk6zommzqce4dfD4Qj51tvgXUs5ys4s,14474
 camel/models/cohere_model.py,sha256=OgRHxlPrei-NT5UVDFf6lVR88k6eKnmcZMyFj4XmONE,14880
@@ -183,7 +183,7 @@ camel/models/nemotron_model.py,sha256=APYCcpDMytZNsXFhdcLnO8bttc6pQWAo6e5h2VTJVw
 camel/models/netmind_model.py,sha256=EmyKBupEQlciI69ba_oF36RNT7EJYqGLtMJ_QVZPFaE,3959
 camel/models/novita_model.py,sha256=tU8RXsV-4wYmQhXcZkPXdlXRvLwsnj_pEJVSxnhXiXc,3921
 camel/models/nvidia_model.py,sha256=XkHBZJ94nkYB1j9AgyPsorYfvgO1Ys6S6_z3Qh3vrhM,3766
-camel/models/ollama_model.py,sha256=daPWcHSTt4Krre9Vy5_SWK1rNwWZb6Hk_7cH9PiM5xA,4275
+camel/models/ollama_model.py,sha256=sc49XZT9KQeUWjvLqXn17kKa1jgAyAHiy2MHiUjQrzw,4416
 camel/models/openai_audio_models.py,sha256=BSixkXlc8xirQLl2qCla-g6_y9wDLnMZVHukHrhzw98,13344
 camel/models/openai_compatible_model.py,sha256=PmNMQKXMPk-4HYiDqn8dJ8cMH8ukl4MAPVtqWyWDnfY,10481
 camel/models/openai_model.py,sha256=atxW2N6xcA9kqGAE6moqKYZD3IxIxOjmKcQnBs7ff7w,12826
@@ -196,7 +196,7 @@ camel/models/sglang_model.py,sha256=GsRxh3yrOQRu5gJgPdES289vCiiUHoBvKw-YZ-iwlI0,
 camel/models/siliconflow_model.py,sha256=mdVcf-5N-ZWS5qGL2pq7TsAsvlhCXxL6jxavxeElFRw,4432
 camel/models/stub_model.py,sha256=JvjeEkXS7RMcR_UA_64a3T6S0QALUhOaMQs-aI7Etug,5955
 camel/models/togetherai_model.py,sha256=16q-0jsO5HIy9K0elSlR-aA9EDN5VhPXPGBG6cU1t1w,3937
-camel/models/vllm_model.py,sha256=vSgIuddQBvduDr5suh5jSG38ug7SCEFFHbERFrwcw8c,4351
+camel/models/vllm_model.py,sha256=bB4-pkXnMD6aGXumCYpJY62JCWRMuK57kIpzYdK3mJQ,4493
 camel/models/volcano_model.py,sha256=Lsg0BDVPaP50vRNW0D37liEsa71RmvapBxN_JCcHe-4,3674
 camel/models/watsonx_model.py,sha256=2jIfx5dGBxxVqaZIUBTd01mtw_XuCUzqtcmKpubibME,9136
 camel/models/yi_model.py,sha256=hZ_LYZWYhDkjBA3UcDiY2sGPFH3jEbxHaRy6IMvLYZ4,3742
@@ -235,10 +235,11 @@ camel/retrievers/bm25_retriever.py,sha256=feQgn3dwnbQG8H7KSbFzjaFAw3KtKObfoyA6gm
 camel/retrievers/cohere_rerank_retriever.py,sha256=tzMS3HG4wD3gbIAVcHsC5fTbFxuiNrT4qJ10oJMJ0BA,4032
 camel/retrievers/hybrid_retrival.py,sha256=2ySeXnLunoBHarqssijjxn7bAQGypAXX6QdzxYstreM,9466
 camel/retrievers/vector_retriever.py,sha256=Fp6k7FkoeUXLiUokqsMIO74Dh2mJcmJP2TrCP-6Ekcc,11051
-camel/runtime/__init__.py,sha256=aMUmX2qBmO4wCVJp4pIjx2Zed88HcrUzimfJvnz9ZZg,1207
+camel/runtime/__init__.py,sha256=bFbqDIST69V6LC_Oe5YBz-8qlUaJt4zWGFFT0ctiMLI,1273
 camel/runtime/api.py,sha256=JfkHqQ_Xs3ZNl4TXC_obV3Ymi21ltP1LAkXzBA3H_Lo,3227
 camel/runtime/base.py,sha256=KKBLO6PwWEWBXbYaVtO9JXqBT8110iYpMhgNSIxQvYQ,1512
 camel/runtime/configs.py,sha256=7swJ6shD5CAnQj16D_j1BWJjRDHLue8_BJcQ1-YiKJI,2431
+camel/runtime/daytona_runtime.py,sha256=bhQyn1ZRNcDg-gDWOzjGszMl1keL90xnvLZ-EH--DaU,9165
 camel/runtime/docker_runtime.py,sha256=Q1eN4rWxDB4PF_G7nq64Rk7xhRZgAhNqmlxsu6YMdCg,13578
 camel/runtime/llm_guard_runtime.py,sha256=n8MImZsYLXCfr6LG6BFvlC75Al16GMJMvGp4vFsob6E,8101
 camel/runtime/remote_http_runtime.py,sha256=Emgz2xz4vbwCvErDk6Ni25aDA3EBXoPOQ7U70AgVg0w,6669
@@ -292,7 +293,7 @@ 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=AQqFlCEzz9lb_eSgSNow0G9BXZyh5hD4vPaDJEz9w5I,4366
+camel/toolkits/__init__.py,sha256=sGw0LKAG4WNVWL7NUYlQH0f0IE_gm2VMSPbkSLCJ-10,4429
 camel/toolkits/arxiv_toolkit.py,sha256=Bs2-K1yfmqhEhHoQ0j00KoI8LpOd8M3ApXcvI_-ApVw,6303
 camel/toolkits/ask_news_toolkit.py,sha256=WfWaqwEo1Apbil3-Rb5y65Ws43NU4rAFWZu5VHe4los,23448
 camel/toolkits/audio_analysis_toolkit.py,sha256=dnDtQJbztVBwBpamSyCfigPw2GBnDAfi3fOPgql4Y50,8941
@@ -312,9 +313,10 @@ camel/toolkits/google_scholar_toolkit.py,sha256=WQ9a0HQr0vro1Uo1m--alCUXvMmaHVKe
 camel/toolkits/human_toolkit.py,sha256=ZbhXPA0G3mQkcNW_jPwywReAft2pIJG0WkVXOG48s1w,2328
 camel/toolkits/image_analysis_toolkit.py,sha256=gnbX2by7_pxPpjUEY8bOj1tV-hGC3mwqEvQRMXyZ9TM,7535
 camel/toolkits/jina_reranker_toolkit.py,sha256=U-V9qZ7SKP3SPTh_0CsE7ZKNqS9jNkmKYsIN1Mk-vFY,8118
+camel/toolkits/klavis_toolkit.py,sha256=L-OiGwgaIue8QiIijNlvGbgtwjGUszLqs9bVRW5md7c,8244
 camel/toolkits/linkedin_toolkit.py,sha256=wn4eXwYYlVA7doTna7k7WYhUqTBF83W79S-UJs_IQr0,8065
 camel/toolkits/math_toolkit.py,sha256=KdI8AJ9Dbq5cfWboAYJUYgSkmADMCO5eZ6yqYkWuiIQ,3686
-camel/toolkits/mcp_toolkit.py,sha256=4eweKFF3M9WOGroJCdsNBdyp8KUZJfaXLPGVYFu9kUQ,18275
+camel/toolkits/mcp_toolkit.py,sha256=Vzw6ACr4z7Emzdobfw8diPB3Wd2G_SDfUKlJoS9lsxI,19024
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
 camel/toolkits/meshy_toolkit.py,sha256=NbgdOBD3FYLtZf-AfonIv6-Q8-8DW129jsaP1PqI2rs,7126
 camel/toolkits/mineru_toolkit.py,sha256=vRX9LholLNkpbJ6axfEN4pTG85aWb0PDmlVy3rAAXhg,6868
@@ -368,14 +370,14 @@ 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=dNrNNA1WIamFxNahGXCuKucZYd0rGLoZNx6ZllUXze8,56612
+camel/types/enums.py,sha256=zisVc5hTqrbrwtH3lijzalP9zMI2pMW62-SIDizn8EQ,56786
 camel/types/openai_types.py,sha256=8ZFzLe-zGmKNPfuVZFzxlxAX98lGf18gtrPhOgMmzus,2104
 camel/types/unified_model_type.py,sha256=TpiUmJ3IuX8LNLtTUeUcVM7U82r4ClSq3ZQlNX3ODKs,5351
 camel/types/agents/__init__.py,sha256=cbvVkogPoZgcwZrgxLH6EtpGXk0kavF79nOic0Dc1vg,786
 camel/types/agents/tool_calling_record.py,sha256=qa-vLyKvYzWprRkFFl1928xaw9CnfacIebHaqM-oY3s,1814
 camel/utils/__init__.py,sha256=0rN9DFjUh7Gv6HIJBhm9edmLKecK-89j9q0TC4ABsZY,2737
 camel/utils/async_func.py,sha256=KqoktGSWjZBuAMQ2CV0X6FRgHGlzCKLfeaWvp-f1Qz8,1568
-camel/utils/commons.py,sha256=WnLInwlT3Cn-M2qhqI_GRX33A0uZaRnnRWvJ248JrrI,33587
+camel/utils/commons.py,sha256=dzZ1zR2RIb6MCCSw_jfil36BGcVe0q4Jy2t2y2T2Vwg,33693
 camel/utils/constants.py,sha256=cqnxmpUeOwrtsR-tRO4bbOc6ZP19TLj7avjm3FONMJs,1410
 camel/utils/deduplication.py,sha256=UHikAtOW1TTDunf2t_wa2kFbmkrXWf7HfOKwLvwCxzo,8958
 camel/utils/filename.py,sha256=HYNc1wbSCgNR1CN21cwHxdAhpnsf5ySJ6jUDfeqOK20,2532
@@ -392,7 +394,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.50.dist-info/METADATA,sha256=zXfL_GgIP8CyRTUax_ubD_fr7bAXVcpTl1R24A1yO0Q,43892
-camel_ai-0.2.50.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.50.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.50.dist-info/RECORD,,
+camel_ai-0.2.52.dist-info/METADATA,sha256=MhuSMpOxRFCshNY5GspU1s-rIkuzPYzsRH921CgJoSA,44000
+camel_ai-0.2.52.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.52.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.52.dist-info/RECORD,,