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

autobyteus/agent/context/agent_runtime_state.py

@@ -16,6 +16,7 @@ from autobyteus.agent.tool_invocation import ToolInvocation
 if TYPE_CHECKING:
     from autobyteus.agent.phases import AgentPhaseManager 
     from autobyteus.tools.base_tool import BaseTool 
+    from autobyteus.agent.tool_invocation import ToolInvocationTurn
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +49,9 @@ class AgentRuntimeState:
         self.pending_tool_approvals: Dict[str, ToolInvocation] = {}
         self.custom_data: Dict[str, Any] = custom_data or {}
         
+        # NEW: State for multi-tool call invocation turns, with a very explicit name.
+        self.active_multi_tool_call_turn: Optional['ToolInvocationTurn'] = None
+        
         self.processed_system_prompt: Optional[str] = None
         # self.final_llm_config_for_creation removed
         
@@ -83,7 +87,9 @@ class AgentRuntimeState:
         tools_status = f"{len(self.tool_instances)} Initialized" if self.tool_instances is not None else "Not Initialized"
         input_queues_status = "Initialized" if self.input_event_queues else "Not Initialized"
         # REMOVED output_queues_status from repr
+        active_turn_status = "Active" if self.active_multi_tool_call_turn else "Inactive"
         return (f"AgentRuntimeState(agent_id='{self.agent_id}', current_phase='{phase_repr}', "
                 f"llm_status='{llm_status}', tools_status='{tools_status}', "
                 f"input_queues_status='{input_queues_status}', "
-                f"pending_approvals={len(self.pending_tool_approvals)}, history_len={len(self.conversation_history)})")
+                f"pending_approvals={len(self.pending_tool_approvals)}, history_len={len(self.conversation_history)}, "
+                f"multi_tool_call_turn='{active_turn_status}')")

autobyteus/agent/handlers/tool_result_event_handler.py

@@ -1,7 +1,7 @@
 # file: autobyteus/autobyteus/agent/handlers/tool_result_event_handler.py
 import logging
 import json 
-from typing import TYPE_CHECKING, Optional 
+from typing import TYPE_CHECKING, Optional, List
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler 
 from autobyteus.agent.events import ToolResultEvent, LLMUserMessageReadyEvent 
@@ -16,13 +16,60 @@ logger = logging.getLogger(__name__)
 
 class ToolResultEventHandler(AgentEventHandler):
     """
-    Handles ToolResultEvents by formatting the tool's output (or error)
-    as a new LLMUserMessage, emitting AGENT_DATA_TOOL_LOG event for this outcome,
-    and enqueuing an LLMUserMessageReadyEvent for further LLM processing.
+    Handles ToolResultEvents. It immediately processes and notifies for each
+    individual tool result. If a multi-tool call turn is active, it accumulates
+    these processed results until the turn is complete, then sends a single
+    aggregated message to the LLM.
     """
     def __init__(self):
         logger.info("ToolResultEventHandler initialized.")
 
+    async def _dispatch_aggregated_results_to_llm(self,
+                                                  processed_events: List[ToolResultEvent],
+                                                  context: 'AgentContext'):
+        """
+        Aggregates a list of PRE-PROCESSED tool results into a single message and
+        dispatches it to the LLM.
+        """
+        agent_id = context.agent_id
+        
+        # --- Aggregate results into a single message ---
+        aggregated_content_parts = []
+        for p_event in processed_events:
+            tool_invocation_id = p_event.tool_invocation_id if p_event.tool_invocation_id else 'N/A'
+            content_part: str
+            if p_event.error:
+                content_part = (
+                    f"Tool: {p_event.tool_name} (ID: {tool_invocation_id})\n"
+                    f"Status: Error\n"
+                    f"Details: {p_event.error}"
+                )
+            else:
+                try:
+                    result_str = json.dumps(p_event.result, indent=2) if not isinstance(p_event.result, str) else p_event.result
+                except TypeError: # pragma: no cover
+                    result_str = str(p_event.result)
+                content_part = (
+                    f"Tool: {p_event.tool_name} (ID: {tool_invocation_id})\n"
+                    f"Status: Success\n"
+                    f"Result:\n{result_str}" 
+                )
+            aggregated_content_parts.append(content_part)
+
+        final_content_for_llm = (
+            "The following tool executions have completed. Please analyze their results and decide the next course of action.\n\n"
+            + "\n\n---\n\n".join(aggregated_content_parts)
+        )
+        
+        logger.debug(f"Agent '{agent_id}' preparing aggregated message for LLM:\n---\n{final_content_for_llm}\n---")
+        llm_user_message = LLMUserMessage(content=final_content_for_llm)
+        
+        next_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
+        await context.input_event_queues.enqueue_internal_system_event(next_event)
+        
+        logger.info(f"Agent '{agent_id}' enqueued LLMUserMessageReadyEvent with aggregated results from {len(processed_events)} tool(s).")
+
+
     async def handle(self,
                      event: ToolResultEvent,
                      context: 'AgentContext') -> None:
@@ -31,99 +78,64 @@ class ToolResultEventHandler(AgentEventHandler):
             return
 
         agent_id = context.agent_id
-        processed_event = event
+        notifier: Optional['AgentExternalEventNotifier'] = context.phase_manager.notifier if context.phase_manager else None
 
-        # --- New: Apply Tool Execution Result Processors ---
+        # --- Step 1: Immediately process the incoming event ---
+        processed_event = event
         processor_instances = context.config.tool_execution_result_processors
         if processor_instances:
-            processor_names = [p.get_name() for p in processor_instances]
-            logger.debug(f"Agent '{agent_id}': Applying tool execution result processors: {processor_names}")
             for processor_instance in processor_instances:
-                processor_name_for_log = "unknown"
+                if not isinstance(processor_instance, BaseToolExecutionResultProcessor):
+                    logger.error(f"Agent '{agent_id}': Invalid tool result processor type: {type(processor_instance)}. Skipping.")
+                    continue
                 try:
-                    if not isinstance(processor_instance, BaseToolExecutionResultProcessor):
-                        logger.error(f"Agent '{agent_id}': Invalid tool result processor type: {type(processor_instance)}. Skipping.")
-                        continue
-                    
-                    processor_name_for_log = processor_instance.get_name()
-                    logger.debug(f"Agent '{agent_id}': Applying tool result processor '{processor_name_for_log}'.")
-                    
-                    event_before_proc = processed_event
-                    processed_event = await processor_instance.process(event_before_proc, context)
-                    logger.info(f"Agent '{agent_id}': Tool result processor '{processor_name_for_log}' applied successfully.")
-
+                    processed_event = await processor_instance.process(processed_event, context)
                 except Exception as e:
-                    logger.error(f"Agent '{agent_id}': Error applying tool result processor '{processor_name_for_log}': {e}. "
-                                 f"Skipping and continuing with result from before this processor.", exc_info=True)
-                    processed_event = event_before_proc
-        # --- End New ---
-
-        tool_invocation_id = processed_event.tool_invocation_id if processed_event.tool_invocation_id else 'N/A'
-
-        logger.info(f"Agent '{agent_id}' handling processed ToolResultEvent from tool: '{processed_event.tool_name}' (Invocation ID: {tool_invocation_id}). Error: {processed_event.error is not None}")
+                    logger.error(f"Agent '{agent_id}': Error applying tool result processor '{processor_instance.get_name()}': {e}", exc_info=True)
         
-        notifier: Optional['AgentExternalEventNotifier'] = None
-        if context.phase_manager:
-            notifier = context.phase_manager.notifier
-        
-        if not notifier: # pragma: no cover
-            logger.error(f"Agent '{agent_id}': Notifier not available in ToolResultEventHandler. Tool result processing logs will not be emitted.")
-
-        if processed_event.error:
-            logger.debug(f"Agent '{agent_id}' tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) raw error details: {processed_event.error}")
-        else:
+        # --- Step 2: Immediately notify the result of this single tool call ---
+        tool_invocation_id = processed_event.tool_invocation_id if processed_event.tool_invocation_id else 'N/A'
+        if notifier:
+            log_message = ""
+            if processed_event.error:
+                log_message = f"[TOOL_RESULT_ERROR_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Error: {processed_event.error}"
+            else:
+                log_message = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Result: {str(processed_event.result)}"
+            
             try:
-                raw_result_str_for_debug_log = json.dumps(processed_event.result, indent=2)
-            except TypeError: # pragma: no cover
-                raw_result_str_for_debug_log = str(processed_event.result)
-            logger.debug(f"Agent '{agent_id}' tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) raw result:\n---\n{raw_result_str_for_debug_log}\n---")
+                log_data = {
+                    "log_entry": log_message,
+                    "tool_invocation_id": tool_invocation_id,
+                    "tool_name": processed_event.tool_name,
+                }
+                notifier.notify_agent_data_tool_log(log_data)
+                logger.debug(f"Agent '{agent_id}': Notified individual tool result for '{processed_event.tool_name}'.")
+            except Exception as e_notify: 
+                logger.error(f"Agent '{agent_id}': Error notifying tool result log: {e_notify}", exc_info=True)
 
+        # --- Step 3: Manage the multi-tool call turn state ---
+        active_turn = context.state.active_multi_tool_call_turn
 
-        content_for_llm: str
-        if processed_event.error:
-            content_for_llm = (
-                f"The tool '{processed_event.tool_name}' (invocation ID: {tool_invocation_id}) encountered an error.\n"
-                f"Error details: {processed_event.error}\n"
-                f"Please analyze this error and decide the next course of action."
-            )
-            log_msg_error_processed = f"[TOOL_RESULT_ERROR_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Error: {processed_event.error}"
-            if notifier:
-                try:
-                    log_data = {
-                        "log_entry": log_msg_error_processed,
-                        "tool_invocation_id": tool_invocation_id,
-                        "tool_name": processed_event.tool_name,
-                    }
-                    notifier.notify_agent_data_tool_log(log_data)
-                except Exception as e_notify: 
-                    logger.error(f"Agent '{agent_id}': Error notifying tool result error log: {e_notify}", exc_info=True)
-        else:
-            try:
-                result_str_for_llm = json.dumps(processed_event.result, indent=2) if not isinstance(processed_event.result, str) else processed_event.result
-            except TypeError: # pragma: no cover
-                result_str_for_llm = str(processed_event.result)
+        # Case 1: Not a multi-tool call turn, dispatch to LLM immediately.
+        if not active_turn:
+            logger.info(f"Agent '{agent_id}' handling single ToolResultEvent from tool: '{processed_event.tool_name}'.")
+            await self._dispatch_aggregated_results_to_llm([processed_event], context)
+            return
 
-            content_for_llm = (
-                f"The tool '{processed_event.tool_name}' (invocation ID: {tool_invocation_id}) has executed.\n"
-                f"Result:\n{result_str_for_llm}\n" 
-                f"Based on this result, what is the next step or final answer?"
-            )
-            log_msg_success_processed = f"[TOOL_RESULT_SUCCESS_PROCESSED] Agent_ID: {agent_id}, Tool: {processed_event.tool_name}, Invocation_ID: {tool_invocation_id}, Result: {str(processed_event.result)}"
-            if notifier:
-                try:
-                    log_data = {
-                        "log_entry": log_msg_success_processed,
-                        "tool_invocation_id": tool_invocation_id,
-                        "tool_name": processed_event.tool_name,
-                    }
-                    notifier.notify_agent_data_tool_log(log_data)
-                except Exception as e_notify: 
-                    logger.error(f"Agent '{agent_id}': Error notifying tool result success log: {e_notify}", exc_info=True)
-        
-        logger.debug(f"Agent '{agent_id}' preparing message for LLM based on tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) result:\n---\n{content_for_llm}\n---")
-        llm_user_message = LLMUserMessage(content=content_for_llm)
-        
-        next_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
-        await context.input_event_queues.enqueue_internal_system_event(next_event)
+        # Case 2: Multi-tool call turn is active, accumulate results.
+        active_turn.results.append(processed_event)
+        num_results = len(active_turn.results)
+        num_expected = len(active_turn.invocations)
+        logger.info(f"Agent '{agent_id}' handling ToolResultEvent for multi-tool call turn. "
+                    f"Collected {num_results}/{num_expected} results.")
+
+        # If not all results are in, just wait for the next ToolResultEvent.
+        if not active_turn.is_complete():
+            return
+            
+        # If all results are in, dispatch them to the LLM and clean up the turn state.
+        logger.info(f"Agent '{agent_id}': All tool results for the turn collected. Aggregating for LLM.")
+        await self._dispatch_aggregated_results_to_llm(active_turn.results, context)
         
-        logger.info(f"Agent '{agent_id}' enqueued LLMUserMessageReadyEvent for LLM based on tool '{processed_event.tool_name}' (ID: {tool_invocation_id}) result summary.")
+        context.state.active_multi_tool_call_turn = None
+        logger.info(f"Agent '{agent_id}': Multi-tool call turn state has been cleared.")

autobyteus/agent/llm_response_processor/provider_aware_tool_usage_processor.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, List
 
 from .base_processor import BaseLLMResponseProcessor
 from autobyteus.agent.events import PendingToolInvocationEvent
-from autobyteus.agent.tool_invocation import ToolInvocation
+from autobyteus.agent.tool_invocation import ToolInvocation, ToolInvocationTurn
 from autobyteus.tools.usage.parsers import ProviderAwareToolUsageParser
 from autobyteus.tools.usage.parsers.exceptions import ToolUsageParseException
 
@@ -72,6 +72,12 @@ class ProviderAwareToolUsageProcessor(BaseLLMResponseProcessor):
             processed_invocations.append(invocation)
 
         # --- END NEW LOGIC ---
+        
+        # --- NEW: Initialize the multi-tool turn state ---
+        if len(processed_invocations) > 0:
+            logger.info(f"Agent '{context.agent_id}': Initializing multi-tool call turn with {len(processed_invocations)} invocations.")
+            context.state.active_multi_tool_call_turn = ToolInvocationTurn(invocations=processed_invocations)
+        # --- END NEW ---
 
         logger.info(f"Agent '{context.agent_id}': Parsed {len(processed_invocations)} tool invocations. Enqueuing events with unique IDs.")
         for invocation in processed_invocations:

autobyteus/agent/tool_invocation.py

@@ -2,7 +2,14 @@
 import uuid
 import hashlib
 import json
-from typing import Optional, Dict, Any
+import logging
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from dataclasses import dataclass, field
+
+if TYPE_CHECKING:
+    from autobyteus.agent.events import ToolResultEvent
+
+logger = logging.getLogger(__name__)
 
 class ToolInvocation:
     def __init__(self, name: Optional[str] = None, arguments: Optional[Dict[str, Any]] = None, id: Optional[str] = None):
@@ -39,6 +46,9 @@ class ToolInvocation:
         # Create a string to hash
         hash_string = f"{name}:{canonical_args}"
         
+        # --- ADDED LOGGING ---
+        logger.debug(f"Generating tool invocation ID from hash_string: '{hash_string}'")
+        
         # Use SHA256 for a robust hash
         sha256_hash = hashlib.sha256(hash_string.encode('utf-8')).hexdigest()
         
@@ -55,3 +65,17 @@ class ToolInvocation:
     def __repr__(self) -> str:
         return (f"ToolInvocation(id='{self.id}', name='{self.name}', "
                 f"arguments={self.arguments})")
+
+
+@dataclass
+class ToolInvocationTurn:
+    """
+    A data class to encapsulate the state of a multi-tool invocation turn.
+    Its existence in the agent's state signifies that a multi-tool turn is active.
+    """
+    invocations: List[ToolInvocation]
+    results: List['ToolResultEvent'] = field(default_factory=list)
+
+    def is_complete(self) -> bool:
+        """Checks if all expected tool results have been collected."""
+        return len(self.results) >= len(self.invocations)

autobyteus/agent_team/agent_team_builder.py

@@ -45,6 +45,7 @@ class AgentTeamBuilder:
         self._coordinator_config: Optional[AgentConfig] = None
         self._added_node_names: Set[str] = set()
         self._task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+        self._use_xml_tool_format: Optional[bool] = None
         logger.info(f"AgentTeamBuilder initialized for team: '{self._name}'.")
 
     def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
@@ -142,6 +143,25 @@ class AgentTeamBuilder:
         logger.debug(f"Task notification mode set to '{mode.value}'.")
         return self
 
+    def set_use_xml_tool_format(self, use_xml: bool) -> 'AgentTeamBuilder':
+        """
+        Sets the team-level override for using XML tool format.
+
+        If set, this will override the setting on all individual agents within the team.
+
+        Args:
+            use_xml: If True, forces the team to use XML format for tool
+                     definitions and parsing.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if not isinstance(use_xml, bool):
+            raise TypeError("use_xml must be a boolean.")
+        self._use_xml_tool_format = use_xml
+        logger.debug(f"Team-level XML tool format override set to '{use_xml}'.")
+        return self
+
     def build(self) -> AgentTeam:
         """
         Constructs and returns the final AgentTeam instance using the
@@ -175,7 +195,8 @@ class AgentTeamBuilder:
             role=self._role,
             nodes=tuple(final_nodes),
             coordinator_node=coordinator_node_instance,
-            task_notification_mode=self._task_notification_mode
+            task_notification_mode=self._task_notification_mode,
+            use_xml_tool_format=self._use_xml_tool_format
         )
         
         logger.info(f"AgentTeamConfig created successfully. Name: '{team_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")

autobyteus/agent_team/context/agent_team_runtime_state.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from autobyteus.agent_team.context.team_manager import TeamManager
     from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
     from autobyteus.task_management.base_task_board import BaseTaskBoard
-    from autobyteus.task_management.artifacts.artifact_manifest import ArtifactManifest
     from autobyteus.agent_team.task_notification.system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 
 logger = logging.getLogger(__name__)
@@ -40,7 +39,6 @@ class AgentTeamRuntimeState:
     
     # Dynamic planning and artifact state
     task_board: Optional['BaseTaskBoard'] = None
-    artifact_registry: Dict[str, 'ArtifactManifest'] = field(default_factory=dict)
 
     def __post_init__(self):
         if not self.team_id or not isinstance(self.team_id, str):

autobyteus/llm/llm_factory.py

@@ -14,6 +14,7 @@ from autobyteus.llm.api.bedrock_llm import BedrockLLM
 from autobyteus.llm.api.mistral_llm import MistralLLM
 from autobyteus.llm.api.openai_llm import OpenAILLM
 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.ollama_provider import OllamaModelProvider
@@ -266,106 +267,73 @@ class LLMFactory(metaclass=SingletonMeta):
                 name="gemini-2.5-pro",
                 value="gemini-2.5-pro",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
+                llm_class=GeminiLLM,
                 canonical_name="gemini-2.5-pro",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(2.50, 10.00)
+                    pricing_config=TokenPricingConfig(2.50, 15.00)
                 )
             ),
             LLMModel(
                 name="gemini-2.5-flash",
                 value="gemini-2.5-flash",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
+                llm_class=GeminiLLM,
                 canonical_name="gemini-2.5-flash",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.15, 0.60)
-                )
-            ),
-            LLMModel(
-                name="gemini-2.0-flash",
-                value="gemini-2.0-flash",
-                provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
-                canonical_name="gemini-2.0-flash",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.1, 0.40)
+                    pricing_config=TokenPricingConfig(0.30, 2.50)
                 )
             ),
             LLMModel(
-                name="gemini-2.0-flash-lite",
-                value="gemini-2.0-flash-lite",
+                name="gemini-2.5-flash-lite",
+                value="gemini-2.5-flash-lite",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
-                canonical_name="gemini-2.0-flash-lite",
+                llm_class=GeminiLLM,
+                canonical_name="gemini-2.5-flash-lite",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.075, 0.30)
-                )
-            ),
-            # GROK Provider Models
-            LLMModel(
-                name="grok-2-1212",
-                value="grok-2-1212",
-                provider=LLMProvider.GROK,
-                llm_class=GrokLLM,
-                canonical_name="grok-2",
-                default_config=LLMConfig(
-                    rate_limit=60,
-                    token_limit=8000,
-                    pricing_config=TokenPricingConfig(2.0, 6.0)
+                    pricing_config=TokenPricingConfig(0.10, 0.40)
                 )
             ),
             # KIMI Provider Models
             LLMModel(
-                name="kimi-latest",
-                value="kimi-latest",
+                name="kimi-k2-0711-preview",
+                value="kimi-k2-0711-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="kimi-latest",
+                canonical_name="kimi-k2-0711-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(1.38, 4.14)
+                    pricing_config=TokenPricingConfig(0.55, 2.21)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-8k",
-                value="moonshot-v1-8k",
+                name="kimi-k2-0905-preview",
+                value="kimi-k2-0905-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-8k",
+                canonical_name="kimi-k2-0905-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.28, 1.38)
+                    pricing_config=TokenPricingConfig(0.55, 2.21)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-32k",
-                value="moonshot-v1-32k",
+                name="kimi-k2-turbo-preview",
+                value="kimi-k2-turbo-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-32k",
+                canonical_name="kimi-k2-turbo-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.69, 2.76)
+                    pricing_config=TokenPricingConfig(2.76, 2.76)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-128k",
-                value="moonshot-v1-128k",
+                name="kimi-latest",
+                value="kimi-latest",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-128k",
+                canonical_name="kimi-latest",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(1.38, 4.14)
                 )
             ),
-            LLMModel(
-                name="kimi-k2-0711-preview",
-                value="kimi-k2-0711-preview",
-                provider=LLMProvider.KIMI,
-                llm_class=KimiLLM,
-                canonical_name="kimi-k2-0711-preview",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.55, 2.21)
-                )
-            ),
             LLMModel(
                 name="kimi-thinking-preview",
                 value="kimi-thinking-preview",

autobyteus/llm/ollama_provider_resolver.py

@@ -18,6 +18,7 @@ class OllamaProviderResolver:
         (['llama'], LLMProvider.GROQ),
         (['mistral'], LLMProvider.MISTRAL),
         (['deepseek'], LLMProvider.DEEPSEEK),
+        (['qwen'], LLMProvider.QWEN),
     ]
 
     @staticmethod

autobyteus/llm/providers.py

@@ -13,4 +13,5 @@ class LLMProvider(Enum):
     GROK = "GROK"
     AUTOBYTEUS = "AUTOBYTEUS"
     KIMI = "KIMI"
+    QWEN = "QWEN"
     LMSTUDIO = "LMSTUDIO"

autobyteus/llm/token_counter/token_counter_factory.py

@@ -34,6 +34,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         return DeepSeekTokenCounter(model, llm)
     elif model.provider == LLMProvider.KIMI:
         return KimiTokenCounter(model, llm)
+    elif model.provider == LLMProvider.QWEN:
+        return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.OLLAMA:
         return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.LMSTUDIO:

autobyteus/multimedia/audio/audio_model.py

@@ -28,7 +28,8 @@ class AudioModelMeta(type):
         model = AudioClientFactory._models_by_identifier.get(name_or_identifier)
         if model:
             return model
-        raise KeyError(f"Audio model '{name_or_identifier}' not found.")
+        available_models = list(AudioClientFactory._models_by_identifier.keys())
+        raise KeyError(f"Audio model '{name_or_identifier}' not found. Available models: {available_models}")
 
     def __len__(cls) -> int:
         from autobyteus.multimedia.audio.audio_client_factory import AudioClientFactory

autobyteus/multimedia/image/image_model.py

@@ -28,7 +28,8 @@ class ImageModelMeta(type):
         model = ImageClientFactory._models_by_identifier.get(name_or_identifier)
         if model:
             return model
-        raise KeyError(f"Image model '{name_or_identifier}' not found.")
+        available_models = list(ImageClientFactory._models_by_identifier.keys())
+        raise KeyError(f"Image model '{name_or_identifier}' not found. Available models: {available_models}")
 
     def __len__(cls) -> int:
         from autobyteus.multimedia.image.image_client_factory import ImageClientFactory

autobyteus/task_management/tools/publish_task_plan.py

@@ -4,12 +4,11 @@ import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
 from pydantic import ValidationError
-# No longer need GenerateJsonSchema from pydantic.json_schema
-# from pydantic.json_schema import GenerateJsonSchema
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.schemas import TaskPlanDefinitionSchema
 from autobyteus.task_management.converters import TaskPlanConverter, TaskBoardConverter
 
@@ -24,8 +23,6 @@ class PublishTaskPlan(BaseTool):
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
-    # The failing custom InlineSchemaGenerator has been removed.
-
     @classmethod
     def get_name(cls) -> str:
         return "PublishTaskPlan"
@@ -44,11 +41,8 @@ class PublishTaskPlan(BaseTool):
     def get_argument_schema(cls) -> Optional[ParameterSchema]:
         schema = ParameterSchema()
         
-        # CORRECTED IMPLEMENTATION:
-        # A direct, standard call to model_json_schema(). This generates a valid
-        # JSON schema with $refs, which the framework handles correctly.
-        # This completely avoids the TypeError caused by the unsupported 'ref_strategy' argument.
-        object_json_schema = TaskPlanDefinitionSchema.model_json_schema()
+        # Convert the Pydantic model to our native ParameterSchema for the nested object
+        plan_object_schema = pydantic_to_parameter_schema(TaskPlanDefinitionSchema)
         
         schema.add_parameter(ParameterDefinition(
             name="plan",
@@ -59,7 +53,7 @@ class PublishTaskPlan(BaseTool):
                 "Each task must have a unique name within the plan."
             ),
             required=True,
-            object_schema=object_json_schema
+            object_schema=plan_object_schema
         ))
         return schema
 
@@ -83,12 +77,8 @@ class PublishTaskPlan(BaseTool):
             return error_msg
             
         try:
-            # Step 1: The input is now a dictionary, so we can directly validate it.
             plan_definition_schema = TaskPlanDefinitionSchema(**plan)
-
-            # Step 2: Use the dedicated converter to create the internal TaskPlan object.
             final_plan = TaskPlanConverter.from_schema(plan_definition_schema)
-
         except (ValidationError, ValueError) as e:
             error_msg = f"Invalid or inconsistent task plan provided: {e}"
             logger.warning(f"Agent '{context.agent_id}' provided an invalid plan for PublishTaskPlan: {error_msg}")
@@ -100,12 +90,10 @@ class PublishTaskPlan(BaseTool):
 
         if task_board.load_task_plan(final_plan):
             logger.info(f"Agent '{context.agent_id}': Task plan published successfully. Returning new board status.")
-            # Convert the new state of the board back to an LLM-friendly schema and return it.
             status_report_schema = TaskBoardConverter.to_schema(task_board)
             if status_report_schema:
                 return status_report_schema.model_dump_json(indent=2)
             else:
-                # This is a fallback case, shouldn't happen right after a successful load.
                 return "Task plan published successfully, but could not generate status report."
         else:
             error_msg = "Failed to load task plan onto the board. This can happen if the board implementation rejects the plan."