removed hosted image gen

giles17 · giles17 · commit 225ede0c5a9a · 2025-09-19T09:44:24.000-07:00
diff --git a/python/packages/main/agent_framework/_tools.py b/python/packages/main/agent_framework/_tools.py
@@ -22,7 +22,7 @@
 )
 
 from opentelemetry import metrics
-from pydantic import AnyUrl, BaseModel, ConfigDict, Field, PrivateAttr, ValidationError, create_model, field_validator
+from pydantic import AnyUrl, BaseModel, Field, PrivateAttr, ValidationError, create_model, field_validator
 
 from ._logging import get_logger
 from ._pydantic import AFBaseModel
@@ -58,7 +58,6 @@
     "AIFunction",
     "HostedCodeInterpreterTool",
     "HostedFileSearchTool",
-    "HostedImageGenerationTool",
     "HostedMCPSpecificApproval",
     "HostedMCPTool",
     "HostedWebSearchTool",
@@ -236,93 +235,6 @@ def __init__(
         super().__init__(**args, **kwargs)
 
 
-class HostedImageGenerationTool(BaseTool):
-    """Represents an image generation tool that can be specified to an AI service to enable it to generate images."""
-
-    # Allow extra fields for provider-specific parameters
-    model_config = ConfigDict(extra="allow")
-
-    # Image generation parameters
-    size: Literal["1024x1024", "1536x1024", "1024x1536", "auto"] | None = None
-    quality: Literal["low", "medium", "high", "auto"] | None = None
-    format: Literal["png", "jpeg", "webp"] | None = None
-    compression: int | None = None
-    background: Literal["transparent", "opaque", "auto"] | None = None
-
-    def __init__(
-        self,
-        description: str | None = None,
-        size: Literal["1024x1024", "1536x1024", "1024x1536", "auto"] | None = None,
-        quality: Literal["low", "medium", "high", "auto"] | None = None,
-        format: Literal["png", "jpeg", "webp"] | None = None,
-        compression: int | None = None,
-        background: Literal["transparent", "opaque", "auto"] | None = None,
-        additional_properties: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ):
-        """Initialize a HostedImageGenerationTool.
-
-        Args:
-            description: A description of the tool.
-            size: Image dimensions. Defaults to "auto".
-                - "1024x1024": Square format
-                - "1536x1024": Landscape format
-                - "1024x1536": Portrait format
-                - "auto": Model automatically selects best size based on prompt
-            quality: Rendering quality. Defaults to "auto".
-                - "low": Low quality, fastest generation
-                - "medium": Medium quality
-                - "high": High quality, slower generation
-                - "auto": Model automatically selects best quality based on prompt
-            format: File output format. Defaults to "png".
-                - "png": PNG format (default)
-                - "jpeg": JPEG format
-                - "webp": WebP format
-            compression: Compression level (0-100%) for JPEG and WebP formats only.
-                Higher values mean more compression (smaller file, lower quality).
-                Only applicable when format is "jpeg" or "webp".
-            background: Background type. Defaults to "auto". (only supported by 'gpt-image-1' and with png and webp)
-                - "transparent": Transparent background
-                - "opaque": Opaque background
-                - "auto": Model automatically selects based on prompt
-            additional_properties: Additional properties associated with the tool.
-            **kwargs: Additional keyword arguments to pass to the base class.
-                Provider-specific parameters can be passed as kwargs.
-        """
-        # Validate compression parameter
-        if compression is not None:
-            if not isinstance(compression, int) or not (0 <= compression <= 100):
-                raise ValueError("compression must be an integer between 0 and 100")
-            if format not in ("jpeg", "webp"):
-                raise ValueError("compression parameter only applies to 'jpeg' and 'webp' formats")
-
-        if "name" in kwargs:
-            raise ValueError("The 'name' argument is reserved for the HostedImageGenerationTool and cannot be set.")
-
-        # Pass all parameters to the parent class
-        args: dict[str, Any] = {
-            "name": "image_generation",
-            "size": size,
-            "quality": quality,
-            "format": format,
-            "compression": compression,
-            "background": background,
-        }
-
-        if description is not None:
-            args["description"] = description
-        if additional_properties is not None:
-            args["additional_properties"] = additional_properties
-
-        super().__init__(**args)
-
-        # Handle OpenAI-specific parameters as attributes
-        openai_params = ["model", "moderation", "partial_images", "input_fidelity", "input_image_mask"]
-        for param in openai_params:
-            if param in kwargs:
-                setattr(self, param, kwargs[param])
-
-
 class HostedMCPSpecificApproval(TypedDict, total=False):
     """Represents the `specific` mode for a hosted tool.
 
diff --git a/python/packages/main/agent_framework/_types.py b/python/packages/main/agent_framework/_types.py
@@ -2108,14 +2108,6 @@ async def from_agent_response_generator(
     def __str__(self) -> str:
         return self.text
 
-    def try_parse_value(self, output_format_type: type[BaseModel]) -> None:
-        """If there is a value, does nothing, otherwise tries to parse the text into the value."""
-        if self.value is None:
-            try:
-                self.value = output_format_type.model_validate_json(self.text)  # type: ignore[reportUnknownMemberType]
-            except ValidationError as ex:
-                logger.debug("Failed to parse value from agent run response text: %s", ex)
-
 
 # region AgentRunResponseUpdate
 
diff --git a/python/packages/main/agent_framework/openai/_responses_client.py b/python/packages/main/agent_framework/openai/_responses_client.py
@@ -30,7 +30,6 @@
     AIFunction,
     HostedCodeInterpreterTool,
     HostedFileSearchTool,
-    HostedImageGenerationTool,
     HostedMCPTool,
     HostedWebSearchTool,
     ToolProtocol,
@@ -270,59 +269,102 @@ def _tools_to_response_tools(
                                 else None,
                             )
                         )
-                    case HostedImageGenerationTool():
-                        image_tool: dict[str, Any] = {"type": "image_generation"}
-
-                        # Handle base parameters as direct attributes
-                        if tool.size is not None:
-                            image_tool["size"] = tool.size
-                        if tool.quality is not None:
-                            image_tool["quality"] = tool.quality
-                        if tool.background is not None:
-                            image_tool["background"] = tool.background
-
-                        # Map developer-friendly parameter names to OpenAI API names
-                        if tool.format is not None:
-                            image_tool["output_format"] = tool.format
-                        if tool.compression is not None:
-                            image_tool["output_compression"] = tool.compression
-
-                        # Handle OpenAI Responses-specific parameters
-                        openai_param_names = [
-                            "model",
-                            "moderation",
-                            "partial_images",
-                            "input_fidelity",
-                            "input_image_mask",
-                        ]
-                        for param in openai_param_names:
-                            value = getattr(tool, param, None)
-                            if value is not None:
-                                # Validate OpenAI Responses-specific parameters
-                                if param == "partial_images" and (not isinstance(value, int) or not (0 <= value <= 3)):
-                                    raise ValueError("partial_images must be an integer between 0 and 3")
-                                if param == "input_fidelity" and value not in ("high", "low"):
-                                    raise ValueError("input_fidelity must be 'high' or 'low'")
-                                if param == "input_image_mask":
-                                    if not isinstance(value, dict):
-                                        raise ValueError("input_image_mask must be a dictionary")
-                                    # Validate that it has at least one of the required fields
-                                    if not any(key in value for key in ["file_id", "image_url"]):
-                                        raise ValueError(
-                                            "input_image_mask must contain at least one of 'file_id' or 'image_url'"
-                                        )
-                                    # Validate field types if present
-                                    if "file_id" in value and not isinstance(value["file_id"], str):
-                                        raise ValueError("input_image_mask.file_id must be a string")
-                                    if "image_url" in value and not isinstance(value["image_url"], str):
-                                        raise ValueError("input_image_mask.image_url must be a string")
-                                image_tool[param] = value
-
-                        response_tools.append(image_tool)
+
                     case _:
                         logger.debug("Unsupported tool passed (type: %s)", type(tool))
             else:
-                response_tools.append(tool if isinstance(tool, dict) else dict(tool))
+                # Handle raw dictionary tools
+                tool_dict = tool if isinstance(tool, dict) else dict(tool)
+
+                # Special handling for image_generation tools
+                if tool_dict.get("type") == "image_generation":
+                    # Create a copy to avoid modifying the original
+                    mapped_tool = tool_dict.copy()
+
+                    # Map user-friendly parameter names to OpenAI API parameter names
+                    parameter_mapping = {
+                        "format": "output_format",
+                        "compression": "output_compression",
+                    }
+
+                    for user_param, api_param in parameter_mapping.items():
+                        if user_param in mapped_tool:
+                            # Map the parameter name and remove the old one
+                            mapped_tool[api_param] = mapped_tool.pop(user_param)
+
+                    # Validate all OpenAI image generation parameters
+
+                    # Background validation
+                    if "background" in mapped_tool:
+                        value = mapped_tool["background"]
+                        if value not in ("transparent", "opaque", "auto"):
+                            raise ValueError("background must be one of: 'transparent', 'opaque', 'auto'")
+
+                    # Input fidelity validation
+                    if "input_fidelity" in mapped_tool:
+                        value = mapped_tool["input_fidelity"]
+                        if value not in ("high", "low"):
+                            raise ValueError("input_fidelity must be 'high' or 'low'")
+
+                    # Input image mask validation
+                    if "input_image_mask" in mapped_tool:
+                        value = mapped_tool["input_image_mask"]
+                        if not isinstance(value, dict):
+                            raise ValueError("input_image_mask must be a dictionary")
+                        # Validate that it has at least one of the required fields
+                        if not any(key in value for key in ["file_id", "image_url"]):
+                            raise ValueError("input_image_mask must contain at least one of 'file_id' or 'image_url'")
+                        # Validate field types if present
+                        if "file_id" in value and not isinstance(value["file_id"], str):
+                            raise ValueError("input_image_mask.file_id must be a string")
+                        if "image_url" in value and not isinstance(value["image_url"], str):
+                            raise ValueError("input_image_mask.image_url must be a string")
+
+                    # Model validation
+                    if "model" in mapped_tool:
+                        value = mapped_tool["model"]
+                        if not isinstance(value, str):
+                            raise ValueError("model must be a string")
+
+                    # Moderation validation
+                    if "moderation" in mapped_tool:
+                        value = mapped_tool["moderation"]
+                        if not isinstance(value, str):
+                            raise ValueError("moderation must be a string")
+
+                    # Output compression validation
+                    if "output_compression" in mapped_tool:
+                        value = mapped_tool["output_compression"]
+                        if not isinstance(value, int) or not (1 <= value <= 100):
+                            raise ValueError("output_compression must be an integer between 1 and 100")
+
+                    # Output format validation
+                    if "output_format" in mapped_tool:
+                        value = mapped_tool["output_format"]
+                        if value not in ("png", "webp", "jpeg"):
+                            raise ValueError("output_format must be one of: 'png', 'webp', 'jpeg'")
+
+                    # Partial images validation
+                    if "partial_images" in mapped_tool:
+                        value = mapped_tool["partial_images"]
+                        if not isinstance(value, int) or not (0 <= value <= 3):
+                            raise ValueError("partial_images must be an integer between 0 and 3")
+
+                    # Quality validation
+                    if "quality" in mapped_tool:
+                        value = mapped_tool["quality"]
+                        if value not in ("low", "medium", "high", "auto"):
+                            raise ValueError("quality must be one of: 'low', 'medium', 'high', 'auto'")
+
+                    # Size validation
+                    if "size" in mapped_tool:
+                        value = mapped_tool["size"]
+                        if value not in ("1024x1024", "1024x1536", "1536x1024", "auto"):
+                            raise ValueError("size must be one of: '1024x1024', '1024x1536', '1536x1024', 'auto'")
+
+                    response_tools.append(mapped_tool)
+                else:
+                    response_tools.append(tool_dict)
         return response_tools
 
     def _prepare_options(self, messages: MutableSequence[ChatMessage], chat_options: ChatOptions) -> dict[str, Any]:
diff --git a/python/packages/main/tests/main/test_tools.py b/python/packages/main/tests/main/test_tools.py
@@ -9,7 +9,6 @@
 from agent_framework import (
     AIFunction,
     HostedCodeInterpreterTool,
-    HostedImageGenerationTool,
     HostedMCPTool,
     ToolProtocol,
     ai_function,
@@ -625,86 +624,3 @@ def test_hosted_mcp_tool_with_dict_of_allowed_tools():
             url="https://mcp.example",
             allowed_tools={"toolA": "Tool A", "toolC": "Tool C"},
         )
-
-
-# region HostedImageGenerationTool tests
-
-
-def test_hosted_image_generation_tool_default():
-    """Test HostedImageGenerationTool with default parameters."""
-    tool = HostedImageGenerationTool()
-
-    assert tool.name == "image_generation"
-    assert tool.description == ""
-    assert tool.additional_properties is None
-    assert tool.size is None
-    assert tool.quality is None
-    assert tool.format is None
-    assert tool.compression is None
-    assert tool.background is None
-
-
-def test_hosted_image_generation_tool_with_all_parameters():
-    """Test HostedImageGenerationTool with all parameters specified."""
-    tool = HostedImageGenerationTool(
-        description="Generate high-quality images",
-        size="1536x1024",
-        quality="high",
-        format="webp",
-        compression=75,
-        background="transparent",
-        additional_properties={"version": "2.0"},
-    )
-
-    assert tool.name == "image_generation"
-    assert tool.description == "Generate high-quality images"
-    assert tool.size == "1536x1024"
-    assert tool.quality == "high"
-    assert tool.format == "webp"
-    assert tool.compression == 75
-    assert tool.background == "transparent"
-    assert tool.additional_properties == {"version": "2.0"}
-    assert str(tool) == "HostedImageGenerationTool(name=image_generation, description=Generate high-quality images)"
-
-
-def test_hosted_image_generation_tool_compression_validation_invalid_range():
-    """Test HostedImageGenerationTool compression validation with invalid range."""
-    with pytest.raises(ValueError, match="compression must be an integer between 0 and 100"):
-        HostedImageGenerationTool(compression=150, format="jpeg")
-
-    with pytest.raises(ValueError, match="compression must be an integer between 0 and 100"):
-        HostedImageGenerationTool(compression=-10, format="webp")
-
-
-def test_hosted_image_generation_tool_compression_validation_invalid_format():
-    """Test HostedImageGenerationTool compression validation with invalid format."""
-    with pytest.raises(ValueError, match="compression parameter only applies to 'jpeg' and 'webp' formats"):
-        HostedImageGenerationTool(compression=50, format="png")
-
-
-def test_hosted_image_generation_tool_with_openai_kwargs():
-    """Test HostedImageGenerationTool with OpenAI-specific parameters via kwargs."""
-    tool = HostedImageGenerationTool(
-        size="1024x1024",
-        model="gpt-image-1",
-        input_fidelity="high",
-        moderation="strict",
-        partial_images=True,
-    )
-
-    assert tool.size == "1024x1024"
-    # Check that OpenAI Responses-specific parameters are set as attributes
-    assert hasattr(tool, "model")
-    assert tool.model == "gpt-image-1"  # type: ignore
-    assert hasattr(tool, "input_fidelity")
-    assert tool.input_fidelity == "high"  # type: ignore
-    assert hasattr(tool, "moderation")
-    assert tool.moderation == "strict"  # type: ignore
-    assert hasattr(tool, "partial_images")
-    assert tool.partial_images is True  # type: ignore
-
-
-def test_hosted_image_generation_tool_reserved_name_validation():
-    """Test HostedImageGenerationTool validation of reserved 'name' parameter."""
-    with pytest.raises(ValueError, match="The 'name' argument is reserved for the HostedImageGenerationTool"):
-        HostedImageGenerationTool(name="custom_name")
diff --git a/python/packages/main/tests/openai/test_openai_responses_client.py b/python/packages/main/tests/openai/test_openai_responses_client.py
diff --git a/python/samples/getting_started/agents/openai_responses_client/openai_responses_client_image_generation.py b/python/samples/getting_started/agents/openai_responses_client/openai_responses_client_image_generation.py
