ComfyUI v0.20.3

Make ImageBlend and ImageCompositeMasked nodes handle images with different channel counts

comfy_api_nodes/apis/luma.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 
-
-import torch
-
 from enum import Enum
 from typing import Optional, Union
 
+import torch
 from pydantic import BaseModel, Field, confloat
 
 
-
 class LumaIO:
     LUMA_REF = "LUMA_REF"
     LUMA_CONCEPTS = "LUMA_CONCEPTS"
@@ -183,13 +180,13 @@ class LumaAssets(BaseModel):
 
 
 class LumaImageRef(BaseModel):
-    '''Used for image gen'''
+    """Used for image gen"""
     url: str = Field(..., description='The URL of the image reference')
     weight: confloat(ge=0.0, le=1.0) = Field(..., description='The weight of the image reference')
 
 
 class LumaImageReference(BaseModel):
-    '''Used for video gen'''
+    """Used for video gen"""
     type: Optional[str] = Field('image', description='Input type, defaults to image')
     url: str = Field(..., description='The URL of the image')
 
@@ -251,3 +248,32 @@ class LumaGeneration(BaseModel):
     assets: Optional[LumaAssets] = Field(None, description='The assets of the generation')
     model: str = Field(..., description='The model used for the generation')
     request: Union[LumaGenerationRequest, LumaImageGenerationRequest] = Field(..., description="The request used for the generation")
+
+
+class Luma2ImageRef(BaseModel):
+    url: str | None = None
+    data: str | None = None
+    media_type: str | None = None
+
+
+class Luma2GenerationRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=6000)
+    model: str | None = None
+    type: str | None = None
+    aspect_ratio: str | None = None
+    style: str | None = None
+    output_format: str | None = None
+    web_search: bool | None = None
+    image_ref: list[Luma2ImageRef] | None = None
+    source: Luma2ImageRef | None = None
+
+
+class Luma2Generation(BaseModel):
+    id: str | None = None
+    type: str | None = None
+    state: str | None = None
+    model: str | None = None
+    created_at: str | None = None
+    output: list[LumaImageReference] | None = None
+    failure_reason: str | None = None
+    failure_code: str | None = None

comfy_api_nodes/apis/openai.py

@@ -56,14 +56,14 @@ class ModelResponseProperties(BaseModel):
     instructions: str | None = Field(None)
     max_output_tokens: int | None = Field(None)
     model: str | None = Field(None)
-    temperature: float | None = Field(1, description="Controls randomness in the response", ge=0.0, le=2.0)
+    temperature: float | None = Field(None, description="Controls randomness in the response", ge=0.0, le=2.0)
     top_p: float | None = Field(
-        1,
+        None,
         description="Controls diversity of the response via nucleus sampling",
         ge=0.0,
         le=1.0,
     )
-    truncation: str | None = Field("disabled", description="Allowed values: 'auto' or 'disabled'")
+    truncation: str | None = Field(None, description="Allowed values: 'auto' or 'disabled'")
 
 
 class ResponseProperties(BaseModel):

comfy_api_nodes/nodes_gemini.py

@@ -83,13 +83,16 @@ class GeminiImageModel(str, Enum):
 
 async def create_image_parts(
     cls: type[IO.ComfyNode],
-    images: Input.Image,
+    images: Input.Image | list[Input.Image],
     image_limit: int = 0,
 ) -> list[GeminiPart]:
     image_parts: list[GeminiPart] = []
     if image_limit < 0:
         raise ValueError("image_limit must be greater than or equal to 0 when creating Gemini image parts.")
-    total_images = get_number_of_images(images)
+
+    # Accept either a single (possibly-batched) tensor or a list of them; share URL budget across all.
+    images_list: list[Input.Image] = images if isinstance(images, list) else [images]
+    total_images = sum(get_number_of_images(img) for img in images_list)
     if total_images <= 0:
         raise ValueError("No images provided to create_image_parts; at least one image is required.")
 
@@ -98,10 +101,18 @@ async def create_image_parts(
 
     # Number of images we'll send as URLs (fileData)
     num_url_images = min(effective_max, 10)  # Vertex API max number of image links
+    upload_kwargs: dict = {"wait_label": "Uploading reference images"}
+    if effective_max > num_url_images:
+        # Split path (e.g. 11+ images): suppress per-image counter to avoid a confusing dual-fraction label.
+        upload_kwargs = {
+            "wait_label": f"Uploading reference images ({num_url_images}+)",
+            "show_batch_index": False,
+        }
     reference_images_urls = await upload_images_to_comfyapi(
         cls,
-        images,
+        images_list,
         max_images=num_url_images,
+        **upload_kwargs,
     )
     for reference_image_url in reference_images_urls:
         image_parts.append(
@@ -112,15 +123,22 @@ async def create_image_parts(
                 )
             )
         )
-    for idx in range(num_url_images, effective_max):
-        image_parts.append(
-            GeminiPart(
-                inlineData=GeminiInlineData(
-                    mimeType=GeminiMimeType.image_png,
-                    data=tensor_to_base64_string(images[idx]),
+    if effective_max > num_url_images:
+        flat: list[torch.Tensor] = []
+        for tensor in images_list:
+            if len(tensor.shape) == 4:
+                flat.extend(tensor[i] for i in range(tensor.shape[0]))
+            else:
+                flat.append(tensor)
+        for idx in range(num_url_images, effective_max):
+            image_parts.append(
+                GeminiPart(
+                    inlineData=GeminiInlineData(
+                        mimeType=GeminiMimeType.image_png,
+                        data=tensor_to_base64_string(flat[idx]),
+                    )
                 )
             )
-        )
     return image_parts
 
 
@@ -891,10 +909,6 @@ class GeminiNanoBanana2(IO.ComfyNode):
                         "9:16",
                         "16:9",
                         "21:9",
-                        # "1:4",
-                        # "4:1",
-                        # "8:1",
-                        # "1:8",
                     ],
                     default="auto",
                     tooltip="If set to 'auto', matches your input image's aspect ratio; "
@@ -902,12 +916,7 @@ class GeminiNanoBanana2(IO.ComfyNode):
                 ),
                 IO.Combo.Input(
                     "resolution",
-                    options=[
-                        # "512px",
-                        "1K",
-                        "2K",
-                        "4K",
-                    ],
+                    options=["1K", "2K", "4K"],
                     tooltip="Target output resolution. For 2K/4K the native Gemini upscaler is used.",
                 ),
                 IO.Combo.Input(
@@ -956,6 +965,7 @@ class GeminiNanoBanana2(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=GEMINI_IMAGE_2_PRICE_BADGE,
+            is_deprecated=True,
         )
 
     @classmethod
@@ -1016,6 +1026,197 @@ class GeminiNanoBanana2(IO.ComfyNode):
         )
 
 
+def _nano_banana_2_v2_model_inputs():
+    return [
+        IO.Combo.Input(
+            "aspect_ratio",
+            options=[
+                "auto",
+                "1:1",
+                "2:3",
+                "3:2",
+                "3:4",
+                "4:3",
+                "4:5",
+                "5:4",
+                "9:16",
+                "16:9",
+                "21:9",
+                "1:4",
+                "4:1",
+                "8:1",
+                "1:8",
+            ],
+            default="auto",
+            tooltip="If set to 'auto', matches your input image's aspect ratio; "
+            "if no image is provided, a 16:9 square is usually generated.",
+        ),
+        IO.Combo.Input(
+            "resolution",
+            options=["1K", "2K", "4K"],
+            tooltip="Target output resolution. For 2K/4K the native Gemini upscaler is used.",
+        ),
+        IO.Combo.Input(
+            "thinking_level",
+            options=["MINIMAL", "HIGH"],
+        ),
+        IO.Autogrow.Input(
+            "images",
+            template=IO.Autogrow.TemplateNames(
+                IO.Image.Input("image"),
+                names=[f"image_{i}" for i in range(1, 15)],
+                min=0,
+            ),
+            tooltip="Optional reference image(s). Up to 14 images total.",
+        ),
+        IO.Custom("GEMINI_INPUT_FILES").Input(
+            "files",
+            optional=True,
+            tooltip="Optional file(s) to use as context for the model. "
+                    "Accepts inputs from the Gemini Generate Content Input Files node.",
+        ),
+    ]
+
+
+class GeminiNanoBanana2V2(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls):
+        return IO.Schema(
+            node_id="GeminiNanoBanana2V2",
+            display_name="Nano Banana 2",
+            category="api node/image/Gemini",
+            description="Generate or edit images synchronously via Google Vertex API.",
+            inputs=[
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    tooltip="Text prompt describing the image to generate or the edits to apply. "
+                    "Include any constraints, styles, or details the model should follow.",
+                    default="",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(
+                            "Nano Banana 2 (Gemini 3.1 Flash Image)",
+                            _nano_banana_2_v2_model_inputs(),
+                        ),
+                    ],
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=42,
+                    min=0,
+                    max=0xFFFFFFFFFFFFFFFF,
+                    control_after_generate=True,
+                    tooltip="When the seed is fixed to a specific value, the model makes a best effort to provide "
+                    "the same response for repeated requests. Deterministic output isn't guaranteed. "
+                    "Also, changing the model or parameter settings, such as the temperature, "
+                    "can cause variations in the response even when you use the same seed value. "
+                    "By default, a random seed value is used.",
+                ),
+                IO.Combo.Input(
+                    "response_modalities",
+                    options=["IMAGE", "IMAGE+TEXT"],
+                    advanced=True,
+                ),
+                IO.String.Input(
+                    "system_prompt",
+                    multiline=True,
+                    default=GEMINI_IMAGE_SYS_PROMPT,
+                    optional=True,
+                    tooltip="Foundational instructions that dictate an AI's behavior.",
+                    advanced=True,
+                ),
+            ],
+            outputs=[
+                IO.Image.Output(),
+                IO.String.Output(),
+                IO.Image.Output(
+                    display_name="thought_image",
+                    tooltip="First image from the model's thinking process. "
+                    "Only available with thinking_level HIGH and IMAGE+TEXT modality.",
+                ),
+            ],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+            is_api_node=True,
+            price_badge=IO.PriceBadge(
+                depends_on=IO.PriceBadgeDepends(widgets=["model", "model.resolution"]),
+                expr="""
+                (
+                  $r := $lookup(widgets, "model.resolution");
+                  $prices := {"1k": 0.0696, "2k": 0.1014, "4k": 0.154};
+                  {"type":"usd","usd": $lookup($prices, $r), "format":{"suffix":"/Image","approximate":true}}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        prompt: str,
+        model: dict,
+        seed: int,
+        response_modalities: str,
+        system_prompt: str = "",
+    ) -> IO.NodeOutput:
+        validate_string(prompt, strip_whitespace=True, min_length=1)
+        model_choice = model["model"]
+        if model_choice == "Nano Banana 2 (Gemini 3.1 Flash Image)":
+            model_id = "gemini-3.1-flash-image-preview"
+        else:
+            model_id = model_choice
+
+        images = model.get("images") or {}
+        parts: list[GeminiPart] = [GeminiPart(text=prompt)]
+        if images:
+            image_tensors: list[Input.Image] = [t for t in images.values() if t is not None]
+            if image_tensors:
+                if sum(get_number_of_images(t) for t in image_tensors) > 14:
+                    raise ValueError("The current maximum number of supported images is 14.")
+                parts.extend(await create_image_parts(cls, image_tensors))
+        files = model.get("files")
+        if files is not None:
+            parts.extend(files)
+
+        image_config = GeminiImageConfig(imageSize=model["resolution"])
+        if model["aspect_ratio"] != "auto":
+            image_config.aspectRatio = model["aspect_ratio"]
+
+        gemini_system_prompt = None
+        if system_prompt:
+            gemini_system_prompt = GeminiSystemInstructionContent(parts=[GeminiTextPart(text=system_prompt)], role=None)
+
+        response = await sync_op(
+            cls,
+            ApiEndpoint(path=f"/proxy/vertexai/gemini/{model_id}", method="POST"),
+            data=GeminiImageGenerateContentRequest(
+                contents=[
+                    GeminiContent(role=GeminiRole.user, parts=parts),
+                ],
+                generationConfig=GeminiImageGenerationConfig(
+                    responseModalities=(["IMAGE"] if response_modalities == "IMAGE" else ["TEXT", "IMAGE"]),
+                    imageConfig=image_config,
+                    thinkingConfig=GeminiThinkingConfig(thinkingLevel=model["thinking_level"]),
+                ),
+                systemInstruction=gemini_system_prompt,
+            ),
+            response_model=GeminiGenerateContentResponse,
+            price_extractor=calculate_tokens_price,
+        )
+        return IO.NodeOutput(
+            await get_image_from_response(response),
+            get_text_from_response(response),
+            await get_image_from_response(response, thought=True),
+        )
+
+
 class GeminiExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -1024,6 +1225,7 @@ class GeminiExtension(ComfyExtension):
             GeminiImage,
             GeminiImage2,
             GeminiNanoBanana2,
+            GeminiNanoBanana2V2,
             GeminiInputFiles,
         ]
 

comfy_api_nodes/nodes_grok.py

@@ -54,7 +54,12 @@ class GrokImageNode(IO.ComfyNode):
             inputs=[
                 IO.Combo.Input(
                     "model",
-                    options=["grok-imagine-image-pro", "grok-imagine-image", "grok-imagine-image-beta"],
+                    options=[
+                        "grok-imagine-image-quality",
+                        "grok-imagine-image-pro",
+                        "grok-imagine-image",
+                        "grok-imagine-image-beta",
+                    ],
                 ),
                 IO.String.Input(
                     "prompt",
@@ -111,10 +116,12 @@ class GrokImageNode(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model", "number_of_images"]),
+                depends_on=IO.PriceBadgeDepends(widgets=["model", "number_of_images", "resolution"]),
                 expr="""
                 (
-                  $rate := $contains(widgets.model, "pro") ? 0.07 : 0.02;
+                  $rate := widgets.model = "grok-imagine-image-quality"
+                    ? (widgets.resolution = "1k" ? 0.05 : 0.07)
+                    : ($contains(widgets.model, "pro") ? 0.07 : 0.02);
                   {"type":"usd","usd": $rate * widgets.number_of_images}
                 )
                 """,
@@ -167,7 +174,12 @@ class GrokImageEditNode(IO.ComfyNode):
             inputs=[
                 IO.Combo.Input(
                     "model",
-                    options=["grok-imagine-image-pro", "grok-imagine-image", "grok-imagine-image-beta"],
+                    options=[
+                        "grok-imagine-image-quality",
+                        "grok-imagine-image-pro",
+                        "grok-imagine-image",
+                        "grok-imagine-image-beta",
+                    ],
                 ),
                 IO.Image.Input("image", display_name="images"),
                 IO.String.Input(
@@ -228,11 +240,19 @@ class GrokImageEditNode(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model", "number_of_images"]),
+                depends_on=IO.PriceBadgeDepends(widgets=["model", "number_of_images", "resolution"]),
                 expr="""
                 (
-                  $rate := $contains(widgets.model, "pro") ? 0.07 : 0.02;
-                  {"type":"usd","usd": 0.002 + $rate * widgets.number_of_images}
+                  $isQualityModel := widgets.model = "grok-imagine-image-quality";
+                  $isPro := $contains(widgets.model, "pro");
+                  $rate := $isQualityModel
+                    ? (widgets.resolution = "1k" ? 0.05 : 0.07)
+                    : ($isPro ? 0.07 : 0.02);
+                  $base := $isQualityModel ? 0.01 : 0.002;
+                  $output := $rate * widgets.number_of_images;
+                  $isPro
+                    ? {"type":"usd","usd": $base + $output}
+                    : {"type":"range_usd","min_usd": $base + $output, "max_usd": 3 * $base + $output}
                 )
                 """,
             ),

comfy_api_nodes/nodes_kling.py

@@ -2787,11 +2787,15 @@ class MotionControl(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode"]),
+                depends_on=IO.PriceBadgeDepends(widgets=["mode", "model"]),
                 expr="""
                 (
-                  $prices := {"std": 0.07, "pro": 0.112};
-                  {"type":"usd","usd": $lookup($prices, widgets.mode), "format":{"suffix":"/second"}}
+                  $prices := {
+                    "kling-v3": {"std": 0.126, "pro": 0.168},
+                    "kling-v2-6": {"std": 0.07, "pro": 0.112}
+                  };
+                  $modelPrices := $lookup($prices, widgets.model);
+                  {"type":"usd","usd": $lookup($modelPrices, widgets.mode), "format":{"suffix":"/second"}}
                 )
                 """,
             ),

comfy_api_nodes/nodes_luma.py

@@ -1,10 +1,11 @@
-from typing import Optional
-
 import torch
 from typing_extensions import override
 
-from comfy_api.latest import IO, ComfyExtension
+from comfy_api.latest import IO, ComfyExtension, Input
 from comfy_api_nodes.apis.luma import (
+    Luma2Generation,
+    Luma2GenerationRequest,
+    Luma2ImageRef,
     LumaAspectRatio,
     LumaCharacterRef,
     LumaConceptChain,
@@ -30,6 +31,7 @@ from comfy_api_nodes.util import (
     download_url_to_video_output,
     poll_op,
     sync_op,
+    upload_image_to_comfyapi,
     upload_images_to_comfyapi,
     validate_string,
 )
@@ -212,9 +214,9 @@ class LumaImageGenerationNode(IO.ComfyNode):
         aspect_ratio: str,
         seed,
         style_image_weight: float,
-        image_luma_ref: Optional[LumaReferenceChain] = None,
-        style_image: Optional[torch.Tensor] = None,
-        character_image: Optional[torch.Tensor] = None,
+        image_luma_ref: LumaReferenceChain | None = None,
+        style_image: torch.Tensor | None = None,
+        character_image: torch.Tensor | None = None,
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=True, min_length=3)
         # handle image_luma_ref
@@ -434,7 +436,7 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
         duration: str,
         loop: bool,
         seed,
-        luma_concepts: Optional[LumaConceptChain] = None,
+        luma_concepts: LumaConceptChain | None = None,
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=False, min_length=3)
         duration = duration if model != LumaVideoModel.ray_1_6 else None
@@ -533,7 +535,6 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=PRICE_BADGE_VIDEO,
-
         )
 
     @classmethod
@@ -644,6 +645,293 @@ PRICE_BADGE_VIDEO = IO.PriceBadge(
 )
 
 
+def _luma2_uni1_common_inputs(max_image_refs: int) -> list:
+    return [
+        IO.Combo.Input(
+            "style",
+            options=["auto", "manga"],
+            default="auto",
+            tooltip="Style preset. 'auto' picks based on the prompt; "
+            "'manga' applies a manga/anime aesthetic and requires a portrait "
+            "aspect ratio (2:3, 9:16, 1:2, 1:3).",
+        ),
+        IO.Boolean.Input(
+            "web_search",
+            default=False,
+            tooltip="Search the web for visual references before generating.",
+        ),
+        IO.Autogrow.Input(
+            "image_ref",
+            template=IO.Autogrow.TemplateNames(
+                IO.Image.Input("image"),
+                names=[f"image_{i}" for i in range(1, max_image_refs + 1)],
+                min=0,
+            ),
+            optional=True,
+            tooltip=f"Up to {max_image_refs} reference images for style/content guidance.",
+        ),
+    ]
+
+
+async def _luma2_upload_image_refs(
+    cls: type[IO.ComfyNode],
+    refs: dict | None,
+    max_count: int,
+) -> list[Luma2ImageRef] | None:
+    if not refs:
+        return None
+    out: list[Luma2ImageRef] = []
+    for key in refs:
+        url = await upload_image_to_comfyapi(cls, refs[key])
+        out.append(Luma2ImageRef(url=url))
+    if len(out) > max_count:
+        raise ValueError(f"Maximum {max_count} reference images are allowed.")
+    return out or None
+
+
+async def _luma2_submit_and_poll(
+    cls: type[IO.ComfyNode],
+    request: Luma2GenerationRequest,
+) -> Input.Image:
+    initial = await sync_op(
+        cls,
+        ApiEndpoint(path="/proxy/luma_2/generations", method="POST"),
+        response_model=Luma2Generation,
+        data=request,
+    )
+    if not initial.id:
+        raise RuntimeError("Luma 2 API did not return a generation id.")
+    final = await poll_op(
+        cls,
+        ApiEndpoint(path=f"/proxy/luma_2/generations/{initial.id}", method="GET"),
+        response_model=Luma2Generation,
+        status_extractor=lambda r: r.state,
+        progress_extractor=lambda r: None,
+    )
+    if not final.output:
+        msg = final.failure_reason or "no output returned"
+        raise RuntimeError(f"Luma 2 generation failed: {msg}")
+    url = final.output[0].url
+    if not url:
+        raise RuntimeError("Luma 2 generation completed without an output URL.")
+    return await download_url_to_image_tensor(url)
+
+
+class LumaImageNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="LumaImageNode2",
+            display_name="Luma UNI-1 Image",
+            category="api node/image/Luma",
+            description="Generate images from text using the Luma UNI-1 model.",
+            inputs=[
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    default="",
+                    tooltip="Text description of the desired image. 1–6000 characters.",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(
+                            "uni-1",
+                            [
+                                IO.Combo.Input(
+                                    "aspect_ratio",
+                                    options=[
+                                        "auto",
+                                        "3:1",
+                                        "2:1",
+                                        "16:9",
+                                        "3:2",
+                                        "1:1",
+                                        "2:3",
+                                        "9:16",
+                                        "1:2",
+                                        "1:3",
+                                    ],
+                                    default="auto",
+                                    tooltip="Output image aspect ratio. 'auto' lets "
+                                    "the model pick based on the prompt.",
+                                ),
+                                *_luma2_uni1_common_inputs(max_image_refs=9),
+                            ],
+                        ),
+                        IO.DynamicCombo.Option(
+                            "uni-1-max",
+                            [
+                                IO.Combo.Input(
+                                    "aspect_ratio",
+                                    options=[
+                                        "auto",
+                                        "3:1",
+                                        "2:1",
+                                        "16:9",
+                                        "3:2",
+                                        "1:1",
+                                        "2:3",
+                                        "9:16",
+                                        "1:2",
+                                        "1:3",
+                                    ],
+                                    default="auto",
+                                    tooltip="Output image aspect ratio. 'auto' lets "
+                                    "the model pick based on the prompt.",
+                                ),
+                                *_luma2_uni1_common_inputs(max_image_refs=9),
+                            ],
+                        ),
+                    ],
+                    tooltip="Model to use for generation.",
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=0,
+                    min=0,
+                    max=2147483647,
+                    control_after_generate=True,
+                    tooltip="Seed controls whether the node should re-run; "
+                    "results are non-deterministic regardless of seed.",
+                ),
+            ],
+            outputs=[IO.Image.Output()],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+            is_api_node=True,
+            price_badge=IO.PriceBadge(
+                depends_on=IO.PriceBadgeDepends(widgets=["model"], input_groups=["model.image_ref"]),
+                expr="""
+                (
+                  $m := widgets.model;
+                  $refs := $lookup(inputGroups, "model.image_ref");
+                  $base := $m = "uni-1-max" ? 0.1 : 0.0404;
+                  {"type":"usd","usd": $round($base + 0.003 * $refs, 4)}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        prompt: str,
+        model: dict,
+        seed: int,
+    ) -> IO.NodeOutput:
+        validate_string(prompt, min_length=1, max_length=6000)
+        aspect_ratio = model["aspect_ratio"]
+        style = model["style"]
+        allowed_manga_ratios = {"2:3", "9:16", "1:2", "1:3"}
+        if style == "manga" and aspect_ratio != "auto" and aspect_ratio not in allowed_manga_ratios:
+            raise ValueError(
+                f"'manga' style requires a portrait aspect ratio "
+                f"({', '.join(sorted(allowed_manga_ratios))}) or 'auto'; got '{aspect_ratio}'."
+            )
+        request = Luma2GenerationRequest(
+            prompt=prompt,
+            model=model["model"],
+            type="image",
+            aspect_ratio=aspect_ratio if aspect_ratio != "auto" else None,
+            style=style if style != "auto" else None,
+            output_format="png",
+            web_search=model["web_search"],
+            image_ref=await _luma2_upload_image_refs(cls, model.get("image_ref"), max_count=9),
+        )
+        return IO.NodeOutput(await _luma2_submit_and_poll(cls, request))
+
+
+class LumaImageEditNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="LumaImageEditNode2",
+            display_name="Luma UNI-1 Image Edit",
+            category="api node/image/Luma",
+            description="Edit an existing image with a text prompt using the Luma UNI-1 model.",
+            inputs=[
+                IO.Image.Input(
+                    "source",
+                    tooltip="Source image to edit.",
+                ),
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    default="",
+                    tooltip="Description of the desired edit. 1–6000 characters.",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(
+                            "uni-1",
+                            _luma2_uni1_common_inputs(max_image_refs=8),
+                        ),
+                        IO.DynamicCombo.Option(
+                            "uni-1-max",
+                            _luma2_uni1_common_inputs(max_image_refs=8),
+                        ),
+                    ],
+                    tooltip="Model to use for editing.",
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=0,
+                    min=0,
+                    max=2147483647,
+                    control_after_generate=True,
+                    tooltip="Seed controls whether the node should re-run; "
+                    "results are non-deterministic regardless of seed.",
+                ),
+            ],
+            outputs=[IO.Image.Output()],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+            is_api_node=True,
+            price_badge=IO.PriceBadge(
+                depends_on=IO.PriceBadgeDepends(widgets=["model"], input_groups=["model.image_ref"]),
+                expr="""
+                (
+                  $m := widgets.model;
+                  $refs := $lookup(inputGroups, "model.image_ref");
+                  $base := $m = "uni-1-max" ? 0.103 : 0.0434;
+                  {"type":"usd","usd": $round($base + 0.003 * $refs, 4)}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        source: Input.Image,
+        prompt: str,
+        model: dict,
+        seed: int,
+    ) -> IO.NodeOutput:
+        validate_string(prompt, min_length=1, max_length=6000)
+        request = Luma2GenerationRequest(
+            prompt=prompt,
+            model=model["model"],
+            type="image_edit",
+            source=Luma2ImageRef(url=await upload_image_to_comfyapi(cls, source)),
+            style=model["style"] if model["style"] != "auto" else None,
+            output_format="png",
+            web_search=model["web_search"],
+            image_ref=await _luma2_upload_image_refs(cls, model.get("image_ref"), max_count=8),
+        )
+        return IO.NodeOutput(await _luma2_submit_and_poll(cls, request))
+
+
 class LumaExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -654,6 +942,8 @@ class LumaExtension(ComfyExtension):
             LumaImageToVideoGenerationNode,
             LumaReferenceNode,
             LumaConceptsNode,
+            LumaImageNode,
+            LumaImageEditNode,
         ]
 
 

comfy_api_nodes/nodes_openai.py

@@ -39,16 +39,18 @@ STARTING_POINT_ID_PATTERN = r"<starting_point_id:(.*)>"
 
 
 class SupportedOpenAIModel(str, Enum):
-    o4_mini = "o4-mini"
-    o1 = "o1"
-    o3 = "o3"
-    o1_pro = "o1-pro"
-    gpt_4_1 = "gpt-4.1"
-    gpt_4_1_mini = "gpt-4.1-mini"
-    gpt_4_1_nano = "gpt-4.1-nano"
+    gpt_5_5_pro = "gpt-5.5-pro"
+    gpt_5_5 = "gpt-5.5"
     gpt_5 = "gpt-5"
     gpt_5_mini = "gpt-5-mini"
     gpt_5_nano = "gpt-5-nano"
+    gpt_4_1 = "gpt-4.1"
+    gpt_4_1_mini = "gpt-4.1-mini"
+    gpt_4_1_nano = "gpt-4.1-nano"
+    o4_mini = "o4-mini"
+    o3 = "o3"
+    o1_pro = "o1-pro"
+    o1 = "o1"
 
 
 async def validate_and_cast_response(response, timeout: int = None) -> torch.Tensor:
@@ -739,6 +741,16 @@ class OpenAIChatNode(IO.ComfyNode):
                     "usd": [0.002, 0.008],
                     "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
                   }
+                  : $contains($m, "gpt-5.5-pro") ? {
+                    "type": "list_usd",
+                    "usd": [0.03, 0.18],
+                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
+                  }
+                  : $contains($m, "gpt-5.5") ? {
+                    "type": "list_usd",
+                    "usd": [0.005, 0.03],
+                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
+                  }
                   : $contains($m, "gpt-5-nano") ? {
                     "type": "list_usd",
                     "usd": [0.00005, 0.0004],

comfyui_version.py

@@ -1,3 +1,3 @@
 # This file is automatically generated by the build process when version is
 # updated in pyproject.toml.
-__version__ = "0.20.1"
+__version__ = "0.20.3"

node_helpers.py

@@ -86,6 +86,6 @@ def image_alpha_fix(destination, source):
     if destination.shape[-1] < source.shape[-1]:
         source = source[...,:destination.shape[-1]]
     elif destination.shape[-1] > source.shape[-1]:
-        destination = torch.nn.functional.pad(destination, (0, 1))
-        destination[..., -1] = 1.0
+        source = torch.nn.functional.pad(source, (0, 1))
+        source[..., -1] = 1.0
     return destination, source

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ComfyUI"
-version = "0.20.1"
+version = "0.20.3"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"

requirements.txt

@@ -1,5 +1,5 @@
 comfyui-frontend-package==1.42.15
-comfyui-workflow-templates==0.9.68
+comfyui-workflow-templates==0.9.72
 comfyui-embedded-docs==0.4.4
 torch
 torchsde