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

autobyteus/tools/multimedia/image_tools.py

@@ -0,0 +1,186 @@
+import os
+import logging
+from typing import Optional, List
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.multimedia.image import image_client_factory, ImageModel, ImageClientFactory
+
+logger = logging.getLogger(__name__)
+
+
+def _get_configured_model_identifier(env_var: str, default_model: Optional[str] = None) -> str:
+    """
+    Retrieves a model identifier from an environment variable, with a fallback to a default.
+    """
+    model_identifier = os.getenv(env_var)
+    if not model_identifier:
+        if default_model:
+            return default_model
+        raise ValueError(f"The '{env_var}' environment variable is not set. Please configure it.")
+    return model_identifier
+
+
+def _build_dynamic_image_schema(base_params: List[ParameterDefinition], model_env_var: str, default_model: str) -> ParameterSchema:
+    """
+    Builds the tool schema dynamically based on the configured image model.
+    """
+    try:
+        model_identifier = _get_configured_model_identifier(model_env_var, default_model)
+        ImageClientFactory.ensure_initialized()
+        model = ImageModel[model_identifier]
+    except (ValueError, KeyError) as e:
+        logger.error(f"Cannot generate image tool schema. Check environment and model registry. Error: {e}")
+        raise RuntimeError(f"Failed to configure image tool. Error: {e}")
+
+    config_schema = ParameterSchema()
+    if model.parameter_schema:
+        for name, meta in model.parameter_schema.items():
+            param_type_str = meta.get("type", "string").upper()
+            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
+            
+            allowed_values = meta.get("allowed_values")
+            if param_type == ParameterType.STRING and allowed_values:
+                param_type = ParameterType.ENUM
+
+            config_schema.add_parameter(ParameterDefinition(
+                name=name,
+                param_type=param_type,
+                description=meta.get("description", ""),
+                required=False,
+                default_value=meta.get("default"),
+                enum_values=allowed_values
+            ))
+
+    schema = ParameterSchema()
+    for param in base_params:
+        schema.add_parameter(param)
+    
+    if config_schema.parameters:
+        schema.add_parameter(ParameterDefinition(
+            name="generation_config",
+            param_type=ParameterType.OBJECT,
+            description=f"Model-specific generation parameters for the configured '{model_identifier}' model.",
+            required=False,
+            object_schema=config_schema
+        ))
+    return schema
+
+
+class GenerateImageTool(BaseTool):
+    """
+    An agent tool for generating images from a text prompt using a pre-configured model.
+    """
+    CATEGORY = ToolCategory.MULTIMEDIA
+    MODEL_ENV_VAR = "DEFAULT_IMAGE_GENERATION_MODEL"
+    DEFAULT_MODEL = "gpt-image-1"
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "GenerateImage"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Generates one or more images based on a textual description (prompt) using the system's default image model. "
+            "Returns a list of URLs to the generated images upon success."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        base_params = [
+            ParameterDefinition(
+                name="prompt",
+                param_type=ParameterType.STRING,
+                description="A detailed textual description of the image to generate.",
+                required=True
+            )
+        ]
+        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) -> 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
+        try:
+            client = image_client_factory.create_image_client(model_identifier=model_identifier)
+            response = await client.generate_image(prompt=prompt, generation_config=generation_config)
+            
+            if not response.image_urls:
+                raise ValueError("Image generation failed to return any image URLs.")
+            
+            return response.image_urls
+        finally:
+            if client:
+                await client.cleanup()
+
+
+class EditImageTool(BaseTool):
+    """
+    An agent tool for editing an existing image using a text prompt and a pre-configured model.
+    """
+    CATEGORY = ToolCategory.MULTIMEDIA
+    MODEL_ENV_VAR = "DEFAULT_IMAGE_GENERATION_MODEL"
+    DEFAULT_MODEL = "gpt-image-1"
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "EditImage"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Edits an existing image based on a textual description (prompt) using the system's default image model. "
+            "A mask can be provided to specify the exact area to edit (inpainting). "
+            "Returns a list of URLs to the edited images."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        base_params = [
+            ParameterDefinition(
+                name="prompt",
+                param_type=ParameterType.STRING,
+                description="A detailed textual description of the edits to apply to the image.",
+                required=True
+            ),
+            ParameterDefinition(
+                name="input_image_urls",
+                param_type=ParameterType.STRING,
+                description="A comma-separated string of URLs to the source images that need to be edited. Some models may only use the first URL.",
+                required=True
+            ),
+            ParameterDefinition(
+                name="mask_image_url",
+                param_type=ParameterType.STRING,
+                description="Optional. A URL to a mask image (PNG). The transparent areas of this mask define where the input image should be edited.",
+                required=False
+            )
+        ]
+        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) -> 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
+        try:
+            urls_list = [url.strip() for url in input_image_urls.split(',') if url.strip()]
+            if not urls_list:
+                raise ValueError("The 'input_image_urls' parameter cannot be empty.")
+
+            client = image_client_factory.create_image_client(model_identifier=model_identifier)
+            response = await client.edit_image(
+                prompt=prompt,
+                input_image_urls=urls_list,
+                mask_url=mask_image_url,
+                generation_config=generation_config
+            )
+
+            if not response.image_urls:
+                raise ValueError("Image editing failed to return any 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/tool_category.py

@@ -17,6 +17,7 @@ class ToolCategory(str, Enum):
     TASK_MANAGEMENT = "Task Management" # NEW CATEGORY ADDED
     GENERAL = "General"
     MCP = "MCP"
+    MULTIMEDIA = "Multimedia"
 
     def __str__(self) -> str:
         return self.value