camel-ai 0.2.28__tar.gz → 0.2.30__tar.gz

{camel_ai-0.2.28 → camel_ai-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.28
+Version: 0.2.30
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -239,6 +239,7 @@ Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'test'
 Requires-Dist: pytest<8,>=7; extra == 'test'
 Provides-Extra: web-tools
 Requires-Dist: apify-client<2,>=1.8.1; extra == 'web-tools'
+Requires-Dist: beautifulsoup4<5,>=4; extra == 'web-tools'
 Requires-Dist: dappier<0.4,>=0.3.3; extra == 'web-tools'
 Requires-Dist: duckduckgo-search<7,>=6.3.5; extra == 'web-tools'
 Requires-Dist: fastapi>=0.115.11; extra == 'web-tools'
@@ -447,7 +448,7 @@ pip install camel-ai
 
 For more detailed instructions and additional configuration options, check out the [installation section](https://github.com/camel-ai/camel/blob/master/docs/get_started/installation.md).
 
-After running, you can explore our CAMEL Tech Stack and Cookbooks at [www.docs.camel-ai.org](https://www.docs.camel-ai.org) to build powerful multi-agent systems.
+After running, you can explore our CAMEL Tech Stack and Cookbooks at [www.docs.camel-ai.org](https://docs.camel-ai.org) to build powerful multi-agent systems.
 
 We provide a [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1AzP33O8rnMW__7ocWJhVBXjKziJXPtim?usp=sharing) demo showcasing a conversation between two ChatGPT agents playing roles as a python programmer and a stock trader collaborating on developing a trading bot for stock market.
 

{camel_ai-0.2.28 → camel_ai-0.2.30}/README.md

@@ -189,7 +189,7 @@ pip install camel-ai
 
 For more detailed instructions and additional configuration options, check out the [installation section](https://github.com/camel-ai/camel/blob/master/docs/get_started/installation.md).
 
-After running, you can explore our CAMEL Tech Stack and Cookbooks at [www.docs.camel-ai.org](https://www.docs.camel-ai.org) to build powerful multi-agent systems.
+After running, you can explore our CAMEL Tech Stack and Cookbooks at [www.docs.camel-ai.org](https://docs.camel-ai.org) to build powerful multi-agent systems.
 
 We provide a [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1AzP33O8rnMW__7ocWJhVBXjKziJXPtim?usp=sharing) demo showcasing a conversation between two ChatGPT agents playing roles as a python programmer and a stock trader collaborating on developing a trading bot for stock market.
 

{camel_ai-0.2.28 → camel_ai-0.2.30}/camel/__init__.py

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

{camel_ai-0.2.28 → camel_ai-0.2.30}/camel/agents/chat_agent.py

@@ -707,10 +707,13 @@ class ChatAgent(BaseAgent):
                 f"did not run successfully. Error: {error_info}"
             )
 
+        sanitized_messages = self._sanitize_messages_for_logging(
+            openai_messages
+        )
         logger.info(
             f"Model {self.model_backend.model_type}, "
             f"index {self.model_backend.current_model_index}, "
-            f"processed these messages: {openai_messages}"
+            f"processed these messages: {sanitized_messages}"
         )
 
         if isinstance(response, ChatCompletion):
@@ -752,10 +755,13 @@ class ChatAgent(BaseAgent):
                 f"did not run successfully. Error: {error_info}"
             )
 
+        sanitized_messages = self._sanitize_messages_for_logging(
+            openai_messages
+        )
         logger.info(
             f"Model {self.model_backend.model_type}, "
             f"index {self.model_backend.current_model_index}, "
-            f"processed these messages: {openai_messages}"
+            f"processed these messages: {sanitized_messages}"
         )
 
         if isinstance(response, ChatCompletion):
@@ -763,6 +769,134 @@ class ChatAgent(BaseAgent):
         else:
             return await self._ahandle_stream_response(response, num_tokens)
 
+    def _sanitize_messages_for_logging(self, messages):
+        r"""Sanitize OpenAI messages for logging by replacing base64 image
+        data with a simple message and a link to view the image.
+
+        Args:
+            messages (List[OpenAIMessage]): The OpenAI messages to sanitize.
+
+        Returns:
+            List[OpenAIMessage]: The sanitized OpenAI messages.
+        """
+        import hashlib
+        import os
+        import re
+        import tempfile
+
+        # Create a copy of messages for logging to avoid modifying the
+        # original messages
+        sanitized_messages = []
+        for msg in messages:
+            if isinstance(msg, dict):
+                sanitized_msg = msg.copy()
+                # Check if content is a list (multimodal content with images)
+                if isinstance(sanitized_msg.get('content'), list):
+                    content_list = []
+                    for item in sanitized_msg['content']:
+                        if (
+                            isinstance(item, dict)
+                            and item.get('type') == 'image_url'
+                        ):
+                            # Handle image URL
+                            image_url = item.get('image_url', {}).get(
+                                'url', ''
+                            )
+                            if image_url and image_url.startswith(
+                                'data:image'
+                            ):
+                                # Extract image data and format
+                                match = re.match(
+                                    r'data:image/([^;]+);base64,(.+)',
+                                    image_url,
+                                )
+                                if match:
+                                    img_format, base64_data = match.groups()
+
+                                    # Create a hash of the image data to use
+                                    # as filename
+                                    img_hash = hashlib.md5(
+                                        base64_data[:100].encode()
+                                    ).hexdigest()[:10]
+                                    img_filename = (
+                                        f"image_{img_hash}.{img_format}"
+                                    )
+
+                                    # Save image to temp directory for viewing
+                                    try:
+                                        import base64
+
+                                        temp_dir = tempfile.gettempdir()
+                                        img_path = os.path.join(
+                                            temp_dir, img_filename
+                                        )
+
+                                        # Only save if file doesn't exist
+                                        if not os.path.exists(img_path):
+                                            with open(img_path, 'wb') as f:
+                                                f.write(
+                                                    base64.b64decode(
+                                                        base64_data
+                                                    )
+                                                )
+
+                                        # Create a file:// URL that can be
+                                        # opened
+                                        file_url = f"file://{img_path}"
+
+                                        content_list.append(
+                                            {
+                                                'type': 'image_url',
+                                                'image_url': {
+                                                    'url': f'{file_url}',
+                                                    'detail': item.get(
+                                                        'image_url', {}
+                                                    ).get('detail', 'auto'),
+                                                },
+                                            }
+                                        )
+                                    except Exception as e:
+                                        # If saving fails, fall back to simple
+                                        # message
+                                        content_list.append(
+                                            {
+                                                'type': 'image_url',
+                                                'image_url': {
+                                                    'url': '[base64 '
+                                                    + 'image - error saving: '
+                                                    + str(e)
+                                                    + ']',
+                                                    'detail': item.get(
+                                                        'image_url', {}
+                                                    ).get('detail', 'auto'),
+                                                },
+                                            }
+                                        )
+                                else:
+                                    # If regex fails, fall back to simple
+                                    # message
+                                    content_list.append(
+                                        {
+                                            'type': 'image_url',
+                                            'image_url': {
+                                                'url': '[base64 '
+                                                + 'image - invalid format]',
+                                                'detail': item.get(
+                                                    'image_url', {}
+                                                ).get('detail', 'auto'),
+                                            },
+                                        }
+                                    )
+                            else:
+                                content_list.append(item)
+                        else:
+                            content_list.append(item)
+                    sanitized_msg['content'] = content_list
+                sanitized_messages.append(sanitized_msg)
+            else:
+                sanitized_messages.append(msg)
+        return sanitized_messages
+
     def _step_get_info(
         self,
         output_messages: List[BaseMessage],
@@ -1043,7 +1177,13 @@ class ChatAgent(BaseAgent):
         args = tool_call_request.args
         tool_call_id = tool_call_request.tool_call_id
         tool = self._internal_tools[func_name]
-        result = tool(**args)
+        try:
+            result = tool(**args)
+        except Exception as e:
+            # Capture the error message to prevent framework crash
+            error_msg = f"Error executing tool '{func_name}': {e!s}"
+            result = {"error": error_msg}
+            logging.warning(error_msg)
 
         return self._record_tool_calling(func_name, args, result, tool_call_id)
 
@@ -1055,7 +1195,14 @@ class ChatAgent(BaseAgent):
         args = tool_call_request.args
         tool_call_id = tool_call_request.tool_call_id
         tool = self._internal_tools[func_name]
-        result = await tool.async_call(**args)
+        try:
+            result = await tool.async_call(**args)
+        except Exception as e:
+            # Capture the error message to prevent framework crash
+            error_msg = f"Error executing async tool '{func_name}': {e!s}"
+            result = {"error": error_msg}
+            logging.warning(error_msg)
+
         return self._record_tool_calling(func_name, args, result, tool_call_id)
 
     def _record_tool_calling(

{camel_ai-0.2.28 → camel_ai-0.2.30}/camel/datasets/__init__.py

@@ -11,18 +11,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from .base import (
-    BaseDataset,
-    DataPoint,
-    GenerativeDataset,
-    SeedDataset,
-    SyntheticDataset,
+from .base_generator import (
+    BaseGenerator,
+    FewShotGenerator,
 )
+from .models import DataPoint
+from .static_dataset import StaticDataset
 
 __all__ = [
+    "BaseGenerator",
     "DataPoint",
-    "BaseDataset",
-    "SeedDataset",
-    "GenerativeDataset",
-    "SyntheticDataset",
+    "FewShotGenerator",
+    "StaticDataset",
 ]

camel_ai-0.2.30/camel/datasets/base_generator.py

@@ -0,0 +1,335 @@
+# ========= 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 abc
+import json
+import random
+from datetime import datetime
+from pathlib import Path
+from typing import (
+    List,
+    Union,
+)
+
+from pydantic import ValidationError
+
+from camel.agents import ChatAgent
+from camel.logger import get_logger
+from camel.verifiers import BaseVerifier
+from camel.verifiers.models import VerifierInput
+
+from .models import DataPoint
+from .static_dataset import StaticDataset
+
+logger = get_logger(__name__)
+
+
+class BaseGenerator(abc.ABC):
+    r"""Abstract base class for data generators.
+
+    This class defines the interface for generating synthetic datapoints.
+    Concrete implementations should provide specific generation strategies.
+    """
+
+    def __init__(self, seed: int = 42, **kwargs):
+        r"""Initialize the base generator.
+
+        Args:
+            seed (int): Random seed for reproducibility. (default: :obj:`42`)
+            **kwargs: Additional generator parameters.
+        """
+        self._rng = random.Random(seed)
+
+        self._data: List[DataPoint] = []
+
+    @abc.abstractmethod
+    async def generate_new(self, n: int, **kwargs) -> List[DataPoint]:
+        r"""Generate n new datapoints.
+
+        Args:
+            n (int): Number of datapoints to generate.
+            **kwargs: Additional generation parameters.
+
+        Returns:
+            List[DataPoint]: A list of newly generated datapoints.
+        """
+        pass
+
+    def __len__(self) -> int:
+        r"""Return the size of the generated dataset."""
+        return len(self._data)
+
+    def __getitem__(self, idx: int) -> DataPoint:
+        r"""Retrieve a datapoint by index.
+
+        Args:
+            idx (int): Index of the datapoint.
+
+        Returns:
+            DataPoint: The datapoint corresponding to the given index.
+
+        Raises:
+            IndexError: If idx is out of bounds.
+        """
+        if idx < 0 or idx >= len(self._data):
+            raise IndexError(
+                f"Index {idx} out of bounds for dataset of "
+                f"size {len(self._data)}"
+            )
+        return self._data[idx]
+
+    def sample(self) -> DataPoint:
+        if len(self._data) == 0:
+            raise RuntimeError("Dataset is empty, cannot sample.")
+        idx = self._rng.randint(0, len(self._data) - 1)
+        return self[idx]
+
+    def save_to_jsonl(self, file_path: Union[str, Path]) -> None:
+        r"""Saves the generated datapoints to a JSONL (JSON Lines) file.
+
+        Each datapoint is stored as a separate JSON object on a new line.
+
+        Args:
+            file_path (Union[str, Path]): Path to save the JSONL file.
+
+        Raises:
+            ValueError: If no datapoints have been generated.
+            IOError: If there is an issue writing to the file.
+
+        Notes:
+            - Uses `self._data`, which contains the generated datapoints.
+            - Overwrites the file if it already exists.
+            - Ensures compatibility with large datasets by using JSONL format.
+        """
+        if not self._data:
+            raise ValueError("Dataset is empty. No data to save.")
+
+        file_path = Path(file_path)
+
+        try:
+            with file_path.open("w", encoding="utf-8") as f:
+                for datapoint in self._data:
+                    json.dump(datapoint.to_dict(), f)
+                    f.write("\n")  # Ensure each entry is on a new line
+            logger.info(f"Dataset saved successfully to {file_path}")
+        except IOError as e:
+            logger.error(f"Error writing to file {file_path}: {e}")
+            raise
+
+
+class FewShotGenerator(BaseGenerator):
+    r"""A generator for creating synthetic datapoints using few-shot learning.
+
+    This class leverages a seed dataset, an agent, and a verifier to generate
+    new synthetic datapoints on demand through few-shot prompting.
+    """
+
+    def __init__(
+        self,
+        seed_dataset: StaticDataset,
+        verifier: BaseVerifier,
+        agent: ChatAgent,
+        seed: int = 42,
+        **kwargs,
+    ):
+        r"""Initialize the few-shot generator.
+
+        Args:
+            seed_dataset (StaticDataset): Validated static dataset to
+                use for examples.
+            verifier (BaseVerifier): Verifier to validate generated content.
+            agent (ChatAgent): Agent to generate new datapoints.
+            seed (int): Random seed for reproducibility. (default: :obj:`42`)
+            **kwargs: Additional generator parameters.
+        """
+        super().__init__(seed=seed, **kwargs)
+        self.seed_dataset = seed_dataset
+        try:
+            self._validate_seed_dataset()
+        except Exception:
+            raise RuntimeError("Seed Data does not follow Datapoint format")
+        self.verifier = verifier
+        self.agent = agent
+
+    # TODO: Validate that seed dataset contains rationale
+    def _validate_seed_dataset(self) -> None:
+        pass
+
+    def _construct_prompt(self, examples: List[DataPoint]) -> str:
+        r"""Construct a prompt for generating new datapoints
+        using a fixed sample of examples from the seed dataset.
+
+        Args:
+            examples (List[DataPoint]): Examples to include in the prompt.
+
+        Returns:
+            str: Formatted prompt with examples.
+        """
+        prompt = (
+            "Generate a new datapoint similar to the following examples:\n\n"
+        )
+        for i, example in enumerate(examples, 1):
+            prompt += f"Example {i}:\n"
+            prompt += f"Question: {example.question}\n"
+            if example.rationale is not None:
+                prompt += f"Rationale: {example.rationale}\n"
+            else:
+                prompt += "Rationale: None\n"
+            prompt += f"Final Answer: {example.final_answer}\n\n"
+        prompt += "New datapoint:"
+        return prompt
+
+    async def generate_new(
+        self,
+        n: int,
+        max_retries: int = 10,
+        num_examples: int = 3,
+        **kwargs,
+    ) -> List[DataPoint]:
+        r"""Generates and validates `n` new datapoints through
+        few-shot prompting, with a retry limit.
+
+        Steps:
+            1. Samples examples from the seed dataset.
+            2. Constructs a prompt using the selected examples.
+            3. Uses an agent to generate a new datapoint,
+            consisting of a question and code to solve the question.
+            4. Executes code using a verifier to get pseudo ground truth.
+            5. Stores valid datapoints in memory.
+
+        Args:
+            n (int): Number of valid datapoints to generate.
+            max_retries (int): Maximum number of retries before stopping.
+                (default: :obj:`10`)
+            num_examples (int): Number of examples to sample from the
+            seed dataset for few shot prompting.
+                (default: :obj:`3`)
+            **kwargs: Additional generation parameters.
+
+        Returns:
+            List[DataPoint]: A list of newly generated valid datapoints.
+
+        Raises:
+            TypeError: If the agent's output is not a dictionary (or does not
+                match the expected format).
+            KeyError: If required keys are missing from the response.
+            AttributeError: If the verifier response lacks attributes.
+            ValidationError: If a datapoint fails schema validation.
+            RuntimeError: If retries are exhausted before `n` valid datapoints
+                are generated.
+
+        Notes:
+            - Retries on validation failures until `n` valid datapoints exist
+                or `max_retries` is reached, whichever comes first.
+            - If retries are exhausted before reaching `n`, a `RuntimeError`
+                is raised.
+            - Metadata includes a timestamp for tracking datapoint creation.
+        """
+        valid_data_points: List[DataPoint] = []
+        retries = 0
+
+        while len(valid_data_points) < n and retries < max_retries:
+            try:
+                examples = [
+                    self.seed_dataset.sample() for _ in range(num_examples)
+                ]
+                prompt = self._construct_prompt(examples)
+
+                try:
+                    agent_output = (
+                        self.agent.step(prompt, response_format=DataPoint)
+                        .msgs[0]
+                        .parsed
+                    )
+                    if not isinstance(agent_output, dict):
+                        raise TypeError("Agent output must be a dictionary")
+                    if "question" not in agent_output:
+                        raise KeyError(
+                            "Missing 'question' in agent"
+                            f"output {agent_output}"
+                        )
+                    if "rationale" not in agent_output:
+                        raise KeyError(
+                            "Missing 'rationale' in agent"
+                            f"output {agent_output}"
+                        )
+                except (TypeError, KeyError) as e:
+                    logger.warning(
+                        f"Agent output issue: {e}, retrying... "
+                        f"({retries + 1}/{max_retries})"
+                    )
+                    retries += 1
+                    continue
+
+                rationale = agent_output.get("rationale")
+
+                if not isinstance(rationale, str):
+                    raise TypeError(f"Rationale {rationale} is not a string.")
+
+                try:
+                    verifier_response = await self.verifier.verify(
+                        VerifierInput(
+                            llm_response=rationale,
+                            ground_truth=None,
+                        )
+                    )
+                    if not verifier_response or not verifier_response.result:
+                        raise ValueError(
+                            "Verifier unsuccessful, response: "
+                            f"{verifier_response}"
+                        )
+                except (ValueError, AttributeError) as e:
+                    logger.warning(
+                        f"Verifier issue: {e}, "
+                        f"retrying... ({retries + 1}/{max_retries})"
+                    )
+                    retries += 1
+                    continue
+
+                try:
+                    new_datapoint = DataPoint(
+                        question=agent_output["question"],
+                        rationale=rationale,
+                        final_answer=verifier_response.result,
+                        metadata={
+                            "synthetic": str(True),
+                            "created": datetime.now().isoformat(),
+                            "generator": "few_shot",
+                        },
+                    )
+                except ValidationError as e:
+                    logger.warning(
+                        f"Datapoint validation failed: {e}, "
+                        f"retrying... ({retries + 1}/{max_retries})"
+                    )
+                    retries += 1
+                    continue
+
+                valid_data_points.append(new_datapoint)
+
+            except Exception as e:
+                logger.warning(
+                    f"Unexpected error: {e}, retrying..."
+                    f" ({retries + 1}/{max_retries})"
+                )
+                retries += 1
+
+        if len(valid_data_points) < n:
+            raise RuntimeError(
+                f"Failed to generate {n} valid datapoints "
+                f"after {max_retries} retries."
+            )
+
+        self._data.extend(valid_data_points)
+        return valid_data_points

camel_ai-0.2.30/camel/datasets/models.py

@@ -0,0 +1,61 @@
+# ========= 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, Optional
+
+from pydantic import BaseModel, Field
+
+
+class DataPoint(BaseModel):
+    r"""A single data point in the dataset.
+
+    Attributes:
+        question (str): The primary question or issue to be addressed.
+        final_answer (str): The final answer.
+        rationale (Optional[str]): Logical reasoning or explanation behind the
+            answer. (default: :obj:`None`)
+        metadata Optional[Dict[str, Any]]: Additional metadata about the data
+            point. (default: :obj:`None`)
+    """
+
+    question: str = Field(
+        ..., description="The primary question or issue to be addressed."
+    )
+    final_answer: str = Field(..., description="The final answer.")
+    rationale: Optional[str] = Field(
+        default=None,
+        description="Logical reasoning or explanation behind the answer.",
+    )
+    metadata: Optional[Dict[str, Any]] = Field(
+        default=None, description="Additional metadata about the data point."
+    )
+
+    def to_dict(self) -> Dict[str, Any]:
+        r"""Convert DataPoint to a dictionary.
+
+        Returns:
+            Dict[str, Any]: Dictionary representation of the DataPoint.
+        """
+        return self.dict()
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'DataPoint':
+        r"""Create a DataPoint from a dictionary.
+
+        Args:
+            data (Dict[str, Any]): Dictionary containing DataPoint fields.
+
+        Returns:
+            DataPoint: New DataPoint instance.
+        """
+        return cls(**data)