camel-ai 0.2.58__py3-none-any.whl → 0.2.60__py3-none-any.whl

camel/configs/cohere_config.py

@@ -74,4 +74,4 @@ class CohereConfig(BaseConfig):
     p: Optional[float] = None
 
 
-COHERE_API_PARAMS = {param for param in CohereConfig().model_fields.keys()}
+COHERE_API_PARAMS = {param for param in CohereConfig.model_fields.keys()}

camel/configs/mistral_config.py

@@ -76,4 +76,4 @@ class MistralConfig(BaseConfig):
         return response_format
 
 
-MISTRAL_API_PARAMS = {param for param in MistralConfig().model_fields.keys()}
+MISTRAL_API_PARAMS = {param for param in MistralConfig.model_fields.keys()}

camel/configs/openai_config.py

@@ -104,6 +104,8 @@ class ChatGPTConfig(BaseConfig):
         parallel_tool_calls (bool, optional): A parameter specifying whether
             the model should call tools in parallel or not.
             (default: :obj:`None`)
+        extra_headers: Optional[Dict[str, str]]: Extra headers to use for the
+            model. (default: :obj:`None`)
     """
 
     temperature: Optional[float] = None
@@ -120,6 +122,7 @@ class ChatGPTConfig(BaseConfig):
     tool_choice: Optional[Union[Dict[str, str], str]] = None
     reasoning_effort: Optional[str] = None
     parallel_tool_calls: Optional[bool] = None
+    extra_headers: Optional[Dict[str, str]] = None
 
 
 OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}

camel/configs/reka_config.py

@@ -66,4 +66,4 @@ class RekaConfig(BaseConfig):
     use_search_engine: Optional[bool] = None
 
 
-REKA_API_PARAMS = {param for param in RekaConfig().model_fields.keys()}
+REKA_API_PARAMS = {param for param in RekaConfig.model_fields.keys()}

camel/configs/samba_config.py

@@ -65,7 +65,7 @@ class SambaVerseAPIConfig(BaseConfig):
 
 
 SAMBA_VERSE_API_PARAMS = {
-    param for param in SambaVerseAPIConfig().model_fields.keys()
+    param for param in SambaVerseAPIConfig.model_fields.keys()
 }
 
 
@@ -160,5 +160,5 @@ class SambaCloudAPIConfig(BaseConfig):
 
 
 SAMBA_CLOUD_API_PARAMS = {
-    param for param in SambaCloudAPIConfig().model_fields.keys()
+    param for param in SambaCloudAPIConfig.model_fields.keys()
 }

camel/datagen/cot_datagen.py

@@ -204,26 +204,23 @@ class CoTDataGenerator:
         logger.info("Answer verification result: %s", is_correct)
         return is_correct
 
-    def monte_carlo_tree_search(
+    def evaluate_partial_solution(
         self, question: str, partial_solution: str = ""
     ) -> float:
-        r"""Perform Monte Carlo Tree Search to find the best solution.
+        r"""Evaluate the quality of a partial solution against the
+        golden answer.
 
-        Process:
-        a. Selection: Choose promising partial solutions based on previous
-        scores
-        b. Expansion: Generate new solution steps using the generator agent
-        c. Simulation: Evaluate solution quality using similarity scores
-        d. Backpropagation: Update solution tree with new findings
+        This function generates a similarity score between the given partial
+        solution and the correct answer (golden answer).
 
         Args:
-            question (str): The question to solve.
-            partial_solution (str): The current partial solution.
+            question (str): The question being solved.
+            partial_solution (str): The partial solution generated so far.
                 (default::obj:`""`)
 
         Returns:
-            float: The similarity score between the current
-                solution and golden answer.
+            float: A similarity score between 0 and 1, indicating how close the
+                partial solution is to the golden answer.
         """
         if question not in self.golden_answers:
             raise ValueError(
@@ -293,10 +290,21 @@ class CoTDataGenerator:
         r"""Solve a question using a multi-step approach.
 
         The solution process follows these steps:
-        1. Try to solve directly - if correct, return the solution
-        2. If not correct, use Monte Carlo Tree Search to find a good solution
-        3. If the solution isn't perfect, use binary search to locate errors
-        4. Generate a new solution based on the correct part
+        1. Try to solve directly - if correct, return the solution.
+        2. If not correct, perform a search by iteratively generating
+        new solutions and evaluating their similarity scores to
+        find a good solution. The search process involves:
+            a. Generation: Generate new solution candidates using
+            the generator agent.
+            b. Evaluation: Score each solution candidate for similarity
+            to the golden answer.
+            c. Selection: Keep the best-scoring candidate found so far.
+            d. Early stopping: If a sufficiently high-scoring solution
+            is found (score > 0.9), stop early.
+        3. If the solution isn't perfect, use binary search to locate
+        errors.
+        4. Generate a new solution based on the correct part of the
+        initial solution.
 
         Args:
             question (str): The question to solve.
@@ -304,14 +312,14 @@ class CoTDataGenerator:
         Returns:
             str: The best solution found.
         """
+
         # 1. Try direct solution first
         solution = self.get_answer(question)
         if self.verify_answer(question, solution):
             logger.info("Initial solution is correct")
             return solution
 
-        # 2. If direct solution fails, try Monte Carlo Tree Search
-        # to find a solution with high similarity score
+        # 2. If direct solution fails, iteratively search for a better solution
         best_solution = ""
         best_score: float = 0.0
         for i in range(self.search_limit):
@@ -319,23 +327,10 @@ class CoTDataGenerator:
             current_solution = self.get_answer(question, best_solution)
 
             # Evaluate solution similarity score
-            prompt = (
-                f"Please evaluate this solution and "
-                f"give a score between 0-1:\n"
-                f"Question: {question}\n"
-                f"Solution: {current_solution}\n"
-                f"Correct answer: {self.golden_answers.get(question, '')}\n"
-                f"Return a JSON object with a single field 'score' containing "
-                f"a float between 0 and 1, like this: {{'score': 0.85}}\n"
-            )
-            self.generator_agent.reset()
-            response = self.generator_agent.step(prompt)
             try:
-                response = self.generator_agent.step(
-                    prompt, response_format=AgentResponse
+                score = self.evaluate_partial_solution(
+                    question, current_solution
                 )
-                agent_response = response.msgs[0].parsed.score  # type: ignore [union-attr]
-                score = agent_response
 
                 # Exit early if we find a very good solution (score > 0.9)
                 if score > 0.9:
@@ -357,7 +352,7 @@ class CoTDataGenerator:
                     best_score,
                 )
             except Exception as e:
-                logger.error("Error parsing agent response: %s", str(e))
+                logger.error("Error evaluating partial solution: %s", str(e))
                 continue
 
         # 3. If the answer is not completely correct,

camel/embeddings/jina_embedding.py

@@ -12,6 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+# Enables postponed evaluation of annotations (for string-based type hints)
+from __future__ import annotations
+
 import base64
 import io
 import os
@@ -104,6 +107,7 @@ class JinaEmbedding(BaseEmbedding[Union[str, Image.Image]]):
             ValueError: If the input type is not supported.
             RuntimeError: If the API request fails.
         """
+
         input_data = []
         for obj in objs:
             if isinstance(obj, str):
@@ -111,7 +115,10 @@ class JinaEmbedding(BaseEmbedding[Union[str, Image.Image]]):
                     input_data.append({"text": obj})
                 else:
                     input_data.append(obj)  # type: ignore[arg-type]
-            elif isinstance(obj, Image.Image):
+            elif (
+                obj.__class__.__module__ == "PIL.Image"
+                and obj.__class__.__name__ == "Image"
+            ):
                 if self.model_type != EmbeddingModelType.JINA_CLIP_V2:
                     raise ValueError(
                         f"Model {self.model_type} does not support "

camel/embeddings/sentence_transformers_embeddings.py

@@ -15,8 +15,6 @@ from __future__ import annotations
 
 from typing import Any
 
-from numpy import ndarray
-
 from camel.embeddings.base import BaseEmbedding
 
 
@@ -61,6 +59,8 @@ class SentenceTransformerEncoder(BaseEmbedding[str]):
             list[list[float]]: A list that represents the generated embedding
                 as a list of floating-point numbers.
         """
+        from numpy import ndarray
+
         if not objs:
             raise ValueError("Input text list is empty")
         embeddings = self.model.encode(

camel/embeddings/vlm_embedding.py

@@ -11,6 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+# Enables postponed evaluation of annotations (for string-based type hints)
+from __future__ import annotations
+
 from typing import Any, List, Optional, Union
 
 from PIL import Image
@@ -70,7 +74,7 @@ class VisionLanguageEmbedding(BaseEmbedding[Union[str, Image.Image]]):
     def embed_list(
         self, objs: List[Union[Image.Image, str]], **kwargs: Any
     ) -> List[List[float]]:
-        """Generates embeddings for the given images or texts.
+        r"""Generates embeddings for the given images or texts.
 
         Args:
             objs (List[Image.Image|str]): The list of images or texts for
@@ -98,7 +102,10 @@ class VisionLanguageEmbedding(BaseEmbedding[Union[str, Image.Image]]):
 
         result_list = []
         for obj in objs:
-            if isinstance(obj, Image.Image):
+            if (
+                obj.__class__.__module__ == "PIL.Image"
+                and obj.__class__.__name__ == "Image"
+            ):
                 image_input = self.processor(
                     images=obj,
                     return_tensors="pt",

camel/human.py

@@ -136,3 +136,17 @@ class Human:
         content = self.parse_input(human_input)
         message = meta_chat_message.create_new_instance(content)
         return ChatAgentResponse(msgs=[message], terminated=False, info={})
+
+    def clone(self, with_memory: bool = False) -> 'Human':
+        r"""Creates a new instance of the Human class with the same
+        attributes.
+
+        Args:
+            with_memory (bool): Flag indicating whether to include memory in
+                the cloned instance. Currently not used.
+                (default: :obj:`False`)
+
+        Returns:
+            Human: A new Human instance with the same name and logger_color.
+        """
+        return Human(name=self.name, logger_color=self.logger_color)

camel/memories/records.py

@@ -12,6 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+# Enables postponed evaluation of annotations (for string-based type hints)
+from __future__ import annotations
+
 from dataclasses import asdict
 from datetime import datetime, timezone
 from typing import Any, ClassVar, Dict

camel/messages/base.py

@@ -11,13 +11,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+# Enables postponed evaluation of annotations (for string-based type hints)
+from __future__ import annotations
+
 import base64
 import io
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Union,
+)
 
-import numpy as np
 from PIL import Image
 from pydantic import BaseModel
 
@@ -48,7 +59,7 @@ class BaseMessage:
         role_name (str): The name of the user or assistant role.
         role_type (RoleType): The type of role, either :obj:`RoleType.
             ASSISTANT` or :obj:`RoleType.USER`.
-        meta_dict (Optional[Dict[str, str]]): Additional metadata dictionary
+        meta_dict (Optional[Dict[str, Any]]): Additional metadata dictionary
             for the message.
         content (str): The content of the message.
         video_bytes (Optional[bytes]): Optional bytes of a video associated
@@ -457,6 +468,7 @@ class BaseMessage:
 
         if self.video_bytes:
             import imageio.v3 as iio
+            import numpy as np
 
             base64Frames: List[str] = []
             frame_count = 0

camel/models/azure_openai_model.py

@@ -62,6 +62,7 @@ class AzureOpenAIModel(BaseModelBackend):
             environment variable or default to 180 seconds.
             (default: :obj:`None`)
 
+
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
     """

camel/models/model_factory.py

@@ -14,8 +14,6 @@
 import json
 from typing import ClassVar, Dict, Optional, Type, Union
 
-import yaml
-
 from camel.models.aiml_model import AIMLModel
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.aws_bedrock_model import AWSBedrockModel
@@ -221,6 +219,8 @@ class ModelFactory:
 
     @classmethod
     def __load_yaml(cls, filepath: str) -> Dict:
+        import yaml
+
         r"""Loads and parses a YAML file into a dictionary.
 
         Args:

camel/retrievers/bm25_retriever.py

@@ -13,8 +13,6 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from typing import Any, Dict, List
 
-import numpy as np
-
 from camel.loaders import UnstructuredIO
 from camel.retrievers import BaseRetriever
 from camel.utils import dependencies_required
@@ -106,6 +104,7 @@ class BM25Retriever(BaseRetriever):
                 model has not been initialized by calling `process`
                 first.
         """
+        import numpy as np
 
         if top_k <= 0:
             raise ValueError("top_k must be a positive integer.")

camel/retrievers/hybrid_retrival.py

@@ -13,8 +13,6 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from typing import Any, Collection, Dict, List, Optional, Sequence, Union
 
-import numpy as np
-
 from camel.embeddings import BaseEmbedding
 from camel.retrievers import BaseRetriever, BM25Retriever, VectorRetriever
 from camel.storages import BaseVectorStorage
@@ -96,6 +94,8 @@ class HybridRetriever(BaseRetriever):
             https://medium.com/@devalshah1619/mathematical-intuition-behind-reciprocal-rank-fusion-rrf-explained-in-2-mins-002df0cc5e2a
             https://colab.research.google.com/drive/1iwVJrN96fiyycxN1pBqWlEr_4EPiGdGy#scrollTo=0qh83qGV2dY8
         """
+        import numpy as np
+
         text_to_id = {}
         id_to_info = {}
         current_id = 1

camel/societies/role_playing.py

@@ -120,6 +120,9 @@ class RolePlaying:
         self.task_type = task_type
         self.task_prompt = task_prompt
 
+        self.task_specify_agent_kwargs = task_specify_agent_kwargs
+        self.task_planner_agent_kwargs = task_planner_agent_kwargs
+
         self.specified_task_prompt: Optional[TextPrompt] = None
         self._init_specified_task_prompt(
             assistant_role_name,
@@ -680,3 +683,50 @@ class RolePlaying:
                 info=user_response.info,
             ),
         )
+
+    def clone(
+        self, task_prompt: str, with_memory: bool = False
+    ) -> 'RolePlaying':
+        r"""Creates a new instance of RolePlaying with the same configuration.
+
+        Args:
+            task_prompt (str): The task prompt to be used by the new instance.
+            with_memory (bool, optional): Whether to copy the memory
+                (conversation history) to the new instance. If True, the new
+                instance will have the same conversation history. If False,
+                the new instance will have a fresh memory.
+                (default: :obj:`False`)
+
+        Returns:
+            RolePlaying: A new instance of RolePlaying with the same
+                configuration.
+        """
+
+        new_instance = RolePlaying(
+            assistant_role_name=self.assistant_agent.role_name,
+            user_role_name=self.user_agent.role_name,
+            task_prompt=task_prompt,
+            with_task_specify=self.with_task_specify,
+            task_specify_agent_kwargs=self.task_specify_agent_kwargs,
+            with_task_planner=self.with_task_planner,
+            task_planner_agent_kwargs=self.task_planner_agent_kwargs,
+            with_critic_in_the_loop=False,
+            model=self.model,
+            task_type=self.task_type,
+        )
+        tmp_assistant_sys_msg = new_instance.assistant_sys_msg
+        new_instance.assistant_agent = self.assistant_agent.clone(with_memory)
+        new_instance.assistant_sys_msg = tmp_assistant_sys_msg
+        new_instance.assistant_agent._system_message = tmp_assistant_sys_msg
+
+        tmp_user_sys_msg = new_instance.user_sys_msg
+        new_instance.user_agent = self.user_agent.clone(with_memory)
+        new_instance.user_sys_msg = tmp_user_sys_msg
+        new_instance.user_agent._system_message = tmp_user_sys_msg
+
+        new_instance.with_critic_in_the_loop = self.with_critic_in_the_loop
+        new_instance.critic_sys_msg = self.critic_sys_msg
+        if self.critic:
+            new_instance.critic = self.critic.clone(with_memory)
+
+        return new_instance

camel/societies/workforce/role_playing_worker.py

@@ -38,14 +38,17 @@ class RolePlayingWorker(Worker):
         description (str): Description of the node.
         assistant_role_name (str): The role name of the assistant agent.
         user_role_name (str): The role name of the user agent.
-        assistant_agent_kwargs (Optional[Dict], optional): The keyword
-            arguments to initialize the assistant agent in the role playing,
-            like the model name, etc. Defaults to None.
-        user_agent_kwargs (Optional[Dict], optional): The keyword arguments to
+        assistant_agent_kwargs (Optional[Dict]): The keyword arguments to
+            initialize the assistant agent in the role playing, like the model
+            name, etc. (default: :obj:`None`)
+        user_agent_kwargs (Optional[Dict]): The keyword arguments to
             initialize the user agent in the role playing, like the model name,
-            etc. Defaults to None.
-        chat_turn_limit (int, optional): The maximum number of chat turns in
-            the role playing. Defaults to 3.
+            etc. (default: :obj:`None`)
+        summarize_agent_kwargs (Optional[Dict]): The keyword arguments to
+            initialize the summarize agent, like the model name, etc.
+            (default: :obj:`None`)
+        chat_turn_limit (int): The maximum number of chat turns in the role
+            playing. (default: :obj:`3`)
     """
 
     def __init__(
@@ -55,9 +58,11 @@ class RolePlayingWorker(Worker):
         user_role_name: str,
         assistant_agent_kwargs: Optional[Dict] = None,
         user_agent_kwargs: Optional[Dict] = None,
+        summarize_agent_kwargs: Optional[Dict] = None,
         chat_turn_limit: int = 3,
     ) -> None:
         super().__init__(description)
+        self.summarize_agent_kwargs = summarize_agent_kwargs
         summ_sys_msg = BaseMessage.make_assistant_message(
             role_name="Summarizer",
             content="You are a good summarizer. You will be presented with "
@@ -65,7 +70,11 @@ class RolePlayingWorker(Worker):
             "are trying to solve a task. Your job is summarizing the result "
             "of the task based on the chat history.",
         )
-        self.summarize_agent = ChatAgent(summ_sys_msg)
+        summarize_agent_dict = (
+            summarize_agent_kwargs if summarize_agent_kwargs else {}
+        )
+        summarize_agent_dict['system_message'] = summ_sys_msg
+        self.summarize_agent = ChatAgent(**summarize_agent_dict)
         self.chat_turn_limit = chat_turn_limit
         self.assistant_role_name = assistant_role_name
         self.user_role_name = user_role_name

camel/societies/workforce/workforce.py

@@ -202,6 +202,7 @@ class Workforce(BaseNode):
         user_role_name: str,
         assistant_agent_kwargs: Optional[Dict] = None,
         user_agent_kwargs: Optional[Dict] = None,
+        summarize_agent_kwargs: Optional[Dict] = None,
         chat_turn_limit: int = 3,
     ) -> Workforce:
         r"""Add a worker node to the workforce that uses `RolePlaying` system.
@@ -210,25 +211,29 @@ class Workforce(BaseNode):
             description (str): Description of the node.
             assistant_role_name (str): The role name of the assistant agent.
             user_role_name (str): The role name of the user agent.
-            assistant_agent_kwargs (Optional[Dict], optional): The keyword
-                arguments to initialize the assistant agent in the role
-                playing, like the model name, etc. Defaults to `None`.
-            user_agent_kwargs (Optional[Dict], optional): The keyword arguments
-                to initialize the user agent in the role playing, like the
-                model name, etc. Defaults to `None`.
-            chat_turn_limit (int, optional): The maximum number of chat turns
-                in the role playing. Defaults to 3.
+            assistant_agent_kwargs (Optional[Dict]): The keyword arguments to
+                initialize the assistant agent in the role playing, like the
+                model name, etc. (default: :obj:`None`)
+            user_agent_kwargs (Optional[Dict]): The keyword arguments to
+                initialize the user agent in the role playing, like the
+                model name, etc. (default: :obj:`None`)
+            summarize_agent_kwargs (Optional[Dict]): The keyword arguments to
+                initialize the summarize agent, like the model name, etc.
+                (default: :obj:`None`)
+            chat_turn_limit (int): The maximum number of chat turns in the
+                role playing. (default: :obj:`3`)
 
         Returns:
             Workforce: The workforce node itself.
         """
         worker_node = RolePlayingWorker(
-            description,
-            assistant_role_name,
-            user_role_name,
-            assistant_agent_kwargs,
-            user_agent_kwargs,
-            chat_turn_limit,
+            description=description,
+            assistant_role_name=assistant_role_name,
+            user_role_name=user_role_name,
+            assistant_agent_kwargs=assistant_agent_kwargs,
+            user_agent_kwargs=user_agent_kwargs,
+            summarize_agent_kwargs=summarize_agent_kwargs,
+            chat_turn_limit=chat_turn_limit,
         )
         self._children.append(worker_node)
         return self
@@ -501,3 +506,54 @@ class Workforce(BaseNode):
         for child_task in self._child_listening_tasks:
             child_task.cancel()
         self._running = False
+
+    def clone(self, with_memory: bool = False) -> 'Workforce':
+        r"""Creates a new instance of Workforce with the same configuration.
+
+        Args:
+            with_memory (bool, optional): Whether to copy the memory
+                (conversation history) to the new instance. If True, the new
+                instance will have the same conversation history. If False,
+                the new instance will have a fresh memory.
+                (default: :obj:`False`)
+
+        Returns:
+            Workforce: A new instance of Workforce with the same configuration.
+        """
+
+        # Create a new instance with the same configuration
+        new_instance = Workforce(
+            description=self.description,
+            coordinator_agent_kwargs={},
+            task_agent_kwargs={},
+            new_worker_agent_kwargs=self.new_worker_agent_kwargs,
+        )
+
+        new_instance.task_agent = self.task_agent.clone(with_memory)
+        new_instance.coordinator_agent = self.coordinator_agent.clone(
+            with_memory
+        )
+
+        for child in self._children:
+            if isinstance(child, SingleAgentWorker):
+                cloned_worker = child.worker.clone(with_memory)
+                new_instance.add_single_agent_worker(
+                    child.description, cloned_worker
+                )
+            elif isinstance(child, RolePlayingWorker):
+                new_instance.add_role_playing_worker(
+                    child.description,
+                    child.assistant_role_name,
+                    child.user_role_name,
+                    child.assistant_agent_kwargs,
+                    child.user_agent_kwargs,
+                    child.summarize_agent_kwargs,
+                    child.chat_turn_limit,
+                )
+            elif isinstance(child, Workforce):
+                new_instance.add_workforce(child.clone(with_memory))
+            else:
+                logger.warning(f"{type(child)} is not being cloned.")
+                continue
+
+        return new_instance

camel/storages/vectordb_storages/oceanbase.py

@@ -16,8 +16,6 @@ import json
 import logging
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
 
-from sqlalchemy import JSON, Column, Integer
-
 if TYPE_CHECKING:
     from pyobvector.client import ObVecClient
 
@@ -80,6 +78,7 @@ class OceanBaseStorage(BaseVectorStorage):
             IndexParams,
         )
         from pyobvector.schema import VECTOR
+        from sqlalchemy import JSON, Column, Integer
 
         self.vector_dim: int = vector_dim
         self.table_name: str = table_name

camel/toolkits/async_browser_toolkit.py

@@ -11,6 +11,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+# Enables postponed evaluation of annotations (for string-based type hints)
+from __future__ import annotations
+
 import asyncio
 import datetime
 import io
@@ -1336,7 +1340,7 @@ class AsyncBrowserToolkit(BaseToolkit):
 
     def _initialize_agent(self) -> Tuple["ChatAgent", "ChatAgent"]:
         r"""Initialize the agent."""
-        from camel.agents import ChatAgent
+        from camel.agents.chat_agent import ChatAgent
 
         if self.web_agent_model is None:
             web_agent_model = ModelFactory.create(

camel/toolkits/base.py

@@ -53,11 +53,13 @@ class BaseToolkit(metaclass=AgentOpsMeta):
         """
         raise NotImplementedError("Subclasses must implement this method.")
 
-    def run_mcp_server(self, mode: Literal["stdio", "sse"]) -> None:
+    def run_mcp_server(
+        self, mode: Literal["stdio", "sse", "streamable-http"]
+    ) -> None:
         r"""Run the MCP server in the specified mode.
 
         Args:
-            mode (Literal["stdio", "sse"]): The mode to run
+            mode (Literal["stdio", "sse", "streamable-http"]): The mode to run
                 the MCP server in.
         """
         self.mcp.run(mode)