autobyteus 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

autobyteus/agent_team/task_notification/task_activator.py

@@ -0,0 +1,66 @@
+# file: autobyteus/autobyteus/agent_team/task_notification/task_activator.py
+"""
+Defines the component responsible for the action of activating an agent.
+"""
+import logging
+from typing import TYPE_CHECKING
+
+from autobyteus.agent.message import AgentInputUserMessage
+from autobyteus.agent_team.events import ProcessUserMessageEvent
+from autobyteus.agent.sender_type import SenderType, TASK_NOTIFIER_SENDER_ID
+
+if TYPE_CHECKING:
+    from autobyteus.agent_team.context.team_manager import TeamManager
+
+logger = logging.getLogger(__name__)
+
+class TaskActivator:
+    """
+    A component with the single responsibility of activating an agent.
+
+    Activation involves ensuring the agent is running and sending it a
+    standardized "start work" message.
+    """
+    def __init__(self, team_manager: 'TeamManager'):
+        """
+        Initializes the TaskActivator.
+
+        Args:
+            team_manager: The team's manager, used to start agents and dispatch messages.
+        """
+        if not team_manager:
+            raise ValueError("TaskActivator requires a valid TeamManager instance.")
+        self._team_manager = team_manager
+        logger.debug(f"TaskActivator initialized for team '{self._team_manager.team_id}'.")
+
+    async def activate_agent(self, agent_name: str):
+        """
+        Activates a specific agent by ensuring it is ready and sending it a
+        generic "start work" notification.
+
+        Args:
+            agent_name: The unique name of the agent to activate.
+        """
+        team_id = self._team_manager.team_id
+        try:
+            logger.info(f"Team '{team_id}': TaskActivator is activating agent '{agent_name}'.")
+            
+            # This ensures the agent is started and ready to receive the message.
+            await self._team_manager.ensure_node_is_ready(agent_name)
+
+            notification_message = AgentInputUserMessage(
+                content="You have new tasks in your queue. Please review your task list using your tools and begin your work.",
+                sender_type=SenderType.SYSTEM,
+                metadata={'sender_id': TASK_NOTIFIER_SENDER_ID}
+            )
+            event = ProcessUserMessageEvent(
+                user_message=notification_message,
+                target_agent_name=agent_name
+            )
+            await self._team_manager.dispatch_user_message_to_agent(event)
+            
+            logger.info(f"Team '{team_id}': Successfully sent activation notification to '{agent_name}'.")
+
+        except Exception as e:
+            # FIXED: Removed "TaskActivator" from the log message to align with the unit test assertion.
+            logger.error(f"Team '{team_id}': Failed to activate agent '{agent_name}': {e}", exc_info=True)

autobyteus/cli/agent_team_tui/state.py

@@ -16,8 +16,8 @@ from autobyteus.agent.streaming.stream_event_payloads import (
 )
 from autobyteus.agent_team.streaming.agent_team_stream_events import AgentTeamStreamEvent
 from autobyteus.agent_team.streaming.agent_team_stream_event_payloads import AgentEventRebroadcastPayload, SubTeamEventRebroadcastPayload, AgentTeamPhaseTransitionData
-from autobyteus.task_management.task_plan import Task
-from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.task import Task
+from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
 from autobyteus.task_management.base_task_board import TaskStatus
 
 logger = logging.getLogger(__name__)
@@ -86,29 +86,26 @@ class TUIStateStore:
         self._team_event_history[parent_name].append(event)
         
         if event.event_source_type == "TASK_BOARD":
-            # The 'parent_name' argument holds the friendly name of the team (or sub-team)
-            # that is the context for this event. This is the key we use for UI state.
             team_name_key = parent_name
-            if isinstance(event.data, TaskPlanPublishedEvent):
-                self._task_plans[team_name_key] = event.data.plan.tasks
-                # Reset statuses when a new plan is published
-                self._task_statuses[team_name_key] = {task.task_id: TaskStatus.NOT_STARTED for task in event.data.plan.tasks}
-                logger.debug(f"TUI State: Updated task plan for '{team_name_key}' with {len(event.data.plan.tasks)} tasks.")
+            if isinstance(event.data, TasksAddedEvent):
+                if team_name_key not in self._task_plans: self._task_plans[team_name_key] = []
+                if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
+                self._task_plans[team_name_key].extend(event.data.tasks)
+                for task in event.data.tasks:
+                    self._task_statuses[team_name_key][task.task_id] = TaskStatus.NOT_STARTED
+                logger.debug(f"TUI State: Added {len(event.data.tasks)} tasks to board for '{team_name_key}'.")
+
             elif isinstance(event.data, TaskStatusUpdatedEvent):
-                # Update status
-                if team_name_key not in self._task_statuses:
-                    self._task_statuses[team_name_key] = {}
+                if team_name_key not in self._task_statuses: self._task_statuses[team_name_key] = {}
                 self._task_statuses[team_name_key][event.data.task_id] = event.data.new_status
                 logger.debug(f"TUI State: Updated status for task '{event.data.task_id}' in team '{team_name_key}' to {event.data.new_status}.")
                 
-                # Update deliverables if they are provided in the event.
-                if event.data.deliverables is not None:
-                    if team_name_key in self._task_plans:
-                        for task in self._task_plans[team_name_key]:
-                            if task.task_id == event.data.task_id:
-                                task.file_deliverables = event.data.deliverables
-                                logger.debug(f"TUI State: Synced deliverables for task '{event.data.task_id}' in team '{team_name_key}'.")
-                                break
+                if event.data.deliverables is not None and team_name_key in self._task_plans:
+                    for task in self._task_plans[team_name_key]:
+                        if task.task_id == event.data.task_id:
+                            task.file_deliverables = event.data.deliverables
+                            logger.debug(f"TUI State: Synced deliverables for task '{event.data.task_id}' in team '{team_name_key}'.")
+                            break
             return
 
         if isinstance(event.data, AgentEventRebroadcastPayload):

autobyteus/cli/agent_team_tui/widgets/focus_pane.py

@@ -15,7 +15,7 @@ from textual.containers import VerticalScroll, Horizontal
 from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent_team.phases import AgentTeamOperationalPhase
 from autobyteus.task_management.base_task_board import TaskStatus
-from autobyteus.task_management.task_plan import Task
+from autobyteus.task_management.task import Task
 from autobyteus.agent.streaming.stream_events import StreamEvent as AgentStreamEvent, StreamEventType as AgentStreamEventType
 from autobyteus.agent.streaming.stream_event_payloads import (
     AgentOperationalPhaseTransitionData, AssistantChunkData, AssistantCompleteResponseData,

autobyteus/cli/agent_team_tui/widgets/task_board_panel.py

@@ -6,7 +6,7 @@ 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.task import Task
 from autobyteus.task_management.base_task_board import TaskStatus
 from .shared import TASK_STATUS_ICONS, LOG_ICON
 

autobyteus/clients/__init__.py

@@ -0,0 +1,10 @@
+"""
+Client utilities for communicating with the Autobyteus LLM server.
+
+Consolidates the previously standalone autobyteus-llm-client package so the
+HTTP client can evolve alongside the rest of the framework.
+"""
+
+from .autobyteus_client import AutobyteusClient, CertificateError
+
+__all__ = ["AutobyteusClient", "CertificateError"]

autobyteus/clients/autobyteus_client.py

@@ -0,0 +1,318 @@
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+from urllib.parse import urljoin
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class CertificateError(Exception):
+    """Custom exception for certificate-related errors."""
+
+
+class AutobyteusClient:
+    """Async + sync HTTP client for talking to an Autobyteus LLM server."""
+
+    DEFAULT_SERVER_URL = "https://api.autobyteus.com"
+    API_KEY_HEADER = "AUTOBYTEUS_API_KEY"
+    API_KEY_ENV_VAR = "AUTOBYTEUS_API_KEY"
+    SSL_CERT_FILE_ENV_VAR = "AUTOBYTEUS_SSL_CERT_FILE"
+
+    def __init__(self, server_url: Optional[str] = None):
+        """
+        Initialize the client.
+
+        Args:
+            server_url: Explicit server URL. Takes precedence over env vars.
+        """
+        self.server_url = server_url or os.getenv(
+            "AUTOBYTEUS_LLM_SERVER_URL", self.DEFAULT_SERVER_URL
+        )
+        self.api_key = os.getenv(self.API_KEY_ENV_VAR)
+
+        if not self.api_key:
+            raise ValueError(
+                f"{self.API_KEY_ENV_VAR} environment variable is required. "
+                "Please set it before initializing the client."
+            )
+
+        custom_cert_path_str = os.getenv(self.SSL_CERT_FILE_ENV_VAR)
+        verify_param: Union[str, bool, Path]
+
+        if custom_cert_path_str:
+            custom_cert_path = Path(custom_cert_path_str)
+            if not custom_cert_path.exists():
+                raise CertificateError(
+                    f"Custom SSL certificate file specified via {self.SSL_CERT_FILE_ENV_VAR} "
+                    f"not found at: {custom_cert_path}"
+                )
+            if not custom_cert_path.is_file():
+                raise CertificateError(
+                    f"Custom SSL certificate path specified via {self.SSL_CERT_FILE_ENV_VAR} "
+                    f"is not a file: {custom_cert_path}"
+                )
+            verify_param = str(custom_cert_path)
+            logger.info(
+                "Using custom SSL certificate file for TLS verification: %s. "
+                "This is the recommended secure method for servers with self-signed or "
+                "private CA certificates.",
+                verify_param,
+            )
+        else:
+            verify_param = False
+            logger.warning(
+                "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
+                "SECURITY WARNING: SSL certificate verification is DISABLED because the \n"
+                f"'{self.SSL_CERT_FILE_ENV_VAR}' environment variable is not set.\n"
+                "This configuration is INSECURE and makes the client vulnerable to \n"
+                "Man-in-the-Middle (MitM) attacks. It should ONLY be used for development \n"
+                "or testing in trusted environments with self-signed certificates if \n"
+                "providing the certificate path is not possible.\n"
+                "FOR PRODUCTION or secure environments with self-signed certificates, \n"
+                f"it is STRONGLY RECOMMENDED to set the '{self.SSL_CERT_FILE_ENV_VAR}' \n"
+                "environment variable to the path of the server's certificate (.pem file) \n"
+                "to enable proper TLS verification.\n"
+                "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+            )
+
+        timeout_config = httpx.Timeout(connect=10.0, read=None, write=None, pool=None)
+
+        try:
+            self.async_client = httpx.AsyncClient(
+                verify=verify_param,
+                headers={self.API_KEY_HEADER: self.api_key},
+                timeout=timeout_config,
+            )
+            self.sync_client = httpx.Client(
+                verify=verify_param,
+                headers={self.API_KEY_HEADER: self.api_key},
+                timeout=timeout_config,
+            )
+        except Exception as exc:
+            logger.error(
+                "Failed to initialize httpx client with SSL configuration (verify='%s'): %s",
+                verify_param,
+                exc,
+            )
+            raise RuntimeError(f"HTTP client initialization failed: {exc}") from exc
+
+        logger.info("Initialized Autobyteus client with server URL: %s", self.server_url)
+
+    async def get_available_llm_models(self) -> Dict[str, Any]:
+        """Async discovery of available LLM models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/llm")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async LLM model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_llm_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available LLM models."""
+        try:
+            response = self.sync_client.get(urljoin(self.server_url, "/models/llm"))
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync LLM model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def get_available_image_models(self) -> Dict[str, Any]:
+        """Async discovery of available image models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/image")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async image model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_image_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available image models."""
+        try:
+            response = self.sync_client.get(
+                urljoin(self.server_url, "/models/image")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync image model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def get_available_audio_models(self) -> Dict[str, Any]:
+        """Async discovery of available audio models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/audio")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async audio model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_audio_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available audio models."""
+        try:
+            response = self.sync_client.get(
+                urljoin(self.server_url, "/models/audio")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync audio model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def send_message(
+        self,
+        conversation_id: str,
+        model_name: str,
+        user_message: str,
+        image_urls: Optional[List[str]] = None,
+        audio_urls: Optional[List[str]] = None,
+        video_urls: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Send a message and get a response."""
+        try:
+            data = {
+                "conversation_id": conversation_id,
+                "model_name": model_name,
+                "user_message": user_message,
+                "image_urls": image_urls or [],
+                "audio_urls": audio_urls or [],
+                "video_urls": video_urls or [],
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/send-message"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error sending message: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def stream_message(
+        self,
+        conversation_id: str,
+        model_name: str,
+        user_message: str,
+        image_urls: Optional[List[str]] = None,
+        audio_urls: Optional[List[str]] = None,
+        video_urls: Optional[List[str]] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """Stream a message and get responses."""
+        try:
+            data = {
+                "conversation_id": conversation_id,
+                "model_name": model_name,
+                "user_message": user_message,
+                "image_urls": image_urls or [],
+                "audio_urls": audio_urls or [],
+                "video_urls": video_urls or [],
+            }
+
+            async with self.async_client.stream(
+                "POST",
+                urljoin(self.server_url, "/stream-message"),
+                json=data,
+            ) as response:
+                response.raise_for_status()
+
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        try:
+                            chunk = json.loads(line[6:])
+                            if "error" in chunk:
+                                raise RuntimeError(chunk["error"])
+                            yield chunk
+                        except json.JSONDecodeError as exc:
+                            logger.error("Failed to parse stream chunk: %s", exc)
+                            raise RuntimeError("Invalid stream response format") from exc
+
+        except httpx.HTTPError as exc:
+            logger.error("Stream error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def generate_image(
+        self,
+        model_name: str,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Generate or edit an image and return the server response."""
+        try:
+            data = {
+                "model_name": model_name,
+                "prompt": prompt,
+                "input_image_urls": input_image_urls or [],
+                "mask_url": mask_url,
+                "generation_config": generation_config or {},
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/generate-image"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error generating image: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def generate_speech(
+        self,
+        model_name: str,
+        prompt: str,
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Generate speech from text and return the server response."""
+        try:
+            data = {
+                "model_name": model_name,
+                "prompt": prompt,
+                "generation_config": generation_config or {},
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/generate-speech"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error generating speech: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def cleanup(self, conversation_id: str) -> Dict[str, Any]:
+        """Clean up a conversation."""
+        try:
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/cleanup"),
+                json={"conversation_id": conversation_id},
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Cleanup error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def close(self) -> None:
+        """Close both HTTP clients."""
+        await self.async_client.aclose()
+        self.sync_client.close()
+
+    async def __aenter__(self) -> "AutobyteusClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # type: ignore[override]
+        await self.close()

autobyteus/clients/cert_utils.py

@@ -0,0 +1,105 @@
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+from cryptography import x509
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+
+logger = logging.getLogger(__name__)
+
+
+class CertificateError(Exception):
+    """Custom exception for certificate-related errors."""
+
+
+def get_certificate_info(cert_path: Union[str, Path]) -> Dict[str, object]:
+    """
+    Retrieve certificate information including fingerprint and validity window.
+    """
+    try:
+        cert_path = Path(cert_path)
+        cert_data = cert_path.read_bytes()
+        cert = x509.load_pem_x509_certificate(cert_data, default_backend())
+
+        cert_der = cert.fingerprint(hashes.SHA256())
+        fingerprint = ":".join(f"{byte:02X}" for byte in cert_der)
+
+        now = datetime.utcnow()
+        days_until_expiry = (cert.not_valid_after - now).days
+
+        return {
+            "subject": cert.subject.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[
+                0
+            ].value,
+            "issuer": cert.issuer.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[
+                0
+            ].value,
+            "valid_from": cert.not_valid_before,
+            "valid_until": cert.not_valid_after,
+            "fingerprint": fingerprint,
+            "is_valid": cert.not_valid_before < now < cert.not_valid_after,
+            "days_until_expiry": days_until_expiry,
+            "cert_data": cert_data,
+            "cert": cert,
+        }
+    except Exception as exc:  # pragma: no cover - defensive logging
+        raise CertificateError(f"Failed to get certificate info: {exc}") from exc
+
+
+def verify_certificate(
+    cert_path: Union[str, Path],
+    expected_fingerprint: Optional[str] = None,
+    warn_expiry_days: int = 30,
+) -> Dict[str, object]:
+    """
+    Verify the certificate's validity and optional fingerprint match.
+    """
+    try:
+        info = get_certificate_info(cert_path)
+
+        if not info["is_valid"]:
+            if datetime.utcnow() < info["valid_from"]:
+                raise CertificateError("Certificate is not yet valid")
+            raise CertificateError(
+                f"Certificate has expired on {info['valid_until'].strftime('%Y-%m-%d')}"
+            )
+
+        if expected_fingerprint:
+            expected = expected_fingerprint.replace(" ", "").upper()
+            actual = str(info["fingerprint"]).replace(" ", "")
+            if actual != expected:
+                raise CertificateError(
+                    "Certificate fingerprint mismatch. "
+                    f"Expected: {expected}\nGot: {actual}"
+                )
+            logger.info("Certificate fingerprint verified successfully")
+        else:
+            logger.warning(
+                "Certificate fingerprint verification skipped. "
+                "Set AUTOBYTEUS_CERT_FINGERPRINT to enable this security feature. "
+                "Current certificate fingerprint: %s",
+                info["fingerprint"],
+            )
+
+        logger.info(
+            "Certificate valid from %s to %s",
+            info["valid_from"],
+            info["valid_until"],
+        )
+        logger.info("Certificate fingerprint (SHA256): %s", info["fingerprint"])
+        logger.info("Certificate subject: %s", info["subject"])
+
+        if info["days_until_expiry"] <= warn_expiry_days:
+            logger.warning(
+                "Certificate will expire in %s days on %s",
+                info["days_until_expiry"],
+                info["valid_until"].strftime("%Y-%m-%d"),
+            )
+
+        return info
+    except CertificateError:
+        raise
+    except Exception as exc:  # pragma: no cover - defensive logging
+        raise CertificateError(f"Certificate verification failed: {exc}") from exc

autobyteus/clients/certificates/cert.pem

@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----
+MIIF4TCCA8mgAwIBAgIUeyxZ82RF2o2HFOrxZXBmqo5DBUwwDQYJKoZIhvcNAQEL
+BQAwdTELMAkGA1UEBhMCVVMxDjAMBgNVBAgMBVN0YXRlMQ0wCwYDVQQHDARDaXR5
+MRMwEQYDVQQKDApBdXRvYnl0ZXVzMRUwEwYDVQQLDAxBUEkgU2VydmljZXMxGzAZ
+BgNVBAMMEmFwaS5hdXRvYnl0ZXVzLmNvbTAeFw0yNTAxMjUxNjUyMjhaFw0yNjAx
+MjUxNjUyMjhaMHUxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVTdGF0ZTENMAsGA1UE
+BwwEQ2l0eTETMBEGA1UECgwKQXV0b2J5dGV1czEVMBMGA1UECwwMQVBJIFNlcnZp
+Y2VzMRswGQYDVQQDDBJhcGkuYXV0b2J5dGV1cy5jb20wggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQDXIlOVOkioEVpq7q+TY7/CUsraIYMy+liXM0ef+oJh
+qV7hBRJPgW79ZJIsBNWlGKSB3DRe5mSET/CmeOeGxpH6LJZxMbXfJOHNHtnZnpNV
+6k/EhrjRMSavMwNvMo4d8NkmH+K/aBJ5sNprkxF9sh3drxod+Cw2Z1tKIdMOuNmx
+clVnQy2CEiVyBKLxqLP4e6D3boIXbu2k8HcZWtNNzhDuJxAj0qyGpZawb4Ey6U2t
+CBHjX/7sw9/YW7F13cXM2jSeRLkefO/LIcZ0iFM4psEr9pO7dbctrbNZlXyeBEDB
++jTZ6IefHPH31ZwGGPJTL+3mWWP4SDySvcJlr/YYpQ/siP07WAUA5bKEDC2SJCX8
+1xcc7TphD1jsdtgH80q+gG9gE5lGVShVTvJXhRigBNVqCslcRAqoUuMXqo5BNBBB
+DYljsaWsxUeA8Y5rhRKL9OapqHTcX7FrgUC4j42zwb5jMhmK2unYW+khyuewFcyS
+Dfne32Tp2SoE4drFIDcCQkxcOLREm5Lr1HnJwsaLHgNaHXriWThwOoqxRdF9M++A
+a3njvOEDuOaE4c6yg7nvAXMyOgoIbiwqAGWpxmVV3EI2VQX9Jvmnah7Uw7RVdNlx
+JQpVBdPjUq2prwB+lCfCFPPOwRDP5vnNuGtvbNxhxNEGDcsqnbsVJYm+75+gP/bx
+xQIDAQABo2kwZzAuBgNVHREEJzAlghJhcGkuYXV0b2J5dGV1cy5jb22CCWxvY2Fs
+aG9zdIcEfwAAATAJBgNVHRMEAjAAMAsGA1UdDwQEAwIF4DAdBgNVHQ4EFgQUcD2a
+4/EZkZpiRjr4U9WXl04i3GQwDQYJKoZIhvcNAQELBQADggIBAD8LzFt358VVK0w9
+g8MebSpJdNQwkfkg7AllFLCzAQ/5dQ/Zti5sjJ5xSQSeu4heZGThX5rt3XWYUr1H
+6eT5UcuqpEkkRERzdM5PzmWjPk0bdPO8I0phtOaWUWPhR/tLqWeF4vEJrDJxPONr
+AL54wX4tnTAdDi7F4A9z5LtAiEmwWvufhde0etqOhSGYjjk/T/YjlaSSX3WmesLD
+zUHajumZkZ7xbTIoD7iehaixE93Gc2L6J5/obFemjG0P37bfGprM7HY2h6i07333
+5YwUSuq51sVUmj7lDPsx/bdzhzask2zOS40598QmAfSFGuxmxZ23omDxJg3859R3
+KoMVNR/DMHTNHJGOHjDWANChE+4C8dAXgwwnGpAg1VWTZPQ1LK4n6+SAenbtAUMw
+gXeYiLnVPEFCY6olImmKYvTR8pH8BPrkZgPW4di/aOaTj21oTYShS13xkc8LHoeW
+sBQ8/afZOAPp7XrhYqxS6fgS+nWVq2QBdt7G9poQ/Z5agH5F3TXeAmJLUBqxpUX/
+xx+a0h3yWdE+/eW343A41lO+1kOkBu9Ehqk0i0Y1Ut8EsD2tdTfl7Ywa4k8sq9xr
+f1tm2ebBmHY+ZQvCTARScT/IVOvHpDs0ln1ailIt+P5Qs7V3Hgpftr4Y+fh1gmh7
+m0StS7OaDEX18yPCiIz9DxVKlsPN
+-----END CERTIFICATE-----

autobyteus/events/event_types.py

@@ -47,8 +47,8 @@ class EventType(Enum):
     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"
+    TASK_BOARD_TASKS_ADDED = "task_board.tasks.added"
+    TASK_BOARD_STATUS_UPDATED = "task_board.status.updated"
 
     def __str__(self): 
         return self.value

autobyteus/llm/api/autobyteus_llm.py

@@ -5,7 +5,7 @@ from autobyteus.llm.utils.llm_config import LLMConfig
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
 from autobyteus.llm.user_message import LLMUserMessage
-from autobyteus_llm_client.client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 import logging
 import uuid