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

autobyteus/tools/multimedia/image_tools.py

@@ -63,7 +63,7 @@ def _build_dynamic_image_schema(base_params: List[ParameterDefinition], model_en
             param_type=ParameterType.OBJECT,
             description=f"Model-specific generation parameters for the configured '{model_identifier}' model.",
             required=False,
-            object_schema=config_schema.to_json_schema_dict()
+            object_schema=config_schema
         ))
     return schema
 
@@ -99,7 +99,7 @@ class GenerateImageTool(BaseTool):
         ]
         return _build_dynamic_image_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
 
-    async def _execute(self, context, prompt: str, generation_config: Optional[dict] = None) -> str:
+    async def _execute(self, context, prompt: str, generation_config: Optional[dict] = None) -> List[str]:
         model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
         logger.info(f"GenerateImageTool executing with configured model '{model_identifier}'.")
         client = None
@@ -110,7 +110,7 @@ class GenerateImageTool(BaseTool):
             if not response.image_urls:
                 raise ValueError("Image generation failed to return any image URLs.")
             
-            return f"Image generation successful. URLs: {response.image_urls}"
+            return response.image_urls
         finally:
             if client:
                 await client.cleanup()
@@ -160,7 +160,7 @@ class EditImageTool(BaseTool):
         ]
         return _build_dynamic_image_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
 
-    async def _execute(self, context, prompt: str, input_image_urls: str, generation_config: Optional[dict] = None, mask_image_url: Optional[str] = None) -> str:
+    async def _execute(self, context, prompt: str, input_image_urls: str, generation_config: Optional[dict] = None, mask_image_url: Optional[str] = None) -> List[str]:
         model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
         logger.info(f"EditImageTool executing with configured model '{model_identifier}'.")
         client = None
@@ -180,7 +180,7 @@ class EditImageTool(BaseTool):
             if not response.image_urls:
                 raise ValueError("Image editing failed to return any image URLs.")
 
-            return f"Image editing successful. URLs: {response.image_urls}"
+            return response.image_urls
         finally:
             if client:
                 await client.cleanup()

autobyteus/tools/parameter_schema.py

@@ -1,4 +1,5 @@
 # file: autobyteus/autobyteus/tools/parameter_schema.py
+from __future__ import annotations
 import logging
 from typing import Dict, Any, List, Optional, Union, Type
 from dataclasses import dataclass, field
@@ -41,8 +42,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
-    object_schema: Optional[Dict[str, Any]] = None
+    # FIX: Allow dict for raw JSON schemas, in addition to ParameterType and ParameterSchema.
+    array_item_schema: Optional[Union[ParameterType, ParameterSchema, dict]] = None
+    object_schema: Optional[ParameterSchema] = None
 
     def __post_init__(self):
         if not self.name or not isinstance(self.name, str):
@@ -54,8 +56,15 @@ class ParameterDefinition:
         if self.param_type == ParameterType.ENUM and not self.enum_values:
             raise ValueError(f"ParameterDefinition '{self.name}' of type ENUM must specify enum_values")
         
+        # FIX: Update validation to allow dict for array_item_schema.
+        if self.array_item_schema is not None and not isinstance(self.array_item_schema, (ParameterType, ParameterSchema, dict)):
+            raise ValueError(f"ParameterDefinition '{self.name}': array_item_schema must be a ParameterType, ParameterSchema, or dict instance.")
+
+        if self.object_schema is not None and not isinstance(self.object_schema, ParameterSchema):
+            raise ValueError(f"ParameterDefinition '{self.name}': object_schema must be a ParameterSchema instance.")
+            
         if self.param_type == ParameterType.ARRAY and self.array_item_schema is None:
-            logger.debug(f"ParameterDefinition '{self.name}' of type ARRAY has no array_item_schema. Will be represented as a generic array.")
+            logger.debug(f"ParameterDefinition '{self.name}' of type ARRAY has no item schema. Will be a generic array of any type.")
 
         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.")
@@ -71,44 +80,30 @@ class ParameterDefinition:
             return not self.required 
 
         if self.param_type == ParameterType.STRING:
-            if not isinstance(value, str):
-                return False
-            if self.pattern:
-                if not re.match(self.pattern, value):
-                    return False 
+            if not isinstance(value, str): return False
+            if self.pattern and not re.match(self.pattern, value): return False 
         
         elif self.param_type == ParameterType.INTEGER:
-            if not isinstance(value, int): 
-                if isinstance(value, bool): return False
-                return False
-            if self.min_value is not None and value < self.min_value:
-                return False
-            if self.max_value is not None and value > self.max_value:
-                return False
+            if not isinstance(value, int) or isinstance(value, bool): return False
+            if self.min_value is not None and value < self.min_value: return False
+            if self.max_value is not None and value > self.max_value: return False
         
         elif self.param_type == ParameterType.FLOAT:
-            if not isinstance(value, (float, int)): 
-                return False
-            if self.min_value is not None and float(value) < self.min_value:
-                return False
-            if self.max_value is not None and float(value) > self.max_value:
-                return False
+            if not isinstance(value, (float, int)): return False
+            if self.min_value is not None and float(value) < self.min_value: return False
+            if self.max_value is not None and float(value) > self.max_value: return False
         
         elif self.param_type == ParameterType.BOOLEAN:
-            if not isinstance(value, bool):
-                return False
+            if not isinstance(value, bool): return False
         
         elif self.param_type == ParameterType.ENUM:
-            if not isinstance(value, str) or value not in (self.enum_values or []):
-                return False
+            if not isinstance(value, str) or value not in (self.enum_values or []): return False
         
         elif self.param_type == ParameterType.OBJECT:
-            if not isinstance(value, dict):
-                return False
+            if not isinstance(value, dict): return False
         
         elif self.param_type == ParameterType.ARRAY:
-            if not isinstance(value, list):
-                return False
+            if not isinstance(value, list): return False
 
         return True
 
@@ -124,17 +119,22 @@ class ParameterDefinition:
             "max_value": self.max_value,
             "pattern": self.pattern,
         }
+        # FIX: Correctly serialize dicts for array_item_schema.
         if self.param_type == ParameterType.ARRAY and self.array_item_schema is not None:
-            data["array_item_schema"] = self.array_item_schema
+            if isinstance(self.array_item_schema, ParameterSchema):
+                data["array_item_schema"] = self.array_item_schema.to_dict()
+            elif isinstance(self.array_item_schema, dict):
+                data["array_item_schema"] = self.array_item_schema
+            elif isinstance(self.array_item_schema, ParameterType):
+                data["array_item_schema"] = {"type": self.array_item_schema.value}
+
         if self.param_type == ParameterType.OBJECT and self.object_schema is not None:
-            data["object_schema"] = self.object_schema
+            data["object_schema"] = self.object_schema.to_dict()
         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 = self.object_schema.to_json_schema_dict()
             schema["description"] = self.description
             return schema
 
@@ -148,40 +148,37 @@ class ParameterDefinition:
         if self.param_type == ParameterType.ENUM and self.enum_values:
             prop_dict["enum"] = self.enum_values
         
-        if self.min_value is not None:
-            if self.param_type in [ParameterType.INTEGER, ParameterType.FLOAT]:
-                prop_dict["minimum"] = self.min_value
+        if self.min_value is not None and self.param_type in [ParameterType.INTEGER, ParameterType.FLOAT]:
+            prop_dict["minimum"] = self.min_value
         
-        if self.max_value is not None:
-            if self.param_type in [ParameterType.INTEGER, ParameterType.FLOAT]:
-                prop_dict["maximum"] = self.max_value
+        if self.max_value is not None and self.param_type in [ParameterType.INTEGER, ParameterType.FLOAT]:
+            prop_dict["maximum"] = self.max_value
         
         if self.pattern and self.param_type == ParameterType.STRING:
             prop_dict["pattern"] = self.pattern
             
+        # FIX: Correctly handle dicts when generating the 'items' part of an array schema.
         if self.param_type == ParameterType.ARRAY:
-            if self.array_item_schema is not None:
+            if isinstance(self.array_item_schema, ParameterSchema):
+                prop_dict["items"] = self.array_item_schema.to_json_schema_dict()
+            elif isinstance(self.array_item_schema, dict):
                 prop_dict["items"] = self.array_item_schema
+            elif isinstance(self.array_item_schema, ParameterType):
+                prop_dict["items"] = {"type": self.array_item_schema.to_json_schema_type()}
             else:
                 prop_dict["items"] = True 
-                logger.debug(f"Parameter '{self.name}' is ARRAY type with no item schema; JSON schema 'items' will be generic.")
         
         return prop_dict
 
 @dataclass
 class ParameterSchema:
-    """
-    Describes a schema for a set of parameters, either for tool arguments or instantiation configuration.
-    """
     parameters: List[ParameterDefinition] = field(default_factory=list)
     
     def add_parameter(self, parameter: ParameterDefinition) -> None:
         if not isinstance(parameter, ParameterDefinition):
             raise TypeError("parameter must be a ParameterDefinition instance")
-        
         if any(p.name == parameter.name for p in self.parameters):
             raise ValueError(f"Parameter '{parameter.name}' already exists in schema")
-        
         self.parameters.append(parameter)
 
     def get_parameter(self, name: str) -> Optional[ParameterDefinition]:
@@ -189,67 +186,64 @@ class ParameterSchema:
 
     def validate_config(self, config_data: Dict[str, Any]) -> tuple[bool, List[str]]:
         errors = []
-        
         for param_def in self.parameters:
             if param_def.required and param_def.name not in config_data:
                 errors.append(f"Required parameter '{param_def.name}' is missing.")
-        
         for key, value in config_data.items():
             param_def = self.get_parameter(key)
             if not param_def:
-                logger.debug(f"Unknown parameter '{key}' provided. It will be ignored by schema-based processing but passed through if possible.")
+                logger.debug(f"Unknown parameter '{key}' provided. It will be ignored.")
                 continue 
-            
             if not param_def.validate_value(value):
                 errors.append(f"Invalid value for parameter '{param_def.name}': '{str(value)[:50]}...'. Expected type compatible with {param_def.param_type.value}.")
-
         return len(errors) == 0, errors
 
-    def get_defaults(self) -> Dict[str, Any]:
-        return {
-            param.name: param.default_value 
-            for param in self.parameters 
-            if param.default_value is not None
-        }
-
     def to_dict(self) -> Dict[str, Any]:
-        return {
-            "parameters": [param.to_dict() for param in self.parameters]
-        }
+        return {"parameters": [param.to_dict() for param in self.parameters]}
 
     def to_json_schema_dict(self) -> Dict[str, Any]:
         if not self.parameters:
-             return {
-                "type": "object",
-                "properties": {},
-                "required": []
-            }
-
-        properties = {
-            param.name: param.to_json_schema_property_dict()
-            for param in self.parameters
-        }
-        required = [
-            param.name for param in self.parameters if param.required
-        ]
-        
-        return {
-            "type": "object",
-            "properties": properties,
-            "required": required,
-        }
+             return {"type": "object", "properties": {}, "required": []}
+        properties = {p.name: p.to_json_schema_property_dict() for p in self.parameters}
+        required = [p.name for p in self.parameters if p.required]
+        return {"type": "object", "properties": properties, "required": required}
 
     @classmethod
     def from_dict(cls, schema_data: Dict[str, Any]) -> 'ParameterSchema':
         schema = cls()
-        
         for param_data in schema_data.get("parameters", []):
-            param_type_value = param_data["type"]
             try:
-                param_type_enum = ParameterType(param_type_value)
+                param_type_enum = ParameterType(param_data["type"])
             except ValueError:
-                raise ValueError(f"Invalid parameter type string '{param_type_value}' in schema data for parameter '{param_data.get('name')}'.")
+                raise ValueError(f"Invalid parameter type string '{param_data['type']}' for param '{param_data.get('name')}'.")
+            
+            array_schema_obj = None
+            if "array_item_schema" in param_data and param_data["array_item_schema"] is not None:
+                item_schema_data = param_data["array_item_schema"]
+                
+                # FIX: Add robust logic to deserialize array_item_schema correctly.
+                if isinstance(item_schema_data, dict):
+                    if "parameters" in item_schema_data:
+                        # It's our internal ParameterSchema format.
+                        array_schema_obj = ParameterSchema.from_dict(item_schema_data)
+                    elif "type" in item_schema_data and len(item_schema_data) == 1:
+                        # Heuristic: it's a simple primitive type like {'type': 'string'}.
+                        try:
+                            array_schema_obj = ParameterType(item_schema_data["type"])
+                        except ValueError:
+                            # Not a valid ParameterType, so treat it as a raw schema dict.
+                            array_schema_obj = item_schema_data
+                    else:
+                        # It's a complex JSON schema dict, store it as is.
+                        array_schema_obj = item_schema_data
+                else:
+                    # Should not be hit if serialized with to_dict, but handle for robustness.
+                    array_schema_obj = item_schema_data
 
+            object_schema_obj = None
+            if "object_schema" in param_data and param_data["object_schema"] is not None:
+                object_schema_obj = ParameterSchema.from_dict(param_data["object_schema"])
+                
             param = ParameterDefinition(
                 name=param_data["name"],
                 param_type=param_type_enum,
@@ -260,15 +254,14 @@ 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"),
-                object_schema=param_data.get("object_schema")
+                array_item_schema=array_schema_obj,
+                object_schema=object_schema_obj
             )
             schema.add_parameter(param)
-        
         return schema
 
     def __len__(self) -> int:
         return len(self.parameters)
 
     def __bool__(self) -> bool:
-        return len(self.parameters) > 0
+        return bool(self.parameters)

autobyteus/tools/pydantic_schema_converter.py

@@ -0,0 +1,81 @@
+# file: autobyteus/autobyteus/tools/pydantic_to_parameter_schema.py
+import logging
+from typing import Type, get_origin, get_args, Union, List, Dict
+from pydantic import BaseModel
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+
+logger = logging.getLogger(__name__)
+
+_PYDANTIC_TYPE_MAP = {
+    str: ParameterType.STRING,
+    int: ParameterType.INTEGER,
+    float: ParameterType.FLOAT,
+    bool: ParameterType.BOOLEAN,
+    dict: ParameterType.OBJECT,
+    list: ParameterType.ARRAY,
+}
+
+def pydantic_to_parameter_schema(pydantic_model: Type[BaseModel]) -> ParameterSchema:
+    """
+    Converts a Pydantic BaseModel into an AutoByteUs ParameterSchema.
+
+    This function inspects the Pydantic model's fields and recursively builds a
+    corresponding ParameterSchema, handling nested models and lists of models.
+
+    Args:
+        pydantic_model: The Pydantic model class to convert.
+
+    Returns:
+        A fully constructed ParameterSchema object.
+    """
+    schema = ParameterSchema()
+    required_fields = {name for name, field_info in pydantic_model.model_fields.items() if field_info.is_required()}
+
+    for field_name, field_info in pydantic_model.model_fields.items():
+        param_type = ParameterType.STRING # Default
+        object_schema = None
+        array_item_schema = None
+        
+        # Determine if the type is Optional (e.g., Union[str, None])
+        is_optional = False
+        field_type = field_info.annotation
+        origin_type = get_origin(field_type)
+        
+        if origin_type is Union:
+            union_args = get_args(field_type)
+            if type(None) in union_args:
+                is_optional = True
+            # Get the non-None type from the Union
+            non_none_args = [arg for arg in union_args if arg is not type(None)]
+            if len(non_none_args) == 1:
+                field_type = non_none_args[0]
+                origin_type = get_origin(field_type)
+        
+        if origin_type is list or origin_type is List:
+            param_type = ParameterType.ARRAY
+            list_item_type = get_args(field_type)[0] if get_args(field_type) else any
+            if isinstance(list_item_type, type) and issubclass(list_item_type, BaseModel):
+                # FIX: Recursively call the converter for the nested Pydantic model.
+                array_item_schema = pydantic_to_parameter_schema(list_item_type)
+            else:
+                # Fallback for list of primitives
+                primitive_type_str = _PYDANTIC_TYPE_MAP.get(list_item_type, ParameterType.STRING).value
+                array_item_schema = {"type": primitive_type_str}
+        
+        elif isinstance(field_type, type) and issubclass(field_type, BaseModel):
+            param_type = ParameterType.OBJECT
+            # Recursively convert the nested Pydantic model
+            object_schema = pydantic_to_parameter_schema(field_type)
+        else:
+            param_type = _PYDANTIC_TYPE_MAP.get(field_type, ParameterType.STRING)
+
+        schema.add_parameter(ParameterDefinition(
+            name=field_name,
+            param_type=param_type,
+            description=field_info.description or f"Parameter '{field_name}'.",
+            required=field_name in required_fields and not is_optional,
+            object_schema=object_schema,
+            array_item_schema=array_item_schema
+        ))
+
+    return schema

autobyteus/tools/usage/formatters/default_json_example_formatter.py

@@ -1,7 +1,8 @@
 # file: autobyteus/autobyteus/tools/usage/formatters/default_json_example_formatter.py
-from typing import Dict, Any, TYPE_CHECKING, List, Optional
+import json
+from typing import Dict, Any, TYPE_CHECKING, List, Optional, Union
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition
+from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
 from .base_formatter import BaseExampleFormatter
 
 if TYPE_CHECKING:
@@ -10,20 +11,47 @@ if TYPE_CHECKING:
 class DefaultJsonExampleFormatter(BaseExampleFormatter):
     """
     Formats a tool usage example into a generic JSON format.
-    It intelligently generates detailed examples for complex object schemas.
+    It intelligently generates detailed examples for complex object schemas, providing
+    both a basic (required parameters only) and an advanced (all parameters) example
+    if optional parameters are available.
     """
 
-    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 the full tool call example structure 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:
-                # 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)
+            params_to_render = arg_schema.parameters
+            if mode == 'basic':
+                # In basic mode, we only render required parameters.
+                params_to_render = [p for p in arg_schema.parameters if p.required]
+            
+            for param_def in params_to_render:
+                arguments[param_def.name] = self._generate_placeholder_value(param_def, mode=mode)
 
         return {
             "tool": {
@@ -32,12 +60,34 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
             },
         }
 
-    def _generate_placeholder_value(self, param_def: ParameterDefinition) -> Any:
+    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  # Found an optional param at this level
+            if param.object_schema and self._schema_has_advanced_params(param.object_schema):
+                return True  # Found an optional param in a nested object
+            if isinstance(param.array_item_schema, ParameterSchema) and self._schema_has_advanced_params(param.array_item_schema):
+                return True  # Found an optional param in an array of objects
+        return False
+
+    def _generate_placeholder_value(self, param_def: ParameterDefinition, mode: str = 'basic') -> Any:
+        """
+        Generates a placeholder value for a parameter, recursing for complex types.
+        The mode determines whether to include optional fields in nested structures.
+        """
         # 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)
+            return DefaultJsonExampleFormatter._generate_example_from_schema(param_def.object_schema, param_def.object_schema, mode=mode)
         
+        # Handle arrays with a detailed item schema.
+        if param_def.param_type == ParameterType.ARRAY and param_def.array_item_schema:
+            # Generate one example item for the array to keep it concise.
+            example_item = DefaultJsonExampleFormatter._generate_example_from_schema(param_def.array_item_schema, param_def.array_item_schema, mode=mode)
+            return [example_item]
+
         # 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}"
@@ -46,15 +96,34 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
         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"]
+        if param_def.param_type == ParameterType.ARRAY: return ["item1", "item2"] # This now only applies to generic arrays
         return "placeholder"
 
     @staticmethod
-    def _generate_example_from_schema(sub_schema: Dict[str, Any], full_schema: Dict[str, Any]) -> Any:
+    def _generate_example_from_schema(
+        sub_schema: Union[Dict[str, Any], 'ParameterSchema', 'ParameterType'], 
+        full_schema: Union[Dict[str, Any], 'ParameterSchema', 'ParameterType'], 
+        mode: str = 'basic'
+    ) -> Any:
         """
         Recursively generates an example value from a JSON schema dictionary.
         This is a static method so it can be reused by other formatters.
+        The 'mode' parameter controls whether optional fields are included in nested objects.
+        The default mode is 'basic' to maintain backward compatibility.
         """
+        # FIX: Handle primitive ParameterType for array items directly.
+        if isinstance(sub_schema, ParameterType):
+            if sub_schema == ParameterType.STRING: return "example_string"
+            if sub_schema == ParameterType.INTEGER: return 1
+            if sub_schema == ParameterType.FLOAT: return 1.1
+            if sub_schema == ParameterType.BOOLEAN: return True
+            return "unknown_primitive"
+
+        if isinstance(sub_schema, ParameterSchema):
+            sub_schema = sub_schema.to_json_schema_dict()
+        if isinstance(full_schema, ParameterSchema):
+            full_schema = full_schema.to_json_schema_dict()
+
         if "$ref" in sub_schema:
             ref_path = sub_schema["$ref"]
             try:
@@ -63,7 +132,7 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
                 resolved_schema = full_schema
                 for part in parts:
                     resolved_schema = resolved_schema[part]
-                return DefaultJsonExampleFormatter._generate_example_from_schema(resolved_schema, full_schema)
+                return DefaultJsonExampleFormatter._generate_example_from_schema(resolved_schema, full_schema, mode=mode)
             except (KeyError, IndexError):
                 return {"error": f"Could not resolve schema reference: {ref_path}"}
 
@@ -80,16 +149,16 @@ class DefaultJsonExampleFormatter(BaseExampleFormatter):
             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)
+                # Include fields if in 'advanced' mode or if they are required.
+                if mode == 'advanced' or prop_name in required_fields:
+                    example_obj[prop_name] = DefaultJsonExampleFormatter._generate_example_from_schema(prop_schema, full_schema, mode=mode)
             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)]
+                # Generate one example item for the array to keep it concise.
+                return [DefaultJsonExampleFormatter._generate_example_from_schema(items_schema, full_schema, mode=mode)]
             else:
                 return ["example_item_1"]