camel-ai 0.2.69a4__tar.gz → 0.2.69a7__tar.gz

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a4
+Version: 0.2.69a7
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -31,6 +31,7 @@ Requires-Dist: arxiv<3,>=2.1.3; extra == 'all'
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'all'
 Requires-Dist: beautifulsoup4<5,>=4; extra == 'all'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'all'
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'all'
 Requires-Dist: chunkr-ai>=0.0.50; extra == 'all'
 Requires-Dist: cohere<6,>=5.11.0; extra == 'all'
 Requires-Dist: crawl4ai>=0.3.745; extra == 'all'
@@ -176,7 +177,7 @@ Requires-Dist: types-pyyaml<7,>=6.0.12; extra == 'dev'
 Requires-Dist: types-requests<3,>=2.31.0; extra == 'dev'
 Requires-Dist: types-setuptools<70,>=69.2.0; extra == 'dev'
 Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'dev'
-Requires-Dist: uv==0.6.5; extra == 'dev'
+Requires-Dist: uv<0.8,>=0.7.0; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: aci-sdk>=1.0.0b1; extra == 'dev-tools'
 Requires-Dist: agentops<0.4,>=0.3.21; extra == 'dev-tools'
@@ -288,6 +289,7 @@ Requires-Dist: wikipedia<2,>=1; extra == 'owl'
 Requires-Dist: xls2xlsx>=0.2.0; extra == 'owl'
 Requires-Dist: yt-dlp<2025,>=2024.11.4; extra == 'owl'
 Provides-Extra: rag
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'rag'
 Requires-Dist: chunkr-ai>=0.0.50; extra == 'rag'
 Requires-Dist: cohere<6,>=5.11.0; extra == 'rag'
 Requires-Dist: crawl4ai>=0.3.745; extra == 'rag'
@@ -311,6 +313,7 @@ Requires-Dist: scholarly[tor]==1.7.11; extra == 'research-tools'
 Provides-Extra: storage
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'storage'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'storage'
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'storage'
 Requires-Dist: faiss-cpu<2,>=1.7.2; extra == 'storage'
 Requires-Dist: google-cloud-storage<3,>=2.18.0; extra == 'storage'
 Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
@@ -322,10 +325,6 @@ Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'
 Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'storage'
 Requires-Dist: redis<6,>=5.0.6; extra == 'storage'
 Requires-Dist: weaviate-client>=4.15.0; extra == 'storage'
-Provides-Extra: test
-Requires-Dist: mock<6,>=5; extra == 'test'
-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'

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.69a4'
+__version__ = '0.2.69a7'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/agents/chat_agent.py

@@ -406,7 +406,10 @@ class ChatAgent(BaseAgent):
             # List of tuples (platform, type)
             resolved_models_list = []
             for model_spec in model_list:
-                platform, type_ = model_spec[0], model_spec[1]  # type: ignore[index]
+                platform, type_ = (  # type: ignore[index]
+                    model_spec[0],
+                    model_spec[1],
+                )
                 resolved_models_list.append(
                     ModelFactory.create(
                         model_platform=platform, model_type=type_
@@ -846,6 +849,185 @@ class ChatAgent(BaseAgent):
         except ValidationError:
             return False
 
+    def _check_tools_strict_compatibility(self) -> bool:
+        r"""Check if all tools are compatible with OpenAI strict mode.
+
+        Returns:
+            bool: True if all tools are strict mode compatible,
+                False otherwise.
+        """
+        tool_schemas = self._get_full_tool_schemas()
+        for schema in tool_schemas:
+            if not schema.get("function", {}).get("strict", True):
+                return False
+        return True
+
+    def _convert_response_format_to_prompt(
+        self, response_format: Type[BaseModel]
+    ) -> str:
+        r"""Convert a Pydantic response format to a prompt instruction.
+
+        Args:
+            response_format (Type[BaseModel]): The Pydantic model class.
+
+        Returns:
+            str: A prompt instruction requesting the specific format.
+        """
+        try:
+            # Get the JSON schema from the Pydantic model
+            schema = response_format.model_json_schema()
+
+            # Create a prompt based on the schema
+            format_instruction = (
+                "\n\nPlease respond in the following JSON format:\n" "{\n"
+            )
+
+            properties = schema.get("properties", {})
+            for field_name, field_info in properties.items():
+                field_type = field_info.get("type", "string")
+                description = field_info.get("description", "")
+
+                if field_type == "array":
+                    format_instruction += (
+                        f'    "{field_name}": ["array of values"]'
+                    )
+                elif field_type == "object":
+                    format_instruction += f'    "{field_name}": {{"object"}}'
+                elif field_type == "boolean":
+                    format_instruction += f'    "{field_name}": true'
+                elif field_type == "number":
+                    format_instruction += f'    "{field_name}": 0'
+                else:
+                    format_instruction += f'    "{field_name}": "string value"'
+
+                if description:
+                    format_instruction += f'  // {description}'
+
+                # Add comma if not the last item
+                if field_name != list(properties.keys())[-1]:
+                    format_instruction += ","
+                format_instruction += "\n"
+
+            format_instruction += "}"
+            return format_instruction
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to convert response_format to prompt: {e}. "
+                f"Using generic format instruction."
+            )
+            return (
+                "\n\nPlease respond in a structured JSON format "
+                "that matches the requested schema."
+            )
+
+    def _handle_response_format_with_non_strict_tools(
+        self,
+        input_message: Union[BaseMessage, str],
+        response_format: Optional[Type[BaseModel]] = None,
+    ) -> Tuple[Union[BaseMessage, str], Optional[Type[BaseModel]], bool]:
+        r"""Handle response format when tools are not strict mode compatible.
+
+        Args:
+            input_message: The original input message.
+            response_format: The requested response format.
+
+        Returns:
+            Tuple: (modified_message, modified_response_format,
+                   used_prompt_formatting)
+        """
+        if response_format is None:
+            return input_message, response_format, False
+
+        # Check if tools are strict mode compatible
+        if self._check_tools_strict_compatibility():
+            return input_message, response_format, False
+
+        # Tools are not strict compatible, convert to prompt
+        logger.info(
+            "Non-strict tools detected. Converting response_format to "
+            "prompt-based formatting."
+        )
+
+        format_prompt = self._convert_response_format_to_prompt(
+            response_format
+        )
+
+        # Modify the message to include format instruction
+        modified_message: Union[BaseMessage, str]
+        if isinstance(input_message, str):
+            modified_message = input_message + format_prompt
+        else:
+            modified_message = input_message.create_new_instance(
+                input_message.content + format_prompt
+            )
+
+        # Return None for response_format to avoid strict mode conflicts
+        # and True to indicate we used prompt formatting
+        return modified_message, None, True
+
+    def _apply_prompt_based_parsing(
+        self,
+        response: ModelResponse,
+        original_response_format: Type[BaseModel],
+    ) -> None:
+        r"""Apply manual parsing when using prompt-based formatting.
+
+        Args:
+            response: The model response to parse.
+            original_response_format: The original response format class.
+        """
+        for message in response.output_messages:
+            if message.content:
+                try:
+                    # Try to extract JSON from the response content
+                    import json
+                    import re
+
+                    from pydantic import ValidationError
+
+                    # Try to find JSON in the content
+                    content = message.content.strip()
+
+                    # Try direct parsing first
+                    try:
+                        parsed_json = json.loads(content)
+                        message.parsed = (
+                            original_response_format.model_validate(
+                                parsed_json
+                            )
+                        )
+                        continue
+                    except (json.JSONDecodeError, ValidationError):
+                        pass
+
+                    # Try to extract JSON from text
+                    json_pattern = r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}'
+                    json_matches = re.findall(json_pattern, content, re.DOTALL)
+
+                    for json_str in json_matches:
+                        try:
+                            parsed_json = json.loads(json_str)
+                            message.parsed = (
+                                original_response_format.model_validate(
+                                    parsed_json
+                                )
+                            )
+                            # Update content to just the JSON for consistency
+                            message.content = json.dumps(parsed_json)
+                            break
+                        except (json.JSONDecodeError, ValidationError):
+                            continue
+
+                    if not message.parsed:
+                        logger.warning(
+                            f"Failed to parse JSON from response: "
+                            f"{content[:100]}..."
+                        )
+
+                except Exception as e:
+                    logger.warning(f"Error during prompt-based parsing: {e}")
+
     def _format_response_if_needed(
         self,
         response: ModelResponse,
@@ -932,6 +1114,14 @@ class ChatAgent(BaseAgent):
         except ImportError:
             pass  # Langfuse not available
 
+        # Handle response format compatibility with non-strict tools
+        original_response_format = response_format
+        input_message, response_format, used_prompt_formatting = (
+            self._handle_response_format_with_non_strict_tools(
+                input_message, response_format
+            )
+        )
+
         # Convert input message to BaseMessage if necessary
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
@@ -1014,6 +1204,13 @@ class ChatAgent(BaseAgent):
             break
 
         self._format_response_if_needed(response, response_format)
+
+        # Apply manual parsing if we used prompt-based formatting
+        if used_prompt_formatting and original_response_format:
+            self._apply_prompt_based_parsing(
+                response, original_response_format
+            )
+
         self._record_final_output(response.output_messages)
 
         return self._convert_to_chatagent_response(
@@ -1065,6 +1262,14 @@ class ChatAgent(BaseAgent):
         except ImportError:
             pass  # Langfuse not available
 
+        # Handle response format compatibility with non-strict tools
+        original_response_format = response_format
+        input_message, response_format, used_prompt_formatting = (
+            self._handle_response_format_with_non_strict_tools(
+                input_message, response_format
+            )
+        )
+
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
                 role_name="User", content=input_message
@@ -1098,6 +1303,11 @@ class ChatAgent(BaseAgent):
             )
             iteration_count += 1
 
+            # Accumulate API token usage
+            self._update_token_usage_tracker(
+                step_token_usage, response.usage_dict
+            )
+
             # Terminate Agent if stop_event is set
             if self.stop_event and self.stop_event.is_set():
                 # Use the _step_terminate to terminate the agent with reason
@@ -1139,13 +1349,14 @@ class ChatAgent(BaseAgent):
             break
 
         await self._aformat_response_if_needed(response, response_format)
-        self._record_final_output(response.output_messages)
 
-        # Create token usage tracker for this step
-        step_token_usage = self._create_token_usage_tracker()
+        # Apply manual parsing if we used prompt-based formatting
+        if used_prompt_formatting and original_response_format:
+            self._apply_prompt_based_parsing(
+                response, original_response_format
+            )
 
-        # Update with response usage
-        self._update_token_usage_tracker(step_token_usage, response.usage_dict)
+        self._record_final_output(response.output_messages)
 
         return self._convert_to_chatagent_response(
             response,
@@ -1924,7 +2135,9 @@ class ChatAgent(BaseAgent):
                 schema for schema in self._external_tool_schemas.values()
             ],
             response_terminators=self.response_terminators,
-            scheduling_strategy=self.model_backend.scheduling_strategy.__name__,
+            scheduling_strategy=(
+                self.model_backend.scheduling_strategy.__name__
+            ),
             max_iteration=self.max_iteration,
             stop_event=self.stop_event,
         )

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/interpreters/internal_python_interpreter.py

@@ -79,6 +79,9 @@ class InternalPythonInterpreter(BaseInterpreter):
             (default: :obj:`False`)
         raise_error (bool, optional): Raise error if the interpreter fails.
             (default: :obj:`False`)
+        allow_builtins (bool, optional): If `True`, safe built-in functions
+            like print, len, str, etc. are added to the action space.
+            (default: :obj:`True`)
     """
 
     _CODE_TYPES: ClassVar[List[str]] = ["python", "py", "python3", "python2"]
@@ -89,16 +92,62 @@ class InternalPythonInterpreter(BaseInterpreter):
         import_white_list: Optional[List[str]] = None,
         unsafe_mode: bool = False,
         raise_error: bool = False,
+        allow_builtins: bool = True,
     ) -> None:
         self.action_space = action_space or dict()
-        # Add print to action space
-        self.action_space['print'] = print
         self.state = self.action_space.copy()
         self.fuzz_state: Dict[str, Any] = dict()
         self.import_white_list = import_white_list or list()
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
+        # Add safe built-in functions if allowed
+        if allow_builtins:
+            self._add_safe_builtins()
+
+    def _add_safe_builtins(self):
+        r"""Add safe built-in functions to the action space."""
+        safe_builtins = {
+            'print': print,
+            'len': len,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'abs': abs,
+            'min': min,
+            'max': max,
+            'sum': sum,
+            'sorted': sorted,
+            'reversed': reversed,
+            'enumerate': enumerate,
+            'zip': zip,
+            'range': range,
+            'round': round,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'dir': dir,
+            'help': help,
+            'map': map,
+            'filter': filter,
+            'any': any,
+            'all': all,
+            'ord': ord,
+            'chr': chr,
+            'bin': bin,
+            'oct': oct,
+            'hex': hex,
+        }
+        self.action_space.update(safe_builtins)
+        self.state.update(safe_builtins)
+
     def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/memories/context_creators/score_based.py

@@ -155,16 +155,21 @@ class ScoreBasedContextCreator(BaseContextCreator):
         # ======================
         # 6. Truncation Logic with Tool Call Awareness
         # ======================
-        logger.warning(
-            f"Context truncation required "
-            f"({total_tokens} > {self.token_limit}), "
-            f"pruning low-score messages."
-        )
-
         remaining_units = self._truncate_with_tool_call_awareness(
             regular_units, tool_call_groups, system_tokens
         )
 
+        # Log only after truncation is actually performed so that both
+        # the original and the final token counts are visible.
+        tokens_after = system_tokens + sum(
+            u.num_tokens for u in remaining_units
+        )
+        logger.warning(
+            "Context truncation performed: "
+            f"before={total_tokens}, after={tokens_after}, "
+            f"limit={self.token_limit}"
+        )
+
         # ======================
         # 7. Output Assembly
         # ======================

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/messages/base.py

@@ -69,7 +69,7 @@ class BaseMessage:
         image_detail (Literal["auto", "low", "high"]): Detail level of the
             images associated with the message. (default: :obj:`auto`)
         video_detail (Literal["auto", "low", "high"]): Detail level of the
-            videos associated with the message. (default: :obj:`low`)
+            videos associated with the message. (default: :obj:`auto`)
         parsed: Optional[Union[Type[BaseModel], dict]]: Optional object which
             is parsed from the content. (default: :obj:`None`)
     """
@@ -82,7 +82,7 @@ class BaseMessage:
     video_bytes: Optional[bytes] = None
     image_list: Optional[List[Image.Image]] = None
     image_detail: Literal["auto", "low", "high"] = "auto"
-    video_detail: Literal["auto", "low", "high"] = "low"
+    video_detail: Literal["auto", "low", "high"] = "auto"
     parsed: Optional[Union[BaseModel, dict]] = None
 
     @classmethod

{camel_ai-0.2.69a4 → camel_ai-0.2.69a7}/camel/models/base_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import abc
+import os
 import re
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type, Union
@@ -94,6 +95,12 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._token_counter = token_counter
         self._timeout = timeout
         self._max_retries = max_retries
+        # Initialize logging configuration
+        self._log_enabled = (
+            os.environ.get("CAMEL_MODEL_LOG_ENABLED", "False").lower()
+            == "true"
+        )
+        self._log_dir = os.environ.get("CAMEL_LOG_DIR", "camel_logs")
         self.check_model_config()
 
     @property
@@ -232,6 +239,68 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
 
         return formatted_messages
 
+    def _log_request(self, messages: List[OpenAIMessage]) -> Optional[str]:
+        r"""Log the request messages to a JSON file if logging is enabled.
+
+        Args:
+            messages (List[OpenAIMessage]): The messages to log.
+
+        Returns:
+            Optional[str]: The path to the log file if logging is enabled,
+                None otherwise.
+        """
+        if not self._log_enabled:
+            return None
+
+        import json
+        from datetime import datetime
+
+        os.makedirs(self._log_dir, exist_ok=True)
+
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
+        log_file_path = os.path.join(self._log_dir, f"conv_{timestamp}.json")
+
+        log_entry = {
+            "request_timestamp": datetime.now().isoformat(),
+            "model": str(self.model_type),
+            "request": {"messages": messages},
+        }
+
+        with open(log_file_path, "w") as f:
+            json.dump(log_entry, f, indent=4)
+
+        return log_file_path
+
+    def _log_response(self, log_path: str, response: Any) -> None:
+        r"""Log the response to the existing log file.
+
+        Args:
+            log_path (str): The path to the log file.
+            response (Any): The response to log.
+        """
+        if not self._log_enabled or not log_path:
+            return
+
+        import json
+        from datetime import datetime
+
+        with open(log_path, "r+") as f:
+            log_data = json.load(f)
+
+            log_data["response_timestamp"] = datetime.now().isoformat()
+            if isinstance(response, BaseModel):
+                log_data["response"] = response.model_dump()
+            else:
+                try:
+                    json.dumps(response)
+                    log_data["response"] = response
+                except TypeError:
+                    log_data["response"] = str(response)
+
+            f.seek(0)
+            json.dump(log_data, f, indent=4)
+            f.truncate()
+
     @abstractmethod
     def _run(
         self,
@@ -273,13 +342,23 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         # None -> use default tools
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         # Empty -> use no tools
         elif not tools:
             tools = None
-        return self._run(messages, response_format, tools)
+
+        result = self._run(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     async def arun(
         self,
@@ -304,11 +383,21 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
+        # Log the request if logging is enabled
+        log_path = self._log_request(messages)
+
         if tools is None:
             tools = self.model_config_dict.get("tools", None)
         elif not tools:
             tools = None
-        return await self._arun(messages, response_format, tools)
+
+        result = await self._arun(messages, response_format, tools)
+
+        # Log the response if logging is enabled
+        if log_path:
+            self._log_response(log_path, result)
+
+        return result
 
     @abstractmethod
     def check_model_config(self):