camel-ai 0.2.76a9__py3-none-any.whl → 0.2.76a13__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.76a9'
+__version__ = '0.2.76a13'
 
 __all__ = [
     '__version__',

camel/agents/mcp_agent.py

@@ -15,16 +15,25 @@
 import asyncio
 import json
 import platform
-import re
-from typing import Any, Callable, Dict, List, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Union,
+    cast,
+)
 
-from camel.agents import ChatAgent
+from camel.agents.chat_agent import ChatAgent
 from camel.logger import get_logger
 from camel.messages import BaseMessage
-from camel.models import BaseModelBackend, ModelFactory
+from camel.models.base_model import BaseModelBackend
+from camel.models.model_factory import ModelFactory
 from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
-from camel.toolkits import FunctionTool, MCPToolkit
+from camel.toolkits.function_tool import FunctionTool
 from camel.types import (
     BaseMCPRegistryConfig,
     MCPRegistryType,
@@ -33,6 +42,9 @@ from camel.types import (
     RoleType,
 )
 
+if TYPE_CHECKING:
+    from camel.toolkits.mcp_toolkit import MCPToolkit
+
 # AgentOps decorator setting
 try:
     import os
@@ -44,6 +56,8 @@ try:
 except (ImportError, AttributeError):
     from camel.utils import track_agent
 
+from camel.parsers.mcp_tool_call_parser import extract_tool_calls_from_text
+
 logger = get_logger(__name__)
 
 
@@ -168,8 +182,10 @@ class MCPAgent(ChatAgent):
             **kwargs,
         )
 
-    def _initialize_mcp_toolkit(self) -> MCPToolkit:
+    def _initialize_mcp_toolkit(self) -> "MCPToolkit":
         r"""Initialize the MCP toolkit from the provided configuration."""
+        from camel.toolkits.mcp_toolkit import MCPToolkit
+
         config_dict = {}
         for registry_config in self.registry_configs:
             config_dict.update(registry_config.get_config())
@@ -334,27 +350,14 @@ class MCPAgent(ChatAgent):
             task = f"## Task:\n  {input_message}"
             input_message = str(self._text_tools) + task
             response = await super().astep(input_message, *args, **kwargs)
-            content = response.msgs[0].content.lower()
-
-            tool_calls = []
-            while "```json" in content:
-                json_match = re.search(r'```json', content)
-                if not json_match:
-                    break
-                json_start = json_match.span()[1]
-
-                end_match = re.search(r'```', content[json_start:])
-                if not end_match:
-                    break
-                json_end = end_match.span()[0] + json_start
-
-                tool_json = content[json_start:json_end].strip('\n')
-                try:
-                    tool_calls.append(json.loads(tool_json))
-                except json.JSONDecodeError:
-                    logger.warning(f"Failed to parse JSON: {tool_json}")
-                    continue
-                content = content[json_end:]
+            raw_content = response.msgs[0].content if response.msgs else ""
+            content = (
+                raw_content
+                if isinstance(raw_content, str)
+                else str(raw_content)
+            )
+
+            tool_calls = extract_tool_calls_from_text(content)
 
             if not tool_calls:
                 return response

camel/loaders/__init__.py

@@ -21,7 +21,6 @@ from .jina_url_reader import JinaURLReader
 from .markitdown import MarkItDownLoader
 from .mineru_extractor import MinerU
 from .mistral_reader import MistralReader
-from .pandas_reader import PandasReader
 from .scrapegraph_reader import ScrapeGraphAI
 from .unstructured_io import UnstructuredIO
 
@@ -33,7 +32,6 @@ __all__ = [
     'JinaURLReader',
     'Firecrawl',
     'Apify',
-    'PandasReader',
     'ChunkrReader',
     'ChunkrReaderConfig',
     'MinerU',
@@ -42,3 +40,14 @@ __all__ = [
     'ScrapeGraphAI',
     'MistralReader',
 ]
+
+
+def __getattr__(name: str):
+    if name == 'PandasReader':
+        raise ImportError(
+            "PandasReader has been removed from camel.loaders. "
+            "The pandasai dependency limited pandas to version 1.5.3. "
+            "Please use ExcelToolkit from camel.toolkits instead for "
+            "handling structured data."
+        )
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

camel/loaders/chunkr_reader.py

@@ -34,6 +34,12 @@ class ChunkrReaderConfig:
         high_resolution (bool, optional): Whether to use high resolution OCR.
             (default: :obj:`True`)
         ocr_strategy (str, optional): The OCR strategy. Defaults to 'Auto'.
+        **kwargs: Additional keyword arguments to pass to the Chunkr
+            Configuration. This accepts all other Configuration parameters
+            such as expires_in, pipeline, segment_processing,
+            segmentation_strategy, etc.
+            See: https://github.com/lumina-ai-inc/chunkr/blob/main/core/src/
+            models/task.rs#L749
     """
 
     def __init__(
@@ -41,10 +47,12 @@ class ChunkrReaderConfig:
         chunk_processing: int = 512,
         high_resolution: bool = True,
         ocr_strategy: str = "Auto",
+        **kwargs,
     ):
         self.chunk_processing = chunk_processing
         self.high_resolution = high_resolution
         self.ocr_strategy = ocr_strategy
+        self.kwargs = kwargs
 
 
 class ChunkrReader:
@@ -190,4 +198,5 @@ class ChunkrReader:
                 "Auto": OcrStrategy.AUTO,
                 "All": OcrStrategy.ALL,
             }.get(chunkr_config.ocr_strategy, OcrStrategy.ALL),
+            **chunkr_config.kwargs,
         )

camel/memories/records.py

@@ -94,6 +94,42 @@ class MemoryRecord(BaseModel):
         if "role_type" in data and isinstance(data["role_type"], str):
             data["role_type"] = RoleType(data["role_type"])
 
+        # Deserialize image_list from base64 strings/URLs back to PIL Images/
+        # URLs
+        if "image_list" in data and data["image_list"] is not None:
+            import base64
+            from io import BytesIO
+
+            from PIL import Image
+
+            image_objects = []
+            for img_item in data["image_list"]:
+                if isinstance(img_item, dict):
+                    # New format with type indicator
+                    if img_item["type"] == "url":
+                        # URL string, keep as-is
+                        image_objects.append(img_item["data"])
+                    else:  # type == "base64"
+                        # Base64 encoded image, convert to PIL Image
+                        img_bytes = base64.b64decode(img_item["data"])
+                        img = Image.open(BytesIO(img_bytes))
+                        # Restore the format attribute if it was saved
+                        if "format" in img_item:
+                            img.format = img_item["format"]
+                        image_objects.append(img)
+                else:
+                    # Legacy format: assume it's a base64 string
+                    img_bytes = base64.b64decode(img_item)
+                    img = Image.open(BytesIO(img_bytes))
+                    image_objects.append(img)
+            data["image_list"] = image_objects
+
+        # Deserialize video_bytes from base64 string
+        if "video_bytes" in data and data["video_bytes"] is not None:
+            import base64
+
+            data["video_bytes"] = base64.b64decode(data["video_bytes"])
+
         # Get valid constructor parameters (cached)
         valid_params = cls._get_constructor_params(message_cls)
 

camel/messages/base.py

@@ -64,8 +64,9 @@ class BaseMessage:
         content (str): The content of the message.
         video_bytes (Optional[bytes]): Optional bytes of a video associated
             with the message. (default: :obj:`None`)
-        image_list (Optional[List[Image.Image]]): Optional list of PIL Image
-            objects associated with the message. (default: :obj:`None`)
+        image_list (Optional[List[Union[Image.Image, str]]]): Optional list of
+            PIL Image objects or image URLs (strings) associated with the
+            message. (default: :obj:`None`)
         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
@@ -80,7 +81,7 @@ class BaseMessage:
     content: str
 
     video_bytes: Optional[bytes] = None
-    image_list: Optional[List[Image.Image]] = None
+    image_list: Optional[List[Union[Image.Image, str]]] = None
     image_detail: Literal["auto", "low", "high"] = "auto"
     video_detail: Literal["auto", "low", "high"] = "auto"
     parsed: Optional[Union[BaseModel, dict]] = None
@@ -92,7 +93,7 @@ class BaseMessage:
         content: str,
         meta_dict: Optional[Dict[str, str]] = None,
         video_bytes: Optional[bytes] = None,
-        image_list: Optional[List[Image.Image]] = None,
+        image_list: Optional[List[Union[Image.Image, str]]] = None,
         image_detail: Union[
             OpenAIVisionDetailType, str
         ] = OpenAIVisionDetailType.AUTO,
@@ -109,8 +110,9 @@ class BaseMessage:
                 dictionary for the message.
             video_bytes (Optional[bytes]): Optional bytes of a video
                 associated with the message.
-            image_list (Optional[List[Image.Image]]): Optional list of PIL
-                Image objects associated with the message.
+            image_list (Optional[List[Union[Image.Image, str]]]): Optional list
+                of PIL Image objects or image URLs (strings) associated with
+                the message.
             image_detail (Union[OpenAIVisionDetailType, str]): Detail level of
                 the images associated with the message.
             video_detail (Union[OpenAIVisionDetailType, str]): Detail level of
@@ -137,7 +139,7 @@ class BaseMessage:
         content: str,
         meta_dict: Optional[Dict[str, str]] = None,
         video_bytes: Optional[bytes] = None,
-        image_list: Optional[List[Image.Image]] = None,
+        image_list: Optional[List[Union[Image.Image, str]]] = None,
         image_detail: Union[
             OpenAIVisionDetailType, str
         ] = OpenAIVisionDetailType.AUTO,
@@ -154,8 +156,9 @@ class BaseMessage:
                 dictionary for the message.
             video_bytes (Optional[bytes]): Optional bytes of a video
                 associated with the message.
-            image_list (Optional[List[Image.Image]]): Optional list of PIL
-                Image objects associated with the message.
+            image_list (Optional[List[Union[Image.Image, str]]]): Optional list
+                of PIL Image objects or image URLs (strings) associated with
+                the message.
             image_detail (Union[OpenAIVisionDetailType, str]): Detail level of
                 the images associated with the message.
             video_detail (Union[OpenAIVisionDetailType, str]): Detail level of
@@ -436,31 +439,64 @@ class BaseMessage:
         )
         if self.image_list and len(self.image_list) > 0:
             for image in self.image_list:
-                if image.format is None:
-                    # Set default format to PNG as fallback
-                    image.format = 'PNG'
-
-                image_type: str = image.format.lower()
-                if image_type not in OpenAIImageType:
-                    raise ValueError(
-                        f"Image type {image.format} "
-                        f"is not supported by OpenAI vision model"
+                # Check if image is a URL string or PIL Image
+                if isinstance(image, str):
+                    # Image is a URL string
+                    hybrid_content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": image,
+                                "detail": self.image_detail,
+                            },
+                        }
                     )
-                with io.BytesIO() as buffer:
-                    image.save(fp=buffer, format=image.format)
-                    encoded_image = base64.b64encode(buffer.getvalue()).decode(
-                        "utf-8"
+                else:
+                    # Image is a PIL Image object
+                    if image.format is None:
+                        # Set default format to PNG as fallback
+                        image.format = 'PNG'
+
+                    image_type: str = image.format.lower()
+                    if image_type not in OpenAIImageType:
+                        raise ValueError(
+                            f"Image type {image.format} "
+                            f"is not supported by OpenAI vision model"
+                        )
+
+                    # Convert RGBA to RGB for formats that don't support
+                    # transparency or when the image has transparency channel
+                    img_to_save = image
+                    if image.mode in ('RGBA', 'LA', 'P') and image_type in (
+                        'jpeg',
+                        'jpg',
+                    ):
+                        # JPEG doesn't support transparency, convert to RGB
+                        img_to_save = image.convert('RGB')
+                    elif (
+                        image.mode in ('RGBA', 'LA', 'P')
+                        and image_type == 'png'
+                    ):
+                        # For PNG with transparency, convert to RGBA if needed
+                        if image.mode in ('LA', 'P'):
+                            img_to_save = image.convert('RGBA')
+                        # else: RGBA mode, keep as-is
+
+                    with io.BytesIO() as buffer:
+                        img_to_save.save(fp=buffer, format=image.format)
+                        encoded_image = base64.b64encode(
+                            buffer.getvalue()
+                        ).decode("utf-8")
+                    image_prefix = f"data:image/{image_type};base64,"
+                    hybrid_content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"{image_prefix}{encoded_image}",
+                                "detail": self.image_detail,
+                            },
+                        }
                     )
-                image_prefix = f"data:image/{image_type};base64,"
-                hybrid_content.append(
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"{image_prefix}{encoded_image}",
-                            "detail": self.image_detail,
-                        },
-                    }
-                )
 
         if self.video_bytes:
             import imageio.v3 as iio
@@ -552,9 +588,66 @@ class BaseMessage:
         Returns:
             dict: The converted dictionary.
         """
-        return {
+        result = {
             "role_name": self.role_name,
             "role_type": self.role_type.value,
             **(self.meta_dict or {}),
             "content": self.content,
         }
+
+        # Include image/video fields if present
+        if self.image_list is not None:
+            # Handle both PIL Images and URL strings
+            import base64
+            from io import BytesIO
+
+            image_data_list = []
+            for img in self.image_list:
+                if isinstance(img, str):
+                    # Image is a URL string, store as-is
+                    image_data_list.append({"type": "url", "data": img})
+                else:
+                    # Image is a PIL Image, convert to base64
+                    # Preserve format, default to PNG if not set
+                    img_format = img.format if img.format else "PNG"
+
+                    # Handle transparency for different formats
+                    img_to_save = img
+                    if img.mode in (
+                        'RGBA',
+                        'LA',
+                        'P',
+                    ) and img_format.upper() in ('JPEG', 'JPG'):
+                        # JPEG doesn't support transparency, convert to RGB
+                        img_to_save = img.convert('RGB')
+                    elif (
+                        img.mode in ('LA', 'P') and img_format.upper() == 'PNG'
+                    ):
+                        # For PNG with transparency, convert to RGBA if needed
+                        img_to_save = img.convert('RGBA')
+                    # else: keep as-is for other combinations
+
+                    buffered = BytesIO()
+                    img_to_save.save(buffered, format=img_format)
+                    img_str = base64.b64encode(buffered.getvalue()).decode()
+                    image_data_list.append(
+                        {
+                            "type": "base64",
+                            "data": img_str,
+                            "format": img_format,  # Preserve format
+                        }
+                    )
+            result["image_list"] = image_data_list
+
+        if self.video_bytes is not None:
+            import base64
+
+            result["video_bytes"] = base64.b64encode(self.video_bytes).decode()
+
+        if self.image_detail is not None:
+            result["image_detail"] = self.image_detail
+
+        if self.video_detail is not None:
+            result["video_detail"] = self.video_detail
+
+        return result

camel/parsers/__init__.py

@@ -0,0 +1,18 @@
+# ========= 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. =========
+"""Helper parsers used across the CAMEL project."""
+
+from .mcp_tool_call_parser import extract_tool_calls_from_text
+
+__all__ = ["extract_tool_calls_from_text"]

camel/parsers/mcp_tool_call_parser.py

@@ -0,0 +1,176 @@
+# ========= 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. =========
+"""Utility functions for parsing MCP tool calls from model output."""
+
+import ast
+import json
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+try:  # pragma: no cover - optional dependency
+    import yaml
+except ImportError:  # pragma: no cover
+    yaml = None  # type: ignore[assignment]
+
+
+CODE_BLOCK_PATTERN = re.compile(
+    r"```(?:[a-z0-9_-]+)?\s*([\s\S]+?)\s*```",
+    re.IGNORECASE,
+)
+
+JSON_START_PATTERN = re.compile(r"[{\[]")
+JSON_TOKEN_PATTERN = re.compile(
+    r"""
+    (?P<double>"(?:\\.|[^"\\])*")
+    |
+    (?P<single>'(?:\\.|[^'\\])*')
+    |
+    (?P<brace>[{}\[\]])
+    """,
+    re.VERBOSE,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def extract_tool_calls_from_text(content: str) -> List[Dict[str, Any]]:
+    """Extract tool call dictionaries from raw text output."""
+
+    if not content:
+        return []
+
+    tool_calls: List[Dict[str, Any]] = []
+    seen_ranges: List[tuple[int, int]] = []
+
+    for match in CODE_BLOCK_PATTERN.finditer(content):
+        snippet = match.group(1).strip()
+        if not snippet:
+            continue
+
+        parsed = _try_parse_json_like(snippet)
+        if parsed is None:
+            logger.warning(
+                "Failed to parse JSON payload from fenced block: %s",
+                snippet,
+            )
+            continue
+
+        _collect_tool_calls(parsed, tool_calls)
+        seen_ranges.append((match.start(1), match.end(1)))
+
+    for start_match in JSON_START_PATTERN.finditer(content):
+        start_idx = start_match.start()
+
+        if any(start <= start_idx < stop for start, stop in seen_ranges):
+            continue
+
+        segment = _find_json_candidate(content, start_idx)
+        if segment is None:
+            continue
+
+        end_idx = start_idx + len(segment)
+        if any(start <= start_idx < stop for start, stop in seen_ranges):
+            continue
+
+        parsed = _try_parse_json_like(segment)
+        if parsed is None:
+            logger.debug(
+                "Unable to parse JSON-like candidate: %s",
+                _truncate_snippet(segment),
+            )
+            continue
+
+        _collect_tool_calls(parsed, tool_calls)
+        seen_ranges.append((start_idx, end_idx))
+
+    return tool_calls
+
+
+def _collect_tool_calls(
+    payload: Any, accumulator: List[Dict[str, Any]]
+) -> None:
+    """Collect valid tool call dictionaries from parsed payloads."""
+
+    if isinstance(payload, dict):
+        if payload.get("tool_name") is None:
+            return
+        accumulator.append(payload)
+    elif isinstance(payload, list):
+        for item in payload:
+            _collect_tool_calls(item, accumulator)
+
+
+def _try_parse_json_like(snippet: str) -> Optional[Any]:
+    """Parse a JSON or JSON-like snippet into Python data."""
+
+    try:
+        return json.loads(snippet)
+    except json.JSONDecodeError as exc:
+        logger.debug(
+            "json.loads failed: %s | snippet=%s",
+            exc,
+            _truncate_snippet(snippet),
+        )
+
+    if yaml is not None:
+        try:
+            return yaml.safe_load(snippet)
+        except yaml.YAMLError:
+            pass
+
+    try:
+        return ast.literal_eval(snippet)
+    except (ValueError, SyntaxError):
+        return None
+
+
+def _find_json_candidate(content: str, start_idx: int) -> Optional[str]:
+    """Locate a balanced JSON-like segment starting at ``start_idx``."""
+
+    opening = content[start_idx]
+    if opening not in "{[":
+        return None
+
+    stack = ["}" if opening == "{" else "]"]
+
+    for token in JSON_TOKEN_PATTERN.finditer(content, start_idx + 1):
+        if token.lastgroup in {"double", "single"}:
+            continue
+
+        brace = token.group("brace")
+        if brace in "{[":
+            stack.append("}" if brace == "{" else "]")
+            continue
+
+        if not stack:
+            return None
+
+        expected = stack.pop()
+        if brace != expected:
+            return None
+
+        if not stack:
+            return content[start_idx : token.end()]
+
+    return None
+
+
+def _truncate_snippet(snippet: str, limit: int = 120) -> str:
+    """Return a truncated representation suitable for logging."""
+
+    compact = " ".join(snippet.strip().split())
+    if len(compact) <= limit:
+        return compact
+    return f"{compact[: limit - 3]}..."

camel/societies/workforce/task_channel.py

@@ -16,8 +16,11 @@ from collections import defaultdict, deque
 from enum import Enum
 from typing import Dict, List, Optional, Set
 
+from camel.logger import get_logger
 from camel.tasks import Task
 
+logger = get_logger(__name__)
+
 
 class PacketStatus(Enum):
     r"""The status of a packet. The packet can be in one of the following
@@ -269,6 +272,46 @@ class TaskChannel:
         async with self._condition:
             return list(self._task_by_status[PacketStatus.ARCHIVED])
 
+    async def get_in_flight_tasks(self, publisher_id: str) -> List[Task]:
+        r"""Get all tasks that are currently in-flight (SENT, RETURNED
+        or PROCESSING) published by the given publisher.
+
+        Args:
+            publisher_id (str): The ID of the publisher whose
+            in-flight tasks to retrieve.
+
+        Returns:
+            List[Task]: List of tasks that are currently in-flight.
+        """
+        async with self._condition:
+            in_flight_tasks = []
+            seen_task_ids = set()  # Track seen IDs for duplicate detection
+
+            # Get tasks with SENT, RETURNED or PROCESSING
+            # status published by this publisher
+            for status in [
+                PacketStatus.SENT,
+                PacketStatus.PROCESSING,
+                PacketStatus.RETURNED,
+            ]:
+                for task_id in self._task_by_status[status]:
+                    if task_id in self._task_dict:
+                        packet = self._task_dict[task_id]
+                        if packet.publisher_id == publisher_id:
+                            # Defensive check: detect if task appears in
+                            # multiple status sets (should never happen)
+                            if task_id in seen_task_ids:
+                                logger.warning(
+                                    f"Task {task_id} found in multiple "
+                                    f"status sets. This indicates a bug in "
+                                    f"status management."
+                                )
+                                continue
+                            in_flight_tasks.append(packet.task)
+                            seen_task_ids.add(task_id)
+
+            return in_flight_tasks
+
     async def get_task_by_id(self, task_id: str) -> Task:
         r"""Get a task from the channel by its ID."""
         async with self._condition: