autobyteus 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

autobyteus/tools/usage/providers/json_tool_usage_parser_provider.py

@@ -0,0 +1,28 @@
+# file: autobyteus/autobyteus/tools/usage/providers/json_tool_usage_parser_provider.py
+from typing import Optional, TYPE_CHECKING
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.registries.json_tool_usage_parser_registry import JsonToolUsageParserRegistry
+
+if TYPE_CHECKING:
+    from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
+
+class JsonToolUsageParserProvider:
+    """Provides a tool usage parser for JSON-based responses, specific to an LLM provider."""
+
+    def __init__(self):
+        self._registry = JsonToolUsageParserRegistry()
+
+    def provide(self, llm_provider: Optional[LLMProvider] = None) -> 'BaseToolUsageParser':
+        """
+        Gets the appropriate parser from the registry.
+
+        Args:
+            llm_provider: The LLMProvider for which to get a parser.
+
+        Returns:
+            An instance of a class derived from BaseToolUsageParser.
+        """
+        if llm_provider:
+            return self._registry.get_parser(llm_provider)
+        return self._registry.get_default_parser()

autobyteus/tools/usage/providers/tool_manifest_provider.py

@@ -0,0 +1,68 @@
+# file: autobyteus/autobyteus/tools/usage/providers/tool_manifest_provider.py
+import logging
+import json
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+logger = logging.getLogger(__name__)
+
+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.
+    """
+    SCHEMA_HEADER = "## Tool Definition:"
+    EXAMPLE_HEADER = "## Example Usage:"
+    JSON_EXAMPLE_HEADER = "To use this tool, you MUST output a JSON object in the following format:"
+
+    def provide(self,
+                tool_definitions: List['ToolDefinition'],
+                use_xml: bool,
+                provider: Optional[str] = None) -> str:
+        """
+        Generates the manifest string for a list of tools.
+
+        Args:
+            tool_definitions: A list of ToolDefinition objects.
+            use_xml: If True, generate in XML format. Otherwise, use JSON.
+            provider: The LLM provider name, for provider-specific formatting.
+
+        Returns:
+            A single string containing the formatted manifest.
+        """
+        tool_blocks = []
+
+        for td in tool_definitions:
+            try:
+                if use_xml:
+                    schema = td.get_usage_xml(provider=provider)
+                    example = td.get_usage_xml_example(provider=provider)
+                    if schema and example:
+                        tool_blocks.append(f"{self.SCHEMA_HEADER}\n{schema}\n\n{self.EXAMPLE_HEADER}\n{example}")
+                    else:
+                        logger.warning(f"Could not generate schema or example for XML tool '{td.name}'.")
+                else:  # JSON format
+                    schema = td.get_usage_json(provider=provider)
+                    example = td.get_usage_json_example(provider=provider)
+                    if schema and example:
+                        # Per user feedback, wrap schema in a 'tool' key.
+                        schema_wrapped = {"tool": schema}
+                        schema_str = json.dumps(schema_wrapped, indent=2)
+                        
+                        # Example is already formatted correctly by the example formatter.
+                        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}")
+                    else:
+                        logger.warning(f"Could not generate schema or example for JSON tool '{td.name}'.")
+
+            except Exception as e:
+                logger.error(f"Failed to generate manifest block for tool '{td.name}': {e}", exc_info=True)
+
+        if use_xml:
+            return "\n\n---\n\n".join(tool_blocks)
+        else: 
+            return "[\n" + ",\n".join(tool_blocks) + "\n]"

autobyteus/tools/usage/providers/xml_example_provider.py

@@ -0,0 +1,28 @@
+# file: autobyteus/autobyteus/tools/usage/providers/xml_example_provider.py
+from typing import Optional, TYPE_CHECKING
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.registries.xml_example_formatter_registry import XmlExampleFormatterRegistry
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class XmlExampleProvider:
+    """Provides a tool usage example formatted as a single XML string."""
+
+    def __init__(self):
+        self._registry = XmlExampleFormatterRegistry()
+
+    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> str:
+        """
+        Generates a single XML string for a tool usage example.
+
+        Args:
+            tool_definition: A ToolDefinition object.
+            llm_provider: Ignored, for API consistency.
+
+        Returns:
+            A string containing the XML tool usage example.
+        """
+        formatter = self._registry.get_formatter(llm_provider)
+        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/xml_schema_provider.py

@@ -0,0 +1,29 @@
+# file: autobyteus/autobyteus/tools/usage/providers/xml_schema_provider.py
+from typing import Optional, TYPE_CHECKING
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.registries.xml_schema_formatter_registry import XmlSchemaFormatterRegistry
+
+if TYPE_CHECKING:
+    from autobyteus.tools.registry import ToolDefinition
+
+class XmlSchemaProvider:
+    """
+    Provides the schema for a single tool formatted as an XML string.
+    """
+    def __init__(self):
+        self._registry = XmlSchemaFormatterRegistry()
+
+    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> str:
+        """
+        Generates an XML string for a single tool's schema.
+
+        Args:
+            tool_definition: A ToolDefinition object.
+            llm_provider: This argument is passed to the registry for API consistency.
+
+        Returns:
+            A string containing the XML tool schema.
+        """
+        formatter = self._registry.get_formatter(llm_provider)
+        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/xml_tool_usage_parser_provider.py

@@ -0,0 +1,26 @@
+# file: autobyteus/autobyteus/tools/usage/providers/xml_tool_usage_parser_provider.py
+from typing import Optional, TYPE_CHECKING
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.registries.xml_tool_usage_parser_registry import XmlToolUsageParserRegistry
+
+if TYPE_CHECKING:
+    from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
+
+class XmlToolUsageParserProvider:
+    """Provides a tool usage parser for XML-based responses."""
+
+    def __init__(self):
+        self._registry = XmlToolUsageParserRegistry()
+
+    def provide(self, llm_provider: Optional[LLMProvider] = None) -> 'BaseToolUsageParser':
+        """
+        Gets the appropriate parser from the registry.
+
+        Args:
+            llm_provider: Ignored, for API consistency.
+
+        Returns:
+            An instance of a class derived from BaseToolUsageParser.
+        """
+        return self._registry.get_parser(llm_provider)

autobyteus/tools/usage/registries/__init__.py

@@ -0,0 +1,20 @@
+# file: autobyteus/autobyteus/tools/usage/registries/__init__.py
+"""
+This package contains registries for schema/example formatters and parsers,
+allowing for easy retrieval of the correct component based on the LLM provider.
+"""
+from .json_schema_formatter_registry import JsonSchemaFormatterRegistry
+from .xml_schema_formatter_registry import XmlSchemaFormatterRegistry
+from .json_example_formatter_registry import JsonExampleFormatterRegistry
+from .xml_example_formatter_registry import XmlExampleFormatterRegistry
+from .xml_tool_usage_parser_registry import XmlToolUsageParserRegistry
+from .json_tool_usage_parser_registry import JsonToolUsageParserRegistry
+
+__all__ = [
+    "JsonSchemaFormatterRegistry",
+    "XmlSchemaFormatterRegistry",
+    "JsonExampleFormatterRegistry",
+    "XmlExampleFormatterRegistry",
+    "XmlToolUsageParserRegistry",
+    "JsonToolUsageParserRegistry",
+]

autobyteus/tools/usage/registries/json_example_formatter_registry.py

@@ -0,0 +1,51 @@
+# file: autobyteus/autobyteus/tools/usage/registries/json_example_formatter_registry.py
+import logging
+from typing import Dict
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.formatters.base_formatter import BaseExampleFormatter
+from autobyteus.tools.usage.formatters.default_json_example_formatter import DefaultJsonExampleFormatter
+from autobyteus.tools.usage.formatters.openai_json_example_formatter import OpenAiJsonExampleFormatter
+from autobyteus.tools.usage.formatters.anthropic_json_example_formatter import AnthropicJsonExampleFormatter
+from autobyteus.tools.usage.formatters.gemini_json_example_formatter import GeminiJsonExampleFormatter
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class JsonExampleFormatterRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving JSON example formatters based on LLM provider."""
+
+    def __init__(self):
+        self._formatters: Dict[LLMProvider, BaseExampleFormatter] = {
+            LLMProvider.OPENAI: OpenAiJsonExampleFormatter(),
+            LLMProvider.MISTRAL: OpenAiJsonExampleFormatter(),
+            LLMProvider.DEEPSEEK: OpenAiJsonExampleFormatter(),
+            LLMProvider.GROK: OpenAiJsonExampleFormatter(),
+            LLMProvider.ANTHROPIC: AnthropicJsonExampleFormatter(),
+            LLMProvider.GEMINI: GeminiJsonExampleFormatter(),
+        }
+        self._default_formatter = DefaultJsonExampleFormatter()
+        logger.info("JsonExampleFormatterRegistry initialized.")
+
+    def get_formatter(self, provider: LLMProvider) -> BaseExampleFormatter:
+        """
+        Retrieves the appropriate example formatter for a given LLM provider.
+
+        Args:
+            provider: The LLMProvider enum member.
+
+        Returns:
+            An instance of a class derived from BaseExampleFormatter.
+        """
+        formatter = self._formatters.get(provider)
+        if formatter:
+            logger.debug(f"Found specific example formatter for provider {provider.name}: {formatter.__class__.__name__}")
+            return formatter
+        
+        logger.debug(f"No specific example formatter for provider {provider.name}. "
+                     f"Returning default: {self._default_formatter.__class__.__name__}")
+        return self._default_formatter
+    
+    def get_default_formatter(self) -> BaseExampleFormatter:
+        """Explicitly returns the default formatter."""
+        return self._default_formatter

autobyteus/tools/usage/registries/json_schema_formatter_registry.py

@@ -0,0 +1,51 @@
+# file: autobyteus/autobyteus/tools/usage/registries/json_schema_formatter_registry.py
+import logging
+from typing import Dict
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.formatters.base_formatter import BaseSchemaFormatter
+from autobyteus.tools.usage.formatters.default_json_schema_formatter import DefaultJsonSchemaFormatter
+from autobyteus.tools.usage.formatters.openai_json_schema_formatter import OpenAiJsonSchemaFormatter
+from autobyteus.tools.usage.formatters.anthropic_json_schema_formatter import AnthropicJsonSchemaFormatter
+from autobyteus.tools.usage.formatters.gemini_json_schema_formatter import GeminiJsonSchemaFormatter
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class JsonSchemaFormatterRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving JSON schema formatters based on LLM provider."""
+
+    def __init__(self):
+        self._formatters: Dict[LLMProvider, BaseSchemaFormatter] = {
+            LLMProvider.OPENAI: OpenAiJsonSchemaFormatter(),
+            LLMProvider.MISTRAL: OpenAiJsonSchemaFormatter(),
+            LLMProvider.DEEPSEEK: OpenAiJsonSchemaFormatter(),
+            LLMProvider.GROK: OpenAiJsonSchemaFormatter(),
+            LLMProvider.ANTHROPIC: AnthropicJsonSchemaFormatter(),
+            LLMProvider.GEMINI: GeminiJsonSchemaFormatter(),
+        }
+        self._default_formatter = DefaultJsonSchemaFormatter()
+        logger.info("JsonSchemaFormatterRegistry initialized.")
+
+    def get_formatter(self, provider: LLMProvider) -> BaseSchemaFormatter:
+        """
+        Retrieves the appropriate schema formatter for a given LLM provider.
+
+        Args:
+            provider: The LLMProvider enum member.
+
+        Returns:
+            An instance of a class derived from BaseSchemaFormatter.
+        """
+        formatter = self._formatters.get(provider)
+        if formatter:
+            logger.debug(f"Found specific schema formatter for provider {provider.name}: {formatter.__class__.__name__}")
+            return formatter
+
+        logger.debug(f"No specific schema formatter for provider {provider.name}. "
+                     f"Returning default: {self._default_formatter.__class__.__name__}")
+        return self._default_formatter
+
+    def get_default_formatter(self) -> BaseSchemaFormatter:
+        """Explicitly returns the default formatter."""
+        return self._default_formatter

autobyteus/tools/usage/registries/json_tool_usage_parser_registry.py

@@ -0,0 +1,42 @@
+# file: autobyteus/autobyteus/tools/usage/registries/json_tool_usage_parser_registry.py
+import logging
+from typing import Dict
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
+from autobyteus.tools.usage.parsers.default_json_tool_usage_parser import DefaultJsonToolUsageParser
+from autobyteus.tools.usage.parsers.openai_json_tool_usage_parser import OpenAiJsonToolUsageParser
+from autobyteus.tools.usage.parsers.gemini_json_tool_usage_parser import GeminiJsonToolUsageParser
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class JsonToolUsageParserRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving JSON-based tool usage parsers."""
+
+    def __init__(self):
+        self._parsers: Dict[LLMProvider, BaseToolUsageParser] = {
+            LLMProvider.OPENAI: OpenAiJsonToolUsageParser(),
+            LLMProvider.MISTRAL: OpenAiJsonToolUsageParser(),
+            LLMProvider.DEEPSEEK: OpenAiJsonToolUsageParser(),
+            LLMProvider.GROK: OpenAiJsonToolUsageParser(),
+            LLMProvider.GEMINI: GeminiJsonToolUsageParser(),
+        }
+        self._default_parser = DefaultJsonToolUsageParser()
+        logger.info("JsonToolUsageParserRegistry initialized.")
+
+    def get_parser(self, provider: LLMProvider) -> BaseToolUsageParser:
+        """
+        Retrieves the appropriate parser for a given LLM provider.
+        """
+        parser = self._parsers.get(provider)
+        if parser:
+            logger.debug(f"Found specific tool usage parser for provider {provider.name}: {parser.get_name()}")
+            return parser
+        
+        logger.debug(f"No specific tool usage parser for provider {provider.name}. Returning default: {self._default_parser.get_name()}")
+        return self._default_parser
+    
+    def get_default_parser(self) -> BaseToolUsageParser:
+        """Explicitly returns the default parser."""
+        return self._default_parser

autobyteus/tools/usage/registries/xml_example_formatter_registry.py

@@ -0,0 +1,30 @@
+# file: autobyteus/autobyteus/tools/usage/registries/xml_example_formatter_registry.py
+import logging
+from typing import Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.formatters.base_formatter import BaseExampleFormatter
+from autobyteus.tools.usage.formatters.default_xml_example_formatter import DefaultXmlExampleFormatter
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class XmlExampleFormatterRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving XML example formatters."""
+
+    def __init__(self):
+        self._default_formatter = DefaultXmlExampleFormatter()
+        logger.info("XmlExampleFormatterRegistry initialized.")
+
+    def get_formatter(self, provider: Optional[LLMProvider] = None) -> BaseExampleFormatter:
+        """
+        Retrieves the appropriate XML example formatter.
+
+        Args:
+            provider: The LLMProvider enum member. This is currently ignored
+                      but is kept for API consistency and future expansion.
+
+        Returns:
+            An instance of the DefaultXmlExampleFormatter.
+        """
+        return self._default_formatter

autobyteus/tools/usage/registries/xml_schema_formatter_registry.py

@@ -0,0 +1,33 @@
+# file: autobyteus/autobyteus/tools/usage/registries/xml_schema_formatter_registry.py
+import logging
+from typing import Dict, Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.formatters.base_formatter import BaseSchemaFormatter
+from autobyteus.tools.usage.formatters.default_xml_schema_formatter import DefaultXmlSchemaFormatter
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class XmlSchemaFormatterRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving XML schema formatters based on LLM provider."""
+
+    def __init__(self):
+        # Currently, there is only one XML format, so all providers map to it.
+        # This structure allows for future expansion if providers diverge.
+        self._default_formatter = DefaultXmlSchemaFormatter()
+        logger.info("XmlSchemaFormatterRegistry initialized.")
+
+    def get_formatter(self, provider: Optional[LLMProvider] = None) -> BaseSchemaFormatter:
+        """
+        Retrieves the appropriate XML schema formatter.
+
+        Args:
+            provider: The LLMProvider enum member. This is currently ignored
+                      but is kept for API consistency and future expansion.
+
+        Returns:
+            An instance of the DefaultXmlSchemaFormatter.
+        """
+        # For now, we only have one XML formatter. This always returns it.
+        return self._default_formatter

autobyteus/tools/usage/registries/xml_tool_usage_parser_registry.py

@@ -0,0 +1,30 @@
+# file: autobyteus/autobyteus/tools/usage/registries/xml_tool_usage_parser_registry.py
+import logging
+from typing import Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
+from autobyteus.tools.usage.parsers.default_xml_tool_usage_parser import DefaultXmlToolUsageParser
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class XmlToolUsageParserRegistry(metaclass=SingletonMeta):
+    """A singleton registry for retrieving XML-based tool usage parsers."""
+
+    def __init__(self):
+        self._default_parser = DefaultXmlToolUsageParser()
+        logger.info("XmlToolUsageParserRegistry initialized.")
+
+    def get_parser(self, provider: Optional[LLMProvider] = None) -> BaseToolUsageParser:
+        """
+        Retrieves the appropriate XML parser.
+
+        Args:
+            provider: The LLMProvider enum member. Currently ignored but kept for API consistency.
+
+        Returns:
+            An instance of a class derived from BaseToolUsageParser.
+        """
+        # For now, there's only one XML format, so always return the default.
+        return self._default_parser

{autobyteus-1.0.6.dist-info → autobyteus-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.0.6
+Version: 1.1.1
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -25,10 +25,12 @@ Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: anthropic==0.37.1
 Requires-Dist: Jinja2
-Requires-Dist: ollama==0.4.5
+Requires-Dist: ollama
 Requires-Dist: mistral_common
+Requires-Dist: certifi==2025.4.26
+Requires-Dist: numpy==2.2.5
 Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.1.0
+Requires-Dist: autobyteus-llm-client==1.1.1
 Requires-Dist: brui-core==1.0.8
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
@@ -64,7 +66,19 @@ Dynamic: summary
 
 # Autobyteus
 
-Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
+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.
+
+## 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.
+-   **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 extension points to inject custom logic. `InputProcessors` and `LLMResponseProcessors` modify data in the main processing pipeline, while `PhaseHooks` allow custom code to run on specific agent lifecycle transitions (e.g., from `BOOTSTRAPPING` to `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.
 
 ## Features
 
@@ -74,7 +88,11 @@ Autobyteus is an open-source coding assistance tool designed to enhance the soft
 
 ## Knowledge Base
 
-A significant part of Autobytus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+A significant part of Autobyteus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+
+## 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