Merge branch 'master' into cloud-openapi-projection

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/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_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/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_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_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)
 

server.py

@@ -27,7 +27,6 @@ import logging
 
 import mimetypes
 from comfy.cli_args import args
-from comfy.deploy_environment import get_deploy_environment
 import comfy.utils
 import comfy.model_management
 from comfy_api import feature_flags
@@ -691,7 +690,6 @@ class PromptServer():
                     "python_version": sys.version,
                     "pytorch_version": comfy.model_management.torch_version,
                     "embedded_python": os.path.split(os.path.split(sys.executable)[0])[1] == "python_embeded",
-                    "deploy_environment": get_deploy_environment(),
                     "argv": sys.argv
                 },
                 "devices": device_entries