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

autobyteus/tools/usage/providers/tool_manifest_provider.py

@@ -16,60 +16,87 @@ class ToolManifestProvider:
     """
     Generates a complete tool manifest string, which includes the schema
     and an example for each provided tool. This is suitable for injection
+
     into a system prompt. It uses the central ToolFormattingRegistry to get
     the correct formatters for the specified provider.
     """
-    SCHEMA_HEADER = "## Tool Definition:"
-    EXAMPLE_HEADER = "## Example Usage:"
-    # UPDATED: Changed the header to be more descriptive as requested.
+    # --- XML Specific Headers and Guidelines ---
+    XML_SCHEMA_HEADER = "## Tool Definition:"
+    XML_EXAMPLE_HEADER = "## Tool Usage Examples and Guidelines:"
+    XML_GENERAL_GUIDELINES = (
+        "To use this tool, you must construct an XML block exactly like the examples below. "
+        "Ensure all tags are correctly named and nested. Pay close attention to how arguments, "
+        "especially complex ones like lists and objects, are formatted."
+    )
+    XML_ARRAY_GUIDELINES = (
+        "Formatting Lists/Arrays: For any argument that is a list (an array), you MUST wrap each "
+        "individual value in its own `<item>` tag. Do not use comma-separated strings or JSON-style `[...]` arrays within a single tag.\n\n"
+        "Correct:\n"
+        '<arg name="dependencies">\n'
+        '    <item>task_1</item>\n'
+        '    <item>task_2</item>\n'
+        '</arg>\n\n'
+        "Incorrect:\n"
+        '<arg name="dependencies">[task_1, task_2]</arg>\n'
+        '<arg name="dependencies">task_1, task_2</arg>'
+    )
+    
+    # --- JSON Specific Headers ---
+    JSON_SCHEMA_HEADER = "## Tool Definition:"
     JSON_EXAMPLE_HEADER = "Example: To use this tool, you could provide the following JSON object as a tool call:"
 
+
     def __init__(self):
         self._formatting_registry = ToolFormattingRegistry()
         logger.debug("ToolManifestProvider initialized.")
 
     def provide(self,
                 tool_definitions: List['ToolDefinition'],
-                provider: Optional[LLMProvider] = None) -> str:
+                provider: Optional[LLMProvider] = None,
+                use_xml_tool_format: bool = False) -> str:
         """
         Generates the manifest string for a list of tools.
 
         Args:
             tool_definitions: A list of ToolDefinition objects.
             provider: The LLM provider, for provider-specific formatting.
+            use_xml_tool_format: If True, forces the use of XML formatters.
 
         Returns:
             A single string containing the formatted manifest.
         """
         tool_blocks = []
 
-        # Get the correct formatting pair from the registry using only the provider.
-        formatter_pair = self._formatting_registry.get_formatter_pair(provider)
+        formatter_pair = self._formatting_registry.get_formatter_pair(provider, use_xml_tool_format=use_xml_tool_format)
         schema_formatter = formatter_pair.schema_formatter
         example_formatter = formatter_pair.example_formatter
 
-        # Determine if the chosen formatter is XML-based. This determines the final assembly format.
         is_xml_format = isinstance(schema_formatter, DefaultXmlSchemaFormatter)
 
         for td in tool_definitions:
             try:
                 schema = schema_formatter.provide(td)
-                example = example_formatter.provide(td)
+                example = example_formatter.provide(td) # This is now a pre-formatted string for both XML and JSON
 
                 if schema and example:
                     if is_xml_format:
-                        tool_blocks.append(f"{self.SCHEMA_HEADER}\n{schema}\n\n{self.EXAMPLE_HEADER}\n{example}")
-                    else:  # JSON format
-                        # UPDATED: Removed the redundant {"tool": schema} wrapper.
+                        tool_blocks.append(f"{self.XML_SCHEMA_HEADER}\n{schema}\n\n{self.XML_EXAMPLE_HEADER}\n{example}")
+                    else:
+                        # For JSON, the schema is a dict, but the example is now a pre-formatted string.
                         schema_str = json.dumps(schema, indent=2)
-                        example_str = json.dumps(example, indent=2)
-                        tool_blocks.append(f"{self.SCHEMA_HEADER}\n{schema_str}\n\n{self.JSON_EXAMPLE_HEADER}\n{example_str}")
+                        # FIX: Do NOT call json.dumps() on the 'example' variable, as it is already a string.
+                        tool_blocks.append(f"{self.JSON_SCHEMA_HEADER}\n{schema_str}\n\n{self.JSON_EXAMPLE_HEADER}\n{example}")
                 else:
                     logger.warning(f"Could not generate schema or example for tool '{td.name}' using format {'XML' if is_xml_format else 'JSON'}.")
 
             except Exception as e:
                 logger.error(f"Failed to generate manifest block for tool '{td.name}': {e}", exc_info=True)
         
-        # UPDATED: Unify the return for all formats to provide a consistent structure
-        # without the incorrect '[]' wrapper for JSON.
-        return "\n\n---\n\n".join(tool_blocks)
+        # Assemble the final manifest string
+        manifest_content = "\n\n---\n\n".join(tool_blocks)
+
+        if is_xml_format and manifest_content:
+            # Prepend the general guidelines for XML format
+            return f"{self.XML_GENERAL_GUIDELINES}\n\n{self.XML_ARRAY_GUIDELINES}\n\n---\n\n{manifest_content}"
+        
+        return manifest_content

autobyteus/tools/usage/registries/tool_formatting_registry.py

@@ -36,19 +36,26 @@ class ToolFormattingRegistry(metaclass=SingletonMeta):
         }
         # A default pair for any provider not explicitly listed (defaults to JSON)
         self._default_pair = ToolFormatterPair(DefaultJsonSchemaFormatter(), DefaultJsonExampleFormatter())
+        # A specific pair for the XML override
+        self._xml_override_pair = ToolFormatterPair(DefaultXmlSchemaFormatter(), DefaultXmlExampleFormatter())
         
         logger.info("ToolFormattingRegistry initialized with direct provider-to-formatter mappings.")
 
-    def get_formatter_pair(self, provider: Optional[LLMProvider]) -> ToolFormatterPair:
+    def get_formatter_pair(self, provider: Optional[LLMProvider], use_xml_tool_format: bool = False) -> ToolFormatterPair:
         """
-        Retrieves the appropriate formatting pair for a given provider.
+        Retrieves the appropriate formatting pair for a given provider, honoring the XML override.
 
         Args:
             provider: The LLMProvider enum member.
+            use_xml_tool_format: If True, forces the use of XML formatters.
 
         Returns:
             The corresponding ToolFormatterPair instance.
         """
+        if use_xml_tool_format:
+            logger.debug("XML tool format is forced by configuration. Returning XML formatter pair.")
+            return self._xml_override_pair
+
         if provider and provider in self._pairs:
             pair = self._pairs[provider]
             logger.debug(f"Found specific formatter pair for provider {provider.name}: {pair}")

autobyteus/tools/usage/registries/tool_usage_parser_registry.py

@@ -34,18 +34,25 @@ class ToolUsageParserRegistry(metaclass=SingletonMeta):
         }
         # A default parser for any provider not explicitly listed (defaults to JSON)
         self._default_parser = DefaultJsonToolUsageParser()
+        # A specific parser for the XML override
+        self._xml_override_parser = DefaultXmlToolUsageParser()
         logger.info("ToolUsageParserRegistry initialized with direct provider-to-parser mappings.")
 
-    def get_parser(self, provider: Optional[LLMProvider]) -> BaseToolUsageParser:
+    def get_parser(self, provider: Optional[LLMProvider], use_xml_tool_format: bool = False) -> BaseToolUsageParser:
         """
-        Retrieves the appropriate tool usage parser for a given provider.
+        Retrieves the appropriate tool usage parser for a given provider, honoring the XML override.
 
         Args:
             provider: The LLMProvider enum member.
+            use_xml_tool_format: If True, forces the use of the XML parser.
 
         Returns:
             The corresponding BaseToolUsageParser instance.
         """
+        if use_xml_tool_format:
+            logger.debug("XML tool format is forced by configuration. Returning XML parser.")
+            return self._xml_override_parser
+
         if provider and provider in self._parsers:
             parser = self._parsers[provider]
             logger.debug(f"Found specific tool usage parser for provider {provider.name}: {parser.get_name()}")

autobyteus-1.1.7.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: autobyteus
+Version: 1.1.7
+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.