fix!: switch DALLEImageGenerator to gpt-image-2 (#11321)

Author: anakin87

.github/workflows/slow.yml

@@ -36,9 +36,9 @@ on:
 
 jobs:
   check-if-changed:
-  # This job checks if the relevant files have been changed.
-  # We check for changes in the check-if-changed job instead of using paths/paths-ignore at workflow level.
-  # This ensures the "Slow Integration Tests completed" job always runs, which is required by Branch Protection rules.
+    # This job checks if the relevant files have been changed.
+    # We check for changes in the check-if-changed job instead of using paths/paths-ignore at workflow level.
+    # This ensures the "Slow Integration Tests completed" job always runs, which is required by Branch Protection rules.
     name: Check if changed
     runs-on: ubuntu-slim
     permissions:
@@ -71,6 +71,7 @@ jobs:
               - "haystack/components/generators/chat/hugging_face_local.py"
               - "haystack/components/generators/hugging_face_api.py"
               - "haystack/components/generators/hugging_face_local_generator.py"
+              - "haystack/components/generators/openai_dalle.py"
               - "haystack/components/preprocessors/embedding_based_document_splitter.py"
               - "haystack/components/rankers/sentence_transformers_diversity.py"
               - "haystack/components/rankers/sentence_transformers_similarity.py"
@@ -94,6 +95,7 @@ jobs:
               - "test/components/generators/chat/test_hugging_face_local.py"
               - "test/components/generators/test_hugging_face_api.py"
               - "test/components/generators/test_hugging_face_local_generator.py"
+              - "test/components/generators/test_openai_dalle.py"
               - "test/components/preprocessors/test_embedding_based_document_splitter.py"
               - "test/components/rankers/test_sentence_transformers_diversity.py"
               - "test/components/rankers/test_sentence_transformers_similarity.py"
@@ -168,11 +170,11 @@ jobs:
     needs: slow-integration-tests
 
     steps:
-    - name: Mark tests as completed
-      run: |
-        if [ "${{ needs.slow-integration-tests.result }}" = "failure" ]; then
-          echo "Slow Integration Tests failed!"
-          exit 1
-        else
-          echo "Slow Integration Tests completed!"
-        fi
+      - name: Mark tests as completed
+        run: |
+          if [ "${{ needs.slow-integration-tests.result }}" = "failure" ]; then
+            echo "Slow Integration Tests failed!"
+            exit 1
+          else
+            echo "Slow Integration Tests completed!"
+          fi

docs-website/docs/pipeline-components/generators.mdx

@@ -23,7 +23,7 @@ Generators are responsible for generating text after you give them a prompt. The
 | [CohereChatGenerator](generators/coherechatgenerator.mdx)                     | Enables chat completion using Cohere's LLMs.                                                                                                                                                                             | ✅                 |
 | [CohereGenerator](generators/coheregenerator.mdx)                             | Queries the LLM using Cohere API.                                                                                                                                                                                        | ✅                 |
 | [CometAPIChatGenerator](generators/cometapichatgenerator.mdx)                 | Enables chat completion using AI models through the Comet API.                                                                                                                                                           | ✅                 |
-| [DALLEImageGenerator](generators/dalleimagegenerator.mdx)                       | Generate images using OpenAI's DALL-E model.                                                                                                                                                                             | ❌                 |
+| [DALLEImageGenerator](generators/dalleimagegenerator.mdx)                       | Generate images using OpenAI's image generation models such as `gpt-image-2`.                                                                                                                                            | ❌                 |
 | [FallbackChatGenerator](generators/fallbackchatgenerator.mdx)                   | A ChatGenerator wrapper that tries multiple Chat Generators sequentially until one succeeds.                                                                                                                             | ✅                 |
 | [GoogleAIGeminiChatGenerator](generators/googleaigeminichatgenerator.mdx)     | Enables chat completion using Google Gemini models. **_This integration will be deprecated soon. We recommend using [GoogleGenAIChatGenerator](generators/googlegenaichatgenerator.mdx) integration instead._**                     | ✅                 |
 | [GoogleAIGeminiGenerator](generators/googleaigeminigenerator.mdx)             | Enables text generation using Google Gemini models. **_This integration will be deprecated soon. We recommend using [GoogleGenAIChatGenerator](generators/googlegenaichatgenerator.mdx)  integration instead._**                    | ✅                 |

docs-website/docs/pipeline-components/generators/dalleimagegenerator.mdx

@@ -2,12 +2,12 @@
 title: "DALLEImageGenerator"
 id: dalleimagegenerator
 slug: "/dalleimagegenerator"
-description: "Generate images using OpenAI's DALL-E model."
+description: "Generate images using OpenAI's image generation models such as `gpt-image-2`."
 ---
 
 # DALLEImageGenerator
 
-Generate images using OpenAI's DALL-E model.
+Generate images using OpenAI's image generation models such as `gpt-image-2`.
 
 <div className="key-value-table">
 
@@ -25,17 +25,17 @@ Generate images using OpenAI's DALL-E model.
 
 ## Overview
 
-The `DALLEImageGenerator` component generates images using OpenAI's DALL-E model.
+The `DALLEImageGenerator` component generates images using OpenAI's image generation models (such as `gpt-image-2`).
 
-By default, the component uses `dall-e-3` model, standard picture quality, and 1024x1024 resolution. You can change these parameters using `model` (during component initialization), `quality`, and `size` (during component initialization or run) parameters.
+By default, the component uses the `gpt-image-2` model, `"auto"` quality, and 1024x1024 resolution. You can change these parameters using `model` (during component initialization), `quality`, and `size` (during component initialization or run) parameters.
 
 `DALLEImageGenerator` needs an OpenAI key to work. It uses an `OPENAI_API_KEY` environment variable by default. Otherwise, you can pass an API key at initialization with `api_key`:
 
 ```
 image_generator = DALLEImageGenerator(api_key=Secret.from_token("<your-api-key>"))
 ```
 
-Check our [API reference](/reference/generators-api#dalleimagegenerator) for the detailed component parameters description, or the [OpenAI documentation](https://platform.openai.com/docs/api-reference/images/create) for the details on OpenAI API parameters.
+Check our [API reference](/reference/generators-api#dalleimagegenerator) for the detailed component parameters description, or the [OpenAI documentation](https://developers.openai.com/api/reference/resources/images/methods/generate) for the details on OpenAI API parameters.
 
 ## Usage
 
@@ -93,6 +93,6 @@ results = pipeline.run(
 generated_images = results["image_generator"]["images"]
 revised_prompt = results["image_generator"]["revised_prompt"]
 
-print(f"Generated image URL: {generated_images[0]}")
+print(f"Generated image (base64-encoded): {generated_images[0]}")
 print(f"Revised prompt: {revised_prompt}")
 ```

haystack/components/generators/openai_dalle.py

@@ -8,18 +8,20 @@
 from openai import OpenAI
 from openai.types.image import Image
 
-from haystack import component, default_from_dict, default_to_dict
+from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.utils import Secret
 from haystack.utils.http_client import init_http_client
 
+logger = logging.getLogger(__name__)
+
 
 @component
 class DALLEImageGenerator:
     """
-    Generates images using OpenAI's DALL-E model.
+    Generates images using OpenAI's image generation models such as `gpt-image-2`.
 
     For details on OpenAI API parameters, see
-    [OpenAI documentation](https://platform.openai.com/docs/api-reference/images/create).
+    [OpenAI documentation](https://developers.openai.com/api/reference/resources/images/methods/generate).
 
     ### Usage example
     ```python
@@ -32,10 +34,10 @@ class DALLEImageGenerator:
 
     def __init__(
         self,
-        model: str = "dall-e-3",
-        quality: Literal["standard", "hd"] = "standard",
-        size: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"] = "1024x1024",
-        response_format: Literal["url", "b64_json"] = "url",
+        model: str = "gpt-image-2",
+        quality: Literal["auto", "high", "medium", "low"] = "auto",
+        size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"] = "1024x1024",
+        response_format: Literal["b64_json"] = "b64_json",
         api_key: Secret = Secret.from_env_var("OPENAI_API_KEY"),
         api_base_url: str | None = None,
         organization: str | None = None,
@@ -44,14 +46,15 @@ def __init__(
         http_client_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """
-        Creates an instance of DALLEImageGenerator. Unless specified otherwise in `model`, uses OpenAI's dall-e-3.
-
-        :param model: The model to use for image generation. Can be "dall-e-2" or "dall-e-3".
-        :param quality: The quality of the generated image. Can be "standard" or "hd".
-        :param size: The size of the generated images.
-            Must be one of 256x256, 512x512, or 1024x1024 for dall-e-2.
-            Must be one of 1024x1024, 1792x1024, or 1024x1792 for dall-e-3 models.
-        :param response_format: The format of the response. Can be "url" or "b64_json".
+        Creates an instance of DALLEImageGenerator. Unless specified otherwise in `model`, uses OpenAI's gpt-image-2.
+
+        :param model: The model to use for image generation. Model names can be found in the
+            [OpenAI documentation](https://developers.openai.com/api/docs/models/all).
+        :param quality: The quality of the generated image. Can be "auto", "high", "medium", or "low".
+        :param size: The size of the generated images. One of 1024x1024, 1024x1536, 1536x1024, or "auto".
+            `gpt-image-2` also supports arbitrary sizes. You can find more information about supported sizes in
+            the [OpenAI documentation](https://developers.openai.com/api/reference/resources/images/methods/generate).
+        :param response_format: This parameter is ignored and only kept for backward compatibility.
         :param api_key: The OpenAI API key to connect to OpenAI.
         :param api_base_url: An optional base URL.
         :param organization: The Organization ID, defaults to `None`.
@@ -66,9 +69,13 @@ def __init__(
             For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).
         """
         self.model = model
+        if quality not in ["auto", "high", "medium", "low"]:
+            logger.warning("Invalid quality: {quality}. Defaulting to 'auto'.", quality=quality)
+            quality = "auto"
         self.quality = quality
         self.size = size
-        self.response_format = response_format
+        if response_format != "b64_json":
+            logger.warning("response_format is ignored. A base64-encoded image will be returned.")
         self.api_key = api_key
         self.api_base_url = api_base_url
         self.organization = organization
@@ -97,40 +104,39 @@ def warm_up(self) -> None:
     def run(
         self,
         prompt: str,
-        size: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"] | None = None,
-        quality: Literal["standard", "hd"] | None = None,
-        response_format: Literal["url", "b64_json"] | None = None,
+        size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"] | None = None,
+        quality: Literal["auto", "high", "medium", "low"] | None = None,
+        response_format: Literal["b64_json"] | None = None,  # noqa: ARG002
     ) -> dict[str, Any]:
         """
         Invokes the image generation inference based on the provided prompt and generation parameters.
 
         :param prompt: The prompt to generate the image.
         :param size: If provided, overrides the size provided during initialization.
         :param quality: If provided, overrides the quality provided during initialization.
-        :param response_format: If provided, overrides the response format provided during initialization.
+        :param response_format: This parameter is ignored and only kept for backward compatibility.
 
         :returns:
-            A dictionary containing the generated list of images and the revised prompt.
-            Depending on the `response_format` parameter, the list of images can be URLs or base64 encoded JSON strings.
+            A dictionary containing the generated list of images as base64 encoded JSON strings and the revised prompt.
             The revised prompt is the prompt that was used to generate the image, if there was any revision
             to the prompt made by OpenAI.
         """
         if self.client is None:
             self.warm_up()
 
+        # at this point the client is initialized, but mypy doesn't know that
+        assert self.client is not None
+
         size = size or self.size
         quality = quality or self.quality
-        response_format = response_format or self.response_format
-        response = self.client.images.generate(  # type: ignore[union-attr]
-            model=self.model, prompt=prompt, size=size, quality=quality, response_format=response_format, n=1
-        )
+        response = self.client.images.generate(model=self.model, prompt=prompt, size=size, quality=quality, n=1)
+        image_str = ""
+        revised_prompt = ""
         if response.data is not None:
             image: Image = response.data[0]
-            image_str = image.url or image.b64_json or ""
+            image_str = image.b64_json or ""
             revised_prompt = image.revised_prompt or ""
-        else:
-            image_str = ""
-            revised_prompt = ""
+
         return {"images": [image_str], "revised_prompt": revised_prompt}
 
     def to_dict(self) -> dict[str, Any]:
@@ -145,7 +151,6 @@ def to_dict(self) -> dict[str, Any]:
             model=self.model,
             quality=self.quality,
             size=self.size,
-            response_format=self.response_format,
             api_key=self.api_key,
             api_base_url=self.api_base_url,
             organization=self.organization,

releasenotes/notes/dalle-image-generator-uses-gpt-image-2-314ce9ce713c928b.yaml

@@ -0,0 +1,11 @@
+---
+upgrade:
+  - |
+    ``DALLEImageGenerator`` has been updated to account for OpenAI's retirement of the DALL-E models.
+    The default model is now ``gpt-image-2`` (previously ``dall-e-3``). To migrate:
+    - Update ``model`` value: besides ``gpt-image-2``, ``gpt-image-1`` and ``gpt-image-1-mini`` are also supported.
+    - Update ``quality`` value: the new accepted values are ``auto``, ``high``, ``medium``, or ``low``
+      (previously ``standard`` or ``hd``).
+    - Update ``size`` value: the new accepted values are ``1024x1024``, ``1024x1536``, ``1536x1024``,
+      or ``auto``. ``gpt-image-2`` also supports arbitrary sizes.
+    - The ``response_format`` parameter is now ignored. The component always returns base64-encoded JSON.