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

examples/run_sqlite_agent.py

@@ -207,15 +207,18 @@ async def main(args: argparse.Namespace):
         # 5. Configure and create the agent.
         try:
             _ = LLMModel[args.llm_model]
-        except KeyError:
-            all_models = sorted(list(LLMModel), key=lambda m: m.name)
-            available_models_list = [f"  - Name: {m.name:<35} Value: {m.value}" for m in all_models]
-            logger.error(
-                f"LLM Model '{args.llm_model}' is not valid.\n"
-                f"You can use either the model name (e.g., 'GPT_4o_API') or its value (e.g., 'gpt-4o').\n\n"
-                f"Available models:\n" +
-                "\n".join(available_models_list)
-            )
+        except (KeyError, ValueError):
+            logger.error(f"LLM Model '{args.llm_model}' is not valid or ambiguous.", file=sys.stderr)
+            try:
+                LLMFactory.ensure_initialized()
+                print("\nAvailable LLM Models (use the 'Identifier' with --llm-model):")
+                all_models = sorted(list(LLMModel), key=lambda m: m.model_identifier)
+                if not all_models:
+                    print("  No models found.")
+                for model in all_models:
+                    print(f"  - Display Name: {model.name:<30} Identifier: {model.model_identifier}")
+            except Exception as e:
+                print(f"Additionally, an error occurred while listing models: {e}", file=sys.stderr)
             sys.exit(1)
 
         logger.info(f"Creating LLM instance for model: {args.llm_model}")
@@ -238,8 +241,7 @@ async def main(args: argparse.Namespace):
             llm_instance=llm_instance,
             system_prompt=system_prompt,
             tools=tools_for_agent,
-            auto_execute_tools=False,
-            use_xml_tool_format=False
+            auto_execute_tools=False
         )
 
         agent = AgentFactory().create_agent(config=sqlite_agent_config)
@@ -257,7 +259,7 @@ async def main(args: argparse.Namespace):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Run the SQLiteAgent interactively.")
-    parser.add_argument("--llm-model", type=str, default="kimi-latest", help=f"The LLM model to use. Call --help-models for list.")
+    parser.add_argument("--llm-model", type=str, default="kimi-latest", help=f"The LLM model identifier to use. Call --help-models for list.")
     parser.add_argument("--help-models", action="store_true", help="Display available LLM models and exit.")
     parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
     parser.add_argument("--agent-log-file", type=str, default="./agent_logs_sqlite.txt", 
@@ -268,12 +270,12 @@ if __name__ == "__main__":
     if "--help-models" in sys.argv:
         try:
             LLMFactory.ensure_initialized() 
-            print("Available LLM Models (you can use either name or value with --llm-model):")
-            all_models = sorted(list(LLMModel), key=lambda m: m.name)
+            print("Available LLM Models (use the 'Identifier' with --llm-model):")
+            all_models = sorted(list(LLMModel), key=lambda m: m.model_identifier)
             if not all_models:
                 print("  No models found.")
             for model in all_models:
-                print(f"  - Name: {model.name:<35} Value: {model.value}")
+                print(f"  - Display Name: {model.name:<30} Identifier: {model.model_identifier}")
         except Exception as e:
             print(f"Error listing models: {e}")
         sys.exit(0)

autobyteus/tools/mcp/call_handlers/__init__.py

@@ -1,16 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/__init__.py
-"""
-This package contains the MCP Call Handlers.
-Each handler is responsible for performing a complete, end-to-end tool call
-for a specific transport protocol (e.g., STDIO, Streamable HTTP).
-"""
-
-from .base_handler import McpCallHandler
-from .stdio_handler import StdioMcpCallHandler
-from .streamable_http_handler import StreamableHttpMcpCallHandler
-
-__all__ = [
-    "McpCallHandler",
-    "StdioMcpCallHandler",
-    "StreamableHttpMcpCallHandler",
-]

autobyteus/tools/mcp/call_handlers/base_handler.py

@@ -1,40 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/base_handler.py
-import logging
-from abc import ABC, abstractmethod
-from typing import Dict, Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig
-
-logger = logging.getLogger(__name__)
-
-class McpCallHandler(ABC):
-    """
-    Abstract base class for a handler that performs a single, end-to-end
-    MCP tool call for a specific transport protocol.
-    """
-
-    @abstractmethod
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Handles a complete MCP tool call, including connection, execution,
-        and disconnection if necessary.
-
-        Args:
-            config: The configuration object for the target MCP server.
-            remote_tool_name: The name of the tool to call on the remote server.
-            arguments: A dictionary of arguments for the tool call.
-
-        Returns:
-            The result returned by the remote tool.
-            
-        Raises:
-            NotImplementedError: If the handler for a specific transport is not implemented.
-            RuntimeError: If the tool call fails for any reason.
-        """
-        pass

autobyteus/tools/mcp/call_handlers/stdio_handler.py

@@ -1,76 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/stdio_handler.py
-import logging
-import asyncio
-from typing import Dict, Any, cast, TYPE_CHECKING
-
-from .base_handler import McpCallHandler
-from mcp import StdioServerParameters, ClientSession
-from mcp.client.stdio import stdio_client
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig, StdioMcpServerConfig
-
-logger = logging.getLogger(__name__)
-
-# A default timeout for STDIO subprocesses to prevent indefinite hangs.
-DEFAULT_STDIO_TIMEOUT = 30  # seconds
-
-class StdioMcpCallHandler(McpCallHandler):
-    """Handles MCP tool calls over a stateless STDIO transport."""
-
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Creates a new subprocess, establishes a session, and executes the
-        requested tool call. It handles 'list_tools' as a special case.
-        Includes a timeout to prevent hanging on unresponsive subprocesses.
-        """
-        logger.debug(f"Handling STDIO call to tool '{remote_tool_name}' on server '{config.server_id}'.")
-        
-        from ..types import StdioMcpServerConfig
-        if not isinstance(config, StdioMcpServerConfig):
-            raise TypeError(f"StdioMcpCallHandler requires a StdioMcpServerConfig, but got {type(config).__name__}.")
-        
-        stdio_config = cast(StdioMcpServerConfig, config)
-
-        mcp_lib_stdio_params = StdioServerParameters(
-            command=stdio_config.command,
-            args=stdio_config.args,
-            env=stdio_config.env,
-            cwd=stdio_config.cwd
-        )
-
-        async def _perform_call():
-            """Inner function to be wrapped by the timeout."""
-            # The stdio_client context manager provides the read/write streams.
-            async with stdio_client(mcp_lib_stdio_params) as (read_stream, write_stream):
-                # The ClientSession is its own context manager that handles initialization.
-                async with ClientSession(read_stream, write_stream) as session:
-                    logger.debug(f"STDIO session established for '{config.server_id}'. Calling tool '{remote_tool_name}'.")
-                    
-                    # The 'list_tools' command is a special method on the session.
-                    if remote_tool_name == "list_tools":
-                        result = await session.list_tools()
-                    else:
-                        result = await session.call_tool(remote_tool_name, arguments)
-                    
-                    logger.debug(f"STDIO call to tool '{remote_tool_name}' on server '{config.server_id}' completed.")
-                    return result
-
-        try:
-            return await asyncio.wait_for(_perform_call(), timeout=DEFAULT_STDIO_TIMEOUT)
-        except asyncio.TimeoutError:
-            error_message = (f"MCP call to '{remote_tool_name}' on server '{config.server_id}' timed out "
-                             f"after {DEFAULT_STDIO_TIMEOUT} seconds. The subprocess may have hung.")
-            logger.error(error_message)
-            raise RuntimeError(error_message) from None
-        except Exception as e:
-            logger.error(
-                f"An error occurred during STDIO tool call to '{remote_tool_name}' on server '{config.server_id}': {e}",
-                exc_info=True
-            )
-            raise RuntimeError(f"Failed to execute MCP tool '{remote_tool_name}' via STDIO on server '{config.server_id}': {e}") from e

autobyteus/tools/mcp/call_handlers/streamable_http_handler.py

@@ -1,55 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/streamable_http_handler.py
-import logging
-from typing import Dict, Any, cast, TYPE_CHECKING
-
-from .base_handler import McpCallHandler
-from mcp import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig, StreamableHttpMcpServerConfig
-
-logger = logging.getLogger(__name__)
-
-class StreamableHttpMcpCallHandler(McpCallHandler):
-    """Handles MCP tool calls over a stateless Streamable HTTP transport."""
-
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Creates a new HTTP connection, establishes a session, and executes the
-        requested tool call. It handles 'list_tools' as a special case.
-        """
-        logger.debug(f"Handling Streamable HTTP call to tool '{remote_tool_name}' on server '{config.server_id}'.")
-        
-        from ..types import StreamableHttpMcpServerConfig
-        if not isinstance(config, StreamableHttpMcpServerConfig):
-            raise TypeError(f"StreamableHttpMcpCallHandler requires a StreamableHttpMcpServerConfig, got {type(config).__name__}.")
-
-        http_config = cast(StreamableHttpMcpServerConfig, config)
-
-        try:
-            # The streamablehttp_client context manager provides the read/write streams.
-            async with streamablehttp_client(http_config.url, headers=http_config.headers) as (read_stream, write_stream):
-                # The ClientSession is its own context manager that handles initialization.
-                async with ClientSession(read_stream, write_stream) as session:
-                    logger.debug(f"Streamable HTTP session established for '{config.server_id}'. Calling tool '{remote_tool_name}'.")
-
-                    # The 'list_tools' command is a special method on the session.
-                    if remote_tool_name == "list_tools":
-                        result = await session.list_tools()
-                    else:
-                        result = await session.call_tool(remote_tool_name, arguments)
-
-                    logger.debug(f"Streamable HTTP call to tool '{remote_tool_name}' on server '{config.server_id}' completed.")
-                    return result
-        except Exception as e:
-            logger.error(
-                f"An error occurred during Streamable HTTP tool call to '{remote_tool_name}' on server '{config.server_id}': {e}",
-                exc_info=True
-            )
-            raise RuntimeError(f"Failed to execute MCP tool '{remote_tool_name}' via Streamable HTTP on server '{config.server_id}': {e}") from e

autobyteus/tools/usage/providers/json_example_provider.py

@@ -1,32 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/json_example_provider.py
-from typing import Optional, Any, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.json_example_formatter_registry import JsonExampleFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class JsonExampleProvider:
-    """Provides a tool usage example as a JSON dictionary for a specific LLM provider."""
-
-    def __init__(self):
-        self._registry = JsonExampleFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> Any:
-        """
-        Generates a JSON dictionary or string for a single tool usage example.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: The LLMProvider for which to format the JSON.
-
-        Returns:
-            A dictionary or string representing the tool usage example.
-        """
-        if llm_provider:
-            formatter = self._registry.get_formatter(llm_provider)
-        else:
-            formatter = self._registry.get_default_formatter()
-
-        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/json_schema_provider.py

@@ -1,35 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/json_schema_provider.py
-from typing import Optional, Dict, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.json_schema_formatter_registry import JsonSchemaFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class JsonSchemaProvider:
-    """
-    Provides the schema for a single tool formatted as a JSON dictionary,
-    tailored to the specific LLM provider's requirements.
-    """
-    def __init__(self):
-        self._registry = JsonSchemaFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> Dict:
-        """
-        Generates a JSON dictionary for a single tool's schema.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: The LLMProvider for which to format the JSON. If None,
-                          a default generic format is used.
-
-        Returns:
-            A dictionary representing the tool schema.
-        """
-        if llm_provider:
-            formatter = self._registry.get_formatter(llm_provider)
-        else:
-            formatter = self._registry.get_default_formatter()
-
-        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/json_tool_usage_parser_provider.py

@@ -1,28 +0,0 @@
-# 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/xml_example_provider.py

@@ -1,28 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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/json_example_formatter_registry.py

@@ -1,51 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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