feat(api): manual updates

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 111
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-c7dacca97e28bceff218684bb429481a70aa47aadad983ed9178bfda75ff4cd2.yml
-openapi_spec_hash: 28eb1bb901ca10d2e37db4606d2bcfa7
-config_hash: 167ad0ca036d0f023c78e6496b4311e8
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-670ea0d2cc44f52a87dd3cadea45632953283e0636ba30788fdbdb22a232ccac.yml
+openapi_spec_hash: d8b7d38911fead545adf3e4297956410
+config_hash: 5525bda35e48ea6387c6175c4d1651fa

api.md

@@ -127,7 +127,17 @@ Methods:
 Types:
 
 ```python
-from openai.types import Image, ImageModel, ImagesResponse
+from openai.types import (
+    Image,
+    ImageEditCompletedEvent,
+    ImageEditPartialImageEvent,
+    ImageEditStreamEvent,
+    ImageGenCompletedEvent,
+    ImageGenPartialImageEvent,
+    ImageGenStreamEvent,
+    ImageModel,
+    ImagesResponse,
+)
 ```
 
 Methods:

examples/image_stream.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+
+import base64
+from pathlib import Path
+
+from openai import OpenAI
+
+client = OpenAI()
+
+
+def main() -> None:
+    """Example of OpenAI image streaming with partial images."""
+    stream = client.images.generate(
+        model="gpt-image-1",
+        prompt="A cute baby sea otter",
+        n=1,
+        size="1024x1024",
+        stream=True,
+        partial_images=3,
+    )
+
+    for event in stream:
+        if event.type == "image_generation.partial_image":
+            print(f"  Partial image {event.partial_image_index + 1}/3 received")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save partial image to file
+            filename = f"partial_{event.partial_image_index + 1}.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        elif event.type == "image_generation.completed":
+            print(f"\n✅ Final image completed!")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save final image to file
+            filename = "final_image.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        else:
+            print(f"❓ Unknown event: {event}")  # type: ignore[unreachable]
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(f"Error generating image: {error}")

src/openai/_streaming.py

@@ -59,7 +59,12 @@ def __stream__(self) -> Iterator[_T]:
             if sse.data.startswith("[DONE]"):
                 break
 
-            if sse.event is None or sse.event.startswith("response.") or sse.event.startswith("transcript."):
+            if sse.event is None or (
+                sse.event.startswith("response.") or 
+                sse.event.startswith("transcript.") or 
+                sse.event.startswith("image_edit.") or 
+                sse.event.startswith("image_generation.")
+            ):
                 data = sse.json()
                 if is_mapping(data) and data.get("error"):
                     message = None

src/openai/resources/images.py

@@ -60,15 +60,19 @@
 from .image_generate_params import ImageGenerateParams as ImageGenerateParams
 from .eval_retrieve_response import EvalRetrieveResponse as EvalRetrieveResponse
 from .file_chunking_strategy import FileChunkingStrategy as FileChunkingStrategy
+from .image_gen_stream_event import ImageGenStreamEvent as ImageGenStreamEvent
 from .upload_complete_params import UploadCompleteParams as UploadCompleteParams
 from .container_create_params import ContainerCreateParams as ContainerCreateParams
 from .container_list_response import ContainerListResponse as ContainerListResponse
 from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .image_edit_stream_event import ImageEditStreamEvent as ImageEditStreamEvent
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
 from .moderation_create_params import ModerationCreateParams as ModerationCreateParams
 from .vector_store_list_params import VectorStoreListParams as VectorStoreListParams
 from .container_create_response import ContainerCreateResponse as ContainerCreateResponse
 from .create_embedding_response import CreateEmbeddingResponse as CreateEmbeddingResponse
+from .image_gen_completed_event import ImageGenCompletedEvent as ImageGenCompletedEvent
+from .image_edit_completed_event import ImageEditCompletedEvent as ImageEditCompletedEvent
 from .moderation_create_response import ModerationCreateResponse as ModerationCreateResponse
 from .vector_store_create_params import VectorStoreCreateParams as VectorStoreCreateParams
 from .vector_store_search_params import VectorStoreSearchParams as VectorStoreSearchParams
@@ -79,8 +83,10 @@
 from .vector_store_search_response import VectorStoreSearchResponse as VectorStoreSearchResponse
 from .websocket_connection_options import WebsocketConnectionOptions as WebsocketConnectionOptions
 from .image_create_variation_params import ImageCreateVariationParams as ImageCreateVariationParams
+from .image_gen_partial_image_event import ImageGenPartialImageEvent as ImageGenPartialImageEvent
 from .static_file_chunking_strategy import StaticFileChunkingStrategy as StaticFileChunkingStrategy
 from .eval_custom_data_source_config import EvalCustomDataSourceConfig as EvalCustomDataSourceConfig
+from .image_edit_partial_image_event import ImageEditPartialImageEvent as ImageEditPartialImageEvent
 from .moderation_image_url_input_param import ModerationImageURLInputParam as ModerationImageURLInputParam
 from .auto_file_chunking_strategy_param import AutoFileChunkingStrategyParam as AutoFileChunkingStrategyParam
 from .moderation_multi_modal_input_param import ModerationMultiModalInputParam as ModerationMultiModalInputParam

src/openai/types/__init__.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageEditCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded final edited image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the edited image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the edited image."""
+
+    type: Literal["image_edit.completed"]
+    """The type of the event. Always `image_edit.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""

src/openai/types/image_edit_completed_event.py

@@ -8,10 +8,10 @@
 from .._types import FileTypes
 from .image_model import ImageModel
 
-__all__ = ["ImageEditParams"]
+__all__ = ["ImageEditParamsBase", "ImageEditParamsNonStreaming", "ImageEditParamsStreaming"]
 
 
-class ImageEditParams(TypedDict, total=False):
+class ImageEditParamsBase(TypedDict, total=False):
     image: Required[Union[FileTypes, List[FileTypes]]]
     """The image(s) to edit. Must be a supported image file or an array of images.
 
@@ -40,6 +40,13 @@ class ImageEditParams(TypedDict, total=False):
     be set to either `png` (default value) or `webp`.
     """
 
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+    """
+
     mask: FileTypes
     """An additional image whose fully transparent areas (e.g.
 
@@ -72,6 +79,14 @@ class ImageEditParams(TypedDict, total=False):
     `jpeg`, or `webp`. The default value is `png`.
     """
 
+    partial_images: Optional[int]
+    """The number of partial images to generate.
+
+    This parameter is used for streaming responses that return partial images. Value
+    must be between 0 and 3. When set to 0, the response will be a single image sent
+    in one streaming event.
+    """
+
     quality: Optional[Literal["standard", "low", "medium", "high", "auto"]]
     """The quality of the image that will be generated.
 
@@ -101,3 +116,26 @@ class ImageEditParams(TypedDict, total=False):
     and detect abuse.
     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
     """
+
+
+class ImageEditParamsNonStreaming(ImageEditParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+class ImageEditParamsStreaming(ImageEditParamsBase):
+    stream: Required[Literal[True]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+ImageEditParams = Union[ImageEditParamsNonStreaming, ImageEditParamsStreaming]

src/openai/types/image_edit_params.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditPartialImageEvent"]
+
+
+class ImageEditPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested edited image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested edited image."""
+
+    type: Literal["image_edit.partial_image"]
+    """The type of the event. Always `image_edit.partial_image`."""

src/openai/types/image_edit_partial_image_event.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .image_edit_completed_event import ImageEditCompletedEvent
+from .image_edit_partial_image_event import ImageEditPartialImageEvent
+
+__all__ = ["ImageEditStreamEvent"]
+
+ImageEditStreamEvent: TypeAlias = Annotated[
+    Union[ImageEditPartialImageEvent, ImageEditCompletedEvent], PropertyInfo(discriminator="type")
+]