test(assets): make seed content unique per test for isolation

Removing the delete_content param means delete is always a soft delete, so
content created by one test now survives into the next. The suite had been
relying on hard-delete teardown for isolation, so shared fixed-content
fixtures started colliding: seeded_asset (b"A"*4096) and
make_asset_bytes (deterministic on name) produced the same hash every test,
so the second seed deduped to the surviving asset and returned 200 instead
of 201, cascading into ~14 failures/errors.

Salt both fixtures with a per-test uuid so each test creates fresh content
(created_new True, 201), while keeping content deterministic within a test
(same name/size -> same bytes) and preserving exact byte length so size-based
list/sort assertions are unaffected.

README.md

@@ -462,6 +462,16 @@ To use the most up-to-date frontend version:
 
 This approach allows you to easily switch between the stable fortnightly release and the cutting-edge daily updates, or even specific versions for testing purposes.
 
+### Accessing the Legacy Frontend
+
+If you need to use the legacy frontend for any reason, you can access it using the following command line argument:
+
+```
+--front-end-version Comfy-Org/ComfyUI_legacy_frontend@latest
+```
+
+This will use a snapshot of the legacy frontend preserved in the [ComfyUI Legacy Frontend repository](https://github.com/Comfy-Org/ComfyUI_legacy_frontend).
+
 # QA
 
 ### Which GPU should I buy for this?

comfy/model_base.py

@@ -1816,24 +1816,7 @@ class WAN21_SCAIL2(WAN21_SCAIL):
 
     def resize_cond_for_context_window(self, cond_key, cond_value, window, x_in, device, retain_index_list=[]):
         if cond_key in ("sam_latents", "pose_latents"):
-            # Return sliced view omitting retain_index_list
-            return comfy.context_windows.slice_cond(cond_value, window, x_in, device, temporal_dim=2, temporal_offset=0)
-        if cond_key == "ref_mask_latents" and hasattr(cond_value, "cond") and isinstance(cond_value.cond, torch.Tensor):
-            # The ref mask is just a single frame padded with frames of zeros, so just grab the first frames for all windows
-            full_ref_mask = cond_value.cond
-            video_frame_count = x_in.shape[2]
-            if full_ref_mask.shape[2] != video_frame_count + 1:
-                return None
-            window_length = len(window.index_list)
-
-            # Account for the causal anchor frame if it exists
-            anchor_index = getattr(window, "causal_anchor_index", None)
-            if anchor_index is not None and anchor_index >= 0:
-                window_length += 1
-
-            window_ref_mask = full_ref_mask[:, :, :window_length + 1].to(device)
-            return cond_value._copy_with(window_ref_mask)
-
+            return comfy.context_windows.slice_cond(cond_value, window, x_in, device, temporal_dim=2, temporal_offset=1)
         return super().resize_cond_for_context_window(cond_key, cond_value, window, x_in, device, retain_index_list=retain_index_list)
 
     def concat_cond(self, **kwargs):

comfy/model_management.py

@@ -534,10 +534,8 @@ try:
 except:
     pass
 
-
-def set_cudnn_benchmark():
-    if torch.cuda.is_available() and torch.backends.cudnn.is_available():
-        torch.backends.cudnn.benchmark = PerformanceFeature.AutoTune in args.fast
+if torch.cuda.is_available() and torch.backends.cudnn.is_available() and PerformanceFeature.AutoTune in args.fast:
+    torch.backends.cudnn.benchmark = True
 
 try:
     if torch_version_numeric >= (2, 5):

comfy/ops.py

@@ -299,21 +299,21 @@ def cast_bias_weight(s, input=None, dtype=None, device=None, bias_dtype=None, of
 
     non_blocking = comfy.model_management.device_supports_non_blocking(device)
 
-    if hasattr(s, "_v") and comfy.model_management.is_device_cpu(device):
+    if hasattr(s, "_v"):
 
         #vbar doesn't support CPU weights, but some custom nodes have weird paths
         #that might switch the layer to the CPU and expect it to work. We have to take
         #a clone conservatively as we are mmapped and some SFT files are packed misaligned
         #If you are a custom node author reading this, please move your layer to the GPU
         #or declare your ModelPatcher as CPU in the first place.
-        materialize_meta_param(s, ["weight", "bias"])
-        weight = s.weight.to(dtype=dtype, copy=True)
-        if isinstance(weight, QuantizedTensor):
-            weight = weight.dequantize()
-        bias = s.bias.to(dtype=bias_dtype, copy=True) if s.bias is not None else None
-        return format_return((weight, bias, (None, None, None)), offloadable)
+        if comfy.model_management.is_device_cpu(device):
+            materialize_meta_param(s, ["weight", "bias"])
+            weight = s.weight.to(dtype=dtype, copy=True)
+            if isinstance(weight, QuantizedTensor):
+                weight = weight.dequantize()
+            bias = s.bias.to(dtype=bias_dtype, copy=True) if s.bias is not None else None
+            return format_return((weight, bias, (None, None, None)), offloadable)
 
-    elif hasattr(s, "_v") and s.weight.device != device:
         prefetched = hasattr(s, "_prefetch")
         offload_stream = None
         offload_device = None

comfy_api/latest/_io.py

@@ -1253,140 +1253,6 @@ 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
@@ -1517,8 +1383,6 @@ 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()
@@ -1530,8 +1394,6 @@ 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).'
 
@@ -1865,7 +1727,6 @@ 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
@@ -1881,10 +1742,6 @@ 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:
@@ -1920,12 +1777,10 @@ 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()
@@ -1948,8 +1803,6 @@ 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
@@ -1957,34 +1810,6 @@ 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
 
 
@@ -2547,9 +2372,7 @@ __all__ = [
     # Dynamic Types
     "MatchType",
     "DynamicCombo",
-    "DynamicSlot",
     "Autogrow",
-    "List",
     # Other classes
     "HiddenHolder",
     "Hidden",

comfy_api_nodes/nodes_openai.py

@@ -9,7 +9,6 @@ from PIL import Image
 from typing_extensions import override
 
 import folder_paths
-from comfy.utils import common_upscale
 from comfy_api.latest import IO, ComfyExtension, Input
 from comfy_api_nodes.apis.openai import (
     InputFileContent,
@@ -63,8 +62,7 @@ async def validate_and_cast_response(response, timeout: int = None) -> torch.Ten
         timeout: Request timeout in seconds. Defaults to None (no timeout).
 
     Returns:
-        A torch.Tensor of shape (N, H, W, C) with all returned images; images whose
-        dimensions differ from the first image's are resized to match it.
+        A torch.Tensor representing the image (1, H, W, C).
 
     Raises:
         ValueError: If the response is not valid.
@@ -91,14 +89,6 @@ async def validate_and_cast_response(response, timeout: int = None) -> torch.Ten
         arr = np.asarray(pil_img).astype(np.float32) / 255.0
         image_tensors.append(torch.from_numpy(arr))
 
-    # With size="auto" the API can return images whose dimensions differ by a few pixels within a single response
-    # resize them to the first image's dimensions so they can be stacked into one batch.
-    ref_h, ref_w = image_tensors[0].shape[:2]
-    for i, t in enumerate(image_tensors):
-        if t.shape[:2] != (ref_h, ref_w):
-            samples = t.unsqueeze(0).movedim(-1, 1)
-            samples = common_upscale(samples, ref_w, ref_h, "bilinear", "center")
-            image_tensors[i] = samples.movedim(1, -1).squeeze(0)
     return torch.stack(image_tensors, dim=0)
 
 

comfy_execution/asset_enrichment.py

@@ -1,66 +0,0 @@
-"""Enrich executed-node output entries with asset id."""
-import logging
-import os
-
-
-def enrich_output_with_assets(output_ui: dict) -> dict:
-    """Register file-type output entries as assets and inject their ``id``.
-
-    Runs at output-processing time, once per produced output, when
-    --enable-assets is set. Returns a new dict; entries without a resolvable
-    on-disk file path are left unchanged. Errors are caught per-entry so a
-    failure never blocks execution or the other entries.
-    """
-    from comfy.cli_args import args
-    if not args.enable_assets:
-        return output_ui
-
-    import folder_paths
-    from app.assets.services.ingest import register_file_in_place, DependencyMissingError
-
-    enriched = {}
-    for key, entries in output_ui.items():
-        if not isinstance(entries, list):
-            enriched[key] = entries
-            continue
-        new_entries = []
-        for entry in entries:
-            if not isinstance(entry, dict) or "filename" not in entry or "type" not in entry:
-                new_entries.append(entry)
-                continue
-            try:
-                base = folder_paths.get_directory_by_type(entry["type"])
-                if base is None:
-                    new_entries.append(entry)
-                    continue
-                base_abs = os.path.abspath(base)
-                abs_path = os.path.abspath(os.path.join(base_abs, entry.get("subfolder") or "", entry["filename"]))
-                try:
-                    if os.path.commonpath([base_abs, abs_path]) != base_abs:
-                        raise ValueError("escapes base")
-                except ValueError:
-                    logging.warning("Asset enrichment skipped (path escapes base): %s", entry.get("filename"))
-                    new_entries.append(entry)
-                    continue
-                if not os.path.isfile(abs_path):
-                    new_entries.append(entry)
-                    continue
-
-                # Register unconditionally: the file was just produced, and
-                # register_file_in_place re-hashes so an overwritten path can
-                # never carry a stale id.
-                result = register_file_in_place(
-                    abs_path=abs_path,
-                    name=entry["filename"],
-                    tags=[entry["type"]],
-                )
-
-                entry = dict(entry)
-                entry["id"] = result.ref.id
-            except DependencyMissingError:
-                logging.warning("Asset enrichment skipped (blake3 not available): %s", entry.get("filename"))
-            except Exception:
-                logging.warning("Failed to enrich output entry with asset id: %s", entry.get("filename"), exc_info=True)
-            new_entries.append(entry)
-        enriched[key] = new_entries
-    return enriched

comfy_execution/jobs.py

@@ -3,7 +3,6 @@ Job utilities for the /api/jobs endpoint.
 Provides normalization and helper functions for job status tracking.
 """
 
-import uuid
 from typing import Optional
 
 from comfy_api.internal import prune_dict
@@ -20,25 +19,6 @@ class JobStatus:
     ALL = [PENDING, IN_PROGRESS, COMPLETED, FAILED, CANCELLED]
 
 
-def validate_job_id(value) -> str:
-    """Validate a client-supplied job (prompt) id.
-
-    Job ids must be UUIDs in the canonical lowercase hyphenated form. The id
-    is stored and compared verbatim everywhere downstream — history keys,
-    websocket events, and /interrupt matching — so accepting another spelling
-    would silently rewrite the client's id and then miss every exact-match
-    lookup. Rejecting loudly beats that.
-
-    Returns the id unchanged. Raises ValueError when the value is not a
-    string in canonical UUID form.
-    """
-    if not isinstance(value, str):
-        raise ValueError(f"job id must be a string, got {type(value).__name__}")
-    if str(uuid.UUID(value)) != value:
-        raise ValueError("job id must be a UUID in canonical lowercase hyphenated form")
-    return value
-
-
 # Media types that can be previewed in the frontend
 PREVIEWABLE_MEDIA_TYPES = frozenset({'images', 'video', 'audio', '3d', 'text'})
 

comfy_extras/nodes_scail.py

@@ -267,8 +267,7 @@ class SCAIL2ColoredMask(io.ComfyNode):
                 io.Combo.Input("sort_by", options=["none", "left_to_right", "area"], default="left_to_right",
                                tooltip="Order in which palette colors are assigned to the tracked objects (applied to both reference and pose video so each identity keeps the same color). left_to_right = leftmost object (by first-frame centroid) gets the first color; area = biggest object (by first-frame mask area) gets the first color; none = keep SAM3's order."),
                 io.Boolean.Input("replacement_mode", default=False,
-                                 tooltip="False = Animation Mode (pose_video_mask has black background, reference_image_mask has white background). "
-                                         "True = Replacement Mode (pose_video_mask has white background, reference_image_mask has black background)."),
+                                 tooltip="False = mask_video has black bg (Animation Mode). True = white bg (Replacement Mode). Set the matching replacement_mode on WanSCAILToVideo. reference_image_mask is always black-bg regardless."),
             ],
             outputs=[
                 io.Image.Output("pose_video_mask"),
@@ -297,17 +296,14 @@ class SCAIL2ColoredMask(io.ComfyNode):
             return td
 
         drv = _prep(driving_track_data)
-        # Animation: driving=black, ref=white. Replacement: driving=white, ref=black.
         mask_video = _render_colored_masks(drv, "white" if replacement_mode else "black")
-        ref_bg = "black" if replacement_mode else "white"
 
         if ref_track_data is not None:
             ref = _prep(ref_track_data)
-            reference_image_mask = _render_colored_masks(ref, ref_bg)
+            reference_image_mask = _render_colored_masks(ref, "black")
         else:
             H, W = drv["orig_size"]
-            fill_value = 1.0 if ref_bg == "white" else 0.0
-            reference_image_mask = torch.full((1, H, W, 3), fill_value, device=comfy.model_management.intermediate_device(), dtype=comfy.model_management.intermediate_dtype())
+            reference_image_mask = torch.zeros(1, H, W, 3, device=comfy.model_management.intermediate_device(), dtype=comfy.model_management.intermediate_dtype())
 
         return io.NodeOutput(mask_video, reference_image_mask)
 

execution.py

@@ -40,7 +40,6 @@ from comfy_execution.graph_utils import GraphBuilder, is_link
 from comfy_execution.validation import validate_node_input
 from comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandler
 from comfy_execution.utils import CurrentNodeContext
-from comfy_execution.asset_enrichment import enrich_output_with_assets
 from comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_func
 from comfy_api.latest import io, _io
 from comfy_execution.cache_provider import _has_cache_providers, _get_cache_providers, _logger as _cache_logger
@@ -419,7 +418,6 @@ def _is_intermediate_output(dynprompt, node_id):
     class_def = nodes.NODE_CLASS_MAPPINGS[class_type]
     return getattr(class_def, 'HAS_INTERMEDIATE_OUTPUT', False)
 
-
 def _send_cached_ui(server, node_id, display_node_id, cached, prompt_id, ui_outputs):
     if server.client_id is None:
         return
@@ -554,10 +552,6 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,
                 asyncio.create_task(await_completion())
                 return (ExecutionResult.PENDING, None, None)
         if len(output_ui) > 0:
-            # Enrich at output-processing time (not in the send path) so assets
-            # are registered even when no client is connected, and the asset id
-            # flows into ui_outputs and the cache alongside the raw entries.
-            output_ui = enrich_output_with_assets(output_ui)
             ui_outputs[unique_id] = {
                 "meta": {
                     "node_id": unique_id,

main.py

@@ -490,11 +490,6 @@ def start_comfyui(asyncio_loop=None):
         init_custom_nodes=(not args.disable_all_custom_nodes) or len(args.whitelist_custom_nodes) > 0,
         init_api_nodes=not args.disable_api_nodes
     ))
-
-    # Re-apply Comfy's cuDNN benchmark policy after custom-node imports. Benchmark
-    # mode can request near-card-sized autotune workspaces, and some custom nodes set it at import time.
-    comfy.model_management.set_cudnn_benchmark()
-
     hook_breaker_ac10a0.restore_functions()
 
     cuda_malloc_warning()

openapi.yaml

@@ -896,11 +896,6 @@ 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
@@ -1067,9 +1062,6 @@ components:
                         comfyui_version:
                             description: ComfyUI version
                             type: string
-                        deploy_environment:
-                            description: How this ComfyUI instance is deployed (e.g. cloud, local-git, local-portable, local-desktop)
-                            type: string
                         embedded_python:
                             description: Whether using embedded Python
                             type: boolean

server.py

@@ -8,7 +8,7 @@ import time
 import nodes
 import folder_paths
 import execution
-from comfy_execution.jobs import JobStatus, get_job, get_all_jobs, validate_job_id
+from comfy_execution.jobs import JobStatus, get_job, get_all_jobs
 import uuid
 import urllib
 import json
@@ -942,21 +942,7 @@ class PromptServer():
 
             if "prompt" in json_data:
                 prompt = json_data["prompt"]
-                client_prompt_id = json_data.get("prompt_id")
-                if client_prompt_id is None:
-                    # Absent or explicit null: the server mints the id.
-                    prompt_id = str(uuid.uuid4())
-                else:
-                    try:
-                        prompt_id = validate_job_id(client_prompt_id)
-                    except ValueError:
-                        error = {
-                            "type": "invalid_prompt_id",
-                            "message": "prompt_id must be a valid UUID",
-                            "details": "prompt_id must be a UUID string in canonical lowercase hyphenated form; omit it to let the server generate one",
-                            "extra_info": {}
-                        }
-                        return web.json_response({"error": error, "node_errors": {}}, status=400)
+                prompt_id = str(json_data.get("prompt_id", uuid.uuid4()))
 
                 partial_execution_targets = None
                 if "partial_execution_targets" in json_data:

tests-unit/assets_test/test_prompt_id_enforcement.py

@@ -1,69 +0,0 @@
-"""POST /prompt enforces canonical-UUID job ids at creation time.
-
-Lives in assets_test because it uses this suite's booted-server fixture. The
-invariant itself is pipeline-wide: a job id is stored and compared verbatim
-downstream — history keys, websocket correlation, and /interrupt matching —
-so a job minted with a non-canonical id would miss every exact-match lookup.
-
-The prompt bodies here are intentionally invalid workflows — prompt_id
-validation happens before workflow validation, so a rejected id returns
-``invalid_prompt_id`` while an accepted id falls through to the ordinary
-workflow-validation error (proving it cleared the id check).
-"""
-import requests
-
-
-def _post_prompt(http: requests.Session, api_base: str, body: dict) -> requests.Response:
-    return http.post(api_base + "/prompt", json=body, timeout=30)
-
-
-def _error_type(r: requests.Response) -> str:
-    return r.json()["error"]["type"]
-
-
-def test_non_uuid_prompt_id_rejected(http: requests.Session, api_base: str):
-    r = _post_prompt(http, api_base, {"prompt": {}, "prompt_id": "not-a-uuid"})
-    assert r.status_code == 400, r.text
-    assert _error_type(r) == "invalid_prompt_id"
-
-
-def test_non_string_prompt_id_rejected(http: requests.Session, api_base: str):
-    # Previously str()-coerced (123 became the job id "123"); must now be a 400,
-    # not a 500 from uuid.UUID choking on a non-string.
-    r = _post_prompt(http, api_base, {"prompt": {}, "prompt_id": 123})
-    assert r.status_code == 400, r.text
-    assert _error_type(r) == "invalid_prompt_id"
-
-
-def test_non_canonical_uuid_rejected(http: requests.Session, api_base: str):
-    # Parseable as a UUID, but not the canonical lowercase form: rejected
-    # loudly rather than silently rewritten (downstream lookups match the
-    # stored id exactly).
-    r = _post_prompt(
-        http,
-        api_base,
-        {"prompt": {}, "prompt_id": "AAAAAAAA-BBBB-4CCC-8DDD-EEEEEEEEEEEE"},
-    )
-    assert r.status_code == 400, r.text
-    assert _error_type(r) == "invalid_prompt_id"
-
-
-def test_canonical_uuid_accepted(http: requests.Session, api_base: str):
-    # The id clears validation; the empty workflow then fails ordinary prompt
-    # validation, proving the request got past the id check.
-    r = _post_prompt(
-        http,
-        api_base,
-        {"prompt": {}, "prompt_id": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"},
-    )
-    assert r.status_code == 400, r.text
-    assert _error_type(r) != "invalid_prompt_id"
-
-
-def test_null_prompt_id_not_rejected(http: requests.Session, api_base: str):
-    # Explicit null means "server generates" and must not be rejected as an
-    # invalid id. (The minted id itself is not observable here because the
-    # workflow is invalid; unit tests cover validate_job_id directly.)
-    r = _post_prompt(http, api_base, {"prompt": {}, "prompt_id": None})
-    assert r.status_code == 400, r.text
-    assert _error_type(r) != "invalid_prompt_id"

tests-unit/comfy_api_test/io_list_test.py

@@ -1,204 +0,0 @@
-"""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)

tests-unit/execution_test/test_enrich_output.py

@@ -1,205 +0,0 @@
-"""Tests for enrich_output_with_assets in comfy_execution/asset_enrichment.py."""
-import os
-import types
-import unittest
-from unittest.mock import MagicMock, patch
-
-
-def _make_args(enable_assets: bool):
-    a = types.SimpleNamespace()
-    a.enable_assets = enable_assets
-    return a
-
-
-def _make_register_result(ref_id="ref-id-2"):
-    result = MagicMock()
-    result.ref.id = ref_id
-    return result
-
-
-# Platform-appropriate absolute base. tempfile.gettempdir() returns C:\... on
-# Windows and /tmp on POSIX, so containment via commonpath behaves naturally.
-_DEFAULT_BASE = os.path.join(__import__("tempfile").gettempdir(), "asset-enrichment-test-base")
-
-
-def _mocked_modules(*, enable_assets=True, register_file_in_place=None, directory=_DEFAULT_BASE):
-    return {
-        "comfy.cli_args": MagicMock(args=_make_args(enable_assets)),
-        "folder_paths": MagicMock(get_directory_by_type=MagicMock(return_value=directory)),
-        "app.assets.services.ingest": MagicMock(
-            register_file_in_place=register_file_in_place or MagicMock(return_value=_make_register_result()),
-            DependencyMissingError=type("DependencyMissingError", (Exception,), {}),
-        ),
-    }
-
-
-def _call(output_ui, *, enable_assets=True, file_exists=True, register_result=None, directory=_DEFAULT_BASE):
-    register_mock = MagicMock(return_value=register_result or _make_register_result())
-    mocked = _mocked_modules(
-        enable_assets=enable_assets,
-        register_file_in_place=register_mock,
-        directory=directory,
-    )
-
-    # Only os.path.isfile is patched — abspath/join must run natively so the
-    # containment check sees real platform paths.
-    with patch.dict("sys.modules", mocked), \
-         patch("os.path.isfile", return_value=file_exists):
-        import importlib
-        import comfy_execution.asset_enrichment as mod
-        importlib.reload(mod)
-        return mod.enrich_output_with_assets(output_ui)
-
-
-class TestEnrichOutputWithAssets(unittest.TestCase):
-
-    def test_disabled_returns_unchanged(self):
-        output = {"images": [{"filename": "a.png", "subfolder": "", "type": "output"}]}
-        result = _call(output, enable_assets=False)
-        self.assertNotIn("id", result["images"][0])
-
-    def test_non_list_value_passed_through(self):
-        output = {"text": "hello"}
-        result = _call(output)
-        self.assertEqual(result["text"], "hello")
-
-    def test_entry_without_filename_unchanged(self):
-        output = {"latent": [{"subfolder": "", "type": "output"}]}
-        result = _call(output)
-        self.assertNotIn("id", result["latent"][0])
-
-    def test_entry_without_type_unchanged(self):
-        output = {"data": [{"filename": "a.png", "subfolder": ""}]}
-        result = _call(output)
-        self.assertNotIn("id", result["data"][0])
-
-    def test_file_not_on_disk_unchanged(self):
-        output = {"images": [{"filename": "missing.png", "subfolder": "", "type": "output"}]}
-        result = _call(output, file_exists=False)
-        self.assertNotIn("id", result["images"][0])
-
-    def test_unknown_type_returns_none_directory_unchanged(self):
-        output = {"images": [{"filename": "a.png", "subfolder": "", "type": "unknown"}]}
-        result = _call(output, directory=None)
-        self.assertNotIn("id", result["images"][0])
-
-    def test_register_injects_only_id(self):
-        reg = _make_register_result(ref_id="inline-ref")
-        output = {"images": [{"filename": "new.png", "subfolder": "", "type": "output"}]}
-        result = _call(output, register_result=reg)
-        img = result["images"][0]
-        self.assertEqual(img["id"], "inline-ref")
-        # Only id is injected — no asset_hash, name, preview_url, size
-        self.assertNotIn("asset_hash", img)
-        self.assertNotIn("name", img)
-        self.assertNotIn("preview_url", img)
-        self.assertNotIn("size", img)
-
-    def test_register_called_per_entry(self):
-        register_mock = MagicMock(return_value=_make_register_result())
-        mocked = _mocked_modules(register_file_in_place=register_mock)
-        output = {
-            "images": [
-                {"filename": "a.png", "subfolder": "", "type": "output"},
-                {"filename": "b.png", "subfolder": "", "type": "output"},
-            ]
-        }
-
-        with patch.dict("sys.modules", mocked), \
-             patch("os.path.isfile", return_value=True):
-            import importlib
-            import comfy_execution.asset_enrichment as mod
-            importlib.reload(mod)
-            mod.enrich_output_with_assets(output)
-
-        self.assertEqual(register_mock.call_count, 2)
-
-    def test_original_entry_not_mutated(self):
-        orig = {"filename": "a.png", "subfolder": "", "type": "output"}
-        output = {"images": [orig]}
-        _call(output)
-        self.assertNotIn("id", orig)
-
-    def test_enrichment_error_does_not_block_sibling_entries(self):
-        call_count = [0]
-        good_reg = _make_register_result(ref_id="good-ref")
-
-        def register_side_effect(abs_path, name, tags):
-            call_count[0] += 1
-            if call_count[0] == 1:
-                raise RuntimeError("boom")
-            return good_reg
-
-        mocked = _mocked_modules(register_file_in_place=register_side_effect)
-
-        output = {
-            "images": [
-                {"filename": "bad.png", "subfolder": "", "type": "output"},
-                {"filename": "good.png", "subfolder": "", "type": "output"},
-            ]
-        }
-
-        with patch.dict("sys.modules", mocked), \
-             patch("os.path.isfile", return_value=True):
-            import importlib
-            import comfy_execution.asset_enrichment as mod
-            importlib.reload(mod)
-            result = mod.enrich_output_with_assets(output)
-
-        imgs = result["images"]
-        self.assertNotIn("id", imgs[0])
-        self.assertEqual(imgs[1]["id"], "good-ref")
-
-    def test_multiple_output_keys_all_enriched(self):
-        output = {
-            "images": [{"filename": "a.png", "subfolder": "", "type": "output"}],
-            "videos": [{"filename": "b.mp4", "subfolder": "", "type": "output"}],
-        }
-        result = _call(output)
-        self.assertIn("id", result["images"][0])
-        self.assertIn("id", result["videos"][0])
-
-    def test_none_entry_in_list_unchanged(self):
-        output = {"images": [None, {"filename": "a.png", "subfolder": "", "type": "output"}]}
-        result = _call(output)
-        self.assertIsNone(result["images"][0])
-        self.assertIn("id", result["images"][1])
-
-    def test_path_traversal_subfolder_skipped(self):
-        register_mock = MagicMock(return_value=_make_register_result())
-        mocked = _mocked_modules(register_file_in_place=register_mock)
-
-        output = {"images": [{"filename": "passwd", "subfolder": "../../etc", "type": "output"}]}
-
-        # Do NOT patch os.path.abspath — real resolution is required for the containment check.
-        with patch.dict("sys.modules", mocked), \
-             patch("os.path.isfile", return_value=True):
-            import importlib
-            import comfy_execution.asset_enrichment as mod
-            importlib.reload(mod)
-            result = mod.enrich_output_with_assets(output)
-
-        self.assertNotIn("id", result["images"][0])
-        register_mock.assert_not_called()
-
-    def test_absolute_filename_skipped(self):
-        register_mock = MagicMock(return_value=_make_register_result())
-        mocked = _mocked_modules(register_file_in_place=register_mock)
-
-        # Absolute filename — os.path.join discards earlier components when a later one is absolute.
-        absolute_filename = os.path.abspath(os.sep + "etc" + os.sep + "passwd")
-        output = {"images": [{"filename": absolute_filename, "subfolder": "", "type": "output"}]}
-
-        with patch.dict("sys.modules", mocked), \
-             patch("os.path.isfile", return_value=True):
-            import importlib
-            import comfy_execution.asset_enrichment as mod
-            importlib.reload(mod)
-            result = mod.enrich_output_with_assets(output)
-
-        self.assertNotIn("id", result["images"][0])
-        register_mock.assert_not_called()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/execution/test_jobs.py

@@ -1,7 +1,5 @@
 """Unit tests for comfy_execution/jobs.py"""
 
-import pytest
-
 from comfy_execution.jobs import (
     JobStatus,
     is_previewable,
@@ -12,50 +10,9 @@ from comfy_execution.jobs import (
     get_outputs_summary,
     apply_sorting,
     has_3d_extension,
-    validate_job_id,
 )
 
 
-class TestValidateJobId:
-    """validate_job_id guards job creation: POST /prompt rejects ids it raises on."""
-
-    def test_canonical_form_passes_through(self):
-        cid = "a1b2c3d4-e5f6-7a89-b0c1-d2e3f4a5b6c7"
-        assert validate_job_id(cid) == cid
-
-    @pytest.mark.parametrize(
-        "variant",
-        [
-            "A1B2C3D4-E5F6-7A89-B0C1-D2E3F4A5B6C7",          # uppercase
-            "{a1b2c3d4-e5f6-7a89-b0c1-d2e3f4a5b6c7}",        # braced
-            "urn:uuid:a1b2c3d4-e5f6-7a89-b0c1-d2e3f4a5b6c7",  # URN
-            "a1b2c3d4e5f67a89b0c1d2e3f4a5b6c7",              # bare hex
-            " a1b2c3d4-e5f6-7a89-b0c1-d2e3f4a5b6c7 ",        # padded
-        ],
-    )
-    def test_non_canonical_spellings_rejected(self, variant):
-        # uuid.UUID parses all of these, but accepting them would silently
-        # rewrite the client's id (history keys, websocket events, and
-        # /interrupt matching all match the stored form exactly).
-        with pytest.raises(ValueError):
-            validate_job_id(variant)
-
-    @pytest.mark.parametrize(
-        "bad",
-        ["", "not-a-uuid", "prompt-123", "a1b2c3d4-e5f6-7a89-b0c1", "None"],
-    )
-    def test_non_uuid_strings_rejected(self, bad):
-        with pytest.raises(ValueError):
-            validate_job_id(bad)
-
-    @pytest.mark.parametrize("bad", [123, 1.5, True, None, ["a"], {"id": "x"}])
-    def test_non_strings_rejected(self, bad):
-        # uuid.UUID raises AttributeError/TypeError on non-strings; the helper
-        # must normalize those to ValueError so callers need one except clause.
-        with pytest.raises(ValueError):
-            validate_job_id(bad)
-
-
 class TestJobStatus:
     """Test JobStatus constants."""