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

camel/tasks/task.py

@@ -14,20 +14,81 @@
 
 import re
 from enum import Enum
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+)
 
 from pydantic import BaseModel
 
-from camel.agents import ChatAgent
+if TYPE_CHECKING:
+    from camel.agents import ChatAgent
+from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 
+# Note: validate_task_content moved here to avoid circular imports
 from .task_prompt import (
     TASK_COMPOSE_PROMPT,
     TASK_DECOMPOSE_PROMPT,
     TASK_EVOLVE_PROMPT,
 )
 
+logger = get_logger(__name__)
+
+
+def validate_task_content(
+    content: str, task_id: str = "unknown", min_length: int = 10
+) -> bool:
+    r"""Validates task result content to avoid silent failures.
+    It performs basic checks to ensure the content meets minimum
+    quality standards.
+
+    Args:
+        content (str): The task result content to validate.
+        task_id (str): Task ID for logging purposes.
+            (default: :obj:`"unknown"`)
+        min_length (int): Minimum content length after stripping whitespace.
+            (default: :obj:`10`)
+
+    Returns:
+        bool: True if content passes validation, False otherwise.
+    """
+    # 1: Content must not be None
+    if content is None:
+        logger.warning(f"Task {task_id}: None content rejected")
+        return False
+
+    # 2: Content must not be empty after stripping whitespace
+    stripped_content = content.strip()
+    if not stripped_content:
+        logger.warning(
+            f"Task {task_id}: Empty or whitespace-only content rejected."
+        )
+        return False
+
+    # 3: Content must meet minimum meaningful length
+    if len(stripped_content) < min_length:
+        logger.warning(
+            f"Task {task_id}: Content too short ({len(stripped_content)} "
+            f"chars < {min_length} minimum). Content preview: "
+            f"'{stripped_content[:50]}...'"
+        )
+        return False
+
+    # All validation checks passed
+    logger.debug(
+        f"Task {task_id}: Content validation passed "
+        f"({len(stripped_content)} chars)"
+    )
+    return True
+
 
 def parse_response(
     response: str, task_id: Optional[str] = None
@@ -49,7 +110,16 @@ def parse_response(
     if task_id is None:
         task_id = "0"
     for i, content in enumerate(tasks_content):
-        tasks.append(Task(content=content.strip(), id=f"{task_id}.{i}"))
+        stripped_content = content.strip()
+        # validate subtask content before creating the task
+        if validate_task_content(stripped_content, f"{task_id}.{i}"):
+            tasks.append(Task(content=stripped_content, id=f"{task_id}.{i}"))
+        else:
+            logger.warning(
+                f"Skipping invalid subtask {task_id}.{i} "
+                f"during decomposition: "
+                f"Content '{stripped_content[:50]}...' failed validation"
+            )
     return tasks
 
 
@@ -228,7 +298,7 @@ class Task(BaseModel):
 
     def decompose(
         self,
-        agent: ChatAgent,
+        agent: "ChatAgent",
         prompt: Optional[str] = None,
         task_parser: Callable[[str, str], List["Task"]] = parse_response,
     ) -> List["Task"]:
@@ -263,7 +333,7 @@ class Task(BaseModel):
 
     def compose(
         self,
-        agent: ChatAgent,
+        agent: "ChatAgent",
         template: TextPrompt = TASK_COMPOSE_PROMPT,
         result_parser: Optional[Callable[[str], str]] = None,
     ):
@@ -412,12 +482,13 @@ class TaskManager:
     def evolve(
         self,
         task: Task,
-        agent: ChatAgent,
+        agent: "ChatAgent",
         template: Optional[TextPrompt] = None,
         task_parser: Optional[Callable[[str, str], List[Task]]] = None,
     ) -> Optional[Task]:
         r"""Evolve a task to a new task.
             Evolve is only used for data generation.
+
         Args:
             task (Task): A given task.
             agent (ChatAgent): An agent that used to evolve the task.

camel/toolkits/__init__.py

@@ -76,6 +76,7 @@ from .klavis_toolkit import KlavisToolkit
 from .aci_toolkit import ACIToolkit
 from .playwright_mcp_toolkit import PlaywrightMCPToolkit
 from .wolfram_alpha_toolkit import WolframAlphaToolkit
+from .task_planning_toolkit import TaskPlanningToolkit
 
 
 __all__ = [
@@ -140,4 +141,5 @@ __all__ = [
     'PlaywrightMCPToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
+    'TaskPlanningToolkit',
 ]

camel/toolkits/code_execution.py

@@ -122,7 +122,7 @@ class CodeExecutionToolkit(BaseToolkit):
 
     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.
+        code. Useful if there's dependency issues when you try to execute code.
 
         Args:
             command (str): The command to execute.

camel/toolkits/function_tool.py

@@ -190,7 +190,9 @@ def sanitize_and_enforce_required(parameters_dict):
     r"""Cleans and updates the function schema to conform with OpenAI's
     requirements:
     - Removes invalid 'default' fields from the parameters schema.
-    - Ensures all fields or function parameters are marked as required.
+    - Ensures all fields are marked as required or have null type for optional
+    fields.
+    - Recursively adds additionalProperties: false to all nested objects.
 
     Args:
         parameters_dict (dict): The dictionary representing the function
@@ -198,8 +200,38 @@ def sanitize_and_enforce_required(parameters_dict):
 
     Returns:
         dict: The updated dictionary with invalid defaults removed and all
-            fields set as required.
+            fields properly configured for strict mode.
     """
+
+    def _add_additional_properties_false(obj):
+        r"""Recursively add additionalProperties: false to all objects."""
+        if isinstance(obj, dict):
+            if (
+                obj.get("type") == "object"
+                and "additionalProperties" not in obj
+            ):
+                obj["additionalProperties"] = False
+
+            # Process nested structures
+            for key, value in obj.items():
+                if key == "properties" and isinstance(value, dict):
+                    for prop_value in value.values():
+                        _add_additional_properties_false(prop_value)
+                elif key in [
+                    "items",
+                    "allOf",
+                    "oneOf",
+                    "anyOf",
+                ] and isinstance(value, (dict, list)):
+                    if isinstance(value, dict):
+                        _add_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            _add_additional_properties_false(item)
+                elif key == "$defs" and isinstance(value, dict):
+                    for def_value in value.values():
+                        _add_additional_properties_false(def_value)
+
     # Check if 'function' and 'parameters' exist
     if (
         'function' in parameters_dict
@@ -209,12 +241,52 @@ def sanitize_and_enforce_required(parameters_dict):
         parameters = parameters_dict['function']['parameters']
         properties = parameters.get('properties', {})
 
-        # Remove 'default' key from each property
-        for field in properties.values():
-            field.pop('default', None)
+        # Track which fields should be required vs optional
+        required_fields = []
+
+        # Process each property
+        for field_name, field_schema in properties.items():
+            # Check if this field had a default value (making it optional)
+            had_default = 'default' in field_schema
+
+            # Remove 'default' key from field schema as required by OpenAI
+            field_schema.pop('default', None)
+
+            if had_default:
+                # This field is optional - add null to its type
+                current_type = field_schema.get('type')
+                has_ref = '$ref' in field_schema
+
+                if has_ref:
+                    # Fields with $ref shouldn't have additional type field
+                    # The $ref itself defines the type structure
+                    pass
+                elif current_type:
+                    if isinstance(current_type, str):
+                        # Single type - convert to array with null
+                        field_schema['type'] = [current_type, 'null']
+                    elif (
+                        isinstance(current_type, list)
+                        and 'null' not in current_type
+                    ):
+                        # Array of types - add null if not present
+                        field_schema['type'] = [*current_type, 'null']
+                else:
+                    # No type specified, add null type
+                    field_schema['type'] = ['null']
+
+                # Optional fields are still marked as required in strict mode
+                # but with null type to indicate they can be omitted
+                required_fields.append(field_name)
+            else:
+                # This field is required
+                required_fields.append(field_name)
+
+        # Set all fields as required (strict mode requirement)
+        parameters['required'] = required_fields
 
-        # Mark all keys in 'properties' as required
-        parameters['required'] = list(properties.keys())
+        # Recursively add additionalProperties: false to all objects
+        _add_additional_properties_false(parameters)
 
     return parameters_dict
 

camel/toolkits/mcp_toolkit.py

@@ -98,8 +98,6 @@ 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
@@ -148,7 +146,6 @@ 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)
@@ -165,7 +162,6 @@ 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
 
@@ -313,7 +309,6 @@ 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.
 
@@ -331,8 +326,6 @@ 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`
@@ -361,7 +354,6 @@ class MCPToolkit(BaseToolkit):
             config_path=config_path,
             config_dict=config_dict,
             timeout=timeout,
-            strict=strict,
         )
         try:
             await toolkit.connect()
@@ -381,11 +373,10 @@ 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, strict
+            clients, config_path, config_dict, timeout
         )
 
     def _load_clients_from_config(self, config_path: str) -> List[MCPClient]:
@@ -442,12 +433,10 @@ class MCPToolkit(BaseToolkit):
 
         try:
             # Use the new mcp_client factory function
-            # Pass timeout and strict from toolkit if available
+            # Pass timeout 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
@@ -455,17 +444,68 @@ class MCPToolkit(BaseToolkit):
             error_msg = f"Failed to create client for server '{name}': {e}"
             raise ValueError(error_msg) from e
 
+    def _ensure_strict_tool_schema(self, tool: FunctionTool) -> FunctionTool:
+        r"""Ensure a tool has a strict schema compatible with OpenAI's
+        requirements.
+
+        Args:
+            tool (FunctionTool): The tool to check and update if necessary.
+
+        Returns:
+            FunctionTool: The tool with a strict schema.
+        """
+        try:
+            schema = tool.get_openai_tool_schema()
+
+            # Check if the tool already has strict mode enabled
+            if schema.get("function", {}).get("strict") is True:
+                return tool
+
+            # Update the schema to be strict
+            if "function" in schema:
+                schema["function"]["strict"] = True
+
+                # Ensure parameters have proper strict mode configuration
+                parameters = schema["function"].get("parameters", {})
+                if parameters:
+                    # Ensure additionalProperties is false
+                    parameters["additionalProperties"] = False
+
+                    # Process properties to handle optional fields
+                    properties = parameters.get("properties", {})
+                    parameters["required"] = list(properties.keys())
+
+                    # Apply the sanitization function from function_tool
+                    from camel.toolkits.function_tool import (
+                        sanitize_and_enforce_required,
+                    )
+
+                    schema = sanitize_and_enforce_required(schema)
+
+            tool.set_openai_tool_schema(schema)
+            logger.debug(
+                f"Updated tool '{tool.get_function_name()}' to strict mode"
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to ensure strict schema for tool: {e}")
+
+        return tool
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Aggregates all tools from the managed MCP client instances.
 
         Collects and combines tools from all connected MCP clients into a
         single unified list. Each tool is converted to a CAMEL-compatible
-        :obj:`FunctionTool` that can be used with CAMEL agents.
+        :obj:`FunctionTool` that can be used with CAMEL agents. All tools
+        are ensured to have strict schemas compatible with OpenAI's
+        requirements.
 
         Returns:
             List[FunctionTool]: Combined list of all available function tools
-                from all connected MCP servers. Returns an empty list if no
-                clients are connected or if no tools are available.
+                from all connected MCP servers with strict schemas. Returns an
+                empty list if no clients are connected or if no tools are
+                available.
 
         Note:
             This method can be called even when the toolkit is not connected,
@@ -492,14 +532,25 @@ class MCPToolkit(BaseToolkit):
         for i, client in enumerate(self.clients):
             try:
                 client_tools = client.get_tools()
-                all_tools.extend(client_tools)
+
+                # Ensure all tools have strict schemas
+                strict_tools = []
+                for tool in client_tools:
+                    strict_tool = self._ensure_strict_tool_schema(tool)
+                    strict_tools.append(strict_tool)
+
+                all_tools.extend(strict_tools)
                 logger.debug(
-                    f"Client {i+1} contributed {len(client_tools)} tools"
+                    f"Client {i+1} contributed {len(strict_tools)} "
+                    f"tools (strict mode enabled)"
                 )
             except Exception as e:
                 logger.error(f"Failed to get tools from client {i+1}: {e}")
 
-        logger.info(f"Total tools available: {len(all_tools)}")
+        logger.info(
+            f"Total tools available: {len(all_tools)} (all with strict "
+            f"schemas)"
+        )
         return all_tools
 
     def get_text_tools(self) -> str:

camel/toolkits/playwright_mcp_toolkit.py

@@ -62,7 +62,8 @@ class PlaywrightMCPToolkit(BaseToolkit):
                         + (additional_args or []),
                     }
                 }
-            }
+            },
+            timeout=timeout,
         )
 
     async def connect(self):

camel/toolkits/pptx_toolkit.py

@@ -260,7 +260,7 @@ class PPTXToolkit(BaseToolkit):
                 provided, the default template will be used. (default: :obj:
                 `None`)
         """
-        import pptx
+        from pptx import Presentation
 
         # Use template if provided, otherwise create new presentation
         if template is not None:
@@ -270,9 +270,9 @@ class PPTXToolkit(BaseToolkit):
                     f"Template file not found: {template_path}, using "
                     "default template"
                 )
-                presentation = pptx.Presentation()
+                presentation = Presentation()
             else:
-                presentation = pptx.Presentation(str(template_path))
+                presentation = Presentation(str(template_path))
                 # Clear all existing slides by removing them from the slide
                 # list
                 while len(presentation.slides) > 0:
@@ -280,7 +280,7 @@ class PPTXToolkit(BaseToolkit):
                     presentation.part.drop_rel(rId)
                     del presentation.slides._sldIdLst[-1]
         else:
-            presentation = pptx.Presentation()
+            presentation = Presentation()
 
         slide_width_inch, slide_height_inch = (
             self._get_slide_width_height_inches(presentation)

camel/types/enums.py

@@ -386,6 +386,16 @@ class ModelType(UnifiedModelType, Enum):
     )
     WATSONX_MISTRAL_LARGE = "mistralai/mistral-large"
 
+    # Qianfan models
+    QIANFAN_ERNIE_X1_TURBO_32K = "ernie-x1-turbo-32k"
+    QIANFAN_ERNIE_X1_32K = "ernie-x1-32k"
+    QIANFAN_ERNIE_X1_32K_PREVIEW = "ernie-x1-32k-preview"
+    QIANFAN_ERNIE_4_5_TURBO_128K = "ernie-4.5-turbo-128k"
+    QIANFAN_ERNIE_4_5_TURBO_32K = "ernie-4.5-turbo-32k"
+    QIANFAN_DEEPSEEK_V3 = "deepseek-v3"
+    QIANFAN_DEEPSEEK_R1 = "deepseek-r1"
+    QIANFAN_QWEN3_235B_A22B = "qwen3-235b-a22b"
+
     # Crynux models
     CRYNUX_DEEPSEEK_R1_DISTILL_QWEN_1_5B = (
         "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
@@ -867,6 +877,19 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.WATSONX_MISTRAL_LARGE,
         }
 
+    @property
+    def is_qianfan(self) -> bool:
+        return self in {
+            ModelType.QIANFAN_ERNIE_X1_TURBO_32K,
+            ModelType.QIANFAN_ERNIE_X1_32K,
+            ModelType.QIANFAN_ERNIE_X1_32K_PREVIEW,
+            ModelType.QIANFAN_ERNIE_4_5_TURBO_128K,
+            ModelType.QIANFAN_ERNIE_4_5_TURBO_32K,
+            ModelType.QIANFAN_DEEPSEEK_V3,
+            ModelType.QIANFAN_DEEPSEEK_R1,
+            ModelType.QIANFAN_QWEN3_235B_A22B,
+        }
+
     @property
     def is_novita(self) -> bool:
         return self in {
@@ -1038,6 +1061,11 @@ class ModelType(UnifiedModelType, Enum):
             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,
+            ModelType.QIANFAN_ERNIE_X1_TURBO_32K,
+            ModelType.QIANFAN_ERNIE_X1_32K,
+            ModelType.QIANFAN_ERNIE_X1_32K_PREVIEW,
+            ModelType.QIANFAN_ERNIE_4_5_TURBO_32K,
+            ModelType.QIANFAN_QWEN3_235B_A22B,
         }:
             return 32_000
         elif self in {
@@ -1118,6 +1146,7 @@ class ModelType(UnifiedModelType, Enum):
             return 65_535
         elif self in {
             ModelType.NOVITA_QWEN_2_5_V1_72B,
+            ModelType.QIANFAN_DEEPSEEK_R1,
         }:
             return 96_000
         elif self in {
@@ -1171,6 +1200,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NETMIND_DEEPSEEK_V3,
             ModelType.NOVITA_DEEPSEEK_V3_0324,
             ModelType.MISTRAL_MEDIUM_3,
+            ModelType.QIANFAN_ERNIE_4_5_TURBO_128K,
+            ModelType.QIANFAN_DEEPSEEK_V3,
         }:
             return 128_000
         elif self in {
@@ -1502,6 +1533,7 @@ class ModelPlatformType(Enum):
     NETMIND = "netmind"
     NOVITA = "novita"
     WATSONX = "watsonx"
+    QIANFAN = "qianfan"
     CRYNUX = "crynux"
 
     @classmethod

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_qianfan(self) -> bool:
+        r"""Returns whether the model is a Qianfan served model."""
+        return True
+
     @property
     def is_crynux(self) -> bool:
         r"""Returns whether the model is a Crynux served model."""

camel/utils/mcp_client.py

@@ -173,8 +173,6 @@ class MCPClient:
             initialization. (default: :obj:`None`)
         timeout (Optional[float], optional): Timeout for waiting for messages
             from the server in seconds. (default: :obj:`10.0`)
-        strict (Optional[bool], optional): Strict mode for generating
-            FunctionTool objects. (default: :obj:`False`)
 
     Examples:
         STDIO server:
@@ -209,20 +207,6 @@ class MCPClient:
             async with MCPClient({"url": "ws://localhost:8080/mcp"}) as client:
                 tools = client.get_tools()
 
-        With strict mode enabled:
-
-        .. code-block:: python
-
-            async with MCPClient({
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/path"
-                ]
-            }, strict=True) as client:
-                tools = client.get_tools()
-
     Attributes:
         config (ServerConfig): The server configuration object.
         client_info (Optional[types.Implementation]): Client implementation
@@ -235,14 +219,12 @@ class MCPClient:
         config: Union[ServerConfig, Dict[str, Any]],
         client_info: Optional[types.Implementation] = None,
         timeout: Optional[float] = 10.0,
-        strict: Optional[bool] = False,
     ):
         # Convert dict config to ServerConfig if needed
         if isinstance(config, dict):
             config = ServerConfig(**config)
 
         self.config = config
-        self.strict = strict
 
         # Validate transport type early (this will raise ValueError if invalid)
         _ = self.config.transport_type
@@ -766,7 +748,6 @@ class MCPClient:
                 "name": mcp_tool.name,
                 "description": mcp_tool.description
                 or "No description provided.",
-                "strict": self.strict,
                 "parameters": parameters,
             },
         }
@@ -932,8 +913,7 @@ def create_mcp_client(
             dictionary is provided, it will be automatically converted to
             a :obj:`ServerConfig`.
         **kwargs: Additional keyword arguments passed to the :obj:`MCPClient`
-            constructor, such as :obj:`client_info`, :obj:`timeout`, and
-            :obj:`strict`.
+            constructor, such as :obj:`client_info`, :obj:`timeout`.
 
     Returns:
         MCPClient: A configured :obj:`MCPClient` instance ready for use as
@@ -972,20 +952,6 @@ def create_mcp_client(
                 "url": "ws://localhost:8080/mcp"
             }) as client:
                 tools = client.get_tools()
-
-        With strict mode enabled:
-
-        .. code-block:: python
-
-            async with create_mcp_client({
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/path",
-                ],
-            }, strict=True) as client:
-                tools = client.get_tools()
     """
     return MCPClient(config, **kwargs)
 

{camel_ai-0.2.65.dist-info → camel_ai-0.2.67.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.65
+Version: 0.2.67
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -38,7 +38,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: daytona-sdk>=0.20.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'
@@ -178,7 +178,7 @@ Requires-Dist: uv==0.6.5; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: aci-sdk>=1.0.0b1; 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: daytona-sdk>=0.20.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'