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

camel/toolkits/math_toolkit.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import warnings
 from typing import List
 
 from camel.toolkits.base import BaseToolkit
@@ -27,7 +28,7 @@ class MathToolkit(BaseToolkit):
     addition, subtraction, multiplication, division, and rounding.
     """
 
-    def add(self, a: float, b: float) -> float:
+    def math_add(self, a: float, b: float) -> float:
         r"""Adds two numbers.
 
         Args:
@@ -39,7 +40,7 @@ class MathToolkit(BaseToolkit):
         """
         return a + b
 
-    def sub(self, a: float, b: float) -> float:
+    def math_subtract(self, a: float, b: float) -> float:
         r"""Do subtraction between two numbers.
 
         Args:
@@ -51,7 +52,9 @@ class MathToolkit(BaseToolkit):
         """
         return a - b
 
-    def multiply(self, a: float, b: float, decimal_places: int = 2) -> float:
+    def math_multiply(
+        self, a: float, b: float, decimal_places: int = 2
+    ) -> float:
         r"""Multiplies two numbers.
 
         Args:
@@ -65,7 +68,9 @@ class MathToolkit(BaseToolkit):
         """
         return round(a * b, decimal_places)
 
-    def divide(self, a: float, b: float, decimal_places: int = 2) -> float:
+    def math_divide(
+        self, a: float, b: float, decimal_places: int = 2
+    ) -> float:
         r"""Divides two numbers.
 
         Args:
@@ -79,7 +84,7 @@ class MathToolkit(BaseToolkit):
         """
         return round(a / b, decimal_places)
 
-    def round(self, a: float, decimal_places: int = 0) -> float:
+    def math_round(self, a: float, decimal_places: int = 0) -> float:
         r"""Rounds a number to a specified number of decimal places.
 
         Args:
@@ -101,9 +106,58 @@ class MathToolkit(BaseToolkit):
                 representing the functions in the toolkit.
         """
         return [
-            FunctionTool(self.add),
-            FunctionTool(self.sub),
-            FunctionTool(self.multiply),
-            FunctionTool(self.divide),
-            FunctionTool(self.round),
+            FunctionTool(self.math_add),
+            FunctionTool(self.math_subtract),
+            FunctionTool(self.math_multiply),
+            FunctionTool(self.math_divide),
+            FunctionTool(self.math_round),
         ]
+
+    # Deprecated method aliases for backward compatibility
+    def add(self, *args, **kwargs):
+        r"""Deprecated: Use math_add instead."""
+        warnings.warn(
+            "add is deprecated. Use math_add instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.math_add(*args, **kwargs)
+
+    def sub(self, *args, **kwargs):
+        r"""Deprecated: Use math_subtract instead."""
+        warnings.warn(
+            "sub is deprecated. Use math_subtract instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.math_subtract(*args, **kwargs)
+
+    def multiply(self, *args, **kwargs):
+        r"""Deprecated: Use math_multiply instead."""
+        warnings.warn(
+            "multiply is deprecated. Use math_multiply instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.math_multiply(*args, **kwargs)
+
+    def divide(self, *args, **kwargs):
+        r"""Deprecated: Use math_divide instead."""
+        warnings.warn(
+            "divide is deprecated. Use math_divide instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.math_divide(*args, **kwargs)
+
+    def round(self, *args, **kwargs):
+        r"""Deprecated: Use math_round instead. Note: This was shadowing
+        Python's built-in round().
+        """
+        warnings.warn(
+            "round is deprecated. Use math_round instead. This was "
+            "shadowing Python's built-in round().",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.math_round(*args, **kwargs)

camel/toolkits/mcp_toolkit.py

@@ -220,26 +220,34 @@ class MCPToolkit(BaseToolkit):
         self._exit_stack = AsyncExitStack()
 
         try:
-            # Connect to all clients using AsyncExitStack
-            for i, client in enumerate(self.clients):
-                try:
-                    # Use MCPClient directly as async context manager
-                    await self._exit_stack.enter_async_context(client)
-                    msg = f"Connected to client {i+1}/{len(self.clients)}"
-                    logger.debug(msg)
-                except Exception as e:
-                    logger.error(f"Failed to connect to client {i+1}: {e}")
-                    # AsyncExitStack will handle cleanup of already connected
-                    await self._exit_stack.aclose()
-                    self._exit_stack = None
-                    error_msg = f"Failed to connect to client {i+1}: {e}"
-                    raise MCPConnectionError(error_msg) from e
+            # Apply timeout to the entire connection process
+            import asyncio
+
+            timeout_seconds = self.timeout or 30.0
+            await asyncio.wait_for(
+                self._connect_all_clients(), timeout=timeout_seconds
+            )
 
             self._is_connected = True
             msg = f"Successfully connected to {len(self.clients)} MCP servers"
             logger.info(msg)
             return self
 
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            self._is_connected = False
+            if self._exit_stack:
+                await self._exit_stack.aclose()
+                self._exit_stack = None
+
+            timeout_seconds = self.timeout or 30.0
+            error_msg = (
+                f"Connection timeout after {timeout_seconds}s. "
+                f"One or more MCP servers are not responding. "
+                f"Please check if the servers are running and accessible."
+            )
+            logger.error(error_msg)
+            raise MCPConnectionError(error_msg)
+
         except Exception:
             self._is_connected = False
             if self._exit_stack:
@@ -247,6 +255,23 @@ class MCPToolkit(BaseToolkit):
                 self._exit_stack = None
             raise
 
+    async def _connect_all_clients(self):
+        r"""Connect to all clients sequentially."""
+        # Connect to all clients using AsyncExitStack
+        for i, client in enumerate(self.clients):
+            try:
+                # Use MCPClient directly as async context manager
+                await self._exit_stack.enter_async_context(client)
+                msg = f"Connected to client {i+1}/{len(self.clients)}"
+                logger.debug(msg)
+            except Exception as e:
+                logger.error(f"Failed to connect to client {i+1}: {e}")
+                # AsyncExitStack will cleanup already connected clients
+                await self._exit_stack.aclose()
+                self._exit_stack = None
+                error_msg = f"Failed to connect to client {i+1}: {e}"
+                raise MCPConnectionError(error_msg) from e
+
     async def disconnect(self):
         r"""Disconnect from all MCP servers."""
         if not self._is_connected:

camel/toolkits/minimax_mcp_toolkit.py

@@ -0,0 +1,195 @@
+# ========= 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
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class MinimaxMCPToolkit(BaseToolkit):
+    r"""MinimaxMCPToolkit provides an interface for interacting with
+    MiniMax AI services using the MiniMax MCP server.
+
+    This toolkit enables access to MiniMax's multimedia generation
+    capabilities including text-to-audio, voice cloning, video generation,
+    image generation, music generation, and voice design.
+
+    This toolkit can be used as an async context manager for automatic
+    connection management:
+
+        # Using explicit API key
+        async with MinimaxMCPToolkit(api_key="your-key") as toolkit:
+            tools = toolkit.get_tools()
+            # Toolkit is automatically disconnected when exiting
+
+        # Using environment variables (recommended for security)
+        # Set MINIMAX_API_KEY=your-key in environment
+        async with MinimaxMCPToolkit() as toolkit:
+            tools = toolkit.get_tools()
+
+    Environment Variables:
+        MINIMAX_API_KEY: MiniMax API key for authentication
+        MINIMAX_API_HOST: API host URL (default: https://api.minimax.io)
+        MINIMAX_MCP_BASE_PATH: Base path for output files
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_host: str = "https://api.minimax.io",
+        base_path: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the MinimaxMCPToolkit.
+
+        Args:
+            api_key (Optional[str]): MiniMax API key for authentication.
+                If None, will attempt to read from MINIMAX_API_KEY
+                environment variable. (default: :obj:`None`)
+            api_host (str): MiniMax API host URL. Can be either
+                "https://api.minimax.io" (global) or
+                "https://api.minimaxi.com" (mainland China).
+                Can also be read from MINIMAX_API_HOST environment variable.
+                (default: :obj:`"https://api.minimax.io"`)
+            base_path (Optional[str]): Base path for output files.
+                If None, uses current working directory. Can also be read
+                from MINIMAX_MCP_BASE_PATH environment variable.
+                (default: :obj:`None`)
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        # Read API key from parameter or environment variable
+        if api_key is None:
+            api_key = os.getenv("MINIMAX_API_KEY")
+
+        if not api_key:
+            raise ValueError(
+                "api_key must be provided either as a parameter or through "
+                "the MINIMAX_API_KEY environment variable"
+            )
+
+        # Read API host from environment variable if not overridden
+        env_api_host = os.getenv("MINIMAX_API_HOST")
+        if env_api_host:
+            api_host = env_api_host
+
+        # Read base path from environment variable if not provided
+        if base_path is None:
+            base_path = os.getenv("MINIMAX_MCP_BASE_PATH")
+
+        # Set up environment variables for the MCP server
+        env = {
+            "MINIMAX_API_KEY": api_key,
+            "MINIMAX_API_HOST": api_host,
+        }
+
+        if base_path:
+            env["MINIMAX_MCP_BASE_PATH"] = base_path
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "minimax": {
+                        "command": "uvx",
+                        "args": ["minimax-mcp", "-y"],
+                        "env": env,
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the MiniMax MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the MiniMax MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    @property
+    def is_connected(self) -> bool:
+        r"""Check if the toolkit is connected to the MCP server.
+
+        Returns:
+            bool: True if connected, False otherwise.
+        """
+        return self._mcp_toolkit.is_connected
+
+    async def __aenter__(self) -> "MinimaxMCPToolkit":
+        r"""Async context manager entry point.
+
+        Returns:
+            MinimaxMCPToolkit: The connected toolkit instance.
+
+        Example:
+            async with MinimaxMCPToolkit(api_key="your-key") as toolkit:
+                tools = toolkit.get_tools()
+        """
+        await self.connect()
+        return self
+
+    async def __aexit__(self, _exc_type, _exc_val, _exc_tb) -> None:
+        r"""Async context manager exit point.
+
+        Automatically disconnects from the MiniMax MCP server.
+        """
+        await self.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the MiniMax MCP server.
+
+        This includes tools for:
+        - Text-to-audio conversion
+        - Voice cloning
+        - Video generation
+        - Image generation
+        - Music generation
+        - Voice design
+
+        Returns:
+            List[FunctionTool]: List of available MiniMax AI tools.
+        """
+        return self._mcp_toolkit.get_tools()
+
+    def get_text_tools(self) -> str:
+        r"""Returns a string containing the descriptions of the tools.
+
+        Returns:
+            str: A string containing the descriptions of all MiniMax tools.
+        """
+        return self._mcp_toolkit.get_text_tools()
+
+    async def call_tool(
+        self, tool_name: str, tool_args: Dict[str, Any]
+    ) -> Any:
+        r"""Call a MiniMax tool by name.
+
+        Args:
+            tool_name (str): Name of the tool to call.
+            tool_args (Dict[str, Any]): Arguments to pass to the tool.
+
+        Returns:
+            Any: The result of the tool call.
+        """
+        return await self._mcp_toolkit.call_tool(tool_name, tool_args)

camel/toolkits/search_toolkit.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
+import warnings
 from typing import Any, Dict, List, Literal, Optional, TypeAlias, Union, cast
 
 import requests
@@ -683,7 +684,7 @@ class SearchToolkit(BaseToolkit):
             responses.append({"error": f"google search failed: {e!s}"})
         return responses
 
-    def tavily_search(
+    def search_tavily(
         self, query: str, number_of_result_pages: int = 10, **kwargs
     ) -> List[Dict[str, Any]]:
         r"""Use Tavily Search API to search information for the given query.
@@ -1358,7 +1359,7 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.search_linkup),
             FunctionTool(self.search_google),
             FunctionTool(self.search_duckduckgo),
-            FunctionTool(self.tavily_search),
+            FunctionTool(self.search_tavily),
             FunctionTool(self.search_brave),
             FunctionTool(self.search_bocha),
             FunctionTool(self.search_baidu),
@@ -1367,3 +1368,13 @@ class SearchToolkit(BaseToolkit):
             FunctionTool(self.search_alibaba_tongxiao),
             FunctionTool(self.search_metaso),
         ]
+
+    # Deprecated method alias for backward compatibility
+    def tavily_search(self, *args, **kwargs):
+        r"""Deprecated: Use search_tavily instead for consistency with other search methods."""
+        warnings.warn(
+            "tavily_search is deprecated. Use search_tavily instead for consistency.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.search_tavily(*args, **kwargs)

camel/toolkits/terminal_toolkit.py

@@ -66,6 +66,9 @@ class TerminalToolkit(BaseToolkit):
             connecting them to the terminal's standard input. This is useful
             for commands that require user input, like `ssh`. Interactive mode
             is only supported on macOS and Linux. (default: :obj:`False`)
+        log_dir (Optional[str]): Custom directory path for log files.
+            If None, logs are saved to the current working directory.
+            (default: :obj:`None`)
 
     Note:
         Most functions are compatible with Unix-based systems (macOS, Linux).
@@ -83,6 +86,7 @@ class TerminalToolkit(BaseToolkit):
         clone_current_env: bool = False,
         safe_mode: bool = True,
         interactive: bool = False,
+        log_dir: Optional[str] = None,
     ):
         # Store timeout before calling super().__init__
         self._timeout = timeout
@@ -99,6 +103,7 @@ class TerminalToolkit(BaseToolkit):
         self.use_shell_mode = use_shell_mode
         self._human_takeover_active = False
         self.interactive = interactive
+        self.log_dir = log_dir
 
         self.python_executable = sys.executable
         self.is_macos = platform.system() == 'Darwin'
@@ -153,8 +158,13 @@ class TerminalToolkit(BaseToolkit):
         r"""Set up file output to replace GUI, using a fixed file to simulate
         terminal.
         """
-
-        self.log_file = os.path.join(os.getcwd(), "camel_terminal.txt")
+        # Use custom log directory if provided, otherwise use current directory
+        if self.log_dir:
+            # Create the log directory if it doesn't exist
+            os.makedirs(self.log_dir, exist_ok=True)
+            self.log_file = os.path.join(self.log_dir, "camel_terminal.txt")
+        else:
+            self.log_file = os.path.join(os.getcwd(), "camel_terminal.txt")
 
         # Inform the user
         logger.info(f"Terminal output will be redirected to: {self.log_file}")

camel/toolkits/video_analysis_toolkit.py

@@ -195,18 +195,24 @@ class VideoAnalysisToolkit(BaseToolkit):
         destroyed.
         """
         # Clean up temporary files
-        for temp_file in self._temp_files:
-            if os.path.exists(temp_file):
-                try:
-                    os.remove(temp_file)
-                    logger.debug(f"Removed temporary file: {temp_file}")
-                except OSError as e:
-                    logger.warning(
-                        f"Failed to remove temporary file {temp_file}: {e}"
-                    )
+        if hasattr(self, '_temp_files'):
+            for temp_file in self._temp_files:
+                if os.path.exists(temp_file):
+                    try:
+                        os.remove(temp_file)
+                        logger.debug(f"Removed temporary file: {temp_file}")
+                    except OSError as e:
+                        logger.warning(
+                            f"Failed to remove temporary file {temp_file}: {e}"
+                        )
 
         # Clean up temporary directory if needed
-        if self._cleanup and os.path.exists(self._working_directory):
+        if (
+            hasattr(self, '_cleanup')
+            and self._cleanup
+            and hasattr(self, '_working_directory')
+            and os.path.exists(self._working_directory)
+        ):
             try:
                 import sys
 

camel/types/enums.py

@@ -64,6 +64,8 @@ class ModelType(UnifiedModelType, Enum):
     AWS_CLAUDE_OPUS_4 = "anthropic.claude-opus-4-20250514-v1:0"
     AWS_CLAUDE_OPUS_4_1 = "anthropic.claude-opus-4-1-20250805-v1:0"
 
+    AMD_GPT4 = "dvue-aoai-001-gpt-4.1"
+
     GLM_4 = "glm-4"
     GLM_4V = "glm-4v"
     GLM_4V_FLASH = "glm-4v-flash"
@@ -87,6 +89,15 @@ class ModelType(UnifiedModelType, Enum):
     GROQ_MIXTRAL_8_7B = "mixtral-8x7b-32768"
     GROQ_GEMMA_2_9B_IT = "gemma2-9b-it"
 
+    # Nebius AI Studio platform models
+    NEBIUS_GPT_OSS_120B = "gpt-oss-120b"
+    NEBIUS_GPT_OSS_20B = "gpt-oss-20b"
+    NEBIUS_GLM_4_5 = "GLM-4.5"
+    NEBIUS_DEEPSEEK_V3 = "deepseek-ai/DeepSeek-V3"
+    NEBIUS_DEEPSEEK_R1 = "deepseek-ai/DeepSeek-R1"
+    NEBIUS_LLAMA_3_1_70B = "meta-llama/Meta-Llama-3.1-70B-Instruct"
+    NEBIUS_MISTRAL_7B_INSTRUCT = "mistralai/Mistral-7B-Instruct-v0.3"
+
     # OpenRouter models
     OPENROUTER_LLAMA_3_1_405B = "meta-llama/llama-3.1-405b-instruct"
     OPENROUTER_LLAMA_3_1_70B = "meta-llama/llama-3.1-70b-instruct"
@@ -507,6 +518,13 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.O3,
         }
 
+    @property
+    def is_amd(self) -> bool:
+        r"""Returns whether this type of models is a AMD model."""
+        return self in {
+            ModelType.AMD_GPT4,
+        }
+
     @property
     def is_aws_bedrock(self) -> bool:
         r"""Returns whether this type of models is an AWS Bedrock model."""
@@ -603,6 +621,20 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GROQ_GEMMA_2_9B_IT,
         }
 
+    @property
+    def is_nebius(self) -> bool:
+        r"""Returns whether this type of models is served by Nebius AI
+        Studio."""
+        return self in {
+            ModelType.NEBIUS_GPT_OSS_120B,
+            ModelType.NEBIUS_GPT_OSS_20B,
+            ModelType.NEBIUS_GLM_4_5,
+            ModelType.NEBIUS_DEEPSEEK_V3,
+            ModelType.NEBIUS_DEEPSEEK_R1,
+            ModelType.NEBIUS_LLAMA_3_1_70B,
+            ModelType.NEBIUS_MISTRAL_7B_INSTRUCT,
+        }
+
     @property
     def is_openrouter(self) -> bool:
         r"""Returns whether this type of models is served by OpenRouter."""
@@ -1138,6 +1170,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NOVITA_MISTRAL_7B,
             ModelType.NOVITA_LLAMA_3_2_11B_VISION,
             ModelType.NOVITA_LLAMA_3_2_3B,
+            ModelType.NEBIUS_MISTRAL_7B_INSTRUCT,
         }:
             return 32_768
         elif self in {
@@ -1227,6 +1260,11 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.ERNIE_4_5_TURBO_128K,
             ModelType.DEEPSEEK_V3,
             ModelType.MOONSHOT_KIMI_K2,
+            ModelType.NEBIUS_GLM_4_5,
+            ModelType.NEBIUS_DEEPSEEK_V3,
+            ModelType.NEBIUS_DEEPSEEK_R1,
+            ModelType.NEBIUS_GPT_OSS_120B,
+            ModelType.NEBIUS_GPT_OSS_20B,
         }:
             return 128_000
         elif self in {
@@ -1261,6 +1299,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NOVITA_LLAMA_4_SCOUT_17B,
             ModelType.NOVITA_LLAMA_3_3_70B,
             ModelType.NOVITA_MISTRAL_NEMO,
+            ModelType.NEBIUS_LLAMA_3_1_70B,
         }:
             return 131_072
         elif self in {
@@ -1319,6 +1358,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GLM_4_LONG,
             ModelType.TOGETHER_LLAMA_4_MAVERICK,
             ModelType.OPENROUTER_LLAMA_4_MAVERICK,
+            ModelType.AMD_GPT4,
             ModelType.GPT_4_1,
             ModelType.GPT_4_1_MINI,
             ModelType.GPT_4_1_NANO,
@@ -1532,6 +1572,7 @@ class ModelPlatformType(Enum):
     AZURE = "azure"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
+    NEBIUS = "nebius"
     OPENROUTER = "openrouter"
     OLLAMA = "ollama"
     LITELLM = "litellm"
@@ -1548,6 +1589,7 @@ class ModelPlatformType(Enum):
     COHERE = "cohere"
     YI = "lingyiwanwu"
     QWEN = "tongyi-qianwen"
+    AMD = "amd"
     NVIDIA = "nvidia"
     DEEPSEEK = "deepseek"
     PPIO = "ppio"

camel/types/unified_model_type.py

@@ -95,6 +95,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a Groq served model."""
         return True
 
+    @property
+    def is_nebius(self) -> bool:
+        r"""Returns whether the model is a Nebius AI Studio served model."""
+        return True
+
     @property
     def is_openrouter(self) -> bool:
         r"""Returns whether the model is a OpenRouter served model."""

camel/utils/commons.py

@@ -354,6 +354,8 @@ def api_keys_required(
                 key_way = "https://www.zhipuai.cn/"
             elif env_var_name == 'KLAVIS_API_KEY':
                 key_way = "https://www.klavis.ai/docs"
+            elif env_var_name == 'XAI_API_KEY':
+                key_way = "https://api.x.ai/v1"
 
             if missing_keys:
                 raise ValueError(