Add Slack notification on CI failure

.github/workflows/test-ci.yml

@@ -97,3 +97,16 @@ jobs:
           torch_version: ${{ matrix.torch_version }}
           google_credentials: ${{ secrets.GCS_SERVICE_ACCOUNT_JSON }}
           comfyui_flags: ${{ matrix.flags }}
+
+  notify-failure:
+    needs: [test-stable, test-unix-nightly]
+    if: ${{ failure() && github.event_name == 'push' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify Slack of CI failure
+        uses: slackapi/slack-github-action@v2.1.0
+        with:
+          webhook: ${{ secrets.CI_ALERTS_SLACK_WEBHOOK }}
+          webhook-type: incoming-webhook
+          payload: |
+            text: ":rotating_siren: ComfyUI CI failed on `${{ github.ref_name }}`\n*Commit:* <${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }}|${{ github.sha }}>\n*Run:* <${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}|view logs>\n*Dashboard:* <https://ci.comfy.org/?branch=${{ github.ref_name }}|ci.comfy.org>"

comfy/cli_args.py

@@ -115,7 +115,6 @@ cache_group.add_argument("--cache-ram", nargs='*', type=float, default=[], metav
 cache_group.add_argument("--cache-classic", action="store_true", help="Use the old style (aggressive) caching.")
 cache_group.add_argument("--cache-lru", type=int, default=0, help="Use LRU caching with a maximum of N node results cached. May use more RAM/VRAM.")
 cache_group.add_argument("--cache-none", action="store_true", help="Reduced RAM/VRAM usage at the expense of executing every node for each run.")
-cache_group.add_argument("--high-ram", action="store_true", help="Can improve performance slightly on high RAM or on systems where pagefile use is preferred over model loading.")
 
 attn_group = parser.add_mutually_exclusive_group()
 attn_group.add_argument("--use-split-cross-attention", action="store_true", help="Use the split cross attention optimization. Ignored when xformers is used.")
@@ -250,9 +249,6 @@ else:
 if args.cache_ram is not None and len(args.cache_ram) > 2:
     parser.error("--cache-ram accepts at most two values: active GB and inactive GB")
 
-if args.high_ram:
-    args.cache_classic = True
-
 if args.windows_standalone_build:
     args.auto_launch = True
 

comfy/ldm/ideogram4/model.py

@@ -106,11 +106,11 @@ class Ideogram4EmbedScalar(nn.Module):
         self.mlp_in = operations.Linear(dim, dim, bias=True, dtype=dtype, device=device)
         self.mlp_out = operations.Linear(dim, dim, bias=True, dtype=dtype, device=device)
 
-    def forward(self, x, dtype):
+    def forward(self, x):
         x = x.to(torch.float32)
         scaled = 1e4 * (x - self.range_min) / (self.range_max - self.range_min)
         emb = _sinusoidal_embedding(scaled, self.dim)
-        emb = emb.to(dtype)
+        emb = emb.to(self.mlp_in.weight.dtype)
         emb = F.silu(self.mlp_in(emb))
         return self.mlp_out(emb)
 
@@ -161,7 +161,7 @@ class Ideogram4Transformer(nn.Module):
         x = x * output_image_mask
         h = self.input_proj(x) * output_image_mask
 
-        t_cond = self.t_embedding(t, dtype=x.dtype)
+        t_cond = self.t_embedding(t)
         if t.dim() == 1:
             t_cond = t_cond.unsqueeze(1)
         adaln_input = F.silu(self.adaln_proj(t_cond))

comfy/ldm/omnigen/omnigen2.py

@@ -8,7 +8,6 @@ import torch.nn.functional as F
 from einops import rearrange, repeat
 from comfy.ldm.lightricks.model import Timesteps
 from comfy.ldm.flux.layers import EmbedND
-from comfy.ldm.flux.math import apply_rope1
 from comfy.ldm.modules.attention import optimized_attention_masked
 import comfy.model_management
 import comfy.ldm.common_dit
@@ -18,7 +17,9 @@ def apply_rotary_emb(x, freqs_cis):
     if x.shape[1] == 0:
         return x
 
-    return apply_rope1(x, freqs_cis)
+    t_ = x.reshape(*x.shape[:-1], -1, 1, 2)
+    t_out = freqs_cis[..., 0] * t_[..., 0] + freqs_cis[..., 1] * t_[..., 1]
+    return t_out.reshape(*x.shape).to(dtype=x.dtype)
 
 
 def swiglu(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:

comfy/model_management.py

@@ -643,8 +643,6 @@ def free_pins(size, evict_active=False):
     return freed_total
 
 def ensure_pin_budget(size, evict_active=False):
-    if args.high_ram:
-        return True
     if args.fast_disk:
         shortfall = TOTAL_PINNED_MEMORY + size - MAX_PINNED_MEMORY
     else:
@@ -1498,8 +1496,6 @@ if not args.disable_pinned_memory:
 PINNING_ALLOWED_TYPES = set(["Tensor", "Parameter", "QuantizedTensor"])
 
 def pinned_hostbuf_size(size):
-    if args.high_ram:
-        return max(0, int(size * 2))
     return max(0, int(min(size, MAX_PINNED_MEMORY) * 2))
 
 def discard_cuda_async_error():

comfy/ops.py

@@ -180,7 +180,7 @@ def cast_modules_with_vbar(comfy_modules, dtype, device, bias_dtype, non_blockin
             if pin is not None:
                 cast_maybe_lowvram_patch([pin], dest, offload_stream)
                 return
-            if signature is None or args.high_ram:
+            if signature is None:
                 comfy.pinned_memory.pin_memory(m, subset=subset, size=size)
                 pin = comfy.pinned_memory.get_pin(m, subset=subset)
             cast_maybe_lowvram_patch(source, pin, offload_stream, xfer_dest2=dest)

comfy_api_nodes/apis/runway.py

@@ -67,6 +67,15 @@ class RunwayImageToVideoResponse(BaseModel):
     id: Optional[str] = Field(None, description='Task ID')
 
 
+class RunwayTaskStatusEnum(str, Enum):
+    SUCCEEDED = 'SUCCEEDED'
+    RUNNING = 'RUNNING'
+    FAILED = 'FAILED'
+    PENDING = 'PENDING'
+    CANCELLED = 'CANCELLED'
+    THROTTLED = 'THROTTLED'
+
+
 class RunwayTaskStatusResponse(BaseModel):
     createdAt: datetime = Field(..., description='Task creation timestamp')
     id: str = Field(..., description='Task ID')
@@ -77,7 +86,7 @@ class RunwayTaskStatusResponse(BaseModel):
         ge=0.0,
         le=1.0,
     )
-    status: str = Field(..., description="SUCCEEDED, RUNNING, FAILED, PENDING, CANCELLED or THROTTLED")
+    status: RunwayTaskStatusEnum
 
 
 class Model4(str, Enum):
@@ -116,144 +125,3 @@ class RunwayTextToImageRequest(BaseModel):
 
 class RunwayTextToImageResponse(BaseModel):
     id: Optional[str] = Field(None, description='Task ID')
-
-
-class RunwayAleph2IO:
-    """Custom socket types for chaining Aleph2 guidance images."""
-
-    KEYFRAME = "RUNWAY_ALEPH2_KEYFRAME"
-    PROMPT_IMAGE = "RUNWAY_ALEPH2_PROMPT_IMAGE"
-
-
-# Keyframe timing modes (anchored to the INPUT video). Stored on the chain item and used to
-# choose the request model below. The values match the Aleph2 keyframe union field names.
-KEYFRAME_MODE_SECONDS = "seconds"  # absolute time, in seconds, from the start of the input video
-KEYFRAME_MODE_AT = "at"  # fraction [0.0, 1.0] of the input video duration
-
-# Prompt-image position modes (anchored to the OUTPUT video). Values match the Aleph2 position `type`.
-PROMPT_IMAGE_MODE_TIMESTAMP = "timestamp"  # absolute time, in seconds, from the start of the output video
-PROMPT_IMAGE_MODE_POSITION = "position"  # fraction [0.0, 1.0] of the output video duration
-
-
-class RunwayAleph2KeyframeItem:
-    """A guidance image anchored to a point of the INPUT video (one Aleph2 ``keyframe``)."""
-
-    def __init__(self, image, mode: str, value: float):
-        self.image = image
-        self.mode = mode  # KEYFRAME_MODE_SECONDS | KEYFRAME_MODE_AT
-        self.value = value
-
-
-class RunwayAleph2KeyframeChain:
-    """An ordered collection of keyframes, built by chaining Runway Aleph2 Keyframe nodes."""
-
-    def __init__(self):
-        self.items: list[RunwayAleph2KeyframeItem] = []
-
-    def add(self, item: RunwayAleph2KeyframeItem) -> None:
-        self.items.append(item)
-
-    def clone(self) -> "RunwayAleph2KeyframeChain":
-        c = RunwayAleph2KeyframeChain()
-        c.items = list(self.items)
-        return c
-
-
-class RunwayAleph2PromptImageItem:
-    """A guidance image anchored to a point of the OUTPUT video (one Aleph2 ``promptImage``)."""
-
-    def __init__(self, image, mode: str, value: float):
-        self.image = image
-        self.mode = mode  # PROMPT_IMAGE_MODE_TIMESTAMP | PROMPT_IMAGE_MODE_POSITION
-        self.value = value
-
-
-class RunwayAleph2PromptImageChain:
-    """An ordered collection of prompt images, built by chaining Runway Aleph2 Prompt Image nodes."""
-
-    def __init__(self):
-        self.items: list[RunwayAleph2PromptImageItem] = []
-
-    def add(self, item: RunwayAleph2PromptImageItem) -> None:
-        self.items.append(item)
-
-    def clone(self) -> "RunwayAleph2PromptImageChain":
-        c = RunwayAleph2PromptImageChain()
-        c.items = list(self.items)
-        return c
-
-
-class RunwayAleph2KeyframeSeconds(BaseModel):
-    seconds: float = Field(
-        ...,
-        description="Absolute timestamp in seconds from the start of the input video when this guidance image should apply.",
-        ge=0.0,
-    )
-    uri: str = Field(...)
-
-
-class RunwayAleph2KeyframeAt(BaseModel):
-    at: float = Field(
-        ...,
-        description="Position as a fraction [0.0, 1.0] of the input video duration.",
-        ge=0.0,
-        le=1.0,
-    )
-    uri: str = Field(...)
-
-
-class RunwayAleph2TimestampPosition(BaseModel):
-    type: str = Field(default="timestamp")
-    timestampSeconds: float = Field(
-        ...,
-        description="Absolute timestamp in seconds from the start of the output video.",
-        ge=0.0,
-    )
-
-
-class RunwayAleph2RelativePosition(BaseModel):
-    type: str = Field(default="position")
-    positionPercentage: float = Field(
-        ...,
-        description="Position as a fraction [0.0, 1.0] of the total output video duration.",
-        ge=0.0,
-        le=1.0,
-    )
-
-
-class RunwayAleph2PromptImage(BaseModel):
-    position: RunwayAleph2TimestampPosition | RunwayAleph2RelativePosition
-    uri: str = Field(...)
-
-
-class RunwayAleph2ContentModeration(BaseModel):
-    publicFigureThreshold: str = Field(
-        ...,
-        description='When set to "low", the content moderation system is less strict about '
-        'recognizable public figures. One of "auto" or "low".',
-    )
-
-
-class RunwayAleph2Request(BaseModel):
-    model: str = Field(default="aleph2")
-    promptText: str = Field(
-        ...,
-        description="A non-empty string describing what should appear in the output.",
-        min_length=1,
-        max_length=1000,
-    )
-    videoUri: str = Field(...)
-    seed: int = Field(..., description="Random seed for generation", ge=0, le=4294967295)
-    contentModeration: RunwayAleph2ContentModeration = Field(...)
-    keyframes: list[RunwayAleph2KeyframeSeconds | RunwayAleph2KeyframeAt] | None = Field(
-        None,
-        description="Timed guidance images placed at specific points in the input video. Up to 5.",
-    )
-    promptImage: list[RunwayAleph2PromptImage] | None = Field(
-        None,
-        description="Up to 5 image keyframes for guiding the edit at specific points in the output video.",
-    )
-
-
-class RunwayAleph2Response(BaseModel):
-    id: str | None = Field(None, description="Task ID")

comfy_api_nodes/nodes_runway.py

@@ -30,33 +30,13 @@ from comfy_api_nodes.apis.runway import (
     Model4,
     ReferenceImage,
     RunwayTextToImageAspectRatioEnum,
-    RunwayAleph2IO,
-    RunwayAleph2KeyframeChain,
-    RunwayAleph2KeyframeItem,
-    RunwayAleph2PromptImageChain,
-    RunwayAleph2PromptImageItem,
-    RunwayAleph2Request,
-    RunwayAleph2Response,
-    RunwayAleph2KeyframeSeconds,
-    RunwayAleph2KeyframeAt,
-    RunwayAleph2PromptImage,
-    RunwayAleph2TimestampPosition,
-    RunwayAleph2RelativePosition,
-    RunwayAleph2ContentModeration,
-    KEYFRAME_MODE_SECONDS,
-    KEYFRAME_MODE_AT,
-    PROMPT_IMAGE_MODE_TIMESTAMP,
-    PROMPT_IMAGE_MODE_POSITION,
 )
 from comfy_api_nodes.util import (
     image_tensor_pair_to_batch,
     validate_string,
     validate_image_dimensions,
     validate_image_aspect_ratio,
-    validate_video_duration,
     upload_images_to_comfyapi,
-    upload_image_to_comfyapi,
-    upload_video_to_comfyapi,
     download_url_to_video_output,
     download_url_to_image_tensor,
     ApiEndpoint,
@@ -65,7 +45,6 @@ from comfy_api_nodes.util import (
 )
 
 PATH_IMAGE_TO_VIDEO = "/proxy/runway/image_to_video"
-PATH_VIDEO_TO_VIDEO = "/proxy/runway/video_to_video"
 PATH_TEXT_TO_IMAGE = "/proxy/runway/text_to_image"
 PATH_GET_TASK_STATUS = "/proxy/runway/tasks"
 
@@ -74,6 +53,12 @@ AVERAGE_DURATION_FLF_SECONDS = 256
 AVERAGE_DURATION_T2I_SECONDS = 41
 
 
+class RunwayApiError(Exception):
+    """Base exception for Runway API errors."""
+
+    pass
+
+
 class RunwayGen4TurboAspectRatio(str, Enum):
     """Aspect ratios supported for Image to Video API when using gen4_turbo model."""
 
@@ -99,6 +84,14 @@ def get_video_url_from_task_status(response: TaskStatusResponse) -> str | None:
     return None
 
 
+def extract_progress_from_task_status(
+    response: TaskStatusResponse,
+) -> float | None:
+    if hasattr(response, "progress") and response.progress is not None:
+        return response.progress * 100
+    return None
+
+
 def get_image_url_from_task_status(response: TaskStatusResponse) -> str | None:
     """Returns the image URL from the task status response if it exists."""
     if hasattr(response, "output") and len(response.output) > 0:
@@ -109,13 +102,14 @@ def get_image_url_from_task_status(response: TaskStatusResponse) -> str | None:
 async def get_response(
     cls: type[IO.ComfyNode], task_id: str, estimated_duration: int | None = None
 ) -> TaskStatusResponse:
+    """Poll the task status until it is finished then get the response."""
     return await poll_op(
         cls,
         ApiEndpoint(path=f"{PATH_GET_TASK_STATUS}/{task_id}"),
         response_model=TaskStatusResponse,
-        status_extractor=lambda r: r.status,
+        status_extractor=lambda r: r.status.value,
         estimated_duration=estimated_duration,
-        progress_extractor=lambda r: r.progress * 100 if r.progress is not None else None,
+        progress_extractor=extract_progress_from_task_status,
     )
 
 
@@ -133,7 +127,7 @@ async def generate_video(
 
     final_response = await get_response(cls, initial_response.id, estimated_duration)
     if not final_response.output:
-        raise ValueError("Runway task succeeded but no video data found in response.")
+        raise RunwayApiError("Runway task succeeded but no video data found in response.")
 
     video_url = get_video_url_from_task_status(final_response)
     return await download_url_to_video_output(video_url)
@@ -416,7 +410,7 @@ class RunwayFirstLastFrameNode(IO.ComfyNode):
             mime_type="image/png",
         )
         if len(download_urls) != 2:
-            raise ValueError("Failed to upload one or more images to comfy api.")
+            raise RunwayApiError("Failed to upload one or more images to comfy api.")
 
         return IO.NodeOutput(
             await generate_video(
@@ -520,321 +514,11 @@ class RunwayTextToImageNode(IO.ComfyNode):
             estimated_duration=AVERAGE_DURATION_T2I_SECONDS,
         )
         if not final_response.output:
-            raise ValueError("Runway task succeeded but no image data found in response.")
+            raise RunwayApiError("Runway task succeeded but no image data found in response.")
 
         return IO.NodeOutput(await download_url_to_image_tensor(get_image_url_from_task_status(final_response)))
 
 
-_TIMING_ABSOLUTE = "Absolute time (seconds)"
-_TIMING_FRACTION = "Fraction of duration (0.0-1.0)"
-
-
-class RunwayAleph2KeyframeNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="RunwayAleph2KeyframeNode",
-            display_name="Runway Aleph2 Keyframe",
-            category="partner/video/Runway",
-            description="Anchor a guidance image to a moment of the input (source) video, so Aleph2 "
-            "steers the edit at that point of your footage. Connect this to the 'keyframes' input of "
-            "the Runway Aleph2 Video to Video node; chain several together (up to 5) via the optional "
-            "'keyframes' input below.",
-            inputs=[
-                IO.Image.Input(
-                    "image",
-                    tooltip="The guidance image to apply at the chosen moment of the input video.",
-                ),
-                IO.DynamicCombo.Input(
-                    "timing",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            _TIMING_ABSOLUTE,
-                            [
-                                IO.Float.Input(
-                                    "seconds",
-                                    default=0.0,
-                                    min=0.0,
-                                    max=30.0,
-                                    step=0.1,
-                                    display_mode=IO.NumberDisplay.number,
-                                    tooltip="Time in seconds from start of the input video where this image applies.",
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option(
-                            _TIMING_FRACTION,
-                            [
-                                IO.Float.Input(
-                                    "fraction",
-                                    default=0.0,
-                                    min=0.0,
-                                    max=1.0,
-                                    step=0.01,
-                                    display_mode=IO.NumberDisplay.number,
-                                    tooltip="Where in the input video this image applies, "
-                                    "as a fraction of its duration (0.0 = start, 1.0 = end).",
-                                ),
-                            ],
-                        ),
-                    ],
-                    tooltip="How to place this image on the input video's timeline.",
-                ),
-                IO.Custom(RunwayAleph2IO.KEYFRAME).Input(
-                    "keyframes",
-                    optional=True,
-                    tooltip="Optional earlier keyframes to chain with this one.",
-                ),
-            ],
-            outputs=[IO.Custom(RunwayAleph2IO.KEYFRAME).Output(display_name="keyframes")],
-        )
-
-    @classmethod
-    def execute(
-        cls,
-        image: Input.Image,
-        timing: dict,
-        keyframes: RunwayAleph2KeyframeChain | None = None,
-    ) -> IO.NodeOutput:
-        chain = keyframes.clone() if keyframes is not None else RunwayAleph2KeyframeChain()
-        if timing["timing"] == _TIMING_ABSOLUTE:
-            mode, value = KEYFRAME_MODE_SECONDS, float(timing["seconds"])
-        else:
-            mode, value = KEYFRAME_MODE_AT, float(timing["fraction"])
-        chain.add(RunwayAleph2KeyframeItem(image=image, mode=mode, value=value))
-        return IO.NodeOutput(chain)
-
-
-class RunwayAleph2PromptImageNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="RunwayAleph2PromptImageNode",
-            display_name="Runway Aleph2 Prompt Image",
-            category="partner/video/Runway",
-            description="Anchor a guidance image to a moment of the output (result) video, to guide what "
-            "the edited video looks like at that point. Connect this to the 'prompt_images' input of the "
-            "Runway Aleph2 Video to Video node; chain several together (up to 5) via the optional "
-            "'prompt_images' input below.",
-            inputs=[
-                IO.Image.Input(
-                    "image",
-                    tooltip="The guidance image to place at the chosen moment of the output video.",
-                ),
-                IO.DynamicCombo.Input(
-                    "position",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            _TIMING_ABSOLUTE,
-                            [
-                                IO.Float.Input(
-                                    "seconds",
-                                    default=0.0,
-                                    min=0.0,
-                                    max=30.0,
-                                    step=0.1,
-                                    display_mode=IO.NumberDisplay.number,
-                                    tooltip="Time in seconds from start of the output video where this image applies.",
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option(
-                            _TIMING_FRACTION,
-                            [
-                                IO.Float.Input(
-                                    "fraction",
-                                    default=0.0,
-                                    min=0.0,
-                                    max=1.0,
-                                    step=0.01,
-                                    display_mode=IO.NumberDisplay.number,
-                                    tooltip="Where in the output video this image applies, "
-                                    "as a fraction of its duration (0.0 = start, 1.0 = end).",
-                                ),
-                            ],
-                        ),
-                    ],
-                    tooltip="How to place this image on the output video's timeline.",
-                ),
-                IO.Custom(RunwayAleph2IO.PROMPT_IMAGE).Input(
-                    "prompt_images",
-                    optional=True,
-                    tooltip="Optional earlier prompt images to chain with this one.",
-                ),
-            ],
-            outputs=[IO.Custom(RunwayAleph2IO.PROMPT_IMAGE).Output(display_name="prompt_images")],
-        )
-
-    @classmethod
-    def execute(
-        cls,
-        image: Input.Image,
-        position: dict,
-        prompt_images: RunwayAleph2PromptImageChain | None = None,
-    ) -> IO.NodeOutput:
-        chain = prompt_images.clone() if prompt_images is not None else RunwayAleph2PromptImageChain()
-        if position["position"] == _TIMING_ABSOLUTE:
-            mode, value = PROMPT_IMAGE_MODE_TIMESTAMP, float(position["seconds"])
-        else:
-            mode, value = PROMPT_IMAGE_MODE_POSITION, float(position["fraction"])
-        chain.add(RunwayAleph2PromptImageItem(image=image, mode=mode, value=value))
-        return IO.NodeOutput(chain)
-
-
-class RunwayAleph2VideoToVideoNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="RunwayAleph2VideoToVideoNode",
-            display_name="Runway Aleph2 Video to Video",
-            category="partner/video/Runway",
-            description="Edit a video with a text prompt using Runway's Aleph2 model. Aleph2 transforms "
-            "your footage (restyle, relight, add or remove elements, change the viewpoint) while keeping "
-            "the original motion and timing; the output resolution matches the input video, which must be "
-            "2-30 seconds at 30 fps or lower. Optionally steer the edit with either keyframes (anchored to "
-            "the input video) or prompt images (anchored to the output video) - use one or the other, not both.",
-            inputs=[
-                IO.String.Input(
-                    "prompt",
-                    multiline=True,
-                    default="",
-                    tooltip="Describes what should appear in the output (1-1000 characters).",
-                ),
-                IO.Video.Input(
-                    "video",
-                    tooltip="Input video to edit. Must be 2-30 seconds at 30 fps or lower.",
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=4294967295,
-                    step=1,
-                    control_after_generate=True,
-                    display_mode=IO.NumberDisplay.number,
-                    tooltip="Random seed for generation",
-                ),
-                IO.Combo.Input(
-                    "public_figure_threshold",
-                    options=["auto", "low"],
-                    default="low",
-                    tooltip="Content moderation for recognizable public figures.",
-                ),
-                IO.Custom(RunwayAleph2IO.KEYFRAME).Input(
-                    "keyframes",
-                    optional=True,
-                    tooltip="Guidance images anchored to the input video, from Aleph2 Keyframe nodes (up to 5). "
-                    "Use keyframes or prompt images, not both.",
-                ),
-                IO.Custom(RunwayAleph2IO.PROMPT_IMAGE).Input(
-                    "prompt_images",
-                    optional=True,
-                    tooltip="Guidance images anchored to the output video, from Aleph2 Prompt Image nodes (up to 5). "
-                    "Use keyframes or prompt images, not both.",
-                ),
-            ],
-            outputs=[
-                IO.Video.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(
-                expr="""{"type":"usd","usd": 0.4004, "format":{"suffix":"/second"}}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        prompt: str,
-        video: Input.Video,
-        seed: int,
-        public_figure_threshold: str = "low",
-        keyframes: RunwayAleph2KeyframeChain | None = None,
-        prompt_images: RunwayAleph2PromptImageChain | None = None,
-    ) -> IO.NodeOutput:
-        validate_string(prompt, min_length=1, max_length=1000)
-        validate_video_duration(
-            video,
-            min_duration=2.0,
-            max_duration=30.0,
-        )
-        try:
-            fps = float(video.get_frame_rate())
-        except Exception:
-            fps = None
-        if fps is not None and fps > 30.0 + 0.01:
-            raise ValueError(f"Input video frame rate ({fps:.2f} fps) exceeds Aleph2's maximum of 30 fps.")
-
-        if (keyframes and keyframes.items) and (prompt_images and prompt_images.items):
-            raise ValueError("Aleph2 accepts either keyframes or prompt images, not both.")
-
-        video_duration: float | None = None
-        try:
-            video_duration = video.get_duration()
-        except Exception:
-            video_duration = None
-
-        def _check_seconds(value: float, label: str) -> None:
-            if video_duration is not None and value > video_duration + 0.0001:
-                raise ValueError(f"{label} {value:.2f}s exceeds the input video duration ({video_duration:.2f}s).")
-
-        video_url = await upload_video_to_comfyapi(cls, video)
-
-        keyframe_models: list[RunwayAleph2KeyframeSeconds | RunwayAleph2KeyframeAt] = []
-        if keyframes is not None:
-            if len(keyframes.items) > 5:
-                raise ValueError("Aleph2 supports at most 5 keyframes.")
-            for item in keyframes.items:
-                image_url = await upload_image_to_comfyapi(cls, item.image, mime_type="image/png")
-                if item.mode == KEYFRAME_MODE_SECONDS:
-                    _check_seconds(item.value, "Keyframe timestamp")
-                    keyframe_models.append(RunwayAleph2KeyframeSeconds(seconds=item.value, uri=image_url))
-                else:
-                    keyframe_models.append(RunwayAleph2KeyframeAt(at=item.value, uri=image_url))
-
-        prompt_image_models: list[RunwayAleph2PromptImage] = []
-        if prompt_images is not None:
-            if len(prompt_images.items) > 5:
-                raise ValueError("Aleph2 supports at most 5 prompt images.")
-            for item in prompt_images.items:
-                image_url = await upload_image_to_comfyapi(cls, item.image, mime_type="image/png")
-                position: RunwayAleph2TimestampPosition | RunwayAleph2RelativePosition
-                if item.mode == PROMPT_IMAGE_MODE_TIMESTAMP:
-                    _check_seconds(item.value, "Prompt image timestamp")
-                    position = RunwayAleph2TimestampPosition(timestampSeconds=item.value)
-                else:
-                    position = RunwayAleph2RelativePosition(positionPercentage=item.value)
-                prompt_image_models.append(RunwayAleph2PromptImage(position=position, uri=image_url))
-
-        initial_response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path=PATH_VIDEO_TO_VIDEO, method="POST"),
-            response_model=RunwayAleph2Response,
-            data=RunwayAleph2Request(
-                promptText=prompt,
-                videoUri=video_url,
-                seed=seed,
-                contentModeration=RunwayAleph2ContentModeration(publicFigureThreshold=public_figure_threshold),
-                keyframes=keyframe_models or None,
-                promptImage=prompt_image_models or None,
-            ),
-        )
-
-        final_response = await get_response(cls, initial_response.id)
-        if not final_response.output:
-            raise ValueError("Runway task succeeded but no video data found in response.")
-
-        return IO.NodeOutput(await download_url_to_video_output(get_video_url_from_task_status(final_response)))
-
-
 class RunwayExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -843,9 +527,6 @@ class RunwayExtension(ComfyExtension):
             RunwayImageToVideoNodeGen3a,
             RunwayImageToVideoNodeGen4,
             RunwayTextToImageNode,
-            RunwayAleph2VideoToVideoNode,
-            RunwayAleph2KeyframeNode,
-            RunwayAleph2PromptImageNode,
         ]
 
 

openapi.yaml

@@ -896,6 +896,11 @@ components:
                     additionalProperties: true
                     description: The workflow graph to execute
                     type: object
+                prompt_id:
+                    description: Optional client-supplied job id. Must be a UUID in canonical lowercase hyphenated form; it is echoed back in the response. Omitted or null means the server generates one.
+                    format: uuid
+                    nullable: true
+                    type: string
                 workflow_id:
                     description: UUID identifying the cloud workflow entity to associate with this job
                     type: string
@@ -1795,9 +1800,7 @@ paths:
                         application/json:
                             schema:
                                 $ref: '#/components/schemas/ErrorResponse'
-                    description: |
-                        Invalid request — no fields provided, or `preview_id` is the zero UUID
-                        (`INVALID_PREVIEW_ID`).
+                    description: Invalid request (no fields provided)
                 "401":
                     content:
                         application/json:
@@ -1809,10 +1812,7 @@ paths:
                         application/json:
                             schema:
                                 $ref: '#/components/schemas/ErrorResponse'
-                    description: |
-                        Asset not found — returned both when the asset being updated does
-                        not exist and when `preview_id` does not reference an asset
-                        accessible to the caller.
+                    description: Asset not found
                 "500":
                     content:
                         application/json: