camel-ai 0.2.57__py3-none-any.whl → 0.2.59__py3-none-any.whl

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/loaders/__init__.py

@@ -18,6 +18,7 @@ from .chunkr_reader import ChunkrReader
 from .crawl4ai_reader import Crawl4AI
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
+from .markitdown import MarkItDownLoader
 from .mineru_extractor import MinerU
 from .pandas_reader import PandasReader
 from .scrapegraph_reader import ScrapeGraphAI
@@ -35,5 +36,6 @@ __all__ = [
     'PandasReader',
     'MinerU',
     'Crawl4AI',
+    'MarkItDownLoader',
     'ScrapeGraphAI',
 ]

camel/loaders/markitdown.py

@@ -0,0 +1,204 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import ClassVar, Dict, List, Optional
+
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class MarkItDownLoader:
+    r"""MarkitDown convert various file types into Markdown format.
+
+    Supported Input Formats:
+        - PDF
+        - Microsoft Office documents:
+            - Word (.doc, .docx)
+            - Excel (.xls, .xlsx)
+            - PowerPoint (.ppt, .pptx)
+        - EPUB
+        - HTML
+        - Images (with EXIF metadata and OCR support)
+        - Audio files (with EXIF metadata and speech transcription)
+        - Text-based formats:
+            - CSV
+            - JSON
+            - XML
+        - ZIP archives (iterates over contents)
+        - YouTube URLs (via transcript extraction)
+    """
+
+    SUPPORTED_FORMATS: ClassVar[List[str]] = [
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".ppt",
+        ".pptx",
+        ".epub",
+        ".html",
+        ".htm",
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".mp3",
+        ".wav",
+        ".csv",
+        ".json",
+        ".xml",
+        ".zip",
+        ".txt",
+    ]
+
+    def __init__(
+        self,
+        llm_client: Optional[object] = None,
+        llm_model: Optional[str] = None,
+    ):
+        r"""Initializes the Converter.
+
+        Args:
+            llm_client (Optional[object]): Optional client for LLM integration.
+                (default: :obj:`None`)
+            llm_model (Optional[str]): Optional model name for the LLM.
+                (default: :obj:`None`)
+        """
+        from markitdown import MarkItDown
+
+        try:
+            self.converter = MarkItDown(
+                llm_client=llm_client, llm_model=llm_model
+            )
+            logger.info("MarkItDownLoader initialized successfully.")
+        except Exception as e:
+            logger.error(f"Failed to initialize MarkItDown Converter: {e}")
+            raise Exception(f"Failed to initialize MarkItDown Converter: {e}")
+
+    def _validate_format(self, file_path: str) -> bool:
+        r"""Validates if the file format is supported.
+
+        Args:
+            file_path (str): Path to the input file.
+
+        Returns:
+            bool: True if the format is supported, False otherwise.
+        """
+        _, ext = os.path.splitext(file_path)
+        return ext.lower() in self.SUPPORTED_FORMATS
+
+    def convert_file(self, file_path: str) -> str:
+        r"""Converts the given file to Markdown format.
+
+        Args:
+            file_path (str): Path to the input file.
+
+        Returns:
+            str: Converted Markdown text.
+
+        Raises:
+            FileNotFoundError: If the specified file does not exist.
+            ValueError: If the file format is not supported.
+            Exception: For other errors during conversion.
+        """
+        if not os.path.isfile(file_path):
+            logger.error(f"File not found: {file_path}")
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        if not self._validate_format(file_path):
+            logger.error(
+                f"Unsupported file format: {file_path}."
+                f"Supported formats are "
+                f"{MarkItDownLoader.SUPPORTED_FORMATS}"
+            )
+            raise ValueError(f"Unsupported file format: {file_path}")
+
+        try:
+            logger.info(f"Converting file: {file_path}")
+            result = self.converter.convert(file_path)
+            logger.info(f"File converted successfully: {file_path}")
+            return result.text_content
+        except Exception as e:
+            logger.error(f"Error converting file '{file_path}': {e}")
+            raise Exception(f"Error converting file '{file_path}': {e}")
+
+    def convert_files(
+        self,
+        file_paths: List[str],
+        parallel: bool = False,
+        skip_failed: bool = False,
+    ) -> Dict[str, str]:
+        r"""Converts multiple files to Markdown format.
+
+        Args:
+            file_paths (List[str]): List of file paths to convert.
+            parallel (bool): Whether to process files in parallel.
+                (default: :obj:`False`)
+            skip_failed (bool): Whether to skip failed files instead
+                of including error messages.
+                (default: :obj:`False`)
+
+        Returns:
+            Dict[str, str]: Dictionary mapping file paths to their
+                converted Markdown text.
+
+        Raises:
+            Exception: For errors during conversion of any file if
+                skip_failed is False.
+        """
+        from tqdm.auto import tqdm
+
+        converted_files = {}
+
+        if parallel:
+            with ThreadPoolExecutor() as executor:
+                future_to_path = {
+                    executor.submit(self.convert_file, path): path
+                    for path in file_paths
+                }
+                for future in tqdm(
+                    as_completed(future_to_path),
+                    total=len(file_paths),
+                    desc="Converting files (parallel)",
+                ):
+                    path = future_to_path[future]
+                    try:
+                        converted_files[path] = future.result()
+                    except Exception as e:
+                        if skip_failed:
+                            logger.warning(
+                                f"Skipping file '{path}' due to error: {e}"
+                            )
+                        else:
+                            logger.error(
+                                f"Error processing file '{path}': {e}"
+                            )
+                            converted_files[path] = f"Error: {e}"
+        else:
+            for path in tqdm(file_paths, desc="Converting files (sequential)"):
+                try:
+                    logger.info(f"Processing file: {path}")
+                    converted_files[path] = self.convert_file(path)
+                except Exception as e:
+                    if skip_failed:
+                        logger.warning(
+                            f"Skipping file '{path}' due to error: {e}"
+                        )
+                    else:
+                        logger.error(f"Error processing file '{path}': {e}")
+                        converted_files[path] = f"Error: {e}"
+
+        return converted_files

camel/models/openai_compatible_model.py

@@ -16,7 +16,7 @@ import os
 from json import JSONDecodeError
 from typing import Any, Dict, List, Optional, Type, Union
 
-from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from openai import AsyncOpenAI, AsyncStream, BadRequestError, OpenAI, Stream
 from pydantic import BaseModel, ValidationError
 
 from camel.logger import get_logger
@@ -198,7 +198,7 @@ class OpenAICompatibleModel(BaseModelBackend):
                 model=self.model_type,
                 **request_config,
             )
-        except (ValidationError, JSONDecodeError) as e:
+        except (ValidationError, JSONDecodeError, BadRequestError) as e:
             logger.warning(
                 f"Format validation error: {e}. "
                 f"Attempting fallback with JSON format."
@@ -237,7 +237,7 @@ class OpenAICompatibleModel(BaseModelBackend):
                 model=self.model_type,
                 **request_config,
             )
-        except (ValidationError, JSONDecodeError) as e:
+        except (ValidationError, JSONDecodeError, BadRequestError) as e:
             logger.warning(
                 f"Format validation error: {e}. "
                 f"Attempting fallback with JSON format."

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

@@ -41,7 +41,7 @@ from camel.societies.workforce.utils import (
 )
 from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState
-from camel.toolkits import GoogleMapsToolkit, SearchToolkit, WeatherToolkit
+from camel.toolkits import CodeExecutionToolkit, SearchToolkit, ThinkingToolkit
 from camel.types import ModelPlatformType, ModelType
 
 logger = get_logger(__name__)
@@ -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
@@ -370,9 +375,9 @@ class Workforce(BaseNode):
 
         # Default tools for a new agent
         function_list = [
-            *SearchToolkit().get_tools(),
-            *WeatherToolkit().get_tools(),
-            *GoogleMapsToolkit().get_tools(),
+            SearchToolkit().search_duckduckgo,
+            *CodeExecutionToolkit().get_tools(),
+            *ThinkingToolkit().get_tools(),
         ]
 
         model_config_dict = ChatGPTConfig(
@@ -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/toolkits/__init__.py

@@ -59,6 +59,7 @@ from .video_analysis_toolkit import VideoAnalysisToolkit
 from .image_analysis_toolkit import ImageAnalysisToolkit
 from .mcp_toolkit import MCPToolkit
 from .browser_toolkit import BrowserToolkit
+from .async_browser_toolkit import AsyncBrowserToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
@@ -72,6 +73,7 @@ from .pulse_mcp_search_toolkit import PulseMCPSearchToolkit
 from .klavis_toolkit import KlavisToolkit
 from .aci_toolkit import ACIToolkit
 from .playwright_mcp_toolkit import PlaywrightMCPToolkit
+from .wolfram_alpha_toolkit import WolframAlphaToolkit
 
 
 __all__ = [
@@ -119,6 +121,7 @@ __all__ = [
     'VideoAnalysisToolkit',
     'ImageAnalysisToolkit',
     'BrowserToolkit',
+    'AsyncBrowserToolkit',
     'FileWriteToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
@@ -132,4 +135,5 @@ __all__ = [
     'KlavisToolkit',
     'ACIToolkit',
     'PlaywrightMCPToolkit',
+    'WolframAlphaToolkit',
 ]