ComfyUI v0.18.2

comfy/ldm/flux/model.py

@@ -386,7 +386,7 @@ class Flux(nn.Module):
                     h = max(h, ref.shape[-2] + h_offset)
                     w = max(w, ref.shape[-1] + w_offset)
 
-                kontext, kontext_ids = self.process_img(ref, index=index, h_offset=h_offset, w_offset=w_offset, transformer_options=transformer_options)
+                kontext, kontext_ids = self.process_img(ref, index=index, h_offset=h_offset, w_offset=w_offset)
                 img = torch.cat([img, kontext], dim=1)
                 img_ids = torch.cat([img_ids, kontext_ids], dim=1)
                 ref_num_tokens.append(kontext.shape[1])

comfy/ldm/lightricks/av_model.py

@@ -681,33 +681,6 @@ class LTXAVModel(LTXVModel):
         additional_args["has_spatial_mask"] = has_spatial_mask
 
         ax, a_latent_coords = self.a_patchifier.patchify(ax)
-
-        # Inject reference audio for ID-LoRA in-context conditioning
-        ref_audio = kwargs.get("ref_audio", None)
-        ref_audio_seq_len = 0
-        if ref_audio is not None:
-            ref_tokens = ref_audio["tokens"].to(dtype=ax.dtype, device=ax.device)
-            if ref_tokens.shape[0] < ax.shape[0]:
-                ref_tokens = ref_tokens.expand(ax.shape[0], -1, -1)
-            ref_audio_seq_len = ref_tokens.shape[1]
-            B = ax.shape[0]
-
-            # Compute negative temporal positions matching ID-LoRA convention:
-            # offset by -(end_of_last_token + time_per_latent) so reference ends just before t=0
-            p = self.a_patchifier
-            tpl = p.hop_length * p.audio_latent_downsample_factor / p.sample_rate
-            ref_start = p._get_audio_latent_time_in_sec(0, ref_audio_seq_len, torch.float32, ax.device)
-            ref_end = p._get_audio_latent_time_in_sec(1, ref_audio_seq_len + 1, torch.float32, ax.device)
-            time_offset = ref_end[-1].item() + tpl
-            ref_start = (ref_start - time_offset).unsqueeze(0).expand(B, -1).unsqueeze(1)
-            ref_end = (ref_end - time_offset).unsqueeze(0).expand(B, -1).unsqueeze(1)
-            ref_pos = torch.stack([ref_start, ref_end], dim=-1)
-
-            additional_args["ref_audio_seq_len"] = ref_audio_seq_len
-            additional_args["target_audio_seq_len"] = ax.shape[1]
-            ax = torch.cat([ref_tokens, ax], dim=1)
-            a_latent_coords = torch.cat([ref_pos.to(a_latent_coords), a_latent_coords], dim=2)
-
         ax = self.audio_patchify_proj(ax)
 
         # additional_args.update({"av_orig_shape": list(x.shape)})
@@ -748,14 +721,6 @@ class LTXAVModel(LTXVModel):
 
         # Prepare audio timestep
         a_timestep = kwargs.get("a_timestep")
-        ref_audio_seq_len = kwargs.get("ref_audio_seq_len", 0)
-        if ref_audio_seq_len > 0 and a_timestep is not None:
-            # Reference tokens must have timestep=0, expand scalar/1D timestep to per-token so ref=0 and target=sigma.
-            target_len = kwargs.get("target_audio_seq_len")
-            if a_timestep.dim() <= 1:
-                a_timestep = a_timestep.view(-1, 1).expand(batch_size, target_len)
-            ref_ts = torch.zeros(batch_size, ref_audio_seq_len, *a_timestep.shape[2:], device=a_timestep.device, dtype=a_timestep.dtype)
-            a_timestep = torch.cat([ref_ts, a_timestep], dim=1)
         if a_timestep is not None:
             a_timestep_scaled = a_timestep * self.timestep_scale_multiplier
             a_timestep_flat = a_timestep_scaled.flatten()
@@ -990,13 +955,6 @@ class LTXAVModel(LTXVModel):
         v_embedded_timestep = embedded_timestep[0]
         a_embedded_timestep = embedded_timestep[1]
 
-        # Trim reference audio tokens before unpatchification
-        ref_audio_seq_len = kwargs.get("ref_audio_seq_len", 0)
-        if ref_audio_seq_len > 0:
-            ax = ax[:, ref_audio_seq_len:]
-            if a_embedded_timestep.shape[1] > 1:
-                a_embedded_timestep = a_embedded_timestep[:, ref_audio_seq_len:]
-
         # Expand compressed video timestep if needed
         if isinstance(v_embedded_timestep, CompressedTimestep):
             v_embedded_timestep = v_embedded_timestep.expand()

comfy/model_base.py

@@ -937,10 +937,9 @@ class LongCatImage(Flux):
         transformer_options = transformer_options.copy()
         rope_opts = transformer_options.get("rope_options", {})
         rope_opts = dict(rope_opts)
-        pe_len = float(c_crossattn.shape[1]) if c_crossattn is not None else 512.0
         rope_opts.setdefault("shift_t", 1.0)
-        rope_opts.setdefault("shift_y", pe_len)
-        rope_opts.setdefault("shift_x", pe_len)
+        rope_opts.setdefault("shift_y", 512.0)
+        rope_opts.setdefault("shift_x", 512.0)
         transformer_options["rope_options"] = rope_opts
         return super()._apply_model(x, t, c_concat, c_crossattn, control, transformer_options, **kwargs)
 
@@ -1061,10 +1060,6 @@ class LTXAV(BaseModel):
         if guide_attention_entries is not None:
             out['guide_attention_entries'] = comfy.conds.CONDConstant(guide_attention_entries)
 
-        ref_audio = kwargs.get("ref_audio", None)
-        if ref_audio is not None:
-            out['ref_audio'] = comfy.conds.CONDConstant(ref_audio)
-
         return out
 
     def process_timestep(self, timestep, x, denoise_mask=None, audio_denoise_mask=None, **kwargs):

comfy/text_encoders/llama.py

@@ -1028,19 +1028,12 @@ class Qwen25_7BVLI(BaseLlama, BaseGenerate, torch.nn.Module):
                 grid = e.get("extra", None)
                 start = e.get("index")
                 if position_ids is None:
-                    position_ids = torch.ones((3, embeds.shape[1]), device=embeds.device, dtype=torch.long)
+                    position_ids = torch.zeros((3, embeds.shape[1]), device=embeds.device)
                     position_ids[:, :start] = torch.arange(0, start, device=embeds.device)
                 end = e.get("size") + start
                 len_max = int(grid.max()) // 2
                 start_next = len_max + start
-                if attention_mask is not None:
-                    # Assign compact sequential positions to attended tokens only,
-                    # skipping over padding so post-padding tokens aren't inflated.
-                    after_mask = attention_mask[0, end:]
-                    text_positions = after_mask.cumsum(0) - 1 + start_next + offset
-                    position_ids[:, end:] = torch.where(after_mask.bool(), text_positions, position_ids[0, end:])
-                else:
-                    position_ids[:, end:] = torch.arange(start_next + offset, start_next + (embeds.shape[1] - end) + offset, device=embeds.device)
+                position_ids[:, end:] = torch.arange(start_next + offset, start_next + (embeds.shape[1] - end) + offset, device=embeds.device)
                 position_ids[0, start:end] = start + offset
                 max_d = int(grid[0][1]) // 2
                 position_ids[1, start:end] = torch.arange(start + offset, start + max_d + offset, device=embeds.device).unsqueeze(1).repeat(1, math.ceil((end - start) / max_d)).flatten(0)[:end - start]

comfy/text_encoders/longcat_image.py

@@ -64,13 +64,7 @@ class LongCatImageBaseTokenizer(Qwen25_7BVLITokenizer):
         return [output]
 
 
-IMAGE_PAD_TOKEN_ID = 151655
-
 class LongCatImageTokenizer(sd1_clip.SD1Tokenizer):
-    T2I_PREFIX = "<|im_start|>system\nAs an image captioning expert, generate a descriptive text prompt based on an image content, suitable for input to a text-to-image model.<|im_end|>\n<|im_start|>user\n"
-    EDIT_PREFIX = "<|im_start|>system\nAs an image editing expert, first analyze the content and attributes of the input image(s). Then, based on the user's editing instructions, clearly and precisely determine how to modify the given image(s), ensuring that only the specified parts are altered and all other aspects remain consistent with the original(s).<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>"
-    SUFFIX = "<|im_end|>\n<|im_start|>assistant\n"
-
     def __init__(self, embedding_directory=None, tokenizer_data={}):
         super().__init__(
             embedding_directory=embedding_directory,
@@ -78,8 +72,10 @@ class LongCatImageTokenizer(sd1_clip.SD1Tokenizer):
             name="qwen25_7b",
             tokenizer=LongCatImageBaseTokenizer,
         )
+        self.longcat_template_prefix = "<|im_start|>system\nAs an image captioning expert, generate a descriptive text prompt based on an image content, suitable for input to a text-to-image model.<|im_end|>\n<|im_start|>user\n"
+        self.longcat_template_suffix = "<|im_end|>\n<|im_start|>assistant\n"
 
-    def tokenize_with_weights(self, text, return_word_ids=False, images=None, **kwargs):
+    def tokenize_with_weights(self, text, return_word_ids=False, **kwargs):
         skip_template = False
         if text.startswith("<|im_start|>"):
             skip_template = True
@@ -94,14 +90,11 @@ class LongCatImageTokenizer(sd1_clip.SD1Tokenizer):
                 text, return_word_ids=return_word_ids, disable_weights=True, **kwargs
             )
         else:
-            has_images = images is not None and len(images) > 0
-            template_prefix = self.EDIT_PREFIX if has_images else self.T2I_PREFIX
-
             prefix_ids = base_tok.tokenizer(
-                template_prefix, add_special_tokens=False
+                self.longcat_template_prefix, add_special_tokens=False
             )["input_ids"]
             suffix_ids = base_tok.tokenizer(
-                self.SUFFIX, add_special_tokens=False
+                self.longcat_template_suffix, add_special_tokens=False
             )["input_ids"]
 
             prompt_tokens = base_tok.tokenize_with_weights(
@@ -113,14 +106,6 @@ class LongCatImageTokenizer(sd1_clip.SD1Tokenizer):
             suffix_pairs = [(t, 1.0) for t in suffix_ids]
 
             combined = prefix_pairs + prompt_pairs + suffix_pairs
-
-            if has_images:
-                embed_count = 0
-                for i in range(len(combined)):
-                    if combined[i][0] == IMAGE_PAD_TOKEN_ID and embed_count < len(images):
-                        combined[i] = ({"type": "image", "data": images[embed_count], "original_type": "image"}, combined[i][1])
-                        embed_count += 1
-
             tokens = {"qwen25_7b": [combined]}
 
         return tokens

comfy/text_encoders/qwen_vl.py

@@ -425,7 +425,4 @@ class Qwen2VLVisionTransformer(nn.Module):
             hidden_states = block(hidden_states, position_embeddings, cu_seqlens_now, optimized_attention=optimized_attention)
 
         hidden_states = self.merger(hidden_states)
-        # Potentially important for spatially precise edits. This is present in the HF implementation.
-        reverse_indices = torch.argsort(window_index)
-        hidden_states = hidden_states[reverse_indices, :]
         return hidden_states

comfy_api/input/__init__.py

@@ -5,10 +5,6 @@ from comfy_api.latest._input import (
     MaskInput,
     LatentInput,
     VideoInput,
-    CurvePoint,
-    CurveInput,
-    MonotoneCubicCurve,
-    LinearCurve,
 )
 
 __all__ = [
@@ -17,8 +13,4 @@ __all__ = [
     "MaskInput",
     "LatentInput",
     "VideoInput",
-    "CurvePoint",
-    "CurveInput",
-    "MonotoneCubicCurve",
-    "LinearCurve",
 ]

comfy_api/latest/_input/__init__.py

@@ -1,5 +1,4 @@
 from .basic_types import ImageInput, AudioInput, MaskInput, LatentInput
-from .curve_types import CurvePoint, CurveInput, MonotoneCubicCurve, LinearCurve
 from .video_types import VideoInput
 
 __all__ = [
@@ -8,8 +7,4 @@ __all__ = [
     "VideoInput",
     "MaskInput",
     "LatentInput",
-    "CurvePoint",
-    "CurveInput",
-    "MonotoneCubicCurve",
-    "LinearCurve",
 ]

comfy_api/latest/_input/curve_types.py

@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-import logging
-import math
-from abc import ABC, abstractmethod
-import numpy as np
-
-logger = logging.getLogger(__name__)
-
-
-CurvePoint = tuple[float, float]
-
-
-class CurveInput(ABC):
-    """Abstract base class for curve inputs.
-
-    Subclasses represent different curve representations (control-point
-    interpolation, analytical functions, LUT-based, etc.) while exposing a
-    uniform evaluation interface to downstream nodes.
-    """
-
-    @property
-    @abstractmethod
-    def points(self) -> list[CurvePoint]:
-        """The control points that define this curve."""
-
-    @abstractmethod
-    def interp(self, x: float) -> float:
-        """Evaluate the curve at a single *x* value in [0, 1]."""
-
-    def interp_array(self, xs: np.ndarray) -> np.ndarray:
-        """Vectorised evaluation over a numpy array of x values.
-
-        Subclasses should override this for better performance. The default
-        falls back to scalar ``interp`` calls.
-        """
-        return np.fromiter((self.interp(float(x)) for x in xs), dtype=np.float64, count=len(xs))
-
-    def to_lut(self, size: int = 256) -> np.ndarray:
-        """Generate a float64 lookup table of *size* evenly-spaced samples in [0, 1]."""
-        return self.interp_array(np.linspace(0.0, 1.0, size))
-
-    @staticmethod
-    def from_raw(data) -> CurveInput:
-        """Convert raw curve data (dict or point list) to a CurveInput instance.
-
-        Accepts:
-        - A ``CurveInput`` instance (returned as-is).
-        - A dict with ``"points"`` and optional ``"interpolation"`` keys.
-        - A bare list/sequence of ``(x, y)`` pairs (defaults to monotone cubic).
-        """
-        if isinstance(data, CurveInput):
-            return data
-        if isinstance(data, dict):
-            raw_points = data["points"]
-            interpolation = data.get("interpolation", "monotone_cubic")
-        else:
-            raw_points = data
-            interpolation = "monotone_cubic"
-        points = [(float(x), float(y)) for x, y in raw_points]
-        if interpolation == "linear":
-            return LinearCurve(points)
-        if interpolation != "monotone_cubic":
-            logger.warning("Unknown curve interpolation %r, falling back to monotone_cubic", interpolation)
-        return MonotoneCubicCurve(points)
-
-
-class MonotoneCubicCurve(CurveInput):
-    """Monotone cubic Hermite interpolation over control points.
-
-    Mirrors the frontend ``createMonotoneInterpolator`` in
-    ``ComfyUI_frontend/src/components/curve/curveUtils.ts`` so that
-    backend evaluation matches the editor preview exactly.
-
-    All heavy work (sorting, slope computation) happens once at construction.
-    ``interp_array`` is fully vectorised with numpy.
-    """
-
-    def __init__(self, control_points: list[CurvePoint]):
-        sorted_pts = sorted(control_points, key=lambda p: p[0])
-        self._points = [(float(x), float(y)) for x, y in sorted_pts]
-        self._xs = np.array([p[0] for p in self._points], dtype=np.float64)
-        self._ys = np.array([p[1] for p in self._points], dtype=np.float64)
-        self._slopes = self._compute_slopes()
-
-    @property
-    def points(self) -> list[CurvePoint]:
-        return list(self._points)
-
-    def _compute_slopes(self) -> np.ndarray:
-        xs, ys = self._xs, self._ys
-        n = len(xs)
-        if n < 2:
-            return np.zeros(n, dtype=np.float64)
-
-        dx = np.diff(xs)
-        dy = np.diff(ys)
-        dx_safe = np.where(dx == 0, 1.0, dx)
-        deltas = np.where(dx == 0, 0.0, dy / dx_safe)
-
-        slopes = np.empty(n, dtype=np.float64)
-        slopes[0] = deltas[0]
-        slopes[-1] = deltas[-1]
-        for i in range(1, n - 1):
-            if deltas[i - 1] * deltas[i] <= 0:
-                slopes[i] = 0.0
-            else:
-                slopes[i] = (deltas[i - 1] + deltas[i]) / 2
-
-        for i in range(n - 1):
-            if deltas[i] == 0:
-                slopes[i] = 0.0
-                slopes[i + 1] = 0.0
-            else:
-                alpha = slopes[i] / deltas[i]
-                beta = slopes[i + 1] / deltas[i]
-                s = alpha * alpha + beta * beta
-                if s > 9:
-                    t = 3 / math.sqrt(s)
-                    slopes[i] = t * alpha * deltas[i]
-                    slopes[i + 1] = t * beta * deltas[i]
-        return slopes
-
-    def interp(self, x: float) -> float:
-        xs, ys, slopes = self._xs, self._ys, self._slopes
-        n = len(xs)
-        if n == 0:
-            return 0.0
-        if n == 1:
-            return float(ys[0])
-        if x <= xs[0]:
-            return float(ys[0])
-        if x >= xs[-1]:
-            return float(ys[-1])
-
-        hi = int(np.searchsorted(xs, x, side='right'))
-        hi = min(hi, n - 1)
-        lo = hi - 1
-
-        dx = xs[hi] - xs[lo]
-        if dx == 0:
-            return float(ys[lo])
-
-        t = (x - xs[lo]) / dx
-        t2 = t * t
-        t3 = t2 * t
-        h00 = 2 * t3 - 3 * t2 + 1
-        h10 = t3 - 2 * t2 + t
-        h01 = -2 * t3 + 3 * t2
-        h11 = t3 - t2
-        return float(h00 * ys[lo] + h10 * dx * slopes[lo] + h01 * ys[hi] + h11 * dx * slopes[hi])
-
-    def interp_array(self, xs_in: np.ndarray) -> np.ndarray:
-        """Fully vectorised evaluation using numpy."""
-        xs, ys, slopes = self._xs, self._ys, self._slopes
-        n = len(xs)
-        if n == 0:
-            return np.zeros_like(xs_in, dtype=np.float64)
-        if n == 1:
-            return np.full_like(xs_in, ys[0], dtype=np.float64)
-
-        hi = np.searchsorted(xs, xs_in, side='right').clip(1, n - 1)
-        lo = hi - 1
-
-        dx = xs[hi] - xs[lo]
-        dx_safe = np.where(dx == 0, 1.0, dx)
-        t = np.where(dx == 0, 0.0, (xs_in - xs[lo]) / dx_safe)
-        t2 = t * t
-        t3 = t2 * t
-
-        h00 = 2 * t3 - 3 * t2 + 1
-        h10 = t3 - 2 * t2 + t
-        h01 = -2 * t3 + 3 * t2
-        h11 = t3 - t2
-
-        result = h00 * ys[lo] + h10 * dx * slopes[lo] + h01 * ys[hi] + h11 * dx * slopes[hi]
-        result = np.where(xs_in <= xs[0], ys[0], result)
-        result = np.where(xs_in >= xs[-1], ys[-1], result)
-        return result
-
-    def __repr__(self) -> str:
-        return f"MonotoneCubicCurve(points={self._points})"
-
-
-class LinearCurve(CurveInput):
-    """Piecewise linear interpolation over control points.
-
-    Mirrors the frontend ``createLinearInterpolator`` in
-    ``ComfyUI_frontend/src/components/curve/curveUtils.ts``.
-    """
-
-    def __init__(self, control_points: list[CurvePoint]):
-        sorted_pts = sorted(control_points, key=lambda p: p[0])
-        self._points = [(float(x), float(y)) for x, y in sorted_pts]
-        self._xs = np.array([p[0] for p in self._points], dtype=np.float64)
-        self._ys = np.array([p[1] for p in self._points], dtype=np.float64)
-
-    @property
-    def points(self) -> list[CurvePoint]:
-        return list(self._points)
-
-    def interp(self, x: float) -> float:
-        xs, ys = self._xs, self._ys
-        n = len(xs)
-        if n == 0:
-            return 0.0
-        if n == 1:
-            return float(ys[0])
-        return float(np.interp(x, xs, ys))
-
-    def interp_array(self, xs_in: np.ndarray) -> np.ndarray:
-        if len(self._xs) == 0:
-            return np.zeros_like(xs_in, dtype=np.float64)
-        if len(self._xs) == 1:
-            return np.full_like(xs_in, self._ys[0], dtype=np.float64)
-        return np.interp(xs_in, self._xs, self._ys)
-
-    def __repr__(self) -> str:
-        return f"LinearCurve(points={self._points})"

comfy_api/latest/_io.py

@@ -23,7 +23,7 @@ if TYPE_CHECKING:
     from comfy.samplers import CFGGuider, Sampler
     from comfy.sd import CLIP, VAE
     from comfy.sd import StyleModel as StyleModel_
-    from comfy_api.input import VideoInput, CurveInput as CurveInput_
+    from comfy_api.input import VideoInput
 from comfy_api.internal import (_ComfyNodeInternal, _NodeOutputInternal, classproperty, copy_class, first_real_override, is_class,
     prune_dict, shallow_clone_class)
 from comfy_execution.graph_utils import ExecutionBlocker
@@ -1242,9 +1242,8 @@ class BoundingBox(ComfyTypeIO):
 
 @comfytype(io_type="CURVE")
 class Curve(ComfyTypeIO):
-    from comfy_api.input import CurvePoint
-    if TYPE_CHECKING:
-        Type = CurveInput_
+    CurvePoint = tuple[float, float]
+    Type = list[CurvePoint]
 
     class Input(WidgetInput):
         def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
@@ -1253,18 +1252,6 @@ class Curve(ComfyTypeIO):
             if default is None:
                 self.default = [(0.0, 0.0), (1.0, 1.0)]
 
-        def as_dict(self):
-            d = super().as_dict()
-            if self.default is not None:
-                d["default"] = {"points": [list(p) for p in self.default], "interpolation": "monotone_cubic"}
-            return d
-
-
-@comfytype(io_type="HISTOGRAM")
-class Histogram(ComfyTypeIO):
-    """A histogram represented as a list of bin counts."""
-    Type = list[int]
-
 
 DYNAMIC_INPUT_LOOKUP: dict[str, Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]] = {}
 def register_dynamic_input_func(io_type: str, func: Callable[[dict[str, Any], dict[str, Any], tuple[str, dict[str, Any]], str, list[str] | None], None]):
@@ -2253,6 +2240,5 @@ __all__ = [
     "PriceBadge",
     "BoundingBox",
     "Curve",
-    "Histogram",
     "NodeReplace",
 ]

comfy_extras/nodes_curve.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from comfy_api.latest import ComfyExtension, io
-from comfy_api.input import CurveInput
-from typing_extensions import override
-
-
-class CurveEditor(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="CurveEditor",
-            display_name="Curve Editor",
-            category="utils",
-            inputs=[
-                io.Curve.Input("curve"),
-                io.Histogram.Input("histogram", optional=True),
-            ],
-            outputs=[
-                io.Curve.Output("curve"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, curve, histogram=None) -> io.NodeOutput:
-        result = CurveInput.from_raw(curve)
-
-        ui = {}
-        if histogram is not None:
-            ui["histogram"] = histogram if isinstance(histogram, list) else list(histogram)
-
-        return io.NodeOutput(result, ui=ui) if ui else io.NodeOutput(result)
-
-
-class CurveExtension(ComfyExtension):
-    @override
-    async def get_node_list(self):
-        return [CurveEditor]
-
-
-async def comfy_entrypoint():
-    return CurveExtension()

comfy_extras/nodes_lt.py

@@ -3,7 +3,6 @@ import node_helpers
 import torch
 import comfy.model_management
 import comfy.model_sampling
-import comfy.samplers
 import comfy.utils
 import math
 import numpy as np
@@ -683,84 +682,6 @@ class LTXVSeparateAVLatent(io.ComfyNode):
         return io.NodeOutput(video_latent, audio_latent)
 
 
-class LTXVReferenceAudio(io.ComfyNode):
-    @classmethod
-    def define_schema(cls) -> io.Schema:
-        return io.Schema(
-            node_id="LTXVReferenceAudio",
-            display_name="LTXV Reference Audio (ID-LoRA)",
-            category="conditioning/audio",
-            description="Set reference audio for ID-LoRA speaker identity transfer. Encodes a reference audio clip into the conditioning and optionally patches the model with identity guidance (extra forward pass without reference, amplifying the speaker identity effect).",
-            inputs=[
-                io.Model.Input("model"),
-                io.Conditioning.Input("positive"),
-                io.Conditioning.Input("negative"),
-                io.Audio.Input("reference_audio", tooltip="Reference audio clip whose speaker identity to transfer. ~5 seconds recommended (training duration). Shorter or longer clips may degrade voice identity transfer."),
-                io.Vae.Input(id="audio_vae", display_name="Audio VAE", tooltip="LTXV Audio VAE for encoding."),
-                io.Float.Input("identity_guidance_scale", default=3.0, min=0.0, max=100.0, step=0.01, round=0.01, tooltip="Strength of identity guidance. Runs an extra forward pass without reference each step to amplify speaker identity. Set to 0 to disable (no extra pass)."),
-                io.Float.Input("start_percent", default=0.0, min=0.0, max=1.0, step=0.001, advanced=True, tooltip="Start of the sigma range where identity guidance is active."),
-                io.Float.Input("end_percent", default=1.0, min=0.0, max=1.0, step=0.001, advanced=True, tooltip="End of the sigma range where identity guidance is active."),
-            ],
-            outputs=[
-                io.Model.Output(),
-                io.Conditioning.Output(display_name="positive"),
-                io.Conditioning.Output(display_name="negative"),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, model, positive, negative, reference_audio, audio_vae, identity_guidance_scale, start_percent, end_percent) -> io.NodeOutput:
-        # Encode reference audio to latents and patchify
-        audio_latents = audio_vae.encode(reference_audio)
-        b, c, t, f = audio_latents.shape
-        ref_tokens = audio_latents.permute(0, 2, 1, 3).reshape(b, t, c * f)
-        ref_audio = {"tokens": ref_tokens}
-
-        positive = node_helpers.conditioning_set_values(positive, {"ref_audio": ref_audio})
-        negative = node_helpers.conditioning_set_values(negative, {"ref_audio": ref_audio})
-
-        # Patch model with identity guidance
-        m = model.clone()
-        scale = identity_guidance_scale
-        model_sampling = m.get_model_object("model_sampling")
-        sigma_start = model_sampling.percent_to_sigma(start_percent)
-        sigma_end = model_sampling.percent_to_sigma(end_percent)
-
-        def post_cfg_function(args):
-            if scale == 0:
-                return args["denoised"]
-
-            sigma = args["sigma"]
-            sigma_ = sigma[0].item()
-            if sigma_ > sigma_start or sigma_ < sigma_end:
-                return args["denoised"]
-
-            cond_pred = args["cond_denoised"]
-            cond = args["cond"]
-            cfg_result = args["denoised"]
-            model_options = args["model_options"].copy()
-            x = args["input"]
-
-            # Strip ref_audio from conditioning for the no-reference pass
-            noref_cond = []
-            for entry in cond:
-                new_entry = entry.copy()
-                mc = new_entry.get("model_conds", {}).copy()
-                mc.pop("ref_audio", None)
-                new_entry["model_conds"] = mc
-                noref_cond.append(new_entry)
-
-            (pred_noref,) = comfy.samplers.calc_cond_batch(
-                args["model"], [noref_cond], x, sigma, model_options
-            )
-
-            return cfg_result + (cond_pred - pred_noref) * scale
-
-        m.set_model_sampler_post_cfg_function(post_cfg_function)
-
-        return io.NodeOutput(m, positive, negative)
-
-
 class LtxvExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[io.ComfyNode]]:
@@ -776,7 +697,6 @@ class LtxvExtension(ComfyExtension):
             LTXVCropGuides,
             LTXVConcatAVLatent,
             LTXVSeparateAVLatent,
-            LTXVReferenceAudio,
         ]
 
 

comfyui_version.py

@@ -1,3 +1,3 @@
 # This file is automatically generated by the build process when version is
 # updated in pyproject.toml.
-__version__ = "0.18.1"
+__version__ = "0.18.2"

main.py

@@ -471,9 +471,6 @@ if __name__ == "__main__":
     if sys.version_info.major == 3 and sys.version_info.minor < 10:
         logging.warning("WARNING: You are using a python version older than 3.10, please upgrade to a newer one. 3.12 and above is recommended.")
 
-    if args.disable_dynamic_vram:
-        logging.warning("Dynamic vram disabled with argument. If you have any issues with dynamic vram enabled please give us a detailed reports as this argument will be removed soon.")
-
     event_loop, _, start_all_func = start_comfyui()
     try:
         x = start_all_func()

manager_requirements.txt

@@ -1 +1 @@
-comfyui_manager==4.1b8
+comfyui_manager==4.1b6

nodes.py

@@ -2455,7 +2455,6 @@ async def init_builtin_extra_nodes():
         "nodes_sdpose.py",
         "nodes_math.py",
         "nodes_painter.py",
-        "nodes_curve.py",
     ]
 
     import_failed = []

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ComfyUI"
-version = "0.18.1"
+version = "0.18.2"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"

requirements.txt

@@ -1,4 +1,4 @@
-comfyui-frontend-package==1.42.8
+comfyui-frontend-package==1.41.21
 comfyui-workflow-templates==0.9.36
 comfyui-embedded-docs==0.4.3
 torch