chore(openapi): sync shared API contract from cloud@5989e82

alembic_db/versions/0005_allow_case_sensitive_tags.py

@@ -1,107 +0,0 @@
-"""
-Allow case-sensitive tag names.
-
-Revision ID: 0005_allow_case_sensitive_tags
-Revises: 0004_drop_tag_type
-Create Date: 2026-06-16
-"""
-
-import sqlalchemy as sa
-from alembic import op
-
-revision = "0005_allow_case_sensitive_tags"
-down_revision = "0004_drop_tag_type"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    bind = op.get_bind()
-    if bind.dialect.name == "sqlite":
-        # SQLite cannot ALTER/DROP CHECK constraints. Recreate the small tag
-        # vocabulary table without the lowercase constraint while preserving
-        # existing tag names.
-        op.execute("PRAGMA foreign_keys=OFF")
-        try:
-            op.execute(
-                "CREATE TABLE tags_new ("
-                "name VARCHAR(512) NOT NULL, "
-                "CONSTRAINT pk_tags PRIMARY KEY (name)"
-                ")"
-            )
-            op.execute("INSERT INTO tags_new(name) SELECT name FROM tags")
-            op.execute("DROP TABLE tags")
-            op.execute("ALTER TABLE tags_new RENAME TO tags")
-        finally:
-            op.execute("PRAGMA foreign_keys=ON")
-        return
-
-    op.drop_constraint("ck_tags_ck_tags_lowercase", "tags", type_="check")
-
-
-def downgrade() -> None:
-    # Existing mixed-case tags cannot satisfy the old constraint. Lowercase them
-    # before restoring it, merging duplicate vocabulary/link rows that collide.
-    bind = op.get_bind()
-
-    tag_names = [row[0] for row in bind.execute(sa.text("SELECT name FROM tags"))]
-    existing_names = set(tag_names)
-    lowercase_names = sorted({name.lower() for name in tag_names})
-    missing_lowercase_rows = [
-        {"name": name} for name in lowercase_names if name not in existing_names
-    ]
-    if missing_lowercase_rows:
-        bind.execute(sa.text("INSERT INTO tags(name) VALUES (:name)"), missing_lowercase_rows)
-
-    link_rows = bind.execute(
-        sa.text(
-            "SELECT asset_reference_id, tag_name, origin, added_at "
-            "FROM asset_reference_tags "
-            "ORDER BY asset_reference_id, tag_name"
-        )
-    ).mappings()
-    deduped_links = {}
-    for row in link_rows:
-        key = (row["asset_reference_id"], row["tag_name"].lower())
-        deduped_links.setdefault(
-            key,
-            {
-                "asset_reference_id": row["asset_reference_id"],
-                "tag_name": row["tag_name"].lower(),
-                "origin": row["origin"],
-                "added_at": row["added_at"],
-            },
-        )
-
-    op.execute("DELETE FROM asset_reference_tags")
-    if deduped_links:
-        bind.execute(
-            sa.text(
-                "INSERT INTO asset_reference_tags "
-                "(asset_reference_id, tag_name, origin, added_at) "
-                "VALUES (:asset_reference_id, :tag_name, :origin, :added_at)"
-            ),
-            list(deduped_links.values()),
-        )
-    op.execute("DELETE FROM tags WHERE name != lower(name)")
-
-    if bind.dialect.name == "sqlite":
-        op.execute("PRAGMA foreign_keys=OFF")
-        try:
-            op.execute(
-                "CREATE TABLE tags_new ("
-                "name VARCHAR(512) NOT NULL, "
-                "CONSTRAINT pk_tags PRIMARY KEY (name), "
-                "CONSTRAINT ck_tags_lowercase CHECK (name = lower(name))"
-                ")"
-            )
-            op.execute("INSERT INTO tags_new(name) SELECT name FROM tags")
-            op.execute("DROP TABLE tags")
-            op.execute("ALTER TABLE tags_new RENAME TO tags")
-        finally:
-            op.execute("PRAGMA foreign_keys=ON")
-        return
-
-    op.create_check_constraint(
-        "ck_tags_ck_tags_lowercase", "tags", "name = lower(name)"
-    )

alembic_db/versions/0006_add_loader_path.py

@@ -1,30 +0,0 @@
-"""
-Add loader_path column to asset_references.
-
-Stores the in-root loader path (path relative to the storage root with the
-top-level model category dropped) derived from file_path at scan/ingest time,
-so the assets API can return it without re-resolving against every registered
-model-folder base on every request.
-
-Revision ID: 0006_add_loader_path
-Revises: 0005_allow_case_sensitive_tags
-Create Date: 2026-07-02
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0006_add_loader_path"
-down_revision = "0005_allow_case_sensitive_tags"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.add_column(sa.Column("loader_path", sa.Text(), nullable=True))
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.drop_column("loader_path")

app/assets/api/routes.py

@@ -40,7 +40,6 @@ from app.assets.services import (
     upload_from_temp_path,
 )
 from app.assets.services.cursor import InvalidCursorError
-from app.assets.services.path_utils import compute_display_name
 from app.assets.services.tagging import list_tag_histogram
 
 ROUTES = web.RouteTableDef()
@@ -162,19 +161,11 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResu
             preview_url = None
     else:
         preview_url = _build_preview_url_from_view(result.tags, result.ref.user_metadata)
-    if result.ref.file_path:
-        display_name = compute_display_name(result.ref.file_path)
-        # In-root loader path (model category dropped): what model loaders consume.
-        loader_path = result.ref.loader_path
-    else:
-        display_name, loader_path = None, None
     asset_content_hash = result.asset.hash if result.asset else None
     return schemas_out.Asset(
         id=result.ref.id,
         name=result.ref.name,
         hash=asset_content_hash,
-        loader_path=loader_path,
-        display_name=display_name,
         asset_hash=asset_content_hash,
         size=int(result.asset.size_bytes) if result.asset else None,
         mime_type=result.asset.mime_type if result.asset else None,
@@ -428,6 +419,17 @@ async def upload_asset(request: web.Request) -> web.Response:
             400, "INVALID_BODY", f"Validation failed: {ve.json()}"
         )
 
+    if spec.tags and spec.tags[0] == "models":
+        if (
+            len(spec.tags) < 2
+            or spec.tags[1] not in folder_paths.folder_names_and_paths
+        ):
+            delete_temp_file_if_exists(parsed.tmp_path)
+            category = spec.tags[1] if len(spec.tags) >= 2 else ""
+            return _build_error_response(
+                400, "INVALID_BODY", f"unknown models category '{category}'"
+            )
+
     try:
         # Fast path: hash exists, create AssetReference without writing anything
         if spec.hash and parsed.provided_hash_exists is True:
@@ -471,7 +473,7 @@ async def upload_asset(request: web.Request) -> web.Response:
         return _build_error_response(400, e.code, str(e))
     except ValueError as e:
         delete_temp_file_if_exists(parsed.tmp_path)
-        return _build_error_response(400, "INVALID_BODY", str(e))
+        return _build_error_response(400, "BAD_REQUEST", str(e))
     except HashMismatchError as e:
         delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(400, "HASH_MISMATCH", str(e))

app/assets/api/schemas_in.py

@@ -140,7 +140,7 @@ class CreateFromHashBody(BaseModel):
         if v is None:
             return []
         if isinstance(v, list):
-            out = [str(t).strip() for t in v if str(t).strip()]
+            out = [str(t).strip().lower() for t in v if str(t).strip()]
             seen = set()
             dedup = []
             for t in out:
@@ -149,7 +149,7 @@ class CreateFromHashBody(BaseModel):
                     dedup.append(t)
             return dedup
         if isinstance(v, str):
-            return list(dict.fromkeys(t.strip() for t in v.split(",") if t.strip()))
+            return [t.strip().lower() for t in v.split(",") if t.strip()]
         return []
 
 
@@ -206,7 +206,7 @@ class TagsListQuery(BaseModel):
         if v is None:
             return v
         v = v.strip()
-        return v or None
+        return v.lower() or None
 
 
 class TagsAdd(BaseModel):
@@ -220,7 +220,7 @@ class TagsAdd(BaseModel):
         for t in v:
             if not isinstance(t, str):
                 raise TypeError("tags must be strings")
-            tnorm = t.strip()
+            tnorm = t.strip().lower()
             if tnorm:
                 out.append(tnorm)
         seen = set()
@@ -239,8 +239,8 @@ class TagsRemove(TagsAdd):
 class UploadAssetSpec(BaseModel):
     """Upload Asset operation.
 
-    - tags: labels plus one destination role ('models'|'input'|'output') for new bytes;
-            if role == 'models', exactly one model_type:<folder_name> tag is required
+    - tags: optional list; if provided, first is root ('models'|'input'|'output');
+            if root == 'models', second must be a valid category
     - name: display name
     - user_metadata: arbitrary JSON object (optional)
     - hash: optional canonical 'blake3:<hex>' for validation / fast-path
@@ -309,7 +309,7 @@ class UploadAssetSpec(BaseModel):
         norm = []
         seen = set()
         for t in items:
-            tnorm = str(t).strip()
+            tnorm = str(t).strip().lower()
             if tnorm and tnorm not in seen:
                 seen.add(tnorm)
                 norm.append(tnorm)
@@ -335,4 +335,14 @@ class UploadAssetSpec(BaseModel):
 
     @model_validator(mode="after")
     def _validate_order(self):
+        if not self.tags:
+            raise ValueError("at least one tag is required for uploads")
+        root = self.tags[0]
+        if root not in {"models", "input", "output"}:
+            raise ValueError("first tag must be one of: models, input, output")
+        if root == "models":
+            if len(self.tags) < 2:
+                raise ValueError(
+                    "models uploads require a category tag as the second tag"
+                )
         return self

app/assets/api/schemas_out.py

@@ -9,20 +9,8 @@ class Asset(BaseModel):
     ``id`` here is the AssetReference id, not the content-addressed Asset id."""
 
     id: str
-    name: str = Field(
-        ...,
-        deprecated=True,
-        description="Reference label, often caller-provided or derived from the filename. Deprecated for storage path/display semantics; use `loader_path` and `display_name` when present.",
-    )
+    name: str
     hash: str | None = None
-    loader_path: str | None = Field(
-        default=None,
-        description="The value a loader consumes to load this asset. `None` when no loader can resolve the file.",
-    )
-    display_name: str | None = Field(
-        default=None,
-        description="Human-facing label for the asset. Not unique.",
-    )
     asset_hash: str | None = None
     size: int | None = None
     mime_type: str | None = None

app/assets/api/upload.py

@@ -140,6 +140,7 @@ async def parse_multipart_upload(
             provided_mime_type = ((await field.text()) or "").strip() or None
         elif fname == "preview_id":
             provided_preview_id = ((await field.text()) or "").strip() or None
+
     if not file_present and not (provided_hash and provided_hash_exists):
         raise UploadError(
             400, "MISSING_FILE", "Form must include a 'file' part or a known 'hash'."

app/assets/database/models.py

@@ -76,8 +76,6 @@ class AssetReference(Base):
 
     # Cache state fields (from former AssetCacheState)
     file_path: Mapped[str | None] = mapped_column(Text, nullable=True)
-    # In-root loader path derived from file_path at scan/ingest time.
-    loader_path: Mapped[str | None] = mapped_column(Text, nullable=True)
     mtime_ns: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
     needs_verify: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     is_missing: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)

app/assets/database/queries/asset_reference.py

@@ -650,7 +650,6 @@ def upsert_reference(
     name: str,
     mtime_ns: int,
     owner_id: str = "",
-    loader_path: str | None = None,
 ) -> tuple[bool, bool]:
     """Upsert a reference by file_path. Returns (created, updated).
 
@@ -660,7 +659,6 @@ def upsert_reference(
     vals = {
         "asset_id": asset_id,
         "file_path": file_path,
-        "loader_path": loader_path,
         "name": name,
         "owner_id": owner_id,
         "mtime_ns": int(mtime_ns),
@@ -688,14 +686,13 @@ def upsert_reference(
                 AssetReference.asset_id != asset_id,
                 AssetReference.mtime_ns.is_(None),
                 AssetReference.mtime_ns != int(mtime_ns),
-                AssetReference.loader_path.is_distinct_from(loader_path),
                 AssetReference.is_missing == True,  # noqa: E712
                 AssetReference.deleted_at.isnot(None),
             )
         )
         .values(
-            asset_id=asset_id, mtime_ns=int(mtime_ns), loader_path=loader_path,
-            is_missing=False, deleted_at=None, updated_at=now,
+            asset_id=asset_id, mtime_ns=int(mtime_ns), is_missing=False,
+            deleted_at=None, updated_at=now,
         )
     )
     res2 = session.execute(upd)

app/assets/database/queries/tags.py

@@ -265,8 +265,6 @@ def list_tags_with_usage(
     order: str = "count_desc",
     owner_id: str = "",
 ) -> tuple[list[tuple[str, str, int]], int]:
-    prefix_filter = prefix.strip() if prefix else ""
-
     counts_sq = (
         select(
             AssetReferenceTag.tag_name.label("tag_name"),
@@ -295,8 +293,9 @@ def list_tags_with_usage(
         .join(counts_sq, counts_sq.c.tag_name == Tag.name, isouter=True)
     )
 
-    if prefix_filter:
-        q = q.where(func.substr(Tag.name, 1, len(prefix_filter)) == prefix_filter)
+    if prefix:
+        escaped, esc = escape_sql_like_string(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)
@@ -307,8 +306,9 @@ def list_tags_with_usage(
         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_filter:
-        total_q = total_q.where(func.substr(Tag.name, 1, len(prefix_filter)) == prefix_filter)
+    if prefix:
+        escaped, esc = escape_sql_like_string(prefix.strip().lower())
+        total_q = total_q.where(Tag.name.like(escaped + "%", escape=esc))
     if not include_zero:
         visible_tags_sq = (
             select(AssetReferenceTag.tag_name)

app/assets/helpers.py

@@ -41,10 +41,10 @@ def get_utc_now() -> datetime:
 def normalize_tags(tags: list[str] | None) -> list[str]:
     """
     Normalize a list of tags by:
-      - Stripping whitespace.
-      - Removing exact duplicates while preserving order and case.
+      - Stripping whitespace and converting to lowercase.
+      - Removing duplicates.
     """
-    return list(dict.fromkeys(t.strip() for t in (tags or []) if (t or "").strip()))
+    return list(dict.fromkeys(t.strip().lower() for t in (tags or []) if (t or "").strip()))
 
 
 def validate_blake3_hash(s: str) -> str:

app/assets/scanner.py

@@ -36,7 +36,7 @@ from app.assets.services.hashing import HashCheckpoint, compute_blake3_hash
 from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.metadata_extract import extract_file_metadata
 from app.assets.services.path_utils import (
-    compute_loader_path,
+    compute_relative_filename,
     get_comfy_models_folders,
     get_name_and_tags_from_asset_path,
 )
@@ -63,7 +63,7 @@ RootType = Literal["models", "input", "output"]
 def get_prefixes_for_root(root: RootType) -> list[str]:
     if root == "models":
         bases: list[str] = []
-        for _bucket, paths, _exts in get_comfy_models_folders():
+        for _bucket, paths in get_comfy_models_folders():
             bases.extend(paths)
         return [os.path.abspath(p) for p in bases]
     if root == "input":
@@ -81,7 +81,7 @@ def get_all_known_prefixes() -> list[str]:
 
 def collect_models_files() -> list[str]:
     out: list[str] = []
-    for folder_name, bases, _exts in get_comfy_models_folders():
+    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:
             if not all(is_visible(part) for part in Path(rel_path).parts):
@@ -308,7 +308,7 @@ def build_asset_specs(
         if not stat_p.st_size:
             continue
         name, tags = get_name_and_tags_from_asset_path(abs_p)
-        rel_fname = compute_loader_path(abs_p)
+        rel_fname = compute_relative_filename(abs_p)
 
         # Extract metadata (tier 1: filesystem, tier 2: safetensors header)
         metadata = None
@@ -430,7 +430,7 @@ def enrich_asset(
         return new_level
 
     initial_mtime_ns = get_mtime_ns(stat_p)
-    rel_fname = compute_loader_path(file_path)
+    rel_fname = compute_relative_filename(file_path)
     mime_type: str | None = None
     metadata = None
 

app/assets/services/asset_management.py

@@ -38,7 +38,7 @@ from app.assets.database.queries import (
     update_reference_updated_at,
 )
 from app.assets.helpers import select_best_live_path
-from app.assets.services.path_utils import compute_loader_path
+from app.assets.services.path_utils import compute_relative_filename
 from app.assets.services.schemas import (
     AssetData,
     AssetDetailResult,
@@ -91,7 +91,7 @@ def update_asset_metadata(
             update_reference_name(session, reference_id=reference_id, name=name)
             touched = True
 
-        computed_filename = compute_loader_path(ref.file_path) if ref.file_path else None
+        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
 
         new_meta: dict | None = None
         if user_metadata is not None:

app/assets/services/bulk_ingest.py

@@ -56,7 +56,6 @@ class ReferenceRow(TypedDict):
     id: str
     asset_id: str
     file_path: str
-    loader_path: str | None
     mtime_ns: int
     owner_id: str
     name: str
@@ -135,14 +134,6 @@ def batch_insert_seed_assets(
 
     for spec in specs:
         absolute_path = os.path.abspath(spec["abs_path"])
-        existing_asset_id = path_to_asset_id.get(absolute_path)
-        if existing_asset_id is not None:
-            existing_tags = asset_id_to_ref_data[existing_asset_id]["tags"]
-            asset_id_to_ref_data[existing_asset_id]["tags"] = list(
-                dict.fromkeys([*existing_tags, *spec["tags"]])
-            )
-            continue
-
         asset_id = str(uuid.uuid4())
         reference_id = str(uuid.uuid4())
         absolute_path_list.append(absolute_path)
@@ -173,8 +164,6 @@ def batch_insert_seed_assets(
                 "id": reference_id,
                 "asset_id": asset_id,
                 "file_path": absolute_path,
-                # spec["fname"] is compute_loader_path(abs_path) from build_asset_specs.
-                "loader_path": spec["fname"],
                 "mtime_ns": spec["mtime_ns"],
                 "owner_id": owner_id,
                 "name": spec["info_name"],

app/assets/services/ingest.py

@@ -33,9 +33,8 @@ from app.assets.services.bulk_ingest import batch_insert_seed_assets
 from app.assets.services.file_utils import get_size_and_mtime_ns
 from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.path_utils import (
-    compute_loader_path,
+    compute_relative_filename,
     get_name_and_tags_from_asset_path,
-    get_path_derived_tags_from_path,
     resolve_destination_from_tags,
     validate_path_within_base,
 )
@@ -92,7 +91,6 @@ def _ingest_file_from_path(
             name=info_name or os.path.basename(locator),
             mtime_ns=mtime_ns,
             owner_id=owner_id,
-            loader_path=compute_loader_path(locator),
         )
 
         # Get the reference we just created/updated
@@ -103,32 +101,17 @@ def _ingest_file_from_path(
             if preview_id and ref.preview_id != preview_id:
                 ref.preview_id = preview_id
 
-            try:
-                backend_tags = get_path_derived_tags_from_path(locator)
-            except ValueError:
-                backend_tags = []
-            caller_tags = normalize_tags(tags)
-            backend_tags = normalize_tags(backend_tags)
-            all_tags = normalize_tags([*caller_tags, *backend_tags])
-            if all_tags:
+            norm = normalize_tags(list(tags))
+            if norm:
                 if require_existing_tags:
-                    validate_tags_exist(session, all_tags)
-                if backend_tags:
-                    add_tags_to_reference(
-                        session,
-                        reference_id=reference_id,
-                        tags=backend_tags,
-                        origin="automatic",
-                        create_if_missing=not require_existing_tags,
-                    )
-                if caller_tags:
-                    add_tags_to_reference(
-                        session,
-                        reference_id=reference_id,
-                        tags=caller_tags,
-                        origin=tag_origin,
-                        create_if_missing=not require_existing_tags,
-                    )
+                    validate_tags_exist(session, norm)
+                add_tags_to_reference(
+                    session,
+                    reference_id=reference_id,
+                    tags=norm,
+                    origin=tag_origin,
+                    create_if_missing=not require_existing_tags,
+                )
 
             _update_metadata_with_filename(
                 session,
@@ -245,7 +228,7 @@ def ingest_existing_file(
             "mtime_ns": mtime_ns,
             "info_name": name,
             "tags": tags,
-            "fname": compute_loader_path(abs_path),
+            "fname": os.path.basename(abs_path),
             "metadata": None,
             "hash": None,
             "mime_type": mime_type,
@@ -305,7 +288,7 @@ def _register_existing_asset(
             return result
 
         new_meta = dict(user_metadata)
-        computed_filename = compute_loader_path(ref.file_path) if ref.file_path else None
+        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
         if computed_filename:
             new_meta["filename"] = computed_filename
 
@@ -352,7 +335,7 @@ def _update_metadata_with_filename(
     current_metadata: dict | None,
     user_metadata: dict[str, Any],
 ) -> None:
-    computed_filename = compute_loader_path(file_path) if file_path else None
+    computed_filename = compute_relative_filename(file_path) if file_path else None
 
     current_meta = current_metadata or {}
     new_meta = dict(current_meta)
@@ -491,10 +474,6 @@ def upload_from_temp_path(
         existing = get_asset_by_hash(session, asset_hash=asset_hash)
 
     if existing is not None:
-        # Once content is already known, duplicate byte uploads are treated as
-        # reference-only creation. Request tags are labels only here: do not
-        # require upload destination tags, do not move bytes, and do not
-        # synthesize path-derived classification or uploaded provenance.
         with contextlib.suppress(Exception):
             if temp_path and os.path.exists(temp_path):
                 os.remove(temp_path)
@@ -556,7 +535,7 @@ def upload_from_temp_path(
         owner_id=owner_id,
         preview_id=preview_id,
         user_metadata=user_metadata or {},
-        tags=[*(tags or []), "uploaded"],
+        tags=tags,
         tag_origin="manual",
         require_existing_tags=False,
     )
@@ -590,19 +569,15 @@ def register_file_in_place(
 ) -> UploadResult:
     """Register an already-saved file in the asset database without moving it.
 
-    This helper is used by upload paths that have already written bytes before
-    registering the file, so it records the same ``uploaded`` tag as the
-    multipart byte-upload path.
-
-    Tags are derived from trusted filesystem classification and merged with any
-    caller-provided tags, matching the behavior of the scanner.
+    Tags are derived from the filesystem path (root category + subfolder names),
+    merged with any caller-provided tags, matching the behavior of the scanner.
     If the path is not under a known root, only the caller-provided tags are used.
     """
     try:
         _, path_tags = get_name_and_tags_from_asset_path(abs_path)
     except ValueError:
         path_tags = []
-    merged_tags = normalize_tags([*path_tags, *tags, "uploaded"])
+    merged_tags = normalize_tags([*path_tags, *tags])
 
     try:
         digest, _ = hashing.compute_blake3_hash(abs_path)

app/assets/services/path_utils.py

@@ -3,66 +3,59 @@ from pathlib import Path
 from typing import Literal
 
 import folder_paths
+from app.assets.helpers import normalize_tags
 
 
-_NON_MODEL_FOLDER_NAMES = frozenset({"configs", "custom_nodes"})
-_KNOWN_SUBFOLDER_TAGS = frozenset({"3d", "pasted", "painter", "threed", "webcam"})
+_NON_MODEL_FOLDER_NAMES = frozenset({"custom_nodes"})
 
 
-def get_comfy_models_folders() -> list[tuple[str, list[str], set[str]]]:
-    """Build list of (folder_name, base_paths[], extensions) for all model locations.
+def get_comfy_models_folders() -> list[tuple[str, list[str]]]:
+    """Build list of (folder_name, base_paths[]) for all model locations.
 
     Includes every category registered in folder_names_and_paths,
     regardless of whether its paths are under the main models_dir,
-    but excludes non-model entries like configs and custom_nodes.
-
-    An empty extensions set means the category accepts any extension,
-    matching folder_paths.filter_files_extensions semantics.
+    but excludes non-model entries like custom_nodes.
     """
-    targets: list[tuple[str, list[str], set[str]]] = []
+    targets: list[tuple[str, list[str]]] = []
     for name, values in folder_paths.folder_names_and_paths.items():
         if name in _NON_MODEL_FOLDER_NAMES:
             continue
-        paths, exts = values[0], values[1]
+        paths, _exts = values[0], values[1]
         if paths:
-            targets.append((name, paths, set(exts)))
+            targets.append((name, paths))
     return targets
 
 
 def resolve_destination_from_tags(tags: list[str]) -> tuple[str, list[str]]:
-    """Validates and maps upload routing tags -> (base_dir, subdirs_for_fs).
-
-    The request tags are only used to choose the write destination. Extra tags
-    remain labels; they do not become path components or trusted classification.
-    """
-    destination_roles = [t for t in tags if t in {"input", "models", "output"}]
-    if len(destination_roles) != 1:
-        raise ValueError("uploads require exactly one destination role: input, models, or output")
-
-    root = destination_roles[0]
+    """Validates and maps tags -> (base_dir, subdirs_for_fs)"""
+    if not tags:
+        raise ValueError("tags must not be empty")
+    root = tags[0].lower()
     if root == "models":
-        model_type_tags = [t for t in tags if t.startswith("model_type:")]
-        if len(model_type_tags) != 1:
-            raise ValueError("models uploads require exactly one model_type:<folder_name> tag")
-        folder_name = model_type_tags[0].split(":", 1)[1]
-        if not folder_name:
-            raise ValueError("models uploads require exactly one model_type:<folder_name> tag")
-        model_folder_paths = {
-            name: paths for name, paths, _exts in get_comfy_models_folders()
-        }
+        if len(tags) < 2:
+            raise ValueError("at least two tags required for model asset")
         try:
-            bases = model_folder_paths[folder_name]
+            bases = folder_paths.folder_names_and_paths[tags[1]][0]
         except KeyError:
-            raise ValueError(f"unknown model category '{folder_name}'")
+            raise ValueError(f"unknown model category '{tags[1]}'")
         if not bases:
-            raise ValueError(f"no base path configured for category '{folder_name}'")
+            raise ValueError(f"no base path configured for category '{tags[1]}'")
         base_dir = os.path.abspath(bases[0])
+        raw_subdirs = tags[2:]
     elif root == "input":
         base_dir = os.path.abspath(folder_paths.get_input_directory())
-    else:
+        raw_subdirs = tags[1:]
+    elif root == "output":
         base_dir = os.path.abspath(folder_paths.get_output_directory())
+        raw_subdirs = tags[1:]
+    else:
+        raise ValueError(f"unknown root tag '{tags[0]}'; expected 'models', 'input', or 'output'")
+    _sep_chars = frozenset(("/", "\\", os.sep))
+    for i in raw_subdirs:
+        if i in (".", "..") or _sep_chars & set(i):
+            raise ValueError("invalid path component in tags")
 
-    return base_dir, []
+    return base_dir, raw_subdirs if raw_subdirs else []
 
 
 def validate_path_within_base(candidate: str, base: str) -> None:
@@ -72,79 +65,14 @@ def validate_path_within_base(candidate: str, base: str) -> None:
         raise ValueError("destination escapes base directory")
 
 
-def _compute_relative_path(child: str, parent: str) -> str:
-    rel = os.path.relpath(os.path.abspath(child), os.path.abspath(parent))
-    if rel == ".":
-        return ""
-    return rel.replace(os.sep, "/")
-
-
-def _is_relative_to(child: str, parent: str) -> bool:
-    return Path(os.path.abspath(child)).is_relative_to(os.path.abspath(parent))
-
-
-def compute_asset_response_paths(file_path: str) -> tuple[str, str | None] | None:
-    """Return (logical_path, display_name) for a file path.
-
-    ``logical_path`` is the internal namespaced storage locator (e.g.
-    ``models/checkpoints/foo/bar.safetensors``); ``display_name`` is the
-    human-facing label below that namespace, served on Asset responses. These
-    are storage locators, not model-loader namespaces. Registered model-folder
-    membership is represented by backend tags such as
-    ``model_type:<folder_name>``; these paths only use known storage roots.
+def compute_relative_filename(file_path: str) -> str | None:
     """
-    fp_abs = os.path.abspath(file_path)
-    candidates: list[tuple[int, int, str, str]] = []
-
-    for order, (namespace, base) in enumerate(
-        (
-            ("input", folder_paths.get_input_directory()),
-            ("output", folder_paths.get_output_directory()),
-            ("temp", folder_paths.get_temp_directory()),
-            ("models", getattr(folder_paths, "models_dir", "")),
-        )
-    ):
-        if not base:
-            continue
-        base_abs = os.path.abspath(base)
-        if _is_relative_to(fp_abs, base_abs):
-            candidates.append((len(base_abs), -order, namespace, base_abs))
-
-    if not candidates:
-        return None
-
-    _base_len, _order, namespace, base = max(candidates)
-    rel = _compute_relative_path(fp_abs, base)
-    public_path = f"{namespace}/{rel}" if rel else namespace
-    return public_path, rel or None
-
-
-def compute_display_name(file_path: str) -> str | None:
-    """Return the asset's `display_name`, or None for unknown paths."""
-    result = compute_asset_response_paths(file_path)
-    return result[1] if result else None
-
-
-def compute_logical_path(file_path: str) -> str | None:
-    """Return the internal namespaced storage locator, or None for unknown paths."""
-    result = compute_asset_response_paths(file_path)
-    return result[0] if result else None
-
-
-def compute_loader_path(file_path: str) -> str | None:
-    """
-    Return the asset's in-root loader path: the path relative to the last
-    well-known folder (the model category), using forward slashes, eg:
+    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"
 
-    This is the value model loaders consume (the model category is dropped). It
-    is persisted as ``AssetReference.loader_path`` and served as the public
-    Asset response `loader_path` field. The human-facing `display_name` comes
-    from compute_asset_response_paths().
-
-    For input/output/temp paths the full path relative to that root is returned.
-    For paths outside any known root, returns None.
+    For non-model paths, returns None.
     """
     try:
         root_category, rel_path = get_asset_category_and_relative_path(file_path)
@@ -188,10 +116,9 @@ def get_asset_category_and_relative_path(
     def _compute_relative(child: str, parent: str) -> str:
         # Normalize relative path, stripping any leading ".." components
         # by anchoring to root (os.sep) then computing relpath back from it.
-        rel = os.path.relpath(
+        return os.path.relpath(
             os.path.join(os.sep, os.path.relpath(child, parent)), os.sep
         )
-        return "" if rel == "." else rel.replace(os.sep, "/")
 
     # 1) input
     input_base = os.path.abspath(folder_paths.get_input_directory())
@@ -209,14 +136,8 @@ def get_asset_category_and_relative_path(
         return "temp", _compute_relative(fp_abs, temp_base)
 
     # 4) models (check deepest matching base to avoid ambiguity)
-    ext = os.path.splitext(fp_abs)[1].lower()
     best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
-    for bucket, bases, extensions in get_comfy_models_folders():
-        # A bucket only lists files within its extension set (empty set
-        # accepts any extension), so a bucket that cannot load the file
-        # must not contribute a loader path.
-        if extensions and ext not in extensions:
-            continue
+    for bucket, bases in get_comfy_models_folders():
         for b in bases:
             base_abs = os.path.abspath(b)
             if not _check_is_within(fp_abs, base_abs):
@@ -228,111 +149,25 @@ def get_asset_category_and_relative_path(
     if best is not None:
         _, bucket, rel_inside = best
         combined = os.path.join(bucket, rel_inside)
-        normalized = os.path.relpath(os.path.join(os.sep, combined), os.sep)
-        return "models", normalized.replace(os.sep, "/")
+        return "models", os.path.relpath(os.path.join(os.sep, combined), os.sep)
 
     raise ValueError(
         f"Path is not within input, output, temp, or configured model bases: {file_path}"
     )
 
 
-def get_backend_system_tags_from_path(path: str) -> list[str]:
-    """Return trusted backend tags derived from current filesystem facts.
-
-    The returned tags are only the backend-generated system tags: ``models``,
-    ``model_type:<folder_name>``, ``input``, ``output``, and ``temp``. Model
-    type tags are based on registered folder names, not path components.
-
-    A ``model_type:<folder_name>`` tag is only emitted when the file's
-    extension is accepted by that folder's registered extension set, so
-    categories sharing a base directory tag only the files they can
-    actually load. Files under a model base whose extension matches no
-    category still get the ``models`` tag.
-    """
-    fp_abs = os.path.abspath(path)
-    fp_path = Path(fp_abs)
-    tags: list[str] = []
-
-    def _add(tag: str) -> None:
-        if tag not in tags:
-            tags.append(tag)
-
-    for role, base in (
-        ("input", folder_paths.get_input_directory()),
-        ("output", folder_paths.get_output_directory()),
-        ("temp", folder_paths.get_temp_directory()),
-    ):
-        if fp_path.is_relative_to(os.path.abspath(base)):
-            _add(role)
-
-    ext = os.path.splitext(fp_abs)[1].lower()
-    model_types: list[str] = []
-    under_models_base = False
-    for folder_name, bases, extensions in get_comfy_models_folders():
-        for base in bases:
-            if fp_path.is_relative_to(os.path.abspath(base)):
-                under_models_base = True
-                # Empty set accepts any extension, matching
-                # folder_paths.filter_files_extensions semantics.
-                if not extensions or ext in extensions:
-                    model_types.append(folder_name)
-                break
-
-    if under_models_base:
-        _add("models")
-    for folder_name in model_types:
-        _add(f"model_type:{folder_name}")
-
-    if not tags:
-        raise ValueError(
-            f"Path is not within input, output, temp, or configured model bases: {path}"
-        )
-    return tags
-
-
-def get_known_subfolder_tags(subfolder: str | None) -> list[str]:
-    """Return tags for known UI/input subfolder names."""
-    if subfolder in _KNOWN_SUBFOLDER_TAGS:
-        return [subfolder]
-    return []
-
-
-def get_known_input_subfolder_tags_from_path(path: str) -> list[str]:
-    """Return known input-layout tags for files in canonical input subfolders.
-
-    These are compatibility tags for current UI-origin input directories such as
-    ``pasted`` and ``webcam``. They are intentionally narrow: only files directly
-    inside a known top-level input directory receive the matching tag.
-    """
-    fp_abs = os.path.abspath(path)
-    input_base = os.path.abspath(folder_paths.get_input_directory())
-    if not Path(fp_abs).is_relative_to(input_base):
-        return []
-
-    rel = os.path.relpath(fp_abs, input_base)
-    parts = Path(rel).parts
-    if len(parts) == 2:
-        return get_known_subfolder_tags(parts[0])
-    return []
-
-
-def get_path_derived_tags_from_path(path: str) -> list[str]:
-    """Return all backend-derived tags for an asset path."""
-    tags = get_backend_system_tags_from_path(path)
-    for tag in get_known_input_subfolder_tags_from_path(path):
-        if tag not in tags:
-            tags.append(tag)
-    return tags
-
-
 def get_name_and_tags_from_asset_path(file_path: str) -> tuple[str, list[str]]:
     """Return (name, tags) derived from a filesystem path.
 
     - name: base filename with extension
-    - tags: backend-derived tags from root/model classification and known input
-      subfolder layout conventions
+    - tags: [root_category] + parent folder names in order
 
     Raises:
         ValueError: path does not belong to any known root.
     """
-    return Path(file_path).name, get_path_derived_tags_from_path(file_path)
+    root_category, some_path = get_asset_category_and_relative_path(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])))

app/assets/services/schemas.py

@@ -25,7 +25,6 @@ class ReferenceData:
     preview_id: str | None
     created_at: datetime
     updated_at: datetime
-    loader_path: str | None = None
     system_metadata: dict[str, Any] | None = None
     job_id: str | None = None
     last_access_time: datetime | None = None
@@ -94,7 +93,6 @@ def extract_reference_data(ref: AssetReference) -> ReferenceData:
         id=ref.id,
         name=ref.name,
         file_path=ref.file_path,
-        loader_path=ref.loader_path,
         user_metadata=ref.user_metadata,
         preview_id=ref.preview_id,
         system_metadata=ref.system_metadata,

app/model_manager.py

@@ -35,11 +35,7 @@ class ModelFileManager:
             for folder in model_types:
                 if folder in folder_black_list:
                     continue
-                output_folders.append({
-                    "name": folder,
-                    "folders": folder_paths.get_folder_paths(folder),
-                    "extensions": sorted(folder_paths.folder_names_and_paths[folder][1]),
-                })
+                output_folders.append({"name": folder, "folders": folder_paths.get_folder_paths(folder)})
             return web.json_response(output_folders)
 
         # NOTE: This is an experiment to replace `/models/{folder}`

comfy/sd.py

@@ -1255,10 +1255,7 @@ class VAE:
             return None
 
     def is_dynamic(self):
-        # A VAE built from a state dict with no detectable VAE weights returns early
-        # from __init__ ("No VAE weights detected") before self.patcher is assigned.
-        patcher = getattr(self, "patcher", None)
-        return patcher is not None and patcher.is_dynamic()
+        return self.patcher.is_dynamic()
 
 class StyleModel:
     def __init__(self, model, device="cpu"):

comfy_api/feature_flags.py

@@ -100,7 +100,6 @@ def _parse_cli_feature_flags() -> dict[str, Any]:
 # Default server capabilities
 _CORE_FEATURE_FLAGS: dict[str, Any] = {
     "supports_preview_metadata": True,
-    "supports_model_type_tags": True,
     "max_upload_size": args.max_upload_size * 1024 * 1024, # Convert MB to bytes
     "extension": {"manager": {"supports_v4": True}},
     "node_replacements": True,

comfy_api_nodes/apis/bytedance.py

@@ -24,8 +24,8 @@ class Seedream4TaskCreationRequest(BaseModel):
     image: list[str] | None = Field(None, description="Image URLs")
     size: str = Field(...)
     seed: int = Field(..., ge=0, le=2147483647)
-    sequential_image_generation: str | None = Field("disabled")
-    sequential_image_generation_options: Seedream4Options | None = Field(Seedream4Options(max_images=15))
+    sequential_image_generation: str = Field("disabled")
+    sequential_image_generation_options: Seedream4Options = Field(Seedream4Options(max_images=15))
     watermark: bool = Field(False)
     output_format: str | None = None
 
@@ -261,19 +261,6 @@ _PRESETS_SEEDREAM_4K = [
 
 _CUSTOM_PRESET = [("Custom", None, None)]
 
-_PRESETS_SEEDREAM_2K_PRO = [
-    ("(2K) 2048x2048 (1:1)", 2048, 2048),
-    ("(2K) 1728x2304 (3:4)", 1728, 2304),
-    ("(2K) 2304x1728 (4:3)", 2304, 1728),
-    # ("(2K) 2848x1600 (16:9)", 2848, 1600),  # 4,556,800 px - temporarily unavailable
-    # ("(2K) 1600x2848 (9:16)", 1600, 2848),  # 4,556,800 px - temporarily unavailable
-    ("(2K) 1664x2496 (2:3)", 1664, 2496),
-    ("(2K) 2496x1664 (3:2)", 2496, 1664),
-    # ("(2K) 3136x1344 (21:9)", 3136, 1344),  # 4,214,784 px - temporarily unavailable
-]
-RECOMMENDED_PRESETS_SEEDREAM_5_PRO = (
-    _PRESETS_SEEDREAM_1K + _PRESETS_SEEDREAM_2K_PRO + _CUSTOM_PRESET
-)
 RECOMMENDED_PRESETS_SEEDREAM_5_LITE = (
     _PRESETS_SEEDREAM_2K + _PRESETS_SEEDREAM_3K + _PRESETS_SEEDREAM_4K + _CUSTOM_PRESET
 )

comfy_api_nodes/nodes_bytedance.py

@@ -16,7 +16,6 @@ from comfy_api_nodes.apis.bytedance import (
     RECOMMENDED_PRESETS_SEEDREAM_4_0,
     RECOMMENDED_PRESETS_SEEDREAM_4_5,
     RECOMMENDED_PRESETS_SEEDREAM_5_LITE,
-    RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
     SEEDANCE2_REF_VIDEO_PIXEL_LIMITS,
     VIDEO_TASKS_EXECUTION_TIME,
     GetAssetResponse,
@@ -81,14 +80,12 @@ _VERIFICATION_POLL_TIMEOUT_SEC = 120
 _VERIFICATION_POLL_INTERVAL_SEC = 3
 
 SEEDREAM_MODELS = {
-    "seedream 5.0 pro": "seedream-5-0-pro-260628",
     "seedream 5.0 lite": "seedream-5-0-260128",
     "seedream-4-5-251128": "seedream-4-5-251128",
     "seedream-4-0-250828": "seedream-4-0-250828",
 }
 
 SEEDREAM_PRESETS = {
-    "seedream-5-0-pro-260628": RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
     "seedream-5-0-260128": RECOMMENDED_PRESETS_SEEDREAM_5_LITE,
     "seedream-4-5-251128": RECOMMENDED_PRESETS_SEEDREAM_4_5,
     "seedream-4-0-250828": RECOMMENDED_PRESETS_SEEDREAM_4_0,
@@ -746,15 +743,8 @@ class ByteDanceSeedreamNode(IO.ComfyNode):
         return IO.NodeOutput(torch.cat([await download_url_to_image_tensor(i) for i in urls]))
 
 
-def _seedream_model_inputs(
-    *,
-    max_ref_images: int,
-    presets: list,
-    max_width: int = 6240,
-    max_height: int = 4992,
-    supports_batch: bool = True,
-):
-    inputs = [
+def _seedream_model_inputs(*, max_ref_images: int, presets: list):
+    return [
         IO.Combo.Input(
             "size_preset",
             options=[label for label, _, _ in presets],
@@ -764,7 +754,7 @@ def _seedream_model_inputs(
             "width",
             default=2048,
             min=1024,
-            max=max_width,
+            max=6240,
             step=2,
             tooltip="Custom width for image. Value is working only if `size_preset` is set to `Custom`",
         ),
@@ -772,27 +762,22 @@ def _seedream_model_inputs(
             "height",
             default=2048,
             min=1024,
-            max=max_height,
+            max=4992,
             step=2,
             tooltip="Custom height for image. Value is working only if `size_preset` is set to `Custom`",
         ),
-    ]
-    if supports_batch:
-        inputs.append(
-            IO.Int.Input(
-                "max_images",
-                default=1,
-                min=1,
-                max=max_ref_images,
-                step=1,
-                display_mode=IO.NumberDisplay.number,
-                tooltip="Maximum number of images to generate. With 1, exactly one image is produced. "
-                "With >1, the model generates between 1 and max_images related images "
-                "(e.g., story scenes, character variations). "
-                "Total images (input + generated) cannot exceed 15.",
-            )
-        )
-    inputs.append(
+        IO.Int.Input(
+            "max_images",
+            default=1,
+            min=1,
+            max=max_ref_images,
+            step=1,
+            display_mode=IO.NumberDisplay.number,
+            tooltip="Maximum number of images to generate. With 1, exactly one image is produced. "
+            "With >1, the model generates between 1 and max_images related images "
+            "(e.g., story scenes, character variations). "
+            "Total images (input + generated) cannot exceed 15.",
+        ),
         IO.Autogrow.Input(
             "images",
             template=IO.Autogrow.TemplateNames(
@@ -802,18 +787,14 @@ def _seedream_model_inputs(
             ),
             tooltip=f"Optional reference image(s) for image-to-image or multi-reference generation. "
             f"Up to {max_ref_images} images.",
-        )
-    )
-    if supports_batch:
-        inputs.append(
-            IO.Boolean.Input(
-                "fail_on_partial",
-                default=False,
-                tooltip="If enabled, abort execution if any requested images are missing or return an error.",
-                advanced=True,
-            )
-        )
-    return inputs
+        ),
+        IO.Boolean.Input(
+            "fail_on_partial",
+            default=False,
+            tooltip="If enabled, abort execution if any requested images are missing or return an error.",
+            advanced=True,
+        ),
+    ]
 
 
 class ByteDanceSeedreamNodeV2(IO.ComfyNode):
@@ -835,16 +816,6 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
                 IO.DynamicCombo.Input(
                     "model",
                     options=[
-                        IO.DynamicCombo.Option(
-                            "seedream 5.0 pro",
-                            _seedream_model_inputs(
-                                max_ref_images=10,
-                                presets=RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
-                                max_width=3136,
-                                max_height=2496,
-                                supports_batch=False,
-                            ),
-                        ),
                         IO.DynamicCombo.Option(
                             "seedream 5.0 lite",
                             _seedream_model_inputs(max_ref_images=14, presets=RECOMMENDED_PRESETS_SEEDREAM_5_LITE),
@@ -886,27 +857,15 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(
-                    widgets=["model", "model.size_preset", "model.width", "model.height"]
-                ),
+                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
                 expr="""
                 (
-                  $sp := $lookup(widgets, "model.size_preset");
-                  $px := $lookup(widgets, "model.width") * $lookup(widgets, "model.height");
-                  $isPro := $contains(widgets.model, "5.0 pro");
-                  $price := $isPro
-                              ? (
-                                  $contains($sp, "custom")
-                                    ? ($px <= 2360000 ? 0.045 : 0.09)
-                                    : ($contains($sp, "1k") ? 0.045 : 0.09)
-                                )
-                              : $contains(widgets.model, "5.0 lite") ? 0.035
-                              : $contains(widgets.model, "4-5") ? 0.04
-                              : 0.03;
+                  $price := $contains(widgets.model, "5.0 lite") ? 0.035 :
+                            $contains(widgets.model, "4-5") ? 0.04 : 0.03;
                   {
-                    "type": "usd",
+                    "type":"usd",
                     "usd": $price,
-                    "format": { "suffix": $isPro ? "/Image" : " x images/Run", "approximate": true }
+                    "format": { "suffix":" x images/Run", "approximate": true }
                   }
                 )
                 """,
@@ -924,7 +883,6 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
         validate_string(prompt, strip_whitespace=True, min_length=1)
         model_id = SEEDREAM_MODELS[model["model"]]
         presets = SEEDREAM_PRESETS[model_id]
-        is_pro = "seedream-5-0-pro" in model_id
 
         size_preset = model.get("size_preset", presets[0][0])
         width = model.get("width", 2048)
@@ -944,29 +902,19 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
 
         out_num_pixels = w * h
         mp_provided = out_num_pixels / 1_000_000.0
-        if is_pro:
-            if out_num_pixels < 921_600:
-                raise ValueError(
-                    f"Minimum image resolution for the selected model is 0.92MP, but {mp_provided:.2f}MP provided."
-                )
-            if out_num_pixels > 4_194_304:
-                raise ValueError(
-                    f"Maximum image resolution for the selected model is 4.19MP, but {mp_provided:.2f}MP provided."
-                )
-        else:
-            if ("seedream-4-5" in model_id or "seedream-5-0" in model_id) and out_num_pixels < 3_686_400:
-                raise ValueError(
-                    f"Minimum image resolution for the selected model is 3.68MP, but {mp_provided:.2f}MP provided."
-                )
-            if "seedream-4-0" in model_id and out_num_pixels < 921_600:
-                raise ValueError(
-                    f"Minimum image resolution that the selected model can generate is 0.92MP, "
-                    f"but {mp_provided:.2f}MP provided."
-                )
-            if out_num_pixels > 16_777_216:
-                raise ValueError(
-                    f"Maximum image resolution for the selected model is 16.78MP, but {mp_provided:.2f}MP provided."
-                )
+        if ("seedream-4-5" in model_id or "seedream-5-0" in model_id) and out_num_pixels < 3686400:
+            raise ValueError(
+                f"Minimum image resolution for the selected model is 3.68MP, but {mp_provided:.2f}MP provided."
+            )
+        if "seedream-4-0" in model_id and out_num_pixels < 921600:
+            raise ValueError(
+                f"Minimum image resolution that the selected model can generate is 0.92MP, "
+                f"but {mp_provided:.2f}MP provided."
+            )
+        if out_num_pixels > 16_777_216:
+            raise ValueError(
+                f"Maximum image resolution for the selected model is 16.78MP, but {mp_provided:.2f}MP provided."
+            )
 
         image_tensors: list[Input.Image] = [t for t in images_dict.values() if t is not None]
         n_input_images = sum(get_number_of_images(t) for t in image_tensors)
@@ -1002,8 +950,8 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
                 image=reference_images_urls,
                 size=f"{w}x{h}",
                 seed=seed,
-                sequential_image_generation=None if is_pro else sequential_image_generation,
-                sequential_image_generation_options=None if is_pro else Seedream4Options(max_images=max_images),
+                sequential_image_generation=sequential_image_generation,
+                sequential_image_generation_options=Seedream4Options(max_images=max_images),
                 watermark=watermark,
             ),
         )

openapi.yaml

@@ -7,18 +7,18 @@ components:
                     description: Timestamp when the asset was created
                     format: date-time
                     type: string
+                display_name:
+                    description: Display name of the asset. Mirrors name for backwards compatibility.
+                    nullable: true
+                    type: string
+                file_path:
+                    description: Relative path in global-namespace-root form (e.g. "models/checkpoints/flux.safetensors")
+                    nullable: true
+                    type: string
                 hash:
                     description: Blake3 hash of the asset content.
                     pattern: ^blake3:[a-f0-9]{64}$
                     type: string
-                loader_path:
-                    description: The value a loader consumes to load this asset. Null when no loader can resolve the file.
-                    nullable: true
-                    type: string
-                display_name:
-                    description: Human-facing label for the asset. Not unique.
-                    nullable: true
-                    type: string
                 id:
                     description: Unique identifier for the asset
                     format: uuid
@@ -144,6 +144,14 @@ components:
         AssetUpdated:
             description: Response returned when an existing asset is successfully updated.
             properties:
+                display_name:
+                    description: Display name of the asset. Mirrors name for backwards compatibility.
+                    nullable: true
+                    type: string
+                file_path:
+                    description: Relative path in global-namespace-root form (e.g. "models/checkpoints/flux.safetensors")
+                    nullable: true
+                    type: string
                 hash:
                     description: Blake3 hash of the asset content.
                     pattern: ^blake3:[a-f0-9]{64}$
@@ -775,14 +783,6 @@ components:
         ModelFolder:
             description: Represents a folder containing models
             properties:
-                extensions:
-                    description: The folder's registered file-extension allowlist. An empty array means the folder accepts any extension (match-all).
-                    example:
-                        - .ckpt
-                        - .safetensors
-                    items:
-                        type: string
-                    type: array
                 folders:
                     description: List of paths where models of this type are stored
                     example:
@@ -1644,7 +1644,7 @@ paths:
                                     format: uuid
                                     type: string
                                 tags:
-                                    description: JSON-encoded array of tag strings. For new byte uploads, include exactly one destination role (`input`, `output`, or `models`); `models` uploads also require exactly one `model_type:<folder_name>` tag. Extra tags are stored as labels and do not create path components.
+                                    description: JSON-encoded array of freeform tag strings, e.g. '["models","checkpoint"]'. Common types include "models", "input", "output", and "temp", but any tag can be used in any order.
                                     type: string
                                 user_metadata:
                                     description: Custom JSON metadata as a string
@@ -1829,7 +1829,7 @@ paths:
                     content:
                         application/json:
                             schema:
-                                $ref: '#/components/schemas/Asset'
+                                $ref: '#/components/schemas/AssetUpdated'
                     description: Asset updated successfully
                 "400":
                     content:
@@ -2470,9 +2470,6 @@ paths:
                                     supports_preview_metadata:
                                         description: Whether the server supports preview metadata
                                         type: boolean
-                                    supports_model_type_tags:
-                                        description: Whether the server supports namespaced model type asset tags
-                                        type: boolean
                                 type: object
                     description: Success
                     headers:
@@ -3300,6 +3297,12 @@ paths:
                             schema:
                                 $ref: '#/components/schemas/ErrorResponse'
                     description: Invalid request parameters
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorResponse'
+                    description: Unauthorized - Authentication required
                 "500":
                     content:
                         application/json:

requirements.txt

@@ -1,5 +1,5 @@
 comfyui-frontend-package==1.45.20
-comfyui-workflow-templates==0.11.6
+comfyui-workflow-templates==0.11.2
 comfyui-embedded-docs==0.5.7
 torch
 torchsde

server.py

@@ -46,7 +46,6 @@ from comfy_api.internal import _ComfyNodeInternal
 from app.assets.seeder import asset_seeder
 from app.assets.api.routes import register_assets_routes
 from app.assets.services.ingest import register_file_in_place
-from app.assets.services.path_utils import get_known_subfolder_tags
 from app.assets.services.asset_management import resolve_hash_to_path
 
 from app.user_manager import UserManager
@@ -442,9 +441,7 @@ class PromptServer():
                 if args.enable_assets:
                     try:
                         tag = image_upload_type if image_upload_type in ("input", "output") else "input"
-                        tags = [tag]
-                        tags.extend(get_known_subfolder_tags(subfolder))
-                        result = register_file_in_place(abs_path=filepath, name=filename, tags=tags)
+                        result = register_file_in_place(abs_path=filepath, name=filename, tags=[tag])
                         resp["asset"] = {
                             "id": result.ref.id,
                             "name": result.ref.name,

tests-unit/app_test/model_manager_test.py

@@ -24,28 +24,6 @@ def app(model_manager):
     app.add_routes(routes)
     return app
 
-async def test_get_model_folders_includes_registered_extensions(aiohttp_client, app, tmp_path):
-    """Folders expose their registered extension set verbatim; an empty list
-    means match-all (filter_files_extensions semantics)."""
-    with patch('folder_paths.folder_names_and_paths', {
-        'test_checkpoints': ([str(tmp_path)], {'.safetensors', '.ckpt'}),
-        'test_configs': ([str(tmp_path)], ['.yaml']),
-        'test_match_all': ([str(tmp_path)], set()),
-        'configs': ([str(tmp_path)], ['.yaml']),
-    }):
-        client = await aiohttp_client(app)
-        response = await client.get('/experiment/models')
-
-        assert response.status == 200
-        folders = {f['name']: f for f in await response.json()}
-
-        assert 'configs' not in folders  # blocklisted
-        assert folders['test_checkpoints']['folders'] == [str(tmp_path)]
-        assert folders['test_checkpoints']['extensions'] == ['.ckpt', '.safetensors']
-        assert folders['test_configs']['extensions'] == ['.yaml']
-        # Match-all registrations are exposed honestly, not substituted.
-        assert folders['test_match_all']['extensions'] == []
-
 async def test_get_model_preview_safetensors(aiohttp_client, app, tmp_path):
     img = Image.new('RGB', (100, 100), 'white')
     img_byte_arr = BytesIO()

tests-unit/app_test/test_migrations.py

@@ -8,7 +8,6 @@ upgrade/downgrade for 0003+.
 """
 
 import os
-import sqlite3
 
 import pytest
 from alembic import command
@@ -31,12 +30,6 @@ def _make_config(db_path: str) -> Config:
     return cfg
 
 
-def _sqlite_path(cfg: Config) -> str:
-    url = cfg.get_main_option("sqlalchemy.url")
-    assert url is not None and url.startswith("sqlite:///")
-    return url.removeprefix("sqlite:///")
-
-
 @pytest.fixture
 def migration_db(tmp_path):
     """Yield an alembic Config pre-upgraded to the baseline revision."""
@@ -62,26 +55,3 @@ def test_upgrade_downgrade_cycle(migration_db):
     command.upgrade(migration_db, "head")
     command.downgrade(migration_db, _BASELINE)
     command.upgrade(migration_db, "head")
-
-
-def test_case_sensitive_tags_downgrade_normalizes_existing_tags(migration_db):
-    """Downgrading 0005 folds mixed-case tag vocabulary before restoring CHECK."""
-    command.upgrade(migration_db, "0005_allow_case_sensitive_tags")
-
-    db_path = _sqlite_path(migration_db)
-    with sqlite3.connect(db_path) as conn:
-        conn.execute("INSERT INTO tags(name) VALUES (?)", ("NewTag",))
-        conn.execute("INSERT INTO tags(name) VALUES (?)", ("newtag",))
-        conn.execute("INSERT INTO tags(name) VALUES (?)", ("model_type:LLM",))
-
-    command.downgrade(migration_db, "0004_drop_tag_type")
-
-    with sqlite3.connect(db_path) as conn:
-        tags = {row[0] for row in conn.execute("SELECT name FROM tags")}
-        assert "newtag" in tags
-        assert "model_type:llm" in tags
-        assert "NewTag" not in tags
-        assert "model_type:LLM" not in tags
-
-        with pytest.raises(sqlite3.IntegrityError):
-            conn.execute("INSERT INTO tags(name) VALUES (?)", ("Upper",))

tests-unit/assets_test/conftest.py

@@ -234,7 +234,7 @@ def seeded_asset(request: pytest.FixtureRequest, http: requests.Session, api_bas
     p = getattr(request, "param", {}) or {}
     tags: Optional[list[str]] = p.get("tags")
     if tags is None:
-        tags = ["models", "model_type:checkpoints", "unit-tests", "alpha"]
+        tags = ["models", "checkpoints", "unit-tests", "alpha"]
     meta = {"purpose": "test", "epoch": 1, "flags": ["x", "y"], "nullable": None}
     # Unique content per test so the seed always creates a fresh asset (201).
     # Delete is now always a soft delete, so content from a prior test survives

tests-unit/assets_test/queries/test_asset_info.py

@@ -133,66 +133,6 @@ class TestListReferencesPage:
         assert total == 1
         assert refs[0].name == "tagged"
 
-    def test_include_tags_filter_ands_persisted_model_tags(self, session: Session):
-        asset = _make_asset(session, "hash-model-tags")
-        checkpoint = _make_reference(session, asset, name="checkpoint")
-        lora = _make_reference(session, asset, name="lora")
-        input_ref = _make_reference(session, asset, name="input")
-        ensure_tags_exist(
-            session,
-            ["models", "model_type:checkpoints", "model_type:loras", "unit-tests"],
-        )
-        add_tags_to_reference(
-            session,
-            reference_id=checkpoint.id,
-            tags=["models", "model_type:checkpoints", "unit-tests"],
-            origin="automatic",
-        )
-        add_tags_to_reference(
-            session,
-            reference_id=lora.id,
-            tags=["models", "model_type:loras", "unit-tests"],
-            origin="automatic",
-        )
-        add_tags_to_reference(
-            session,
-            reference_id=input_ref.id,
-            tags=["unit-tests"],
-        )
-        session.commit()
-
-        refs, _, total = list_references_page(
-            session,
-            include_tags=["models", "model_type:checkpoints", "unit-tests"],
-        )
-
-        assert total == 1
-        assert refs[0].id == checkpoint.id
-
-    def test_include_tags_filter_preserves_model_type_case(self, session: Session):
-        asset = _make_asset(session, "hash-model-case")
-        ref = _make_reference(session, asset, name="llm")
-        ensure_tags_exist(session, ["models", "model_type:LLM"])
-        add_tags_to_reference(
-            session,
-            reference_id=ref.id,
-            tags=["models", "model_type:LLM"],
-            origin="automatic",
-        )
-        session.commit()
-
-        refs, _, total = list_references_page(
-            session, include_tags=["models", "model_type:LLM"]
-        )
-        refs_lower, _, total_lower = list_references_page(
-            session, include_tags=["models", "model_type:llm"]
-        )
-
-        assert total == 1
-        assert refs[0].id == ref.id
-        assert total_lower == 0
-        assert refs_lower == []
-
     def test_exclude_tags_filter(self, session: Session):
         asset = _make_asset(session, "hash1")
         _make_reference(session, asset, name="keep")

tests-unit/assets_test/queries/test_cache_state.py

@@ -176,39 +176,6 @@ class TestUpsertReference:
         ref = session.query(AssetReference).filter_by(file_path=file_path).one()
         assert ref.mtime_ns == final_mtime
 
-    def test_upsert_refreshes_loader_path_on_existing_reference(self, session: Session):
-        """Re-ingesting an existing reference writes the loader_path computed
-        by that ingest, healing NULL or stale values even when nothing else
-        about the row changed."""
-        asset = _make_asset(session, "hash1")
-        file_path = "/models/checkpoints/sub/model.safetensors"
-
-        upsert_reference(
-            session, asset_id=asset.id, file_path=file_path, name="model",
-            mtime_ns=100, loader_path=None,
-        )
-        session.commit()
-
-        created, updated = upsert_reference(
-            session, asset_id=asset.id, file_path=file_path, name="model",
-            mtime_ns=100, loader_path="sub/model.safetensors",
-        )
-        session.commit()
-
-        assert created is False
-        assert updated is True
-        ref = session.query(AssetReference).filter_by(file_path=file_path).one()
-        assert ref.loader_path == "sub/model.safetensors"
-
-        # Identical loader_path is a no-op, not a spurious update.
-        created, updated = upsert_reference(
-            session, asset_id=asset.id, file_path=file_path, name="model",
-            mtime_ns=100, loader_path="sub/model.safetensors",
-        )
-        session.commit()
-        assert created is False
-        assert updated is False
-
     def test_upsert_restores_missing_reference(self, session: Session):
         """Upserting a reference that was marked missing should restore it."""
         asset = _make_asset(session, "hash1")

tests-unit/assets_test/queries/test_tags.py

@@ -58,7 +58,7 @@ class TestEnsureTagsExist:
         session.commit()
 
         tags = session.query(Tag).all()
-        assert {t.name for t in tags} == {"ALPHA", "Beta", "alpha"}
+        assert {t.name for t in tags} == {"alpha", "beta"}
 
     def test_empty_list_is_noop(self, session: Session):
         ensure_tags_exist(session, [])
@@ -258,16 +258,6 @@ class TestListTagsWithUsage:
         tag_names = {name for name, _ in rows}
         assert tag_names == {"alpha", "alphabet"}
 
-    def test_prefix_filter_is_case_sensitive(self, session: Session):
-        ensure_tags_exist(session, ["model_type:LLM", "model_type:llm"])
-        session.commit()
-
-        rows, total = list_tags_with_usage(session, prefix="model_type:L")
-
-        tag_names = {name for name, _ in rows}
-        assert tag_names == {"model_type:LLM"}
-        assert total == 1
-
     def test_order_by_name(self, session: Session):
         ensure_tags_exist(session, ["zebra", "alpha", "middle"])
         session.commit()

tests-unit/assets_test/services/test_asset_response_loader_path.py

@@ -1,83 +0,0 @@
-"""Tests for how _build_asset_response derives the response `loader_path`.
-
-Guards the persist-and-read contract: the response reads the stored
-`loader_path` verbatim, with no read-time recomputation. Like tags, the
-value is a seed-time derivative healed by the scan lifecycle.
-"""
-
-from datetime import datetime
-from pathlib import Path
-from unittest.mock import patch
-
-from app.assets.api.routes import _build_asset_response
-from app.assets.services.schemas import AssetDetailResult, ReferenceData
-
-_TS = datetime(2024, 1, 1, 0, 0, 0)
-
-
-def _make_result(
-    *, file_path: str | None, loader_path: str | None
-) -> AssetDetailResult:
-    ref = ReferenceData(
-        id="ref-1",
-        name="model.safetensors",
-        file_path=file_path,
-        loader_path=loader_path,
-        user_metadata=None,
-        preview_id=None,
-        created_at=_TS,
-        updated_at=_TS,
-        last_access_time=_TS,
-    )
-    return AssetDetailResult(ref=ref, asset=None, tags=[])
-
-
-def test_uses_persisted_loader_path_without_recomputing():
-    """A stored loader_path is returned verbatim, not re-derived from file_path.
-
-    The sentinel value could never be produced by compute_loader_path for this
-    file_path, so seeing it in the response proves the stored column is read.
-    """
-    result = _make_result(
-        file_path="/unmatched/root/model.safetensors",
-        loader_path="SENTINEL/stored.safetensors",
-    )
-
-    resp = _build_asset_response(result)
-
-    assert resp.loader_path == "SENTINEL/stored.safetensors"
-
-
-def test_null_stored_loader_path_is_served_as_null(tmp_path: Path):
-    """No read-time recomputation: a NULL column is served as null even when
-    the path would resolve."""
-    models = tmp_path / "models"
-    ckpt = models / "checkpoints"
-    ckpt.mkdir(parents=True)
-    f = ckpt / "bar.safetensors"
-    f.touch()
-
-    with patch("app.assets.services.path_utils.folder_paths") as mock_fp, patch(
-        "app.assets.services.path_utils.get_comfy_models_folders",
-        return_value=[("checkpoints", [str(ckpt)], {".safetensors"})],
-    ):
-        mock_fp.get_input_directory.return_value = str(tmp_path / "in")
-        mock_fp.get_output_directory.return_value = str(tmp_path / "out")
-        mock_fp.get_temp_directory.return_value = str(tmp_path / "tmp")
-        mock_fp.models_dir = str(models)
-
-        result = _make_result(file_path=str(f), loader_path=None)
-        resp = _build_asset_response(result)
-
-        assert resp.loader_path is None
-        assert resp.display_name == "checkpoints/bar.safetensors"
-
-
-def test_all_path_fields_null_without_file_path():
-    """API-created / hash-only references (no file_path) expose no paths."""
-    result = _make_result(file_path=None, loader_path=None)
-
-    resp = _build_asset_response(result)
-
-    assert resp.loader_path is None
-    assert resp.display_name is None

tests-unit/assets_test/services/test_bulk_ingest.py

@@ -1,14 +1,10 @@
 """Tests for bulk ingest services."""
 
-import os
 from pathlib import Path
-from unittest.mock import patch
 
 from sqlalchemy.orm import Session
 
 from app.assets.database.models import Asset, AssetReference
-from app.assets.database.queries import get_reference_tags
-from app.assets.scanner import build_asset_specs
 from app.assets.services.bulk_ingest import SeedAssetSpec, batch_insert_seed_assets
 
 
@@ -105,184 +101,6 @@ class TestBatchInsertSeedAssets:
             asset = session.query(Asset).filter_by(id=ref.asset_id).first()
             assert asset.mime_type == expected_mime, f"Expected {expected_mime} for {filename}, got {asset.mime_type}"
 
-    def test_duplicate_paths_merge_tags_before_insert(
-        self, session: Session, temp_dir: Path
-    ):
-        """Overlapping model-folder registrations can emit the same path twice."""
-        file_path = temp_dir / "shared.safetensors"
-        file_path.write_bytes(b"shared model")
-
-        specs: list[SeedAssetSpec] = [
-            {
-                "abs_path": str(file_path),
-                "size_bytes": 12,
-                "mtime_ns": 1234567890000000000,
-                "info_name": "Shared Model",
-                "tags": ["models", "model_type:checkpoints"],
-                "fname": "shared.safetensors",
-                "metadata": None,
-                "hash": None,
-                "mime_type": "application/safetensors",
-            },
-            {
-                "abs_path": str(file_path),
-                "size_bytes": 12,
-                "mtime_ns": 1234567890000000000,
-                "info_name": "Shared Model",
-                "tags": ["models", "model_type:diffusion_models"],
-                "fname": "shared.safetensors",
-                "metadata": None,
-                "hash": None,
-                "mime_type": "application/safetensors",
-            },
-        ]
-
-        result = batch_insert_seed_assets(session, specs=specs, owner_id="")
-
-        assert result.inserted_refs == 1
-        assert result.won_paths == 1
-        refs = session.query(AssetReference).all()
-        assert len(refs) == 1
-        assert set(get_reference_tags(session, reference_id=refs[0].id)) == {
-            "models",
-            "model_type:checkpoints",
-            "model_type:diffusion_models",
-        }
-
-    def test_duplicate_paths_are_merged_after_abspath_normalization(
-        self, session: Session, temp_dir: Path, monkeypatch
-    ):
-        """The scanner may emit equivalent paths with different spelling."""
-        file_path = temp_dir / "same-file.safetensors"
-        file_path.write_bytes(b"shared model")
-        monkeypatch.chdir(temp_dir)
-        relative_path = file_path.name
-        absolute_path = os.path.abspath(relative_path)
-
-        specs: list[SeedAssetSpec] = [
-            {
-                "abs_path": relative_path,
-                "size_bytes": 12,
-                "mtime_ns": 1234567890000000000,
-                "info_name": "Shared Model",
-                "tags": ["models", "model_type:checkpoints"],
-                "fname": "same-file.safetensors",
-                "metadata": None,
-                "hash": None,
-                "mime_type": "application/safetensors",
-            },
-            {
-                "abs_path": absolute_path,
-                "size_bytes": 12,
-                "mtime_ns": 1234567890000000000,
-                "info_name": "Shared Model",
-                "tags": ["models", "model_type:diffusion_models"],
-                "fname": "same-file.safetensors",
-                "metadata": None,
-                "hash": None,
-                "mime_type": "application/safetensors",
-            },
-        ]
-
-        result = batch_insert_seed_assets(session, specs=specs, owner_id="")
-
-        assert result.inserted_refs == 1
-        assert result.won_paths == 1
-        refs = session.query(AssetReference).all()
-        assert len(refs) == 1
-        assert refs[0].file_path == absolute_path
-        # loader_path is persisted from the spec's fname (compute_loader_path).
-        assert refs[0].loader_path == "same-file.safetensors"
-        assert set(get_reference_tags(session, reference_id=refs[0].id)) == {
-            "models",
-            "model_type:checkpoints",
-            "model_type:diffusion_models",
-        }
-
-    def test_scanner_duplicate_shared_model_paths_keep_all_model_type_tags(
-        self, session: Session, temp_dir: Path
-    ):
-        """Shared extra model roots make scanner collection emit duplicate paths."""
-        shared_root = temp_dir / "shared"
-        input_dir = temp_dir / "input"
-        output_dir = temp_dir / "output"
-        temp_root = temp_dir / "temp"
-        for directory in (shared_root, input_dir, output_dir, temp_root):
-            directory.mkdir()
-        file_path = shared_root / "dual_use_model.safetensors"
-        file_path.write_bytes(b"shared model")
-
-        with (
-            patch("app.assets.services.path_utils.folder_paths") as mock_fp,
-            patch(
-                "app.assets.services.path_utils.get_comfy_models_folders",
-                return_value=[
-                    ("checkpoints", [str(shared_root)], {".safetensors"}),
-                    ("diffusion_models", [str(shared_root)], {".safetensors"}),
-                ],
-            ),
-        ):
-            mock_fp.get_input_directory.return_value = str(input_dir)
-            mock_fp.get_output_directory.return_value = str(output_dir)
-            mock_fp.get_temp_directory.return_value = str(temp_root)
-
-            specs, tag_pool, skipped = build_asset_specs(
-                paths=[str(file_path), str(file_path)],
-                existing_paths=set(),
-                enable_metadata_extraction=False,
-                compute_hashes=False,
-            )
-
-        assert skipped == 0
-        assert len(specs) == 2
-        assert tag_pool == {
-            "models",
-            "model_type:checkpoints",
-            "model_type:diffusion_models",
-        }
-
-        result = batch_insert_seed_assets(session, specs=specs, owner_id="")
-
-        assert result.inserted_refs == 1
-        assert result.won_paths == 1
-        refs = session.query(AssetReference).all()
-        assert len(refs) == 1
-        assert set(get_reference_tags(session, reference_id=refs[0].id)) == {
-            "models",
-            "model_type:checkpoints",
-            "model_type:diffusion_models",
-        }
-
-    def test_loader_path_persisted_as_null_when_fname_is_none(
-        self, session: Session, temp_dir: Path
-    ):
-        """A file with no in-root loader path (fname=None, e.g. an orphan under
-        models_root) persists loader_path as NULL rather than a synthesized value."""
-        file_path = temp_dir / "orphan.bin"
-        file_path.write_bytes(b"x")
-
-        specs: list[SeedAssetSpec] = [
-            {
-                "abs_path": str(file_path),
-                "size_bytes": 1,
-                "mtime_ns": 1234567890000000000,
-                "info_name": "orphan.bin",
-                "tags": [],
-                "fname": None,
-                "metadata": None,
-                "hash": None,
-                "mime_type": None,
-            }
-        ]
-
-        result = batch_insert_seed_assets(session, specs=specs, owner_id="")
-
-        assert result.inserted_refs == 1
-        refs = session.query(AssetReference).all()
-        assert len(refs) == 1
-        assert refs[0].file_path == str(file_path)
-        assert refs[0].loader_path is None
-
 
 class TestMetadataExtraction:
     def test_extracts_mime_type_for_model_files(self, temp_dir: Path):

tests-unit/assets_test/services/test_ingest.py

@@ -94,47 +94,6 @@ class TestIngestFileFromPath:
         ref_tags = get_reference_tags(session, reference_id=result.reference_id)
         assert set(ref_tags) == {"models", "checkpoints"}
 
-    def test_path_derived_tags_use_automatic_origin(
-        self, mock_create_session, temp_dir: Path, session: Session
-    ):
-        input_dir = temp_dir / "input"
-        output_dir = temp_dir / "output"
-        temp_root = temp_dir / "temp"
-        for directory in (input_dir, output_dir, temp_root):
-            directory.mkdir()
-        file_path = input_dir / "pasted" / "tagged.png"
-        file_path.parent.mkdir()
-        file_path.write_bytes(b"data")
-
-        with (
-            patch("app.assets.services.path_utils.folder_paths") as mock_fp,
-            patch(
-                "app.assets.services.path_utils.get_comfy_models_folders",
-                return_value=[],
-            ),
-        ):
-            mock_fp.get_input_directory.return_value = str(input_dir)
-            mock_fp.get_output_directory.return_value = str(output_dir)
-            mock_fp.get_temp_directory.return_value = str(temp_root)
-
-            result = _ingest_file_from_path(
-                abs_path=str(file_path),
-                asset_hash="blake3:pathorigin",
-                size_bytes=4,
-                mtime_ns=1234567890000000000,
-                info_name="Tagged Asset",
-                tags=["input", "manual-label"],
-            )
-
-        assert result.reference_id is not None
-        links = session.query(AssetReferenceTag).filter_by(
-            asset_reference_id=result.reference_id
-        )
-        origin_by_tag = {link.tag_name: link.origin for link in links}
-        assert origin_by_tag["input"] == "automatic"
-        assert origin_by_tag["pasted"] == "automatic"
-        assert origin_by_tag["manual-label"] == "manual"
-
     def test_idempotent_upsert(self, mock_create_session, temp_dir: Path, session: Session):
         file_path = temp_dir / "dup.bin"
         file_path.write_bytes(b"content")
@@ -329,45 +288,6 @@ class TestIngestExistingFileTagFK:
             assert "output" in ref_tag_names
 
 
-class TestIngestExistingFileLoaderPath:
-    """Outputs saved into a subfolder must persist the subfolder-qualified
-    loader path, not the bare basename (regression: spec["fname"] was
-    os.path.basename)."""
-
-    def test_subfoldered_output_persists_relative_loader_path(
-        self, mock_create_session, temp_dir: Path, session: Session
-    ):
-        input_dir = temp_dir / "input"
-        output_dir = temp_dir / "output"
-        temp_root = temp_dir / "temp"
-        for directory in (input_dir, output_dir, temp_root):
-            directory.mkdir()
-        file_path = output_dir / "sub" / "img_00001_.png"
-        file_path.parent.mkdir()
-        file_path.write_bytes(b"image data")
-
-        with (
-            patch("app.assets.services.path_utils.folder_paths") as mock_fp,
-            patch(
-                "app.assets.services.path_utils.get_comfy_models_folders",
-                return_value=[],
-            ),
-        ):
-            mock_fp.get_input_directory.return_value = str(input_dir)
-            mock_fp.get_output_directory.return_value = str(output_dir)
-            mock_fp.get_temp_directory.return_value = str(temp_root)
-
-            assert ingest_existing_file(abs_path=str(file_path)) is True
-
-        ref = (
-            session.query(AssetReference)
-            .filter_by(file_path=str(file_path))
-            .one()
-        )
-        assert ref.loader_path == "sub/img_00001_.png"
-        assert (ref.user_metadata or {}).get("filename") == "sub/img_00001_.png"
-
-
 class TestIngestImageDimensions:
     """system_metadata should carry {kind, width, height} for image assets."""
 

tests-unit/assets_test/services/test_path_utils.py

@@ -6,16 +6,7 @@ from unittest.mock import patch
 
 import pytest
 
-from app.assets.services.path_utils import (
-    compute_display_name,
-    compute_loader_path,
-    compute_logical_path,
-    get_asset_category_and_relative_path,
-    get_known_input_subfolder_tags_from_path,
-    get_known_subfolder_tags,
-    get_name_and_tags_from_asset_path,
-    resolve_destination_from_tags,
-)
+from app.assets.services.path_utils import get_asset_category_and_relative_path
 
 
 @pytest.fixture
@@ -26,8 +17,7 @@ def fake_dirs():
         input_dir = root_path / "input"
         output_dir = root_path / "output"
         temp_dir = root_path / "temp"
-        models_root = root_path / "models"
-        models_dir = models_root / "checkpoints"
+        models_dir = root_path / "models" / "checkpoints"
         for d in (input_dir, output_dir, temp_dir, models_dir):
             d.mkdir(parents=True)
 
@@ -35,17 +25,15 @@ def fake_dirs():
             mock_fp.get_input_directory.return_value = str(input_dir)
             mock_fp.get_output_directory.return_value = str(output_dir)
             mock_fp.get_temp_directory.return_value = str(temp_dir)
-            mock_fp.models_dir = str(models_root)
 
             with patch(
                 "app.assets.services.path_utils.get_comfy_models_folders",
-                return_value=[("checkpoints", [str(models_dir)], {".safetensors"})],
+                return_value=[("checkpoints", [str(models_dir)])],
             ):
                 yield {
                     "input": input_dir,
                     "output": output_dir,
                     "temp": temp_dir,
-                    "models_root": models_root,
                     "models": models_dir,
                 }
 
@@ -88,538 +76,6 @@ class TestGetAssetCategoryAndRelativePath:
         cat, rel = get_asset_category_and_relative_path(str(f))
         assert cat == "models"
 
-    def test_model_path_tags_include_registered_model_type_only(self, fake_dirs):
-        f = fake_dirs["models"] / "subdir" / "model.safetensors"
-        f.parent.mkdir()
-        f.touch()
-
-        _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:checkpoints" in tags
-        assert "checkpoints" not in tags
-        assert "subdir" not in tags
-
-    def test_model_type_preserves_registered_folder_case(self, fake_dirs):
-        llm_dir = fake_dirs["models"].parent / "LLM"
-        llm_dir.mkdir()
-        f = llm_dir / "model.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("LLM", [str(llm_dir)], {".safetensors"})],
-        ):
-            _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:LLM" in tags
-        assert "model_type:llm" not in tags
-
-    def test_path_components_do_not_create_model_type_tags(self, fake_dirs):
-        f = fake_dirs["models"] / "loras" / "model.safetensors"
-        f.parent.mkdir()
-        f.touch()
-
-        _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:checkpoints" in tags
-        assert "loras" not in tags
-        assert "model_type:loras" not in tags
-
-    def test_shared_root_returns_all_matching_model_type_tags(self, fake_dirs):
-        shared_root = fake_dirs["models"].parent / "shared"
-        shared_root.mkdir()
-        f = shared_root / "foo.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[
-                ("checkpoints", [str(shared_root)], {".safetensors"}),
-                ("loras", [str(shared_root)], {".safetensors"}),
-            ],
-        ):
-            _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:checkpoints" in tags
-        assert "model_type:loras" in tags
-
-    def test_shared_root_model_type_tags_respect_bucket_extensions(self, fake_dirs):
-        """Buckets sharing a base dir only tag files matching their extensions."""
-        shared_root = fake_dirs["models"].parent / "unet"
-        shared_root.mkdir()
-        safetensors_file = shared_root / "wan.safetensors"
-        gguf_file = shared_root / "wan.gguf"
-        safetensors_file.touch()
-        gguf_file.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[
-                ("diffusion_models", [str(shared_root)], {".safetensors"}),
-                ("unet_gguf", [str(shared_root)], {".gguf"}),
-            ],
-        ):
-            _name, safetensors_tags = get_name_and_tags_from_asset_path(str(safetensors_file))
-            _name, gguf_tags = get_name_and_tags_from_asset_path(str(gguf_file))
-
-        assert "model_type:diffusion_models" in safetensors_tags
-        assert "model_type:unet_gguf" not in safetensors_tags
-        assert "model_type:unet_gguf" in gguf_tags
-        assert "model_type:diffusion_models" not in gguf_tags
-
-    def test_empty_extension_set_tags_any_extension(self, fake_dirs):
-        """Custom buckets registered without extensions accept every file."""
-        custom_root = fake_dirs["models"].parent / "custom_bucket"
-        custom_root.mkdir()
-        f = custom_root / "weights.bin"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("custom_bucket", [str(custom_root)], set())],
-        ):
-            _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:custom_bucket" in tags
-
-    def test_no_extension_match_keeps_models_tag_without_model_type(self, fake_dirs):
-        f = fake_dirs["models"] / "notes.txt"
-        f.touch()
-
-        _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert not any(tag.startswith("model_type:") for tag in tags)
-
-    def test_output_backed_registered_folder_gets_model_and_output_tags(self, fake_dirs):
-        output_checkpoints_dir = fake_dirs["output"] / "checkpoints"
-        output_checkpoints_dir.mkdir()
-        f = output_checkpoints_dir / "saved.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("checkpoints", [str(output_checkpoints_dir)], {".safetensors"})],
-        ):
-            _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "models" in tags
-        assert "model_type:checkpoints" in tags
-        assert "output" in tags
-
-    def test_temp_path_tags_include_temp_not_output_or_preview(self, fake_dirs):
-        f = fake_dirs["temp"] / "preview.png"
-        f.touch()
-
-        _name, tags = get_name_and_tags_from_asset_path(str(f))
-
-        assert "temp" in tags
-        assert "output" not in tags
-        assert "preview:true" not in tags
-
-    def test_known_subfolder_tags_are_centralized(self):
-        assert get_known_subfolder_tags("pasted") == ["pasted"]
-        assert get_known_subfolder_tags("arbitrary") == []
-
-    def test_known_input_subfolder_tags_are_path_derived_for_direct_children(self, fake_dirs):
-        f = fake_dirs["input"] / "pasted" / "image.png"
-        f.parent.mkdir()
-        f.touch()
-
-        assert get_known_input_subfolder_tags_from_path(str(f)) == ["pasted"]
-
-        _name, tags = get_name_and_tags_from_asset_path(str(f))
-        assert "input" in tags
-        assert "pasted" in tags
-
-    def test_known_input_subfolder_tags_do_not_apply_to_nested_or_other_roots(self, fake_dirs):
-        nested = fake_dirs["input"] / "pasted" / "session" / "image.png"
-        output = fake_dirs["output"] / "pasted" / "image.png"
-        for path in (nested, output):
-            path.parent.mkdir(parents=True)
-            path.touch()
-
-        assert get_known_input_subfolder_tags_from_path(str(nested)) == []
-        assert get_known_input_subfolder_tags_from_path(str(output)) == []
-
     def test_unknown_path_raises(self, fake_dirs):
         with pytest.raises(ValueError, match="not within"):
             get_asset_category_and_relative_path("/some/random/path.png")
-
-
-class TestResponseStoragePaths:
-    def test_input_file_path_and_display_name_include_subfolder(self, fake_dirs):
-        sub = fake_dirs["input"] / "some" / "folder"
-        sub.mkdir(parents=True)
-        f = sub / "image.png"
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "input/some/folder/image.png"
-        assert compute_display_name(str(f)) == "some/folder/image.png"
-
-    def test_output_file_path_and_display_name_include_subfolder(self, fake_dirs):
-        sub = fake_dirs["output"] / "renders"
-        sub.mkdir()
-        f = sub / "ComfyUI_00001_.png"
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "output/renders/ComfyUI_00001_.png"
-        assert compute_display_name(str(f)) == "renders/ComfyUI_00001_.png"
-
-    def test_temp_file_path_and_display_name(self, fake_dirs):
-        f = fake_dirs["temp"] / "preview.png"
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "temp/preview.png"
-        assert compute_display_name(str(f)) == "preview.png"
-
-    def test_exact_storage_root_has_no_display_name(self, fake_dirs):
-        assert compute_logical_path(str(fake_dirs["input"])) == "input"
-        assert compute_display_name(str(fake_dirs["input"])) is None
-
-    def test_longest_matching_builtin_root_wins(self, fake_dirs, tmp_path: Path):
-        nested_output = fake_dirs["input"] / "nested-output"
-        nested_output.mkdir()
-        f = nested_output / "image.png"
-        f.touch()
-
-        with patch("app.assets.services.path_utils.folder_paths") as mock_fp:
-            mock_fp.get_input_directory.return_value = str(fake_dirs["input"])
-            mock_fp.get_output_directory.return_value = str(nested_output)
-            mock_fp.get_temp_directory.return_value = str(tmp_path / "temp")
-            mock_fp.models_dir = str(fake_dirs["models_root"])
-
-            assert compute_logical_path(str(f)) == "output/image.png"
-            assert compute_display_name(str(f)) == "image.png"
-
-    def test_model_file_path_is_relative_to_physical_models_root(self, fake_dirs):
-        sub = fake_dirs["models"] / "flux"
-        sub.mkdir()
-        f = sub / "model.safetensors"
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "models/checkpoints/flux/model.safetensors"
-        assert compute_display_name(str(f)) == "checkpoints/flux/model.safetensors"
-
-        name, tags = get_name_and_tags_from_asset_path(str(f))
-        assert name == "model.safetensors"
-        assert "models" in tags
-        assert "model_type:checkpoints" in tags
-        assert "checkpoints" not in tags
-        assert "flux" not in tags
-
-    @pytest.mark.parametrize(
-        "folder_name",
-        ["checkpoints", "clip", "vae", "diffusion_models", "loras"],
-    )
-    def test_output_model_folder_uses_output_storage_file_path(self, fake_dirs, folder_name):
-        output_model_dir = fake_dirs["output"] / folder_name
-        output_model_dir.mkdir(exist_ok=True)
-        default_model_dir = fake_dirs["models_root"] / folder_name
-        default_model_dir.mkdir(exist_ok=True)
-        f = output_model_dir / "saved.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[
-                (folder_name, [str(default_model_dir), str(output_model_dir)], {".safetensors"})
-            ],
-        ):
-            assert compute_logical_path(str(f)) == f"output/{folder_name}/saved.safetensors"
-            assert compute_display_name(str(f)) == f"{folder_name}/saved.safetensors"
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "saved.safetensors"
-            assert "output" in tags
-            assert "models" in tags
-            assert f"model_type:{folder_name}" in tags
-            assert folder_name not in tags
-
-    def test_output_model_subfolder_uses_output_storage_file_path(self, fake_dirs):
-        folder_name = "loras"
-        output_model_dir = fake_dirs["output"] / folder_name
-        subdir = output_model_dir / "experiments"
-        subdir.mkdir(parents=True)
-        f = subdir / "my_lora.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[(folder_name, [str(output_model_dir)], {".safetensors"})],
-        ):
-            assert (
-                compute_logical_path(str(f))
-                == "output/loras/experiments/my_lora.safetensors"
-            )
-            assert compute_display_name(str(f)) == "loras/experiments/my_lora.safetensors"
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "my_lora.safetensors"
-            assert "output" in tags
-            assert "models" in tags
-            assert "model_type:loras" in tags
-            assert "loras" not in tags
-            assert "experiments" not in tags
-
-    def test_external_model_folder_without_provenance_has_no_file_path(self, tmp_path: Path):
-        external_checkpoints_dir = tmp_path / "external" / "not_named_like_category"
-        external_checkpoints_dir.mkdir(parents=True)
-        f = external_checkpoints_dir / "external.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("checkpoints", [str(external_checkpoints_dir)], {".safetensors"})],
-        ):
-            assert compute_logical_path(str(f)) is None
-            assert compute_display_name(str(f)) is None
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "external.safetensors"
-            assert "models" in tags
-            assert "model_type:checkpoints" in tags
-
-    def test_same_relative_model_file_under_multiple_external_roots_has_no_storage_file_path(
-        self, tmp_path: Path
-    ):
-        foo_dir = tmp_path / "foo"
-        bar_dir = tmp_path / "bar"
-        foo_dir.mkdir()
-        bar_dir.mkdir()
-        foo_file = foo_dir / "baz.safetensors"
-        bar_file = bar_dir / "baz.safetensors"
-        foo_file.touch()
-        bar_file.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("checkpoints", [str(foo_dir), str(bar_dir)], {".safetensors"})],
-        ):
-            assert compute_logical_path(str(foo_file)) is None
-            assert compute_logical_path(str(bar_file)) is None
-            assert compute_display_name(str(foo_file)) is None
-            assert compute_display_name(str(bar_file)) is None
-
-    def test_output_clip_folder_uses_output_storage_and_text_encoder_tag(self, fake_dirs):
-        output_clip_dir = fake_dirs["output"] / "clip"
-        output_clip_dir.mkdir()
-        f = output_clip_dir / "clip_l.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("text_encoders", [str(output_clip_dir)], {".safetensors"})],
-        ):
-            assert compute_logical_path(str(f)) == "output/clip/clip_l.safetensors"
-            assert compute_display_name(str(f)) == "clip/clip_l.safetensors"
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "clip_l.safetensors"
-            assert "output" in tags
-            assert "models" in tags
-            assert "model_type:text_encoders" in tags
-            assert "clip" not in tags
-
-    def test_physical_unet_folder_uses_storage_path_and_diffusion_models_tag(self, fake_dirs):
-        unet_dir = fake_dirs["models_root"] / "unet"
-        diffusion_models_dir = fake_dirs["models_root"] / "diffusion_models"
-        unet_dir.mkdir()
-        diffusion_models_dir.mkdir()
-        f = unet_dir / "wan.safetensors"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[
-                ("diffusion_models", [str(unet_dir), str(diffusion_models_dir)], {".safetensors"})
-            ],
-        ):
-            assert compute_logical_path(str(f)) == "models/unet/wan.safetensors"
-            assert compute_display_name(str(f)) == "unet/wan.safetensors"
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "wan.safetensors"
-            assert "models" in tags
-            assert "model_type:diffusion_models" in tags
-            assert "unet" not in tags
-
-    def test_unregistered_file_under_physical_models_root_still_has_storage_file_path(self, fake_dirs):
-        f = fake_dirs["models_root"] / "not_registered" / "orphan.bin"
-        f.parent.mkdir()
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "models/not_registered/orphan.bin"
-        assert compute_display_name(str(f)) == "not_registered/orphan.bin"
-
-    def test_output_checkpoint_folder_without_registration_has_only_output_tag(self, fake_dirs):
-        f = fake_dirs["output"] / "checkpoints" / "saved.safetensors"
-        f.parent.mkdir(exist_ok=True)
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[],
-        ):
-            assert compute_logical_path(str(f)) == "output/checkpoints/saved.safetensors"
-            assert compute_display_name(str(f)) == "checkpoints/saved.safetensors"
-
-            name, tags = get_name_and_tags_from_asset_path(str(f))
-            assert name == "saved.safetensors"
-            assert "output" in tags
-            assert "models" not in tags
-            assert not any(tag.startswith("model_type:") for tag in tags)
-
-    def test_unknown_path_returns_none(self):
-        assert compute_logical_path("/some/random/path.png") is None
-        assert compute_display_name("/some/random/path.png") is None
-
-
-class TestLoaderPath:
-    """In-root loader path: relative to the storage root, model category dropped."""
-
-    def test_model_loader_path_drops_category(self, fake_dirs):
-        sub = fake_dirs["models"] / "flux"
-        sub.mkdir()
-        f = sub / "model.safetensors"
-        f.touch()
-
-        # logical_path keeps the category, file_path (loader) drops it
-        assert compute_logical_path(str(f)) == "models/checkpoints/flux/model.safetensors"
-        assert compute_loader_path(str(f)) == "flux/model.safetensors"
-
-    def test_model_loader_path_flat_file(self, fake_dirs):
-        f = fake_dirs["models"] / "model.safetensors"
-        f.touch()
-
-        assert compute_loader_path(str(f)) == "model.safetensors"
-
-    def test_input_loader_path_keeps_subfolders(self, fake_dirs):
-        sub = fake_dirs["input"] / "some" / "folder"
-        sub.mkdir(parents=True)
-        f = sub / "image.png"
-        f.touch()
-
-        assert compute_loader_path(str(f)) == "some/folder/image.png"
-
-    def test_temp_loader_path(self, fake_dirs):
-        f = fake_dirs["temp"] / "preview.png"
-        f.touch()
-
-        assert compute_loader_path(str(f)) == "preview.png"
-
-    def test_unregistered_file_under_models_root_has_no_loader_path(self, fake_dirs):
-        # Under models_root but not within any registered category base.
-        f = fake_dirs["models_root"] / "not_registered" / "orphan.bin"
-        f.parent.mkdir()
-        f.touch()
-
-        # It still has a namespaced logical_path, but no loader path.
-        assert compute_logical_path(str(f)) == "models/not_registered/orphan.bin"
-        assert compute_loader_path(str(f)) is None
-
-    def test_extension_mismatch_in_registered_bucket_has_no_loader_path(self, fake_dirs):
-        # Inside a registered bucket, but the bucket's extension set cannot
-        # load it: no model_type tag, and no loader path either.
-        f = fake_dirs["models"] / "notes.txt"
-        f.touch()
-
-        assert compute_logical_path(str(f)) == "models/checkpoints/notes.txt"
-        assert compute_loader_path(str(f)) is None
-
-    def test_shared_base_loader_path_uses_extension_matching_bucket(self, fake_dirs):
-        shared_root = fake_dirs["models"].parent / "unet"
-        shared_root.mkdir()
-        f = shared_root / "wan.gguf"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[
-                ("diffusion_models", [str(shared_root)], {".safetensors"}),
-                ("unet_gguf", [str(shared_root)], {".gguf"}),
-            ],
-        ):
-            assert compute_loader_path(str(f)) == "wan.gguf"
-
-    def test_match_all_bucket_provides_loader_path_for_any_extension(self, fake_dirs):
-        custom_root = fake_dirs["models"].parent / "custom_bucket"
-        custom_root.mkdir()
-        f = custom_root / "weights.bin"
-        f.touch()
-
-        with patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("custom_bucket", [str(custom_root)], set())],
-        ):
-            assert compute_loader_path(str(f)) == "weights.bin"
-
-    def test_extra_path_model_has_loader_path_but_no_logical_path(self, tmp_path: Path):
-        """Registered category base outside models_dir (extra_model_paths style).
-
-        Loadable, so loader_path resolves; but it is not under any canonical
-        storage root, so logical_path/display_name are None. This asymmetry is
-        intentional: loader_path resolves every registered model-folder base,
-        logical_path only resolves the canonical storage roots.
-        """
-        extra = tmp_path / "extra_ckpts"
-        extra.mkdir()
-        f = extra / "foo.safetensors"
-        f.touch()
-
-        with patch("app.assets.services.path_utils.folder_paths") as mock_fp, patch(
-            "app.assets.services.path_utils.get_comfy_models_folders",
-            return_value=[("checkpoints", [str(extra)], {".safetensors"})],
-        ):
-            mock_fp.get_input_directory.return_value = str(tmp_path / "in")
-            mock_fp.get_output_directory.return_value = str(tmp_path / "out")
-            mock_fp.get_temp_directory.return_value = str(tmp_path / "tmp")
-            mock_fp.models_dir = str(tmp_path / "models")  # extra is NOT under this
-
-            assert compute_loader_path(str(f)) == "foo.safetensors"
-            assert compute_logical_path(str(f)) is None
-            assert compute_display_name(str(f)) is None
-
-    def test_unknown_path_returns_none(self):
-        assert compute_loader_path("/some/random/path.png") is None
-
-
-class TestResolveDestinationFromTags:
-    def test_extra_tags_are_not_path_components(self, fake_dirs):
-        base_dir, subdirs = resolve_destination_from_tags(["input", "unit-tests", "foo"])
-
-        assert base_dir == os.path.abspath(fake_dirs["input"])
-        assert subdirs == []
-
-    def test_model_upload_rejects_non_writable_registered_folders(self):
-        with tempfile.TemporaryDirectory() as root:
-            root_path = Path(root)
-            checkpoints_dir = root_path / "models" / "checkpoints"
-            configs_dir = root_path / "models" / "configs"
-            custom_nodes_dir = root_path / "custom_nodes"
-            for path in (checkpoints_dir, configs_dir, custom_nodes_dir):
-                path.mkdir(parents=True)
-
-            with patch("app.assets.services.path_utils.folder_paths") as mock_fp:
-                mock_fp.folder_names_and_paths = {
-                    "checkpoints": ([str(checkpoints_dir)], set()),
-                    "configs": ([str(configs_dir)], set()),
-                    "custom_nodes": ([str(custom_nodes_dir)], set()),
-                }
-
-                base_dir, subdirs = resolve_destination_from_tags(
-                    ["models", "model_type:checkpoints"]
-                )
-                assert base_dir == os.path.abspath(checkpoints_dir)
-                assert subdirs == []
-
-                for folder_name in ("configs", "custom_nodes"):
-                    with pytest.raises(ValueError, match="unknown model category"):
-                        resolve_destination_from_tags(
-                            ["models", f"model_type:{folder_name}"]
-                        )

tests-unit/assets_test/test_assets_missing_sync.py

@@ -19,8 +19,7 @@ def test_seed_asset_removed_when_file_is_deleted(
     """Asset without hash (seed) whose file disappears:
        after triggering sync_seed_assets, Asset + AssetInfo disappear.
     """
-    # Create a file directly under input/unit-tests/<case>. Backend tags only
-    # classify the root; nested path components are not exposed as tags.
+    # Create a file directly under input/unit-tests/<case> so tags include "unit-tests"
     case_dir = comfy_tmp_base_dir / root / "unit-tests" / "syncseed"
     case_dir.mkdir(parents=True, exist_ok=True)
     name = f"seed_{uuid.uuid4().hex[:8]}.bin"
@@ -33,7 +32,7 @@ def test_seed_asset_removed_when_file_is_deleted(
     # Verify it is visible via API and carries no hash (seed)
     r1 = http.get(
         api_base + "/api/assets",
-        params={"include_tags": root, "name_contains": name},
+        params={"include_tags": "unit-tests,syncseed", "name_contains": name},
         timeout=120,
     )
     body1 = r1.json()
@@ -55,7 +54,7 @@ def test_seed_asset_removed_when_file_is_deleted(
     # It should disappear (AssetInfo and seed Asset gone)
     r2 = http.get(
         api_base + "/api/assets",
-        params={"include_tags": root, "name_contains": name},
+        params={"include_tags": "unit-tests,syncseed", "name_contains": name},
         timeout=120,
     )
     body2 = r2.json()
@@ -133,7 +132,7 @@ def test_hashed_asset_two_asset_infos_both_get_missing(
     second_id = b2["id"]
 
     # Remove the single underlying file
-    p = comfy_tmp_base_dir / "input" / get_asset_filename(created["asset_hash"], ".png")
+    p = comfy_tmp_base_dir / "input" / "unit-tests" / "multiinfo" / get_asset_filename(b2["asset_hash"], ".png")
     assert p.exists()
     p.unlink()
 
@@ -251,7 +250,8 @@ def test_missing_tag_clears_on_fastpass_when_mtime_and_size_match(
 
     a = asset_factory(name, [root, "unit-tests", scope], {}, data)
     aid = a["id"]
-    p = comfy_tmp_base_dir / root / get_asset_filename(a["asset_hash"], ".bin")
+    base = comfy_tmp_base_dir / root / "unit-tests" / scope
+    p = base / get_asset_filename(a["asset_hash"], ".bin")
     st0 = p.stat()
     orig_mtime_ns = getattr(st0, "st_mtime_ns", int(st0.st_mtime * 1_000_000_000))
 

tests-unit/assets_test/test_crud.py

@@ -290,7 +290,7 @@ def test_metadata_filename_is_set_for_seed_asset_without_hash(
 
     r1 = http.get(
         api_base + "/api/assets",
-        params={"include_tags": root, "name_contains": name},
+        params={"include_tags": f"unit-tests,{scope}", "name_contains": name},
         timeout=120,
     )
     body = r1.json()

tests-unit/assets_test/test_downloads.py

@@ -23,7 +23,7 @@ def test_download_svg_forced_to_attachment(http: requests.Session, api_base: str
     svg = b'<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>'
     files = {"file": ("evil.svg", svg, "image/svg+xml")}
     form_data = {
-        "tags": json.dumps(["models", "model_type:checkpoints", "unit-tests", "svgxss"]),
+        "tags": json.dumps(["models", "checkpoints", "unit-tests", "svgxss"]),
         "name": "evil.svg",
     }
     up = http.post(api_base + "/api/assets", files=files, data=form_data, timeout=120)
@@ -131,7 +131,7 @@ def test_download_chooses_existing_state_and_updates_access_time(
         assert t1 > t0
 
 
-@pytest.mark.parametrize("seeded_asset", [{"tags": ["models", "model_type:checkpoints"]}], indirect=True)
+@pytest.mark.parametrize("seeded_asset", [{"tags": ["models", "checkpoints"]}], indirect=True)
 def test_download_missing_file_returns_404(
     http: requests.Session, api_base: str, comfy_tmp_base_dir: Path, seeded_asset: dict
 ):

tests-unit/assets_test/test_list_cursor.py

@@ -13,7 +13,7 @@ def _seed(asset_factory, make_asset_bytes, count: int, tag: str) -> list[str]:
     for n in names:
         asset_factory(
             n,
-            ["models", "model_type:checkpoints", "unit-tests", tag],
+            ["models", "checkpoints", "unit-tests", tag],
             {},
             make_asset_bytes(n, size=2048),
         )
@@ -208,7 +208,7 @@ def test_cursor_walks_for_non_name_sorts(sort_field, http: requests.Session, api
     names = []
     for i in range(4):
         n = f"cursor_{sort_field}_{i:02d}.safetensors"
-        asset_factory(n, ["models", "model_type:checkpoints", "unit-tests", f"cursor-{sort_field}"], {}, make_asset_bytes(n, size=2048 + i))
+        asset_factory(n, ["models", "checkpoints", "unit-tests", f"cursor-{sort_field}"], {}, make_asset_bytes(n, size=2048 + i))
         names.append(n)
 
     params = {

tests-unit/assets_test/test_list_filter.py

@@ -11,7 +11,7 @@ def test_list_assets_paging_and_sort(http: requests.Session, api_base: str, asse
     for n in names:
         asset_factory(
             n,
-            ["models", "model_type:checkpoints", "unit-tests", "paging"],
+            ["models", "checkpoints", "unit-tests", "paging"],
             {"epoch": 1},
             make_asset_bytes(n, size=2048),
         )
@@ -45,8 +45,8 @@ def test_list_assets_paging_and_sort(http: requests.Session, api_base: str, asse
 
 
 def test_list_assets_include_exclude_and_name_contains(http: requests.Session, api_base: str, asset_factory):
-    a = asset_factory("inc_a.safetensors", ["models", "model_type:checkpoints", "unit-tests", "alpha"], {}, b"X" * 1024)
-    b = asset_factory("inc_b.safetensors", ["models", "model_type:checkpoints", "unit-tests", "beta"], {}, b"Y" * 1024)
+    a = asset_factory("inc_a.safetensors", ["models", "checkpoints", "unit-tests", "alpha"], {}, b"X" * 1024)
+    b = asset_factory("inc_b.safetensors", ["models", "checkpoints", "unit-tests", "beta"], {}, b"Y" * 1024)
 
     r = http.get(
         api_base + "/api/assets",
@@ -81,7 +81,7 @@ def test_list_assets_include_exclude_and_name_contains(http: requests.Session, a
 
 
 def test_list_assets_sort_by_size_both_orders(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-size"]
+    t = ["models", "checkpoints", "unit-tests", "lf-size"]
     n1, n2, n3 = "sz1.safetensors", "sz2.safetensors", "sz3.safetensors"
     asset_factory(n1, t, {}, make_asset_bytes(n1, 1024))
     asset_factory(n2, t, {}, make_asset_bytes(n2, 2048))
@@ -108,7 +108,7 @@ def test_list_assets_sort_by_size_both_orders(http, api_base, asset_factory, mak
 
 
 def test_list_assets_sort_by_updated_at_desc(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-upd"]
+    t = ["models", "checkpoints", "unit-tests", "lf-upd"]
     a1 = asset_factory("upd_a.safetensors", t, {}, make_asset_bytes("upd_a", 1200))
     a2 = asset_factory("upd_b.safetensors", t, {}, make_asset_bytes("upd_b", 1200))
 
@@ -131,7 +131,7 @@ def test_list_assets_sort_by_updated_at_desc(http, api_base, asset_factory, make
 
 
 def test_list_assets_sort_by_last_access_time_desc(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-access"]
+    t = ["models", "checkpoints", "unit-tests", "lf-access"]
     asset_factory("acc_a.safetensors", t, {}, make_asset_bytes("acc_a", 1100))
     time.sleep(0.02)
     a2 = asset_factory("acc_b.safetensors", t, {}, make_asset_bytes("acc_b", 1100))
@@ -154,14 +154,14 @@ def test_list_assets_sort_by_last_access_time_desc(http, api_base, asset_factory
 
 
 def test_list_assets_include_tags_variants_and_case(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-include"]
+    t = ["models", "checkpoints", "unit-tests", "lf-include"]
     a = asset_factory("incvar_alpha.safetensors", [*t, "alpha"], {}, make_asset_bytes("iva"))
     asset_factory("incvar_beta.safetensors", [*t, "beta"], {}, make_asset_bytes("ivb"))
 
-    # CSV tag filters are whitespace-trimmed and case-sensitive.
+    # CSV + case-insensitive
     r1 = http.get(
         api_base + "/api/assets",
-        params={"include_tags": "unit-tests,lf-include,alpha"},
+        params={"include_tags": "UNIT-TESTS,LF-INCLUDE,alpha"},
         timeout=120,
     )
     b1 = r1.json()
@@ -196,14 +196,14 @@ def test_list_assets_include_tags_variants_and_case(http, api_base, asset_factor
 
 
 def test_list_assets_exclude_tags_dedup_and_case(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-exclude"]
+    t = ["models", "checkpoints", "unit-tests", "lf-exclude"]
     a = asset_factory("ex_a_alpha.safetensors", [*t, "alpha"], {}, make_asset_bytes("exa", 900))
     asset_factory("ex_b_beta.safetensors", [*t, "beta"], {}, make_asset_bytes("exb", 900))
 
-    # Exclude filters are case-sensitive.
+    # Exclude uppercase should work
     r1 = http.get(
         api_base + "/api/assets",
-        params={"include_tags": "unit-tests,lf-exclude", "exclude_tags": "beta"},
+        params={"include_tags": "unit-tests,lf-exclude", "exclude_tags": "BETA"},
         timeout=120,
     )
     b1 = r1.json()
@@ -225,7 +225,7 @@ def test_list_assets_exclude_tags_dedup_and_case(http, api_base, asset_factory,
 
 
 def test_list_assets_name_contains_case_and_specials(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-name"]
+    t = ["models", "checkpoints", "unit-tests", "lf-name"]
     a1 = asset_factory("CaseMix.SAFE", t, {}, make_asset_bytes("cm", 800))
     a2 = asset_factory("case-other.safetensors", t, {}, make_asset_bytes("co", 800))
 
@@ -261,7 +261,7 @@ def test_list_assets_name_contains_case_and_specials(http, api_base, asset_facto
 
 
 def test_list_assets_offset_beyond_total_and_limit_boundary(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "lf-pagelimits"]
+    t = ["models", "checkpoints", "unit-tests", "lf-pagelimits"]
     asset_factory("pl1.safetensors", t, {}, make_asset_bytes("pl1", 600))
     asset_factory("pl2.safetensors", t, {}, make_asset_bytes("pl2", 600))
     asset_factory("pl3.safetensors", t, {}, make_asset_bytes("pl3", 600))
@@ -319,7 +319,7 @@ def test_list_assets_name_contains_literal_underscore(
       - foobar.safetensors       (must NOT match)
     """
     scope = f"lf-underscore-{uuid.uuid4().hex[:6]}"
-    tags = ["models", "model_type:checkpoints", "unit-tests", scope]
+    tags = ["models", "checkpoints", "unit-tests", scope]
 
     a = asset_factory("foo_bar.safetensors", tags, {}, make_asset_bytes("a", 700))
     b = asset_factory("fooxbar.safetensors", tags, {}, make_asset_bytes("b", 700))

tests-unit/assets_test/test_metadata_filters.py

@@ -5,7 +5,7 @@ def test_meta_and_across_keys_and_types(
     http, api_base: str, asset_factory, make_asset_bytes
 ):
     name = "mf_and_mix.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-and"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-and"]
     meta = {"purpose": "mix", "epoch": 1, "active": True, "score": 1.23}
     asset_factory(name, tags, meta, make_asset_bytes(name, 4096))
 
@@ -41,7 +41,7 @@ def test_meta_and_across_keys_and_types(
 
 def test_meta_type_strictness_int_vs_str_and_bool(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_types.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-types"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-types"]
     meta = {"epoch": 1, "active": True}
     asset_factory(name, tags, meta, make_asset_bytes(name))
 
@@ -95,7 +95,7 @@ def test_meta_type_strictness_int_vs_str_and_bool(http, api_base, asset_factory,
 
 def test_meta_any_of_list_of_scalars(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_list_scalars.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-list"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-list"]
     meta = {"flags": ["red", "green"]}
     asset_factory(name, tags, meta, make_asset_bytes(name, 3000))
 
@@ -134,7 +134,7 @@ def test_meta_none_semantics_missing_or_null_and_any_of_with_none(
     http, api_base, asset_factory, make_asset_bytes
 ):
     # a1: key missing; a2: explicit null; a3: concrete value
-    t = ["models", "model_type:checkpoints", "unit-tests", "mf-none"]
+    t = ["models", "checkpoints", "unit-tests", "mf-none"]
     a1 = asset_factory("mf_none_missing.safetensors", t, {"x": 1}, make_asset_bytes("a1"))
     a2 = asset_factory("mf_none_null.safetensors", t, {"maybe": None}, make_asset_bytes("a2"))
     a3 = asset_factory("mf_none_value.safetensors", t, {"maybe": "x"}, make_asset_bytes("a3"))
@@ -166,7 +166,7 @@ def test_meta_none_semantics_missing_or_null_and_any_of_with_none(
 
 def test_meta_nested_json_object_equality(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_nested_json.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-nested"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-nested"]
     cfg = {"optimizer": "adam", "lr": 0.001, "schedule": {"type": "cosine", "warmup": 100}}
     asset_factory(name, tags, {"config": cfg}, make_asset_bytes(name, 2200))
 
@@ -197,7 +197,7 @@ def test_meta_nested_json_object_equality(http, api_base, asset_factory, make_as
 
 def test_meta_list_of_objects_any_of(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_list_objects.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-objlist"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-objlist"]
     transforms = [{"type": "crop", "size": 128}, {"type": "flip", "p": 0.5}]
     asset_factory(name, tags, {"transforms": transforms}, make_asset_bytes(name, 2048))
 
@@ -228,7 +228,7 @@ def test_meta_list_of_objects_any_of(http, api_base, asset_factory, make_asset_b
 
 def test_meta_with_special_and_unicode_keys(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_keys_unicode.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-keys"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-keys"]
     meta = {
         "weird.key": "v1",
         "path/like": 7,
@@ -259,7 +259,7 @@ def test_meta_with_special_and_unicode_keys(http, api_base, asset_factory, make_
 
 
 def test_meta_with_zero_and_boolean_lists(http, api_base, asset_factory, make_asset_bytes):
-    t = ["models", "model_type:checkpoints", "unit-tests", "mf-zero-bool"]
+    t = ["models", "checkpoints", "unit-tests", "mf-zero-bool"]
     a0 = asset_factory("mf_zero_count.safetensors", t, {"count": 0}, make_asset_bytes("z", 1025))
     a1 = asset_factory("mf_bool_list.safetensors", t, {"choices": [True, False]}, make_asset_bytes("b", 1026))
 
@@ -286,7 +286,7 @@ def test_meta_with_zero_and_boolean_lists(http, api_base, asset_factory, make_as
 
 def test_meta_mixed_list_types_and_strictness(http, api_base, asset_factory, make_asset_bytes):
     name = "mf_mixed_list.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "mf-mixed"]
+    tags = ["models", "checkpoints", "unit-tests", "mf-mixed"]
     meta = {"mix": ["1", 1, True, None]}
     asset_factory(name, tags, meta, make_asset_bytes(name, 1999))
 
@@ -311,7 +311,7 @@ def test_meta_mixed_list_types_and_strictness(http, api_base, asset_factory, mak
 
 def test_meta_unknown_key_and_none_behavior_with_scope_tags(http, api_base, asset_factory, make_asset_bytes):
     # Use a unique scope tag to avoid interference
-    t = ["models", "model_type:checkpoints", "unit-tests", "mf-unknown-scope"]
+    t = ["models", "checkpoints", "unit-tests", "mf-unknown-scope"]
     x = asset_factory("mf_unknown_a.safetensors", t, {"k1": 1}, make_asset_bytes("ua"))
     y = asset_factory("mf_unknown_b.safetensors", t, {"k2": 2}, make_asset_bytes("ub"))
 
@@ -340,13 +340,13 @@ def test_meta_with_tags_include_exclude_and_name_contains(http, api_base, asset_
     # alpha matches epoch=1; beta has epoch=2
     a = asset_factory(
         "mf_tag_alpha.safetensors",
-        ["models", "model_type:checkpoints", "unit-tests", "mf-tag", "alpha"],
+        ["models", "checkpoints", "unit-tests", "mf-tag", "alpha"],
         {"epoch": 1},
         make_asset_bytes("alpha"),
     )
     b = asset_factory(
         "mf_tag_beta.safetensors",
-        ["models", "model_type:checkpoints", "unit-tests", "mf-tag", "beta"],
+        ["models", "checkpoints", "unit-tests", "mf-tag", "beta"],
         {"epoch": 2},
         make_asset_bytes("beta"),
     )
@@ -367,7 +367,7 @@ def test_meta_with_tags_include_exclude_and_name_contains(http, api_base, asset_
 
 def test_meta_sort_and_paging_under_filter(http, api_base, asset_factory, make_asset_bytes):
     # Three assets in same scope with different sizes and a common filter key
-    t = ["models", "model_type:checkpoints", "unit-tests", "mf-sort"]
+    t = ["models", "checkpoints", "unit-tests", "mf-sort"]
     n1, n2, n3 = "mf_sort_1.safetensors", "mf_sort_2.safetensors", "mf_sort_3.safetensors"
     asset_factory(n1, t, {"group": "g"}, make_asset_bytes(n1, 1024))
     asset_factory(n2, t, {"group": "g"}, make_asset_bytes(n2, 2048))

tests-unit/assets_test/test_prune_orphaned_assets.py

@@ -29,7 +29,7 @@ def create_seed_file(comfy_tmp_base_dir: Path):
 def find_asset(http: requests.Session, api_base: str):
     """Query API for assets matching scope and optional name."""
     def _find(scope: str, name: str | None = None) -> list[dict]:
-        params = {"limit": "500"}
+        params = {"include_tags": f"unit-tests,{scope}"}
         if name:
             params["name_contains"] = name
         r = http.get(f"{api_base}/api/assets", params=params, timeout=120)
@@ -91,7 +91,7 @@ def test_hashed_asset_not_pruned_when_file_missing(
     data = make_asset_bytes("test", 2048)
     a = asset_factory("test.bin", ["input", "unit-tests", scope], {}, data)
 
-    path = comfy_tmp_base_dir / "input" / get_asset_filename(a["asset_hash"], ".bin")
+    path = comfy_tmp_base_dir / "input" / "unit-tests" / scope / get_asset_filename(a["asset_hash"], ".bin")
     path.unlink()
 
     trigger_sync_seed_assets(http, api_base)
@@ -108,20 +108,18 @@ def test_prune_across_multiple_roots(
 ):
     """Prune correctly handles assets across input and output roots."""
     scope = f"multi-{uuid.uuid4().hex[:6]}"
-    input_name = f"{scope}-input.bin"
-    output_name = f"{scope}-output.bin"
-    input_fp = create_seed_file("input", scope, input_name)
-    create_seed_file("output", scope, output_name)
+    input_fp = create_seed_file("input", scope, "input.bin")
+    create_seed_file("output", scope, "output.bin")
 
     trigger_sync_seed_assets(http, api_base)
-    assert find_asset(scope, input_name)
-    assert find_asset(scope, output_name)
+    assert len(find_asset(scope)) == 2
 
     input_fp.unlink()
     trigger_sync_seed_assets(http, api_base)
 
-    assert not find_asset(scope, input_name)
-    assert find_asset(scope, output_name)
+    remaining = find_asset(scope)
+    assert len(remaining) == 1
+    assert remaining[0]["name"] == "output.bin"
 
 
 @pytest.mark.parametrize("dirname", ["100%_done", "my_folder_name", "has spaces"])

tests-unit/assets_test/test_tags_api.py

@@ -10,9 +10,9 @@ def test_tags_present(http: requests.Session, api_base: str, seeded_asset: dict)
     body1 = r1.json()
     assert r1.status_code == 200
     names = [t["name"] for t in body1["tags"]]
-    # A few selected contract tags should exist.
+    # A few system tags from migration should exist:
     assert "models" in names
-    assert "model_type:checkpoints" in names
+    assert "checkpoints" in names
 
     # Only used tags before we add anything new from this test cycle
     r2 = http.get(api_base + "/api/tags", params={"include_zero": "false"}, timeout=120)
@@ -21,7 +21,7 @@ def test_tags_present(http: requests.Session, api_base: str, seeded_asset: dict)
     # We already seeded one asset via fixture, so used tags must be non-empty
     used_names = [t["name"] for t in body2["tags"]]
     assert "models" in used_names
-    assert "model_type:checkpoints" in used_names
+    assert "checkpoints" in used_names
 
     # Prefix filter should refine the list
     r3 = http.get(api_base + "/api/tags", params={"include_zero": "false", "prefix": "uni"}, timeout=120)
@@ -45,7 +45,7 @@ def test_tags_empty_usage(http: requests.Session, api_base: str, asset_factory,
     body1 = r1.json()
     assert r1.status_code == 200
     names = [t["name"] for t in body1["tags"]]
-    assert "models" in names and "model_type:checkpoints" in names
+    assert "models" in names and "checkpoints" in names
 
     # Create a short-lived asset under input with a unique custom tag
     scope = f"tags-empty-usage-{uuid.uuid4().hex[:6]}"
@@ -89,28 +89,28 @@ def test_tags_empty_usage(http: requests.Session, api_base: str, asset_factory,
 def test_add_and_remove_tags(http: requests.Session, api_base: str, seeded_asset: dict):
     aid = seeded_asset["id"]
 
-    # Add tags with duplicates while preserving source case.
-    payload_add = {"tags": ["NewTag", "unit-tests", "NewTag", "BETA"]}
+    # Add tags with duplicates and mixed case
+    payload_add = {"tags": ["NewTag", "unit-tests", "newtag", "BETA"]}
     r1 = http.post(f"{api_base}/api/assets/{aid}/tags", json=payload_add, timeout=120)
     b1 = r1.json()
     assert r1.status_code == 200, b1
-    # stripped, deduplicated; 'unit-tests' was already present from the seed
-    assert set(b1["added"]) == {"NewTag", "BETA"}
+    # normalized, deduplicated; 'unit-tests' was already present from the seed
+    assert set(b1["added"]) == {"newtag", "beta"}
     assert set(b1["already_present"]) == {"unit-tests"}
-    assert "NewTag" in b1["total_tags"] and "BETA" in b1["total_tags"]
+    assert "newtag" in b1["total_tags"] and "beta" in b1["total_tags"]
 
     rg = http.get(f"{api_base}/api/assets/{aid}", timeout=120)
     g = rg.json()
     assert rg.status_code == 200
     tags_now = set(g["tags"])
-    assert {"NewTag", "BETA"}.issubset(tags_now)
+    assert {"newtag", "beta"}.issubset(tags_now)
 
     # Remove a tag and a non-existent tag
-    payload_del = {"tags": ["NewTag", "does-not-exist"]}
+    payload_del = {"tags": ["newtag", "does-not-exist"]}
     r2 = http.delete(f"{api_base}/api/assets/{aid}/tags", json=payload_del, timeout=120)
     b2 = r2.json()
     assert r2.status_code == 200
-    assert set(b2["removed"]) == {"NewTag"}
+    assert set(b2["removed"]) == {"newtag"}
     assert set(b2["not_present"]) == {"does-not-exist"}
 
     # Verify remaining tags after deletion
@@ -118,44 +118,8 @@ def test_add_and_remove_tags(http: requests.Session, api_base: str, seeded_asset
     g2 = rg2.json()
     assert rg2.status_code == 200
     tags_later = set(g2["tags"])
-    assert "NewTag" not in tags_later
-    assert "BETA" in tags_later  # still present
-
-
-def test_add_system_looking_tags_allowed_as_labels(
-    http: requests.Session, api_base: str, seeded_asset: dict
-):
-    aid = seeded_asset["id"]
-
-    response = http.post(
-        f"{api_base}/api/assets/{aid}/tags",
-        json={
-            "tags": [
-                "models",
-                "model_type:manual",
-                "model:true",
-                "models:foo",
-                "input:true",
-                "output:true",
-                "uploaded:true",
-                "temp:true",
-                "temporary",
-            ]
-        },
-        timeout=120,
-    )
-    body = response.json()
-
-    assert response.status_code == 200, body
-    assert "models" in body["total_tags"]
-    assert "model_type:manual" in body["total_tags"]
-    assert "model:true" in body["total_tags"]
-    assert "models:foo" in body["total_tags"]
-    assert "input:true" in body["total_tags"]
-    assert "output:true" in body["total_tags"]
-    assert "uploaded:true" in body["total_tags"]
-    assert "temp:true" in body["total_tags"]
-    assert "temporary" in body["total_tags"]
+    assert "newtag" not in tags_later
+    assert "beta" in tags_later  # still present
 
 
 def test_tags_list_order_and_prefix(http: requests.Session, api_base: str, seeded_asset: dict):

tests-unit/assets_test/test_uploads.py

@@ -1,14 +1,11 @@
 import json
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
 
 import requests
 import pytest
 
-from app.assets.api.schemas_in import UploadAssetSpec
 from app.assets.api.schemas_out import Asset, AssetCreated
-from helpers import get_asset_filename
 
 
 def test_asset_created_inherits_hash_field():
@@ -23,18 +20,9 @@ def test_asset_created_inherits_hash_field():
     assert AssetCreated.model_fields["hash"].annotation == Asset.model_fields["hash"].annotation
 
 
-def test_upload_asset_spec_ignores_subfolder_field():
-    spec = UploadAssetSpec.model_validate(
-        {"tags": ["input"], "subfolder": "pasted", "name": "image.png"}
-    )
-
-    assert "subfolder" not in UploadAssetSpec.model_fields
-    assert not hasattr(spec, "subfolder")
-
-
 def test_upload_ok_duplicate_reference(http: requests.Session, api_base: str, make_asset_bytes):
     name = "dup_a.safetensors"
-    tags = ["models", "model_type:checkpoints", "unit-tests", "alpha"]
+    tags = ["models", "checkpoints", "unit-tests", "alpha"]
     meta = {"purpose": "dup"}
     data = make_asset_bytes(name)
     files = {"file": (name, data, "application/octet-stream")}
@@ -55,8 +43,6 @@ def test_upload_ok_duplicate_reference(http: requests.Session, api_base: str, ma
     assert a2["asset_hash"] == a1["asset_hash"]
     assert a2["hash"] == a1["hash"]
     assert a2["id"] != a1["id"]  # new reference with same content
-    assert a2.get("loader_path") is None
-    assert a2.get("display_name") is None
 
     # Third upload with the same data but different name also creates new AssetReference
     files = {"file": (name, data, "application/octet-stream")}
@@ -67,14 +53,12 @@ def test_upload_ok_duplicate_reference(http: requests.Session, api_base: str, ma
     assert a3["asset_hash"] == a1["asset_hash"]
     assert a3["id"] != a1["id"]
     assert a3["id"] != a2["id"]
-    assert a3.get("loader_path") is None
-    assert a3.get("display_name") is None
 
 
 def test_upload_fastpath_from_existing_hash_no_file(http: requests.Session, api_base: str):
     # Seed a small file first
     name = "fastpath_seed.safetensors"
-    tags = ["input", "unit-tests"]
+    tags = ["models", "checkpoints", "unit-tests"]
     meta = {}
     files = {"file": (name, b"B" * 1024, "application/octet-stream")}
     form = {"tags": json.dumps(tags), "name": name, "user_metadata": json.dumps(meta)}
@@ -85,10 +69,9 @@ def test_upload_fastpath_from_existing_hash_no_file(http: requests.Session, api_
     assert b1["hash"] == h
 
     # Now POST /api/assets with only hash and no file
-    hash_only_tags = ["models", "checkpoints", "unit-tests", "hash-labels"]
     files = [
         ("hash", (None, h)),
-        ("tags", (None, json.dumps(hash_only_tags))),
+        ("tags", (None, json.dumps(tags))),
         ("name", (None, "fastpath_copy.safetensors")),
         ("user_metadata", (None, json.dumps({"purpose": "copy"}))),
     ]
@@ -98,53 +81,6 @@ def test_upload_fastpath_from_existing_hash_no_file(http: requests.Session, api_
     assert b2["created_new"] is False
     assert b2["asset_hash"] == h
     assert b2["hash"] == h
-    assert "models" in b2["tags"]
-    assert "checkpoints" in b2["tags"]
-    assert "uploaded" not in b2["tags"]
-    assert not any(tag.startswith("model_type:") for tag in b2["tags"])
-    assert b2.get("loader_path") is None
-    assert b2.get("display_name") is None
-
-    rg = http.get(f"{api_base}/api/assets/{b2['id']}", timeout=120)
-    detail = rg.json()
-    assert rg.status_code == 200, detail
-    assert detail.get("loader_path") is None
-    assert detail.get("display_name") is None
-
-
-def test_create_from_hash_with_model_tags_does_not_synthesize_loader_path(
-    http: requests.Session, api_base: str
-):
-    seed_name = "from_hash_seed.safetensors"
-    seed_tags = ["models", "model_type:checkpoints", "unit-tests"]
-    files = {"file": (seed_name, b"D" * 1024, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(seed_tags),
-        "name": seed_name,
-        "user_metadata": json.dumps({}),
-    }
-    seed_r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    seed = seed_r.json()
-    assert seed_r.status_code == 201, seed
-
-    payload = {
-        "hash": seed["asset_hash"],
-        "name": "from_hash_copy.safetensors",
-        "tags": ["models", "model_type:checkpoints", "unit-tests", "spoofed"],
-    }
-    created_r = http.post(api_base + "/api/assets/from-hash", json=payload, timeout=120)
-    created = created_r.json()
-    assert created_r.status_code == 201, created
-    assert created["created_new"] is False
-    assert created["asset_hash"] == seed["asset_hash"]
-    assert created.get("loader_path") is None
-    assert created.get("display_name") is None
-
-    detail_r = http.get(f"{api_base}/api/assets/{created['id']}", timeout=120)
-    detail = detail_r.json()
-    assert detail_r.status_code == 200, detail
-    assert detail.get("loader_path") is None
-    assert detail.get("display_name") is None
 
 
 def test_upload_fastpath_with_known_hash_and_file(
@@ -152,7 +88,7 @@ def test_upload_fastpath_with_known_hash_and_file(
 ):
     # Seed
     files = {"file": ("seed.safetensors", b"C" * 128, "application/octet-stream")}
-    form = {"tags": json.dumps(["models", "model_type:checkpoints", "unit-tests", "fp"]), "name": "seed.safetensors", "user_metadata": json.dumps({})}
+    form = {"tags": json.dumps(["models", "checkpoints", "unit-tests", "fp"]), "name": "seed.safetensors", "user_metadata": json.dumps({})}
     r1 = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
     b1 = r1.json()
     assert r1.status_code == 201, b1
@@ -168,49 +104,11 @@ def test_upload_fastpath_with_known_hash_and_file(
     assert b2["created_new"] is False
     assert b2["asset_hash"] == h
     assert b2["hash"] == h
-    assert "checkpoints" in b2["tags"]
-    assert "uploaded" not in b2["tags"]
-    assert not any(tag == "model_type:checkpoints" for tag in b2["tags"])
-
-
-def test_duplicate_byte_upload_is_reference_only_and_does_not_need_destination(
-    http: requests.Session, api_base: str
-):
-    data = b"duplicate-reference-only" * 64
-    seed_files = {"file": ("duplicate-seed.bin", data, "application/octet-stream")}
-    seed_form = {
-        "tags": json.dumps(["input", "unit-tests", "duplicate-seed"]),
-        "name": "duplicate-seed.bin",
-        "user_metadata": json.dumps({}),
-    }
-    seed_response = http.post(api_base + "/api/assets", data=seed_form, files=seed_files, timeout=120)
-    seed = seed_response.json()
-    assert seed_response.status_code == 201, seed
-
-    duplicate_files = {"file": ("duplicate-copy.bin", data, "application/octet-stream")}
-    duplicate_form = {
-        "tags": json.dumps(["not-a-destination", "unit-tests", "duplicate-copy"]),
-        "name": "duplicate-copy.bin",
-        "user_metadata": json.dumps({}),
-    }
-    duplicate_response = http.post(
-        api_base + "/api/assets", data=duplicate_form, files=duplicate_files, timeout=120
-    )
-    duplicate = duplicate_response.json()
-
-    assert duplicate_response.status_code == 200, duplicate
-    assert duplicate["created_new"] is False
-    assert duplicate["asset_hash"] == seed["asset_hash"]
-    assert "not-a-destination" in duplicate["tags"]
-    assert "uploaded" not in duplicate["tags"]
-    assert "input" not in duplicate["tags"]
-    assert duplicate.get("loader_path") is None
-    assert duplicate.get("display_name") is None
 
 
 def test_upload_multiple_tags_fields_are_merged(http: requests.Session, api_base: str):
     data = [
-        ("tags", "models,model_type:checkpoints"),
+        ("tags", "models,checkpoints"),
         ("tags", json.dumps(["unit-tests", "alpha"])),
         ("name", "merge.safetensors"),
         ("user_metadata", json.dumps({"u": 1})),
@@ -226,71 +124,7 @@ def test_upload_multiple_tags_fields_are_merged(http: requests.Session, api_base
     detail = rg.json()
     assert rg.status_code == 200, detail
     tags = set(detail["tags"])
-    assert {"models", "model_type:checkpoints", "unit-tests", "alpha"}.issubset(tags)
-
-
-@pytest.mark.parametrize(
-    (
-        "tags",
-        "extension",
-        "expected_display_prefix",
-    ),
-    [
-        (["input", "unit-tests"], ".png", ""),
-        (
-            ["models", "model_type:checkpoints", "unit-tests"],
-            ".safetensors",
-            "checkpoints/",
-        ),
-    ],
-)
-def test_upload_response_includes_loader_path_and_display_name(
-    tags: list[str],
-    extension: str,
-    expected_display_prefix: str,
-    http: requests.Session,
-    api_base: str,
-    make_asset_bytes,
-):
-    scope = f"response-paths-{uuid.uuid4().hex[:6]}"
-    scoped_tags = [*tags, scope]
-    name = f"asset_response_path{extension}"
-
-    files = {"file": (name, make_asset_bytes(name, 1024), "application/octet-stream")}
-    form = {
-        "tags": json.dumps(scoped_tags),
-        "name": name,
-        "user_metadata": json.dumps({}),
-    }
-    created_r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    created = created_r.json()
-    assert created_r.status_code in (200, 201), created
-    stored_filename = get_asset_filename(created["asset_hash"], extension)
-    expected_suffix = stored_filename
-    expected_display_name = f"{expected_display_prefix}{expected_suffix}"
-    # In-root loader path: model category dropped, no subfolders here -> just the filename.
-    expected_loader_path = expected_suffix
-
-    assert created["loader_path"] == expected_loader_path
-    assert created["display_name"] == expected_display_name
-    assert "logical_path" not in created
-
-    detail_r = http.get(f"{api_base}/api/assets/{created['id']}", timeout=120)
-    detail = detail_r.json()
-    assert detail_r.status_code == 200, detail
-    assert detail["loader_path"] == expected_loader_path
-    assert detail["display_name"] == expected_display_name
-
-    list_r = http.get(
-        api_base + "/api/assets",
-        params={"include_tags": f"unit-tests,{scope}", "limit": "50"},
-        timeout=120,
-    )
-    listed = list_r.json()
-    assert list_r.status_code == 200, listed
-    match = next(a for a in listed["assets"] if a["id"] == created["id"])
-    assert match["loader_path"] == expected_loader_path
-    assert match["display_name"] == expected_display_name
+    assert {"models", "checkpoints", "unit-tests", "alpha"}.issubset(tags)
 
 
 @pytest.mark.parametrize("root", ["input", "output"])
@@ -358,55 +192,16 @@ def test_create_from_hash_endpoint_404(http: requests.Session, api_base: str):
     assert body["error"]["code"] == "ASSET_NOT_FOUND"
 
 
-def test_create_from_hash_accepts_arbitrary_system_looking_tags(
-    http: requests.Session, api_base: str
-):
-    files = {"file": ("hash-seed.bin", b"hash-seed" * 64, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(["input", "unit-tests", "hash-seed"]),
-        "name": "hash-seed.bin",
-        "user_metadata": json.dumps({}),
-    }
-    seed_response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    seed = seed_response.json()
-    assert seed_response.status_code == 201, seed
-
-    response = http.post(
-        api_base + "/api/assets/from-hash",
-        json={
-            "hash": seed["asset_hash"],
-            "name": "hash-copy.bin",
-            "tags": [
-                "models",
-                "model:true",
-                "models:foo",
-                "temporary:true",
-                "unit-tests",
-                "hash-copy",
-            ],
-        },
-        timeout=120,
-    )
-    body = response.json()
-
-    assert response.status_code == 201, body
-    assert "models" in body["tags"]
-    assert "model:true" in body["tags"]
-    assert "models:foo" in body["tags"]
-    assert "temporary:true" in body["tags"]
-    assert "uploaded" not in body["tags"]
-
-
 def test_upload_zero_byte_rejected(http: requests.Session, api_base: str):
     files = {"file": ("empty.safetensors", b"", "application/octet-stream")}
-    form = {"tags": json.dumps(["models", "model_type:checkpoints", "unit-tests", "edge"]), "name": "empty.safetensors", "user_metadata": json.dumps({})}
+    form = {"tags": json.dumps(["models", "checkpoints", "unit-tests", "edge"]), "name": "empty.safetensors", "user_metadata": json.dumps({})}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
     body = r.json()
     assert r.status_code == 400
     assert body["error"]["code"] == "EMPTY_UPLOAD"
 
 
-def test_upload_rejects_arbitrary_labels_without_required_destination_role(http: requests.Session, api_base: str):
+def test_upload_invalid_root_tag_rejected(http: requests.Session, api_base: str):
     files = {"file": ("badroot.bin", b"A" * 64, "application/octet-stream")}
     form = {"tags": json.dumps(["not-a-root", "whatever"]), "name": "badroot.bin", "user_metadata": json.dumps({})}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
@@ -417,7 +212,7 @@ def test_upload_rejects_arbitrary_labels_without_required_destination_role(http:
 
 def test_upload_user_metadata_must_be_json(http: requests.Session, api_base: str):
     files = {"file": ("badmeta.bin", b"A" * 128, "application/octet-stream")}
-    form = {"tags": json.dumps(["models", "model_type:checkpoints", "unit-tests", "edge"]), "name": "badmeta.bin", "user_metadata": "{not json}"}
+    form = {"tags": json.dumps(["models", "checkpoints", "unit-tests", "edge"]), "name": "badmeta.bin", "user_metadata": "{not json}"}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
     body = r.json()
     assert r.status_code == 400
@@ -433,7 +228,7 @@ def test_upload_requires_multipart(http: requests.Session, api_base: str):
 
 def test_upload_missing_file_and_hash(http: requests.Session, api_base: str):
     files = [
-        ("tags", (None, json.dumps(["models", "model_type:checkpoints", "unit-tests"]))),
+        ("tags", (None, json.dumps(["models", "checkpoints", "unit-tests"]))),
         ("name", (None, "x.safetensors")),
     ]
     r = http.post(api_base + "/api/assets", files=files, timeout=120)
@@ -442,33 +237,17 @@ def test_upload_missing_file_and_hash(http: requests.Session, api_base: str):
     assert body["error"]["code"] == "MISSING_FILE"
 
 
-def test_upload_models_unknown_model_type(http: requests.Session, api_base: str):
+def test_upload_models_unknown_category(http: requests.Session, api_base: str):
     files = {"file": ("m.safetensors", b"A" * 128, "application/octet-stream")}
-    form = {"tags": json.dumps(["models", "model_type:no_such_category", "unit-tests"]), "name": "m.safetensors"}
+    form = {"tags": json.dumps(["models", "no_such_category", "unit-tests"]), "name": "m.safetensors"}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
     body = r.json()
-    assert r.status_code == 400, body
+    assert r.status_code == 400
     assert body["error"]["code"] == "INVALID_BODY"
+    assert body["error"]["message"].startswith("unknown models category")
 
 
-@pytest.mark.parametrize("model_type", ["configs", "custom_nodes"])
-def test_upload_models_rejects_non_model_registered_folder(
-    model_type: str, http: requests.Session, api_base: str
-):
-    files = {"file": ("not-a-model.py", b"A" * 128, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(["models", f"model_type:{model_type}", "unit-tests"]),
-        "name": "not-a-model.py",
-    }
-
-    response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 400, body
-    assert body["error"]["code"] == "INVALID_BODY"
-
-
-def test_upload_models_requires_model_type(http: requests.Session, api_base: str):
+def test_upload_models_requires_category(http: requests.Session, api_base: str):
     files = {"file": ("nocat.safetensors", b"A" * 64, "application/octet-stream")}
     form = {"tags": json.dumps(["models"]), "name": "nocat.safetensors", "user_metadata": json.dumps({})}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
@@ -477,152 +256,13 @@ def test_upload_models_requires_model_type(http: requests.Session, api_base: str
     assert body["error"]["code"] == "INVALID_BODY"
 
 
-def test_upload_extra_tags_are_labels_not_path_components(http: requests.Session, api_base: str):
+def test_upload_tags_traversal_guard(http: requests.Session, api_base: str):
     files = {"file": ("evil.safetensors", b"A" * 256, "application/octet-stream")}
-    form = {"tags": json.dumps(["models", "model_type:checkpoints", "unit-tests", "..", "zzz"]), "name": "evil.safetensors"}
+    form = {"tags": json.dumps(["models", "checkpoints", "unit-tests", "..", "zzz"]), "name": "evil.safetensors"}
     r = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
     body = r.json()
-    assert r.status_code == 201, body
-    assert ".." in body["tags"]
-    assert "zzz" in body["tags"]
-    assert "models" in body["tags"]
-    assert "model_type:checkpoints" in body["tags"]
-
-
-@pytest.mark.parametrize(
-    ("subfolder", "expected_tag", "unexpected_tags"),
-    [
-        ("custom/session", None, {"custom", "session"}),
-        ("pasted", "pasted", set()),
-    ],
-)
-def test_upload_image_accepts_arbitrary_subfolder_but_only_known_values_become_tags(
-    http: requests.Session,
-    api_base: str,
-    comfy_tmp_base_dir: Path,
-    subfolder: str,
-    expected_tag: str | None,
-    unexpected_tags: set[str],
-):
-    name = f"upload-image-{uuid.uuid4().hex}.png"
-    files = {"image": (name, b"image-upload" * 64, "image/png")}
-    form = {"type": "input", "subfolder": subfolder}
-
-    response = http.post(api_base + "/upload/image", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 200, body
-    assert body["subfolder"] == subfolder
-    assert (comfy_tmp_base_dir / "input" / subfolder / body["name"]).exists()
-
-    asset = body["asset"]
-    tags = set(asset["tags"])
-    assert "input" in tags
-    assert "uploaded" in tags
-    if expected_tag:
-        assert expected_tag in tags
-    assert tags.isdisjoint(unexpected_tags)
-
-
-def test_multipart_upload_accepts_system_looking_extra_labels(
-    http: requests.Session, api_base: str
-):
-    files = {"file": ("relaxed-labels.bin", b"relaxed" * 64, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(
-            [
-                "input",
-                "unit-tests",
-                "model:true",
-                "models:foo",
-                "temporary",
-                "uploaded:true",
-            ]
-        ),
-        "name": "relaxed-labels.bin",
-        "user_metadata": json.dumps({}),
-    }
-    response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 201, body
-    assert "input" in body["tags"]
-    assert "model:true" in body["tags"]
-    assert "models:foo" in body["tags"]
-    assert "temporary" in body["tags"]
-    assert "uploaded:true" in body["tags"]
-
-
-def test_multipart_upload_rejects_ambiguous_destination_roles(
-    http: requests.Session, api_base: str
-):
-    files = {"file": ("ambiguous.bin", b"ambiguous" * 64, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(["input", "output", "unit-tests"]),
-        "name": "ambiguous.bin",
-        "user_metadata": json.dumps({}),
-    }
-    response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 400, body
-    assert body["error"]["code"] == "INVALID_BODY"
-
-
-def test_multipart_upload_rejects_multiple_model_types_for_models_destination(
-    http: requests.Session, api_base: str
-):
-    files = {"file": ("ambiguous-model.safetensors", b"ambiguous-model" * 64, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(
-            ["models", "model_type:checkpoints", "model_type:loras", "unit-tests"]
-        ),
-        "name": "ambiguous-model.safetensors",
-        "user_metadata": json.dumps({}),
-    }
-    response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 400, body
-    assert body["error"]["code"] == "INVALID_BODY"
-
-
-@pytest.mark.parametrize(
-    ("tags", "expected_root", "extension"),
-    [
-        (["input", "unit-tests", "upload-location-input"], "input", ".bin"),
-        (["output", "unit-tests", "upload-location-output"], "output", ".bin"),
-        (
-            ["models", "model_type:checkpoints", "unit-tests", "upload-location-model"],
-            "models/checkpoints",
-            ".safetensors",
-        ),
-    ],
-)
-def test_multipart_upload_role_selects_write_location(
-    http: requests.Session,
-    api_base: str,
-    comfy_tmp_base_dir: Path,
-    tags: list[str],
-    expected_root: str,
-    extension: str,
-):
-    role = next(tag for tag in tags if tag in {"input", "models", "output"})
-    name = f"{role}-role-upload{extension}"
-    files = {"file": (name, f"{role}-role-bytes".encode() * 64, "application/octet-stream")}
-    form = {
-        "tags": json.dumps(tags),
-        "name": name,
-        "user_metadata": json.dumps({}),
-    }
-
-    response = http.post(api_base + "/api/assets", data=form, files=files, timeout=120)
-    body = response.json()
-
-    assert response.status_code == 201, body
-    stored_name = get_asset_filename(body["asset_hash"], extension)
-    expected_disk_path = comfy_tmp_base_dir / expected_root / stored_name
-    assert expected_disk_path.exists()
+    assert r.status_code == 400
+    assert body["error"]["code"] in ("BAD_REQUEST", "INVALID_BODY")
 
 
 def test_upload_empty_tags_rejected(http: requests.Session, api_base: str):

tests-unit/feature_flags_test.py

@@ -29,8 +29,6 @@ class TestFeatureFlags:
         features = get_server_features()
         assert "supports_preview_metadata" in features
         assert features["supports_preview_metadata"] is True
-        assert "supports_model_type_tags" in features
-        assert features["supports_model_type_tags"] is True
         assert "max_upload_size" in features
         assert isinstance(features["max_upload_size"], (int, float))
 

tests-unit/websocket_feature_flags_test.py

@@ -12,8 +12,6 @@ class TestWebSocketFeatureFlags:
         # Check expected server features
         assert "supports_preview_metadata" in features
         assert features["supports_preview_metadata"] is True
-        assert "supports_model_type_tags" in features
-        assert features["supports_model_type_tags"] is True
         assert "max_upload_size" in features
         assert isinstance(features["max_upload_size"], (int, float))
 
@@ -77,5 +75,3 @@ class TestWebSocketFeatureFlags:
         assert server_message["type"] == "feature_flags"
         assert "supports_preview_metadata" in server_message["data"]
         assert server_message["data"]["supports_preview_metadata"] is True
-        assert "supports_model_type_tags" in server_message["data"]
-        assert server_message["data"]["supports_model_type_tags"] is True