.github/workflows/test-ci.yml

@@ -20,6 +20,7 @@ jobs:
   test-stable:
     strategy:
       fail-fast: false
+      max-parallel: 1  # This forces sequential execution
       matrix:
         # os: [macos, linux, windows]
         # os: [macos, linux]
@@ -74,6 +75,7 @@ jobs:
   test-unix-nightly:
     strategy:
       fail-fast: false
+      max-parallel: 1  # This forces sequential execution
       matrix:
         # os: [macos, linux]
         os: [linux]

.github/workflows/test-launch.yml

@@ -13,7 +13,7 @@ jobs:
     - name: Checkout ComfyUI
       uses: actions/checkout@v4
       with:
-        repository: "Comfy-Org/ComfyUI"
+        repository: "comfyanonymous/ComfyUI"
         path: "ComfyUI"
     - uses: actions/setup-python@v4
       with:

.github/workflows/update-ci-container.yml

@@ -1,59 +0,0 @@
-name: "CI: Update CI Container"
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'ComfyUI version (e.g., v0.7.0)'
-        required: true
-        type: string
-
-jobs:
-  update-ci-container:
-    runs-on: ubuntu-latest
-    # Skip pre-releases unless manually triggered
-    if: github.event_name == 'workflow_dispatch' || !github.event.release.prerelease
-    steps:
-      - name: Get version
-        id: version
-        run: |
-          if [ "${{ github.event_name }}" = "release" ]; then
-            VERSION="${{ github.event.release.tag_name }}"
-          else
-            VERSION="${{ inputs.version }}"
-          fi
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-      - name: Checkout comfyui-ci-container
-        uses: actions/checkout@v4
-        with:
-          repository: comfy-org/comfyui-ci-container
-          token: ${{ secrets.CI_CONTAINER_PAT }}
-
-      - name: Check current version
-        id: current
-        run: |
-          CURRENT=$(grep -oP 'ARG COMFYUI_VERSION=\K.*' Dockerfile || echo "unknown")
-          echo "current_version=$CURRENT" >> $GITHUB_OUTPUT
-
-      - name: Update Dockerfile
-        run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          sed -i "s/^ARG COMFYUI_VERSION=.*/ARG COMFYUI_VERSION=${VERSION}/" Dockerfile
-
-      - name: Create Pull Request
-        id: create-pr
-        uses: peter-evans/create-pull-request@v7
-        with:
-          token: ${{ secrets.CI_CONTAINER_PAT }}
-          branch: automation/comfyui-${{ steps.version.outputs.version }}
-          title: "chore: bump ComfyUI to ${{ steps.version.outputs.version }}"
-          body: |
-            Updates ComfyUI version from `${{ steps.current.outputs.current_version }}` to `${{ steps.version.outputs.version }}`
-
-            **Triggered by:** ${{ github.event_name == 'release' && format('[Release {0}]({1})', github.event.release.tag_name, github.event.release.html_url) || 'Manual workflow dispatch' }}
-
-          labels: automation
-          commit-message: "chore: bump ComfyUI to ${{ steps.version.outputs.version }}"

README.md

@@ -108,7 +108,7 @@ See what ComfyUI can do with the [example workflows](https://comfyanonymous.gith
 - [LCM models and Loras](https://comfyanonymous.github.io/ComfyUI_examples/lcm/)
 - Latent previews with [TAESD](#how-to-show-high-quality-previews)
 - Works fully offline: core will never download anything unless you want to.
-- Optional API nodes to use paid models from external providers through the online [Comfy API](https://docs.comfy.org/tutorials/api-nodes/overview) disable with: `--disable-api-nodes`
+- Optional API nodes to use paid models from external providers through the online [Comfy API](https://docs.comfy.org/tutorials/api-nodes/overview).
 - [Config file](extra_model_paths.yaml.example) to set the search paths for models.
 
 Workflow examples can be found on the [Examples page](https://comfyanonymous.github.io/ComfyUI_examples/)
@@ -183,7 +183,7 @@ Simply download, extract with [7-Zip](https://7-zip.org) or with the windows exp
 
 If you have trouble extracting it, right click the file -> properties -> unblock
 
-The portable above currently comes with python 3.13 and pytorch cuda 13.0. Update your Nvidia drivers if it doesn't start.
+Update your Nvidia drivers if it doesn't start.
 
 #### Alternative Downloads:
 
@@ -212,7 +212,7 @@ Python 3.14 works but you may encounter issues with the torch compile node. The
 
 Python 3.13 is very well supported. If you have trouble with some custom node dependencies on 3.13 you can try 3.12
 
-torch 2.4 and above is supported but some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old.
+torch 2.4 and above is supported but some features might only work on newer versions. We generally recommend using the latest major version of pytorch unless it is less than 2 weeks old.
 
 ### Instructions:
 
@@ -229,7 +229,7 @@ AMD users can install rocm and pytorch with pip if you don't have it already ins
 
 ```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.4```
 
-This is the command to install the nightly with ROCm 7.1 which might have some performance improvements:
+This is the command to install the nightly with ROCm 7.0 which might have some performance improvements:
 
 ```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm7.1```
 
@@ -240,7 +240,7 @@ These have less hardware support than the builds above but they work on windows.
 
 RDNA 3 (RX 7000 series):
 
-```pip install --pre torch torchvision torchaudio --index-url https://rocm.nightlies.amd.com/v2/gfx110X-all/```
+```pip install --pre torch torchvision torchaudio --index-url https://rocm.nightlies.amd.com/v2/gfx110X-dgpu/```
 
 RDNA 3.5 (Strix halo/Ryzen AI Max+ 365):
 

alembic_db/versions/0001_assets.py

@@ -1,174 +0,0 @@
-"""
-Initial assets schema
-Revision ID: 0001_assets
-Revises: None
-Create Date: 2025-12-10 00:00:00
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0001_assets"
-down_revision = None
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ASSETS: content identity
-    op.create_table(
-        "assets",
-        sa.Column("id", sa.String(length=36), primary_key=True),
-        sa.Column("hash", sa.String(length=256), nullable=True),
-        sa.Column("size_bytes", sa.BigInteger(), nullable=False, server_default="0"),
-        sa.Column("mime_type", sa.String(length=255), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=False), nullable=False),
-        sa.CheckConstraint("size_bytes >= 0", name="ck_assets_size_nonneg"),
-    )
-    op.create_index("uq_assets_hash", "assets", ["hash"], unique=True)
-    op.create_index("ix_assets_mime_type", "assets", ["mime_type"])
-
-    # ASSETS_INFO: user-visible references
-    op.create_table(
-        "assets_info",
-        sa.Column("id", sa.String(length=36), primary_key=True),
-        sa.Column("owner_id", sa.String(length=128), nullable=False, server_default=""),
-        sa.Column("name", sa.String(length=512), nullable=False),
-        sa.Column("asset_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="RESTRICT"), nullable=False),
-        sa.Column("preview_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="SET NULL"), nullable=True),
-        sa.Column("user_metadata", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("last_access_time", sa.DateTime(timezone=False), nullable=False),
-        sa.UniqueConstraint("asset_id", "owner_id", "name", name="uq_assets_info_asset_owner_name"),
-    )
-    op.create_index("ix_assets_info_owner_id", "assets_info", ["owner_id"])
-    op.create_index("ix_assets_info_asset_id", "assets_info", ["asset_id"])
-    op.create_index("ix_assets_info_name", "assets_info", ["name"])
-    op.create_index("ix_assets_info_created_at", "assets_info", ["created_at"])
-    op.create_index("ix_assets_info_last_access_time", "assets_info", ["last_access_time"])
-    op.create_index("ix_assets_info_owner_name", "assets_info", ["owner_id", "name"])
-
-    # TAGS: normalized tag vocabulary
-    op.create_table(
-        "tags",
-        sa.Column("name", sa.String(length=512), primary_key=True),
-        sa.Column("tag_type", sa.String(length=32), nullable=False, server_default="user"),
-        sa.CheckConstraint("name = lower(name)", name="ck_tags_lowercase"),
-    )
-    op.create_index("ix_tags_tag_type", "tags", ["tag_type"])
-
-    # ASSET_INFO_TAGS: many-to-many for tags on AssetInfo
-    op.create_table(
-        "asset_info_tags",
-        sa.Column("asset_info_id", sa.String(length=36), sa.ForeignKey("assets_info.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("tag_name", sa.String(length=512), sa.ForeignKey("tags.name", ondelete="RESTRICT"), nullable=False),
-        sa.Column("origin", sa.String(length=32), nullable=False, server_default="manual"),
-        sa.Column("added_at", sa.DateTime(timezone=False), nullable=False),
-        sa.PrimaryKeyConstraint("asset_info_id", "tag_name", name="pk_asset_info_tags"),
-    )
-    op.create_index("ix_asset_info_tags_tag_name", "asset_info_tags", ["tag_name"])
-    op.create_index("ix_asset_info_tags_asset_info_id", "asset_info_tags", ["asset_info_id"])
-
-    # ASSET_CACHE_STATE: N:1 local cache rows per Asset
-    op.create_table(
-        "asset_cache_state",
-        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
-        sa.Column("asset_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("file_path", sa.Text(), nullable=False),  # absolute local path to cached file
-        sa.Column("mtime_ns", sa.BigInteger(), nullable=True),
-        sa.Column("needs_verify", sa.Boolean(), nullable=False, server_default=sa.text("false")),
-        sa.CheckConstraint("(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_acs_mtime_nonneg"),
-        sa.UniqueConstraint("file_path", name="uq_asset_cache_state_file_path"),
-    )
-    op.create_index("ix_asset_cache_state_file_path", "asset_cache_state", ["file_path"])
-    op.create_index("ix_asset_cache_state_asset_id", "asset_cache_state", ["asset_id"])
-
-    # ASSET_INFO_META: typed KV projection of user_metadata for filtering/sorting
-    op.create_table(
-        "asset_info_meta",
-        sa.Column("asset_info_id", sa.String(length=36), sa.ForeignKey("assets_info.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("key", sa.String(length=256), nullable=False),
-        sa.Column("ordinal", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("val_str", sa.String(length=2048), nullable=True),
-        sa.Column("val_num", sa.Numeric(38, 10), nullable=True),
-        sa.Column("val_bool", sa.Boolean(), nullable=True),
-        sa.Column("val_json", sa.JSON(), nullable=True),
-        sa.PrimaryKeyConstraint("asset_info_id", "key", "ordinal", name="pk_asset_info_meta"),
-    )
-    op.create_index("ix_asset_info_meta_key", "asset_info_meta", ["key"])
-    op.create_index("ix_asset_info_meta_key_val_str", "asset_info_meta", ["key", "val_str"])
-    op.create_index("ix_asset_info_meta_key_val_num", "asset_info_meta", ["key", "val_num"])
-    op.create_index("ix_asset_info_meta_key_val_bool", "asset_info_meta", ["key", "val_bool"])
-
-    # Tags vocabulary
-    tags_table = sa.table(
-        "tags",
-        sa.column("name", sa.String(length=512)),
-        sa.column("tag_type", sa.String()),
-    )
-    op.bulk_insert(
-        tags_table,
-        [
-            {"name": "models", "tag_type": "system"},
-            {"name": "input", "tag_type": "system"},
-            {"name": "output", "tag_type": "system"},
-
-            {"name": "configs", "tag_type": "system"},
-            {"name": "checkpoints", "tag_type": "system"},
-            {"name": "loras", "tag_type": "system"},
-            {"name": "vae", "tag_type": "system"},
-            {"name": "text_encoders", "tag_type": "system"},
-            {"name": "diffusion_models", "tag_type": "system"},
-            {"name": "clip_vision", "tag_type": "system"},
-            {"name": "style_models", "tag_type": "system"},
-            {"name": "embeddings", "tag_type": "system"},
-            {"name": "diffusers", "tag_type": "system"},
-            {"name": "vae_approx", "tag_type": "system"},
-            {"name": "controlnet", "tag_type": "system"},
-            {"name": "gligen", "tag_type": "system"},
-            {"name": "upscale_models", "tag_type": "system"},
-            {"name": "hypernetworks", "tag_type": "system"},
-            {"name": "photomaker", "tag_type": "system"},
-            {"name": "classifiers", "tag_type": "system"},
-
-            {"name": "encoder", "tag_type": "system"},
-            {"name": "decoder", "tag_type": "system"},
-
-            {"name": "missing", "tag_type": "system"},
-            {"name": "rescan", "tag_type": "system"},
-        ],
-    )
-
-
-def downgrade() -> None:
-    op.drop_index("ix_asset_info_meta_key_val_bool", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key_val_num", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key_val_str", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key", table_name="asset_info_meta")
-    op.drop_table("asset_info_meta")
-
-    op.drop_index("ix_asset_cache_state_asset_id", table_name="asset_cache_state")
-    op.drop_index("ix_asset_cache_state_file_path", table_name="asset_cache_state")
-    op.drop_constraint("uq_asset_cache_state_file_path", table_name="asset_cache_state")
-    op.drop_table("asset_cache_state")
-
-    op.drop_index("ix_asset_info_tags_asset_info_id", table_name="asset_info_tags")
-    op.drop_index("ix_asset_info_tags_tag_name", table_name="asset_info_tags")
-    op.drop_table("asset_info_tags")
-
-    op.drop_index("ix_tags_tag_type", table_name="tags")
-    op.drop_table("tags")
-
-    op.drop_constraint("uq_assets_info_asset_owner_name", table_name="assets_info")
-    op.drop_index("ix_assets_info_owner_name", table_name="assets_info")
-    op.drop_index("ix_assets_info_last_access_time", table_name="assets_info")
-    op.drop_index("ix_assets_info_created_at", table_name="assets_info")
-    op.drop_index("ix_assets_info_name", table_name="assets_info")
-    op.drop_index("ix_assets_info_asset_id", table_name="assets_info")
-    op.drop_index("ix_assets_info_owner_id", table_name="assets_info")
-    op.drop_table("assets_info")
-
-    op.drop_index("uq_assets_hash", table_name="assets")
-    op.drop_index("ix_assets_mime_type", table_name="assets")
-    op.drop_table("assets")

app/assets/api/routes.py

@@ -1,102 +0,0 @@
-import logging
-import uuid
-from aiohttp import web
-
-from pydantic import ValidationError
-
-import app.assets.manager as manager
-from app import user_manager
-from app.assets.api import schemas_in
-from app.assets.helpers import get_query_dict
-
-ROUTES = web.RouteTableDef()
-USER_MANAGER: user_manager.UserManager | None = None
-
-# UUID regex (canonical hyphenated form, case-insensitive)
-UUID_RE = r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
-
-def register_assets_system(app: web.Application, user_manager_instance: user_manager.UserManager) -> None:
-    global USER_MANAGER
-    USER_MANAGER = user_manager_instance
-    app.add_routes(ROUTES)
-
-def _error_response(status: int, code: str, message: str, details: dict | None = None) -> web.Response:
-    return web.json_response({"error": {"code": code, "message": message, "details": details or {}}}, status=status)
-
-
-def _validation_error_response(code: str, ve: ValidationError) -> web.Response:
-    return _error_response(400, code, "Validation failed.", {"errors": ve.json()})
-
-
-@ROUTES.get("/api/assets")
-async def list_assets(request: web.Request) -> web.Response:
-    """
-    GET request to list assets.
-    """
-    query_dict = get_query_dict(request)
-    try:
-        q = schemas_in.ListAssetsQuery.model_validate(query_dict)
-    except ValidationError as ve:
-        return _validation_error_response("INVALID_QUERY", ve)
-
-    payload = manager.list_assets(
-        include_tags=q.include_tags,
-        exclude_tags=q.exclude_tags,
-        name_contains=q.name_contains,
-        metadata_filter=q.metadata_filter,
-        limit=q.limit,
-        offset=q.offset,
-        sort=q.sort,
-        order=q.order,
-        owner_id=USER_MANAGER.get_request_user_id(request),
-    )
-    return web.json_response(payload.model_dump(mode="json"))
-
-
-@ROUTES.get(f"/api/assets/{{id:{UUID_RE}}}")
-async def get_asset(request: web.Request) -> web.Response:
-    """
-    GET request to get an asset's info as JSON.
-    """
-    asset_info_id = str(uuid.UUID(request.match_info["id"]))
-    try:
-        result = manager.get_asset(
-            asset_info_id=asset_info_id,
-            owner_id=USER_MANAGER.get_request_user_id(request),
-        )
-    except ValueError as e:
-        return _error_response(404, "ASSET_NOT_FOUND", str(e), {"id": asset_info_id})
-    except Exception:
-        logging.exception(
-            "get_asset failed for asset_info_id=%s, owner_id=%s",
-            asset_info_id,
-            USER_MANAGER.get_request_user_id(request),
-        )
-        return _error_response(500, "INTERNAL", "Unexpected server error.")
-    return web.json_response(result.model_dump(mode="json"), status=200)
-
-
-@ROUTES.get("/api/tags")
-async def get_tags(request: web.Request) -> web.Response:
-    """
-    GET request to list all tags based on query parameters.
-    """
-    query_map = dict(request.rel_url.query)
-
-    try:
-        query = schemas_in.TagsListQuery.model_validate(query_map)
-    except ValidationError as e:
-        return web.json_response(
-            {"error": {"code": "INVALID_QUERY", "message": "Invalid query parameters", "details": e.errors()}},
-            status=400,
-        )
-
-    result = manager.list_tags(
-        prefix=query.prefix,
-        limit=query.limit,
-        offset=query.offset,
-        order=query.order,
-        include_zero=query.include_zero,
-        owner_id=USER_MANAGER.get_request_user_id(request),
-    )
-    return web.json_response(result.model_dump(mode="json"))

app/assets/api/schemas_in.py

@@ -1,94 +0,0 @@
-import json
-import uuid
-from typing import Any, Literal
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    conint,
-    field_validator,
-)
-
-
-class ListAssetsQuery(BaseModel):
-    include_tags: list[str] = Field(default_factory=list)
-    exclude_tags: list[str] = Field(default_factory=list)
-    name_contains: str | None = None
-
-    # Accept either a JSON string (query param) or a dict
-    metadata_filter: dict[str, Any] | None = None
-
-    limit: conint(ge=1, le=500) = 20
-    offset: conint(ge=0) = 0
-
-    sort: Literal["name", "created_at", "updated_at", "size", "last_access_time"] = "created_at"
-    order: Literal["asc", "desc"] = "desc"
-
-    @field_validator("include_tags", "exclude_tags", mode="before")
-    @classmethod
-    def _split_csv_tags(cls, v):
-        # Accept "a,b,c" or ["a","b"] (we are liberal in what we accept)
-        if v is None:
-            return []
-        if isinstance(v, str):
-            return [t.strip() for t in v.split(",") if t.strip()]
-        if isinstance(v, list):
-            out: list[str] = []
-            for item in v:
-                if isinstance(item, str):
-                    out.extend([t.strip() for t in item.split(",") if t.strip()])
-            return out
-        return v
-
-    @field_validator("metadata_filter", mode="before")
-    @classmethod
-    def _parse_metadata_json(cls, v):
-        if v is None or isinstance(v, dict):
-            return v
-        if isinstance(v, str) and v.strip():
-            try:
-                parsed = json.loads(v)
-            except Exception as e:
-                raise ValueError(f"metadata_filter must be JSON: {e}") from e
-            if not isinstance(parsed, dict):
-                raise ValueError("metadata_filter must be a JSON object")
-            return parsed
-        return None
-
-
-class TagsListQuery(BaseModel):
-    model_config = ConfigDict(extra="ignore", str_strip_whitespace=True)
-
-    prefix: str | None = Field(None, min_length=1, max_length=256)
-    limit: int = Field(100, ge=1, le=1000)
-    offset: int = Field(0, ge=0, le=10_000_000)
-    order: Literal["count_desc", "name_asc"] = "count_desc"
-    include_zero: bool = True
-
-    @field_validator("prefix")
-    @classmethod
-    def normalize_prefix(cls, v: str | None) -> str | None:
-        if v is None:
-            return v
-        v = v.strip()
-        return v.lower() or None
-
-
-class SetPreviewBody(BaseModel):
-    """Set or clear the preview for an AssetInfo. Provide an Asset.id or null."""
-    preview_id: str | None = None
-
-    @field_validator("preview_id", mode="before")
-    @classmethod
-    def _norm_uuid(cls, v):
-        if v is None:
-            return None
-        s = str(v).strip()
-        if not s:
-            return None
-        try:
-            uuid.UUID(s)
-        except Exception:
-            raise ValueError("preview_id must be a UUID")
-        return s

app/assets/api/schemas_out.py

@@ -1,60 +0,0 @@
-from datetime import datetime
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict, Field, field_serializer
-
-
-class AssetSummary(BaseModel):
-    id: str
-    name: str
-    asset_hash: str | None = None
-    size: int | None = None
-    mime_type: str | None = None
-    tags: list[str] = Field(default_factory=list)
-    preview_url: str | None = None
-    created_at: datetime | None = None
-    updated_at: datetime | None = None
-    last_access_time: datetime | None = None
-
-    model_config = ConfigDict(from_attributes=True)
-
-    @field_serializer("created_at", "updated_at", "last_access_time")
-    def _ser_dt(self, v: datetime | None, _info):
-        return v.isoformat() if v else None
-
-
-class AssetsList(BaseModel):
-    assets: list[AssetSummary]
-    total: int
-    has_more: bool
-
-
-class AssetDetail(BaseModel):
-    id: str
-    name: str
-    asset_hash: str | None = None
-    size: int | None = None
-    mime_type: str | None = None
-    tags: list[str] = Field(default_factory=list)
-    user_metadata: dict[str, Any] = Field(default_factory=dict)
-    preview_id: str | None = None
-    created_at: datetime | None = None
-    last_access_time: datetime | None = None
-
-    model_config = ConfigDict(from_attributes=True)
-
-    @field_serializer("created_at", "last_access_time")
-    def _ser_dt(self, v: datetime | None, _info):
-        return v.isoformat() if v else None
-
-
-class TagUsage(BaseModel):
-    name: str
-    count: int
-    type: str
-
-
-class TagsList(BaseModel):
-    tags: list[TagUsage] = Field(default_factory=list)
-    total: int
-    has_more: bool

app/assets/database/bulk_ops.py

@@ -1,204 +0,0 @@
-import os
-import uuid
-import sqlalchemy
-from typing import Iterable
-from sqlalchemy.orm import Session
-from sqlalchemy.dialects import sqlite
-
-from app.assets.helpers import utcnow
-from app.assets.database.models import Asset, AssetCacheState, AssetInfo, AssetInfoTag, AssetInfoMeta
-
-MAX_BIND_PARAMS = 800
-
-def _chunk_rows(rows: list[dict], cols_per_row: int, max_bind_params: int) -> Iterable[list[dict]]:
-    if not rows:
-        return []
-    rows_per_stmt = max(1, max_bind_params // max(1, cols_per_row))
-    for i in range(0, len(rows), rows_per_stmt):
-        yield rows[i:i + rows_per_stmt]
-
-def _iter_chunks(seq, n: int):
-    for i in range(0, len(seq), n):
-        yield seq[i:i + n]
-
-def _rows_per_stmt(cols: int) -> int:
-    return max(1, MAX_BIND_PARAMS // max(1, cols))
-
-
-def seed_from_paths_batch(
-    session: Session,
-    *,
-    specs: list[dict],
-    owner_id: str = "",
-) -> dict:
-    """Each spec is a dict with keys:
-      - abs_path: str
-      - size_bytes: int
-      - mtime_ns: int
-      - info_name: str
-      - tags: list[str]
-      - fname: Optional[str]
-    """
-    if not specs:
-        return {"inserted_infos": 0, "won_states": 0, "lost_states": 0}
-
-    now = utcnow()
-    asset_rows: list[dict] = []
-    state_rows: list[dict] = []
-    path_to_asset: dict[str, str] = {}
-    asset_to_info: dict[str, dict] = {}  # asset_id -> prepared info row
-    path_list: list[str] = []
-
-    for sp in specs:
-        ap = os.path.abspath(sp["abs_path"])
-        aid = str(uuid.uuid4())
-        iid = str(uuid.uuid4())
-        path_list.append(ap)
-        path_to_asset[ap] = aid
-
-        asset_rows.append(
-            {
-                "id": aid,
-                "hash": None,
-                "size_bytes": sp["size_bytes"],
-                "mime_type": None,
-                "created_at": now,
-            }
-        )
-        state_rows.append(
-            {
-                "asset_id": aid,
-                "file_path": ap,
-                "mtime_ns": sp["mtime_ns"],
-            }
-        )
-        asset_to_info[aid] = {
-            "id": iid,
-            "owner_id": owner_id,
-            "name": sp["info_name"],
-            "asset_id": aid,
-            "preview_id": None,
-            "user_metadata": {"filename": sp["fname"]} if sp["fname"] else None,
-            "created_at": now,
-            "updated_at": now,
-            "last_access_time": now,
-            "_tags": sp["tags"],
-            "_filename": sp["fname"],
-        }
-
-    # insert all seed Assets (hash=NULL)
-    ins_asset = sqlite.insert(Asset)
-    for chunk in _iter_chunks(asset_rows, _rows_per_stmt(5)):
-        session.execute(ins_asset, chunk)
-
-    # try to claim AssetCacheState (file_path)
-    # Insert with ON CONFLICT DO NOTHING, then query to find which paths were actually inserted
-    ins_state = (
-        sqlite.insert(AssetCacheState)
-        .on_conflict_do_nothing(index_elements=[AssetCacheState.file_path])
-    )
-    for chunk in _iter_chunks(state_rows, _rows_per_stmt(3)):
-        session.execute(ins_state, chunk)
-
-    # Query to find which of our paths won (were actually inserted)
-    winners_by_path: set[str] = set()
-    for chunk in _iter_chunks(path_list, MAX_BIND_PARAMS):
-        result = session.execute(
-            sqlalchemy.select(AssetCacheState.file_path)
-            .where(AssetCacheState.file_path.in_(chunk))
-            .where(AssetCacheState.asset_id.in_([path_to_asset[p] for p in chunk]))
-        )
-        winners_by_path.update(result.scalars().all())
-
-    all_paths_set = set(path_list)
-    losers_by_path = all_paths_set - winners_by_path
-    lost_assets = [path_to_asset[p] for p in losers_by_path]
-    if lost_assets:  # losers get their Asset removed
-        for id_chunk in _iter_chunks(lost_assets, MAX_BIND_PARAMS):
-            session.execute(sqlalchemy.delete(Asset).where(Asset.id.in_(id_chunk)))
-
-    if not winners_by_path:
-        return {"inserted_infos": 0, "won_states": 0, "lost_states": len(losers_by_path)}
-
-    # insert AssetInfo only for winners
-    # Insert with ON CONFLICT DO NOTHING, then query to find which were actually inserted
-    winner_info_rows = [asset_to_info[path_to_asset[p]] for p in winners_by_path]
-    ins_info = (
-        sqlite.insert(AssetInfo)
-        .on_conflict_do_nothing(index_elements=[AssetInfo.asset_id, AssetInfo.owner_id, AssetInfo.name])
-    )
-    for chunk in _iter_chunks(winner_info_rows, _rows_per_stmt(9)):
-        session.execute(ins_info, chunk)
-
-    # Query to find which info rows were actually inserted (by matching our generated IDs)
-    all_info_ids = [row["id"] for row in winner_info_rows]
-    inserted_info_ids: set[str] = set()
-    for chunk in _iter_chunks(all_info_ids, MAX_BIND_PARAMS):
-        result = session.execute(
-            sqlalchemy.select(AssetInfo.id).where(AssetInfo.id.in_(chunk))
-        )
-        inserted_info_ids.update(result.scalars().all())
-
-    # build and insert tag + meta rows for the AssetInfo
-    tag_rows: list[dict] = []
-    meta_rows: list[dict] = []
-    if inserted_info_ids:
-        for row in winner_info_rows:
-            iid = row["id"]
-            if iid not in inserted_info_ids:
-                continue
-            for t in row["_tags"]:
-                tag_rows.append({
-                    "asset_info_id": iid,
-                    "tag_name": t,
-                    "origin": "automatic",
-                    "added_at": now,
-                })
-            if row["_filename"]:
-                meta_rows.append(
-                    {
-                        "asset_info_id": iid,
-                        "key": "filename",
-                        "ordinal": 0,
-                        "val_str": row["_filename"],
-                        "val_num": None,
-                        "val_bool": None,
-                        "val_json": None,
-                    }
-                )
-
-    bulk_insert_tags_and_meta(session, tag_rows=tag_rows, meta_rows=meta_rows, max_bind_params=MAX_BIND_PARAMS)
-    return {
-        "inserted_infos": len(inserted_info_ids),
-        "won_states": len(winners_by_path),
-        "lost_states": len(losers_by_path),
-    }
-
-
-def bulk_insert_tags_and_meta(
-    session: Session,
-    *,
-    tag_rows: list[dict],
-    meta_rows: list[dict],
-    max_bind_params: int,
-) -> None:
-    """Batch insert into asset_info_tags and asset_info_meta with ON CONFLICT DO NOTHING.
-    - tag_rows keys: asset_info_id, tag_name, origin, added_at
-    - meta_rows keys: asset_info_id, key, ordinal, val_str, val_num, val_bool, val_json
-    """
-    if tag_rows:
-        ins_links = (
-            sqlite.insert(AssetInfoTag)
-            .on_conflict_do_nothing(index_elements=[AssetInfoTag.asset_info_id, AssetInfoTag.tag_name])
-        )
-        for chunk in _chunk_rows(tag_rows, cols_per_row=4, max_bind_params=max_bind_params):
-            session.execute(ins_links, chunk)
-    if meta_rows:
-        ins_meta = (
-            sqlite.insert(AssetInfoMeta)
-            .on_conflict_do_nothing(
-                index_elements=[AssetInfoMeta.asset_info_id, AssetInfoMeta.key, AssetInfoMeta.ordinal]
-            )
-        )
-        for chunk in _chunk_rows(meta_rows, cols_per_row=7, max_bind_params=max_bind_params):
-            session.execute(ins_meta, chunk)

app/assets/database/models.py

@@ -1,233 +0,0 @@
-from __future__ import annotations
-
-import uuid
-from datetime import datetime
-
-from typing import Any
-from sqlalchemy import (
-    JSON,
-    BigInteger,
-    Boolean,
-    CheckConstraint,
-    DateTime,
-    ForeignKey,
-    Index,
-    Integer,
-    Numeric,
-    String,
-    Text,
-    UniqueConstraint,
-)
-from sqlalchemy.orm import Mapped, foreign, mapped_column, relationship
-
-from app.assets.helpers import utcnow
-from app.database.models import to_dict, Base
-
-
-class Asset(Base):
-    __tablename__ = "assets"
-
-    id: Mapped[str] = mapped_column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    hash: Mapped[str | None] = mapped_column(String(256), nullable=True)
-    size_bytes: Mapped[int] = mapped_column(BigInteger, nullable=False, default=0)
-    mime_type: Mapped[str | None] = mapped_column(String(255))
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=False), nullable=False, default=utcnow
-    )
-
-    infos: Mapped[list[AssetInfo]] = relationship(
-        "AssetInfo",
-        back_populates="asset",
-        primaryjoin=lambda: Asset.id == foreign(AssetInfo.asset_id),
-        foreign_keys=lambda: [AssetInfo.asset_id],
-        cascade="all,delete-orphan",
-        passive_deletes=True,
-    )
-
-    preview_of: Mapped[list[AssetInfo]] = relationship(
-        "AssetInfo",
-        back_populates="preview_asset",
-        primaryjoin=lambda: Asset.id == foreign(AssetInfo.preview_id),
-        foreign_keys=lambda: [AssetInfo.preview_id],
-        viewonly=True,
-    )
-
-    cache_states: Mapped[list[AssetCacheState]] = relationship(
-        back_populates="asset",
-        cascade="all, delete-orphan",
-        passive_deletes=True,
-    )
-
-    __table_args__ = (
-        Index("uq_assets_hash", "hash", unique=True),
-        Index("ix_assets_mime_type", "mime_type"),
-        CheckConstraint("size_bytes >= 0", name="ck_assets_size_nonneg"),
-    )
-
-    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
-        return to_dict(self, include_none=include_none)
-
-    def __repr__(self) -> str:
-        return f"<Asset id={self.id} hash={(self.hash or '')[:12]}>"
-
-
-class AssetCacheState(Base):
-    __tablename__ = "asset_cache_state"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    asset_id: Mapped[str] = mapped_column(String(36), ForeignKey("assets.id", ondelete="CASCADE"), nullable=False)
-    file_path: Mapped[str] = mapped_column(Text, nullable=False)
-    mtime_ns: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
-    needs_verify: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-
-    asset: Mapped[Asset] = relationship(back_populates="cache_states")
-
-    __table_args__ = (
-        Index("ix_asset_cache_state_file_path", "file_path"),
-        Index("ix_asset_cache_state_asset_id", "asset_id"),
-        CheckConstraint("(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_acs_mtime_nonneg"),
-        UniqueConstraint("file_path", name="uq_asset_cache_state_file_path"),
-    )
-
-    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
-        return to_dict(self, include_none=include_none)
-
-    def __repr__(self) -> str:
-        return f"<AssetCacheState id={self.id} asset_id={self.asset_id} path={self.file_path!r}>"
-
-
-class AssetInfo(Base):
-    __tablename__ = "assets_info"
-
-    id: Mapped[str] = mapped_column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    owner_id: Mapped[str] = mapped_column(String(128), nullable=False, default="")
-    name: Mapped[str] = mapped_column(String(512), nullable=False)
-    asset_id: Mapped[str] = mapped_column(String(36), ForeignKey("assets.id", ondelete="RESTRICT"), nullable=False)
-    preview_id: Mapped[str | None] = mapped_column(String(36), ForeignKey("assets.id", ondelete="SET NULL"))
-    user_metadata: Mapped[dict[str, Any] | None] = mapped_column(JSON(none_as_null=True))
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=False), nullable=False, default=utcnow)
-    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=False), nullable=False, default=utcnow)
-    last_access_time: Mapped[datetime] = mapped_column(DateTime(timezone=False), nullable=False, default=utcnow)
-
-    asset: Mapped[Asset] = relationship(
-        "Asset",
-        back_populates="infos",
-        foreign_keys=[asset_id],
-        lazy="selectin",
-    )
-    preview_asset: Mapped[Asset | None] = relationship(
-        "Asset",
-        back_populates="preview_of",
-        foreign_keys=[preview_id],
-    )
-
-    metadata_entries: Mapped[list[AssetInfoMeta]] = relationship(
-        back_populates="asset_info",
-        cascade="all,delete-orphan",
-        passive_deletes=True,
-    )
-
-    tag_links: Mapped[list[AssetInfoTag]] = relationship(
-        back_populates="asset_info",
-        cascade="all,delete-orphan",
-        passive_deletes=True,
-        overlaps="tags,asset_infos",
-    )
-
-    tags: Mapped[list[Tag]] = relationship(
-        secondary="asset_info_tags",
-        back_populates="asset_infos",
-        lazy="selectin",
-        viewonly=True,
-        overlaps="tag_links,asset_info_links,asset_infos,tag",
-    )
-
-    __table_args__ = (
-        UniqueConstraint("asset_id", "owner_id", "name", name="uq_assets_info_asset_owner_name"),
-        Index("ix_assets_info_owner_name", "owner_id", "name"),
-        Index("ix_assets_info_owner_id", "owner_id"),
-        Index("ix_assets_info_asset_id", "asset_id"),
-        Index("ix_assets_info_name", "name"),
-        Index("ix_assets_info_created_at", "created_at"),
-        Index("ix_assets_info_last_access_time", "last_access_time"),
-    )
-
-    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
-        data = to_dict(self, include_none=include_none)
-        data["tags"] = [t.name for t in self.tags]
-        return data
-
-    def __repr__(self) -> str:
-        return f"<AssetInfo id={self.id} name={self.name!r} asset_id={self.asset_id}>"
-
-
-class AssetInfoMeta(Base):
-    __tablename__ = "asset_info_meta"
-
-    asset_info_id: Mapped[str] = mapped_column(
-        String(36), ForeignKey("assets_info.id", ondelete="CASCADE"), primary_key=True
-    )
-    key: Mapped[str] = mapped_column(String(256), primary_key=True)
-    ordinal: Mapped[int] = mapped_column(Integer, primary_key=True, default=0)
-
-    val_str: Mapped[str | None] = mapped_column(String(2048), nullable=True)
-    val_num: Mapped[float | None] = mapped_column(Numeric(38, 10), nullable=True)
-    val_bool: Mapped[bool | None] = mapped_column(Boolean, nullable=True)
-    val_json: Mapped[Any | None] = mapped_column(JSON(none_as_null=True), nullable=True)
-
-    asset_info: Mapped[AssetInfo] = relationship(back_populates="metadata_entries")
-
-    __table_args__ = (
-        Index("ix_asset_info_meta_key", "key"),
-        Index("ix_asset_info_meta_key_val_str", "key", "val_str"),
-        Index("ix_asset_info_meta_key_val_num", "key", "val_num"),
-        Index("ix_asset_info_meta_key_val_bool", "key", "val_bool"),
-    )
-
-
-class AssetInfoTag(Base):
-    __tablename__ = "asset_info_tags"
-
-    asset_info_id: Mapped[str] = mapped_column(
-        String(36), ForeignKey("assets_info.id", ondelete="CASCADE"), primary_key=True
-    )
-    tag_name: Mapped[str] = mapped_column(
-        String(512), ForeignKey("tags.name", ondelete="RESTRICT"), primary_key=True
-    )
-    origin: Mapped[str] = mapped_column(String(32), nullable=False, default="manual")
-    added_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=False), nullable=False, default=utcnow
-    )
-
-    asset_info: Mapped[AssetInfo] = relationship(back_populates="tag_links")
-    tag: Mapped[Tag] = relationship(back_populates="asset_info_links")
-
-    __table_args__ = (
-        Index("ix_asset_info_tags_tag_name", "tag_name"),
-        Index("ix_asset_info_tags_asset_info_id", "asset_info_id"),
-    )
-
-
-class Tag(Base):
-    __tablename__ = "tags"
-
-    name: Mapped[str] = mapped_column(String(512), primary_key=True)
-    tag_type: Mapped[str] = mapped_column(String(32), nullable=False, default="user")
-
-    asset_info_links: Mapped[list[AssetInfoTag]] = relationship(
-        back_populates="tag",
-        overlaps="asset_infos,tags",
-    )
-    asset_infos: Mapped[list[AssetInfo]] = relationship(
-        secondary="asset_info_tags",
-        back_populates="tags",
-        viewonly=True,
-        overlaps="asset_info_links,tag_links,tags,asset_info",
-    )
-
-    __table_args__ = (
-        Index("ix_tags_tag_type", "tag_type"),
-    )
-
-    def __repr__(self) -> str:
-        return f"<Tag {self.name}>"

app/assets/database/queries.py

@@ -1,267 +0,0 @@
-import sqlalchemy as sa
-from collections import defaultdict
-from sqlalchemy import select, exists, func
-from sqlalchemy.orm import Session, contains_eager, noload
-from app.assets.database.models import Asset, AssetInfo, AssetInfoMeta, AssetInfoTag, Tag
-from app.assets.helpers import escape_like_prefix, normalize_tags
-from typing import Sequence
-
-
-def visible_owner_clause(owner_id: str) -> sa.sql.ClauseElement:
-    """Build owner visibility predicate for reads. Owner-less rows are visible to everyone."""
-    owner_id = (owner_id or "").strip()
-    if owner_id == "":
-        return AssetInfo.owner_id == ""
-    return AssetInfo.owner_id.in_(["", owner_id])
-
-
-def apply_tag_filters(
-    stmt: sa.sql.Select,
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-) -> sa.sql.Select:
-    """include_tags: every tag must be present; exclude_tags: none may be present."""
-    include_tags = normalize_tags(include_tags)
-    exclude_tags = normalize_tags(exclude_tags)
-
-    if include_tags:
-        for tag_name in include_tags:
-            stmt = stmt.where(
-                exists().where(
-                    (AssetInfoTag.asset_info_id == AssetInfo.id)
-                    & (AssetInfoTag.tag_name == tag_name)
-                )
-            )
-
-    if exclude_tags:
-        stmt = stmt.where(
-            ~exists().where(
-                (AssetInfoTag.asset_info_id == AssetInfo.id)
-                & (AssetInfoTag.tag_name.in_(exclude_tags))
-            )
-        )
-    return stmt
-
-def apply_metadata_filter(
-    stmt: sa.sql.Select,
-    metadata_filter: dict | None = None,
-) -> sa.sql.Select:
-    """Apply filters using asset_info_meta projection table."""
-    if not metadata_filter:
-        return stmt
-
-    def _exists_for_pred(key: str, *preds) -> sa.sql.ClauseElement:
-        return sa.exists().where(
-            AssetInfoMeta.asset_info_id == AssetInfo.id,
-            AssetInfoMeta.key == key,
-            *preds,
-        )
-
-    def _exists_clause_for_value(key: str, value) -> sa.sql.ClauseElement:
-        if value is None:
-            no_row_for_key = sa.not_(
-                sa.exists().where(
-                    AssetInfoMeta.asset_info_id == AssetInfo.id,
-                    AssetInfoMeta.key == key,
-                )
-            )
-            null_row = _exists_for_pred(
-                key,
-                AssetInfoMeta.val_json.is_(None),
-                AssetInfoMeta.val_str.is_(None),
-                AssetInfoMeta.val_num.is_(None),
-                AssetInfoMeta.val_bool.is_(None),
-            )
-            return sa.or_(no_row_for_key, null_row)
-
-        if isinstance(value, bool):
-            return _exists_for_pred(key, AssetInfoMeta.val_bool == bool(value))
-        if isinstance(value, (int, float)):
-            from decimal import Decimal
-            num = value if isinstance(value, Decimal) else Decimal(str(value))
-            return _exists_for_pred(key, AssetInfoMeta.val_num == num)
-        if isinstance(value, str):
-            return _exists_for_pred(key, AssetInfoMeta.val_str == value)
-        return _exists_for_pred(key, AssetInfoMeta.val_json == value)
-
-    for k, v in metadata_filter.items():
-        if isinstance(v, list):
-            ors = [_exists_clause_for_value(k, elem) for elem in v]
-            if ors:
-                stmt = stmt.where(sa.or_(*ors))
-        else:
-            stmt = stmt.where(_exists_clause_for_value(k, v))
-    return stmt
-
-
-def asset_exists_by_hash(session: Session, asset_hash: str) -> bool:
-    """
-    Check if an asset with a given hash exists in database.
-    """
-    row = (
-        session.execute(
-            select(sa.literal(True)).select_from(Asset).where(Asset.hash == asset_hash).limit(1)
-        )
-    ).first()
-    return row is not None
-
-def get_asset_info_by_id(session: Session, asset_info_id: str) -> AssetInfo | None:
-    return session.get(AssetInfo, asset_info_id)
-
-def list_asset_infos_page(
-    session: Session,
-    owner_id: str = "",
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-    name_contains: str | None = None,
-    metadata_filter: dict | None = None,
-    limit: int = 20,
-    offset: int = 0,
-    sort: str = "created_at",
-    order: str = "desc",
-) -> tuple[list[AssetInfo], dict[str, list[str]], int]:
-    base = (
-        select(AssetInfo)
-        .join(Asset, Asset.id == AssetInfo.asset_id)
-        .options(contains_eager(AssetInfo.asset), noload(AssetInfo.tags))
-        .where(visible_owner_clause(owner_id))
-    )
-
-    if name_contains:
-        escaped, esc = escape_like_prefix(name_contains)
-        base = base.where(AssetInfo.name.ilike(f"%{escaped}%", escape=esc))
-
-    base = apply_tag_filters(base, include_tags, exclude_tags)
-    base = apply_metadata_filter(base, metadata_filter)
-
-    sort = (sort or "created_at").lower()
-    order = (order or "desc").lower()
-    sort_map = {
-        "name": AssetInfo.name,
-        "created_at": AssetInfo.created_at,
-        "updated_at": AssetInfo.updated_at,
-        "last_access_time": AssetInfo.last_access_time,
-        "size": Asset.size_bytes,
-    }
-    sort_col = sort_map.get(sort, AssetInfo.created_at)
-    sort_exp = sort_col.desc() if order == "desc" else sort_col.asc()
-
-    base = base.order_by(sort_exp).limit(limit).offset(offset)
-
-    count_stmt = (
-        select(sa.func.count())
-        .select_from(AssetInfo)
-        .join(Asset, Asset.id == AssetInfo.asset_id)
-        .where(visible_owner_clause(owner_id))
-    )
-    if name_contains:
-        escaped, esc = escape_like_prefix(name_contains)
-        count_stmt = count_stmt.where(AssetInfo.name.ilike(f"%{escaped}%", escape=esc))
-    count_stmt = apply_tag_filters(count_stmt, include_tags, exclude_tags)
-    count_stmt = apply_metadata_filter(count_stmt, metadata_filter)
-
-    total = int((session.execute(count_stmt)).scalar_one() or 0)
-
-    infos = (session.execute(base)).unique().scalars().all()
-
-    id_list: list[str] = [i.id for i in infos]
-    tag_map: dict[str, list[str]] = defaultdict(list)
-    if id_list:
-        rows = session.execute(
-            select(AssetInfoTag.asset_info_id, Tag.name)
-            .join(Tag, Tag.name == AssetInfoTag.tag_name)
-            .where(AssetInfoTag.asset_info_id.in_(id_list))
-        )
-        for aid, tag_name in rows.all():
-            tag_map[aid].append(tag_name)
-
-    return infos, tag_map, total
-
-def fetch_asset_info_asset_and_tags(
-    session: Session,
-    asset_info_id: str,
-    owner_id: str = "",
-) -> tuple[AssetInfo, Asset, list[str]] | None:
-    stmt = (
-        select(AssetInfo, Asset, Tag.name)
-        .join(Asset, Asset.id == AssetInfo.asset_id)
-        .join(AssetInfoTag, AssetInfoTag.asset_info_id == AssetInfo.id, isouter=True)
-        .join(Tag, Tag.name == AssetInfoTag.tag_name, isouter=True)
-        .where(
-            AssetInfo.id == asset_info_id,
-            visible_owner_clause(owner_id),
-        )
-        .options(noload(AssetInfo.tags))
-        .order_by(Tag.name.asc())
-    )
-
-    rows = (session.execute(stmt)).all()
-    if not rows:
-        return None
-
-    first_info, first_asset, _ = rows[0]
-    tags: list[str] = []
-    seen: set[str] = set()
-    for _info, _asset, tag_name in rows:
-        if tag_name and tag_name not in seen:
-            seen.add(tag_name)
-            tags.append(tag_name)
-    return first_info, first_asset, tags
-
-def list_tags_with_usage(
-    session: Session,
-    prefix: str | None = None,
-    limit: int = 100,
-    offset: int = 0,
-    include_zero: bool = True,
-    order: str = "count_desc",
-    owner_id: str = "",
-) -> tuple[list[tuple[str, str, int]], int]:
-    counts_sq = (
-        select(
-            AssetInfoTag.tag_name.label("tag_name"),
-            func.count(AssetInfoTag.asset_info_id).label("cnt"),
-        )
-        .select_from(AssetInfoTag)
-        .join(AssetInfo, AssetInfo.id == AssetInfoTag.asset_info_id)
-        .where(visible_owner_clause(owner_id))
-        .group_by(AssetInfoTag.tag_name)
-        .subquery()
-    )
-
-    q = (
-        select(
-            Tag.name,
-            Tag.tag_type,
-            func.coalesce(counts_sq.c.cnt, 0).label("count"),
-        )
-        .select_from(Tag)
-        .join(counts_sq, counts_sq.c.tag_name == Tag.name, isouter=True)
-    )
-
-    if prefix:
-        escaped, esc = escape_like_prefix(prefix.strip().lower())
-        q = q.where(Tag.name.like(escaped + "%", escape=esc))
-
-    if not include_zero:
-        q = q.where(func.coalesce(counts_sq.c.cnt, 0) > 0)
-
-    if order == "name_asc":
-        q = q.order_by(Tag.name.asc())
-    else:
-        q = q.order_by(func.coalesce(counts_sq.c.cnt, 0).desc(), Tag.name.asc())
-
-    total_q = select(func.count()).select_from(Tag)
-    if prefix:
-        escaped, esc = escape_like_prefix(prefix.strip().lower())
-        total_q = total_q.where(Tag.name.like(escaped + "%", escape=esc))
-    if not include_zero:
-        total_q = total_q.where(
-            Tag.name.in_(select(AssetInfoTag.tag_name).group_by(AssetInfoTag.tag_name))
-        )
-
-    rows = (session.execute(q.limit(limit).offset(offset))).all()
-    total = (session.execute(total_q)).scalar_one()
-
-    rows_norm = [(name, ttype, int(count or 0)) for (name, ttype, count) in rows]
-    return rows_norm, int(total or 0)

app/assets/database/tags.py

@@ -1,62 +0,0 @@
-from typing import Iterable
-
-import sqlalchemy
-from sqlalchemy.orm import Session
-from sqlalchemy.dialects import sqlite
-
-from app.assets.helpers import normalize_tags, utcnow
-from app.assets.database.models import Tag, AssetInfoTag, AssetInfo
-
-
-def ensure_tags_exist(session: Session, names: Iterable[str], tag_type: str = "user") -> None:
-    wanted = normalize_tags(list(names))
-    if not wanted:
-        return
-    rows = [{"name": n, "tag_type": tag_type} for n in list(dict.fromkeys(wanted))]
-    ins = (
-            sqlite.insert(Tag)
-            .values(rows)
-            .on_conflict_do_nothing(index_elements=[Tag.name])
-        )
-    return session.execute(ins)
-
-def add_missing_tag_for_asset_id(
-    session: Session,
-    *,
-    asset_id: str,
-    origin: str = "automatic",
-) -> None:
-    select_rows = (
-        sqlalchemy.select(
-            AssetInfo.id.label("asset_info_id"),
-            sqlalchemy.literal("missing").label("tag_name"),
-            sqlalchemy.literal(origin).label("origin"),
-            sqlalchemy.literal(utcnow()).label("added_at"),
-        )
-        .where(AssetInfo.asset_id == asset_id)
-        .where(
-            sqlalchemy.not_(
-                sqlalchemy.exists().where((AssetInfoTag.asset_info_id == AssetInfo.id) & (AssetInfoTag.tag_name == "missing"))
-            )
-        )
-    )
-    session.execute(
-        sqlite.insert(AssetInfoTag)
-        .from_select(
-            ["asset_info_id", "tag_name", "origin", "added_at"],
-            select_rows,
-        )
-        .on_conflict_do_nothing(index_elements=[AssetInfoTag.asset_info_id, AssetInfoTag.tag_name])
-    )
-
-def remove_missing_tag_for_asset_id(
-    session: Session,
-    *,
-    asset_id: str,
-) -> None:
-    session.execute(
-        sqlalchemy.delete(AssetInfoTag).where(
-            AssetInfoTag.asset_info_id.in_(sqlalchemy.select(AssetInfo.id).where(AssetInfo.asset_id == asset_id)),
-            AssetInfoTag.tag_name == "missing",
-        )
-    )

app/assets/hashing.py

@@ -1,75 +0,0 @@
-from blake3 import blake3
-from typing import IO
-import os
-import asyncio
-
-
-DEFAULT_CHUNK = 8 * 1024 *1024 # 8MB
-
-# NOTE: this allows hashing different representations of a file-like object
-def blake3_hash(
-    fp: str | IO[bytes],
-    chunk_size: int = DEFAULT_CHUNK,
-) -> str:
-    """
-    Returns a BLAKE3 hex digest for ``fp``, which may be:
-      - a filename (str/bytes) or PathLike
-      - an open binary file object
-    If ``fp`` is a file object, it must be opened in **binary** mode and support
-    ``read``, ``seek``, and ``tell``. The function will seek to the start before
-    reading and will attempt to restore the original position afterward.
-    """
-    # duck typing to check if input is a file-like object
-    if hasattr(fp, "read"):
-        return _hash_file_obj(fp, chunk_size)
-
-    with open(os.fspath(fp), "rb") as f:
-        return _hash_file_obj(f, chunk_size)
-
-
-async def blake3_hash_async(
-    fp: str | IO[bytes],
-    chunk_size: int = DEFAULT_CHUNK,
-) -> str:
-    """Async wrapper for ``blake3_hash_sync``.
-    Uses a worker thread so the event loop remains responsive.
-    """
-    # If it is a path, open inside the worker thread to keep I/O off the loop.
-    if hasattr(fp, "read"):
-        return await asyncio.to_thread(blake3_hash, fp, chunk_size)
-
-    def _worker() -> str:
-        with open(os.fspath(fp), "rb") as f:
-            return _hash_file_obj(f, chunk_size)
-
-    return await asyncio.to_thread(_worker)
-
-
-def _hash_file_obj(file_obj: IO, chunk_size: int = DEFAULT_CHUNK) -> str:
-    """
-    Hash an already-open binary file object by streaming in chunks.
-    - Seeks to the beginning before reading (if supported).
-    - Restores the original position afterward (if tell/seek are supported).
-    """
-    if chunk_size <= 0:
-        chunk_size = DEFAULT_CHUNK
-
-    # in case file object is already open and not at the beginning, track so can be restored after hashing
-    orig_pos = file_obj.tell()
-
-    try:
-        # seek to the beginning before reading
-        if orig_pos != 0:
-            file_obj.seek(0)
-
-        h = blake3()
-        while True:
-            chunk = file_obj.read(chunk_size)
-            if not chunk:
-                break
-            h.update(chunk)
-        return h.hexdigest()
-    finally:
-        # restore original position in file object, if needed
-        if orig_pos != 0:
-            file_obj.seek(orig_pos)

app/assets/helpers.py

@@ -1,217 +0,0 @@
-import contextlib
-import os
-from aiohttp import web
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Literal, Any
-
-import folder_paths
-
-
-RootType = Literal["models", "input", "output"]
-ALLOWED_ROOTS: tuple[RootType, ...] = ("models", "input", "output")
-
-def get_query_dict(request: web.Request) -> dict[str, Any]:
-    """
-    Gets a dictionary of query parameters from the request.
-
-    'request.query' is a MultiMapping[str], needs to be converted to a dictionary to be validated by Pydantic.
-    """
-    query_dict = {
-        key: request.query.getall(key) if len(request.query.getall(key)) > 1 else request.query.get(key)
-        for key in request.query.keys()
-    }
-    return query_dict
-
-def list_tree(base_dir: str) -> list[str]:
-    out: list[str] = []
-    base_abs = os.path.abspath(base_dir)
-    if not os.path.isdir(base_abs):
-        return out
-    for dirpath, _subdirs, filenames in os.walk(base_abs, topdown=True, followlinks=False):
-        for name in filenames:
-            out.append(os.path.abspath(os.path.join(dirpath, name)))
-    return out
-
-def prefixes_for_root(root: RootType) -> list[str]:
-    if root == "models":
-        bases: list[str] = []
-        for _bucket, paths in get_comfy_models_folders():
-            bases.extend(paths)
-        return [os.path.abspath(p) for p in bases]
-    if root == "input":
-        return [os.path.abspath(folder_paths.get_input_directory())]
-    if root == "output":
-        return [os.path.abspath(folder_paths.get_output_directory())]
-    return []
-
-def escape_like_prefix(s: str, escape: str = "!") -> tuple[str, str]:
-    """Escapes %, _ and the escape char itself in a LIKE prefix.
-    Returns (escaped_prefix, escape_char). Caller should append '%' and pass escape=escape_char to .like().
-    """
-    s = s.replace(escape, escape + escape)  # escape the escape char first
-    s = s.replace("%", escape + "%").replace("_", escape + "_")  # escape LIKE wildcards
-    return s, escape
-
-def fast_asset_file_check(
-    *,
-    mtime_db: int | None,
-    size_db: int | None,
-    stat_result: os.stat_result,
-) -> bool:
-    if mtime_db is None:
-        return False
-    actual_mtime_ns = getattr(stat_result, "st_mtime_ns", int(stat_result.st_mtime * 1_000_000_000))
-    if int(mtime_db) != int(actual_mtime_ns):
-        return False
-    sz = int(size_db or 0)
-    if sz > 0:
-        return int(stat_result.st_size) == sz
-    return True
-
-def utcnow() -> datetime:
-    """Naive UTC timestamp (no tzinfo). We always treat DB datetimes as UTC."""
-    return datetime.now(timezone.utc).replace(tzinfo=None)
-
-def get_comfy_models_folders() -> list[tuple[str, list[str]]]:
-    """Build a list of (folder_name, base_paths[]) categories that are configured for model locations.
-
-    We trust `folder_paths.folder_names_and_paths` and include a category if
-    *any* of its base paths lies under the Comfy `models_dir`.
-    """
-    targets: list[tuple[str, list[str]]] = []
-    models_root = os.path.abspath(folder_paths.models_dir)
-    for name, values in folder_paths.folder_names_and_paths.items():
-        paths, _exts = values[0], values[1]  # NOTE: this prevents nodepacks that hackily edit folder_... from breaking ComfyUI
-        if any(os.path.abspath(p).startswith(models_root + os.sep) for p in paths):
-            targets.append((name, paths))
-    return targets
-
-def compute_relative_filename(file_path: str) -> str | None:
-    """
-    Return the model's path relative to the last well-known folder (the model category),
-    using forward slashes, eg:
-      /.../models/checkpoints/flux/123/flux.safetensors -> "flux/123/flux.safetensors"
-      /.../models/text_encoders/clip_g.safetensors -> "clip_g.safetensors"
-
-    For non-model paths, returns None.
-    NOTE: this is a temporary helper, used only for initializing metadata["filename"] field.
-    """
-    try:
-        root_category, rel_path = get_relative_to_root_category_path_of_asset(file_path)
-    except ValueError:
-        return None
-
-    p = Path(rel_path)
-    parts = [seg for seg in p.parts if seg not in (".", "..", p.anchor)]
-    if not parts:
-        return None
-
-    if root_category == "models":
-        # parts[0] is the category ("checkpoints", "vae", etc) – drop it
-        inside = parts[1:] if len(parts) > 1 else [parts[0]]
-        return "/".join(inside)
-    return "/".join(parts)  # input/output: keep all parts
-
-
-def get_relative_to_root_category_path_of_asset(file_path: str) -> tuple[Literal["input", "output", "models"], str]:
-    """Given an absolute or relative file path, determine which root category the path belongs to:
-      - 'input' if the file resides under `folder_paths.get_input_directory()`
-      - 'output' if the file resides under `folder_paths.get_output_directory()`
-      - 'models' if the file resides under any base path of categories returned by `get_comfy_models_folders()`
-
-    Returns:
-        (root_category, relative_path_inside_that_root)
-        For 'models', the relative path is prefixed with the category name:
-            e.g. ('models', 'vae/test/sub/ae.safetensors')
-
-    Raises:
-        ValueError: if the path does not belong to input, output, or configured model bases.
-    """
-    fp_abs = os.path.abspath(file_path)
-
-    def _is_within(child: str, parent: str) -> bool:
-        try:
-            return os.path.commonpath([child, parent]) == parent
-        except Exception:
-            return False
-
-    def _rel(child: str, parent: str) -> str:
-        return os.path.relpath(os.path.join(os.sep, os.path.relpath(child, parent)), os.sep)
-
-    # 1) input
-    input_base = os.path.abspath(folder_paths.get_input_directory())
-    if _is_within(fp_abs, input_base):
-        return "input", _rel(fp_abs, input_base)
-
-    # 2) output
-    output_base = os.path.abspath(folder_paths.get_output_directory())
-    if _is_within(fp_abs, output_base):
-        return "output", _rel(fp_abs, output_base)
-
-    # 3) models (check deepest matching base to avoid ambiguity)
-    best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
-    for bucket, bases in get_comfy_models_folders():
-        for b in bases:
-            base_abs = os.path.abspath(b)
-            if not _is_within(fp_abs, base_abs):
-                continue
-            cand = (len(base_abs), bucket, _rel(fp_abs, base_abs))
-            if best is None or cand[0] > best[0]:
-                best = cand
-
-    if best is not None:
-        _, bucket, rel_inside = best
-        combined = os.path.join(bucket, rel_inside)
-        return "models", os.path.relpath(os.path.join(os.sep, combined), os.sep)
-
-    raise ValueError(f"Path is not within input, output, or configured model bases: {file_path}")
-
-def get_name_and_tags_from_asset_path(file_path: str) -> tuple[str, list[str]]:
-    """Return a tuple (name, tags) derived from a filesystem path.
-
-    Semantics:
-      - Root category is determined by `get_relative_to_root_category_path_of_asset`.
-      - The returned `name` is the base filename with extension from the relative path.
-      - The returned `tags` are:
-            [root_category] + parent folders of the relative path (in order)
-        For 'models', this means:
-            file '/.../ModelsDir/vae/test_tag/ae.safetensors'
-            -> root_category='models', some_path='vae/test_tag/ae.safetensors'
-            -> name='ae.safetensors', tags=['models', 'vae', 'test_tag']
-
-    Raises:
-        ValueError: if the path does not belong to input, output, or configured model bases.
-    """
-    root_category, some_path = get_relative_to_root_category_path_of_asset(file_path)
-    p = Path(some_path)
-    parent_parts = [part for part in p.parent.parts if part not in (".", "..", p.anchor)]
-    return p.name, list(dict.fromkeys(normalize_tags([root_category, *parent_parts])))
-
-def normalize_tags(tags: list[str] | None) -> list[str]:
-    """
-    Normalize a list of tags by:
-      - Stripping whitespace and converting to lowercase.
-      - Removing duplicates.
-    """
-    return [t.strip().lower() for t in (tags or []) if (t or "").strip()]
-
-def collect_models_files() -> list[str]:
-    out: list[str] = []
-    for folder_name, bases in get_comfy_models_folders():
-        rel_files = folder_paths.get_filename_list(folder_name) or []
-        for rel_path in rel_files:
-            abs_path = folder_paths.get_full_path(folder_name, rel_path)
-            if not abs_path:
-                continue
-            abs_path = os.path.abspath(abs_path)
-            allowed = False
-            for b in bases:
-                base_abs = os.path.abspath(b)
-                with contextlib.suppress(Exception):
-                    if os.path.commonpath([abs_path, base_abs]) == base_abs:
-                        allowed = True
-                        break
-            if allowed:
-                out.append(abs_path)
-    return out

app/assets/manager.py

@@ -1,123 +0,0 @@
-from typing import Sequence
-
-from app.database.db import create_session
-from app.assets.api import schemas_out
-from app.assets.database.queries import (
-    asset_exists_by_hash,
-    fetch_asset_info_asset_and_tags,
-    list_asset_infos_page,
-    list_tags_with_usage,
-)
-
-
-def _safe_sort_field(requested: str | None) -> str:
-    if not requested:
-        return "created_at"
-    v = requested.lower()
-    if v in {"name", "created_at", "updated_at", "size", "last_access_time"}:
-        return v
-    return "created_at"
-
-
-def asset_exists(asset_hash: str) -> bool:
-    with create_session() as session:
-        return asset_exists_by_hash(session, asset_hash=asset_hash)
-
-def list_assets(
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-    name_contains: str | None = None,
-    metadata_filter: dict | None = None,
-    limit: int = 20,
-    offset: int = 0,
-    sort: str = "created_at",
-    order: str = "desc",
-    owner_id: str = "",
-) -> schemas_out.AssetsList:
-    sort = _safe_sort_field(sort)
-    order = "desc" if (order or "desc").lower() not in {"asc", "desc"} else order.lower()
-
-    with create_session() as session:
-        infos, tag_map, total = list_asset_infos_page(
-            session,
-            owner_id=owner_id,
-            include_tags=include_tags,
-            exclude_tags=exclude_tags,
-            name_contains=name_contains,
-            metadata_filter=metadata_filter,
-            limit=limit,
-            offset=offset,
-            sort=sort,
-            order=order,
-        )
-
-    summaries: list[schemas_out.AssetSummary] = []
-    for info in infos:
-        asset = info.asset
-        tags = tag_map.get(info.id, [])
-        summaries.append(
-            schemas_out.AssetSummary(
-                id=info.id,
-                name=info.name,
-                asset_hash=asset.hash if asset else None,
-                size=int(asset.size_bytes) if asset else None,
-                mime_type=asset.mime_type if asset else None,
-                tags=tags,
-                preview_url=f"/api/assets/{info.id}/content",
-                created_at=info.created_at,
-                updated_at=info.updated_at,
-                last_access_time=info.last_access_time,
-            )
-        )
-
-    return schemas_out.AssetsList(
-        assets=summaries,
-        total=total,
-        has_more=(offset + len(summaries)) < total,
-    )
-
-def get_asset(asset_info_id: str, owner_id: str = "") -> schemas_out.AssetDetail:
-    with create_session() as session:
-        res = fetch_asset_info_asset_and_tags(session, asset_info_id=asset_info_id, owner_id=owner_id)
-        if not res:
-            raise ValueError(f"AssetInfo {asset_info_id} not found")
-        info, asset, tag_names = res
-        preview_id = info.preview_id
-
-    return schemas_out.AssetDetail(
-        id=info.id,
-        name=info.name,
-        asset_hash=asset.hash if asset else None,
-        size=int(asset.size_bytes) if asset and asset.size_bytes is not None else None,
-        mime_type=asset.mime_type if asset else None,
-        tags=tag_names,
-        user_metadata=info.user_metadata or {},
-        preview_id=preview_id,
-        created_at=info.created_at,
-        last_access_time=info.last_access_time,
-    )
-
-def list_tags(
-    prefix: str | None = None,
-    limit: int = 100,
-    offset: int = 0,
-    order: str = "count_desc",
-    include_zero: bool = True,
-    owner_id: str = "",
-) -> schemas_out.TagsList:
-    limit = max(1, min(1000, limit))
-    offset = max(0, offset)
-
-    with create_session() as session:
-        rows, total = list_tags_with_usage(
-            session,
-            prefix=prefix,
-            limit=limit,
-            offset=offset,
-            include_zero=include_zero,
-            order=order,
-            owner_id=owner_id,
-        )
-
-    tags = [schemas_out.TagUsage(name=name, count=count, type=tag_type) for (name, tag_type, count) in rows]
-    return schemas_out.TagsList(tags=tags, total=total, has_more=(offset + len(tags)) < total)

app/assets/scanner.py

@@ -1,229 +0,0 @@
-import contextlib
-import time
-import logging
-import os
-import sqlalchemy
-
-import folder_paths
-from app.database.db import create_session, dependencies_available
-from app.assets.helpers import (
-    collect_models_files, compute_relative_filename, fast_asset_file_check, get_name_and_tags_from_asset_path,
-    list_tree,prefixes_for_root, escape_like_prefix,
-    RootType
-)
-from app.assets.database.tags import add_missing_tag_for_asset_id, ensure_tags_exist, remove_missing_tag_for_asset_id
-from app.assets.database.bulk_ops import seed_from_paths_batch
-from app.assets.database.models import Asset, AssetCacheState, AssetInfo
-
-
-def seed_assets(roots: tuple[RootType, ...], enable_logging: bool = False) -> None:
-    """
-    Scan the given roots and seed the assets into the database.
-    """
-    if not dependencies_available():
-        if enable_logging:
-            logging.warning("Database dependencies not available, skipping assets scan")
-        return
-    t_start = time.perf_counter()
-    created = 0
-    skipped_existing = 0
-    paths: list[str] = []
-    try:
-        existing_paths: set[str] = set()
-        for r in roots:
-            try:
-                survivors: set[str] = _fast_db_consistency_pass(r, collect_existing_paths=True, update_missing_tags=True)
-                if survivors:
-                    existing_paths.update(survivors)
-            except Exception as e:
-                logging.exception("fast DB scan failed for %s: %s", r, e)
-
-        if "models" in roots:
-            paths.extend(collect_models_files())
-        if "input" in roots:
-            paths.extend(list_tree(folder_paths.get_input_directory()))
-        if "output" in roots:
-            paths.extend(list_tree(folder_paths.get_output_directory()))
-
-        specs: list[dict] = []
-        tag_pool: set[str] = set()
-        for p in paths:
-            abs_p = os.path.abspath(p)
-            if abs_p in existing_paths:
-                skipped_existing += 1
-                continue
-            try:
-                stat_p = os.stat(abs_p, follow_symlinks=False)
-            except OSError:
-                continue
-            # skip empty files
-            if not stat_p.st_size:
-                continue
-            name, tags = get_name_and_tags_from_asset_path(abs_p)
-            specs.append(
-                {
-                    "abs_path": abs_p,
-                    "size_bytes": stat_p.st_size,
-                    "mtime_ns": getattr(stat_p, "st_mtime_ns", int(stat_p.st_mtime * 1_000_000_000)),
-                    "info_name": name,
-                    "tags": tags,
-                    "fname": compute_relative_filename(abs_p),
-                }
-            )
-            for t in tags:
-                tag_pool.add(t)
-        # if no file specs, nothing to do
-        if not specs:
-            return
-        with create_session() as sess:
-            if tag_pool:
-                ensure_tags_exist(sess, tag_pool, tag_type="user")
-
-            result = seed_from_paths_batch(sess, specs=specs, owner_id="")
-            created += result["inserted_infos"]
-            sess.commit()
-    finally:
-        if enable_logging:
-            logging.info(
-                "Assets scan(roots=%s) completed in %.3fs (created=%d, skipped_existing=%d, total_seen=%d)",
-                roots,
-                time.perf_counter() - t_start,
-                created,
-                skipped_existing,
-                len(paths),
-            )
-
-
-def _fast_db_consistency_pass(
-    root: RootType,
-    *,
-    collect_existing_paths: bool = False,
-    update_missing_tags: bool = False,
-) -> set[str] | None:
-    """Fast DB+FS pass for a root:
-      - Toggle needs_verify per state using fast check
-      - For hashed assets with at least one fast-ok state in this root: delete stale missing states
-      - For seed assets with all states missing: delete Asset and its AssetInfos
-      - Optionally add/remove 'missing' tags based on fast-ok in this root
-      - Optionally return surviving absolute paths
-    """
-    prefixes = prefixes_for_root(root)
-    if not prefixes:
-        return set() if collect_existing_paths else None
-
-    conds = []
-    for p in prefixes:
-        base = os.path.abspath(p)
-        if not base.endswith(os.sep):
-            base += os.sep
-        escaped, esc = escape_like_prefix(base)
-        conds.append(AssetCacheState.file_path.like(escaped + "%", escape=esc))
-
-    with create_session() as sess:
-        rows = (
-            sess.execute(
-                sqlalchemy.select(
-                    AssetCacheState.id,
-                    AssetCacheState.file_path,
-                    AssetCacheState.mtime_ns,
-                    AssetCacheState.needs_verify,
-                    AssetCacheState.asset_id,
-                    Asset.hash,
-                    Asset.size_bytes,
-                )
-                .join(Asset, Asset.id == AssetCacheState.asset_id)
-                .where(sqlalchemy.or_(*conds))
-                .order_by(AssetCacheState.asset_id.asc(), AssetCacheState.id.asc())
-            )
-        ).all()
-
-        by_asset: dict[str, dict] = {}
-        for sid, fp, mtime_db, needs_verify, aid, a_hash, a_size in rows:
-            acc = by_asset.get(aid)
-            if acc is None:
-                acc = {"hash": a_hash, "size_db": int(a_size or 0), "states": []}
-                by_asset[aid] = acc
-
-            fast_ok = False
-            try:
-                exists = True
-                fast_ok = fast_asset_file_check(
-                    mtime_db=mtime_db,
-                    size_db=acc["size_db"],
-                    stat_result=os.stat(fp, follow_symlinks=True),
-                )
-            except FileNotFoundError:
-                exists = False
-            except OSError:
-                exists = False
-
-            acc["states"].append({
-                "sid": sid,
-                "fp": fp,
-                "exists": exists,
-                "fast_ok": fast_ok,
-                "needs_verify": bool(needs_verify),
-            })
-
-        to_set_verify: list[int] = []
-        to_clear_verify: list[int] = []
-        stale_state_ids: list[int] = []
-        survivors: set[str] = set()
-
-        for aid, acc in by_asset.items():
-            a_hash = acc["hash"]
-            states = acc["states"]
-            any_fast_ok = any(s["fast_ok"] for s in states)
-            all_missing = all(not s["exists"] for s in states)
-
-            for s in states:
-                if not s["exists"]:
-                    continue
-                if s["fast_ok"] and s["needs_verify"]:
-                    to_clear_verify.append(s["sid"])
-                if not s["fast_ok"] and not s["needs_verify"]:
-                    to_set_verify.append(s["sid"])
-
-            if a_hash is None:
-                if states and all_missing:  # remove seed Asset completely, if no valid AssetCache exists
-                    sess.execute(sqlalchemy.delete(AssetInfo).where(AssetInfo.asset_id == aid))
-                    asset = sess.get(Asset, aid)
-                    if asset:
-                        sess.delete(asset)
-                else:
-                    for s in states:
-                        if s["exists"]:
-                            survivors.add(os.path.abspath(s["fp"]))
-                continue
-
-            if any_fast_ok:  # if Asset has at least one valid AssetCache record, remove any invalid AssetCache records
-                for s in states:
-                    if not s["exists"]:
-                        stale_state_ids.append(s["sid"])
-                if update_missing_tags:
-                    with contextlib.suppress(Exception):
-                        remove_missing_tag_for_asset_id(sess, asset_id=aid)
-            elif update_missing_tags:
-                with contextlib.suppress(Exception):
-                    add_missing_tag_for_asset_id(sess, asset_id=aid, origin="automatic")
-
-            for s in states:
-                if s["exists"]:
-                    survivors.add(os.path.abspath(s["fp"]))
-
-        if stale_state_ids:
-            sess.execute(sqlalchemy.delete(AssetCacheState).where(AssetCacheState.id.in_(stale_state_ids)))
-        if to_set_verify:
-            sess.execute(
-                sqlalchemy.update(AssetCacheState)
-                .where(AssetCacheState.id.in_(to_set_verify))
-                .values(needs_verify=True)
-            )
-        if to_clear_verify:
-            sess.execute(
-                sqlalchemy.update(AssetCacheState)
-                .where(AssetCacheState.id.in_(to_clear_verify))
-                .values(needs_verify=False)
-            )
-        sess.commit()
-        return survivors if collect_existing_paths else None

app/database/models.py

@@ -1,21 +1,14 @@
-from typing import Any
-from datetime import datetime
-from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import declarative_base
 
-class Base(DeclarativeBase):
-    pass
+Base = declarative_base()
 
-def to_dict(obj: Any, include_none: bool = False) -> dict[str, Any]:
+
+def to_dict(obj):
     fields = obj.__table__.columns.keys()
-    out: dict[str, Any] = {}
-    for field in fields:
-        val = getattr(obj, field)
-        if val is None and not include_none:
-            continue
-        if isinstance(val, datetime):
-            out[field] = val.isoformat()
-        else:
-            out[field] = val
-    return out
+    return {
+        field: (val.to_dict() if hasattr(val, "to_dict") else val)
+        for field in fields
+        if (val := getattr(obj, field))
+    }
 
 # TODO: Define models here

app/subgraph_manager.py

@@ -10,7 +10,6 @@ import hashlib
 
 class Source:
     custom_node = "custom_node"
-    templates = "templates"
 
 class SubgraphEntry(TypedDict):
     source: str
@@ -39,18 +38,6 @@ class CustomNodeSubgraphEntryInfo(TypedDict):
 class SubgraphManager:
     def __init__(self):
         self.cached_custom_node_subgraphs: dict[SubgraphEntry] | None = None
-        self.cached_blueprint_subgraphs: dict[SubgraphEntry] | None = None
-
-    def _create_entry(self, file: str, source: str, node_pack: str) -> tuple[str, SubgraphEntry]:
-        """Create a subgraph entry from a file path. Expects normalized path (forward slashes)."""
-        entry_id = hashlib.sha256(f"{source}{file}".encode()).hexdigest()
-        entry: SubgraphEntry = {
-            "source": source,
-            "name": os.path.splitext(os.path.basename(file))[0],
-            "path": file,
-            "info": {"node_pack": node_pack},
-        }
-        return entry_id, entry
 
     async def load_entry_data(self, entry: SubgraphEntry):
         with open(entry['path'], 'r') as f:
@@ -73,60 +60,53 @@ class SubgraphManager:
         return entries
 
     async def get_custom_node_subgraphs(self, loadedModules, force_reload=False):
-        """Load subgraphs from custom nodes."""
+        # if not forced to reload and cached, return cache
         if not force_reload and self.cached_custom_node_subgraphs is not None:
             return self.cached_custom_node_subgraphs
-
+        # Load subgraphs from custom nodes
+        subfolder = "subgraphs"
         subgraphs_dict: dict[SubgraphEntry] = {}
-        for folder in folder_paths.get_folder_paths("custom_nodes"):
-            pattern = os.path.join(folder, "*/subgraphs/*.json")
-            for file in glob.glob(pattern):
-                file = file.replace('\\', '/')
-                node_pack = "custom_nodes." + file.split('/')[-3]
-                entry_id, entry = self._create_entry(file, Source.custom_node, node_pack)
-                subgraphs_dict[entry_id] = entry
 
+        for folder in folder_paths.get_folder_paths("custom_nodes"):
+            pattern = os.path.join(folder, f"*/{subfolder}/*.json")
+            matched_files = glob.glob(pattern)
+            for file in matched_files:
+                # replace backslashes with forward slashes
+                file = file.replace('\\', '/')
+                info: CustomNodeSubgraphEntryInfo = {
+                    "node_pack": "custom_nodes." + file.split('/')[-3]
+                }
+                source = Source.custom_node
+                # hash source + path to make sure id will be as unique as possible, but
+                # reproducible across backend reloads
+                id = hashlib.sha256(f"{source}{file}".encode()).hexdigest()
+                entry: SubgraphEntry = {
+                    "source": Source.custom_node,
+                    "name": os.path.splitext(os.path.basename(file))[0],
+                    "path": file,
+                    "info": info,
+                }
+                subgraphs_dict[id] = entry
         self.cached_custom_node_subgraphs = subgraphs_dict
         return subgraphs_dict
 
-    async def get_blueprint_subgraphs(self, force_reload=False):
-        """Load subgraphs from the blueprints directory."""
-        if not force_reload and self.cached_blueprint_subgraphs is not None:
-            return self.cached_blueprint_subgraphs
-
-        subgraphs_dict: dict[SubgraphEntry] = {}
-        blueprints_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'blueprints')
-
-        if os.path.exists(blueprints_dir):
-            for file in glob.glob(os.path.join(blueprints_dir, "*.json")):
-                file = file.replace('\\', '/')
-                entry_id, entry = self._create_entry(file, Source.templates, "comfyui")
-                subgraphs_dict[entry_id] = entry
-
-        self.cached_blueprint_subgraphs = subgraphs_dict
-        return subgraphs_dict
-
-    async def get_all_subgraphs(self, loadedModules, force_reload=False):
-        """Get all subgraphs from all sources (custom nodes and blueprints)."""
-        custom_node_subgraphs = await self.get_custom_node_subgraphs(loadedModules, force_reload)
-        blueprint_subgraphs = await self.get_blueprint_subgraphs(force_reload)
-        return {**custom_node_subgraphs, **blueprint_subgraphs}
-
-    async def get_subgraph(self, id: str, loadedModules):
-        """Get a specific subgraph by ID from any source."""
-        entry = (await self.get_all_subgraphs(loadedModules)).get(id)
-        if entry is not None and entry.get('data') is None:
+    async def get_custom_node_subgraph(self, id: str, loadedModules):
+        subgraphs = await self.get_custom_node_subgraphs(loadedModules)
+        entry: SubgraphEntry = subgraphs.get(id, None)
+        if entry is not None and entry.get('data', None) is None:
             await self.load_entry_data(entry)
         return entry
 
     def add_routes(self, routes, loadedModules):
         @routes.get("/global_subgraphs")
         async def get_global_subgraphs(request):
-            subgraphs_dict = await self.get_all_subgraphs(loadedModules)
+            subgraphs_dict = await self.get_custom_node_subgraphs(loadedModules)
+            # NOTE: we may want to include other sources of global subgraphs such as templates in the future;
+            # that's the reasoning for the current implementation
             return web.json_response(await self.sanitize_entries(subgraphs_dict, remove_data=True))
 
         @routes.get("/global_subgraphs/{id}")
         async def get_global_subgraph(request):
             id = request.match_info.get("id", None)
-            subgraph = await self.get_subgraph(id, loadedModules)
+            subgraph = await self.get_custom_node_subgraph(id, loadedModules)
             return web.json_response(await self.sanitize_entry(subgraph))

comfy/cli_args.py

@@ -231,7 +231,6 @@ database_default_path = os.path.abspath(
     os.path.join(os.path.dirname(__file__), "..", "user", "comfyui.db")
 )
 parser.add_argument("--database-url", type=str, default=f"sqlite:///{database_default_path}", help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'.")
-parser.add_argument("--disable-assets-autoscan", action="store_true", help="Disable asset scanning on startup for database synchronization.")
 
 if comfy.options.args_parsing:
     args = parser.parse_args()

comfy/clip_model.py

@@ -1,7 +1,6 @@
 import torch
 from comfy.ldm.modules.attention import optimized_attention_for_device
 import comfy.ops
-import math
 
 def clip_preprocess(image, size=224, mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711], crop=True):
     image = image[:, :, :, :3] if image.shape[3] > 3 else image
@@ -22,39 +21,6 @@ def clip_preprocess(image, size=224, mean=[0.48145466, 0.4578275, 0.40821073], s
     image = torch.clip((255. * image), 0, 255).round() / 255.0
     return (image - mean.view([3,1,1])) / std.view([3,1,1])
 
-def siglip2_flex_calc_resolution(oh, ow, patch_size, max_num_patches, eps=1e-5):
-    def scale_dim(size, scale):
-        scaled = math.ceil(size * scale / patch_size) * patch_size
-        return max(patch_size, int(scaled))
-
-    # Binary search for optimal scale
-    lo, hi = eps / 10, 100.0
-    while hi - lo >= eps:
-        mid = (lo + hi) / 2
-        h, w = scale_dim(oh, mid), scale_dim(ow, mid)
-        if (h // patch_size) * (w // patch_size) <= max_num_patches:
-            lo = mid
-        else:
-            hi = mid
-
-    return scale_dim(oh, lo), scale_dim(ow, lo)
-
-def siglip2_preprocess(image, size, patch_size, num_patches, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], crop=True):
-    if size > 0:
-        return clip_preprocess(image, size=size, mean=mean, std=std, crop=crop)
-
-    image = image[:, :, :, :3] if image.shape[3] > 3 else image
-    mean = torch.tensor(mean, device=image.device, dtype=image.dtype)
-    std = torch.tensor(std, device=image.device, dtype=image.dtype)
-    image = image.movedim(-1, 1)
-
-    b, c, h, w = image.shape
-    h, w = siglip2_flex_calc_resolution(h, w, patch_size, num_patches)
-
-    image = torch.nn.functional.interpolate(image, size=(h, w), mode="bilinear", antialias=True)
-    image = torch.clip((255. * image), 0, 255).round() / 255.0
-    return (image - mean.view([3, 1, 1])) / std.view([3, 1, 1])
-
 class CLIPAttention(torch.nn.Module):
     def __init__(self, embed_dim, heads, dtype, device, operations):
         super().__init__()
@@ -209,27 +175,6 @@ class CLIPTextModel(torch.nn.Module):
         out = self.text_projection(x[2])
         return (x[0], x[1], out, x[2])
 
-def siglip2_pos_embed(embed_weight, embeds, orig_shape):
-    embed_weight_len = round(embed_weight.shape[0] ** 0.5)
-    embed_weight = comfy.ops.cast_to_input(embed_weight, embeds).movedim(1, 0).reshape(1, -1, embed_weight_len, embed_weight_len)
-    embed_weight = torch.nn.functional.interpolate(embed_weight, size=orig_shape, mode="bilinear", align_corners=False, antialias=True)
-    embed_weight = embed_weight.reshape(-1, embed_weight.shape[-2] * embed_weight.shape[-1]).movedim(0, 1)
-    return embeds + embed_weight
-
-class Siglip2Embeddings(torch.nn.Module):
-    def __init__(self, embed_dim, num_channels=3, patch_size=14, image_size=224, model_type="", num_patches=None, dtype=None, device=None, operations=None):
-        super().__init__()
-        self.patch_embedding = operations.Linear(num_channels * patch_size * patch_size, embed_dim, dtype=dtype, device=device)
-        self.position_embedding = operations.Embedding(num_patches, embed_dim, dtype=dtype, device=device)
-        self.patch_size = patch_size
-
-    def forward(self, pixel_values):
-        b, c, h, w = pixel_values.shape
-        img = pixel_values.movedim(1, -1).reshape(b, h // self.patch_size, self.patch_size, w // self.patch_size, self.patch_size, c)
-        img = img.permute(0, 1, 3, 2, 4, 5)
-        img = img.reshape(b, img.shape[1] * img.shape[2], -1)
-        img = self.patch_embedding(img)
-        return siglip2_pos_embed(self.position_embedding.weight, img, (h // self.patch_size, w // self.patch_size))
 
 class CLIPVisionEmbeddings(torch.nn.Module):
     def __init__(self, embed_dim, num_channels=3, patch_size=14, image_size=224, model_type="", dtype=None, device=None, operations=None):
@@ -273,11 +218,8 @@ class CLIPVision(torch.nn.Module):
         intermediate_activation = config_dict["hidden_act"]
         model_type = config_dict["model_type"]
 
-        if model_type in ["siglip2_vision_model"]:
-            self.embeddings = Siglip2Embeddings(embed_dim, config_dict["num_channels"], config_dict["patch_size"], config_dict["image_size"], model_type=model_type, num_patches=config_dict.get("num_patches", None), dtype=dtype, device=device, operations=operations)
-        else:
         self.embeddings = CLIPVisionEmbeddings(embed_dim, config_dict["num_channels"], config_dict["patch_size"], config_dict["image_size"], model_type=model_type, dtype=dtype, device=device, operations=operations)
-        if model_type in ["siglip_vision_model", "siglip2_vision_model"]:
+        if model_type == "siglip_vision_model":
             self.pre_layrnorm = lambda a: a
             self.output_layernorm = True
         else:

comfy/clip_vision.py

@@ -21,7 +21,6 @@ clip_preprocess = comfy.clip_model.clip_preprocess  # Prevent some stuff from br
 IMAGE_ENCODERS = {
     "clip_vision_model": comfy.clip_model.CLIPVisionModelProjection,
     "siglip_vision_model": comfy.clip_model.CLIPVisionModelProjection,
-    "siglip2_vision_model": comfy.clip_model.CLIPVisionModelProjection,
     "dinov2": comfy.image_encoders.dino2.Dinov2Model,
 }
 
@@ -33,10 +32,9 @@ class ClipVisionModel():
         self.image_size = config.get("image_size", 224)
         self.image_mean = config.get("image_mean", [0.48145466, 0.4578275, 0.40821073])
         self.image_std = config.get("image_std", [0.26862954, 0.26130258, 0.27577711])
-        self.model_type = config.get("model_type", "clip_vision_model")
-        self.config = config.copy()
-        model_class = IMAGE_ENCODERS.get(self.model_type)
-        if self.model_type == "siglip_vision_model":
+        model_type = config.get("model_type", "clip_vision_model")
+        model_class = IMAGE_ENCODERS.get(model_type)
+        if model_type == "siglip_vision_model":
             self.return_all_hidden_states = True
         else:
             self.return_all_hidden_states = False
@@ -57,16 +55,12 @@ class ClipVisionModel():
 
     def encode_image(self, image, crop=True):
         comfy.model_management.load_model_gpu(self.patcher)
-        if self.model_type == "siglip2_vision_model":
-            pixel_values = comfy.clip_model.siglip2_preprocess(image.to(self.load_device), size=self.image_size, patch_size=self.config.get("patch_size", 16), num_patches=self.config.get("num_patches", 256), mean=self.image_mean, std=self.image_std, crop=crop).float()
-        else:
         pixel_values = comfy.clip_model.clip_preprocess(image.to(self.load_device), size=self.image_size, mean=self.image_mean, std=self.image_std, crop=crop).float()
         out = self.model(pixel_values=pixel_values, intermediate_output='all' if self.return_all_hidden_states else -2)
 
         outputs = Output()
         outputs["last_hidden_state"] = out[0].to(comfy.model_management.intermediate_device())
         outputs["image_embeds"] = out[2].to(comfy.model_management.intermediate_device())
-        outputs["image_sizes"] = [pixel_values.shape[1:]] * pixel_values.shape[0]
         if self.return_all_hidden_states:
             all_hs = out[1].to(comfy.model_management.intermediate_device())
             outputs["penultimate_hidden_states"] = all_hs[:, -2]
@@ -113,10 +107,6 @@ def load_clipvision_from_sd(sd, prefix="", convert_keys=False):
     elif "vision_model.encoder.layers.22.layer_norm1.weight" in sd:
         embed_shape = sd["vision_model.embeddings.position_embedding.weight"].shape[0]
         if sd["vision_model.encoder.layers.0.layer_norm1.weight"].shape[0] == 1152:
-            patch_embedding_shape = sd["vision_model.embeddings.patch_embedding.weight"].shape
-            if len(patch_embedding_shape) == 2:
-                json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_siglip2_base_naflex.json")
-            else:
             if embed_shape == 729:
                 json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "clip_vision_siglip_384.json")
             elif embed_shape == 1024:

comfy/clip_vision_siglip2_base_naflex.json

@@ -1,14 +0,0 @@
-{
-  "num_channels": 3,
-  "hidden_act": "gelu_pytorch_tanh",
-  "hidden_size": 1152,
-  "image_size": -1,
-  "intermediate_size": 4304,
-  "model_type": "siglip2_vision_model",
-  "num_attention_heads": 16,
-  "num_hidden_layers": 27,
-  "patch_size": 16,
-  "num_patches": 256,
-  "image_mean": [0.5, 0.5, 0.5],
-  "image_std": [0.5, 0.5, 0.5]
-}

comfy/float.py

@@ -65,147 +65,3 @@ def stochastic_rounding(value, dtype, seed=0):
         return output
 
     return value.to(dtype=dtype)
-
-
-# TODO: improve this?
-def stochastic_float_to_fp4_e2m1(x, generator):
-    orig_shape = x.shape
-    sign = torch.signbit(x).to(torch.uint8)
-
-    exp = torch.floor(torch.log2(x.abs()) + 1.0).clamp(0, 3)
-    x += (torch.rand(x.size(), dtype=x.dtype, layout=x.layout, device=x.device, generator=generator) - 0.5) * (2 ** (exp - 2.0)) * 1.25
-
-    x = x.abs()
-    exp = torch.floor(torch.log2(x) + 1.1925).clamp(0, 3)
-
-    mantissa = torch.where(
-        exp > 0,
-        (x / (2.0 ** (exp - 1)) - 1.0) * 2.0,
-        (x * 2.0),
-        out=x
-    ).round().to(torch.uint8)
-    del x
-
-    exp = exp.to(torch.uint8)
-
-    fp4 = (sign << 3) | (exp << 1) | mantissa
-    del sign, exp, mantissa
-
-    fp4_flat = fp4.view(-1)
-    packed = (fp4_flat[0::2] << 4) | fp4_flat[1::2]
-    return packed.reshape(list(orig_shape)[:-1] + [-1])
-
-
-def to_blocked(input_matrix, flatten: bool = True) -> torch.Tensor:
-    """
-    Rearrange a large matrix by breaking it into blocks and applying the rearrangement pattern.
-    See:
-        https://docs.nvidia.com/cuda/cublas/index.html#d-block-scaling-factors-layout
-
-    Args:
-        input_matrix: Input tensor of shape (H, W)
-    Returns:
-        Rearranged tensor of shape (32*ceil_div(H,128), 16*ceil_div(W,4))
-    """
-
-    def ceil_div(a, b):
-        return (a + b - 1) // b
-
-    rows, cols = input_matrix.shape
-    n_row_blocks = ceil_div(rows, 128)
-    n_col_blocks = ceil_div(cols, 4)
-
-    # Calculate the padded shape
-    padded_rows = n_row_blocks * 128
-    padded_cols = n_col_blocks * 4
-
-    padded = input_matrix
-    if (rows, cols) != (padded_rows, padded_cols):
-        padded = torch.zeros(
-            (padded_rows, padded_cols),
-            device=input_matrix.device,
-            dtype=input_matrix.dtype,
-        )
-        padded[:rows, :cols] = input_matrix
-
-    # Rearrange the blocks
-    blocks = padded.view(n_row_blocks, 128, n_col_blocks, 4).permute(0, 2, 1, 3)
-    rearranged = blocks.reshape(-1, 4, 32, 4).transpose(1, 2).reshape(-1, 32, 16)
-    if flatten:
-        return rearranged.flatten()
-
-    return rearranged.reshape(padded_rows, padded_cols)
-
-
-def stochastic_round_quantize_nvfp4_block(x, per_tensor_scale, generator):
-    F4_E2M1_MAX = 6.0
-    F8_E4M3_MAX = 448.0
-
-    orig_shape = x.shape
-
-    block_size = 16
-
-    x = x.reshape(orig_shape[0], -1, block_size)
-    scaled_block_scales_fp8 = torch.clamp(((torch.amax(torch.abs(x), dim=-1)) / F4_E2M1_MAX) / per_tensor_scale.to(x.dtype), max=F8_E4M3_MAX).to(torch.float8_e4m3fn)
-    x = x / (per_tensor_scale.to(x.dtype) * scaled_block_scales_fp8.to(x.dtype)).unsqueeze(-1)
-
-    x = x.view(orig_shape).nan_to_num()
-    data_lp = stochastic_float_to_fp4_e2m1(x, generator=generator)
-    return data_lp, scaled_block_scales_fp8
-
-
-def stochastic_round_quantize_nvfp4(x, per_tensor_scale, pad_16x, seed=0):
-    def roundup(x: int, multiple: int) -> int:
-        """Round up x to the nearest multiple."""
-        return ((x + multiple - 1) // multiple) * multiple
-
-    generator = torch.Generator(device=x.device)
-    generator.manual_seed(seed)
-
-    # Handle padding
-    if pad_16x:
-        rows, cols = x.shape
-        padded_rows = roundup(rows, 16)
-        padded_cols = roundup(cols, 16)
-        if padded_rows != rows or padded_cols != cols:
-            x = torch.nn.functional.pad(x, (0, padded_cols - cols, 0, padded_rows - rows))
-
-    x, blocked_scaled = stochastic_round_quantize_nvfp4_block(x, per_tensor_scale, generator)
-    return x, to_blocked(blocked_scaled, flatten=False)
-
-
-def stochastic_round_quantize_nvfp4_by_block(x, per_tensor_scale, pad_16x, seed=0, block_size=4096 * 4096):
-    def roundup(x: int, multiple: int) -> int:
-        """Round up x to the nearest multiple."""
-        return ((x + multiple - 1) // multiple) * multiple
-
-    orig_shape = x.shape
-
-    # Handle padding
-    if pad_16x:
-        rows, cols = x.shape
-        padded_rows = roundup(rows, 16)
-        padded_cols = roundup(cols, 16)
-        if padded_rows != rows or padded_cols != cols:
-            x = torch.nn.functional.pad(x, (0, padded_cols - cols, 0, padded_rows - rows))
-            # Note: We update orig_shape because the output tensor logic below assumes x.shape matches
-            # what we want to produce. If we pad here, we want the padded output.
-            orig_shape = x.shape
-
-    orig_shape = list(orig_shape)
-
-    output_fp4 = torch.empty(orig_shape[:-1] + [orig_shape[-1] // 2], dtype=torch.uint8, device=x.device)
-    output_block = torch.empty(orig_shape[:-1] + [orig_shape[-1] // 16], dtype=torch.float8_e4m3fn, device=x.device)
-
-    generator = torch.Generator(device=x.device)
-    generator.manual_seed(seed)
-
-    num_slices = max(1, (x.numel() / block_size))
-    slice_size = max(1, (round(x.shape[0] / num_slices)))
-
-    for i in range(0, x.shape[0], slice_size):
-        fp4, block = stochastic_round_quantize_nvfp4_block(x[i: i + slice_size], per_tensor_scale, generator=generator)
-        output_fp4[i:i + slice_size].copy_(fp4)
-        output_block[i:i + slice_size].copy_(block)
-
-    return output_fp4, to_blocked(output_block, flatten=False)

comfy/ldm/anima/model.py

@@ -1,202 +0,0 @@
-from comfy.ldm.cosmos.predict2 import MiniTrainDIT
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-
-def rotate_half(x):
-    x1 = x[..., : x.shape[-1] // 2]
-    x2 = x[..., x.shape[-1] // 2 :]
-    return torch.cat((-x2, x1), dim=-1)
-
-
-def apply_rotary_pos_emb(x, cos, sin, unsqueeze_dim=1):
-    cos = cos.unsqueeze(unsqueeze_dim)
-    sin = sin.unsqueeze(unsqueeze_dim)
-    x_embed = (x * cos) + (rotate_half(x) * sin)
-    return x_embed
-
-
-class RotaryEmbedding(nn.Module):
-    def __init__(self, head_dim):
-        super().__init__()
-        self.rope_theta = 10000
-        inv_freq = 1.0 / (self.rope_theta ** (torch.arange(0, head_dim, 2, dtype=torch.int64).to(dtype=torch.float) / head_dim))
-        self.register_buffer("inv_freq", inv_freq, persistent=False)
-
-    @torch.no_grad()
-    def forward(self, x, position_ids):
-        inv_freq_expanded = self.inv_freq[None, :, None].float().expand(position_ids.shape[0], -1, 1).to(x.device)
-        position_ids_expanded = position_ids[:, None, :].float()
-
-        device_type = x.device.type if isinstance(x.device.type, str) and x.device.type != "mps" else "cpu"
-        with torch.autocast(device_type=device_type, enabled=False):  # Force float32
-            freqs = (inv_freq_expanded.float() @ position_ids_expanded.float()).transpose(1, 2)
-            emb = torch.cat((freqs, freqs), dim=-1)
-            cos = emb.cos()
-            sin = emb.sin()
-
-        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
-
-
-class Attention(nn.Module):
-    def __init__(self, query_dim, context_dim, n_heads, head_dim, device=None, dtype=None, operations=None):
-        super().__init__()
-
-        inner_dim = head_dim * n_heads
-        self.n_heads = n_heads
-        self.head_dim = head_dim
-        self.query_dim = query_dim
-        self.context_dim = context_dim
-
-        self.q_proj = operations.Linear(query_dim, inner_dim, bias=False, device=device, dtype=dtype)
-        self.q_norm = operations.RMSNorm(self.head_dim, eps=1e-6, device=device, dtype=dtype)
-
-        self.k_proj = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype)
-        self.k_norm = operations.RMSNorm(self.head_dim, eps=1e-6, device=device, dtype=dtype)
-
-        self.v_proj = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype)
-
-        self.o_proj = operations.Linear(inner_dim, query_dim, bias=False, device=device, dtype=dtype)
-
-    def forward(self, x, mask=None, context=None, position_embeddings=None, position_embeddings_context=None):
-        context = x if context is None else context
-        input_shape = x.shape[:-1]
-        q_shape = (*input_shape, self.n_heads, self.head_dim)
-        context_shape = context.shape[:-1]
-        kv_shape = (*context_shape, self.n_heads, self.head_dim)
-
-        query_states = self.q_norm(self.q_proj(x).view(q_shape)).transpose(1, 2)
-        key_states = self.k_norm(self.k_proj(context).view(kv_shape)).transpose(1, 2)
-        value_states = self.v_proj(context).view(kv_shape).transpose(1, 2)
-
-        if position_embeddings is not None:
-            assert position_embeddings_context is not None
-            cos, sin = position_embeddings
-            query_states = apply_rotary_pos_emb(query_states, cos, sin)
-            cos, sin = position_embeddings_context
-            key_states = apply_rotary_pos_emb(key_states, cos, sin)
-
-        attn_output = F.scaled_dot_product_attention(query_states, key_states, value_states, attn_mask=mask)
-
-        attn_output = attn_output.transpose(1, 2).reshape(*input_shape, -1).contiguous()
-        attn_output = self.o_proj(attn_output)
-        return attn_output
-
-    def init_weights(self):
-        torch.nn.init.zeros_(self.o_proj.weight)
-
-
-class TransformerBlock(nn.Module):
-    def __init__(self, source_dim, model_dim, num_heads=16, mlp_ratio=4.0, use_self_attn=False, layer_norm=False, device=None, dtype=None, operations=None):
-        super().__init__()
-        self.use_self_attn = use_self_attn
-
-        if self.use_self_attn:
-            self.norm_self_attn = operations.LayerNorm(model_dim, device=device, dtype=dtype) if layer_norm else operations.RMSNorm(model_dim, eps=1e-6, device=device, dtype=dtype)
-            self.self_attn = Attention(
-                query_dim=model_dim,
-                context_dim=model_dim,
-                n_heads=num_heads,
-                head_dim=model_dim//num_heads,
-                device=device,
-                dtype=dtype,
-                operations=operations,
-            )
-
-        self.norm_cross_attn = operations.LayerNorm(model_dim, device=device, dtype=dtype) if layer_norm else operations.RMSNorm(model_dim, eps=1e-6, device=device, dtype=dtype)
-        self.cross_attn = Attention(
-            query_dim=model_dim,
-            context_dim=source_dim,
-            n_heads=num_heads,
-            head_dim=model_dim//num_heads,
-            device=device,
-            dtype=dtype,
-            operations=operations,
-        )
-
-        self.norm_mlp = operations.LayerNorm(model_dim, device=device, dtype=dtype) if layer_norm else operations.RMSNorm(model_dim, eps=1e-6, device=device, dtype=dtype)
-        self.mlp = nn.Sequential(
-            operations.Linear(model_dim, int(model_dim * mlp_ratio), device=device, dtype=dtype),
-            nn.GELU(),
-            operations.Linear(int(model_dim * mlp_ratio), model_dim, device=device, dtype=dtype)
-        )
-
-    def forward(self, x, context, target_attention_mask=None, source_attention_mask=None, position_embeddings=None, position_embeddings_context=None):
-        if self.use_self_attn:
-            normed = self.norm_self_attn(x)
-            attn_out = self.self_attn(normed, mask=target_attention_mask, position_embeddings=position_embeddings, position_embeddings_context=position_embeddings)
-            x = x + attn_out
-
-        normed = self.norm_cross_attn(x)
-        attn_out = self.cross_attn(normed, mask=source_attention_mask, context=context, position_embeddings=position_embeddings, position_embeddings_context=position_embeddings_context)
-        x = x + attn_out
-
-        x = x + self.mlp(self.norm_mlp(x))
-        return x
-
-    def init_weights(self):
-        torch.nn.init.zeros_(self.mlp[2].weight)
-        self.cross_attn.init_weights()
-
-
-class LLMAdapter(nn.Module):
-    def __init__(
-            self,
-            source_dim=1024,
-            target_dim=1024,
-            model_dim=1024,
-            num_layers=6,
-            num_heads=16,
-            use_self_attn=True,
-            layer_norm=False,
-            device=None,
-            dtype=None,
-            operations=None,
-        ):
-        super().__init__()
-
-        self.embed = operations.Embedding(32128, target_dim, device=device, dtype=dtype)
-        if model_dim != target_dim:
-            self.in_proj = operations.Linear(target_dim, model_dim, device=device, dtype=dtype)
-        else:
-            self.in_proj = nn.Identity()
-        self.rotary_emb = RotaryEmbedding(model_dim//num_heads)
-        self.blocks = nn.ModuleList([
-            TransformerBlock(source_dim, model_dim, num_heads=num_heads, use_self_attn=use_self_attn, layer_norm=layer_norm, device=device, dtype=dtype, operations=operations) for _ in range(num_layers)
-        ])
-        self.out_proj = operations.Linear(model_dim, target_dim, device=device, dtype=dtype)
-        self.norm = operations.RMSNorm(target_dim, eps=1e-6, device=device, dtype=dtype)
-
-    def forward(self, source_hidden_states, target_input_ids, target_attention_mask=None, source_attention_mask=None):
-        if target_attention_mask is not None:
-            target_attention_mask = target_attention_mask.to(torch.bool)
-            if target_attention_mask.ndim == 2:
-                target_attention_mask = target_attention_mask.unsqueeze(1).unsqueeze(1)
-
-        if source_attention_mask is not None:
-            source_attention_mask = source_attention_mask.to(torch.bool)
-            if source_attention_mask.ndim == 2:
-                source_attention_mask = source_attention_mask.unsqueeze(1).unsqueeze(1)
-
-        x = self.in_proj(self.embed(target_input_ids))
-        context = source_hidden_states
-        position_ids = torch.arange(x.shape[1], device=x.device).unsqueeze(0)
-        position_ids_context = torch.arange(context.shape[1], device=x.device).unsqueeze(0)
-        position_embeddings = self.rotary_emb(x, position_ids)
-        position_embeddings_context = self.rotary_emb(x, position_ids_context)
-        for block in self.blocks:
-            x = block(x, context, target_attention_mask=target_attention_mask, source_attention_mask=source_attention_mask, position_embeddings=position_embeddings, position_embeddings_context=position_embeddings_context)
-        return self.norm(self.out_proj(x))
-
-
-class Anima(MiniTrainDIT):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.llm_adapter = LLMAdapter(device=kwargs.get("device"), dtype=kwargs.get("dtype"), operations=kwargs.get("operations"))
-
-    def preprocess_text_embeds(self, text_embeds, text_ids):
-        if text_ids is not None:
-            return self.llm_adapter(text_embeds, text_ids)
-        else:
-            return text_embeds

comfy/ldm/hunyuan_video/upsampler.py

@@ -3,8 +3,8 @@ import torch.nn as nn
 import torch.nn.functional as F
 from comfy.ldm.modules.diffusionmodules.model import ResnetBlock, VideoConv3d
 from comfy.ldm.hunyuan_video.vae_refiner import RMS_norm
-import comfy.model_management
-import comfy.model_patcher
+import model_management
+import model_patcher
 
 class SRResidualCausalBlock3D(nn.Module):
     def __init__(self, channels: int):
@@ -103,13 +103,13 @@ UPSAMPLERS = {
 
 class HunyuanVideo15SRModel():
     def __init__(self, model_type, config):
-        self.load_device = comfy.model_management.vae_device()
-        offload_device = comfy.model_management.vae_offload_device()
-        self.dtype = comfy.model_management.vae_dtype(self.load_device)
+        self.load_device = model_management.vae_device()
+        offload_device = model_management.vae_offload_device()
+        self.dtype = model_management.vae_dtype(self.load_device)
         self.model_class = UPSAMPLERS.get(model_type)
         self.model = self.model_class(**config).eval()
 
-        self.patcher = comfy.model_patcher.ModelPatcher(self.model, load_device=self.load_device, offload_device=offload_device)
+        self.patcher = model_patcher.ModelPatcher(self.model, load_device=self.load_device, offload_device=offload_device)
 
     def load_sd(self, sd):
         return self.model.load_state_dict(sd, strict=True)
@@ -118,5 +118,5 @@ class HunyuanVideo15SRModel():
         return self.model.state_dict()
 
     def resample_latent(self, latent):
-        comfy.model_management.load_model_gpu(self.patcher)
+        model_management.load_model_gpu(self.patcher)
         return self.model(latent.to(self.load_device))

comfy/ldm/lightricks/av_model.py

@@ -11,69 +11,6 @@ from comfy.ldm.lightricks.model import (
 from comfy.ldm.lightricks.symmetric_patchifier import AudioPatchifier
 import comfy.ldm.common_dit
 
-class CompressedTimestep:
-    """Store video timestep embeddings in compressed form using per-frame indexing."""
-    __slots__ = ('data', 'batch_size', 'num_frames', 'patches_per_frame', 'feature_dim')
-
-    def __init__(self, tensor: torch.Tensor, patches_per_frame: int):
-        """
-        tensor: [batch_size, num_tokens, feature_dim] tensor where num_tokens = num_frames * patches_per_frame
-        patches_per_frame: Number of spatial patches per frame (height * width in latent space)
-        """
-        self.batch_size, num_tokens, self.feature_dim = tensor.shape
-
-        # Check if compression is valid (num_tokens must be divisible by patches_per_frame)
-        if num_tokens % patches_per_frame == 0 and num_tokens >= patches_per_frame:
-            self.patches_per_frame = patches_per_frame
-            self.num_frames = num_tokens // patches_per_frame
-
-            # Reshape to [batch, frames, patches_per_frame, feature_dim] and store one value per frame
-            # All patches in a frame are identical, so we only keep the first one
-            reshaped = tensor.view(self.batch_size, self.num_frames, patches_per_frame, self.feature_dim)
-            self.data = reshaped[:, :, 0, :].contiguous()  # [batch, frames, feature_dim]
-        else:
-            # Not divisible or too small - store directly without compression
-            self.patches_per_frame = 1
-            self.num_frames = num_tokens
-            self.data = tensor
-
-    def expand(self):
-        """Expand back to original tensor."""
-        if self.patches_per_frame == 1:
-            return self.data
-
-        # [batch, frames, feature_dim] -> [batch, frames, patches_per_frame, feature_dim] -> [batch, tokens, feature_dim]
-        expanded = self.data.unsqueeze(2).expand(self.batch_size, self.num_frames, self.patches_per_frame, self.feature_dim)
-        return expanded.reshape(self.batch_size, -1, self.feature_dim)
-
-    def expand_for_computation(self, scale_shift_table: torch.Tensor, batch_size: int, indices: slice = slice(None, None)):
-        """Compute ada values on compressed per-frame data, then expand spatially."""
-        num_ada_params = scale_shift_table.shape[0]
-
-        # No compression - compute directly
-        if self.patches_per_frame == 1:
-            num_tokens = self.data.shape[1]
-            dim_per_param = self.feature_dim // num_ada_params
-            reshaped = self.data.reshape(batch_size, num_tokens, num_ada_params, dim_per_param)[:, :, indices, :]
-            table_values = scale_shift_table[indices].unsqueeze(0).unsqueeze(0).to(device=self.data.device, dtype=self.data.dtype)
-            ada_values = (table_values + reshaped).unbind(dim=2)
-            return ada_values
-
-        # Compressed: compute on per-frame data then expand spatially
-        # Reshape: [batch, frames, feature_dim] -> [batch, frames, num_ada_params, dim_per_param]
-        frame_reshaped = self.data.reshape(batch_size, self.num_frames, num_ada_params, -1)[:, :, indices, :]
-        table_values = scale_shift_table[indices].unsqueeze(0).unsqueeze(0).to(
-            device=self.data.device, dtype=self.data.dtype
-        )
-        frame_ada = (table_values + frame_reshaped).unbind(dim=2)
-
-        # Expand each ada parameter spatially: [batch, frames, dim] -> [batch, frames, patches, dim] -> [batch, tokens, dim]
-        return tuple(
-            frame_val.unsqueeze(2).expand(batch_size, self.num_frames, self.patches_per_frame, -1)
-            .reshape(batch_size, -1, frame_val.shape[-1])
-            for frame_val in frame_ada
-        )
-
 class BasicAVTransformerBlock(nn.Module):
     def __init__(
         self,
@@ -182,9 +119,6 @@ class BasicAVTransformerBlock(nn.Module):
     def get_ada_values(
         self, scale_shift_table: torch.Tensor, batch_size: int, timestep: torch.Tensor, indices: slice = slice(None, None)
     ):
-        if isinstance(timestep, CompressedTimestep):
-            return timestep.expand_for_computation(scale_shift_table, batch_size, indices)
-
         num_ada_params = scale_shift_table.shape[0]
 
         ada_values = (
@@ -212,7 +146,10 @@ class BasicAVTransformerBlock(nn.Module):
             gate_timestep,
         )
 
-        return (*scale_shift_ada_values, *gate_ada_values)
+        scale_shift_chunks = [t.squeeze(2) for t in scale_shift_ada_values]
+        gate_ada_values = [t.squeeze(2) for t in gate_ada_values]
+
+        return (*scale_shift_chunks, *gate_ada_values)
 
     def forward(
         self,
@@ -606,80 +543,72 @@ class LTXAVModel(LTXVModel):
         if grid_mask is not None:
             timestep = timestep[:, grid_mask]
 
-        timestep_scaled = timestep * self.timestep_scale_multiplier
-
+        timestep = timestep * self.timestep_scale_multiplier
         v_timestep, v_embedded_timestep = self.adaln_single(
-            timestep_scaled.flatten(),
+            timestep.flatten(),
             {"resolution": None, "aspect_ratio": None},
             batch_size=batch_size,
             hidden_dtype=hidden_dtype,
         )
 
-        # Calculate patches_per_frame from orig_shape: [batch, channels, frames, height, width]
-        # Video tokens are arranged as (frames * height * width), so patches_per_frame = height * width
-        orig_shape = kwargs.get("orig_shape")
-        v_patches_per_frame = None
-        if orig_shape is not None and len(orig_shape) == 5:
-            # orig_shape[3] = height, orig_shape[4] = width (in latent space)
-            v_patches_per_frame = orig_shape[3] * orig_shape[4]
-
-        # Reshape to [batch_size, num_tokens, dim] and compress for storage
-        v_timestep = CompressedTimestep(v_timestep.view(batch_size, -1, v_timestep.shape[-1]), v_patches_per_frame)
-        v_embedded_timestep = CompressedTimestep(v_embedded_timestep.view(batch_size, -1, v_embedded_timestep.shape[-1]), v_patches_per_frame)
+        # Second dimension is 1 or number of tokens (if timestep_per_token)
+        v_timestep = v_timestep.view(batch_size, -1, v_timestep.shape[-1])
+        v_embedded_timestep = v_embedded_timestep.view(
+            batch_size, -1, v_embedded_timestep.shape[-1]
+        )
 
         # Prepare audio timestep
         a_timestep = kwargs.get("a_timestep")
         if a_timestep is not None:
-            a_timestep_scaled = a_timestep * self.timestep_scale_multiplier
-            a_timestep_flat = a_timestep_scaled.flatten()
-            timestep_flat = timestep_scaled.flatten()
+            a_timestep = a_timestep * self.timestep_scale_multiplier
             av_ca_factor = self.av_ca_timestep_scale_multiplier / self.timestep_scale_multiplier
 
-            # Cross-attention timesteps - compress these too
             av_ca_audio_scale_shift_timestep, _ = self.av_ca_audio_scale_shift_adaln_single(
-                a_timestep_flat,
+                a_timestep.flatten(),
                 {"resolution": None, "aspect_ratio": None},
                 batch_size=batch_size,
                 hidden_dtype=hidden_dtype,
             )
             av_ca_video_scale_shift_timestep, _ = self.av_ca_video_scale_shift_adaln_single(
-                timestep_flat,
+                timestep.flatten(),
                 {"resolution": None, "aspect_ratio": None},
                 batch_size=batch_size,
                 hidden_dtype=hidden_dtype,
             )
             av_ca_a2v_gate_noise_timestep, _ = self.av_ca_a2v_gate_adaln_single(
-                timestep_flat * av_ca_factor,
+                timestep.flatten() * av_ca_factor,
                 {"resolution": None, "aspect_ratio": None},
                 batch_size=batch_size,
                 hidden_dtype=hidden_dtype,
             )
             av_ca_v2a_gate_noise_timestep, _ = self.av_ca_v2a_gate_adaln_single(
-                a_timestep_flat * av_ca_factor,
+                a_timestep.flatten() * av_ca_factor,
                 {"resolution": None, "aspect_ratio": None},
                 batch_size=batch_size,
                 hidden_dtype=hidden_dtype,
             )
 
-            # Compress cross-attention timesteps (only video side, audio is too small to benefit)
-            cross_av_timestep_ss = [
-                av_ca_audio_scale_shift_timestep.view(batch_size, -1, av_ca_audio_scale_shift_timestep.shape[-1]),
-                CompressedTimestep(av_ca_video_scale_shift_timestep.view(batch_size, -1, av_ca_video_scale_shift_timestep.shape[-1]), v_patches_per_frame),  # video - compressed
-                CompressedTimestep(av_ca_a2v_gate_noise_timestep.view(batch_size, -1, av_ca_a2v_gate_noise_timestep.shape[-1]), v_patches_per_frame),  # video - compressed
-                av_ca_v2a_gate_noise_timestep.view(batch_size, -1, av_ca_v2a_gate_noise_timestep.shape[-1]),
-            ]
-
             a_timestep, a_embedded_timestep = self.audio_adaln_single(
-                a_timestep_flat,
+                a_timestep.flatten(),
                 {"resolution": None, "aspect_ratio": None},
                 batch_size=batch_size,
                 hidden_dtype=hidden_dtype,
             )
-            # Audio timesteps
             a_timestep = a_timestep.view(batch_size, -1, a_timestep.shape[-1])
-            a_embedded_timestep = a_embedded_timestep.view(batch_size, -1, a_embedded_timestep.shape[-1])
+            a_embedded_timestep = a_embedded_timestep.view(
+                batch_size, -1, a_embedded_timestep.shape[-1]
+            )
+            cross_av_timestep_ss = [
+                av_ca_audio_scale_shift_timestep,
+                av_ca_video_scale_shift_timestep,
+                av_ca_a2v_gate_noise_timestep,
+                av_ca_v2a_gate_noise_timestep,
+            ]
+            cross_av_timestep_ss = list(
+                [t.view(batch_size, -1, t.shape[-1]) for t in cross_av_timestep_ss]
+            )
         else:
-            a_timestep = timestep_scaled
+            a_timestep = timestep
             a_embedded_timestep = kwargs.get("embedded_timestep")
             cross_av_timestep_ss = []
 
@@ -838,11 +767,6 @@ class LTXAVModel(LTXVModel):
         ax = x[1]
         v_embedded_timestep = embedded_timestep[0]
         a_embedded_timestep = embedded_timestep[1]
-
-        # Expand compressed video timestep if needed
-        if isinstance(v_embedded_timestep, CompressedTimestep):
-            v_embedded_timestep = v_embedded_timestep.expand()
-
         vx = super()._process_output(vx, v_embedded_timestep, keyframe_idxs, **kwargs)
 
         # Process audio output

comfy/ldm/lightricks/vae/audio_vae.py

@@ -103,10 +103,20 @@ class AudioPreprocessor:
             return waveform
         return torchaudio.functional.resample(waveform, source_rate, self.target_sample_rate)
 
+    @staticmethod
+    def normalize_amplitude(
+        waveform: torch.Tensor, max_amplitude: float = 0.5, eps: float = 1e-5
+    ) -> torch.Tensor:
+        waveform = waveform - waveform.mean(dim=2, keepdim=True)
+        peak = torch.max(torch.abs(waveform)) + eps
+        scale = peak.clamp(max=max_amplitude) / peak
+        return waveform * scale
+
     def waveform_to_mel(
         self, waveform: torch.Tensor, waveform_sample_rate: int, device
     ) -> torch.Tensor:
         waveform = self.resample(waveform, waveform_sample_rate)
+        waveform = self.normalize_amplitude(waveform)
 
         mel_transform = torchaudio.transforms.MelSpectrogram(
             sample_rate=self.target_sample_rate,
@@ -179,9 +189,6 @@ class AudioVAE(torch.nn.Module):
         waveform = self.device_manager.move_to_load_device(waveform)
         expected_channels = self.autoencoder.encoder.in_channels
         if waveform.shape[1] != expected_channels:
-            if waveform.shape[1] == 1:
-                waveform = waveform.expand(-1, expected_channels, *waveform.shape[2:])
-            else:
             raise ValueError(
                 f"Input audio must have {expected_channels} channels, got {waveform.shape[1]}"
             )

comfy/ldm/lightricks/vae/causal_conv3d.py

@@ -1,11 +1,11 @@
 from typing import Tuple, Union
 
-import threading
 import torch
 import torch.nn as nn
 import comfy.ops
 ops = comfy.ops.disable_weight_init
 
+
 class CausalConv3d(nn.Module):
     def __init__(
         self,
@@ -42,34 +42,23 @@ class CausalConv3d(nn.Module):
             padding_mode=spatial_padding_mode,
             groups=groups,
         )
-        self.temporal_cache_state={}
 
     def forward(self, x, causal: bool = True):
-        tid = threading.get_ident()
-
-        cached, is_end = self.temporal_cache_state.get(tid, (None, False))
-        if cached is None:
-            padding_length = self.time_kernel_size - 1
-            if not causal:
-                padding_length = padding_length // 2
-            if x.shape[2] == 0:
+        if causal:
+            first_frame_pad = x[:, :, :1, :, :].repeat(
+                (1, 1, self.time_kernel_size - 1, 1, 1)
+            )
+            x = torch.concatenate((first_frame_pad, x), dim=2)
+        else:
+            first_frame_pad = x[:, :, :1, :, :].repeat(
+                (1, 1, (self.time_kernel_size - 1) // 2, 1, 1)
+            )
+            last_frame_pad = x[:, :, -1:, :, :].repeat(
+                (1, 1, (self.time_kernel_size - 1) // 2, 1, 1)
+            )
+            x = torch.concatenate((first_frame_pad, x, last_frame_pad), dim=2)
+        x = self.conv(x)
         return x
-            cached = x[:, :, :1, :, :].repeat((1, 1, padding_length, 1, 1))
-        pieces = [ cached, x ]
-        if is_end and not causal:
-            pieces.append(x[:, :, -1:, :, :].repeat((1, 1, (self.time_kernel_size - 1) // 2, 1, 1)))
-
-        needs_caching = not is_end
-        if needs_caching and x.shape[2] >= self.time_kernel_size - 1:
-            needs_caching = False
-            self.temporal_cache_state[tid] = (x[:, :, -(self.time_kernel_size - 1):, :, :], False)
-
-        x = torch.cat(pieces, dim=2)
-
-        if needs_caching:
-            self.temporal_cache_state[tid] = (x[:, :, -(self.time_kernel_size - 1):, :, :], False)
-
-        return self.conv(x) if x.shape[2] >= self.time_kernel_size else x[:, :, :0, :, :]
 
     @property
     def weight(self):

comfy/ldm/lightricks/vae/causal_video_autoencoder.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
-import threading
 import torch
 from torch import nn
 from functools import partial
@@ -7,35 +6,12 @@ import math
 from einops import rearrange
 from typing import List, Optional, Tuple, Union
 from .conv_nd_factory import make_conv_nd, make_linear_nd
-from .causal_conv3d import CausalConv3d
 from .pixel_norm import PixelNorm
 from ..model import PixArtAlphaCombinedTimestepSizeEmbeddings
 import comfy.ops
-from comfy.ldm.modules.diffusionmodules.model import torch_cat_if_needed
 
 ops = comfy.ops.disable_weight_init
 
-def mark_conv3d_ended(module):
-    tid = threading.get_ident()
-    for _, m in module.named_modules():
-        if isinstance(m, CausalConv3d):
-            current = m.temporal_cache_state.get(tid, (None, False))
-            m.temporal_cache_state[tid] = (current[0], True)
-
-def split2(tensor, split_point, dim=2):
-    return torch.split(tensor, [split_point, tensor.shape[dim] - split_point], dim=dim)
-
-def add_exchange_cache(dest, cache_in, new_input, dim=2):
-    if dest is not None:
-        if cache_in is not None:
-            cache_to_dest = min(dest.shape[dim], cache_in.shape[dim])
-            lead_in_dest, dest = split2(dest, cache_to_dest, dim=dim)
-            lead_in_source, cache_in = split2(cache_in, cache_to_dest, dim=dim)
-            lead_in_dest.add_(lead_in_source)
-        body, new_input = split2(new_input, dest.shape[dim], dim)
-        dest.add_(body)
-    return torch_cat_if_needed([cache_in, new_input], dim=dim)
-
 class Encoder(nn.Module):
     r"""
     The `Encoder` layer of a variational autoencoder that encodes its input into a latent representation.
@@ -229,7 +205,7 @@ class Encoder(nn.Module):
 
         self.gradient_checkpointing = False
 
-    def forward_orig(self, sample: torch.FloatTensor) -> torch.FloatTensor:
+    def forward(self, sample: torch.FloatTensor) -> torch.FloatTensor:
         r"""The forward method of the `Encoder` class."""
 
         sample = patchify(sample, patch_size_hw=self.patch_size, patch_size_t=1)
@@ -278,22 +254,6 @@ class Encoder(nn.Module):
 
         return sample
 
-    def forward(self, *args, **kwargs):
-        #No encoder support so just flag the end so it doesnt use the cache.
-        mark_conv3d_ended(self)
-        try:
-            return self.forward_orig(*args, **kwargs)
-        finally:
-            tid = threading.get_ident()
-            for _, module in self.named_modules():
-                # ComfyUI doesn't thread this kind of stuff today, but just in case
-                # we key on the thread to make it thread safe.
-                tid = threading.get_ident()
-                if hasattr(module, "temporal_cache_state"):
-                    module.temporal_cache_state.pop(tid, None)
-
-
-MAX_CHUNK_SIZE=(128 * 1024 ** 2)
 
 class Decoder(nn.Module):
     r"""
@@ -381,6 +341,18 @@ class Decoder(nn.Module):
                     timestep_conditioning=timestep_conditioning,
                     spatial_padding_mode=spatial_padding_mode,
                 )
+            elif block_name == "attn_res_x":
+                block = UNetMidBlock3D(
+                    dims=dims,
+                    in_channels=input_channel,
+                    num_layers=block_params["num_layers"],
+                    resnet_groups=norm_num_groups,
+                    norm_layer=norm_layer,
+                    inject_noise=block_params.get("inject_noise", False),
+                    timestep_conditioning=timestep_conditioning,
+                    attention_head_dim=block_params["attention_head_dim"],
+                    spatial_padding_mode=spatial_padding_mode,
+                )
             elif block_name == "res_x_y":
                 output_channel = output_channel // block_params.get("multiplier", 2)
                 block = ResnetBlock3D(
@@ -456,9 +428,8 @@ class Decoder(nn.Module):
             )
             self.last_scale_shift_table = nn.Parameter(torch.empty(2, output_channel))
 
-
     # def forward(self, sample: torch.FloatTensor, target_shape) -> torch.FloatTensor:
-    def forward_orig(
+    def forward(
         self,
         sample: torch.FloatTensor,
         timestep: Optional[torch.Tensor] = None,
@@ -466,7 +437,6 @@ class Decoder(nn.Module):
         r"""The forward method of the `Decoder` class."""
         batch_size = sample.shape[0]
 
-        mark_conv3d_ended(self.conv_in)
         sample = self.conv_in(sample, causal=self.causal)
 
         checkpoint_fn = (
@@ -475,12 +445,24 @@ class Decoder(nn.Module):
             else lambda x: x
         )
 
-        timestep_shift_scale = None
+        scaled_timestep = None
         if self.timestep_conditioning:
             assert (
                 timestep is not None
             ), "should pass timestep with timestep_conditioning=True"
             scaled_timestep = timestep * self.timestep_scale_multiplier.to(dtype=sample.dtype, device=sample.device)
+
+        for up_block in self.up_blocks:
+            if self.timestep_conditioning and isinstance(up_block, UNetMidBlock3D):
+                sample = checkpoint_fn(up_block)(
+                    sample, causal=self.causal, timestep=scaled_timestep
+                )
+            else:
+                sample = checkpoint_fn(up_block)(sample, causal=self.causal)
+
+        sample = self.conv_norm_out(sample)
+
+        if self.timestep_conditioning:
             embedded_timestep = self.last_time_embedder(
                 timestep=scaled_timestep.flatten(),
                 resolution=None,
@@ -501,62 +483,16 @@ class Decoder(nn.Module):
                 embedded_timestep.shape[-2],
                 embedded_timestep.shape[-1],
             )
-            timestep_shift_scale = ada_values.unbind(dim=1)
-
-        output = []
-
-        def run_up(idx, sample, ended):
-            if idx >= len(self.up_blocks):
-                sample = self.conv_norm_out(sample)
-                if timestep_shift_scale is not None:
-                    shift, scale = timestep_shift_scale
+            shift, scale = ada_values.unbind(dim=1)
             sample = sample * (1 + scale) + shift
+
         sample = self.conv_act(sample)
-                if ended:
-                    mark_conv3d_ended(self.conv_out)
         sample = self.conv_out(sample, causal=self.causal)
-                if sample is not None and sample.shape[2] > 0:
-                    output.append(sample)
-                return
-
-            up_block = self.up_blocks[idx]
-            if (ended):
-                mark_conv3d_ended(up_block)
-            if self.timestep_conditioning and isinstance(up_block, UNetMidBlock3D):
-                sample = checkpoint_fn(up_block)(
-                    sample, causal=self.causal, timestep=scaled_timestep
-                )
-            else:
-                sample = checkpoint_fn(up_block)(sample, causal=self.causal)
-
-            if sample is None or sample.shape[2] == 0:
-                return
-
-            total_bytes = sample.numel() * sample.element_size()
-            num_chunks = (total_bytes + MAX_CHUNK_SIZE - 1) // MAX_CHUNK_SIZE
-            samples = torch.chunk(sample, chunks=num_chunks, dim=2)
-
-            for chunk_idx, sample1 in enumerate(samples):
-                run_up(idx + 1, sample1, ended and chunk_idx == len(samples) - 1)
-
-        run_up(0, sample, True)
-        sample = torch.cat(output, dim=2)
 
         sample = unpatchify(sample, patch_size_hw=self.patch_size, patch_size_t=1)
 
         return sample
 
-    def forward(self, *args, **kwargs):
-        try:
-            return self.forward_orig(*args, **kwargs)
-        finally:
-            for _, module in self.named_modules():
-                #ComfyUI doesn't thread this kind of stuff today, but just incase
-                #we key on the thread to make it thread safe.
-                tid = threading.get_ident()
-                if hasattr(module, "temporal_cache_state"):
-                    module.temporal_cache_state.pop(tid, None)
-
 
 class UNetMidBlock3D(nn.Module):
     """
@@ -727,22 +663,8 @@ class DepthToSpaceUpsample(nn.Module):
         )
         self.residual = residual
         self.out_channels_reduction_factor = out_channels_reduction_factor
-        self.temporal_cache_state = {}
 
     def forward(self, x, causal: bool = True, timestep: Optional[torch.Tensor] = None):
-        tid = threading.get_ident()
-        cached, drop_first_conv, drop_first_res = self.temporal_cache_state.get(tid, (None, True, True))
-        y = self.conv(x, causal=causal)
-        y = rearrange(
-            y,
-            "b (c p1 p2 p3) d h w -> b c (d p1) (h p2) (w p3)",
-            p1=self.stride[0],
-            p2=self.stride[1],
-            p3=self.stride[2],
-        )
-        if self.stride[0] == 2 and y.shape[2] > 0 and drop_first_conv:
-            y = y[:, :, 1:, :, :]
-            drop_first_conv = False
         if self.residual:
             # Reshape and duplicate the input to match the output shape
             x_in = rearrange(
@@ -754,20 +676,21 @@ class DepthToSpaceUpsample(nn.Module):
             )
             num_repeat = math.prod(self.stride) // self.out_channels_reduction_factor
             x_in = x_in.repeat(1, num_repeat, 1, 1, 1)
-            if self.stride[0] == 2 and x_in.shape[2] > 0 and drop_first_res:
+            if self.stride[0] == 2:
                 x_in = x_in[:, :, 1:, :, :]
-                drop_first_res = False
-
-            if y.shape[2] == 0:
-                y = None
-
-            cached = add_exchange_cache(y, cached, x_in, dim=2)
-            self.temporal_cache_state[tid] = (cached, drop_first_conv, drop_first_res)
-
-        else:
-            self.temporal_cache_state[tid] = (None, drop_first_conv, False)
-
-        return y
+        x = self.conv(x, causal=causal)
+        x = rearrange(
+            x,
+            "b (c p1 p2 p3) d h w -> b c (d p1) (h p2) (w p3)",
+            p1=self.stride[0],
+            p2=self.stride[1],
+            p3=self.stride[2],
+        )
+        if self.stride[0] == 2:
+            x = x[:, :, 1:, :, :]
+        if self.residual:
+            x = x + x_in
+        return x
 
 class LayerNorm(nn.Module):
     def __init__(self, dim, eps, elementwise_affine=True) -> None:
@@ -884,8 +807,6 @@ class ResnetBlock3D(nn.Module):
                 torch.randn(4, in_channels) / in_channels**0.5
             )
 
-        self.temporal_cache_state={}
-
     def _feed_spatial_noise(
         self, hidden_states: torch.FloatTensor, per_channel_scale: torch.FloatTensor
     ) -> torch.FloatTensor:
@@ -959,12 +880,9 @@ class ResnetBlock3D(nn.Module):
 
         input_tensor = self.conv_shortcut(input_tensor)
 
-        tid = threading.get_ident()
-        cached = self.temporal_cache_state.get(tid, None)
-        cached = add_exchange_cache(hidden_states, cached, input_tensor, dim=2)
-        self.temporal_cache_state[tid] = cached
+        output_tensor = input_tensor + hidden_states
 
-        return hidden_states
+        return output_tensor
 
 
 def patchify(x, patch_size_hw, patch_size_t=1):

comfy/ldm/lumina/model.py

@@ -13,53 +13,10 @@ from comfy.ldm.modules.attention import optimized_attention_masked
 from comfy.ldm.flux.layers import EmbedND
 from comfy.ldm.flux.math import apply_rope
 import comfy.patcher_extension
-import comfy.utils
 
 
-def invert_slices(slices, length):
-    sorted_slices = sorted(slices)
-    result = []
-    current = 0
-
-    for start, end in sorted_slices:
-        if current < start:
-            result.append((current, start))
-        current = max(current, end)
-
-    if current < length:
-        result.append((current, length))
-
-    return result
-
-
-def modulate(x, scale, timestep_zero_index=None):
-    if timestep_zero_index is None:
+def modulate(x, scale):
     return x * (1 + scale.unsqueeze(1))
-    else:
-        scale = (1 + scale.unsqueeze(1))
-        actual_batch = scale.size(0) // 2
-        slices = timestep_zero_index
-        invert = invert_slices(timestep_zero_index, x.shape[1])
-        for s in slices:
-            x[:, s[0]:s[1]] *= scale[actual_batch:]
-        for s in invert:
-            x[:, s[0]:s[1]] *= scale[:actual_batch]
-        return x
-
-
-def apply_gate(gate, x, timestep_zero_index=None):
-    if timestep_zero_index is None:
-        return gate * x
-    else:
-        actual_batch = gate.size(0) // 2
-
-        slices = timestep_zero_index
-        invert = invert_slices(timestep_zero_index, x.shape[1])
-        for s in slices:
-            x[:, s[0]:s[1]] *= gate[actual_batch:]
-        for s in invert:
-            x[:, s[0]:s[1]] *= gate[:actual_batch]
-        return x
 
 #############################################################################
 #                               Core NextDiT Model                              #
@@ -301,7 +258,6 @@ class JointTransformerBlock(nn.Module):
         x_mask: torch.Tensor,
         freqs_cis: torch.Tensor,
         adaln_input: Optional[torch.Tensor]=None,
-        timestep_zero_index=None,
         transformer_options={},
     ):
         """
@@ -320,18 +276,18 @@ class JointTransformerBlock(nn.Module):
             assert adaln_input is not None
             scale_msa, gate_msa, scale_mlp, gate_mlp = self.adaLN_modulation(adaln_input).chunk(4, dim=1)
 
-            x = x + apply_gate(gate_msa.unsqueeze(1).tanh(), self.attention_norm2(
+            x = x + gate_msa.unsqueeze(1).tanh() * self.attention_norm2(
                 clamp_fp16(self.attention(
-                    modulate(self.attention_norm1(x), scale_msa, timestep_zero_index=timestep_zero_index),
+                    modulate(self.attention_norm1(x), scale_msa),
                     x_mask,
                     freqs_cis,
                     transformer_options=transformer_options,
-                ))), timestep_zero_index=timestep_zero_index
+                ))
             )
-            x = x + apply_gate(gate_mlp.unsqueeze(1).tanh(), self.ffn_norm2(
+            x = x + gate_mlp.unsqueeze(1).tanh() * self.ffn_norm2(
                 clamp_fp16(self.feed_forward(
-                    modulate(self.ffn_norm1(x), scale_mlp, timestep_zero_index=timestep_zero_index),
-                ))), timestep_zero_index=timestep_zero_index
+                    modulate(self.ffn_norm1(x), scale_mlp),
+                ))
             )
         else:
             assert adaln_input is None
@@ -389,37 +345,13 @@ class FinalLayer(nn.Module):
             ),
         )
 
-    def forward(self, x, c, timestep_zero_index=None):
+    def forward(self, x, c):
         scale = self.adaLN_modulation(c)
-        x = modulate(self.norm_final(x), scale, timestep_zero_index=timestep_zero_index)
+        x = modulate(self.norm_final(x), scale)
         x = self.linear(x)
         return x
 
 
-def pad_zimage(feats, pad_token, pad_tokens_multiple):
-    pad_extra = (-feats.shape[1]) % pad_tokens_multiple
-    return torch.cat((feats, pad_token.to(device=feats.device, dtype=feats.dtype, copy=True).unsqueeze(0).repeat(feats.shape[0], pad_extra, 1)), dim=1), pad_extra
-
-
-def pos_ids_x(start_t, H_tokens, W_tokens, batch_size, device, transformer_options={}):
-    rope_options = transformer_options.get("rope_options", None)
-    h_scale = 1.0
-    w_scale = 1.0
-    h_start = 0
-    w_start = 0
-    if rope_options is not None:
-        h_scale = rope_options.get("scale_y", 1.0)
-        w_scale = rope_options.get("scale_x", 1.0)
-
-        h_start = rope_options.get("shift_y", 0.0)
-        w_start = rope_options.get("shift_x", 0.0)
-    x_pos_ids = torch.zeros((batch_size, H_tokens * W_tokens, 3), dtype=torch.float32, device=device)
-    x_pos_ids[:, :, 0] = start_t
-    x_pos_ids[:, :, 1] = (torch.arange(H_tokens, dtype=torch.float32, device=device) * h_scale + h_start).view(-1, 1).repeat(1, W_tokens).flatten()
-    x_pos_ids[:, :, 2] = (torch.arange(W_tokens, dtype=torch.float32, device=device) * w_scale + w_start).view(1, -1).repeat(H_tokens, 1).flatten()
-    return x_pos_ids
-
-
 class NextDiT(nn.Module):
     """
     Diffusion model with a Transformer backbone.
@@ -446,7 +378,6 @@ class NextDiT(nn.Module):
         time_scale=1.0,
         pad_tokens_multiple=None,
         clip_text_dim=None,
-        siglip_feat_dim=None,
         image_model=None,
         device=None,
         dtype=None,
@@ -560,41 +491,6 @@ class NextDiT(nn.Module):
                 for layer_id in range(n_layers)
             ]
         )
-
-        if siglip_feat_dim is not None:
-            self.siglip_embedder = nn.Sequential(
-                operation_settings.get("operations").RMSNorm(siglip_feat_dim, eps=norm_eps, elementwise_affine=True, device=operation_settings.get("device"), dtype=operation_settings.get("dtype")),
-                operation_settings.get("operations").Linear(
-                    siglip_feat_dim,
-                    dim,
-                    bias=True,
-                    device=operation_settings.get("device"),
-                    dtype=operation_settings.get("dtype"),
-                ),
-            )
-            self.siglip_refiner = nn.ModuleList(
-                [
-                    JointTransformerBlock(
-                        layer_id,
-                        dim,
-                        n_heads,
-                        n_kv_heads,
-                        multiple_of,
-                        ffn_dim_multiplier,
-                        norm_eps,
-                        qk_norm,
-                        modulation=False,
-                        operation_settings=operation_settings,
-                    )
-                    for layer_id in range(n_refiner_layers)
-                ]
-            )
-            self.siglip_pad_token = nn.Parameter(torch.empty((1, dim), device=device, dtype=dtype))
-        else:
-            self.siglip_embedder = None
-            self.siglip_refiner = None
-            self.siglip_pad_token = None
-
         # This norm final is in the lumina 2.0 code but isn't actually used for anything.
         # self.norm_final = operation_settings.get("operations").RMSNorm(dim, eps=norm_eps, elementwise_affine=True, device=operation_settings.get("device"), dtype=operation_settings.get("dtype"))
         self.final_layer = FinalLayer(dim, patch_size, self.out_channels, z_image_modulation=z_image_modulation, operation_settings=operation_settings)
@@ -635,168 +531,70 @@ class NextDiT(nn.Module):
             imgs = torch.stack(imgs, dim=0)
         return imgs
 
-    def embed_cap(self, cap_feats=None, offset=0, bsz=1, device=None, dtype=None):
-        if cap_feats is not None:
-            cap_feats = self.cap_embedder(cap_feats)
-            cap_feats_len = cap_feats.shape[1]
+    def patchify_and_embed(
+        self, x: List[torch.Tensor] | torch.Tensor, cap_feats: torch.Tensor, cap_mask: torch.Tensor, t: torch.Tensor, num_tokens, transformer_options={}
+    ) -> Tuple[torch.Tensor, torch.Tensor, List[Tuple[int, int]], List[int], torch.Tensor]:
+        bsz = len(x)
+        pH = pW = self.patch_size
+        device = x[0].device
+        orig_x = x
+
         if self.pad_tokens_multiple is not None:
-                cap_feats, _ = pad_zimage(cap_feats, self.cap_pad_token, self.pad_tokens_multiple)
-        else:
-            cap_feats_len = 0
-            cap_feats = self.cap_pad_token.to(device=device, dtype=dtype, copy=True).unsqueeze(0).repeat(bsz, self.pad_tokens_multiple, 1)
+            pad_extra = (-cap_feats.shape[1]) % self.pad_tokens_multiple
+            cap_feats = torch.cat((cap_feats, self.cap_pad_token.to(device=cap_feats.device, dtype=cap_feats.dtype, copy=True).unsqueeze(0).repeat(cap_feats.shape[0], pad_extra, 1)), dim=1)
 
         cap_pos_ids = torch.zeros(bsz, cap_feats.shape[1], 3, dtype=torch.float32, device=device)
-        cap_pos_ids[:, :, 0] = torch.arange(cap_feats.shape[1], dtype=torch.float32, device=device) + 1.0 + offset
-        embeds = (cap_feats,)
-        freqs_cis = (self.rope_embedder(cap_pos_ids).movedim(1, 2),)
-        return embeds, freqs_cis, cap_feats_len
-
-    def embed_all(self, x, cap_feats=None, siglip_feats=None, offset=0, omni=False, transformer_options={}):
-        bsz = 1
-        pH = pW = self.patch_size
-        device = x.device
-        embeds, freqs_cis, cap_feats_len = self.embed_cap(cap_feats, offset=offset, bsz=bsz, device=device, dtype=x.dtype)
-
-        if (not omni) or self.siglip_embedder is None:
-            cap_feats_len = embeds[0].shape[1] + offset
-            embeds += (None,)
-            freqs_cis += (None,)
-        else:
-            cap_feats_len += offset
-            if siglip_feats is not None:
-                b, h, w, c = siglip_feats.shape
-                siglip_feats = siglip_feats.permute(0, 3, 1, 2).reshape(b, h * w, c)
-                siglip_feats = self.siglip_embedder(siglip_feats)
-                siglip_pos_ids = torch.zeros((bsz, siglip_feats.shape[1], 3), dtype=torch.float32, device=device)
-                siglip_pos_ids[:, :, 0] = cap_feats_len + 2
-                siglip_pos_ids[:, :, 1] = (torch.linspace(0, h * 8 - 1, steps=h, dtype=torch.float32, device=device).floor()).view(-1, 1).repeat(1, w).flatten()
-                siglip_pos_ids[:, :, 2] = (torch.linspace(0, w * 8 - 1, steps=w, dtype=torch.float32, device=device).floor()).view(1, -1).repeat(h, 1).flatten()
-                if self.siglip_pad_token is not None:
-                    siglip_feats, pad_extra = pad_zimage(siglip_feats, self.siglip_pad_token, self.pad_tokens_multiple)  # TODO: double check
-                    siglip_pos_ids = torch.nn.functional.pad(siglip_pos_ids, (0, 0, 0, pad_extra))
-            else:
-                if self.siglip_pad_token is not None:
-                    siglip_feats = self.siglip_pad_token.to(device=device, dtype=x.dtype, copy=True).unsqueeze(0).repeat(bsz, self.pad_tokens_multiple, 1)
-                    siglip_pos_ids = torch.zeros((bsz, siglip_feats.shape[1], 3), dtype=torch.float32, device=device)
-
-            if siglip_feats is None:
-                embeds += (None,)
-                freqs_cis += (None,)
-            else:
-                embeds += (siglip_feats,)
-                freqs_cis += (self.rope_embedder(siglip_pos_ids).movedim(1, 2),)
+        cap_pos_ids[:, :, 0] = torch.arange(cap_feats.shape[1], dtype=torch.float32, device=device) + 1.0
 
         B, C, H, W = x.shape
         x = self.x_embedder(x.view(B, C, H // pH, pH, W // pW, pW).permute(0, 2, 4, 3, 5, 1).flatten(3).flatten(1, 2))
-        x_pos_ids = pos_ids_x(cap_feats_len + 1, H // pH, W // pW, bsz, device, transformer_options=transformer_options)
+
+        rope_options = transformer_options.get("rope_options", None)
+        h_scale = 1.0
+        w_scale = 1.0
+        h_start = 0
+        w_start = 0
+        if rope_options is not None:
+            h_scale = rope_options.get("scale_y", 1.0)
+            w_scale = rope_options.get("scale_x", 1.0)
+
+            h_start = rope_options.get("shift_y", 0.0)
+            w_start = rope_options.get("shift_x", 0.0)
+
+        H_tokens, W_tokens = H // pH, W // pW
+        x_pos_ids = torch.zeros((bsz, x.shape[1], 3), dtype=torch.float32, device=device)
+        x_pos_ids[:, :, 0] = cap_feats.shape[1] + 1
+        x_pos_ids[:, :, 1] = (torch.arange(H_tokens, dtype=torch.float32, device=device) * h_scale + h_start).view(-1, 1).repeat(1, W_tokens).flatten()
+        x_pos_ids[:, :, 2] = (torch.arange(W_tokens, dtype=torch.float32, device=device) * w_scale + w_start).view(1, -1).repeat(H_tokens, 1).flatten()
+
         if self.pad_tokens_multiple is not None:
-            x, pad_extra = pad_zimage(x, self.x_pad_token, self.pad_tokens_multiple)
+            pad_extra = (-x.shape[1]) % self.pad_tokens_multiple
+            x = torch.cat((x, self.x_pad_token.to(device=x.device, dtype=x.dtype, copy=True).unsqueeze(0).repeat(x.shape[0], pad_extra, 1)), dim=1)
             x_pos_ids = torch.nn.functional.pad(x_pos_ids, (0, 0, 0, pad_extra))
 
-        embeds += (x,)
-        freqs_cis += (self.rope_embedder(x_pos_ids).movedim(1, 2),)
-        return embeds, freqs_cis, cap_feats_len + len(freqs_cis) - 1
-
-
-    def patchify_and_embed(
-        self, x: torch.Tensor, cap_feats: torch.Tensor, cap_mask: torch.Tensor, t: torch.Tensor, num_tokens, ref_latents=[], ref_contexts=[], siglip_feats=[], transformer_options={}
-    ) -> Tuple[torch.Tensor, torch.Tensor, List[Tuple[int, int]], List[int], torch.Tensor]:
-        bsz = x.shape[0]
-        cap_mask = None  # TODO?
-        main_siglip = None
-        orig_x = x
-
-        embeds = ([], [], [])
-        freqs_cis = ([], [], [])
-        leftover_cap = []
-
-        start_t = 0
-        omni = len(ref_latents) > 0
-        if omni:
-            for i, ref in enumerate(ref_latents):
-                if i < len(ref_contexts):
-                    ref_con = ref_contexts[i]
-                else:
-                    ref_con = None
-                if i < len(siglip_feats):
-                    sig_feat = siglip_feats[i]
-                else:
-                    sig_feat = None
-
-                out = self.embed_all(ref, ref_con, sig_feat, offset=start_t, omni=omni, transformer_options=transformer_options)
-                for i, e in enumerate(out[0]):
-                    if e is not None:
-                        embeds[i].append(comfy.utils.repeat_to_batch_size(e, bsz))
-                        freqs_cis[i].append(out[1][i])
-                start_t = out[2]
-            leftover_cap = ref_contexts[len(ref_latents):]
-
-        H, W = x.shape[-2], x.shape[-1]
-        img_sizes = [(H, W)] * bsz
-        out = self.embed_all(x, cap_feats, main_siglip, offset=start_t, omni=omni, transformer_options=transformer_options)
-        img_len = out[0][-1].shape[1]
-        cap_len = out[0][0].shape[1]
-        for i, e in enumerate(out[0]):
-            if e is not None:
-                e = comfy.utils.repeat_to_batch_size(e, bsz)
-                embeds[i].append(e)
-                freqs_cis[i].append(out[1][i])
-        start_t = out[2]
-
-        for cap in leftover_cap:
-            out = self.embed_cap(cap, offset=start_t, bsz=bsz, device=x.device, dtype=x.dtype)
-            cap_len += out[0][0].shape[1]
-            embeds[0].append(comfy.utils.repeat_to_batch_size(out[0][0], bsz))
-            freqs_cis[0].append(out[1][0])
-            start_t += out[2]
+        freqs_cis = self.rope_embedder(torch.cat((cap_pos_ids, x_pos_ids), dim=1)).movedim(1, 2)
 
         patches = transformer_options.get("patches", {})
 
         # refine context
-        cap_feats = torch.cat(embeds[0], dim=1)
-        cap_freqs_cis = torch.cat(freqs_cis[0], dim=1)
         for layer in self.context_refiner:
-            cap_feats = layer(cap_feats, cap_mask, cap_freqs_cis, transformer_options=transformer_options)
-
-        feats = (cap_feats,)
-        fc = (cap_freqs_cis,)
-
-        if omni and len(embeds[1]) > 0:
-            siglip_mask = None
-            siglip_feats_combined = torch.cat(embeds[1], dim=1)
-            siglip_feats_freqs_cis = torch.cat(freqs_cis[1], dim=1)
-            if self.siglip_refiner is not None:
-                for layer in self.siglip_refiner:
-                    siglip_feats_combined = layer(siglip_feats_combined, siglip_mask, siglip_feats_freqs_cis, transformer_options=transformer_options)
-            feats += (siglip_feats_combined,)
-            fc += (siglip_feats_freqs_cis,)
+            cap_feats = layer(cap_feats, cap_mask, freqs_cis[:, :cap_pos_ids.shape[1]], transformer_options=transformer_options)
 
         padded_img_mask = None
-        x = torch.cat(embeds[-1], dim=1)
-        fc_x = torch.cat(freqs_cis[-1], dim=1)
-        if omni:
-            timestep_zero_index = [(x.shape[1] - img_len, x.shape[1])]
-        else:
-            timestep_zero_index = None
-
         x_input = x
         for i, layer in enumerate(self.noise_refiner):
-            x = layer(x, padded_img_mask, fc_x, t, timestep_zero_index=timestep_zero_index, transformer_options=transformer_options)
+            x = layer(x, padded_img_mask, freqs_cis[:, cap_pos_ids.shape[1]:], t, transformer_options=transformer_options)
             if "noise_refiner" in patches:
                 for p in patches["noise_refiner"]:
-                    out = p({"img": x, "img_input": x_input, "txt": cap_feats, "pe": fc_x, "vec": t, "x": orig_x, "block_index": i, "transformer_options": transformer_options, "block_type": "noise_refiner"})
+                    out = p({"img": x, "img_input": x_input, "txt": cap_feats, "pe": freqs_cis[:, cap_pos_ids.shape[1]:], "vec": t, "x": orig_x, "block_index": i, "transformer_options": transformer_options, "block_type": "noise_refiner"})
                     if "img" in out:
                         x = out["img"]
 
-        padded_full_embed = torch.cat(feats + (x,), dim=1)
-        if timestep_zero_index is not None:
-            ind = padded_full_embed.shape[1] - x.shape[1]
-            timestep_zero_index = [(ind + x.shape[1] - img_len, ind + x.shape[1])]
-            timestep_zero_index.append((feats[0].shape[1] - cap_len, feats[0].shape[1]))
-
+        padded_full_embed = torch.cat((cap_feats, x), dim=1)
         mask = None
-        l_effective_cap_len = [padded_full_embed.shape[1] - img_len] * bsz
-        return padded_full_embed, mask, img_sizes, l_effective_cap_len, torch.cat(fc + (fc_x,), dim=1), timestep_zero_index
+        img_sizes = [(H, W)] * bsz
+        l_effective_cap_len = [cap_feats.shape[1]] * bsz
+        return padded_full_embed, mask, img_sizes, l_effective_cap_len, freqs_cis
 
     def forward(self, x, timesteps, context, num_tokens, attention_mask=None, **kwargs):
         return comfy.patcher_extension.WrapperExecutor.new_class_executor(
@@ -806,11 +604,7 @@ class NextDiT(nn.Module):
         ).execute(x, timesteps, context, num_tokens, attention_mask, **kwargs)
 
     # def forward(self, x, t, cap_feats, cap_mask):
-    def _forward(self, x, timesteps, context, num_tokens, attention_mask=None, ref_latents=[], ref_contexts=[], siglip_feats=[], transformer_options={}, **kwargs):
-        omni = len(ref_latents) > 0
-        if omni:
-            timesteps = torch.cat([timesteps * 0, timesteps], dim=0)
-
+    def _forward(self, x, timesteps, context, num_tokens, attention_mask=None, transformer_options={}, **kwargs):
         t = 1.0 - timesteps
         cap_feats = context
         cap_mask = attention_mask
@@ -825,6 +619,8 @@ class NextDiT(nn.Module):
         t = self.t_embedder(t * self.time_scale, dtype=x.dtype)  # (N, D)
         adaln_input = t
 
+        cap_feats = self.cap_embedder(cap_feats)  # (N, L, D)  # todo check if able to batchify w.o. redundant compute
+
         if self.clip_text_pooled_proj is not None:
             pooled = kwargs.get("clip_text_pooled", None)
             if pooled is not None:
@@ -836,7 +632,7 @@ class NextDiT(nn.Module):
 
         patches = transformer_options.get("patches", {})
         x_is_tensor = isinstance(x, torch.Tensor)
-        img, mask, img_size, cap_size, freqs_cis, timestep_zero_index = self.patchify_and_embed(x, cap_feats, cap_mask, adaln_input, num_tokens, ref_latents=ref_latents, ref_contexts=ref_contexts, siglip_feats=siglip_feats, transformer_options=transformer_options)
+        img, mask, img_size, cap_size, freqs_cis = self.patchify_and_embed(x, cap_feats, cap_mask, adaln_input, num_tokens, transformer_options=transformer_options)
         freqs_cis = freqs_cis.to(img.device)
 
         transformer_options["total_blocks"] = len(self.layers)
@@ -844,7 +640,7 @@ class NextDiT(nn.Module):
         img_input = img
         for i, layer in enumerate(self.layers):
             transformer_options["block_index"] = i
-            img = layer(img, mask, freqs_cis, adaln_input, timestep_zero_index=timestep_zero_index, transformer_options=transformer_options)
+            img = layer(img, mask, freqs_cis, adaln_input, transformer_options=transformer_options)
             if "double_block" in patches:
                 for p in patches["double_block"]:
                     out = p({"img": img[:, cap_size[0]:], "img_input": img_input[:, cap_size[0]:], "txt": img[:, :cap_size[0]], "pe": freqs_cis[:, cap_size[0]:], "vec": adaln_input, "x": x, "block_index": i, "transformer_options": transformer_options})
@@ -853,7 +649,8 @@ class NextDiT(nn.Module):
                     if "txt" in out:
                         img[:, :cap_size[0]] = out["txt"]
 
-        img = self.final_layer(img, adaln_input, timestep_zero_index=timestep_zero_index)
+        img = self.final_layer(img, adaln_input)
         img = self.unpatchify(img, img_size, cap_size, return_tensor=x_is_tensor)[:, :, :h, :w]
+
         return -img
 

comfy/ldm/modules/diffusionmodules/model.py

@@ -14,13 +14,10 @@ if model_management.xformers_enabled_vae():
     import xformers.ops
 
 def torch_cat_if_needed(xl, dim):
-    xl = [x for x in xl if x is not None and x.shape[dim] > 0]
     if len(xl) > 1:
         return torch.cat(xl, dim)
-    elif len(xl) == 1:
-        return xl[0]
     else:
-        return None
+        return xl[0]
 
 def get_timestep_embedding(timesteps, embedding_dim):
     """

comfy/ldm/qwen_image/model.py

@@ -170,14 +170,8 @@ class Attention(nn.Module):
         joint_query = apply_rope1(joint_query, image_rotary_emb)
         joint_key = apply_rope1(joint_key, image_rotary_emb)
 
-        if encoder_hidden_states_mask is not None:
-            attn_mask = torch.zeros((batch_size, 1, seq_txt + seq_img), dtype=hidden_states.dtype, device=hidden_states.device)
-            attn_mask[:, 0, :seq_txt] = encoder_hidden_states_mask
-        else:
-            attn_mask = None
-
         joint_hidden_states = optimized_attention_masked(joint_query, joint_key, joint_value, self.heads,
-                                                         attn_mask, transformer_options=transformer_options,
+                                                         attention_mask, transformer_options=transformer_options,
                                                          skip_reshape=True)
 
         txt_attn_output = joint_hidden_states[:, :seq_txt, :]
@@ -436,9 +430,6 @@ class QwenImageTransformer2DModel(nn.Module):
         encoder_hidden_states = context
         encoder_hidden_states_mask = attention_mask
 
-        if encoder_hidden_states_mask is not None and not torch.is_floating_point(encoder_hidden_states_mask):
-            encoder_hidden_states_mask = (encoder_hidden_states_mask - 1).to(x.dtype) * torch.finfo(x.dtype).max
-
         hidden_states, img_ids, orig_shape = self.process_img(x)
         num_embeds = hidden_states.shape[1]
 

comfy/ldm/wan/model.py

@@ -62,8 +62,6 @@ class WanSelfAttention(nn.Module):
             x(Tensor): Shape [B, L, num_heads, C / num_heads]
             freqs(Tensor): Rope freqs, shape [1024, C / num_heads / 2]
         """
-        patches = transformer_options.get("patches", {})
-
         b, s, n, d = *x.shape[:2], self.num_heads, self.head_dim
 
         def qkv_fn_q(x):
@@ -88,10 +86,6 @@ class WanSelfAttention(nn.Module):
             transformer_options=transformer_options,
         )
 
-        if "attn1_patch" in patches:
-            for p in patches["attn1_patch"]:
-                x = p({"x": x, "q": q, "k": k, "transformer_options": transformer_options})
-
         x = self.o(x)
         return x
 
@@ -231,8 +225,6 @@ class WanAttentionBlock(nn.Module):
         """
         # assert e.dtype == torch.float32
 
-        patches = transformer_options.get("patches", {})
-
         if e.ndim < 4:
             e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e).chunk(6, dim=1)
         else:
@@ -250,11 +242,6 @@ class WanAttentionBlock(nn.Module):
 
         # cross-attention & ffn
         x = x + self.cross_attn(self.norm3(x), context, context_img_len=context_img_len, transformer_options=transformer_options)
-
-        if "attn2_patch" in patches:
-            for p in patches["attn2_patch"]:
-                x = p({"x": x, "transformer_options": transformer_options})
-
         y = self.ffn(torch.addcmul(repeat_e(e[3], x), self.norm2(x), 1 + repeat_e(e[4], x)))
         x = torch.addcmul(x, y, repeat_e(e[5], x))
         return x
@@ -501,7 +488,7 @@ class WanModel(torch.nn.Module):
         self.blocks = nn.ModuleList([
             wan_attn_block_class(cross_attn_type, dim, ffn_dim, num_heads,
                                  window_size, qk_norm, cross_attn_norm, eps, operation_settings=operation_settings)
-            for i in range(num_layers)
+            for _ in range(num_layers)
         ])
 
         # head
@@ -554,7 +541,6 @@ class WanModel(torch.nn.Module):
         # embeddings
         x = self.patch_embedding(x.float()).to(x.dtype)
         grid_sizes = x.shape[2:]
-        transformer_options["grid_sizes"] = grid_sizes
         x = x.flatten(2).transpose(1, 2)
 
         # time embeddings
@@ -752,7 +738,6 @@ class VaceWanModel(WanModel):
         # embeddings
         x = self.patch_embedding(x.float()).to(x.dtype)
         grid_sizes = x.shape[2:]
-        transformer_options["grid_sizes"] = grid_sizes
         x = x.flatten(2).transpose(1, 2)
 
         # time embeddings

comfy/ldm/wan/model_multitalk.py

@@ -1,500 +0,0 @@
-import torch
-from einops import rearrange, repeat
-import comfy
-from comfy.ldm.modules.attention import optimized_attention
-
-
-def calculate_x_ref_attn_map(visual_q, ref_k, ref_target_masks, split_num=8):
-    scale = 1.0 / visual_q.shape[-1] ** 0.5
-    visual_q = visual_q.transpose(1, 2) * scale
-
-    B, H, x_seqlens, K = visual_q.shape
-
-    x_ref_attn_maps = []
-    for class_idx, ref_target_mask in enumerate(ref_target_masks):
-        ref_target_mask = ref_target_mask.view(1, 1, 1, -1)
-
-        x_ref_attnmap = torch.zeros(B, H, x_seqlens, device=visual_q.device, dtype=visual_q.dtype)
-        chunk_size = min(max(x_seqlens // split_num, 1), x_seqlens)
-
-        for i in range(0, x_seqlens, chunk_size):
-            end_i = min(i + chunk_size, x_seqlens)
-
-            attn_chunk = visual_q[:, :, i:end_i] @ ref_k.permute(0, 2, 3, 1)  # B, H, chunk, ref_seqlens
-
-            # Apply softmax
-            attn_max = attn_chunk.max(dim=-1, keepdim=True).values
-            attn_chunk = (attn_chunk - attn_max).exp()
-            attn_sum = attn_chunk.sum(dim=-1, keepdim=True)
-            attn_chunk = attn_chunk / (attn_sum + 1e-8)
-
-            # Apply mask and sum
-            masked_attn = attn_chunk * ref_target_mask
-            x_ref_attnmap[:, :, i:end_i] = masked_attn.sum(-1) / (ref_target_mask.sum() + 1e-8)
-
-            del attn_chunk, masked_attn
-
-        # Average across heads
-        x_ref_attnmap = x_ref_attnmap.mean(dim=1)  # B, x_seqlens
-        x_ref_attn_maps.append(x_ref_attnmap)
-
-    del visual_q, ref_k
-
-    return torch.cat(x_ref_attn_maps, dim=0)
-
-def get_attn_map_with_target(visual_q, ref_k, shape, ref_target_masks=None, split_num=2):
-    """Args:
-        query (torch.tensor): B M H K
-        key (torch.tensor): B M H K
-        shape (tuple): (N_t, N_h, N_w)
-        ref_target_masks: [B, N_h * N_w]
-    """
-
-    N_t, N_h, N_w = shape
-
-    x_seqlens = N_h * N_w
-    ref_k     = ref_k[:, :x_seqlens]
-    _, seq_lens, heads, _ = visual_q.shape
-    class_num, _ = ref_target_masks.shape
-    x_ref_attn_maps = torch.zeros(class_num, seq_lens).to(visual_q)
-
-    split_chunk = heads // split_num
-
-    for i in range(split_num):
-        x_ref_attn_maps_perhead = calculate_x_ref_attn_map(
-            visual_q[:, :, i*split_chunk:(i+1)*split_chunk, :],
-            ref_k[:, :, i*split_chunk:(i+1)*split_chunk, :],
-            ref_target_masks
-            )
-        x_ref_attn_maps += x_ref_attn_maps_perhead
-
-    return x_ref_attn_maps / split_num
-
-
-def normalize_and_scale(column, source_range, target_range, epsilon=1e-8):
-    source_min, source_max = source_range
-    new_min, new_max = target_range
-    normalized = (column - source_min) / (source_max - source_min + epsilon)
-    scaled = normalized * (new_max - new_min) + new_min
-    return scaled
-
-
-def rotate_half(x):
-    x = rearrange(x, "... (d r) -> ... d r", r=2)
-    x1, x2 = x.unbind(dim=-1)
-    x = torch.stack((-x2, x1), dim=-1)
-    return rearrange(x, "... d r -> ... (d r)")
-
-
-def get_audio_embeds(encoded_audio, audio_start, audio_end):
-    audio_embs = []
-    human_num = len(encoded_audio)
-    audio_frames = encoded_audio[0].shape[0]
-
-    indices = (torch.arange(4 + 1) - 2) * 1
-
-    for human_idx in range(human_num):
-        if audio_end > audio_frames: # in case of not enough audio for current window, pad with first audio frame as that's most likely silence
-            pad_len = audio_end - audio_frames
-            pad_shape = list(encoded_audio[human_idx].shape)
-            pad_shape[0] = pad_len
-            pad_tensor = encoded_audio[human_idx][:1].repeat(pad_len, *([1] * (encoded_audio[human_idx].dim() - 1)))
-            encoded_audio_in = torch.cat([encoded_audio[human_idx], pad_tensor], dim=0)
-        else:
-            encoded_audio_in = encoded_audio[human_idx]
-        center_indices = torch.arange(audio_start, audio_end, 1).unsqueeze(1) + indices.unsqueeze(0)
-        center_indices = torch.clamp(center_indices, min=0, max=encoded_audio_in.shape[0] - 1)
-        audio_emb = encoded_audio_in[center_indices].unsqueeze(0)
-        audio_embs.append(audio_emb)
-
-    return torch.cat(audio_embs, dim=0)
-
-
-def project_audio_features(audio_proj, encoded_audio, audio_start, audio_end):
-    audio_embs = get_audio_embeds(encoded_audio, audio_start, audio_end)
-
-    first_frame_audio_emb_s = audio_embs[:, :1, ...]
-    latter_frame_audio_emb = audio_embs[:, 1:, ...]
-    latter_frame_audio_emb = rearrange(latter_frame_audio_emb, "b (n_t n) w s c -> b n_t n w s c", n=4)
-
-    middle_index = audio_proj.seq_len // 2
-
-    latter_first_frame_audio_emb = latter_frame_audio_emb[:, :, :1, :middle_index+1, ...]
-    latter_first_frame_audio_emb = rearrange(latter_first_frame_audio_emb, "b n_t n w s c -> b n_t (n w) s c")
-    latter_last_frame_audio_emb = latter_frame_audio_emb[:, :, -1:, middle_index:, ...]
-    latter_last_frame_audio_emb = rearrange(latter_last_frame_audio_emb, "b n_t n w s c -> b n_t (n w) s c")
-    latter_middle_frame_audio_emb = latter_frame_audio_emb[:, :, 1:-1, middle_index:middle_index+1, ...]
-    latter_middle_frame_audio_emb = rearrange(latter_middle_frame_audio_emb, "b n_t n w s c -> b n_t (n w) s c")
-    latter_frame_audio_emb_s = torch.cat([latter_first_frame_audio_emb, latter_middle_frame_audio_emb, latter_last_frame_audio_emb], dim=2)
-
-    audio_emb = audio_proj(first_frame_audio_emb_s, latter_frame_audio_emb_s)
-    audio_emb = torch.cat(audio_emb.split(1), dim=2)
-
-    return audio_emb
-
-
-class RotaryPositionalEmbedding1D(torch.nn.Module):
-    def __init__(self,
-                 head_dim,
-                 ):
-        super().__init__()
-        self.head_dim = head_dim
-        self.base = 10000
-
-    def precompute_freqs_cis_1d(self, pos_indices):
-        freqs = 1.0 / (self.base ** (torch.arange(0, self.head_dim, 2)[: (self.head_dim // 2)].float() / self.head_dim))
-        freqs = freqs.to(pos_indices.device)
-        freqs = torch.einsum("..., f -> ... f", pos_indices.float(), freqs)
-        freqs = repeat(freqs, "... n -> ... (n r)", r=2)
-        return freqs
-
-    def forward(self, x, pos_indices):
-        freqs_cis = self.precompute_freqs_cis_1d(pos_indices)
-
-        x_ = x.float()
-
-        freqs_cis = freqs_cis.float().to(x.device)
-        cos, sin = freqs_cis.cos(), freqs_cis.sin()
-        cos, sin = rearrange(cos, 'n d -> 1 1 n d'), rearrange(sin, 'n d -> 1 1 n d')
-        x_ = (x_ * cos) + (rotate_half(x_) * sin)
-
-        return x_.type_as(x)
-
-class SingleStreamAttention(torch.nn.Module):
-    def __init__(
-        self,
-        dim: int,
-        encoder_hidden_states_dim: int,
-        num_heads: int,
-        qkv_bias: bool,
-        device=None, dtype=None, operations=None
-    ) -> None:
-        super().__init__()
-        self.dim = dim
-        self.encoder_hidden_states_dim = encoder_hidden_states_dim
-        self.num_heads = num_heads
-        self.head_dim = dim // num_heads
-
-        self.q_linear = operations.Linear(dim, dim, bias=qkv_bias, device=device, dtype=dtype)
-        self.proj = operations.Linear(dim, dim, device=device, dtype=dtype)
-        self.kv_linear = operations.Linear(encoder_hidden_states_dim, dim * 2, bias=qkv_bias, device=device, dtype=dtype)
-
-    def forward(self, x: torch.Tensor, encoder_hidden_states: torch.Tensor, shape=None) -> torch.Tensor:
-        N_t, N_h, N_w = shape
-
-        expected_tokens = N_t * N_h * N_w
-        actual_tokens = x.shape[1]
-        x_extra = None
-
-        if actual_tokens != expected_tokens:
-            x_extra = x[:, -N_h * N_w:, :]
-            x = x[:, :-N_h * N_w, :]
-            N_t = N_t - 1
-
-        B = x.shape[0]
-        S = N_h * N_w
-        x = x.view(B * N_t, S, self.dim)
-
-        # get q for hidden_state
-        q = self.q_linear(x).view(B * N_t, S, self.num_heads, self.head_dim)
-
-        # get kv from encoder_hidden_states # shape: (B, N, num_heads, head_dim)
-        kv = self.kv_linear(encoder_hidden_states)
-        encoder_k, encoder_v = kv.view(B * N_t, encoder_hidden_states.shape[1], 2, self.num_heads, self.head_dim).unbind(2)
-
-        #print("q.shape", q.shape) #torch.Size([21, 1024, 40, 128])
-        x = optimized_attention(
-            q.transpose(1, 2),
-            encoder_k.transpose(1, 2),
-            encoder_v.transpose(1, 2),
-            heads=self.num_heads, skip_reshape=True, skip_output_reshape=True).transpose(1, 2)
-
-        # linear transform
-        x = self.proj(x.reshape(B * N_t, S, self.dim))
-        x = x.view(B, N_t * S, self.dim)
-
-        if x_extra is not None:
-            x = torch.cat([x, torch.zeros_like(x_extra)], dim=1)
-
-        return x
-
-class SingleStreamMultiAttention(SingleStreamAttention):
-    def __init__(
-        self,
-        dim: int,
-        encoder_hidden_states_dim: int,
-        num_heads: int,
-        qkv_bias: bool,
-        class_range: int = 24,
-        class_interval: int = 4,
-        device=None, dtype=None, operations=None
-    ) -> None:
-        super().__init__(
-            dim=dim,
-            encoder_hidden_states_dim=encoder_hidden_states_dim,
-            num_heads=num_heads,
-            qkv_bias=qkv_bias,
-            device=device,
-            dtype=dtype,
-            operations=operations
-        )
-
-        # Rotary-embedding layout parameters
-        self.class_interval = class_interval
-        self.class_range = class_range
-        self.max_humans = self.class_range // self.class_interval
-
-        # Constant bucket used for background tokens
-        self.rope_bak = int(self.class_range // 2)
-
-        self.rope_1d = RotaryPositionalEmbedding1D(self.head_dim)
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        shape=None,
-        x_ref_attn_map=None
-    ) -> torch.Tensor:
-        encoder_hidden_states = encoder_hidden_states.squeeze(0).to(x.device)
-        human_num = x_ref_attn_map.shape[0] if x_ref_attn_map is not None else 1
-        # Single-speaker fall-through
-        if human_num <= 1:
-            return super().forward(x, encoder_hidden_states, shape)
-
-        N_t, N_h, N_w = shape
-
-        x_extra = None
-        if x.shape[0] * N_t != encoder_hidden_states.shape[0]:
-            x_extra = x[:, -N_h * N_w:, :]
-            x = x[:, :-N_h * N_w, :]
-            N_t = N_t - 1
-        x = rearrange(x, "B (N_t S) C -> (B N_t) S C", N_t=N_t)
-
-        # Query projection
-        B, N, C = x.shape
-        q = self.q_linear(x)
-        q = q.view(B, N, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
-
-        # Use `class_range` logic for 2 speakers
-        rope_h1 = (0, self.class_interval)
-        rope_h2 = (self.class_range - self.class_interval, self.class_range)
-        rope_bak = int(self.class_range // 2)
-
-        # Normalize and scale attention maps for each speaker
-        max_values = x_ref_attn_map.max(1).values[:, None, None]
-        min_values = x_ref_attn_map.min(1).values[:, None, None]
-        max_min_values = torch.cat([max_values, min_values], dim=2)
-
-        human1_max_value, human1_min_value = max_min_values[0, :, 0].max(), max_min_values[0, :, 1].min()
-        human2_max_value, human2_min_value = max_min_values[1, :, 0].max(), max_min_values[1, :, 1].min()
-
-        human1 = normalize_and_scale(x_ref_attn_map[0], (human1_min_value, human1_max_value), rope_h1)
-        human2 = normalize_and_scale(x_ref_attn_map[1], (human2_min_value, human2_max_value), rope_h2)
-        back = torch.full((x_ref_attn_map.size(1),), rope_bak, dtype=human1.dtype, device=human1.device)
-
-        # Token-wise speaker dominance
-        max_indices = x_ref_attn_map.argmax(dim=0)
-        normalized_map = torch.stack([human1, human2, back], dim=1)
-        normalized_pos = normalized_map[torch.arange(x_ref_attn_map.size(1)), max_indices]
-
-        # Apply rotary to Q
-        q = rearrange(q, "(B N_t) H S C -> B H (N_t S) C", N_t=N_t)
-        q = self.rope_1d(q, normalized_pos)
-        q = rearrange(q, "B H (N_t S) C -> (B N_t) H S C", N_t=N_t)
-
-        # Keys / Values
-        _, N_a, _ = encoder_hidden_states.shape
-        encoder_kv = self.kv_linear(encoder_hidden_states)
-        encoder_kv = encoder_kv.view(B, N_a, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
-        encoder_k, encoder_v = encoder_kv.unbind(0)
-
-        # Rotary for keys – assign centre of each speaker bucket to its context tokens
-        per_frame = torch.zeros(N_a, dtype=encoder_k.dtype, device=encoder_k.device)
-        per_frame[: per_frame.size(0) // 2] = (rope_h1[0] + rope_h1[1]) / 2
-        per_frame[per_frame.size(0) // 2 :] = (rope_h2[0] + rope_h2[1]) / 2
-        encoder_pos = torch.cat([per_frame] * N_t, dim=0)
-
-        encoder_k = rearrange(encoder_k, "(B N_t) H S C -> B H (N_t S) C", N_t=N_t)
-        encoder_k = self.rope_1d(encoder_k, encoder_pos)
-        encoder_k = rearrange(encoder_k, "B H (N_t S) C -> (B N_t) H S C", N_t=N_t)
-
-        # Final attention
-        q = rearrange(q, "B H M K -> B M H K")
-        encoder_k = rearrange(encoder_k, "B H M K -> B M H K")
-        encoder_v = rearrange(encoder_v, "B H M K -> B M H K")
-
-        x = optimized_attention(
-            q.transpose(1, 2),
-            encoder_k.transpose(1, 2),
-            encoder_v.transpose(1, 2),
-            heads=self.num_heads, skip_reshape=True, skip_output_reshape=True).transpose(1, 2)
-
-        # Linear projection
-        x = x.reshape(B, N, C)
-        x = self.proj(x)
-
-        # Restore original layout
-        x = rearrange(x, "(B N_t) S C -> B (N_t S) C", N_t=N_t)
-        if x_extra is not None:
-            x = torch.cat([x, torch.zeros_like(x_extra)], dim=1)
-
-        return x
-
-
-class MultiTalkAudioProjModel(torch.nn.Module):
-    def __init__(
-        self,
-        seq_len: int = 5,
-        seq_len_vf: int = 12,
-        blocks: int = 12,
-        channels: int = 768,
-        intermediate_dim: int = 512,
-        out_dim: int = 768,
-        context_tokens: int = 32,
-        device=None, dtype=None, operations=None
-    ):
-        super().__init__()
-
-        self.seq_len = seq_len
-        self.blocks = blocks
-        self.channels = channels
-        self.input_dim = seq_len * blocks * channels
-        self.input_dim_vf = seq_len_vf * blocks * channels
-        self.intermediate_dim = intermediate_dim
-        self.context_tokens = context_tokens
-        self.out_dim = out_dim
-
-        # define multiple linear layers
-        self.proj1 = operations.Linear(self.input_dim, intermediate_dim, device=device, dtype=dtype)
-        self.proj1_vf = operations.Linear(self.input_dim_vf, intermediate_dim, device=device, dtype=dtype)
-        self.proj2 = operations.Linear(intermediate_dim, intermediate_dim, device=device, dtype=dtype)
-        self.proj3 = operations.Linear(intermediate_dim, context_tokens * out_dim, device=device, dtype=dtype)
-        self.norm = operations.LayerNorm(out_dim, device=device, dtype=dtype)
-
-    def forward(self, audio_embeds, audio_embeds_vf):
-        video_length = audio_embeds.shape[1] + audio_embeds_vf.shape[1]
-        B, _, _, S, C = audio_embeds.shape
-
-        # process audio of first frame
-        audio_embeds = rearrange(audio_embeds, "bz f w b c -> (bz f) w b c")
-        batch_size, window_size, blocks, channels = audio_embeds.shape
-        audio_embeds = audio_embeds.view(batch_size, window_size * blocks * channels)
-
-        # process audio of latter frame
-        audio_embeds_vf = rearrange(audio_embeds_vf, "bz f w b c -> (bz f) w b c")
-        batch_size_vf, window_size_vf, blocks_vf, channels_vf = audio_embeds_vf.shape
-        audio_embeds_vf = audio_embeds_vf.view(batch_size_vf, window_size_vf * blocks_vf * channels_vf)
-
-        # first projection
-        audio_embeds = torch.relu(self.proj1(audio_embeds))
-        audio_embeds_vf = torch.relu(self.proj1_vf(audio_embeds_vf))
-        audio_embeds = rearrange(audio_embeds, "(bz f) c -> bz f c", bz=B)
-        audio_embeds_vf = rearrange(audio_embeds_vf, "(bz f) c -> bz f c", bz=B)
-        audio_embeds_c = torch.concat([audio_embeds, audio_embeds_vf], dim=1)
-        batch_size_c, N_t, C_a = audio_embeds_c.shape
-        audio_embeds_c = audio_embeds_c.view(batch_size_c*N_t, C_a)
-
-        # second projection
-        audio_embeds_c = torch.relu(self.proj2(audio_embeds_c))
-
-        context_tokens = self.proj3(audio_embeds_c).reshape(batch_size_c*N_t, self.context_tokens, self.out_dim)
-
-        # normalization and reshape
-        context_tokens = self.norm(context_tokens)
-        context_tokens = rearrange(context_tokens, "(bz f) m c -> bz f m c", f=video_length)
-
-        return context_tokens
-
-
-class WanMultiTalkAttentionBlock(torch.nn.Module):
-    def __init__(self, in_dim=5120, out_dim=768, device=None, dtype=None, operations=None):
-        super().__init__()
-        self.audio_cross_attn = SingleStreamMultiAttention(in_dim, out_dim, num_heads=40, qkv_bias=True, device=device, dtype=dtype, operations=operations)
-        self.norm_x = operations.LayerNorm(in_dim, device=device, dtype=dtype, elementwise_affine=True)
-
-
-class MultiTalkGetAttnMapPatch:
-    def __init__(self, ref_target_masks=None):
-        self.ref_target_masks = ref_target_masks
-
-    def __call__(self, kwargs):
-        transformer_options = kwargs.get("transformer_options", {})
-        x = kwargs["x"]
-
-        if self.ref_target_masks is not None:
-            x_ref_attn_map = get_attn_map_with_target(kwargs["q"], kwargs["k"], transformer_options["grid_sizes"], ref_target_masks=self.ref_target_masks.to(x.device))
-            transformer_options["x_ref_attn_map"] = x_ref_attn_map
-        return x
-
-
-class MultiTalkCrossAttnPatch:
-    def __init__(self, model_patch, audio_scale=1.0, ref_target_masks=None):
-        self.model_patch = model_patch
-        self.audio_scale = audio_scale
-        self.ref_target_masks = ref_target_masks
-
-    def __call__(self, kwargs):
-        transformer_options = kwargs.get("transformer_options", {})
-        block_idx = transformer_options.get("block_index", None)
-        x = kwargs["x"]
-        if block_idx is None:
-            return torch.zeros_like(x)
-
-        audio_embeds = transformer_options.get("audio_embeds")
-        x_ref_attn_map = transformer_options.pop("x_ref_attn_map", None)
-
-        norm_x = self.model_patch.model.blocks[block_idx].norm_x(x)
-        x_audio = self.model_patch.model.blocks[block_idx].audio_cross_attn(
-            norm_x, audio_embeds.to(x.dtype),
-            shape=transformer_options["grid_sizes"],
-            x_ref_attn_map=x_ref_attn_map
-        )
-        x = x + x_audio * self.audio_scale
-        return x
-
-    def models(self):
-        return [self.model_patch]
-
-class MultiTalkApplyModelWrapper:
-    def __init__(self, init_latents):
-        self.init_latents = init_latents
-
-    def __call__(self, executor, x, *args, **kwargs):
-        x[:, :, :self.init_latents.shape[2]] = self.init_latents.to(x)
-        samples = executor(x, *args, **kwargs)
-        return samples
-
-
-class InfiniteTalkOuterSampleWrapper:
-    def __init__(self, motion_frames_latent, model_patch, is_extend=False):
-        self.motion_frames_latent = motion_frames_latent
-        self.model_patch = model_patch
-        self.is_extend = is_extend
-
-    def __call__(self, executor, *args, **kwargs):
-        model_patcher = executor.class_obj.model_patcher
-        model_options = executor.class_obj.model_options
-        process_latent_in = model_patcher.model.process_latent_in
-
-        # for InfiniteTalk, model input first latent(s) need to always be replaced on every step
-        if self.motion_frames_latent is not None:
-            wrappers = model_options["transformer_options"]["wrappers"]
-            w = wrappers.setdefault(comfy.patcher_extension.WrappersMP.APPLY_MODEL, {})
-            w["MultiTalk_apply_model"] = [MultiTalkApplyModelWrapper(process_latent_in(self.motion_frames_latent))]
-
-        # run the sampling process
-        result = executor(*args, **kwargs)
-
-        # insert motion frames before decoding
-        if self.is_extend:
-            overlap = self.motion_frames_latent.shape[2]
-            result = torch.cat([self.motion_frames_latent.to(result), result[:, :, overlap:]], dim=2)
-
-        return result
-
-    def to(self, device_or_dtype):
-        if isinstance(device_or_dtype, torch.device):
-            if self.motion_frames_latent is not None:
-                self.motion_frames_latent = self.motion_frames_latent.to(device_or_dtype)
-        return self

comfy/lora.py

@@ -322,7 +322,6 @@ def model_lora_keys_unet(model, key_map={}):
                 key_map["diffusion_model.{}".format(key_lora)] = to
                 key_map["transformer.{}".format(key_lora)] = to
                 key_map["lycoris_{}".format(key_lora.replace(".", "_"))] = to
-                key_map[key_lora] = to
 
     if isinstance(model, comfy.model_base.Kandinsky5):
         for k in sdk:

comfy/model_base.py

@@ -49,7 +49,6 @@ import comfy.ldm.ace.model
 import comfy.ldm.omnigen.omnigen2
 import comfy.ldm.qwen_image.model
 import comfy.ldm.kandinsky5.model
-import comfy.ldm.anima.model
 
 import comfy.model_management
 import comfy.patcher_extension
@@ -1148,31 +1147,9 @@ class CosmosPredict2(BaseModel):
         sigma = (sigma / (sigma + 1))
         return latent_image / (1.0 - sigma)
 
-class Anima(BaseModel):
-    def __init__(self, model_config, model_type=ModelType.FLOW, device=None):
-        super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.anima.model.Anima)
-
-    def extra_conds(self, **kwargs):
-        out = super().extra_conds(**kwargs)
-        cross_attn = kwargs.get("cross_attn", None)
-        t5xxl_ids = kwargs.get("t5xxl_ids", None)
-        t5xxl_weights = kwargs.get("t5xxl_weights", None)
-        device = kwargs["device"]
-        if cross_attn is not None:
-            if t5xxl_ids is not None:
-                cross_attn = self.diffusion_model.preprocess_text_embeds(cross_attn.to(device=device, dtype=self.get_dtype()), t5xxl_ids.unsqueeze(0).to(device=device))
-                if t5xxl_weights is not None:
-                    cross_attn *= t5xxl_weights.unsqueeze(0).unsqueeze(-1).to(cross_attn)
-
-                if cross_attn.shape[1] < 512:
-                    cross_attn = torch.nn.functional.pad(cross_attn, (0, 0, 0, 512 - cross_attn.shape[1]))
-            out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn)
-        return out
-
 class Lumina2(BaseModel):
     def __init__(self, model_config, model_type=ModelType.FLOW, device=None):
         super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.lumina.model.NextDiT)
-        self.memory_usage_factor_conds = ("ref_latents",)
 
     def extra_conds(self, **kwargs):
         out = super().extra_conds(**kwargs)
@@ -1192,35 +1169,6 @@ class Lumina2(BaseModel):
         if clip_text_pooled is not None:
             out['clip_text_pooled'] = comfy.conds.CONDRegular(clip_text_pooled)
 
-        clip_vision_outputs = kwargs.get("clip_vision_outputs", list(map(lambda a: a.get("clip_vision_output"), kwargs.get("unclip_conditioning", [{}]))))  # Z Image omni
-        if clip_vision_outputs is not None and len(clip_vision_outputs) > 0:
-            sigfeats = []
-            for clip_vision_output in clip_vision_outputs:
-                if clip_vision_output is not None:
-                    image_size = clip_vision_output.image_sizes[0]
-                    shape = clip_vision_output.last_hidden_state.shape
-                    sigfeats.append(clip_vision_output.last_hidden_state.reshape(shape[0], image_size[1] // 16, image_size[2] // 16, shape[-1]))
-            if len(sigfeats) > 0:
-                out['siglip_feats'] = comfy.conds.CONDList(sigfeats)
-
-        ref_latents = kwargs.get("reference_latents", None)
-        if ref_latents is not None:
-            latents = []
-            for lat in ref_latents:
-                latents.append(self.process_latent_in(lat))
-            out['ref_latents'] = comfy.conds.CONDList(latents)
-
-        ref_contexts = kwargs.get("reference_latents_text_embeds", None)
-        if ref_contexts is not None:
-            out['ref_contexts'] = comfy.conds.CONDList(ref_contexts)
-
-        return out
-
-    def extra_conds_shapes(self, **kwargs):
-        out = {}
-        ref_latents = kwargs.get("reference_latents", None)
-        if ref_latents is not None:
-            out['ref_latents'] = list([1, 16, sum(map(lambda a: math.prod(a.size()[2:]), ref_latents))])
         return out
 
 class WAN21(BaseModel):
@@ -1578,9 +1526,6 @@ class QwenImage(BaseModel):
 
     def extra_conds(self, **kwargs):
         out = super().extra_conds(**kwargs)
-        attention_mask = kwargs.get("attention_mask", None)
-        if attention_mask is not None:
-            out['attention_mask'] = comfy.conds.CONDRegular(attention_mask)
         cross_attn = kwargs.get("cross_attn", None)
         if cross_attn is not None:
             out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn)

comfy/model_detection.py

@@ -237,8 +237,6 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
         else:
             dit_config["vec_in_dim"] = None
 
-        dit_config["num_heads"] = dit_config["hidden_size"] // sum(dit_config["axes_dim"])
-
         dit_config["depth"] = count_blocks(state_dict_keys, '{}double_blocks.'.format(key_prefix) + '{}.')
         dit_config["depth_single_blocks"] = count_blocks(state_dict_keys, '{}single_blocks.'.format(key_prefix) + '{}.')
         if '{}distilled_guidance_layer.0.norms.0.scale'.format(key_prefix) in state_dict_keys or '{}distilled_guidance_layer.norms.0.scale'.format(key_prefix) in state_dict_keys: #Chroma
@@ -253,7 +251,7 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
                 dit_config["image_model"] = "chroma_radiance"
                 dit_config["in_channels"] = 3
                 dit_config["out_channels"] = 3
-                dit_config["patch_size"] = state_dict.get('{}img_in_patch.weight'.format(key_prefix)).size(dim=-1)
+                dit_config["patch_size"] = 16
                 dit_config["nerf_hidden_size"] = 64
                 dit_config["nerf_mlp_ratio"] = 4
                 dit_config["nerf_depth"] = 4
@@ -446,9 +444,6 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
             dit_config["time_scale"] = 1000.0
             if '{}cap_pad_token'.format(key_prefix) in state_dict_keys:
                 dit_config["pad_tokens_multiple"] = 32
-            sig_weight = state_dict.get('{}siglip_embedder.0.weight'.format(key_prefix), None)
-            if sig_weight is not None:
-                dit_config["siglip_feat_dim"] = sig_weight.shape[0]
 
         return dit_config
 
@@ -550,8 +545,6 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
     if '{}blocks.0.mlp.layer1.weight'.format(key_prefix) in state_dict_keys:  # Cosmos predict2
         dit_config = {}
         dit_config["image_model"] = "cosmos_predict2"
-        if "{}llm_adapter.blocks.0.cross_attn.q_proj.weight".format(key_prefix) in state_dict_keys:
-            dit_config["image_model"] = "anima"
         dit_config["max_img_h"] = 240
         dit_config["max_img_w"] = 240
         dit_config["max_frames"] = 128

comfy/model_management.py

@@ -22,6 +22,7 @@ from enum import Enum
 from comfy.cli_args import args, PerformanceFeature
 import torch
 import sys
+import importlib
 import platform
 import weakref
 import gc
@@ -348,27 +349,15 @@ try:
         except:
             rocm_version = (6, -1)
 
-        def aotriton_supported(gpu_arch):
-            path = torch.__path__[0]
-            path = os.path.join(os.path.join(path, "lib"), "aotriton.images")
-            gfx = set(map(lambda a: a[4:], filter(lambda a: a.startswith("amd-gfx"), os.listdir(path))))
-            if gpu_arch in gfx:
-                return True
-            if "{}x".format(gpu_arch[:-1]) in gfx:
-                return True
-            if "{}xx".format(gpu_arch[:-2]) in gfx:
-                return True
-            return False
-
         logging.info("AMD arch: {}".format(arch))
         logging.info("ROCm version: {}".format(rocm_version))
         if args.use_split_cross_attention == False and args.use_quad_cross_attention == False:
-            if aotriton_supported(arch):  # AMD efficient attention implementation depends on aotriton.
+            if importlib.util.find_spec('triton') is not None:  # AMD efficient attention implementation depends on triton. TODO: better way of detecting if it's compiled in or not.
                 if torch_version_numeric >= (2, 7):  # works on 2.6 but doesn't actually seem to improve much
                     if any((a in arch) for a in ["gfx90a", "gfx942", "gfx1100", "gfx1101", "gfx1151"]):  # TODO: more arches, TODO: gfx950
                         ENABLE_PYTORCH_ATTENTION = True
                 if rocm_version >= (7, 0):
-                   if any((a in arch) for a in ["gfx1200", "gfx1201"]):
+                   if any((a in arch) for a in ["gfx1201"]):
                        ENABLE_PYTORCH_ATTENTION = True
         if torch_version_numeric >= (2, 7) and rocm_version >= (6, 4):
             if any((a in arch) for a in ["gfx1200", "gfx1201", "gfx950"]):  # TODO: more arches, "gfx942" gives error on pytorch nightly 2.10 1013 rocm7.0

comfy/ops.py

@@ -546,8 +546,7 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                 weight_key = f"{prefix}weight"
                 weight = state_dict.pop(weight_key, None)
                 if weight is None:
-                    logging.warning(f"Missing weight for layer {layer_name}")
-                    return
+                    raise ValueError(f"Missing weight for layer {layer_name}")
 
                 manually_loaded_keys = [weight_key]
 
@@ -625,29 +624,21 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                         missing_keys.remove(key)
 
             def state_dict(self, *args, destination=None, prefix="", **kwargs):
-                if destination is not None:
-                    sd = destination
-                else:
-                    sd = {}
-
-                if self.bias is not None:
-                    sd["{}bias".format(prefix)] = self.bias
-
+                sd = super().state_dict(*args, destination=destination, prefix=prefix, **kwargs)
                 if isinstance(self.weight, QuantizedTensor):
-                    sd_out = self.weight.state_dict("{}weight".format(prefix))
-                    for k in sd_out:
-                        sd[k] = sd_out[k]
+                    layout_cls = self.weight._layout_cls
+
+                    # Check if it's any FP8 variant (E4M3 or E5M2)
+                    if layout_cls in ("TensorCoreFP8E4M3Layout", "TensorCoreFP8E5M2Layout", "TensorCoreFP8Layout"):
+                        sd["{}weight_scale".format(prefix)] = self.weight._params.scale
+                    elif layout_cls == "TensorCoreNVFP4Layout":
+                        sd["{}weight_scale_2".format(prefix)] = self.weight._params.scale
+                        sd["{}weight_scale".format(prefix)] = self.weight._params.block_scale
 
                     quant_conf = {"format": self.quant_format}
                     if self._full_precision_mm_config:
                         quant_conf["full_precision_matrix_mult"] = True
                     sd["{}comfy_quant".format(prefix)] = torch.tensor(list(json.dumps(quant_conf).encode('utf-8')), dtype=torch.uint8)
-
-                    input_scale = getattr(self, 'input_scale', None)
-                    if input_scale is not None:
-                        sd["{}input_scale".format(prefix)] = input_scale
-                else:
-                    sd["{}weight".format(prefix)] = self.weight
                 return sd
 
             def _forward(self, input, weight, bias):
@@ -699,7 +690,7 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
             def set_weight(self, weight, inplace_update=False, seed=None, return_weight=False, **kwargs):
                 if getattr(self, 'layout_type', None) is not None:
                     # dtype is now implicit in the layout class
-                    weight = QuantizedTensor.from_float(weight, self.layout_type, scale="recalculate", stochastic_rounding=seed, inplace_ops=True).to(self.weight.dtype)
+                    weight = QuantizedTensor.from_float(weight, self.layout_type, scale="recalculate", stochastic_rounding=seed, inplace_ops=True)
                 else:
                     weight = weight.to(self.weight.dtype)
                 if return_weight:

comfy/quant_ops.py

@@ -7,7 +7,7 @@ try:
         QuantizedTensor,
         QuantizedLayout,
         TensorCoreFP8Layout as _CKFp8Layout,
-        TensorCoreNVFP4Layout as _CKNvfp4Layout,
+        TensorCoreNVFP4Layout,  # Direct import, no wrapper needed
         register_layout_op,
         register_layout_class,
         get_layout_class,
@@ -34,7 +34,7 @@ except ImportError as e:
     class _CKFp8Layout:
         pass
 
-    class _CKNvfp4Layout:
+    class TensorCoreNVFP4Layout:
         pass
 
     def register_layout_class(name, cls):
@@ -84,39 +84,6 @@ class _TensorCoreFP8LayoutBase(_CKFp8Layout):
         return qdata, params
 
 
-class TensorCoreNVFP4Layout(_CKNvfp4Layout):
-    @classmethod
-    def quantize(cls, tensor, scale=None, stochastic_rounding=0, inplace_ops=False):
-        if tensor.dim() != 2:
-            raise ValueError(f"NVFP4 requires 2D tensor, got {tensor.dim()}D")
-
-        orig_dtype = tensor.dtype
-        orig_shape = tuple(tensor.shape)
-
-        if scale is None or (isinstance(scale, str) and scale == "recalculate"):
-            scale = torch.amax(tensor.abs()) / (ck.float_utils.F8_E4M3_MAX * ck.float_utils.F4_E2M1_MAX)
-
-        if not isinstance(scale, torch.Tensor):
-            scale = torch.tensor(scale)
-        scale = scale.to(device=tensor.device, dtype=torch.float32)
-
-        padded_shape = cls.get_padded_shape(orig_shape)
-        needs_padding = padded_shape != orig_shape
-
-        if stochastic_rounding > 0:
-            qdata, block_scale = comfy.float.stochastic_round_quantize_nvfp4_by_block(tensor, scale, pad_16x=needs_padding, seed=stochastic_rounding)
-        else:
-            qdata, block_scale = ck.quantize_nvfp4(tensor, scale, pad_16x=needs_padding)
-
-        params = cls.Params(
-            scale=scale,
-            orig_dtype=orig_dtype,
-            orig_shape=orig_shape,
-            block_scale=block_scale,
-        )
-        return qdata, params
-
-
 class TensorCoreFP8E4M3Layout(_TensorCoreFP8LayoutBase):
     FP8_DTYPE = torch.float8_e4m3fn
 

comfy/sd.py

@@ -57,7 +57,6 @@ import comfy.text_encoders.ovis
 import comfy.text_encoders.kandinsky5
 import comfy.text_encoders.jina_clip_2
 import comfy.text_encoders.newbie
-import comfy.text_encoders.anima
 
 import comfy.model_patcher
 import comfy.lora
@@ -636,13 +635,14 @@ class VAE:
                 self.upscale_index_formula = (4, 16, 16)
                 self.downscale_ratio = (lambda a: max(0, math.floor((a + 3) / 4)), 16, 16)
                 self.downscale_index_formula = (4, 16, 16)
-                if self.latent_channels in [48, 128]: # Wan 2.2 and LTX2
+                if self.latent_channels == 48: # Wan 2.2
                     self.first_stage_model = comfy.taesd.taehv.TAEHV(latent_channels=self.latent_channels, latent_format=None) # taehv doesn't need scaling
-                    self.process_input = self.process_output = lambda image: image
+                    self.process_input = lambda image: (_ for _ in ()).throw(NotImplementedError("This light tae doesn't support encoding currently"))
                     self.process_output = lambda image: image
                     self.memory_used_decode = lambda shape, dtype: (1800 * (max(1, (shape[-3] ** 0.7 * 0.1)) * shape[-2] * shape[-1] * 16 * 16) * model_management.dtype_size(dtype))
                 elif self.latent_channels == 32 and sd["decoder.22.bias"].shape[0] == 12: # lighttae_hv15
                     self.first_stage_model = comfy.taesd.taehv.TAEHV(latent_channels=self.latent_channels, latent_format=comfy.latent_formats.HunyuanVideo15)
+                    self.process_input = lambda image: (_ for _ in ()).throw(NotImplementedError("This light tae doesn't support encoding currently"))
                     self.memory_used_decode = lambda shape, dtype: (1200 * (max(1, (shape[-3] ** 0.7 * 0.05)) * shape[-2] * shape[-1] * 32 * 32) * model_management.dtype_size(dtype))
                 else:
                     if sd["decoder.1.weight"].dtype == torch.float16: # taehv currently only available in float16, so assume it's not lighttaew2_1 as otherwise state dicts are identical
@@ -1014,7 +1014,6 @@ class CLIPType(Enum):
     KANDINSKY5 = 22
     KANDINSKY5_IMAGE = 23
     NEWBIE = 24
-    FLUX2 = 25
 
 
 def load_clip(ckpt_paths, embedding_directory=None, clip_type=CLIPType.STABLE_DIFFUSION, model_options={}):
@@ -1047,8 +1046,6 @@ class TEModel(Enum):
     QWEN3_2B = 17
     GEMMA_3_12B = 18
     JINA_CLIP_2 = 19
-    QWEN3_8B = 20
-    QWEN3_06B = 21
 
 
 def detect_te_model(sd):
@@ -1062,9 +1059,9 @@ def detect_te_model(sd):
         return TEModel.JINA_CLIP_2
     if "encoder.block.23.layer.1.DenseReluDense.wi_1.weight" in sd:
         weight = sd["encoder.block.23.layer.1.DenseReluDense.wi_1.weight"]
-        if weight.shape[0] == 10240:
+        if weight.shape[-1] == 4096:
             return TEModel.T5_XXL
-        elif weight.shape[0] == 5120:
+        elif weight.shape[-1] == 2048:
             return TEModel.T5_XL
     if 'encoder.block.23.layer.1.DenseReluDense.wi.weight' in sd:
         return TEModel.T5_XXL_OLD
@@ -1092,10 +1089,6 @@ def detect_te_model(sd):
                 return TEModel.QWEN3_4B
             elif weight.shape[0] == 2048:
                 return TEModel.QWEN3_2B
-            elif weight.shape[0] == 4096:
-                return TEModel.QWEN3_8B
-            elif weight.shape[0] == 1024:
-                return TEModel.QWEN3_06B
         if weight.shape[0] == 5120:
             if "model.layers.39.post_attention_layernorm.weight" in sd:
                 return TEModel.MISTRAL3_24B
@@ -1221,24 +1214,14 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
             clip_target.tokenizer = comfy.text_encoders.flux.Flux2Tokenizer
             tokenizer_data["tekken_model"] = clip_data[0].get("tekken_model", None)
         elif te_model == TEModel.QWEN3_4B:
-            if clip_type == CLIPType.FLUX or clip_type == CLIPType.FLUX2:
-                clip_target.clip = comfy.text_encoders.flux.klein_te(**llama_detect(clip_data), model_type="qwen3_4b")
-                clip_target.tokenizer = comfy.text_encoders.flux.KleinTokenizer
-            else:
             clip_target.clip = comfy.text_encoders.z_image.te(**llama_detect(clip_data))
             clip_target.tokenizer = comfy.text_encoders.z_image.ZImageTokenizer
         elif te_model == TEModel.QWEN3_2B:
             clip_target.clip = comfy.text_encoders.ovis.te(**llama_detect(clip_data))
             clip_target.tokenizer = comfy.text_encoders.ovis.OvisTokenizer
-        elif te_model == TEModel.QWEN3_8B:
-            clip_target.clip = comfy.text_encoders.flux.klein_te(**llama_detect(clip_data), model_type="qwen3_8b")
-            clip_target.tokenizer = comfy.text_encoders.flux.KleinTokenizer8B
         elif te_model == TEModel.JINA_CLIP_2:
             clip_target.clip = comfy.text_encoders.jina_clip_2.JinaClip2TextModelWrapper
             clip_target.tokenizer = comfy.text_encoders.jina_clip_2.JinaClip2TokenizerWrapper
-        elif te_model == TEModel.QWEN3_06B:
-            clip_target.clip = comfy.text_encoders.anima.te(**llama_detect(clip_data))
-            clip_target.tokenizer = comfy.text_encoders.anima.AnimaTokenizer
         else:
             # clip_l
             if clip_type == CLIPType.SD3:

comfy/supported_models.py

@@ -23,7 +23,6 @@ import comfy.text_encoders.qwen_image
 import comfy.text_encoders.hunyuan_image
 import comfy.text_encoders.kandinsky5
 import comfy.text_encoders.z_image
-import comfy.text_encoders.anima
 
 from . import supported_models_base
 from . import latent_formats
@@ -764,31 +763,17 @@ class Flux2(Flux):
 
     def __init__(self, unet_config):
         super().__init__(unet_config)
-        self.memory_usage_factor = self.memory_usage_factor * (2.0 * 2.0) * (unet_config['hidden_size'] / 2604)
+        self.memory_usage_factor = self.memory_usage_factor * (2.0 * 2.0) * 2.36
 
     def get_model(self, state_dict, prefix="", device=None):
         out = model_base.Flux2(self, device=device)
         return out
 
     def clip_target(self, state_dict={}):
+        return None # TODO
         pref = self.text_encoder_key_prefix[0]
-        detect = comfy.text_encoders.hunyuan_video.llama_detect(state_dict, "{}qwen3_4b.transformer.".format(pref))
-        if len(detect) > 0:
-            detect["model_type"] = "qwen3_4b"
-            return supported_models_base.ClipTarget(comfy.text_encoders.flux.KleinTokenizer, comfy.text_encoders.flux.klein_te(**detect))
-
-        detect = comfy.text_encoders.hunyuan_video.llama_detect(state_dict, "{}qwen3_8b.transformer.".format(pref))
-        if len(detect) > 0:
-            detect["model_type"] = "qwen3_8b"
-            return supported_models_base.ClipTarget(comfy.text_encoders.flux.KleinTokenizer8B, comfy.text_encoders.flux.klein_te(**detect))
-
-        detect = comfy.text_encoders.hunyuan_video.llama_detect(state_dict, "{}mistral3_24b.transformer.".format(pref))
-        if len(detect) > 0:
-            if "{}mistral3_24b.transformer.model.layers.39.post_attention_layernorm.weight".format(pref) not in state_dict:
-                detect["pruned"] = True
-            return supported_models_base.ClipTarget(comfy.text_encoders.flux.Flux2Tokenizer, comfy.text_encoders.flux.flux2_te(**detect))
-
-        return None
+        t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}t5xxl.transformer.".format(pref))
+        return supported_models_base.ClipTarget(comfy.text_encoders.flux.FluxTokenizer, comfy.text_encoders.flux.flux_clip(**t5_detect))
 
 class GenmoMochi(supported_models_base.BASE):
     unet_config = {
@@ -860,7 +845,7 @@ class LTXAV(LTXV):
 
     def __init__(self, unet_config):
         super().__init__(unet_config)
-        self.memory_usage_factor = 0.077  # TODO
+        self.memory_usage_factor = 0.061  # TODO
 
     def get_model(self, state_dict, prefix="", device=None):
         out = model_base.LTXAV(self, device=device)
@@ -1007,36 +992,6 @@ class CosmosT2IPredict2(supported_models_base.BASE):
         t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}t5xxl.transformer.".format(pref))
         return supported_models_base.ClipTarget(comfy.text_encoders.cosmos.CosmosT5Tokenizer, comfy.text_encoders.cosmos.te(**t5_detect))
 
-class Anima(supported_models_base.BASE):
-    unet_config = {
-        "image_model": "anima",
-    }
-
-    sampling_settings = {
-        "multiplier": 1.0,
-        "shift": 3.0,
-    }
-
-    unet_extra_config = {}
-    latent_format = latent_formats.Wan21
-
-    memory_usage_factor = 1.0
-
-    supported_inference_dtypes = [torch.bfloat16, torch.float32]
-
-    def __init__(self, unet_config):
-        super().__init__(unet_config)
-        self.memory_usage_factor = (unet_config.get("model_channels", 2048) / 2048) * 0.95
-
-    def get_model(self, state_dict, prefix="", device=None):
-        out = model_base.Anima(self, device=device)
-        return out
-
-    def clip_target(self, state_dict={}):
-        pref = self.text_encoder_key_prefix[0]
-        detect = comfy.text_encoders.hunyuan_video.llama_detect(state_dict, "{}qwen3_06b.transformer.".format(pref))
-        return supported_models_base.ClipTarget(comfy.text_encoders.anima.AnimaTokenizer, comfy.text_encoders.anima.te(**detect))
-
 class CosmosI2VPredict2(CosmosT2IPredict2):
     unet_config = {
         "image_model": "cosmos_predict2",
@@ -1087,7 +1042,7 @@ class ZImage(Lumina2):
         "shift": 3.0,
     }
 
-    memory_usage_factor = 2.8
+    memory_usage_factor = 2.0
 
     supported_inference_dtypes = [torch.bfloat16, torch.float32]
 
@@ -1596,6 +1551,6 @@ class Kandinsky5Image(Kandinsky5):
         return supported_models_base.ClipTarget(comfy.text_encoders.kandinsky5.Kandinsky5TokenizerImage, comfy.text_encoders.kandinsky5.te(**hunyuan_detect))
 
 
-models = [LotusD, Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, LTXAV, HunyuanVideo15_SR_Distilled, HunyuanVideo15, HunyuanImage21Refiner, HunyuanImage21, HunyuanVideoSkyreelsI2V, HunyuanVideoI2V, HunyuanVideo, CosmosT2V, CosmosI2V, CosmosT2IPredict2, CosmosI2VPredict2, ZImage, Lumina2, WAN22_T2V, WAN21_T2V, WAN21_I2V, WAN21_FunControl2V, WAN21_Vace, WAN21_Camera, WAN22_Camera, WAN22_S2V, WAN21_HuMo, WAN22_Animate, Hunyuan3Dv2mini, Hunyuan3Dv2, Hunyuan3Dv2_1, HiDream, Chroma, ChromaRadiance, ACEStep, Omnigen2, QwenImage, Flux2, Kandinsky5Image, Kandinsky5, Anima]
+models = [LotusD, Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, LTXAV, HunyuanVideo15_SR_Distilled, HunyuanVideo15, HunyuanImage21Refiner, HunyuanImage21, HunyuanVideoSkyreelsI2V, HunyuanVideoI2V, HunyuanVideo, CosmosT2V, CosmosI2V, CosmosT2IPredict2, CosmosI2VPredict2, ZImage, Lumina2, WAN22_T2V, WAN21_T2V, WAN21_I2V, WAN21_FunControl2V, WAN21_Vace, WAN21_Camera, WAN22_Camera, WAN22_S2V, WAN21_HuMo, WAN22_Animate, Hunyuan3Dv2mini, Hunyuan3Dv2, Hunyuan3Dv2_1, HiDream, Chroma, ChromaRadiance, ACEStep, Omnigen2, QwenImage, Flux2, Kandinsky5Image, Kandinsky5]
 
 models += [SVD_img2vid]

comfy/taesd/taehv.py

@@ -112,8 +112,7 @@ def apply_model_with_memblocks(model, x, parallel, show_progress_bar):
 
 
 class TAEHV(nn.Module):
-    def __init__(self, latent_channels, parallel=False, encoder_time_downscale=(True, True, False), decoder_time_upscale=(False, True, True), decoder_space_upscale=(True, True, True),
-                 latent_format=None, show_progress_bar=False):
+    def __init__(self, latent_channels, parallel=False, decoder_time_upscale=(True, True), decoder_space_upscale=(True, True, True), latent_format=None, show_progress_bar=True):
         super().__init__()
         self.image_channels = 3
         self.patch_size = 1
@@ -125,9 +124,6 @@ class TAEHV(nn.Module):
         self.process_out = latent_format().process_out if latent_format is not None else (lambda x: x)
         if self.latent_channels in [48, 32]: # Wan 2.2 and HunyuanVideo1.5
             self.patch_size = 2
-        elif self.latent_channels == 128: # LTX2
-            self.patch_size, self.latent_channels, encoder_time_downscale, decoder_time_upscale = 4, 128, (True, True, True), (True, True, True)
-
         if self.latent_channels == 32: # HunyuanVideo1.5
             act_func = nn.LeakyReLU(0.2, inplace=True)
         else: # HunyuanVideo, Wan 2.1
@@ -135,26 +131,20 @@ class TAEHV(nn.Module):
 
         self.encoder = nn.Sequential(
             conv(self.image_channels*self.patch_size**2, 64), act_func,
-            TPool(64, 2 if encoder_time_downscale[0] else 1), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
-            TPool(64, 2 if encoder_time_downscale[1] else 1), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
-            TPool(64, 2 if encoder_time_downscale[2] else 1), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
+            TPool(64, 2), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
+            TPool(64, 2), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
+            TPool(64, 1), conv(64, 64, stride=2, bias=False), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func), MemBlock(64, 64, act_func),
             conv(64, self.latent_channels),
         )
         n_f = [256, 128, 64, 64]
-
+        self.frames_to_trim = 2**sum(decoder_time_upscale) - 1
         self.decoder = nn.Sequential(
             Clamp(), conv(self.latent_channels, n_f[0]), act_func,
-            MemBlock(n_f[0], n_f[0], act_func), MemBlock(n_f[0], n_f[0], act_func), MemBlock(n_f[0], n_f[0], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[0] else 1), TGrow(n_f[0], 2 if decoder_time_upscale[0] else 1), conv(n_f[0], n_f[1], bias=False),
-            MemBlock(n_f[1], n_f[1], act_func), MemBlock(n_f[1], n_f[1], act_func), MemBlock(n_f[1], n_f[1], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[1] else 1), TGrow(n_f[1], 2 if decoder_time_upscale[1] else 1), conv(n_f[1], n_f[2], bias=False),
-            MemBlock(n_f[2], n_f[2], act_func), MemBlock(n_f[2], n_f[2], act_func), MemBlock(n_f[2], n_f[2], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[2] else 1), TGrow(n_f[2], 2 if decoder_time_upscale[2] else 1), conv(n_f[2], n_f[3], bias=False),
+            MemBlock(n_f[0], n_f[0], act_func), MemBlock(n_f[0], n_f[0], act_func), MemBlock(n_f[0], n_f[0], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[0] else 1), TGrow(n_f[0], 1), conv(n_f[0], n_f[1], bias=False),
+            MemBlock(n_f[1], n_f[1], act_func), MemBlock(n_f[1], n_f[1], act_func), MemBlock(n_f[1], n_f[1], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[1] else 1), TGrow(n_f[1], 2 if decoder_time_upscale[0] else 1), conv(n_f[1], n_f[2], bias=False),
+            MemBlock(n_f[2], n_f[2], act_func), MemBlock(n_f[2], n_f[2], act_func), MemBlock(n_f[2], n_f[2], act_func), nn.Upsample(scale_factor=2 if decoder_space_upscale[2] else 1), TGrow(n_f[2], 2 if decoder_time_upscale[1] else 1), conv(n_f[2], n_f[3], bias=False),
             act_func, conv(n_f[3], self.image_channels*self.patch_size**2),
         )
-
-        self.t_downscale = 2**sum(t.stride == 2 for t in self.encoder if isinstance(t, TPool))
-        self.t_upscale = 2**sum(t.stride == 2 for t in self.decoder if isinstance(t, TGrow))
-        self.frames_to_trim = self.t_upscale - 1
-        self._show_progress_bar = show_progress_bar
-
         @property
         def show_progress_bar(self):
             return self._show_progress_bar
@@ -164,23 +154,18 @@ class TAEHV(nn.Module):
             self._show_progress_bar = value
 
     def encode(self, x, **kwargs):
-        x = x.movedim(2, 1)  # [B, C, T, H, W] -> [B, T, C, H, W]
         if self.patch_size > 1:
-            B, T, C, H, W = x.shape
-            x = x.reshape(B * T, C, H, W)
             x = F.pixel_unshuffle(x, self.patch_size)
-            x = x.reshape(B, T, C * self.patch_size ** 2, H // self.patch_size, W // self.patch_size)
-        if x.shape[1] % self.t_downscale != 0:
-            # pad at end to multiple of t_downscale
-            n_pad = self.t_downscale - x.shape[1] % self.t_downscale
+        x = x.movedim(2, 1)  # [B, C, T, H, W] -> [B, T, C, H, W]
+        if x.shape[1] % 4 != 0:
+            # pad at end to multiple of 4
+            n_pad = 4 - x.shape[1] % 4
             padding = x[:, -1:].repeat_interleave(n_pad, dim=1)
             x = torch.cat([x, padding], 1)
         x = apply_model_with_memblocks(self.encoder, x, self.parallel, self.show_progress_bar).movedim(2, 1)
         return self.process_out(x)
 
     def decode(self, x, **kwargs):
-        x = x.unsqueeze(0) if x.ndim == 4 else x  # [T, C, H, W] -> [1, T, C, H, W]
-        x = x.movedim(1, 2) if x.shape[1] != self.latent_channels else x  # [B, T, C, H, W] or [B, C, T, H, W]
         x = self.process_in(x).movedim(2, 1)  # [B, C, T, H, W] -> [B, T, C, H, W]
         x = apply_model_with_memblocks(self.decoder, x, self.parallel, self.show_progress_bar)
         if self.patch_size > 1:

comfy/text_encoders/anima.py

@@ -1,61 +0,0 @@
-from transformers import Qwen2Tokenizer, T5TokenizerFast
-import comfy.text_encoders.llama
-from comfy import sd1_clip
-import os
-import torch
-
-
-class Qwen3Tokenizer(sd1_clip.SDTokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}):
-        tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "qwen25_tokenizer")
-        super().__init__(tokenizer_path, pad_with_end=False, embedding_size=1024, embedding_key='qwen3_06b', tokenizer_class=Qwen2Tokenizer, has_start_token=False, has_end_token=False, pad_to_max_length=False, max_length=99999999, min_length=1, pad_token=151643, tokenizer_data=tokenizer_data)
-
-class T5XXLTokenizer(sd1_clip.SDTokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}):
-        tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_tokenizer")
-        super().__init__(tokenizer_path, embedding_directory=embedding_directory, pad_with_end=False, embedding_size=4096, embedding_key='t5xxl', tokenizer_class=T5TokenizerFast, has_start_token=False, pad_to_max_length=False, max_length=99999999, min_length=1, tokenizer_data=tokenizer_data)
-
-class AnimaTokenizer:
-    def __init__(self, embedding_directory=None, tokenizer_data={}):
-        self.qwen3_06b = Qwen3Tokenizer(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data)
-        self.t5xxl = T5XXLTokenizer(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data)
-
-    def tokenize_with_weights(self, text:str, return_word_ids=False, **kwargs):
-        out = {}
-        qwen_ids = self.qwen3_06b.tokenize_with_weights(text, return_word_ids, **kwargs)
-        out["qwen3_06b"] = [[(token, 1.0) for token, _ in inner_list] for inner_list in qwen_ids]  # Set weights to 1.0
-        out["t5xxl"] = self.t5xxl.tokenize_with_weights(text, return_word_ids, **kwargs)
-        return out
-
-    def untokenize(self, token_weight_pair):
-        return self.t5xxl.untokenize(token_weight_pair)
-
-    def state_dict(self):
-        return {}
-
-
-class Qwen3_06BModel(sd1_clip.SDClipModel):
-    def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, attention_mask=True, model_options={}):
-        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config={}, dtype=dtype, special_tokens={"pad": 151643}, layer_norm_hidden_state=False, model_class=comfy.text_encoders.llama.Qwen3_06B, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options)
-
-
-class AnimaTEModel(sd1_clip.SD1ClipModel):
-    def __init__(self, device="cpu", dtype=None, model_options={}):
-        super().__init__(device=device, dtype=dtype, name="qwen3_06b", clip_model=Qwen3_06BModel, model_options=model_options)
-
-    def encode_token_weights(self, token_weight_pairs):
-        out = super().encode_token_weights(token_weight_pairs)
-        out[2]["t5xxl_ids"] = torch.tensor(list(map(lambda a: a[0], token_weight_pairs["t5xxl"][0])), dtype=torch.int)
-        out[2]["t5xxl_weights"] = torch.tensor(list(map(lambda a: a[1], token_weight_pairs["t5xxl"][0])))
-        return out
-
-def te(dtype_llama=None, llama_quantization_metadata=None):
-    class AnimaTEModel_(AnimaTEModel):
-        def __init__(self, device="cpu", dtype=None, model_options={}):
-            if dtype_llama is not None:
-                dtype = dtype_llama
-            if llama_quantization_metadata is not None:
-                model_options = model_options.copy()
-                model_options["quantization_metadata"] = llama_quantization_metadata
-            super().__init__(device=device, dtype=dtype, model_options=model_options)
-    return AnimaTEModel_

comfy/text_encoders/cosmos.py

@@ -36,7 +36,7 @@ def te(dtype_t5=None, t5_quantization_metadata=None):
             if t5_quantization_metadata is not None:
                 model_options = model_options.copy()
                 model_options["t5xxl_quantization_metadata"] = t5_quantization_metadata
-            if dtype_t5 is not None:
+            if dtype is None:
                 dtype = dtype_t5
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return CosmosTEModel_

comfy/text_encoders/flux.py

@@ -3,7 +3,7 @@ import comfy.text_encoders.t5
 import comfy.text_encoders.sd3_clip
 import comfy.text_encoders.llama
 import comfy.model_management
-from transformers import T5TokenizerFast, LlamaTokenizerFast, Qwen2Tokenizer
+from transformers import T5TokenizerFast, LlamaTokenizerFast
 import torch
 import os
 import json
@@ -172,60 +172,3 @@ def flux2_te(dtype_llama=None, llama_quantization_metadata=None, pruned=False):
                 model_options["num_layers"] = 30
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return Flux2TEModel_
-
-class Qwen3Tokenizer(sd1_clip.SDTokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}):
-        tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "qwen25_tokenizer")
-        super().__init__(tokenizer_path, pad_with_end=False, embedding_size=2560, embedding_key='qwen3_4b', tokenizer_class=Qwen2Tokenizer, has_start_token=False, has_end_token=False, pad_to_max_length=False, max_length=99999999, min_length=512, pad_token=151643, tokenizer_data=tokenizer_data)
-
-class Qwen3Tokenizer8B(sd1_clip.SDTokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}):
-        tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "qwen25_tokenizer")
-        super().__init__(tokenizer_path, pad_with_end=False, embedding_size=4096, embedding_key='qwen3_8b', tokenizer_class=Qwen2Tokenizer, has_start_token=False, has_end_token=False, pad_to_max_length=False, max_length=99999999, min_length=512, pad_token=151643, tokenizer_data=tokenizer_data)
-
-class KleinTokenizer(sd1_clip.SD1Tokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}, name="qwen3_4b"):
-        if name == "qwen3_4b":
-            tokenizer = Qwen3Tokenizer
-        elif name == "qwen3_8b":
-            tokenizer = Qwen3Tokenizer8B
-
-        super().__init__(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data, name=name, tokenizer=tokenizer)
-        self.llama_template = "<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
-
-    def tokenize_with_weights(self, text, return_word_ids=False, llama_template=None, **kwargs):
-        if llama_template is None:
-            llama_text = self.llama_template.format(text)
-        else:
-            llama_text = llama_template.format(text)
-
-        tokens = super().tokenize_with_weights(llama_text, return_word_ids=return_word_ids, disable_weights=True, **kwargs)
-        return tokens
-
-class KleinTokenizer8B(KleinTokenizer):
-    def __init__(self, embedding_directory=None, tokenizer_data={}, name="qwen3_8b"):
-        super().__init__(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data, name=name)
-
-class Qwen3_4BModel(sd1_clip.SDClipModel):
-    def __init__(self, device="cpu", layer=[9, 18, 27], layer_idx=None, dtype=None, attention_mask=True, model_options={}):
-        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config={}, dtype=dtype, special_tokens={"pad": 151643}, layer_norm_hidden_state=False, model_class=comfy.text_encoders.llama.Qwen3_4B, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options)
-
-class Qwen3_8BModel(sd1_clip.SDClipModel):
-    def __init__(self, device="cpu", layer=[9, 18, 27], layer_idx=None, dtype=None, attention_mask=True, model_options={}):
-        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config={}, dtype=dtype, special_tokens={"pad": 151643}, layer_norm_hidden_state=False, model_class=comfy.text_encoders.llama.Qwen3_8B, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options)
-
-def klein_te(dtype_llama=None, llama_quantization_metadata=None, model_type="qwen3_4b"):
-    if model_type == "qwen3_4b":
-        model = Qwen3_4BModel
-    elif model_type == "qwen3_8b":
-        model = Qwen3_8BModel
-
-    class Flux2TEModel_(Flux2TEModel):
-        def __init__(self, device="cpu", dtype=None, model_options={}):
-            if llama_quantization_metadata is not None:
-                model_options = model_options.copy()
-                model_options["quantization_metadata"] = llama_quantization_metadata
-            if dtype_llama is not None:
-                dtype = dtype_llama
-            super().__init__(device=device, dtype=dtype, name=model_type, model_options=model_options, clip_model=model)
-    return Flux2TEModel_

comfy/text_encoders/genmo.py

@@ -32,7 +32,7 @@ def mochi_te(dtype_t5=None, t5_quantization_metadata=None):
             if t5_quantization_metadata is not None:
                 model_options = model_options.copy()
                 model_options["t5xxl_quantization_metadata"] = t5_quantization_metadata
-            if dtype_t5 is not None:
+            if dtype is None:
                 dtype = dtype_t5
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return MochiTEModel_

comfy/text_encoders/hunyuan_video.py

@@ -10,11 +10,9 @@ import comfy.utils
 
 def llama_detect(state_dict, prefix=""):
     out = {}
-    norm_keys = ["{}model.norm.weight".format(prefix), "{}model.layers.0.input_layernorm.weight".format(prefix)]
-    for norm_key in norm_keys:
-        if norm_key in state_dict:
-            out["dtype_llama"] = state_dict[norm_key].dtype
-            break
+    t5_key = "{}model.norm.weight".format(prefix)
+    if t5_key in state_dict:
+        out["dtype_llama"] = state_dict[t5_key].dtype
 
     quant = comfy.utils.detect_layer_quantization(state_dict, prefix)
     if quant is not None:

comfy/text_encoders/llama.py

@@ -77,28 +77,6 @@ class Qwen25_3BConfig:
     rope_scale = None
     final_norm: bool = True
 
-@dataclass
-class Qwen3_06BConfig:
-    vocab_size: int = 151936
-    hidden_size: int = 1024
-    intermediate_size: int = 3072
-    num_hidden_layers: int = 28
-    num_attention_heads: int = 16
-    num_key_value_heads: int = 8
-    max_position_embeddings: int = 32768
-    rms_norm_eps: float = 1e-6
-    rope_theta: float = 1000000.0
-    transformer_type: str = "llama"
-    head_dim = 128
-    rms_norm_add = False
-    mlp_activation = "silu"
-    qkv_bias = False
-    rope_dims = None
-    q_norm = "gemma3"
-    k_norm = "gemma3"
-    rope_scale = None
-    final_norm: bool = True
-
 @dataclass
 class Qwen3_4BConfig:
     vocab_size: int = 151936
@@ -121,28 +99,6 @@ class Qwen3_4BConfig:
     rope_scale = None
     final_norm: bool = True
 
-@dataclass
-class Qwen3_8BConfig:
-    vocab_size: int = 151936
-    hidden_size: int = 4096
-    intermediate_size: int = 12288
-    num_hidden_layers: int = 36
-    num_attention_heads: int = 32
-    num_key_value_heads: int = 8
-    max_position_embeddings: int = 40960
-    rms_norm_eps: float = 1e-6
-    rope_theta: float = 1000000.0
-    transformer_type: str = "llama"
-    head_dim = 128
-    rms_norm_add = False
-    mlp_activation = "silu"
-    qkv_bias = False
-    rope_dims = None
-    q_norm = "gemma3"
-    k_norm = "gemma3"
-    rope_scale = None
-    final_norm: bool = True
-
 @dataclass
 class Ovis25_2BConfig:
     vocab_size: int = 151936
@@ -663,15 +619,6 @@ class Qwen25_3B(BaseLlama, torch.nn.Module):
         self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
         self.dtype = dtype
 
-class Qwen3_06B(BaseLlama, torch.nn.Module):
-    def __init__(self, config_dict, dtype, device, operations):
-        super().__init__()
-        config = Qwen3_06BConfig(**config_dict)
-        self.num_layers = config.num_hidden_layers
-
-        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
-        self.dtype = dtype
-
 class Qwen3_4B(BaseLlama, torch.nn.Module):
     def __init__(self, config_dict, dtype, device, operations):
         super().__init__()
@@ -681,15 +628,6 @@ class Qwen3_4B(BaseLlama, torch.nn.Module):
         self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
         self.dtype = dtype
 
-class Qwen3_8B(BaseLlama, torch.nn.Module):
-    def __init__(self, config_dict, dtype, device, operations):
-        super().__init__()
-        config = Qwen3_8BConfig(**config_dict)
-        self.num_layers = config.num_hidden_layers
-
-        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
-        self.dtype = dtype
-
 class Ovis25_2B(BaseLlama, torch.nn.Module):
     def __init__(self, config_dict, dtype, device, operations):
         super().__init__()

comfy/text_encoders/lt.py

@@ -119,17 +119,7 @@ class LTXAVTEModel(torch.nn.Module):
             if len(sdo) == 0:
                 sdo = sd
 
-            missing_all = []
-            unexpected_all = []
-
-            for prefix, component in [("text_embedding_projection.", self.text_embedding_projection), ("video_embeddings_connector.", self.video_embeddings_connector), ("audio_embeddings_connector.", self.audio_embeddings_connector)]:
-                component_sd = {k.replace(prefix, ""): v for k, v in sdo.items() if k.startswith(prefix)}
-                if component_sd:
-                    missing, unexpected = component.load_state_dict(component_sd, strict=False)
-                    missing_all.extend([f"{prefix}{k}" for k in missing])
-                    unexpected_all.extend([f"{prefix}{k}" for k in unexpected])
-
-            return (missing_all, unexpected_all)
+            return self.load_state_dict(sdo, strict=False)
 
     def memory_estimation_function(self, token_weight_pairs, device=None):
         constant = 6.0

comfy/text_encoders/ovis.py

@@ -61,7 +61,6 @@ def te(dtype_llama=None, llama_quantization_metadata=None):
             if dtype_llama is not None:
                 dtype = dtype_llama
             if llama_quantization_metadata is not None:
-                model_options = model_options.copy()
                 model_options["quantization_metadata"] = llama_quantization_metadata
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return OvisTEModel_

comfy/text_encoders/pixart_t5.py

@@ -36,7 +36,7 @@ def pixart_te(dtype_t5=None, t5_quantization_metadata=None):
             if t5_quantization_metadata is not None:
                 model_options = model_options.copy()
                 model_options["t5xxl_quantization_metadata"] = t5_quantization_metadata
-            if dtype_t5 is not None:
+            if dtype is None:
                 dtype = dtype_t5
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return PixArtTEModel_

comfy/text_encoders/z_image.py

@@ -40,7 +40,6 @@ def te(dtype_llama=None, llama_quantization_metadata=None):
             if dtype_llama is not None:
                 dtype = dtype_llama
             if llama_quantization_metadata is not None:
-                model_options = model_options.copy()
                 model_options["quantization_metadata"] = llama_quantization_metadata
             super().__init__(device=device, dtype=dtype, model_options=model_options)
     return ZImageTEModel_

comfy/utils.py

@@ -30,7 +30,6 @@ from torch.nn.functional import interpolate
 from einops import rearrange
 from comfy.cli_args import args
 import json
-import time
 
 MMAP_TORCH_FILES = args.mmap_torch_files
 DISABLE_MMAP = args.disable_mmap
@@ -611,14 +610,6 @@ def flux_to_diffusers(mmdit_config, output_prefix=""):
                         "ff_context.net.0.proj.bias": "txt_mlp.0.bias",
                         "ff_context.net.2.weight": "txt_mlp.2.weight",
                         "ff_context.net.2.bias": "txt_mlp.2.bias",
-                        "ff.linear_in.weight": "img_mlp.0.weight",  # LyCoris LoKr
-                        "ff.linear_in.bias": "img_mlp.0.bias",
-                        "ff.linear_out.weight": "img_mlp.2.weight",
-                        "ff.linear_out.bias": "img_mlp.2.bias",
-                        "ff_context.linear_in.weight": "txt_mlp.0.weight",
-                        "ff_context.linear_in.bias": "txt_mlp.0.bias",
-                        "ff_context.linear_out.weight": "txt_mlp.2.weight",
-                        "ff_context.linear_out.bias": "txt_mlp.2.bias",
                         "attn.norm_q.weight": "img_attn.norm.query_norm.scale",
                         "attn.norm_k.weight": "img_attn.norm.key_norm.scale",
                         "attn.norm_added_q.weight": "txt_attn.norm.query_norm.scale",
@@ -647,8 +638,6 @@ def flux_to_diffusers(mmdit_config, output_prefix=""):
                         "proj_out.bias": "linear2.bias",
                         "attn.norm_q.weight": "norm.query_norm.scale",
                         "attn.norm_k.weight": "norm.key_norm.scale",
-                        "attn.to_qkv_mlp_proj.weight": "linear1.weight", # Flux 2
-                        "attn.to_out.weight": "linear2.weight", # Flux 2
                     }
 
         for k in block_map:
@@ -939,9 +928,7 @@ def bislerp(samples, width, height):
     return result.to(orig_dtype)
 
 def lanczos(samples, width, height):
-    #the below API is strict and expects grayscale to be squeezed
-    samples = samples.squeeze(1) if samples.shape[1] == 1 else samples.movedim(1, -1)
-    images = [Image.fromarray(np.clip(255. * image.cpu().numpy(), 0, 255).astype(np.uint8)) for image in samples]
+    images = [Image.fromarray(np.clip(255. * image.movedim(0, -1).cpu().numpy(), 0, 255).astype(np.uint8)) for image in samples]
     images = [image.resize((width, height), resample=Image.Resampling.LANCZOS) for image in images]
     images = [torch.from_numpy(np.array(image).astype(np.float32) / 255.0).movedim(-1, 0) for image in images]
     result = torch.stack(images)
@@ -1110,10 +1097,6 @@ def set_progress_bar_global_hook(function):
     global PROGRESS_BAR_HOOK
     PROGRESS_BAR_HOOK = function
 
-# Throttle settings for progress bar updates to reduce WebSocket flooding
-PROGRESS_THROTTLE_MIN_INTERVAL = 0.1  # 100ms minimum between updates
-PROGRESS_THROTTLE_MIN_PERCENT = 0.5   # 0.5% minimum progress change
-
 class ProgressBar:
     def __init__(self, total, node_id=None):
         global PROGRESS_BAR_HOOK
@@ -1121,8 +1104,6 @@ class ProgressBar:
         self.current = 0
         self.hook = PROGRESS_BAR_HOOK
         self.node_id = node_id
-        self._last_update_time = 0.0
-        self._last_sent_value = -1
 
     def update_absolute(self, value, total=None, preview=None):
         if total is not None:
@@ -1131,29 +1112,7 @@ class ProgressBar:
             value = self.total
         self.current = value
         if self.hook is not None:
-            current_time = time.perf_counter()
-            is_first = (self._last_sent_value < 0)
-            is_final = (value >= self.total)
-            has_preview = (preview is not None)
-
-            # Always send immediately for previews, first update, or final update
-            if has_preview or is_first or is_final:
             self.hook(self.current, self.total, preview, node_id=self.node_id)
-                self._last_update_time = current_time
-                self._last_sent_value = value
-                return
-
-            # Apply throttling for regular progress updates
-            if self.total > 0:
-                percent_changed = ((value - max(0, self._last_sent_value)) / self.total) * 100
-            else:
-                percent_changed = 100
-            time_elapsed = current_time - self._last_update_time
-
-            if time_elapsed >= PROGRESS_THROTTLE_MIN_INTERVAL and percent_changed >= PROGRESS_THROTTLE_MIN_PERCENT:
-                self.hook(self.current, self.total, preview, node_id=self.node_id)
-                self._last_update_time = current_time
-                self._last_sent_value = value
 
     def update(self, value):
         self.update_absolute(self.current + value)

comfy_api/latest/_input_impl/video_types.py

@@ -374,7 +374,7 @@ class VideoFromComponents(VideoInput):
             if audio_stream and self.__components.audio:
                 waveform = self.__components.audio['waveform']
                 waveform = waveform[:, :, :math.ceil((audio_sample_rate / frame_rate) * self.__components.images.shape[0])]
-                frame = av.AudioFrame.from_ndarray(waveform.movedim(2, 1).reshape(1, -1).float().cpu().numpy(), format='flt', layout='mono' if waveform.shape[1] == 1 else 'stereo')
+                frame = av.AudioFrame.from_ndarray(waveform.movedim(2, 1).reshape(1, -1).float().numpy(), format='flt', layout='mono' if waveform.shape[1] == 1 else 'stereo')
                 frame.sample_rate = audio_sample_rate
                 frame.pts = 0
                 output.mux(audio_stream.encode(frame))

comfy_api/latest/_io.py

@@ -153,7 +153,7 @@ class Input(_IO_V3):
     '''
     Base class for a V3 Input.
     '''
-    def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
+    def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None):
         super().__init__()
         self.id = id
         self.display_name = display_name
@@ -162,7 +162,6 @@ class Input(_IO_V3):
         self.lazy = lazy
         self.extra_dict = extra_dict if extra_dict is not None else {}
         self.rawLink = raw_link
-        self.advanced = advanced
 
     def as_dict(self):
         return prune_dict({
@@ -171,7 +170,6 @@ class Input(_IO_V3):
             "tooltip": self.tooltip,
             "lazy": self.lazy,
             "rawLink": self.rawLink,
-            "advanced": self.advanced,
         }) | prune_dict(self.extra_dict)
 
     def get_io_type(self):
@@ -186,8 +184,8 @@ class WidgetInput(Input):
     '''
     def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                  default: Any=None,
-                 socketless: bool=None, widget_type: str=None, force_input: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-        super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link, advanced)
+                 socketless: bool=None, widget_type: str=None, force_input: bool=None, extra_dict=None, raw_link: bool=None):
+        super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link)
         self.default = default
         self.socketless = socketless
         self.widget_type = widget_type
@@ -244,8 +242,8 @@ class Boolean(ComfyTypeIO):
         '''Boolean input.'''
         def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                     default: bool=None, label_on: str=None, label_off: str=None,
-                    socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link, advanced)
+                    socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link)
             self.label_on = label_on
             self.label_off = label_off
             self.default: bool
@@ -264,8 +262,8 @@ class Int(ComfyTypeIO):
         '''Integer input.'''
         def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                     default: int=None, min: int=None, max: int=None, step: int=None, control_after_generate: bool=None,
-                    display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link, advanced)
+                    display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link)
             self.min = min
             self.max = max
             self.step = step
@@ -290,8 +288,8 @@ class Float(ComfyTypeIO):
         '''Float input.'''
         def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                     default: float=None, min: float=None, max: float=None, step: float=None, round: float=None,
-                    display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link, advanced)
+                    display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link)
             self.min = min
             self.max = max
             self.step = step
@@ -316,8 +314,8 @@ class String(ComfyTypeIO):
         '''String input.'''
         def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                     multiline=False, placeholder: str=None, default: str=None, dynamic_prompts: bool=None,
-                    socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link, advanced)
+                    socketless: bool=None, force_input: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input, extra_dict, raw_link)
             self.multiline = multiline
             self.placeholder = placeholder
             self.dynamic_prompts = dynamic_prompts
@@ -352,13 +350,12 @@ class Combo(ComfyTypeIO):
             socketless: bool=None,
             extra_dict=None,
             raw_link: bool=None,
-            advanced: bool=None,
         ):
             if isinstance(options, type) and issubclass(options, Enum):
                 options = [v.value for v in options]
             if isinstance(default, Enum):
                 default = default.value
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, None, extra_dict, raw_link, advanced)
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, None, extra_dict, raw_link)
             self.multiselect = False
             self.options = options
             self.control_after_generate = control_after_generate
@@ -390,8 +387,8 @@ class MultiCombo(ComfyTypeI):
     class Input(Combo.Input):
         def __init__(self, id: str, options: list[str], display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
                     default: list[str]=None, placeholder: str=None, chip: bool=None, control_after_generate: bool=None,
-                    socketless: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, options, display_name, optional, tooltip, lazy, default, control_after_generate, socketless=socketless, extra_dict=extra_dict, raw_link=raw_link, advanced=advanced)
+                    socketless: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, options, display_name, optional, tooltip, lazy, default, control_after_generate, socketless=socketless, extra_dict=extra_dict, raw_link=raw_link)
             self.multiselect = True
             self.placeholder = placeholder
             self.chip = chip
@@ -424,9 +421,9 @@ class Webcam(ComfyTypeIO):
         Type = str
         def __init__(
                 self, id: str, display_name: str=None, optional=False,
-                tooltip: str=None, lazy: bool=None, default: str=None, socketless: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None
+                tooltip: str=None, lazy: bool=None, default: str=None, socketless: bool=None, extra_dict=None, raw_link: bool=None
         ):
-            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, None, extra_dict, raw_link, advanced)
+            super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, None, extra_dict, raw_link)
 
 
 @comfytype(io_type="MASK")
@@ -754,7 +751,7 @@ class AnyType(ComfyTypeIO):
     Type = Any
 
 @comfytype(io_type="MODEL_PATCH")
-class ModelPatch(ComfyTypeIO):
+class MODEL_PATCH(ComfyTypeIO):
     Type = Any
 
 @comfytype(io_type="AUDIO_ENCODER")
@@ -779,7 +776,7 @@ class MultiType:
         '''
         Input that permits more than one input type; if `id` is an instance of `ComfyType.Input`, then that input will be used to create a widget (if applicable) with overridden values.
         '''
-        def __init__(self, id: str | Input, types: list[type[_ComfyType] | _ComfyType], display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
+        def __init__(self, id: str | Input, types: list[type[_ComfyType] | _ComfyType], display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None):
             # if id is an Input, then use that Input with overridden values
             self.input_override = None
             if isinstance(id, Input):
@@ -792,7 +789,7 @@ class MultiType:
                 # if is a widget input, make sure widget_type is set appropriately
                 if isinstance(self.input_override, WidgetInput):
                     self.input_override.widget_type = self.input_override.get_io_type()
-            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link, advanced)
+            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link)
             self._io_types = types
 
         @property
@@ -846,8 +843,8 @@ class MatchType(ComfyTypeIO):
 
     class Input(Input):
         def __init__(self, id: str, template: MatchType.Template,
-                    display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None, advanced: bool=None):
-            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link, advanced)
+                    display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None, raw_link: bool=None):
+            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict, raw_link)
             self.template = template
 
         def as_dict(self):
@@ -1000,38 +997,20 @@ class Autogrow(ComfyTypeI):
             names = [f"{prefix}{i}" for i in range(max)]
         # need to create a new input based on the contents of input
         template_input = None
-        template_required = True
-        for _input_type, dict_input in input.items():
-            # for now, get just the first value from dict_input; if not required, min can be ignored
-            if len(dict_input) == 0:
-                continue
+        for _, dict_input in input.items():
+            # for now, get just the first value from dict_input
             template_input = list(dict_input.values())[0]
-            template_required = _input_type == "required"
-            break
-        if template_input is None:
-            raise Exception("template_input could not be determined from required or optional; this should never happen.")
         new_dict = {}
-        new_dict_added_to = False
-        # first, add possible inputs into out_dict
         for i, name in enumerate(names):
             expected_id = finalize_prefix(curr_prefix, name)
+            if expected_id in live_inputs:
                 # required
-            if i < min and template_required:
-                out_dict["required"][expected_id] = template_input
+                if i < min:
                     type_dict = new_dict.setdefault("required", {})
                 # optional
                 else:
-                out_dict["optional"][expected_id] = template_input
                     type_dict = new_dict.setdefault("optional", {})
-            if expected_id in live_inputs:
-                # NOTE: prefix gets added in parse_class_inputs
                 type_dict[name] = template_input
-                new_dict_added_to = True
-        # account for the edge case that all inputs are optional and no values are received
-        if not new_dict_added_to:
-            finalized_prefix = finalize_prefix(curr_prefix)
-            out_dict["dynamic_paths"][finalized_prefix] = finalized_prefix
-            out_dict["dynamic_paths_default_value"][finalized_prefix] = DynamicPathsDefaultValue.EMPTY_DICT
         parse_class_inputs(out_dict, live_inputs, new_dict, curr_prefix)
 
 @comfytype(io_type="COMFY_DYNAMICCOMBO_V3")
@@ -1134,18 +1113,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="IMAGECOMPARE")
-class ImageCompare(ComfyTypeI):
-  Type = dict
-
-  class Input(WidgetInput):
-      def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None,
-                   socketless: bool=True, advanced: bool=None):
-          super().__init__(id, display_name, optional, tooltip, None, None, socketless, None, None, None, None, advanced)
-
-      def as_dict(self):
-          return super().as_dict()
-
 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]):
     DYNAMIC_INPUT_LOOKUP[io_type] = func
@@ -1169,8 +1136,6 @@ class V3Data(TypedDict):
     'Dictionary where the keys are the hidden input ids and the values are the values of the hidden inputs.'
     dynamic_paths: dict[str, Any]
     '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.'
     create_dynamic_tuple: bool
     'When True, the value of the dynamic input will be in the format (value, path_key).'
 
@@ -1248,8 +1213,6 @@ class NodeInfoV1:
     deprecated: bool=None
     experimental: bool=None
     api_node: bool=None
-    price_badge: dict | None = None
-    search_aliases: list[str]=None
 
 @dataclass
 class NodeInfoV3:
@@ -1259,77 +1222,11 @@ class NodeInfoV3:
     name: str=None
     display_name: str=None
     description: str=None
-    python_module: Any = None
     category: str=None
     output_node: bool=None
     deprecated: bool=None
     experimental: bool=None
     api_node: bool=None
-    price_badge: dict | None = None
-
-
-@dataclass
-class PriceBadgeDepends:
-    widgets: list[str] = field(default_factory=list)
-    inputs: list[str] = field(default_factory=list)
-    input_groups: list[str] = field(default_factory=list)
-
-    def validate(self) -> None:
-        if not isinstance(self.widgets, list) or any(not isinstance(x, str) for x in self.widgets):
-            raise ValueError("PriceBadgeDepends.widgets must be a list[str].")
-        if not isinstance(self.inputs, list) or any(not isinstance(x, str) for x in self.inputs):
-            raise ValueError("PriceBadgeDepends.inputs must be a list[str].")
-        if not isinstance(self.input_groups, list) or any(not isinstance(x, str) for x in self.input_groups):
-            raise ValueError("PriceBadgeDepends.input_groups must be a list[str].")
-
-    def as_dict(self, schema_inputs: list["Input"]) -> dict[str, Any]:
-        # Build lookup: widget_id -> io_type
-        input_types: dict[str, str] = {}
-        for inp in schema_inputs:
-            all_inputs = inp.get_all()
-            input_types[inp.id] = inp.get_io_type()  # First input is always the parent itself
-            for nested_inp in all_inputs[1:]:
-                # For DynamicCombo/DynamicSlot, nested inputs are prefixed with parent ID
-                # to match frontend naming convention (e.g., "should_texture.enable_pbr")
-                prefixed_id = f"{inp.id}.{nested_inp.id}"
-                input_types[prefixed_id] = nested_inp.get_io_type()
-
-        # Enrich widgets with type information, raising error for unknown widgets
-        widgets_data: list[dict[str, str]] = []
-        for w in self.widgets:
-            if w not in input_types:
-                raise ValueError(
-                    f"PriceBadge depends_on.widgets references unknown widget '{w}'. "
-                    f"Available widgets: {list(input_types.keys())}"
-                )
-            widgets_data.append({"name": w, "type": input_types[w]})
-
-        return {
-            "widgets": widgets_data,
-            "inputs": self.inputs,
-            "input_groups": self.input_groups,
-        }
-
-
-@dataclass
-class PriceBadge:
-    expr: str
-    depends_on: PriceBadgeDepends = field(default_factory=PriceBadgeDepends)
-    engine: str = field(default="jsonata")
-
-    def validate(self) -> None:
-        if self.engine != "jsonata":
-            raise ValueError(f"Unsupported PriceBadge.engine '{self.engine}'. Only 'jsonata' is supported.")
-        if not isinstance(self.expr, str) or not self.expr.strip():
-            raise ValueError("PriceBadge.expr must be a non-empty string.")
-        self.depends_on.validate()
-
-    def as_dict(self, schema_inputs: list["Input"]) -> dict[str, Any]:
-        return {
-            "engine": self.engine,
-            "depends_on": self.depends_on.as_dict(schema_inputs),
-            "expr": self.expr,
-        }
 
 
 @dataclass
@@ -1347,8 +1244,6 @@ class Schema:
     hidden: list[Hidden] = field(default_factory=list)
     description: str=""
     """Node description, shown as a tooltip when hovering over the node."""
-    search_aliases: list[str] = field(default_factory=list)
-    """Alternative names for search. Useful for synonyms, abbreviations, or old names after renaming."""
     is_input_list: bool = False
     """A flag indicating if this node implements the additional code necessary to deal with OUTPUT_IS_LIST nodes.
 
@@ -1377,8 +1272,6 @@ class Schema:
     """Flags a node as experimental, informing users that it may change or not work as expected."""
     is_api_node: bool=False
     """Flags a node as an API node. See: https://docs.comfy.org/tutorials/api-nodes/overview."""
-    price_badge: PriceBadge | None = None
-    """Optional client-evaluated pricing badge declaration for this node."""
     not_idempotent: bool=False
     """Flags a node as not idempotent; when True, the node will run and not reuse the cached outputs when identical inputs are provided on a different node in the graph."""
     enable_expand: bool=False
@@ -1409,8 +1302,6 @@ class Schema:
             input.validate()
         for output in self.outputs:
             output.validate()
-        if self.price_badge is not None:
-            self.price_badge.validate()
 
     def finalize(self):
         """Add hidden based on selected schema options, and give outputs without ids default ids."""
@@ -1484,9 +1375,7 @@ class Schema:
             deprecated=self.is_deprecated,
             experimental=self.is_experimental,
             api_node=self.is_api_node,
-            python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes"),
-            price_badge=self.price_badge.as_dict(self.inputs) if self.price_badge is not None else None,
-            search_aliases=self.search_aliases if self.search_aliases else None,
+            python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes")
         )
         return info
 
@@ -1518,8 +1407,7 @@ class Schema:
             deprecated=self.is_deprecated,
             experimental=self.is_experimental,
             api_node=self.is_api_node,
-            python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes"),
-            price_badge=self.price_badge.as_dict(self.inputs) if self.price_badge is not None else None,
+            python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes")
         )
         return info
 
@@ -1528,7 +1416,6 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
         "required": {},
         "optional": {},
         "dynamic_paths": {},
-        "dynamic_paths_default_value": {},
     }
     d = d.copy()
     # ignore hidden for parsing
@@ -1538,12 +1425,8 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
         out_dict["hidden"] = hidden
     v3_data = {}
     dynamic_paths = out_dict.pop("dynamic_paths", None)
-    if dynamic_paths is not None and len(dynamic_paths) > 0:
+    if dynamic_paths is not None:
         v3_data["dynamic_paths"] = dynamic_paths
-    # this list is used for autogrow, in the case all inputs are optional and no values are passed
-    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
     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:
@@ -1580,16 +1463,11 @@ def add_to_dict_v1(i: Input, d: dict):
 def add_to_dict_v3(io: Input | Output, d: dict):
     d[io.id] = (io.get_io_type(), io.as_dict())
 
-class DynamicPathsDefaultValue:
-    EMPTY_DICT = "empty_dict"
-
 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", {})
     if paths is None:
         return values
     values = values.copy()
-
     result = {}
 
     create_tuple = v3_data.get("create_dynamic_tuple", False)
@@ -1603,11 +1481,6 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
 
             if is_last:
                 value = values.pop(key, None)
-                if value is None:
-                    # see if a default value was provided for this key
-                    default_option = default_value_dict.get(key, None)
-                    if default_option == DynamicPathsDefaultValue.EMPTY_DICT:
-                        value = {}
                 if create_tuple:
                     value = (value, key)
                 current[p] = value
@@ -2038,7 +1911,6 @@ __all__ = [
     "ControlNet",
     "Vae",
     "Model",
-    "ModelPatch",
     "ClipVision",
     "ClipVisionOutput",
     "AudioEncoder",
@@ -2086,7 +1958,4 @@ __all__ = [
     "add_to_dict_v1",
     "add_to_dict_v3",
     "V3Data",
-    "ImageCompare",
-    "PriceBadgeDepends",
-    "PriceBadge",
 ]

comfy_api_nodes/README.md

@@ -0,0 +1,65 @@
+# ComfyUI API Nodes
+
+## Introduction 
+
+Below are a collection of nodes that work by calling external APIs. More information available in our [docs](https://docs.comfy.org/tutorials/api-nodes/overview).
+
+## Development
+
+While developing, you should be testing against the Staging environment. To test against staging:
+
+**Install ComfyUI_frontend**
+
+Follow the instructions [here](https://github.com/Comfy-Org/ComfyUI_frontend) to start the frontend server. By default, it will connect to Staging authentication. 
+
+> **Hint:** If you use --front-end-version argument for ComfyUI, it will use production authentication.
+
+```bash
+python run main.py --comfy-api-base https://stagingapi.comfy.org
+```
+
+To authenticate to staging, please login and then ask one of Comfy Org team to whitelist you for access to staging.
+
+API stubs are generated through automatic codegen tools from OpenAPI definitions. Since the Comfy Org OpenAPI definition contains many things from the Comfy Registry as well, we use redocly/cli to filter out only the paths relevant for API nodes.
+
+### Redocly Instructions 
+
+**Tip**
+When developing locally, use the `redocly-dev.yaml` file to generate pydantic models. This lets you use stubs for APIs that are not marked `Released` yet.
+
+Before your API node PR merges, make sure to add the `Released` tag to the `openapi.yaml` file and test in staging.
+
+```bash
+# Download the OpenAPI file from staging server.
+curl -o openapi.yaml https://stagingapi.comfy.org/openapi
+
+# Filter out unneeded API definitions.
+npm install -g @redocly/cli
+redocly bundle openapi.yaml --output filtered-openapi.yaml --config comfy_api_nodes/redocly-dev.yaml --remove-unused-components
+
+# Generate the pydantic datamodels for validation.
+datamodel-codegen --use-subclass-enum --field-constraints --strict-types bytes --input filtered-openapi.yaml --output comfy_api_nodes/apis/__init__.py --output-model-type pydantic_v2.BaseModel
+
+```
+
+
+# Merging to Master
+
+Before merging to comfyanonymous/ComfyUI master, follow these steps:
+
+1. Add the "Released" tag to the ComfyUI OpenAPI yaml file for each endpoint you are using in the nodes. 
+1. Make sure the ComfyUI API is deployed to prod with your changes.
+1. Run the code generation again with `redocly.yaml` and the production OpenAPI yaml file.
+
+```bash
+# Download the OpenAPI file from prod server.
+curl -o openapi.yaml https://api.comfy.org/openapi
+
+# Filter out unneeded API definitions.
+npm install -g @redocly/cli
+redocly bundle openapi.yaml --output filtered-openapi.yaml --config comfy_api_nodes/redocly.yaml --remove-unused-components
+
+# Generate the pydantic datamodels for validation.
+datamodel-codegen --use-subclass-enum --field-constraints --strict-types bytes --input filtered-openapi.yaml --output comfy_api_nodes/apis/__init__.py --output-model-type pydantic_v2.BaseModel
+
+```

comfy_api_nodes/apis/bria.py

@@ -1,61 +0,0 @@
-from typing import TypedDict
-
-from pydantic import BaseModel, Field
-
-
-class InputModerationSettings(TypedDict):
-    prompt_content_moderation: bool
-    visual_input_moderation: bool
-    visual_output_moderation: bool
-
-
-class BriaEditImageRequest(BaseModel):
-    instruction: str | None = Field(...)
-    structured_instruction: str | None = Field(
-        ...,
-        description="Use this instead of instruction for precise, programmatic control.",
-    )
-    images: list[str] = Field(
-        ...,
-        description="Required. Publicly available URL or Base64-encoded. Must contain exactly one item.",
-    )
-    mask: str | None = Field(
-        None,
-        description="Mask image (black and white). Black areas will be preserved, white areas will be edited. "
-        "If omitted, the edit applies to the entire image. "
-        "The input image and the the input mask must be of the same size.",
-    )
-    negative_prompt: str | None = Field(None)
-    guidance_scale: float = Field(...)
-    model_version: str = Field(...)
-    steps_num: int = Field(...)
-    seed: int = Field(...)
-    ip_signal: bool = Field(
-        False,
-        description="If true, returns a warning for potential IP content in the instruction.",
-    )
-    prompt_content_moderation: bool = Field(
-        False, description="If true, returns 422 on instruction moderation failure."
-    )
-    visual_input_content_moderation: bool = Field(
-        False, description="If true, returns 422 on images or mask moderation failure."
-    )
-    visual_output_content_moderation: bool = Field(
-        False, description="If true, returns 422 on visual output moderation failure."
-    )
-
-
-class BriaStatusResponse(BaseModel):
-    request_id: str = Field(...)
-    status_url: str = Field(...)
-    warning: str | None = Field(None)
-
-
-class BriaResult(BaseModel):
-    structured_prompt: str = Field(...)
-    image_url: str = Field(...)
-
-
-class BriaResponse(BaseModel):
-    status: str = Field(...)
-    result: BriaResult | None = Field(None)

comfy_api_nodes/apis/bytedance_api.py

@@ -65,13 +65,11 @@ class TaskImageContent(BaseModel):
 class Text2VideoTaskCreationRequest(BaseModel):
     model: str = Field(...)
     content: list[TaskTextContent] = Field(..., min_length=1)
-    generate_audio: bool | None = Field(...)
 
 
 class Image2VideoTaskCreationRequest(BaseModel):
     model: str = Field(...)
     content: list[TaskTextContent | TaskImageContent] = Field(..., min_length=2)
-    generate_audio: bool | None = Field(...)
 
 
 class TaskCreationResponse(BaseModel):
@@ -143,9 +141,4 @@ VIDEO_TASKS_EXECUTION_TIME = {
         "720p": 65,
         "1080p": 100,
     },
-    "seedance-1-5-pro-251215": {
-        "480p": 80,
-        "720p": 100,
-        "1080p": 150,
-    },
 }

comfy_api_nodes/apis/ideogram.py

@@ -1,292 +0,0 @@
-from enum import Enum
-from typing import Optional, List, Dict, Any, Union
-from datetime import datetime
-
-from pydantic import BaseModel, Field, RootModel, StrictBytes
-
-
-class IdeogramColorPalette1(BaseModel):
-    name: str = Field(..., description='Name of the preset color palette')
-
-
-class Member(BaseModel):
-    color: Optional[str] = Field(
-        None, description='Hexadecimal color code', pattern='^#[0-9A-Fa-f]{6}$'
-    )
-    weight: Optional[float] = Field(
-        None, description='Optional weight for the color (0-1)', ge=0.0, le=1.0
-    )
-
-
-class IdeogramColorPalette2(BaseModel):
-    members: List[Member] = Field(
-        ..., description='Array of color definitions with optional weights'
-    )
-
-
-class IdeogramColorPalette(
-    RootModel[Union[IdeogramColorPalette1, IdeogramColorPalette2]]
-):
-    root: Union[IdeogramColorPalette1, IdeogramColorPalette2] = Field(
-        ...,
-        description='A color palette specification that can either use a preset name or explicit color definitions with weights',
-    )
-
-
-class ImageRequest(BaseModel):
-    aspect_ratio: Optional[str] = Field(
-        None,
-        description="Optional. The aspect ratio (e.g., 'ASPECT_16_9', 'ASPECT_1_1'). Cannot be used with resolution. Defaults to 'ASPECT_1_1' if unspecified.",
-    )
-    color_palette: Optional[Dict[str, Any]] = Field(
-        None, description='Optional. Color palette object. Only for V_2, V_2_TURBO.'
-    )
-    magic_prompt_option: Optional[str] = Field(
-        None, description="Optional. MagicPrompt usage ('AUTO', 'ON', 'OFF')."
-    )
-    model: str = Field(..., description="The model used (e.g., 'V_2', 'V_2A_TURBO')")
-    negative_prompt: Optional[str] = Field(
-        None,
-        description='Optional. Description of what to exclude. Only for V_1, V_1_TURBO, V_2, V_2_TURBO.',
-    )
-    num_images: Optional[int] = Field(
-        1,
-        description='Optional. Number of images to generate (1-8). Defaults to 1.',
-        ge=1,
-        le=8,
-    )
-    prompt: str = Field(
-        ..., description='Required. The prompt to use to generate the image.'
-    )
-    resolution: Optional[str] = Field(
-        None,
-        description="Optional. Resolution (e.g., 'RESOLUTION_1024_1024'). Only for model V_2. Cannot be used with aspect_ratio.",
-    )
-    seed: Optional[int] = Field(
-        None,
-        description='Optional. A number between 0 and 2147483647.',
-        ge=0,
-        le=2147483647,
-    )
-    style_type: Optional[str] = Field(
-        None,
-        description="Optional. Style type ('AUTO', 'GENERAL', 'REALISTIC', 'DESIGN', 'RENDER_3D', 'ANIME'). Only for models V_2 and above.",
-    )
-
-
-class IdeogramGenerateRequest(BaseModel):
-    image_request: ImageRequest = Field(
-        ..., description='The image generation request parameters.'
-    )
-
-
-class Datum(BaseModel):
-    is_image_safe: Optional[bool] = Field(
-        None, description='Indicates whether the image is considered safe.'
-    )
-    prompt: Optional[str] = Field(
-        None, description='The prompt used to generate this image.'
-    )
-    resolution: Optional[str] = Field(
-        None, description="The resolution of the generated image (e.g., '1024x1024')."
-    )
-    seed: Optional[int] = Field(
-        None, description='The seed value used for this generation.'
-    )
-    style_type: Optional[str] = Field(
-        None,
-        description="The style type used for generation (e.g., 'REALISTIC', 'ANIME').",
-    )
-    url: Optional[str] = Field(None, description='URL to the generated image.')
-
-
-class IdeogramGenerateResponse(BaseModel):
-    created: Optional[datetime] = Field(
-        None, description='Timestamp when the generation was created.'
-    )
-    data: Optional[List[Datum]] = Field(
-        None, description='Array of generated image information.'
-    )
-
-
-class StyleCode(RootModel[str]):
-    root: str = Field(..., pattern='^[0-9A-Fa-f]{8}$')
-
-
-class Datum1(BaseModel):
-    is_image_safe: Optional[bool] = None
-    prompt: Optional[str] = None
-    resolution: Optional[str] = None
-    seed: Optional[int] = None
-    style_type: Optional[str] = None
-    url: Optional[str] = None
-
-
-class IdeogramV3IdeogramResponse(BaseModel):
-    created: Optional[datetime] = None
-    data: Optional[List[Datum1]] = None
-
-
-class RenderingSpeed1(str, Enum):
-    TURBO = 'TURBO'
-    DEFAULT = 'DEFAULT'
-    QUALITY = 'QUALITY'
-
-
-class IdeogramV3ReframeRequest(BaseModel):
-    color_palette: Optional[Dict[str, Any]] = None
-    image: Optional[StrictBytes] = None
-    num_images: Optional[int] = Field(None, ge=1, le=8)
-    rendering_speed: Optional[RenderingSpeed1] = None
-    resolution: str
-    seed: Optional[int] = Field(None, ge=0, le=2147483647)
-    style_codes: Optional[List[str]] = None
-    style_reference_images: Optional[List[StrictBytes]] = None
-
-
-class MagicPrompt(str, Enum):
-    AUTO = 'AUTO'
-    ON = 'ON'
-    OFF = 'OFF'
-
-
-class StyleType(str, Enum):
-    AUTO = 'AUTO'
-    GENERAL = 'GENERAL'
-    REALISTIC = 'REALISTIC'
-    DESIGN = 'DESIGN'
-
-
-class IdeogramV3RemixRequest(BaseModel):
-    aspect_ratio: Optional[str] = None
-    color_palette: Optional[Dict[str, Any]] = None
-    image: Optional[StrictBytes] = None
-    image_weight: Optional[int] = Field(50, ge=1, le=100)
-    magic_prompt: Optional[MagicPrompt] = None
-    negative_prompt: Optional[str] = None
-    num_images: Optional[int] = Field(None, ge=1, le=8)
-    prompt: str
-    rendering_speed: Optional[RenderingSpeed1] = None
-    resolution: Optional[str] = None
-    seed: Optional[int] = Field(None, ge=0, le=2147483647)
-    style_codes: Optional[List[str]] = None
-    style_reference_images: Optional[List[StrictBytes]] = None
-    style_type: Optional[StyleType] = None
-
-
-class IdeogramV3ReplaceBackgroundRequest(BaseModel):
-    color_palette: Optional[Dict[str, Any]] = None
-    image: Optional[StrictBytes] = None
-    magic_prompt: Optional[MagicPrompt] = None
-    num_images: Optional[int] = Field(None, ge=1, le=8)
-    prompt: str
-    rendering_speed: Optional[RenderingSpeed1] = None
-    seed: Optional[int] = Field(None, ge=0, le=2147483647)
-    style_codes: Optional[List[str]] = None
-    style_reference_images: Optional[List[StrictBytes]] = None
-
-
-class ColorPalette(BaseModel):
-    name: str = Field(..., description='Name of the color palette', examples=['PASTEL'])
-
-
-class MagicPrompt2(str, Enum):
-    ON = 'ON'
-    OFF = 'OFF'
-
-
-class StyleType1(str, Enum):
-    AUTO = 'AUTO'
-    GENERAL = 'GENERAL'
-    REALISTIC = 'REALISTIC'
-    DESIGN = 'DESIGN'
-    FICTION = 'FICTION'
-
-
-class RenderingSpeed(str, Enum):
-    DEFAULT = 'DEFAULT'
-    TURBO = 'TURBO'
-    QUALITY = 'QUALITY'
-
-
-class IdeogramV3EditRequest(BaseModel):
-    color_palette: Optional[IdeogramColorPalette] = None
-    image: Optional[StrictBytes] = Field(
-        None,
-        description='The image being edited (max size 10MB); only JPEG, WebP and PNG formats are supported at this time.',
-    )
-    magic_prompt: Optional[str] = Field(
-        None,
-        description='Determine if MagicPrompt should be used in generating the request or not.',
-    )
-    mask: Optional[StrictBytes] = Field(
-        None,
-        description='A black and white image of the same size as the image being edited (max size 10MB). Black regions in the mask should match up with the regions of the image that you would like to edit; only JPEG, WebP and PNG formats are supported at this time.',
-    )
-    num_images: Optional[int] = Field(
-        None, description='The number of images to generate.'
-    )
-    prompt: str = Field(
-        ..., description='The prompt used to describe the edited result.'
-    )
-    rendering_speed: RenderingSpeed
-    seed: Optional[int] = Field(
-        None, description='Random seed. Set for reproducible generation.'
-    )
-    style_codes: Optional[List[StyleCode]] = Field(
-        None,
-        description='A list of 8 character hexadecimal codes representing the style of the image. Cannot be used in conjunction with style_reference_images or style_type.',
-    )
-    style_reference_images: Optional[List[StrictBytes]] = Field(
-        None,
-        description='A set of images to use as style references (maximum total size 10MB across all style references). The images should be in JPEG, PNG or WebP format.',
-    )
-    character_reference_images: Optional[List[str]] = Field(
-        None,
-        description='Generations with character reference are subject to the character reference pricing. A set of images to use as character references (maximum total size 10MB across all character references), currently only supports 1 character reference image. The images should be in JPEG, PNG or WebP format.'
-    )
-    character_reference_images_mask: Optional[List[str]] = Field(
-        None,
-        description='Optional masks for character reference images. When provided, must match the number of character_reference_images. Each mask should be a grayscale image of the same dimensions as the corresponding character reference image. The images should be in JPEG, PNG or WebP format.'
-    )
-
-
-class IdeogramV3Request(BaseModel):
-    aspect_ratio: Optional[str] = Field(
-        None, description='Aspect ratio in format WxH', examples=['1x3']
-    )
-    color_palette: Optional[ColorPalette] = None
-    magic_prompt: Optional[MagicPrompt2] = Field(
-        None, description='Whether to enable magic prompt enhancement'
-    )
-    negative_prompt: Optional[str] = Field(
-        None, description='Text prompt specifying what to avoid in the generation'
-    )
-    num_images: Optional[int] = Field(
-        None, description='Number of images to generate', ge=1
-    )
-    prompt: str = Field(..., description='The text prompt for image generation')
-    rendering_speed: RenderingSpeed
-    resolution: Optional[str] = Field(
-        None, description='Image resolution in format WxH', examples=['1280x800']
-    )
-    seed: Optional[int] = Field(
-        None, description='Seed value for reproducible generation'
-    )
-    style_codes: Optional[List[StyleCode]] = Field(
-        None, description='Array of style codes in hexadecimal format'
-    )
-    style_reference_images: Optional[List[str]] = Field(
-        None, description='Array of reference image URLs or identifiers'
-    )
-    style_type: Optional[StyleType1] = Field(
-        None, description='The type of style to apply'
-    )
-    character_reference_images: Optional[List[str]] = Field(
-        None,
-        description='Generations with character reference are subject to the character reference pricing. A set of images to use as character references (maximum total size 10MB across all character references), currently only supports 1 character reference image. The images should be in JPEG, PNG or WebP format.'
-    )
-    character_reference_images_mask: Optional[List[str]] = Field(
-        None,
-        description='Optional masks for character reference images. When provided, must match the number of character_reference_images. Each mask should be a grayscale image of the same dimensions as the corresponding character reference image. The images should be in JPEG, PNG or WebP format.'
-    )

comfy_api_nodes/apis/meshy.py

@@ -1,160 +0,0 @@
-from typing import TypedDict
-
-from pydantic import BaseModel, Field
-
-from comfy_api.latest import Input
-
-
-class InputShouldRemesh(TypedDict):
-    should_remesh: str
-    topology: str
-    target_polycount: int
-
-
-class InputShouldTexture(TypedDict):
-    should_texture: str
-    enable_pbr: bool
-    texture_prompt: str
-    texture_image: Input.Image | None
-
-
-class MeshyTaskResponse(BaseModel):
-    result: str = Field(...)
-
-
-class MeshyTextToModelRequest(BaseModel):
-    mode: str = Field("preview")
-    prompt: str = Field(..., max_length=600)
-    art_style: str = Field(..., description="'realistic' or 'sculpture'")
-    ai_model: str = Field(...)
-    topology: str | None = Field(..., description="'quad' or 'triangle'")
-    target_polycount: int | None = Field(..., ge=100, le=300000)
-    should_remesh: bool = Field(
-        True,
-        description="False returns the original mesh, ignoring topology and polycount.",
-    )
-    symmetry_mode: str = Field(..., description="'auto', 'off' or 'on'")
-    pose_mode: str = Field(...)
-    seed: int = Field(...)
-    moderation: bool = Field(False)
-
-
-class MeshyRefineTask(BaseModel):
-    mode: str = Field("refine")
-    preview_task_id: str = Field(...)
-    enable_pbr: bool | None = Field(...)
-    texture_prompt: str | None = Field(...)
-    texture_image_url: str | None = Field(...)
-    ai_model: str = Field(...)
-    moderation: bool = Field(False)
-
-
-class MeshyImageToModelRequest(BaseModel):
-    image_url: str = Field(...)
-    ai_model: str = Field(...)
-    topology: str | None = Field(..., description="'quad' or 'triangle'")
-    target_polycount: int | None = Field(..., ge=100, le=300000)
-    symmetry_mode: str = Field(..., description="'auto', 'off' or 'on'")
-    should_remesh: bool = Field(
-        True,
-        description="False returns the original mesh, ignoring topology and polycount.",
-    )
-    should_texture: bool = Field(...)
-    enable_pbr: bool | None = Field(...)
-    pose_mode: str = Field(...)
-    texture_prompt: str | None = Field(None, max_length=600)
-    texture_image_url: str | None = Field(None)
-    seed: int = Field(...)
-    moderation: bool = Field(False)
-
-
-class MeshyMultiImageToModelRequest(BaseModel):
-    image_urls: list[str] = Field(...)
-    ai_model: str = Field(...)
-    topology: str | None = Field(..., description="'quad' or 'triangle'")
-    target_polycount: int | None = Field(..., ge=100, le=300000)
-    symmetry_mode: str = Field(..., description="'auto', 'off' or 'on'")
-    should_remesh: bool = Field(
-        True,
-        description="False returns the original mesh, ignoring topology and polycount.",
-    )
-    should_texture: bool = Field(...)
-    enable_pbr: bool | None = Field(...)
-    pose_mode: str = Field(...)
-    texture_prompt: str | None = Field(None, max_length=600)
-    texture_image_url: str | None = Field(None)
-    seed: int = Field(...)
-    moderation: bool = Field(False)
-
-
-class MeshyRiggingRequest(BaseModel):
-    input_task_id: str = Field(...)
-    height_meters: float = Field(...)
-    texture_image_url: str | None = Field(...)
-
-
-class MeshyAnimationRequest(BaseModel):
-    rig_task_id: str = Field(...)
-    action_id: int = Field(...)
-
-
-class MeshyTextureRequest(BaseModel):
-    input_task_id: str = Field(...)
-    ai_model: str = Field(...)
-    enable_original_uv: bool = Field(...)
-    enable_pbr: bool = Field(...)
-    text_style_prompt: str | None = Field(...)
-    image_style_url: str | None = Field(...)
-
-
-class MeshyModelsUrls(BaseModel):
-    glb: str = Field("")
-
-
-class MeshyRiggedModelsUrls(BaseModel):
-    rigged_character_glb_url: str = Field("")
-
-
-class MeshyAnimatedModelsUrls(BaseModel):
-    animation_glb_url: str = Field("")
-
-
-class MeshyResultTextureUrls(BaseModel):
-    base_color: str = Field(...)
-    metallic: str | None = Field(None)
-    normal: str | None = Field(None)
-    roughness: str | None = Field(None)
-
-
-class MeshyTaskError(BaseModel):
-    message: str | None = Field(None)
-
-
-class MeshyModelResult(BaseModel):
-    id: str = Field(...)
-    type: str = Field(...)
-    model_urls: MeshyModelsUrls = Field(MeshyModelsUrls())
-    thumbnail_url: str = Field(...)
-    video_url: str | None = Field(None)
-    status: str = Field(...)
-    progress: int = Field(0)
-    texture_urls: list[MeshyResultTextureUrls] | None = Field([])
-    task_error: MeshyTaskError | None = Field(None)
-
-
-class MeshyRiggedResult(BaseModel):
-    id: str = Field(...)
-    type: str = Field(...)
-    status: str = Field(...)
-    progress: int = Field(0)
-    result: MeshyRiggedModelsUrls = Field(MeshyRiggedModelsUrls())
-    task_error: MeshyTaskError | None = Field(None)
-
-
-class MeshyAnimationResult(BaseModel):
-    id: str = Field(...)
-    type: str = Field(...)
-    status: str = Field(...)
-    progress: int = Field(0)
-    result: MeshyAnimatedModelsUrls = Field(MeshyAnimatedModelsUrls())
-    task_error: MeshyTaskError | None = Field(None)

comfy_api_nodes/apis/moonvalley.py

@@ -1,152 +0,0 @@
-from enum import Enum
-from typing import Optional, Dict, Any
-
-from pydantic import BaseModel, Field, StrictBytes
-
-
-class MoonvalleyPromptResponse(BaseModel):
-    error: Optional[Dict[str, Any]] = None
-    frame_conditioning: Optional[Dict[str, Any]] = None
-    id: Optional[str] = None
-    inference_params: Optional[Dict[str, Any]] = None
-    meta: Optional[Dict[str, Any]] = None
-    model_params: Optional[Dict[str, Any]] = None
-    output_url: Optional[str] = None
-    prompt_text: Optional[str] = None
-    status: Optional[str] = None
-
-
-class MoonvalleyTextToVideoInferenceParams(BaseModel):
-    add_quality_guidance: Optional[bool] = Field(
-        True, description='Whether to add quality guidance'
-    )
-    caching_coefficient: Optional[float] = Field(
-        0.3, description='Caching coefficient for optimization'
-    )
-    caching_cooldown: Optional[int] = Field(
-        3, description='Number of caching cooldown steps'
-    )
-    caching_warmup: Optional[int] = Field(
-        3, description='Number of caching warmup steps'
-    )
-    clip_value: Optional[float] = Field(
-        3, description='CLIP value for generation control'
-    )
-    conditioning_frame_index: Optional[int] = Field(
-        0, description='Index of the conditioning frame'
-    )
-    cooldown_steps: Optional[int] = Field(
-        75, description='Number of cooldown steps (calculated based on num_frames)'
-    )
-    fps: Optional[int] = Field(
-        24, description='Frames per second of the generated video'
-    )
-    guidance_scale: Optional[float] = Field(
-        10, description='Guidance scale for generation control'
-    )
-    height: Optional[int] = Field(
-        1080, description='Height of the generated video in pixels'
-    )
-    negative_prompt: Optional[str] = Field(None, description='Negative prompt text')
-    num_frames: Optional[int] = Field(64, description='Number of frames to generate')
-    seed: Optional[int] = Field(
-        None, description='Random seed for generation (default: random)'
-    )
-    shift_value: Optional[float] = Field(
-        3, description='Shift value for generation control'
-    )
-    steps: Optional[int] = Field(80, description='Number of denoising steps')
-    use_guidance_schedule: Optional[bool] = Field(
-        True, description='Whether to use guidance scheduling'
-    )
-    use_negative_prompts: Optional[bool] = Field(
-        False, description='Whether to use negative prompts'
-    )
-    use_timestep_transform: Optional[bool] = Field(
-        True, description='Whether to use timestep transformation'
-    )
-    warmup_steps: Optional[int] = Field(
-        0, description='Number of warmup steps (calculated based on num_frames)'
-    )
-    width: Optional[int] = Field(
-        1920, description='Width of the generated video in pixels'
-    )
-
-
-class MoonvalleyTextToVideoRequest(BaseModel):
-    image_url: Optional[str] = None
-    inference_params: Optional[MoonvalleyTextToVideoInferenceParams] = None
-    prompt_text: Optional[str] = None
-    webhook_url: Optional[str] = None
-
-
-class MoonvalleyUploadFileRequest(BaseModel):
-    file: Optional[StrictBytes] = None
-
-
-class MoonvalleyUploadFileResponse(BaseModel):
-    access_url: Optional[str] = None
-
-
-class MoonvalleyVideoToVideoInferenceParams(BaseModel):
-    add_quality_guidance: Optional[bool] = Field(
-        True, description='Whether to add quality guidance'
-    )
-    caching_coefficient: Optional[float] = Field(
-        0.3, description='Caching coefficient for optimization'
-    )
-    caching_cooldown: Optional[int] = Field(
-        3, description='Number of caching cooldown steps'
-    )
-    caching_warmup: Optional[int] = Field(
-        3, description='Number of caching warmup steps'
-    )
-    clip_value: Optional[float] = Field(
-        3, description='CLIP value for generation control'
-    )
-    conditioning_frame_index: Optional[int] = Field(
-        0, description='Index of the conditioning frame'
-    )
-    cooldown_steps: Optional[int] = Field(
-        36, description='Number of cooldown steps (calculated based on num_frames)'
-    )
-    guidance_scale: Optional[float] = Field(
-        15, description='Guidance scale for generation control'
-    )
-    negative_prompt: Optional[str] = Field(None, description='Negative prompt text')
-    seed: Optional[int] = Field(
-        None, description='Random seed for generation (default: random)'
-    )
-    shift_value: Optional[float] = Field(
-        3, description='Shift value for generation control'
-    )
-    steps: Optional[int] = Field(80, description='Number of denoising steps')
-    use_guidance_schedule: Optional[bool] = Field(
-        True, description='Whether to use guidance scheduling'
-    )
-    use_negative_prompts: Optional[bool] = Field(
-        False, description='Whether to use negative prompts'
-    )
-    use_timestep_transform: Optional[bool] = Field(
-        True, description='Whether to use timestep transformation'
-    )
-    warmup_steps: Optional[int] = Field(
-        24, description='Number of warmup steps (calculated based on num_frames)'
-    )
-
-
-class ControlType(str, Enum):
-    motion_control = 'motion_control'
-    pose_control = 'pose_control'
-
-
-class MoonvalleyVideoToVideoRequest(BaseModel):
-    control_type: ControlType = Field(
-        ..., description='Supported types for video control'
-    )
-    inference_params: Optional[MoonvalleyVideoToVideoInferenceParams] = None
-    prompt_text: str = Field(..., description='Describes the video to generate')
-    video_url: str = Field(..., description='Url to control video')
-    webhook_url: Optional[str] = Field(
-        None, description='Optional webhook URL for notifications'
-    )

comfy_api_nodes/apis/openai.py

@@ -1,170 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class Datum2(BaseModel):
-    b64_json: str | None = Field(None, description="Base64 encoded image data")
-    revised_prompt: str | None = Field(None, description="Revised prompt")
-    url: str | None = Field(None, description="URL of the image")
-
-
-class InputTokensDetails(BaseModel):
-    image_tokens: int | None = Field(None)
-    text_tokens: int | None = Field(None)
-
-
-class Usage(BaseModel):
-    input_tokens: int | None = Field(None)
-    input_tokens_details: InputTokensDetails | None = Field(None)
-    output_tokens: int | None = Field(None)
-    total_tokens: int | None = Field(None)
-
-
-class OpenAIImageGenerationResponse(BaseModel):
-    data: list[Datum2] | None = Field(None)
-    usage: Usage | None = Field(None)
-
-
-class OpenAIImageEditRequest(BaseModel):
-    background: str | None = Field(None, description="Background transparency")
-    model: str = Field(...)
-    moderation: str | None = Field(None)
-    n: int | None = Field(None, description="The number of images to generate")
-    output_compression: int | None = Field(None, description="Compression level for JPEG or WebP (0-100)")
-    output_format: str | None = Field(None)
-    prompt: str = Field(...)
-    quality: str | None = Field(None, description="Size of the image (e.g., 1024x1024, 1536x1024, auto)")
-    size: str | None = Field(None, description="Size of the output image")
-
-
-class OpenAIImageGenerationRequest(BaseModel):
-    background: str | None = Field(None, description="Background transparency")
-    model: str | None = Field(None)
-    moderation: str | None = Field(None)
-    n: int | None = Field(
-        None,
-        description="The number of images to generate.",
-    )
-    output_compression: int | None = Field(None, description="Compression level for JPEG or WebP (0-100)")
-    output_format: str | None = Field(None)
-    prompt: str = Field(...)
-    quality: str | None = Field(None, description="The quality of the generated image")
-    size: str | None = Field(None, description="Size of the image (e.g., 1024x1024, 1536x1024, auto)")
-    style: str | None = Field(None, description="Style of the image (only for dall-e-3)")
-
-
-class ModelResponseProperties(BaseModel):
-    instructions: str | None = Field(None)
-    max_output_tokens: int | None = Field(None)
-    model: str | None = Field(None)
-    temperature: float | None = Field(1, description="Controls randomness in the response", ge=0.0, le=2.0)
-    top_p: float | None = Field(
-        1,
-        description="Controls diversity of the response via nucleus sampling",
-        ge=0.0,
-        le=1.0,
-    )
-    truncation: str | None = Field("disabled", description="Allowed values: 'auto' or 'disabled'")
-
-
-class ResponseProperties(BaseModel):
-    instructions: str | None = Field(None)
-    max_output_tokens: int | None = Field(None)
-    model: str | None = Field(None)
-    previous_response_id: str | None = Field(None)
-    truncation: str | None = Field("disabled", description="Allowed values: 'auto' or 'disabled'")
-
-
-class ResponseError(BaseModel):
-    code: str = Field(...)
-    message: str = Field(...)
-
-
-class OutputTokensDetails(BaseModel):
-    reasoning_tokens: int = Field(..., description="The number of reasoning tokens.")
-
-
-class CachedTokensDetails(BaseModel):
-    cached_tokens: int = Field(
-        ...,
-        description="The number of tokens that were retrieved from the cache.",
-    )
-
-
-class ResponseUsage(BaseModel):
-    input_tokens: int = Field(..., description="The number of input tokens.")
-    input_tokens_details: CachedTokensDetails = Field(...)
-    output_tokens: int = Field(..., description="The number of output tokens.")
-    output_tokens_details: OutputTokensDetails = Field(...)
-    total_tokens: int = Field(..., description="The total number of tokens used.")
-
-
-class InputTextContent(BaseModel):
-    text: str = Field(..., description="The text input to the model.")
-    type: str = Field("input_text")
-
-
-class OutputContent(BaseModel):
-    type: str = Field(..., description="The type of output content")
-    text: str | None = Field(None, description="The text content")
-    data: str | None = Field(None, description="Base64-encoded audio data")
-    transcript: str | None = Field(None, description="Transcript of the audio")
-
-
-class OutputMessage(BaseModel):
-    type: str = Field(..., description="The type of output item")
-    content: list[OutputContent] | None = Field(None, description="The content of the message")
-    role: str | None = Field(None, description="The role of the message")
-
-
-class OpenAIResponse(ModelResponseProperties, ResponseProperties):
-    created_at: float | None = Field(
-        None,
-        description="Unix timestamp (in seconds) of when this Response was created.",
-    )
-    error: ResponseError | None = Field(None)
-    id: str | None = Field(None, description="Unique identifier for this Response.")
-    object: str | None = Field(None, description="The object type of this resource - always set to `response`.")
-    output: list[OutputMessage] | None = Field(None)
-    parallel_tool_calls: bool | None = Field(True)
-    status: str | None = Field(
-        None,
-        description="One of `completed`, `failed`, `in_progress`, or `incomplete`.",
-    )
-    usage: ResponseUsage | None = Field(None)
-
-
-class InputImageContent(BaseModel):
-    detail: str = Field(..., description="One of `high`, `low`, or `auto`. Defaults to `auto`.")
-    file_id: str | None = Field(None)
-    image_url: str | None = Field(None)
-    type: str = Field(..., description="The type of the input item. Always `input_image`.")
-
-
-class InputFileContent(BaseModel):
-    file_data: str | None = Field(None)
-    file_id: str | None = Field(None)
-    filename: str | None = Field(None, description="The name of the file to be sent to the model.")
-    type: str = Field(..., description="The type of the input item. Always `input_file`.")
-
-
-class InputMessage(BaseModel):
-    content: list[InputTextContent | InputImageContent | InputFileContent] = Field(
-        ...,
-        description="A list of one or many input items to the model, containing different content types.",
-    )
-    role: str | None = Field(None)
-    type: str | None = Field(None)
-
-
-class OpenAICreateResponse(ModelResponseProperties, ResponseProperties):
-    include: str | None = Field(None)
-    input: list[InputMessage] = Field(...)
-    parallel_tool_calls: bool | None = Field(
-        True, description="Whether to allow the model to run tool calls in parallel."
-    )
-    store: bool | None = Field(
-        True,
-        description="Whether to store the generated model response for later retrieval via API.",
-    )
-    stream: bool | None = Field(False)
-    usage: ResponseUsage | None = Field(None)

comfy_api_nodes/apis/openai_api.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel, Field
+
+
+class Datum2(BaseModel):
+    b64_json: str | None = Field(None, description="Base64 encoded image data")
+    revised_prompt: str | None = Field(None, description="Revised prompt")
+    url: str | None = Field(None, description="URL of the image")
+
+
+class InputTokensDetails(BaseModel):
+    image_tokens: int | None = None
+    text_tokens: int | None = None
+
+
+class Usage(BaseModel):
+    input_tokens: int | None = None
+    input_tokens_details: InputTokensDetails | None = None
+    output_tokens: int | None = None
+    total_tokens: int | None = None
+
+
+class OpenAIImageGenerationResponse(BaseModel):
+    data: list[Datum2] | None = None
+    usage: Usage | None = None
+
+
+class OpenAIImageEditRequest(BaseModel):
+    background: str | None = Field(None, description="Background transparency")
+    model: str = Field(...)
+    moderation: str | None = Field(None)
+    n: int | None = Field(None, description="The number of images to generate")
+    output_compression: int | None = Field(None, description="Compression level for JPEG or WebP (0-100)")
+    output_format: str | None = Field(None)
+    prompt: str = Field(...)
+    quality: str | None = Field(None, description="Size of the image (e.g., 1024x1024, 1536x1024, auto)")
+    size: str | None = Field(None, description="Size of the output image")
+
+
+class OpenAIImageGenerationRequest(BaseModel):
+    background: str | None = Field(None, description="Background transparency")
+    model: str | None = Field(None)
+    moderation: str | None = Field(None)
+    n: int | None = Field(
+        None,
+        description="The number of images to generate.",
+    )
+    output_compression: int | None = Field(None, description="Compression level for JPEG or WebP (0-100)")
+    output_format: str | None = Field(None)
+    prompt: str = Field(...)
+    quality: str | None = Field(None, description="The quality of the generated image")
+    size: str | None = Field(None, description="Size of the image (e.g., 1024x1024, 1536x1024, auto)")
+    style: str | None = Field(None, description="Style of the image (only for dall-e-3)")

comfy_api_nodes/apis/runway.py

@@ -1,127 +0,0 @@
-from enum import Enum
-from typing import Optional, List, Union
-from datetime import datetime
-
-from pydantic import BaseModel, Field, RootModel
-
-
-class RunwayAspectRatioEnum(str, Enum):
-    field_1280_720 = '1280:720'
-    field_720_1280 = '720:1280'
-    field_1104_832 = '1104:832'
-    field_832_1104 = '832:1104'
-    field_960_960 = '960:960'
-    field_1584_672 = '1584:672'
-    field_1280_768 = '1280:768'
-    field_768_1280 = '768:1280'
-
-
-class Position(str, Enum):
-    first = 'first'
-    last = 'last'
-
-
-class RunwayPromptImageDetailedObject(BaseModel):
-    position: Position = Field(
-        ...,
-        description="The position of the image in the output video. 'last' is currently supported for gen3a_turbo only.",
-    )
-    uri: str = Field(
-        ..., description='A HTTPS URL or data URI containing an encoded image.'
-    )
-
-
-class RunwayPromptImageObject(
-    RootModel[Union[str, List[RunwayPromptImageDetailedObject]]]
-):
-    root: Union[str, List[RunwayPromptImageDetailedObject]] = Field(
-        ...,
-        description='Image(s) to use for the video generation. Can be a single URI or an array of image objects with positions.',
-    )
-
-
-class RunwayModelEnum(str, Enum):
-    gen4_turbo = 'gen4_turbo'
-    gen3a_turbo = 'gen3a_turbo'
-
-
-class RunwayDurationEnum(int, Enum):
-    integer_5 = 5
-    integer_10 = 10
-
-
-class RunwayImageToVideoRequest(BaseModel):
-    duration: RunwayDurationEnum
-    model: RunwayModelEnum
-    promptImage: RunwayPromptImageObject
-    promptText: Optional[str] = Field(
-        None, description='Text prompt for the generation', max_length=1000
-    )
-    ratio: RunwayAspectRatioEnum
-    seed: int = Field(
-        ..., description='Random seed for generation', ge=0, le=4294967295
-    )
-
-
-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')
-    output: Optional[List[str]] = Field(None, description='Array of output video URLs')
-    progress: Optional[float] = Field(
-        None,
-        description='Float value between 0 and 1 representing the progress of the task. Only available if status is RUNNING.',
-        ge=0.0,
-        le=1.0,
-    )
-    status: RunwayTaskStatusEnum
-
-
-class Model4(str, Enum):
-    gen4_image = 'gen4_image'
-
-
-class ReferenceImage(BaseModel):
-    uri: Optional[str] = Field(
-        None, description='A HTTPS URL or data URI containing an encoded image'
-    )
-
-
-class RunwayTextToImageAspectRatioEnum(str, Enum):
-    field_1920_1080 = '1920:1080'
-    field_1080_1920 = '1080:1920'
-    field_1024_1024 = '1024:1024'
-    field_1360_768 = '1360:768'
-    field_1080_1080 = '1080:1080'
-    field_1168_880 = '1168:880'
-    field_1440_1080 = '1440:1080'
-    field_1080_1440 = '1080:1440'
-    field_1808_768 = '1808:768'
-    field_2112_912 = '2112:912'
-
-
-class RunwayTextToImageRequest(BaseModel):
-    model: Model4 = Field(..., description='Model to use for generation')
-    promptText: str = Field(
-        ..., description='Text prompt for the image generation', max_length=1000
-    )
-    ratio: RunwayTextToImageAspectRatioEnum
-    referenceImages: Optional[List[ReferenceImage]] = Field(
-        None, description='Array of reference images to guide the generation'
-    )
-
-
-class RunwayTextToImageResponse(BaseModel):
-    id: Optional[str] = Field(None, description='Task ID')

comfy_api_nodes/apis/topaz_api.py

@@ -41,7 +41,7 @@ class Resolution(BaseModel):
     height: int = Field(...)
 
 
-class CreateVideoRequestSource(BaseModel):
+class CreateCreateVideoRequestSource(BaseModel):
     container: str = Field(...)
     size: int = Field(..., description="Size of the video file in bytes")
     duration: int = Field(..., description="Duration of the video file in seconds")
@@ -89,7 +89,7 @@ class Overrides(BaseModel):
 
 
 class CreateVideoRequest(BaseModel):
-    source: CreateVideoRequestSource = Field(...)
+    source: CreateCreateVideoRequestSource = Field(...)
     filters: list[Union[VideoFrameInterpolationFilter, VideoEnhancementFilter]] = Field(...)
     output: OutputInformationVideo = Field(...)
     overrides: Overrides = Field(Overrides(isPaidDiffusion=True))

comfy_api_nodes/apis/vidu.py

@@ -1,41 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class SubjectReference(BaseModel):
-    id: str = Field(...)
-    images: list[str] = Field(...)
-
-
-class TaskCreationRequest(BaseModel):
-    model: str = Field(...)
-    prompt: str = Field(..., max_length=2000)
-    duration: int = Field(...)
-    seed: int = Field(..., ge=0, le=2147483647)
-    aspect_ratio: str | None = Field(None)
-    resolution: str | None = Field(None)
-    movement_amplitude: str | None = Field(None)
-    images: list[str] | None = Field(None, description="Base64 encoded string or image URL")
-    subjects: list[SubjectReference] | None = Field(None)
-    bgm: bool | None = Field(None)
-    audio: bool | None = Field(None)
-
-
-class TaskCreationResponse(BaseModel):
-    task_id: str = Field(...)
-    state: str = Field(...)
-    created_at: str = Field(...)
-    code: int | None = Field(None, description="Error code")
-
-
-class TaskResult(BaseModel):
-    id: str = Field(..., description="Creation id")
-    url: str = Field(..., description="The URL of the generated results, valid for one hour")
-    cover_url: str = Field(..., description="The cover URL of the generated results, valid for one hour")
-
-
-class TaskStatusResponse(BaseModel):
-    state: str = Field(...)
-    err_code: str | None = Field(None)
-    progress: float | None = Field(None)
-    credits: int | None = Field(None)
-    creations: list[TaskResult] = Field(..., description="Generated results")

comfy_api_nodes/apis/wavespeed.py

@@ -1,35 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class SeedVR2ImageRequest(BaseModel):
-    image: str = Field(...)
-    target_resolution: str = Field(...)
-    output_format: str = Field("png")
-    enable_sync_mode: bool = Field(False)
-
-
-class FlashVSRRequest(BaseModel):
-    target_resolution: str = Field(...)
-    video: str = Field(...)
-    duration: float = Field(...)
-
-
-class TaskCreatedDataResponse(BaseModel):
-    id: str = Field(...)
-
-
-class TaskCreatedResponse(BaseModel):
-    code: int = Field(...)
-    message: str = Field(...)
-    data: TaskCreatedDataResponse | None = Field(None)
-
-
-class TaskResultDataResponse(BaseModel):
-    status: str = Field(...)
-    outputs: list[str] = Field([])
-
-
-class TaskResultResponse(BaseModel):
-    code: int = Field(...)
-    message: str = Field(...)
-    data: TaskResultDataResponse | None = Field(None)

comfy_api_nodes/canary.py

@@ -0,0 +1,10 @@
+import av
+
+ver = av.__version__.split(".")
+if int(ver[0]) < 14:
+    raise Exception("INSTALL NEW VERSION OF PYAV TO USE API NODES.")
+
+if int(ver[0]) == 14 and int(ver[1]) < 2:
+    raise Exception("INSTALL NEW VERSION OF PYAV TO USE API NODES.")
+
+NODE_CLASS_MAPPINGS = {}

comfy_api_nodes/mapper_utils.py

@@ -0,0 +1,116 @@
+from enum import Enum
+
+from pydantic.fields import FieldInfo
+from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
+
+from comfy.comfy_types.node_typing import IO, InputTypeOptions
+
+NodeInput = tuple[IO, InputTypeOptions]
+
+
+def _create_base_config(field_info: FieldInfo) -> InputTypeOptions:
+    config = {}
+    if hasattr(field_info, "default") and field_info.default is not PydanticUndefined:
+        config["default"] = field_info.default
+    if hasattr(field_info, "description") and field_info.description is not None:
+        config["tooltip"] = field_info.description
+    return config
+
+
+def _get_number_constraints_config(field_info: FieldInfo) -> dict:
+    config = {}
+    if hasattr(field_info, "metadata"):
+        metadata = field_info.metadata
+        for constraint in metadata:
+            if hasattr(constraint, "ge"):
+                config["min"] = constraint.ge
+            if hasattr(constraint, "le"):
+                config["max"] = constraint.le
+            if hasattr(constraint, "multiple_of"):
+                config["step"] = constraint.multiple_of
+    return config
+
+
+def _model_field_to_image_input(field_info: FieldInfo, **kwargs) -> NodeInput:
+    return IO.IMAGE, {
+        **_create_base_config(field_info),
+        **kwargs,
+    }
+
+
+def _model_field_to_string_input(field_info: FieldInfo, **kwargs) -> NodeInput:
+    return IO.STRING, {
+        **_create_base_config(field_info),
+        **kwargs,
+    }
+
+
+def _model_field_to_float_input(field_info: FieldInfo, **kwargs) -> NodeInput:
+    return IO.FLOAT, {
+        **_create_base_config(field_info),
+        **_get_number_constraints_config(field_info),
+        **kwargs,
+    }
+
+
+def _model_field_to_int_input(field_info: FieldInfo, **kwargs) -> NodeInput:
+    return IO.INT, {
+        **_create_base_config(field_info),
+        **_get_number_constraints_config(field_info),
+        **kwargs,
+    }
+
+
+def _model_field_to_combo_input(
+    field_info: FieldInfo, enum_type: type[Enum] = None, **kwargs
+) -> NodeInput:
+    combo_config = {}
+    if enum_type is not None:
+        combo_config["options"] = [option.value for option in enum_type]
+    combo_config = {
+        **combo_config,
+        **_create_base_config(field_info),
+        **kwargs,
+    }
+    return IO.COMBO, combo_config
+
+
+def model_field_to_node_input(
+    input_type: IO, base_model: type[BaseModel], field_name: str, **kwargs
+) -> NodeInput:
+    """
+    Maps a field from a Pydantic model to a Comfy node input.
+
+    Args:
+        input_type: The type of the input.
+        base_model: The Pydantic model to map the field from.
+        field_name: The name of the field to map.
+        **kwargs: Additional key/values to include in the input options.
+
+    Note:
+        For combo inputs, pass an `Enum` to the `enum_type` keyword argument to populate the options automatically.
+
+    Example:
+        >>> model_field_to_node_input(IO.STRING, MyModel, "my_field", multiline=True)
+        >>> model_field_to_node_input(IO.COMBO, MyModel, "my_field", enum_type=MyEnum)
+        >>> model_field_to_node_input(IO.FLOAT, MyModel, "my_field", slider=True)
+    """
+    field_info: FieldInfo = base_model.model_fields[field_name]
+    result: NodeInput
+
+    if input_type == IO.IMAGE:
+        result = _model_field_to_image_input(field_info, **kwargs)
+    elif input_type == IO.STRING:
+        result = _model_field_to_string_input(field_info, **kwargs)
+    elif input_type == IO.FLOAT:
+        result = _model_field_to_float_input(field_info, **kwargs)
+    elif input_type == IO.INT:
+        result = _model_field_to_int_input(field_info, **kwargs)
+    elif input_type == IO.COMBO:
+        result = _model_field_to_combo_input(field_info, **kwargs)
+    else:
+        message = f"Invalid input type: {input_type}"
+        raise ValueError(message)
+
+    return result

comfy_api_nodes/nodes_bfl.py

@@ -3,7 +3,7 @@ from pydantic import BaseModel
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.bfl import (
+from comfy_api_nodes.apis.bfl_api import (
     BFLFluxExpandImageRequest,
     BFLFluxFillImageRequest,
     BFLFluxKontextProGenerateRequest,
@@ -97,9 +97,6 @@ class FluxProUltraImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.06}""",
-            ),
         )
 
     @classmethod
@@ -355,9 +352,6 @@ class FluxProExpandNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.05}""",
-            ),
         )
 
     @classmethod
@@ -464,9 +458,6 @@ class FluxProFillNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.05}""",
-            ),
         )
 
     @classmethod
@@ -520,21 +511,6 @@ class Flux2ProImageNode(IO.ComfyNode):
     NODE_ID = "Flux2ProImageNode"
     DISPLAY_NAME = "Flux.2 [pro] Image"
     API_ENDPOINT = "/proxy/bfl/flux-2-pro/generate"
-    PRICE_BADGE_EXPR = """
-    (
-      $MP := 1024 * 1024;
-      $outMP := $max([1, $floor(((widgets.width * widgets.height) + $MP - 1) / $MP)]);
-      $outputCost := 0.03 + 0.015 * ($outMP - 1);
-      inputs.images.connected
-        ? {
-            "type":"range_usd",
-            "min_usd": $outputCost + 0.015,
-            "max_usd": $outputCost + 0.12,
-            "format": { "approximate": true }
-          }
-        : {"type":"usd","usd": $outputCost}
-    )
-    """
 
     @classmethod
     def define_schema(cls) -> IO.Schema:
@@ -587,10 +563,6 @@ class Flux2ProImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["width", "height"], inputs=["images"]),
-                expr=cls.PRICE_BADGE_EXPR,
-            ),
         )
 
     @classmethod
@@ -651,22 +623,6 @@ class Flux2MaxImageNode(Flux2ProImageNode):
     NODE_ID = "Flux2MaxImageNode"
     DISPLAY_NAME = "Flux.2 [max] Image"
     API_ENDPOINT = "/proxy/bfl/flux-2-max/generate"
-    PRICE_BADGE_EXPR = """
-    (
-      $MP := 1024 * 1024;
-      $outMP := $max([1, $floor(((widgets.width * widgets.height) + $MP - 1) / $MP)]);
-      $outputCost := 0.07 + 0.03 * ($outMP - 1);
-
-      inputs.images.connected
-        ? {
-            "type":"range_usd",
-            "min_usd": $outputCost + 0.03,
-            "max_usd": $outputCost + 0.24,
-            "format": { "approximate": true }
-          }
-        : {"type":"usd","usd": $outputCost}
-    )
-    """
 
 
 class BFLExtension(ComfyExtension):

comfy_api_nodes/nodes_bria.py

@@ -1,198 +0,0 @@
-from typing_extensions import override
-
-from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.bria import (
-    BriaEditImageRequest,
-    BriaResponse,
-    BriaStatusResponse,
-    InputModerationSettings,
-)
-from comfy_api_nodes.util import (
-    ApiEndpoint,
-    convert_mask_to_image,
-    download_url_to_image_tensor,
-    get_number_of_images,
-    poll_op,
-    sync_op,
-    upload_images_to_comfyapi,
-)
-
-
-class BriaImageEditNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="BriaImageEditNode",
-            display_name="Bria FIBO Image Edit",
-            category="api node/image/Bria",
-            description="Edit images using Bria latest model",
-            inputs=[
-                IO.Combo.Input("model", options=["FIBO"]),
-                IO.Image.Input("image"),
-                IO.String.Input(
-                    "prompt",
-                    multiline=True,
-                    default="",
-                    tooltip="Instruction to edit image",
-                ),
-                IO.String.Input("negative_prompt", multiline=True, default=""),
-                IO.String.Input(
-                    "structured_prompt",
-                    multiline=True,
-                    default="",
-                    tooltip="A string containing the structured edit prompt in JSON format. "
-                    "Use this instead of usual prompt for precise, programmatic control.",
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=1,
-                    min=1,
-                    max=2147483647,
-                    step=1,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                ),
-                IO.Float.Input(
-                    "guidance_scale",
-                    default=3,
-                    min=3,
-                    max=5,
-                    step=0.01,
-                    display_mode=IO.NumberDisplay.number,
-                    tooltip="Higher value makes the image follow the prompt more closely.",
-                ),
-                IO.Int.Input(
-                    "steps",
-                    default=50,
-                    min=20,
-                    max=50,
-                    step=1,
-                    display_mode=IO.NumberDisplay.number,
-                ),
-                IO.DynamicCombo.Input(
-                    "moderation",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Boolean.Input(
-                                    "prompt_content_moderation", default=False
-                                ),
-                                IO.Boolean.Input(
-                                    "visual_input_moderation", default=False
-                                ),
-                                IO.Boolean.Input(
-                                    "visual_output_moderation", default=True
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="Moderation settings",
-                ),
-                IO.Mask.Input(
-                    "mask",
-                    tooltip="If omitted, the edit applies to the entire image.",
-                    optional=True,
-                ),
-            ],
-            outputs=[
-                IO.Image.Output(),
-                IO.String.Output(display_name="structured_prompt"),
-            ],
-            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.04}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        image: Input.Image,
-        prompt: str,
-        negative_prompt: str,
-        structured_prompt: str,
-        seed: int,
-        guidance_scale: float,
-        steps: int,
-        moderation: InputModerationSettings,
-        mask: Input.Image | None = None,
-    ) -> IO.NodeOutput:
-        if not prompt and not structured_prompt:
-            raise ValueError(
-                "One of prompt or structured_prompt is required to be non-empty."
-            )
-        if get_number_of_images(image) != 1:
-            raise ValueError("Exactly one input image is required.")
-        mask_url = None
-        if mask is not None:
-            mask_url = (
-                await upload_images_to_comfyapi(
-                    cls,
-                    convert_mask_to_image(mask),
-                    max_images=1,
-                    mime_type="image/png",
-                    wait_label="Uploading mask",
-                )
-            )[0]
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="proxy/bria/v2/image/edit", method="POST"),
-            data=BriaEditImageRequest(
-                instruction=prompt if prompt else None,
-                structured_instruction=structured_prompt if structured_prompt else None,
-                images=await upload_images_to_comfyapi(
-                    cls,
-                    image,
-                    max_images=1,
-                    mime_type="image/png",
-                    wait_label="Uploading image",
-                ),
-                mask=mask_url,
-                negative_prompt=negative_prompt if negative_prompt else None,
-                guidance_scale=guidance_scale,
-                seed=seed,
-                model_version=model,
-                steps_num=steps,
-                prompt_content_moderation=moderation.get(
-                    "prompt_content_moderation", False
-                ),
-                visual_input_content_moderation=moderation.get(
-                    "visual_input_moderation", False
-                ),
-                visual_output_content_moderation=moderation.get(
-                    "visual_output_moderation", False
-                ),
-            ),
-            response_model=BriaStatusResponse,
-        )
-        response = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/bria/v2/status/{response.request_id}"),
-            status_extractor=lambda r: r.status,
-            response_model=BriaResponse,
-        )
-        return IO.NodeOutput(
-            await download_url_to_image_tensor(response.result.image_url),
-            response.result.structured_prompt,
-        )
-
-
-class BriaExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
-        return [
-            BriaImageEditNode,
-        ]
-
-
-async def comfy_entrypoint() -> BriaExtension:
-    return BriaExtension()

comfy_api_nodes/nodes_bytedance.py

@@ -5,7 +5,7 @@ import torch
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.bytedance import (
+from comfy_api_nodes.apis.bytedance_api import (
     RECOMMENDED_PRESETS,
     RECOMMENDED_PRESETS_SEEDREAM_4,
     VIDEO_TASKS_EXECUTION_TIME,
@@ -126,9 +126,6 @@ class ByteDanceImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.03}""",
-            ),
         )
 
     @classmethod
@@ -370,19 +367,6 @@ class ByteDanceSeedreamNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $price := $contains(widgets.model, "seedream-4-5-251128") ? 0.04 : 0.03;
-                  {
-                    "type":"usd",
-                    "usd": $price,
-                    "format": { "suffix":" x images/Run", "approximate": true }
-                  }
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -477,12 +461,7 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
             inputs=[
                 IO.Combo.Input(
                     "model",
-                    options=[
-                        "seedance-1-5-pro-251215",
-                        "seedance-1-0-pro-250528",
-                        "seedance-1-0-lite-t2v-250428",
-                        "seedance-1-0-pro-fast-251015",
-                    ],
+                    options=["seedance-1-0-pro-250528", "seedance-1-0-lite-t2v-250428", "seedance-1-0-pro-fast-251015"],
                     default="seedance-1-0-pro-fast-251015",
                 ),
                 IO.String.Input(
@@ -533,12 +512,6 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
                 ),
-                IO.Boolean.Input(
-                    "generate_audio",
-                    default=False,
-                    tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
-                    optional=True,
-                ),
             ],
             outputs=[
                 IO.Video.Output(),
@@ -549,7 +522,6 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -563,10 +535,7 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
         seed: int,
         camera_fixed: bool,
         watermark: bool,
-        generate_audio: bool = False,
     ) -> IO.NodeOutput:
-        if model == "seedance-1-5-pro-251215" and duration < 4:
-            raise ValueError("Minimum supported duration for Seedance 1.5 Pro is 4 seconds.")
         validate_string(prompt, strip_whitespace=True, min_length=1)
         raise_if_text_params(prompt, ["resolution", "ratio", "duration", "seed", "camerafixed", "watermark"])
 
@@ -581,11 +550,7 @@ class ByteDanceTextToVideoNode(IO.ComfyNode):
         )
         return await process_video_task(
             cls,
-            payload=Text2VideoTaskCreationRequest(
-                model=model,
-                content=[TaskTextContent(text=prompt)],
-                generate_audio=generate_audio if model == "seedance-1-5-pro-251215" else None,
-            ),
+            payload=Text2VideoTaskCreationRequest(model=model, content=[TaskTextContent(text=prompt)]),
             estimated_duration=max(1, math.ceil(VIDEO_TASKS_EXECUTION_TIME[model][resolution] * (duration / 10.0))),
         )
 
@@ -602,12 +567,7 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
             inputs=[
                 IO.Combo.Input(
                     "model",
-                    options=[
-                        "seedance-1-5-pro-251215",
-                        "seedance-1-0-pro-250528",
-                        "seedance-1-0-lite-i2v-250428",
-                        "seedance-1-0-pro-fast-251015",
-                    ],
+                    options=["seedance-1-0-pro-250528", "seedance-1-0-lite-t2v-250428", "seedance-1-0-pro-fast-251015"],
                     default="seedance-1-0-pro-fast-251015",
                 ),
                 IO.String.Input(
@@ -662,12 +622,6 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
                 ),
-                IO.Boolean.Input(
-                    "generate_audio",
-                    default=False,
-                    tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
-                    optional=True,
-                ),
             ],
             outputs=[
                 IO.Video.Output(),
@@ -678,7 +632,6 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -693,10 +646,7 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
         seed: int,
         camera_fixed: bool,
         watermark: bool,
-        generate_audio: bool = False,
     ) -> IO.NodeOutput:
-        if model == "seedance-1-5-pro-251215" and duration < 4:
-            raise ValueError("Minimum supported duration for Seedance 1.5 Pro is 4 seconds.")
         validate_string(prompt, strip_whitespace=True, min_length=1)
         raise_if_text_params(prompt, ["resolution", "ratio", "duration", "seed", "camerafixed", "watermark"])
         validate_image_dimensions(image, min_width=300, min_height=300, max_width=6000, max_height=6000)
@@ -718,7 +668,6 @@ class ByteDanceImageToVideoNode(IO.ComfyNode):
             payload=Image2VideoTaskCreationRequest(
                 model=model,
                 content=[TaskTextContent(text=prompt), TaskImageContent(image_url=TaskImageContentUrl(url=image_url))],
-                generate_audio=generate_audio if model == "seedance-1-5-pro-251215" else None,
             ),
             estimated_duration=max(1, math.ceil(VIDEO_TASKS_EXECUTION_TIME[model][resolution] * (duration / 10.0))),
         )
@@ -736,7 +685,7 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
             inputs=[
                 IO.Combo.Input(
                     "model",
-                    options=["seedance-1-5-pro-251215", "seedance-1-0-pro-250528", "seedance-1-0-lite-i2v-250428"],
+                    options=["seedance-1-0-pro-250528", "seedance-1-0-lite-i2v-250428"],
                     default="seedance-1-0-lite-i2v-250428",
                 ),
                 IO.String.Input(
@@ -795,12 +744,6 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
                     tooltip='Whether to add an "AI generated" watermark to the video.',
                     optional=True,
                 ),
-                IO.Boolean.Input(
-                    "generate_audio",
-                    default=False,
-                    tooltip="This parameter is ignored for any model except seedance-1-5-pro.",
-                    optional=True,
-                ),
             ],
             outputs=[
                 IO.Video.Output(),
@@ -811,7 +754,6 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -827,10 +769,7 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
         seed: int,
         camera_fixed: bool,
         watermark: bool,
-        generate_audio: bool = False,
     ) -> IO.NodeOutput:
-        if model == "seedance-1-5-pro-251215" and duration < 4:
-            raise ValueError("Minimum supported duration for Seedance 1.5 Pro is 4 seconds.")
         validate_string(prompt, strip_whitespace=True, min_length=1)
         raise_if_text_params(prompt, ["resolution", "ratio", "duration", "seed", "camerafixed", "watermark"])
         for i in (first_frame, last_frame):
@@ -863,7 +802,6 @@ class ByteDanceFirstLastFrameNode(IO.ComfyNode):
                     TaskImageContent(image_url=TaskImageContentUrl(url=str(download_urls[0])), role="first_frame"),
                     TaskImageContent(image_url=TaskImageContentUrl(url=str(download_urls[1])), role="last_frame"),
                 ],
-                generate_audio=generate_audio if model == "seedance-1-5-pro-251215" else None,
             ),
             estimated_duration=max(1, math.ceil(VIDEO_TASKS_EXECUTION_TIME[model][resolution] * (duration / 10.0))),
         )
@@ -939,41 +877,6 @@ class ByteDanceImageReferenceNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model", "duration", "resolution"]),
-                expr="""
-                (
-                  $priceByModel := {
-                    "seedance-1-0-pro": {
-                      "480p":[0.23,0.24],
-                      "720p":[0.51,0.56]
-                    },
-                    "seedance-1-0-lite": {
-                      "480p":[0.17,0.18],
-                      "720p":[0.37,0.41]
-                    }
-                  };
-                  $model := widgets.model;
-                  $modelKey :=
-                    $contains($model, "seedance-1-0-pro")  ? "seedance-1-0-pro" :
-                    "seedance-1-0-lite";
-                  $resolution := widgets.resolution;
-                  $resKey :=
-                    $contains($resolution, "720") ? "720p" :
-                    "480p";
-                  $modelPrices := $lookup($priceByModel, $modelKey);
-                  $baseRange := $lookup($modelPrices, $resKey);
-                  $min10s := $baseRange[0];
-                  $max10s := $baseRange[1];
-                  $scale := widgets.duration / 10;
-                  $minCost := $min10s * $scale;
-                  $maxCost := $max10s * $scale;
-                  ($minCost = $maxCost)
-                    ? {"type":"usd","usd": $minCost}
-                    : {"type":"range_usd","min_usd": $minCost, "max_usd": $maxCost}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1043,59 +946,6 @@ def raise_if_text_params(prompt: str, text_params: list[str]) -> None:
             )
 
 
-PRICE_BADGE_VIDEO = IO.PriceBadge(
-    depends_on=IO.PriceBadgeDepends(widgets=["model", "duration", "resolution", "generate_audio"]),
-    expr="""
-    (
-      $priceByModel := {
-        "seedance-1-5-pro": {
-          "480p":[0.12,0.12],
-          "720p":[0.26,0.26],
-          "1080p":[0.58,0.59]
-        },
-        "seedance-1-0-pro": {
-          "480p":[0.23,0.24],
-          "720p":[0.51,0.56],
-          "1080p":[1.18,1.22]
-        },
-        "seedance-1-0-pro-fast": {
-          "480p":[0.09,0.1],
-          "720p":[0.21,0.23],
-          "1080p":[0.47,0.49]
-        },
-        "seedance-1-0-lite": {
-          "480p":[0.17,0.18],
-          "720p":[0.37,0.41],
-          "1080p":[0.85,0.88]
-        }
-      };
-      $model := widgets.model;
-      $modelKey :=
-        $contains($model, "seedance-1-5-pro")      ? "seedance-1-5-pro" :
-        $contains($model, "seedance-1-0-pro-fast") ? "seedance-1-0-pro-fast" :
-        $contains($model, "seedance-1-0-pro")      ? "seedance-1-0-pro" :
-        "seedance-1-0-lite";
-      $resolution := widgets.resolution;
-      $resKey :=
-        $contains($resolution, "1080") ? "1080p" :
-        $contains($resolution, "720")  ? "720p" :
-        "480p";
-      $modelPrices := $lookup($priceByModel, $modelKey);
-      $baseRange := $lookup($modelPrices, $resKey);
-      $min10s := $baseRange[0];
-      $max10s := $baseRange[1];
-      $scale := widgets.duration / 10;
-      $audioMultiplier := ($modelKey = "seedance-1-5-pro" and widgets.generate_audio) ? 2 : 1;
-      $minCost := $min10s * $scale * $audioMultiplier;
-      $maxCost := $max10s * $scale * $audioMultiplier;
-      ($minCost = $maxCost)
-        ? {"type":"usd","usd": $minCost, "format": { "approximate": true }}
-        : {"type":"range_usd","min_usd": $minCost, "max_usd": $maxCost, "format": { "approximate": true }}
-    )
-    """,
-)
-
-
 class ByteDanceExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:

comfy_api_nodes/nodes_gemini.py

@@ -14,7 +14,7 @@ from typing_extensions import override
 
 import folder_paths
 from comfy_api.latest import IO, ComfyExtension, Input, Types
-from comfy_api_nodes.apis.gemini import (
+from comfy_api_nodes.apis.gemini_api import (
     GeminiContent,
     GeminiFileData,
     GeminiGenerateContentRequest,
@@ -130,7 +130,7 @@ def get_parts_by_type(response: GeminiGenerateContentResponse, part_type: Litera
     Returns:
         List of response parts matching the requested type.
     """
-    if not response.candidates:
+    if response.candidates is None:
         if response.promptFeedback and response.promptFeedback.blockReason:
             feedback = response.promptFeedback
             raise ValueError(
@@ -141,24 +141,14 @@ def get_parts_by_type(response: GeminiGenerateContentResponse, part_type: Litera
             "try changing it to `IMAGE+TEXT` to view the model's reasoning and understand why image generation failed."
         )
     parts = []
-    blocked_reasons = []
-    for candidate in response.candidates:
-        if candidate.finishReason and candidate.finishReason.upper() == "IMAGE_PROHIBITED_CONTENT":
-            blocked_reasons.append(candidate.finishReason)
-            continue
-        if candidate.content is None or candidate.content.parts is None:
-            continue
-        for part in candidate.content.parts:
+    for part in response.candidates[0].content.parts:
         if part_type == "text" and part.text:
             parts.append(part)
         elif part.inlineData and part.inlineData.mimeType == part_type:
             parts.append(part)
         elif part.fileData and part.fileData.mimeType == part_type:
             parts.append(part)
-
-    if not parts and blocked_reasons:
-        raise ValueError(f"Gemini API blocked the request. Reasons: {blocked_reasons}")
-
+        # Skip parts that don't match the requested type
     return parts
 
 
@@ -319,30 +309,6 @@ class GeminiNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $m := widgets.model;
-                  $contains($m, "gemini-2.5-flash") ? {
-                    "type": "list_usd",
-                    "usd": [0.0003, 0.0025],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens"}
-                  }
-                  : $contains($m, "gemini-2.5-pro") ? {
-                    "type": "list_usd",
-                    "usd": [0.00125, 0.01],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gemini-3-pro-preview") ? {
-                    "type": "list_usd",
-                    "usd": [0.002, 0.012],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : {"type":"text", "text":"Token-based"}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -604,9 +570,6 @@ class GeminiImage(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.039,"format":{"suffix":"/Image (1K)","approximate":true}}""",
-            ),
         )
 
     @classmethod
@@ -737,19 +700,6 @@ class GeminiImage2(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["resolution"]),
-                expr="""
-                (
-                  $r := widgets.resolution;
-                  ($contains($r,"1k") or $contains($r,"2k"))
-                    ? {"type":"usd","usd":0.134,"format":{"suffix":"/Image","approximate":true}}
-                    : $contains($r,"4k")
-                      ? {"type":"usd","usd":0.24,"format":{"suffix":"/Image","approximate":true}}
-                      : {"type":"text","text":"Token-based"}
-                )
-                """,
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_ideogram.py

@@ -4,7 +4,7 @@ from comfy_api.latest import IO, ComfyExtension
 from PIL import Image
 import numpy as np
 import torch
-from comfy_api_nodes.apis.ideogram import (
+from comfy_api_nodes.apis import (
     IdeogramGenerateRequest,
     IdeogramGenerateResponse,
     ImageRequest,
@@ -236,6 +236,7 @@ class IdeogramV1(IO.ComfyNode):
             display_name="Ideogram V1",
             category="api node/image/Ideogram",
             description="Generates images using the Ideogram V1 model.",
+            is_api_node=True,
             inputs=[
                 IO.String.Input(
                     "prompt",
@@ -297,17 +298,6 @@ class IdeogramV1(IO.ComfyNode):
                 IO.Hidden.api_key_comfy_org,
                 IO.Hidden.unique_id,
             ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["num_images", "turbo"]),
-                expr="""
-                (
-                  $n := widgets.num_images;
-                  $base := (widgets.turbo = true) ? 0.0286 : 0.0858;
-                  {"type":"usd","usd": $round($base * $n, 2)}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -361,6 +351,7 @@ class IdeogramV2(IO.ComfyNode):
             display_name="Ideogram V2",
             category="api node/image/Ideogram",
             description="Generates images using the Ideogram V2 model.",
+            is_api_node=True,
             inputs=[
                 IO.String.Input(
                     "prompt",
@@ -445,17 +436,6 @@ class IdeogramV2(IO.ComfyNode):
                 IO.Hidden.api_key_comfy_org,
                 IO.Hidden.unique_id,
             ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["num_images", "turbo"]),
-                expr="""
-                (
-                  $n := widgets.num_images;
-                  $base := (widgets.turbo = true) ? 0.0715 : 0.1144;
-                  {"type":"usd","usd": $round($base * $n, 2)}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -526,6 +506,7 @@ class IdeogramV3(IO.ComfyNode):
             category="api node/image/Ideogram",
             description="Generates images using the Ideogram V3 model. "
                         "Supports both regular image generation from text prompts and image editing with mask.",
+            is_api_node=True,
             inputs=[
                 IO.String.Input(
                     "prompt",
@@ -610,23 +591,6 @@ class IdeogramV3(IO.ComfyNode):
                 IO.Hidden.api_key_comfy_org,
                 IO.Hidden.unique_id,
             ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["rendering_speed", "num_images"], inputs=["character_image"]),
-                expr="""
-                (
-                  $n := widgets.num_images;
-                  $speed := widgets.rendering_speed;
-                  $hasChar := inputs.character_image.connected;
-                  $base :=
-                    $contains($speed,"quality") ? ($hasChar ? 0.286 : 0.1287) :
-                    $contains($speed,"default") ? ($hasChar ? 0.2145 : 0.0858) :
-                    $contains($speed,"turbo") ? ($hasChar ? 0.143 : 0.0429) :
-                    0.0858;
-                  {"type":"usd","usd": $round($base * $n, 2)}
-                )
-                """,
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_kling.py

@@ -49,7 +49,7 @@ from comfy_api_nodes.apis import (
     KlingCharacterEffectModelName,
     KlingSingleImageEffectModelName,
 )
-from comfy_api_nodes.apis.kling import (
+from comfy_api_nodes.apis.kling_api import (
     ImageToVideoWithAudioRequest,
     MotionControlRequest,
     OmniImageParamImage,
@@ -567,7 +567,7 @@ async def execute_lipsync(
     # Upload the audio file to Comfy API and get download URL
     if audio:
         audio_url = await upload_audio_to_comfyapi(
-            cls, audio, container_format="mp3", codec_name="libmp3lame", mime_type="audio/mpeg"
+            cls, audio, container_format="mp3", codec_name="libmp3lame", mime_type="audio/mpeg", filename="output.mp3"
         )
         logging.info("Uploaded audio to Comfy API. URL: %s", audio_url)
     else:
@@ -764,33 +764,6 @@ class KlingTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode"]),
-                expr="""
-                (
-                  $m := widgets.mode;
-                  $contains($m,"v2-5-turbo")
-                    ? ($contains($m,"10") ? {"type":"usd","usd":0.7} : {"type":"usd","usd":0.35})
-                    : $contains($m,"v2-1-master")
-                      ? ($contains($m,"10s") ? {"type":"usd","usd":2.8} : {"type":"usd","usd":1.4})
-                      : $contains($m,"v2-master")
-                        ? ($contains($m,"10s") ? {"type":"usd","usd":2.8} : {"type":"usd","usd":1.4})
-                        : $contains($m,"v1-6")
-                          ? (
-                              $contains($m,"pro")
-                                ? ($contains($m,"10s") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                                : ($contains($m,"10s") ? {"type":"usd","usd":0.56} : {"type":"usd","usd":0.28})
-                            )
-                          : $contains($m,"v1")
-                            ? (
-                                $contains($m,"pro")
-                                  ? ($contains($m,"10s") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                                  : ($contains($m,"10s") ? {"type":"usd","usd":0.28} : {"type":"usd","usd":0.14})
-                              )
-                            : {"type":"usd","usd":0.14}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -845,16 +818,6 @@ class OmniProTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "resolution"]),
-                expr="""
-                (
-                  $mode := (widgets.resolution = "720p") ? "std" : "pro";
-                  $rates := {"std": 0.084, "pro": 0.112};
-                  {"type":"usd","usd": $lookup($rates, $mode) * widgets.duration}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -923,16 +886,6 @@ class OmniProFirstLastFrameNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "resolution"]),
-                expr="""
-                (
-                  $mode := (widgets.resolution = "720p") ? "std" : "pro";
-                  $rates := {"std": 0.084, "pro": 0.112};
-                  {"type":"usd","usd": $lookup($rates, $mode) * widgets.duration}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1028,16 +981,6 @@ class OmniProImageToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "resolution"]),
-                expr="""
-                (
-                  $mode := (widgets.resolution = "720p") ? "std" : "pro";
-                  $rates := {"std": 0.084, "pro": 0.112};
-                  {"type":"usd","usd": $lookup($rates, $mode) * widgets.duration}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1113,16 +1056,6 @@ class OmniProVideoToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "resolution"]),
-                expr="""
-                (
-                  $mode := (widgets.resolution = "720p") ? "std" : "pro";
-                  $rates := {"std": 0.126, "pro": 0.168};
-                  {"type":"usd","usd": $lookup($rates, $mode) * widgets.duration}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1209,16 +1142,6 @@ class OmniProEditVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["resolution"]),
-                expr="""
-                (
-                  $mode := (widgets.resolution = "720p") ? "std" : "pro";
-                  $rates := {"std": 0.126, "pro": 0.168};
-                  {"type":"usd","usd": $lookup($rates, $mode), "format":{"suffix":"/second"}}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1305,9 +1228,6 @@ class OmniProImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.028}""",
-            ),
         )
 
     @classmethod
@@ -1393,9 +1313,6 @@ class KlingCameraControlT2VNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.14}""",
-            ),
         )
 
     @classmethod
@@ -1458,33 +1375,6 @@ class KlingImage2VideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode", "model_name", "duration"]),
-                expr="""
-                (
-                  $mode := widgets.mode;
-                  $model := widgets.model_name;
-                  $dur := widgets.duration;
-                  $contains($model,"v2-5-turbo")
-                    ? ($contains($dur,"10") ? {"type":"usd","usd":0.7} : {"type":"usd","usd":0.35})
-                    : ($contains($model,"v2-1-master") or $contains($model,"v2-master"))
-                      ? ($contains($dur,"10") ? {"type":"usd","usd":2.8} : {"type":"usd","usd":1.4})
-                      : ($contains($model,"v2-1") or $contains($model,"v1-6") or $contains($model,"v1-5"))
-                        ? (
-                            $contains($mode,"pro")
-                              ? ($contains($dur,"10") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                              : ($contains($dur,"10") ? {"type":"usd","usd":0.56} : {"type":"usd","usd":0.28})
-                          )
-                        : $contains($model,"v1")
-                          ? (
-                              $contains($mode,"pro")
-                                ? ($contains($dur,"10") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                                : ($contains($dur,"10") ? {"type":"usd","usd":0.28} : {"type":"usd","usd":0.14})
-                            )
-                          : {"type":"usd","usd":0.14}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1558,9 +1448,6 @@ class KlingCameraControlI2VNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.49}""",
-            ),
         )
 
     @classmethod
@@ -1631,33 +1518,6 @@ class KlingStartEndFrameNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode"]),
-                expr="""
-                (
-                  $m := widgets.mode;
-                  $contains($m,"v2-5-turbo")
-                    ? ($contains($m,"10") ? {"type":"usd","usd":0.7} : {"type":"usd","usd":0.35})
-                    : $contains($m,"v2-1")
-                      ? ($contains($m,"10s") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                      : $contains($m,"v2-master")
-                        ? ($contains($m,"10s") ? {"type":"usd","usd":2.8} : {"type":"usd","usd":1.4})
-                        : $contains($m,"v1-6")
-                          ? (
-                              $contains($m,"pro")
-                                ? ($contains($m,"10s") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                                : ($contains($m,"10s") ? {"type":"usd","usd":0.56} : {"type":"usd","usd":0.28})
-                            )
-                          : $contains($m,"v1")
-                            ? (
-                                $contains($m,"pro")
-                                  ? ($contains($m,"10s") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                                  : ($contains($m,"10s") ? {"type":"usd","usd":0.28} : {"type":"usd","usd":0.14})
-                              )
-                            : {"type":"usd","usd":0.14}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1723,9 +1583,6 @@ class KlingVideoExtendNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.28}""",
-            ),
         )
 
     @classmethod
@@ -1807,29 +1664,6 @@ class KlingDualCharacterVideoEffectNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode", "model_name", "duration"]),
-                expr="""
-                (
-                  $mode := widgets.mode;
-                  $model := widgets.model_name;
-                  $dur := widgets.duration;
-                  ($contains($model,"v1-6") or $contains($model,"v1-5"))
-                    ? (
-                        $contains($mode,"pro")
-                          ? ($contains($dur,"10") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                          : ($contains($dur,"10") ? {"type":"usd","usd":0.56} : {"type":"usd","usd":0.28})
-                      )
-                    : $contains($model,"v1")
-                      ? (
-                          $contains($mode,"pro")
-                            ? ($contains($dur,"10") ? {"type":"usd","usd":0.98} : {"type":"usd","usd":0.49})
-                            : ($contains($dur,"10") ? {"type":"usd","usd":0.28} : {"type":"usd","usd":0.14})
-                        )
-                      : {"type":"usd","usd":0.14}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1894,16 +1728,6 @@ class KlingSingleImageVideoEffectNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["effect_scene"]),
-                expr="""
-                (
-                  ($contains(widgets.effect_scene,"dizzydizzy") or $contains(widgets.effect_scene,"bloombloom"))
-                    ? {"type":"usd","usd":0.49}
-                    : {"type":"usd","usd":0.28}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -1958,9 +1782,6 @@ class KlingLipSyncAudioToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.1,"format":{"approximate":true}}""",
-            ),
         )
 
     @classmethod
@@ -2021,9 +1842,6 @@ class KlingLipSyncTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.1,"format":{"approximate":true}}""",
-            ),
         )
 
     @classmethod
@@ -2074,9 +1892,6 @@ class KlingVirtualTryOnNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.7}""",
-            ),
         )
 
     @classmethod
@@ -2176,19 +1991,6 @@ class KlingImageGenerationNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model_name", "n"], inputs=["image"]),
-                expr="""
-                (
-                  $m := widgets.model_name;
-                  $base :=
-                    $contains($m,"kling-v1-5")
-                      ? (inputs.image.connected ? 0.028 : 0.014)
-                      : ($contains($m,"kling-v1") ? 0.0035 : 0.014);
-                  {"type":"usd","usd": $base * widgets.n}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -2272,10 +2074,6 @@ class TextToVideoWithAudio(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "generate_audio"]),
-                expr="""{"type":"usd","usd": 0.07 * widgets.duration * (widgets.generate_audio ? 2 : 1)}""",
-            ),
         )
 
     @classmethod
@@ -2340,10 +2138,6 @@ class ImageToVideoWithAudio(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration", "generate_audio"]),
-                expr="""{"type":"usd","usd": 0.07 * widgets.duration * (widgets.generate_audio ? 2 : 1)}""",
-            ),
         )
 
     @classmethod
@@ -2424,15 +2218,6 @@ class MotionControl(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode"]),
-                expr="""
-                (
-                  $prices := {"std": 0.07, "pro": 0.112};
-                  {"type":"usd","usd": $lookup($prices, widgets.mode), "format":{"suffix":"/second"}}
-                )
-                """,
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_ltxv.py

@@ -28,22 +28,6 @@ class ExecuteTaskRequest(BaseModel):
     image_uri: str | None = Field(None)
 
 
-PRICE_BADGE = IO.PriceBadge(
-    depends_on=IO.PriceBadgeDepends(widgets=["model", "duration", "resolution"]),
-    expr="""
-    (
-      $prices := {
-        "ltx-2 (pro)": {"1920x1080":0.06,"2560x1440":0.12,"3840x2160":0.24},
-        "ltx-2 (fast)": {"1920x1080":0.04,"2560x1440":0.08,"3840x2160":0.16}
-      };
-      $modelPrices := $lookup($prices, $lowercase(widgets.model));
-      $pps := $lookup($modelPrices, widgets.resolution);
-      {"type":"usd","usd": $pps * widgets.duration}
-    )
-    """,
-)
-
-
 class TextToVideoNode(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -85,7 +69,6 @@ class TextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE,
         )
 
     @classmethod
@@ -162,7 +145,6 @@ class ImageToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE,
         )
 
     @classmethod

comfy_api_nodes/nodes_luma.py

@@ -4,7 +4,7 @@ import torch
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension
-from comfy_api_nodes.apis.luma import (
+from comfy_api_nodes.apis.luma_api import (
     LumaAspectRatio,
     LumaCharacterRef,
     LumaConceptChain,
@@ -189,19 +189,6 @@ class LumaImageGenerationNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $m := widgets.model;
-                  $contains($m,"photon-flash-1")
-                    ? {"type":"usd","usd":0.0027}
-                    : $contains($m,"photon-1")
-                      ? {"type":"usd","usd":0.0104}
-                      : {"type":"usd","usd":0.0246}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -316,19 +303,6 @@ class LumaImageModifyNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $m := widgets.model;
-                  $contains($m,"photon-flash-1")
-                    ? {"type":"usd","usd":0.0027}
-                    : $contains($m,"photon-1")
-                      ? {"type":"usd","usd":0.0104}
-                      : {"type":"usd","usd":0.0246}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -421,7 +395,6 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -532,8 +505,6 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
-
         )
 
     @classmethod
@@ -597,53 +568,6 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
         return LumaKeyframes(frame0=frame0, frame1=frame1)
 
 
-PRICE_BADGE_VIDEO = IO.PriceBadge(
-    depends_on=IO.PriceBadgeDepends(widgets=["model", "resolution", "duration"]),
-    expr="""
-    (
-      $p := {
-        "ray-flash-2": {
-          "5s": {"4k":3.13,"1080p":0.79,"720p":0.34,"540p":0.2},
-          "9s": {"4k":5.65,"1080p":1.42,"720p":0.61,"540p":0.36}
-        },
-        "ray-2": {
-          "5s": {"4k":9.11,"1080p":2.27,"720p":1.02,"540p":0.57},
-          "9s": {"4k":16.4,"1080p":4.1,"720p":1.83,"540p":1.03}
-        }
-      };
-
-      $m := widgets.model;
-      $d := widgets.duration;
-      $r := widgets.resolution;
-
-      $modelKey :=
-        $contains($m,"ray-flash-2") ? "ray-flash-2" :
-        $contains($m,"ray-2") ? "ray-2" :
-        $contains($m,"ray-1-6") ? "ray-1-6" :
-        "other";
-
-      $durKey := $contains($d,"5s") ? "5s" : $contains($d,"9s") ? "9s" : "";
-      $resKey :=
-        $contains($r,"4k") ? "4k" :
-        $contains($r,"1080p") ? "1080p" :
-        $contains($r,"720p") ? "720p" :
-        $contains($r,"540p") ? "540p" : "";
-
-      $modelPrices := $lookup($p, $modelKey);
-      $durPrices := $lookup($modelPrices, $durKey);
-      $v := $lookup($durPrices, $resKey);
-
-      $price :=
-        ($modelKey = "ray-1-6") ? 0.5 :
-        ($modelKey = "other") ? 0.79 :
-        ($exists($v) ? $v : 0.79);
-
-      {"type":"usd","usd": $price}
-    )
-    """,
-)
-
-
 class LumaExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:

comfy_api_nodes/nodes_meshy.py

@@ -1,790 +0,0 @@
-import os
-
-from typing_extensions import override
-
-from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.meshy import (
-    InputShouldRemesh,
-    InputShouldTexture,
-    MeshyAnimationRequest,
-    MeshyAnimationResult,
-    MeshyImageToModelRequest,
-    MeshyModelResult,
-    MeshyMultiImageToModelRequest,
-    MeshyRefineTask,
-    MeshyRiggedResult,
-    MeshyRiggingRequest,
-    MeshyTaskResponse,
-    MeshyTextToModelRequest,
-    MeshyTextureRequest,
-)
-from comfy_api_nodes.util import (
-    ApiEndpoint,
-    download_url_to_bytesio,
-    poll_op,
-    sync_op,
-    upload_images_to_comfyapi,
-    validate_string,
-)
-from folder_paths import get_output_directory
-
-
-class MeshyTextToModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyTextToModelNode",
-            display_name="Meshy: Text to Model",
-            category="api node/3d/Meshy",
-            inputs=[
-                IO.Combo.Input("model", options=["latest"]),
-                IO.String.Input("prompt", multiline=True, default=""),
-                IO.Combo.Input("style", options=["realistic", "sculpture"]),
-                IO.DynamicCombo.Input(
-                    "should_remesh",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Combo.Input("topology", options=["triangle", "quad"]),
-                                IO.Int.Input(
-                                    "target_polycount",
-                                    default=300000,
-                                    min=100,
-                                    max=300000,
-                                    display_mode=IO.NumberDisplay.number,
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="When set to false, returns an unprocessed triangular mesh.",
-                ),
-                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"]),
-                IO.Combo.Input(
-                    "pose_mode",
-                    options=["", "A-pose", "T-pose"],
-                    tooltip="Specify the pose mode for the generated model.",
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=2147483647,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                    tooltip="Seed controls whether the node should re-run; "
-                    "results are non-deterministic regardless of seed.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MESHY_TASK_ID").Output(display_name="meshy_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.8}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        prompt: str,
-        style: str,
-        should_remesh: InputShouldRemesh,
-        symmetry_mode: str,
-        pose_mode: str,
-        seed: int,
-    ) -> IO.NodeOutput:
-        validate_string(prompt, field_name="prompt", min_length=1, max_length=600)
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="/proxy/meshy/openapi/v2/text-to-3d", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyTextToModelRequest(
-                prompt=prompt,
-                art_style=style,
-                ai_model=model,
-                topology=should_remesh.get("topology", None),
-                target_polycount=should_remesh.get("target_polycount", None),
-                should_remesh=should_remesh["should_remesh"] == "true",
-                symmetry_mode=symmetry_mode,
-                pose_mode=pose_mode.lower(),
-                seed=seed,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v2/text-to-3d/{response.result}"),
-            response_model=MeshyModelResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.model_urls.glb, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyRefineNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyRefineNode",
-            display_name="Meshy: Refine Draft Model",
-            category="api node/3d/Meshy",
-            description="Refine a previously created draft model.",
-            inputs=[
-                IO.Combo.Input("model", options=["latest"]),
-                IO.Custom("MESHY_TASK_ID").Input("meshy_task_id"),
-                IO.Boolean.Input(
-                    "enable_pbr",
-                    default=False,
-                    tooltip="Generate PBR Maps (metallic, roughness, normal) in addition to the base color. "
-                    "Note: this should be set to false when using Sculpture style, "
-                    "as Sculpture style generates its own set of PBR maps.",
-                ),
-                IO.String.Input(
-                    "texture_prompt",
-                    default="",
-                    multiline=True,
-                    tooltip="Provide a text prompt to guide the texturing process. "
-                    "Maximum 600 characters. Cannot be used at the same time as 'texture_image'.",
-                ),
-                IO.Image.Input(
-                    "texture_image",
-                    tooltip="Only one of 'texture_image' or 'texture_prompt' may be used at the same time.",
-                    optional=True,
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MESHY_TASK_ID").Output(display_name="meshy_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        meshy_task_id: str,
-        enable_pbr: bool,
-        texture_prompt: str,
-        texture_image: Input.Image | None = None,
-    ) -> IO.NodeOutput:
-        if texture_prompt and texture_image is not None:
-            raise ValueError("texture_prompt and texture_image cannot be used at the same time")
-        texture_image_url = None
-        if texture_prompt:
-            validate_string(texture_prompt, field_name="texture_prompt", max_length=600)
-        if texture_image is not None:
-            texture_image_url = (await upload_images_to_comfyapi(cls, texture_image, wait_label="Uploading texture"))[0]
-        response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path="/proxy/meshy/openapi/v2/text-to-3d", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyRefineTask(
-                preview_task_id=meshy_task_id,
-                enable_pbr=enable_pbr,
-                texture_prompt=texture_prompt if texture_prompt else None,
-                texture_image_url=texture_image_url,
-                ai_model=model,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v2/text-to-3d/{response.result}"),
-            response_model=MeshyModelResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.model_urls.glb, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyImageToModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyImageToModelNode",
-            display_name="Meshy: Image to Model",
-            category="api node/3d/Meshy",
-            inputs=[
-                IO.Combo.Input("model", options=["latest"]),
-                IO.Image.Input("image"),
-                IO.DynamicCombo.Input(
-                    "should_remesh",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Combo.Input("topology", options=["triangle", "quad"]),
-                                IO.Int.Input(
-                                    "target_polycount",
-                                    default=300000,
-                                    min=100,
-                                    max=300000,
-                                    display_mode=IO.NumberDisplay.number,
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="When set to false, returns an unprocessed triangular mesh.",
-                ),
-                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"]),
-                IO.DynamicCombo.Input(
-                    "should_texture",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Boolean.Input(
-                                    "enable_pbr",
-                                    default=False,
-                                    tooltip="Generate PBR Maps (metallic, roughness, normal) "
-                                    "in addition to the base color.",
-                                ),
-                                IO.String.Input(
-                                    "texture_prompt",
-                                    default="",
-                                    multiline=True,
-                                    tooltip="Provide a text prompt to guide the texturing process. "
-                                    "Maximum 600 characters. Cannot be used at the same time as 'texture_image'.",
-                                ),
-                                IO.Image.Input(
-                                    "texture_image",
-                                    tooltip="Only one of 'texture_image' or 'texture_prompt' "
-                                    "may be used at the same time.",
-                                    optional=True,
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="Determines whether textures are generated. "
-                    "Setting it to false skips the texture phase and returns a mesh without textures.",
-                ),
-                IO.Combo.Input(
-                    "pose_mode",
-                    options=["", "A-pose", "T-pose"],
-                    tooltip="Specify the pose mode for the generated model.",
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=2147483647,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                    tooltip="Seed controls whether the node should re-run; "
-                    "results are non-deterministic regardless of seed.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MESHY_TASK_ID").Output(display_name="meshy_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["should_texture"]),
-                expr="""
-                (
-                  $prices := {"true": 1.2, "false": 0.8};
-                  {"type":"usd","usd": $lookup($prices, widgets.should_texture)}
-                )
-                """,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        image: Input.Image,
-        should_remesh: InputShouldRemesh,
-        symmetry_mode: str,
-        should_texture: InputShouldTexture,
-        pose_mode: str,
-        seed: int,
-    ) -> IO.NodeOutput:
-        texture = should_texture["should_texture"] == "true"
-        texture_image_url = texture_prompt = None
-        if texture:
-            if should_texture["texture_prompt"] and should_texture["texture_image"] is not None:
-                raise ValueError("texture_prompt and texture_image cannot be used at the same time")
-            if should_texture["texture_prompt"]:
-                validate_string(should_texture["texture_prompt"], field_name="texture_prompt", max_length=600)
-                texture_prompt = should_texture["texture_prompt"]
-            if should_texture["texture_image"] is not None:
-                texture_image_url = (
-                    await upload_images_to_comfyapi(
-                        cls, should_texture["texture_image"], wait_label="Uploading texture"
-                    )
-                )[0]
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="/proxy/meshy/openapi/v1/image-to-3d", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyImageToModelRequest(
-                image_url=(await upload_images_to_comfyapi(cls, image, wait_label="Uploading base image"))[0],
-                ai_model=model,
-                topology=should_remesh.get("topology", None),
-                target_polycount=should_remesh.get("target_polycount", None),
-                symmetry_mode=symmetry_mode,
-                should_remesh=should_remesh["should_remesh"] == "true",
-                should_texture=texture,
-                enable_pbr=should_texture.get("enable_pbr", None),
-                pose_mode=pose_mode.lower(),
-                texture_prompt=texture_prompt,
-                texture_image_url=texture_image_url,
-                seed=seed,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v1/image-to-3d/{response.result}"),
-            response_model=MeshyModelResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.model_urls.glb, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyMultiImageToModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyMultiImageToModelNode",
-            display_name="Meshy: Multi-Image to Model",
-            category="api node/3d/Meshy",
-            inputs=[
-                IO.Combo.Input("model", options=["latest"]),
-                IO.Autogrow.Input(
-                    "images",
-                    template=IO.Autogrow.TemplatePrefix(IO.Image.Input("image"), prefix="image", min=2, max=4),
-                ),
-                IO.DynamicCombo.Input(
-                    "should_remesh",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Combo.Input("topology", options=["triangle", "quad"]),
-                                IO.Int.Input(
-                                    "target_polycount",
-                                    default=300000,
-                                    min=100,
-                                    max=300000,
-                                    display_mode=IO.NumberDisplay.number,
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="When set to false, returns an unprocessed triangular mesh.",
-                ),
-                IO.Combo.Input("symmetry_mode", options=["auto", "on", "off"]),
-                IO.DynamicCombo.Input(
-                    "should_texture",
-                    options=[
-                        IO.DynamicCombo.Option(
-                            "true",
-                            [
-                                IO.Boolean.Input(
-                                    "enable_pbr",
-                                    default=False,
-                                    tooltip="Generate PBR Maps (metallic, roughness, normal) "
-                                    "in addition to the base color.",
-                                ),
-                                IO.String.Input(
-                                    "texture_prompt",
-                                    default="",
-                                    multiline=True,
-                                    tooltip="Provide a text prompt to guide the texturing process. "
-                                    "Maximum 600 characters. Cannot be used at the same time as 'texture_image'.",
-                                ),
-                                IO.Image.Input(
-                                    "texture_image",
-                                    tooltip="Only one of 'texture_image' or 'texture_prompt' "
-                                    "may be used at the same time.",
-                                    optional=True,
-                                ),
-                            ],
-                        ),
-                        IO.DynamicCombo.Option("false", []),
-                    ],
-                    tooltip="Determines whether textures are generated. "
-                    "Setting it to false skips the texture phase and returns a mesh without textures.",
-                ),
-                IO.Combo.Input(
-                    "pose_mode",
-                    options=["", "A-pose", "T-pose"],
-                    tooltip="Specify the pose mode for the generated model.",
-                ),
-                IO.Int.Input(
-                    "seed",
-                    default=0,
-                    min=0,
-                    max=2147483647,
-                    display_mode=IO.NumberDisplay.number,
-                    control_after_generate=True,
-                    tooltip="Seed controls whether the node should re-run; "
-                    "results are non-deterministic regardless of seed.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MESHY_TASK_ID").Output(display_name="meshy_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["should_texture"]),
-                expr="""
-                (
-                  $prices := {"true": 0.6, "false": 0.2};
-                  {"type":"usd","usd": $lookup($prices, widgets.should_texture)}
-                )
-                """,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        images: IO.Autogrow.Type,
-        should_remesh: InputShouldRemesh,
-        symmetry_mode: str,
-        should_texture: InputShouldTexture,
-        pose_mode: str,
-        seed: int,
-    ) -> IO.NodeOutput:
-        texture = should_texture["should_texture"] == "true"
-        texture_image_url = texture_prompt = None
-        if texture:
-            if should_texture["texture_prompt"] and should_texture["texture_image"] is not None:
-                raise ValueError("texture_prompt and texture_image cannot be used at the same time")
-            if should_texture["texture_prompt"]:
-                validate_string(should_texture["texture_prompt"], field_name="texture_prompt", max_length=600)
-                texture_prompt = should_texture["texture_prompt"]
-            if should_texture["texture_image"] is not None:
-                texture_image_url = (
-                    await upload_images_to_comfyapi(
-                        cls, should_texture["texture_image"], wait_label="Uploading texture"
-                    )
-                )[0]
-        response = await sync_op(
-            cls,
-            ApiEndpoint(path="/proxy/meshy/openapi/v1/multi-image-to-3d", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyMultiImageToModelRequest(
-                image_urls=await upload_images_to_comfyapi(
-                    cls, list(images.values()), wait_label="Uploading base images"
-                ),
-                ai_model=model,
-                topology=should_remesh.get("topology", None),
-                target_polycount=should_remesh.get("target_polycount", None),
-                symmetry_mode=symmetry_mode,
-                should_remesh=should_remesh["should_remesh"] == "true",
-                should_texture=texture,
-                enable_pbr=should_texture.get("enable_pbr", None),
-                pose_mode=pose_mode.lower(),
-                texture_prompt=texture_prompt,
-                texture_image_url=texture_image_url,
-                seed=seed,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v1/multi-image-to-3d/{response.result}"),
-            response_model=MeshyModelResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.model_urls.glb, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyRigModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyRigModelNode",
-            display_name="Meshy: Rig Model",
-            category="api node/3d/Meshy",
-            description="Provides a rigged character in standard formats. "
-            "Auto-rigging is currently not suitable for untextured meshes, non-humanoid assets, "
-            "or humanoid assets with unclear limb and body structure.",
-            inputs=[
-                IO.Custom("MESHY_TASK_ID").Input("meshy_task_id"),
-                IO.Float.Input(
-                    "height_meters",
-                    min=0.1,
-                    max=15.0,
-                    default=1.7,
-                    tooltip="The approximate height of the character model in meters. "
-                    "This aids in scaling and rigging accuracy.",
-                ),
-                IO.Image.Input(
-                    "texture_image",
-                    tooltip="The model's UV-unwrapped base color texture image.",
-                    optional=True,
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MESHY_RIGGED_TASK_ID").Output(display_name="rig_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.2}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        meshy_task_id: str,
-        height_meters: float,
-        texture_image: Input.Image | None = None,
-    ) -> IO.NodeOutput:
-        texture_image_url = None
-        if texture_image is not None:
-            texture_image_url = (await upload_images_to_comfyapi(cls, texture_image, wait_label="Uploading texture"))[0]
-        response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path="/proxy/meshy/openapi/v1/rigging", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyRiggingRequest(
-                input_task_id=meshy_task_id,
-                height_meters=height_meters,
-                texture_image_url=texture_image_url,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v1/rigging/{response.result}"),
-            response_model=MeshyRiggedResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(
-            result.result.rigged_character_glb_url, os.path.join(get_output_directory(), model_file)
-        )
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyAnimateModelNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyAnimateModelNode",
-            display_name="Meshy: Animate Model",
-            category="api node/3d/Meshy",
-            description="Apply a specific animation action to a previously rigged character.",
-            inputs=[
-                IO.Custom("MESHY_RIGGED_TASK_ID").Input("rig_task_id"),
-                IO.Int.Input(
-                    "action_id",
-                    default=0,
-                    min=0,
-                    max=696,
-                    tooltip="Visit https://docs.meshy.ai/en/api/animation-library for a list of available values.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.12}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        rig_task_id: str,
-        action_id: int,
-    ) -> IO.NodeOutput:
-        response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path="/proxy/meshy/openapi/v1/animations", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyAnimationRequest(
-                rig_task_id=rig_task_id,
-                action_id=action_id,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v1/animations/{response.result}"),
-            response_model=MeshyAnimationResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.result.animation_glb_url, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyTextureNode(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="MeshyTextureNode",
-            display_name="Meshy: Texture Model",
-            category="api node/3d/Meshy",
-            inputs=[
-                IO.Combo.Input("model", options=["latest"]),
-                IO.Custom("MESHY_TASK_ID").Input("meshy_task_id"),
-                IO.Boolean.Input(
-                    "enable_original_uv",
-                    default=True,
-                    tooltip="Use the original UV of the model instead of generating new UVs. "
-                    "When enabled, Meshy preserves existing textures from the uploaded model. "
-                    "If the model has no original UV, the quality of the output might not be as good.",
-                ),
-                IO.Boolean.Input("pbr", default=False),
-                IO.String.Input(
-                    "text_style_prompt",
-                    default="",
-                    multiline=True,
-                    tooltip="Describe your desired texture style of the object using text. Maximum 600 characters."
-                    "Maximum 600 characters. Cannot be used at the same time as 'image_style'.",
-                ),
-                IO.Image.Input(
-                    "image_style",
-                    optional=True,
-                    tooltip="A 2d image to guide the texturing process. "
-                    "Can not be used at the same time with 'text_style_prompt'.",
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="model_file"),
-                IO.Custom("MODEL_TASK_ID").Output(display_name="meshy_task_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            is_output_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        model: str,
-        meshy_task_id: str,
-        enable_original_uv: bool,
-        pbr: bool,
-        text_style_prompt: str,
-        image_style: Input.Image | None = None,
-    ) -> IO.NodeOutput:
-        if text_style_prompt and image_style is not None:
-            raise ValueError("text_style_prompt and image_style cannot be used at the same time")
-        if not text_style_prompt and image_style is None:
-            raise ValueError("Either text_style_prompt or image_style is required")
-        image_style_url = None
-        if image_style is not None:
-            image_style_url = (await upload_images_to_comfyapi(cls, image_style, wait_label="Uploading style"))[0]
-        response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path="/proxy/meshy/openapi/v1/retexture", method="POST"),
-            response_model=MeshyTaskResponse,
-            data=MeshyTextureRequest(
-                input_task_id=meshy_task_id,
-                ai_model=model,
-                enable_original_uv=enable_original_uv,
-                enable_pbr=pbr,
-                text_style_prompt=text_style_prompt if text_style_prompt else None,
-                image_style_url=image_style_url,
-            ),
-        )
-        result = await poll_op(
-            cls,
-            ApiEndpoint(path=f"/proxy/meshy/openapi/v1/retexture/{response.result}"),
-            response_model=MeshyModelResult,
-            status_extractor=lambda r: r.status,
-            progress_extractor=lambda r: r.progress,
-        )
-        model_file = f"meshy_model_{response.result}.glb"
-        await download_url_to_bytesio(result.model_urls.glb, os.path.join(get_output_directory(), model_file))
-        return IO.NodeOutput(model_file, response.result)
-
-
-class MeshyExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
-        return [
-            MeshyTextToModelNode,
-            MeshyRefineNode,
-            MeshyImageToModelNode,
-            MeshyMultiImageToModelNode,
-            MeshyRigModelNode,
-            MeshyAnimateModelNode,
-            MeshyTextureNode,
-        ]
-
-
-async def comfy_entrypoint() -> MeshyExtension:
-    return MeshyExtension()

comfy_api_nodes/nodes_minimax.py

@@ -4,7 +4,7 @@ import torch
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension
-from comfy_api_nodes.apis.minimax import (
+from comfy_api_nodes.apis.minimax_api import (
     MinimaxFileRetrieveResponse,
     MiniMaxModel,
     MinimaxTaskResultResponse,
@@ -134,9 +134,6 @@ class MinimaxTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.43}""",
-            ),
         )
 
     @classmethod
@@ -200,9 +197,6 @@ class MinimaxImageToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.43}""",
-            ),
         )
 
     @classmethod
@@ -346,20 +340,6 @@ class MinimaxHailuoVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["resolution", "duration"]),
-                expr="""
-                (
-                  $prices := {
-                    "768p": {"6": 0.28, "10": 0.56},
-                    "1080p": {"6": 0.49}
-                  };
-                  $resPrices := $lookup($prices, $lowercase(widgets.resolution));
-                  $price := $lookup($resPrices, $string(widgets.duration));
-                  {"type":"usd","usd": $price ? $price : 0.43}
-                )
-                """,
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_moonvalley.py

@@ -3,7 +3,7 @@ import logging
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.moonvalley import (
+from comfy_api_nodes.apis import (
     MoonvalleyPromptResponse,
     MoonvalleyTextToVideoInferenceParams,
     MoonvalleyTextToVideoRequest,
@@ -233,10 +233,6 @@ class MoonvalleyImg2VideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(),
-                expr="""{"type":"usd","usd": 1.5}""",
-            ),
         )
 
     @classmethod
@@ -355,10 +351,6 @@ class MoonvalleyVideo2VideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(),
-                expr="""{"type":"usd","usd": 2.25}""",
-            ),
         )
 
     @classmethod
@@ -479,10 +471,6 @@ class MoonvalleyTxt2VideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(),
-                expr="""{"type":"usd","usd": 1.5}""",
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_openai.py

@@ -10,18 +10,24 @@ from typing_extensions import override
 
 import folder_paths
 from comfy_api.latest import IO, ComfyExtension, Input
-from comfy_api_nodes.apis.openai import (
+from comfy_api_nodes.apis import (
+    CreateModelResponseProperties,
+    Detail,
+    InputContent,
     InputFileContent,
     InputImageContent,
     InputMessage,
+    InputMessageContentList,
     InputTextContent,
-    ModelResponseProperties,
+    Item,
     OpenAICreateResponse,
+    OpenAIResponse,
+    OutputContent,
+)
+from comfy_api_nodes.apis.openai_api import (
     OpenAIImageEditRequest,
     OpenAIImageGenerationRequest,
     OpenAIImageGenerationResponse,
-    OpenAIResponse,
-    OutputContent,
 )
 from comfy_api_nodes.util import (
     ApiEndpoint,
@@ -154,23 +160,6 @@ class OpenAIDalle2(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["size", "n"]),
-                expr="""
-                (
-                  $size := widgets.size;
-                  $nRaw := widgets.n;
-                  $n := ($nRaw != null and $nRaw != 0) ? $nRaw : 1;
-
-                  $base :=
-                    $contains($size, "256x256") ? 0.016 :
-                    $contains($size, "512x512") ? 0.018 :
-                    0.02;
-
-                  {"type":"usd","usd": $round($base * $n, 3)}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -260,7 +249,7 @@ class OpenAIDalle3(IO.ComfyNode):
                     "seed",
                     default=0,
                     min=0,
-                    max=2**31 - 1,
+                    max=2 ** 31 - 1,
                     step=1,
                     display_mode=IO.NumberDisplay.number,
                     control_after_generate=True,
@@ -298,25 +287,6 @@ class OpenAIDalle3(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["size", "quality"]),
-                expr="""
-                (
-                  $size := widgets.size;
-                  $q := widgets.quality;
-                  $hd := $contains($q, "hd");
-
-                  $price :=
-                    $contains($size, "1024x1024")
-                      ? ($hd ? 0.08 : 0.04)
-                      : (($contains($size, "1792x1024") or $contains($size, "1024x1792"))
-                          ? ($hd ? 0.12 : 0.08)
-                          : 0.04);
-
-                  {"type":"usd","usd": $price}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -364,9 +334,9 @@ class OpenAIGPTImage1(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="OpenAIGPTImage1",
-            display_name="OpenAI GPT Image 1.5",
+            display_name="OpenAI GPT Image 1",
             category="api node/image/OpenAI",
-            description="Generates images synchronously via OpenAI's GPT Image endpoint.",
+            description="Generates images synchronously via OpenAI's GPT Image 1 endpoint.",
             inputs=[
                 IO.String.Input(
                     "prompt",
@@ -378,7 +348,7 @@ class OpenAIGPTImage1(IO.ComfyNode):
                     "seed",
                     default=0,
                     min=0,
-                    max=2**31 - 1,
+                    max=2 ** 31 - 1,
                     step=1,
                     display_mode=IO.NumberDisplay.number,
                     control_after_generate=True,
@@ -429,7 +399,6 @@ class OpenAIGPTImage1(IO.ComfyNode):
                 IO.Combo.Input(
                     "model",
                     options=["gpt-image-1", "gpt-image-1.5"],
-                    default="gpt-image-1.5",
                     optional=True,
                 ),
             ],
@@ -442,28 +411,6 @@ class OpenAIGPTImage1(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["quality", "n"]),
-                expr="""
-                (
-                  $ranges := {
-                    "low":    [0.011, 0.02],
-                    "medium": [0.046, 0.07],
-                    "high":   [0.167, 0.3]
-                  };
-                  $range := $lookup($ranges, widgets.quality);
-                  $n := widgets.n;
-                  ($n = 1)
-                    ? {"type":"range_usd","min_usd": $range[0], "max_usd": $range[1]}
-                    : {
-                        "type":"range_usd",
-                        "min_usd": $range[0],
-                        "max_usd": $range[1],
-                        "format": { "suffix": " x " & $string($n) & "/Run" }
-                      }
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -495,8 +442,8 @@ class OpenAIGPTImage1(IO.ComfyNode):
             files = []
             batch_size = image.shape[0]
             for i in range(batch_size):
-                single_image = image[i : i + 1]
-                scaled_image = downscale_image_tensor(single_image, total_pixels=2048 * 2048).squeeze()
+                single_image = image[i: i + 1]
+                scaled_image = downscale_image_tensor(single_image, total_pixels=2048*2048).squeeze()
 
                 image_np = (scaled_image.numpy() * 255).astype(np.uint8)
                 img = Image.fromarray(image_np)
@@ -518,7 +465,7 @@ class OpenAIGPTImage1(IO.ComfyNode):
                 rgba_mask = torch.zeros(height, width, 4, device="cpu")
                 rgba_mask[:, :, 3] = 1 - mask.squeeze().cpu()
 
-                scaled_mask = downscale_image_tensor(rgba_mask.unsqueeze(0), total_pixels=2048 * 2048).squeeze()
+                scaled_mask = downscale_image_tensor(rgba_mask.unsqueeze(0), total_pixels=2048*2048).squeeze()
 
                 mask_np = (scaled_mask.numpy() * 255).astype(np.uint8)
                 mask_img = Image.fromarray(mask_np)
@@ -619,95 +566,32 @@ class OpenAIChatNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $m := widgets.model;
-                  $contains($m, "o4-mini") ? {
-                    "type": "list_usd",
-                    "usd": [0.0011, 0.0044],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "o1-pro") ? {
-                    "type": "list_usd",
-                    "usd": [0.15, 0.6],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "o1") ? {
-                    "type": "list_usd",
-                    "usd": [0.015, 0.06],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "o3-mini") ? {
-                    "type": "list_usd",
-                    "usd": [0.0011, 0.0044],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "o3") ? {
-                    "type": "list_usd",
-                    "usd": [0.01, 0.04],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-4o") ? {
-                    "type": "list_usd",
-                    "usd": [0.0025, 0.01],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-4.1-nano") ? {
-                    "type": "list_usd",
-                    "usd": [0.0001, 0.0004],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-4.1-mini") ? {
-                    "type": "list_usd",
-                    "usd": [0.0004, 0.0016],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-4.1") ? {
-                    "type": "list_usd",
-                    "usd": [0.002, 0.008],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-5-nano") ? {
-                    "type": "list_usd",
-                    "usd": [0.00005, 0.0004],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-5-mini") ? {
-                    "type": "list_usd",
-                    "usd": [0.00025, 0.002],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : $contains($m, "gpt-5") ? {
-                    "type": "list_usd",
-                    "usd": [0.00125, 0.01],
-                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
-                  }
-                  : {"type": "text", "text": "Token-based"}
-                )
-                """,
-            ),
         )
 
     @classmethod
-    def get_message_content_from_response(cls, response: OpenAIResponse) -> list[OutputContent]:
+    def get_message_content_from_response(
+        cls, response: OpenAIResponse
+    ) -> list[OutputContent]:
         """Extract message content from the API response."""
         for output in response.output:
-            if output.type == "message":
-                return output.content
+            if output.root.type == "message":
+                return output.root.content
         raise TypeError("No output message found in response")
 
     @classmethod
-    def get_text_from_message_content(cls, message_content: list[OutputContent]) -> str:
+    def get_text_from_message_content(
+        cls, message_content: list[OutputContent]
+    ) -> str:
         """Extract text content from message content."""
         for content_item in message_content:
-            if content_item.type == "output_text":
-                return str(content_item.text)
+            if content_item.root.type == "output_text":
+                return str(content_item.root.text)
         return "No text output found in response"
 
     @classmethod
-    def tensor_to_input_image_content(cls, image: torch.Tensor, detail_level: str = "auto") -> InputImageContent:
+    def tensor_to_input_image_content(
+        cls, image: torch.Tensor, detail_level: Detail = "auto"
+    ) -> InputImageContent:
         """Convert a tensor to an input image content object."""
         return InputImageContent(
             detail=detail_level,
@@ -721,9 +605,9 @@ class OpenAIChatNode(IO.ComfyNode):
         prompt: str,
         image: torch.Tensor | None = None,
         files: list[InputFileContent] | None = None,
-    ) -> list[InputTextContent | InputImageContent | InputFileContent]:
+    ) -> InputMessageContentList:
         """Create a list of input message contents from prompt and optional image."""
-        content_list: list[InputTextContent | InputImageContent | InputFileContent] = [
+        content_list: list[InputContent | InputTextContent | InputImageContent | InputFileContent] = [
             InputTextContent(text=prompt, type="input_text"),
         ]
         if image is not None:
@@ -735,9 +619,13 @@ class OpenAIChatNode(IO.ComfyNode):
                         type="input_image",
                     )
                 )
+
         if files is not None:
             content_list.extend(files)
-        return content_list
+
+        return InputMessageContentList(
+            root=content_list,
+        )
 
     @classmethod
     async def execute(
@@ -747,7 +635,7 @@ class OpenAIChatNode(IO.ComfyNode):
         model: SupportedOpenAIModel = SupportedOpenAIModel.gpt_5.value,
         images: torch.Tensor | None = None,
         files: list[InputFileContent] | None = None,
-        advanced_options: ModelResponseProperties | None = None,
+        advanced_options: CreateModelResponseProperties | None = None,
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=False)
 
@@ -758,16 +646,24 @@ class OpenAIChatNode(IO.ComfyNode):
             response_model=OpenAIResponse,
             data=OpenAICreateResponse(
                 input=[
-                    InputMessage(
-                        content=cls.create_input_message_contents(prompt, images, files),
+                    Item(
+                        root=InputMessage(
+                            content=cls.create_input_message_contents(
+                                prompt, images, files
+                            ),
                             role="user",
+                        )
                     ),
                 ],
                 store=True,
                 stream=False,
                 model=model,
                 previous_response_id=None,
-                **(advanced_options.model_dump(exclude_none=True) if advanced_options else {}),
+                **(
+                    advanced_options.model_dump(exclude_none=True)
+                    if advanced_options
+                    else {}
+                ),
             ),
         )
         response_id = create_response.id
@@ -778,7 +674,7 @@ class OpenAIChatNode(IO.ComfyNode):
                 ApiEndpoint(path=f"{RESPONSES_ENDPOINT}/{response_id}"),
                 response_model=OpenAIResponse,
                 status_extractor=lambda response: response.status,
-            completed_statuses=["incomplete", "completed"],
+                completed_statuses=["incomplete", "completed"]
             )
         return IO.NodeOutput(cls.get_text_from_message_content(cls.get_message_content_from_response(result_response)))
 
@@ -900,7 +796,7 @@ class OpenAIChatConfig(IO.ComfyNode):
             remove depending on model choice.
         """
         return IO.NodeOutput(
-            ModelResponseProperties(
+            CreateModelResponseProperties(
                 instructions=instructions,
                 truncation=truncation,
                 max_output_tokens=max_output_tokens,

comfy_api_nodes/nodes_pixverse.py

@@ -1,7 +1,7 @@
 import torch
 from typing_extensions import override
 from comfy_api.latest import IO, ComfyExtension
-from comfy_api_nodes.apis.pixverse import (
+from comfy_api_nodes.apis.pixverse_api import (
     PixverseTextVideoRequest,
     PixverseImageVideoRequest,
     PixverseTransitionVideoRequest,
@@ -128,7 +128,6 @@ class PixverseTextToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -243,7 +242,6 @@ class PixverseImageToVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -357,7 +355,6 @@ class PixverseTransitionVideoNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=PRICE_BADGE_VIDEO,
         )
 
     @classmethod
@@ -419,33 +416,6 @@ class PixverseTransitionVideoNode(IO.ComfyNode):
         return IO.NodeOutput(await download_url_to_video_output(response_poll.Resp.url))
 
 
-PRICE_BADGE_VIDEO = IO.PriceBadge(
-    depends_on=IO.PriceBadgeDepends(widgets=["duration_seconds", "quality", "motion_mode"]),
-    expr="""
-    (
-      $prices := {
-        "5": {
-          "1080p": {"normal": 1.2, "fast": 1.2},
-          "720p": {"normal": 0.6, "fast": 1.2},
-          "540p": {"normal": 0.45, "fast": 0.9},
-          "360p": {"normal": 0.45, "fast": 0.9}
-        },
-        "8": {
-          "1080p": {"normal": 1.2, "fast": 1.2},
-          "720p": {"normal": 1.2, "fast": 1.2},
-          "540p": {"normal": 0.9, "fast": 1.2},
-          "360p": {"normal": 0.9, "fast": 1.2}
-        }
-      };
-      $durPrices := $lookup($prices, $string(widgets.duration_seconds));
-      $qualityPrices := $lookup($durPrices, widgets.quality);
-      $price := $lookup($qualityPrices, widgets.motion_mode);
-      {"type":"usd","usd": $price ? $price : 0.9}
-    )
-    """,
-)
-
-
 class PixVerseExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:

comfy_api_nodes/nodes_recraft.py

@@ -8,7 +8,7 @@ from typing_extensions import override
 
 from comfy.utils import ProgressBar
 from comfy_api.latest import IO, ComfyExtension
-from comfy_api_nodes.apis.recraft import (
+from comfy_api_nodes.apis.recraft_api import (
     RecraftColor,
     RecraftColorChain,
     RecraftControls,
@@ -378,10 +378,6 @@ class RecraftTextToImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["n"]),
-                expr="""{"type":"usd","usd": $round(0.04 * widgets.n, 2)}""",
-            ),
         )
 
     @classmethod
@@ -494,10 +490,6 @@ class RecraftImageToImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["n"]),
-                expr="""{"type":"usd","usd": $round(0.04 * widgets.n, 2)}""",
-            ),
         )
 
     @classmethod
@@ -599,10 +591,6 @@ class RecraftImageInpaintingNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["n"]),
-                expr="""{"type":"usd","usd": $round(0.04 * widgets.n, 2)}""",
-            ),
         )
 
     @classmethod
@@ -704,10 +692,6 @@ class RecraftTextToVectorNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["n"]),
-                expr="""{"type":"usd","usd": $round(0.08 * widgets.n, 2)}""",
-            ),
         )
 
     @classmethod
@@ -775,10 +759,6 @@ class RecraftVectorizeImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(),
-                expr="""{"type":"usd","usd": 0.01}""",
-            ),
         )
 
     @classmethod
@@ -837,9 +817,6 @@ class RecraftReplaceBackgroundNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.04}""",
-            ),
         )
 
     @classmethod
@@ -906,9 +883,6 @@ class RecraftRemoveBackgroundNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.01}""",
-            ),
         )
 
     @classmethod
@@ -955,9 +929,6 @@ class RecraftCrispUpscaleNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.004}""",
-            ),
         )
 
     @classmethod
@@ -1001,9 +972,6 @@ class RecraftCreativeUpscaleNode(RecraftCrispUpscaleNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.25}""",
-            ),
         )
 
 

comfy_api_nodes/nodes_rodin.py

@@ -14,7 +14,7 @@ from typing import Optional
 from io import BytesIO
 from typing_extensions import override
 from PIL import Image
-from comfy_api_nodes.apis.rodin import (
+from comfy_api_nodes.apis.rodin_api import (
     Rodin3DGenerateRequest,
     Rodin3DGenerateResponse,
     Rodin3DCheckStatusRequest,
@@ -241,9 +241,6 @@ class Rodin3D_Regular(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
         )
 
     @classmethod
@@ -297,9 +294,6 @@ class Rodin3D_Detail(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
         )
 
     @classmethod
@@ -353,9 +347,6 @@ class Rodin3D_Smooth(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
         )
 
     @classmethod
@@ -415,9 +406,6 @@ class Rodin3D_Sketch(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.4}""",
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_runway.py

@@ -16,7 +16,7 @@ from enum import Enum
 from typing_extensions import override
 
 from comfy_api.latest import IO, ComfyExtension, Input, InputImpl
-from comfy_api_nodes.apis.runway import (
+from comfy_api_nodes.apis import (
     RunwayImageToVideoRequest,
     RunwayImageToVideoResponse,
     RunwayTaskStatusResponse as TaskStatusResponse,
@@ -184,10 +184,6 @@ class RunwayImageToVideoNodeGen3a(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration"]),
-                expr="""{"type":"usd","usd": 0.0715 * widgets.duration}""",
-            ),
         )
 
     @classmethod
@@ -278,10 +274,6 @@ class RunwayImageToVideoNodeGen4(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration"]),
-                expr="""{"type":"usd","usd": 0.0715 * widgets.duration}""",
-            ),
         )
 
     @classmethod
@@ -380,10 +372,6 @@ class RunwayFirstLastFrameNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["duration"]),
-                expr="""{"type":"usd","usd": 0.0715 * widgets.duration}""",
-            ),
         )
 
     @classmethod
@@ -469,9 +457,6 @@ class RunwayTextToImageNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.11}""",
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_sora.py

@@ -89,24 +89,6 @@ class OpenAIVideoSora2(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model", "size", "duration"]),
-                expr="""
-                (
-                  $m := widgets.model;
-                  $size := widgets.size;
-                  $dur := widgets.duration;
-                  $isPro := $contains($m, "sora-2-pro");
-                  $isSora2 := $contains($m, "sora-2");
-                  $isProSize := ($size = "1024x1792" or $size = "1792x1024");
-                  $perSec :=
-                    $isPro ? ($isProSize ? 0.5 : 0.3) :
-                    $isSora2 ? 0.1 :
-                    ($isProSize ? 0.5 : 0.1);
-                  {"type":"usd","usd": $round($perSec * $dur, 2)}
-                )
-                """,
-            ),
         )
 
     @classmethod

comfy_api_nodes/nodes_stability.py

@@ -3,7 +3,7 @@ from typing import Optional
 from typing_extensions import override
 
 from comfy_api.latest import ComfyExtension, Input, IO
-from comfy_api_nodes.apis.stability import (
+from comfy_api_nodes.apis.stability_api import (
     StabilityUpscaleConservativeRequest,
     StabilityUpscaleCreativeRequest,
     StabilityAsyncResponse,
@@ -127,9 +127,6 @@ class StabilityStableImageUltraNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.08}""",
-            ),
         )
 
     @classmethod
@@ -267,16 +264,6 @@ class StabilityStableImageSD_3_5Node(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
-                expr="""
-                (
-                  $contains(widgets.model,"large")
-                    ? {"type":"usd","usd":0.065}
-                    : {"type":"usd","usd":0.035}
-                )
-                """,
-            ),
         )
 
     @classmethod
@@ -395,9 +382,6 @@ class StabilityUpscaleConservativeNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.25}""",
-            ),
         )
 
     @classmethod
@@ -502,9 +486,6 @@ class StabilityUpscaleCreativeNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.25}""",
-            ),
         )
 
     @classmethod
@@ -585,9 +566,6 @@ class StabilityUpscaleFastNode(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.01}""",
-            ),
         )
 
     @classmethod
@@ -670,9 +648,6 @@ class StabilityTextToAudio(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.2}""",
-            ),
         )
 
     @classmethod
@@ -757,9 +732,6 @@ class StabilityAudioToAudio(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.2}""",
-            ),
         )
 
     @classmethod
@@ -856,9 +828,6 @@ class StabilityAudioInpaint(IO.ComfyNode):
                 IO.Hidden.unique_id,
             ],
             is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd":0.2}""",
-            ),
         )
 
     @classmethod