autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/tools/usage/parsers/default_xml_tool_usage_parser.py

@@ -1,316 +0,0 @@
-import logging
-import re
-import html
-from typing import TYPE_CHECKING, Dict, Any, List
-from dataclasses import dataclass, field
-
-from autobyteus.agent.tool_invocation import ToolInvocation
-from .base_parser import BaseToolUsageParser
-
-if TYPE_CHECKING:
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-# A unique UUID to use as an internal key for storing text content.
-# This prevents any potential collision with user-provided argument names.
-_INTERNAL_TEXT_KEY_UUID = "4e1a3b1e-3b2a-4d3c-9a8b-2a1c2b3d4e5f"
-
-# --- Internal Arguments Parser with State Machine ---
-# This entire section is now encapsulated in its own class for clarity.
-
-class _XmlArgumentsParser:
-    """
-    A dedicated parser for the XML content within an <arguments> tag.
-    It encapsulates the state machine and all related logic, separating it
-    from the higher-level tool-finding logic.
-    """
-    
-    # --- Nested State Machine Components ---
-
-    @dataclass
-    class _ParsingContext:
-        """Holds the shared state for the parsing process."""
-        parser: '_XmlArgumentsParser'
-        input_string: str
-        cursor: int = 0
-        stack: List[Any] = field(default_factory=list)
-        content_buffer: str = ""
-
-        def __post_init__(self):
-            self.stack.append({}) # Root of arguments is a dictionary
-
-        def is_eof(self) -> bool:
-            return self.cursor >= len(self.input_string)
-
-        def append_to_buffer(self, text: str):
-            self.content_buffer += text
-        
-        def commit_content_buffer(self):
-            if self.content_buffer:
-                self.parser._commit_content(self.stack, self.content_buffer)
-                self.content_buffer = ""
-
-    class _ParserState:
-        """Abstract base class for a state in our parser's state machine."""
-        def handle(self, context: '_XmlArgumentsParser._ParsingContext') -> '_XmlArgumentsParser._ParserState':
-            raise NotImplementedError
-
-    class _ParsingContentState(_ParserState):
-        """Handles accumulation of character data between tags."""
-        def handle(self, context: '_XmlArgumentsParser._ParsingContext') -> '_XmlArgumentsParser._ParserState':
-            if context.is_eof():
-                return None
-            
-            next_tag_start = context.input_string.find('<', context.cursor)
-
-            if next_tag_start == -1:
-                context.append_to_buffer(context.input_string[context.cursor:])
-                context.cursor = len(context.input_string)
-                return self
-            
-            is_valid_tag = False
-            if next_tag_start + 1 < len(context.input_string):
-                next_char = context.input_string[next_tag_start + 1]
-                if next_char.isalpha() or next_char == '/':
-                    is_valid_tag = True
-            
-            if is_valid_tag:
-                content_before_tag = context.input_string[context.cursor:next_tag_start]
-                context.append_to_buffer(content_before_tag)
-                context.commit_content_buffer()
-                context.cursor = next_tag_start
-                return self.parser._ParsingTagState(self.parser)
-            else:
-                content_with_char = context.input_string[context.cursor : next_tag_start + 1]
-                context.append_to_buffer(content_with_char)
-                context.cursor = next_tag_start + 1
-                return self
-
-        def __init__(self, parser: '_XmlArgumentsParser'):
-            self.parser = parser
-
-    class _ParsingTagState(_ParserState):
-        """Handles parsing of a tag, from '<' to '>'."""
-        def handle(self, context: '_XmlArgumentsParser._ParsingContext') -> '_XmlArgumentsParser._ParserState':
-            tag_content_end = context.input_string.find('>', context.cursor)
-            if tag_content_end == -1:
-                context.append_to_buffer(context.input_string[context.cursor:])
-                context.cursor = len(context.input_string)
-                return self.parser._ParsingContentState(self.parser)
-
-            tag_content = context.input_string[context.cursor + 1 : tag_content_end]
-            context.parser.process_tag(tag_content, context)
-            
-            context.cursor = tag_content_end + 1
-            return self.parser._ParsingContentState(self.parser)
-
-        def __init__(self, parser: '_XmlArgumentsParser'):
-            self.parser = parser
-
-    # --- Parser Implementation ---
-    
-    def __init__(self, xml_string: str):
-        self.xml_string = xml_string
-
-    def parse(self) -> Dict[str, Any]:
-        """Drives the state machine to parse the XML string."""
-        context = self._ParsingContext(parser=self, input_string=self.xml_string)
-        state = self._ParsingContentState(self)
-
-        while state and not context.is_eof():
-            state = state.handle(context)
-        
-        context.commit_content_buffer()
-        
-        final_args = context.stack[0]
-        self._cleanup_internal_keys(final_args)
-        final_args = self._decode_entities_inplace(final_args)
-        return final_args
-
-    def process_tag(self, tag_content: str, context: '_ParsingContext'):
-        STRUCTURAL_TAGS = {'arg', 'item'}
-        stripped_content = tag_content.strip()
-        if not stripped_content:
-            context.append_to_buffer(f"<{tag_content}>")
-            return
-
-        is_closing = stripped_content.startswith('/')
-        tag_name = (stripped_content[1:] if is_closing else stripped_content).split(' ')[0]
-
-        if tag_name in STRUCTURAL_TAGS:
-            if is_closing:
-                self._handle_closing_tag(context.stack)
-            else:
-                self._handle_opening_tag(context.stack, tag_content)
-        else:
-            context.append_to_buffer(f"<{tag_content}>")
-    
-    def _commit_content(self, stack: List[Any], content: str):
-        trimmed_content = content.strip()
-        if not trimmed_content and '<' not in content and '>' not in content:
-            return
-
-        top = stack[-1]
-        if isinstance(top, dict):
-            top[_INTERNAL_TEXT_KEY_UUID] = top.get(_INTERNAL_TEXT_KEY_UUID, '') + content
-
-    def _handle_opening_tag(self, stack: List[Any], tag_content: str):
-        parent = stack[-1]
-        
-        if tag_content.strip().startswith('arg'):
-            name_match = re.search(r'name="([^"]+)"', tag_content)
-            if name_match and isinstance(parent, dict):
-                arg_name = name_match.group(1)
-                new_container = {}
-                parent[arg_name] = new_container
-                stack.append(new_container)
-        
-        elif tag_content.strip().startswith('item'):
-            if isinstance(parent, dict):
-                grandparent = stack[-2]
-                parent_key = next((k for k, v in grandparent.items() if v is parent), None)
-                if parent_key:
-                    new_list = []
-                    grandparent[parent_key] = new_list
-                    stack[-1] = new_list
-                    parent = new_list
-            
-            if isinstance(parent, list):
-                new_item_container = {}
-                parent.append(new_item_container)
-                stack.append(new_item_container)
-
-    def _handle_closing_tag(self, stack: List[Any]):
-        if len(stack) > 1:
-            top = stack.pop()
-            parent = stack[-1]
-
-            is_primitive = False
-            if isinstance(top, dict):
-                keys = top.keys()
-                if not keys or (len(keys) == 1 and _INTERNAL_TEXT_KEY_UUID in keys):
-                    is_primitive = True
-
-            if is_primitive:
-                value = top.get(_INTERNAL_TEXT_KEY_UUID, '')
-                if isinstance(parent, list):
-                    try:
-                        idx = parent.index(top)
-                        parent[idx] = value
-                    except ValueError:
-                        logger.warning("Could not find item to collapse in parent list.")
-                elif isinstance(parent, dict):
-                    parent_key = next((k for k, v in parent.items() if v is top), None)
-                    if parent_key:
-                        parent[parent_key] = value
-
-    def _cleanup_internal_keys(self, data: Any):
-        if isinstance(data, dict):
-            if _INTERNAL_TEXT_KEY_UUID in data and len(data) > 1:
-                del data[_INTERNAL_TEXT_KEY_UUID]
-            for value in data.values():
-                self._cleanup_internal_keys(value)
-        elif isinstance(data, list):
-            for item in data:
-                self._cleanup_internal_keys(item)
-
-    def _decode_entities_inplace(self, data: Any):
-        if isinstance(data, dict):
-            for key, value in list(data.items()):
-                data[key] = self._decode_entities_inplace(value)
-            return data
-        if isinstance(data, list):
-            for index, item in enumerate(data):
-                data[index] = self._decode_entities_inplace(item)
-            return data
-        if isinstance(data, str):
-            return html.unescape(data)
-        return data
-
-
-# --- Main Parser Class ---
-
-class DefaultXmlToolUsageParser(BaseToolUsageParser):
-    """
-    Parses LLM responses for tool usage commands formatted as XML.
-    This class is responsible for finding <tool> blocks and delegating the
-    parsing of their arguments to the specialized _XmlArgumentsParser.
-    """
-
-    def get_name(self) -> str:
-        return "default_xml_tool_usage_parser"
-
-    def parse(self, response: 'CompleteResponse') -> List[ToolInvocation]:
-        text = response.content
-        invocations: List[ToolInvocation] = []
-        i = 0
-
-        while i < len(text):
-            try:
-                i = text.index('<tool', i)
-            except ValueError:
-                break
-
-            open_tag_end = text.find('>', i)
-            if open_tag_end == -1: break
-
-            open_tag_content = text[i:open_tag_end+1]
-            name_match = re.search(r'name="([^"]+)"', open_tag_content)
-            if not name_match:
-                i = open_tag_end + 1
-                continue
-            
-            tool_name = name_match.group(1)
-            logger.debug(f"--- Found tool '{tool_name}' at index {i} ---")
-
-            cursor = open_tag_end + 1
-            nesting_level = 1
-            content_end = -1
-            
-            while cursor < len(text):
-                next_open = text.find('<tool', cursor)
-                next_close = text.find('</tool>', cursor)
-
-                if next_close == -1: break
-
-                if next_open != -1 and next_open < next_close:
-                    nesting_level += 1
-                    end_of_nested_open = text.find('>', next_open)
-                    if end_of_nested_open == -1: break
-                    cursor = end_of_nested_open + 1
-                else:
-                    nesting_level -= 1
-                    if nesting_level == 0:
-                        content_end = next_close
-                        break
-                    cursor = next_close + len('</tool>')
-            
-            if content_end == -1:
-                logger.warning(f"Malformed XML for tool '{tool_name}': could not find matching </tool> tag.")
-                i = open_tag_end + 1
-                continue
-
-            tool_content = text[open_tag_end+1:content_end]
-            args_match = re.search(r'<arguments>(.*)</arguments>', tool_content, re.DOTALL)
-            
-            arguments = {}
-            if args_match:
-                arguments_xml = args_match.group(1)
-                try:
-                    # Delegate parsing to the specialized class
-                    arguments = self._parse_arguments(arguments_xml)
-                except Exception as e:
-                    logger.error(f"Arguments parser failed for tool '{tool_name}': {e}", exc_info=True)
-            
-            invocations.append(ToolInvocation(name=tool_name, arguments=arguments))
-            i = content_end + len('</tool>')
-        
-        return invocations
-
-    def _parse_arguments(self, xml_string: str) -> Dict[str, Any]:
-        """
-        Delegates parsing of an arguments XML string to the dedicated parser class.
-        """
-        parser = _XmlArgumentsParser(xml_string)
-        return parser.parse()

autobyteus/tools/usage/parsers/exceptions.py

@@ -1,13 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/exceptions.py
-"""
-Custom exceptions for the tool usage parsing module.
-"""
-
-class ToolUsageParseException(Exception):
-    """
-    Raised when a tool usage parser fails to parse an LLM response due to
-    malformed content or other parsing errors.
-    """
-    def __init__(self, message: str, original_exception: Exception = None):
-        super().__init__(message)
-        self.original_exception = original_exception

autobyteus/tools/usage/parsers/gemini_json_tool_usage_parser.py

@@ -1,77 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/gemini_json_tool_usage_parser.py
-import json
-import logging
-from typing import TYPE_CHECKING, List, Dict
-
-from autobyteus.agent.tool_invocation import ToolInvocation
-from .base_parser import BaseToolUsageParser
-from .exceptions import ToolUsageParseException
-from ._json_extractor import _find_json_blobs
-from ._string_decoders import decode_html_entities
-
-if TYPE_CHECKING:
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-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 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"
-
-    def parse(self, response: 'CompleteResponse') -> List[ToolInvocation]:
-        response_text = response.content
-        json_blobs = _find_json_blobs(response_text)
-        if not json_blobs:
-            return []
-
-        invocations: List[ToolInvocation] = []
-        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
-
-                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):
-                        decoded_tool_name = decode_html_entities(tool_name)
-                        decoded_arguments = decode_html_entities(arguments)
-                        # Pass id=None to trigger deterministic ID generation in ToolInvocation
-                        tool_invocation = ToolInvocation(name=decoded_tool_name, arguments=decoded_arguments)
-                        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: {call_data}")
-
-            except json.JSONDecodeError:
-                logger.debug(f"Could not parse extracted text as JSON in {self.get_name()}. Blob: {blob[:200]}")
-                # Not a tool call, ignore.
-                continue
-            except Exception as e:
-                error_msg = f"Unexpected error while parsing JSON blob in {self.get_name()}: {e}. Blob: {blob[:200]}"
-                logger.error(error_msg, exc_info=True)
-                raise ToolUsageParseException(error_msg, original_exception=e)
-
-        return invocations

autobyteus/tools/usage/parsers/openai_json_tool_usage_parser.py

@@ -1,149 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/openai_json_tool_usage_parser.py
-import json
-import logging
-from typing import TYPE_CHECKING, List, Optional, Any, Dict
-
-from autobyteus.agent.tool_invocation import ToolInvocation
-from .base_parser import BaseToolUsageParser
-from .exceptions import ToolUsageParseException
-from ._json_extractor import _find_json_blobs
-from ._string_decoders import decode_html_entities
-
-if TYPE_CHECKING:
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class OpenAiJsonToolUsageParser(BaseToolUsageParser):
-    """
-    Parses LLM responses for tool usage commands formatted in various JSON
-    styles commonly produced by OpenAI and similar models.
-
-    This parser is highly flexible and robustly handles multiple formats:
-    - A root object with a "tool_calls" or "tools" key containing a list of tool calls.
-    - A root object with a single "tool" key.
-    - A root object that is itself a single tool call.
-    - A raw list of tool calls.
-    - Tool call arguments can be either a JSON object or a stringified JSON.
-    """
-    def get_name(self) -> str:
-        return "openai_json_tool_usage_parser"
-
-    def parse(self, response: 'CompleteResponse') -> List[ToolInvocation]:
-        response_text = response.content
-        invocations: List[ToolInvocation] = []
-        
-        # Use a robust method to find all potential JSON blobs in the text
-        json_blobs = _find_json_blobs(response_text)
-        if not json_blobs:
-            logger.debug("No valid JSON object could be extracted from the response content.")
-            return invocations
-
-        for blob in json_blobs:
-            try:
-                data = json.loads(blob)
-                
-                # Determine the structure of the JSON data
-                tool_calls_data: List[Dict[str, Any]] = []
-                if isinstance(data, list):
-                    # Format: [{"function":...}, {"function":...}]
-                    tool_calls_data = data
-                elif isinstance(data, dict):
-                    # Format: {"tool_calls": [...]} or {"tools": [...]}
-                    if "tool_calls" in data and isinstance(data["tool_calls"], list):
-                        tool_calls_data = data["tool_calls"]
-                    elif "tools" in data and isinstance(data["tools"], list):
-                        tool_calls_data = data["tools"]
-                    # Format: {"tool": {...}}
-                    elif "tool" in data and isinstance(data["tool"], dict):
-                        tool_calls_data = [data["tool"]]
-                    # Format: {"function": ...}
-                    else:
-                        tool_calls_data = [data]
-                
-                if not tool_calls_data:
-                    logger.debug(f"JSON response does not match any expected tool call format. Content: {blob[:200]}")
-                    continue
-
-                for call_data in tool_calls_data:
-                    invocation = self._parse_tool_call_object(call_data)
-                    if invocation:
-                        invocations.append(invocation)
-
-            except json.JSONDecodeError:
-                # This can happen if a blob is not a tool call (e.g., just example JSON).
-                # We can safely ignore these.
-                logger.debug(f"Could not parse extracted text as JSON in {self.get_name()}. Blob: {blob[:200]}")
-                continue
-            except Exception as e:
-                # If we're here, it's likely a valid JSON but with unexpected structure.
-                # It's safer to raise this for upstream handling.
-                error_msg = f"Unexpected error while parsing JSON blob: {e}. Blob: {blob[:200]}"
-                logger.error(error_msg, exc_info=True)
-                raise ToolUsageParseException(error_msg, original_exception=e)
-
-        return invocations
-
-    def _parse_tool_call_object(self, call_data: Dict[str, Any]) -> Optional[ToolInvocation]:
-        """
-        Parses a single tool call object, which can have various structures.
-        - {"function": {"name": str, "arguments": str_json_or_dict}}
-        - {"name": str, "arguments": dict}
-        """
-        if not isinstance(call_data, dict):
-            logger.debug(f"Skipping non-dictionary item in tool call list: {call_data}")
-            return None
-
-        function_data: Optional[Dict] = call_data.get("function")
-        if isinstance(function_data, dict):
-            # Standard OpenAI format: {"function": {"name": ..., "arguments": ...}}
-            tool_name = function_data.get("name")
-            arguments_raw = function_data.get("arguments")
-        else:
-            # Handle flattened format: {"name": ..., "arguments": ...}
-            tool_name = call_data.get("name")
-            arguments_raw = call_data.get("arguments")
-
-        if not tool_name or not isinstance(tool_name, str):
-            logger.debug(f"Skipping malformed tool call (missing or invalid 'name'): {call_data}")
-            return None
-
-        arguments: Dict[str, Any]
-        if arguments_raw is None:
-            arguments = {}
-        elif isinstance(arguments_raw, dict):
-            # Arguments are already a dictionary
-            arguments = arguments_raw
-        elif isinstance(arguments_raw, str):
-            # Arguments are a stringified JSON
-            arg_string = arguments_raw.strip()
-            if not arg_string:
-                arguments = {}
-            else:
-                try:
-                    parsed_args = json.loads(arg_string)
-                    if not isinstance(parsed_args, dict):
-                        logger.error(f"Parsed 'arguments' string for tool '{tool_name}' must be a dictionary, but got {type(parsed_args)}.")
-                        return None
-                    arguments = parsed_args
-                except json.JSONDecodeError as e:
-                    # If it's a string but not valid JSON, it's a hard error.
-                    raise ToolUsageParseException(
-                        f"Failed to parse 'arguments' string for tool '{tool_name}': {arguments_raw}",
-                        original_exception=e
-                    )
-        else:
-            # Any other type for arguments is invalid
-            logger.error(f"Skipping tool call with invalid 'arguments' type. Expected dict or string, got {type(arguments_raw)}: {call_data}")
-            return None
-                
-        try:
-            # The ToolInvocation constructor will generate a deterministic ID if 'id' is None.
-            decoded_tool_name = decode_html_entities(tool_name)
-            decoded_arguments = decode_html_entities(arguments)
-            tool_invocation = ToolInvocation(name=decoded_tool_name, arguments=decoded_arguments, id=None)
-            logger.info(f"Successfully parsed OpenAI-style JSON tool invocation for '{tool_name}'.")
-            return tool_invocation
-        except Exception as e:
-            logger.error(f"Unexpected error creating ToolInvocation for tool '{tool_name}': {e}", exc_info=True)
-            return None

autobyteus/tools/usage/parsers/provider_aware_tool_usage_parser.py

@@ -1,59 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/provider_aware_tool_usage_parser.py
-import logging
-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.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
-    based on the agent's LLM provider by consulting the central ToolUsageParserRegistry.
-    """
-    def __init__(self):
-        # 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 from the registry, parses the response,
-        and returns a list of tool invocations.
-
-        Args:
-            response: The CompleteResponse object from the LLM.
-            context: The agent's context, used to determine configuration.
-
-        Returns:
-            A list of ToolInvocation objects. Returns an empty list if no
-            valid tool calls are found.
-        """
-        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.")
-        
-        # Retrieve the override flag from the agent's configuration.
-        use_xml_tool_format = context.config.use_xml_tool_format
-
-        # Get the correct parser from the registry, passing the override flag.
-        parser = self._parser_registry.get_parser(llm_provider, use_xml_tool_format=use_xml_tool_format)
-        
-        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)
-        except ToolUsageParseException:
-            # Propagate the exception upwards to be handled by the caller.
-            raise

autobyteus/tools/usage/registries/tool_usage_parser_registry.py

@@ -1,62 +0,0 @@
-# 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()
-        # 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], use_xml_tool_format: bool = False) -> BaseToolUsageParser:
-        """
-        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()}")
-            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