autobyteus 1.1.6__tar.gz → 1.1.8__tar.gz

autobyteus-1.1.8/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: autobyteus
+Version: 1.1.8
+Summary: Multi-Agent framework
+Home-page: https://github.com/AutoByteus/autobyteus
+Author: Ryan Zheng
+Author-email: ryan.zheng.work@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: anthropic
+Requires-Dist: autobyteus-llm-client==1.1.3
+Requires-Dist: beautifulsoup4
+Requires-Dist: boto3
+Requires-Dist: botocore
+Requires-Dist: brui-core==1.0.9
+Requires-Dist: certifi==2025.4.26
+Requires-Dist: google-api-python-client
+Requires-Dist: google-generativeai
+Requires-Dist: Jinja2
+Requires-Dist: mcp[cli]
+Requires-Dist: mistral_common
+Requires-Dist: mistralai
+Requires-Dist: numpy
+Requires-Dist: ollama
+Requires-Dist: openai
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: textual
+Requires-Dist: tiktoken
+Requires-Dist: tokenizers
+Provides-Extra: dev
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: gitpython==3.1.31; extra == "dev"
+Requires-Dist: auto-gpt-plugin-template; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: asynctest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-integration; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: vcrpy; extra == "dev"
+Requires-Dist: pytest-vcr; extra == "dev"
+Requires-Dist: load_dotenv; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Autobyteus
+
+Autobyteus is an open-source, application-first agentic framework for Python. It is designed to help developers build, test, and deploy complex, stateful, and extensible AI agents by providing a robust architecture and a powerful set of tools.
+
+![Autobyteus TUI Dashboard](docs/images/image_1.png)
+
+## Architecture
+
+Autobyteus is built with a modular, event-driven architecture designed for extensibility and clear separation of concerns. The key components are:
+
+-   **Agent Core**: The heart of the system. Each agent is a stateful, autonomous entity that runs as a background process in its own thread, managed by a dedicated `AgentWorker`. This design makes every agent a truly independent entity capable of handling long-running tasks.
+-   **Agent Teams**: The framework provides powerful constructs for building hierarchical multi-agent systems. The `AgentTeam` module allows you to compose teams of individual agents and even nest teams within other teams, enabling sophisticated, real-world organizational structures and delegation patterns.
+-   **Context & Configuration**: Agent behavior is defined through a static configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is passed to all components, providing a single source of truth.
+-   **Event-Driven System**: Agents operate on an internal `asyncio` event loop. User messages, tool results, and internal signals are handled as events, which are processed by dedicated `EventHandlers`. This decouples logic and makes the system highly extensible.
+-   **Pluggable Processors & Hooks**: The framework provides a chain of extension points to inject custom logic at every major step of an agent's reasoning loop. This architecture powers features like flexible tool format parsing. You can customize behavior by implementing:
+    -   **`InputProcessors`**: To modify or enrich user messages *before* they are sent to the LLM.
+    -   **`LLMResponseProcessors`**: To parse the LLM's raw output and extract structured actions, such as tool calls.
+    -   **`ToolExecutionResultProcessors`**: To modify the result from a tool *before* it is sent back to the LLM for the next step of reasoning.
+    -   **`PhaseHooks`**: To run custom code on specific agent lifecycle transitions (e.g., when an agent becomes `IDLE`).
+-   **Context-Aware Tooling**: Tools are first-class citizens that receive the agent's full `AgentContext` during execution. This allows tools to be deeply integrated with the agent's state, configuration, and workspace, enabling more intelligent and powerful actions.
+-   **Tool Approval Flow**: The framework has native support for human-in-the-loop workflows. By setting `auto_execute_tools=False` in the agent's configuration, the agent will pause before executing a tool, emit an event requesting permission, and wait for external approval before proceeding.
+-   **MCP Integration**: The framework has native support for the Model Context Protocol (MCP). This allows agents to discover and use tools from external, language-agnostic tool servers, making the ecosystem extremely flexible and ready for enterprise integration.
+
+## Key Features
+
+#### 📊 Interactive TUI Dashboard
+Launch and monitor your agent teams with our built-in Textual-based TUI.
+-   **Hierarchical View**: See the structure of your team, including sub-teams and their agents.
+-   **Real-Time Status**: Agent and team statuses are updated live, showing you who is idle, thinking, or executing a tool.
+-   **Detailed Logs**: Select any agent to view a detailed, streaming log of their thoughts, actions, and tool interactions.
+-   **Live Task Board**: Watch your team's `TaskBoard` update in real-time as the coordinator publishes a plan and agents complete their tasks.
+
+| TUI - Detailed Agent Log | TUI - Task Board with Completed Task |
+| :---: | :---: |
+| ![Autobyteus Agent Log](docs/images/image_4.png) | ![Autobyteus Task Board](docs/images/image_3.png) |
+
+#### 🏗️ Fluent Team Building
+Define complex agent and team structures with an intuitive, fluent API. The `AgentTeamBuilder` makes composing your team simple and readable.
+
+```python
+# --- From the Multi-Researcher Team Example ---
+research_team = (
+    AgentTeamBuilder(
+        name="MultiSpecialistResearchTeam",
+        description="A team for delegating to multiple specialists."
+    )
+    .set_coordinator(coordinator_config)
+    .add_agent_node(researcher_web_config)
+    .add_agent_node(researcher_db_config)
+    .build()
+)
+```
+
+#### 🔁 Flexible Tool Formatting (JSON & XML)
+Autobyteus intelligently handles tool communication with LLMs while giving you full control.
+-   **Provider-Aware by Default**: The framework automatically generates tool manifests and parses responses in the optimal format for the selected LLM provider (e.g., JSON for OpenAI/Gemini, XML for Anthropic).
+-   **XML Override for Efficiency**: You can set `use_xml_tool_format=True` on an `AgentConfig` or `AgentTeamBuilder` to force the use of XML for tool calls, which can be more efficient and reliable than JSON for complex tool schemas.
+
+#### 📈 Flexible Communication Protocols
+Choose the collaboration pattern that best fits your use case with configurable `TaskNotificationMode`s.
+-   **`AGENT_MANUAL_NOTIFICATION` (Default)**: A traditional approach where a coordinator agent is responsible for creating a plan and then explicitly notifying other agents to begin their work via messages.
+-   **`SYSTEM_EVENT_DRIVEN`**: A more automated approach where the coordinator's only job is to publish a plan to the `TaskBoard`. The framework then monitors the board and automatically notifies agents when their tasks become unblocked, enabling parallel execution and reducing coordinator overhead.
+
+## Requirements
+
+-   **Python Version**: Python 3.11 is the recommended and tested version for this project. Using newer versions of Python may result in dependency conflicts when installing the required packages. For a stable and tested environment, please use Python 3.11.
+
+## Getting Started
+
+### Installation
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/your-username/autobyteus.git
+    cd autobyteus
+    ```
+
+2.  **For users:**
+    To install Autobyteus and its core dependencies:
+    ```bash
+    pip install .
+    ```
+
+3.  **For developers:**
+    To install Autobyteus with all development and example dependencies (including the TUI):
+    ```bash
+    pip install -r requirements-dev.txt
+    ```
+
+4.  **Set up Environment Variables:**
+    Create a `.env` file in the root of the project and add your LLM provider API keys:
+    ```
+    # .env
+    OPENAI_API_KEY="sk-..."
+    KIMI_API_KEY="your-kimi-api-key"
+    # etc.
+    ```
+
+### Running the Examples
+
+The best way to experience Autobyteus is to run one of the included examples. The event-driven software engineering team is a great showcase of the framework's capabilities.
+
+```bash
+# Run the event-driven software engineering team example
+python autobyteus/examples/agent_team/event_driven/run_software_engineering_team.py --llm-model gpt-4o
+
+# Run the hierarchical debate team example
+python autobyteus/examples/agent_team/manual_notification/run_debate_team.py --llm-model gpt-4-turbo
+```
+You can see all available models and their identifiers by running an example with the `--help-models` flag.
+
+### Building the Library
+
+To build Autobyteus as a distributable package, follow these steps:
+
+1.  Ensure you have the latest version of `setuptools` and `wheel` installed:
+    ```
+    pip install --upgrade setuptools wheel
+    ```
+
+2.  Build the distribution packages:
+    ```
+    python setup.py sdist bdist_wheel
+    ```
+
+This will create a `dist` directory containing the built `sdist` and `wheel` distributions.
+
+## Contributing
+
+(Add guidelines for contributing to the project)
+
+## License
+
+This project is licensed under the MIT License.

autobyteus-1.1.8/README.md

@@ -0,0 +1,134 @@
+# Autobyteus
+
+Autobyteus is an open-source, application-first agentic framework for Python. It is designed to help developers build, test, and deploy complex, stateful, and extensible AI agents by providing a robust architecture and a powerful set of tools.
+
+![Autobyteus TUI Dashboard](docs/images/image_1.png)
+
+## Architecture
+
+Autobyteus is built with a modular, event-driven architecture designed for extensibility and clear separation of concerns. The key components are:
+
+-   **Agent Core**: The heart of the system. Each agent is a stateful, autonomous entity that runs as a background process in its own thread, managed by a dedicated `AgentWorker`. This design makes every agent a truly independent entity capable of handling long-running tasks.
+-   **Agent Teams**: The framework provides powerful constructs for building hierarchical multi-agent systems. The `AgentTeam` module allows you to compose teams of individual agents and even nest teams within other teams, enabling sophisticated, real-world organizational structures and delegation patterns.
+-   **Context & Configuration**: Agent behavior is defined through a static configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is passed to all components, providing a single source of truth.
+-   **Event-Driven System**: Agents operate on an internal `asyncio` event loop. User messages, tool results, and internal signals are handled as events, which are processed by dedicated `EventHandlers`. This decouples logic and makes the system highly extensible.
+-   **Pluggable Processors & Hooks**: The framework provides a chain of extension points to inject custom logic at every major step of an agent's reasoning loop. This architecture powers features like flexible tool format parsing. You can customize behavior by implementing:
+    -   **`InputProcessors`**: To modify or enrich user messages *before* they are sent to the LLM.
+    -   **`LLMResponseProcessors`**: To parse the LLM's raw output and extract structured actions, such as tool calls.
+    -   **`ToolExecutionResultProcessors`**: To modify the result from a tool *before* it is sent back to the LLM for the next step of reasoning.
+    -   **`PhaseHooks`**: To run custom code on specific agent lifecycle transitions (e.g., when an agent becomes `IDLE`).
+-   **Context-Aware Tooling**: Tools are first-class citizens that receive the agent's full `AgentContext` during execution. This allows tools to be deeply integrated with the agent's state, configuration, and workspace, enabling more intelligent and powerful actions.
+-   **Tool Approval Flow**: The framework has native support for human-in-the-loop workflows. By setting `auto_execute_tools=False` in the agent's configuration, the agent will pause before executing a tool, emit an event requesting permission, and wait for external approval before proceeding.
+-   **MCP Integration**: The framework has native support for the Model Context Protocol (MCP). This allows agents to discover and use tools from external, language-agnostic tool servers, making the ecosystem extremely flexible and ready for enterprise integration.
+
+## Key Features
+
+#### 📊 Interactive TUI Dashboard
+Launch and monitor your agent teams with our built-in Textual-based TUI.
+-   **Hierarchical View**: See the structure of your team, including sub-teams and their agents.
+-   **Real-Time Status**: Agent and team statuses are updated live, showing you who is idle, thinking, or executing a tool.
+-   **Detailed Logs**: Select any agent to view a detailed, streaming log of their thoughts, actions, and tool interactions.
+-   **Live Task Board**: Watch your team's `TaskBoard` update in real-time as the coordinator publishes a plan and agents complete their tasks.
+
+| TUI - Detailed Agent Log | TUI - Task Board with Completed Task |
+| :---: | :---: |
+| ![Autobyteus Agent Log](docs/images/image_4.png) | ![Autobyteus Task Board](docs/images/image_3.png) |
+
+#### 🏗️ Fluent Team Building
+Define complex agent and team structures with an intuitive, fluent API. The `AgentTeamBuilder` makes composing your team simple and readable.
+
+```python
+# --- From the Multi-Researcher Team Example ---
+research_team = (
+    AgentTeamBuilder(
+        name="MultiSpecialistResearchTeam",
+        description="A team for delegating to multiple specialists."
+    )
+    .set_coordinator(coordinator_config)
+    .add_agent_node(researcher_web_config)
+    .add_agent_node(researcher_db_config)
+    .build()
+)
+```
+
+#### 🔁 Flexible Tool Formatting (JSON & XML)
+Autobyteus intelligently handles tool communication with LLMs while giving you full control.
+-   **Provider-Aware by Default**: The framework automatically generates tool manifests and parses responses in the optimal format for the selected LLM provider (e.g., JSON for OpenAI/Gemini, XML for Anthropic).
+-   **XML Override for Efficiency**: You can set `use_xml_tool_format=True` on an `AgentConfig` or `AgentTeamBuilder` to force the use of XML for tool calls, which can be more efficient and reliable than JSON for complex tool schemas.
+
+#### 📈 Flexible Communication Protocols
+Choose the collaboration pattern that best fits your use case with configurable `TaskNotificationMode`s.
+-   **`AGENT_MANUAL_NOTIFICATION` (Default)**: A traditional approach where a coordinator agent is responsible for creating a plan and then explicitly notifying other agents to begin their work via messages.
+-   **`SYSTEM_EVENT_DRIVEN`**: A more automated approach where the coordinator's only job is to publish a plan to the `TaskBoard`. The framework then monitors the board and automatically notifies agents when their tasks become unblocked, enabling parallel execution and reducing coordinator overhead.
+
+## Requirements
+
+-   **Python Version**: Python 3.11 is the recommended and tested version for this project. Using newer versions of Python may result in dependency conflicts when installing the required packages. For a stable and tested environment, please use Python 3.11.
+
+## Getting Started
+
+### Installation
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/your-username/autobyteus.git
+    cd autobyteus
+    ```
+
+2.  **For users:**
+    To install Autobyteus and its core dependencies:
+    ```bash
+    pip install .
+    ```
+
+3.  **For developers:**
+    To install Autobyteus with all development and example dependencies (including the TUI):
+    ```bash
+    pip install -r requirements-dev.txt
+    ```
+
+4.  **Set up Environment Variables:**
+    Create a `.env` file in the root of the project and add your LLM provider API keys:
+    ```
+    # .env
+    OPENAI_API_KEY="sk-..."
+    KIMI_API_KEY="your-kimi-api-key"
+    # etc.
+    ```
+
+### Running the Examples
+
+The best way to experience Autobyteus is to run one of the included examples. The event-driven software engineering team is a great showcase of the framework's capabilities.
+
+```bash
+# Run the event-driven software engineering team example
+python autobyteus/examples/agent_team/event_driven/run_software_engineering_team.py --llm-model gpt-4o
+
+# Run the hierarchical debate team example
+python autobyteus/examples/agent_team/manual_notification/run_debate_team.py --llm-model gpt-4-turbo
+```
+You can see all available models and their identifiers by running an example with the `--help-models` flag.
+
+### Building the Library
+
+To build Autobyteus as a distributable package, follow these steps:
+
+1.  Ensure you have the latest version of `setuptools` and `wheel` installed:
+    ```
+    pip install --upgrade setuptools wheel
+    ```
+
+2.  Build the distribution packages:
+    ```
+    python setup.py sdist bdist_wheel
+    ```
+
+This will create a `dist` directory containing the built `sdist` and `wheel` distributions.
+
+## Contributing
+
+(Add guidelines for contributing to the project)
+
+## License
+
+This project is licensed under the MIT License.

{autobyteus-1.1.6 → autobyteus-1.1.8}/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-1.1.8/autobyteus/agent/handlers/tool_result_event_handler.py

@@ -0,0 +1,161 @@
+# file: autobyteus/autobyteus/agent/handlers/tool_result_event_handler.py
+import logging
+import json 
+from typing import TYPE_CHECKING, Optional, List
+
+from autobyteus.agent.handlers.base_event_handler import AgentEventHandler 
+from autobyteus.agent.events import ToolResultEvent, LLMUserMessageReadyEvent 
+from autobyteus.llm.user_message import LLMUserMessage 
+from autobyteus.agent.tool_execution_result_processor import BaseToolExecutionResultProcessor
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext 
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier 
+
+logger = logging.getLogger(__name__)
+
+class ToolResultEventHandler(AgentEventHandler):
+    """
+    Handles ToolResultEvents. It processes and notifies for each individual tool
+    result as it arrives. If a multi-tool call turn is active, it accumulates
+    these results until the turn is complete, re-orders them to match the original
+    invocation sequence, and 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 and ORDERED 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:
+        if not isinstance(event, ToolResultEvent): 
+            logger.warning(f"ToolResultEventHandler received non-ToolResultEvent: {type(event)}. Skipping.")
+            return
+
+        agent_id = context.agent_id
+        notifier: Optional['AgentExternalEventNotifier'] = context.phase_manager.notifier if context.phase_manager else None
+
+        # --- Step 1: Immediately process the incoming event ---
+        processed_event = event
+        processor_instances = context.config.tool_execution_result_processors
+        if processor_instances:
+            for processor_instance in processor_instances:
+                if not isinstance(processor_instance, BaseToolExecutionResultProcessor):
+                    logger.error(f"Agent '{agent_id}': Invalid tool result processor type: {type(processor_instance)}. Skipping.")
+                    continue
+                try:
+                    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_instance.get_name()}': {e}", exc_info=True)
+        
+        # --- 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:
+                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
+
+        # 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
+
+        # 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, re-order them and then dispatch to the LLM.
+        logger.info(f"Agent '{agent_id}': All tool results for the turn collected. Re-ordering to match invocation sequence.")
+        
+        # --- NEW RE-ORDERING LOGIC ---
+        results_by_id = {res.tool_invocation_id: res for res in active_turn.results}
+        sorted_results: List[ToolResultEvent] = []
+        for original_invocation in active_turn.invocations:
+            result = results_by_id.get(original_invocation.id)
+            if result:
+                sorted_results.append(result)
+            else:
+                # This should not happen if the logic is correct, but it's a good safeguard.
+                logger.error(f"Agent '{agent_id}': Missing result for invocation ID '{original_invocation.id}' during re-ordering.")
+                # Add a synthetic error result to maintain sequence length.
+                sorted_results.append(ToolResultEvent(
+                    tool_name=original_invocation.name,
+                    result=None,
+                    error=f"Critical Error: Result for this tool call was lost.",
+                    tool_invocation_id=original_invocation.id
+                ))
+
+        await self._dispatch_aggregated_results_to_llm(sorted_results, context)
+        
+        context.state.active_multi_tool_call_turn = None
+        logger.info(f"Agent '{agent_id}': Multi-tool call turn state has been cleared.")
+

{autobyteus-1.1.6 → autobyteus-1.1.8}/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-1.1.6 → autobyteus-1.1.8}/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-1.1.6 → autobyteus-1.1.8}/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-1.1.6 → autobyteus-1.1.8}/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):