autobyteus 1.1.7__py3-none-any.whl → 1.1.9__py3-none-any.whl

autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py

@@ -1,14 +1,14 @@
 # file: autobyteus/autobyteus/agent_team/task_notification/system_event_driven_agent_task_notifier.py
-import asyncio
 import logging
-from typing import Set, Any, TYPE_CHECKING, List, Union
+from typing import Union, TYPE_CHECKING
 
 from autobyteus.events.event_types import EventType
-from autobyteus.agent_team.events import ProcessUserMessageEvent
-from autobyteus.agent.message import AgentInputUserMessage
-from autobyteus.task_management.events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from autobyteus.task_management.events import TasksAddedEvent, TaskStatusUpdatedEvent
 from autobyteus.task_management.base_task_board import TaskStatus
-from autobyteus.task_management.task_plan import Task
+
+# Import the new, separated components
+from .activation_policy import ActivationPolicy
+from .task_activator import TaskActivator
 
 if TYPE_CHECKING:
     from autobyteus.task_management.base_task_board import BaseTaskBoard
@@ -18,8 +18,11 @@ logger = logging.getLogger(__name__)
 
 class SystemEventDrivenAgentTaskNotifier:
     """
-    An internal component that monitors a TaskBoard and automatically sends
-    notifications to agents when their assigned tasks become runnable.
+    An internal component that monitors a TaskBoard and orchestrates agent
+    activation based on task runnability.
+
+    This class acts as a conductor, delegating the logic for *when* to activate
+    to an ActivationPolicy and the action of *how* to activate to a TaskActivator.
     """
     def __init__(self, task_board: 'BaseTaskBoard', team_manager: 'TeamManager'):
         """
@@ -27,138 +30,69 @@ class SystemEventDrivenAgentTaskNotifier:
 
         Args:
             task_board: The team's shared task board instance.
-            team_manager: The team's manager for submitting notification events.
+            team_manager: The team's manager for activating agents.
         """
         if not task_board or not team_manager:
             raise ValueError("TaskBoard and TeamManager are required for the notifier.")
             
         self._task_board = task_board
         self._team_manager = team_manager
-        self._dispatched_task_ids: Set[str] = set()
-        logger.info(f"SystemEventDrivenAgentTaskNotifier initialized for team '{self._team_manager.team_id}'.")
+        
+        # Instantiate the components that hold the actual logic and action
+        self._policy = ActivationPolicy(team_id=self._team_manager.team_id)
+        self._activator = TaskActivator(team_manager=self._team_manager)
+
+        logger.info(f"SystemEventDrivenAgentTaskNotifier orchestrator initialized for team '{self._team_manager.team_id}'.")
 
     def start_monitoring(self):
         """
         Subscribes to task board events to begin monitoring for runnable tasks.
-        This should be called once during the agent team's bootstrap process.
         """
-        self._task_board.subscribe(
-            EventType.TASK_BOARD_PLAN_PUBLISHED,
-            self._handle_task_board_update
-        )
-        self._task_board.subscribe(
-            EventType.TASK_BOARD_STATUS_UPDATED,
-            self._handle_task_board_update
-        )
-        logger.info(f"Team '{self._team_manager.team_id}': Task notifier is now monitoring TaskBoard events.")
-
-    async def _handle_task_board_update(self, payload: Union[TaskPlanPublishedEvent, TaskStatusUpdatedEvent], **kwargs):
+        self._task_board.subscribe(EventType.TASK_BOARD_TASKS_ADDED, self._handle_tasks_changed)
+        self._task_board.subscribe(EventType.TASK_BOARD_STATUS_UPDATED, self._handle_tasks_changed)
+        logger.info(f"Team '{self._team_manager.team_id}': Task notifier orchestrator is now monitoring TaskBoard events.")
+    
+    async def _handle_tasks_changed(self, payload: Union[TasksAddedEvent, TaskStatusUpdatedEvent], **kwargs):
         """
-        Asynchronous event handler triggered by the task board. It uses the event
-        payload to decide when to check for and notify agents of newly runnable tasks.
+        Orchestrates the agent activation workflow upon any change to the task board.
         """
-        if isinstance(payload, TaskPlanPublishedEvent):
-            logger.info(f"Team '{self._team_manager.team_id}': New task plan detected. Resetting dispatched tasks and checking for initial runnable tasks.")
-            self._dispatched_task_ids.clear()
-            await self._scan_and_notify_all_runnable_tasks()
-        
-        elif isinstance(payload, TaskStatusUpdatedEvent):
-            # Only trigger a check for dependent tasks if a task has been completed,
-            # as this is the only status change that can unblock dependent tasks.
-            if payload.new_status == TaskStatus.COMPLETED:
-                logger.info(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' completed. Checking for newly unblocked dependent tasks.")
-                await self._check_and_notify_dependent_tasks(payload.task_id)
-            else:
-                logger.debug(f"Team '{self._team_manager.team_id}': Task '{payload.task_id}' status updated to '{payload.new_status.value}'. No dependent task check needed.")
-        else:
-            # This case should ideally not be hit with the new strong typing, but is kept as a safeguard.
-            logger.warning(f"Team '{self._team_manager.team_id}': Task notifier received an unhandled payload type: {type(payload)}")
+        team_id = self._team_manager.team_id
+        logger.info(f"Team '{team_id}': Task board changed ({type(payload).__name__}). Orchestrating activation check.")
 
+        # If a new batch of tasks was added, it's a new "wave" of work.
+        # We must reset the policy's memory of who has been activated.
+        if isinstance(payload, TasksAddedEvent):
+            logger.info(f"Team '{team_id}': New tasks added. Resetting activation policy.")
+            self._policy.reset()
 
-    async def _check_and_notify_dependent_tasks(self, completed_task_id: str):
-        """
-        Finds tasks that depend on the completed task and notifies their assignees
-        if all of their other dependencies are also met.
-        """
-        if not getattr(self._task_board, 'current_plan', None):
+        # 1. DATA FETCHING: Get the current state of runnable tasks from the board.
+        runnable_tasks = self._task_board.get_next_runnable_tasks()
+        
+        if not runnable_tasks:
+            logger.debug(f"Team '{team_id}': No runnable tasks found after change. No action needed.")
             return
 
-        all_tasks = self._task_board.current_plan.tasks
-        task_statuses = getattr(self._task_board, 'task_statuses', {})
+        # 2. POLICY DECISION: Ask the policy to decide which agents to activate.
+        # The policy contains all the complex state and logic.
+        agents_to_activate = self._policy.determine_activations(runnable_tasks)
 
-        for child_task in all_tasks:
-            # Find tasks that are direct children of the completed task
-            if completed_task_id in child_task.dependencies:
-                # Now, check if this child task is fully runnable (all its parents are done)
-                all_deps_met = all(
-                    task_statuses.get(dep_id) == TaskStatus.COMPLETED for dep_id in child_task.dependencies
-                )
-                
-                if all_deps_met and child_task.task_id not in self._dispatched_task_ids:
-                    await self._dispatch_notification_for_task(child_task)
+        if not agents_to_activate:
+            logger.info(f"Team '{team_id}': Runnable tasks exist, but policy determined no new agents need activation.")
+            return
 
-    async def _scan_and_notify_all_runnable_tasks(self):
-        """
-        Scans the entire board for any runnable tasks. Used for initial plan loading.
-        """
-        try:
-            runnable_tasks = self._task_board.get_next_runnable_tasks()
-            for task in runnable_tasks:
-                if task.task_id not in self._dispatched_task_ids:
-                    await self._dispatch_notification_for_task(task)
-        except Exception as e:
-            logger.error(f"Team '{self._team_manager.team_id}': Error during full scan for runnable tasks: {e}", exc_info=True)
-    
-    async def _dispatch_notification_for_task(self, task: Task):
-        """
-        Constructs and sends a context-rich notification for a single runnable task
-        by treating it as a user message to trigger the full processing pipeline.
-        It tags the message with metadata to indicate its system origin.
-        """
-        try:
-            team_id = self._team_manager.team_id
-            logger.info(f"Team '{team_id}': Dispatching notification for runnable task '{task.task_name}' to assignee '{task.assignee_name}'.")
-            
-            context_from_parents = []
-            if task.dependencies:
-                parent_task_deliverables_info = []
-                for dep_id in task.dependencies:
-                    parent_task = getattr(self._task_board, '_task_map', {}).get(dep_id)
-                    if parent_task and parent_task.file_deliverables:
-                        deliverables_str = "\n".join(
-                            [f"  - File: {d.file_path}, Summary: {d.summary}" for d in parent_task.file_deliverables]
-                        )
-                        parent_task_deliverables_info.append(
-                            f"The parent task '{parent_task.task_name}' produced the following deliverables:\n{deliverables_str}"
-                        )
-                
-                if parent_task_deliverables_info:
-                    context_from_parents.append(
-                        "Your task is now unblocked. Here is the context from the completed parent task(s):\n" +
-                        "\n\n".join(parent_task_deliverables_info)
+        # 3. ACTION EXECUTION: Tell the activator to perform the activations.
+        for agent_name in agents_to_activate:
+            # First, update the status for all of that agent's runnable tasks to QUEUED.
+            # This is a state change action, which the orchestrator is responsible for.
+            agent_runnable_tasks = [t for t in runnable_tasks if t.assignee_name == agent_name]
+            for task in agent_runnable_tasks:
+                # We only need to queue tasks that are NOT_STARTED.
+                if self._task_board.task_statuses.get(task.task_id) == TaskStatus.NOT_STARTED:
+                    self._task_board.update_task_status(
+                        task_id=task.task_id,
+                        status=TaskStatus.QUEUED,
+                        agent_name="SystemTaskNotifier"
                     )
-
-            message_parts: List[str] = [f"Your task '{task.task_name}' is now ready to start."]
-            if context_from_parents:
-                message_parts.extend(context_from_parents)
-            
-            message_parts.append(f"\nYour task description:\n{task.description}")
-            
-            content = "\n\n".join(message_parts)
             
-            # Create the user message with metadata indicating its origin.
-            user_message = AgentInputUserMessage(
-                content=content,
-                metadata={'source': 'system_task_notifier'}
-            )
-            event = ProcessUserMessageEvent(
-                user_message=user_message,
-                target_agent_name=task.assignee_name
-            )
-
-            # Use the existing method for dispatching user messages.
-            await self._team_manager.dispatch_user_message_to_agent(event)
-            self._dispatched_task_ids.add(task.task_id)
-
-        except Exception as e:
-            logger.error(f"Team '{self._team_manager.team_id}': Failed to dispatch notification for task '{task.task_id}': {e}", exc_info=True)
+            # Now, trigger the single activation notification.
+            await self._activator.activate_agent(agent_name)

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,