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

autobyteus/tools/mcp/schema_mapper.py

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/mcp/schema_mapper.py
+# file: autobyteus/autobyteus/tools/mcp/schema_mapper.py
 import logging
 from typing import Dict, Any, List, Optional
 
@@ -8,7 +8,8 @@ logger = logging.getLogger(__name__)
 
 class McpSchemaMapper:
     """
-    Converts MCP tool JSON schemas to AutoByteUs ParameterSchema.
+    Converts MCP tool JSON schemas to AutoByteUs ParameterSchema,
+    handling nested object structures recursively.
     """
 
     _MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP = {
@@ -19,12 +20,6 @@ class McpSchemaMapper:
         "object": ParameterType.OBJECT, 
         "array": ParameterType.ARRAY,   
     }
-    
-    # REMOVED: _FILE_PATH_NAMES, _DIR_PATH_PARAM_NAMES, _URI_FORMATS
-    # as FILE_PATH and DIRECTORY_PATH types are removed.
-    # All string-based path parameters will now be ParameterType.STRING.
-    # The 'format' hint from MCP schema (e.g., "uri", "url") will still be available
-    # on the ParameterDefinition if it includes 'pattern', but it won't change the type from STRING.
 
     def map_to_autobyteus_schema(self, mcp_json_schema: Dict[str, Any]) -> ParameterSchema:
         if not isinstance(mcp_json_schema, dict):
@@ -37,95 +32,58 @@ class McpSchemaMapper:
 
         schema_type = mcp_json_schema.get("type")
         if schema_type != "object":
-            logger.warning(f"MCP JSON schema root 'type' is '{schema_type}', not 'object'. "
-                           "Mapping may be incomplete or incorrect for non-object root schemas.")
-            if schema_type in McpSchemaMapper._MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP:
-                 param_type_enum = McpSchemaMapper._MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP[schema_type]
-                 array_item_schema_for_root: Optional[Dict[str, Any]] = None
-                 if param_type_enum == ParameterType.ARRAY:
-                     array_item_schema_for_root = mcp_json_schema.get("items", True) 
-
-                 param_def = ParameterDefinition(
-                     name="input_value", 
-                     param_type=param_type_enum,
-                     description=mcp_json_schema.get("description", "Input value for the tool."),
-                     required=True, 
-                     default_value=mcp_json_schema.get("default"),
-                     enum_values=mcp_json_schema.get("enum") if schema_type == "string" else None,
-                     array_item_schema=array_item_schema_for_root
-                 )
-                 autobyteus_schema.add_parameter(param_def)
-                 return autobyteus_schema
-            else: 
-                logger.error(f"Unsupported root schema type '{schema_type}' for direct mapping to ParameterSchema properties.")
-                raise ValueError(f"MCP JSON schema root 'type' must be 'object' for typical mapping, got '{schema_type}'.")
-
+            logger.error(f"Unsupported root schema type '{schema_type}' for mapping to ParameterSchema. Must be 'object'.")
+            raise ValueError(f"MCP JSON schema root 'type' must be 'object', got '{schema_type}'.")
 
         properties = mcp_json_schema.get("properties")
         if not isinstance(properties, dict):
-            logger.warning("MCP JSON schema of type 'object' has no 'properties' or 'properties' is not a dict. Resulting ParameterSchema will be empty.")
+            logger.warning("MCP JSON schema of type 'object' has no 'properties'. Resulting ParameterSchema will be empty.")
             return autobyteus_schema 
-
-        required_params: List[str] = mcp_json_schema.get("required", [])
-        if not isinstance(required_params, list) or not all(isinstance(p, str) for p in required_params):
-            logger.warning("MCP JSON schema 'required' field is not a list of strings. Treating all params as optional.")
-            required_params = []
+        
+        # FIX: The 'required' list is specific to its own schema level.
+        required_params_at_this_level: List[str] = mcp_json_schema.get("required", [])
 
         for param_name, param_mcp_schema in properties.items():
             if not isinstance(param_mcp_schema, dict):
-                logger.warning(f"Property '{param_name}' in MCP schema is not a dictionary. Skipping this parameter.")
+                logger.warning(f"Property '{param_name}' in MCP schema is not a dictionary. Skipping.")
                 continue
 
             mcp_param_type_str = param_mcp_schema.get("type")
             description = param_mcp_schema.get("description", f"Parameter '{param_name}'.")
-            default_value = param_mcp_schema.get("default")
-            enum_values = param_mcp_schema.get("enum")
-            # format_hint is still read but won't be used to change type to FILE_PATH/DIR_PATH
-            # format_hint = param_mcp_schema.get("format", "").lower() 
             
+            nested_object_schema: Optional[ParameterSchema] = None
             item_schema_for_array: Optional[Dict[str, Any]] = None
-            if mcp_param_type_str == "array":
-                item_schema_for_array = param_mcp_schema.get("items")
-                if item_schema_for_array is None: 
-                    item_schema_for_array = True 
-                    logger.debug(f"MCP parameter '{param_name}' is 'array' type with no 'items' schema. Defaulting to generic items (true).")
-            
-            autobyteus_param_type: Optional[ParameterType] = None
-            # REMOVED: Logic block that inferred FILE_PATH or DIRECTORY_PATH based on format_hint or param_name_lower.
-            # All string types from MCP will now map to STRING or ENUM.
 
-            if mcp_param_type_str in McpSchemaMapper._MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP:
-                autobyteus_param_type = McpSchemaMapper._MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP[mcp_param_type_str]
-                if autobyteus_param_type == ParameterType.STRING and enum_values: 
-                    autobyteus_param_type = ParameterType.ENUM
-            elif mcp_param_type_str: 
-                logger.warning(f"Unsupported MCP parameter type '{mcp_param_type_str}' for parameter '{param_name}'. Defaulting to STRING.")
-                autobyteus_param_type = ParameterType.STRING
-            else: 
-                logger.warning(f"MCP parameter '{param_name}' has no 'type' specified. Defaulting to STRING.")
-                autobyteus_param_type = ParameterType.STRING
+            if mcp_param_type_str == "object" and "properties" in param_mcp_schema:
+                # Recursively map the nested object schema. The recursive call will handle its own 'required' list.
+                nested_object_schema = self.map_to_autobyteus_schema(param_mcp_schema)
             
-            if autobyteus_param_type == ParameterType.ENUM:
-                if not enum_values or not isinstance(enum_values, list) or not all(isinstance(ev, str) for ev in enum_values):
-                    logger.warning(f"Parameter '{param_name}' is ENUM type but 'enum' field is missing, not a list, or not list of strings in MCP schema. Problematic. Schema: {enum_values}")
+            elif mcp_param_type_str == "array":
+                item_schema_for_array = param_mcp_schema.get("items", True)
+            
+            autobyteus_param_type = self._MCP_TYPE_TO_AUTOBYTEUS_TYPE_MAP.get(mcp_param_type_str, ParameterType.STRING)
+            enum_values = param_mcp_schema.get("enum")
+            if autobyteus_param_type == ParameterType.STRING and enum_values: 
+                autobyteus_param_type = ParameterType.ENUM
 
             try:
                 param_def = ParameterDefinition(
                     name=param_name,
-                    param_type=autobyteus_param_type, # This will now be STRING for former path types
+                    param_type=autobyteus_param_type,
                     description=description,
-                    required=(param_name in required_params),
-                    default_value=default_value,
+                    required=(param_name in required_params_at_this_level), # FIX: Use the list for the current level.
+                    default_value=param_mcp_schema.get("default"),
                     enum_values=enum_values if autobyteus_param_type == ParameterType.ENUM else None,
                     min_value=param_mcp_schema.get("minimum"),
                     max_value=param_mcp_schema.get("maximum"),
-                    pattern=param_mcp_schema.get("pattern") if mcp_param_type_str == "string" else None,
-                    array_item_schema=item_schema_for_array 
+                    pattern=param_mcp_schema.get("pattern"),
+                    array_item_schema=item_schema_for_array,
+                    object_schema=nested_object_schema,
                 )
                 autobyteus_schema.add_parameter(param_def)
             except ValueError as e:
-                 logger.error(f"Failed to create ParameterDefinition for '{param_name}': {e}. MCP schema for param: {param_mcp_schema}")
+                 logger.error(f"Failed to create ParameterDefinition for '{param_name}': {e}.")
                  continue
 
-        logger.debug(f"Successfully mapped MCP schema to AutoByteUs ParameterSchema with {len(autobyteus_schema.parameters)} parameters.")
+        logger.debug(f"Successfully mapped MCP schema to ParameterSchema with {len(autobyteus_schema.parameters)} params.")
         return autobyteus_schema

autobyteus/tools/multimedia/audio_tools.py

@@ -63,7 +63,7 @@ def _build_dynamic_audio_schema(base_params: List[ParameterDefinition], model_en
             param_type=ParameterType.OBJECT,
             description=f"Model-specific 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 GenerateSpeechTool(BaseTool):
         ]
         return _build_dynamic_audio_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"GenerateSpeechTool executing with configured model '{model_identifier}'.")
         client = None
@@ -110,7 +110,7 @@ class GenerateSpeechTool(BaseTool):
             if not response.audio_urls:
                 raise ValueError("Speech generation failed to return any audio file paths.")
             
-            return f"Speech generation successful. Audio file(s) saved at: {response.audio_urls}"
+            return response.audio_urls
         finally:
             if client:
                 await client.cleanup()

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