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

autobyteus/tools/mcp/tool_registrar.py

@@ -79,67 +79,120 @@ class McpToolRegistrar(metaclass=SingletonMeta):
             tool_class=None
         )
 
-    async def discover_and_register_tools(self, mcp_config: Optional[Union[BaseMcpConfig, Dict[str, Any]]] = None) -> List[ToolDefinition]:
+    async def _discover_and_register_from_config(self, server_config: BaseMcpConfig, schema_mapper: McpSchemaMapper) -> List[ToolDefinition]:
         """
-        Discovers tools from MCP servers and registers them.
+        Performs the core discovery and registration logic for a single server configuration.
+        This method does NOT handle un-registration of existing tools.
         """
-        configs_to_process: List[BaseMcpConfig]
+        registered_tool_definitions: List[ToolDefinition] = []
+        if not server_config.enabled:
+            logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
+            return registered_tool_definitions
+
+        logger.info(f"Discovering tools from MCP server: '{server_config.server_id}'")
         
-        if mcp_config:
-            validated_config: BaseMcpConfig
-            if isinstance(mcp_config, dict):
+        try:
+            remote_tools = await self._fetch_tools_from_server(server_config)
+            logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
+
+            for remote_tool in remote_tools:
                 try:
-                    validated_config = self._config_service.load_config(mcp_config)
-                except ValueError as e:
-                    logger.error(f"Failed to parse provided MCP config dictionary: {e}")
-                    raise
-            elif isinstance(mcp_config, BaseMcpConfig):
-                validated_config = self._config_service.add_config(mcp_config)
-            else:
-                raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-            
-            logger.info(f"Starting targeted MCP tool discovery for server: {validated_config.server_id}")
-            self.unregister_tools_from_server(validated_config.server_id)
-            configs_to_process = [validated_config]
-        else:
-            logger.info("Starting full MCP tool discovery. Unregistering all existing MCP tools first.")
-            all_server_ids = list(self._registered_tools_by_server.keys())
-            for server_id in all_server_ids:
-                self.unregister_tools_from_server(server_id)
-            self._registered_tools_by_server.clear()
-            configs_to_process = self._config_service.get_all_configs()
+                    tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, schema_mapper)
+                    self._tool_registry.register_tool(tool_def)
+                    self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
+                    registered_tool_definitions.append(tool_def)
+                except Exception as e_tool:
+                    logger.error(f"Failed to process or register remote tool '{remote_tool.name}': {e_tool}", exc_info=True)
+        
+        except Exception as e_server:
+            logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
+            # Re-raise to signal failure to the caller
+            raise
+        
+        return registered_tool_definitions
+
+    async def register_server(self, config_object: BaseMcpConfig) -> List[ToolDefinition]:
+        """
+        Discovers and registers tools from a single MCP server using a validated
+        config object. This will overwrite any existing tools from that server.
+
+        Args:
+            config_object: A pre-instantiated and validated BaseMcpConfig object.
+
+        Returns:
+            A list of the successfully registered ToolDefinition objects from this server.
+        """
+        if not isinstance(config_object, BaseMcpConfig):
+            raise TypeError(f"config_object must be a BaseMcpConfig object, not {type(config_object)}.")
+
+        # Add/update the config in the service
+        self._config_service.add_config(config_object)
+
+        logger.info(f"Starting targeted MCP tool registration for server: {config_object.server_id}")
+        
+        # Unregister existing tools for this specific server before re-registering
+        self.unregister_tools_from_server(config_object.server_id)
+        
+        schema_mapper = McpSchemaMapper()
+        
+        return await self._discover_and_register_from_config(config_object, schema_mapper)
+
+    async def load_and_register_server(self, config_dict: Dict[str, Any]) -> List[ToolDefinition]:
+        """
+        Loads a server configuration from a dictionary, then discovers and registers its tools.
+        This is a convenience method that wraps the parsing and registration process.
+
+        Args:
+            config_dict: The raw dictionary configuration for a single MCP server.
+
+        Returns:
+            A list of the successfully registered ToolDefinition objects from this server.
+        """
+        logger.debug(f"Attempting to load and register server from dictionary: {config_dict.get(next(iter(config_dict), 'unknown'))}")
+        try:
+            validated_config = self._config_service.load_config_from_dict(config_dict)
+        except ValueError as e:
+            logger.error(f"Failed to parse provided MCP config dictionary: {e}")
+            raise
+        
+        return await self.register_server(validated_config)
+
+    async def reload_all_mcp_tools(self) -> List[ToolDefinition]:
+        """
+        Performs a full refresh of tools from ALL MCP servers currently configured
+        in the McpConfigService. This first unregisters all previously registered
+        MCP tools, then re-discovers and re-registers them. This process is resilient
+        to failures from individual servers.
 
+        Returns:
+            A list of all successfully registered ToolDefinition objects.
+        """
+        logger.info("Reloading all MCP tools. Unregistering existing MCP tools first.")
+        
+        # Unregister all previously known MCP tools
+        all_server_ids = list(self._registered_tools_by_server.keys())
+        for server_id in all_server_ids:
+            self.unregister_tools_from_server(server_id)
+        
+        configs_to_process = self._config_service.get_all_configs()
         if not configs_to_process:
-            logger.info("No MCP server configurations to process. Skipping discovery.")
+            logger.info("No MCP server configurations to process. Skipping reload.")
             return []
 
         schema_mapper = McpSchemaMapper()
-        registered_tool_definitions: List[ToolDefinition] = []
+        all_registered_definitions: List[ToolDefinition] = []
+        
         for server_config in configs_to_process:
-            if not server_config.enabled:
-                logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
-                continue
-
-            logger.info(f"Discovering tools from MCP server: '{server_config.server_id}'")
-            
             try:
-                remote_tools = await self._fetch_tools_from_server(server_config)
-                logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
-
-                for remote_tool in remote_tools:
-                    try:
-                        tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, schema_mapper)
-                        self._tool_registry.register_tool(tool_def)
-                        self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
-                        registered_tool_definitions.append(tool_def)
-                    except Exception as e_tool:
-                        logger.error(f"Failed to process or register remote tool '{remote_tool.name}': {e_tool}", exc_info=True)
-            
-            except Exception as e_server:
-                logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
-        
-        logger.info(f"MCP tool discovery and registration process completed. Total tools registered: {len(registered_tool_definitions)}.")
-        return registered_tool_definitions
+                newly_registered = await self._discover_and_register_from_config(server_config, schema_mapper)
+                all_registered_definitions.extend(newly_registered)
+            except Exception as e:
+                # Log the error but continue to the next server. This makes the process resilient.
+                # exc_info is False because the inner method already logged the full stack trace.
+                logger.error(f"Failed to complete discovery for server '{server_config.server_id}', it will be skipped. Error: {e}", exc_info=False)
+
+        logger.info(f"Finished reloading all MCP tools. Total tools registered: {len(all_registered_definitions)}.")
+        return all_registered_definitions
 
     async def list_remote_tools(self, mcp_config: Union[BaseMcpConfig, Dict[str, Any]]) -> List[ToolDefinition]:
         validated_config: BaseMcpConfig

autobyteus/tools/parameter_schema.py

@@ -14,8 +14,6 @@ class ParameterType(str, Enum):
     FLOAT = "float"
     BOOLEAN = "boolean"
     ENUM = "enum"
-    # FILE_PATH = "file_path" # REMOVED
-    # DIRECTORY_PATH = "directory_path" # REMOVED
     OBJECT = "object"
     ARRAY = "array"
 
@@ -23,11 +21,8 @@ class ParameterType(str, Enum):
         """Maps parameter type to JSON schema type."""
         if self == ParameterType.FLOAT:
             return "number"
-        # REMOVED: FILE_PATH and DIRECTORY_PATH handling, ENUM still maps to string
         if self == ParameterType.ENUM:
             return "string"
-        # For OBJECT and ARRAY, their value is already the correct JSON schema type
-        # STRING, INTEGER, BOOLEAN also map directly to their values.
         if self in [ParameterType.OBJECT, ParameterType.ARRAY, ParameterType.STRING, ParameterType.INTEGER, ParameterType.BOOLEAN]:
             return self.value
         return self.value # Fallback, should be covered by above
@@ -46,8 +41,9 @@ class ParameterDefinition:
     min_value: Optional[Union[int, float]] = None
     max_value: Optional[Union[int, float]] = None
     pattern: Optional[str] = None
-    array_item_schema: Optional[Dict[str, Any]] = None 
-    
+    array_item_schema: Optional[Dict[str, Any]] = None
+    object_schema: Optional[Dict[str, Any]] = None
+
     def __post_init__(self):
         if not self.name or not isinstance(self.name, str):
             raise ValueError("ParameterDefinition name must be a non-empty string")
@@ -64,6 +60,9 @@ class ParameterDefinition:
         if self.param_type != ParameterType.ARRAY and self.array_item_schema is not None:
             raise ValueError(f"ParameterDefinition '{self.name}': array_item_schema should only be provided if param_type is ARRAY.")
 
+        if self.param_type != ParameterType.OBJECT and self.object_schema is not None:
+            raise ValueError(f"ParameterDefinition '{self.name}': object_schema should only be provided if param_type is OBJECT.")
+
         if self.required and self.default_value is not None:
             logger.debug(f"ParameterDefinition '{self.name}' is marked as required but has a default value. This is acceptable.")
 
@@ -103,8 +102,6 @@ class ParameterDefinition:
             if not isinstance(value, str) or value not in (self.enum_values or []):
                 return False
         
-        # REMOVED: Specific validation for FILE_PATH, DIRECTORY_PATH (they are now STRING)
-        
         elif self.param_type == ParameterType.OBJECT:
             if not isinstance(value, dict):
                 return False
@@ -129,9 +126,18 @@ class ParameterDefinition:
         }
         if self.param_type == ParameterType.ARRAY and self.array_item_schema is not None:
             data["array_item_schema"] = self.array_item_schema
+        if self.param_type == ParameterType.OBJECT and self.object_schema is not None:
+            data["object_schema"] = self.object_schema
         return data
 
     def to_json_schema_property_dict(self) -> Dict[str, Any]:
+        if self.param_type == ParameterType.OBJECT and self.object_schema:
+            # If a detailed object schema is provided, use it directly.
+            # We add the description at the top level for clarity.
+            schema = self.object_schema.copy()
+            schema["description"] = self.description
+            return schema
+
         prop_dict: Dict[str, Any] = {
             "type": self.param_type.to_json_schema_type(),
             "description": self.description,
@@ -150,7 +156,6 @@ class ParameterDefinition:
             if self.param_type in [ParameterType.INTEGER, ParameterType.FLOAT]:
                 prop_dict["maximum"] = self.max_value
         
-        # REMOVED: Pattern check specific to FILE_PATH/DIRECTORY_PATH as they are now STRING
         if self.pattern and self.param_type == ParameterType.STRING:
             prop_dict["pattern"] = self.pattern
             
@@ -255,7 +260,8 @@ class ParameterSchema:
                 min_value=param_data.get("min_value"),
                 max_value=param_data.get("max_value"),
                 pattern=param_data.get("pattern"),
-                array_item_schema=param_data.get("array_item_schema") 
+                array_item_schema=param_data.get("array_item_schema"),
+                object_schema=param_data.get("object_schema")
             )
             schema.add_parameter(param)
         

autobyteus/tools/registry/tool_definition.py

@@ -7,11 +7,12 @@ from autobyteus.llm.providers import LLMProvider
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.parameter_schema import ParameterSchema
 from autobyteus.tools.tool_origin import ToolOrigin
-from autobyteus.tools.usage.providers import (
-    XmlSchemaProvider, 
-    JsonSchemaProvider, 
-    XmlExampleProvider, 
-    JsonExampleProvider
+# Import default formatters directly to provide convenience methods
+from autobyteus.tools.usage.formatters import (
+    DefaultXmlSchemaFormatter,
+    DefaultJsonSchemaFormatter,
+    DefaultXmlExampleFormatter,
+    DefaultJsonExampleFormatter
 )
 
 if TYPE_CHECKING:
@@ -22,7 +23,7 @@ logger = logging.getLogger(__name__)
 class ToolDefinition:
     """
     Represents the definition of a tool, containing its metadata and the means
-    to create an instance. It can generate provider-specific usage information on demand.
+    to create an instance. It can generate provider-agnostic usage information on demand.
     """
     def __init__(self,
                  name: str,
@@ -95,44 +96,38 @@ class ToolDefinition:
     @property
     def metadata(self) -> Dict[str, Any]: return self._metadata
     
-    # --- Schema Generation API ---
+    # --- Convenience Schema/Example Generation API (using default formatters) ---
     def get_usage_xml(self, provider: Optional[LLMProvider] = None) -> str:
         """
-        Generates the standardized XML usage schema string for this tool.
-        The provider argument is included for API consistency and future-proofing.
+        Generates the default XML usage schema string for this tool.
+        The provider argument is ignored, kept for API consistency.
         """
-        provider_instance = XmlSchemaProvider()
-        return provider_instance.provide(self, llm_provider=provider)
+        formatter = DefaultXmlSchemaFormatter()
+        return formatter.provide(self)
 
     def get_usage_json(self, provider: Optional[LLMProvider] = None) -> Dict[str, Any]:
         """
-        Generates the usage schema as a dictionary.
-        
-        Args:
-            provider: If provided, generates a provider-specific JSON format.
-                      If None, generates a default, generic JSON format.
-        
-        Returns:
-            A dictionary representing the tool's usage schema.
+        Generates the default JSON usage schema as a dictionary.
+        The provider argument is ignored, kept for API consistency.
         """
-        provider_instance = JsonSchemaProvider()
-        return provider_instance.provide(self, llm_provider=provider)
+        formatter = DefaultJsonSchemaFormatter()
+        return formatter.provide(self)
 
-    # --- Example Generation API ---
     def get_usage_xml_example(self, provider: Optional[LLMProvider] = None) -> str:
         """
-        Generates a standardized XML usage example string for this tool.
-        The provider argument is included for API consistency and future-proofing.
+        Generates a default XML usage example string for this tool.
+        The provider argument is ignored, kept for API consistency.
         """
-        provider_instance = XmlExampleProvider()
-        return provider_instance.provide(self, llm_provider=provider)
+        formatter = DefaultXmlExampleFormatter()
+        return formatter.provide(self)
 
     def get_usage_json_example(self, provider: Optional[LLMProvider] = None) -> Any:
         """
-        Generates a usage example, either as a dict or a string.
+        Generates a default JSON usage example as a dictionary.
+        The provider argument is ignored, kept for API consistency.
         """
-        provider_instance = JsonExampleProvider()
-        return provider_instance.provide(self, llm_provider=provider)
+        formatter = DefaultJsonExampleFormatter()
+        return formatter.provide(self)
 
     # --- Other methods ---
     @property

autobyteus/tools/tool_category.py

@@ -14,6 +14,7 @@ class ToolCategory(str, Enum):
     UTILITY = "Utility"
     AGENT_COMMUNICATION = "Agent Communication"
     PROMPT_MANAGEMENT = "Prompt Management"
+    TASK_MANAGEMENT = "Task Management" # NEW CATEGORY ADDED
     GENERAL = "General"
     MCP = "MCP"
 

autobyteus/tools/usage/formatters/default_json_example_formatter.py

@@ -1,5 +1,5 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/default_json_example_formatter.py
-from typing import Dict, Any, TYPE_CHECKING
+from typing import Dict, Any, TYPE_CHECKING, List, Optional
 
 from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
@@ -9,8 +9,8 @@ if TYPE_CHECKING:
 
 class DefaultJsonExampleFormatter(BaseExampleFormatter):
     """
-    Formats a tool usage example into a generic JSON format, inspired by
-    the default XML format.
+    Formats a tool usage example into a generic JSON format.
+    It intelligently generates detailed examples for complex object schemas.
     """
 
     def provide(self, tool_definition: 'ToolDefinition') -> Dict:
@@ -20,6 +20,8 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
 
         if arg_schema and arg_schema.parameters:
             for param_def in arg_schema.parameters:
+                # Always include required parameters in the example.
+                # Also include optional parameters that have a default value to show common usage.
                 if param_def.required or param_def.default_value is not None:
                     arguments[param_def.name] = self._generate_placeholder_value(param_def)
 
@@ -31,6 +33,12 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
         }
 
     def _generate_placeholder_value(self, param_def: ParameterDefinition) -> Any:
+        # If an object parameter has a detailed schema, generate a structured example from it.
+        if param_def.param_type == ParameterType.OBJECT and param_def.object_schema:
+            # We pass the full schema document to allow for resolving $refs
+            return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.object_schema, param_def.object_schema)
+        
+        # Fallback to simple placeholder generation for primitives or objects without schemas.
         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
@@ -40,3 +48,70 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
         if param_def.param_type == ParameterType.OBJECT: return {"key": "value"}
         if param_def.param_type == ParameterType.ARRAY: return ["item1", "item2"]
         return "placeholder"
+
+    @staticmethod
+    def _generate_example_from_schema(sub_schema: Dict[str, Any], full_schema: Dict[str, Any]) -> Any:
+        """
+        Recursively generates an example value from a JSON schema dictionary.
+        This is a static method so it can be reused by other formatters.
+        """
+        if "$ref" in sub_schema:
+            ref_path = sub_schema["$ref"]
+            try:
+                # Resolve the reference, e.g., "#/$defs/MySchema"
+                parts = ref_path.lstrip("#/").split("/")
+                resolved_schema = full_schema
+                for part in parts:
+                    resolved_schema = resolved_schema[part]
+                return DefaultJsonExampleFormatter._generate_example_from_schema(resolved_schema, full_schema)
+            except (KeyError, IndexError):
+                return {"error": f"Could not resolve schema reference: {ref_path}"}
+
+        schema_type = sub_schema.get("type")
+        
+        if "default" in sub_schema:
+            return sub_schema["default"]
+        
+        if "enum" in sub_schema and sub_schema["enum"]:
+            return sub_schema["enum"][0]
+
+        if schema_type == "object":
+            example_obj = {}
+            properties = sub_schema.get("properties", {})
+            required_fields = sub_schema.get("required", [])
+            for prop_name, prop_schema in properties.items():
+                # Include required fields and a subset of optional fields for a concise example.
+                if prop_name in required_fields:
+                    example_obj[prop_name] = DefaultJsonExampleFormatter._generate_example_from_schema(prop_schema, full_schema)
+            return example_obj
+        
+        elif schema_type == "array":
+            items_schema = sub_schema.get("items")
+            if isinstance(items_schema, dict):
+                # Generate one example item for the array to keep it concise
+                return [DefaultJsonExampleFormatter._generate_example_from_schema(items_schema, full_schema)]
+            else:
+                return ["example_item_1"]
+
+        elif schema_type == "string":
+            description = sub_schema.get("description", "")
+            if "e.g." in description.lower():
+                try:
+                    return description.split("e.g.,")[1].split(')')[0].strip().strip("'\"")
+                except IndexError:
+                    pass
+            return "example_string"
+        
+        elif schema_type == "integer":
+            return 1
+            
+        elif schema_type == "number":
+            return 1.1
+            
+        elif schema_type == "boolean":
+            return True
+        
+        elif schema_type == "null":
+            return None
+
+        return "unknown_type"

autobyteus/tools/usage/formatters/default_xml_example_formatter.py

@@ -1,9 +1,11 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/default_xml_example_formatter.py
 import xml.sax.saxutils
+import json # Import json for embedding complex objects
 from typing import Any, TYPE_CHECKING
 
 from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
+from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 
 if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
@@ -22,8 +24,21 @@ class DefaultXmlExampleFormatter(BaseExampleFormatter):
             for param_def in arg_schema.parameters:
                 if param_def.required or param_def.default_value is not None:
                     placeholder_value = self._generate_placeholder_value(param_def)
-                    escaped_value = xml.sax.saxutils.escape(str(placeholder_value))
-                    arguments_part.append(f'        <arg name="{param_def.name}">{escaped_value}</arg>')
+                    # For complex objects/arrays, we now get a dict/list.
+                    # Convert it to a JSON string for embedding in XML.
+                    if isinstance(placeholder_value, (dict, list)):
+                        value_str = json.dumps(placeholder_value, indent=2)
+                    else:
+                        value_str = str(placeholder_value)
+
+                    escaped_value = xml.sax.saxutils.escape(value_str)
+                    
+                    # Add newlines for readability if the value is a multiline JSON string
+                    if '\n' in escaped_value:
+                        arguments_part.append(f'        <arg name="{param_def.name}">\n{escaped_value}\n        </arg>')
+                    else:
+                        arguments_part.append(f'        <arg name="{param_def.name}">{escaped_value}</arg>')
+
 
         if arguments_part:
             example_xml_parts.append("    <arguments>")
@@ -36,6 +51,11 @@ class DefaultXmlExampleFormatter(BaseExampleFormatter):
         return "\n".join(example_xml_parts)
 
     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)
+
+        # Fallback for primitives
         if param_def.default_value is not None:
             return param_def.default_value
         if param_def.param_type == ParameterType.STRING:
@@ -49,7 +69,7 @@ class DefaultXmlExampleFormatter(BaseExampleFormatter):
         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"}
+            return {"key": "value"} # Fallback if no schema
         if param_def.param_type == ParameterType.ARRAY:
             return ["item1", "item2"]
         return "placeholder"

autobyteus/tools/usage/formatters/gemini_json_example_formatter.py

@@ -3,6 +3,7 @@ from typing import Dict, Any, TYPE_CHECKING
 
 from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
+from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 
 if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
@@ -23,6 +24,11 @@ class GeminiJsonExampleFormatter(BaseExampleFormatter):
         return {"name": tool_name, "args": arguments}
 
     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)
+            
+        # Fallback for primitives
         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

autobyteus/tools/usage/formatters/google_json_example_formatter.py

@@ -3,6 +3,8 @@ from typing import Dict, Any, TYPE_CHECKING
 
 from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
+# Import for reuse of the intelligent example generation logic
+from .default_json_example_formatter import DefaultJsonExampleFormatter
 
 if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
@@ -23,6 +25,11 @@ class GoogleJsonExampleFormatter(BaseExampleFormatter):
         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)
+
+        # Fallback for primitives
         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

autobyteus/tools/usage/formatters/openai_json_example_formatter.py

@@ -4,6 +4,7 @@ from typing import Dict, Any, TYPE_CHECKING
 
 from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
 from .base_formatter import BaseExampleFormatter
+from .default_json_example_formatter import DefaultJsonExampleFormatter # Import for reuse
 
 if TYPE_CHECKING:
     from autobyteus.tools.registry import ToolDefinition
@@ -12,7 +13,6 @@ 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.
-    The output is wrapped in a 'tool' key for consistency in prompts.
     """
 
     def provide(self, tool_definition: 'ToolDefinition') -> Dict:
@@ -25,8 +25,6 @@ class OpenAiJsonExampleFormatter(BaseExampleFormatter):
                 if param_def.required or param_def.default_value is not None:
                     arguments[param_def.name] = self._generate_placeholder_value(param_def)
 
-        # This format contains the 'function' wrapper with a stringified 'arguments' field.
-        # This aligns with the structure often seen inside an OpenAI API tool_calls object.
         function_call = {
             "function": {
                 "name": tool_name,
@@ -34,10 +32,14 @@ class OpenAiJsonExampleFormatter(BaseExampleFormatter):
             },
         }
 
-        # Wrap in a 'tool' key for consistency in prompt generation.
         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)
+
+        # Fallback for primitives
         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