camel-ai 0.2.62__py3-none-any.whl → 0.2.64__py3-none-any.whl

camel/tasks/task.py

@@ -14,7 +14,7 @@
 
 import re
 from enum import Enum
-from typing import Callable, Dict, List, Literal, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -69,14 +69,23 @@ class Task(BaseModel):
     r"""Task is specific assignment that can be passed to a agent.
 
     Attributes:
-        content: string content for task.
-        id: An unique string identifier for the task. This should
-        ideally be provided by the provider/model which created the task.
-        state: The state which should be OPEN, RUNNING, DONE or DELETED.
-        type: task type
-        parent: The parent task, None for root task.
-        subtasks: The childrent sub-tasks for the task.
-        result: The answer for the task.
+        content (str): string content for task.
+        id (str): An unique string identifier for the task. This should
+            ideally be provided by the provider/model which created the task.
+            (default: :obj: `""`)
+        state (TaskState): The state which should be OPEN, RUNNING, DONE or
+            DELETED. (default: :obj: `TaskState.OPEN`)
+        type (Optional[str]): task type. (default: :obj: `None`)
+        parent (Optional[Task]): The parent task, None for root task.
+            (default: :obj: `None`)
+        subtasks (List[Task]): The childrent sub-tasks for the task.
+            (default: :obj: `[]`)
+        result (Optional[str]): The answer for the task.
+            (default: :obj: `""`)
+        failure_count (int): The failure count for the task.
+            (default: :obj: `0`)
+        additional_info (Optional[Dict[str, Any]]): Additional information for
+            the task. (default: :obj: `None`)
     """
 
     content: str
@@ -95,7 +104,7 @@ class Task(BaseModel):
 
     failure_count: int = 0
 
-    additional_info: Optional[str] = None
+    additional_info: Optional[Dict[str, Any]] = None
 
     @classmethod
     def from_message(cls, message: BaseMessage) -> "Task":

camel/toolkits/code_execution.py

@@ -20,10 +20,13 @@ from camel.interpreters import (
     JupyterKernelInterpreter,
     SubprocessInterpreter,
 )
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 from camel.utils import MCPServer
 
+logger = get_logger(__name__)
+
 
 @MCPServer()
 class CodeExecutionToolkit(BaseToolkit):
@@ -36,10 +39,10 @@ class CodeExecutionToolkit(BaseToolkit):
             (default: :obj:`False`)
         unsafe_mode (bool):  If `True`, the interpreter runs the code
             by `eval()` without any security check. (default: :obj:`False`)
-        import_white_list ( Optional[List[str]]): A list of allowed imports.
+        import_white_list (Optional[List[str]]): A list of allowed imports.
             (default: :obj:`None`)
-        require_confirm (bool): Whether to require confirmation before executing code.
-            (default: :obj:`False`)
+        require_confirm (bool): Whether to require confirmation before
+            executing code. (default: :obj:`False`)
     """
 
     def __init__(
@@ -97,18 +100,41 @@ class CodeExecutionToolkit(BaseToolkit):
                 f"The sandbox type `{sandbox}` is not supported."
             )
 
-    def execute_code(self, code: str) -> str:
+    def execute_code(self, code: str, code_type: str = "python") -> str:
         r"""Execute a given code snippet.
 
         Args:
             code (str): The input code to the Code Interpreter tool call.
+            code_type (str): The type of the code to be executed
+                (e.g. node.js, python, etc). (default: obj:`python`)
 
         Returns:
             str: The text output from the Code Interpreter tool call.
         """
-        output = self.interpreter.run(code, "python")
-        # ruff: noqa: E501
-        content = f"Executed the code below:\n```py\n{code}\n```\n> Executed Results:\n{output}"
+        output = self.interpreter.run(code, code_type)
+        content = (
+            f"Executed the code below:\n```{code_type}\n{code}\n```\n"
+            f"> Executed Results:\n{output}"
+        )
+        if self.verbose:
+            print(content)
+        return content
+
+    def execute_command(self, command: str) -> Union[str, tuple[str, str]]:
+        r"""Execute a command can be used to resolve the dependency of the
+        code.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            Union[str, tuple[str, str]]: The output of the command.
+        """
+        output = self.interpreter.execute_command(command)
+        content = (
+            f"Executed the command below:\n```sh\n{command}\n```\n"
+            f"> Executed Results:\n{output}"
+        )
         if self.verbose:
             print(content)
         return content
@@ -121,4 +147,7 @@ class CodeExecutionToolkit(BaseToolkit):
             List[FunctionTool]: A list of FunctionTool objects
                 representing the functions in the toolkit.
         """
-        return [FunctionTool(self.execute_code)]
+        return [
+            FunctionTool(self.execute_code),
+            FunctionTool(self.execute_command),
+        ]

camel/toolkits/mcp_toolkit.py

@@ -98,6 +98,8 @@ class MCPToolkit(BaseToolkit):
         timeout (Optional[float], optional): Timeout for connection attempts
             in seconds. This timeout applies to individual client connections.
             (default: :obj:`None`)
+        strict (Optional[bool], optional): Flag to indicate strict mode.
+            (default: :obj:`False`)
 
     Note:
         At least one of :obj:`clients`, :obj:`config_path`, or
@@ -146,6 +148,7 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        strict: Optional[bool] = False,
     ):
         # Call parent constructor first
         super().__init__(timeout=timeout)
@@ -162,6 +165,7 @@ class MCPToolkit(BaseToolkit):
             raise ValueError(error_msg)
 
         self.clients: List[MCPClient] = clients or []
+        self.strict = strict  # Store strict parameter
         self._is_connected = False
         self._exit_stack: Optional[AsyncExitStack] = None
 
@@ -309,6 +313,7 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        strict: Optional[bool] = False,
     ) -> "MCPToolkit":
         r"""Factory method that creates and connects to all MCP servers.
 
@@ -326,6 +331,8 @@ class MCPToolkit(BaseToolkit):
                 config file. (default: :obj:`None`)
             timeout (Optional[float], optional): Timeout for connection
                 attempts in seconds. (default: :obj:`None`)
+            strict (Optional[bool], optional): Flag to indicate strict mode.
+                (default: :obj:`False`)
 
         Returns:
             MCPToolkit: A fully initialized and connected :obj:`MCPToolkit`
@@ -354,6 +361,7 @@ class MCPToolkit(BaseToolkit):
             config_path=config_path,
             config_dict=config_dict,
             timeout=timeout,
+            strict=strict,
         )
         try:
             await toolkit.connect()
@@ -373,10 +381,11 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        strict: Optional[bool] = False,
     ) -> "MCPToolkit":
         r"""Synchronously create and connect to all MCP servers."""
         return run_async(cls.create)(
-            clients, config_path, config_dict, timeout
+            clients, config_path, config_dict, timeout, strict
         )
 
     def _load_clients_from_config(self, config_path: str) -> List[MCPClient]:
@@ -433,10 +442,12 @@ class MCPToolkit(BaseToolkit):
 
         try:
             # Use the new mcp_client factory function
-            # Pass timeout from toolkit if available
+            # Pass timeout and strict from toolkit if available
             kwargs = {}
             if hasattr(self, "timeout") and self.timeout is not None:
                 kwargs["timeout"] = self.timeout
+            if hasattr(self, "strict") and self.strict is not None:
+                kwargs["strict"] = self.strict
 
             client = create_mcp_client(cfg, **kwargs)
             return client

camel/types/enums.py

@@ -185,7 +185,7 @@ class ModelType(UnifiedModelType, Enum):
 
     # Gemini models
     GEMINI_2_5_FLASH_PREVIEW = "gemini-2.5-flash-preview-04-17"
-    GEMINI_2_5_PRO_PREVIEW = "gemini-2.5-pro-preview-05-06"
+    GEMINI_2_5_PRO_PREVIEW = "gemini-2.5-pro-preview-06-05"
     GEMINI_2_0_FLASH = "gemini-2.0-flash"
     GEMINI_2_0_FLASH_EXP = "gemini-2.0-flash-exp"
     GEMINI_2_0_FLASH_THINKING = "gemini-2.0-flash-thinking-exp"
@@ -207,6 +207,7 @@ class ModelType(UnifiedModelType, Enum):
     MISTRAL_NEMO = "open-mistral-nemo"
     MISTRAL_PIXTRAL_12B = "pixtral-12b-2409"
     MISTRAL_MEDIUM_3 = "mistral-medium-latest"
+    MAGISTRAL_MEDIUM = "magistral-medium-2506"
 
     # Reka models
     REKA_CORE = "reka-core"
@@ -384,6 +385,25 @@ class ModelType(UnifiedModelType, Enum):
     )
     WATSONX_MISTRAL_LARGE = "mistralai/mistral-large"
 
+    # Crynux models
+    CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_1_5B = (
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
+    )
+    CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_7B = (
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
+    )
+    CRYNUX_DEEPSEEK_R1_DISTILL_LLAMA_8B = (
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
+    )
+
+    CRYNUX_QWEN_3_4_B = "Qwen/Qwen3-4B"
+    CRYNUX_QWEN_3_8_B = "Qwen/Qwen3-8B"
+    CRYNUX_QWEN_2_5_7B = "Qwen/Qwen2.5-7B"
+    CRYNUX_QWEN_2_5_7B_INSTRUCT = "Qwen/Qwen2.5-7B-Instruct"
+
+    CRYNUX_NOUS_HERMES_3_LLAMA_3_1_8B = "NousResearch/Hermes-3-Llama-3.1-8B"
+    CRYNUX_NOUS_HERMES_3_LLAMA_3_2_3B = "NousResearch/Hermes-3-Llama-3.2-3B"
+
     def __str__(self):
         return self.value
 
@@ -612,6 +632,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_8B,
             ModelType.MISTRAL_3B,
             ModelType.MISTRAL_MEDIUM_3,
+            ModelType.MAGISTRAL_MEDIUM,
         }
 
     @property
@@ -891,6 +912,20 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NOVITA_L31_70B_EURYALE_V2_2,
         }
 
+    @property
+    def is_crynux(self) -> bool:
+        return self in {
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_1_5B,
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_7B,
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_LLAMA_8B,
+            ModelType.CRYNUX_QWEN_3_4_B,
+            ModelType.CRYNUX_QWEN_3_8_B,
+            ModelType.CRYNUX_QWEN_2_5_7B,
+            ModelType.CRYNUX_QWEN_2_5_7B_INSTRUCT,
+            ModelType.CRYNUX_NOUS_HERMES_3_LLAMA_3_1_8B,
+            ModelType.CRYNUX_NOUS_HERMES_3_LLAMA_3_2_3B,
+        }
+
     @property
     def is_aiml(self) -> bool:
         return self in {
@@ -991,6 +1026,15 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NOVITA_GLM_4_32B_0414,
             ModelType.NOVITA_GLM_Z1_RUMINATION_32B_0414,
             ModelType.NOVITA_QWEN_2_5_7B,
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_1_5B,
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_7B,
+            ModelType.CRYNUX_DEEPSEEK_R1_DISTILL_LLAMA_8B,
+            ModelType.CRYNUX_QWEN_3_4_B,
+            ModelType.CRYNUX_QWEN_3_8_B,
+            ModelType.CRYNUX_QWEN_2_5_7B,
+            ModelType.CRYNUX_QWEN_2_5_7B_INSTRUCT,
+            ModelType.CRYNUX_NOUS_HERMES_3_LLAMA_3_1_8B,
+            ModelType.CRYNUX_NOUS_HERMES_3_LLAMA_3_2_3B,
         }:
             return 32_000
         elif self in {
@@ -1223,6 +1267,11 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.TOGETHER_LLAMA_4_SCOUT,
         }:
             return 10_000_000
+        elif self in {
+            ModelType.MAGISTRAL_MEDIUM,
+        }:
+            return 40_000
+
         else:
             logger.warning(
                 f"Unknown model type {self}, set maximum token limit "
@@ -1449,6 +1498,7 @@ class ModelPlatformType(Enum):
     NETMIND = "netmind"
     NOVITA = "novita"
     WATSONX = "watsonx"
+    CRYNUX = "crynux"
 
     @classmethod
     def from_name(cls, name):
@@ -1624,6 +1674,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is WatsonX."""
         return self is ModelPlatformType.WATSONX
 
+    @property
+    def is_crynux(self) -> bool:
+        r"""Returns whether this platform is Crynux."""
+        return self is ModelPlatformType.CRYNUX
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/types/unified_model_type.py

@@ -163,6 +163,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a WatsonX served model."""
         return True
 
+    @property
+    def is_crynux(self) -> bool:
+        r"""Returns whether the model is a Crynux served model."""
+        return True
+
     @property
     def support_native_structured_output(self) -> bool:
         r"""Returns whether the model supports native structured output."""

camel/utils/__init__.py

@@ -44,6 +44,15 @@ from .commons import (
 from .constants import Constants
 from .deduplication import DeduplicationResult, deduplicate_internally
 from .filename import sanitize_filename
+from .langfuse import (
+    configure_langfuse,
+    get_current_agent_session_id,
+    get_langfuse_status,
+    is_langfuse_available,
+    observe,
+    update_current_observation,
+    update_langfuse_trace,
+)
 from .mcp import MCPServer
 from .response_format import get_pydantic_model, model_from_json_schema
 from .token_counting import (
@@ -97,4 +106,11 @@ __all__ = [
     "sanitize_filename",
     "browser_toolkit_save_auth_cookie",
     "run_async",
+    "configure_langfuse",
+    "is_langfuse_available",
+    "get_current_agent_session_id",
+    "update_langfuse_trace",
+    "observe",
+    "update_current_observation",
+    "get_langfuse_status",
 ]

camel/utils/langfuse.py

@@ -0,0 +1,258 @@
+# ========= 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
+import threading
+from typing import Any, Dict, List, Optional
+
+from camel.logger import get_logger
+from camel.utils import dependencies_required
+
+logger = get_logger(__name__)
+# Thread-local storage for agent session IDs
+_local = threading.local()
+
+# Global flag to track if Langfuse has been configured
+_langfuse_configured = False
+
+try:
+    from langfuse.decorators import langfuse_context
+
+    LANGFUSE_AVAILABLE = True
+except ImportError:
+    LANGFUSE_AVAILABLE = False
+
+
+@dependencies_required('langfuse')
+def configure_langfuse(
+    public_key: Optional[str] = None,
+    secret_key: Optional[str] = None,
+    host: Optional[str] = None,
+    debug: Optional[bool] = None,
+    enabled: Optional[bool] = None,
+):
+    r"""Configure Langfuse for CAMEL models.
+
+    Args:
+        public_key(Optional[str]): Langfuse public key. Can be set via LANGFUSE_PUBLIC_KEY.
+            (default: :obj:`None`)
+        secret_key(Optional[str]): Langfuse secret key. Can be set via LANGFUSE_SECRET_KEY.
+            (default: :obj:`None`)
+        host(Optional[str]): Langfuse host URL. Can be set via LANGFUSE_HOST.
+            (default: :obj:`https://cloud.langfuse.com`)
+        debug(Optional[bool]): Enable debug mode. Can be set via LANGFUSE_DEBUG.
+            (default: :obj:`None`)
+        enabled(Optional[bool]): Enable/disable tracing. Can be set via LANGFUSE_ENABLED.
+            (default: :obj:`None`)
+
+    Note:
+        This function configures the native langfuse_context which works with
+            @observe() decorators. Set enabled=False to disable all tracing.
+    """  # noqa: E501
+    global _langfuse_configured
+
+    # Get configuration from environment or parameters
+    public_key = public_key or os.environ.get("LANGFUSE_PUBLIC_KEY")
+    secret_key = secret_key or os.environ.get("LANGFUSE_SECRET_KEY")
+    host = host or os.environ.get(
+        "LANGFUSE_HOST", "https://cloud.langfuse.com"
+    )
+    debug = (
+        debug
+        if debug is not None
+        else os.environ.get("LANGFUSE_DEBUG", "False").lower() == "true"
+    )
+
+    # Handle enabled parameter
+    if enabled is None:
+        env_enabled_str = os.environ.get("LANGFUSE_ENABLED")
+        if env_enabled_str is not None:
+            enabled = env_enabled_str.lower() == "true"
+        else:
+            enabled = False  # Default to disabled
+
+    # If not enabled, don't configure anything and don't call langfuse function
+    if not enabled:
+        _langfuse_configured = False
+        logger.info("Langfuse tracing disabled for CAMEL models")
+
+    logger.debug(
+        f"Configuring Langfuse - enabled: {enabled}, "
+        f"public_key: {'***' + public_key[-4:] if public_key else None}, "
+        f"host: {host}, debug: {debug}"
+    )
+    if enabled and public_key and secret_key and LANGFUSE_AVAILABLE:
+        _langfuse_configured = True
+    else:
+        _langfuse_configured = False
+
+    try:
+        # Configure langfuse_context with native method
+        langfuse_context.configure(
+            public_key=public_key,
+            secret_key=secret_key,
+            host=host,
+            debug=debug,
+            enabled=True,  # Always True here since we checked enabled above
+        )
+
+        logger.info("Langfuse tracing enabled for CAMEL models")
+
+    except Exception as e:
+        logger.error(f"Failed to configure Langfuse: {e}")
+
+
+def is_langfuse_available() -> bool:
+    r"""Check if Langfuse is configured."""
+    return _langfuse_configured
+
+
+def set_current_agent_session_id(session_id: str) -> None:
+    r"""Set the session ID for the current agent in thread-local storage.
+
+    Args:
+        session_id(str): The session ID to set for the current agent.
+    """
+
+    _local.agent_session_id = session_id
+
+
+def get_current_agent_session_id() -> Optional[str]:
+    r"""Get the session ID for the current agent from thread-local storage.
+
+    Returns:
+        Optional[str]: The session ID for the current agent.
+    """
+    if is_langfuse_available():
+        return getattr(_local, 'agent_session_id', None)
+    return None
+
+
+def update_langfuse_trace(
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    tags: Optional[List[str]] = None,
+) -> bool:
+    r"""Update the current Langfuse trace with session ID and metadata.
+
+    Args:
+        session_id(Optional[str]): Optional session ID to use. If :obj:`None`
+            uses the current agent's session ID. (default: :obj:`None`)
+        user_id(Optional[str]): Optional user ID for the trace.
+            (default: :obj:`None`)
+        metadata(Optional[Dict[str, Any]]): Optional metadata dictionary.
+            (default: :obj:`None`)
+        tags(Optional[List[str]]): Optional list of tags.
+            (default: :obj:`None`)
+
+    Returns:
+        bool: True if update was successful, False otherwise.
+    """
+    if not is_langfuse_available():
+        return False
+
+    # Use provided session_id or get from thread-local storage
+    final_session_id = session_id or get_current_agent_session_id()
+
+    update_data: Dict[str, Any] = {}
+    if final_session_id:
+        update_data["session_id"] = final_session_id
+    if user_id:
+        update_data["user_id"] = user_id
+    if metadata:
+        update_data["metadata"] = metadata
+    if tags:
+        update_data["tags"] = tags
+
+    if update_data:
+        langfuse_context.update_current_trace(**update_data)
+        return True
+
+    return False
+
+
+def update_current_observation(
+    input: Optional[Dict[str, Any]] = None,
+    output: Optional[Dict[str, Any]] = None,
+    model: Optional[str] = None,
+    model_parameters: Optional[Dict[str, Any]] = None,
+    usage_details: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> None:
+    r"""Update the current Langfuse observation with input, output,
+    model, model_parameters, and usage_details.
+
+    Args:
+        input(Optional[Dict[str, Any]]): Optional input dictionary.
+            (default: :obj:`None`)
+        output(Optional[Dict[str, Any]]): Optional output dictionary.
+            (default: :obj:`None`)
+        model(Optional[str]): Optional model name. (default: :obj:`None`)
+        model_parameters(Optional[Dict[str, Any]]): Optional model parameters
+            dictionary. (default: :obj:`None`)
+        usage_details(Optional[Dict[str, Any]]): Optional usage details
+            dictionary. (default: :obj:`None`)
+
+    Returns:
+        None
+    """
+    if not is_langfuse_available():
+        return
+
+    langfuse_context.update_current_observation(
+        input=input,
+        output=output,
+        model=model,
+        model_parameters=model_parameters,
+        usage_details=usage_details,
+        **kwargs,
+    )
+
+
+def get_langfuse_status() -> Dict[str, Any]:
+    r"""Get detailed Langfuse configuration status for debugging.
+
+    Returns:
+        Dict[str, Any]: Status information including configuration state.
+    """
+    env_enabled_str = os.environ.get("LANGFUSE_ENABLED")
+    env_enabled = (
+        env_enabled_str.lower() == "true" if env_enabled_str else None
+    )
+
+    status = {
+        "configured": _langfuse_configured,
+        "has_public_key": bool(os.environ.get("LANGFUSE_PUBLIC_KEY")),
+        "has_secret_key": bool(os.environ.get("LANGFUSE_SECRET_KEY")),
+        "env_enabled": env_enabled,
+        "host": os.environ.get("LANGFUSE_HOST", "https://cloud.langfuse.com"),
+        "debug": os.environ.get("LANGFUSE_DEBUG", "false").lower() == "true",
+        "current_session_id": get_current_agent_session_id(),
+    }
+
+    if _langfuse_configured:
+        try:
+            # Try to get some context information
+            status["langfuse_context_available"] = True
+        except Exception as e:
+            status["langfuse_context_error"] = str(e)
+
+    return status
+
+
+def observe(*args, **kwargs):
+    def decorator(func):
+        return func
+
+    return decorator