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

autobyteus/tools/usage/formatters/default_xml_schema_formatter.py

@@ -1,8 +1,8 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/default_xml_schema_formatter.py
 import xml.sax.saxutils
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Dict
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
 from .base_formatter import BaseSchemaFormatter
 
 if TYPE_CHECKING:
@@ -30,6 +30,49 @@ class DefaultXmlSchemaFormatter(BaseSchemaFormatter):
         xml_parts.append("</tool>")
         return "\n".join(xml_parts)
 
+    def _json_schema_props_to_param_defs(self, schema_dict: Dict) -> List[ParameterDefinition]:
+        """
+        Converts a JSON schema's 'properties' dictionary into a list of ParameterDefinition objects.
+        This is used to bridge raw JSON schemas with the internal formatting logic.
+        """
+        param_defs = []
+        properties = schema_dict.get("properties", {})
+        required_fields = schema_dict.get("required", [])
+
+        for prop_name, prop_schema in properties.items():
+            if not isinstance(prop_schema, dict):
+                continue
+
+            param_type_str = prop_schema.get("type", "string").upper()
+            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
+
+            # JSON Schema uses 'enum' key for enumerations
+            allowed_values = prop_schema.get("enum")
+            if param_type == ParameterType.STRING and allowed_values:
+                param_type = ParameterType.ENUM
+
+            object_schema = None
+            if param_type == ParameterType.OBJECT and "properties" in prop_schema:
+                # Recursively build a ParameterSchema for nested objects
+                nested_param_defs = self._json_schema_props_to_param_defs(prop_schema)
+                object_schema = ParameterSchema(parameters=nested_param_defs)
+            
+            array_item_schema = None
+            if param_type == ParameterType.ARRAY and "items" in prop_schema:
+                # Pass the nested schema down; it will be handled by the next recursive call
+                array_item_schema = prop_schema["items"]
+
+            param_defs.append(ParameterDefinition(
+                name=prop_name,
+                param_type=param_type,
+                description=prop_schema.get("description", ""),
+                required=(prop_name in required_fields),
+                enum_values=allowed_values,
+                object_schema=object_schema,
+                array_item_schema=array_item_schema
+            ))
+        return param_defs
+
     def _format_params_recursively(self, params: List[ParameterDefinition], indent_level: int) -> List[str]:
         """Recursively formats parameter definitions into XML strings."""
         xml_lines = []
@@ -61,13 +104,26 @@ class DefaultXmlSchemaFormatter(BaseSchemaFormatter):
             elif is_array:
                 xml_lines.append(f'{indent}<arg {" ".join(attrs)}>')
                 if isinstance(param.array_item_schema, ParameterSchema):
-                    # Array of objects
+                    # Array of objects defined with our internal ParameterSchema
                     xml_lines.append(f'{indent}    <items type="object">')
                     xml_lines.extend(self._format_params_recursively(param.array_item_schema.parameters, indent_level + 2))
                     xml_lines.append(f'{indent}    </items>')
                 elif isinstance(param.array_item_schema, ParameterType):
                     # Array of primitives
                     xml_lines.append(f'{indent}    <items type="{param.array_item_schema.value}" />')
+                elif isinstance(param.array_item_schema, dict):
+                    # FIX: Handle array of objects defined with a raw JSON schema dict
+                    item_schema_dict = param.array_item_schema
+                    item_type = item_schema_dict.get("type", "string")
+                    
+                    xml_lines.append(f'{indent}    <items type="{item_type}">')
+                    
+                    if item_type == "object":
+                        # Convert the JSON schema properties to our internal ParameterDefinition list
+                        param_defs = self._json_schema_props_to_param_defs(item_schema_dict)
+                        xml_lines.extend(self._format_params_recursively(param_defs, indent_level + 2))
+
+                    xml_lines.append(f'{indent}    </items>')
                 xml_lines.append(f'{indent}</arg>')
             else:
                 # This is a simple/primitive type or a generic array

autobyteus/tools/usage/formatters/gemini_json_example_formatter.py

@@ -2,7 +2,7 @@
 import json
 from typing import Dict, Any, TYPE_CHECKING, Optional
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
 from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 

autobyteus/tools/usage/formatters/google_json_example_formatter.py

@@ -2,7 +2,7 @@
 import json
 from typing import Dict, Any, TYPE_CHECKING, Optional
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
+from autobyteus.utils.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

autobyteus/tools/usage/formatters/openai_json_example_formatter.py

@@ -2,7 +2,7 @@
 import json
 from typing import Dict, Any, TYPE_CHECKING, Optional
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
 from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 

autobyteus/tools/usage/parsers/_string_decoders.py

@@ -0,0 +1,18 @@
+# file: autobyteus/autobyteus/tools/usage/parsers/_string_decoders.py
+"""Utility helpers for normalizing string content inside parsed tool payloads."""
+
+from __future__ import annotations
+
+import html
+from typing import Any
+
+
+def decode_html_entities(data: Any) -> Any:
+    """Recursively decode HTML/XML entities in strings within a data structure."""
+    if isinstance(data, dict):
+        return {key: decode_html_entities(value) for key, value in data.items()}
+    if isinstance(data, list):
+        return [decode_html_entities(item) for item in data]
+    if isinstance(data, str):
+        return html.unescape(data)
+    return data

autobyteus/tools/usage/parsers/default_json_tool_usage_parser.py

@@ -3,6 +3,8 @@ import json
 import logging
 from typing import Dict, Any, TYPE_CHECKING, List
 
+from ._string_decoders import decode_html_entities
+
 from autobyteus.agent.tool_invocation import ToolInvocation
 from .base_parser import BaseToolUsageParser
 from .exceptions import ToolUsageParseException
@@ -53,9 +55,15 @@ class DefaultJsonToolUsageParser(BaseToolUsageParser):
                         logger.debug(f"Skipping tool block with invalid 'parameters' type ({type(arguments)}): {tool_block}")
                         continue
                     
+                    decoded_arguments = decode_html_entities(arguments)
+                    decoded_tool_name = decode_html_entities(tool_name)
                     try:
                         # Pass id=None to trigger deterministic ID generation.
-                        tool_invocation = ToolInvocation(name=tool_name, arguments=arguments, id=None)
+                        tool_invocation = ToolInvocation(
+                            name=decoded_tool_name,
+                            arguments=decoded_arguments,
+                            id=None,
+                        )
                         invocations.append(tool_invocation)
                         logger.info(f"Successfully parsed default JSON tool invocation for '{tool_name}'.")
                     except Exception as e:

autobyteus/tools/usage/parsers/default_xml_tool_usage_parser.py

@@ -1,5 +1,6 @@
 import logging
 import re
+import html
 from typing import TYPE_CHECKING, Dict, Any, List
 from dataclasses import dataclass, field
 
@@ -124,6 +125,7 @@ class _XmlArgumentsParser:
         
         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'):
@@ -213,6 +215,19 @@ class _XmlArgumentsParser:
             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 ---
 
@@ -299,4 +314,3 @@ class DefaultXmlToolUsageParser(BaseToolUsageParser):
         """
         parser = _XmlArgumentsParser(xml_string)
         return parser.parse()
-

autobyteus/tools/usage/parsers/gemini_json_tool_usage_parser.py

@@ -7,6 +7,7 @@ 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
@@ -55,8 +56,10 @@ class GeminiJsonToolUsageParser(BaseToolUsageParser):
                     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=tool_name, arguments=arguments)
+                        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:

autobyteus/tools/usage/parsers/openai_json_tool_usage_parser.py

@@ -7,6 +7,7 @@ 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
@@ -138,7 +139,9 @@ class OpenAiJsonToolUsageParser(BaseToolUsageParser):
                 
         try:
             # The ToolInvocation constructor will generate a deterministic ID if 'id' is None.
-            tool_invocation = ToolInvocation(name=tool_name, arguments=arguments, id=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:

autobyteus/{tools → utils}/parameter_schema.py

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/tools/parameter_schema.py
+# file: autobyteus/autobyteus/utils/parameter_schema.py
 from __future__ import annotations
 import logging
 from typing import Dict, Any, List, Optional, Union, Type

{autobyteus-1.1.8.dist-info → autobyteus-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.8
+Version: 1.2.0
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -16,14 +16,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: anthropic
-Requires-Dist: autobyteus-llm-client==1.1.3
 Requires-Dist: beautifulsoup4
 Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: brui-core==1.0.9
 Requires-Dist: certifi==2025.4.26
+Requires-Dist: cryptography
 Requires-Dist: google-api-python-client
-Requires-Dist: google-generativeai
+Requires-Dist: google-genai==1.38.0
+Requires-Dist: httpx
 Requires-Dist: Jinja2
 Requires-Dist: mcp[cli]
 Requires-Dist: mistral_common