autobyteus 1.1.8__py3-none-any.whl → 1.1.9__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/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/gemini_llm.py

@@ -1,6 +1,7 @@
 import logging
-from typing import Dict, List, AsyncGenerator, Any
-import google.generativeai as genai  # CHANGED: Using the older 'google.generativeai' library
+from typing import Dict, Optional, List, AsyncGenerator, Any
+from google import genai
+from google.genai import types as genai_types
 import os
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.base_llm import BaseLLM
@@ -13,66 +14,60 @@ from autobyteus.llm.user_message import LLMUserMessage
 logger = logging.getLogger(__name__)
 
 def _format_gemini_history(messages: List[Message]) -> List[Dict[str, Any]]:
-    """
-    Formats internal message history for the Gemini API.
-    This function remains compatible with the older library.
-    """
+    """Formats internal message history for the Gemini API."""
     history = []
-    # System message is handled separately in the model initialization
+    # System message is handled separately in the new API
     for msg in messages:
         if msg.role in [MessageRole.USER, MessageRole.ASSISTANT]:
+            # NOTE: This history conversion will need to be updated for multimodal messages
             role = 'model' if msg.role == MessageRole.ASSISTANT else 'user'
+            # The `parts` must be a list of dictionaries (Part objects), not a list of strings.
             history.append({"role": role, "parts": [{"text": msg.content}]})
     return history
 
 class GeminiLLM(BaseLLM):
     def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        self.generation_config_dict = {
+            "response_mime_type": "text/plain",
+        }
+        
         if model is None:
-            model = LLMModel['gemini-2.5-flash'] # Note: Ensure model name is compatible, e.g., 'gemini-1.5-flash-latest'
+            model = LLMModel['gemini-2.5-flash']
         if llm_config is None:
             llm_config = LLMConfig()
-
+            
         super().__init__(model=model, llm_config=llm_config)
-        
-        # CHANGED: Initialization flow. Configure API key and then instantiate the model.
-        self.initialize()
-        
-        system_instruction = self.system_message if self.system_message else None
-        
-        self.model = genai.GenerativeModel(
-            model_name=self.model.value,
-            system_instruction=system_instruction
-        )
+        self.client = self.initialize()
+        self.async_client = self.client.aio
 
-    @staticmethod
-    def initialize():
-        """
-        CHANGED: This method now configures the genai library with the API key
-        instead of creating a client instance.
-        """
+    @classmethod
+    def initialize(cls) -> genai.client.Client:
         api_key = os.environ.get("GEMINI_API_KEY")
         if not api_key:
             logger.error("GEMINI_API_KEY environment variable is not set.")
             raise ValueError("GEMINI_API_KEY environment variable is not set.")
         try:
-            genai.configure(api_key=api_key)
+            return genai.Client()
         except Exception as e:
-            logger.error(f"Failed to configure Gemini client: {str(e)}")
-            raise ValueError(f"Failed to configure Gemini client: {str(e)}")
+            logger.error(f"Failed to initialize Gemini client: {str(e)}")
+            raise ValueError(f"Failed to initialize Gemini client: {str(e)}")
 
-    def _get_generation_config(self) -> Dict[str, Any]:
-        """
-        CHANGED: Builds the generation config as a dictionary.
-        'thinking_config' is not available in the old library.
-        'system_instruction' is passed during model initialization.
-        """
-        # Basic configuration, you can expand this with temperature, top_p, etc.
-        # from self.llm_config if needed.
-        config = {
-            "response_mime_type": "text/plain",
-            # Example: "temperature": self.llm_config.temperature
-        }
-        return config
+    def _get_generation_config(self) -> genai_types.GenerateContentConfig:
+        """Builds the generation config, handling special cases like 'thinking'."""
+        config = self.generation_config_dict.copy()
+
+        thinking_config = None
+        if "flash" in self.model.value:
+            thinking_config = genai_types.ThinkingConfig(thinking_budget=0)
+        
+        # System instruction is now part of the config
+        system_instruction = self.system_message if self.system_message else None
+        
+        return genai_types.GenerateContentConfig(
+            **config,
+            thinking_config=thinking_config,
+            system_instruction=system_instruction
+        )
 
     async def _send_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
         self.add_user_message(user_message)
@@ -81,20 +76,19 @@ class GeminiLLM(BaseLLM):
             history = _format_gemini_history(self.messages)
             generation_config = self._get_generation_config()
 
-            # CHANGED: API call now uses the model instance directly.
-            response = await self.model.generate_content_async(
+            response = await self.async_client.models.generate_content(
+                model=f"models/{self.model.value}",
                 contents=history,
-                generation_config=generation_config,
+                config=generation_config,
             )
             
             assistant_message = response.text
             self.add_assistant_message(assistant_message)
             
-            # CHANGED: Token usage is extracted from 'usage_metadata'.
             token_usage = TokenUsage(
-                prompt_tokens=response.usage_metadata.prompt_token_count,
-                completion_tokens=response.usage_metadata.candidates_token_count,
-                total_tokens=response.usage_metadata.total_token_count
+                prompt_tokens=0,
+                completion_tokens=0,
+                total_tokens=0
             )
             
             return CompleteResponse(
@@ -113,11 +107,10 @@ class GeminiLLM(BaseLLM):
             history = _format_gemini_history(self.messages)
             generation_config = self._get_generation_config()
 
-            # CHANGED: API call for streaming is now part of generate_content_async.
-            response_stream = await self.model.generate_content_async(
+            response_stream = await self.async_client.models.generate_content_stream(
+                model=f"models/{self.model.value}",
                 contents=history,
-                generation_config=generation_config,
-                stream=True
+                config=generation_config,
             )
 
             async for chunk in response_stream:
@@ -130,8 +123,6 @@ class GeminiLLM(BaseLLM):
 
             self.add_assistant_message(complete_response)
 
-            # NOTE: The old library's async stream does not easily expose token usage.
-            # Keeping it at 0, consistent with your original implementation.
             token_usage = TokenUsage(
                 prompt_tokens=0,
                 completion_tokens=0,

autobyteus/llm/api/qwen_llm.py

@@ -0,0 +1,25 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class QwenLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        if model is None:
+            model = LLMModel['qwen3-max-preview']
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="DASHSCOPE_API_KEY",
+            base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+        )
+        logger.info(f"QwenLLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus/llm/autobyteus_provider.py

@@ -19,7 +19,9 @@ class AutobyteusModelProvider:
 
     @staticmethod
     def _get_hosts() -> List[str]:
-        """Gets Autobyteus LLM server hosts from env vars, supporting a comma-separated list."""
+        """
+        Gets Autobyteus LLM server hosts from env vars. Skips discovery if no host is configured.
+        """
         hosts_str = os.getenv('AUTOBYTEUS_LLM_SERVER_HOSTS')
         if hosts_str:
             return [host.strip() for host in hosts_str.split(',')]
@@ -28,7 +30,7 @@ class AutobyteusModelProvider:
         if legacy_host:
             return [legacy_host]
             
-        return [AutobyteusModelProvider.DEFAULT_SERVER_URL]
+        return []
 
     @staticmethod
     def discover_and_register():
@@ -37,6 +39,10 @@ class AutobyteusModelProvider:
             from autobyteus.llm.llm_factory import LLMFactory
 
             hosts = AutobyteusModelProvider._get_hosts()
+            if not hosts:
+                logger.info("No Autobyteus LLM server hosts configured. Skipping Autobyteus LLM model discovery.")
+                return
+
             total_registered_count = 0
 
             for host_url in hosts:

autobyteus/llm/llm_factory.py

@@ -17,6 +17,7 @@ from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
 from autobyteus.llm.api.gemini_llm import GeminiLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
+from autobyteus.llm.api.qwen_llm import QwenLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
 from autobyteus.llm.lmstudio_provider import LMStudioModelProvider
 from autobyteus.utils.singleton import SingletonMeta
@@ -344,6 +345,21 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(27.59, 27.59)
                 )
             ),
+            # QWEN Provider Models
+            LLMModel(
+                name="qwen3-max",
+                value="qwen-max",
+                provider=LLMProvider.QWEN,
+                llm_class=QwenLLM,
+                canonical_name="qwen3-max",
+                default_config=LLMConfig(
+                    token_limit=262144,
+                    pricing_config=TokenPricingConfig(
+                        input_token_pricing=2.4,
+                        output_token_pricing=12.0
+                    )
+                )
+            ),
         ]
         for model in supported_models:
             LLMFactory.register_model(model)

autobyteus/multimedia/audio/api/autobyteus_audio_client.py

@@ -26,7 +26,8 @@ class AutobyteusAudioClient(BaseAudioClient):
     async def generate_speech(
         self,
         prompt: str,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> SpeechGenerationResponse:
         """
         Generates speech by calling the generate_speech endpoint on the remote Autobyteus server.
@@ -36,6 +37,8 @@ class AutobyteusAudioClient(BaseAudioClient):
             
             model_name_for_server = self.model.name
 
+            # Note: The underlying autobyteus_client.generate_speech does not currently accept **kwargs.
+            # They are accepted here for interface consistency and future-proofing.
             response_data = await self.autobyteus_client.generate_speech(
                 model_name=model_name_for_server,
                 prompt=prompt,