camel-ai 0.2.71a3__tar.gz → 0.2.71a4__tar.gz

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.71a3
+Version: 0.2.71a4
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -15,7 +15,7 @@ Requires-Dist: docstring-parser<0.16,>=0.15
 Requires-Dist: httpx<1.0.0dev,>=0.28.0
 Requires-Dist: jsonschema<5,>=4
 Requires-Dist: mcp>=1.3.0
-Requires-Dist: openai<2,>=1.68.0
+Requires-Dist: openai<2,>=1.86.0
 Requires-Dist: pillow<11.0.0,>=10.1.0
 Requires-Dist: psutil<6,>=5.9.8
 Requires-Dist: pydantic>=2.10.6
@@ -39,7 +39,7 @@ Requires-Dist: dappier<0.4,>=0.3.3; extra == 'all'
 Requires-Dist: datacommons-pandas<0.0.4,>=0.0.3; extra == 'all'
 Requires-Dist: datacommons<2,>=1.4.3; extra == 'all'
 Requires-Dist: datasets<4,>=3; extra == 'all'
-Requires-Dist: daytona-sdk>=0.20.0; extra == 'all'
+Requires-Dist: daytona-sdk==0.20.0; extra == 'all'
 Requires-Dist: diffusers<0.26,>=0.25.0; extra == 'all'
 Requires-Dist: discord-py<3,>=2.3.2; extra == 'all'
 Requires-Dist: docker<8,>=7.1.0; extra == 'all'
@@ -183,7 +183,7 @@ 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'
-Requires-Dist: daytona-sdk>=0.20.0; extra == 'dev-tools'
+Requires-Dist: daytona-sdk==0.20.0; extra == 'dev-tools'
 Requires-Dist: docker<8,>=7.1.0; extra == 'dev-tools'
 Requires-Dist: e2b-code-interpreter<2,>=1.0.3; extra == 'dev-tools'
 Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'
@@ -753,6 +753,45 @@ Practical guides and tutorials for implementing specific functionalities in CAME
 | **[3 Ways to Ingest Data from Websites with Firecrawl](https://docs.camel-ai.org/cookbooks/data_processing/ingest_data_from_websites_with_Firecrawl.html)** | Explore three methods for extracting and processing data from websites using Firecrawl. |
 | **[Create AI Agents that work with your PDFs](https://docs.camel-ai.org/cookbooks/data_processing/agent_with_chunkr_for_pdf_parsing.html)** | Learn how to create AI agents that work with your PDFs using Chunkr and Mistral AI. |
 
+<br>
+
+## Real-World Usecases
+
+Real-world usecases demonstrating how CAMEL’s multi-agent framework enables real business value across infrastructure automation, productivity workflows, retrieval-augmented conversations, intelligent document/video analysis, and collaborative research.
+
+### 1 Infrastructure Automation
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[ACI MCP](https://github.com/camel-ai/camel/tree/master/examples/usecases/aci_mcp)** | Real-world usecases demonstrating how CAMEL’s multi-agent framework enables real business value across infrastructure automation, productivity workflows, retrieval-augmented conversations, intelligent document/video analysis, and collaborative research. |
+| **[Cloudflare MCP CAMEL](https://github.com/camel-ai/camel/tree/master/examples/usecases/cloudfare_mcp_camel)** | Intelligent agents manage Cloudflare resources dynamically, enabling scalable and efficient cloud security and performance tuning. |
+
+### 2 Productivity & Business Workflows
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Airbnb MCP](https://github.com/camel-ai/camel/tree/master/examples/usecases/airbnb_mcp)** | Coordinate agents to optimize and manage Airbnb listings and host operations. |
+| **[PPTX Toolkit Usecase](https://github.com/camel-ai/camel/tree/master/examples/usecases/pptx_toolkit_usecase)** | Analyze PowerPoint documents and extract structured insights through multi-agent collaboration. |
+
+### 3 Retrieval-Augmented Multi-Agent Chat
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Chat with GitHub](https://github.com/camel-ai/camel/tree/master/examples/usecases/chat_with_github)** | Query and understand GitHub codebases through CAMEL agents leveraging RAG-style workflows, accelerating developer onboarding and codebase navigation. |
+| **[Chat with YouTube](https://github.com/camel-ai/camel/tree/master/examples/usecases/chat_with_youtube)** | Conversational agents extract and summarize video transcripts, enabling faster content understanding and repurposing. |
+
+### 4 Video & Document Intelligence
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[YouTube OCR](https://github.com/camel-ai/camel/tree/master/examples/usecases/youtube_ocr)** | Agents perform OCR on video screenshots to summarize visual content, supporting media monitoring and compliance. |
+| **[Mistral OCR](https://github.com/camel-ai/camel/tree/master/examples/usecases/mistral_OCR)** | CAMEL agents use OCR with Mistral to analyze documents, reducing manual effort in document understanding workflows. |
+
+### 5 Research & Collaboration
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Multi-Agent Research Assistant](https://github.com/camel-ai/camel/tree/master/examples/usecases/multi_agent_research_assistant)** | Simulates a team of research agents collaborating on literature review, improving efficiency in exploratory analysis and reporting. |
 
 <br>
 

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/README.md

@@ -396,6 +396,45 @@ Practical guides and tutorials for implementing specific functionalities in CAME
 | **[3 Ways to Ingest Data from Websites with Firecrawl](https://docs.camel-ai.org/cookbooks/data_processing/ingest_data_from_websites_with_Firecrawl.html)** | Explore three methods for extracting and processing data from websites using Firecrawl. |
 | **[Create AI Agents that work with your PDFs](https://docs.camel-ai.org/cookbooks/data_processing/agent_with_chunkr_for_pdf_parsing.html)** | Learn how to create AI agents that work with your PDFs using Chunkr and Mistral AI. |
 
+<br>
+
+## Real-World Usecases
+
+Real-world usecases demonstrating how CAMEL’s multi-agent framework enables real business value across infrastructure automation, productivity workflows, retrieval-augmented conversations, intelligent document/video analysis, and collaborative research.
+
+### 1 Infrastructure Automation
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[ACI MCP](https://github.com/camel-ai/camel/tree/master/examples/usecases/aci_mcp)** | Real-world usecases demonstrating how CAMEL’s multi-agent framework enables real business value across infrastructure automation, productivity workflows, retrieval-augmented conversations, intelligent document/video analysis, and collaborative research. |
+| **[Cloudflare MCP CAMEL](https://github.com/camel-ai/camel/tree/master/examples/usecases/cloudfare_mcp_camel)** | Intelligent agents manage Cloudflare resources dynamically, enabling scalable and efficient cloud security and performance tuning. |
+
+### 2 Productivity & Business Workflows
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Airbnb MCP](https://github.com/camel-ai/camel/tree/master/examples/usecases/airbnb_mcp)** | Coordinate agents to optimize and manage Airbnb listings and host operations. |
+| **[PPTX Toolkit Usecase](https://github.com/camel-ai/camel/tree/master/examples/usecases/pptx_toolkit_usecase)** | Analyze PowerPoint documents and extract structured insights through multi-agent collaboration. |
+
+### 3 Retrieval-Augmented Multi-Agent Chat
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Chat with GitHub](https://github.com/camel-ai/camel/tree/master/examples/usecases/chat_with_github)** | Query and understand GitHub codebases through CAMEL agents leveraging RAG-style workflows, accelerating developer onboarding and codebase navigation. |
+| **[Chat with YouTube](https://github.com/camel-ai/camel/tree/master/examples/usecases/chat_with_youtube)** | Conversational agents extract and summarize video transcripts, enabling faster content understanding and repurposing. |
+
+### 4 Video & Document Intelligence
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[YouTube OCR](https://github.com/camel-ai/camel/tree/master/examples/usecases/youtube_ocr)** | Agents perform OCR on video screenshots to summarize visual content, supporting media monitoring and compliance. |
+| **[Mistral OCR](https://github.com/camel-ai/camel/tree/master/examples/usecases/mistral_OCR)** | CAMEL agents use OCR with Mistral to analyze documents, reducing manual effort in document understanding workflows. |
+
+### 5 Research & Collaboration
+
+| Usecase                                                      | Description                                                  |
+| :----------------------------------------------------------- | :----------------------------------------------------------- |
+| **[Multi-Agent Research Assistant](https://github.com/camel-ai/camel/tree/master/examples/usecases/multi_agent_research_assistant)** | Simulates a team of research agents collaborating on literature review, improving efficiency in exploratory analysis and reporting. |
 
 <br>
 

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/camel/__init__.py

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

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/camel/interpreters/docker_interpreter.py

@@ -146,8 +146,9 @@ class DockerInterpreter(BaseInterpreter):
         tar_stream = io.BytesIO()
         with tarfile.open(fileobj=tar_stream, mode='w') as tar:
             tarinfo = tarfile.TarInfo(name=filename)
-            tarinfo.size = len(content)
-            tar.addfile(tarinfo, io.BytesIO(content.encode('utf-8')))
+            encoded_content = content.encode('utf-8')
+            tarinfo.size = len(encoded_content)
+            tar.addfile(tarinfo, io.BytesIO(encoded_content))
         tar_stream.seek(0)
 
         # copy the tar into the container

camel_ai-0.2.71a4/camel/loaders/base_loader.py

@@ -0,0 +1,85 @@
+# ========= 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 abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+
+class BaseLoader(ABC):
+    r"""Abstract base class for all data loaders in CAMEL."""
+
+    @abstractmethod
+    def _load_single(self, source: Union[str, Path]) -> Dict[str, Any]:
+        r"""Load data from a single source.
+
+        Args:
+            source (Union[str, Path]): The data source to load from.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the loaded data. It is
+                recommended that the dictionary includes a "content" key with
+                the primary data and optional metadata keys.
+        """
+        pass
+
+    def load(
+        self,
+        source: Union[str, Path, List[Union[str, Path]]],
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        r"""Load data from one or multiple sources.
+
+        Args:
+            source (Union[str, Path, List[Union[str, Path]]]): The data source
+                (s) to load from. Can be:
+                - A single path/URL (str or Path)
+                - A list of paths/URLs
+
+        Returns:
+            Dict[str, List[Dict[str, Any]]]: A dictionary with a single key
+                "contents" containing a list of loaded data. If a single source
+                is provided, the list will contain a single item.
+
+        Raises:
+            ValueError: If no sources are provided
+            Exception: If loading fails for any source
+        """
+        if not source:
+            raise ValueError("At least one source must be provided")
+
+        # Convert single source to list for uniform processing
+        sources = [source] if isinstance(source, (str, Path)) else list(source)
+
+        # Process all sources
+        results = []
+        for i, src in enumerate(sources, 1):
+            try:
+                content = self._load_single(src)
+                results.append(content)
+            except Exception as e:
+                raise RuntimeError(
+                    f"Error loading source {i}/{len(sources)}: {src}"
+                ) from e
+
+        return {"contents": results}
+
+    @property
+    @abstractmethod
+    def supported_formats(self) -> set[str]:
+        r"""Get the set of supported file formats or data sources.
+
+        Returns:
+            set[str]: A set of strings representing the supported formats/
+            sources.
+        """
+        pass

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/camel/societies/workforce/workforce.py

@@ -19,7 +19,16 @@ import time
 import uuid
 from collections import deque
 from enum import Enum
-from typing import Any, Coroutine, Deque, Dict, List, Optional, Set, Tuple
+from typing import (
+    Any,
+    Coroutine,
+    Deque,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+)
 
 from colorama import Fore
 
@@ -200,7 +209,7 @@ class Workforce(BaseNode):
         children: Optional[List[BaseNode]] = None,
         coordinator_agent: Optional[ChatAgent] = None,
         task_agent: Optional[ChatAgent] = None,
-        new_worker_agent: Optional[ChatAgent] = None,  # TODO: use MCP Agent
+        new_worker_agent: Optional[ChatAgent] = None,
         graceful_shutdown_timeout: float = 15.0,
         share_memory: bool = False,
     ) -> None:
@@ -325,9 +334,10 @@ class Workforce(BaseNode):
                 "settings (ModelPlatformType.DEFAULT, ModelType.DEFAULT) "
                 "with default system message and TaskPlanningToolkit."
             )
+            task_tools = TaskPlanningToolkit().get_tools()
             self.task_agent = ChatAgent(
                 task_sys_msg,
-                tools=TaskPlanningToolkit().get_tools(),  # type: ignore[arg-type]
+                tools=task_tools,  # type: ignore[arg-type]
             )
         else:
             logger.info(
@@ -563,6 +573,44 @@ class Workforce(BaseNode):
         except Exception as e:
             logger.warning(f"Error synchronizing shared memory: {e}")
 
+    def _update_dependencies_for_decomposition(
+        self, original_task: Task, subtasks: List[Task]
+    ) -> None:
+        r"""Update dependency tracking when a task is decomposed into subtasks.
+        Tasks that depended on the original task should now depend on all
+        subtasks. The last subtask inherits the original task's dependencies.
+        """
+        if not subtasks:
+            return
+
+        original_task_id = original_task.id
+        subtask_ids = [subtask.id for subtask in subtasks]
+
+        # Find tasks that depend on the original task
+        dependent_task_ids = [
+            task_id
+            for task_id, deps in self._task_dependencies.items()
+            if original_task_id in deps
+        ]
+
+        # Update dependent tasks to depend on all subtasks
+        for task_id in dependent_task_ids:
+            dependencies = self._task_dependencies[task_id]
+            dependencies.remove(original_task_id)
+            dependencies.extend(subtask_ids)
+
+        # The last subtask inherits original task's dependencies (if any)
+        if original_task_id in self._task_dependencies:
+            original_dependencies = self._task_dependencies[original_task_id]
+            if original_dependencies:
+                # Set dependencies for the last subtask to maintain execution
+                # order
+                self._task_dependencies[subtask_ids[-1]] = (
+                    original_dependencies.copy()
+                )
+            # Remove original task dependencies as it's now decomposed
+            del self._task_dependencies[original_task_id]
+
     def _cleanup_task_tracking(self, task_id: str) -> None:
         r"""Clean up tracking data for a task to prevent memory leaks.
 
@@ -590,6 +638,10 @@ class Workforce(BaseNode):
         for subtask in subtasks:
             subtask.parent = task
 
+        # Update dependency tracking for decomposed task
+        if subtasks:
+            self._update_dependencies_for_decomposition(task, subtasks)
+
         return subtasks
 
     # Human intervention methods
@@ -1436,7 +1488,9 @@ class Workforce(BaseNode):
 
         return valid_assignments, invalid_assignments
 
-    def _handle_task_assignment_fallbacks(self, tasks: List[Task]) -> List:
+    async def _handle_task_assignment_fallbacks(
+        self, tasks: List[Task]
+    ) -> List:
         r"""Create new workers for unassigned tasks as fallback.
 
         Args:
@@ -1449,7 +1503,7 @@ class Workforce(BaseNode):
 
         for task in tasks:
             logger.info(f"Creating new worker for unassigned task {task.id}")
-            new_worker = self._create_worker_node_for_task(task)
+            new_worker = await self._create_worker_node_for_task(task)
 
             assignment = TaskAssignment(
                 task_id=task.id,
@@ -1460,7 +1514,7 @@ class Workforce(BaseNode):
 
         return fallback_assignments
 
-    def _handle_assignment_retry_and_fallback(
+    async def _handle_assignment_retry_and_fallback(
         self,
         invalid_assignments: List[TaskAssignment],
         tasks: List[Task],
@@ -1531,14 +1585,14 @@ class Workforce(BaseNode):
                 f"Creating fallback workers for {len(unassigned_tasks)} "
                 f"unassigned tasks"
             )
-            fallback_assignments = self._handle_task_assignment_fallbacks(
-                unassigned_tasks
+            fallback_assignments = (
+                await self._handle_task_assignment_fallbacks(unassigned_tasks)
             )
             final_assignments.extend(fallback_assignments)
 
         return final_assignments
 
-    def _find_assignee(
+    async def _find_assignee(
         self,
         tasks: List[Task],
     ) -> TaskAssignResult:
@@ -1580,7 +1634,7 @@ class Workforce(BaseNode):
         # invalid assignments and unassigned tasks
         all_problem_assignments = invalid_assignments
         retry_and_fallback_assignments = (
-            self._handle_assignment_retry_and_fallback(
+            await self._handle_assignment_retry_and_fallback(
                 all_problem_assignments, tasks, valid_worker_ids
             )
         )
@@ -1616,7 +1670,7 @@ class Workforce(BaseNode):
     async def _post_dependency(self, dependency: Task) -> None:
         await self._channel.post_dependency(dependency, self.node_id)
 
-    def _create_worker_node_for_task(self, task: Task) -> Worker:
+    async def _create_worker_node_for_task(self, task: Task) -> Worker:
         r"""Creates a new worker node for a given task and add it to the
         children list of this node. This is one of the actions that
         the coordinator can take when a task has failed.
@@ -1662,7 +1716,7 @@ class Workforce(BaseNode):
                     f"Coordinator agent returned malformed JSON response. "
                 )
 
-        new_agent = self._create_new_agent(
+        new_agent = await self._create_new_agent(
             new_node_conf.role,
             new_node_conf.sys_msg,
         )
@@ -1689,14 +1743,19 @@ class Workforce(BaseNode):
         )
         return new_node
 
-    def _create_new_agent(self, role: str, sys_msg: str) -> ChatAgent:
+    async def _create_new_agent(self, role: str, sys_msg: str) -> ChatAgent:
         worker_sys_msg = BaseMessage.make_assistant_message(
             role_name=role,
             content=sys_msg,
         )
 
         if self.new_worker_agent is not None:
-            return self.new_worker_agent
+            # Clone the template agent to create an independent instance
+            cloned_agent = self.new_worker_agent.clone(with_memory=False)
+            # Update the system message for the specific role
+            cloned_agent._system_message = worker_sys_msg
+            cloned_agent.init_messages()  # Initialize with new system message
+            return cloned_agent
         else:
             # Default tools for a new agent
             function_list = [
@@ -1712,7 +1771,7 @@ class Workforce(BaseNode):
             )
 
             return ChatAgent(
-                worker_sys_msg,
+                system_message=worker_sys_msg,
                 model=model,
                 tools=function_list,  # type: ignore[arg-type]
                 pause_event=self._pause_event,
@@ -1765,7 +1824,7 @@ class Workforce(BaseNode):
                 f"Found {len(tasks_to_assign)} new tasks. "
                 f"Requesting assignment..."
             )
-            batch_result = self._find_assignee(tasks_to_assign)
+            batch_result = await self._find_assignee(tasks_to_assign)
             logger.debug(
                 f"Coordinator returned assignments:\n"
                 f"{json.dumps(batch_result.dict(), indent=2)}"
@@ -1788,17 +1847,19 @@ class Workforce(BaseNode):
         # Step 2: Iterate through all pending tasks and post those that are
         # ready
         posted_tasks = []
-        # Pre-compute completed task IDs set for O(1) lookups
-        completed_task_ids = {t.id for t in self._completed_tasks}
+        # Pre-compute completed task IDs and their states for O(1) lookups
+        completed_tasks_info = {t.id: t.state for t in self._completed_tasks}
 
         for task in self._pending_tasks:
             # A task must be assigned to be considered for posting
             if task.id in self._task_dependencies:
                 dependencies = self._task_dependencies[task.id]
                 # Check if all dependencies for this task are in the completed
-                # set
+                # set and their state is DONE
                 if all(
-                    dep_id in completed_task_ids for dep_id in dependencies
+                    dep_id in completed_tasks_info
+                    and completed_tasks_info[dep_id] == TaskState.DONE
+                    for dep_id in dependencies
                 ):
                     assignee_id = self._assignees[task.id]
                     logger.debug(
@@ -1885,7 +1946,7 @@ class Workforce(BaseNode):
 
         if task.get_depth() > 3:
             # Create a new worker node and reassign
-            assignee = self._create_worker_node_for_task(task)
+            assignee = await self._create_worker_node_for_task(task)
 
             # Sync shared memory after creating new worker to provide context
             if self.share_memory:
@@ -1915,19 +1976,35 @@ class Workforce(BaseNode):
             # Insert packets at the head of the queue
             self._pending_tasks.extendleft(reversed(subtasks))
 
+            await self._post_ready_tasks()
+            action_taken = f"decomposed into {len(subtasks)} subtasks"
+
+            # Handle task completion differently for decomposed tasks
+            if task.id in self._assignees:
+                await self._channel.archive_task(task.id)
+
+            self._cleanup_task_tracking(task.id)
+            logger.debug(
+                f"Task {task.id} failed and was {action_taken}. "
+                f"Dependencies updated for subtasks."
+            )
+
             # Sync shared memory after task decomposition
             if self.share_memory:
                 logger.info(
-                    f"Syncing shared memory after decomposing failed "
-                    f"task {task.id}"
+                    f"Syncing shared memory after task {task.id} decomposition"
                 )
                 self._sync_shared_memory()
 
+            # Check if any pending tasks are now ready to execute
             await self._post_ready_tasks()
-            action_taken = f"decomposed into {len(subtasks)} subtasks"
+            return False
+
+        # For reassigned tasks (depth > 3), handle normally
         if task.id in self._assignees:
             await self._channel.archive_task(task.id)
 
+        self._cleanup_task_tracking(task.id)
         logger.debug(
             f"Task {task.id} failed and was {action_taken}. "
             f"Updating dependency state."
@@ -2020,31 +2097,65 @@ class Workforce(BaseNode):
                 break
 
         if not found_and_removed:
-            # Task was already removed from pending queue (expected case when
-            # it had been popped immediately after posting).  No need to
-            # draw user attention with a warning; record at debug level.
+            # Task was already removed from pending queue (common case when
+            # it was posted and removed immediately).
             logger.debug(
                 f"Completed task {task.id} was already removed from pending "
-                "queue."
+                "queue (normal for posted tasks)."
             )
 
         # Archive the task and update dependency tracking
         if task.id in self._assignees:
             await self._channel.archive_task(task.id)
 
-        # Ensure it's in completed tasks set
-        self._completed_tasks.append(task)
+        # Ensure it's in completed tasks set by updating if it exists or
+        # appending if it's new.
+        task_found_in_completed = False
+        for i, t in enumerate(self._completed_tasks):
+            if t.id == task.id:
+                self._completed_tasks[i] = task
+                task_found_in_completed = True
+                break
+        if not task_found_in_completed:
+            self._completed_tasks.append(task)
 
         # Handle parent task completion logic
         parent = task.parent
-        if parent and parent.id not in {t.id for t in self._completed_tasks}:
+        if parent:
+            # Check if all subtasks are completed and successful
             all_subtasks_done = all(
-                sub.id in {t.id for t in self._completed_tasks}
+                any(
+                    t.id == sub.id and t.state == TaskState.DONE
+                    for t in self._completed_tasks
+                )
                 for sub in parent.subtasks
             )
             if all_subtasks_done:
-                # Set the parent task state to done
+                # Collect results from successful subtasks only
+                successful_results = []
+                for sub in parent.subtasks:
+                    completed_subtask = next(
+                        (
+                            t
+                            for t in self._completed_tasks
+                            if t.id == sub.id and t.state == TaskState.DONE
+                        ),
+                        None,
+                    )
+                    if completed_subtask and completed_subtask.result:
+                        successful_results.append(
+                            f"--- Subtask {sub.id} Result ---\n"
+                            f"{completed_subtask.result}"
+                        )
+
+                # Set parent task state and result
                 parent.state = TaskState.DONE
+                parent.result = (
+                    "\n\n".join(successful_results)
+                    if successful_results
+                    else "All subtasks completed"
+                )
+
                 logger.debug(
                     f"All subtasks of {parent.id} are done. "
                     f"Marking parent as complete."

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/camel/toolkits/__init__.py

@@ -23,7 +23,7 @@ from .open_api_specs.security_config import openapi_security_config
 from .math_toolkit import MathToolkit
 from .search_toolkit import SearchToolkit
 from .weather_toolkit import WeatherToolkit
-from .dalle_toolkit import DalleToolkit
+from .openai_image_toolkit import OpenAIImageToolkit
 from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
@@ -82,6 +82,7 @@ from .edgeone_pages_mcp_toolkit import EdgeOnePagesMCPToolkit
 from .google_drive_mcp_toolkit import GoogleDriveMCPToolkit
 from .craw4ai_toolkit import Crawl4AIToolkit
 from .markitdown_toolkit import MarkItDownToolkit
+from .note_taking_toolkit import NoteTakingToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -96,7 +97,7 @@ __all__ = [
     'SearchToolkit',
     'SlackToolkit',
     'WhatsAppToolkit',
-    'DalleToolkit',
+    'OpenAIImageToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
     'RetrievalToolkit',
@@ -145,10 +146,12 @@ __all__ = [
     'PlaywrightMCPToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
+    'OpenAIImageToolkit',
     'TaskPlanningToolkit',
     'HybridBrowserToolkit',
     'EdgeOnePagesMCPToolkit',
     'GoogleDriveMCPToolkit',
     'Crawl4AIToolkit',
     'MarkItDownToolkit',
+    'NoteTakingToolkit',
 ]

{camel_ai-0.2.71a3 → camel_ai-0.2.71a4}/camel/toolkits/craw4ai_toolkit.py

@@ -71,11 +71,11 @@ class Crawl4AIToolkit(BaseToolkit):
             return f"Error scraping {url}: {e}"
 
     async def __aenter__(self):
-        """Async context manager entry."""
+        r"""Async context manager entry."""
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit - cleanup the client."""
+        r"""Async context manager exit - cleanup the client."""
         if self._client is not None:
             await self._client.__aexit__(exc_type, exc_val, exc_tb)
             self._client = None