Merge branch 'master' into feat/api-nodes/beeble-switchx

Signed-off-by: bigcat88 <bigcat88@icloud.com>

comfy_api_nodes/apis/beeble.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field
+
+
+class CreateSwitchXRequest(BaseModel):
+    generation_type: str = Field(...)
+    source_uri: str = Field(...)
+    alpha_mode: str = Field(...)
+    prompt: str | None = Field(None, max_length=2000)
+    reference_image_uri: str | None = Field(None)
+    alpha_uri: str | None = Field(None)
+    max_resolution: int = Field(1080)
+    callback_url: str | None = Field(None)
+    idempotency_key: str | None = Field(None, max_length=256, min_length=1)
+
+
+class SwitchXOutputUrls(BaseModel):
+    render: str | None = Field(None)
+    source: str | None = Field(None)
+    alpha: str | None = Field(None)
+
+
+class SwitchXStatusResponse(BaseModel):
+    id: str = Field(...)
+    status: str = Field(...)
+    progress: int | None = Field(None)
+    generation_type: str | None = Field(None)
+    alpha_mode: str | None = Field(None)
+    output: SwitchXOutputUrls | None = Field(None)
+    error: str | None = Field(None)
+    created_at: str | None = Field(None)
+    modified_at: str | None = Field(None)
+    completed_at: str | None = Field(None)

comfy_api_nodes/apis/bytedance.py

@@ -158,8 +158,9 @@ class SeedanceCreateAssetResponse(BaseModel):
 
 
 class SeedanceVirtualLibraryCreateAssetRequest(BaseModel):
-    url: str = Field(..., description="Publicly accessible URL of the image asset to upload.")
+    url: str = Field(..., description="Publicly accessible URL of the asset to upload.")
     hash: str = Field(..., description="Dedup key. Re-submitting the same hash returns the existing asset id.")
+    asset_type: str | None = Field(None, description="BytePlus asset type. Defaults to Image server-side when omitted.")
 
 
 # Dollars per 1K tokens, keyed by (model_id, has_video_input).

comfy_api_nodes/apis/krea.py

@@ -0,0 +1,46 @@
+"""Pydantic models for the Krea image-generation API."""
+
+from pydantic import BaseModel, Field
+
+
+class KreaMoodboard(BaseModel):
+    id: str = Field(...)
+    strength: float = Field(default=0.35, ge=-0.5, le=1.5)
+
+
+class KreaImageStyleReference(BaseModel):
+    strength: float = Field(..., ge=-2.0, le=2.0)
+    url: str | None = Field(default=None)
+
+
+class KreaGenerateImageRequest(BaseModel):
+    prompt: str = Field(...)
+    aspect_ratio: str = Field(...)
+    resolution: str = Field(...)
+    seed: int | None = Field(default=None)
+    creativity: str = Field(default="medium")
+    moodboards: list[KreaMoodboard] | None = Field(default=None)
+    image_style_references: list[KreaImageStyleReference] | None = Field(default=None)
+
+
+class KreaJobResult(BaseModel):
+    urls: list[str] | None = Field(default=None)
+    style_id: str | None = Field(default=None)
+
+
+class KreaJob(BaseModel):
+    job_id: str = Field(...)
+    status: str = Field(...)
+    created_at: str = Field(...)
+    completed_at: str | None = Field(default=None)
+    result: KreaJobResult | None = Field(default=None)
+
+
+class KreaAssetResponse(BaseModel):
+    id: str = Field(...)
+    image_url: str = Field(...)
+    uploaded_at: str = Field(...)
+    width: float | None = Field(default=None)
+    height: float | None = Field(default=None)
+    size_bytes: float | None = Field(default=None)
+    mime_type: str | None = Field(default=None)

comfy_api_nodes/nodes_beeble.py

@@ -0,0 +1,404 @@
+from fractions import Fraction
+
+from typing_extensions import override
+
+from comfy_api.latest import IO, ComfyExtension, Input, InputImpl, Types
+from comfy_api_nodes.apis.beeble import (
+    CreateSwitchXRequest,
+    SwitchXStatusResponse,
+)
+from comfy_api_nodes.util import (
+    ApiEndpoint,
+    bytesio_to_image_tensor,
+    convert_mask_to_image,
+    download_url_as_bytesio,
+    download_url_to_image_tensor,
+    download_url_to_video_output,
+    downscale_image_tensor,
+    downscale_video_to_max_pixels,
+    poll_op,
+    sync_op,
+    upload_image_to_comfyapi,
+    upload_video_to_comfyapi,
+    validate_string,
+    validate_video_frame_count,
+)
+
+_MAX_PIXELS = 2_770_000
+_MAX_FRAMES = 240
+_MAX_PROMPT_LEN = 2000
+
+
+def _validate_inputs(prompt: str | None, reference_image: Input.Image | None) -> str | None:
+    """Beeble requires at least one of prompt or reference_image. Returns the cleaned prompt."""
+    cleaned = prompt.strip() if prompt else ""
+    if not cleaned and reference_image is None:
+        raise ValueError("At least one of 'prompt' or 'reference_image' must be provided.")
+    if cleaned:
+        validate_string(cleaned, strip_whitespace=False, max_length=_MAX_PROMPT_LEN)
+    return cleaned or None
+
+
+async def _upload_mask_as_image(
+    cls: type[IO.ComfyNode],
+    mask: Input.Image,
+    *,
+    wait_label: str,
+) -> str:
+    """Encode a single-frame MASK (H, W) or (1, H, W) as a PNG and upload."""
+    if mask.dim() == 2:
+        mask = mask.unsqueeze(0)
+    image = convert_mask_to_image(mask[:1])
+    return await upload_image_to_comfyapi(
+        cls,
+        image,
+        mime_type="image/png",
+        wait_label=wait_label,
+        total_pixels=_MAX_PIXELS,
+    )
+
+
+async def _upload_mask_batch_as_video(
+    cls: type[IO.ComfyNode],
+    mask: Input.Image,
+    *,
+    frame_rate: Fraction,
+    source_frame_count: int,
+    wait_label: str,
+) -> str:
+    """Encode a MASK batch (N, H, W) as a grayscale H.264 MP4 at frame_rate and upload.
+
+    The matte is always downscaled to the pixel budget so it stays within Beeble's limit and
+    keeps the same dimensions as the (similarly downscaled) source — both use the same algorithm
+    from the same starting dimensions, and downscaling is a no-op when already within budget.
+    """
+    if mask.dim() == 2:
+        mask = mask.unsqueeze(0)
+    if mask.shape[0] != source_frame_count:
+        raise ValueError(
+            f"Custom alpha video frame count ({mask.shape[0]}) does not match the "
+            f"source video frame count ({source_frame_count}). The Beeble API requires "
+            "one mask per source frame."
+        )
+    images = downscale_image_tensor(convert_mask_to_image(mask), _MAX_PIXELS)
+    alpha_video = InputImpl.VideoFromComponents(Types.VideoComponents(images=images, audio=None, frame_rate=frame_rate))
+    return await upload_video_to_comfyapi(cls, alpha_video, wait_label=wait_label)
+
+
+def _alpha_mode_input(*, video: bool) -> IO.DynamicCombo.Input:
+    """Build the alpha_mode DynamicCombo with mode-specific extra inputs."""
+    select_keyframe_tooltip = (
+        "First-frame keyframe mask. Beeble propagates this across the video." if video else "Grayscale keyframe mask."
+    )
+    custom_tooltip = (
+        "Per-frame grayscale mask covering the entire video. "
+        "Must have the same frame count as the source. "
+        "Connect a MASK output from SAM3_TrackToMask or similar."
+        if video
+        else "Grayscale mask to apply."
+    )
+    return IO.DynamicCombo.Input(
+        "alpha_mode",
+        tooltip=(
+            "Controls how SwitchX decides what to keep vs. regenerate. "
+            "'auto' isolates the main subject automatically. "
+            "'fill' regenerates the entire frame while preserving geometry. "
+            "'select' propagates a first-frame keyframe across the clip. "
+            "'custom' uses a per-frame alpha matte you provide."
+        ),
+        options=[
+            IO.DynamicCombo.Option("auto", []),
+            IO.DynamicCombo.Option("fill", []),
+            IO.DynamicCombo.Option(
+                "select",
+                [IO.Mask.Input("alpha_keyframe", tooltip=select_keyframe_tooltip)],
+            ),
+            IO.DynamicCombo.Option(
+                "custom",
+                [IO.Mask.Input("alpha_mask", tooltip=custom_tooltip)],
+            ),
+        ],
+    )
+
+
+def _common_inputs(*, source: IO.Input, video: bool) -> list[IO.Input]:
+    return [
+        source,
+        IO.String.Input(
+            "prompt",
+            multiline=True,
+            default="",
+            tooltip=(
+                "Text description of the desired output (max 2000 chars). "
+                "At least one of 'prompt' or 'reference_image' is required."
+            ),
+        ),
+        IO.Image.Input(
+            "reference_image",
+            optional=True,
+            tooltip=(
+                "Reference image whose look (background, lighting, costume) the result "
+                "should adopt. At least one of 'reference_image' or 'prompt' is required."
+            ),
+        ),
+        _alpha_mode_input(video=video),
+        IO.Combo.Input(
+            "max_resolution",
+            options=["1080p", "720p"],
+            default="1080p",
+            tooltip="Maximum output resolution.",
+        ),
+        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."
+            ),
+        ),
+    ]
+
+
+async def _submit_and_poll(
+    cls: type[IO.ComfyNode],
+    request: CreateSwitchXRequest,
+) -> SwitchXStatusResponse:
+    initial = await sync_op(
+        cls,
+        ApiEndpoint(path="/proxy/beeble/v1/switchx/generations", method="POST"),
+        response_model=SwitchXStatusResponse,
+        data=request,
+    )
+    return await poll_op(
+        cls,
+        ApiEndpoint(path=f"/proxy/beeble/v1/switchx/generations/{initial.id}"),
+        response_model=SwitchXStatusResponse,
+        status_extractor=lambda r: r.status,
+        progress_extractor=lambda r: r.progress,
+    )
+
+
+def _require_output_url(response: SwitchXStatusResponse, name: str) -> str:
+    if response.output is None or getattr(response.output, name) is None:
+        raise RuntimeError(f"Beeble job {response.id} completed without a {name!r} output URL.")
+    return getattr(response.output, name)
+
+
+def _alpha_url(response: SwitchXStatusResponse, mode: str) -> str | None:
+    """URL of the alpha matte, or None when the mode produces no separate matte.
+
+    'fill' selects the whole frame, so Beeble writes no alpha asset even though the status
+    response still returns a (dangling) signed URL for it — fetching it 403s with S3
+    AccessDenied. The other three modes ('auto', 'custom', 'select') all produce a real,
+    downloadable matte.
+    """
+    if mode == "fill" or response.output is None:
+        return None
+    return response.output.alpha
+
+
+class BeebleSwitchXVideoEdit(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="BeebleSwitchXVideoEdit",
+            display_name="Beeble SwitchX Video Edit",
+            category="api node/video/Beeble",
+            description=(
+                "Edit a video with Beeble SwitchX. Switches anything in the scene (background, "
+                "lighting, costume) while preserving the original subject's pixels and motion. "
+                "Provide a reference image and/or text prompt to describe the new look. "
+                "Max 240 frames, max ~2.77MP per frame."
+            ),
+            inputs=_common_inputs(source=IO.Video.Input("video"), video=True),
+            outputs=[
+                IO.Video.Output(display_name="video"),
+                IO.Video.Output(
+                    display_name="alpha",
+                    tooltip="The alpha matte Beeble used. Empty for 'fill' mode, which has no separate matte.",
+                ),
+            ],
+            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=["max_resolution"]),
+                expr="""
+                (
+                  $rate := widgets.max_resolution = "1080p" ? 0.429 : 0.143;
+                  {"type":"usd","usd": $rate, "format":{"suffix":"/30 frames"}}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        video: Input.Video,
+        prompt: str,
+        alpha_mode: dict,
+        max_resolution: str,
+        seed: int,
+        reference_image: Input.Image | None = None,
+    ) -> IO.NodeOutput:
+        cleaned_prompt = _validate_inputs(prompt, reference_image)
+
+        validate_video_frame_count(video, max_frame_count=_MAX_FRAMES)
+        video = downscale_video_to_max_pixels(video, _MAX_PIXELS)
+
+        mode = alpha_mode["alpha_mode"]
+        alpha_uri: str | None = None
+        if mode == "select":
+            alpha_uri = await _upload_mask_as_image(cls, alpha_mode["alpha_keyframe"], wait_label="Uploading keyframe")
+        elif mode == "custom":
+            alpha_uri = await _upload_mask_batch_as_video(
+                cls,
+                alpha_mode["alpha_mask"],
+                frame_rate=video.get_frame_rate(),
+                source_frame_count=video.get_frame_count(),
+                wait_label="Uploading alpha video",
+            )
+
+        source_uri = await upload_video_to_comfyapi(cls, video, wait_label="Uploading source")
+        reference_uri: str | None = None
+        if reference_image is not None:
+            reference_uri = await upload_image_to_comfyapi(
+                cls,
+                reference_image,
+                mime_type="image/png",
+                wait_label="Uploading reference",
+                total_pixels=_MAX_PIXELS,
+            )
+
+        request = CreateSwitchXRequest(
+            generation_type="video",
+            source_uri=source_uri,
+            alpha_mode=mode,
+            prompt=cleaned_prompt,
+            reference_image_uri=reference_uri,
+            alpha_uri=alpha_uri,
+            max_resolution=1080 if max_resolution == "1080p" else 720,
+        )
+        response = await _submit_and_poll(cls, request)
+
+        render = await download_url_to_video_output(_require_output_url(response, "render"))
+        alpha = None
+        if (alpha_url := _alpha_url(response, mode)) is not None:
+            alpha = await download_url_to_video_output(alpha_url)
+        return IO.NodeOutput(render, alpha)
+
+
+class BeebleSwitchXImageEdit(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="BeebleSwitchXImageEdit",
+            display_name="Beeble SwitchX Image Edit",
+            category="api node/image/Beeble",
+            description=(
+                "Edit a single image with Beeble SwitchX. Switches anything in the scene "
+                "(background, lighting, costume) while preserving the original subject's pixels. "
+                "Provide a reference image and/or text prompt to describe the new look. "
+                "Max ~2.77MP."
+            ),
+            inputs=_common_inputs(source=IO.Image.Input("image"), video=False),
+            outputs=[
+                IO.Image.Output(display_name="image"),
+                IO.Mask.Output(
+                    display_name="alpha",
+                    tooltip="The alpha matte Beeble used. Empty for 'fill' mode, which has no separate matte.",
+                ),
+            ],
+            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=["max_resolution"]),
+                expr="""
+                (
+                  $rate := widgets.max_resolution = "1080p" ? 0.429 : 0.143;
+                  {"type":"usd","usd": $rate}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        image: Input.Image,
+        prompt: str,
+        alpha_mode: dict,
+        max_resolution: str,
+        seed: int,
+        reference_image: Input.Image | None = None,
+    ) -> IO.NodeOutput:
+        cleaned_prompt = _validate_inputs(prompt, reference_image)
+
+        image = downscale_image_tensor(image, _MAX_PIXELS)
+
+        mode = alpha_mode["alpha_mode"]
+        alpha_uri: str | None = None
+        if mode == "select":
+            alpha_uri = await _upload_mask_as_image(cls, alpha_mode["alpha_keyframe"], wait_label="Uploading keyframe")
+        elif mode == "custom":
+            alpha_uri = await _upload_mask_as_image(cls, alpha_mode["alpha_mask"], wait_label="Uploading alpha")
+
+        source_uri = await upload_image_to_comfyapi(
+            cls,
+            image,
+            mime_type="image/png",
+            wait_label="Uploading source",
+            total_pixels=None,
+        )
+        reference_uri: str | None = None
+        if reference_image is not None:
+            reference_uri = await upload_image_to_comfyapi(
+                cls,
+                reference_image,
+                mime_type="image/png",
+                wait_label="Uploading reference",
+                total_pixels=_MAX_PIXELS,
+            )
+
+        request = CreateSwitchXRequest(
+            generation_type="image",
+            source_uri=source_uri,
+            alpha_mode=mode,
+            prompt=cleaned_prompt,
+            reference_image_uri=reference_uri,
+            alpha_uri=alpha_uri,
+            max_resolution=1080 if max_resolution == "1080p" else 720,
+        )
+        response = await _submit_and_poll(cls, request)
+
+        render = await download_url_to_image_tensor(_require_output_url(response, "render"))
+        alpha_mask = None
+        if (alpha_url := _alpha_url(response, mode)) is not None:
+            alpha_image = bytesio_to_image_tensor(await download_url_as_bytesio(alpha_url), mode="L")
+            alpha_mask = alpha_image.squeeze(-1) if alpha_image.dim() == 4 else alpha_image
+        return IO.NodeOutput(render, alpha_mask)
+
+
+class BeebleExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
+        return [
+            BeebleSwitchXVideoEdit,
+            BeebleSwitchXImageEdit,
+        ]
+
+
+async def comfy_entrypoint() -> BeebleExtension:
+    return BeebleExtension()

comfy_api_nodes/nodes_bytedance.py

@@ -2,11 +2,12 @@ import hashlib
 import logging
 import math
 import re
+from io import BytesIO
 
 import torch
 from typing_extensions import override
 
-from comfy_api.latest import IO, ComfyExtension, Input
+from comfy_api.latest import IO, ComfyExtension, Input, Types
 from comfy_api_nodes.apis.bytedance import (
     RECOMMENDED_PRESETS,
     RECOMMENDED_PRESETS_SEEDREAM_4,
@@ -308,6 +309,26 @@ async def _seedance_virtual_library_upload_image_asset(
     return f"asset://{create_resp.asset_id}"
 
 
+async def _seedance_virtual_library_upload_video_asset(
+    cls: type[IO.ComfyNode],
+    video: Input.Video,
+    *,
+    wait_label: str = "Uploading video",
+) -> str:
+    buf = BytesIO()
+    video.save_to(buf, format=Types.VideoContainer.MP4, codec=Types.VideoCodec.H264)
+    video_hash = hashlib.sha256(buf.getbuffer()).hexdigest()
+    public_url = await upload_video_to_comfyapi(cls, video, wait_label=wait_label)
+    create_resp = await sync_op(
+        cls,
+        ApiEndpoint(path="/proxy/seedance/virtual-library/assets", method="POST"),
+        response_model=SeedanceCreateAssetResponse,
+        data=SeedanceVirtualLibraryCreateAssetRequest(url=public_url, hash=video_hash, asset_type="Video"),
+    )
+    await _wait_for_asset_active(cls, create_resp.asset_id, group_id="virtual-library")
+    return f"asset://{create_resp.asset_id}"
+
+
 def _seedance2_price_extractor(model_id: str, has_video_input: bool):
     """Returns a price_extractor closure for Seedance 2.0 poll_op."""
     rate = SEEDANCE2_PRICE_PER_1K_TOKENS.get((model_id, has_video_input))
@@ -2106,7 +2127,7 @@ class ByteDance2ReferenceNode(IO.ComfyNode):
             content.append(
                 TaskVideoContent(
                     video_url=TaskVideoContentUrl(
-                        url=await upload_video_to_comfyapi(
+                        url=await _seedance_virtual_library_upload_video_asset(
                             cls,
                             reference_videos[key],
                             wait_label=f"Uploading video {i}",

comfy_api_nodes/nodes_krea.py

@@ -0,0 +1,290 @@
+"""Krea image-generation nodes."""
+
+import re
+
+from typing_extensions import override
+
+from comfy_api.latest import IO, ComfyExtension, Input
+from comfy_api_nodes.apis.krea import (
+    KreaAssetResponse,
+    KreaGenerateImageRequest,
+    KreaImageStyleReference,
+    KreaJob,
+    KreaMoodboard,
+)
+from comfy_api_nodes.util import (
+    ApiEndpoint,
+    download_url_to_image_tensor,
+    poll_op,
+    sync_op,
+    tensor_to_bytesio,
+    validate_string,
+)
+
+
+class KreaIO:
+    STYLE_REF = "KREA_STYLE_REF"
+
+
+async def _upload_image_to_krea_assets(cls: type[IO.ComfyNode], image: Input.Image) -> str:
+    """Upload an image to Krea's /assets endpoint and return the Krea-hosted image URL."""
+    img_io = tensor_to_bytesio(image, total_pixels=2048 * 2048, mime_type="image/png")
+    response = await sync_op(
+        cls,
+        endpoint=ApiEndpoint(path="/proxy/krea/assets", method="POST"),
+        response_model=KreaAssetResponse,
+        files=[("file", (img_io.name, img_io, "image/png"))],
+        content_type="multipart/form-data",
+        max_retries=1,
+        wait_label="Uploading reference",
+    )
+    return response.image_url
+
+
+_MODEL_MEDIUM = "Krea 2 Medium"
+_MODEL_LARGE = "Krea 2 Large"
+_MODEL_ENDPOINTS: dict[str, str] = {
+    _MODEL_MEDIUM: "/proxy/krea/generate/image/krea/krea-2/medium",
+    _MODEL_LARGE: "/proxy/krea/generate/image/krea/krea-2/large",
+}
+
+_ASPECT_RATIOS = ["1:1", "4:3", "3:2", "16:9", "2.35:1", "4:5", "2:3", "9:16"]
+_RESOLUTIONS = ["1K"]
+_CREATIVITY_LEVELS = ["raw", "low", "medium", "high"]
+_KREA_QUEUED_STATUSES = ["backlogged", "queued", "scheduled"]
+
+_UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+
+def _krea_model_inputs() -> list:
+    """Nested inputs shared by both Krea 2 Medium and Large under the DynamicCombo."""
+    return [
+        IO.Combo.Input(
+            "aspect_ratio",
+            options=_ASPECT_RATIOS,
+            tooltip="Output aspect ratio.",
+        ),
+        IO.Combo.Input(
+            "resolution",
+            options=_RESOLUTIONS,
+            tooltip="Resolution scale.",
+        ),
+        IO.Combo.Input(
+            "creativity",
+            options=_CREATIVITY_LEVELS,
+            default="medium",
+            tooltip="Prompt interpretation strength: raw stays closest to the prompt; high is most creative.",
+        ),
+        IO.String.Input(
+            "moodboard_id",
+            default="",
+            tooltip="Optional Krea moodboard UUID (e.g. from the Krea website). "
+            "Leave empty to disable. Only one moodboard is supported per request.",
+            optional=True,
+        ),
+        IO.Float.Input(
+            "moodboard_strength",
+            default=0.35,
+            min=-0.5,
+            max=1.5,
+            step=0.05,
+            tooltip="Moodboard influence; ignored when moodboard_id is empty.",
+            optional=True,
+        ),
+        IO.Custom(KreaIO.STYLE_REF).Input(
+            "style_reference",
+            optional=True,
+            tooltip="Optional chain of style references (max 10) from Krea 2 Style Reference nodes.",
+        ),
+    ]
+
+
+class Krea2ImageNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="Krea2ImageNode",
+            display_name="Krea 2 Image",
+            category="api node/image/Krea",
+            description=(
+                "Generate images via Krea 2 — pick Medium (expressive illustrations) or "
+                "Large (expressive photorealism). Supports an optional moodboard and up "
+                "to 10 chained image style references."
+            ),
+            inputs=[
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    default="",
+                    tooltip="Text prompt for the image.",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(_MODEL_MEDIUM, _krea_model_inputs()),
+                        IO.DynamicCombo.Option(_MODEL_LARGE, _krea_model_inputs()),
+                    ],
+                    tooltip="Krea 2 Medium is best for expressive illustrations; "
+                    "Krea 2 Large is best for expressive photorealism.",
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=0,
+                    min=0,
+                    max=2147483647,
+                    control_after_generate=True,
+                    tooltip="Random seed for reproducibility.",
+                ),
+            ],
+            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", "model.moodboard_id"],
+                    inputs=["model.style_reference"],
+                ),
+                expr="""
+                (
+                  $isLarge := widgets.model = "krea 2 large";
+                  $hasMoodboard := $length($lookup(widgets, "model.moodboard_id")) > 0;
+                  $hasStyle := $lookup(inputs, "model.style_reference").connected;
+                  $usd := $hasMoodboard
+                    ? ($isLarge ? 0.07 : 0.04)
+                    : ($hasStyle
+                        ? ($isLarge ? 0.065 : 0.035)
+                        : ($isLarge ? 0.06 : 0.03));
+                  {"type":"usd","usd": $usd}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        prompt: str,
+        model: dict,
+        seed: int,
+    ) -> IO.NodeOutput:
+        validate_string(prompt, strip_whitespace=False, min_length=1)
+
+        model_choice = model["model"]
+        endpoint_path = _MODEL_ENDPOINTS.get(model_choice)
+        if endpoint_path is None:
+            raise ValueError(f"Unknown Krea 2 model: {model_choice!r}")
+
+        moodboards: list[KreaMoodboard] | None = None
+        mb_id = (model.get("moodboard_id") or "").strip()
+        if mb_id:
+            if not _UUID_RE.match(mb_id):
+                raise ValueError(f"moodboard_id must be a UUID (received {mb_id!r}); copy it from the Krea website.")
+            mb_strength = model.get("moodboard_strength")
+            moodboards = [KreaMoodboard(id=mb_id, strength=0.35 if mb_strength is None else float(mb_strength))]
+
+        style_reference = model.get("style_reference")
+        image_style_references: list[KreaImageStyleReference] | None = None
+        if style_reference:
+            if len(style_reference) > 10:
+                raise ValueError(f"Krea 2 accepts at most 10 image_style_references; received {len(style_reference)}.")
+            image_style_references = [
+                KreaImageStyleReference(url=ref["url"], strength=float(ref["strength"])) for ref in style_reference
+            ]
+        initial = await sync_op(
+            cls,
+            ApiEndpoint(path=endpoint_path, method="POST"),
+            response_model=KreaJob,
+            data=KreaGenerateImageRequest(
+                prompt=prompt,
+                aspect_ratio=model["aspect_ratio"],
+                resolution=model["resolution"],
+                seed=seed,
+                creativity=model["creativity"],
+                moodboards=moodboards,
+                image_style_references=image_style_references,
+            ),
+        )
+        job = await poll_op(
+            cls,
+            ApiEndpoint(path=f"/proxy/krea/jobs/{initial.job_id}", method="GET"),
+            response_model=KreaJob,
+            status_extractor=lambda r: r.status,
+            queued_statuses=_KREA_QUEUED_STATUSES,
+        )
+        if not job.result or not job.result.urls:
+            raise RuntimeError(f"Krea 2 job {job.job_id} completed without any image URLs.")
+        image = await download_url_to_image_tensor(job.result.urls[0])
+        return IO.NodeOutput(image)
+
+
+class Krea2StyleReferenceNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="Krea2StyleReferenceNode",
+            display_name="Krea 2 Style Reference",
+            category="api node/image/Krea",
+            description=(
+                "Add an image style reference to a Krea 2 generation. Chain multiple Krea 2 "
+                "Style Reference nodes (max 10) and feed the final `style_reference` output "
+                "into Krea 2 Image. Each image is uploaded to ComfyAPI storage and passed as URL."
+            ),
+            inputs=[
+                IO.Image.Input(
+                    "image",
+                    tooltip="Reference image whose style influences the generation.",
+                ),
+                IO.Float.Input(
+                    "strength",
+                    default=1.0,
+                    min=-2.0,
+                    max=2.0,
+                    step=0.05,
+                    tooltip="Reference strength; negative values invert the style influence.",
+                ),
+                IO.Custom(KreaIO.STYLE_REF).Input(
+                    "style_reference",
+                    optional=True,
+                    tooltip="Optional incoming chain of style references; this node appends one more.",
+                ),
+            ],
+            outputs=[IO.Custom(KreaIO.STYLE_REF).Output(display_name="style_reference")],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        image: Input.Image,
+        strength: float,
+        style_reference: list[dict] | None = None,
+    ) -> IO.NodeOutput:
+        chain: list[dict] = list(style_reference) if style_reference else []
+        if len(chain) >= 10:
+            raise ValueError("Krea 2 accepts at most 10 image_style_references in one generation.")
+        url = await _upload_image_to_krea_assets(cls, image)
+        chain.append({"url": url, "strength": float(strength)})
+        return IO.NodeOutput(chain)
+
+
+class KreaExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
+        return [
+            Krea2ImageNode,
+            Krea2StyleReferenceNode,
+        ]
+
+
+async def comfy_entrypoint() -> KreaExtension:
+    return KreaExtension()

comfy_api_nodes/util/client.py

@@ -86,7 +86,7 @@ class _PollUIState:
 _RETRY_STATUS = {408, 500, 502, 503, 504}  # status 429 is handled separately
 COMPLETED_STATUSES = ["succeeded", "succeed", "success", "completed", "finished", "done", "complete"]
 FAILED_STATUSES = ["cancelled", "canceled", "canceling", "fail", "failed", "error"]
-QUEUED_STATUSES = ["created", "queued", "queueing", "submitted", "initializing", "wait"]
+QUEUED_STATUSES = ["created", "queued", "queueing", "submitted", "initializing", "wait", "in_queue"]
 
 
 async def sync_op(

comfy_extras/nodes_lt_upsampler.py

@@ -1,32 +1,32 @@
 from comfy import model_management
+from comfy_api.latest import ComfyExtension, IO
+from typing_extensions import override
 import math
 
-class LTXVLatentUpsampler:
+
+class LTXVLatentUpsampler(IO.ComfyNode):
     """
     Upsamples a video latent by a factor of 2.
     """
 
     @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "samples": ("LATENT",),
-                "upscale_model": ("LATENT_UPSCALE_MODEL",),
-                "vae": ("VAE",),
-            }
-        }
+    def define_schema(cls):
+        return IO.Schema(
+            node_id="LTXVLatentUpsampler",
+            category="latent/video",
+            is_experimental=True,
+            inputs=[
+                IO.Latent.Input("samples"),
+                IO.LatentUpscaleModel.Input("upscale_model"),
+                IO.Vae.Input("vae"),
+            ],
+            outputs=[
+                IO.Latent.Output(),
+            ],
+        )
 
-    RETURN_TYPES = ("LATENT",)
-    FUNCTION = "upsample_latent"
-    CATEGORY = "latent/video"
-    EXPERIMENTAL = True
-
-    def upsample_latent(
-        self,
-        samples: dict,
-        upscale_model,
-        vae,
-    ) -> tuple:
+    @classmethod
+    def execute(cls, samples, upscale_model, vae) -> IO.NodeOutput:
         """
         Upsample the input latent using the provided model.
 
@@ -34,7 +34,6 @@ class LTXVLatentUpsampler:
             samples (dict): Input latent samples
             upscale_model (LatentUpsampler): Loaded upscale model
             vae: VAE model for normalization
-            auto_tiling (bool): Whether to automatically tile the input for processing
 
         Returns:
             tuple: Tuple containing the upsampled latent
@@ -67,9 +66,16 @@ class LTXVLatentUpsampler:
         return_dict = samples.copy()
         return_dict["samples"] = upsampled_latents
         return_dict.pop("noise_mask", None)
-        return (return_dict,)
+        return IO.NodeOutput(return_dict)
+
+    upsample_latent = execute  # TODO: remove
 
 
-NODE_CLASS_MAPPINGS = {
-    "LTXVLatentUpsampler": LTXVLatentUpsampler,
-}
+class LTXVLatentUpsamplerExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
+        return [LTXVLatentUpsampler]
+
+
+async def comfy_entrypoint() -> LTXVLatentUpsamplerExtension:
+    return LTXVLatentUpsamplerExtension()

openapi.yaml

@@ -887,9 +887,9 @@ paths:
                     x-runtime: [cloud]
                     description: "[cloud-only] Version identifier for the workflow templates bundle. Local ComfyUI returns null."
                   workflow_templates_source:
+                    type: string
                     nullable: true
-                    allOf:
-                      - $ref: "#/components/schemas/WorkflowTemplatesSource"
+                    enum: [dynamic_config_override, workflow_templates_version_json]
                     x-runtime: [cloud]
                     description: "[cloud-only] How the templates version was resolved. Local ComfyUI returns null."
 
@@ -5628,7 +5628,6 @@ paths:
           required: true
           schema:
             type: string
-            format: uuid
           description: The API key ID.
       responses:
         "204":
@@ -6759,7 +6758,6 @@ paths:
           required: true
           schema:
             type: string
-            format: uuid
           description: The secret ID.
       responses:
         "204":
@@ -7527,39 +7525,6 @@ components:
           type: object
           description: Metadata about the execution and nodes
           additionalProperties: true
-        create_time:
-          type: integer
-          format: int64
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Unix-ms timestamp when the history entry was created."
-        extra_data:
-          type: object
-          additionalProperties: true
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Workflow-attached extra_data passed through with the prompt."
-        priority:
-          type: number
-          format: double
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Scheduling priority assigned to the history entry."
-        prompt_id:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] ID of the prompt this history entry belongs to."
-        workflow_id:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] ID of the workflow associated with the history entry."
 
     HistoryManageRequest:
       type: object
@@ -7682,12 +7647,6 @@ components:
         execution_meta:
           type: object
           additionalProperties: true
-        workflow_id:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] ID of the workflow associated with this job."
 
     ExecutionError:
       type: object
@@ -7867,24 +7826,6 @@ components:
     # -------------------------------------------------------------------
     # Node / Object Info
     # -------------------------------------------------------------------
-        cloud_version:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Version identifier of the cloud control plane."
-        comfyui_frontend_version:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Pinned ComfyUI frontend version served by the cloud."
-        workflow_templates_version:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Pinned workflow-templates version served by the cloud."
     NodeInfo:
       type: object
       description: 'Definition of a registered node class: its inputs, outputs, category, and display metadata.'
@@ -8158,12 +8099,6 @@ components:
         name:
           type: string
           description: Name of the asset file
-        display_name:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Human-friendly display name for the asset. Cloud-populated; null in local ComfyUI."
         hash:
           type: string
           nullable: true
@@ -8286,12 +8221,6 @@ components:
         updated_at:
           type: string
           format: date-time
-        display_name:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Human-friendly display name for the updated asset."
 
     ListAssetsResponse:
       type: object
@@ -8309,12 +8238,6 @@ components:
           type: integer
         has_more:
           type: boolean
-        next_cursor:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Opaque cursor for fetching the next page of assets; absent when no more pages."
 
     TagInfo:
       type: object
@@ -9043,20 +8966,6 @@ components:
         created_at:
           type: string
           format: date-time
-        description:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Profile description / bio."
-        website_urls:
-          type: array
-          items:
-            type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] List of websites/social links associated with the profile."
 
     HubWorkflow:
       type: object
@@ -9648,25 +9557,6 @@ components:
         created_at:
           type: string
           format: date-time
-        event_id:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Unique identifier of the billing event."
-        event_type:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Type/category of the billing event."
-        params:
-          type: object
-          additionalProperties: true
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Event-specific parameters (free-form map)."
 
     BillingEventList:
       type: object
@@ -10166,42 +10056,6 @@ components:
         size_bytes:
           type: integer
           format: int64
-        in_library:
-          type: boolean
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Whether the asset is present in the user's library (vs. a discovery/search result)."
-        name:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Display name of the asset."
-        model:
-          type: boolean
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Whether the asset is a model file (vs. a generic input/output)."
-        public:
-          type: boolean
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Whether the asset is publicly visible (vs. private to the user)."
-        preview_url:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] URL of a preview/thumbnail rendition for the asset."
-        storage_url:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] URL to fetch the asset's stored content."
 
     BulkRevokeAPIKeysResponse:
       type: object
@@ -10348,12 +10202,6 @@ components:
           format: date-time
         error:
           type: string
-        error_message:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Human-readable error message when the task fails."
 
     TasksListResponse:
       type: object
@@ -11899,30 +11747,3 @@ components:
         message:
           type: string
           description: User-provided feedback message
-        content:
-          type: string
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Free-form feedback text body."
-        metadata:
-          type: object
-          additionalProperties: true
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Submitter-supplied metadata attached to the feedback."
-        rating:
-          type: integer
-          nullable: true
-          x-runtime:
-            - cloud
-          description: "[cloud-only] Numeric rating (e.g. 1-5 stars) associated with the feedback."
-
-    WorkflowTemplatesSource:
-      type: string
-      x-runtime: [cloud]
-      enum:
-        - dynamic_config_override
-        - workflow_templates_version_json
-      description: "[cloud-only] How the workflow templates version was resolved (config override vs. bundled JSON)."

requirements.txt

@@ -1,5 +1,5 @@
 comfyui-frontend-package==1.44.19
-comfyui-workflow-templates==0.9.82
+comfyui-workflow-templates==0.9.85
 comfyui-embedded-docs==0.5.1
 torch
 torchsde