The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[Partner Nodes] feat(Comfy-Cloud): add nodes that run curated workflows on Comfy Cloud GPUs (#15935)
Deep Mehta250b2e9551a7
diff --git a/comfy_api_nodes/apis/comfy_cloud.py b/comfy_api_nodes/apis/comfy_cloud.pynew file mode 100644index 000000000..083f0e987--- /dev/null+++ b/comfy_api_nodes/apis/comfy_cloud.py@@ -0,0 +1,107 @@+from typing import Literal++from pydantic import BaseModel, Field, field_validator+++# Only the workflows this build ships. The backend serves more.+ComfyCloudWorkflow = Literal[+ "z-image-turbo/text-to-image",+ "flux-2/text-to-image",+ "minimax-h3/text-to-video",+ "minimax-h3/first-last-frame-to-video",+ "minimax-h3/reference-to-video",+ "minimax-h3/image-to-video",+ "mage-flow/text-to-image",+ "mage-flow-turbo/text-to-image",+ "minimax-music-3/text-to-audio",+]+++# Only the inputs the shipped nodes send. The manifests accept more.+class ComfyCloudWorkflowInputs(BaseModel):+ prompt: str | None = Field(None)+ image_url: str | None = Field(None)+ assets: dict[str, "ComfyCloudAssetInput"] | None = Field(None)+ audio_url: str | None = Field(None)+ first_frame_url: str | None = Field(None)+ last_frame_url: str | None = Field(None)+ instruction: str | None = Field(None)+ prompt_enhance: bool | None = Field(None)+ enhance_prompt: bool | None = Field(None)+ negative_prompt: str | None = Field(None)+ aspect_ratio: str | None = Field(None)+ duration_seconds: float | None = Field(None)+ quality_mode: str | None = Field(None)+ seed: int | None = Field(None, ge=0, le=0xFFFFFFFFFFFFFFFF)+ scale: str | None = Field(None)+ width: int | None = Field(None, ge=256, le=2048)+ height: int | None = Field(None, ge=256, le=2048)+ resolution: str | None = Field(None)+ rendering_speed: str | None = Field(None)+ color_correction: str | None = Field(None)+ turbo: bool | None = Field(None)+ style_lora: bool | None = Field(None)+ model: str | None = Field(None)+ lora: str | None = Field(None)+ steps: int | None = Field(None, ge=1)+ turbo_steps: int | None = Field(None, ge=1)+ fast_steps: int | None = Field(None, ge=1)+ cfg: float | None = Field(None, ge=0)+ guidance: float | None = Field(None, ge=0)+ shift: float | None = Field(None, ge=0)+ turbo_strength: float | None = Field(None, ge=0)+ style_strength: float | None = Field(None, ge=0)+ megapixels: float | None = Field(None, gt=0)+ size_multiple: int | None = Field(None, ge=1)+ sampler: str | None = Field(None)+ scheduler: str | None = Field(None)+ denoise: float | None = Field(None, ge=0, le=1)+ text_encoder: str | None = Field(None)+ ref_image_size: str | None = Field(None)+ lyrics: str | None = Field(None)+ max_duration: float | None = Field(None, gt=0)+ caption_cfg: float | None = Field(None, ge=0)+ top_k: int | None = Field(None, ge=1)+ tiled_decode: bool | None = Field(None)+ tile_size: int | None = Field(None, ge=1)+ tile_overlap: int | None = Field(None, ge=0)+ audio_quality: str | None = Field(None)+++class ComfyCloudAssetInput(BaseModel):+ type: Literal["IMAGE", "VIDEO", "AUDIO"] = Field(...)+ url: str = Field(...)+++class ComfyCloudGenerateRequest(BaseModel):+ workflow: ComfyCloudWorkflow = Field(...)+ inputs: ComfyCloudWorkflowInputs = Field(...)+++class ComfyCloudGenerateResponse(BaseModel):+ task_id: str = Field(..., min_length=1)+ status: str = Field(...)+ polling_url: str | None = Field(None)+ cancel_url: str | None = Field(None)++ @field_validator("task_id")+ @classmethod+ def task_id_must_not_be_blank(cls, value: str) -> str:+ if not value.strip():+ raise ValueError("task_id must not be blank")+ return value+++class ComfyCloudStatusResponse(BaseModel):+ task_id: str = Field(..., min_length=1)+ status: str = Field(...)+ progress: float | None = Field(None)+ output_url: str | None = Field(None)+ error: str | None = Field(None)++ @field_validator("task_id")+ @classmethod+ def task_id_must_not_be_blank(cls, value: str) -> str:+ if not value.strip():+ raise ValueError("task_id must not be blank")+ return valuediff --git a/comfy_api_nodes/nodes_comfy_cloud.py b/comfy_api_nodes/nodes_comfy_cloud.pynew file mode 100644index 000000000..2abc18daa--- /dev/null+++ b/comfy_api_nodes/nodes_comfy_cloud.py@@ -0,0 +1,858 @@+import contextlib+import math+import posixpath+from io import BytesIO+from typing import ClassVar+from urllib.parse import quote, unquote, urlsplit++import torch++from typing_extensions import override++from comfy_api.latest import IO, ComfyExtension, Input+from comfy_api_nodes.apis.comfy_cloud import (+ ComfyCloudAssetInput,+ ComfyCloudGenerateRequest,+ ComfyCloudGenerateResponse,+ ComfyCloudStatusResponse,+ ComfyCloudWorkflow,+ ComfyCloudWorkflowInputs,+)+from comfy_api_nodes.util import (+ ApiEndpoint,+ audio_bytes_to_audio_input,+ download_url_to_bytesio,+ download_url_to_image_tensor,+ download_url_to_video_output,+ get_number_of_images,+ poll_op,+ sync_op,+ sync_op_raw,+ upload_audio_to_comfyapi,+ upload_image_to_comfyapi,+ upload_video_to_comfyapi,+ validate_string,+)+++# Must stay in step with comfyCloudOutputBuckets in cloud's services/comfy-api/config/config.go.+_OUTPUT_BUCKETS = frozenset(+ {+ "comfy-cloud-assets",+ "comfy-cloud-assets-stg",+ "comfy-cloud-assets-test",+ "partner-nodes-assets",+ "partner-nodes-assets-staging",+ }+)+_GENERATE_ENDPOINT = ApiEndpoint(path="/proxy/comfy-cloud/workflow/generate", method="POST")+_RUN_TIMEOUT_SECONDS = 2100+_POLL_INTERVAL_SECONDS = 5.0+_POLL_MAX_ATTEMPTS = int(_RUN_TIMEOUT_SECONDS / _POLL_INTERVAL_SECONDS) + 24 # +2 min of slack+_OUTPUT_DOWNLOAD_TIMEOUT = 30 * 60+_MAX_UPLOAD_IMAGE_PIXELS = 32_000_000+_MAX_UPLOAD_IMAGE_DIMENSION = 8192+_MAX_DECODED_AUDIO_BYTES = 256 * 1024 * 1024+# Hardcoded mirror of Metronome's GPU rate. Nothing links the two, so it must be+# changed by hand when the rate card moves.+#+# VERIFY AGAINST A REAL CHARGE, not the rate card. This was briefly set to+# 0.00185, read off rtx_pro_6000's card entry, which over-quoted every run by+# ~43%. Dividing an actual billed event gives the truth:+# credits_used 1.98 / gpu_seconds 7.244173 / 211 credits-per-USD = 0.0012954+#+# THIS IS THE LIST PRICE. Never put a promotional or time-boxed rate here.+# ComfyUI is pulled, not pushed, so a user keeps whatever value they last pulled+# for as long as they like. A promo rate shipped here does not expire when the+# promotion does: the rate card returns to list, that user's node still quotes+# the discount, and they are charged MORE than they were shown, indefinitely and+# invisibly to us. A promo belongs in Metronome alone, where ending it actually+# ends it, and in the launch copy. Quoting above the charged rate is the safe+# direction; quoting below it is not.+#+# The same asymmetry applies to any list-price INCREASE, which is why a+# server-supplied per-run estimate (BE-9841) is the only way to change this+# number safely rather than a nicety.+COMFY_CLOUD_GPU_SECOND_USD = 0.001295+COMFY_CLOUD_CREDITS_PER_USD = 211+COMFY_CLOUD_GPU_SECOND_CREDITS = COMFY_CLOUD_GPU_SECOND_USD * COMFY_CLOUD_CREDITS_PER_USD+_COMFY_CLOUD_PRICE_BADGE = IO.PriceBadge(+ expr=(+ f'{{"type":"usd","usd":{COMFY_CLOUD_GPU_SECOND_USD:.6f},'+ '"format":{"suffix":"/GPU-second","approximate":true}}'+ )+)+_COMFY_CLOUD_RATE_DESCRIPTION = (+ f" Runs on a Comfy Cloud GPU, billed by how long it runs at "+ f"${COMFY_CLOUD_GPU_SECOND_USD:.6f}/GPU-second "+ f"({COMFY_CLOUD_GPU_SECOND_CREDITS:.2f} credits). Paid in credits, no Cloud "+ "subscription required."+)+++# Marked beta on purpose: the workflow set is curated by hand and expected to+# change, so a node can gain or lose options, and a workflow can be retired.+# display_name is not stored in a saved graph, so this is free to remove later;+# node_id and the input names are the parts that are permanent.+_COMFY_CLOUD_BETA_SUFFIX = " [BETA]"+_COMFY_CLOUD_BETA_DESCRIPTION = (+ "BETA. The Comfy Cloud node set is still changing: options may be added or "+ "removed, and a workflow may be retired. "+)+++def _comfy_cloud_display_name(display_name: str) -> str:+ """A SUFFIX, not a prefix: the menu and node search sort alphabetically, so a+ leading marker would file all of these under "[" instead of their model."""+ return display_name + _COMFY_CLOUD_BETA_SUFFIX+++def _comfy_cloud_description(summary: str) -> str:+ """Node descriptions carry the beta notice and the rate. The beta notice leads+ because it is the caveat to read first; the rate is here because the price+ badge only renders on Nodes 2.0, and a plain local install still defaults to+ the classic canvas."""+ return _COMFY_CLOUD_BETA_DESCRIPTION + summary + _COMFY_CLOUD_RATE_DESCRIPTION+++_TEXT_LIMITS = {+ "prompt": (1, 4096),+ "instruction": (1, 4096),+ "negative_prompt": (0, 2048),+ "lyrics": (0, 4096),+}+++def _task_endpoints(task_id: str) -> tuple[ApiEndpoint, ApiEndpoint]:+ if not task_id.strip():+ raise ValueError("Comfy Cloud returned an empty task ID.")+ task_path = f"/proxy/comfy-cloud/workflow/tasks/{quote(task_id, safe='')}"+ return ApiEndpoint(path=task_path), ApiEndpoint(path=f"{task_path}/cancel", method="POST")+++def _with_input_sockets(inputs: list[IO.Input]) -> list[IO.Input]:+ for input_spec in inputs:+ if isinstance(input_spec, IO.WidgetInput):+ input_spec.socketless = False+ return inputs+++def _cloud_schema(+ node_id: str,+ display_name: str,+ summary: str,+ category: str,+ inputs: list[IO.Input],+ output: IO.Output,+) -> IO.Schema:+ """Every Comfy Cloud node is the same schema but for its id, name, blurb, category,+ inputs and output type, so they are all built here."""+ return IO.Schema(+ node_id=node_id,+ display_name=_comfy_cloud_display_name(display_name),+ category=category,+ description=_comfy_cloud_description(summary),+ inputs=_with_input_sockets(inputs),+ outputs=[output],+ hidden=[+ IO.Hidden.auth_token_comfy_org,+ IO.Hidden.api_key_comfy_org,+ IO.Hidden.unique_id,+ ],+ is_api_node=True,+ price_badge=_COMFY_CLOUD_PRICE_BADGE,+ )+++def _validated_output_url(url: str) -> str:+ parsed = urlsplit(url)+ decoded_path = unquote(parsed.path)+ is_proxy_path = (+ not parsed.scheme+ and not parsed.netloc+ and decoded_path.startswith("/proxy/comfy-cloud/")+ and posixpath.normpath(decoded_path) == decoded_path+ )+ # normpath first: a client resolves dot segments before sending, so+ # ".../comfy-cloud-assets/../other/x.png" would advertise an allowed bucket here+ # and fetch from another one on the wire.+ bucket = decoded_path.lstrip("/").split("/", 1)[0]+ is_signed_https_url = (+ parsed.scheme == "https"+ and parsed.hostname == "storage.googleapis.com"+ and parsed.port is None+ and parsed.username is None+ and parsed.password is None+ and posixpath.normpath(decoded_path) == decoded_path+ and bucket in _OUTPUT_BUCKETS+ )+ if not is_proxy_path and not is_signed_https_url:+ raise RuntimeError("Comfy Cloud returned an invalid output URL.")+ return url+++def _validate_image_upload(image: Input.Image) -> None:+ if not isinstance(image, torch.Tensor):+ return+ if image.ndim not in (3, 4):+ raise ValueError("Invalid input image shape.")+ height, width = image.shape[-3:-1]+ if max(height, width) > _MAX_UPLOAD_IMAGE_DIMENSION or height * width > _MAX_UPLOAD_IMAGE_PIXELS:+ raise ValueError("Input image exceeds the 8192px or 32-megapixel Comfy Cloud limit.")+++def _progress(response: ComfyCloudStatusResponse) -> float | None:+ if response.progress is None or not math.isfinite(response.progress):+ return None+ return min(100.0, max(0.0, response.progress))+++async def _poll_task(cls: type[IO.ComfyNode], task_id: str) -> ComfyCloudStatusResponse:+ polling_endpoint, cancel_endpoint = _task_endpoints(task_id)+ try:+ return await poll_op(+ cls,+ polling_endpoint,+ response_model=ComfyCloudStatusResponse,+ status_extractor=lambda response: response.status,+ progress_extractor=_progress,+ cancel_endpoint=cancel_endpoint,+ poll_interval=_POLL_INTERVAL_SECONDS,+ max_poll_attempts=_POLL_MAX_ATTEMPTS,+ )+ except Exception:+ with contextlib.suppress(Exception):+ await sync_op_raw(cls, cancel_endpoint, max_retries=0)+ raise+++def _validate_node_inputs(cls: type[IO.ComfyNode], values: dict) -> dict:+ validated = dict(values)+ for input_spec in cls.define_schema().inputs:+ if not isinstance(input_spec, IO.WidgetInput) or input_spec.id not in values:+ continue+ value = values[input_spec.id]+ io_type = input_spec.get_io_type()+ if io_type == "STRING":+ if not isinstance(value, str):+ raise ValueError(f"{input_spec.id} must be a string.")+ value = value.strip()+ minimum, maximum = _TEXT_LIMITS.get(input_spec.id, (0, None))+ validate_string(+ value,+ min_length=minimum,+ max_length=maximum,+ field_name=input_spec.id,+ )+ validated[input_spec.id] = value+ elif io_type == "COMBO" and value not in input_spec.options:+ raise ValueError(f"Invalid {input_spec.id}: {value!r}.")+ elif io_type == "BOOLEAN" and not isinstance(value, bool):+ raise ValueError(f"{input_spec.id} must be a boolean.")+ elif io_type == "INT":+ if isinstance(value, bool) or not isinstance(value, int):+ raise ValueError(f"{input_spec.id} must be an integer.")+ if input_spec.min is not None and value < input_spec.min:+ raise ValueError(f"{input_spec.id} must be at least {input_spec.min}.")+ if input_spec.max is not None and value > input_spec.max:+ raise ValueError(f"{input_spec.id} must be at most {input_spec.max}.")+ elif io_type == "FLOAT":+ if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):+ raise ValueError(f"{input_spec.id} must be a finite number.")+ if input_spec.min is not None and value < input_spec.min:+ raise ValueError(f"{input_spec.id} must be at least {input_spec.min}.")+ if input_spec.max is not None and value > input_spec.max:+ raise ValueError(f"{input_spec.id} must be at most {input_spec.max}.")+ if input_spec.step:+ origin = input_spec.min or 0+ steps = (value - origin) / input_spec.step+ if not math.isclose(steps, round(steps), abs_tol=1e-7):+ raise ValueError(f"{input_spec.id} must use increments of {input_spec.step}.")+ return validated+++_ASPECT_RATIOS = ["1:1", "3:4", "2:3", "3:2", "4:3", "16:9", "9:16", "21:9"]+_VIDEO_RESOLUTIONS = ["480p", "720p"]+_MINIMAX_MUSIC3_QUALITIES = ["V0", "128k", "320k"]+_UINT64_MAX = 0xFFFFFFFFFFFFFFFF+_NEGATIVE_PROMPT_TOOLTIP = "Leave empty to keep the negative prompt this pipeline was tuned with."+++def _prompt_input(name: str = "prompt") -> IO.String.Input:+ return IO.String.Input(name, multiline=True, default="")+++def _negative_prompt_input() -> IO.String.Input:+ return IO.String.Input(+ "negative_prompt", multiline=True, default="", tooltip=_NEGATIVE_PROMPT_TOOLTIP+ )+++def _aspect_ratio_input(default: str = "1:1") -> IO.Combo.Input:+ return IO.Combo.Input("aspect_ratio", options=_ASPECT_RATIOS, default=default)+++def _megapixels_input() -> IO.Float.Input:+ # Resolution Selector graphs take a ratio and pixel budget rather than raw dimensions.+ return IO.Float.Input(+ "megapixels", default=1.0, min=0.1, max=16.0, step=0.1,+ tooltip="Total pixel budget. 1.0 is about 1024x1024 at a square ratio.",+ )+++def _seed_input(maximum: int = _UINT64_MAX) -> IO.Int.Input:+ return IO.Int.Input("seed", default=42, min=0, max=maximum, control_after_generate=True)+++def _video_resolution_input(advanced: bool = True) -> IO.Combo.Input:+ return IO.Combo.Input(+ "resolution",+ options=_VIDEO_RESOLUTIONS,+ default="480p",+ advanced=advanced,+ tooltip="Frame size budget. 720p costs roughly twice the GPU-seconds of 480p.",+ )+++async def _submit_workflow(+ cls: type[IO.ComfyNode], workflow: ComfyCloudWorkflow, inputs: ComfyCloudWorkflowInputs+) -> str:+ task = await sync_op(+ cls,+ _GENERATE_ENDPOINT,+ response_model=ComfyCloudGenerateResponse,+ data=ComfyCloudGenerateRequest(workflow=workflow, inputs=inputs),+ )+ result = await _poll_task(cls, task.task_id)+ if not result.output_url:+ raise RuntimeError("Comfy Cloud task completed without an output URL.")+ return _validated_output_url(result.output_url)+++async def _run_image_workflow(+ cls: type[IO.ComfyNode], workflow: ComfyCloudWorkflow, inputs: ComfyCloudWorkflowInputs+) -> IO.NodeOutput:+ url = await _submit_workflow(cls, workflow, inputs)+ return IO.NodeOutput(+ await download_url_to_image_tensor(+ url, timeout=_OUTPUT_DOWNLOAD_TIMEOUT, cls=cls, allow_redirects=False+ )+ )+++async def _run_video_workflow(+ cls: type[IO.ComfyNode], workflow: ComfyCloudWorkflow, inputs: ComfyCloudWorkflowInputs+) -> IO.NodeOutput:+ url = await _submit_workflow(cls, workflow, inputs)+ return IO.NodeOutput(+ await download_url_to_video_output(+ url, timeout=_OUTPUT_DOWNLOAD_TIMEOUT, cls=cls, allow_redirects=False+ )+ )+++async def _run_audio_workflow(+ cls: type[IO.ComfyNode], workflow: ComfyCloudWorkflow, inputs: ComfyCloudWorkflowInputs+) -> IO.NodeOutput:+ url = await _submit_workflow(cls, workflow, inputs)+ buffer = BytesIO()+ await download_url_to_bytesio(+ url, buffer, timeout=_OUTPUT_DOWNLOAD_TIMEOUT, cls=cls, allow_redirects=False+ )+ return IO.NodeOutput(audio_bytes_to_audio_input(buffer.getvalue()))+++async def _upload_workflow_image(cls: type[IO.ComfyNode], image: Input.Image, **options) -> str:+ if get_number_of_images(image) != 1:+ raise ValueError("Exactly one input image is required.")+ _validate_image_upload(image)+ return await upload_image_to_comfyapi(cls, image, **options)+++def _image_schema(cls: type[IO.ComfyNode], inputs: list[IO.Input]) -> IO.Schema:+ return _cloud_schema(+ cls.node_id, cls.display_name, cls.summary, "comfy cloud/image", inputs, IO.Image.Output()+ )+++class ComfyCloudFlux2TextToImageNode(IO.ComfyNode):+ node_id = "ComfyCloudFlux2TextToImageNode"+ display_name = "Comfy Cloud Flux 2 Text to Image"+ summary = (+ "Generates an image from a text prompt with Flux 2 dev. Turbo swaps in the chosen LoRA "+ "and a short schedule, trading a little fidelity for a much quicker run; switch it off "+ "for the full-length dev pass with no LoRA."+ )++ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _image_schema(+ cls,+ [+ _prompt_input(),+ _seed_input(),+ _aspect_ratio_input(),+ _megapixels_input(),+ IO.Boolean.Input(+ "turbo",+ default=True,+ tooltip="Run the Turbo LoRA on a short schedule, trading a little fidelity "+ "for a much quicker run. Off runs the full dev pass with no LoRA.",+ ),+ ],+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ seed: int = 42,+ aspect_ratio: str = "1:1",+ megapixels: float = 1.0,+ turbo: bool = True,+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ return await _run_image_workflow(+ cls,+ "flux-2/text-to-image",+ ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, megapixels=megapixels, turbo=turbo, seed=seed,+ ),+ )+++class ComfyCloudZImageTurboNode(IO.ComfyNode):+ node_id = "ComfyCloudZImageTurboNode"+ display_name = "Comfy Cloud Z-Image Turbo Text to Image"+ summary = (+ "Generates an image from a text prompt with Z-Image Turbo in 8 steps. One of the "+ "quickest and cheapest nodes here, which makes it the one to iterate on."+ )++ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _image_schema(+ cls,+ [+ _prompt_input(),+ _seed_input(),+ _aspect_ratio_input(),+ _megapixels_input(),+ ],+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ seed: int = 42,+ aspect_ratio: str = "1:1",+ megapixels: float = 1.0,+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ return await _run_image_workflow(+ cls,+ "z-image-turbo/text-to-image",+ ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, megapixels=megapixels, seed=seed,+ ),+ )+++class _ComfyCloudMageFlowNode(IO.ComfyNode):+ """Mage-Flow text to image. The base and turbo graphs are the same pipeline at+ two schedule lengths, so they differ only in their step and cfg defaults and+ which checkpoints load."""++ workflow: ClassVar[ComfyCloudWorkflow]+ node_id: ClassVar[str]+ display_name: ClassVar[str]+ summary: ClassVar[str]++ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _image_schema(+ cls,+ [+ _prompt_input(),+ _negative_prompt_input(),+ _seed_input(),+ _aspect_ratio_input(),+ _megapixels_input(),+ ],+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ negative_prompt: str = "",+ seed: int = 42,+ aspect_ratio: str = "1:1",+ megapixels: float = 1.0,+ ) -> IO.NodeOutput:+ validated = _validate_node_inputs(cls, locals())+ return await _run_image_workflow(+ cls,+ cls.workflow,+ ComfyCloudWorkflowInputs(+ prompt=validated["prompt"], negative_prompt=validated["negative_prompt"],+ aspect_ratio=aspect_ratio, megapixels=megapixels, seed=seed,+ ),+ )+++class ComfyCloudMageFlowTextToImageNode(_ComfyCloudMageFlowNode):+ workflow = "mage-flow/text-to-image"+ node_id = "ComfyCloudMageFlowTextToImageNode"+ display_name = "Comfy Cloud Mage Flow Text to Image"+ summary = (+ "Generates an image from a text prompt with Mage-Flow over a full 30-step pass. "+ "It takes a negative prompt, which the distilled turbo variant cannot use well."+ )+++class ComfyCloudMageFlowTurboTextToImageNode(_ComfyCloudMageFlowNode):+ workflow = "mage-flow-turbo/text-to-image"+ node_id = "ComfyCloudMageFlowTurboTextToImageNode"+ display_name = "Comfy Cloud Mage Flow Turbo Text to Image"+ summary = (+ "Generates an image from a text prompt with distilled Mage-Flow in 4 steps at cfg 1. "+ "Roughly a seventh of the GPU time of the full pass, which makes it the one to iterate on."+ )+++class ComfyCloudMiniMaxMusic3TextToAudioNode(IO.ComfyNode):+ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _cloud_schema(+ "ComfyCloudMiniMaxMusic3TextToAudioNode",+ "Comfy Cloud MiniMax Music 3 Text to Audio",+ (+ "Generates a full song from a description with MiniMax Music 3. The prompt "+ "carries the style, instrumentation and mood; lyrics are sung rather than "+ "described, and an empty lyric leaves the track instrumental."+ ),+ "comfy cloud/audio",+ [+ _prompt_input(),+ IO.String.Input(+ "lyrics", multiline=True, default="",+ tooltip="Words to sing. Leave empty for an instrumental.",+ ),+ # SeedNode caps at int64, below the uint64 the other graphs take.+ _seed_input(0x7FFFFFFFFFFFFFFF),+ IO.Float.Input(+ "max_duration", default=120.0, min=0.04, max=360.0, step=0.04,+ tooltip="Longest the track may run. The model can end the song earlier.",+ ),+ IO.Combo.Input(+ "audio_quality",+ options=_MINIMAX_MUSIC3_QUALITIES,+ default=_MINIMAX_MUSIC3_QUALITIES[0],+ tooltip="mp3 bitrate. V0 is variable and the highest quality of the three.",+ ),+ ],+ IO.Audio.Output(),+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ lyrics: str = "",+ seed: int = 42,+ max_duration: float = 120.0,+ audio_quality: str = "V0",+ ) -> IO.NodeOutput:+ validated = _validate_node_inputs(cls, locals())+ return await _run_audio_workflow(+ cls,+ "minimax-music-3/text-to-audio",+ ComfyCloudWorkflowInputs(+ prompt=validated["prompt"], lyrics=validated["lyrics"], seed=seed,+ max_duration=max_duration, caption_cfg=1.5,+ audio_quality=audio_quality,+ ),+ )+++def _video_schema(node_id: str, display_name: str, summary: str, inputs: list[IO.Input]) -> IO.Schema:+ return _cloud_schema(+ node_id, display_name, summary, "comfy cloud/video", inputs, IO.Video.Output()+ )+++_MINIMAX_H3_MAX_REFERENCES = 4+_MINIMAX_H3_MAX_AUDIO_REFERENCES = 3+++def _minimax_h3_inputs(default_ratio: str, plain: list[IO.Input] | None = None) -> list[IO.Input]:+ """Everything the three fl2va/ref2va graphs expose past their media inputs.++ The turbo LoRA branch those templates carry is not here: its weights have+ catalog entries but no bytes in the mirror, so cloud's frozen graphs leave+ the branch out until they are uploaded.+ """+ return [+ _prompt_input(),+ _seed_input(),+ _aspect_ratio_input(default_ratio),+ _video_resolution_input(advanced=False),+ IO.Int.Input(+ "duration_seconds",+ default=5,+ min=5,+ max=15,+ display_mode=IO.NumberDisplay.slider,+ tooltip=(+ "Length in seconds. The pipeline quantises to 17-frame steps at 24fps, "+ "so the clip lands within about two thirds of a second of this."+ ),+ ),+ *(plain or []),+ ]+++async def _minimax_h3_asset(cls: type[IO.ComfyNode], image: Input.Image) -> ComfyCloudAssetInput:+ return ComfyCloudAssetInput(+ type="IMAGE", url=await _upload_workflow_image(cls, image, total_pixels=2048 * 2048)+ )+++async def _minimax_h3_video_asset(cls: type[IO.ComfyNode], video: Input.Video) -> ComfyCloudAssetInput:+ return ComfyCloudAssetInput(type="VIDEO", url=await upload_video_to_comfyapi(cls, video))+++async def _minimax_h3_audio_asset(cls: type[IO.ComfyNode], audio: Input.Audio) -> ComfyCloudAssetInput:+ return ComfyCloudAssetInput(type="AUDIO", url=await upload_audio_to_comfyapi(cls, audio))+++class ComfyCloudMiniMaxH3TextToVideoNode(IO.ComfyNode):+ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _video_schema(+ "ComfyCloudMiniMaxH3TextToVideoNode",+ "Comfy Cloud MiniMax H3 Text to Video",+ (+ "Generates a video with a matching soundtrack from a text prompt, using MiniMax "+ "H3. Picture and audio come out of the same pass rather than being dubbed on "+ "afterwards."+ ),+ _minimax_h3_inputs("16:9"),+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ seed: int = 42,+ aspect_ratio: str = "16:9",+ resolution: str = "480p",+ duration_seconds: int = 5+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ inputs = ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, duration_seconds=duration_seconds,+ seed=seed, resolution=resolution+ )+ return await _run_video_workflow(cls, "minimax-h3/text-to-video", inputs)+++# MiniMax H3's two Qwen3-VL encoder precisions. Keys, not filenames: cloud holds+# the file each one maps to.+class ComfyCloudMiniMaxH3FirstLastFrameToVideoNode(IO.ComfyNode):+ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _video_schema(+ "ComfyCloudMiniMaxH3FirstLastFrameToVideoNode",+ "Comfy Cloud MiniMax H3 First-Last Frame to Video",+ (+ "Generates the motion between two keyframes, with a matching soundtrack, using "+ "MiniMax H3. Give it the opening and closing frames and the model fills in the "+ "shot between them. The last frame is optional: leave it out and the motion runs "+ "away from the first frame instead."+ ),+ [+ IO.Image.Input("first_frame"),+ IO.Image.Input("last_frame", optional=True),+ *_minimax_h3_inputs("1:1"),+ ],+ )++ @classmethod+ async def execute(+ cls,+ first_frame: Input.Image,+ prompt: str,+ seed: int = 42,+ aspect_ratio: str = "1:1",+ resolution: str = "480p",+ duration_seconds: int = 5,+ last_frame: Input.Image | None = None,+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ assets = {"first_frame": await _minimax_h3_asset(cls, first_frame)}+ if last_frame is not None:+ assets["last_frame"] = await _minimax_h3_asset(cls, last_frame)+ return await _run_video_workflow(+ cls,+ "minimax-h3/first-last-frame-to-video",+ ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, resolution=resolution,+ duration_seconds=duration_seconds, seed=seed, assets=assets+ ),+ )+++class ComfyCloudMiniMaxH3ImageToVideoNode(IO.ComfyNode):+ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _video_schema(+ "ComfyCloudMiniMaxH3ImageToVideoNode",+ "Comfy Cloud MiniMax H3 Image to Video",+ (+ "Animates a still into a video with a matching soundtrack, using MiniMax H3. "+ "Feed it a clip's closing frame and it continues the sequence, so chaining "+ "several builds a longer shot."+ ),+ [IO.Image.Input("first_frame"), *_minimax_h3_inputs("1:1")],+ )++ @classmethod+ async def execute(+ cls,+ first_frame: Input.Image,+ prompt: str,+ seed: int = 42,+ aspect_ratio: str = "1:1",+ resolution: str = "480p",+ duration_seconds: int = 5+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ return await _run_video_workflow(+ cls,+ "minimax-h3/image-to-video",+ ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, resolution=resolution,+ duration_seconds=duration_seconds, seed=seed,+ assets={"first_frame": await _minimax_h3_asset(cls, first_frame)},+ ),+ )+++class ComfyCloudMiniMaxH3ReferenceToVideoNode(IO.ComfyNode):+ @classmethod+ def define_schema(cls) -> IO.Schema:+ return _video_schema(+ "ComfyCloudMiniMaxH3ReferenceToVideoNode",+ "Comfy Cloud MiniMax H3 Reference to Video",+ (+ "Generates a video with a matching soundtrack from optional image, video, and "+ "audio references, using MiniMax H3. The references carry subject and style "+ "across the shot, and the prompt addresses images by connection order."+ ),+ [+ IO.Autogrow.Input(+ "reference_images",+ template=IO.Autogrow.TemplatePrefix(+ input=IO.Image.Input("reference_image"),+ prefix="reference_image_",+ min=0,+ max=_MINIMAX_H3_MAX_REFERENCES,+ ),+ tooltip=(+ "Up to four references, addressed in the prompt as <Picture 1> upwards "+ "in connection order."+ ),+ ),+ IO.Video.Input("ref_video", optional=True),+ IO.Autogrow.Input(+ "ref_audio",+ template=IO.Autogrow.TemplatePrefix(+ input=IO.Audio.Input("ref_audio"),+ prefix="ref_audio_",+ min=0,+ max=_MINIMAX_H3_MAX_AUDIO_REFERENCES,+ ),+ ),+ *_minimax_h3_inputs(+ "16:9",+ plain=[+ IO.Combo.Input(+ "ref_image_size",+ options=["match", "max"],+ default="match",+ tooltip=(+ "'match' scales each reference to the output's pixel area; 'max' "+ "sends it at the 2048px short edge for the closest likeness. "+ "Reference tokens ride through every sampling step, so 'max' "+ "costs several times the GPU-seconds."+ ),+ )+ ],+ ),+ ],+ )++ @classmethod+ async def execute(+ cls,+ prompt: str,+ reference_images: dict[str, Input.Image] | None = None,+ ref_video: Input.Video | None = None,+ ref_audio: dict[str, Input.Audio] | None = None,+ seed: int = 42,+ aspect_ratio: str = "16:9",+ resolution: str = "480p",+ duration_seconds: int = 5,+ ref_image_size: str = "match"+ ) -> IO.NodeOutput:+ prompt = _validate_node_inputs(cls, locals())["prompt"]+ images = [image for image in (reference_images or {}).values() if image is not None]+ if len(images) > _MINIMAX_H3_MAX_REFERENCES:+ raise ValueError(f"At most {_MINIMAX_H3_MAX_REFERENCES} reference images are supported.")+ audios = [audio for audio in (ref_audio or {}).values() if audio is not None]+ if len(audios) > _MINIMAX_H3_MAX_AUDIO_REFERENCES:+ raise ValueError(f"At most {_MINIMAX_H3_MAX_AUDIO_REFERENCES} reference audio inputs are supported.")+ # Numbered by connection order, which is the order the prompt's+ # <Picture i> tags refer to them in.+ assets = {+ f"reference_image_{index}": await _minimax_h3_asset(cls, image)+ for index, image in enumerate(images, 1)+ }+ if ref_video is not None:+ assets["ref_video"] = await _minimax_h3_video_asset(cls, ref_video)+ assets.update({+ f"ref_audio_{index}": await _minimax_h3_audio_asset(cls, audio)+ for index, audio in enumerate(audios, 1)+ })+ return await _run_video_workflow(+ cls,+ "minimax-h3/reference-to-video",+ ComfyCloudWorkflowInputs(+ prompt=prompt, aspect_ratio=aspect_ratio, resolution=resolution,+ duration_seconds=duration_seconds, seed=seed, ref_image_size=ref_image_size,+ assets=assets,+ ),+ )+++class ComfyCloudExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[IO.ComfyNode]]:+ return [+ ComfyCloudMiniMaxH3TextToVideoNode,+ ComfyCloudMiniMaxH3FirstLastFrameToVideoNode,+ # ComfyCloudMiniMaxH3ReferenceToVideoNode, # Disabled until the server-side issue is fixed.+ ComfyCloudMiniMaxH3ImageToVideoNode,+ ComfyCloudMiniMaxMusic3TextToAudioNode,+ ComfyCloudFlux2TextToImageNode,+ ComfyCloudZImageTurboNode,+ ComfyCloudMageFlowTextToImageNode,+ ComfyCloudMageFlowTurboTextToImageNode,+ ]+++async def comfy_entrypoint() -> ComfyCloudExtension:+ return ComfyCloudExtension()diff --git a/comfy_api_nodes/util/client.py b/comfy_api_nodes/util/client.pyindex 039e97d58..a896027c9 100644--- a/comfy_api_nodes/util/client.py+++ b/comfy_api_nodes/util/client.py@@ -574,6 +574,15 @@ def _merge_params(endpoint_params: dict[str, Any], method: str, data: dict[str,return params+# 5xx codes that mean "switched off", not "try again": retrying only makes the+# user wait through the backoff for the same answer.+_TERMINAL_SERVICE_REFUSALS = frozenset({"comfy_cloud_provider_disabled"})+++def _is_terminal_service_refusal(body: Any) -> bool:+ return isinstance(body, dict) and body.get("error") in _TERMINAL_SERVICE_REFUSALS++def _friendly_http_message(status: int, body: Any) -> str:if status == 401:return "Unauthorized: Please login first to use this node."@@ -586,6 +595,11 @@ def _friendly_http_message(status: int, body: Any) -> str:try:if isinstance(body, dict):err = body.get("error")+ # comfy-api's envelope is flat: {"error": code, "message": text}.+ if isinstance(err, str):+ msg = body.get("message")+ if isinstance(msg, str) and msg:+ return msgif isinstance(err, dict):msg = err.get("message")typ = err.get("type")@@ -776,7 +790,11 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):rate_limit_delay *= cfg.retry_backoffretry_label = f"rate-limit retry {rate_limit_attempts} of {cfg.max_retries_on_rate_limit}"should_retry = True- elif resp.status in _RETRY_STATUS and (attempt - rate_limit_attempts) <= cfg.max_retries:+ elif (+ resp.status in _RETRY_STATUS+ and not _is_terminal_service_refusal(body)+ and (attempt - rate_limit_attempts) <= cfg.max_retries+ ):wait_time = delaydelay *= cfg.retry_backoffretry_label = f"retry {attempt - rate_limit_attempts} of {cfg.max_retries}"diff --git a/comfy_api_nodes/util/download_helpers.py b/comfy_api_nodes/util/download_helpers.pyindex 0ec3c6e66..4344bf7dc 100644--- a/comfy_api_nodes/util/download_helpers.py+++ b/comfy_api_nodes/util/download_helpers.py@@ -38,6 +38,7 @@ async def download_url_to_bytesio(retry_delay: float = 1.0,retry_backoff: float = 2.0,cls: type[COMFY_IO.ComfyNode] = None,+ allow_redirects: bool = True,) -> None:"""Stream-download a URL to `dest`.@@ -49,6 +50,10 @@ async def download_url_to_bytesio(If `url` starts with `/proxy/`, `cls` must be provided so the URL can be expandedto an absolute URL and authentication headers can be applied.+ Pass `allow_redirects=False` when the caller has already vetted `url` and a+ redirect would move the download somewhere it did not vet. The default keeps+ aiohttp's redirect following.+Raises:ProcessingInterrupted, LocalNetworkError, ApiServerError, Exception (HTTP and other errors)"""@@ -68,6 +73,11 @@ async def download_url_to_bytesio(while True:attempt += 1+ # A retry re-reads from byte zero, so a part-filled BytesIO must be emptied+ # or the two bodies concatenate.+ if isinstance(dest, BytesIO):+ dest.seek(0)+ dest.truncate(0)op_id = _generate_operation_id("GET", url, attempt)timeout_cfg = aiohttp.ClientTimeout(total=timeout)@@ -96,7 +106,9 @@ async def download_url_to_bytesio(monitor_task = asyncio.create_task(_monitor())- req_task = asyncio.create_task(session.get(to_aiohttp_url(url), headers=headers))+ req_task = asyncio.create_task(+ session.get(to_aiohttp_url(url), headers=headers, allow_redirects=allow_redirects)+ )done, pending = await asyncio.wait({req_task, monitor_task}, return_when=asyncio.FIRST_COMPLETED)if monitor_task in done and req_task in pending:@@ -111,7 +123,9 @@ async def download_url_to_bytesio(raise ProcessingInterrupted("Task cancelled") from Noneasync with resp:- if resp.status >= 400:+ # Under allow_redirects=False a redirect lands here unfollowed, and its+ # body is not the file that was asked for.+ if resp.status >= 300:with contextlib.suppress(Exception):try:body = await resp.json()@@ -221,10 +235,11 @@ async def download_url_to_image_tensor(*,timeout: float = None,cls: type[COMFY_IO.ComfyNode] = None,+ allow_redirects: bool = True,) -> torch.Tensor:"""Downloads an image from a URL and returns a [B, H, W, C] tensor."""result = BytesIO()- await download_url_to_bytesio(url, result, timeout=timeout, cls=cls)+ await download_url_to_bytesio(url, result, timeout=timeout, cls=cls, allow_redirects=allow_redirects)return bytesio_to_image_tensor(result)@@ -234,10 +249,18 @@ async def download_url_to_video_output(timeout: float = None,max_retries: int = 5,cls: type[COMFY_IO.ComfyNode] = None,+ allow_redirects: bool = True,) -> InputImpl.VideoFromFile:"""Downloads a video from a URL and returns a `VIDEO` output."""result = BytesIO()- await download_url_to_bytesio(video_url, result, timeout=timeout, max_retries=max_retries, cls=cls)+ await download_url_to_bytesio(+ video_url,+ result,+ timeout=timeout,+ max_retries=max_retries,+ cls=cls,+ allow_redirects=allow_redirects,+ )return InputImpl.VideoFromFile(result)@@ -270,6 +293,7 @@ async def download_url_to_file_3d(timeout: float | None = None,max_retries: int = 5,cls: type[COMFY_IO.ComfyNode] = None,+ allow_redirects: bool = True,) -> Types.File3D:"""Downloads a 3D model file from a URL into memory as BytesIO.@@ -284,6 +308,7 @@ async def download_url_to_file_3d(timeout=timeout,max_retries=max_retries,cls=cls,+ allow_redirects=allow_redirects,)if task_id is not None:diff --git a/tests-unit/comfy_api_nodes_test/comfy_cloud_test.py b/tests-unit/comfy_api_nodes_test/comfy_cloud_test.pynew file mode 100644index 000000000..78ab160ea--- /dev/null+++ b/tests-unit/comfy_api_nodes_test/comfy_cloud_test.py@@ -0,0 +1,881 @@+import ast+import asyncio+import re+from pathlib import Path+from io import BytesIO+from typing import get_args+from unittest.mock import AsyncMock++import aiohttp+import pytest+import torch++from comfy.cli_args import args++if not torch.cuda.is_available():+ args.cpu = True++from comfy_api_nodes.apis.comfy_cloud import (+ ComfyCloudGenerateRequest,+ ComfyCloudGenerateResponse,+ ComfyCloudStatusResponse,+ ComfyCloudWorkflow,+ ComfyCloudWorkflowInputs,+)+from comfy_api_nodes import nodes_comfy_cloud+from comfy_api_nodes.util import download_helpers++++def _execute_with_defaults(node, prompt, **overrides):+ """Call a node with its own schema defaults, so a test does not have to track+ each workflow's argument list."""+ kwargs = {}+ for spec in node.define_schema().inputs:+ default = getattr(spec, "default", None)+ if default is not None:+ kwargs[spec.id] = default+ elif getattr(spec, "options", None):+ kwargs[spec.id] = spec.options[0]+ kwargs["prompt"] = prompt+ kwargs.update(overrides)+ return asyncio.run(node.execute(**kwargs))++ ("node", "workflow", "returns_video", "requires_image", "controls"),+ [+ (+ nodes_comfy_cloud.ComfyCloudZImageTurboNode, "z-image-turbo/text-to-image", False, False,+ {"aspect_ratio": "1:1", "megapixels": 1.0},+ ),+ (+ nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode, "minimax-h3/text-to-video", True, False,+ {+ "aspect_ratio": "16:9", "duration_seconds": 5.0, "resolution": "480p",+ },+ ),+ ],+)+def test_workflow_submission_polling_and_download(+ monkeypatch, node, workflow, returns_video, requires_image, controls+):+ sync = AsyncMock(+ return_value=ComfyCloudGenerateResponse(+ task_id="task-1",+ status="queued",+ polling_url="/proxy/comfy-cloud/workflow/tasks/task-1",+ cancel_url="/proxy/comfy-cloud/workflow/tasks/task-1/cancel",+ )+ )+ poll = AsyncMock(+ return_value=ComfyCloudStatusResponse(+ task_id="task-1",+ status="completed",+ progress=100,+ output_url="/proxy/comfy-cloud/results/task-1/output",+ )+ )+ upload = AsyncMock(return_value="https://example.com/input.png")+ image_download = AsyncMock(return_value="image-output")+ video_download = AsyncMock(return_value="video-output")+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)+ monkeypatch.setattr(nodes_comfy_cloud, "upload_image_to_comfyapi", upload)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_image_tensor", image_download)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_video_output", video_download)+ monkeypatch.setattr(nodes_comfy_cloud, "get_number_of_images", lambda image: 1)++ output = _execute_with_defaults(node, "A tiny fennec fox")++ endpoint = sync.call_args.args[1]+ request = sync.call_args.kwargs["data"]+ assert endpoint.path == "/proxy/comfy-cloud/workflow/generate"+ assert endpoint.method == "POST"+ assert request == ComfyCloudGenerateRequest(+ workflow=workflow,+ inputs=ComfyCloudWorkflowInputs(+ prompt="A tiny fennec fox",+ image_url="https://example.com/input.png" if requires_image else None,+ seed=42,+ **controls,+ ),+ )+ assert upload.await_count == int(requires_image)++ poll_endpoint = poll.call_args.args[1]+ cancel_endpoint = poll.call_args.kwargs["cancel_endpoint"]+ assert poll_endpoint.path == "/proxy/comfy-cloud/workflow/tasks/task-1"+ assert cancel_endpoint.path == "/proxy/comfy-cloud/workflow/tasks/task-1/cancel"+ assert cancel_endpoint.method == "POST"+ assert output[0] == ("video-output" if returns_video else "image-output")+++def test_contract_omits_optional_status_fields():+ request = ComfyCloudGenerateRequest(+ workflow="z-image-turbo/text-to-image",+ inputs=ComfyCloudWorkflowInputs(prompt="A lighthouse"),+ )+ status = ComfyCloudStatusResponse(task_id="task-1", status="queued")++ assert request.model_dump(exclude_none=True) == {+ "workflow": "z-image-turbo/text-to-image",+ "inputs": {"prompt": "A lighthouse"},+ }+ assert status.model_dump(exclude_none=True) == {"task_id": "task-1", "status": "queued"}+++def test_status_progress_is_clamped_for_display():+ assert nodes_comfy_cloud._progress(ComfyCloudStatusResponse(task_id="task-1", status="running", progress=100.5)) == 100+ assert nodes_comfy_cloud._progress(ComfyCloudStatusResponse(task_id="task-1", status="running", progress=-1)) == 0+++def test_poll_failure_cancels_submitted_task(monkeypatch):+ poll = AsyncMock(side_effect=ValueError("invalid status response"))+ cancel = AsyncMock(return_value={"status": "cancellation_requested"})+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op_raw", cancel)++ with pytest.raises(ValueError, match="invalid status response"):+ asyncio.run(nodes_comfy_cloud._poll_task(nodes_comfy_cloud.ComfyCloudZImageTurboNode, "task/1"))++ cancel.assert_awaited_once()+ assert cancel.call_args.args[1].path == "/proxy/comfy-cloud/workflow/tasks/task%2F1/cancel"+ assert cancel.call_args.kwargs["max_retries"] == 0++[email protected]("response_model", [ComfyCloudGenerateResponse, ComfyCloudStatusResponse])[email protected]("task_id", ["", " "])+def test_contract_rejects_empty_task_ids(response_model, task_id):+ values = {"task_id": task_id, "status": "queued"}+ if response_model is ComfyCloudGenerateResponse:+ values.update(polling_url="/poll", cancel_url="/cancel")++ with pytest.raises(ValueError, match="task_id"):+ response_model(**values)+++ "url",+ [+ "http://example.com/output.png",+ "http://127.0.0.1/output.png",+ "//169.254.169.254/latest/meta-data",+ "/unrelated/path/output.png",+ "https://[email protected]/output.png",+ "/proxy/comfy-cloud/../../v1/users/me",+ "/proxy/comfy-cloud/%2e%2e/%2e%2e/v1/users/me",+ "https://127.0.0.1/output.png",+ "https://169.254.169.254/latest/meta-data",+ "https://attacker.example/output.png",+ ],+)+def test_cloud_workflows_reject_untrusted_output_urls(monkeypatch, url):+ sync = AsyncMock(+ return_value=ComfyCloudGenerateResponse(+ task_id="task-1",+ status="queued",+ polling_url="/poll",+ cancel_url="/cancel",+ )+ )+ poll = AsyncMock(+ return_value=ComfyCloudStatusResponse(task_id="task-1", status="completed", output_url=url)+ )+ download = AsyncMock()+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_image_tensor", download)++ with pytest.raises(RuntimeError, match="invalid output URL"):+ asyncio.run(nodes_comfy_cloud.ComfyCloudZImageTurboNode.execute("prompt"))+ download.assert_not_awaited()+++def test_cloud_workflows_accept_signed_https_output_urls(monkeypatch):+ sync = AsyncMock(+ return_value=ComfyCloudGenerateResponse(+ task_id="task-1",+ status="queued",+ polling_url="/poll",+ cancel_url="/cancel",+ )+ )+ poll = AsyncMock(+ return_value=ComfyCloudStatusResponse(+ task_id="task-1",+ status="completed",+ output_url="https://storage.googleapis.com/comfy-cloud-assets/output.png?signature=example",+ )+ )+ download = AsyncMock(return_value="image-output")+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_image_tensor", download)++ output = asyncio.run(nodes_comfy_cloud.ComfyCloudZImageTurboNode.execute("prompt"))++ assert output[0] == "image-output"+ download.assert_awaited_once_with(+ "https://storage.googleapis.com/comfy-cloud-assets/output.png?signature=example",+ timeout=nodes_comfy_cloud._OUTPUT_DOWNLOAD_TIMEOUT,+ cls=nodes_comfy_cloud.ComfyCloudZImageTurboNode,+ allow_redirects=False,+ )+++ "node",+ [+ nodes_comfy_cloud.ComfyCloudZImageTurboNode,+ nodes_comfy_cloud.ComfyCloudFlux2TextToImageNode,+ nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode,+ ],+)+def test_capability_nodes_reject_oversized_prompts(monkeypatch, node):+ sync = AsyncMock()+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)++ with pytest.raises(Exception, match="4096"):+ asyncio.run(node.execute("x" * 4097, object()))+ sync.assert_not_awaited()+++def test_capability_nodes_strip_prompts_before_submission(monkeypatch):+ values = nodes_comfy_cloud._validate_node_inputs(+ nodes_comfy_cloud.ComfyCloudZImageTurboNode, {"prompt": " prompt "}+ )++ assert values["prompt"] == "prompt"+++def test_task_routes_ignore_response_urls_and_errors_hide_task_token(monkeypatch):+ sync = AsyncMock(+ return_value=ComfyCloudGenerateResponse(+ task_id="secret/task-token",+ status="queued",+ polling_url="https://attacker.example/poll",+ cancel_url="https://attacker.example/cancel",+ )+ )+ poll = AsyncMock(+ return_value=ComfyCloudStatusResponse(+ task_id="secret/task-token",+ status="completed",+ error="provider details with secret/task-token",+ )+ )+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)++ with pytest.raises(RuntimeError) as error:+ _execute_with_defaults(nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode, "A prompt")++ assert poll.call_args.args[1].path == "/proxy/comfy-cloud/workflow/tasks/secret%2Ftask-token"+ assert poll.call_args.kwargs["cancel_endpoint"].path == "/proxy/comfy-cloud/workflow/tasks/secret%2Ftask-token/cancel"+ assert "task-token" not in str(error.value)+ assert "provider details" not in str(error.value)+++CONTROLLED_IMAGE_NODES = [+ (+ nodes_comfy_cloud.ComfyCloudZImageTurboNode,+ "z-image-turbo/text-to-image",+ ["prompt", "seed", "aspect_ratio", "megapixels"],+ {"prompt": "A glass forest", "seed": 9, "aspect_ratio": "16:9", "megapixels": 1.5},+ {"prompt": "A glass forest", "aspect_ratio": "16:9", "megapixels": 1.5, "seed": 9},+ ),+ (+ nodes_comfy_cloud.ComfyCloudFlux2TextToImageNode,+ "flux-2/text-to-image",+ ["prompt", "seed", "aspect_ratio", "megapixels", "turbo"],+ {"prompt": "A glass forest", "seed": 9, "aspect_ratio": "3:2", "megapixels": 2.0, "turbo": False},+ {"prompt": "A glass forest", "aspect_ratio": "3:2", "megapixels": 2.0, "turbo": False, "seed": 9},+ ),+]++[email protected](("node", "workflow", "input_names", "arguments", "expected_inputs"), CONTROLLED_IMAGE_NODES)+def test_controlled_image_node_schema_and_request_mapping(+ monkeypatch, node, workflow, input_names, arguments, expected_inputs+):+ sync = AsyncMock(+ return_value=ComfyCloudGenerateResponse(+ task_id="task-2",+ status="queued",+ polling_url="/tasks/task-2",+ cancel_url="/tasks/task-2/cancel",+ )+ )+ poll = AsyncMock(+ return_value=ComfyCloudStatusResponse(+ task_id="task-2",+ status="completed",+ output_url="/proxy/comfy-cloud/results/task-2/image.png",+ )+ )+ upload = AsyncMock(return_value="/uploads/input.png")+ download = AsyncMock(return_value="image-output")+ monkeypatch.setattr(nodes_comfy_cloud, "sync_op", sync)+ monkeypatch.setattr(nodes_comfy_cloud, "poll_op", poll)+ monkeypatch.setattr(nodes_comfy_cloud, "upload_image_to_comfyapi", upload)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_image_tensor", download)+ monkeypatch.setattr(nodes_comfy_cloud, "get_number_of_images", lambda image: 1)++ schema = node.define_schema()+ assert schema.node_id == node.node_id+ # The schema decorates the class attribute with the beta marker.+ assert schema.display_name == f"{node.display_name} [BETA]"+ assert schema.is_api_node is True+ assert [input.id for input in schema.inputs] == input_names+ assert len(schema.outputs) == 1+ assert schema.outputs[0].get_io_type() == "IMAGE"++ output = asyncio.run(node.execute(**arguments))+ request = sync.call_args.kwargs["data"]++ assert request.workflow == workflow+ assert request.inputs.model_dump(exclude_none=True) == expected_inputs+ assert "asset_id" not in request.model_dump_json()+ assert '"id"' not in request.model_dump_json()+ assert upload.await_count == int("image" in arguments)+ if "image" in arguments:+ assert upload.call_args.kwargs == {"total_pixels": None}+ download.assert_awaited_once_with(+ "/proxy/comfy-cloud/results/task-2/image.png",+ timeout=30 * 60,+ cls=node,+ allow_redirects=False,+ )+ assert output[0] == "image-output"+++def test_controlled_image_nodes_are_declared_and_registered():+ workflows = {workflow for _, workflow, _, _, _ in CONTROLLED_IMAGE_NODES}+ registered = set(asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()))++ assert workflows <= set(get_args(ComfyCloudWorkflow))+ assert {node for node, _, _, _, _ in CONTROLLED_IMAGE_NODES} <= registered+++def test_music_node_sends_its_hidden_caption_cfg(monkeypatch):+ run = AsyncMock(return_value="audio-output")+ monkeypatch.setattr(nodes_comfy_cloud, "_run_audio_workflow", run)++ output = _execute_with_defaults(+ nodes_comfy_cloud.ComfyCloudMiniMaxMusic3TextToAudioNode,+ "A dreamy instrumental",+ )++ inputs = run.call_args.args[2]+ assert inputs.caption_cfg == 1.5+ assert output == "audio-output"++[email protected](reason="Disabled until the server-side issue is fixed")+def test_reference_video_exposes_and_sends_multimodal_references(monkeypatch):+ node = nodes_comfy_cloud.ComfyCloudMiniMaxH3ReferenceToVideoNode+ run = AsyncMock(return_value="video-output")+ asset = AsyncMock(+ return_value=nodes_comfy_cloud.ComfyCloudAssetInput(type="IMAGE", url="/uploads/reference.png")+ )+ video_asset = AsyncMock(+ return_value=nodes_comfy_cloud.ComfyCloudAssetInput(type="VIDEO", url="/uploads/reference.mp4")+ )+ audio_asset = AsyncMock(+ side_effect=[+ nodes_comfy_cloud.ComfyCloudAssetInput(type="AUDIO", url="/uploads/reference-1.m4a"),+ nodes_comfy_cloud.ComfyCloudAssetInput(type="AUDIO", url="/uploads/reference-2.m4a"),+ ]+ )+ monkeypatch.setattr(nodes_comfy_cloud, "_run_video_workflow", run)+ monkeypatch.setattr(nodes_comfy_cloud, "_minimax_h3_asset", asset)+ monkeypatch.setattr(nodes_comfy_cloud, "_minimax_h3_video_asset", video_asset)+ monkeypatch.setattr(nodes_comfy_cloud, "_minimax_h3_audio_asset", audio_asset)++ schema = node.define_schema()+ input_names = [input_spec.id for input_spec in schema.inputs]+ assert input_names == [+ "reference_images", "ref_video", "ref_audio", "prompt", "seed",+ "aspect_ratio", "resolution", "duration_seconds", "ref_image_size",+ ]+ assert next(input_spec for input_spec in schema.inputs if input_spec.id == "ref_video").optional is True+ image_template = next(input_spec for input_spec in schema.inputs if input_spec.id == "reference_images").template+ assert (image_template.min, image_template.max) == (0, 4)+ audio_template = next(input_spec for input_spec in schema.inputs if input_spec.id == "ref_audio").template+ assert (audio_template.min, audio_template.max) == (0, 3)++ asyncio.run(+ node.execute(+ prompt="A glass forest",+ reference_images={"reference_image_1": "image"},+ ref_video="video",+ ref_audio={"ref_audio_1": "audio-1", "ref_audio_2": "audio-2"},+ ref_image_size="max",+ )+ )++ inputs = run.call_args.args[2]+ assert inputs.ref_image_size == "max"+ assert inputs.assets == {+ "reference_image_1": nodes_comfy_cloud.ComfyCloudAssetInput(type="IMAGE", url="/uploads/reference.png"),+ "ref_video": nodes_comfy_cloud.ComfyCloudAssetInput(type="VIDEO", url="/uploads/reference.mp4"),+ "ref_audio_1": nodes_comfy_cloud.ComfyCloudAssetInput(type="AUDIO", url="/uploads/reference-1.m4a"),+ "ref_audio_2": nodes_comfy_cloud.ComfyCloudAssetInput(type="AUDIO", url="/uploads/reference-2.m4a"),+ }+ video_asset.assert_awaited_once_with(node, "video")+ assert audio_asset.await_count == 2++[email protected](reason="Disabled until the server-side issue is fixed")+def test_reference_video_accepts_no_references(monkeypatch):+ run = AsyncMock(return_value="video-output")+ monkeypatch.setattr(nodes_comfy_cloud, "_run_video_workflow", run)++ output = _execute_with_defaults(+ nodes_comfy_cloud.ComfyCloudMiniMaxH3ReferenceToVideoNode,+ "An empty desert",+ )++ assert run.call_args.args[2].assets == {}+ assert output == "video-output"+++def _workflow_ids_submitted_by_the_nodes() -> set[str]:+ """Every workflow id the module names, read off the source.++ Matched by shape rather than by call site: most nodes pass a literal to their+ runner, while Mage Flow passes a `workflow` ClassVar. Categories do not collide+ with the shape ("comfy cloud/image" has a space).+ """+ tree = ast.parse(Path(nodes_comfy_cloud.__file__).read_text())+ shape = re.compile(r"^[a-z0-9][a-z0-9.-]*/[a-z0-9][a-z0-9.-]*$")+ return {+ node.value+ for node in ast.walk(tree)+ if isinstance(node, ast.Constant) and isinstance(node.value, str) and shape.match(node.value)+ }+++def test_every_submitted_workflow_id_is_accepted_by_the_request_model():+ """BE-12049. The union is what pydantic validates the outgoing request+ against, so an id a node submits but the union does not name is a+ ValidationError on Run, for that node only, and no test caught it: the+ check above covers the image nodes alone and only as a subset, so a video+ id could drift and a stale union entry naming no node stayed invisible.++ Exact equality in both directions, deliberately.+ """+ submitted = _workflow_ids_submitted_by_the_nodes()+ declared = set(get_args(ComfyCloudWorkflow))++ assert submitted, "found no workflow ids; the AST scan above has broken"+ assert submitted - declared == set(), f"submitted but not in the union: {sorted(submitted - declared)}"+ assert declared - submitted == set(), f"in the union but submitted by nothing: {sorted(declared - submitted)}"+++# The controls a first-time user is shown before expanding anything. Everything+# outside this set has to be advanced, or the node opens on a wall of dials.+PLAIN_CONTROLS = {+ "prompt", "instruction", "image", "audio", "first_frame", "last_frame",+ "aspect_ratio", "duration_seconds", "seed", "scale", "quality_mode",+ "prompt_enhance", "enhance_prompt", "turbo", "rendering_speed",+ # Music: lyrics are sung rather than described, so they are a second prompt+ # rather than a tuning dial; max_duration is that graph's length control and+ # tiled_decode its one quality-against-speed switch.+ "lyrics", "max_duration", "audio_quality",+ # Video: the frame-size budget is a headline choice rather than a dial, and+ # reference-to-video's slots are its media inputs. ref_image_size is that+ # graph's one quality-against-speed switch.+ "resolution", "reference_images", "ref_video", "ref_audio", "ref_image_size",+ # Mage Flow: a negative prompt is a second prompt rather than a dial, and the+ # pixel budget is how that graph is sized at all, so neither is "advanced".+ "negative_prompt", "megapixels",+}+++def test_tuning_controls_are_hidden_behind_the_advanced_flag():+ for node in asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()):+ plain = [+ input_spec.id+ for input_spec in node.define_schema().inputs+ if not getattr(input_spec, "advanced", None)+ ]+ assert set(plain) <= PLAIN_CONTROLS, f"{node.__name__} shows {sorted(set(plain) - PLAIN_CONTROLS)}"+ # The headline set is prompt, the media inputs, aspect ratio, resolution,+ # duration, seed and one quality-against-speed switch. The multimodal+ # reference node also exposes its video and audio reference groups.+ assert len(plain) <= 9, f"{node.__name__} opens with {len(plain)} controls"+++def test_pointer_node_pickers_name_the_trade_off_rather_than_the_model():+ """A default/* id is a pointer: the model behind it is re-pointed over time and+ the id does not change. A saved graph stores the KEY, so a key naming a model+ would stop resolving the day the pointer moved."""+ tiers = {"fast", "balanced", "quality"}+ for node in asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()):+ if not getattr(node, "workflow", "").startswith("default/"):+ continue+ for options in (node.model_options, node.lora_options):+ assert set(options) <= tiers, f"{node.__name__}: {sorted(set(options) - tiers)}"+++def test_every_seed_starts_at_42_and_advances_after_a_run():+ for node in asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()):+ seed = next((i for i in node.define_schema().inputs if i.id == "seed"), None)+ assert seed is not None, f"{node.__name__} has no seed"+ assert seed.default == 42, f"{node.__name__} seeds at {seed.default}"+ assert seed.control_after_generate is True+++def test_cloud_workflow_controls_have_connection_sockets():+ nodes = asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list())++ for node in nodes:+ for input_spec in node.define_schema().inputs:+ if isinstance(input_spec, nodes_comfy_cloud.IO.WidgetInput):+ assert input_spec.socketless is False, f"{node.__name__}.{input_spec.id}"+++def test_cloud_workflow_schemas_have_descriptions():+ nodes = asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list())++ for node in nodes:+ assert node.define_schema().description.strip(), node.__name__+++def test_cloud_workflow_schemas_share_exact_estimated_rate_metadata():+ nodes = asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list())++ assert nodes_comfy_cloud.COMFY_CLOUD_GPU_SECOND_USD == 0.001295+ assert nodes_comfy_cloud.COMFY_CLOUD_CREDITS_PER_USD == 211+ assert nodes_comfy_cloud.COMFY_CLOUD_GPU_SECOND_CREDITS == pytest.approx(0.273245)+ for node in nodes:+ schema = node.define_schema()+ badge = schema.price_badge.as_dict(schema.inputs)+ assert badge["expr"] == (+ '{"type":"usd","usd":0.001295,"format":{"suffix":"/GPU-second","approximate":true}}'+ )+ assert schema.description.endswith(+ "Runs on a Comfy Cloud GPU, billed by how long it runs at "+ "$0.001295/GPU-second (0.27 credits). Paid in credits, no Cloud "+ "subscription required."+ ), node.__name__+++def test_every_node_describes_what_it_actually_does():+ """These descriptions used to be three generic bodies shared across sixteen+ nodes, which left the tooltip saying nothing about which model runs or why+ you would pick this node over the one beside it."""+ nodes = asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list())+ summaries = {}++ for node in nodes:+ schema = node.define_schema()+ summary = schema.description.split(" Runs on a Comfy Cloud GPU")[0]+ assert len(summary) > 60, f"{node.__name__} says too little: {summary!r}"+ summaries.setdefault(summary, []).append(node.__name__)++ shared = {s: n for s, n in summaries.items() if len(n) > 1}+ # The four capability nodes deliberately share wording per output type.+ assert all(len(n) <= 2 for n in shared.values()), shared+++def test_all_linkable_widget_constraints_are_validated():+ nodes = asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list())++ for node in nodes:+ for input_spec in node.define_schema().inputs:+ if not isinstance(input_spec, nodes_comfy_cloud.IO.WidgetInput):+ continue+ io_type = input_spec.get_io_type()+ if io_type == "COMBO":+ invalid = "not-an-option"+ elif io_type == "BOOLEAN":+ invalid = "true"+ elif io_type == "INT":+ invalid = (input_spec.min - 1) if input_spec.min is not None else 1.5+ elif io_type == "FLOAT":+ invalid = float("nan")+ elif io_type == "STRING" and nodes_comfy_cloud._TEXT_LIMITS.get(input_spec.id, (0,))[0]:+ invalid = " "+ else:+ continue+ with pytest.raises((ValueError, Exception), match=input_spec.id):+ nodes_comfy_cloud._validate_node_inputs(node, {input_spec.id: invalid})+++def test_text_inputs_name_the_field_when_a_linked_value_is_not_a_string():+ """_with_input_sockets clears socketless on every widget, so a graph can link an INT+ output into a text input. That must name the field, not raise AttributeError."""+ with pytest.raises(ValueError, match="prompt"):+ nodes_comfy_cloud._validate_node_inputs(+ nodes_comfy_cloud.ComfyCloudZImageTurboNode, {"prompt": 7}+ )+++def test_uploaded_images_have_decoded_resource_limits():+ oversized_image = torch.empty((1, 8193, 1, 3), device="meta")+ # The only case that reaches the pixel-count branch rather than the dimension one.+ oversized_pixels = torch.empty((1, 8000, 5000, 3), device="meta")++ with pytest.raises(ValueError, match="32-megapixel"):+ nodes_comfy_cloud._validate_image_upload(oversized_image)+ with pytest.raises(ValueError, match="32-megapixel"):+ nodes_comfy_cloud._validate_image_upload(oversized_pixels)+++def _stub_download_session(monkeypatch, responses):+ """Point download_url_to_bytesio at a scripted list of responses, one per attempt.++ Returns the list that records the `allow_redirects` each attempt asked aiohttp for.+ """+ seen_allow_redirects = []++ class Session:+ def __init__(self, timeout):+ pass++ async def get(self, url, headers, allow_redirects=True):+ seen_allow_redirects.append(allow_redirects)+ return responses.pop(0)++ async def close(self):+ pass++ monkeypatch.setattr(download_helpers.aiohttp, "ClientSession", Session)+ monkeypatch.setattr(download_helpers, "sleep_with_interrupt", AsyncMock())+ return seen_allow_redirects+++class _StubContent:+ def __init__(self, chunks):+ self.chunks = iter(chunks)+ self.finished = False++ async def read(self, size):+ chunk = next(self.chunks)+ if isinstance(chunk, Exception):+ raise chunk+ if not chunk:+ self.finished = True+ return chunk++ def at_eof(self):+ return self.finished+++class _StubResponse:+ headers = {}+ content_length = None++ def __init__(self, chunks, status=200):+ self.content = _StubContent(chunks)+ self.status = status++ async def json(self):+ return {}++ async def text(self):+ return ""++ async def __aenter__(self):+ return self++ async def __aexit__(self, *args):+ return False+++def test_in_memory_download_empties_its_sink_before_retrying(monkeypatch):+ """A retry re-reads the body from byte zero. Without the reset the caller gets+ the partial first attempt concatenated with the whole second one."""+ _stub_download_session(+ monkeypatch,+ [+ _StubResponse([b"partial", aiohttp.ClientPayloadError("retry")]),+ _StubResponse([b"final", b""]),+ ],+ )+ destination = BytesIO()++ asyncio.run(download_helpers.download_url_to_bytesio("https://example.com/result", destination))++ assert destination.read() == b"final"+++def test_redirects_are_refused_rather_than_followed_when_disallowed(monkeypatch):+ """Comfy Cloud vets the output URL's bucket before downloading, so a redirect has to+ fail rather than quietly fetch the body from somewhere that was never vetted."""+ seen = _stub_download_session(monkeypatch, [_StubResponse([], status=302)])++ with pytest.raises(Exception, match="HTTP 302"):+ asyncio.run(+ download_helpers.download_url_to_bytesio(+ "https://example.com/result", BytesIO(), allow_redirects=False, max_retries=0+ )+ )++ assert seen == [False]+++def test_extension_registers_exactly_the_shipped_set():+ """The shipped surface is deliberate: four capability nodes whose model the backend+ chooses, plus the named workflows that expose control a generic shape cannot."""+ capability_nodes = {+ nodes_comfy_cloud.ComfyCloudZImageTurboNode,+ nodes_comfy_cloud.ComfyCloudFlux2TextToImageNode,+ nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode,+ }+ named_nodes = {+ nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode,+ nodes_comfy_cloud.ComfyCloudZImageTurboNode,+ nodes_comfy_cloud.ComfyCloudFlux2TextToImageNode,+ nodes_comfy_cloud.ComfyCloudMageFlowTextToImageNode,+ nodes_comfy_cloud.ComfyCloudMageFlowTurboTextToImageNode,+ nodes_comfy_cloud.ComfyCloudMiniMaxMusic3TextToAudioNode,+ nodes_comfy_cloud.ComfyCloudMiniMaxH3FirstLastFrameToVideoNode,+ nodes_comfy_cloud.ComfyCloudMiniMaxH3ImageToVideoNode,+ }+ registered = set(asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()))++ assert registered == capability_nodes | named_nodes+++def test_every_node_is_named_for_its_provider():+ """A user searching "flux" sees our paid cloud node beside the free local one.+ The provider prefix is the only thing on the name that tells them apart."""+ for node in asyncio.run(nodes_comfy_cloud.ComfyCloudExtension().get_node_list()):+ name = node.define_schema().display_name+ assert name.startswith("Comfy Cloud "), f"{node.__name__} is named {name!r}"+ # Beta marker is a SUFFIX so the menu still sorts these by model rather+ # than filing all of them under "[".+ assert name.endswith(" [BETA]"), f"{node.__name__} is named {name!r}"+++ "bucket",+ ["comfy-cloud", "comfy-cloud-assets-evil", "example", "comfy-cloud-assets.evil.com",+ "partner-nodes-assets-evil", "partner-nodes",+ # Advertises an allowed bucket in the first segment and resolves to another one.+ "comfy-cloud-assets/../other-bucket", "comfy-cloud-assets/%2e%2e/other-bucket"],+)+def test_output_urls_outside_the_backend_bucket_allowlist_are_rejected(bucket):+ """The output URL is backend-supplied, so this is defence in depth -- but the host check+ alone would accept any bucket on storage.googleapis.com. Pinned to the same set the Go+ side enforces (comfyCloudOutputBuckets)."""+ with pytest.raises(RuntimeError):+ nodes_comfy_cloud._validated_output_url(+ f"https://storage.googleapis.com/{bucket}/output.png?signature=example"+ )+++ "bucket", ["comfy-cloud-assets", "comfy-cloud-assets-stg", "comfy-cloud-assets-test"]+)+def test_output_urls_in_the_backend_bucket_allowlist_are_accepted(bucket):+ url = f"https://storage.googleapis.com/{bucket}/output.png?signature=example"+ assert nodes_comfy_cloud._validated_output_url(url) == url+++def test_poll_budget_covers_the_platform_run_ceiling():+ """The poll budget must sit just above the platform's own max_runtime, so a job that is+ still legitimately running is ended by its own timeout rather than abandoned by the node."""+ budget = nodes_comfy_cloud._POLL_MAX_ATTEMPTS * nodes_comfy_cloud._POLL_INTERVAL_SECONDS+ assert budget > nodes_comfy_cloud._RUN_TIMEOUT_SECONDS+ assert budget - nodes_comfy_cloud._RUN_TIMEOUT_SECONDS <= 300+++def test_output_buckets_match_the_server_allowlist():+ """Pins the bucket set so a change here is deliberate and paired.++ The same list lives in cloud at services/comfy-api/config/config.go+ (comfyCloudOutputBuckets). Widening one side only is not a benign skew: the+ job runs on the GPU, the caller is billed per GPU-second, and the output is+ then rejected on the user's machine. The node half also ships on the ComfyUI+ release train, so a mismatch persists until the next release.+ """+ assert nodes_comfy_cloud._OUTPUT_BUCKETS == frozenset(+ {+ "comfy-cloud-assets",+ "comfy-cloud-assets-stg",+ "comfy-cloud-assets-test",+ "partner-nodes-assets",+ "partner-nodes-assets-staging",+ }+ )+++def test_disabled_provider_message_reaches_the_user_verbatim():+ """comfy-api's error envelope is flat, and the message is what a user reads.++ Before this, _friendly_http_message only unwrapped a NESTED error object, so+ a flat {"error": code, "message": text} body fell through to the raw-JSON+ branch and the user was shown the whole payload.+ """+ from comfy_api_nodes.util import client++ body = {+ "error": "comfy_cloud_provider_disabled",+ "message": "Comfy Cloud is currently unavailable. Please try again later.",+ }+ assert client._friendly_http_message(503, body) == body["message"]+++def test_disabled_provider_is_not_retried():+ """A switched-off provider is a terminal answer, not a transient blip.++ 503 is in _RETRY_STATUS, so without this the user waits through three+ backoff rounds only to be told the same thing.+ """+ from comfy_api_nodes.util import client++ assert client._is_terminal_service_refusal(+ {"error": "comfy_cloud_provider_disabled", "message": "x"}+ )+ # A genuine transient 503 carries no such code and must still be retried.+ assert not client._is_terminal_service_refusal({"error": "upstream_timeout"})+ assert not client._is_terminal_service_refusal({})+ assert not client._is_terminal_service_refusal("bad gateway")+++ ("node", "io_type"),+ [+ (nodes_comfy_cloud.ComfyCloudZImageTurboNode, "IMAGE"),+ (nodes_comfy_cloud.ComfyCloudMiniMaxH3TextToVideoNode, "VIDEO"),+ (nodes_comfy_cloud.ComfyCloudMiniMaxMusic3TextToAudioNode, "AUDIO"),+ ],+)+def test_nodes_declare_their_output_io_type(node, io_type):+ assert node.define_schema().outputs[0].get_io_type() == io_type++[email protected]("kind", ["image", "video", "audio"])+def test_every_output_kind_refuses_a_redirect_off_the_vetted_url(monkeypatch, kind):+ """The bucket pin decides where the bytes may come from. Following a redirect+ would hand that decision back to the server we just checked."""+ seen = {}++ async def fake(url, *args, **kwargs):+ seen.update(kwargs)+ return "output"++ async def fake_bytesio(url, dest, *args, **kwargs):+ seen.update(kwargs)++ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_image_tensor", fake)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_video_output", fake)+ monkeypatch.setattr(nodes_comfy_cloud, "download_url_to_bytesio", fake_bytesio)+ monkeypatch.setattr(nodes_comfy_cloud, "audio_bytes_to_audio_input", lambda data: "audio")+ monkeypatch.setattr(+ nodes_comfy_cloud, "_submit_workflow",+ AsyncMock(return_value="https://storage.googleapis.com/comfy-cloud-assets/o.bin?X-Goog-Signature=x"),+ )++ run = {+ "image": nodes_comfy_cloud._run_image_workflow,+ "video": nodes_comfy_cloud._run_video_workflow,+ "audio": nodes_comfy_cloud._run_audio_workflow,+ }[kind]+ asyncio.run(run(nodes_comfy_cloud.ComfyCloudZImageTurboNode, "z-image-turbo/text-to-image", None))++ assert seen["allow_redirects"] is False