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

autobyteus/cli/agent_team_tui/widgets/task_board_panel.py

@@ -0,0 +1,82 @@
+import logging
+from typing import List, Optional, Dict, Union
+
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from textual.widgets import Static
+
+from autobyteus.task_management.task_plan import Task
+from autobyteus.task_management.base_task_board import TaskStatus
+from .shared import TASK_STATUS_ICONS, LOG_ICON
+
+logger = logging.getLogger(__name__)
+
+class TaskBoardPanel(Static):
+    """A widget to display the team's task board."""
+
+    def __init__(self, tasks: Optional[List[Task]], statuses: Dict[str, TaskStatus], team_name: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.tasks = tasks or []
+        self.statuses = statuses or {}
+        self.team_name = team_name
+
+    def compose(self) -> None:
+        if not self.tasks:
+            yield Static(Panel("No task plan has been published yet.", title="Task Board", border_style="yellow", title_align="left"))
+            return
+
+        table = Table(
+            expand=True,
+            show_header=True,
+            header_style="bold magenta",
+            show_lines=True
+        )
+        table.add_column("ID", justify="left", style="cyan", no_wrap=True, min_width=10)
+        table.add_column("Name", style="white", min_width=15)
+        table.add_column("Status", justify="left", style="white")
+        table.add_column("Assigned To", justify="center", style="green")
+        table.add_column("Deliverables", justify="left", style="cyan", min_width=30)
+        table.add_column("Depends On", justify="center", style="dim")
+
+        # Create a name-to-ID map to resolve dependency names
+        id_to_name_map = {task.task_id: task.task_name for task in self.tasks}
+        
+        # Sort tasks by name for consistent ordering
+        sorted_tasks = sorted(self.tasks, key=lambda t: t.task_name)
+
+        for task in sorted_tasks:
+            task_status = self.statuses.get(task.task_id, TaskStatus.NOT_STARTED)
+            status_icon = TASK_STATUS_ICONS.get(task_status, "❓")
+            status_text = f"{status_icon} {task_status.value.upper().replace('_', ' ')}"
+            
+            status_style = "default"
+            if task_status == TaskStatus.COMPLETED:
+                status_style = "strike dim green"
+            elif task_status == TaskStatus.FAILED:
+                status_style = "bold red"
+            
+            # Create a renderable for the deliverables column
+            deliverables_renderable: Union[str, Text] = "N/A"
+            if task.file_deliverables:
+                text = Text()
+                for i, d in enumerate(task.file_deliverables):
+                    if i > 0:
+                        text.append("\n") # Add a newline for spacing between deliverables
+                    text.append(f"{LOG_ICON} {d.file_path}\n", style="bold")
+                    text.append(f"   └─ {d.summary}", style="dim")
+                deliverables_renderable = text
+
+            # Resolve dependency IDs to names for display
+            dep_names = [id_to_name_map.get(dep_id, dep_id) for dep_id in task.dependencies]
+
+            table.add_row(
+                task.task_id,
+                task.task_name,
+                Text(status_text, style=status_style),
+                task.assignee_name or "N/A",
+                deliverables_renderable,
+                ", ".join(dep_names)
+            )
+
+        yield Static(Panel(table, title="Task Board", border_style="blue", title_align="left"))

autobyteus/events/event_types.py

@@ -34,6 +34,7 @@ class EventType(Enum):
     AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE = "agent_data_assistant_complete_response"
     AGENT_DATA_TOOL_LOG = "agent_data_tool_log" 
     AGENT_DATA_TOOL_LOG_STREAM_END = "agent_data_tool_log_stream_end" 
+    AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED = "agent_data_system_task_notification_received" # NEW
     
     # --- Agent Requests for External Interaction ---
     AGENT_REQUEST_TOOL_INVOCATION_APPROVAL = "agent_request_tool_invocation_approval" 
@@ -42,8 +43,12 @@ class EventType(Enum):
     # --- Agent Errors (not necessarily phase changes, e.g., error during output generation) ---
     AGENT_ERROR_OUTPUT_GENERATION = "agent_error_output_generation"
 
-    # --- Workflow Events ---
-    WORKFLOW_STREAM_EVENT = "workflow_stream_event" # For unified workflow event stream
+    # --- Agent Team Events ---
+    TEAM_STREAM_EVENT = "team_stream_event" # For unified agent team event stream
+
+    # --- Task Board Events ---
+    TASK_BOARD_PLAN_PUBLISHED = "task_board_plan_published"
+    TASK_BOARD_STATUS_UPDATED = "task_board_status_updated"
 
     def __str__(self): 
         return self.value

autobyteus/llm/api/autobyteus_llm.py

@@ -11,18 +11,17 @@ import uuid
 logger = logging.getLogger(__name__)
 
 class AutobyteusLLM(BaseLLM):
-    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        # Provide defaults if not specified
-        if model is None:
-            # This should be set by the factory/caller, but providing a fallback
-            raise ValueError("AutobyteusLLM requires a model to be specified")
-        if llm_config is None:
-            llm_config = LLMConfig()
-            
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        # The host URL is now passed via the model object.
+        if not model.host_url:
+            raise ValueError("AutobyteusLLM requires a host_url to be set in its LLMModel object.")
+
         super().__init__(model=model, llm_config=llm_config)
-        self.client = AutobyteusClient()
+        
+        # Instantiate the client with the specific host for this model.
+        self.client = AutobyteusClient(server_url=self.model.host_url)
         self.conversation_id = str(uuid.uuid4())
-        logger.info(f"AutobyteusLLM initialized with model: {self.model} and conversation ID: {self.conversation_id}")
+        logger.info(f"AutobyteusLLM initialized for model '{self.model.model_identifier}' with conversation ID: {self.conversation_id}")
 
     async def _send_user_message_to_llm(
         self,
@@ -34,7 +33,7 @@ class AutobyteusLLM(BaseLLM):
         try:
             response = await self.client.send_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name,
+                model_name=self.model.name, # Use `name` as it's the original model name for the API
                 user_message=user_message,
                 image_urls=image_urls
             )
@@ -70,7 +69,7 @@ class AutobyteusLLM(BaseLLM):
         try:
             async for chunk in self.client.stream_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name,
+                model_name=self.model.name, # Use `name` for the API call
                 user_message=user_message,
                 image_urls=image_urls
             ):

autobyteus/llm/api/lmstudio_llm.py

@@ -9,29 +9,26 @@ logger = logging.getLogger(__name__)
 class LMStudioLLM(OpenAICompatibleLLM):
     """
     LLM class for models served by a local LM Studio instance.
-
-    This class communicates with an LM Studio server, which exposes an OpenAI-compatible API.
-    It expects the LM Studio server to be running at the address specified by the `LMSTUDIO_HOST`
-    environment variable, or at `http://localhost:1234` by default.
-
-    Note: The LM Studio server does not require a real API key. A dummy key "lm-studio" is used
-    by default. If you need to use a different key, you can set the `LMSTUDIO_API_KEY`
-    environment variable.
+    This class is now decoupled from environment variables and receives its connection
+    details from the LLMModel object.
     """
-    DEFAULT_LMSTUDIO_HOST = 'http://localhost:1234'
     
     def __init__(self, model: LLMModel, llm_config: LLMConfig):
-        lmstudio_host = os.getenv('LMSTUDIO_HOST', self.DEFAULT_LMSTUDIO_HOST)
-        base_url = f"{lmstudio_host}/v1"
+        if not model.host_url:
+            raise ValueError("LMStudioLLM requires a host_url to be set in its LLMModel object.")
+
+        base_url = f"{model.host_url}/v1"
 
+        # The API key is often not needed for LM Studio, but we allow it to be set via env var.
+        # It defaults to a dummy value if not set.
         super().__init__(
             model=model,
             llm_config=llm_config,
             api_key_env_var="LMSTUDIO_API_KEY",
             base_url=base_url,
-            api_key_default="lm-studio"
+            api_key_default="lm-studio" # Dummy key for LM Studio
         )
-        logger.info(f"LMStudioLLM initialized with model: {self.model.name} and base URL: {base_url}")
+        logger.info(f"LMStudioLLM initialized for model '{model.model_identifier}' with base URL: {base_url}")
 
     async def cleanup(self):
         await super().cleanup()

autobyteus/llm/api/ollama_llm.py

@@ -14,22 +14,17 @@ import os
 logger = logging.getLogger(__name__)
 
 class OllamaLLM(BaseLLM):
-    DEFAULT_OLLAMA_HOST = 'http://localhost:11434'
-
-    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        self.ollama_host = os.getenv('DEFAULT_OLLAMA_HOST', self.DEFAULT_OLLAMA_HOST)
-        logger.info(f"Initializing Ollama with host: {self.ollama_host}")
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        # The host URL is now passed via the model object, decoupling from environment variables here.
+        if not model.host_url:
+            raise ValueError("OllamaLLM requires a host_url to be set in its LLMModel object.")
+            
+        logger.info(f"Initializing OllamaLLM for model '{model.name}' with host: {model.host_url}")
         
-        self.client = AsyncClient(host=self.ollama_host)
+        self.client = AsyncClient(host=model.host_url)
         
-        # Provide defaults if not specified
-        if model is None:
-            model = LLMModel.OLLAMA_LLAMA_3_2
-        if llm_config is None:
-            llm_config = LLMConfig()
-            
         super().__init__(model=model, llm_config=llm_config)
-        logger.info(f"OllamaLLM initialized with model: {self.model}")
+        logger.info(f"OllamaLLM initialized with model: {self.model.model_identifier}")
 
     async def _send_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> CompleteResponse:
         self.add_user_message(user_message)

autobyteus/llm/autobyteus_provider.py

@@ -1,8 +1,9 @@
 from autobyteus.llm.api.autobyteus_llm import AutobyteusLLM
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
-from typing import Dict, Any, TYPE_CHECKING
+from typing import Dict, Any, TYPE_CHECKING, List, Optional
 import os
 import logging
 from urllib.parse import urlparse
@@ -15,63 +16,89 @@ logger = logging.getLogger(__name__)
 
 class AutobyteusModelProvider:
     DEFAULT_SERVER_URL = 'https://localhost:8000'
-    CONNECTION_TIMEOUT = 5.0
+
+    @staticmethod
+    def _get_hosts() -> List[str]:
+        """Gets Autobyteus LLM server hosts from env vars, supporting a comma-separated list."""
+        hosts_str = os.getenv('AUTOBYTEUS_LLM_SERVER_HOSTS')
+        if hosts_str:
+            return [host.strip() for host in hosts_str.split(',')]
+        
+        legacy_host = os.getenv('AUTOBYTEUS_LLM_SERVER_URL')
+        if legacy_host:
+            return [legacy_host]
+            
+        return [AutobyteusModelProvider.DEFAULT_SERVER_URL]
 
     @staticmethod
     def discover_and_register():
-        """Discover and register Autobyteus models synchronously"""
+        """Discover and register Autobyteus models from all configured hosts."""
         try:
-            from autobyteus.llm.llm_factory import LLMFactory  # Local import to avoid circular dependency
-
-            client = None
-            try:
-                client = AutobyteusClient()
-                response = client.get_available_models_sync()
-            except Exception as e:
-                logger.error(f"Client initialization failed: {str(e)}")
-                return
-            finally:
-                if client:
-                    client.sync_client.close()
+            from autobyteus.llm.llm_factory import LLMFactory
 
-            if not AutobyteusModelProvider._validate_server_response(response):
-                return
+            hosts = AutobyteusModelProvider._get_hosts()
+            total_registered_count = 0
 
-            models = response.get('models', [])
-            registered_count = 0
-            
-            for model_info in models:
+            for host_url in hosts:
+                if not AutobyteusModelProvider.is_valid_url(host_url):
+                    logger.error(f"Invalid Autobyteus host URL: {host_url}, skipping.")
+                    continue
+                
+                logger.info(f"Discovering Autobyteus models from host: {host_url}")
+                client = None
                 try:
-                    validation_result = AutobyteusModelProvider._validate_model_info(model_info)
-                    if not validation_result["valid"]:
-                        logger.warning(validation_result["message"])
-                        continue
-                        
-                    llm_config = AutobyteusModelProvider._parse_llm_config(model_info["config"])
-                    if not llm_config:
-                        continue
-                        
-                    llm_model = LLMModel(
-                        name=model_info["name"],
-                        value=model_info["value"],
-                        provider=LLMProvider(model_info["provider"]),  # Convert string to enum
-                        llm_class=AutobyteusLLM,
-                        canonical_name=model_info["canonical_name"],  # Add canonical_name
-                        default_config=llm_config
-                    )
-                    
-                    LLMFactory.register_model(llm_model)
-                    registered_count += 1
-                    logger.debug(f"Registered model: {model_info['name']} with canonical name: {model_info['canonical_name']}")
-                    
+                    # Instantiate client for this specific host
+                    client = AutobyteusClient(server_url=host_url)
+                    response = client.get_available_models_sync()
                 except Exception as e:
-                    logger.error(f"Model registration failed: {str(e)}")
+                    logger.warning(f"Could not connect or fetch models from Autobyteus server at {host_url}: {e}")
+                    continue
+                finally:
+                    if client:
+                        client.sync_client.close()
+
+                if not AutobyteusModelProvider._validate_server_response(response):
                     continue
+
+                models = response.get('models', [])
+                host_registered_count = 0
+                for model_info in models:
+                    try:
+                        validation_result = AutobyteusModelProvider._validate_model_info(model_info)
+                        if not validation_result["valid"]:
+                            logger.warning(validation_result["message"])
+                            continue
+                        
+                        llm_config = AutobyteusModelProvider._parse_llm_config(model_info["config"])
+                        if not llm_config:
+                            continue
                         
-            logger.info(f"Registered {registered_count} Autobyteus models")
+                        llm_model = LLMModel(
+                            name=model_info["name"],
+                            value=model_info["value"],
+                            provider=LLMProvider(model_info["provider"]),
+                            llm_class=AutobyteusLLM,
+                            canonical_name=model_info["canonical_name"],
+                            runtime=LLMRuntime.AUTOBYTEUS,
+                            host_url=host_url,
+                            default_config=llm_config
+                        )
+                        
+                        LLMFactory.register_model(llm_model)
+                        host_registered_count += 1
+                        
+                    except Exception as e:
+                        logger.error(f"Failed to register Autobyteus model '{model_info.get('name')}' from {host_url}: {e}")
+                
+                if host_registered_count > 0:
+                    logger.info(f"Registered {host_registered_count} models from Autobyteus host {host_url}")
+                total_registered_count += host_registered_count
+            
+            if total_registered_count > 0:
+                 logger.info(f"Finished Autobyteus discovery. Total models registered: {total_registered_count}")
 
         except Exception as e:
-            logger.error(f"Discovery failed: {str(e)}", exc_info=True)
+            logger.error(f"An unexpected error occurred during Autobyteus model discovery: {e}", exc_info=True)
 
     @staticmethod
     def _validate_server_response(response: Dict[str, Any]) -> bool: