camel-ai 0.2.54__py3-none-any.whl → 0.2.56__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.54'
+__version__ = '0.2.56'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -752,7 +752,7 @@ class ChatAgent(BaseAgent):
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                return self._step_token_exceed(
+                return self._step_terminate(
                     e.args[1], tool_call_records, "max_tokens_exceeded"
                 )
             # Get response from model backend
@@ -765,8 +765,8 @@ class ChatAgent(BaseAgent):
 
             # Terminate Agent if stop_event is set
             if self.stop_event and self.stop_event.is_set():
-                # Use the _step_token_exceed to terminate the agent with reason
-                return self._step_token_exceed(
+                # Use the _step_terminate to terminate the agent with reason
+                return self._step_terminate(
                     num_tokens, tool_call_records, "termination_triggered"
                 )
 
@@ -851,7 +851,7 @@ class ChatAgent(BaseAgent):
             try:
                 openai_messages, num_tokens = self.memory.get_context()
             except RuntimeError as e:
-                return self._step_token_exceed(
+                return self._step_terminate(
                     e.args[1], tool_call_records, "max_tokens_exceeded"
                 )
 
@@ -864,8 +864,8 @@ class ChatAgent(BaseAgent):
 
             # Terminate Agent if stop_event is set
             if self.stop_event and self.stop_event.is_set():
-                # Use the _step_token_exceed to terminate the agent with reason
-                return self._step_token_exceed(
+                # Use the _step_terminate to terminate the agent with reason
+                return self._step_terminate(
                     num_tokens, tool_call_records, "termination_triggered"
                 )
 
@@ -1396,24 +1396,30 @@ class ChatAgent(BaseAgent):
             )
             output_messages.append(chat_message)
 
-    def _step_token_exceed(
+    def _step_terminate(
         self,
         num_tokens: int,
         tool_calls: List[ToolCallingRecord],
         termination_reason: str,
     ) -> ChatAgentResponse:
-        r"""Return trivial response containing number of tokens and information
-        of called functions when the number of tokens exceeds.
+        r"""Create a response when the agent execution is terminated.
+
+        This method is called when the agent needs to terminate its execution
+        due to various reasons such as token limit exceeded, or other
+        termination conditions. It creates a response with empty messages but
+        includes termination information in the info dictionary.
 
         Args:
             num_tokens (int): Number of tokens in the messages.
             tool_calls (List[ToolCallingRecord]): List of information
                 objects of functions called in the current step.
-            termination_reason (str): String of termination reason.
+            termination_reason (str): String describing the reason for
+                termination.
 
         Returns:
-            ChatAgentResponse: The struct containing trivial outputs and
-                information about token number and called functions.
+            ChatAgentResponse: A response object with empty message list,
+                terminated flag set to True, and an info dictionary containing
+                termination details, token counts, and tool call information.
         """
         self.terminated = True
 

camel/models/mistral_model.py

@@ -25,6 +25,7 @@ if TYPE_CHECKING:
 from openai import AsyncStream
 
 from camel.configs import MISTRAL_API_PARAMS, MistralConfig
+from camel.logger import get_logger
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.models._utils import try_modify_message_with_format
@@ -36,6 +37,8 @@ from camel.utils import (
     dependencies_required,
 )
 
+logger = get_logger(__name__)
+
 try:
     if os.getenv("AGENTOPS_API_KEY") is not None:
         from agentops import LLMEvent, record
@@ -235,7 +238,38 @@ class MistralModel(BaseModelBackend):
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        raise NotImplementedError("Mistral does not support async inference.")
+        logger.warning(
+            "Mistral does not support async inference, using sync "
+            "inference instead."
+        )
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+        mistral_messages = self._to_mistral_chatmessage(messages)
+
+        response = self._client.chat.complete(
+            messages=mistral_messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+        openai_response = self._to_openai_response(response)  # type: ignore[arg-type]
+
+        # Add AgentOps LLM Event tracking
+        if LLMEvent:
+            llm_event = LLMEvent(
+                thread_id=openai_response.id,
+                prompt=" ".join(
+                    [message.get("content") for message in messages]  # type: ignore[misc]
+                ),
+                prompt_tokens=openai_response.usage.prompt_tokens,  # type: ignore[union-attr]
+                completion=openai_response.choices[0].message.content,
+                completion_tokens=openai_response.usage.completion_tokens,  # type: ignore[union-attr]
+                model=self.model_type,
+            )
+            record(llm_event)
+
+        return openai_response
 
     def _run(
         self,

camel/models/model_factory.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
-from typing import Dict, Optional, Type, Union
+from typing import ClassVar, Dict, Optional, Type, Union
 
 import yaml
 
@@ -62,6 +62,44 @@ class ModelFactory:
         ValueError: in case the provided model type is unknown.
     """
 
+    _MODEL_PLATFORM_TO_CLASS_MAP: ClassVar[
+        Dict[ModelPlatformType, Type[BaseModelBackend]]
+    ] = {
+        ModelPlatformType.OLLAMA: OllamaModel,
+        ModelPlatformType.VLLM: VLLMModel,
+        ModelPlatformType.SGLANG: SGLangModel,
+        ModelPlatformType.OPENAI_COMPATIBLE_MODEL: OpenAICompatibleModel,
+        ModelPlatformType.SAMBA: SambaModel,
+        ModelPlatformType.TOGETHER: TogetherAIModel,
+        ModelPlatformType.LITELLM: LiteLLMModel,
+        ModelPlatformType.AWS_BEDROCK: AWSBedrockModel,
+        ModelPlatformType.NVIDIA: NvidiaModel,
+        ModelPlatformType.SILICONFLOW: SiliconFlowModel,
+        ModelPlatformType.AIML: AIMLModel,
+        ModelPlatformType.VOLCANO: VolcanoModel,
+        ModelPlatformType.NETMIND: NetmindModel,
+        ModelPlatformType.OPENAI: OpenAIModel,
+        ModelPlatformType.AZURE: AzureOpenAIModel,
+        ModelPlatformType.ANTHROPIC: AnthropicModel,
+        ModelPlatformType.GROQ: GroqModel,
+        ModelPlatformType.LMSTUDIO: LMStudioModel,
+        ModelPlatformType.OPENROUTER: OpenRouterModel,
+        ModelPlatformType.ZHIPU: ZhipuAIModel,
+        ModelPlatformType.GEMINI: GeminiModel,
+        ModelPlatformType.MISTRAL: MistralModel,
+        ModelPlatformType.REKA: RekaModel,
+        ModelPlatformType.COHERE: CohereModel,
+        ModelPlatformType.YI: YiModel,
+        ModelPlatformType.QWEN: QwenModel,
+        ModelPlatformType.DEEPSEEK: DeepSeekModel,
+        ModelPlatformType.PPIO: PPIOModel,
+        ModelPlatformType.INTERNLM: InternLMModel,
+        ModelPlatformType.MOONSHOT: MoonshotModel,
+        ModelPlatformType.MODELSCOPE: ModelScopeModel,
+        ModelPlatformType.NOVITA: NovitaModel,
+        ModelPlatformType.WATSONX: WatsonXModel,
+    }
+
     @staticmethod
     def create(
         model_platform: Union[ModelPlatformType, str],
@@ -124,81 +162,15 @@ class ModelFactory:
         model_class: Optional[Type[BaseModelBackend]] = None
         model_type = UnifiedModelType(model_type)
 
-        if model_platform.is_ollama:
-            model_class = OllamaModel
-        elif model_platform.is_vllm:
-            model_class = VLLMModel
-        elif model_platform.is_sglang:
-            model_class = SGLangModel
-        elif model_platform.is_openai_compatible_model:
-            model_class = OpenAICompatibleModel
-        elif model_platform.is_samba:
-            model_class = SambaModel
-        elif model_platform.is_together:
-            model_class = TogetherAIModel
-        elif model_platform.is_litellm:
-            model_class = LiteLLMModel
-        elif model_platform.is_aws_bedrock:
-            model_class = AWSBedrockModel
-        elif model_platform.is_nvidia:
-            model_class = NvidiaModel
-        elif model_platform.is_siliconflow:
-            model_class = SiliconFlowModel
-        elif model_platform.is_aiml:
-            model_class = AIMLModel
-        elif model_platform.is_volcano:
-            model_class = VolcanoModel
-        elif model_platform.is_netmind:
-            model_class = NetmindModel
-
-        elif model_platform.is_openai and model_type.is_openai:
-            model_class = OpenAIModel
-        elif model_platform.is_azure and model_type.is_azure_openai:
-            model_class = AzureOpenAIModel
-        elif model_platform.is_anthropic and model_type.is_anthropic:
-            model_class = AnthropicModel
-        elif model_platform.is_groq and model_type.is_groq:
-            model_class = GroqModel
-        elif model_platform.is_lmstudio and model_type.is_lmstudio:
-            model_class = LMStudioModel
-        elif model_platform.is_openrouter and model_type.is_openrouter:
-            model_class = OpenRouterModel
-        elif model_platform.is_zhipuai and model_type.is_zhipuai:
-            model_class = ZhipuAIModel
-        elif model_platform.is_gemini and model_type.is_gemini:
-            model_class = GeminiModel
-        elif model_platform.is_mistral and model_type.is_mistral:
-            model_class = MistralModel
-        elif model_platform.is_reka and model_type.is_reka:
-            model_class = RekaModel
-        elif model_platform.is_cohere and model_type.is_cohere:
-            model_class = CohereModel
-        elif model_platform.is_yi and model_type.is_yi:
-            model_class = YiModel
-        elif model_platform.is_qwen and model_type.is_qwen:
-            model_class = QwenModel
-        elif model_platform.is_deepseek:
-            model_class = DeepSeekModel
-        elif model_platform.is_ppio:
-            model_class = PPIOModel
-        elif model_platform.is_internlm and model_type.is_internlm:
-            model_class = InternLMModel
-        elif model_platform.is_moonshot and model_type.is_moonshot:
-            model_class = MoonshotModel
-        elif model_platform.is_modelscope:
-            model_class = ModelScopeModel
-        elif model_platform.is_novita:
-            model_class = NovitaModel
-        elif model_type == ModelType.STUB:
+        model_class = ModelFactory._MODEL_PLATFORM_TO_CLASS_MAP.get(
+            model_platform
+        )
+
+        if model_type == ModelType.STUB:
             model_class = StubModel
-        elif model_type.is_watsonx:
-            model_class = WatsonXModel
 
         if model_class is None:
-            raise ValueError(
-                f"Unknown pair of model platform `{model_platform}` "
-                f"and model type `{model_type}`."
-            )
+            raise ValueError(f"Unknown model platform `{model_platform}`")
 
         return model_class(
             model_type=model_type,

camel/toolkits/__init__.py

@@ -68,8 +68,10 @@ from .pyautogui_toolkit import PyAutoGUIToolkit
 from .openai_agent_toolkit import OpenAIAgentToolkit
 from .searxng_toolkit import SearxNGToolkit
 from .jina_reranker_toolkit import JinaRerankerToolkit
+from .pulse_mcp_search_toolkit import PulseMCPSearchToolkit
 from .klavis_toolkit import KlavisToolkit
 from .aci_toolkit import ACIToolkit
+from .playwright_mcp_toolkit import PlaywrightMCPToolkit
 
 
 __all__ = [
@@ -126,6 +128,8 @@ __all__ = [
     'OpenAIAgentToolkit',
     'SearxNGToolkit',
     'JinaRerankerToolkit',
+    'PulseMCPSearchToolkit',
     'KlavisToolkit',
     'ACIToolkit',
+    'PlaywrightMCPToolkit',
 ]

camel/toolkits/klavis_toolkit.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 import os
+import urllib.parse
 from typing import Any, Dict, List, Optional
 
 import requests
@@ -169,18 +170,6 @@ class KlavisToolkit(BaseToolkit):
         endpoint = f"/mcp-server/instance/delete/{instance_id}"
         return self._request('DELETE', endpoint)
 
-    def get_server_tools(self, server_name: str) -> Dict[str, Any]:
-        r"""Get list of tool names for a specific MCP server.
-
-        Args:
-            server_name (str): The name of the target MCP server.
-
-        Returns:
-            Dict[str, Any]: List of tools available for the specified server.
-        """
-        endpoint = f"/mcp-server/tools/{server_name}"
-        return self._request('GET', endpoint)
-
     def get_all_servers(self) -> Dict[str, Any]:
         r"""Get all MCP servers with their basic information.
 
@@ -209,6 +198,60 @@ class KlavisToolkit(BaseToolkit):
             'POST', endpoint, payload=payload, additional_headers=headers
         )
 
+    def list_tools(self, server_url: str) -> Dict[str, Any]:
+        r"""Lists all tools available for a specific remote MCP server.
+
+        Args:
+            server_url (str): The full URL for connecting to the MCP server
+                via Server-Sent Events (SSE).
+
+        Returns:
+            Dict[str, Any]: Response containing the list of tools or an error.
+        """
+
+        encoded_server_url = urllib.parse.quote(server_url, safe='')
+        endpoint = f"/mcp-server/list-tools/{encoded_server_url}"
+        return self._request('GET', endpoint)
+
+    def call_tool(
+        self,
+        server_url: str,
+        tool_name: str,
+        tool_args: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        r"""Calls a remote MCP server tool directly using the provided server
+        URL.
+
+        Args:
+            server_url (str): The full URL for connecting to the MCP server
+                via Server-Sent Events (SSE).
+            tool_name (str): The name of the tool to call.
+            tool_args (Optional[Dict[str, Any]]): The input parameters for
+                the tool. Defaults to None, which might be treated as empty
+                args by the server. (default: :obj:`None`)
+
+        Returns:
+            Dict[str, Any]: Response containing the result of the tool call
+                or an error.
+        """
+        endpoint = "/mcp-server/call-tool"
+        payload: Dict[str, Any] = {
+            "serverUrl": server_url,
+            "toolName": tool_name,
+        }
+        # Add toolArgs only if provided, otherwise server might expect empty
+        # dict
+        if tool_args is not None:
+            payload["toolArgs"] = tool_args
+        else:
+            # Explicitly setting to empty dict based on schema interpretation
+            payload["toolArgs"] = {}
+
+        headers = {'Content-Type': 'application/json'}
+        return self._request(
+            'POST', endpoint, payload=payload, additional_headers=headers
+        )
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the functions
         in the toolkit.
@@ -222,7 +265,8 @@ class KlavisToolkit(BaseToolkit):
             FunctionTool(self.get_server_instance),
             FunctionTool(self.delete_auth_data),
             FunctionTool(self.delete_server_instance),
-            FunctionTool(self.get_server_tools),
             FunctionTool(self.get_all_servers),
             FunctionTool(self.set_auth_token),
+            FunctionTool(self.list_tools),
+            FunctionTool(self.call_tool),
         ]

camel/toolkits/mcp_toolkit.py

@@ -16,6 +16,7 @@ import json
 import os
 import shlex
 from contextlib import AsyncExitStack, asynccontextmanager
+from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -52,14 +53,15 @@ class MCPClient(BaseToolkit):
 
     Attributes:
         command_or_url (str): URL for SSE mode or command executable for stdio
-            mode. (default: :obj:`'None'`)
+            mode. (default: :obj:`None`)
         args (List[str]): List of command-line arguments if stdio mode is used.
-            (default: :obj:`'None'`)
+            (default: :obj:`None`)
         env (Dict[str, str]): Environment variables for the stdio mode command.
-            (default: :obj:`'None'`)
-        timeout (Optional[float]): Connection timeout. (default: :obj:`'None'`)
+            (default: :obj:`None`)
+        timeout (Optional[float]): Connection timeout.
+            (default: :obj:`None`)
         headers (Dict[str, str]): Headers for the HTTP request.
-            (default: :obj:`'None'`)
+            (default: :obj:`None`)
         strict (Optional[bool]): Whether to enforce strict mode for the
             function call. (default: :obj:`False`)
     """
@@ -111,6 +113,7 @@ class MCPClient(BaseToolkit):
                     sse_client(
                         self.command_or_url,
                         headers=self.headers,
+                        timeout=self.timeout,
                     )
                 )
             else:
@@ -138,7 +141,11 @@ class MCPClient(BaseToolkit):
                 )
 
             self._session = await self._exit_stack.enter_async_context(
-                ClientSession(read_stream, write_stream)
+                ClientSession(
+                    read_stream,
+                    write_stream,
+                    timedelta(seconds=self.timeout) if self.timeout else None,
+                )
             )
             await self._session.initialize()
             list_tools_result = await self.list_mcp_tools()
@@ -399,17 +406,20 @@ class MCPToolkit(BaseToolkit):
 
     Args:
         servers (Optional[List[MCPClient]]): List of MCPClient
-            instances to manage.
+            instances to manage. (default: :obj:`None`)
         config_path (Optional[str]): Path to a JSON configuration file
-            defining MCP servers.
+            defining MCP servers. (default: :obj:`None`)
+        config_dict (Optional[Dict[str, Any]]): Dictionary containing MCP
+            server configurations in the same format as the config file.
+            (default: :obj:`None`)
         strict (Optional[bool]): Whether to enforce strict mode for the
             function call. (default: :obj:`False`)
 
     Note:
-        Either `servers` or `config_path` must be provided. If both are
-        provided, servers from both sources will be combined.
+        Either `servers`, `config_path`, or `config_dict` must be provided.
+        If multiple are provided, servers from all sources will be combined.
 
-        For web servers in the config file, you can specify authorization
+        For web servers in the config, you can specify authorization
         headers using the "headers" field to connect to protected MCP server
         endpoints.
 
@@ -438,14 +448,19 @@ class MCPToolkit(BaseToolkit):
         self,
         servers: Optional[List[MCPClient]] = None,
         config_path: Optional[str] = None,
+        config_dict: Optional[Dict[str, Any]] = None,
         strict: Optional[bool] = False,
     ):
         super().__init__()
 
-        if servers and config_path:
+        sources_provided = sum(
+            1 for src in [servers, config_path, config_dict] if src is not None
+        )
+        if sources_provided > 1:
             logger.warning(
-                "Both servers and config_path are provided. "
-                "Servers from both sources will be combined."
+                "Multiple configuration sources provided "
+                f"({sources_provided}). Servers from all sources "
+                "will be combined."
             )
 
         self.servers: List[MCPClient] = servers or []
@@ -455,6 +470,9 @@ class MCPToolkit(BaseToolkit):
                 self._load_servers_from_config(config_path, strict)
             )
 
+        if config_dict:
+            self.servers.extend(self._load_servers_from_dict(config_dict))
+
         self._exit_stack = AsyncExitStack()
         self._connected = False
 
@@ -484,9 +502,25 @@ class MCPToolkit(BaseToolkit):
             logger.warning(f"Config file not found: '{config_path}'")
             raise e
 
+        return self._load_servers_from_dict(config=data, strict=strict)
+
+    def _load_servers_from_dict(
+        self, config: Dict[str, Any], strict: Optional[bool] = False
+    ) -> List[MCPClient]:
+        r"""Loads MCP server configurations from a dictionary.
+
+        Args:
+            config (Dict[str, Any]): Dictionary containing server
+                configurations.
+            strict (bool): Whether to enforce strict mode for the
+                function call. (default: :obj:`False`)
+
+        Returns:
+            List[MCPClient]: List of configured MCPClient instances.
+        """
         all_servers = []
 
-        mcp_servers = data.get("mcpServers", {})
+        mcp_servers = config.get("mcpServers", {})
         if not isinstance(mcp_servers, dict):
             logger.warning("'mcpServers' is not a dictionary, skipping...")
             mcp_servers = {}
@@ -505,11 +539,16 @@ class MCPToolkit(BaseToolkit):
                 )
                 continue
 
+            # Include headers if provided in the configuration
+            headers = cfg.get("headers", {})
+
+            cmd_or_url = cast(str, cfg.get("command") or cfg.get("url"))
             server = MCPClient(
-                command_or_url=cast(str, cfg.get("command") or cfg.get("url")),
+                command_or_url=cmd_or_url,
                 args=cfg.get("args", []),
                 env={**os.environ, **cfg.get("env", {})},
                 timeout=cfg.get("timeout", None),
+                headers=headers,
                 strict=strict,
             )
             all_servers.append(server)

camel/toolkits/playwright_mcp_toolkit.py

@@ -0,0 +1,69 @@
+# ========= 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. =========
+
+from typing import List, Optional
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class PlaywrightMCPToolkit(BaseToolkit):
+    r"""PlaywrightMCPToolkit provides an interface for interacting with web
+    browsers using the Playwright automation library through the Model Context
+    Protocol (MCP).
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (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.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "playwright": {
+                        "command": "npx",
+                        "args": ["@playwright/mcp@latest"],
+                    }
+                }
+            }
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the Playwright MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the Playwright MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the PlaywrightMCPToolkit.
+
+        Returns:
+            List[FunctionTool]: List of available tools.
+        """
+        return self._mcp_toolkit.get_tools()

camel/toolkits/pulse_mcp_search_toolkit.py

@@ -0,0 +1,132 @@
+# ========= 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. =========
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+
+@MCPServer()
+class PulseMCPSearchToolkit(BaseToolkit):
+    r"""A toolkit for searching MCP servers using the PulseMCP API."""
+
+    def __init__(self, timeout: Optional[float] = None):
+        super().__init__(timeout=timeout)
+        self.api_base_url = "https://api.pulsemcp.com/v0beta"
+
+    def search_mcp_servers(
+        self,
+        query: Optional[str] = None,
+        top_k: Optional[int] = 5,
+        package_registry: Optional[str] = None,
+        count_per_page: int = 5000,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        r"""Search for MCP servers using the PulseMCP API.
+
+        Args:
+            query (Optional[str]): The query to search for.
+                (default: :obj:`None`)
+            top_k (Optional[int]): After sorting, return only the top_k
+                servers. (default: :obj:`5`)
+            package_registry (Optional[str]): The package registry to search
+                for. (default: :obj:`None`)
+            count_per_page (int): The number of servers to return per page.
+                (default: :obj:`5000`)
+            offset (int): The offset to start the search from.
+                (default: :obj:`0`)
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the search results or
+                an error message.
+        """
+        params: Dict[str, Any] = {
+            "count_per_page": min(count_per_page, 5000),
+            "offset": offset,
+        }
+        if query:
+            params["query"] = query
+
+        response = requests.get(f"{self.api_base_url}/servers", params=params)
+
+        if response.status_code != 200:
+            error_msg = f"Error searching MCP servers: {response.status_code}"
+            if response.text:
+                try:
+                    error_info = response.json()
+                    if "error" in error_info:
+                        msg = error_info['error'].get('message', '')
+                        error_msg = f"{error_msg} - {msg}"
+                except Exception:
+                    error_msg = f"{error_msg} - {response.text}"
+            return {"error": error_msg}
+
+        data = response.json()
+        servers = data.get("servers", [])
+
+        if package_registry:
+            package_registry_lower = package_registry.lower()
+            servers = [
+                server
+                for server in servers
+                if isinstance(server.get("package_registry"), str)
+                and server.get("package_registry").lower()
+                == package_registry_lower
+            ]
+
+        if query:
+            query_lower = query.lower()
+            # Helper function to calculate score
+            # 1. With name +5
+            # 2. With description +3
+            # 3. With stars +1
+
+            def score(server: Dict[str, Any]) -> float:
+                name = server.get("name", "").lower()
+                desc = server.get("short_description", "").lower()
+                stars = server.get("github_stars", 0) or 0
+                score: float = 0.0
+                if query_lower in name:
+                    score += 5
+                if query_lower in desc:
+                    score += 3
+                score += stars / 1000
+                return score
+
+            servers = sorted(servers, key=score, reverse=True)
+        else:
+            servers = sorted(
+                servers,
+                key=lambda x: x.get("github_stars", 0) or 0,
+                reverse=True,
+            )
+
+        if top_k is not None:
+            servers = servers[:top_k]
+
+        return {"servers": servers}
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects.
+        """
+        return [
+            FunctionTool(self.search_mcp_servers),
+        ]

camel/types/enums.py

@@ -196,6 +196,7 @@ class ModelType(UnifiedModelType, Enum):
     MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
     MISTRAL_NEMO = "open-mistral-nemo"
     MISTRAL_PIXTRAL_12B = "pixtral-12b-2409"
+    MISTRAL_MEDIUM_3 = "mistral-medium-latest"
 
     # Reka models
     REKA_CORE = "reka-core"
@@ -475,6 +476,16 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GPT_4_TURBO,
             ModelType.GPT_4O,
             ModelType.GPT_4O_MINI,
+            ModelType.O1,
+            ModelType.O1_PREVIEW,
+            ModelType.O1_MINI,
+            ModelType.O3_MINI,
+            ModelType.GPT_4_5_PREVIEW,
+            ModelType.GPT_4_1,
+            ModelType.GPT_4_1_MINI,
+            ModelType.GPT_4_1_NANO,
+            ModelType.O4_MINI,
+            ModelType.O3,
         }
 
     @property
@@ -586,6 +597,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_PIXTRAL_12B,
             ModelType.MISTRAL_8B,
             ModelType.MISTRAL_3B,
+            ModelType.MISTRAL_MEDIUM_3,
         }
 
     @property
@@ -1094,6 +1106,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NETMIND_DEEPSEEK_R1,
             ModelType.NETMIND_DEEPSEEK_V3,
             ModelType.NOVITA_DEEPSEEK_V3_0324,
+            ModelType.MISTRAL_MEDIUM_3,
         }:
             return 128_000
         elif self in {
@@ -1389,6 +1402,7 @@ class ModelPlatformType(Enum):
     MISTRAL = "mistral"
     REKA = "reka"
     TOGETHER = "together"
+    STUB = "stub"
     OPENAI_COMPATIBLE_MODEL = "openai-compatible-model"
     SAMBA = "samba-nova"
     COHERE = "cohere"
@@ -1577,6 +1591,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is Novita."""
         return self is ModelPlatformType.NOVITA
 
+    @property
+    def is_watsonx(self) -> bool:
+        r"""Returns whether this platform is WatsonX."""
+        return self is ModelPlatformType.WATSONX
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/utils/__init__.py

@@ -44,7 +44,7 @@ from .constants import Constants
 from .deduplication import DeduplicationResult, deduplicate_internally
 from .filename import sanitize_filename
 from .mcp import MCPServer
-from .response_format import get_pydantic_model
+from .response_format import get_pydantic_model, model_from_json_schema
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
@@ -92,6 +92,7 @@ __all__ = [
     "BatchProcessor",
     "with_timeout",
     "MCPServer",
+    "model_from_json_schema",
     "sanitize_filename",
     "browser_toolkit_save_auth_cookie",
 ]

camel/utils/response_format.py

@@ -16,9 +16,9 @@ from __future__ import annotations
 
 import inspect
 import json
-from typing import Callable, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Type, Union
 
-from pydantic import BaseModel, create_model
+from pydantic import BaseModel, Field, create_model
 
 
 def get_pydantic_model(
@@ -61,3 +61,85 @@ def get_pydantic_model(
     if issubclass(input_data, BaseModel):
         return input_data
     raise ValueError("Invalid input data provided.")
+
+
+TYPE_MAPPING = {
+    "integer": int,
+    "number": float,
+    "string": str,
+    "boolean": bool,
+    "array": list,
+    "object": dict,
+}
+
+
+def model_from_json_schema(
+    name: str,
+    schema: Dict[str, Any],
+) -> Type[BaseModel]:
+    r"""Create a Pydantic model from a JSON schema.
+
+    Args:
+        name (str): The name of the model.
+        schema (Dict[str, Any]): The JSON schema to create the model from.
+
+    Returns:
+        Type[BaseModel]: The Pydantic model.
+    """
+    properties = schema.get("properties", {})
+    required_fields = set(schema.get("required", []))
+    fields: Dict[str, Any] = {}
+
+    for field_name, field_schema in properties.items():
+        json_type = field_schema.get("type", "string")
+        # Handle nested objects recursively.
+        if json_type == "object" and "properties" in field_schema:
+            py_type = model_from_json_schema(
+                f"{name}_{field_name}", field_schema
+            )
+        elif json_type == "array":
+            # Process array items if available.
+            items_schema = field_schema.get("items", {"type": "string"})
+            items_type: Type[Any] = TYPE_MAPPING.get(
+                items_schema.get("type", "string"), str
+            )
+            if (
+                items_schema.get("type") == "object"
+                and "properties" in items_schema
+            ):
+                items_type = model_from_json_schema(
+                    f"{name}_{field_name}_item", items_schema
+                )
+            py_type = List[items_type]  # type: ignore[assignment, valid-type]
+        else:
+            py_type = TYPE_MAPPING.get(json_type, str)
+
+        # Handle nullable fields.
+        if field_schema.get("nullable", False):
+            py_type = Optional[py_type]  # type: ignore[assignment]
+
+        # Construct constraints if available.
+        constraints = {}
+        if "minLength" in field_schema:
+            constraints["min_length"] = field_schema["minLength"]
+        if "maxLength" in field_schema:
+            constraints["max_length"] = field_schema["maxLength"]
+        if "minimum" in field_schema:
+            constraints["ge"] = field_schema["minimum"]
+        if "maximum" in field_schema:
+            constraints["le"] = field_schema["maximum"]
+        if "enum" in field_schema:
+            constraints["enum"] = field_schema["enum"]
+        if "description" in field_schema:
+            constraints["description"] = field_schema["description"]
+
+        default_value = field_schema.get("default", None)
+        if field_name in required_fields:
+            fields[field_name] = (py_type, Field(..., **constraints))
+        else:
+            fields[field_name] = (
+                Optional[py_type],
+                Field(default_value, **constraints),
+            )
+
+    return create_model(name, **fields)  # type: ignore[call-overload]

{camel_ai-0.2.54.dist-info → camel_ai-0.2.56.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.54
+Version: 0.2.56
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.54.dist-info → camel_ai-0.2.56.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=6mC_LzkYTRDhA5zSGpvdPlBiTCWzoJKYiy2eQWFw4HU,912
+camel/__init__.py,sha256=YtkzoktMmiyIItoI8OWaV4sxG0yQ8KBjS65mn83J5Jo,912
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=9X09UmxI2JqQnhrFfnZ3B9EzFmVfdSWQcjLWTIXKXe0,4962
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -7,7 +7,7 @@ camel/agents/__init__.py,sha256=64weKqdvmpZcGWyVkO-OKASAmVUdrQjv60JApgPk_SA,1644
 camel/agents/_types.py,sha256=ryPRmEXnpNtbFT23GoAcwK-zxWWsIOqYu64mxMx_PhI,1430
 camel/agents/_utils.py,sha256=AR7Qqgbkmn4X2edYUQf1rdksGUyV5hm3iK1z-Dn0Mcg,6266
 camel/agents/base.py,sha256=c4bJYL3G3Z41SaFdMPMn8ZjLdFiFaVOFO6EQIfuCVR8,1124
-camel/agents/chat_agent.py,sha256=DTP9-tFryDu4ezbrVUS-H671ccBXZa4Tz7KxARawtyw,58962
+camel/agents/chat_agent.py,sha256=s19qJ0eK_bVX6P-yIoazO4cMUeAumwVY1XFNVKaDfVo,59281
 camel/agents/critic_agent.py,sha256=qFVlHlQo0CVgmPWfWYLT8_oP_KyzCLFsQw_nN_vu5Bs,7487
 camel/agents/deductive_reasoner_agent.py,sha256=6BZGaq1hR6hKJuQtOfoYQnk_AkZpw_Mr7mUy2MspQgs,13540
 camel/agents/embodied_agent.py,sha256=XBxBu5ZMmSJ4B2U3Z7SMwvLlgp6yNpaBe8HNQmY9CZA,7536
@@ -176,8 +176,8 @@ camel/models/groq_model.py,sha256=596VqRJ_yxv9Jz3sG7UVXVkIjZI1nX7zQAD709m4uig,37
 camel/models/internlm_model.py,sha256=l7WjJ7JISCCqkezhEXzmjj_Mvhqhxxhsg4NuenP7w9w,4374
 camel/models/litellm_model.py,sha256=rlSt3EnBAAYyoIxq0_XTuRmRnc4RWvD2Z14yIrI_7uw,5942
 camel/models/lmstudio_model.py,sha256=_Lnv0e2ichks_MrNJGNIawEtGtP7T_xX8v0bFNNeWes,3641
-camel/models/mistral_model.py,sha256=lsvfxhwp9aDGRpGKLt6Mwtnlw27jFp8AbpGw0UTHJds,12186
-camel/models/model_factory.py,sha256=dS5K44jAa1atbicYwKfNFeSVGlgR97rNTQ74Gm_GMOE,12700
+camel/models/mistral_model.py,sha256=3tT59xJO0rwZK0Gs0RXtV6TC9g6uEO9gD7D_-NzhHDc,13399
+camel/models/model_factory.py,sha256=e-dRSZgNGXCgjgdxDl125qtdts7o9M0RQ6mY8qzoBO0,11470
 camel/models/model_manager.py,sha256=gfpL-WUxuTXgNeCkIVg8Y0zRvxMqRLX8JGt0XEAPQ8Y,9214
 camel/models/modelscope_model.py,sha256=aI7i50DSIE6MO2U_WvULan6Sk4b5d7iZoEHQaARo4FA,10487
 camel/models/moonshot_model.py,sha256=yeD2jrfQpFaWJHVe1s1KrI6aHQVzKRcBDt9C2Qo4nU8,4305
@@ -295,7 +295,7 @@ camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
 camel/terminators/response_terminator.py,sha256=n3G5KP6Oj7-7WlRN0yFcrtLpqAJKaKS0bmhrWlFfCgQ,4982
 camel/terminators/token_limit_terminator.py,sha256=YWv6ZR8R9yI2Qnf_3xES5bEE_O5bb2CxQ0EUXfMh34c,2118
-camel/toolkits/__init__.py,sha256=Vv5yd6_14j6lMhb8XF9R5GBieeLyheM683uVemJaIH4,4483
+camel/toolkits/__init__.py,sha256=JbvxFf-wUFClNSriXB56LkhaRipw4n4PEc2M9f5-47o,4657
 camel/toolkits/aci_toolkit.py,sha256=jhXMQggG22hd3dXdT3iJm7qWTH3KJC-TUVk1txoNWrM,16079
 camel/toolkits/arxiv_toolkit.py,sha256=Bs2-K1yfmqhEhHoQ0j00KoI8LpOd8M3ApXcvI_-ApVw,6303
 camel/toolkits/ask_news_toolkit.py,sha256=WfWaqwEo1Apbil3-Rb5y65Ws43NU4rAFWZu5VHe4los,23448
@@ -316,10 +316,10 @@ camel/toolkits/google_scholar_toolkit.py,sha256=WQ9a0HQr0vro1Uo1m--alCUXvMmaHVKe
 camel/toolkits/human_toolkit.py,sha256=ZbhXPA0G3mQkcNW_jPwywReAft2pIJG0WkVXOG48s1w,2328
 camel/toolkits/image_analysis_toolkit.py,sha256=gnbX2by7_pxPpjUEY8bOj1tV-hGC3mwqEvQRMXyZ9TM,7535
 camel/toolkits/jina_reranker_toolkit.py,sha256=U-V9qZ7SKP3SPTh_0CsE7ZKNqS9jNkmKYsIN1Mk-vFY,8118
-camel/toolkits/klavis_toolkit.py,sha256=L-OiGwgaIue8QiIijNlvGbgtwjGUszLqs9bVRW5md7c,8244
+camel/toolkits/klavis_toolkit.py,sha256=ZKerhgz5e-AV-iv0ftf07HgWikknIHjB3EOQswfuR80,9864
 camel/toolkits/linkedin_toolkit.py,sha256=wn4eXwYYlVA7doTna7k7WYhUqTBF83W79S-UJs_IQr0,8065
 camel/toolkits/math_toolkit.py,sha256=KdI8AJ9Dbq5cfWboAYJUYgSkmADMCO5eZ6yqYkWuiIQ,3686
-camel/toolkits/mcp_toolkit.py,sha256=yBpF6L3mzIs4Ecr3VAyex61CerENOR7ekU0oqAG9WNQ,20449
+camel/toolkits/mcp_toolkit.py,sha256=a2Jdf0TyxqB-P1hB_dh33nH88cEunFMnh7qjgs1H1aQ,21996
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
 camel/toolkits/meshy_toolkit.py,sha256=NbgdOBD3FYLtZf-AfonIv6-Q8-8DW129jsaP1PqI2rs,7126
 camel/toolkits/mineru_toolkit.py,sha256=vRX9LholLNkpbJ6axfEN4pTG85aWb0PDmlVy3rAAXhg,6868
@@ -329,7 +329,9 @@ camel/toolkits/open_api_toolkit.py,sha256=Venfq8JwTMQfzRzzB7AYmYUMEX35hW0BjIv_oz
 camel/toolkits/openai_agent_toolkit.py,sha256=hT2ancdQigngAiY1LNnGJzZeiBDHUxrRGv6BdZTJizc,4696
 camel/toolkits/openbb_toolkit.py,sha256=8yBZL9E2iSgskosBQhD3pTP56oV6gerWpFjIJc_2UMo,28935
 camel/toolkits/page_script.js,sha256=gypbuQ_gn_oa3rQDoCN_q-kJ0jND1eSvY-30PufPZmQ,12613
+camel/toolkits/playwright_mcp_toolkit.py,sha256=_TcCRA3ECaWO0pqUjoZ2whfWXgvank4A4isqNjgZqqc,2403
 camel/toolkits/pubmed_toolkit.py,sha256=VGl8KeyWi7pjb2kEhFBLmpBlP9ezv8JyWRHtEVTQ6nQ,12227
+camel/toolkits/pulse_mcp_search_toolkit.py,sha256=uLUpm19uC_4xLJow0gGVS9f-5T5EW2iRAXdJ4nqJG-A,4783
 camel/toolkits/pyautogui_toolkit.py,sha256=Q810fm8cFvElRory7B74aqS2YV6BOpdRE6jkewoM8xc,16093
 camel/toolkits/reddit_toolkit.py,sha256=x0XAT1zQJVNHUr1R1HwWCgIlkamU-kPmbfb_H1WIv-w,8036
 camel/toolkits/retrieval_toolkit.py,sha256=BKjEyOqW3cGEPTS5yHPYb-Qg795iNNPIs1wjowfuq3U,3825
@@ -373,19 +375,19 @@ camel/toolkits/open_api_specs/web_scraper/openapi.yaml,sha256=u_WalQ01e8W1D27VnZ
 camel/toolkits/open_api_specs/web_scraper/paths/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/web_scraper/paths/scraper.py,sha256=aWy1_ppV4NVVEZfnbN3tu9XA9yAPAC9bRStJ5JuXMRU,1117
 camel/types/__init__.py,sha256=Xdkjh7TQDAQUQ7pFnt7i_rLjjOhsJJnhzusARcFc94Q,2311
-camel/types/enums.py,sha256=4X3QusgMsmJhvAAoWj5r3PcUg7HyiQwRii4pVE7QLr8,57696
+camel/types/enums.py,sha256=ULkVZwiCBO6tjemF8V_A7BlYsSWJH1owp2UVDE39N4A,58317
 camel/types/openai_types.py,sha256=8ZFzLe-zGmKNPfuVZFzxlxAX98lGf18gtrPhOgMmzus,2104
 camel/types/unified_model_type.py,sha256=TpiUmJ3IuX8LNLtTUeUcVM7U82r4ClSq3ZQlNX3ODKs,5351
 camel/types/agents/__init__.py,sha256=cbvVkogPoZgcwZrgxLH6EtpGXk0kavF79nOic0Dc1vg,786
 camel/types/agents/tool_calling_record.py,sha256=qa-vLyKvYzWprRkFFl1928xaw9CnfacIebHaqM-oY3s,1814
-camel/utils/__init__.py,sha256=R2VaBRjYDslfF0qlPgE7-EIdcTNV-mQMWXbEAZ0CsuY,2815
+camel/utils/__init__.py,sha256=v4ugilUllTQGUSjnCfDvpoFGhWo3JMA7JRZlBceftic,2869
 camel/utils/async_func.py,sha256=KqoktGSWjZBuAMQ2CV0X6FRgHGlzCKLfeaWvp-f1Qz8,1568
 camel/utils/commons.py,sha256=3XofL3nZ-tZ3DQLWmP41CAp8lT-ictBBsttJdRJjL4Q,36323
 camel/utils/constants.py,sha256=cqnxmpUeOwrtsR-tRO4bbOc6ZP19TLj7avjm3FONMJs,1410
 camel/utils/deduplication.py,sha256=UHikAtOW1TTDunf2t_wa2kFbmkrXWf7HfOKwLvwCxzo,8958
 camel/utils/filename.py,sha256=HYNc1wbSCgNR1CN21cwHxdAhpnsf5ySJ6jUDfeqOK20,2532
 camel/utils/mcp.py,sha256=iuthL8VuUXIRU34Nvx8guq7frfglpZoxewUKuAg3e1s,5077
-camel/utils/response_format.py,sha256=9KrbwtOM9cA3LSjTgLiK7oKy-53_uMh1cvpyNwwJpng,2419
+camel/utils/response_format.py,sha256=xZcx6xBxeg3A0e7R0JCMJdNm2oQ1-diqVLs0JsiCkZU,5319
 camel/utils/token_counting.py,sha256=apkERzNoVc4sgvJvWVosvepX3KH8pVypVjrL4AA7RB4,17521
 camel/utils/chunker/__init__.py,sha256=6iN6HL6sblIjDuJTILk-9qKcHBZ97t8b6tZCWPZ0OYI,899
 camel/utils/chunker/base.py,sha256=9CuqymFCRncyAdEST-IcRonB732YAPhusznqH-RES3E,960
@@ -397,7 +399,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.54.dist-info/METADATA,sha256=d8FvLrmsbJjNmkNMBo5dUHjdCoWCxMn7Xt98QOgE-pY,44254
-camel_ai-0.2.54.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.54.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.54.dist-info/RECORD,,
+camel_ai-0.2.56.dist-info/METADATA,sha256=EJjtjqfftYHbjaVC_Nv8Kavlpf32Kj685q-2sE98GH4,44254
+camel_ai-0.2.56.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.56.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.56.dist-info/RECORD,,