autobyteus 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

autobyteus/tools/usage/formatters/google_json_example_formatter.py

@@ -1,7 +1,8 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/google_json_example_formatter.py
-from typing import Dict, Any, TYPE_CHECKING
+import json
+from typing import Dict, Any, TYPE_CHECKING, Optional
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
 # Import for reuse of the intelligent example generation logic
 from .default_json_example_formatter import DefaultJsonExampleFormatter
@@ -10,32 +11,64 @@ if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
 
 class GoogleJsonExampleFormatter(BaseExampleFormatter):
-    """Formats a tool usage example into the Google JSON tool_calls format."""
+    """
+    Formats a tool usage example into the Google JSON tool_calls format.
+    Provides both basic (required only) and advanced (all) examples if optional
+    parameters exist for the tool.
+    """
 
-    def provide(self, tool_definition: 'ToolDefinition') -> Dict:
+    def provide(self, tool_definition: 'ToolDefinition') -> str:
+        """
+        Generates a formatted string containing basic and optionally an advanced usage example for the tool.
+        """
+        basic_example_dict = self._create_example_structure(tool_definition, mode='basic')
+        basic_example_str = "### Example 1: Basic Call (Required Arguments)\n"
+        basic_example_str += "```json\n"
+        basic_example_str += json.dumps(basic_example_dict, indent=2)
+        basic_example_str += "\n```"
+        
+        if not self._schema_has_advanced_params(tool_definition.argument_schema):
+            return basic_example_str
+
+        advanced_example_dict = self._create_example_structure(tool_definition, mode='advanced')
+        advanced_example_str = "### Example 2: Advanced Call (With Optional Arguments)\n"
+        advanced_example_str += "```json\n"
+        advanced_example_str += json.dumps(advanced_example_dict, indent=2)
+        advanced_example_str += "\n```"
+        
+        return f"{basic_example_str}\n\n{advanced_example_str}"
+
+    def _create_example_structure(self, tool_definition: 'ToolDefinition', mode: str) -> Dict:
+        """Helper to create a single Google tool call example for a given mode."""
         tool_name = tool_definition.name
         arg_schema = tool_definition.argument_schema
         arguments = {}
 
         if arg_schema and arg_schema.parameters:
-            for param_def in arg_schema.parameters:
-                if param_def.required or param_def.default_value is not None:
-                    arguments[param_def.name] = self._generate_placeholder_value(param_def)
-
+            params_to_render = arg_schema.parameters
+            if mode == 'basic':
+                params_to_render = [p for p in arg_schema.parameters if p.required]
+            
+            for param_def in params_to_render:
+                # Use the intelligent placeholder generator from the default formatter
+                arguments[param_def.name] = DefaultJsonExampleFormatter._generate_example_from_schema(
+                    param_def.object_schema or param_def.array_item_schema or param_def.param_type, 
+                    param_def.object_schema or arg_schema,
+                    mode=mode
+                ) if param_def.object_schema or param_def.array_item_schema else self._generate_simple_placeholder(param_def)
+        
         return {"name": tool_name, "args": arguments}
 
-    def _generate_placeholder_value(self, param_def: ParameterDefinition) -> Any:
-        # REUSE the intelligent generator for complex objects
-        if param_def.param_type == ParameterType.OBJECT and param_def.object_schema:
-            return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.object_schema, param_def.object_schema)
+    def _schema_has_advanced_params(self, schema: Optional[ParameterSchema]) -> bool:
+        """Recursively checks if a schema or any of its sub-schemas have non-required parameters."""
+        if not schema: return False
+        for param in schema.parameters:
+            if not param.required: return True
+            if param.object_schema and self._schema_has_advanced_params(param.object_schema): return True
+            if isinstance(param.array_item_schema, ParameterSchema) and self._schema_has_advanced_params(param.array_item_schema): return True
+        return False
 
-        # Fallback for primitives
+    def _generate_simple_placeholder(self, param_def: ParameterDefinition) -> Any:
+        """Generates a simple placeholder for primitive types."""
         if param_def.default_value is not None: return param_def.default_value
-        if param_def.param_type == ParameterType.STRING: return f"example_{param_def.name}"
-        if param_def.param_type == ParameterType.INTEGER: return 123
-        if param_def.param_type == ParameterType.FLOAT: return 123.45
-        if param_def.param_type == ParameterType.BOOLEAN: return True
-        if param_def.param_type == ParameterType.ENUM: return param_def.enum_values[0] if param_def.enum_values else "enum_val"
-        if param_def.param_type == ParameterType.OBJECT: return {"key": "value"}
-        if param_def.param_type == ParameterType.ARRAY: return ["item1", "item2"]
-        return "placeholder"
+        return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.param_type, param_def.param_type, mode='basic')

autobyteus/tools/usage/formatters/openai_json_example_formatter.py

@@ -1,8 +1,8 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/openai_json_example_formatter.py
 import json
-from typing import Dict, Any, TYPE_CHECKING
+from typing import Dict, Any, TYPE_CHECKING, Optional
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
 from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 
@@ -11,41 +11,71 @@ if TYPE_CHECKING:
 
 class OpenAiJsonExampleFormatter(BaseExampleFormatter):
     """
-    Formats a tool usage example into a format resembling an entry in the
-    OpenAI JSON 'tool_calls' array, intended for prompting a model.
+    Formats a tool usage example into the OpenAI JSON 'tool_calls' format.
+    Provides both basic (required only) and advanced (all) examples if optional
+    parameters exist for the tool.
     """
+    
+    def provide(self, tool_definition: 'ToolDefinition') -> str:
+        """
+        Generates a formatted string containing basic and optionally an advanced usage example for the tool.
+        """
+        basic_example_dict = self._create_example_structure(tool_definition, mode='basic')
+        basic_example_str = "### Example 1: Basic Call (Required Arguments)\n"
+        basic_example_str += "```json\n"
+        basic_example_str += json.dumps(basic_example_dict, indent=2)
+        basic_example_str += "\n```"
+        
+        if not self._schema_has_advanced_params(tool_definition.argument_schema):
+            return basic_example_str
 
-    def provide(self, tool_definition: 'ToolDefinition') -> Dict:
+        advanced_example_dict = self._create_example_structure(tool_definition, mode='advanced')
+        advanced_example_str = "### Example 2: Advanced Call (With Optional Arguments)\n"
+        advanced_example_str += "```json\n"
+        advanced_example_str += json.dumps(advanced_example_dict, indent=2)
+        advanced_example_str += "\n```"
+        
+        return f"{basic_example_str}\n\n{advanced_example_str}"
+
+    def _create_example_structure(self, tool_definition: 'ToolDefinition', mode: str) -> Dict:
+        """Helper to create a single OpenAI tool call example for a given mode."""
         tool_name = tool_definition.name
         arg_schema = tool_definition.argument_schema
         arguments = {}
 
         if arg_schema and arg_schema.parameters:
-            for param_def in arg_schema.parameters:
-                if param_def.required or param_def.default_value is not None:
-                    arguments[param_def.name] = self._generate_placeholder_value(param_def)
+            params_to_render = arg_schema.parameters
+            if mode == 'basic':
+                params_to_render = [p for p in arg_schema.parameters if p.required]
+            
+            for param_def in params_to_render:
+                # Use the intelligent placeholder generator from the default formatter
+                arguments[param_def.name] = DefaultJsonExampleFormatter._generate_example_from_schema(
+                    param_def.object_schema or param_def.array_item_schema or param_def.param_type, 
+                    param_def.object_schema or arg_schema,
+                    mode=mode
+                ) if param_def.object_schema or param_def.array_item_schema else self._generate_simple_placeholder(param_def)
 
         function_call = {
             "function": {
                 "name": tool_name,
-                "arguments": json.dumps(arguments),
+                # FIX: Keep arguments as a dictionary for clear examples in the prompt.
+                # Do NOT stringify it here.
+                "arguments": arguments,
             },
         }
-
         return {"tool": function_call}
 
-    def _generate_placeholder_value(self, param_def: ParameterDefinition) -> Any:
-        # REUSE a more intelligent generator for complex objects
-        if param_def.param_type == ParameterType.OBJECT and param_def.object_schema:
-            return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.object_schema, param_def.object_schema)
+    def _schema_has_advanced_params(self, schema: Optional[ParameterSchema]) -> bool:
+        """Recursively checks if a schema or any of its sub-schemas have non-required parameters."""
+        if not schema: return False
+        for param in schema.parameters:
+            if not param.required: return True
+            if param.object_schema and self._schema_has_advanced_params(param.object_schema): return True
+            if isinstance(param.array_item_schema, ParameterSchema) and self._schema_has_advanced_params(param.array_item_schema): return True
+        return False
 
-        # Fallback for primitives
+    def _generate_simple_placeholder(self, param_def: ParameterDefinition) -> Any:
+        """Generates a simple placeholder for primitive types."""
         if param_def.default_value is not None: return param_def.default_value
-        if param_def.param_type == ParameterType.STRING: return f"example_{param_def.name}"
-        if param_def.param_type == ParameterType.INTEGER: return 123
-        if param_def.param_type == ParameterType.FLOAT: return 123.45
-        if param_def.param_type == ParameterType.BOOLEAN: return True
-        if param_def.param_type == ParameterType.ENUM: return param_def.enum_values[0] if param_def.enum_values else "enum_val"
-        if param_def.param_type == ParameterType.OBJECT: return {"key": "value"}
-        if param_def.param_type == ParameterType.ARRAY: return ["item1", "item2"]
-        return "placeholder"
+        return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.param_type, param_def.param_type, mode='basic')

autobyteus/tools/usage/parsers/default_xml_tool_usage_parser.py

@@ -1,126 +1,302 @@
-import xml.etree.ElementTree as ET
-import re
-import uuid
-import html
-from xml.sax.saxutils import escape
-import xml.parsers.expat
 import logging
+import re
 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
-from .exceptions import ToolUsageParseException
 
 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)
+        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)
+
+
+# --- Main Parser Class ---
+
 class DefaultXmlToolUsageParser(BaseToolUsageParser):
     """
-    Parses LLM responses for tool usage commands formatted as XML using a robust,
-    stateful, character-by-character scanning approach. This parser can correctly
-    identify and extract valid <tool>...</tool> blocks even when they are mixed with
-    conversational text, malformed XML, or other noise.
+    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] = []
-        cursor = 0
-        
-        while cursor < len(text):
-            # Find the start of the next potential tool tag from the current cursor position
-            tool_start_index = text.find('<tool', cursor)
-            if tool_start_index == -1:
-                break # No more tool tags in the rest of the string
-
-            # Find the end of that opening <tool ...> tag. This is a potential end.
-            tool_start_tag_end = text.find('>', tool_start_index)
-            if tool_start_tag_end == -1:
-                # Incomplete tag at the end of the file, break
+        i = 0
+
+        while i < len(text):
+            try:
+                i = text.index('<tool', i)
+            except ValueError:
                 break
 
-            # Check if another '<' appears before the '>', which would indicate a malformed/aborted tag.
-            # Example: <tool name="abc" ... <tool name="xyz">
-            next_opening_bracket = text.find('<', tool_start_index + 1)
-            if next_opening_bracket != -1 and next_opening_bracket < tool_start_tag_end:
-                # The tag was not closed properly before another one started.
-                # Advance the cursor to this new tag and restart the loop.
-                cursor = next_opening_bracket
-                continue
+            open_tag_end = text.find('>', i)
+            if open_tag_end == -1: break
 
-            # Find the corresponding </tool> closing tag
-            tool_end_index = text.find('</tool>', tool_start_tag_end)
-            if tool_end_index == -1:
-                # Found a start tag but no end tag, treat as fragment and advance
-                cursor = tool_start_tag_end + 1
+            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} ---")
 
-            # Extract the full content of this potential tool block
-            block_end_pos = tool_end_index + len('</tool>')
-            tool_block = text[tool_start_index:block_end_pos]
+            cursor = open_tag_end + 1
+            nesting_level = 1
+            content_end = -1
             
-            # CRITICAL NESTING CHECK:
-            # Check if there is another '<tool' start tag within this block.
-            # If so, it means this is a malformed, nested block. We must skip it
-            # and let the loop find the inner tag on the next iteration.
-            # This check is now more of a safeguard, as the logic above should handle most cases.
-            if '<tool' in tool_block[1:]:
-                # Advance cursor past the opening tag of this malformed block to continue scanning
-                cursor = tool_start_tag_end + 1
-                continue
+            while cursor < len(text):
+                next_open = text.find('<tool', cursor)
+                next_close = text.find('</tool>', cursor)
 
-            # This is a valid, non-nested block. Attempt to parse it.
-            try:
-                # Preprocessing and parsing
-                processed_block = self._preprocess_xml_for_parsing(tool_block)
-                root = ET.fromstring(processed_block)
-                
-                tool_name = root.attrib.get("name")
-                if not tool_name:
-                    logger.warning(f"Skipping a <tool> block with no name attribute: {processed_block[:100]}")
+                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:
-                    arguments = self._parse_arguments_from_xml(root)
-                    tool_id_attr = root.attrib.get('id')
-                    
-                    invocation = ToolInvocation(
-                        name=tool_name,
-                        arguments=arguments,
-                        id=tool_id_attr
-                    )
-                    invocations.append(invocation)
-                    logger.info(f"Successfully parsed XML tool invocation for '{tool_name}'.")
-
-            except (ET.ParseError, xml.parsers.expat.ExpatError) as e:
-                # The self-contained block was still malformed. Log and ignore it.
-                logger.warning(f"Skipping malformed XML tool block: {e}")
+                    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)
             
-            # CRITICAL: Advance cursor past the entire block we just processed
-            cursor = block_end_pos
+            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 _preprocess_xml_for_parsing(self, xml_content: str) -> str:
-        # This function remains the same as it's not part of the core logic error.
-        # It's a helper for cleaning up minor syntax issues before parsing.
-        return xml_content
-
-    def _parse_arguments_from_xml(self, command_element: ET.Element) -> Dict[str, Any]:
-        """Helper to extract arguments from a parsed <tool> element."""
-        arguments: Dict[str, Any] = {}
-        arguments_container = command_element.find('arguments')
-        if arguments_container is None:
-            return arguments
-        
-        for arg_element in arguments_container.findall('arg'):
-            arg_name = arg_element.attrib.get('name')
-            if arg_name:
-                # Use .text to get only the direct text content of the tag.
-                # This is safer than itertext() if the LLM hallucinates nested tags.
-                # The XML parser already handles unescaping of standard entities.
-                raw_text = arg_element.text or ""
-                arguments[arg_name] = raw_text
-        return arguments
+    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()
+