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

camel/societies/role_playing.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 import logging
 import threading
 from typing import Dict, List, Optional, Sequence, Tuple, Union
@@ -62,8 +62,8 @@ class RolePlaying:
             (default: :obj:`TaskType.AI_SOCIETY`)
         assistant_agent_kwargs (Dict, optional): Additional arguments to pass
             to the assistant agent. (default: :obj:`None`)
-        user_agent_kwargs (Dict, optional): Additional arguments to pass to
-            the user agent. (default: :obj:`None`)
+        user_agent_kwargs (Dict, optional): Additional arguments to pass to the
+            user agent. (default: :obj:`None`)
         task_specify_agent_kwargs (Dict, optional): Additional arguments to
             pass to the task specify agent. (default: :obj:`None`)
         task_planner_agent_kwargs (Dict, optional): Additional arguments to
@@ -81,6 +81,12 @@ class RolePlaying:
         stop_event (Optional[threading.Event], optional): Event to signal
             termination of the agent's operation. When set, the agent will
             terminate its execution. (default: :obj:`None`)
+        assistant_agent (ChatAgent, optional): A pre-configured ChatAgent to
+            use as the assistant. If provided, this will override the creation
+            of a new assistant agent. (default: :obj:`None`)
+        user_agent (ChatAgent, optional): A pre-configured ChatAgent to use as
+            the user. If provided, this will override the creation of a new
+            user agent. (default: :obj:`None`)
     """
 
     def __init__(
@@ -106,6 +112,8 @@ class RolePlaying:
         extend_task_specify_meta_dict: Optional[Dict] = None,
         output_language: Optional[str] = None,
         stop_event: Optional[threading.Event] = None,
+        assistant_agent: Optional[ChatAgent] = None,
+        user_agent: Optional[ChatAgent] = None,
     ) -> None:
         if model is not None:
             logger.warning(
@@ -143,21 +151,45 @@ class RolePlaying:
             **(sys_msg_generator_kwargs or {}),
         )
 
-        (
-            init_assistant_sys_msg,
-            init_user_sys_msg,
-            sys_msg_meta_dicts,
-        ) = self._get_sys_message_info(
-            assistant_role_name,
-            user_role_name,
-            sys_msg_generator,
-            extend_sys_msg_meta_dicts=extend_sys_msg_meta_dicts,
-        )
-
+        # Initialize agent attributes first
         self.assistant_agent: ChatAgent
         self.user_agent: ChatAgent
-        self.assistant_sys_msg: Optional[BaseMessage]
-        self.user_sys_msg: Optional[BaseMessage]
+        self.assistant_sys_msg: Optional[BaseMessage] = None
+        self.user_sys_msg: Optional[BaseMessage] = None
+
+        # Determine if we need to generate system messages
+        if assistant_agent is None or user_agent is None:
+            # Generate system messages for missing agents
+            (
+                init_assistant_sys_msg,
+                init_user_sys_msg,
+                sys_msg_meta_dicts,
+            ) = self._get_sys_message_info(
+                assistant_role_name,
+                user_role_name,
+                sys_msg_generator,
+                extend_sys_msg_meta_dicts=extend_sys_msg_meta_dicts,
+            )
+        else:
+            # When both agents are provided, use their existing system messages
+            assistant_sys_msg = assistant_agent.system_message
+            user_sys_msg = user_agent.system_message
+
+            # Ensure system messages are not None
+            if assistant_sys_msg is None:
+                raise ValueError(
+                    "Provided assistant_agent has None system_message"
+                )
+            if user_sys_msg is None:
+                raise ValueError("Provided user_agent has None system_message")
+
+            init_assistant_sys_msg = assistant_sys_msg
+            init_user_sys_msg = user_sys_msg
+            # Create a default sys_msg_meta_dicts for critic initialization
+            sys_msg_meta_dicts = [
+                dict(task=self.task_prompt) for _ in range(2)
+            ]
+
         self._init_agents(
             init_assistant_sys_msg,
             init_user_sys_msg,
@@ -165,7 +197,10 @@ class RolePlaying:
             user_agent_kwargs=user_agent_kwargs,
             output_language=output_language,
             stop_event=stop_event,
+            assistant_agent=assistant_agent,
+            user_agent=user_agent,
         )
+
         self.critic: Optional[Union[CriticAgent, Human]] = None
         self.critic_sys_msg: Optional[BaseMessage] = None
         self._init_critic(
@@ -320,20 +355,22 @@ class RolePlaying:
 
     def _init_agents(
         self,
-        init_assistant_sys_msg: BaseMessage,
-        init_user_sys_msg: BaseMessage,
+        init_assistant_sys_msg: Optional[BaseMessage],
+        init_user_sys_msg: Optional[BaseMessage],
         assistant_agent_kwargs: Optional[Dict] = None,
         user_agent_kwargs: Optional[Dict] = None,
         output_language: Optional[str] = None,
         stop_event: Optional[threading.Event] = None,
+        assistant_agent: Optional[ChatAgent] = None,
+        user_agent: Optional[ChatAgent] = None,
     ) -> None:
         r"""Initialize assistant and user agents with their system messages.
 
         Args:
-            init_assistant_sys_msg (BaseMessage): Assistant agent's initial
+            init_assistant_sys_msg (Optional[BaseMessage]): Assistant agent's
+                initial system message.
+            init_user_sys_msg (Optional[BaseMessage]): User agent's initial
                 system message.
-            init_user_sys_msg (BaseMessage): User agent's initial system
-                message.
             assistant_agent_kwargs (Dict, optional): Additional arguments to
                 pass to the assistant agent. (default: :obj:`None`)
             user_agent_kwargs (Dict, optional): Additional arguments to
@@ -343,6 +380,12 @@ class RolePlaying:
             stop_event (Optional[threading.Event], optional): Event to signal
                 termination of the agent's operation. When set, the agent will
                 terminate its execution. (default: :obj:`None`)
+            assistant_agent (ChatAgent, optional): A pre-configured ChatAgent
+                to use as the assistant. If provided, this will override the
+                creation of a new assistant agent. (default: :obj:`None`)
+            user_agent (ChatAgent, optional): A pre-configured ChatAgent to use
+                as the user. If provided, this will override the creation of a
+                new user agent. (default: :obj:`None`)
         """
         if self.model is not None:
             if assistant_agent_kwargs is None:
@@ -354,21 +397,71 @@ class RolePlaying:
             elif 'model' not in user_agent_kwargs:
                 user_agent_kwargs.update(dict(model=self.model))
 
-        self.assistant_agent = ChatAgent(
-            init_assistant_sys_msg,
-            output_language=output_language,
-            stop_event=stop_event,
-            **(assistant_agent_kwargs or {}),
-        )
-        self.assistant_sys_msg = self.assistant_agent.system_message
-
-        self.user_agent = ChatAgent(
-            init_user_sys_msg,
-            output_language=output_language,
-            stop_event=stop_event,
-            **(user_agent_kwargs or {}),
-        )
-        self.user_sys_msg = self.user_agent.system_message
+        # Use provided assistant agent if available, otherwise create a new one
+        if assistant_agent is not None:
+            # Ensure functionality consistent with our configuration
+            if (
+                hasattr(assistant_agent, 'output_language')
+                and output_language is not None
+            ):
+                assistant_agent.output_language = output_language
+            if hasattr(assistant_agent, 'stop_event'):
+                assistant_agent.stop_event = stop_event
+            self.assistant_agent = assistant_agent
+            # Handle potential None system_message - use provided or fallback
+            if assistant_agent.system_message is not None:
+                self.assistant_sys_msg = assistant_agent.system_message
+            elif init_assistant_sys_msg is not None:
+                self.assistant_sys_msg = init_assistant_sys_msg
+            else:
+                raise ValueError("Assistant system message cannot be None")
+        else:
+            # Create new assistant agent
+            if init_assistant_sys_msg is None:
+                raise ValueError(
+                    "Assistant system message cannot be None when creating "
+                    "new agent"
+                )
+            self.assistant_agent = ChatAgent(
+                init_assistant_sys_msg,
+                output_language=output_language,
+                stop_event=stop_event,
+                **(assistant_agent_kwargs or {}),
+            )
+            self.assistant_sys_msg = self.assistant_agent.system_message
+
+        # Use provided user agent if available, otherwise create a new one
+        if user_agent is not None:
+            # Ensure functionality consistent with our configuration
+            if (
+                hasattr(user_agent, 'output_language')
+                and output_language is not None
+            ):
+                user_agent.output_language = output_language
+            if hasattr(user_agent, 'stop_event'):
+                user_agent.stop_event = stop_event
+            self.user_agent = user_agent
+            # Handle potential None system_message - use provided or fallback
+            if user_agent.system_message is not None:
+                self.user_sys_msg = user_agent.system_message
+            elif init_user_sys_msg is not None:
+                self.user_sys_msg = init_user_sys_msg
+            else:
+                raise ValueError("User system message cannot be None")
+        else:
+            # Create new user agent
+            if init_user_sys_msg is None:
+                raise ValueError(
+                    "User system message cannot be None when creating new "
+                    "agent"
+                )
+            self.user_agent = ChatAgent(
+                init_user_sys_msg,
+                output_language=output_language,
+                stop_event=stop_event,
+                **(user_agent_kwargs or {}),
+            )
+            self.user_sys_msg = self.user_agent.system_message
 
     def _init_critic(
         self,
@@ -389,7 +482,7 @@ class RolePlaying:
             sys_msg_meta_dicts (list): A list of system message meta dicts.
             critic_role_name (str): The name of the role played by the critic.
             critic_criteria (str, optional): Critic criteria for the
-                critic agent. If not specified, set the criteria to
+                critic agent. If not specified, set it to
                 improve task performance. (default: :obj:`None`)
             critic_kwargs (Dict, optional): Additional arguments to
                 pass to the critic. (default: :obj:`None`)
@@ -465,20 +558,28 @@ class RolePlaying:
             BaseMessage: A single `BaseMessage` representing the initial
                 message.
         """
-        self.assistant_agent.reset()
-        self.user_agent.reset()
+        if self.assistant_agent is not None:
+            self.assistant_agent.reset()
+        if self.user_agent is not None:
+            self.user_agent.reset()
         default_init_msg_content = (
             "Now start to give me instructions one by one. "
             "Only reply with Instruction and Input."
         )
-        if init_msg_content is None:
-            init_msg_content = default_init_msg_content
+        final_init_msg_content = init_msg_content or default_init_msg_content
 
         # Initialize a message sent by the assistant
+        assistant_role_name = "assistant"
+        if self.assistant_sys_msg is not None and hasattr(
+            self.assistant_sys_msg, 'role_name'
+        ):
+            role_name_attr = getattr(self.assistant_sys_msg, 'role_name', None)
+            if role_name_attr is not None:
+                assistant_role_name = str(role_name_attr)
+
         init_msg = BaseMessage.make_assistant_message(
-            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
-            or "assistant",
-            content=init_msg_content,
+            role_name=assistant_role_name,
+            content=final_init_msg_content,
         )
 
         return init_msg
@@ -501,20 +602,28 @@ class RolePlaying:
         """
         # Currently, reset() is synchronous, but if it becomes async in the
         # future, we can await it here
-        self.assistant_agent.reset()
-        self.user_agent.reset()
+        if self.assistant_agent is not None:
+            self.assistant_agent.reset()
+        if self.user_agent is not None:
+            self.user_agent.reset()
         default_init_msg_content = (
             "Now start to give me instructions one by one. "
             "Only reply with Instruction and Input."
         )
-        if init_msg_content is None:
-            init_msg_content = default_init_msg_content
+        final_init_msg_content = init_msg_content or default_init_msg_content
 
         # Initialize a message sent by the assistant
+        assistant_role_name = "assistant"
+        if self.assistant_sys_msg is not None and hasattr(
+            self.assistant_sys_msg, 'role_name'
+        ):
+            role_name_attr = getattr(self.assistant_sys_msg, 'role_name', None)
+            if role_name_attr is not None:
+                assistant_role_name = str(role_name_attr)
+
         init_msg = BaseMessage.make_assistant_message(
-            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
-            or "assistant",
-            content=init_msg_content,
+            role_name=assistant_role_name,
+            content=final_init_msg_content,
         )
 
         return init_msg
@@ -544,6 +653,11 @@ class RolePlaying:
                 user agent terminated the conversation, and any additional user
                 information.
         """
+        if self.user_agent is None:
+            raise ValueError("User agent is not initialized")
+        if self.assistant_agent is None:
+            raise ValueError("Assistant agent is not initialized")
+
         user_response = self.user_agent.step(assistant_msg)
         if user_response.terminated or user_response.msgs is None:
             return (
@@ -556,13 +670,12 @@ class RolePlaying:
             )
         user_msg = self._reduce_message_options(user_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.user_agent.model_backend.model_config_dict.keys()
-            and self.user_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        # To prevent recording missing messages: ChatAgent.step automatically
+        # saves the response to memory only when a single message is returned.
+        # When multi-response support is enabled (n > 1), it is the caller's
+        # responsibility to record the selected message. Therefore, we record
+        # it here after choosing one message via `_reduce_message_options()`.
+        if self._is_multi_response(self.user_agent):
             self.user_agent.record_message(user_msg)
 
         assistant_response = self.assistant_agent.step(user_msg)
@@ -579,13 +692,7 @@ class RolePlaying:
             )
         assistant_msg = self._reduce_message_options(assistant_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
-            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.assistant_agent):
             self.assistant_agent.record_message(assistant_msg)
 
         return (
@@ -627,6 +734,11 @@ class RolePlaying:
                 user agent terminated the conversation, and any additional user
                 information.
         """
+        if self.user_agent is None:
+            raise ValueError("User agent is not initialized")
+        if self.assistant_agent is None:
+            raise ValueError("Assistant agent is not initialized")
+
         user_response = await self.user_agent.astep(assistant_msg)
         if user_response.terminated or user_response.msgs is None:
             return (
@@ -639,13 +751,7 @@ class RolePlaying:
             )
         user_msg = self._reduce_message_options(user_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.user_agent.model_backend.model_config_dict.keys()
-            and self.user_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.user_agent):
             self.user_agent.record_message(user_msg)
 
         assistant_response = await self.assistant_agent.astep(user_msg)
@@ -662,13 +768,7 @@ class RolePlaying:
             )
         assistant_msg = self._reduce_message_options(assistant_response.msgs)
 
-        # To prevent recording the same memory more than once (once in chat
-        # step and once in role play), and the model generates only one
-        # response when multi-response support is enabled.
-        if (
-            'n' in self.assistant_agent.model_backend.model_config_dict.keys()
-            and self.assistant_agent.model_backend.model_config_dict['n'] > 1
-        ):
+        if self._is_multi_response(self.assistant_agent):
             self.assistant_agent.record_message(assistant_msg)
 
         return (
@@ -701,6 +801,10 @@ class RolePlaying:
             RolePlaying: A new instance of RolePlaying with the same
                 configuration.
         """
+        if self.assistant_agent is None or self.user_agent is None:
+            raise ValueError(
+                "Cannot clone: assistant_agent or user_agent is None"
+            )
 
         new_instance = RolePlaying(
             assistant_role_name=self.assistant_agent.role_name,
@@ -730,3 +834,20 @@ class RolePlaying:
             new_instance.critic = self.critic.clone(with_memory)
 
         return new_instance
+
+    def _is_multi_response(self, agent: ChatAgent) -> bool:
+        r"""Checks if the given agent supports multi-response.
+
+        Args:
+            agent (ChatAgent): The agent to check for multi-response support.
+
+        Returns:
+            bool: True if the agent supports multi-response, False otherwise.
+        """
+        if (
+            'n' in agent.model_backend.model_config_dict.keys()
+            and agent.model_backend.model_config_dict['n'] is not None
+            and agent.model_backend.model_config_dict['n'] > 1
+        ):
+            return True
+        return False

camel/societies/workforce/__init__.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,14 +10,21 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 
 from .role_playing_worker import RolePlayingWorker
 from .single_agent_worker import SingleAgentWorker
-from .workforce import Workforce
+from .utils import FailureHandlingConfig, PipelineTaskBuilder, RecoveryStrategy
+from .workflow_memory_manager import WorkflowSelectionMethod
+from .workforce import Workforce, WorkforceMode
 
 __all__ = [
     "Workforce",
+    "WorkforceMode",
+    "PipelineTaskBuilder",
     "SingleAgentWorker",
     "RolePlayingWorker",
+    "WorkflowSelectionMethod",
+    "FailureHandlingConfig",
+    "RecoveryStrategy",
 ]

camel/societies/workforce/base.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2025 @ 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
@@ -10,9 +10,9 @@
 # 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. =========
+# ========= Copyright 2023-2025 @ CAMEL-AI.org. All Rights Reserved. =========
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Optional
 
 from camel.societies.workforce.task_channel import TaskChannel
 from camel.societies.workforce.utils import check_if_running
@@ -23,10 +23,14 @@ class BaseNode(ABC):
 
     Args:
         description (str): Description of the node.
+        node_id (Optional[str]): ID of the node. If not provided, it will
+            be generated automatically. (default: :obj:`None`)
     """
 
-    def __init__(self, description: str) -> None:
-        self.node_id = str(id(self))
+    def __init__(
+        self, description: str, node_id: Optional[str] = None
+    ) -> None:
+        self.node_id = node_id if node_id is not None else str(id(self))
         self.description = description
         self._channel: TaskChannel = TaskChannel()
         self._running = False

camel/societies/workforce/events.py

@@ -0,0 +1,143 @@
+# ========= Copyright 2023-2025 @ 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-2025 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class WorkforceEventBase(BaseModel):
+    model_config = ConfigDict(frozen=True, extra='forbid')
+    event_type: Literal[
+        "log",
+        "task_decomposed",
+        "task_created",
+        "task_assigned",
+        "task_started",
+        "task_completed",
+        "task_failed",
+        "worker_created",
+        "worker_deleted",
+        "queue_status",
+        "all_tasks_completed",
+    ]
+    metadata: Optional[Dict[str, Any]] = None
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+
+
+class LogEvent(WorkforceEventBase):
+    event_type: Literal["log"] = "log"
+    message: str
+    level: Literal["debug", "info", "warning", "error", "critical"]
+    color: (
+        Literal[
+            "red",
+            "green",
+            "yellow",
+            "blue",
+            "cyan",
+            "magenta",
+            "gray",
+            "black",
+        ]
+        | None
+    ) = None
+
+
+class WorkerCreatedEvent(WorkforceEventBase):
+    event_type: Literal["worker_created"] = "worker_created"
+    worker_id: str
+    worker_type: str
+    role: str
+
+
+class WorkerDeletedEvent(WorkforceEventBase):
+    event_type: Literal["worker_deleted"] = "worker_deleted"
+    worker_id: str
+    reason: Optional[str] = None
+
+
+class TaskDecomposedEvent(WorkforceEventBase):
+    event_type: Literal["task_decomposed"] = "task_decomposed"
+    parent_task_id: str
+    subtask_ids: List[str]
+
+
+class TaskCreatedEvent(WorkforceEventBase):
+    event_type: Literal["task_created"] = "task_created"
+    task_id: str
+    description: str
+    parent_task_id: Optional[str] = None
+    task_type: Optional[str] = None
+
+
+class TaskAssignedEvent(WorkforceEventBase):
+    event_type: Literal["task_assigned"] = "task_assigned"
+    task_id: str
+    worker_id: str
+    queue_time_seconds: Optional[float] = None
+    dependencies: Optional[List[str]] = None
+
+
+class TaskStartedEvent(WorkforceEventBase):
+    event_type: Literal["task_started"] = "task_started"
+    task_id: str
+    worker_id: str
+
+
+class TaskCompletedEvent(WorkforceEventBase):
+    event_type: Literal["task_completed"] = "task_completed"
+    task_id: str
+    worker_id: str
+    result_summary: Optional[str] = None
+    processing_time_seconds: Optional[float] = None
+    token_usage: Optional[Dict[str, int]] = None
+
+
+class TaskFailedEvent(WorkforceEventBase):
+    event_type: Literal["task_failed"] = "task_failed"
+    task_id: str
+    error_message: str
+    worker_id: Optional[str] = None
+
+
+class AllTasksCompletedEvent(WorkforceEventBase):
+    event_type: Literal["all_tasks_completed"] = "all_tasks_completed"
+
+
+class QueueStatusEvent(WorkforceEventBase):
+    event_type: Literal["queue_status"] = "queue_status"
+    queue_name: str
+    length: int
+    pending_task_ids: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+WorkforceEvent = Union[
+    LogEvent,
+    TaskDecomposedEvent,
+    TaskCreatedEvent,
+    TaskAssignedEvent,
+    TaskStartedEvent,
+    TaskCompletedEvent,
+    TaskFailedEvent,
+    WorkerCreatedEvent,
+    WorkerDeletedEvent,
+    AllTasksCompletedEvent,
+    QueueStatusEvent,
+]