autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/workflow/streaming/workflow_event_stream.py

@@ -0,0 +1,33 @@
+# file: autobyteus/autobyteus/workflow/streaming/workflow_event_stream.py
+import asyncio
+import queue
+from typing import AsyncIterator, TYPE_CHECKING
+
+from autobyteus.events.event_types import EventType
+from autobyteus.workflow.streaming.workflow_stream_events import WorkflowStreamEvent
+from autobyteus.agent.streaming.queue_streamer import stream_queue_items
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.agentic_workflow import AgenticWorkflow
+
+_SENTINEL = object()
+
+class WorkflowEventStream:
+    """Consumes events from a WorkflowExternalEventNotifier for a specific workflow."""
+    def __init__(self, workflow: 'AgenticWorkflow'):
+        self.workflow_id = workflow.workflow_id
+        self._internal_q = queue.Queue()
+        self._notifier = workflow._runtime.notifier
+        self._notifier.subscribe(EventType.WORKFLOW_STREAM_EVENT, self._handle_event)
+
+    def _handle_event(self, payload: WorkflowStreamEvent, **kwargs):
+        if isinstance(payload, WorkflowStreamEvent) and payload.workflow_id == self.workflow_id:
+            self._internal_q.put(payload)
+
+    async def close(self):
+        self._notifier.unsubscribe(EventType.WORKFLOW_STREAM_EVENT, self._handle_event)
+        await asyncio.get_running_loop().run_in_executor(None, self._internal_q.put, _SENTINEL)
+
+    def all_events(self) -> AsyncIterator[WorkflowStreamEvent]:
+        """The primary method to consume all structured events from the workflow."""
+        return stream_queue_items(self._internal_q, _SENTINEL, f"workflow_{self.workflow_id}_stream")

autobyteus/workflow/streaming/workflow_stream_event_payloads.py

@@ -0,0 +1,28 @@
+# file: autobyteus/autobyteus/workflow/streaming/workflow_stream_event_payloads.py
+from typing import Optional, Any
+from pydantic import BaseModel, Field
+from autobyteus.workflow.phases.workflow_operational_phase import WorkflowOperationalPhase
+from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent
+# Need to use a forward reference string to avoid circular import at runtime
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from autobyteus.workflow.streaming.workflow_stream_events import WorkflowStreamEvent
+
+# --- Payloads for events originating from the "WORKFLOW" source ---
+class BaseWorkflowSpecificPayload(BaseModel):
+    pass
+
+class WorkflowPhaseTransitionData(BaseWorkflowSpecificPayload):
+    new_phase: WorkflowOperationalPhase
+    old_phase: Optional[WorkflowOperationalPhase] = None
+    error_message: Optional[str] = None
+
+# --- Payload for events originating from the "AGENT" source ---
+class AgentEventRebroadcastPayload(BaseModel):
+    agent_name: str # The friendly name, e.g., "Researcher_1"
+    agent_event: AgentStreamEvent # The original, unmodified event from the agent
+
+# --- Payload for events originating from the "SUB_WORKFLOW" source ---
+class SubWorkflowEventRebroadcastPayload(BaseModel):
+    sub_workflow_node_name: str # The friendly name of the sub-workflow node
+    sub_workflow_event: "WorkflowStreamEvent" = Field(..., description="The original, unmodified event from the sub-workflow's stream")

autobyteus/workflow/streaming/workflow_stream_events.py

@@ -0,0 +1,45 @@
+# file: autobyteus/autobyteus/workflow/streaming/workflow_stream_events.py
+import datetime
+import uuid
+from typing import Literal, Union
+from pydantic import BaseModel, Field, model_validator
+
+from .workflow_stream_event_payloads import WorkflowPhaseTransitionData, AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload
+
+# A union of all possible payloads for a "WORKFLOW" sourced event.
+WorkflowSpecificPayload = Union[WorkflowPhaseTransitionData]
+
+# The top-level discriminated union for the main event stream's payload.
+WorkflowStreamDataPayload = Union[WorkflowSpecificPayload, AgentEventRebroadcastPayload, SubWorkflowEventRebroadcastPayload]
+
+class WorkflowStreamEvent(BaseModel):
+    event_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: datetime.datetime = Field(default_factory=datetime.datetime.utcnow)
+    workflow_id: str
+    event_source_type: Literal["WORKFLOW", "AGENT", "SUB_WORKFLOW"]
+    data: WorkflowStreamDataPayload
+
+    @model_validator(mode='after')
+    def check_data_matches_source_type(self) -> 'WorkflowStreamEvent':
+        is_agent_event = self.event_source_type == "AGENT"
+        is_agent_payload = isinstance(self.data, AgentEventRebroadcastPayload)
+
+        is_sub_workflow_event = self.event_source_type == "SUB_WORKFLOW"
+        is_sub_workflow_payload = isinstance(self.data, SubWorkflowEventRebroadcastPayload)
+
+        is_workflow_event = self.event_source_type == "WORKFLOW"
+        is_workflow_payload = isinstance(self.data, WorkflowPhaseTransitionData)
+
+        if is_agent_event and not is_agent_payload:
+            raise ValueError("event_source_type is 'AGENT' but data is not an AgentEventRebroadcastPayload")
+        
+        if is_sub_workflow_event and not is_sub_workflow_payload:
+            raise ValueError("event_source_type is 'SUB_WORKFLOW' but data is not a SubWorkflowEventRebroadcastPayload")
+        
+        if is_workflow_event and not is_workflow_payload:
+            raise ValueError("event_source_type is 'WORKFLOW' but data is not a valid workflow-specific payload")
+
+        return self
+
+# This is necessary for Pydantic v2 to correctly handle the recursive model
+SubWorkflowEventRebroadcastPayload.model_rebuild()

autobyteus/workflow/utils/__init__.py

@@ -0,0 +1,9 @@
+# file: autobyteus/autobyteus/workflow/utils/__init__.py
+"""
+Utility functions for interacting with workflows.
+"""
+from .wait_for_idle import wait_for_workflow_to_be_idle
+
+__all__ = [
+    "wait_for_workflow_to_be_idle",
+]

autobyteus/workflow/utils/wait_for_idle.py

@@ -0,0 +1,46 @@
+# file: autobyteus/autobyteus/workflow/utils/wait_for_idle.py
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.workflow.streaming.workflow_event_stream import WorkflowEventStream
+from autobyteus.workflow.phases.workflow_operational_phase import WorkflowOperationalPhase
+
+if TYPE_CHECKING:
+    from autobyteus.workflow.agentic_workflow import AgenticWorkflow
+
+logger = logging.getLogger(__name__)
+
+async def _wait_loop(streamer: WorkflowEventStream, workflow_id: str):
+    """Internal helper to listen for the IDLE or ERROR event."""
+    async for event in streamer.all_events():
+        if event.event_source_type == "WORKFLOW" and event.data.new_phase == WorkflowOperationalPhase.IDLE:
+            logger.info(f"Workflow '{workflow_id}' has become idle.")
+            return
+        if event.event_source_type == "WORKFLOW" and event.data.new_phase == WorkflowOperationalPhase.ERROR:
+             error_message = f"Workflow '{workflow_id}' entered an error state while waiting for idle: {event.data.error_message}"
+             logger.error(error_message)
+             raise RuntimeError(error_message)
+
+async def wait_for_workflow_to_be_idle(workflow: 'AgenticWorkflow', timeout: float = 60.0):
+    """
+    Waits for a workflow to complete its bootstrapping and enter the IDLE state.
+
+    Args:
+        workflow: The workflow instance to monitor.
+        timeout: The maximum time in seconds to wait.
+
+    Raises:
+        asyncio.TimeoutError: If the workflow does not become idle within the timeout period.
+        RuntimeError: If the workflow enters an error state.
+    """
+    if workflow.get_current_phase() == WorkflowOperationalPhase.IDLE:
+        return
+    
+    logger.info(f"Waiting for workflow '{workflow.workflow_id}' to become idle (timeout: {timeout}s)...")
+    
+    streamer = WorkflowEventStream(workflow)
+    try:
+        await asyncio.wait_for(_wait_loop(streamer, workflow.workflow_id), timeout=timeout)
+    finally:
+        await streamer.close()

autobyteus/workflow/workflow_builder.py

@@ -0,0 +1,151 @@
+# file: autobyteus/autobyteus/workflow/workflow_builder.py
+import logging
+from typing import List, Optional, Dict, Union
+
+from autobyteus.workflow.agentic_workflow import AgenticWorkflow
+from autobyteus.workflow.context.workflow_config import WorkflowConfig
+from autobyteus.workflow.context.workflow_node_config import WorkflowNodeConfig
+from autobyteus.agent.context.agent_config import AgentConfig
+from autobyteus.workflow.factory.workflow_factory import WorkflowFactory
+
+logger = logging.getLogger(__name__)
+
+# Define a type hint for the possible definition types for clarity
+NodeDefinition = Union[AgentConfig, WorkflowConfig]
+
+class WorkflowBuilder:
+    """
+    A fluent API for constructing and configuring an AgenticWorkflow.
+    
+    This builder simplifies creating a workflow by abstracting away the manual
+    creation of config objects and providing an intuitive way to define the
+    agent and sub-workflow graph.
+    """
+    def __init__(self, name: str, description: str, role: Optional[str] = None):
+        """
+        Initializes the WorkflowBuilder.
+
+        Args:
+            name: A unique name for the workflow.
+            description: A high-level description of the workflow's goal.
+            role: An optional role description for when this workflow is used
+                  as a sub-workflow within a parent.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Workflow name must be a non-empty string.")
+        if not description or not isinstance(description, str):
+            raise ValueError("Workflow description must be a non-empty string.")
+
+        self._name = name
+        self._description = description
+        self._role = role
+        self._nodes: Dict[NodeDefinition, List[NodeDefinition]] = {}
+        self._coordinator_config: Optional[AgentConfig] = None
+        logger.info(f"WorkflowBuilder initialized for workflow: '{self._name}'.")
+
+    def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'WorkflowBuilder':
+        """
+        Adds a regular agent node to the workflow.
+
+        Args:
+            agent_config: The configuration for the agent at this node.
+            dependencies: A list of AgentConfig or WorkflowConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(agent_config, dependencies)
+        return self
+
+    def add_workflow_node(self, workflow_config: WorkflowConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'WorkflowBuilder':
+        """
+        Adds a sub-workflow node to the workflow.
+
+        Args:
+            workflow_config: The configuration for the sub-workflow.
+            dependencies: A list of AgentConfig or WorkflowConfig objects for nodes 
+                          that this node depends on. These must have been added previously.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        self._add_node_internal(workflow_config, dependencies)
+        return self
+
+    def _add_node_internal(self, node_definition: NodeDefinition, dependencies: Optional[List[NodeDefinition]]):
+        """Internal helper to add a node of any type."""
+        if not isinstance(node_definition, (AgentConfig, WorkflowConfig)):
+            raise TypeError("node_definition must be an instance of AgentConfig or WorkflowConfig.")
+        
+        if node_definition in self._nodes or node_definition == self._coordinator_config:
+            raise ValueError(f"Node definition for '{node_definition.name}' has already been added to the workflow.")
+
+        if dependencies:
+            for dep_config in dependencies:
+                if dep_config not in self._nodes and dep_config != self._coordinator_config:
+                    raise ValueError(f"Dependency node '{dep_config.name}' must be added to the builder before being used as a dependency.")
+
+        self._nodes[node_definition] = dependencies or []
+        node_type = "Sub-workflow" if isinstance(node_definition, WorkflowConfig) else "Agent"
+        logger.debug(f"Added {node_type} node '{node_definition.name}' to builder with {len(dependencies or [])} dependencies.")
+
+    def set_coordinator(self, agent_config: AgentConfig) -> 'WorkflowBuilder':
+        """
+        Sets the coordinator agent for the workflow. A coordinator must be an agent.
+
+        Args:
+            agent_config: The configuration for the coordinator agent.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if self._coordinator_config is not None:
+            raise ValueError("A coordinator has already been set for this workflow.")
+            
+        if not isinstance(agent_config, AgentConfig):
+            raise TypeError("Coordinator must be an instance of AgentConfig.")
+
+        self._coordinator_config = agent_config
+        logger.debug(f"Set coordinator for workflow to '{agent_config.name}'.")
+        return self
+
+    def build(self) -> AgenticWorkflow:
+        """
+        Constructs and returns the final AgenticWorkflow instance using the
+        singleton WorkflowFactory.
+        """
+        logger.info("Building AgenticWorkflow from builder...")
+        if self._coordinator_config is None:
+            raise ValueError("Cannot build workflow: A coordinator must be set.")
+
+        node_map: Dict[NodeDefinition, WorkflowNodeConfig] = {}
+        all_definitions = list(self._nodes.keys()) + [self._coordinator_config]
+        
+        for definition in all_definitions:
+            node_map[definition] = WorkflowNodeConfig(node_definition=definition)
+        
+        all_nodes_with_deps = self._nodes.copy()
+        all_nodes_with_deps[self._coordinator_config] = [] # Coordinator has no explicit deps in this model
+        
+        for node_def, dep_defs in all_nodes_with_deps.items():
+            if node_def in node_map and dep_defs:
+                current_node = node_map[node_def]
+                dependency_nodes = [node_map[dep_def] for dep_def in dep_defs]
+                current_node.dependencies = tuple(dependency_nodes)
+
+        final_nodes = list(node_map.values())
+        coordinator_node_instance = node_map[self._coordinator_config]
+
+        workflow_config = WorkflowConfig(
+            name=self._name,
+            description=self._description,
+            role=self._role,
+            nodes=tuple(final_nodes),
+            coordinator_node=coordinator_node_instance
+        )
+        
+        logger.info(f"WorkflowConfig created successfully. Name: '{workflow_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")
+
+        factory = WorkflowFactory()
+        return factory.create_workflow(config=workflow_config)

{autobyteus-1.1.3.dist-info → autobyteus-1.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.3
+Version: 1.1.5
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -14,26 +14,28 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: anthropic==0.37.1
+Requires-Dist: autobyteus-llm-client==1.1.2
 Requires-Dist: beautifulsoup4>=4.12.2
-Requires-Dist: openai
-Requires-Dist: requests
-Requires-Dist: tiktoken==0.7.0
-Requires-Dist: google-api-python-client
-Requires-Dist: google-generativeai
-Requires-Dist: mistralai
 Requires-Dist: boto3
 Requires-Dist: botocore
-Requires-Dist: anthropic==0.37.1
+Requires-Dist: brui-core==1.0.9
+Requires-Dist: certifi==2025.4.26
+Requires-Dist: google-api-python-client
+Requires-Dist: google-generativeai
 Requires-Dist: Jinja2
-Requires-Dist: ollama
+Requires-Dist: mcp[cli]==1.9.1
 Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mistralai
 Requires-Dist: mistralai==1.5.2
-Requires-Dist: certifi==2025.4.26
 Requires-Dist: numpy==2.2.5
-Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.1.1
-Requires-Dist: brui-core==1.0.8
-Requires-Dist: mcp[cli]==1.9.1
+Requires-Dist: ollama
+Requires-Dist: openai
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: textual
+Requires-Dist: tiktoken==0.7.0
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: flake8; extra == "dev"