Add io.List input

README.md

@@ -364,7 +364,7 @@ For models compatible with Iluvatar Extension for PyTorch. Here's a step-by-step
 | Flag | Description |
 |------|-------------|
 | `--enable-manager` | Enable ComfyUI-Manager |
-| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (implies `--enable-manager`) |
+| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (requires `--enable-manager`) |
 | `--disable-manager-ui` | Disable the manager UI and endpoints while keeping background features like security checks and scheduled installation completion (requires `--enable-manager`) |
 
 

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.")
@@ -134,7 +133,7 @@ upcast.add_argument("--dont-upcast-attention", action="store_true", help="Disabl
 parser.add_argument("--enable-manager", action="store_true", help="Enable the ComfyUI-Manager feature.")
 manager_group = parser.add_mutually_exclusive_group()
 manager_group.add_argument("--disable-manager-ui", action="store_true", help="Disables only the ComfyUI-Manager UI and endpoints. Scheduled installations and similar background tasks will still operate.")
-manager_group.add_argument("--enable-manager-legacy-ui", action="store_true", help="Enables the legacy UI of ComfyUI-Manager. Implies --enable-manager.")
+manager_group.add_argument("--enable-manager-legacy-ui", action="store_true", help="Enables the legacy UI of ComfyUI-Manager")
 
 
 vram_group = parser.add_mutually_exclusive_group()
@@ -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
 
@@ -262,10 +258,6 @@ if args.disable_auto_launch:
 if args.force_fp16:
     args.fp16_unet = True
 
-# '--enable-manager-legacy-ui' is meaningless unless the manager is enabled, so imply '--enable-manager'.
-if args.enable_manager_legacy_ui:
-    args.enable_manager = True
-
 
 # '--fast' is not provided, use an empty set
 if args.fast is None:

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/latest/_io.py

@@ -1253,6 +1253,140 @@ class DynamicSlot(ComfyTypeI):
             out_dict[input_type][finalized_id] = value
             out_dict["dynamic_paths"][finalized_id] = finalize_prefix(curr_prefix, curr_prefix[-1])
 
+@comfytype(io_type="COMFY_LIST_V3")
+class List(ComfyTypeI):
+    """A repeatable group of widget inputs (e.g. lora_name + strength stacked into N rows).
+
+    At execution time the node receives a ``list[dict]`` where each element is a row.
+
+    Example::
+
+        io.List.Input(
+            "loras",
+            template=[
+                io.Combo.Input("lora_name", options=folder_paths.get_filename_list("loras")),
+                io.Float.Input("strength", default=1.0, min=-100, max=100, step=0.01),
+            ],
+            min=0,
+            max=50,
+        )
+        # execute receives: loras: list[dict] = [{"lora_name": "x.safetensors", "strength": 1.0}, ...]
+    """
+
+    Type = list[dict[str, Any]]
+    _MaxRows = 100
+
+    class Input(DynamicInput):
+        def __init__(
+            self,
+            id: str,
+            template: list["Input"],
+            min: int = 0,
+            max: int = 50,
+            display_name: str = None,
+            optional: bool = False,
+            tooltip: str = None,
+            lazy: bool = None,
+            extra_dict=None,
+        ):
+            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)
+            # Validate template entries: only WidgetInput subclasses, no nesting
+            assert len(template) > 0, "List template must have at least one field."
+            for t in template:
+                assert isinstance(t, WidgetInput), (
+                    f"List template field '{t.id}' must be a WidgetInput subclass "
+                    f"(Combo, Float, Int, String, Boolean, Color). Got {type(t).__name__}."
+                )
+                assert not isinstance(t, DynamicInput), (
+                    f"List template field '{t.id}' must not be a DynamicInput. "
+                    "Nesting dynamic inputs inside List is not supported."
+                )
+            # Enforce unique field ids within template
+            field_ids = [t.id for t in template]
+            assert len(field_ids) == len(set(field_ids)), (
+                f"List template field ids must be unique within a row. Got: {field_ids}"
+            )
+            assert min >= 0, "List min must be >= 0."
+            assert max >= 1, "List max must be >= 1."
+            assert max <= List._MaxRows, f"List max must be <= {List._MaxRows}."
+            assert min <= max, "List min must be <= max."
+            self.template = template
+            self.min = min
+            self.max = max
+
+        def get_all(self) -> list["Input"]:
+            return [self] + list(self.template)
+
+        def as_dict(self):
+            return super().as_dict() | prune_dict({
+                "template": create_input_dict_v1(self.template),
+                "min": self.min,
+                "max": self.max,
+            })
+
+        def validate(self):
+            for t in self.template:
+                t.validate()
+
+    @staticmethod
+    def _expand_schema_for_dynamic(
+        out_dict: dict[str, Any],
+        live_inputs: dict[str, Any],
+        value: tuple[str, dict[str, Any]],
+        input_type: str,
+        curr_prefix: list[str] | None,
+    ):
+        info = value[1]
+        min_rows: int = info.get("min", 0)
+        template: dict[str, Any] = info.get("template", {})
+
+        # Collect all template field specs across required/optional sections
+        field_specs: list[tuple[str, tuple[str, dict[str, Any]], bool]] = []
+        for field_required_key in ("required", "optional"):
+            section = template.get(field_required_key, {})
+            is_required_field = field_required_key == "required"
+            for field_id, field_value in section.items():
+                field_specs.append((field_id, field_value, is_required_field))
+
+        # Determine how many rows are currently present by scanning live_inputs
+        finalized_prefix = finalize_prefix(curr_prefix)
+        present_rows = 0
+        for live_key in live_inputs:
+            # Keys look like "<prefix>.<row>.<field_id>"
+            if live_key.startswith(finalized_prefix + "."):
+                remainder = live_key[len(finalized_prefix) + 1:]
+                parts = remainder.split(".", 1)
+                if len(parts) >= 1:
+                    try:
+                        row_idx = int(parts[0])
+                        present_rows = max(present_rows, row_idx + 1)
+                    except ValueError:
+                        pass
+
+        row_count = max(min_rows, present_rows)
+
+        for row in range(row_count):
+            for field_id, field_value, is_required_field in field_specs:
+                slot_id = f"{finalized_prefix}.{row}.{field_id}"
+                # The first `min_rows` rows are required if the field itself is required
+                if row < min_rows and is_required_field:
+                    out_dict["required"][slot_id] = field_value
+                else:
+                    out_dict["optional"][slot_id] = field_value
+                # Register into dynamic_paths so build_nested_inputs places value at the right path
+                out_dict["dynamic_paths"][slot_id] = slot_id
+
+        # Track the list root path so build_nested_inputs can convert the index dict to a list
+        out_dict.setdefault("list_paths", set()).add(finalized_prefix)
+
+        # Handle the empty case (0 rows) – emit an empty-list default for the parent.
+        # This must only fire when there are genuinely no rows; otherwise the parent
+        # path would clobber the per-row dict built from the slot ids above.
+        if row_count == 0:
+            out_dict["dynamic_paths"][finalized_prefix] = finalized_prefix
+            out_dict["dynamic_paths_default_value"][finalized_prefix] = DynamicPathsDefaultValue.EMPTY_LIST
+
+
 @comfytype(io_type="IMAGECOMPARE")
 class ImageCompare(ComfyTypeI):
   Type = dict
@@ -1383,6 +1517,8 @@ def setup_dynamic_input_funcs():
     register_dynamic_input_func(DynamicCombo.io_type, DynamicCombo._expand_schema_for_dynamic)
     # DynamicSlot.Input
     register_dynamic_input_func(DynamicSlot.io_type, DynamicSlot._expand_schema_for_dynamic)
+    # List.Input
+    register_dynamic_input_func(List.io_type, List._expand_schema_for_dynamic)
 
 if len(DYNAMIC_INPUT_LOOKUP) == 0:
     setup_dynamic_input_funcs()
@@ -1394,14 +1530,15 @@ class V3Data(TypedDict):
     'Dictionary where the keys are the input ids and the values dictate how to turn the inputs into a nested dictionary.'
     dynamic_paths_default_value: dict[str, Any]
     'Dictionary where the keys are the input ids and the values are a string from DynamicPathsDefaultValue for the inputs if value is None.'
+    list_paths: set[str]
+    'Set of top-level keys whose index-keyed dict values should be converted to a sorted list[dict] after build_nested_inputs runs.'
     create_dynamic_tuple: bool
     'When True, the value of the dynamic input will be in the format (value, path_key).'
 
 class HiddenHolder:
     def __init__(self, unique_id: str, prompt: Any,
                  extra_pnginfo: Any, dynprompt: Any,
-                 auth_token_comfy_org: str, api_key_comfy_org: str,
-                 comfy_usage_source: str = None, **kwargs):
+                 auth_token_comfy_org: str, api_key_comfy_org: str, **kwargs):
         self.unique_id = unique_id
         """UNIQUE_ID is the unique identifier of the node, and matches the id property of the node on the client side. It is commonly used in client-server communications (see messages)."""
         self.prompt = prompt
@@ -1414,8 +1551,6 @@ class HiddenHolder:
         """AUTH_TOKEN_COMFY_ORG is a token acquired from signing into a ComfyOrg account on frontend."""
         self.api_key_comfy_org = api_key_comfy_org
         """API_KEY_COMFY_ORG is an API Key generated by ComfyOrg that allows skipping signing into a ComfyOrg account on frontend."""
-        self.comfy_usage_source = comfy_usage_source
-        """COMFY_USAGE_SOURCE identifies the client that submitted the prompt (e.g. comfyui-frontend, comfy-cli, comfyui-mcp); forwarded to API nodes' upstream requests via the Comfy-Usage-Source header."""
 
     def __getattr__(self, key: str):
         '''If hidden variable not found, return None.'''
@@ -1432,7 +1567,6 @@ class HiddenHolder:
             dynprompt=d.get(Hidden.dynprompt, None),
             auth_token_comfy_org=d.get(Hidden.auth_token_comfy_org, None),
             api_key_comfy_org=d.get(Hidden.api_key_comfy_org, None),
-            comfy_usage_source=d.get(Hidden.comfy_usage_source, None),
         )
 
     @classmethod
@@ -1455,8 +1589,6 @@ class Hidden(str, Enum):
     """AUTH_TOKEN_COMFY_ORG is a token acquired from signing into a ComfyOrg account on frontend."""
     api_key_comfy_org = "API_KEY_COMFY_ORG"
     """API_KEY_COMFY_ORG is an API Key generated by ComfyOrg that allows skipping signing into a ComfyOrg account on frontend."""
-    comfy_usage_source = "COMFY_USAGE_SOURCE"
-    """COMFY_USAGE_SOURCE identifies the client that submitted the prompt (e.g. comfyui-frontend, comfy-cli, comfyui-mcp); forwarded to API nodes' upstream requests via the Comfy-Usage-Source header."""
 
 
 @dataclass
@@ -1660,8 +1792,6 @@ class Schema:
                 self.hidden.append(Hidden.auth_token_comfy_org)
             if Hidden.api_key_comfy_org not in self.hidden:
                 self.hidden.append(Hidden.api_key_comfy_org)
-            if Hidden.comfy_usage_source not in self.hidden:
-                self.hidden.append(Hidden.comfy_usage_source)
         # if is an output_node, will need prompt and extra_pnginfo
         if self.is_output_node:
             if Hidden.prompt not in self.hidden:
@@ -1735,6 +1865,7 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
         "optional": {},
         "dynamic_paths": {},
         "dynamic_paths_default_value": {},
+        "list_paths": set(),
     }
     d = d.copy()
     # ignore hidden for parsing
@@ -1750,6 +1881,10 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
     dynamic_paths_default_value = out_dict.pop("dynamic_paths_default_value", None)
     if dynamic_paths_default_value is not None and len(dynamic_paths_default_value) > 0:
         v3_data["dynamic_paths_default_value"] = dynamic_paths_default_value
+    # list_paths: keys whose nested dict should be post-converted to a sorted list[dict]
+    list_paths = out_dict.pop("list_paths", None)
+    if list_paths:
+        v3_data["list_paths"] = list_paths
     return out_dict, hidden, v3_data
 
 def parse_class_inputs(out_dict: dict[str, Any], live_inputs: dict[str, Any], curr_dict: dict[str, Any], curr_prefix: list[str] | None=None) -> None:
@@ -1785,10 +1920,12 @@ def add_to_dict_v1(i: Input, d: dict):
 
 class DynamicPathsDefaultValue:
     EMPTY_DICT = "empty_dict"
+    EMPTY_LIST = "empty_list"
 
 def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
     paths = v3_data.get("dynamic_paths", None)
     default_value_dict = v3_data.get("dynamic_paths_default_value", {})
+    list_paths: set[str] = v3_data.get("list_paths", set()) or set()
     if paths is None:
         return values
     values = values.copy()
@@ -1811,6 +1948,8 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                     default_option = default_value_dict.get(key, None)
                     if default_option == DynamicPathsDefaultValue.EMPTY_DICT:
                         value = {}
+                    elif default_option == DynamicPathsDefaultValue.EMPTY_LIST:
+                        value = []
                 if create_tuple:
                     value = (value, key)
                 current[p] = value
@@ -1818,6 +1957,34 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                 current = current.setdefault(p, {})
 
     values.update(result)
+
+    # Post-pass: convert index-keyed dicts to sorted lists for io.List fields
+    for list_path in list_paths:
+        parts = list_path.split(".")
+        # Navigate to the parent container, then convert the leaf
+        container = values
+        for part in parts[:-1]:
+            if not isinstance(container, dict) or part not in container:
+                container = None
+                break
+            container = container[part]
+        if container is None:
+            continue
+        leaf_key = parts[-1]
+        leaf = container.get(leaf_key, None)
+        if isinstance(leaf, dict):
+            try:
+                sorted_rows = [leaf[k] for k in sorted(leaf.keys(), key=int)]
+                container[leaf_key] = sorted_rows
+            except (ValueError, TypeError):
+                # Keys are not all integers; leave as-is
+                pass
+        elif isinstance(leaf, list):
+            # Already a list (e.g. the EMPTY_LIST default was applied above)
+            pass
+        elif leaf is None:
+            container[leaf_key] = []
+
     return values
 
 
@@ -2380,7 +2547,9 @@ __all__ = [
     # Dynamic Types
     "MatchType",
     "DynamicCombo",
+    "DynamicSlot",
     "Autogrow",
+    "List",
     # Other classes
     "HiddenHolder",
     "Hidden",

comfy_api_nodes/apis/__init__.py

@@ -1310,6 +1310,13 @@ class KlingTaskStatus(str, Enum):
     failed = 'failed'
 
 
+class KlingTextToVideoModelName(str, Enum):
+    kling_v1 = 'kling-v1'
+    kling_v1_6 = 'kling-v1-6'
+    kling_v2_1_master = 'kling-v2-1-master'
+    kling_v2_5_turbo = 'kling-v2-5-turbo'
+
+
 class KlingVideoGenAspectRatio(str, Enum):
     field_16_9 = '16:9'
     field_9_16 = '9:16'
@@ -5172,7 +5179,7 @@ class KlingText2VideoRequest(BaseModel):
     duration: Optional[KlingVideoGenDuration] = '5'
     external_task_id: Optional[str] = Field(None, description='Customized Task ID')
     mode: Optional[KlingVideoGenMode] = 'std'
-    model_name: Optional[str] = 'kling-v1'
+    model_name: Optional[KlingTextToVideoModelName] = 'kling-v1'
     negative_prompt: Optional[str] = Field(
         None, description='Negative text prompt', max_length=2500
     )

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_bria.py

@@ -289,7 +289,7 @@ class BriaRemoveVideoBackground(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.0042,"format":{"suffix":"/second"}}""",
+                expr="""{"type":"usd","usd":0.14,"format":{"suffix":"/second"}}""",
             ),
         )
 
@@ -357,7 +357,7 @@ class BriaVideoGreenScreen(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.0042,"format":{"suffix":"/second"}}""",
+                expr="""{"type":"usd","usd":0.14,"format":{"suffix":"/second"}}""",
             ),
         )
 
@@ -433,7 +433,7 @@ class BriaVideoReplaceBackground(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.0042,"format":{"suffix":"/second"}}""",
+                expr="""{"type":"usd","usd":0.14,"format":{"suffix":"/second"}}""",
             ),
         )
 
@@ -452,10 +452,7 @@ class BriaVideoReplaceBackground(IO.ComfyNode):
             validate_video_duration(background_video, max_duration=60.0)
             background_url = await upload_video_to_comfyapi(cls, background_video, wait_label="Uploading background")
         else:
-            # Bria's replace_background 500s on RGBA, so drop the alpha channel before upload.
-            background_url = await upload_image_to_comfyapi(
-                cls, background_image[:, :, :, :3], wait_label="Uploading background"
-            )
+            background_url = await upload_image_to_comfyapi(cls, background_image, wait_label="Uploading background")
         response = await sync_op(
             cls,
             ApiEndpoint(path="/proxy/bria/v2/video/edit/replace_background", method="POST"),
@@ -533,7 +530,7 @@ class BriaTransparentVideoBackground(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.0042,"format":{"suffix":"/second"}}""",
+                expr="""{"type":"usd","usd":0.14,"format":{"suffix":"/second"}}""",
             ),
         )
 
@@ -574,7 +571,7 @@ class BriaExtension(ComfyExtension):
             BriaRemoveImageBackground,
             BriaRemoveVideoBackground,
             BriaVideoGreenScreen,
-            BriaVideoReplaceBackground,
+            # BriaVideoReplaceBackground,  # server returns Status 500 when we pass background video
             BriaTransparentVideoBackground,
         ]
 

comfy_api_nodes/nodes_kling.py

@@ -436,7 +436,7 @@ async def execute_text2video(
             negative_prompt=negative_prompt if negative_prompt else None,
             duration=KlingVideoGenDuration(duration),
             mode=KlingVideoGenMode(model_mode),
-            model_name=model_name,
+            model_name=KlingVideoGenModelName(model_name),
             cfg_scale=cfg_scale,
             aspect_ratio=KlingVideoGenAspectRatio(aspect_ratio),
             camera_control=camera_control,

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,
         ]
 
 

comfy_api_nodes/nodes_sonilo.py

@@ -16,7 +16,7 @@ from comfy_api_nodes.util import (
 )
 from comfy_api_nodes.util._helpers import (
     default_base_url,
-    get_comfy_api_headers,
+    get_auth_header,
     get_node_id,
     is_processing_interrupted,
 )
@@ -174,7 +174,8 @@ async def _stream_sonilo_music(
     """POST ``form`` to Sonilo, read the NDJSON stream, and return the first stream's audio bytes."""
     url = urljoin(default_base_url().rstrip("/") + "/", endpoint.path.lstrip("/"))
 
-    headers = get_comfy_api_headers(cls)
+    headers: dict[str, str] = {}
+    headers.update(get_auth_header(cls))
     headers.update(endpoint.headers)
 
     node_id = get_node_id(cls)

comfy_api_nodes/util/_helpers.py

@@ -9,7 +9,6 @@ from io import BytesIO
 from yarl import URL
 
 from comfy.cli_args import args
-from comfy.deploy_environment import get_deploy_environment
 from comfy.model_management import processing_interrupted
 from comfy_api.latest import IO
 
@@ -36,30 +35,6 @@ def get_auth_header(node_cls: type[IO.ComfyNode]) -> dict[str, str]:
     return {}
 
 
-def get_usage_source(node_cls: type[IO.ComfyNode]) -> str:
-    """Source of the prompt that triggered this API node.
-
-    Defaults to "comfyui-api" when the submitting client didn't identify itself,
-    i.e. a direct API call to this server.
-    """
-    return node_cls.hidden.comfy_usage_source or "comfyui-api"
-
-
-def get_comfy_api_headers(node_cls: type[IO.ComfyNode]) -> dict[str, str]:
-    """Common headers (auth, deploy environment, usage source) for Comfy API requests.
-
-    Centralizes the shared header set so every Comfy API request sends a consistent
-    set and new shared headers only need to be added in one place. Intended for
-    relative/cloud URLs resolved against ``default_base_url()``; because the result
-    includes auth, callers must not attach it to arbitrary absolute/presigned URLs.
-    """
-    return {
-        **get_auth_header(node_cls),
-        "Comfy-Env": get_deploy_environment(),
-        "Comfy-Usage-Source": get_usage_source(node_cls),
-    }
-
-
 def default_base_url() -> str:
     return getattr(args, "comfy_api_base", "https://api.comfy.org")
 

comfy_api_nodes/util/client.py

@@ -19,10 +19,12 @@ from comfy import utils
 from comfy_api.latest import IO
 from server import PromptServer
 
+from comfy.deploy_environment import get_deploy_environment
+
 from . import request_logger
 from ._helpers import (
     default_base_url,
-    get_comfy_api_headers,
+    get_auth_header,
     get_node_id,
     is_processing_interrupted,
     sleep_with_interrupt,
@@ -643,7 +645,8 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
 
         payload_headers = {"Accept": "*/*"} if expect_binary else {"Accept": "application/json"}
         if not parsed_url.scheme and not parsed_url.netloc:  # is URL relative?
-            payload_headers.update(get_comfy_api_headers(cfg.node_cls))
+            payload_headers.update(get_auth_header(cfg.node_cls))
+            payload_headers["Comfy-Env"] = get_deploy_environment()
         if cfg.endpoint.headers:
             payload_headers.update(cfg.endpoint.headers)
 

comfy_api_nodes/util/download_helpers.py

@@ -17,7 +17,7 @@ from folder_paths import get_output_directory
 from . import request_logger
 from ._helpers import (
     default_base_url,
-    get_comfy_api_headers,
+    get_auth_header,
     is_processing_interrupted,
     sleep_with_interrupt,
     to_aiohttp_url,
@@ -64,7 +64,7 @@ async def download_url_to_bytesio(
         if cls is None:
             raise ValueError("For relative 'cloud' paths, the `cls` parameter is required.")
         url = urljoin(default_base_url().rstrip("/") + "/", url.lstrip("/"))
-        headers = get_comfy_api_headers(cls)
+        headers = get_auth_header(cls)
 
     while True:
         attempt += 1

comfy_extras/nodes_flux.py

@@ -245,11 +245,6 @@ class KV_Attn_Input:
         cache_key = "{}_{}".format(extra_options["block_type"], extra_options["block_index"])
         if cache_key in self.cache:
             kk, vv = self.cache[cache_key]
-
-            # Fix batch size changing.
-            kk = comfy.utils.repeat_to_batch_size(kk, k.shape[0])
-            vv = comfy.utils.repeat_to_batch_size(vv, v.shape[0])
-
             self.set_cache = False
             return {"q": q, "k": torch.cat((k, kk), dim=2), "v": torch.cat((v, vv), dim=2)}
 

execution.py

@@ -200,8 +200,6 @@ def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=
                 hidden_inputs_v3[io.Hidden.auth_token_comfy_org] = extra_data.get("auth_token_comfy_org", None)
             if io.Hidden.api_key_comfy_org.name in hidden:
                 hidden_inputs_v3[io.Hidden.api_key_comfy_org] = extra_data.get("api_key_comfy_org", None)
-            if io.Hidden.comfy_usage_source.name in hidden:
-                hidden_inputs_v3[io.Hidden.comfy_usage_source] = extra_data.get("comfy_usage_source", None)
     else:
         if "hidden" in valid_inputs:
             h = valid_inputs["hidden"]
@@ -218,8 +216,6 @@ def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=
                     input_data_all[x] = [extra_data.get("auth_token_comfy_org", None)]
                 if h[x] == "API_KEY_COMFY_ORG":
                     input_data_all[x] = [extra_data.get("api_key_comfy_org", None)]
-                if h[x] == "COMFY_USAGE_SOURCE":
-                    input_data_all[x] = [extra_data.get("comfy_usage_source", None)]
     v3_data["hidden_inputs"] = hidden_inputs_v3
     return input_data_all, missing_keys, v3_data
 

server.py

@@ -971,11 +971,6 @@ class PromptServer():
 
                 if "client_id" in json_data:
                     extra_data["client_id"] = json_data["client_id"]
-
-                if "comfy_usage_source" not in extra_data:
-                    usage_source = request.headers.get("Comfy-Usage-Source")
-                    if usage_source:
-                        extra_data["comfy_usage_source"] = usage_source
                 if valid[0]:
                     outputs_to_execute = valid[2]
                     sensitive = {}

tests-unit/comfy_api_test/io_list_test.py

@@ -0,0 +1,204 @@
+"""Unit tests for io.List: expansion/reconstruction (0-row and N-row cases)."""
+import sys
+import types
+import pytest
+
+# Stub torch (type-hint only in _io.py; real torch not available in unit-test env)
+if "torch" not in sys.modules:
+    _torch_stub = types.ModuleType("torch")
+    _torch_stub.Tensor = object  # type: ignore[attr-defined]
+    sys.modules["torch"] = _torch_stub
+
+from comfy_api.latest._io import (  # noqa: E402
+    List,
+    Float,
+    Int,
+    String,
+    Boolean,
+    get_finalized_class_inputs,
+    build_nested_inputs,
+    create_input_dict_v1,
+    setup_dynamic_input_funcs,
+)
+
+# Make sure dynamic input funcs are registered (may already be done at import time)
+setup_dynamic_input_funcs()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_class_inputs(list_input: List.Input) -> dict:
+    """Wrap a List.Input into the required/optional dict structure."""
+    return create_input_dict_v1([list_input])
+
+
+def _run(list_input: List.Input, live_values: dict) -> dict:
+    """End-to-end helper: expand schema + reconstruct values.
+
+    Mirrors the production split in execution.py:
+      1. get_finalized_class_inputs  (schema expansion, line 162)
+      2. build_nested_inputs          (value reconstruction, line 281)
+
+    The two steps are separate in production because the engine resolves
+    linked node outputs between them, but in tests we supply values directly.
+    """
+    class_inputs = _make_class_inputs(list_input)
+    _, _, v3_data = get_finalized_class_inputs(class_inputs, live_values)
+    return build_nested_inputs(dict(live_values), v3_data)
+
+
+# ---------------------------------------------------------------------------
+# Schema construction
+# ---------------------------------------------------------------------------
+
+class TestListInputConstruction:
+    def test_basic_construction(self):
+        inp = List.Input(
+            "loras",
+            template=[
+                Float.Input("strength", default=1.0),
+                String.Input("name"),
+            ],
+            min=0,
+            max=10,
+        )
+        assert inp.id == "loras"
+        assert inp.min == 0
+        assert inp.max == 10
+        assert len(inp.template) == 2
+
+    def test_get_all_includes_self_and_template(self):
+        inp = List.Input(
+            "items",
+            template=[Float.Input("value")],
+        )
+        all_inputs = inp.get_all()
+        assert all_inputs[0] is inp
+        assert all_inputs[1].id == "value"
+
+    def test_as_dict_has_template_min_max(self):
+        inp = List.Input(
+            "items",
+            template=[Float.Input("val", default=0.5)],
+            min=1,
+            max=5,
+        )
+        d = inp.as_dict()
+        assert "template" in d
+        assert d["min"] == 1
+        assert d["max"] == 5
+
+    def test_duplicate_field_ids_raises(self):
+        with pytest.raises(AssertionError):
+            List.Input(
+                "bad",
+                template=[Float.Input("x"), Float.Input("x")],
+            )
+
+    def test_empty_template_raises(self):
+        with pytest.raises(AssertionError):
+            List.Input("bad", template=[])
+
+    def test_min_gt_max_raises(self):
+        with pytest.raises(AssertionError):
+            List.Input("bad", template=[Float.Input("x")], min=5, max=3)
+
+    def test_max_exceeds_limit_raises(self):
+        with pytest.raises(AssertionError):
+            List.Input("bad", template=[Float.Input("x")], max=101)
+
+    def test_dynamic_input_in_template_raises(self):
+        with pytest.raises(AssertionError):
+            List.Input(
+                "bad",
+                template=[List.Input("nested", template=[Float.Input("x")])],
+            )
+
+    def test_validate_calls_through(self):
+        inp = List.Input("items", template=[Float.Input("val", min=-1.0, max=1.0)])
+        inp.validate()  # should not raise
+
+
+# ---------------------------------------------------------------------------
+# 0-row case
+# ---------------------------------------------------------------------------
+
+class TestZeroRows:
+    def test_empty_live_inputs_produces_empty_list(self):
+        """With min=0 and no live values, the result should be an empty list."""
+        inp = List.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        assert _run(inp, {}).get("loras") == []
+
+    def test_min_zero_with_values(self):
+        """min=0 but 2 rows of live data."""
+        inp = List.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        result = _run(inp, {"loras.0.strength": 0.8, "loras.1.strength": 0.5})
+        assert result["loras"] == [{"strength": 0.8}, {"strength": 0.5}]
+
+
+# ---------------------------------------------------------------------------
+# N-row case
+# ---------------------------------------------------------------------------
+
+class TestNRows:
+    def test_two_rows_two_fields(self):
+        """Two rows with two fields each produce a list[dict]."""
+        inp = List.Input(
+            "loras",
+            template=[String.Input("lora_name"), Float.Input("strength", default=1.0)],
+            min=0, max=50,
+        )
+        result = _run(inp, {
+            "loras.0.lora_name": "model_a.safetensors", "loras.0.strength": 0.9,
+            "loras.1.lora_name": "model_b.safetensors", "loras.1.strength": 0.4,
+        })
+        assert result["loras"] == [
+            {"lora_name": "model_a.safetensors", "strength": 0.9},
+            {"lora_name": "model_b.safetensors", "strength": 0.4},
+        ]
+
+    def test_rows_are_sorted_by_index(self):
+        """Rows must be in ascending index order even if dict iteration is unordered."""
+        inp = List.Input("items", template=[Int.Input("v", default=0)], min=0, max=10)
+        result = _run(inp, {"items.0.v": 10, "items.2.v": 30, "items.1.v": 20})
+        assert [row["v"] for row in result["items"]] == [10, 20, 30]
+
+    def test_min_rows_schema_slots(self):
+        """With min=2 and no live data, 2 slots must appear in the expanded schema."""
+        inp = List.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        out, _, _ = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        all_slots = {**out.get("required", {}), **out.get("optional", {})}
+        assert "items.0.val" in all_slots
+        assert "items.1.val" in all_slots
+
+    def test_min_rows_reconstructs_when_no_values(self):
+        """min=2 with NO live values must still yield a 2-element list,
+        not collapse to [] (regression: parent-path clobber)."""
+        inp = List.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {})
+        assert len(result["items"]) == 2
+        assert all("val" in row for row in result["items"])
+
+    def test_min_rows_reconstructs_with_partial_values(self):
+        """min=2 with only the first row's value present still yields 2 rows."""
+        inp = List.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {"items.0.val": 0.7})
+        assert len(result["items"]) == 2
+        assert result["items"][0]["val"] == 0.7
+        assert result["items"][1]["val"] is None
+
+    def test_list_paths_in_v3_data(self):
+        """list_paths must contain the list id so build_nested_inputs knows to convert."""
+        inp = List.Input("things", template=[Boolean.Input("flag")], min=0, max=5)
+        _, _, v3_data = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        assert "things" in v3_data.get("list_paths", set())
+
+    def test_no_leftover_flat_keys(self):
+        """Flat keys must be consumed; only the reconstructed list remains."""
+        inp = List.Input("rows", template=[Float.Input("x", default=0.0)], min=0, max=5)
+        result = _run(inp, {"rows.0.x": 1.0, "rows.1.x": 2.0})
+        assert "rows.0.x" not in result
+        assert "rows.1.x" not in result
+        assert isinstance(result["rows"], list)