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

autobyteus/tools/usage/parsers/gemini_json_tool_usage_parser.py

@@ -1,7 +1,7 @@
 # file: autobyteus/autobyteus/tools/usage/parsers/gemini_json_tool_usage_parser.py
 import json
 import logging
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Dict
 
 from autobyteus.agent.tool_invocation import ToolInvocation
 from .base_parser import BaseToolUsageParser
@@ -17,7 +17,8 @@ class GeminiJsonToolUsageParser(BaseToolUsageParser):
     """
     Parses LLM responses for tool usage commands formatted in the Google Gemini style.
     It expects a JSON object with "name" and "args" keys. It robustly extracts
-    all potential JSON objects from the response.
+    all potential JSON objects from the response and can handle both a single
+    tool call object or a list of tool call objects.
     """
     def get_name(self) -> str:
         return "gemini_json_tool_usage_parser"
@@ -32,11 +33,26 @@ class GeminiJsonToolUsageParser(BaseToolUsageParser):
         for blob in json_blobs:
             try:
                 data = json.loads(blob)
+                
+                tool_call_list: List[Dict] = []
+                if isinstance(data, list):
+                    # The blob is a list of tool calls, e.g., [{"name": ..., "args": ...}]
+                    tool_call_list = data
+                elif isinstance(data, dict) and "name" in data and "args" in data:
+                    # The blob is a single tool call object, e.g., {"name": ..., "args": ...}
+                    tool_call_list = [data]
+                else:
+                    # Not a recognized format, skip this blob.
+                    logger.debug(f"JSON blob is not in a recognized Gemini tool call format: {blob[:200]}")
+                    continue
 
-                # This parser specifically looks for the {"name": ..., "args": ...} structure.
-                if isinstance(data, dict) and "name" in data and "args" in data:
-                    tool_name = data.get("name")
-                    arguments = data.get("args")
+                for call_data in tool_call_list:
+                    if not (isinstance(call_data, dict) and "name" in call_data and "args" in call_data):
+                        logger.debug(f"Skipping malformed item in Gemini tool call list: {call_data}")
+                        continue
+                    
+                    tool_name = call_data.get("name")
+                    arguments = call_data.get("args")
 
                     if tool_name and isinstance(tool_name, str) and isinstance(arguments, dict):
                         # Pass id=None to trigger deterministic ID generation in ToolInvocation
@@ -44,7 +60,7 @@ class GeminiJsonToolUsageParser(BaseToolUsageParser):
                         invocations.append(tool_invocation)
                         logger.info(f"Successfully parsed Gemini JSON tool invocation for '{tool_name}'.")
                     else:
-                        logger.debug(f"Skipping malformed Gemini tool call data: {data}")
+                        logger.debug(f"Skipping malformed Gemini tool call data: {call_data}")
 
             except json.JSONDecodeError:
                 logger.debug(f"Could not parse extracted text as JSON in {self.get_name()}. Blob: {blob[:200]}")

autobyteus/tools/usage/parsers/provider_aware_tool_usage_parser.py

@@ -1,34 +1,34 @@
 # file: autobyteus/autobyteus/tools/usage/parsers/provider_aware_tool_usage_parser.py
 import logging
-from typing import TYPE_CHECKING, Optional, List
+from typing import TYPE_CHECKING, List
 
 from .exceptions import ToolUsageParseException
 
+# The import of ToolUsageParserRegistry is deferred to break the circular dependency.
+# It is imported at the top level only for static type analysis.
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
     from autobyteus.llm.utils.response_types import CompleteResponse
     from autobyteus.agent.tool_invocation import ToolInvocation
-    from autobyteus.tools.usage.providers import XmlToolUsageParserProvider, JsonToolUsageParserProvider
+    from autobyteus.tools.usage.registries.tool_usage_parser_registry import ToolUsageParserRegistry
 
 logger = logging.getLogger(__name__)
 
 class ProviderAwareToolUsageParser:
     """
     A high-level orchestrator that selects and uses the correct tool usage parser
-    (e.g., for XML, OpenAI JSON, Gemini JSON) based on the agent's configuration.
-    
-    This class encapsulates the logic for choosing a parser, making it easy for
-    other components to simply request a parse without knowing the underlying details.
+    based on the agent's LLM provider by consulting the central ToolUsageParserRegistry.
     """
     def __init__(self):
-        self._xml_parser_provider: Optional['XmlToolUsageParserProvider'] = None
-        self._json_parser_provider: Optional['JsonToolUsageParserProvider'] = None
+        # Local import to break the circular dependency at module load time.
+        from autobyteus.tools.usage.registries.tool_usage_parser_registry import ToolUsageParserRegistry
+        self._parser_registry: 'ToolUsageParserRegistry' = ToolUsageParserRegistry()
         logger.debug("ProviderAwareToolUsageParser initialized.")
 
     def parse(self, response: 'CompleteResponse', context: 'AgentContext') -> List['ToolInvocation']:
         """
-        Selects the correct underlying parser, parses the response, and returns
-        a list of tool invocations.
+        Selects the correct underlying parser from the registry, parses the response,
+        and returns a list of tool invocations.
 
         Args:
             response: The CompleteResponse object from the LLM.
@@ -38,27 +38,16 @@ class ProviderAwareToolUsageParser:
             A list of ToolInvocation objects. Returns an empty list if no
             valid tool calls are found.
         """
-        from autobyteus.tools.usage.providers import XmlToolUsageParserProvider, JsonToolUsageParserProvider
-
         llm_provider = None
         if context.llm_instance and context.llm_instance.model:
             llm_provider = context.llm_instance.model.provider
         else:
             logger.warning(f"Agent '{context.agent_id}': LLM instance or model not available. Cannot determine provider for tool response parsing.")
         
-        if context.config.use_xml_tool_format:
-            if self._xml_parser_provider is None:
-                self._xml_parser_provider = XmlToolUsageParserProvider()
-            parser_provider = self._xml_parser_provider
-            format_name = "XML"
-        else:
-            if self._json_parser_provider is None:
-                self._json_parser_provider = JsonToolUsageParserProvider()
-            parser_provider = self._json_parser_provider
-            format_name = "JSON"
-
-        parser = parser_provider.provide(llm_provider)
-        logger.debug(f"ProviderAwareToolUsageParser selected delegate parser '{parser.get_name()}' for format '{format_name}' and LLM provider '{llm_provider.name if llm_provider else 'Unknown'}'.")
+        # Get the correct parser directly from the new central registry.
+        parser = self._parser_registry.get_parser(llm_provider)
+        
+        logger.debug(f"ProviderAwareToolUsageParser selected delegate parser '{parser.get_name()}' for LLM provider '{llm_provider.name if llm_provider else 'Unknown'}'.")
 
         try:
             return parser.parse(response)

autobyteus/tools/usage/providers/__init__.py

@@ -3,20 +3,10 @@
 This package contains providers that orchestrate the generation of
 tool usage information and the parsing of tool usage responses.
 """
-from .xml_schema_provider import XmlSchemaProvider
-from .json_schema_provider import JsonSchemaProvider
-from .xml_example_provider import XmlExampleProvider
-from .json_example_provider import JsonExampleProvider
-from .xml_tool_usage_parser_provider import XmlToolUsageParserProvider
-from .json_tool_usage_parser_provider import JsonToolUsageParserProvider
+# The individual parser providers have been removed in favor of a consolidated registry.
+# We only need to export the main manifest provider.
 from .tool_manifest_provider import ToolManifestProvider
 
 __all__ = [
-    "XmlSchemaProvider",
-    "JsonSchemaProvider",
-    "XmlExampleProvider",
-    "JsonExampleProvider",
-    "XmlToolUsageParserProvider",
-    "JsonToolUsageParserProvider",
     "ToolManifestProvider",
 ]

autobyteus/tools/usage/providers/tool_manifest_provider.py

@@ -3,6 +3,10 @@ import logging
 import json
 from typing import TYPE_CHECKING, List, Optional
 
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.tools.usage.registries.tool_formatting_registry import ToolFormattingRegistry
+from autobyteus.tools.usage.formatters import DefaultXmlSchemaFormatter
+
 if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
 
@@ -12,57 +16,60 @@ 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.
+    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:"
-    JSON_EXAMPLE_HEADER = "To use this tool, you MUST output a JSON object in the following format:"
+    # UPDATED: Changed the header to be more descriptive as requested.
+    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'],
-                use_xml: bool,
-                provider: Optional[str] = None) -> str:
+                provider: Optional[LLMProvider] = 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.
+            provider: The LLM provider, for provider-specific formatting.
 
         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)
+        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:
-                if use_xml:
-                    schema = td.get_usage_xml(provider=provider)
-                    example = td.get_usage_xml_example(provider=provider)
-                    if schema and example:
+                schema = schema_formatter.provide(td)
+                example = example_formatter.provide(td)
+
+                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:
-                        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.
+                    else:  # JSON format
+                        # UPDATED: Removed the redundant {"tool": schema} wrapper.
+                        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}")
-                    else:
-                        logger.warning(f"Could not generate schema or example for JSON tool '{td.name}'.")
+                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)
-
-        if use_xml:
-            return "\n\n---\n\n".join(tool_blocks)
-        else: 
-            return "[\n" + ",\n".join(tool_blocks) + "\n]"
+        
+        # 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)

autobyteus/tools/usage/registries/__init__.py

@@ -3,18 +3,13 @@
 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
+# Import the new consolidated components
+from .tool_formatter_pair import ToolFormatterPair
+from .tool_formatting_registry import ToolFormattingRegistry
+from .tool_usage_parser_registry import ToolUsageParserRegistry
 
 __all__ = [
-    "JsonSchemaFormatterRegistry",
-    "XmlSchemaFormatterRegistry",
-    "JsonExampleFormatterRegistry",
-    "XmlExampleFormatterRegistry",
-    "XmlToolUsageParserRegistry",
-    "JsonToolUsageParserRegistry",
+    "ToolFormatterPair",
+    "ToolFormattingRegistry",
+    "ToolUsageParserRegistry",
 ]

autobyteus/tools/usage/registries/tool_formatter_pair.py

@@ -0,0 +1,15 @@
+# file: autobyteus/autobyteus/tools/usage/registries/tool_formatter_pair.py
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.usage.formatters import BaseSchemaFormatter, BaseExampleFormatter
+
+@dataclass(frozen=True)
+class ToolFormatterPair:
+    """
+    A container that pairs a tool's schema formatter with its corresponding example formatter.
+    This provides a complete set of formatters for a given provider's tool usage style.
+    """
+    schema_formatter: 'BaseSchemaFormatter'
+    example_formatter: 'BaseExampleFormatter'

autobyteus/tools/usage/registries/tool_formatting_registry.py

@@ -0,0 +1,58 @@
+# file: autobyteus/autobyteus/tools/usage/registries/tool_formatting_registry.py
+import logging
+from typing import Dict, Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.utils.singleton import SingletonMeta
+from .tool_formatter_pair import ToolFormatterPair
+
+# Import all necessary formatters
+from autobyteus.tools.usage.formatters import (
+    DefaultJsonSchemaFormatter, OpenAiJsonSchemaFormatter, AnthropicJsonSchemaFormatter, GeminiJsonSchemaFormatter,
+    DefaultJsonExampleFormatter, OpenAiJsonExampleFormatter, AnthropicJsonExampleFormatter, GeminiJsonExampleFormatter,
+    DefaultXmlSchemaFormatter, DefaultXmlExampleFormatter
+)
+
+logger = logging.getLogger(__name__)
+
+class ToolFormattingRegistry(metaclass=SingletonMeta):
+    """
+    A consolidated registry that maps an LLMProvider directly to its required
+    ToolFormatterPair, which contains both schema and example formatters.
+    """
+
+    def __init__(self):
+        # A single, direct mapping from provider to its correct formatter pair.
+        self._pairs: Dict[LLMProvider, ToolFormatterPair] = {
+            # JSON-based providers
+            LLMProvider.OPENAI: ToolFormatterPair(OpenAiJsonSchemaFormatter(), OpenAiJsonExampleFormatter()),
+            LLMProvider.MISTRAL: ToolFormatterPair(OpenAiJsonSchemaFormatter(), OpenAiJsonExampleFormatter()),
+            LLMProvider.DEEPSEEK: ToolFormatterPair(OpenAiJsonSchemaFormatter(), OpenAiJsonExampleFormatter()),
+            LLMProvider.GROK: ToolFormatterPair(OpenAiJsonSchemaFormatter(), OpenAiJsonExampleFormatter()),
+            LLMProvider.GEMINI: ToolFormatterPair(GeminiJsonSchemaFormatter(), GeminiJsonExampleFormatter()),
+            
+            # XML-based providers
+            LLMProvider.ANTHROPIC: ToolFormatterPair(DefaultXmlSchemaFormatter(), DefaultXmlExampleFormatter()),
+        }
+        # A default pair for any provider not explicitly listed (defaults to JSON)
+        self._default_pair = ToolFormatterPair(DefaultJsonSchemaFormatter(), DefaultJsonExampleFormatter())
+        
+        logger.info("ToolFormattingRegistry initialized with direct provider-to-formatter mappings.")
+
+    def get_formatter_pair(self, provider: Optional[LLMProvider]) -> ToolFormatterPair:
+        """
+        Retrieves the appropriate formatting pair for a given provider.
+
+        Args:
+            provider: The LLMProvider enum member.
+
+        Returns:
+            The corresponding ToolFormatterPair instance.
+        """
+        if provider and provider in self._pairs:
+            pair = self._pairs[provider]
+            logger.debug(f"Found specific formatter pair for provider {provider.name}: {pair}")
+            return pair
+        
+        logger.debug(f"No specific formatter pair for provider {provider.name if provider else 'Unknown'}. Returning default pair.")
+        return self._default_pair

autobyteus/tools/usage/registries/tool_usage_parser_registry.py

@@ -0,0 +1,55 @@
+# file: autobyteus/autobyteus/tools/usage/registries/tool_usage_parser_registry.py
+import logging
+from typing import Dict, Optional
+
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.tools.usage.parsers import (
+    BaseToolUsageParser,
+    DefaultJsonToolUsageParser,
+    OpenAiJsonToolUsageParser,
+    GeminiJsonToolUsageParser,
+    DefaultXmlToolUsageParser
+)
+
+logger = logging.getLogger(__name__)
+
+class ToolUsageParserRegistry(metaclass=SingletonMeta):
+    """
+    A consolidated registry that maps an LLMProvider directly to its required
+    tool usage parser, encapsulating the logic of which provider uses which format.
+    """
+
+    def __init__(self):
+        self._parsers: Dict[LLMProvider, BaseToolUsageParser] = {
+            # JSON-based providers
+            LLMProvider.OPENAI: OpenAiJsonToolUsageParser(),
+            LLMProvider.MISTRAL: OpenAiJsonToolUsageParser(),
+            LLMProvider.DEEPSEEK: OpenAiJsonToolUsageParser(),
+            LLMProvider.GROK: OpenAiJsonToolUsageParser(),
+            LLMProvider.GEMINI: GeminiJsonToolUsageParser(),
+            
+            # XML-based providers
+            LLMProvider.ANTHROPIC: DefaultXmlToolUsageParser(),
+        }
+        # A default parser for any provider not explicitly listed (defaults to JSON)
+        self._default_parser = DefaultJsonToolUsageParser()
+        logger.info("ToolUsageParserRegistry initialized with direct provider-to-parser mappings.")
+
+    def get_parser(self, provider: Optional[LLMProvider]) -> BaseToolUsageParser:
+        """
+        Retrieves the appropriate tool usage parser for a given provider.
+
+        Args:
+            provider: The LLMProvider enum member.
+
+        Returns:
+            The corresponding BaseToolUsageParser instance.
+        """
+        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()}")
+            return parser
+        
+        logger.debug(f"No specific tool usage parser for provider {provider.name if provider else 'Unknown'}. Returning default parser.")
+        return self._default_parser

{autobyteus-1.1.4.dist-info → autobyteus-1.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.4
+Version: 1.1.5
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -16,11 +16,11 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: anthropic==0.37.1
-Requires-Dist: autobyteus-llm-client==1.1.1
+Requires-Dist: autobyteus-llm-client==1.1.2
 Requires-Dist: beautifulsoup4>=4.12.2
 Requires-Dist: boto3
 Requires-Dist: botocore
-Requires-Dist: brui-core==1.0.8
+Requires-Dist: brui-core==1.0.9
 Requires-Dist: certifi==2025.4.26
 Requires-Dist: google-api-python-client
 Requires-Dist: google-generativeai