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

camel/toolkits/playwright_mcp_toolkit.py

@@ -27,17 +27,29 @@ class PlaywrightMCPToolkit(BaseToolkit):
     Attributes:
         timeout (Optional[float]): Connection timeout in seconds.
             (default: :obj:`None`)
+        additional_args (Optional[List[str]]): Additional command-line
+            arguments to pass to the Playwright MCP server. For example,
+            `["--cdp-endpoint=http://localhost:9222"]`.
+            (default: :obj:`None`)
 
     Note:
         Currently only supports asynchronous operation mode.
     """
 
-    def __init__(self, timeout: Optional[float] = None) -> None:
-        r"""Initializes the PlaywrightMCPToolkit with the specified timeout.
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+        additional_args: Optional[List[str]] = None,
+    ) -> None:
+        r"""Initializes the PlaywrightMCPToolkit.
 
         Args:
             timeout (Optional[float]): Connection timeout in seconds.
                 (default: :obj:`None`)
+            additional_args (Optional[List[str]]): Additional command-line
+                arguments to pass to the Playwright MCP server. For example,
+                `["--cdp-endpoint=http://localhost:9222"]`.
+                (default: :obj:`None`)
         """
         super().__init__(timeout=timeout)
 
@@ -46,7 +58,8 @@ class PlaywrightMCPToolkit(BaseToolkit):
                 "mcpServers": {
                     "playwright": {
                         "command": "npx",
-                        "args": ["@playwright/mcp@latest"],
+                        "args": ["@playwright/mcp@latest"]
+                        + (additional_args or []),
                     }
                 }
             }

camel/toolkits/task_planning_toolkit.py

@@ -0,0 +1,134 @@
+# ========= 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 uuid
+from typing import List, Optional
+
+from camel.logger import get_logger
+from camel.tasks import Task
+from camel.toolkits import BaseToolkit, FunctionTool
+
+logger = get_logger(__name__)
+
+
+class TaskPlanningToolkit(BaseToolkit):
+    r"""A toolkit for task decomposition and re-planning."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initialize the TaskPlanningToolkit.
+
+        Args:
+            timeout (Optional[float]): The timeout for the toolkit.
+                (default: :obj: `None`)
+        """
+        super().__init__(timeout=timeout)
+
+    def decompose_task(
+        self,
+        original_task_content: str,
+        sub_task_contents: List[str],
+        original_task_id: Optional[str] = None,
+    ) -> List[Task]:
+        r"""Use the tool to decompose an original task into several sub-tasks.
+        It creates new Task objects from the provided original task content,
+        used when the original task is complex and needs to be decomposed.
+
+        Args:
+            original_task_content (str): The content of the task to be
+                decomposed.
+            sub_task_contents (List[str]): A list of strings, where each
+                string is the content for a new sub-task.
+            original_task_id (Optional[str]): The id of the task to be
+                decomposed. If not provided, a new id will be generated.
+                (default: :obj: `None`)
+
+        Returns:
+            List[Task]: A list of newly created sub-task objects.
+        """
+        # Create the original task object from its content
+        original_task = Task(
+            content=original_task_content,
+            id=original_task_id if original_task_id else str(uuid.uuid4()),
+        )
+
+        new_tasks: List[Task] = []
+        for i, content in enumerate(sub_task_contents):
+            new_task = Task(
+                content=content,
+                id=f"{original_task.id}.{i}",
+                parent=original_task,
+            )
+            new_tasks.append(new_task)
+            original_task.subtasks.append(new_task)
+
+        logger.debug(
+            f"Decomposed task (content: '{original_task.content[:50]}...', "
+            f"id: {original_task.id}) into {len(new_tasks)} sub-tasks: "
+            f"{[task.id for task in new_tasks]}"
+        )
+
+        return new_tasks
+
+    def replan_tasks(
+        self,
+        original_task_content: str,
+        sub_task_contents: List[str],
+        original_task_id: Optional[str] = None,
+    ) -> List[Task]:
+        r"""Use the tool to re_decompose a task into several subTasks.
+        It creates new Task objects from the provided original task content,
+        used when the decomposed tasks are not good enough to help finish
+        the task.
+
+        Args:
+            original_task_content (str): The content of the task to be
+                decomposed.
+            sub_task_contents (List[str]): A list of strings, where each
+                string is the content for a new sub-task.
+            original_task_id (Optional[str]): The id of the task to be
+                decomposed. (default: :obj: `None`)
+
+        Returns:
+            List[Task]: Reordered or modified tasks.
+        """
+        original_task = Task(
+            content=original_task_content,
+            id=original_task_id if original_task_id else str(uuid.uuid4()),
+        )
+
+        new_tasks: List[Task] = []
+        for i, content in enumerate(sub_task_contents):
+            new_task = Task(
+                content=content,
+                id=f"{original_task.id}.{i}",
+                parent=original_task,
+            )
+            new_tasks.append(new_task)
+            original_task.subtasks.append(new_task)
+
+        logger.debug(
+            f"RePlan task (content: '{original_task.content[:50]}...', "
+            f"id: {original_task.id}) into {len(new_tasks)} sub-tasks: "
+            f"{[task.id for task in new_tasks]}"
+        )
+
+        return new_tasks
+
+    def get_tools(self) -> List[FunctionTool]:
+        return [
+            FunctionTool(self.decompose_task),
+            FunctionTool(self.replan_tasks),
+        ]

camel/types/enums.py

@@ -30,7 +30,7 @@ class RoleType(Enum):
 
 
 class ModelType(UnifiedModelType, Enum):
-    DEFAULT = os.getenv("DEFAULT_MODEL_TYPE", "gpt-4o-mini")
+    DEFAULT = os.getenv("DEFAULT_MODEL_TYPE", "gpt-4.1-mini-2025-04-14")
 
     GPT_3_5_TURBO = "gpt-3.5-turbo"
     GPT_4 = "gpt-4"
@@ -47,6 +47,7 @@ class ModelType(UnifiedModelType, Enum):
     GPT_4_1_NANO = "gpt-4.1-nano-2025-04-14"
     O4_MINI = "o4-mini"
     O3 = "o3"
+    O3_PRO = "o3-pro"
 
     AWS_CLAUDE_3_7_SONNET = "anthropic.claude-3-7-sonnet-20250219-v1:0"
     AWS_CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20241022-v2:0"
@@ -185,7 +186,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 +208,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 +386,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
 
@@ -452,6 +473,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.O1,
             ModelType.O1_PREVIEW,
             ModelType.O1_MINI,
+            ModelType.O3_PRO,
             ModelType.O3_MINI,
             ModelType.GPT_4_5_PREVIEW,
             ModelType.GPT_4_1,
@@ -492,6 +514,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.O1_PREVIEW,
             ModelType.O1_MINI,
             ModelType.O3_MINI,
+            ModelType.O3_PRO,
             ModelType.GPT_4_5_PREVIEW,
             ModelType.GPT_4_1,
             ModelType.GPT_4_1_MINI,
@@ -612,6 +635,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_8B,
             ModelType.MISTRAL_3B,
             ModelType.MISTRAL_MEDIUM_3,
+            ModelType.MAGISTRAL_MEDIUM,
         }
 
     @property
@@ -891,6 +915,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 +1029,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 {
@@ -1163,6 +1210,7 @@ class ModelType(UnifiedModelType, Enum):
         elif self in {
             ModelType.O1,
             ModelType.O3_MINI,
+            ModelType.O3_PRO,
             ModelType.CLAUDE_2_1,
             ModelType.CLAUDE_3_OPUS,
             ModelType.CLAUDE_3_SONNET,
@@ -1223,6 +1271,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 +1502,7 @@ class ModelPlatformType(Enum):
     NETMIND = "netmind"
     NOVITA = "novita"
     WATSONX = "watsonx"
+    CRYNUX = "crynux"
 
     @classmethod
     def from_name(cls, name):
@@ -1624,6 +1678,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