feat(model-modal): improve transition animations and fix navigation logic

- Add `!important` to overlay background and closing opacity for consistent styling
- Remove navigation spam prevention to allow consecutive transitions
- Implement in-place content updates during model transitions instead of reopening modal
- Add opacity transitions for showcase and metadata components
- Fetch complete Civitai metadata during transitions for updated model data

.agents/skills/lora-manager-runtime-context/SKILL.md

@@ -1,69 +0,0 @@
----
-name: lora-manager-runtime-context
-description: Inspect ComfyUI LoRA Manager runtime configuration and local diagnostic state. Use when debugging LoRA Manager issues that require locating or reading settings.json, active library paths, model metadata JSON sidecars, recipe metadata JSON files, example image folders, SQLite caches, symlink maps, download history, aria2 state, or other cache files under the LoRA Manager user config directory.
----
-
-# LoRA Manager Runtime Context
-
-## Core Rules
-
-- Treat runtime state as local user data. Prefer read-only inspection unless the user explicitly asks for mutation.
-- Never print secret-like settings values. Redact keys containing `key`, `token`, `secret`, `password`, `auth`, or `credential`, including `civitai_api_key`.
-- Resolve paths from the runtime configuration before guessing. In this environment the settings file is normally `/home/miao/.config/ComfyUI-LoRA-Manager/settings.json`, but portable settings can override this through the repository `settings.json`.
-- Use the active library when selecting per-library caches and paths. Read `active_library` from settings; fall back to `default` if missing.
-- Normalize and expand `~` before comparing paths. Symlinks are common in this repo.
-
-## Quick Start
-
-Use the bundled helper for a safe first pass:
-
-```bash
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py summary
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py caches
-```
-
-The script redacts sensitive settings, opens SQLite databases read-only, and reports inaccessible or locked databases as warnings.
-
-For focused checks:
-
-```bash
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py recipes
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py model --path /path/to/model.safetensors
-python .agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py sqlite --db /path/to/cache.sqlite --limit 3
-```
-
-## Runtime Path Rules
-
-- Settings directory: use `py/utils/settings_paths.py`. Default platform path is `platformdirs.user_config_dir("ComfyUI-LoRA-Manager", appauthor=False)`.
-- Settings file: `<settings_dir>/settings.json`.
-- Cache root: `<settings_dir>/cache`.
-- Canonical cache files:
-  - Model cache: `cache/model/<active_library>.sqlite`.
-  - Recipe cache: `cache/recipe/<active_library>.sqlite`.
-  - Model update cache: `cache/model_update/<active_library>.sqlite`.
-  - Recipe FTS: `cache/fts/recipe_fts.sqlite`.
-  - Tag FTS: `cache/fts/tag_fts.sqlite`.
-  - Symlink map: `cache/symlink/symlink_map.json`.
-  - Download history: `cache/download_history/downloaded_versions.sqlite`.
-  - aria2 state: `cache/aria2/downloads.json`.
-- Legacy cache locations may exist; prefer canonical paths unless diagnosing migrations.
-
-## Data Location Rules
-
-- Model roots come from `settings.folder_paths` and the active library payload under `settings.libraries[active_library]`.
-- Model metadata JSON sidecars live next to the model file as `<model basename>.metadata.json`.
-- Recipes root is `settings.recipes_path` when it is a non-empty string. If empty, use the first configured LoRA root plus `/recipes`.
-- Recipe JSON files are named `*.recipe.json` under the recipes root and may be nested in folders.
-- Example image root is `settings.example_images_path`.
-- If multiple libraries are configured, example images are stored under `<example_images_path>/<sanitized_library>/<sha256>/`; otherwise they are under `<example_images_path>/<sha256>/`.
-
-## Useful Cache Tables
-
-- Model cache: `models`, `model_tags`, `hash_index`, `excluded_models`.
-- Recipe cache: `recipes`, `cache_metadata`.
-- Model update cache: `model_update_status`, `model_update_versions`.
-- Tag FTS cache: `tags`, `fts_metadata`, plus FTS internal tables.
-- Recipe FTS cache: `recipe_rowid`, `fts_metadata`, plus FTS internal tables.
-- Download history: `downloaded_model_versions`.
-
-Prefer querying only counts, schema, and a few sample rows unless the user asks for full output.

.agents/skills/lora-manager-runtime-context/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "LoRA Manager Runtime Context"
-  short_description: "Inspect LoRA Manager runtime state"
-  default_prompt: "Use $lora-manager-runtime-context to inspect LoRA Manager settings, metadata paths, and caches for debugging."

.agents/skills/lora-manager-runtime-context/scripts/inspect_runtime_context.py

@@ -1,381 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import re
-import shutil
-import sqlite3
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any
-
-SECRET_PATTERN = re.compile(r"(key|token|secret|password|auth|credential)", re.IGNORECASE)
-APP_NAME = "ComfyUI-LoRA-Manager"
-CACHE_SQLITE = {
-    "model": ("model", "{library}.sqlite"),
-    "recipe": ("recipe", "{library}.sqlite"),
-    "model_update": ("model_update", "{library}.sqlite"),
-    "recipe_fts": ("fts", "recipe_fts.sqlite"),
-    "tag_fts": ("fts", "tag_fts.sqlite"),
-    "download_history": ("download_history", "downloaded_versions.sqlite"),
-}
-CACHE_JSON = {
-    "symlink": ("symlink", "symlink_map.json"),
-    "aria2": ("aria2", "downloads.json"),
-}
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Inspect LoRA Manager runtime state read-only.")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    subparsers.add_parser("summary", help="Print redacted settings and resolved paths.")
-    subparsers.add_parser("caches", help="Print cache paths and SQLite table summaries.")
-    subparsers.add_parser("recipes", help="Print resolved recipes root and recipe JSON count.")
-
-    model_parser = subparsers.add_parser("model", help="Inspect a model metadata sidecar path.")
-    model_parser.add_argument("--path", required=True, help="Path to a model file or metadata JSON file.")
-
-    sqlite_parser = subparsers.add_parser("sqlite", help="Inspect a SQLite database read-only.")
-    sqlite_parser.add_argument("--db", required=True, help="Path to the SQLite database.")
-    sqlite_parser.add_argument("--limit", type=int, default=3, help="Rows to sample from each user table.")
-
-    args = parser.parse_args()
-    context = build_context()
-
-    if args.command == "summary":
-        print_json(summary_payload(context))
-    elif args.command == "caches":
-        print_json(caches_payload(context))
-    elif args.command == "recipes":
-        print_json(recipes_payload(context))
-    elif args.command == "model":
-        print_json(model_payload(args.path))
-    elif args.command == "sqlite":
-        print_json(sqlite_payload(Path(args.db).expanduser(), args.limit))
-    return 0
-
-
-def build_context() -> dict[str, Any]:
-    settings_path = resolve_settings_path()
-    settings = load_json(settings_path)
-    settings_dir = settings_path.parent
-    active_library = settings.get("active_library") or "default"
-    safe_library = sanitize_library_name(str(active_library))
-    cache_root = settings_dir / "cache"
-    return {
-        "settings_path": str(settings_path),
-        "settings_dir": str(settings_dir),
-        "settings": settings,
-        "active_library": active_library,
-        "safe_library": safe_library,
-        "cache_root": str(cache_root),
-        "cache_paths": resolve_cache_paths(cache_root, safe_library),
-    }
-
-
-def resolve_settings_path() -> Path:
-    repo_root = find_repo_root()
-    portable = repo_root / "settings.json"
-    if portable.exists():
-        payload = load_json(portable)
-        if isinstance(payload, dict) and payload.get("use_portable_settings") is True:
-            return portable
-
-    config_home = os.environ.get("XDG_CONFIG_HOME")
-    if config_home:
-        return Path(config_home).expanduser() / APP_NAME / "settings.json"
-    return Path.home() / ".config" / APP_NAME / "settings.json"
-
-
-def find_repo_root() -> Path:
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        if (parent / "py").is_dir() and (parent / "standalone.py").exists():
-            return parent
-    return Path.cwd()
-
-
-def load_json(path: Path) -> dict[str, Any]:
-    try:
-        with path.open("r", encoding="utf-8") as handle:
-            payload = json.load(handle)
-    except FileNotFoundError:
-        return {}
-    except json.JSONDecodeError as exc:
-        return {"_error": f"invalid JSON: {exc}"}
-    except OSError as exc:
-        return {"_error": f"unreadable: {exc}"}
-    return payload if isinstance(payload, dict) else {"_error": "JSON root is not an object"}
-
-
-def resolve_cache_paths(cache_root: Path, library: str) -> dict[str, str]:
-    paths: dict[str, str] = {}
-    for name, (subdir, filename) in CACHE_SQLITE.items():
-        paths[name] = str(cache_root / subdir / filename.format(library=library))
-    for name, (subdir, filename) in CACHE_JSON.items():
-        paths[name] = str(cache_root / subdir / filename)
-    return paths
-
-
-def summary_payload(context: dict[str, Any]) -> dict[str, Any]:
-    settings = context["settings"]
-    return {
-        "settings_path": context["settings_path"],
-        "settings_dir": context["settings_dir"],
-        "active_library": context["active_library"],
-        "settings": redact(settings),
-        "model_roots": model_roots(settings, context["active_library"]),
-        "recipes_root": str(resolve_recipes_root(settings, context["active_library"]) or ""),
-        "example_images": example_images_payload(settings, context["active_library"]),
-        "cache_root": context["cache_root"],
-        "cache_paths": context["cache_paths"],
-    }
-
-
-def caches_payload(context: dict[str, Any]) -> dict[str, Any]:
-    caches: dict[str, Any] = {}
-    for name, path_string in context["cache_paths"].items():
-        path = Path(path_string)
-        item: dict[str, Any] = {
-            "path": str(path),
-            "exists": path.exists(),
-            "size": path.stat().st_size if path.exists() else None,
-        }
-        if path.suffix == ".sqlite":
-            item["sqlite"] = sqlite_payload(path, limit=0)
-        elif path.suffix == ".json":
-            item["json"] = json_file_summary(path)
-        caches[name] = item
-    return {"active_library": context["active_library"], "caches": caches}
-
-
-def recipes_payload(context: dict[str, Any]) -> dict[str, Any]:
-    root = resolve_recipes_root(context["settings"], context["active_library"])
-    files: list[str] = []
-    if root and root.exists():
-        files = [str(path) for path in sorted(root.rglob("*.recipe.json"))[:20]]
-    return {
-        "recipes_root": str(root or ""),
-        "exists": bool(root and root.exists()),
-        "recipe_json_count": count_recipe_files(root),
-        "sample_recipe_json": files,
-        "recipe_cache": context["cache_paths"].get("recipe"),
-    }
-
-
-def model_payload(raw_path: str) -> dict[str, Any]:
-    path = Path(raw_path).expanduser()
-    metadata_path = path if path.name.endswith(".metadata.json") else path.with_suffix(".metadata.json")
-    payload = {
-        "input_path": str(path),
-        "metadata_path": str(metadata_path),
-        "model_exists": path.exists(),
-        "metadata_exists": metadata_path.exists(),
-    }
-    if metadata_path.exists():
-        data = load_json(metadata_path)
-        payload["metadata_summary"] = redact(summarize_value(data))
-    return payload
-
-
-def sqlite_payload(path: Path, limit: int = 3, allow_copy: bool = True) -> dict[str, Any]:
-    result: dict[str, Any] = {"path": str(path), "exists": path.exists(), "tables": {}}
-    if not path.exists():
-        return result
-    try:
-        conn = connect_sqlite_readonly(path)
-    except sqlite3.Error as exc:
-        result["error"] = str(exc)
-        return result
-    try:
-        table_rows = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-        ).fetchall()
-        for table_row in table_rows:
-            table = table_row["name"]
-            columns = [
-                row["name"]
-                for row in conn.execute(f"PRAGMA table_info({quote_identifier(table)})").fetchall()
-            ]
-            table_info: dict[str, Any] = {"columns": columns}
-            try:
-                table_info["count"] = conn.execute(
-                    f"SELECT COUNT(*) FROM {quote_identifier(table)}"
-                ).fetchone()[0]
-            except sqlite3.Error as exc:
-                table_info["count_error"] = str(exc)
-            if limit > 0 and columns and not is_internal_sqlite_table(table):
-                try:
-                    rows = conn.execute(
-                        f"SELECT * FROM {quote_identifier(table)} LIMIT ?", (limit,)
-                    ).fetchall()
-                    table_info["sample"] = [redact(dict(row)) for row in rows]
-                except sqlite3.Error as exc:
-                    table_info["sample_error"] = str(exc)
-            result["tables"][table] = table_info
-    except sqlite3.Error as exc:
-        fallback = sqlite_copy_payload(path, limit, str(exc)) if allow_copy else None
-        if fallback is not None:
-            result.update(fallback)
-        else:
-            result["error"] = str(exc)
-    finally:
-        conn.close()
-    return result
-
-
-def connect_sqlite_readonly(path: Path) -> sqlite3.Connection:
-    errors: list[str] = []
-    for query in ("mode=ro", "mode=ro&immutable=1"):
-        try:
-            conn = sqlite3.connect(f"file:{path}?{query}", uri=True)
-            conn.row_factory = sqlite3.Row
-            return conn
-        except sqlite3.Error as exc:
-            errors.append(f"{query}: {exc}")
-    raise sqlite3.OperationalError("; ".join(errors))
-
-
-def sqlite_copy_payload(path: Path, limit: int, original_error: str) -> dict[str, Any] | None:
-    try:
-        with tempfile.TemporaryDirectory(prefix="lm-cache-inspect-") as temp_dir:
-            copy_path = Path(temp_dir) / path.name
-            shutil.copy2(path, copy_path)
-            payload = sqlite_payload(copy_path, limit, allow_copy=False)
-            payload["path"] = str(path)
-            payload["inspected_copy"] = True
-            payload["original_error"] = original_error
-            return payload
-    except Exception:
-        return None
-
-
-def json_file_summary(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        return {"exists": False}
-    data = load_json(path)
-    return {"exists": True, "summary": redact(summarize_value(data))}
-
-
-def model_roots(settings: dict[str, Any], active_library: str) -> dict[str, list[str]]:
-    roots: dict[str, list[str]] = {}
-    sources = [settings]
-    library = settings.get("libraries", {}).get(active_library)
-    if isinstance(library, dict):
-        sources.insert(0, library)
-    for source in sources:
-        folder_paths = source.get("folder_paths")
-        if isinstance(folder_paths, dict):
-            for key, value in folder_paths.items():
-                roots.setdefault(key, []).extend(normalize_path_list(value))
-    for default_key, folder_key in (
-        ("default_lora_root", "loras"),
-        ("default_checkpoint_root", "checkpoints"),
-        ("default_embedding_root", "embeddings"),
-        ("default_unet_root", "unet"),
-    ):
-        value = settings.get(default_key)
-        if isinstance(value, str) and value:
-            roots.setdefault(folder_key, []).append(expand_path(value))
-    return {key: dedupe(values) for key, values in roots.items()}
-
-
-def resolve_recipes_root(settings: dict[str, Any], active_library: str) -> Path | None:
-    recipes_path = settings.get("recipes_path")
-    library = settings.get("libraries", {}).get(active_library)
-    if isinstance(library, dict) and isinstance(library.get("recipes_path"), str):
-        recipes_path = library["recipes_path"] or recipes_path
-    if isinstance(recipes_path, str) and recipes_path.strip():
-        return Path(expand_path(recipes_path.strip()))
-    lora_roots = model_roots(settings, active_library).get("loras") or []
-    return Path(lora_roots[0]) / "recipes" if lora_roots else None
-
-
-def example_images_payload(settings: dict[str, Any], active_library: str) -> dict[str, Any]:
-    root = settings.get("example_images_path") or ""
-    libraries = settings.get("libraries")
-    library_count = len(libraries) if isinstance(libraries, dict) else 0
-    scoped = library_count > 1
-    root_path = Path(expand_path(root)) if isinstance(root, str) and root else None
-    library_root = root_path / sanitize_library_name(active_library) if root_path and scoped else root_path
-    return {
-        "root": str(root_path or ""),
-        "uses_library_scoped_folders": scoped,
-        "library_root": str(library_root or ""),
-    }
-
-
-def count_recipe_files(root: Path | None) -> int:
-    if not root or not root.exists():
-        return 0
-    return sum(1 for _ in root.rglob("*.recipe.json"))
-
-
-def normalize_path_list(value: Any) -> list[str]:
-    if isinstance(value, str):
-        return [expand_path(value)] if value else []
-    if isinstance(value, list):
-        return [expand_path(item) for item in value if isinstance(item, str) and item]
-    return []
-
-
-def expand_path(value: str) -> str:
-    return str(Path(value).expanduser().resolve(strict=False))
-
-
-def sanitize_library_name(name: str) -> str:
-    safe = re.sub(r"[^A-Za-z0-9_.-]", "_", name or "default")
-    return safe or "default"
-
-
-def dedupe(values: list[str]) -> list[str]:
-    seen: set[str] = set()
-    result: list[str] = []
-    for value in values:
-        if value not in seen:
-            result.append(value)
-            seen.add(value)
-    return result
-
-
-def redact(value: Any, key: str = "") -> Any:
-    if key and SECRET_PATTERN.search(key):
-        return "<redacted>"
-    if isinstance(value, dict):
-        return {str(k): redact(v, str(k)) for k, v in value.items()}
-    if isinstance(value, list):
-        return [redact(item) for item in value]
-    return value
-
-
-def summarize_value(value: Any) -> Any:
-    if isinstance(value, dict):
-        return {key: summarize_value(item) for key, item in value.items()}
-    if isinstance(value, list):
-        return {
-            "type": "array",
-            "length": len(value),
-            "first": summarize_value(value[0]) if value else None,
-        }
-    return value
-
-
-def quote_identifier(identifier: str) -> str:
-    return '"' + identifier.replace('"', '""') + '"'
-
-
-def is_internal_sqlite_table(table: str) -> bool:
-    return table.startswith("sqlite_") or table.endswith(("_data", "_idx", "_docsize", "_config", "_content"))
-
-
-def print_json(payload: Any) -> None:
-    json.dump(payload, sys.stdout, indent=2, ensure_ascii=False)
-    sys.stdout.write("\n")
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

.github/ISSUE_TEMPLATE/feature_request.md

@@ -13,5 +13,8 @@ A clear and concise description of what the problem is. Ex. I'm always frustrate
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
 **Additional context**
 Add any other context or screenshots about the feature request here.

.github/workflows/update-supporters.yml

@@ -1,31 +0,0 @@
-name: Update Supporters in README
-
-on:
-  push:
-    paths:
-      - 'data/supporters.json'
-    branches:
-      - main
-  workflow_dispatch: # Allow manual trigger
-
-jobs:
-  update-readme:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-          
-      - name: Update README
-        run: python scripts/update_supporters.py
-        
-      - name: Commit and push changes
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "docs: auto-update supporters list in README"
-          file_pattern: "README.md"

.gitignore

@@ -7,36 +7,15 @@ py/run_test.py
 .vscode/
 cache/
 civitai/
-stats/
-wildcards/
-backups/
-logs/
 node_modules/
 coverage/
 .coverage
 model_cache/
 
-# agent / dev tooling
+# agent
 .opencode/
-.claude/
-.sisyphus/
-.codex
-.omo
-reasonix.toml
-.reasonix/
-.codegraph/
 
 # Vue widgets development cache (but keep build output)
 vue-widgets/node_modules/
 vue-widgets/.vite/
 vue-widgets/dist/
-
-# Hypothesis test cache
-.hypothesis/
-
-# Working/research notes (not committed)
-.docs/
-
-# HF enrichment validation baseline snapshots (contain potentially
-# NSFW README content fetched from community model repos)
-tests/enrich_hf_validation/baselines/

.omo/plans/embeddings-hybrid-approach.md

@@ -1,181 +0,0 @@
-# Embeddings Usage Tracking — Hybrid Approach (Plan C)
-
-> **Status**: Reference document for future implementation
-> **Current implementation**: Plan A (prompt text parsing only, see `usage_stats.py:_process_embeddings`)
-> **Next step**: Add Plan B as a supplement when edge-case coverage is needed
-
-## Problem
-
-Embeddings in ComfyUI are not loaded through dedicated ComfyUI nodes like LoRAs or
-Checkpoints. They are resolved during CLIP tokenization when the prompt text contains
-`embedding:<name>` syntax (see `comfy/sd1_clip.py:SDTokenizer.tokenize_with_weights`).
-
-This means the existing metadata_collector hook (which intercepts node execution via
-`_map_node_over_list`) cannot capture embeddings the same way it captures LoRAs and
-checkpoints — there is no "EmbeddingLoader" node to intercept.
-
-## Solution Architecture
-
-The hybrid approach combines **two complementary mechanisms** to capture embedding
-usage from all possible paths.
-
-```
-┌─────────────────────────────────────────────────────────┐
-│                 Plan A (已实现)                          │
-│                                                         │
-│  MetadataRegistry.prompt_metadata["prompts"]            │
-│       │                                                  │
-│       ▼                                                  │
-│  _process_embeddings()                                   │
-│       │                                                  │
-│       ├─ Iterate all prompt node texts                   │
-│       ├─ regex extract "embedding:<name>"                │
-│       ├─ resolve name → sha256 via EmbeddingScanner      │
-│       └─ UsageStats.stats["embeddings"][sha256]++        │
-│                                                         │
-│  Coverage: ~95% — all CLIPTextEncode/Flux/etc nodes     │
-│                                                         │
-│  Gap: Custom nodes that load embeddings programmatically │
-│       without putting embedding:name in prompt text      │
-└─────────────────────────────────────────────────────────┘
-
-                         +
-                         ↓  (future: enable Plan B when needed)
-
-┌─────────────────────────────────────────────────────────┐
-│                 Plan B (未来 — monkey-patch)              │
-│                                                         │
-│  comfy/sd1_clip.py:load_embed()                         │
-│       │                                                  │
-│       ▼                                                  │
-│  Monkey-patch intercepts EVERY embedding file load       │
-│       │                                                  │
-│       ├─ Records embedding_name + success/failure        │
-│       ├─ Associates with current prompt_id (via registry)│
-│       └─ Feeds into UsageStats same as Plan A            │
-│                                                         │
-│  Coverage: 100% — catches ALL embedding loads            │
-│                                                         │
-│  Cost: Requires patching into ComfyUI internals          │
-│        (sd1_clip.py, sdxl_clip.py, some text_encoders)   │
-└─────────────────────────────────────────────────────────┘
-```
-
-## Plan B Detail — Monkey-patch `load_embed`
-
-### Target Function
-
-**`comfy.sd1_clip.load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None)`**
-at line 415 of `sd1_clip.py`.
-
-This is the **single choke point** for all embedding file loads in ComfyUI. Every
-CLIP variant (SD1, SDXL, SD3, Flux) calls this same function.
-
-### Implementation Sketch
-
-```python
-# In metadata_collector/metadata_hook.py (or a new module)
-import comfy.sd1_clip as sd1_clip
-
-_original_load_embed = sd1_clip.load_embed
-
-def _patched_load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None):
-    result = _original_load_embed(
-        embedding_name, embedding_directory, embedding_size, embed_key
-    )
-    if result is not None:
-        _record_embedding_usage(embedding_name)
-    return result
-
-sd1_clip.load_embed = _patched_load_embed
-```
-
-### Prompt ID Association
-
-The challenge is associating the `load_embed` call with the current `prompt_id`.
-Options:
-
-1. **Thread-local / contextvar**: Store current `prompt_id` in a `contextvars.ContextVar`
-   that the metadata_collector sets at the start of each prompt execution.
-
-2. **MetadataRegistry singleton**: The MetadataRegistry already has `current_prompt_id`.
-   The patch can read it directly since both run in the same thread.
-
-3. **Lazy aggregation**: Instead of associating with prompt_id at load time, collect
-   all loaded embedding names in a global set during execution, then flush to
-   UsageStats after the prompt completes.
-
-### Files to Patch
-
-| File | Function | Coverage |
-|------|----------|----------|
-| `comfy/sd1_clip.py:415` | `load_embed()` | Primary — SD1.x, SDXL, SD3, Flux |
-| `comfy/sdxl_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-| `comfy/text_encoders/sd3_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-| `comfy/text_encoders/flux.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
-
-The SD1 tokenizer is the base class for all CLIP variants' tokenizers, so patching
-`load_embed` covers them all.
-
-### Edge Cases
-
-| Edge Case | Plan A | Plan B |
-|-----------|--------|--------|
-| `embedding:name` in CLIPTextEncode | ✅ | ✅ |
-| `embedding:name` in CLIPTextEncodeFlux | ✅ | ✅ |
-| `embedding:name` in PromptLM (LoRA Manager) | ✅ | ✅ |
-| `embedding:name` in WAS_Text_to_Conditioning | ✅ | ✅ |
-| Custom node that loads embedding programmatically | ❌ | ✅ |
-| Embedding loaded multiple times in same prompt | ✅ (dedup via set) | ✅ (dedup via set) |
-| Embedding file not found | N/A | ✅ (can log) |
-| Embedding dimension mismatch | N/A | ✅ (can log) |
-| Text encoder with non-standard tokenizer (LLaMA, T5...) | Partial | ✅ (if it calls load_embed) |
-
-## Migration Path: Standalone → Hybrid
-
-### Phase 1 — Plan A (当前状态)
-- Prompt text parsing only
-- No monkey-patching required
-- Covers all standard workflows
-
-### Phase 2 — Enable Plan B (未来工作)
-1. Add monkey-patch of `load_embed` in `metadata_collector/metadata_hook.py` (alongside
-   the existing `_map_node_over_list` hook)
-2. Collect loaded embedding names in a `set()` on the registry
-3. In `UsageStats._process_embeddings()`, merge the Plan A results (from prompt text)
-   with the Plan B results (from the patch)
-4. Add `prompt_data` field on MetadataRegistry to store loaded embeddings per prompt
-
-### Deduplication
-
-```python
-# Merge Plan A + Plan B results in _process_embeddings
-plan_a_names = extract_from_prompt_texts(prompts_data)
-plan_b_names = registry.get_loaded_embeddings(prompt_id)
-
-all_names = plan_a_names | plan_b_names
-```
-
-## Testing the Hybrid
-
-| Scenario | What to verify |
-|----------|---------------|
-| Standard `embedding:name` in prompt | Plan A captures it |
-| Embedding loaded by custom node script | Plan B captures it |
-| Both paths fire for same embedding | No double-counting (dedup) |
-| Embedding name resolves to hash | EmbeddingScanner.get_hash_by_filename works |
-| No embedding scanner available | Graceful skip, no crash |
-| Missing embedding file | Plan B logs warning, Plan A skips gracefully |
-| Empty prompt | No crash, no entries |
-| Standalone mode | Both plans disabled gracefully |
-
-## Key Files Reference
-
-| File | Role |
-|------|------|
-| `py/utils/usage_stats.py` | Core — `_process_embeddings()` for Plan A |
-| `py/metadata_collector/constants.py` | `EMBEDDINGS` category constant |
-| `py/metadata_collector/metadata_hook.py` | Future — monkey-patch for Plan B |
-| `py/services/embedding_scanner.py` | Hash resolution service |
-| `py/routes/stats_routes.py` | Already handles `usage_data.get('embeddings', {})` |
-| `comfy/sd1_clip.py` (ComfyUI) | `load_embed()` — Plan B target |

.specs/metadata.schema.json

@@ -1,464 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://github.com/willmiao/ComfyUI-Lora-Manager/.specs/metadata.schema.json",
-  "title": "ComfyUI LoRa Manager Model Metadata",
-  "description": "Schema for .metadata.json sidecar files used by ComfyUI LoRa Manager",
-  "type": "object",
-  "oneOf": [
-    {
-      "title": "LoRA Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string",
-          "description": "Filename without extension"
-        },
-        "model_name": {
-          "type": "string",
-          "description": "Display name of the model"
-        },
-        "file_path": {
-          "type": "string",
-          "description": "Full absolute path to the model file"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0,
-          "description": "File size in bytes at time of import/download"
-        },
-        "modified": {
-          "type": "number",
-          "description": "Unix timestamp when model was imported/added (Date Added)"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$",
-          "description": "SHA256 hash of the model file (lowercase)"
-        },
-        "base_model": {
-          "type": "string",
-          "description": "Base model type (SD1.5, SD2.1, SDXL, SD3, Flux, Unknown, etc.)"
-        },
-        "preview_url": {
-          "type": "string",
-          "description": "Path to preview image file"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "default": 0,
-          "description": "NSFW level using bitmask values: 0 (none), 1 (PG), 2 (PG13), 4 (R), 8 (X), 16 (XXX), 32 (Blocked)"
-        },
-        "notes": {
-          "type": "string",
-          "default": "",
-          "description": "User-defined notes"
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true,
-          "description": "Whether the model originated from Civitai"
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": [],
-          "description": "Model tags"
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": "",
-          "description": "Full model description"
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether the model was deleted from Civitai"
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether the model is marked as favorite"
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether to exclude from cache/scanning"
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false,
-          "description": "Whether checked against archive database"
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false,
-          "description": "Skip this model during bulk metadata refresh"
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null,
-          "description": "Last provider that supplied metadata"
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0,
-          "description": "Unix timestamp of last metadata check"
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed",
-          "description": "Hash calculation status"
-        },
-        "usage_tips": {
-          "type": "string",
-          "default": "{}",
-          "description": "JSON string containing recommended usage parameters (LoRA only)"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    },
-    {
-      "title": "Checkpoint Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string"
-        },
-        "model_name": {
-          "type": "string"
-        },
-        "file_path": {
-          "type": "string"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "modified": {
-          "type": "number"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$"
-        },
-        "base_model": {
-          "type": "string"
-        },
-        "preview_url": {
-          "type": "string"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 3,
-          "default": 0
-        },
-        "notes": {
-          "type": "string",
-          "default": ""
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": []
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": ""
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed"
-        },
-        "sub_type": {
-          "type": "string",
-          "default": "checkpoint",
-          "description": "Model sub-type (checkpoint, diffusion_model, etc.)"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    },
-    {
-      "title": "Embedding Model Metadata",
-      "properties": {
-        "file_name": {
-          "type": "string"
-        },
-        "model_name": {
-          "type": "string"
-        },
-        "file_path": {
-          "type": "string"
-        },
-        "size": {
-          "type": "integer",
-          "minimum": 0
-        },
-        "modified": {
-          "type": "number"
-        },
-        "sha256": {
-          "type": "string",
-          "pattern": "^[a-f0-9]{64}$"
-        },
-        "base_model": {
-          "type": "string"
-        },
-        "preview_url": {
-          "type": "string"
-        },
-        "preview_nsfw_level": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 3,
-          "default": 0
-        },
-        "notes": {
-          "type": "string",
-          "default": ""
-        },
-        "from_civitai": {
-          "type": "boolean",
-          "default": true
-        },
-        "civitai": {
-          "$ref": "#/definitions/civitaiObject"
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": []
-        },
-        "modelDescription": {
-          "type": "string",
-          "default": ""
-        },
-        "civitai_deleted": {
-          "type": "boolean",
-          "default": false
-        },
-        "favorite": {
-          "type": "boolean",
-          "default": false
-        },
-        "exclude": {
-          "type": "boolean",
-          "default": false
-        },
-        "db_checked": {
-          "type": "boolean",
-          "default": false
-        },
-        "skip_metadata_refresh": {
-          "type": "boolean",
-          "default": false
-        },
-        "metadata_source": {
-          "type": ["string", "null"],
-          "enum": ["civitai_api", "civarchive", "archive_db", null],
-          "default": null
-        },
-        "last_checked_at": {
-          "type": "number",
-          "default": 0
-        },
-        "hash_status": {
-          "type": "string",
-          "enum": ["pending", "calculating", "completed", "failed"],
-          "default": "completed"
-        },
-        "sub_type": {
-          "type": "string",
-          "default": "embedding",
-          "description": "Model sub-type"
-        }
-      },
-      "required": [
-        "file_name",
-        "model_name",
-        "file_path",
-        "size",
-        "modified",
-        "sha256",
-        "base_model"
-      ],
-      "additionalProperties": true
-    }
-  ],
-  "definitions": {
-    "civitaiObject": {
-      "type": "object",
-      "default": {},
-      "description": "Civitai/CivArchive API data and user-defined fields",
-      "properties": {
-        "id": {
-          "type": "integer",
-          "description": "Version ID from Civitai"
-        },
-        "modelId": {
-          "type": "integer",
-          "description": "Model ID from Civitai"
-        },
-        "name": {
-          "type": "string",
-          "description": "Version name"
-        },
-        "description": {
-          "type": "string",
-          "description": "Version description"
-        },
-        "baseModel": {
-          "type": "string",
-          "description": "Base model type from Civitai"
-        },
-        "type": {
-          "type": "string",
-          "description": "Model type (checkpoint, embedding, etc.)"
-        },
-        "trainedWords": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Trigger words for the model (from API or user-defined)"
-        },
-        "customImages": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          },
-          "description": "Custom example images added by user"
-        },
-        "model": {
-          "type": "object",
-          "properties": {
-            "name": {
-              "type": "string"
-            },
-            "description": {
-              "type": "string"
-            },
-            "tags": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "files": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          }
-        },
-        "images": {
-          "type": "array",
-          "items": {
-            "type": "object"
-          }
-        },
-        "creator": {
-          "type": "object"
-        }
-      },
-      "additionalProperties": true
-    },
-    "usageTips": {
-      "type": "object",
-      "description": "Structure for usage_tips JSON string (LoRA models)",
-      "properties": {
-        "strength_min": {
-          "type": "number",
-          "description": "Minimum recommended model strength"
-        },
-        "strength_max": {
-          "type": "number",
-          "description": "Maximum recommended model strength"
-        },
-        "strength_range": {
-          "type": "string",
-          "description": "Human-readable strength range"
-        },
-        "strength": {
-          "type": "number",
-          "description": "Single recommended strength value"
-        },
-        "clip_strength": {
-          "type": "number",
-          "description": "Recommended CLIP/embedding strength"
-        },
-        "clip_skip": {
-          "type": "integer",
-          "description": "Recommended CLIP skip value"
-        }
-      },
-      "additionalProperties": true
-    }
-  }
-}

AGENTS.md

@@ -25,134 +25,168 @@ pytest tests/test_recipes.py::test_function_name
 
 # Run backend tests with coverage
 COVERAGE_FILE=coverage/backend/.coverage pytest \
-  --cov=py --cov=standalone \
+  --cov=py \
+  --cov=standalone \
   --cov-report=term-missing \
   --cov-report=html:coverage/backend/html \
-  --cov-report=xml:coverage/backend/coverage.xml
+  --cov-report=xml:coverage/backend/coverage.xml \
+  --cov-report=json:coverage/backend/coverage.json
 ```
 
-### Frontend Development (Standalone Web UI)
+### Frontend Development
 
 ```bash
+# Install frontend dependencies
 npm install
-npm test                    # Run all tests (JS + Vue)
-npm run test:js             # Run JS tests only
-npm run test:watch          # Watch mode
-npm run test:coverage       # Generate coverage report
-```
 
-### Vue Widget Development
+# Run frontend tests
+npm test
 
-```bash
-cd vue-widgets
-npm install
-npm run dev                 # Build in watch mode
-npm run build               # Build production bundle
-npm run typecheck           # Run TypeScript type checking
-npm test                    # Run Vue widget tests
-npm run test:watch          # Watch mode
-npm run test:coverage       # Generate coverage report
+# Run frontend tests in watch mode
+npm run test:watch
+
+# Run frontend tests with coverage
+npm run test:coverage
 ```
 
 ## Python Code Style
 
-### Imports & Formatting
+### Imports
 
-- Use `from __future__ import annotations` for forward references
-- Group imports: standard library, third-party, local (blank line separated)
-- Absolute imports within `py/`: `from ..services import X`
-- PEP 8 with 4-space indentation, type hints required
+- Use `from __future__ import annotations` for forward references in type hints
+- Group imports: standard library, third-party, local (separated by blank lines)
+- Use absolute imports within `py/` package: `from ..services import X`
+- Mock ComfyUI dependencies in tests using `tests/conftest.py` patterns
+
+### Formatting & Types
+
+- PEP 8 with 4-space indentation
+- Type hints required for function signatures and class attributes
+- Use `TYPE_CHECKING` guard for type-checking-only imports
+- Prefer dataclasses for simple data containers
+- Use `Optional[T]` for nullable types, `Union[T, None]` only when necessary
 
 ### Naming Conventions
 
-- Files: `snake_case.py`, Classes: `PascalCase`, Functions/vars: `snake_case`
-- Constants: `UPPER_SNAKE_CASE`, Private: `_protected`, `__mangled`
+- Files: `snake_case.py` (e.g., `model_scanner.py`, `lora_service.py`)
+- Classes: `PascalCase` (e.g., `ModelScanner`, `LoraService`)
+- Functions/variables: `snake_case` (e.g., `get_instance`, `model_type`)
+- Constants: `UPPER_SNAKE_CASE` (e.g., `VALID_LORA_TYPES`)
+- Private members: `_single_underscore` (protected), `__double_underscore` (name-mangled)
 
-### Error Handling & Async
+### Error Handling
 
-- Use `logging.getLogger(__name__)`, define custom exceptions in `py/services/errors.py`
-- `async def` for I/O, `@pytest.mark.asyncio` for async tests
-- Singleton with `asyncio.Lock`: see `ModelScanner.get_instance()`
-- Return `aiohttp.web.json_response` or `web.Response`
+- Use `logging.getLogger(__name__)` for module-level loggers
+- Define custom exceptions in `py/services/errors.py`
+- Use `asyncio.Lock` for thread-safe singleton patterns
+- Raise specific exceptions with descriptive messages
+- Log errors at appropriate levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
 
-### Testing
+### Async Patterns
 
-- `pytest` with `--import-mode=importlib`
-- Fixtures in `tests/conftest.py`, use `tmp_path_factory` for isolation
-- Mark tests needing real paths: `@pytest.mark.no_settings_dir_isolation`
-- Mock ComfyUI dependencies via conftest patterns
+- Use `async def` for I/O-bound operations
+- Mark async tests with `@pytest.mark.asyncio`
+- Use `async with` for context managers
+- Singleton pattern with class-level locks: see `ModelScanner.get_instance()`
+- Use `aiohttp.web.Response` for HTTP responses
 
-## JavaScript/TypeScript Code Style
+### Testing Patterns
+
+- Use `pytest` with `--import-mode=importlib`
+- Fixtures in `tests/conftest.py` handle ComfyUI mocking
+- Use `@pytest.mark.no_settings_dir_isolation` for tests needing real paths
+- Test files: `tests/test_*.py`
+- Use `tmp_path_factory` for temporary directory isolation
+
+## JavaScript Code Style
 
 ### Imports & Modules
 
-- ES modules: `import { app } from "../../scripts/app.js"` for ComfyUI
-- Vue: `import { ref, computed } from 'vue'`, type imports: `import type { Foo }`
-- Export named functions: `export function foo() {}`
+- ES modules with `import`/`export`
+- Use `import { app } from "../../scripts/app.js"` for ComfyUI integration
+- Export named functions/classes: `export function foo() {}`
+- Widget files use `*_widget.js` suffix
 
 ### Naming & Formatting
 
-- camelCase for functions/vars/props, PascalCase for classes
-- Constants: `UPPER_SNAKE_CASE`, Files: `snake_case.js` or `kebab-case.js`
+- camelCase for functions, variables, object properties
+- PascalCase for classes/constructors
+- Constants: `UPPER_SNAKE_CASE` (e.g., `CONVERTED_TYPE`)
+- Files: `snake_case.js` or `kebab-case.js`
 - 2-space indentation preferred (follow existing file conventions)
-- Vue Single File Components: `<script setup lang="ts">` preferred
 
 ### Widget Development
 
-- ComfyUI: `app.registerExtension()`, `node.addDOMWidget(name, type, element, options)`
-- Event handlers via `addEventListener` or widget callbacks
-- Shared utilities: `web/comfyui/utils.js`
-
-### Vue Composables Pattern
-
-- Use composition API: `useXxxState(widget)`, return reactive refs and methods
-- Guard restoration loops with flag: `let isRestoring = false`
-- Build config from state: `const buildConfig = (): Config => { ... }`
+- Use `app.registerExtension()` to register ComfyUI extensions
+- Use `node.addDOMWidget(name, type, element, options)` for custom widgets
+- Event handlers attached via `addEventListener` or widget callbacks
+- See `web/comfyui/utils.js` for shared utilities
 
 ## Architecture Patterns
 
 ### Service Layer
 
-- `ServiceRegistry` singleton for DI, services use `get_instance()` classmethod
+- Use `ServiceRegistry` singleton for dependency injection
+- Services follow singleton pattern via `get_instance()` class method
 - Separate scanners (discovery) from services (business logic)
-- Handlers in `py/routes/handlers/` are pure functions with deps as params
+- Handlers in `py/routes/handlers/` implement route logic
 
-### Model Types & Routes
+### Model Types
 
-- `BaseModelService` base for LoRA, Checkpoint, Embedding
-- `ModelScanner` for file discovery, hash deduplication
-- `PersistentModelCache` (SQLite) for persistence
-- Route registrars: `ModelRouteRegistrar`, endpoints: `/loras/*`, `/checkpoints/*`, `/embeddings/*`
-- WebSocket via `WebSocketManager` for real-time updates
+- BaseModelService is abstract base for LoRA, Checkpoint, Embedding services
+- ModelScanner provides file discovery and hash-based deduplication
+- Persistent cache in SQLite via `PersistentModelCache`
+- Metadata sync from CivitAI/CivArchive via `MetadataSyncService`
+
+### Routes & Handlers
+
+- Route registrars organize endpoints by domain: `ModelRouteRegistrar`, etc.
+- Handlers are pure functions taking dependencies as parameters
+- Use `WebSocketManager` for real-time progress updates
+- Return `aiohttp.web.json_response` or `web.Response`
 
 ### Recipe System
 
-- Base: `py/recipes/base.py`, Enrichment: `RecipeEnrichmentService`
-- Parsers: `py/recipes/parsers/`
+- Base metadata in `py/recipes/base.py`
+- Enrichment adds model metadata: `RecipeEnrichmentService`
+- Parsers for different formats in `py/recipes/parsers/`
 
 ## Important Notes
 
-- ALWAYS use English for comments (per copilot-instructions.md)
-- Dual mode: ComfyUI plugin (folder_paths) vs standalone (settings.json)
+- Always use English for comments (per copilot-instructions.md)
+- Dual mode: ComfyUI plugin (uses folder_paths) vs standalone (reads settings.json)
 - Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
-- Run `python scripts/sync_translation_keys.py` after adding UI strings to `locales/en.json`
-- Symlinks require normalized paths
-
-## Git / Commit Messages
-
-- Follow the style of recent repository commits when writing commit messages
-- Prefer the repo's existing `feat(...)`, `fix(...)`, `chore:` style where applicable
-- If the user has provided a GitHub issue link or issue ID for the task, mention that issue in the commit message, for example `(#871)`
-- When unrelated local changes exist, stage and commit only the files relevant to the requested task
+- Settings auto-saved in user directory or portable mode
+- WebSocket broadcasts for real-time updates (downloads, scans)
+- Symlink handling requires normalized paths
+- API endpoints follow `/loras/*`, `/checkpoints/*`, `/embeddings/*` patterns
+- Run `python scripts/sync_translation_keys.py` after UI string updates
 
 ## Frontend UI Architecture
 
-### 1. Standalone Web UI
+This project has two distinct UI systems:
+
+### 1. Standalone Lora Manager Web UI
 - Location: `./static/` and `./templates/`
-- Tech: Vanilla JS + CSS, served by standalone server
-- Tests via npm in root directory
+- Purpose: Full-featured web application for managing LoRA models
+- Tech stack: Vanilla JS + CSS, served by the standalone server
+- Development: Uses npm for frontend testing (`npm test`, `npm run test:watch`, etc.)
 
 ### 2. ComfyUI Custom Node Widgets
-- Location: `./web/comfyui/` (Vanilla JS) + `./vue-widgets/` (Vue)
-- Primary styles: `./web/comfyui/lm_styles.css` (NOT `./static/css/`)
-- Vue builds to `./web/comfyui/vue-widgets/`, typecheck via `vue-tsc`
+- Location: `./web/comfyui/`
+- Purpose: Widgets and UI logic that ComfyUI loads as custom node extensions
+- Tech stack: Vanilla JS + Vue.js widgets (in `./vue-widgets/` and built to `./web/comfyui/vue-widgets/`)
+- Widget styling: Primary styles in `./web/comfyui/lm_styles.css` (NOT `./static/css/`)
+- Development: No npm build step for these widgets (Vue widgets use build system)
+
+### Widget Development Guidelines
+- Use `app.registerExtension()` to register ComfyUI extensions (ComfyUI integration layer)
+- Use `node.addDOMWidget()` for custom DOM widgets
+- Widget styles should follow the patterns in `./web/comfyui/lm_styles.css`
+  - Selected state: `rgba(66, 153, 225, 0.3)` background, `rgba(66, 153, 225, 0.6)` border
+  - Hover state: `rgba(66, 153, 225, 0.2)` background
+  - Color palette matches the Lora Manager accent color (blue #4299e1)
+  - Use oklch() for color values when possible (defined in `./static/css/base.css`)
+- Vue widget components are in `./vue-widgets/src/components/` and built to `./web/comfyui/vue-widgets/`
+- When modifying widget styles, check `./web/comfyui/lm_styles.css` for consistency with other ComfyUI widgets
+

CLAUDE.md

@@ -8,22 +8,17 @@ ComfyUI LoRA Manager is a comprehensive LoRA management system for ComfyUI that
 
 ## Development Commands
 
-### Backend
-
+### Backend Development
 ```bash
+# Install dependencies
 pip install -r requirements.txt
+
+# Install development dependencies (for testing)
 pip install -r requirements-dev.txt
 
 # Run standalone server (port 8188 by default)
 python standalone.py --port 8188
 
-# Run all backend tests
-pytest
-
-# Run specific test file or function
-pytest tests/test_recipes.py
-pytest tests/test_recipes.py::test_function_name
-
 # Run backend tests with coverage
 COVERAGE_FILE=coverage/backend/.coverage pytest \
   --cov=py \
@@ -32,158 +27,185 @@ COVERAGE_FILE=coverage/backend/.coverage pytest \
   --cov-report=html:coverage/backend/html \
   --cov-report=xml:coverage/backend/coverage.xml \
   --cov-report=json:coverage/backend/coverage.json
+
+# Run specific test file
+pytest tests/test_recipes.py
 ```
 
-### Frontend
-
-There are three test suites run by `npm test`: vanilla JS tests (vitest at root) and Vue widget tests (`vue-widgets/` vitest).
-
+### Frontend Development
 ```bash
+# Install frontend dependencies
 npm install
-cd vue-widgets && npm install && cd ..
 
-# Run all frontend tests (JS + Vue)
+# Run frontend tests
 npm test
 
-# Run only vanilla JS tests
-npm run test:js
-
-# Run only Vue widget tests
-npm run test:vue
-
-# Watch mode (JS tests only)
+# Run frontend tests in watch mode
 npm run test:watch
 
-# Frontend coverage
+# Run frontend tests with coverage
 npm run test:coverage
-
-# Build Vue widgets (output to web/comfyui/vue-widgets/)
-cd vue-widgets && npm run build
-
-# Vue widget dev mode (watch + rebuild)
-cd vue-widgets && npm run dev
-
-# Typecheck Vue widgets
-cd vue-widgets && npm run typecheck
 ```
 
 ### Localization
-
 ```bash
 # Sync translation keys after UI string updates
 python scripts/sync_translation_keys.py
 ```
 
-Locale files are in `locales/` (en, zh-CN, zh-TW, ja, ko, fr, de, es, ru, he).
-
 ## Architecture
 
-### Dual Mode Operation
+### Backend Structure (Python)
 
-The system runs in two modes:
-- **ComfyUI plugin mode**: Integrates with ComfyUI's PromptServer, uses `folder_paths` for model discovery
-- **Standalone mode**: `standalone.py` mocks ComfyUI dependencies, reads paths from `settings.json`
-- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+**Core Entry Points:**
+- `__init__.py` - ComfyUI plugin entry point, registers nodes and routes
+- `standalone.py` - Standalone server that mocks ComfyUI dependencies
+- `py/lora_manager.py` - Main LoraManager class that registers HTTP routes
 
-### Backend (Python)
+**Service Layer** (`py/services/`):
+- `ServiceRegistry` - Singleton service registry for dependency management
+- `ModelServiceFactory` - Factory for creating model services (LoRA, Checkpoint, Embedding)
+- Scanner services (`lora_scanner.py`, `checkpoint_scanner.py`, `embedding_scanner.py`) - Model file discovery and indexing
+- `model_scanner.py` - Base scanner with hash-based deduplication and metadata extraction
+- `persistent_model_cache.py` - SQLite-based cache for model metadata
+- `metadata_sync_service.py` - Syncs metadata from CivitAI/CivArchive APIs
+- `civitai_client.py` / `civarchive_client.py` - API clients for external services
+- `downloader.py` / `download_manager.py` - Model download orchestration
+- `recipe_scanner.py` - Recipe file management and image association
+- `settings_manager.py` - Application settings with migration support
+- `websocket_manager.py` - WebSocket broadcasting for real-time updates
+- `use_cases/` - Business logic orchestration (auto-organize, bulk refresh, downloads)
 
-**Entry points:**
-- `__init__.py` — ComfyUI plugin entry: registers nodes via `NODE_CLASS_MAPPINGS`, sets `WEB_DIRECTORY`, calls `LoraManager.add_routes()`
-- `standalone.py` — Standalone server: mocks `folder_paths` and node modules, starts aiohttp server
-- `py/lora_manager.py` — Main `LoraManager` class that registers all HTTP routes
+**Routes Layer** (`py/routes/`):
+- Route registrars organize endpoints by domain (models, recipes, previews, example images, updates)
+- `handlers/` - Request handlers implementing business logic
+- Routes use aiohttp and integrate with ComfyUI's PromptServer
 
-**Service layer** (`py/services/`):
-- `ServiceRegistry` singleton for dependency injection; services follow `get_instance()` singleton pattern
-- `BaseModelService` abstract base → `LoraService`, `CheckpointService`, `EmbeddingService`
-- `ModelScanner` base → `LoraScanner`, `CheckpointScanner`, `EmbeddingScanner` for file discovery with hash-based deduplication
-- `PersistentModelCache` — SQLite-based metadata cache
-- `MetadataSyncService` — Background sync from CivitAI/CivArchive APIs
-- `SettingsManager` — Settings with schema migration support
-- `WebSocketManager` — Real-time progress broadcasting
-- `ModelServiceFactory` — Creates the right service for each model type
-- Use cases in `py/services/use_cases/` orchestrate complex business logic (auto-organize, bulk refresh, downloads)
+**Recipe System** (`py/recipes/`):
+- `base.py` - Base recipe metadata structure
+- `enrichment.py` - Enriches recipes with model metadata
+- `merger.py` - Merges recipe data from multiple sources
+- `parsers/` - Parsers for different recipe formats (PNG, JSON, workflow)
 
-**Routes** (`py/routes/`):
-- Route registrars organize endpoints by domain: `ModelRouteRegistrar`, `RecipeRouteRegistrar`, etc.
-- Request handlers in `py/routes/handlers/` implement route logic
-- API endpoints follow `/loras/*`, `/checkpoints/*`, `/embeddings/*` patterns
-- All routes use aiohttp, return `web.json_response` or `web.Response`
-
-**Recipe system** (`py/recipes/`):
-- `base.py` — Recipe metadata structure
-- `enrichment.py` — Enriches recipes with model metadata
-- `parsers/` — Parsers for PNG metadata, JSON, and workflow formats
-
-**Custom nodes** (`py/nodes/`):
-- Each node class has a `NAME` class attribute used as key in `NODE_CLASS_MAPPINGS`
-- Standard ComfyUI node pattern: `INPUT_TYPES()` classmethod, `RETURN_TYPES`, `FUNCTION`
-- All nodes registered in `__init__.py`
+**Custom Nodes** (`py/nodes/`):
+- `lora_loader.py` - LoRA loader nodes with preset support
+- `save_image.py` - Enhanced save image with pattern-based filenames
+- `trigger_word_toggle.py` - Toggle trigger words in prompts
+- `lora_stacker.py` - Stack multiple LoRAs
+- `prompt.py` - Prompt node with autocomplete
+- `wanvideo_lora_select.py` - WanVideo-specific LoRA selection
 
 **Configuration** (`py/config.py`):
-- Manages folder paths for models, handles symlink mappings
+- Manages folder paths for models, checkpoints, embeddings
+- Handles symlink mappings for complex directory structures
 - Auto-saves paths to settings.json in ComfyUI mode
 
-### Frontend — Two Distinct UI Systems
+### Frontend Structure (JavaScript)
 
-#### 1. Standalone Manager Web UI
-- **Location:** `static/` (JS/CSS) and `templates/` (HTML)
-- **Tech:** Vanilla JS + CSS, served by standalone server
-- **Structure:** `static/js/core.js` (shared), `loras.js`, `checkpoints.js`, `embeddings.js`, `recipes.js`, `statistics.js`
-- **Tests:** `tests/frontend/**/*.test.js` (vitest + jsdom)
+**ComfyUI Widgets** (`web/comfyui/`):
+- Vanilla JavaScript ES modules extending ComfyUI's LiteGraph-based UI
+- `loras_widget.js` - Main LoRA selection widget with preview
+- `loras_widget_events.js` - Event handling for widget interactions
+- `autocomplete.js` - Autocomplete for trigger words and embeddings
+- `preview_tooltip.js` - Preview tooltip for model cards
+- `top_menu_extension.js` - Adds "Launch LoRA Manager" menu item
+- `trigger_word_highlight.js` - Syntax highlighting for trigger words
+- `utils.js` - Shared utilities and API helpers
 
-#### 2. ComfyUI Custom Node Widgets
-- **Vanilla JS widgets:** `web/comfyui/*.js` — ES modules extending ComfyUI's LiteGraph UI
-  - `loras_widget.js` / `loras_widget_events.js` — Main LoRA selection widget
-  - `autocomplete.js` — Trigger word and embedding autocomplete
-  - `preview_tooltip.js` — Model card preview tooltips
-  - `top_menu_extension.js` — "Launch LoRA Manager" menu item
-  - `utils.js` — Shared utilities and API helpers
-  - Widget styling in `web/comfyui/lm_styles.css` (NOT `static/css/`)
-- **Vue widgets:** `vue-widgets/src/` → built to `web/comfyui/vue-widgets/`
-  - Vue 3 + TypeScript + PrimeVue + vue-i18n
-  - Vite build with CSS-injected-by-JS plugin
-  - Components: `LoraPoolWidget`, `LoraRandomizerWidget`, `LoraCyclerWidget`, `AutocompleteTextWidget`
-  - Auto-built on ComfyUI startup via `py/vue_widget_builder.py`
-  - Tests: `vue-widgets/tests/**/*.test.ts` (vitest)
+**Widget Development:**
+- Widgets use `app.registerExtension` and `getCustomWidgets` hooks
+- `node.addDOMWidget(name, type, element, options)` embeds HTML in nodes
+- See `docs/dom_widget_dev_guide.md` for complete DOMWidget development guide
 
-**Widget registration pattern:**
-- Widgets use `app.registerExtension()` and `getCustomWidgets` hooks
-- `node.addDOMWidget(name, type, element, options)` embeds HTML in LiteGraph nodes
-- See `docs/dom_widget_dev_guide.md` for DOMWidget development guide
+**Web Source** (`web-src/`):
+- Modern frontend components (if migrating from static)
+- `components/` - Reusable UI components
+- `styles/` - CSS styling
+
+### Key Patterns
+
+**Dual Mode Operation:**
+- ComfyUI plugin mode: Integrates with ComfyUI's PromptServer, uses folder_paths
+- Standalone mode: Mocks ComfyUI dependencies via `standalone.py`, reads paths from settings.json
+- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+
+**Settings Management:**
+- Settings stored in user directory (via `platformdirs`) or portable mode (in repo)
+- Migration system tracks settings schema version
+- Template in `settings.json.example` defines defaults
+
+**Model Scanning Flow:**
+1. Scanner walks folder paths, computes file hashes
+2. Hash-based deduplication prevents duplicate processing
+3. Metadata extracted from safetensors headers
+4. Persistent cache stores results in SQLite
+5. Background sync fetches CivitAI/CivArchive metadata
+6. WebSocket broadcasts updates to connected clients
+
+**Recipe System:**
+- Recipes store LoRA combinations with parameters
+- Supports import from workflow JSON, PNG metadata
+- Images associated with recipes via sibling file detection
+- Enrichment adds model metadata for display
+
+**Frontend-Backend Communication:**
+- REST API for CRUD operations
+- WebSocket for real-time progress updates (downloads, scans)
+- API endpoints follow `/loras/*` pattern
 
 ## Code Style
 
 **Python:**
-- PEP 8, 4-space indentation, English comments only
-- Use `from __future__ import annotations` for forward references
-- Use `TYPE_CHECKING` guard for type-checking-only imports
+- PEP 8 with 4-space indentation
+- snake_case for files, functions, variables
+- PascalCase for classes
+- Type hints preferred
+- English comments only (per copilot-instructions.md)
 - Loggers via `logging.getLogger(__name__)`
-- Custom exceptions in `py/services/errors.py`
-- Async patterns: `async def` for I/O, `@pytest.mark.asyncio` for async tests
-- Singleton pattern with class-level `asyncio.Lock` (see `ModelScanner.get_instance()`)
 
 **JavaScript:**
-- ES modules, camelCase functions/variables, PascalCase classes
-- Widget files use `*_widget.js` suffix
-- Prefer vanilla JS for `web/comfyui/` widgets, avoid framework dependencies (except Vue widgets)
+- ES modules with camelCase
+- Files use `*_widget.js` suffix for ComfyUI widgets
+- Prefer vanilla JS, avoid framework dependencies
 
 ## Testing
 
-**Backend (pytest):**
-- Config in `pytest.ini`: `--import-mode=importlib`, testpaths=`tests`
-- Fixtures in `tests/conftest.py` handle ComfyUI dependency mocking
-- Markers: `@pytest.mark.asyncio`, `@pytest.mark.no_settings_dir_isolation`
-- Uses `tmp_path_factory` for directory isolation
+**Backend Tests:**
+- pytest with `--import-mode=importlib`
+- Test files: `tests/test_*.py`
+- Fixtures in `tests/conftest.py`
+- Mock ComfyUI dependencies using standalone.py patterns
+- Markers: `@pytest.mark.asyncio` for async tests, `@pytest.mark.no_settings_dir_isolation` for real paths
 
-**Frontend (vitest):**
-- Vanilla JS tests: `tests/frontend/**/*.test.js` with jsdom
-- Vue widget tests: `vue-widgets/tests/**/*.test.ts` with jsdom + @vue/test-utils
+**Frontend Tests:**
+- Vitest with jsdom environment
+- Test files: `tests/frontend/**/*.test.js`
 - Setup in `tests/frontend/setup.js`
+- Coverage via `npm run test:coverage`
 
-## Key Integration Points
+## Important Notes
 
-- **Settings:** Stored in user directory (via `platformdirs`) or portable mode (`"use_portable_settings": true`)
-- **CivitAI/CivArchive:** API clients for metadata sync and model downloads; CivitAI API key in settings
-- **Symlink handling:** Config scans symlinks to map virtual→physical paths; fingerprinting prevents redundant rescans
-- **WebSocket:** Broadcasts real-time progress for downloads, scans, and metadata sync
-- **Model scanning flow:** Walk folders → compute hashes → deduplicate → extract safetensors metadata → cache in SQLite → background CivitAI sync → WebSocket broadcast
+**Settings Location:**
+- ComfyUI mode: Auto-saves folder paths to user settings directory
+- Standalone mode: Use `settings.json` (copy from `settings.json.example`)
+- Portable mode: Set `"use_portable_settings": true` in settings.json
+
+**API Integration:**
+- CivitAI API key required for downloads (add to settings)
+- CivArchive API used as fallback for deleted models
+- Metadata archive database available for offline metadata
+
+**Symlink Handling:**
+- Config scans symlinks to map virtual paths to physical locations
+- Preview validation uses normalized preview root paths
+- Fingerprinting prevents redundant symlink rescans
+
+**ComfyUI Node Development:**
+- Nodes defined in `py/nodes/`, registered in `__init__.py`
+- Frontend widgets in `web/comfyui/`, matched by node type
+- Use `WEB_DIRECTORY = "./web/comfyui"` convention
+
+**Recipe Image Association:**
+- Recipes scan for sibling images in same directory
+- Supports repair/migration of recipe image paths
+- See `py/services/recipe_scanner.py` for implementation details

__init__.py

@@ -1,13 +1,10 @@
 try:  # pragma: no cover - import fallback for pytest collection
     from .py.lora_manager import LoraManager
     from .py.nodes.lora_loader import LoraLoaderLM, LoraTextLoaderLM
-    from .py.nodes.checkpoint_loader import CheckpointLoaderLM
-    from .py.nodes.unet_loader import UNETLoaderLM
     from .py.nodes.trigger_word_toggle import TriggerWordToggleLM
     from .py.nodes.prompt import PromptLM
     from .py.nodes.text import TextLM
     from .py.nodes.lora_stacker import LoraStackerLM
-    from .py.nodes.lora_stack_combiner import LoraStackCombinerLM
     from .py.nodes.save_image import SaveImageLM
     from .py.nodes.debug_metadata import DebugMetadataLM
     from .py.nodes.wanvideo_lora_select import WanVideoLoraSelectLM
@@ -30,19 +27,16 @@ except (
     PromptLM = importlib.import_module("py.nodes.prompt").PromptLM
     TextLM = importlib.import_module("py.nodes.text").TextLM
     LoraManager = importlib.import_module("py.lora_manager").LoraManager
-    LoraLoaderLM = importlib.import_module("py.nodes.lora_loader").LoraLoaderLM
-    LoraTextLoaderLM = importlib.import_module("py.nodes.lora_loader").LoraTextLoaderLM
-    CheckpointLoaderLM = importlib.import_module(
-        "py.nodes.checkpoint_loader"
-    ).CheckpointLoaderLM
-    UNETLoaderLM = importlib.import_module("py.nodes.unet_loader").UNETLoaderLM
+    LoraLoaderLM = importlib.import_module(
+        "py.nodes.lora_loader"
+    ).LoraLoaderLM
+    LoraTextLoaderLM = importlib.import_module(
+        "py.nodes.lora_loader"
+    ).LoraTextLoaderLM
     TriggerWordToggleLM = importlib.import_module(
         "py.nodes.trigger_word_toggle"
     ).TriggerWordToggleLM
     LoraStackerLM = importlib.import_module("py.nodes.lora_stacker").LoraStackerLM
-    LoraStackCombinerLM = importlib.import_module(
-        "py.nodes.lora_stack_combiner"
-    ).LoraStackCombinerLM
     SaveImageLM = importlib.import_module("py.nodes.save_image").SaveImageLM
     DebugMetadataLM = importlib.import_module("py.nodes.debug_metadata").DebugMetadataLM
     WanVideoLoraSelectLM = importlib.import_module(
@@ -55,7 +49,9 @@ except (
     LoraRandomizerLM = importlib.import_module(
         "py.nodes.lora_randomizer"
     ).LoraRandomizerLM
-    LoraCyclerLM = importlib.import_module("py.nodes.lora_cycler").LoraCyclerLM
+    LoraCyclerLM = importlib.import_module(
+        "py.nodes.lora_cycler"
+    ).LoraCyclerLM
     init_metadata_collector = importlib.import_module("py.metadata_collector").init
 
 NODE_CLASS_MAPPINGS = {
@@ -63,11 +59,8 @@ NODE_CLASS_MAPPINGS = {
     TextLM.NAME: TextLM,
     LoraLoaderLM.NAME: LoraLoaderLM,
     LoraTextLoaderLM.NAME: LoraTextLoaderLM,
-    CheckpointLoaderLM.NAME: CheckpointLoaderLM,
-    UNETLoaderLM.NAME: UNETLoaderLM,
     TriggerWordToggleLM.NAME: TriggerWordToggleLM,
     LoraStackerLM.NAME: LoraStackerLM,
-    LoraStackCombinerLM.NAME: LoraStackCombinerLM,
     SaveImageLM.NAME: SaveImageLM,
     DebugMetadataLM.NAME: DebugMetadataLM,
     WanVideoLoraSelectLM.NAME: WanVideoLoraSelectLM,

data/supporters.json

@@ -1,862 +0,0 @@
-{
-  "specialThanks": [
-    "dispenser",
-    "EbonEagle",
-    "DanielMagPizza",
-    "Scott R"
-  ],
-  "allSupporters": [
-    "megakirbs",
-    "Brennok",
-    "2018cfh",
-    "Insomnia Art Designs",
-    "Rob Williams",
-    "Arlecchino Shion",
-    "Charles Blakemore",
-    "$MetaSamsara",
-    "W+K+White",
-    "stone9k",
-    "Gingko Biloba",
-    "Kiba",
-    "onesecondinosaur",
-    "Christian Byrne",
-    "DM",
-    "Sen314",
-    "Estragon",
-    "wackop",
-    "Phil",
-    "Carl G.",
-    "Dsperado",
-    "Rosenthal",
-    "ClockDaemon",
-    "Francisco Tatis",
-    "Tobi_Swagg",
-    "Andrew Wilson",
-    "Greybush",
-    "Ricky Carter",
-    "JongWon Han",
-    "VantAI",
-    "Michael Wong",
-    "Illrigger",
-    "Tom Corrigan",
-    "JackieWang",
-    "FreelancerZ",
-    "fnkylove",
-    "Robert Stacey",
-    "Edgar Tejeda",
-    "Liam MacDougal",
-    "Polymorphic Indeterminate",
-    "Sterilized",
-    "Dogwalkerbr",
-    "Skalabananen",
-    "Marc Whiffen",
-    "Birdy",
-    "itismyelement",
-    "Mozzel",
-    "quarz",
-    "Reno Lam",
-    "jean jahren",
-    "JSST",
-    "sig",
-    "J\\B/ 8r0wns0n",
-    "Snaggwort",
-    "MKULTRA",
-    "Baekdoosixt",
-    "Jonathan Ross",
-    "KD",
-    "Omnidex",
-    "Nazono_hito",
-    "daniel dove",
-    "Tyler Trebuchon",
-    "Release Cabrakan",
-    "JW Sin",
-    "Alex",
-    "SG",
-    "carozzz",
-    "James Dooley",
-    "zenbound",
-    "Buzzard",
-    "jmack",
-    "Adam Shaw",
-    "Mark Corneglio",
-    "SarcasticHashtag",
-    "RedrockVP",
-    "James Todd",
-    "Wicked Choices by ASLPro3D",
-    "Steven Pfeiffer",
-    "レプサイ",
-    "Timmy",
-    "Johnny",
-    "Tak",
-    "Lisster",
-    "runte3221",
-    "Big Red",
-    "whudunit",
-    "dl0901dm",
-    "Yushio",
-    "Vik71it",
-    "Bishoujoker",
-    "Echo",
-    "Lilleman",
-    "PM",
-    "Todd Keck",
-    "Briton Heilbrun",
-    "wildnut",
-    "Aleksander Wujczyk",
-    "AM Kuro",
-    "Fraser Cross",
-    "BadassArabianMofo",
-    "Pascal Dahle",
-    "Greg",
-    "MiraiKuriyamaSy",
-    "otaku fra",
-    "lmsupporter",
-    "andrew.tappan",
-    "Takkan",
-    "zounic",
-    "wfpearl",
-    "ElitaSSJ4",
-    "Matt+J",
-    "Jack B Nimble",
-    "Melville Parrish",
-    "Lustre",
-    "bh",
-    "Jwk0205",
-    "Marlon Daniels",
-    "Starkselle",
-    "Aaron Bleuer",
-    "LacesOut!",
-    "greebles",
-    "Some Guy Named Barry",
-    "Resist's Creations - Spicy Edition 🔥",
-    "M Postkasse",
-    "Wolffen",
-    "Jacob Hoehler",
-    "FinalyFree",
-    "Matt Wenzel",
-    "Weasyl",
-    "Lex Song",
-    "Cory Paza",
-    "Gonzalo Andre Allendes Lopez",
-    "Jimmy Ledbetter",
-    "Luc Job",
-    "Philip Hempel",
-    "corde",
-    "nwalker94",
-    "dan",
-    "aai",
-    "Tori",
-    "Ran C",
-    "ViperC",
-    "Sangheili460",
-    "MagnaInsomnia",
-    "Akira_HentAI",
-    "Karl P.",
-    "Adam Taylor",
-    "Weird_With_A_Beard",
-    "N/A",
-    "The Spawn",
-    "graysock",
-    "Pozadine1",
-    "Qarob",
-    "AIGooner",
-    "Luc",
-    "ProtonPrince",
-    "Greenmoustache",
-    "fancypants",
-    "John+Edwards",
-    "Joboshy",
-    "Digital",
-    "JaxMax",
-    "Bohemian Corporal",
-    "contrite831",
-    "Dan",
-    "Bro Xie",
-    "batblue",
-    "carey6409",
-    "Olive",
-    "太郎 ゲーム",
-    "jinxedx",
-    "AELOX",
-    "Gooohokrbe",
-    "Dankin-Pics",
-    "Nicfit23",
-    "Cristian Vazquez",
-    "wamekukyouzin",
-    "OldBones",
-    "drum matthieu",
-    "Dogmaster",
-    "Frank Nitty",
-    "Magic Noob",
-    "Christopher Michel",
-    "Zach Gonser",
-    "Serge Bekenkamp",
-    "DougPeterson",
-    "LeoZero",
-    "Antonio Pontes",
-    "nahinahi9",
-    "Kevin John Duck",
-    "Dustin Chen",
-    "Blackfish95",
-    "Mouthlessman",
-    "Paul Kroll",
-    "Penfore",
-    "Bas Imagineer",
-    "Gordon Cole",
-    "AbstractAss",
-    "Dušan Ryban",
-    "decoy",
-    "DiffDuck",
-    "elu3199",
-    "Hasturkun",
-    "Jon Sandman",
-    "Ubivis",
-    "CloudValley",
-    "thesoftwaredruid",
-    "wundershark",
-    "mr_dinosaur",
-    "Tyrswood",
-    "Ray Wing",
-    "Ranzitho",
-    "Gus",
-    "MJG",
-    "David LaVallee",
-    "linnfrey",
-    "Jackthemind",
-    "griffin+dahlberg",
-    "jeaness",
-    "takyamtom",
-    "Josef Lanzl",
-    "Nerezza",
-    "yer fey",
-    "Error_Rule34_Not_found",
-    "aezin",
-    "jcay015",
-    "Erik Lopez",
-    "Roslynd",
-    "Mateo Curić",
-    "Geolog",
-    "Neco28",
-    "Cosmosis",
-    "Eris3D",
-    "David Ortega",
-    "FloPro4Sho",
-    "a _",
-    "Jeff",
-    "Bruce",
-    "Steven Owens",
-    "James Coleman",
-    "Kevin Christopher",
-    "Chad Idk",
-    "dd",
-    "John Statham",
-    "sjon kreutz",
-    "yuxz69",
-    "LarsesFPC",
-    "Metryman55",
-    "esthe",
-    "AlexDuKaNa",
-    "地獄の禄",
-    "ae",
-    "Tr4shP4nda",
-    "Gamalonia",
-    "capn",
-    "Joseph",
-    "Mirko Katzula",
-    "dan",
-    "Piccio08",
-    "kumakichi",
-    "cppbel",
-    "Moon Knight",
-    "Kland",
-    "Hailshem",
-    "Naomi Hale Danchi",
-    "epicgamer0020690",
-    "IamAyam",
-    "Andrew",
-    "Brian M",
-    "Robert Wegemund",
-    "sanborondon",
-    "confiscated Zyra",
-    "Taylor Funk",
-    "Thought2Form",
-    "Gerald Welly",
-    "Kevin Picco",
-    "Sadlip",
-    "Tee Gee",
-    "tarek helmi",
-    "Max Marklund",
-    "m",
-    "Pierce McBride",
-    "Joshua Gray",
-    "Pronredn",
-    "Mikko Hemilä",
-    "Jamie Ogletree",
-    "Temikus",
-    "Michael Taylor",
-    "lh qwe",
-    "Martial",
-    "conner",
-    "Michael Anthony Scott",
-    "Emil Andersson",
-    "Ouro Boros",
-    "Atilla Berke Pekduyar",
-    "Princess Bright Eyes",
-    "Decx _",
-    "Yuji Kaneko",
-    "Rops Alot",
-    "Sam",
-    "Ace Ventura",
-    "四糸凜音",
-    "Xeeosat",
-    "Douglas Gaspar",
-    "George",
-    "dw",
-    "WRL_SPR",
-    "momokai",
-    "몽타주",
-    "kudari",
-    "ken",
-    "Crocket",
-    "Joshua Porrata",
-    "keemun",
-    "SuBu",
-    "RedPIXel",
-    "Wind",
-    "Nexus",
-    "Ramneek“Guy”Ashok",
-    "squid_actually",
-    "Nat_20",
-    "Edward Weeks",
-    "kyoumei",
-    "RadStorm04",
-    "JohnDoe42054",
-    "BillyHill",
-    "emyth",
-    "chriphost",
-    "KitKatM",
-    "socrasteeze",
-    "OrganicArtifact",
-    "MudkipMedkitz",
-    "deanbrian",
-    "Alex Wortman",
-    "Cody",
-    "emadsultan",
-    "gzmzmvp",
-    "Richard",
-    "奚明 刘",
-    "Littlehuggy",
-    "Aberr",
-    "Gregory Kozhemiak",
-    "준희 김",
-    "Brian Buie",
-    "Eric Whitney",
-    "Joey Callahan",
-    "Ivan Tadic",
-    "Tomohiro Baba",
-    "Mike Simone",
-    "Noora",
-    "John J Linehan",
-    "Mattssn",
-    "Elliot E",
-    "Morgandel",
-    "Theerat Jiramate",
-    "Noah",
-    "Jacob McDaniel",
-    "X",
-    "Sloan Steddy",
-    "Artokun",
-    "hexxish",
-    "Derek Baker",
-    "Steam Steam",
-    "NICHOLAS BAXLEY",
-    "CryptoTraderJK",
-    "Davaitamin",
-    "Nathan",
-    "Ed Wang",
-    "tedcor",
-    "Fotek Design",
-    "Nihongasuki",
-    "MadSpin",
-    "FrxzenSnxw",
-    "inbijiburu",
-    "Nick “Loadstone” D",
-    "starbugx",
-    "dc7431",
-    "ResidentDeviant",
-    "Ginnie",
-    "Raku",
-    "InformedViewz",
-    "CHKeeho80",
-    "Bubbafett",
-    "leaf",
-    "Vir",
-    "Skyfire83",
-    "Adam Rinehart",
-    "Pitpe11",
-    "TheD1rtyD03",
-    "moonpetal",
-    "g9p0o",
-    "Pkrsky",
-    "TheHolySheep",
-    "Monte Won",
-    "SpringBootisTrash",
-    "carsten",
-    "ikok",
-    "DarkRoast",
-    "Nasty+Hobbit",
-    "letzte",
-    "Sora+Yori",
-    "lrdchs2",
-    "Duk3+Rand0m",
-    "Nathen+Choi",
-    "T",
-    "David Schenck",
-    "Wolfe7D1",
-    "Draven T",
-    "elleshar666",
-    "ACTUALLY_the_Real_Willem_Dafoe",
-    "Михал Михалыч",
-    "Aquatic Coffee",
-    "Kauffy",
-    "ethanfel",
-    "Focuschannel",
-    "Edward Kennedy",
-    "Nick Kage",
-    "Vane Holzer",
-    "psytrax",
-    "Cyrus Fett",
-    "Anthony Faxlandez",
-    "battu",
-    "Xenon Xue",
-    "notedfakes",
-    "Michael Scott",
-    "Pat Hen",
-    "Saya",
-    "Jordan Shaw",
-    "Wes Sims",
-    "Donor4115",
-    "g unit",
-    "Jimmy Borup",
-    "Filippo Ferrari",
-    "JC",
-    "Prompt Pirate",
-    "uwutismxd",
-    "zenobeus",
-    "ryoma",
-    "Whitepinetrader",
-    "Stryker",
-    "smart.edge5178",
-    "Menard",
-    "SomeDude",
-    "nanana",
-    "raf8osz",
-    "Karru",
-    "ChaChanoKo",
-    "redcarrot",
-    "ghoulars",
-    "null",
-    "Beau",
-    "powerbot99",
-    "Fthehappy",
-    "Ko-fi+Supporter",
-    "J",
-    "Alan+Cano",
-    "FeralOpticsAI",
-    "Pavlaki",
-    "Doug+Rintoul",
-    "Noor",
-    "Yorunai",
-    "quantenmecha",
-    "Jason+Nash",
-    "cocona",
-    "blikkies",
-    "JBsuede",
-    "Time Valentine",
-    "Shock Shockor",
-    "りん あめ",
-    "Matt",
-    "Goldwaters",
-    "Zude",
-    "Frogmilk",
-    "SPJ",
-    "Kyler",
-    "Kor",
-    "Bryan Rutkowski",
-    "Justin Blaylock",
-    "aRtFuL_DodGeR",
-    "TenaciousD",
-    "Dmitry Ryzhov",
-    "Edward Ten Eyck",
-    "Billy Gladky",
-    "Probis",
-    "Solixer",
-    "Pete Pain",
-    "ItsGeneralButtNaked",
-    "RHopkirk",
-    "jinksta187",
-    "robin.kok.",
-    "Manu Thetug",
-    "Maxim",
-    "Karlanx",
-    "Lyavph",
-    "operationancut",
-    "Youguang",
-    "andrewzpong",
-    "BossGame",
-    "lrdchs",
-    "Tree Tagger",
-    "Inversity",
-    "AIVORY3D",
-    "Kevinj",
-    "Mitchell Robson",
-    "POPPIN",
-    "2turbo",
-    "Dmitry+Viznesenskiy",
-    "tanjin90",
-    "sternenkrieger",
-    "Pascalou",
-    "Patrick+Bryan",
-    "lighthawke",
-    "low9",
-    "Winged",
-    "YassineKhaled",
-    "Y",
-    "MatteKey",
-    "Flob",
-    "ShiroSenpai",
-    "Inkognito",
-    "G",
-    "Tan+Huynh",
-    "Bob+Barker",
-    "D",
-    "Dark_Pest",
-    "Eldithor",
-    "Alex",
-    "BillyBoy84",
-    "Buecyb99",
-    "Welkor",
-    "dubious1one",
-    "Tú Nguyễn Lý Hoàng",
-    "shira1011",
-    "moranqianlong",
-    "Kalli Core",
-    "Ben D",
-    "G",
-    "Ronan Delevacq",
-    "Christian Schäfer",
-    "Dave Abraham",
-    "Joaquin Hierrezuelo",
-    "Locrospiel",
-    "Sean voets",
-    "Jarrid Lee",
-    "Poophead27 Blyat",
-    "Joseph Hanson",
-    "John Rednoulf",
-    "Kyron Mahan",
-    "Mythspire",
-    "Boba Smith",
-    "TBitz33",
-    "Anonym dkjglfleeoeldldldlkf",
-    "MR.Bear",
-    "somethingtosay8",
-    "Ezokewn",
-    "ivistorm",
-    "SendingRavens",
-    "Sauv",
-    "Steven",
-    "JackJohnnyJim",
-    "Khánh Đặng",
-    "Michael Docherty",
-    "Ted Cart",
-    "Sage Himeros",
-    "Zeeble",
-    "Paul Hartsuyker",
-    "elitassj",
-    "Tigon",
-    "Tania Nayelli Fernandez",
-    "Draconach",
-    "Jacob Winter",
-    "Ryan Presley Ng",
-    "Andrew Wilkinson",
-    "David",
-    "Meilo",
-    "Dkom22",
-    "shinonomeiro",
-    "Snille",
-    "MaartenAlbers",
-    "khanh duy",
-    "xybrightsummer",
-    "jreedatchison",
-    "PhilW",
-    "Marcus thronico",
-    "Janik",
-    "Cruel",
-    "MRBlack",
-    "Kiyoe",
-    "humptynutz",
-    "michael.isaza",
-    "Kalnei",
-    "dg",
-    "Scott",
-    "Muratoraccio",
-    "D",
-    "Gold_miner_ego",
-    "IshouI;_;",
-    "Monix",
-    "Trolinka",
-    "PredragR",
-    "Clauzmak",
-    "Nerick",
-    "SundayRage",
-    "matter",
-    "SRCRCOSS",
-    "imer",
-    "Akkas+Haque",
-    "Kachac",
-    "SAVEagleBasement",
-    "Kevin+Isom",
-    "Rune+Osnes",
-    "you+halo9",
-    "cloudghost",
-    "Yongkwan+Lee",
-    "PoorStudent",
-    "lucites",
-    "Alex+Zaw",
-    "Mobius2020",
-    "ExLightSaber",
-    "YaboiRay",
-    "nickname",
-    "Sildoren",
-    "Darv",
-    "Seon+Song",
-    "Somebody",
-    "Balut+Omelette",
-    "eriick",
-    "Lev+Lanevskiy",
-    "Jacky+Ho",
-    "generic404",
-    "abattoirblues",
-    "zounik",
-    "4IXplr0r3r",
-    "hayden",
-    "Obsidian.Studios",
-    "ahoystan",
-    "Zomba Mann",
-    "Aquaneo",
-    "edk",
-    "Wolf and Fox Legends",
-    "Neko Desco",
-    "Ninja Tom",
-    "Vinarus",
-    "Josh Snyder",
-    "ja s",
-    "Leslie Andrew Ridings",
-    "Doug Mason",
-    "scoreswazey",
-    "Owen Gwosdz",
-    "Room Light",
-    "Patryk Serious",
-    "AZ Party Oasis",
-    "Devil Lude",
-    "Snorklebort",
-    "David Murcko",
-    "TheFusion",
-    "Jack Dole",
-    "matt",
-    "3zS4QNQ4",
-    "Terminuz",
-    "max blo",
-    "Matt M.",
-    "Ivan Imes",
-    "J M",
-    "Bouya shaka",
-    "Jack Lawfield",
-    "Borte",
-    "Maso",
-    "yyuvuvu",
-    "Eric Ketchum",
-    "Nomki",
-    "Kevin Wallace",
-    "ChicRic",
-    "BastardSama",
-    "mercur",
-    "SkibidiRizzler",
-    "Never_M",
-    "Kalle Björk",
-    "Yavizu3d",
-    "Yves Poezevara",
-    "Teriak47",
-    "Just me",
-    "Raf Stahelin",
-    "Nacho Ferrando",
-    "Вячеслав Маринин",
-    "Marcos Tortosa Carmona",
-    "Cola Matthew",
-    "OniNoKen",
-    "Iain Wisely",
-    "Zertens",
-    "NOHOW",
-    "Apo",
-    "nekotxt",
-    "choowkee",
-    "Clusters",
-    "ibrahim",
-    "Highlandrise",
-    "philcoraz",
-    "mztn",
-    "ImagineerNL",
-    "MrAcrtosSursus",
-    "al300680",
-    "pixl",
-    "Robin",
-    "chahknoir",
-    "nd",
-    "keno94d",
-    "James Melzer",
-    "Bartleby",
-    "Renvertere",
-    "Rahuy",
-    "Hermann003",
-    "D",
-    "Foolish",
-    "RevyHiep",
-    "Captain_Swag",
-    "obkircher",
-    "gwyar",
-    "ResidentDeviant",
-    "D",
-    "edgecase",
-    "Neoxena",
-    "mrmhalo",
-    "Maarten Harms",
-    "Israel",
-    "SelfishMedic",
-    "adderleighn",
-    "EnragedAntelope",
-    "yarsev",
-    "M+Alsulaiti",
-    "Mark+Staaf",
-    "Michael+Fürmann",
-    "Aether",
-    "GhostyGhost",
-    "JACKY",
-    "Jesse",
-    "daga",
-    "Somebody",
-    "Jasper",
-    "megameganck",
-    "thomasand01",
-    "Shiba+Sama",
-    "miduzza",
-    "KB",
-    "shw",
-    "Celestial+Kitten",
-    "bakeliteboy",
-    "TequiTequi",
-    "Homero+Banda",
-    "Nick",
-    "Jim",
-    "JoL",
-    "YoruHime",
-    "Srdb",
-    "jcx29",
-    "Drizzly",
-    "Nebuleux",
-    "Join+Chun",
-    "GDS+DEV",
-    "4rt+r3d",
-    "Somebody",
-    "Somebody",
-    "Crescent~San",
-    "AiGirlTS",
-    "datasl4ve",
-    "Somebody",
-    "koopa990",
-    "The+Forgetful+Dev",
-    "Mateusz+Kosela",
-    "Bula",
-    "KUJYAKU",
-    "Coeur+de+cochon",
-    "han b",
-    "Nico",
-    "Maximilian Krischan",
-    "Banana Joe",
-    "proto merp",
-    "_ G3n",
-    "Brandon Thomas",
-    "Donovan Jenkins",
-    "Hans Meier",
-    "Dustin Hendel",
-    "sicarius",
-    "Michael Eid",
-    "Liberation",
-    "Bob barker",
-    "karim ben brik",
-    "Elemnt",
-    "Bradley Turner",
-    "Michael Zhu",
-    "Nemisu",
-    "Seraphy",
-    "雨の心 落",
-    "AllTimeNoobie",
-    "swra",
-    "JollRodrigo",
-    "jumpd",
-    "John C",
-    "Rim",
-    "Oliverfish",
-    "yfx507",
-    "uruksayshi",
-    "Jairus Knudsen",
-    "Xan Dionysus",
-    "Nathan lee",
-    "nk8",
-    "lylepaul",
-    "Middo",
-    "Forbidden Atelier",
-    "Thomas Sankowski",
-    "DrB",
-    "Nimhloth",
-    "Adictedtohumping",
-    "Moneymaker412K",
-    "vinter",
-    "Towelie",
-    "Jean-françois SEMA",
-    "Andrew Ly",
-    "Slacks",
-    "Glenn Hoetker",
-    "john Greene",
-    "Faburizu",
-    "jimyjomson",
-    "JaeHyun Jang",
-    "Michael Hicks",
-    "Homero Banda",
-    "Chase Kwon",
-    "Bob Ling",
-    "Inyoshu",
-    "Chad Barnes",
-    "MadGod",
-    "Adam Gardner",
-    "inusanorthcape",
-    "James Ming",
-    "vanditking",
-    "kripitonga",
-    "Rizzi",
-    "nimin",
-    "OMAR LUCIANO",
-    "Somebody",
-    "CoffeeMage",
-    "Ken+Suzuki",
-    "hannibal",
-    "Jo+Example",
-    "BrentBertram",
-    "eumelzocker",
-    "dxjaymz",
-    "L C",
-    "Dude",
-    "Somebody",
-    "CK"
-  ],
-  "totalCount": 855
-}

docs/LM-Extension-Wiki.md

@@ -0,0 +1,180 @@
+## Overview
+
+The **LoRA Manager Civitai Extension** is a Browser extension designed to work seamlessly with [LoRA Manager](https://github.com/willmiao/ComfyUI-Lora-Manager) to significantly enhance your browsing experience on [Civitai](https://civitai.com).
+It also supports browsing on [CivArchive](https://civarchive.com/) (formerly CivitaiArchive).
+
+With this extension, you can:
+
+✅ Instantly see which models are already present in your local library  
+✅ Download new models with a single click  
+✅ Manage downloads efficiently with queue and parallel download support  
+✅ Keep your downloaded models automatically organized according to your custom settings    
+
+![Civitai Models page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-models-page.png)  
+![CivArchive Models page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civarchive-models-page.png)  
+
+---
+
+## Why Are All Features for Supporters Only?
+
+I love building tools for the Stable Diffusion and ComfyUI communities, and LoRA Manager is a passion project that I've poured countless hours into. When I created this companion extension, my hope was to offer its core features for free, as a thank-you to all of you.
+
+Unfortunately, I've reached a point where I need to be realistic. The level of support from the free model has been far lower than what's needed to justify the continuous development and maintenance for both projects. It was a difficult decision, but I've chosen to make the extension's features exclusive to supporters.
+
+This change is crucial for me to be able to continue dedicating my time to improving the free and open-source LoRA Manager, which I'm committed to keeping available for everyone.
+
+Your support does more than just unlock a few features—it allows me to keep innovating and ensures the core LoRA Manager project thrives. I'm incredibly grateful for your understanding and any support you can offer. ❤️
+
+(_For those who previously supported me on Ko-fi with a one-time donation, I'll be sending out license keys individually as a thank-you._)
+
+
+---
+
+## Installation
+
+### Supported Browsers & Installation Methods
+
+| Browser            | Installation Method                                                                 |
+|--------------------|-------------------------------------------------------------------------------------|
+| **Google Chrome**   | [Chrome Web Store link](https://chromewebstore.google.com/detail/capigligggeijgmocnaflanlbghnamgm?utm_source=item-share-cb) |
+| **Microsoft Edge**  | Install via Chrome Web Store (compatible)                                          |
+| **Brave Browser**   | Install via Chrome Web Store (compatible)                                          |
+| **Opera**           | Install via Chrome Web Store (compatible)                                          |
+| **Firefox**         | <div id="firefox-install" class="install-ok"><a href="https://github.com/willmiao/lm-civitai-extension-firefox/releases/latest/download/extension.xpi">📦 Install Firefox Extension (reviewed and verified by Mozilla)</a></div>             |
+
+For non-Chrome browsers (e.g., Microsoft Edge), you can typically install extensions from the Chrome Web Store by following these steps: open the extension’s Chrome Web Store page, click 'Get extension', then click 'Allow' when prompted to enable installations from other stores, and finally click 'Add extension' to complete the installation.
+
+---
+
+## Privacy & Security
+
+I understand concerns around browser extensions and privacy, and I want to be fully transparent about how the **LM Civitai Extension** works:
+
+- **Reviewed and Verified**  
+  This extension has been **manually reviewed and approved by the Chrome Web Store**. The Firefox version uses the **exact same code** (only the packaging format differs) and has passed **Mozilla’s Add-on review**.
+
+- **Minimal Network Access**  
+  The only external server this extension connects to is:  
+  **`https://willmiao.shop`** — used solely for **license validation**.
+
+  It does **not collect, transmit, or store any personal or usage data**.  
+  No browsing history, no user IDs, no analytics, no hidden trackers.
+
+- **Local-Only Model Detection**  
+  Model detection and LoRA Manager communication all happen **locally** within your browser, directly interacting with your local LoRA Manager backend.
+
+I value your trust and are committed to keeping your local setup private and secure. If you have any questions, feel free to reach out!
+
+---
+
+## How to Use
+
+After installing the extension, you'll automatically receive a **7-day trial** to explore all features.
+
+When the extension is correctly installed and your license is valid:
+
+- Open **Civitai**, and you'll see visual indicators added by the extension on model cards, showing:
+  - ✅ Models already present in your local library  
+  - ⬇️ A download button for models not in your library  
+
+Clicking the download button adds the corresponding model version to the download queue, waiting to be downloaded. You can set up to **5 models to download simultaneously**.
+
+### Visual Indicators Appear On:
+
+- **Home Page** — Featured models  
+- **Models Page**  
+- **Creator Profiles** — If the creator has set their models to be visible  
+- **Recommended Resources** — On individual model pages  
+
+### Version Buttons on Model Pages
+
+On a specific model page, visual indicators also appear on version buttons, showing which versions are already in your local library.
+
+When switching to a specific version by clicking a version button:
+
+- Clicking the download button will open a dropdown:
+  - Download via **LoRA Manager**  
+  - Download via **Original Download** (browser download)  
+
+You can check **Remember my choice** to set your preferred default. You can change this setting anytime in the extension's settings.
+
+![Civitai Model Page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-model-page.png)
+
+### Resources on Image Pages (2025-08-05) — now shows in-library indicators for image resources. ‘Import image as recipe’ coming soon!
+
+![Civitai Image Page](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/civitai-image-page.jpg)
+
+---
+
+## Model Download Location & LoRA Manager Settings
+
+To use the **one-click download function**, you must first set:
+
+- Your **Default LoRAs Root**  
+- Your **Default Checkpoints Root**  
+
+These are set within LoRA Manager's settings.
+
+When everything is configured, downloaded model files will be placed in:  
+
+`<Default_Models_Root>/<Base_Model_of_the_Model>/<First_Tag_of_the_Model>`
+
+
+### Update: Default Path Customization (2025-07-21)  
+
+A new setting to customize the default download path has been added in the nightly version. You can now personalize where models are saved when downloading via the LM Civitai Extension.
+
+![Default Path Customization](https://github.com/willmiao/ComfyUI-Lora-Manager/blob/main/wiki-images/default-path-customization.png)
+
+The previous YAML path mapping file will be deprecated—settings will now be unified in settings.json to simplify configuration.
+
+---
+
+## Backend Port Configuration
+
+If your **ComfyUI** or **LoRA Manager** backend is running on a port **other than the default 8188**, you must configure the backend port in the extension's settings.
+
+After correctly setting and saving the port, you'll see in the extension's header area:  
+- A **Healthy** status with the tooltip:  `Connected to LoRA Manager on port xxxx`
+
+
+---
+
+## Advanced Usage
+
+### Connecting to a Remote LoRA Manager
+
+If your LoRA Manager is running on another computer, you can still connect from your browser using port forwarding.
+
+> **Why can't you set a remote IP directly?**
+>
+> For privacy and security, the extension only requests access to `http://127.0.0.1/*`. Supporting remote IPs would require much broader permissions, which may be rejected by browser stores and could raise user concerns.
+
+**Solution: Port Forwarding with `socat`**
+
+On your browser computer, run:
+
+`socat TCP-LISTEN:8188,bind=127.0.0.1,fork TCP:REMOTE.IP.ADDRESS.HERE:8188`
+
+- Replace `REMOTE.IP.ADDRESS.HERE` with the IP of the machine running LoRA Manager.
+- Adjust the port if needed.
+
+This lets the extension connect to `127.0.0.1:8188` as usual, with traffic forwarded to your remote server.
+
+_Thanks to user **Temikus** for sharing this solution!_
+
+---
+
+## Roadmap
+
+The extension will evolve alongside **LoRA Manager** improvements. Planned features include:
+
+- [x] Support for **additional model types** (e.g., embeddings)
+- [ ] One-click **Recipe Import**  
+- [x] Display of in-library status for all resources in the **Resources Used** section of the image page  
+- [x] One-click **Auto-organize Models**
+
+**Stay tuned — and thank you for your support!**
+
+---
+

docs/agent_skills.md

@@ -1,208 +0,0 @@
-# Agent Skills System
-
-The LoRA Manager agent skills system enables LLM-powered metadata enrichment and other AI-driven tasks. Users configure their own LLM provider (BYOK), and skills are executed through right-click context menu actions.
-
-## Architecture
-
-```
-┌──────────────────────────────────────────────┐
-│              LoRA Manager Backend             │
-│                                               │
-│  ┌──────────────┐    ┌────────────────┐       │
-│  │ LLMService    │───▶│ LLM Provider   │       │
-│  │ (BYOK config, │◀───│ (OpenAI/Ollama │       │
-│  │  API calls)   │    │ /custom)       │       │
-│  └───────┬───────┘    └────────────────┘       │
-│          │                                     │
-│  ┌───────▼───────────────────────┐             │
-│  │     AgentService              │             │
-│  │  (orchestration: validate     │             │
-│  │   → LLM call → post-process   │             │
-│  │   → WebSocket broadcast)      │             │
-│  └───────┬───────────────────────┘             │
-│          │                                     │
-│  ┌───────▼───────────────────────┐             │
-│  │     SkillRegistry             │             │
-│  │  ┌─────────────────────────┐  │             │
-│  │  │ enrich_hf_metadata:     │  │             │
-│  │  │  - skill.yaml           │  │             │
-│  │  │  - prompt.md            │  │             │
-│  │  │  - handler.py           │  │             │
-│  │  └─────────────────────────┘  │             │
-│  └───────────────────────────────┘             │
-└──────────────────────────────────────────────┘
-```
-
-### Key Design Principle
-
-**Skills define *what* to do (prompt + post-processing). The AgentService handles *how* (LLM calls, validation, progress).**
-
-Skills never call the LLM directly. This keeps BYOK configuration centralized and provider-agnostic.
-
-## BYOK Configuration
-
-Users configure their LLM provider in **Settings → AI Provider**:
-
-| Setting | Description | Example |
-|---|---|---|
-| `llm_provider` | Provider type | `openai`, `ollama`, or `custom` |
-| `llm_api_key` | API key (not needed for local Ollama) | `sk-...` |
-| `llm_api_base` | Custom API base URL (empty = provider default) | `https://api.openai.com/v1` |
-| `llm_model` | Model name | `gpt-4o-mini` |
-
-Environment variable overrides: `LLM_API_KEY`, `LLM_MODEL`, `LLM_API_BASE`, `LLM_PROVIDER`.
-
-### Supported Providers
-
-- **OpenAI**: Uses `https://api.openai.com/v1` by default
-- **Ollama** (local): Uses `http://localhost:11434/v1`, no API key required
-- **Custom**: Any OpenAI-compatible endpoint (vLLM, LM Studio, etc.) — set `llm_api_base` explicitly
-
-## Available Skills
-
-### enrich_hf_metadata
-
-Enriches HuggingFace-downloaded models with metadata extracted by an LLM from the HF model card.
-
-**Entry point**: Right-click context menu → "Enrich Metadata (Agent)"
-
-**What it does**:
-1. Reads the model's `.metadata.json` to get the `hf_url`
-2. Fetches the README.md from the HuggingFace repository
-3. Sends the README + local metadata to the LLM for structured extraction
-4. Writes extracted fields to `.metadata.json`:
-   - `base_model` — only if current value is empty
-   - `trainedWords` — trigger words (LoRA only, if none exist)
-   - `modelDescription` — concise summary (if none exists)
-   - `tags` — merged with existing tags, deduplicated
-   - `metadata_source` — audit trail: `agent:enrich_hf_metadata`
-   - `llm_enriched_at` — ISO timestamp
-5. Downloads and optimizes preview image (if LLM found one in the README)
-6. Updates the scanner cache
-7. Broadcasts WebSocket progress events
-
-**Model types**: LoRA, Checkpoint, Embedding
-
-## Adding a New Skill
-
-### 1. Create the skill directory
-
-```
-py/services/agent/skills/<skill_name>/
-├── skill.yaml      # Skill metadata and schemas
-├── prompt.md       # LLM prompt template
-└── handler.py      # Pre-processing and post-processing
-```
-
-### 2. Write skill.yaml
-
-```yaml
-name: my_skill
-title: "My Skill"
-description: "What this skill does"
-llm_required: true
-model_type_filter: ["lora"]  # or null for all types
-input_schema:
-  type: object
-  properties:
-    model_paths:
-      type: array
-      items:
-        type: string
-  required:
-    - model_paths
-output_schema:
-  type: object
-  properties:
-    # ... JSON schema for LLM output
-permissions:
-  write_metadata: true
-  write_previews: false
-  network_domains:
-    - "example.com"
-```
-
-### 3. Write prompt.md
-
-Use `{{variable}}` placeholders that will be replaced with data from the `prepare` function:
-
-```markdown
-You are an expert assistant...
-
-Model URL: {{hf_url}}
-README content:
-{{readme_content}}
-
-Current metadata:
-{{current_metadata}}
-```
-
-### 4. Write handler.py
-
-```python
-async def prepare(model_path: str, input_data: dict) -> dict:
-    """Gather context for the LLM prompt. Returns variables for template rendering."""
-    return {
-        "model_path": model_path,
-        # ... other variables used in prompt.md
-    }
-
-async def post_process(context) -> dict:
-    """Apply the LLM-extracted data to the model."""
-    llm_response = context.llm_response
-    # ... write metadata, download previews, update cache
-    return {
-        "success": True,
-        "updated_fields": ["base_model", "tags"],
-        "errors": [],
-    }
-```
-
-**Important**: Use absolute imports (`from py.utils.metadata_manager import MetadataManager`) because skills are loaded via `importlib.util.spec_from_file_location`, which doesn't support relative imports.
-
-### 5. Test
-
-The skill is automatically discovered by `SkillRegistry` on startup. Test with:
-
-```python
-pytest tests/services/test_agent_service.py
-```
-
-## API Endpoints
-
-| Method | Path | Description |
-|---|---|---|
-| GET | `/api/lm/agent/skills` | List available skills |
-| POST | `/api/lm/agent/execute/{skill_name}` | Execute a skill (body: `{"model_paths": [...]}`) |
-| POST | `/api/lm/agent/cancel` | Cancel running skill (stub) |
-
-## WebSocket Events
-
-| Type | When | Key fields |
-|---|---|---|
-| `agent_progress` | Skill started/processing | `skill`, `status`, `total`, `processed`, `success`, `current_path` |
-| `agent_progress` | Skill completed | `skill`, `status`, `updated_models`, `errors`, `summary` |
-| `agent_progress` | Skill error | `skill`, `status`, `error` |
-
-## Security Model
-
-Skills declare permissions in `skill.yaml`:
-- `write_metadata` — can write `.metadata.json` files
-- `write_previews` — can download/replace preview images
-- `network_domains` — allowed domains for HTTP requests
-
-These are declarative constraints checked by `AgentService`. They are defense-in-depth, not a sandbox — the Python process can technically do anything, but the contract is clear and auditable.
-
-## File Locations
-
-| Component | Path |
-|---|---|
-| LLMService | `py/services/llm_service.py` |
-| AgentService | `py/services/agent/agent_service.py` |
-| SkillRegistry | `py/services/agent/skill_registry.py` |
-| SkillDefinition | `py/services/agent/skill_definition.py` |
-| Skills directory | `py/services/agent/skills/` |
-| Route handlers | `py/routes/handlers/agent_handlers.py` |
-| Frontend manager | `static/js/managers/AgentManager.js` |
-| Settings UI | `templates/components/modals/settings_modal.html` |
-| Context menu | `templates/components/context_menu.html` |

docs/features/recipe-batch-import-requirements.md

@@ -1,170 +0,0 @@
-# Recipe Batch Import Feature Requirements
-
-## Overview
-Enable users to import multiple images as recipes in a single operation, rather than processing them individually. This feature addresses the need for efficient bulk recipe creation from existing image collections.
-
-## User Stories
-
-### US-1: Directory Batch Import
-As a user with a folder of reference images or workflow screenshots, I want to import all images from a directory at once so that I don't have to import them one by one.
-
-**Acceptance Criteria:**
-- User can specify a local directory path containing images
-- System discovers all supported image files in the directory
-- Each image is analyzed for metadata and converted to a recipe
-- Results show which images succeeded, failed, or were skipped
-
-### US-2: URL Batch Import
-As a user with a list of image URLs (e.g., from Civitai or other sources), I want to import multiple images by URL in one operation.
-
-**Acceptance Criteria:**
-- User can provide multiple image URLs (one per line or as a list)
-- System downloads and processes each image
-- URL-specific metadata (like Civitai info) is preserved when available
-- Failed URLs are reported with clear error messages
-
-### US-3: Concurrent Processing Control
-As a user with varying system resources, I want to control how many images are processed simultaneously to balance speed and system load.
-
-**Acceptance Criteria:**
-- User can configure the number of concurrent operations (1-10)
-- System provides sensible defaults based on common hardware configurations
-- Processing respects the concurrency limit to prevent resource exhaustion
-
-### US-4: Import Results Summary
-As a user performing a batch import, I want to see a clear summary of the operation results so I understand what succeeded and what needs attention.
-
-**Acceptance Criteria:**
-- Total count of images processed is displayed
-- Number of successfully imported recipes is shown
-- Number of failed imports with error details is provided
-- Number of skipped images (no metadata) is indicated
-- Results can be exported or saved for reference
-
-### US-5: Progress Visibility
-As a user importing a large batch, I want to see the progress of the operation so I know it's working and can estimate completion time.
-
-**Acceptance Criteria:**
-- Progress indicator shows current status (e.g., "Processing image 5 of 50")
-- Real-time updates as each image completes
-- Ability to view partial results before completion
-- Clear indication when the operation is finished
-
-## Functional Requirements
-
-### FR-1: Image Discovery
-The system shall discover image files in a specified directory recursively or non-recursively based on user preference.
-
-**Supported formats:** JPG, JPEG, PNG, WebP, GIF, BMP
-
-### FR-2: Metadata Extraction
-For each image, the system shall:
-- Extract EXIF metadata if present
-- Parse embedded workflow data (ComfyUI PNG metadata)
-- Fetch external metadata for known URL patterns (e.g., Civitai)
-- Generate recipes from extracted information
-
-### FR-3: Concurrent Processing
-The system shall support concurrent processing of multiple images with:
-- Configurable concurrency limit (default: 3)
-- Resource-aware execution
-- Graceful handling of individual failures without stopping the batch
-
-### FR-4: Error Handling
-The system shall handle various error conditions:
-- Invalid directory paths
-- Inaccessible files
-- Network errors for URL imports
-- Images without extractable metadata
-- Malformed or corrupted image files
-
-### FR-5: Recipe Persistence
-Successfully analyzed images shall be persisted as recipes with:
-- Extracted generation parameters
-- Preview image association
-- Tags and metadata
-- Source information (file path or URL)
-
-## Non-Functional Requirements
-
-### NFR-1: Performance
-- Batch operations should complete in reasonable time (< 5 seconds per image on average)
-- UI should remain responsive during batch operations
-- Memory usage should scale gracefully with batch size
-
-### NFR-2: Scalability
-- Support batches of 1-1000 images
-- Handle mixed success/failure scenarios gracefully
-- No hard limits on concurrent operations (configurable)
-
-### NFR-3: Usability
-- Clear error messages for common failure cases
-- Intuitive UI for configuring import options
-- Accessible from the main Recipes interface
-
-### NFR-4: Reliability
-- Failed individual imports should not crash the entire batch
-- Partial results should be preserved on unexpected termination
-- All operations should be idempotent (re-importing same image doesn't create duplicates)
-
-## API Requirements
-
-### Batch Import Endpoints
-The system should expose endpoints for:
-
-1. **Directory Import**
-   - Accept directory path and configuration options
-   - Return operation ID for status tracking
-   - Async or sync operation support
-
-2. **URL Import**
-   - Accept list of URLs and configuration options
-   - Support URL validation before processing
-   - Return operation ID for status tracking
-
-3. **Status/Progress**
-   - Query operation status by ID
-   - Get current progress and partial results
-   - Retrieve final results after completion
-
-## UI/UX Requirements
-
-### UIR-1: Entry Point
-Batch import should be accessible from the Recipes page via a clearly labeled button in the toolbar.
-
-### UIR-2: Import Modal
-A modal dialog should provide:
-- Tab or section for Directory import
-- Tab or section for URL import
-- Configuration options (concurrency, options)
-- Start/Stop controls
-- Results display area
-
-### UIR-3: Results Display
-Results should be presented with:
-- Summary statistics (total, success, failed, skipped)
-- Expandable details for each category
-- Export or copy functionality for results
-- Clear visual distinction between success/failure/skip
-
-## Future Considerations
-
-- **Scheduled Imports**: Ability to schedule batch imports for later execution
-- **Import Templates**: Save import configurations for reuse
-- **Cloud Storage**: Import from cloud storage services (Google Drive, Dropbox)
-- **Duplicate Detection**: Advanced duplicate detection based on image hash
-- **Tag Suggestions**: AI-powered tag suggestions for imported recipes
-- **Batch Editing**: Apply tags or organization to multiple imported recipes at once
-
-## Dependencies
-
-- Recipe analysis service (metadata extraction)
-- Recipe persistence service (storage)
-- Image download capability (for URL imports)
-- Recipe scanner (for refresh after import)
-- Civitai client (for enhanced URL metadata)
-
----
-
-*Document Version: 1.0*
-*Status: Requirements Definition*

docs/metadata-json-schema.md

@@ -1,363 +0,0 @@
-# metadata.json Schema Documentation
-
-This document defines the complete schema for `.metadata.json` files used by Lora Manager. These sidecar files store model metadata alongside model files (LoRA, Checkpoint, Embedding).
-
-## Overview
-
-- **File naming**: `<model_name>.metadata.json` (e.g., `my_lora.safetensors` → `my_lora.metadata.json`)
-- **Format**: JSON with UTF-8 encoding
-- **Purpose**: Store model metadata, tags, descriptions, preview images, and Civitai/CivArchive integration data
-- **Extensibility**: Unknown fields are preserved via `_unknown_fields` mechanism for forward compatibility
-
----
-
-## Base Fields (All Model Types)
-
-These fields are present in all model metadata files.
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `file_name` | string | ✅ Yes | ✅ Yes | Filename without extension (e.g., `"my_lora"`) |
-| `model_name` | string | ✅ Yes | ❌ No | Display name of the model. **Default**: `file_name` if no other source |
-| `file_path` | string | ✅ Yes | ✅ Yes | Full absolute path to the model file (normalized with `/` separators) |
-| `size` | integer | ✅ Yes | ❌ No | File size in bytes. **Set at**: Initial scan or download completion. Does not change thereafter. |
-| `modified` | float | ✅ Yes | ❌ No | **Import timestamp** — Unix timestamp when the model was first imported/added to the system. Used for "Date Added" sorting. Does not change after initial creation. |
-| `sha256` | string | ⚠️ Conditional | ✅ Yes | SHA256 hash of the model file (lowercase). **LoRA**: Required. **Checkpoint**: May be empty when `hash_status="pending"` (lazy hash calculation) |
-| `base_model` | string | ❌ No | ❌ No | Base model type. **Examples**: `"SD 1.5"`, `"SDXL 1.0"`, `"SDXL Lightning"`, `"Flux.1 D"`, `"Flux.1 S"`, `"Flux.1 Krea"`, `"Illustrious"`, `"Pony"`, `"AuraFlow"`, `"Kolors"`, `"ZImageTurbo"`, `"Wan Video"`, etc. **Default**: `"Unknown"` or `""` |
-| `preview_url` | string | ❌ No | ✅ Yes | Path to preview image file |
-| `preview_nsfw_level` | integer | ❌ No | ❌ No | NSFW level using **bitmask values** from Civitai: `1` (PG), `2` (PG13), `4` (R), `8` (X), `16` (XXX), `32` (Blocked). **Default**: `0` (none) |
-| `notes` | string | ❌ No | ❌ No | User-defined notes |
-| `from_civitai` | boolean | ❌ No (default: `true`) | ❌ No | Whether the model originated from Civitai |
-| `civitai` | object | ❌ No | ⚠️ Partial | Civitai/CivArchive API data and user-defined fields |
-| `tags` | array[string] | ❌ No | ⚠️ Partial | Model tags (merged from API and user input) |
-| `modelDescription` | string | ❌ No | ⚠️ Partial | Full model description (from API or user) |
-| `civitai_deleted` | boolean | ❌ No (default: `false`) | ❌ No | Whether the model was deleted from Civitai |
-| `favorite` | boolean | ❌ No (default: `false`) | ❌ No | Whether the model is marked as favorite |
-| `exclude` | boolean | ❌ No (default: `false`) | ❌ No | Whether to exclude from cache/scanning. User can set from `false` to `true` (currently no UI to revert) |
-| `db_checked` | boolean | ❌ No (default: `false`) | ❌ No | Whether checked against archive database |
-| `skip_metadata_refresh` | boolean | ❌ No (default: `false`) | ❌ No | Skip this model during bulk metadata refresh |
-| `metadata_source` | string\|null | ❌ No | ✅ Yes | Last provider that supplied metadata (see below) |
-| `last_checked_at` | float | ❌ No (default: `0`) | ✅ Yes | Unix timestamp of last metadata check |
-| `hash_status` | string | ❌ No (default: `"completed"`) | ✅ Yes | Hash calculation status: `"pending"`, `"calculating"`, `"completed"`, `"failed"` |
-
----
-
-## Model-Specific Fields
-
-### LoRA Models
-
-LoRA models do not have a `model_type` field in metadata.json. The type is inferred from context or `civitai.type` (e.g., `"LoRA"`, `"LoCon"`, `"DoRA"`).
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `usage_tips` | string (JSON) | ❌ No (default: `"{}"`) | ❌ No | JSON string containing recommended usage parameters |
-
-**`usage_tips` JSON structure:**
-
-```json
-{
-  "strength_min": 0.3,
-  "strength_max": 0.8,
-  "strength_range": "0.3-0.8",
-  "strength": 0.6,
-  "clip_strength": 0.5,
-  "clip_skip": 2
-}
-```
-
-| Key | Type | Description |
-|-----|------|-------------|
-| `strength_min` | number | Minimum recommended model strength |
-| `strength_max` | number | Maximum recommended model strength |
-| `strength_range` | string | Human-readable strength range |
-| `strength` | number | Single recommended strength value |
-| `clip_strength` | number | Recommended CLIP/embedding strength |
-| `clip_skip` | integer | Recommended CLIP skip value |
-
----
-
-### Checkpoint Models
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `model_type` | string | ❌ No (default: `"checkpoint"`) | ❌ No | Model type: `"checkpoint"`, `"diffusion_model"` |
-
----
-
-### Embedding Models
-
-| Field | Type | Required | Auto-Updated | Description |
-|-------|------|----------|--------------|-------------|
-| `model_type` | string | ❌ No (default: `"embedding"`) | ❌ No | Model type: `"embedding"` |
-
----
-
-## The `civitai` Field Structure
-
-The `civitai` object stores the complete Civitai/CivArchive API response. Lora Manager preserves all fields from the API for future compatibility and extracts specific fields for use in the application.
-
-### Version-Level Fields (Civitai API)
-
-**Fields Used by Lora Manager:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `id` | integer | Version ID |
-| `modelId` | integer | Parent model ID |
-| `name` | string | Version name (e.g., `"v1.0"`, `"v2.0-pruned"`) |
-| `nsfwLevel` | integer | NSFW level (bitmask: 1=PG, 2=PG13, 4=R, 8=X, 16=XXX, 32=Blocked) |
-| `baseModel` | string | Base model (e.g., `"SDXL 1.0"`, `"Flux.1 D"`, `"Illustrious"`, `"Pony"`) |
-| `trainedWords` | array[string] | **Trigger words** for the model |
-| `type` | string | Model type (`"LoRA"`, `"Checkpoint"`, `"TextualInversion"`) |
-| `earlyAccessEndsAt` | string\|null | Early access end date (used for update notifications) |
-| `description` | string | Version description (HTML) |
-| `model` | object | Parent model object (see Model-Level Fields below) |
-| `creator` | object | Creator information (see Creator Fields below) |
-| `files` | array[object] | File list with hashes, sizes, download URLs (used for metadata extraction) |
-| `images` | array[object] | Image list with metadata, prompts, NSFW levels (used for preview/examples) |
-
-**Fields Stored but Not Currently Used:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `createdAt` | string (ISO 8601) | Creation timestamp |
-| `updatedAt` | string (ISO 8601) | Last update timestamp |
-| `status` | string | Version status (e.g., `"Published"`, `"Draft"`) |
-| `publishedAt` | string (ISO 8601) | Publication timestamp |
-| `baseModelType` | string | Base model type (e.g., `"Standard"`, `"Inpaint"`, `"Refiner"`) |
-| `earlyAccessConfig` | object | Early access configuration |
-| `uploadType` | string | Upload type (`"Created"`, `"FineTuned"`, etc.) |
-| `usageControl` | string | Usage control setting |
-| `air` | string | Artifact ID (URN format: `urn:air:sdxl:lora:civitai:122359@135867`) |
-| `stats` | object | Download count, ratings, thumbs up count |
-| `videos` | array[object] | Video list |
-| `downloadUrl` | string | Direct download URL |
-| `trainingStatus` | string\|null | Training status (for on-site training) |
-| `trainingDetails` | object\|null | Training configuration |
-
-### Model-Level Fields (`civitai.model.*`)
-
-**Fields Used by Lora Manager:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `name` | string | Model name |
-| `type` | string | Model type (`"LoRA"`, `"Checkpoint"`, `"TextualInversion"`) |
-| `description` | string | Model description (HTML, used for `modelDescription`) |
-| `tags` | array[string] | Model tags (used for `tags` field) |
-| `allowNoCredit` | boolean | License: allow use without credit |
-| `allowCommercialUse` | array[string] | License: allowed commercial uses. **Values**: `"Image"` (sell generated images), `"Video"` (sell generated videos), `"RentCivit"` (rent on Civitai), `"Rent"` (rent elsewhere) |
-| `allowDerivatives` | boolean | License: allow derivatives |
-| `allowDifferentLicense` | boolean | License: allow different license |
-
-**Fields Stored but Not Currently Used:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `nsfw` | boolean | Model NSFW flag |
-| `poi` | boolean | Person of Interest flag |
-
-### Creator Fields (`civitai.creator.*`)
-
-Both fields are used by Lora Manager:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `username` | string | Creator username (used for author display and search) |
-| `image` | string | Creator avatar URL (used for display) |
-
-### Model Type Field (Top-Level, Outside `civitai`)
-
-| Field | Type | Values | Description |
-|-------|------|--------|-------------|
-| `model_type` | string | `"checkpoint"`, `"diffusion_model"`, `"embedding"` | Stored in metadata.json for Checkpoint and Embedding models. **Note**: LoRA models do not have this field; type is inferred from `civitai.type` or context. |
-
-### User-Defined Fields (Within `civitai`)
-
-For models not from Civitai or user-added data:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `trainedWords` | array[string] | **Trigger words** — manually added by user |
-| `customImages` | array[object] | Custom example images added by user |
-
-### customImages Structure
-
-Each custom image entry has the following structure:
-
-```json
-{
-  "url": "",
-  "id": "short_id",
-  "nsfwLevel": 0,
-  "width": 832,
-  "height": 1216,
-  "type": "image",
-  "meta": {
-    "prompt": "...",
-    "negativePrompt": "...",
-    "steps": 20,
-    "cfgScale": 7,
-    "seed": 123456
-  },
-  "hasMeta": true,
-  "hasPositivePrompt": true
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `url` | string | Empty for local custom images |
-| `id` | string | Short ID or filename |
-| `nsfwLevel` | integer | NSFW level (bitmask) |
-| `width` | integer | Image width in pixels |
-| `height` | integer | Image height in pixels |
-| `type` | string | `"image"` or `"video"` |
-| `meta` | object\|null | Generation metadata (prompt, seed, etc.) extracted from image |
-| `hasMeta` | boolean | Whether metadata is available |
-| `hasPositivePrompt` | boolean | Whether a positive prompt is available |
-
-### Minimal Non-Civitai Example
-
-```json
-{
-  "civitai": {
-    "trainedWords": ["my_trigger_word"]
-  }
-}
-```
-
-### Non-Civitai Example Without Trigger Words
-
-```json
-{
-  "civitai": {}
-}
-```
-
-### Example: User-Added Custom Images
-
-```json
-{
-  "civitai": {
-    "trainedWords": ["custom_style"],
-    "customImages": [
-      {
-        "url": "",
-        "id": "example_1",
-        "nsfwLevel": 0,
-        "width": 832,
-        "height": 1216,
-        "type": "image",
-        "meta": {
-          "prompt": "example prompt",
-          "seed": 12345
-        },
-        "hasMeta": true,
-        "hasPositivePrompt": true
-      }
-    ]
-  }
-}
-```
-
----
-
-## Metadata Source Values
-
-The `metadata_source` field indicates which provider last updated the metadata:
-
-| Value | Source |
-|-------|--------|
-| `"civitai_api"` | Civitai API |
-| `"civarchive"` | CivArchive API |
-| `"archive_db"` | Metadata Archive Database |
-| `null` | No external source (user-defined only) |
-
----
-
-## Auto-Update Behavior
-
-### Fields Updated During Scanning
-
-These fields are automatically synchronized with the filesystem:
-
-- `file_name` — Updated if actual filename differs
-- `file_path` — Normalized and updated if path changes
-- `preview_url` — Updated if preview file is moved/removed
-- `sha256` — Updated during hash calculation (when `hash_status="pending"`)
-- `hash_status` — Updated during hash calculation
-- `last_checked_at` — Timestamp of scan
-- `metadata_source` — Set based on metadata provider
-
-### Fields Set Once (Immutable After Import)
-
-These fields are set when the model is first imported/scanned and **never change** thereafter:
-
-- `modified` — Import timestamp (used for "Date Added" sorting)
-- `size` — File size at time of import/download
-
-### User-Editable Fields
-
-These fields can be edited by users at any time through the Lora Manager UI or by manually editing the metadata.json file:
-
-- `model_name` — Display name
-- `tags` — Model tags
-- `modelDescription` — Model description
-- `notes` — User notes
-- `favorite` — Favorite flag
-- `exclude` — Exclude from scanning (user can set `false`→`true`, currently no UI to revert)
-- `skip_metadata_refresh` — Skip during bulk refresh
-- `civitai.trainedWords` — Trigger words
-- `civitai.customImages` — Custom example images
-- `usage_tips` — Usage recommendations (LoRA only)
-
----
-
-
-## Field Reference by Behavior
-
-### Required Fields (Must Always Exist)
-
-- `file_name`
-- `model_name` (defaults to `file_name` if not provided)
-- `file_path`
-- `size`
-- `modified`
-- `sha256` (LoRA: always required; Checkpoint: may be empty when `hash_status="pending"`)
-
-### Optional Fields with Defaults
-
-| Field | Default |
-|-------|---------|
-| `base_model` | `"Unknown"` or `""` |
-| `preview_nsfw_level` | `0` |
-| `from_civitai` | `true` |
-| `civitai` | `{}` |
-| `tags` | `[]` |
-| `modelDescription` | `""` |
-| `notes` | `""` |
-| `civitai_deleted` | `false` |
-| `favorite` | `false` |
-| `exclude` | `false` |
-| `db_checked` | `false` |
-| `skip_metadata_refresh` | `false` |
-| `metadata_source` | `null` |
-| `last_checked_at` | `0` |
-| `hash_status` | `"completed"` |
-| `usage_tips` | `"{}"` (LoRA only) |
-| `model_type` | `"checkpoint"` or `"embedding"` (not present in LoRA models) |
-
----
-
-## Version History
-
-| Version | Date | Changes |
-|---------|------|---------|
-| 1.0 | 2026-03 | Initial schema documentation |
-
----
-
-## See Also
-
-- [JSON Schema Definition](../.specs/metadata.schema.json) — Formal JSON Schema for validation

docs/plan/model-modal-redesign.md

@@ -0,0 +1,449 @@
+# Model Modal UI/UX 重构计划
+
+> **Status**: Phase 1 Complete ✓  
+> **Created**: 2026-02-06  
+> **Target**: v2.x Release
+
+---
+
+## 1. 项目概述
+
+### 1.1 背景与问题
+
+当前 Model Modal 存在以下 UX 问题：
+
+1. **空间利用率低** - 固定 800px 宽度，大屏环境下大量留白
+2. **Tab 切换繁琐** - 4 个 Tab（Examples/Description/Versions/Recipes）隐藏了重要信息
+3. **Examples 浏览不便** - 需持续向下滚动，无快速导航
+4. **添加自定义示例困难** - 需滚动到底部，操作路径长
+
+### 1.2 设计目标
+
+- **空间效率**: 利用 header 以下、sidebar 右侧的全部可用空间
+- **浏览体验**: 类似 Midjourney 的沉浸式图片浏览
+- **信息架构**: 关键元数据固定可见，次要信息可折叠
+- **操作效率**: 直觉化的键盘导航，减少点击次数
+
+---
+
+## 2. 设计方案
+
+### 2.1 布局架构: Split-View Overlay
+
+```
+┌──────────────────────────────────────────────────────────────────────┐
+│  HEADER (保持现有)                                                    │
+├──────────┬───────────────────────────────────────────────────────────┤
+│          │  ┌───────────────────────────┬────────────────────────┐   │
+│ FOLDER   │  │                           │  MODEL HEADER          │   │
+│ SIDEBAR  │  │      EXAMPLES SHOWCASE    │  ├─ Name               │   │
+│ (可折叠)  │  │                           │  ├─ Creator + Actions  │   │
+│          │  │   ┌─────────────────┐     │  ├─ Tags               │   │
+│          │  │   │                 │     ├────────────────────────┤   │
+│          │  │   │   MAIN IMAGE    │     │  COMPACT METADATA      │   │
+│          │  │   │   (自适应高度)   │     │  ├─ Ver | Base | Size  │   │
+│          │  │   │                 │     │  ├─ Location           │   │
+│          │  │   └─────────────────┘     │  ├─ Usage Tips         │   │
+│          │  │                           │  ├─ Trigger Words      │   │
+│          │  │   [PARAMS PREVIEW]        │  ├─ Notes              │   │
+│          │  │   (Prompt + Copy)         ├────────────────────────┤   │
+│          │  │                           │  CONTENT TABS          │   │
+│          │  │   ┌─────────────────┐     │  [Desc][Versions][Rec] │   │
+│          │  │   │  THUMBNAIL RAIL │     │                        │   │
+│          │  │   │  [1][2][3][4][+]│     │  TAB CONTENT AREA      │   │
+│          │  │   └─────────────────┘     │  (Accordion / List)    │   │
+│          │  └───────────────────────────┴────────────────────────┘   │
+└──────────┴───────────────────────────────────────────────────────────┘
+```
+
+**尺寸规格**:
+- Sidebar 展开: Left 60% | Right 40%
+- Sidebar 折叠: Left 65% | Right 35%
+- 最小宽度: 1200px (低于此值触发移动端适配)
+
+### 2.2 左侧: Examples Showcase
+
+#### 2.2.1 组件结构
+
+| 组件 | 描述 | 优先级 |
+|------|------|--------|
+| Main Image | 自适应容器，保持原始比例，最大高度 70vh | P0 |
+| Params Panel | 底部滑出面板，显示 Prompt/Negative/Params | P0 |
+| Thumbnail Rail | 底部横向滚动条，支持点击跳转 | P0 |
+| Add Button | Rail 最右侧 "+" 按钮，打开上传区 | P0 |
+| Nav Arrows | 图片左右两侧悬停显示 | P1 |
+
+#### 2.2.2 图片悬停操作
+
+```
+┌─────────────────┐
+│ [👁] [📌] [🗑] │  ← 查看参数 | 设为预览 | 删除
+│                 │
+│     IMAGE       │
+│                 │
+└─────────────────┘
+```
+
+#### 2.2.3 键盘导航
+
+| 按键 | 功能 | 说明 |
+|------|------|------|
+| ← | 上一个 Example | 循环（首张时到最后一张） |
+| → | 下一个 Example | 循环（末张时到第一张） |
+| I | Toggle Params Panel | 显示/隐藏图片参数 |
+| C | Copy Prompt | 复制当前 Prompt 到剪贴板 |
+
+### 2.3 右侧: Metadata + Content
+
+#### 2.3.1 固定头部 (不可折叠)
+
+```
+┌────────────────────────┐
+│ MODEL NAME        [×]  │
+│ [👤 Creator] [🌐 Civ]  │
+│ [tag1] [tag2] [tag3]   │
+├────────────────────────┤
+│ Ver: v1.0  Size: 96MB  │
+│ Base: SDXL             │
+│ 📁 /path/to/file       │
+├────────────────────────┤
+│ USAGE TIPS        [✏️] │
+│ [strength: 0.8] [+]    │
+├────────────────────────┤
+│ TRIGGER WORDS     [✏️] │
+│ [word1] [word2]  [📋]  │
+├────────────────────────┤
+│ NOTES             [✏️] │
+│ "Add your notes..."    │
+└────────────────────────┘
+```
+
+#### 2.3.2 Tabs 设计
+
+保留横向 Tab 切换，但优化内容展示：
+
+| Tab | 内容 | 交互方式 |
+|-----|------|----------|
+| Description | About this version + Model Description | Accordion 折叠 |
+| Versions | 版本列表卡片 | 完整列表视图 |
+| Recipes | Recipe 卡片网格 | 网格布局 |
+
+**Accordion 行为**:
+- 手风琴模式：同时只能展开一个 section
+- 默认：About this version 展开，Description 折叠
+- 动画：300ms ease-out
+
+### 2.4 全局导航
+
+#### 2.4.1 Model 切换
+
+| 按键 | 功能 |
+|------|------|
+| ↑ | 上一个 Model |
+| ↓ | 下一个 Model |
+
+**切换动画**:
+1. 当前 Modal 淡出 (150ms)
+2. 加载新 Model 数据
+3. 新 Modal 淡入 (150ms)
+4. 保持当前 Tab 状态（不重置到默认）
+
+#### 2.4.2 首次使用提示
+
+Modal 首次打开时，顶部显示提示条：
+```
+┌─────────────────────────────────────────────────────────────┐
+│  💡 Tip: ↑↓ 切换模型 | ←→ 浏览示例 | I 查看参数 | ESC 关闭   │
+└─────────────────────────────────────────────────────────────┘
+```
+- 3 秒后自动淡出
+- 提供 "不再显示" 选项
+
+---
+
+## 3. 技术实现
+
+### 3.1 文件结构变更
+
+```
+static/
+├── js/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── index.js           # 主入口
+│           ├── ModelModal.js      # Modal 容器
+│           ├── ExampleShowcase.js # 左侧展示
+│           ├── ThumbnailRail.js   # 缩略图导航
+│           ├── MetadataPanel.js   # 右侧元数据
+│           ├── ContentTabs.js     # Tabs 容器
+│           └── accordions/        # Accordion 组件
+│               ├── DescriptionAccordion.js
+│               └── VersionsList.js
+├── css/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── modal-overlay.css
+│           ├── showcase.css
+│           ├── thumbnail-rail.css
+│           ├── metadata.css
+│           └── tabs.css
+```
+
+### 3.2 核心 CSS 架构
+
+```css
+/* modal-overlay.css */
+.model-overlay {
+  position: fixed;
+  top: var(--header-height);
+  left: var(--sidebar-width, 250px);
+  right: 0;
+  bottom: 0;
+  z-index: var(--z-modal);
+  
+  display: grid;
+  grid-template-columns: 1.2fr 0.8fr;
+  gap: 0;
+  
+  background: var(--bg-color);
+  animation: modalSlideIn 0.2s ease-out;
+}
+
+.model-overlay.sidebar-collapsed {
+  left: var(--sidebar-collapsed-width, 60px);
+  grid-template-columns: 1.3fr 0.7fr;
+}
+
+/* 移动端适配 */
+@media (max-width: 768px) {
+  .model-overlay {
+    left: 0;
+    grid-template-columns: 1fr;
+    grid-template-rows: auto 1fr;
+  }
+}
+```
+
+### 3.3 响应式断点
+
+| 断点 | 布局 | 说明 |
+|------|------|------|
+| > 1400px | Split 60/40 | 大屏优化 |
+| 1200-1400px | Split 50/50 | 标准桌面 |
+| 768-1200px | Split 50/50 | 小屏桌面/平板 |
+| < 768px | Stack | 移动端：Examples 在上，Metadata 在下 |
+
+---
+
+## 4. 实施阶段
+
+### Phase 1: 核心重构 (预计 2-3 周)
+
+**目标**: MVP 可用，基础功能完整
+
+**任务清单**:
+
+- [ ] 创建新的文件结构和基础组件
+- [ ] 实现 Split-View Overlay 布局
+  - [ ] CSS Grid 布局系统
+  - [ ] Sidebar 状态联动
+  - [ ] 响应式断点处理
+- [ ] 迁移左侧 Examples 区域
+  - [ ] Main Image 自适应容器
+  - [ ] Thumbnail Rail 组件
+  - [ ] Params Panel 滑出动画
+- [ ] 实现新的快捷键系统
+  - [ ] ↑↓ 切换 Model
+  - [ ] ←→ 切换 Example
+  - [ ] I/C/ESC 功能键
+- [ ] 移除旧 Modal 的 max-width 限制
+- [ ] 基础动画过渡
+
+**验收标准**:
+- [ ] 新布局在各种屏幕尺寸下正常显示
+- [ ] 键盘导航正常工作
+- [ ] 无阻塞性 Bug
+
+---
+
+### Phase 2: 体验优化 (预计 1-2 周)
+
+**目标**: 信息架构优化，交互细节完善
+
+**任务清单**:
+
+- [ ] Accordion 组件实现
+  - [ ] Description Tab 的折叠面板
+  - [ ] 手风琴交互逻辑
+  - [ ] 动画优化
+- [ ] 右侧 Metadata 区域固定化
+  - [ ] 滚动行为优化
+  - [ ] 编辑功能迁移
+- [ ] Example 添加流程优化
+  - [ ] Rail 上的 "+" 按钮
+  - [ ] Inline Upload Area
+  - [ ] 拖拽上传支持
+- [ ] Model 切换动画优化
+  - [ ] 淡入淡出效果
+  - [ ] 加载状态指示
+- [ ] 首次使用提示
+
+**验收标准**:
+- [ ] Accordion 交互流畅
+- [ ] 添加 Example 操作路径 < 2 步
+- [ ] Model 切换视觉反馈清晰
+
+---
+
+### Phase 3: 功能完整化 (预计 1-2 周)
+
+**目标**: 所有现有功能迁移完成
+
+**任务清单**:
+
+- [ ] Versions Tab 完整实现
+  - [ ] 版本列表卡片
+  - [ ] 下载/忽略/删除操作
+  - [ ] 更新状态 Badge
+- [ ] Recipes Tab 完整实现
+  - [ ] Recipe 卡片网格
+  - [ ] 复制/应用操作
+- [ ] Tab 状态保持
+  - [ ] 切换 Model 时保持当前 Tab
+  - [ ] Tab 内容滚动位置记忆
+- [ ] 所有编辑功能迁移
+  - [ ] Model Name 编辑
+  - [ ] Base Model 编辑
+  - [ ] File Name 编辑
+  - [ ] Tags 编辑
+  - [ ] Usage Tips 编辑
+  - [ ] Notes 编辑
+
+**验收标准**:
+- [ ] 所有现有功能可用
+- [ ] 单元测试覆盖率 > 80%
+
+---
+
+### Phase 4: 打磨与优化 (预计 1 周)
+
+**目标**: 性能优化，边缘 case 处理
+
+**任务清单**:
+
+- [ ] 移动端适配完善
+  - [ ] Stack 布局优化
+  - [ ] 触摸手势支持（滑动切换）
+- [ ] 性能优化
+  - [ ] 图片懒加载优化
+  - [ ] 虚拟滚动（大量 Examples 时）
+  - [ ] 减少重渲染
+- [ ] 无障碍支持
+  - [ ] ARIA 标签
+  - [ ] 键盘导航焦点管理
+  - [ ] 屏幕阅读器测试
+- [ ] 动画性能优化
+  - [ ] will-change 优化
+  - [ ] 减少 layout thrashing
+
+**验收标准**:
+- [ ] Lighthouse Performance > 90
+- [ ] 无障碍检查无严重问题
+
+---
+
+### Phase 5: 发布准备 (预计 3-5 天)
+
+**目标**: 稳定版本，文档完整
+
+**任务清单**:
+
+- [ ] Bug 修复
+- [ ] 用户测试
+- [ ] 更新文档
+  - [ ] README 更新
+  - [ ] 快捷键说明
+  - [ ] 截图/GIF 演示
+- [ ] 发布说明
+
+---
+
+## 5. 风险与应对
+
+| 风险 | 影响 | 应对策略 |
+|------|------|----------|
+| 用户不适应新布局 | 中 | 提供设置选项，允许切换回旧版（临时） |
+| 性能问题（大量 Examples） | 高 | Phase 4 重点优化，必要时虚拟滚动 |
+| 移动端体验不佳 | 中 | 单独设计移动端布局，非简单缩放 |
+| 与现有扩展冲突 | 低 | 充分的回归测试 |
+
+---
+
+## 6. 关联文件
+
+### 6.1 需修改的现有文件
+
+```
+static/js/components/shared/ModelModal.js      # 完全重构
+static/js/components/shared/showcase/          # 迁移至新目录
+static/css/components/lora-modal/              # 样式重写
+static/css/components/modal/_base.css          # Overlay 样式调整
+```
+
+### 6.2 参考资源
+
+- [Midjourney Explore](https://www.midjourney.com/explore) - 交互参考
+- [Pinterest Pin View](https://www.pinterest.com) - 布局参考
+- [AGENTS.md](/AGENTS.md) - 项目代码规范
+
+---
+
+## 7. Checklist
+
+### 7.1 启动前
+
+- [ ] 创建 feature branch: `feature/model-modal-redesign`
+- [ ] 设置开发环境
+- [ ] 准备测试数据集（多种 Model 类型）
+
+### 7.2 每个 Phase 完成时
+
+- [ ] 代码审查
+- [ ] 功能测试
+- [ ] 更新本文档状态
+
+### 7.3 发布前
+
+- [ ] 完整回归测试
+- [ ] 更新 CHANGELOG
+- [ ] 更新版本号
+
+---
+
+## 8. 附录
+
+### 8.1 命名规范
+
+| 类型 | 规范 | 示例 |
+|------|------|------|
+| 文件 | kebab-case | `thumbnail-rail.js` |
+| 组件 | PascalCase | `ThumbnailRail` |
+| CSS 类 | BEM | `.thumbnail-rail__item--active` |
+| 变量 | camelCase | `currentExampleIndex` |
+
+### 8.2 颜色规范
+
+使用现有 CSS 变量，不引入新颜色：
+
+```css
+--lora-accent: #4299e1;
+--lora-accent-l: 60%;
+--lora-accent-c: 0.2;
+--lora-accent-h: 250;
+--lora-surface: var(--card-bg);
+--lora-border: var(--border-color);
+```
+
+---
+
+*Last Updated: 2026-02-06*

docs/testing/backend-testing-improvement-plan.md

@@ -1,678 +0,0 @@
-# Backend Testing Improvement Plan
-
-**Status:** Phase 4 Complete ✅  
-**Created:** 2026-02-11  
-**Updated:** 2026-02-11  
-**Priority:** P0 - Critical
-
----
-
-## Executive Summary
-
-This document outlines a comprehensive plan to improve the quality, coverage, and maintainability of the LoRa Manager backend test suite. Recent critical bugs (_handle_download_task_done and get_status methods missing) were not caught by existing tests, highlighting significant gaps in the testing strategy.
-
-## Current State Assessment
-
-### Test Statistics
-- **Total Python Test Files:** 80+
-- **Total JavaScript Test Files:** 29
-- **Test Lines of Code:** ~15,000
-- **Current Pass Rate:** 100% (but missing critical edge cases)
-
-### Key Findings
-1. **Coverage Gaps:** Critical modules have no direct tests
-2. **Mocking Issues:** Over-mocking hides real bugs
-3. **Integration Deficit:** Missing end-to-end tests
-4. **Async Inconsistency:** Multiple patterns for async tests
-5. **Maintenance Burden:** Large, complex test files with duplication
-
----
-
-## Phase 2 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Integration Test Framework** ✅
-   - Created `tests/integration/` directory structure
-   - Added `tests/integration/conftest.py` with shared fixtures
-   - Added `tests/integration/__init__.py` for package organization
-
-2. **Download Flow Integration Tests** ✅
-   - Created `tests/integration/test_download_flow.py` with 7 tests
-   - Tests cover:
-     - Download with mocked network (2 tests)
-     - Progress broadcast verification (1 test)
-     - Error handling (1 test)
-     - Cancellation flow (1 test)
-     - Concurrent download management (1 test)
-     - Route endpoint validation (1 test)
-
-3. **Recipe Flow Integration Tests** ✅
-   - Created `tests/integration/test_recipe_flow.py` with 9 tests
-   - Tests cover:
-     - Recipe save and retrieve flow (1 test)
-     - Recipe update flow (1 test)
-     - Recipe delete flow (1 test)
-     - Recipe model extraction (1 test)
-     - Generation parameters handling (1 test)
-     - Concurrent recipe reads (1 test)
-     - Concurrent read/write operations (1 test)
-     - Recipe list endpoint (1 test)
-     - Recipe metadata parsing (1 test)
-
-4. **ModelLifecycleService Coverage** ✅
-   - Added 12 new tests to `tests/services/test_model_lifecycle_service.py`
-   - Tests cover:
-     - `exclude_model` functionality (3 tests)
-     - `bulk_delete_models` functionality (2 tests)
-     - Error path tests (5 tests)
-     - `_extract_model_id_from_payload` utility (3 tests)
-   - Total: 18 tests (up from 6)
-
-5. **PersistentRecipeCache Concurrent Access** ✅
-   - Added 5 new concurrent access tests to `tests/test_persistent_recipe_cache.py`
-   - Tests cover:
-     - Concurrent reads without corruption (1 test)
-     - Concurrent write and read operations (1 test)
-     - Concurrent updates to same recipe (1 test)
-     - Schema initialization thread safety (1 test)
-     - Concurrent save and remove operations (1 test)
-   - Total: 17 tests (up from 12)
-
-### Test Results
-- **Integration Tests:** 16/16 passing
-- **ModelLifecycleService Tests:** 18/18 passing  
-- **PersistentRecipeCache Tests:** 17/17 passing
-- **Total New Tests Added:** 28 tests
-
----
-
-## Phase 1 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **pytest-asyncio Integration** ✅
-   - Added `pytest-asyncio>=0.21.0` to `requirements-dev.txt`
-   - Updated `pytest.ini` with `asyncio_mode = auto` and `asyncio_default_fixture_loop_scope = function`
-   - Removed custom `pytest_pyfunc_call` handler from `tests/conftest.py`
-   - Added `@pytest.mark.asyncio` decorator to 21 async test functions in `tests/services/test_download_manager.py`
-
-2. **Error Path Tests** ✅
-   - Created `tests/services/test_downloader_error_paths.py` with 19 new tests
-   - Tests cover:
-     - DownloadStreamControl state management (6 tests)
-     - Downloader configuration and initialization (4 tests)
-     - DownloadProgress dataclass (1 test)
-     - Custom exceptions (2 tests)
-     - Authentication headers (3 tests)
-     - Session management (3 tests)
-
-3. **Test Results**
-   - All 45 tests pass (26 in test_download_manager.py + 19 in test_downloader_error_paths.py)
-   - No regressions introduced
-
-### Notes
-- Over-mocking fix in `test_download_manager.py` deferred to Phase 2 as it requires significant refactoring
-- Error path tests focus on unit-level testing of downloader components rather than complex integration scenarios
-
----
-
-## Phase 1: Critical Fixes (P0) - Week 1-2
-
-### 1.1 Fix Over-Mocking Issues
-
-**Problem:** Tests mock the methods they purport to test, hiding real bugs.
-
-**Affected Files:**
-- `tests/services/test_download_manager.py` - Mocks `_execute_download`
-- `tests/utils/test_example_images_download_manager_unit.py` - Mocks callbacks
-- `tests/routes/test_base_model_routes_smoke.py` - Uses fake service stubs
-
-**Actions:**
-1. Refactor `test_download_manager.py` to test actual download logic
-2. Replace method-level mocks with dependency injection
-3. Add integration tests that verify real behavior
-
-**Example Fix:**
-```python
-# BEFORE (Bad - mocks method under test)
-async def fake_execute_download(self, **kwargs):
-    return {"success": True}
-monkeypatch.setattr(DownloadManager, "_execute_download", fake_execute_download)
-
-# AFTER (Good - tests actual logic with injected dependencies)
-async def test_download_executes_with_real_logic(
-    tmp_path, mock_downloader, mock_websocket
-):
-    manager = DownloadManager(
-        downloader=mock_downloader,
-        ws_manager=mock_websocket
-    )
-    result = await manager._execute_download(urls=["http://test.com/file.safetensors"])
-    assert result.success is True
-    assert mock_downloader.download_calls == 1
-```
-
-### 1.2 Add Missing Error Path Tests
-
-**Problem:** Error handling code is not tested, leading to production failures.
-
-**Required Tests:**
-
-| Error Type | Module | Priority |
-|------------|--------|----------|
-| Network timeout | `downloader.py` | P0 |
-| Disk full | `download_manager.py` | P0 |
-| Permission denied | `example_images_download_manager.py` | P0 |
-| Session refresh failure | `downloader.py` | P1 |
-| Partial file cleanup | `download_manager.py` | P1 |
-
-**Implementation:**
-```python
-@pytest.mark.asyncio
-async def test_download_handles_network_timeout():
-    """Verify download retries on timeout and eventually fails gracefully."""
-    # Arrange
-    downloader = Downloader()
-    mock_session = AsyncMock()
-    mock_session.get.side_effect = asyncio.TimeoutError()
-    
-    # Act
-    success, message = await downloader.download_file(
-        url="http://test.com/file.safetensors",
-        target_path=tmp_path / "test.safetensors",
-        session=mock_session
-    )
-    
-    # Assert
-    assert success is False
-    assert "timeout" in message.lower()
-    assert mock_session.get.call_count == MAX_RETRIES
-```
-
-### 1.3 Standardize Async Test Patterns
-
-**Problem:** Inconsistent async test patterns across codebase.
-
-**Current State:**
-- Some use `@pytest.mark.asyncio`
-- Some rely on custom `pytest_pyfunc_call` in conftest.py
-- Some use bare async functions
-
-**Solution:**
-1. Add `pytest-asyncio` to requirements-dev.txt
-2. Update `pytest.ini`:
-   ```ini
-   [pytest]
-   asyncio_mode = auto
-   asyncio_default_fixture_loop_scope = function
-   ```
-3. Remove custom `pytest_pyfunc_call` handler from conftest.py
-4. Bulk update all async tests to use `@pytest.mark.asyncio`
-
-**Migration Script:**
-```bash
-# Find all async test functions missing decorator
-rg "^async def test_" tests/ --type py -A1 | grep -B1 "@pytest.mark" | grep "async def"
-
-# Add decorator (manual review required)
-```
-
----
-
-## Phase 2: Integration & Coverage (P1) - Week 3-4
-
-### 2.1 Add Critical Module Tests
-
-**Priority 1: `py/services/model_lifecycle_service.py`**
-```python
-# tests/services/test_model_lifecycle_service.py
-class TestModelLifecycleService:
-    async def test_create_model_registers_in_cache(self):
-        """Verify new model is registered in both cache and database."""
-        
-    async def test_delete_model_cleans_up_files_and_cache(self):
-        """Verify deletion removes files and updates all indexes."""
-        
-    async def test_update_model_metadata_propagates_changes(self):
-        """Verify metadata updates reach all subscribers."""
-```
-
-**Priority 2: `py/services/persistent_recipe_cache.py`**
-```python
-# tests/services/test_persistent_recipe_cache.py
-class TestPersistentRecipeCache:
-    def test_initialization_creates_schema(self):
-        """Verify SQLite schema is created on first use."""
-        
-    async def test_save_recipe_persists_to_sqlite(self):
-        """Verify recipe data is saved correctly."""
-        
-    async def test_concurrent_access_does_not_corrupt_database(self):
-        """Verify thread safety under concurrent writes."""
-```
-
-**Priority 3: Route Handler Tests**
-- `py/routes/handlers/preview_handlers.py`
-- `py/routes/handlers/misc_handlers.py`
-- `py/routes/handlers/model_handlers.py`
-
-### 2.2 Add End-to-End Integration Tests
-
-**Download Flow Integration Test:**
-```python
-# tests/integration/test_download_flow.py
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_complete_download_flow(tmp_path, test_server):
-    """
-    Integration test covering:
-    1. Route receives download request
-    2. DownloadCoordinator schedules it
-    3. DownloadManager executes actual download
-    4. Downloader makes HTTP request (to test server)
-    5. Progress is broadcast via WebSocket
-    6. File is saved and cache updated
-    """
-    # Setup test server with known file
-    test_file = tmp_path / "test_model.safetensors"
-    test_file.write_bytes(b"fake model data")
-    
-    # Start download
-    async with aiohttp.ClientSession() as session:
-        response = await session.post(
-            "http://localhost:8188/api/lm/download",
-            json={"urls": [f"http://localhost:{test_server.port}/test_model.safetensors"]}
-        )
-        assert response.status == 200
-        
-    # Verify file downloaded
-    downloaded = tmp_path / "downloads" / "test_model.safetensors"
-    assert downloaded.exists()
-    assert downloaded.read_bytes() == b"fake model data"
-    
-    # Verify WebSocket progress updates
-    assert len(ws_manager.broadcasts) > 0
-    assert any(b["status"] == "completed" for b in ws_manager.broadcasts)
-```
-
-**Recipe Flow Integration Test:**
-```python
-# tests/integration/test_recipe_flow.py
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_recipe_analysis_and_save_flow(tmp_path):
-    """
-    Integration test covering:
-    1. Import recipe from image
-    2. Parse metadata and extract models
-    3. Save to cache and database
-    4. Retrieve and display
-    """
-```
-
-### 2.3 Strengthen Assertions
-
-**Replace loose assertions:**
-```python
-# BEFORE
-assert "mismatch" in message.lower()
-
-# AFTER
-assert message == "File size mismatch. Expected: 1000 bytes, Got: 500 bytes"
-assert not target_path.exists()
-assert not Path(str(target_path) + ".part").exists()
-assert len(downloader.retry_history) == 3
-```
-
-**Add state verification:**
-```python
-# BEFORE
-assert result is True
-
-# AFTER
-assert result is True
-assert model["status"] == "downloaded"
-assert model["file_path"].exists()
-assert cache.get_by_hash(model["sha256"]) is not None
-assert len(ws_manager.payloads) >= 2  # Started + completed
-```
-
----
-
-## Phase 4 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Property-Based Tests (Hypothesis)** ✅
-   - Created `tests/utils/test_utils_hypothesis.py` with 19 property-based tests
-   - Tests cover:
-     - `sanitize_folder_name` idempotency and invalid character handling (4 tests)
-     - `_sanitize_library_name` idempotency and safe character filtering (2 tests)
-     - `normalize_path` idempotency and forward slash usage (2 tests)
-     - `fuzzy_match` edge cases and threshold behavior (3 tests)
-     - `determine_base_model` return type guarantees (2 tests)
-     - `get_preview_extension` return type validation (2 tests)
-     - `calculate_recipe_fingerprint` determinism and ordering (4 tests)
-   - Fixed Hypothesis plugin compatibility issue by creating a `MockModule` class in `conftest.py` that is hashable (unlike `types.SimpleNamespace`)
-
-2. **Snapshot Tests (Syrupy)** ✅
-   - Created `tests/routes/test_api_snapshots.py` with 7 snapshot tests
-   - Tests cover:
-     - SettingsHandler response formats (2 tests)
-     - NodeRegistryHandler response formats (2 tests)
-     - Utility function output verification (2 tests)
-     - ModelLibraryHandler empty response format (1 test)
-   - All snapshots generated and tests passing (7/7)
-
-3. **Performance Benchmarks** ✅
-   - Created `tests/performance/test_cache_performance.py` with 11 benchmark tests
-   - Tests cover:
-     - Hash index lookup performance (100, 1K, 10K models) - 3 tests
-     - Hash index add entry performance (100, 10K existing) - 2 tests
-     - Fuzzy matching performance (short text, long text, many words) - 3 tests
-     - Recipe fingerprint calculation (5, 50, 200 LoRAs) - 3 tests
-   - All benchmarks passing with performance metrics (11/11)
-
-4. **Package Dependencies** ✅
-   - Added `hypothesis>=6.0` to `requirements-dev.txt`
-   - Added `syrupy>=5.0` to `requirements-dev.txt`
-   - Added `pytest-benchmark>=5.0` to `requirements-dev.txt`
-
-### Test Results
-- **Property-Based Tests:** 19/19 passing
-- **Snapshot Tests:** 7/7 passing
-- **Performance Benchmarks:** 11/11 passing
-- **Total New Tests Added:** 37 tests
-- **Full Test Suite:** 947/947 passing
-
----
-
-## Phase 3 Completion Summary (2026-02-11)
-
-### Completed Items
-
-1. **Centralized Test Fixtures** ✅
-   - Added `mock_downloader` fixture to `tests/conftest.py`
-     - Configurable mock with `should_fail` and `return_value` attributes
-     - Records all download calls for verification
-   - Added `mock_websocket_manager` fixture to `tests/conftest.py`
-     - Recording WebSocket manager that captures all broadcast payloads
-     - Includes helper method `get_payloads_by_type()` for filtering
-   - Added `reset_singletons` autouse fixture to `tests/conftest.py`
-     - Resets DownloadManager, ServiceRegistry, ModelScanner, and SettingsManager
-     - Ensures test isolation and prevents singleton pollution
-
-2. **Split Large Test Files** ✅
-   - Split `tests/services/test_download_manager.py` (1422 lines) into:
-     - `test_download_manager_basic.py` - Core functionality (12 tests)
-     - `test_download_manager_error.py` - Error handling and execution (15 tests)
-     - `test_download_manager_concurrent.py` - Advanced scenarios (6 tests)
-   - Split `tests/utils/test_cache_paths.py` (530 lines) into:
-     - `test_cache_paths_resolution.py` - Path resolution and CacheType tests (11 tests)
-     - `test_cache_paths_validation.py` - Legacy path validation and cleanup (9 tests)
-     - `test_cache_paths_migration.py` - Migration scenarios and auto-cleanup (9 tests)
-
-3. **Complex Test Refactoring** ✅
-   - Reviewed `test_example_images_download_manager_unit.py`
-   - Existing async event-based patterns are appropriate for testing concurrent behavior
-   - No refactoring needed - tests follow consistent patterns and are maintainable
-
-### Test Results
-- **Download Manager Tests:** 33/33 passing across 3 files
-- **Cache Paths Tests:** 29/29 passing across 3 files
-- **Total Tests Maintained:** All existing tests preserved and organized
-
----
-
-## Phase 3: Architecture & Maintainability (P2) - Week 5-6
-
-### 3.1 Centralize Test Fixtures
-
-**Create `tests/conftest.py` improvements:**
-
-```python
-# tests/conftest.py additions
-
-@pytest.fixture
-def mock_downloader():
-    """Provide a configurable mock downloader."""
-    class MockDownloader:
-        def __init__(self):
-            self.download_calls = []
-            self.should_fail = False
-            
-        async def download_file(self, url, target_path, **kwargs):
-            self.download_calls.append({"url": url, "target_path": target_path})
-            if self.should_fail:
-                return False, "Download failed"
-            return True, str(target_path)
-    
-    return MockDownloader()
-
-@pytest.fixture
-def mock_websocket_manager():
-    """Provide a recording WebSocket manager."""
-    class RecordingWebSocketManager:
-        def __init__(self):
-            self.payloads = []
-            
-        async def broadcast(self, payload):
-            self.payloads.append(payload)
-            
-    return RecordingWebSocketManager()
-
-@pytest.fixture
-def mock_scanner():
-    """Provide a mock model scanner with configurable cache."""
-    # ... existing MockScanner but improved ...
-    
-@pytest.fixture(autouse=True)
-def reset_singletons():
-    """Reset all singletons before each test."""
-    # Centralized singleton reset
-    DownloadManager._instance = None
-    ServiceRegistry.clear_services()
-    ModelScanner._instances.clear()
-    yield
-    # Cleanup
-    DownloadManager._instance = None
-    ServiceRegistry.clear_services()
-    ModelScanner._instances.clear()
-```
-
-### 3.2 Split Large Test Files
-
-**Target Files:**
-- `tests/services/test_download_manager.py` (1000+ lines) → Split into:
-  - `test_download_manager_basic.py` - Core functionality
-  - `test_download_manager_error.py` - Error handling
-  - `test_download_manager_concurrent.py` - Concurrent operations
-
-- `tests/utils/test_cache_paths.py` (529 lines) → Split into:
-  - `test_cache_paths_resolution.py`
-  - `test_cache_paths_validation.py`
-  - `test_cache_paths_migration.py`
-
-### 3.3 Refactor Complex Tests
-
-**Example: Simplify test setup in `test_example_images_download_manager_unit.py`**
-
-**Current (Complex):**
-```python
-async def test_start_download_bootstraps_progress_and_task(
-    monkeypatch: pytest.MonkeyPatch, tmp_path
-):
-    # 40+ lines of setup
-    started = asyncio.Event()
-    release = asyncio.Event()
-    
-    async def fake_download(self, ...):
-        started.set()
-        await release.wait()
-        # ... more logic ...
-```
-
-**Improved (Using fixtures):**
-```python
-async def test_start_download_bootstraps_progress_and_task(
-    download_manager_with_fake_backend, release_event
-):
-    # Setup in fixtures, test is clean
-    manager = download_manager_with_fake_backend
-    result = await manager.start_download({"model_types": ["lora"]})
-    assert result["success"] is True
-    assert manager._is_downloading is True
-```
-
----
-
-## Phase 4: Advanced Testing (P3) - Week 7-8
-
-### 4.1 Add Property-Based Tests (Hypothesis)
-
-**Install:** `pip install hypothesis`
-
-**Example:**
-```python
-# tests/utils/test_hash_utils_hypothesis.py
-from hypothesis import given, strategies as st
-
-@given(st.text(min_size=1, max_size=100))
-def test_hash_normalization_idempotent(name):
-    """Hash normalization should be idempotent."""
-    normalized = normalize_hash(name)
-    assert normalize_hash(normalized) == normalized
-
-@given(st.lists(st.dictionaries(st.text(), st.text()), min_size=0, max_size=1000))
-def test_model_cache_handles_any_model_list(models):
-    """Cache should handle any list of models without crashing."""
-    cache = ModelCache()
-    cache.raw_data = models
-    # Should not raise
-    list(cache.iter_models())
-```
-
-### 4.2 Add Snapshot Tests (Syrupy)
-
-**Install:** `pip install syrupy`
-
-**Example:**
-```python
-# tests/routes/test_api_snapshots.py
-import pytest
-
-@pytest.mark.asyncio
-async def test_lora_list_response_format(snapshot, client):
-    """Verify API response format matches snapshot."""
-    response = await client.get("/api/lm/loras")
-    data = await response.json()
-    assert data == snapshot  # Syrupy handles this
-```
-
-### 4.3 Add Performance Benchmarks
-
-**Install:** `pip install pytest-benchmark`
-
-**Example:**
-```python
-# tests/performance/test_cache_performance.py
-import pytest
-
-def test_cache_lookup_performance(benchmark):
-    """Benchmark cache lookup with 10,000 models."""
-    cache = create_cache_with_n_models(10000)
-    
-    result = benchmark(lambda: cache.get_by_hash("abc123"))
-    # Benchmark automatically collects timing stats
-```
-
----
-
-## Implementation Checklist
-
-### Week 1-2: Critical Fixes
-- [x] Fix over-mocking in `test_download_manager.py` (Skipped - requires major refactoring, see Phase 2)
-- [x] Add network timeout tests (Added `test_downloader_error_paths.py` with 19 error path tests)
-- [x] Add disk full error tests (Covered in error path tests)
-- [x] Add permission denied tests (Covered in error path tests)
-- [x] Install and configure pytest-asyncio (Added to requirements-dev.txt and pytest.ini)
-- [x] Remove custom pytest_pyfunc_call handler (Removed from conftest.py)
-- [x] Add `@pytest.mark.asyncio` to all async tests (Added to 21 async test functions in test_download_manager.py)
-
-### Week 3-4: Integration & Coverage
-- [x] Create `test_model_lifecycle_service.py` tests (12 new tests added)
-- [x] Create `test_persistent_recipe_cache.py` tests (5 new concurrent access tests added)
-- [x] Create `tests/integration/` directory (created with conftest.py)
-- [x] Add download flow integration test (7 tests added)
-- [x] Add recipe flow integration test (9 tests added)
-- [x] Add route handler tests for preview_handlers.py (already exists in test_preview_routes.py)
-- [x] Strengthen assertions across integration tests (comprehensive assertions added)
-
-### Week 5-6: Architecture
-- [x] Add centralized fixtures to conftest.py
-- [x] Split `test_download_manager.py` into 3 files
-- [x] Split `test_cache_paths.py` into 3 files
-- [x] Refactor complex test setups (reviewed - no changes needed)
-- [x] Remove duplicate singleton reset fixtures (consolidated in conftest.py)
-
-### Week 7-8: Advanced Testing
-- [x] Install hypothesis (Added to requirements-dev.txt)
-- [x] Add 10 property-based tests (Created 19 tests in test_utils_hypothesis.py)
-- [x] Install syrupy (Added to requirements-dev.txt)
-- [x] Add 5 snapshot tests (Created 7 tests in test_api_snapshots.py)
-- [x] Install pytest-benchmark (Added to requirements-dev.txt)
-- [x] Add 3 performance benchmarks (Created 11 tests in test_cache_performance.py)
-
----
-
-## Success Metrics
-
-### Quantitative
-- **Code Coverage:** Increase from ~70% to >90%
-- **Test Count:** Increase from 400+ to 600+
-- **Assertion Strength:** Replace 50+ weak assertions
-- **Integration Test Ratio:** Increase from 5% to 20%
-
-### Qualitative
-- **Bug Escape Rate:** Reduce by 80%
-- **Test Maintenance Time:** Reduce by 50%
-- **Time to Write New Tests:** Reduce by 30%
-- **CI Pipeline Speed:** Maintain <5 minutes
-
----
-
-## Risk Mitigation
-
-| Risk | Mitigation |
-|------|------------|
-| Breaking existing tests | Run full test suite after each change |
-| Increased CI time | Optimize tests, parallelize execution |
-| Developer resistance | Provide training, pair programming |
-| Maintenance burden | Document patterns, provide templates |
-| Coverage gaps | Use coverage.py in CI, fail on <90% |
-
----
-
-## Related Documents
-
-- `docs/testing/frontend-testing-roadmap.md` - Frontend testing plan
-- `docs/AGENTS.md` - Development guidelines
-- `pytest.ini` - Test configuration
-- `tests/conftest.py` - Shared fixtures
-
----
-
-## Approval
-
-| Role | Name | Date | Signature |
-|------|------|------|-----------|
-| Tech Lead | | | |
-| QA Lead | | | |
-| Product Owner | | | |
-
----
-
-**Next Review Date:** 2026-02-25
-
-**Document Owner:** Backend Team

docs/ui-ux-optimization/progress-tracker.md

@@ -1,196 +0,0 @@
-# Settings Modal Optimization Progress Tracker
-
-## Project Overview
-**Goal**: Optimize Settings Modal UI/UX with left navigation sidebar
-**Started**: 2026-02-23
-**Current Phase**: P2 - Search Bar (Completed)
-
----
-
-## Phase 0: Left Navigation Sidebar (P0)
-
-### Status: Completed ✓
-
-### Completion Notes
-- All CSS changes implemented
-- HTML structure restructured successfully  
-- JavaScript navigation functionality added
-- Translation keys added and synchronized
-- Ready for testing and review
-
-### Tasks
-
-#### 1. CSS Changes
-- [x] Add two-column layout styles
-  - [x] `.settings-modal` flex layout
-  - [x] `.settings-nav` sidebar styles
-  - [x] `.settings-content` content area styles
-  - [x] `.settings-nav-item` navigation item styles
-  - [x] `.settings-nav-item.active` active state styles
-- [x] Adjust modal width to 950px
-- [x] Add smooth scroll behavior
-- [x] Add responsive styles for mobile
-- [x] Ensure dark theme compatibility
-
-#### 2. HTML Changes
-- [x] Restructure modal HTML
-  - [x] Wrap content in two-column container
-  - [x] Add navigation sidebar structure
-  - [x] Add navigation items for each section
-  - [x] Add ID anchors to each section
-- [x] Update section grouping if needed
-
-#### 3. JavaScript Changes
-- [x] Add navigation click handlers
-- [x] Implement smooth scroll to section
-- [x] Add scroll spy for active nav highlighting
-- [x] Handle nav item click events
-- [x] Update SettingsManager initialization
-
-#### 4. Translation Keys
-- [x] Add translation keys for navigation groups
-  - [x] `settings.nav.general`
-  - [x] `settings.nav.interface`
-  - [x] `settings.nav.download`
-  - [x] `settings.nav.advanced`
-
-#### 4. Testing
-- [x] Verify navigation clicks work
-- [x] Verify active highlighting works
-- [x] Verify smooth scrolling works
-- [ ] Test on mobile viewport (deferred to final QA)
-- [ ] Test dark/light theme (deferred to final QA)
-- [x] Verify all existing settings work
-- [x] Verify save/load functionality
-
-### Blockers
-None currently
-
-### Notes
-- Started implementation on 2026-02-23
-- Following existing design system and CSS variables
-
----
-
-## Phase 1: Section Collapse/Expand (P1)
-
-### Status: Completed ✓
-
-### Completion Notes
-- All sections now have collapse/expand functionality
-- Chevron icon rotates smoothly on toggle
-- State persistence via localStorage working correctly
-- CSS animations for smooth height transitions
-- Settings order reorganized to match sidebar navigation
-
-### Tasks
-- [x] Add collapse/expand toggle to section headers
-- [x] Add chevron icon with rotation animation
-- [x] Implement localStorage for state persistence
-- [x] Add CSS animations for smooth transitions
-- [x] Reorder settings sections to match sidebar navigation
-
----
-
-## Phase 2: Search Bar (P1)
-
-### Status: Completed ✓
-
-### Completion Notes
-- Search input added to settings modal header with icon and clear button
-- Real-time filtering with debounced input (150ms delay)
-- Highlight matching terms with accent color background
-- Handle empty search results with user-friendly message
-- Keyboard shortcuts: Escape to clear search
-- Sections with matches are automatically expanded
-- All translation keys added and synchronized across languages
-
-### Tasks
-- [x] Add search input to header area
-- [x] Implement real-time filtering
-- [x] Add highlight for matched terms
-- [x] Handle empty search results
-
----
-
-## Phase 3: Visual Hierarchy (P2)
-
-### Status: Planned
-
-### Tasks
-- [ ] Add accent border to section headers
-- [ ] Bold setting labels
-- [ ] Increase section spacing
-
----
-
-## Phase 4: Quick Actions (P3)
-
-### Status: Planned
-
-### Tasks
-- [ ] Add reset to defaults button
-- [ ] Add export config button
-- [ ] Add import config button
-- [ ] Implement corresponding functionality
-
----
-
-## Change Log
-
-### 2026-02-23 (P2)
-- Completed Phase 2: Search Bar
-- Added search input to settings modal header with search icon and clear button
-- Implemented real-time filtering with 150ms debounce for performance
-- Added visual highlighting for matched search terms using accent color
-- Implemented empty search results state with user-friendly message
-- Added keyboard shortcuts (Escape to clear search)
-- Sections with matching content are automatically expanded during search
-- Updated SettingsManager.js with search initialization and filtering logic
-- Added comprehensive CSS styles for search input, highlights, and responsive design
-- Added translation keys for search feature (placeholder, clear, no results)
-- Synchronized translations across all language files
-
-### 2026-02-23 (P1)
-- Completed Phase 1: Section Collapse/Expand
-- Added collapse/expand functionality to all settings sections
-- Implemented chevron icon with smooth rotation animation
-- Added localStorage persistence for collapse state
-- Reorganized settings sections to match sidebar navigation order
-- Updated SettingsManager.js with section collapse initialization
-- Added CSS styles for smooth transitions and animations
-
-### 2026-02-23 (P0)
-- Created project documentation
-- Started Phase 0 implementation
-- Analyzed existing code structure
-- Implemented two-column layout with left navigation sidebar
-- Added CSS styles for navigation and responsive design
-- Restructured HTML to support new layout
-- Added JavaScript navigation functionality with scroll spy
-- Added translation keys for navigation groups
-- Synchronized translations across all language files
-- Tested in browser - navigation working correctly
-
----
-
-## Testing Checklist
-
-### Functional Testing
-- [ ] All settings save correctly
-- [ ] All settings load correctly
-- [ ] Navigation scrolls to correct section
-- [ ] Active nav updates on scroll
-- [ ] Mobile responsive layout
-
-### Visual Testing
-- [ ] Design matches existing UI
-- [ ] Dark theme looks correct
-- [ ] Light theme looks correct
-- [ ] Animations are smooth
-- [ ] No layout shifts or jumps
-
-### Cross-browser Testing
-- [ ] Chrome/Chromium
-- [ ] Firefox
-- [ ] Safari (if available)

docs/ui-ux-optimization/settings-modal-optimization-proposal.md

@@ -1,331 +0,0 @@
-# Settings Modal UI/UX Optimization
-
-## Overview
-当前Settings Modal采用单列表长页面设计，随着设置项不断增加，已难以高效浏览和定位。本方案采用 **macOS Settings 模式**（左侧导航 + 右侧单Section独占显示），在保持原有设计语言的前提下，重构信息架构，大幅提升用户体验。
-
-## Goals
-1. **提升浏览效率**：用户能够快速定位和修改设置
-2. **保持设计一致性**：延续现有的颜色、间距、动画系统
-3. **简化交互模型**：移除冗余元素（SETTINGS label、折叠功能）
-4. **清晰的视觉层次**：Section级导航，右侧独占显示
-5. **向后兼容**：不影响现有功能逻辑
-
-## Design Principles
-- **macOS Settings模式**：点击左侧导航，右侧仅显示该Section内容
-- **贴近原有设计语言**：使用现有CSS变量和样式模式
-- **最小化风格改动**：在提升UX的同时保持视觉风格稳定
-- **简化优于复杂**：移除不必要的折叠/展开交互
-
----
-
-## New Design Architecture
-
-### Layout Structure
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Settings                                    [×]            │
-├──────────────┬──────────────────────────────────────────────┤
-│  NAVIGATION  │  CONTENT                                     │
-│              │                                              │
-│  General   → │  ┌─────────────────────────────────────────┐ │
-│  Interface   │  │ General                                 │ │
-│  Download    │  │ ═══════════════════════════════════════ │ │
-│  Advanced    │  │                                           │ │
-│              │  │ ┌─────────────────────────────────────┐   │ │
-│              │  │ │ Civitai API Key                     │   │ │
-│              │  │ │ [                         ] [?]     │   │ │
-│              │  │ └─────────────────────────────────────┘   │ │
-│              │  │                                           │ │
-│              │  │ ┌─────────────────────────────────────┐   │ │
-│              │  │ │ Settings Location                   │   │ │
-│              │  │ │ [/path/to/settings]     [Browse]    │   │ │
-│              │  │ └─────────────────────────────────────┘   │ │
-│              │  └─────────────────────────────────────────┘ │
-│              │                                              │
-│              │  [Cancel]                    [Save Changes]  │
-└──────────────┴──────────────────────────────────────────────┘
-```
-
-### Key Design Decisions
-
-#### 1. 移除冗余元素
-- ❌ 删除 sidebar 中的 "SETTINGS" label
-- ❌ **取消折叠/展开功能**（增加交互成本，无实际收益）
-- ❌ 不再在左侧导航显示具体设置项（减少认知负荷）
-
-#### 2. 导航简化
-- 左侧仅显示 **4个Section**（General / Interface / Download / Advanced）
-- 当前选中项用 accent 色 background highlight
-- 无需滚动监听，点击即切换
-
-#### 3. 右侧单Section独占
-- 点击左侧导航，右侧仅显示该Section的所有设置项
-- Section标题作为页面标题（大号字体 + accent色下划线）
-- 所有设置项平铺展示，无需折叠
-
-#### 4. 视觉层次
-```
-Section Header (20px, bold, accent underline)
-├── Setting Group (card container, subtle border)
-│   ├── Setting Label (14px, semibold)
-│   ├── Setting Description (12px, muted color)
-│   └── Setting Control (input/select/toggle)
-```
-
----
-
-## Optimization Phases
-
-### Phase 0: macOS Settings模式重构 (P0)
-**Status**: Ready for Development
-**Priority**: High
-
-#### Goals
-- 重构为两栏布局（左侧导航 + 右侧内容）
-- 实现Section级导航切换
-- 优化视觉层次和间距
-- 移除冗余元素
-
-#### Implementation Details
-
-##### Layout Specifications
-| Element | Specification |
-|---------|--------------|
-| Modal Width | 800px (比原700px稍宽) |
-| Modal Height | 600px (固定高度) |
-| Left Sidebar | 200px 固定宽度 |
-| Right Content | flex: 1，自动填充 |
-| Content Padding | --space-3 (24px) |
-
-##### Navigation Structure
-```
-General (通用)
-├── Language
-├── Civitai API Key
-└── Settings Location
-
-Interface (界面)
-├── Layout Settings
-├── Video Settings
-└── Content Filtering
-
-Download (下载)
-├── Folder Settings
-├── Download Path Templates
-├── Example Images
-└── Update Flags
-
-Advanced (高级)
-├── Priority Tags
-├── Auto-organize exclusions
-├── Metadata refresh skip paths
-├── Metadata Archive Database
-├── Proxy Settings
-└── Misc
-```
-
-##### CSS Style Guide
-
-**Section Header**
-```css
-.settings-section-header {
-  font-size: 20px;
-  font-weight: 600;
-  padding-bottom: var(--space-2);
-  border-bottom: 2px solid var(--lora-accent);
-  margin-bottom: var(--space-3);
-}
-```
-
-**Setting Group (Card)**
-```css
-.settings-group {
-  background: var(--card-bg);
-  border: 1px solid var(--lora-border);
-  border-radius: var(--border-radius-sm);
-  padding: var(--space-3);
-  margin-bottom: var(--space-3);
-}
-```
-
-**Setting Item**
-```css
-.setting-item {
-  margin-bottom: var(--space-3);
-}
-
-.setting-item:last-child {
-  margin-bottom: 0;
-}
-
-.setting-label {
-  font-size: 14px;
-  font-weight: 500;
-  margin-bottom: var(--space-1);
-}
-
-.setting-description {
-  font-size: 12px;
-  color: var(--text-muted);
-  margin-bottom: var(--space-2);
-}
-```
-
-**Sidebar Navigation**
-```css
-.settings-nav-item {
-  padding: var(--space-2) var(--space-3);
-  border-radius: var(--border-radius-xs);
-  cursor: pointer;
-  transition: background 0.2s ease;
-}
-
-.settings-nav-item:hover {
-  background: rgba(255, 255, 255, 0.05);
-}
-
-.settings-nav-item.active {
-  background: var(--lora-accent);
-  color: white;
-}
-```
-
-#### Files to Modify
-
-1. **static/css/components/modal/settings-modal.css**
-   - [ ] 新增两栏布局样式
-   - [ ] 新增侧边栏导航样式
-   - [ ] 新增Section标题样式
-   - [ ] 调整设置项卡片样式
-   - [ ] 移除折叠相关的CSS
-
-2. **templates/components/modals/settings_modal.html**
-   - [ ] 重构为两栏HTML结构
-   - [ ] 添加4个导航项
-   - [ ] 将Section改为独立内容区域
-   - [ ] 移除折叠按钮HTML
-
-3. **static/js/managers/SettingsManager.js**
-   - [ ] 添加导航点击切换逻辑
-   - [ ] 添加Section显示/隐藏控制
-   - [ ] 移除折叠/展开相关代码
-   - [ ] 默认显示第一个Section
-
----
-
-### Phase 1: 搜索功能 (P1)
-**Status**: Planned
-**Priority**: Medium
-
-#### Goals
-- 快速定位特定设置项
-- 支持关键词搜索设置标签和描述
-
-#### Implementation
-- 搜索框保持在顶部右侧
-- 实时过滤：显示匹配的Section和设置项
-- 高亮匹配的关键词
-- 无结果时显示友好提示
-
----
-
-### Phase 2: 操作按钮优化 (P2)
-**Status**: Planned
-**Priority**: Low
-
-#### Goals
-- 增强功能完整性
-- 提供批量操作能力
-
-#### Implementation
-- 底部固定操作栏（position: sticky）
-- [Cancel] 和 [Save Changes] 按钮
-- 可选：重置为默认、导出配置、导入配置
-
----
-
-## Migration Notes
-
-### Removed Features
-| Feature | Reason |
-|---------|--------|
-| Section折叠/展开 | 单Section独占显示后不再需要 |
-| 滚动监听高亮 | 改为点击切换，无需监听滚动 |
-| 长页面平滑滚动 | 内容不再超长，无需滚动 |
-| "SETTINGS" label | 冗余信息，移除以简化UI |
-
-### Preserved Features
-- 所有设置项功能和逻辑
-- 表单验证
-- 设置项描述和提示
-- 原有的CSS变量系统
-
----
-
-## Success Criteria
-
-### Phase 0
-- [ ] Modal显示为两栏布局
-- [ ] 左侧显示4个Section导航
-- [ ] 点击导航切换右侧显示的Section
-- [ ] 当前选中导航项高亮显示
-- [ ] Section标题有accent色下划线
-- [ ] 设置项以卡片形式分组展示
-- [ ] 移除所有折叠/展开功能
-- [ ] 移动端响应式正常（单栏堆叠）
-- [ ] 所有现有设置功能正常工作
-- [ ] 设计风格与原有UI一致
-
-### Phase 1
-- [ ] 搜索框可输入关键词
-- [ ] 实时过滤显示匹配项
-- [ ] 高亮匹配的关键词
-
-### Phase 2
-- [ ] 底部有固定操作按钮栏
-- [ ] Cancel和Save Changes按钮工作正常
-
----
-
-## Timeline
-
-| Phase | Estimated Time | Status |
-|-------|---------------|--------|
-| P0    | 3-4 hours     | Ready for Development |
-| P1    | 2-3 hours     | Planned |
-| P2    | 1-2 hours     | Planned |
-
----
-
-## Reference
-
-### Design Inspiration
-- **macOS System Settings**: 左侧导航 + 右侧单Section独占
-- **VS Code Settings**: 清晰的视觉层次和搜索体验
-- **Linear**: 简洁的两栏布局设计
-
-### CSS Variables Reference
-```css
-/* Colors */
---lora-accent: #007AFF;
---lora-border: rgba(255, 255, 255, 0.1);
---card-bg: rgba(255, 255, 255, 0.05);
---text-color: #ffffff;
---text-muted: rgba(255, 255, 255, 0.6);
-
-/* Spacing */
---space-1: 8px;
---space-2: 12px;
---space-3: 16px;
---space-4: 24px;
-
-/* Border Radius */
---border-radius-xs: 4px;
---border-radius-sm: 8px;
-```
-
----
-
-**Last Updated**: 2025-02-24
-**Author**: AI Assistant
-**Status**: Ready for Implementation

docs/ui-ux-optimization/settings-modal-progress.md

@@ -1,191 +0,0 @@
-# Settings Modal Optimization Progress
-
-**Project**: Settings Modal UI/UX Optimization  
-**Status**: Phase 0 - Ready for Development  
-**Last Updated**: 2025-02-24
-
----
-
-## Phase 0: macOS Settings模式重构
-
-### Overview
-重构Settings Modal为macOS Settings模式：左侧Section导航 + 右侧单Section独占显示。移除冗余元素，优化视觉层次。
-
-### Tasks
-
-#### 1. CSS Updates ✅
-**File**: `static/css/components/modal/settings-modal.css`
-
-- [x] **Layout Styles**
-  - [x] Modal固定尺寸 800x600px
-  - [x] 左侧 sidebar 固定宽度 200px
-  - [x] 右侧 content flex: 1 自动填充
-
-- [x] **Navigation Styles**
-  - [x] `.settings-nav` 容器样式
-  - [x] `.settings-nav-item` 基础样式（更大字体，更醒目的active状态）
-  - [x] `.settings-nav-item.active` 高亮样式（accent背景）
-  - [x] `.settings-nav-item:hover` 悬停效果
-  - [x] 隐藏 "SETTINGS" label
-  - [x] 隐藏 group titles
-
-- [x] **Content Area Styles**
-  - [x] `.settings-section` 默认隐藏（仅当前显示）
-  - [x] `.settings-section.active` 显示状态
-  - [x] `.settings-section-header` 标题样式（20px + accent下划线）
-  - [x] 添加 fadeIn 动画效果
-
-- [x] **Cleanup**
-  - [x] 移除折叠相关样式
-  - [x] 移除 `.settings-section-toggle` 按钮样式
-  - [x] 移除展开/折叠动画样式
-
-**Status**: ✅ Completed
-
----
-
-#### 2. HTML Structure Update ✅
-**File**: `templates/components/modals/settings_modal.html`
-
-- [x] **Navigation Items**
-  - [x] General (通用)
-  - [x] Interface (界面)
-  - [x] Download (下载)
-  - [x] Advanced (高级)
-  - [x] 移除 "SETTINGS" label
-  - [x] 移除 group titles
-
-- [x] **Content Sections**
-  - [x] 重组为4个Section (general/interface/download/advanced)
-  - [x] 每个section添加 `data-section` 属性
-  - [x] 添加Section标题（带accent下划线）
-  - [x] 移除所有折叠按钮（chevron图标）
-  - [x] 平铺显示所有设置项
-
-**Status**: ✅ Completed
-
----
-
-#### 3. JavaScript Logic Update ✅
-**File**: `static/js/managers/SettingsManager.js`
-
-- [x] **Navigation Logic**
-  - [x] `initializeNavigation()` 改为Section切换模式
-  - [x] 点击导航项显示对应Section
-  - [x] 更新导航高亮状态
-  - [x] 默认显示第一个Section
-
-- [x] **Remove Legacy Code**
-  - [x] 移除 `initializeSectionCollapse()` 方法
-  - [x] 移除滚动监听相关代码
-  - [x] 移除 `localStorage` 折叠状态存储
-
-- [x] **Search Function**
-  - [x] 更新搜索功能以适配新显示模式
-  - [x] 搜索时自动切换到匹配的Section
-  - [x] 高亮匹配的关键词
-
-**Status**: ✅ Completed
-
----
-
-### Testing Checklist
-
-#### Visual Testing
-- [ ] 两栏布局正确显示
-- [ ] 左侧导航4个Section正确显示
-- [ ] 点击导航切换右侧内容
-- [ ] 当前导航项高亮显示（accent背景）
-- [ ] Section标题有accent色下划线
-- [ ] 设置项以卡片形式分组
-- [ ] 无"SETTINGS" label
-- [ ] 无折叠/展开按钮
-
-#### Functional Testing
-- [ ] 所有设置项可正常编辑
-- [ ] 设置保存功能正常
-- [ ] 设置加载功能正常
-- [ ] 表单验证正常工作
-- [ ] 帮助提示（tooltip）正常显示
-
-#### Responsive Testing
-- [ ] 桌面端（>768px）两栏布局
-- [ ] 移动端（<768px）单栏堆叠
-- [ ] 移动端导航可正常切换
-
-#### Cross-Browser Testing
-- [ ] Chrome/Edge
-- [ ] Firefox
-- [ ] Safari（如适用）
-
----
-
-## Phase 1: 搜索功能
-
-### Tasks
-- [ ] 搜索框UI更新
-- [ ] 搜索逻辑实现
-- [ ] 实时过滤显示
-- [ ] 关键词高亮
-
-**Estimated Time**: 2-3 hours  
-**Status**: 📋 Planned
-
----
-
-## Phase 2: 操作按钮优化
-
-### Tasks
-- [ ] 底部操作栏样式
-- [ ] 固定定位（sticky）
-- [ ] Cancel/Save按钮功能
-- [ ] 可选：Reset/Export/Import
-
-**Estimated Time**: 1-2 hours  
-**Status**: 📋 Planned
-
----
-
-## Progress Summary
-
-| Phase | Progress | Status |
-|-------|----------|--------|
-| Phase 0 | 100% | ✅ Completed |
-| Phase 1 | 0% | 📋 Planned |
-| Phase 2 | 0% | 📋 Planned |
-
-**Overall Progress**: 100% (Phase 0)
-
----
-
-## Development Log
-
-### 2025-02-24
-- ✅ 创建优化提案文档（macOS Settings模式）
-- ✅ 创建进度追踪文档
-- ✅ Phase 0 开发完成
-  - ✅ CSS重构完成：新增macOS Settings样式，移除折叠相关样式
-  - ✅ HTML重构完成：重组为4个Section，移除所有折叠按钮
-  - ✅ JavaScript重构完成：实现Section切换逻辑，更新搜索功能
-
----
-
-## Notes
-
-### Design Decisions
-- 采用macOS Settings模式而非长页面滚动模式
-- 左侧仅显示4个Section，不显示具体设置项
-- 移除折叠/展开功能，简化交互
-- Section标题使用accent色下划线强调
-
-### Technical Notes
-- 优先使用现有CSS变量
-- 保持向后兼容，不破坏现有设置存储逻辑
-- 移动端响应式：小屏幕单栏堆叠
-
-### Blockers
-None
-
----
-
-**Next Action**: Start Phase 0 - CSS Updates

package-lock.json

@@ -114,6 +114,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -137,6 +138,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -1611,6 +1613,7 @@
       "integrity": "sha512-MyL55p3Ut3cXbeBEG7Hcv0mVM8pp8PBNWxRqchZnSfAiES1v1mRnMeFfaHWIPULpwsYfvO+ZmMZz5tGCnjzDUQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssstyle": "^4.0.1",
         "data-urls": "^5.0.0",

py/lora_manager.py

@@ -5,10 +5,7 @@ import logging
 from .utils.logging_config import setup_logging
 
 # Check if we're in standalone mode
-standalone_mode = (
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-)
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
 
 # Only setup logging prefix if not in standalone mode
 if not standalone_mode:
@@ -17,10 +14,7 @@ if not standalone_mode:
 from server import PromptServer # type: ignore
 
 from .config import config
-from .services.model_service_factory import (
-    ModelServiceFactory,
-    register_default_model_types,
-)
+from .services.model_service_factory import ModelServiceFactory, register_default_model_types
 from .routes.recipe_routes import RecipeRoutes
 from .routes.stats_routes import StatsRoutes
 from .routes.update_routes import UpdateRoutes
@@ -33,7 +27,6 @@ from .utils.example_images_migration import ExampleImagesMigration
 from .services.websocket_manager import ws_manager
 from .services.example_images_cleanup_service import ExampleImagesCleanupService
 from .middleware.csp_middleware import relax_csp_for_remote_media
-from .middleware.error_middleware import api_json_error
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +61,6 @@ class _SettingsProxy:
 
 settings = _SettingsProxy()
 
-
 class LoraManager:
     """Main entry point for LoRA Manager plugin"""
     
@@ -77,11 +69,6 @@ class LoraManager:
         """Initialize and register all routes using the new refactored architecture"""
         app = PromptServer.instance.app
 
-        # Register JSON error middleware for /api/* routes as the outermost
-        # middleware so it catches errors from all other middlewares.
-        if api_json_error not in app.middlewares:
-            app.middlewares.insert(0, api_json_error)
-
         if relax_csp_for_remote_media not in app.middlewares:
             # Ensure CSP relaxer executes after ComfyUI's block_external_middleware so it can
             # see and extend the restrictive header instead of being overwritten by it.
@@ -89,8 +76,7 @@ class LoraManager:
                 (
                     idx
                     for idx, middleware in enumerate(app.middlewares)
-                    if getattr(middleware, "__name__", "")
-                    == "block_external_middleware"
+                    if getattr(middleware, "__name__", "") == "block_external_middleware"
                 ),
                 None,
             )
@@ -98,9 +84,7 @@ class LoraManager:
             if block_middleware_index is None:
                 app.middlewares.append(relax_csp_for_remote_media)
             else:
-                app.middlewares.insert(
-                    block_middleware_index, relax_csp_for_remote_media
-                )
+                app.middlewares.insert(block_middleware_index, relax_csp_for_remote_media)
 
         # Increase allowed header sizes so browsers with large localhost cookie
         # jars (multiple UIs on 127.0.0.1) don't trip aiohttp's 8KB default
@@ -121,7 +105,7 @@ class LoraManager:
         app._handler_args = updated_handler_args
 
         # Configure aiohttp access logger to be less verbose
-        logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
+        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
 
         # Add specific suppression for connection reset errors
         class ConnectionResetFilter(logging.Filter):
@@ -140,23 +124,19 @@ class LoraManager:
         asyncio_logger.addFilter(ConnectionResetFilter())
 
         # Add static route for example images if the path exists in settings
-        example_images_path = settings.get("example_images_path")
+        example_images_path = settings.get('example_images_path')
         logger.info(f"Example images path: {example_images_path}")
         if example_images_path and os.path.exists(example_images_path):
-            app.router.add_static("/example_images_static", example_images_path)
-            logger.info(
-                f"Added static route for example images: /example_images_static -> {example_images_path}"
-            )
+            app.router.add_static('/example_images_static', example_images_path)
+            logger.info(f"Added static route for example images: /example_images_static -> {example_images_path}")
 
         # Add static route for locales JSON files
         if os.path.exists(config.i18n_path):
-            app.router.add_static("/locales", config.i18n_path)
-            logger.info(
-                f"Added static route for locales: /locales -> {config.i18n_path}"
-            )
+            app.router.add_static('/locales', config.i18n_path)
+            logger.info(f"Added static route for locales: /locales -> {config.i18n_path}")
 
         # Add static route for plugin assets
-        app.router.add_static("/loras_static", config.static_path)
+        app.router.add_static('/loras_static', config.static_path)
         
         # Register default model types with the factory
         register_default_model_types()
@@ -174,11 +154,9 @@ class LoraManager:
         PreviewRoutes.setup_routes(app)
         
         # Setup WebSocket routes that are shared across all model types
-        app.router.add_get("/ws/fetch-progress", ws_manager.handle_connection)
-        app.router.add_get(
-            "/ws/download-progress", ws_manager.handle_download_connection
-        )
-        app.router.add_get("/ws/init-progress", ws_manager.handle_init_connection)
+        app.router.add_get('/ws/fetch-progress', ws_manager.handle_connection)
+        app.router.add_get('/ws/download-progress', ws_manager.handle_download_connection)
+        app.router.add_get('/ws/init-progress', ws_manager.handle_init_connection)
         
         # Schedule service initialization 
         app.on_startup.append(lambda app: cls._initialize_services())
@@ -196,22 +174,12 @@ class LoraManager:
             # Register DownloadManager with ServiceRegistry
             await ServiceRegistry.get_download_manager()
 
-            # Initialize DownloadQueueService for persistent queue/history
-            await ServiceRegistry.get_download_queue_service()
-
-            await ServiceRegistry.get_backup_service()
-
             from .services.metadata_service import initialize_metadata_providers
-
             await initialize_metadata_providers()
             
             # Initialize WebSocket manager
             await ServiceRegistry.get_websocket_manager()
             
-            # Preload LLM model catalog (background task, non-blocking)
-            from .services.llm_service import LLMService
-            await LLMService.get_instance()
-
             # Initialize scanners in background
             lora_scanner = await ServiceRegistry.get_lora_scanner()
             checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
@@ -222,58 +190,39 @@ class LoraManager:
             
             # Create low-priority initialization tasks
             init_tasks = [
-                asyncio.create_task(
-                    lora_scanner.initialize_in_background(), name="lora_cache_init"
-                ),
-                asyncio.create_task(
-                    checkpoint_scanner.initialize_in_background(),
-                    name="checkpoint_cache_init",
-                ),
-                asyncio.create_task(
-                    embedding_scanner.initialize_in_background(),
-                    name="embedding_cache_init",
-                ),
-                asyncio.create_task(
-                    recipe_scanner.initialize_in_background(), name="recipe_cache_init"
-                ),
+                asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init'),
+                asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init'),
+                asyncio.create_task(embedding_scanner.initialize_in_background(), name='embedding_cache_init'),
+                asyncio.create_task(recipe_scanner.initialize_in_background(), name='recipe_cache_init')
             ]
 
             await ExampleImagesMigration.check_and_run_migrations()
             
             # Schedule post-initialization tasks to run after scanners complete
             asyncio.create_task(
-                cls._run_post_initialization_tasks(init_tasks), name="post_init_tasks"
+                cls._run_post_initialization_tasks(init_tasks), 
+                name='post_init_tasks'
             )
             
-            logger.debug(
-                "LoRA Manager: All services initialized and background tasks scheduled"
-            )
+            logger.debug("LoRA Manager: All services initialized and background tasks scheduled")
                 
         except Exception as e:
-            logger.error(
-                f"LoRA Manager: Error initializing services: {e}", exc_info=True
-            )
+            logger.error(f"LoRA Manager: Error initializing services: {e}", exc_info=True)
     
     @classmethod
     async def _run_post_initialization_tasks(cls, init_tasks):
         """Run post-initialization tasks after all scanners complete"""
         try:
-            logger.debug(
-                "LoRA Manager: Waiting for scanner initialization to complete..."
-            )
+            logger.debug("LoRA Manager: Waiting for scanner initialization to complete...")
             
             # Wait for all scanner initialization tasks to complete
             await asyncio.gather(*init_tasks, return_exceptions=True)
 
-            logger.debug(
-                "LoRA Manager: Scanner initialization completed, starting post-initialization tasks..."
-            )
+            logger.debug("LoRA Manager: Scanner initialization completed, starting post-initialization tasks...")
             
             # Run post-initialization tasks
             post_tasks = [
-                asyncio.create_task(
-                    cls._cleanup_backup_files(), name="cleanup_bak_files"
-                ),
+                asyncio.create_task(cls._cleanup_backup_files(), name='cleanup_bak_files'),
                 # Add more post-initialization tasks here as needed
                 # asyncio.create_task(cls._another_post_task(), name='another_task'),
             ]
@@ -285,20 +234,14 @@ class LoraManager:
             for i, result in enumerate(results):
                 task_name = post_tasks[i].get_name()
                 if isinstance(result, Exception):
-                    logger.error(
-                        f"Post-initialization task '{task_name}' failed: {result}"
-                    )
+                    logger.error(f"Post-initialization task '{task_name}' failed: {result}")
                 else:
-                    logger.debug(
-                        f"Post-initialization task '{task_name}' completed successfully"
-                    )
+                    logger.debug(f"Post-initialization task '{task_name}' completed successfully")
                     
             logger.debug("LoRA Manager: All post-initialization tasks completed")
             
         except Exception as e:
-            logger.error(
-                f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True
-            )
+            logger.error(f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True)
     
     @classmethod
     async def _cleanup_backup_files(cls):
@@ -309,8 +252,8 @@ class LoraManager:
             # Collect all model roots
             all_roots = set()
             all_roots.update(config.loras_roots)
-            all_roots.update(config.base_models_roots or [])
-            all_roots.update(config.embeddings_roots or [])
+            all_roots.update(config.base_models_roots) 
+            all_roots.update(config.embeddings_roots)
             
             total_deleted = 0
             total_size_freed = 0
@@ -320,17 +263,12 @@ class LoraManager:
                     continue
                     
                 try:
-                    (
-                        deleted_count,
-                        size_freed,
-                    ) = await cls._cleanup_backup_files_in_directory(root_path)
+                    deleted_count, size_freed = await cls._cleanup_backup_files_in_directory(root_path)
                     total_deleted += deleted_count
                     total_size_freed += size_freed
                     
                     if deleted_count > 0:
-                        logger.debug(
-                            f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024 * 1024):.2f} MB)"
-                        )
+                        logger.debug(f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024*1024):.2f} MB)")
                         
                 except Exception as e:
                     logger.error(f"Error cleaning up .bak files in {root_path}: {e}")
@@ -339,9 +277,7 @@ class LoraManager:
                 await asyncio.sleep(0.01)
             
             if total_deleted > 0:
-                logger.debug(
-                    f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024 * 1024):.2f} MB total"
-                )
+                logger.debug(f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024*1024):.2f} MB total")
             else:
                 logger.debug("Backup cleanup completed: no .bak files found")
 
@@ -374,9 +310,7 @@ class LoraManager:
                 with os.scandir(path) as it:
                     for entry in it:
                         try:
-                            if entry.is_file(
-                                follow_symlinks=True
-                            ) and entry.name.endswith(".bak"):
+                            if entry.is_file(follow_symlinks=True) and entry.name.endswith('.bak'):
                                 file_size = entry.stat().st_size
                                 os.remove(entry.path)
                                 deleted_count += 1
@@ -387,9 +321,7 @@ class LoraManager:
                                 cleanup_recursive(entry.path)
                                 
                         except Exception as e:
-                            logger.warning(
-                                f"Could not delete .bak file {entry.path}: {e}"
-                            )
+                            logger.warning(f"Could not delete .bak file {entry.path}: {e}")
                             
             except Exception as e:
                 logger.error(f"Error scanning directory {path} for .bak files: {e}")
@@ -407,21 +339,21 @@ class LoraManager:
             service = ExampleImagesCleanupService()
             result = await service.cleanup_example_image_folders()
 
-            if result.get("success"):
+            if result.get('success'):
                 logger.debug(
                     "Manual example images cleanup completed: moved=%s",
-                    result.get("moved_total"),
+                    result.get('moved_total'),
                 )
-            elif result.get("partial_success"):
+            elif result.get('partial_success'):
                 logger.warning(
                     "Manual example images cleanup partially succeeded: moved=%s failures=%s",
-                    result.get("moved_total"),
-                    result.get("move_failures"),
+                    result.get('moved_total'),
+                    result.get('move_failures'),
                 )
             else:
                 logger.debug(
                     "Manual example images cleanup skipped or failed: %s",
-                    result.get("error", "no changes"),
+                    result.get('error', 'no changes'),
                 )
 
             return result
@@ -429,9 +361,9 @@ class LoraManager:
         except Exception as e:  # pragma: no cover - defensive guard
             logger.error(f"Error during example images cleanup: {e}", exc_info=True)
             return {
-                "success": False,
-                "error": str(e),
-                "error_code": "unexpected_error",
+                'success': False,
+                'error': str(e),
+                'error_code': 'unexpected_error',
             }
 
     @classmethod
@@ -440,21 +372,5 @@ class LoraManager:
         try:
             logger.info("LoRA Manager: Cleaning up services")
                 
-            # Cancel any in-flight scanner initialization tasks so thread-pool
-            # workers (e.g. _initialize_cache_sync) can break out of their loops
-            # when the server shuts down (e.g. Ctrl+C on WSL).
-            for name in ("lora_scanner", "checkpoint_scanner", "embedding_scanner"):
-                scanner = ServiceRegistry.get_service_sync(name)
-                if scanner is not None and hasattr(scanner, "cancel_task"):
-                    scanner.cancel_task()
-                    logger.debug("LoRA Manager: Cancelled %s", name)
-
-            # Close shared aiohttp sessions to avoid "Unclosed client session" warnings
-            try:
-                from py.routes.handlers.hf_handlers import close_hf_api_session
-                await close_hf_api_session()
-            except Exception as exc:
-                logger.debug("Error closing HF API session: %s", exc)
-
         except Exception as e:
             logger.error(f"Error during cleanup: {e}", exc_info=True)

py/metadata_collector/__init__.py

@@ -4,10 +4,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 # Check if running in standalone mode
-standalone_mode = (
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-)
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
 
 if not standalone_mode:
     from .metadata_hook import MetadataHook
@@ -22,7 +19,7 @@ if not standalone_mode:
         
         logger.info("ComfyUI Metadata Collector initialized")
         
-    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
+    def get_metadata(prompt_id=None):
         """Helper function to get metadata from the registry"""
         registry = MetadataRegistry()
         return registry.get_metadata(prompt_id)
@@ -31,6 +28,6 @@ else:
     def init():
         logger.info("ComfyUI Metadata Collector disabled in standalone mode")
         
-    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
+    def get_metadata(prompt_id=None):
         """Dummy implementation for standalone mode"""
         return {}

py/metadata_collector/constants.py

@@ -5,10 +5,9 @@ MODELS = "models"
 PROMPTS = "prompts"
 SAMPLING = "sampling"
 LORAS = "loras"
-EMBEDDINGS = "embeddings"
 SIZE = "size"
 IMAGES = "images"
 IS_SAMPLER = "is_sampler"  # New constant to mark sampler nodes
 
 # Complete list of categories to track
-METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, EMBEDDINGS, SIZE, IMAGES]
+METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]

py/metadata_collector/metadata_hook.py

@@ -149,12 +149,9 @@ class MetadataHook:
         # Store the original _async_map_node_over_list function
         original_map_node_over_list = getattr(execution, map_node_func_name)
         
-        # Wrapped async function - signature must exactly match _async_map_node_over_list
-        async def async_map_node_over_list_with_metadata(
-            prompt_id, unique_id, obj, input_data_all, func,
-            allow_interrupt=False, execution_block_cb=None,
-            pre_execute_cb=None, v3_data=None
-        ):
+        # Wrapped async function, compatible with both stable and nightly
+        async def async_map_node_over_list_with_metadata(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None, *args, **kwargs):
+            hidden_inputs = kwargs.get('hidden_inputs', None)
             # Only collect metadata when calling the main function of nodes
             if func == obj.FUNCTION and hasattr(obj, '__class__'):
                 try:
@@ -167,10 +164,10 @@ class MetadataHook:
                 except Exception as e:
                     logger.error(f"Error collecting metadata (pre-execution): {str(e)}")
             
-            # Call original function with exact parameters
+            # Call original function with all args/kwargs
             results = await original_map_node_over_list(
                 prompt_id, unique_id, obj, input_data_all, func,
-                allow_interrupt, execution_block_cb, pre_execute_cb, v3_data=v3_data
+                allow_interrupt, execution_block_cb, pre_execute_cb, *args, **kwargs
             )
             
             if func == obj.FUNCTION and hasattr(obj, '__class__'):

py/metadata_collector/metadata_processor.py

@@ -353,100 +353,49 @@ class MetadataProcessor:
         # Check if we have stored conditioning objects for this sampler
         if sampler_id in metadata.get(PROMPTS, {}) and (
             "pos_conditioning" in metadata[PROMPTS][sampler_id] or 
-            "neg_conditioning" in metadata[PROMPTS][sampler_id]
-        ):
+            "neg_conditioning" in metadata[PROMPTS][sampler_id]):
+            
             pos_conditioning = metadata[PROMPTS][sampler_id].get("pos_conditioning")
             neg_conditioning = metadata[PROMPTS][sampler_id].get("neg_conditioning")
             
-            def extend_unique(target, values):
-                for value in values:
-                    if value and value not in target:
-                        target.append(value)
-
-            # Helper function to recursively find prompt texts for a conditioning object.
-            # Transform nodes can map one output conditioning to multiple source conditionings.
-            def find_prompt_texts_for_conditioning(
-                conditioning_obj, is_positive=True, visited=None
-            ):
+            # Helper function to recursively find prompt text for a conditioning object
+            def find_prompt_text_for_conditioning(conditioning_obj, is_positive=True):
                 if conditioning_obj is None:
-                    return []
-
-                if visited is None:
-                    visited = set()
-
-                conditioning_id = id(conditioning_obj)
-                if conditioning_id in visited:
-                    return []
-                visited.add(conditioning_id)
-
-                prompt_texts = []
+                    return ""
                     
                 # Try to match conditioning objects with those stored by extractors
                 for prompt_node_id, prompt_data in metadata[PROMPTS].items():
-                    if not isinstance(prompt_data, dict):
-                        continue
+                    # For nodes with single conditioning output
+                    if "conditioning" in prompt_data:
+                        if id(prompt_data["conditioning"]) == id(conditioning_obj):
+                            return prompt_data.get("text", "")
                     
-                    # For CLIP text nodes with a single conditioning output.
-                    if id(prompt_data.get("conditioning")) == conditioning_id:
-                        text = prompt_data.get("text", "")
-                        if text:
-                            extend_unique(prompt_texts, [text])
-
-                    # Generic provenance for passthrough/transform/combine nodes.
-                    for source in prompt_data.get("conditioning_sources", []):
-                        if id(source.get("output")) != conditioning_id:
-                            continue
-                        for input_conditioning in source.get("inputs", []):
-                            extend_unique(
-                                prompt_texts,
-                                find_prompt_texts_for_conditioning(
-                                    input_conditioning, is_positive, visited
-                                ),
-                            )
-
-                    # For nodes with separate pos_conditioning and neg_conditioning outputs
-                    # like TSC_EfficientLoader and existing ControlNet-style metadata.
-                    if (
-                        is_positive
-                        and id(prompt_data.get("positive_encoded")) == conditioning_id
-                    ):
-                        if prompt_data.get("positive_text"):
-                            extend_unique(prompt_texts, [prompt_data["positive_text"]])
+                    # For nodes with separate pos_conditioning and neg_conditioning outputs (like TSC_EfficientLoader)
+                    if is_positive and "positive_encoded" in prompt_data:
+                        if id(prompt_data["positive_encoded"]) == id(conditioning_obj):
+                            if "positive_text" in prompt_data:
+                                return prompt_data["positive_text"]
                             else:
-                            extend_unique(
-                                prompt_texts,
-                                find_prompt_texts_for_conditioning(
-                                    prompt_data.get("orig_pos_cond"),
-                                    is_positive=True,
-                                    visited=visited,
-                                ),
-                            )
+                                orig_conditioning = prompt_data.get("orig_pos_cond", None)
+                                if orig_conditioning is not None:
+                                    # Recursively find the prompt text for the original conditioning
+                                    return find_prompt_text_for_conditioning(orig_conditioning, is_positive=True)
                     
-                    if (
-                        not is_positive
-                        and id(prompt_data.get("negative_encoded")) == conditioning_id
-                    ):
-                        if prompt_data.get("negative_text"):
-                            extend_unique(prompt_texts, [prompt_data["negative_text"]])
+                    if not is_positive and "negative_encoded" in prompt_data:
+                        if id(prompt_data["negative_encoded"]) == id(conditioning_obj):
+                            if "negative_text" in prompt_data:
+                                return prompt_data["negative_text"]
                             else:
-                            extend_unique(
-                                prompt_texts,
-                                find_prompt_texts_for_conditioning(
-                                    prompt_data.get("orig_neg_cond"),
-                                    is_positive=False,
-                                    visited=visited,
-                                ),
-                            )
+                                orig_conditioning = prompt_data.get("orig_neg_cond", None)
+                                if orig_conditioning is not None:
+                                    # Recursively find the prompt text for the original conditioning
+                                    return find_prompt_text_for_conditioning(orig_conditioning, is_positive=False)
                 
-                return prompt_texts
+                return ""
             
             # Find prompt texts using the helper function
-            result["prompt"] = ", ".join(
-                find_prompt_texts_for_conditioning(pos_conditioning, is_positive=True)
-            )
-            result["negative_prompt"] = ", ".join(
-                find_prompt_texts_for_conditioning(neg_conditioning, is_positive=False)
-            )
+            result["prompt"] = find_prompt_text_for_conditioning(pos_conditioning, is_positive=True)
+            result["negative_prompt"] = find_prompt_text_for_conditioning(neg_conditioning, is_positive=False)
             
         return result
     
@@ -560,14 +509,8 @@ class MetadataProcessor:
         
         params["loras"] = " ".join(lora_parts)
         
-        # Extract clip_skip from any SAMPLING node that provides it
-        for sampler_info in metadata.get(SAMPLING, {}).values():
-            clip_skip = sampler_info.get("parameters", {}).get("clip_skip")
-            if clip_skip is not None:
-                params["clip_skip"] = clip_skip
-                break
-        if params["clip_skip"] is None:
-            params["clip_skip"] = "1"
+        # Set default clip_skip value
+        params["clip_skip"] = "1"  # Common default
         
         return params
     
@@ -652,15 +595,6 @@ class MetadataProcessor:
                     if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
                         params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
                 else:
-                    # Generic guider nodes often expose separate positive/negative inputs.
-                    positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "positive", max_depth=10)
-                    if not positive_node_id:
                     positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
                     if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
                         params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
-
-                    negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "negative", max_depth=10)
-                    if not negative_node_id:
-                        negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
-                    if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
-                        params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")

py/metadata_collector/metadata_registry.py

@@ -1,12 +1,10 @@
 import time
-from nodes import NODE_CLASS_MAPPINGS  # type: ignore
+from nodes import NODE_CLASS_MAPPINGS
 from .node_extractors import NODE_EXTRACTORS, GenericNodeExtractor
 from .constants import METADATA_CATEGORIES, IMAGES
 
-
 class MetadataRegistry:
     """A singleton registry to store and retrieve workflow metadata"""
-
     _instance = None
     
     def __new__(cls):
@@ -39,13 +37,11 @@ class MetadataRegistry:
         # Sort all prompt_ids by timestamp
         sorted_prompts = sorted(
             self.prompt_metadata.keys(),
-            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0),
+            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0)
         )
         
         # Remove oldest records
-        prompts_to_remove = sorted_prompts[
-            : len(sorted_prompts) - self.max_prompt_history
-        ]
+        prompts_to_remove = sorted_prompts[:len(sorted_prompts) - self.max_prompt_history]
         for pid in prompts_to_remove:
             del self.prompt_metadata[pid]
     
@@ -57,13 +53,11 @@ class MetadataRegistry:
             category: {} for category in METADATA_CATEGORIES
         }
         # Add additional metadata fields
-        self.prompt_metadata[prompt_id].update(
-            {
+        self.prompt_metadata[prompt_id].update({
             "execution_order": [],
             "current_prompt": None,  # Will store the prompt object
-                "timestamp": time.time(),
-            }
-        )
+            "timestamp": time.time()
+        })
         
         # Clean up old prompt data
         self._clean_old_prompts()
@@ -131,9 +125,7 @@ class MetadataRegistry:
                     for category in self.metadata_categories:
                         if category in cached_data and node_id in cached_data[category]:
                             if node_id not in metadata[category]:
-                                metadata[category][node_id] = cached_data[category][
-                                    node_id
-                                ]
+                                metadata[category][node_id] = cached_data[category][node_id]
     
     def record_node_execution(self, node_id, class_type, inputs, outputs):
         """Record information about a node's execution"""
@@ -143,9 +135,7 @@ class MetadataRegistry:
         # Add to execution order and mark as executed
         if node_id not in self.executed_nodes:
             self.executed_nodes.add(node_id)
-            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(
-                node_id
-            )
+            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(node_id)
         
         # Process inputs to simplify working with them
         processed_inputs = {}
@@ -162,7 +152,7 @@ class MetadataRegistry:
             node_id, 
             processed_inputs, 
             outputs, 
-            self.prompt_metadata[self.current_prompt_id],
+            self.prompt_metadata[self.current_prompt_id]
         )
         
         # Cache this node's metadata
@@ -178,9 +168,11 @@ class MetadataRegistry:
             
         # Use the same extractor to update with outputs
         extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
-        if hasattr(extractor, "update"):
+        if hasattr(extractor, 'update'):
             extractor.update(
-                node_id, processed_outputs, self.prompt_metadata[self.current_prompt_id]
+                node_id, 
+                processed_outputs, 
+                self.prompt_metadata[self.current_prompt_id]
             )
             
         # Update the cached metadata for this node
@@ -222,7 +214,7 @@ class MetadataRegistry:
         # Find cache keys that are no longer needed
         keys_to_remove = []
         for cache_key in self.node_cache:
-            node_id = cache_key.split(":")[0]
+            node_id = cache_key.split(':')[0]
             if node_id not in active_node_ids:
                 keys_to_remove.append(cache_key)
         
@@ -278,10 +270,7 @@ class MetadataRegistry:
                             if IMAGES in cached_data and node_id in cached_data[IMAGES]:
                                 image_data = cached_data[IMAGES][node_id]["image"]
                                 # Handle different image formats
-                                if (
-                                    isinstance(image_data, (list, tuple))
-                                    and len(image_data) > 0
-                                ):
+                                if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
                                     return image_data[0]
                                 return image_data
         

py/metadata_collector/node_extractors.py

@@ -1,6 +1,4 @@
-import json
 import os
-import re
 
 from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES, IS_SAMPLER
 
@@ -144,118 +142,6 @@ class TSCCheckpointLoaderExtractor(NodeMetadataExtractor):
                 metadata[PROMPTS][node_id]["positive_encoded"] = positive_conditioning
                 metadata[PROMPTS][node_id]["negative_encoded"] = negative_conditioning
 
-
-class EasyComfyLoaderExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        if "ckpt_name" in inputs:
-            _store_checkpoint_metadata(metadata, node_id, inputs["ckpt_name"])
-
-        # Only extract from optional_lora_stack — skip the single lora_name to
-        # avoid double-counting LoRAs that come through the LORA_STACK path.
-        active_loras = []
-        optional_lora_stack = inputs.get("optional_lora_stack")
-        if optional_lora_stack is not None and isinstance(optional_lora_stack, (list, tuple)):
-            for item in optional_lora_stack:
-                if isinstance(item, (list, tuple)) and len(item) >= 2:
-                    lora_path = item[0]
-                    model_strength = item[1]
-                    lora_name = os.path.splitext(os.path.basename(lora_path))[0]
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": model_strength
-                    })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            if node_id not in metadata[PROMPTS]:
-                metadata[PROMPTS][node_id] = {"node_id": node_id}
-            metadata[PROMPTS][node_id]["positive_text"] = positive_text
-            metadata[PROMPTS][node_id]["negative_text"] = negative_text
-
-        if "clip_skip" in inputs:
-            clip_skip = inputs["clip_skip"]
-            if node_id not in metadata[SAMPLING]:
-                metadata[SAMPLING][node_id] = {"parameters": {}, "node_id": node_id}
-            metadata[SAMPLING][node_id]["parameters"]["clip_skip"] = clip_skip
-
-        width = inputs.get("empty_latent_width")
-        height = inputs.get("empty_latent_height")
-        if width is not None and height is not None:
-            if SIZE not in metadata:
-                metadata[SIZE] = {}
-            metadata[SIZE][node_id] = {
-                "width": int(width),
-                "height": int(height),
-                "node_id": node_id
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        # outputs: [(pipe_dict, model, vae), ...]
-        if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-            return
-        first_output = outputs[0]
-        if not isinstance(first_output, tuple) or len(first_output) < 1:
-            return
-        pipe = first_output[0]
-        if not isinstance(pipe, dict):
-            return
-
-        positive_conditioning = pipe.get("positive")
-        negative_conditioning = pipe.get("negative")
-
-        if positive_conditioning is not None or negative_conditioning is not None:
-            if node_id not in metadata[PROMPTS]:
-                metadata[PROMPTS][node_id] = {"node_id": node_id}
-            if positive_conditioning is not None:
-                metadata[PROMPTS][node_id]["positive_encoded"] = positive_conditioning
-            if negative_conditioning is not None:
-                metadata[PROMPTS][node_id]["negative_encoded"] = negative_conditioning
-
-
-class EasyPreSamplingExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        sampling_params = {}
-        for key in ("steps", "cfg", "sampler_name", "scheduler", "denoise", "seed"):
-            if key in inputs:
-                sampling_params[key] = inputs[key]
-
-        metadata[SAMPLING][node_id] = {
-            "parameters": sampling_params,
-            "node_id": node_id,
-            IS_SAMPLER: True
-        }
-
-
-class EasySeedExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs or "seed" not in inputs:
-            return
-
-        metadata[SAMPLING][node_id] = {
-            "parameters": {"seed": inputs["seed"]},
-            "node_id": node_id,
-            IS_SAMPLER: False
-        }
-
-
 class CLIPTextEncodeExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -275,251 +161,6 @@ class CLIPTextEncodeExtractor(NodeMetadataExtractor):
                 conditioning = outputs[0][0]
                 metadata[PROMPTS][node_id]["conditioning"] = conditioning
 
-
-class MyOriginalWaifuTextExtractor(NodeMetadataExtractor):
-    """Extractor for ComfyUI-MyOriginalWaifu TextProvider nodes."""
-
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            metadata[PROMPTS][node_id] = {
-                "positive_text": positive_text,
-                "negative_text": negative_text,
-                "node_id": node_id,
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 2:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["positive_text"] = output_tuple[0]
-        prompt_metadata["negative_text"] = output_tuple[1]
-
-
-class MyOriginalWaifuClipExtractor(NodeMetadataExtractor):
-    """Extractor for ComfyUI-MyOriginalWaifu ClipProvider nodes."""
-
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        positive_text = inputs.get("positive", "")
-        negative_text = inputs.get("negative", "")
-
-        if positive_text or negative_text:
-            metadata[PROMPTS][node_id] = {
-                "positive_text": positive_text,
-                "negative_text": negative_text,
-                "node_id": node_id,
-            }
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 2:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["positive_encoded"] = output_tuple[0]
-        prompt_metadata["negative_encoded"] = output_tuple[1]
-
-
-def _ensure_prompt_metadata(metadata, node_id):
-    if node_id not in metadata[PROMPTS]:
-        metadata[PROMPTS][node_id] = {"node_id": node_id}
-    return metadata[PROMPTS][node_id]
-
-
-def _first_output_tuple(outputs):
-    if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-        return None
-    first_output = outputs[0]
-    if isinstance(first_output, tuple):
-        return first_output
-    return None
-
-
-def _record_conditioning_source(
-    metadata, node_id, output_conditioning, input_conditionings
-):
-    if output_conditioning is None:
-        return
-
-    sources = [
-        conditioning for conditioning in input_conditionings if conditioning is not None
-    ]
-    if not sources:
-        return
-
-    prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-    prompt_metadata.setdefault("conditioning_sources", []).append(
-        {
-            "output": output_conditioning,
-            "inputs": sources,
-        }
-    )
-
-
-def _get_variable_name(inputs):
-    for key in ("key", "name", "variable_name", "tag", "text"):
-        value = inputs.get(key)
-        if isinstance(value, str) and value:
-            return value
-    return None
-
-
-def _get_node_variable_name(metadata, node_id, inputs):
-    variable_name = _get_variable_name(inputs)
-    if variable_name:
-        return variable_name
-
-    prompt = metadata.get("current_prompt")
-    original_prompt = getattr(prompt, "original_prompt", None)
-    if not original_prompt or node_id not in original_prompt:
-        return None
-
-    node_data = original_prompt[node_id]
-    variable_name = _get_variable_name(node_data.get("inputs", {}))
-    if variable_name:
-        return variable_name
-
-    widgets_values = node_data.get("widgets_values", [])
-    if widgets_values and isinstance(widgets_values[0], str):
-        return widgets_values[0]
-
-    return None
-
-
-class ControlNetApplyAdvancedExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        if inputs.get("positive") is not None:
-            prompt_metadata["orig_pos_cond"] = inputs["positive"]
-        if inputs.get("negative") is not None:
-            prompt_metadata["orig_neg_cond"] = inputs["negative"]
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        positive_input = prompt_metadata.get("orig_pos_cond")
-        negative_input = prompt_metadata.get("orig_neg_cond")
-
-        if len(output_tuple) >= 1:
-            prompt_metadata["positive_encoded"] = output_tuple[0]
-            _record_conditioning_source(
-                metadata, node_id, output_tuple[0], [positive_input]
-            )
-        if len(output_tuple) >= 2:
-            prompt_metadata["negative_encoded"] = output_tuple[1]
-            _record_conditioning_source(
-                metadata, node_id, output_tuple[1], [negative_input]
-            )
-
-
-class ConditioningCombineExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        input_conditionings = []
-        for input_name in inputs:
-            if (
-                input_name.startswith("conditioning")
-                and inputs[input_name] is not None
-            ):
-                input_conditionings.append(inputs[input_name])
-
-        if input_conditionings:
-            prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-            prompt_metadata["orig_conditionings"] = input_conditionings
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 1:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        output_conditioning = output_tuple[0]
-        prompt_metadata["conditioning"] = output_conditioning
-        _record_conditioning_source(
-            metadata,
-            node_id,
-            output_conditioning,
-            prompt_metadata.get("orig_conditionings", []),
-        )
-
-
-class SetNodeExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        variable_name = _get_node_variable_name(metadata, node_id, inputs)
-        conditioning = inputs.get("CONDITIONING")
-        if conditioning is None:
-            conditioning = inputs.get("conditioning")
-        if conditioning is None:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        prompt_metadata["conditioning"] = conditioning
-        if variable_name:
-            prompt_metadata["variable_name"] = variable_name
-            metadata[PROMPTS].setdefault("__conditioning_variables__", {})[
-                variable_name
-            ] = conditioning
-
-
-class GetNodeExtractor(NodeMetadataExtractor):
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        variable_name = _get_node_variable_name(metadata, node_id, inputs or {})
-        if variable_name:
-            prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-            prompt_metadata["variable_name"] = variable_name
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        output_tuple = _first_output_tuple(outputs)
-        if not output_tuple or len(output_tuple) < 1:
-            return
-
-        prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
-        output_conditioning = output_tuple[0]
-        prompt_metadata["conditioning"] = output_conditioning
-
-        variable_name = prompt_metadata.get("variable_name")
-        if not variable_name:
-            return
-
-        input_conditioning = metadata[PROMPTS].get("__conditioning_variables__", {}).get(
-            variable_name
-        )
-        _record_conditioning_source(
-            metadata, node_id, output_conditioning, [input_conditioning]
-        )
-
 # Base Sampler Extractor to reduce code redundancy
 class BaseSamplerExtractor(NodeMetadataExtractor):
     """Base extractor for sampler nodes with common functionality"""
@@ -786,75 +427,6 @@ class ImageSizeExtractor(NodeMetadataExtractor):
             "node_id": node_id
         }
 
-class RgthreePowerLoraLoaderExtractor(NodeMetadataExtractor):
-    """Extract LoRA metadata from rgthree Power Lora Loader.
-
-    The node passes LoRAs as dynamic kwargs: LORA_1, LORA_2, ... each containing
-    {'on': bool, 'lora': filename, 'strength': float, 'strengthTwo': float}.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        active_loras = []
-        for key, value in inputs.items():
-            if not key.upper().startswith('LORA_'):
-                continue
-            if not isinstance(value, dict):
-                continue
-            if not value.get('on') or not value.get('lora'):
-                continue
-            lora_name = os.path.splitext(os.path.basename(value['lora']))[0]
-            active_loras.append({
-                "name": lora_name,
-                "strength": round(float(value.get('strength', 1.0)), 2)
-            })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-
-class TensorRTLoaderExtractor(NodeMetadataExtractor):
-    """Extract checkpoint metadata from TensorRT Loader.
-
-    extract() parses the engine filename from 'unet_name' as a best-effort
-    fallback (strips profile suffix after '_$' and counter suffix).
-
-    update() checks if the output MODEL has attachments["source_model"]
-    set by the node (NubeBuster fork) and overrides with the real name.
-    Vanilla TRT doesn't set this — the filename parse stands.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs or "unet_name" not in inputs:
-            return
-        unet_name = inputs.get("unet_name")
-        # Strip path and extension, then drop the $_profile suffix
-        model_name = os.path.splitext(os.path.basename(unet_name))[0]
-        if "_$" in model_name:
-            model_name = model_name[:model_name.index("_$")]
-        # Strip counter suffix (e.g. _00001_) left by ComfyUI's save path
-        model_name = re.sub(r'_\d+_?$', '', model_name)
-        _store_checkpoint_metadata(metadata, node_id, model_name)
-
-    @staticmethod
-    def update(node_id, outputs, metadata):
-        if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
-            return
-        first_output = outputs[0]
-        if not isinstance(first_output, tuple) or len(first_output) < 1:
-            return
-        model = first_output[0]
-        # NubeBuster fork sets attachments["source_model"] on the ModelPatcher
-        source_model = getattr(model, 'attachments', {}).get("source_model")
-        if source_model:
-            _store_checkpoint_metadata(metadata, node_id, source_model)
-
-
 class LoraLoaderManagerExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -901,55 +473,6 @@ class LoraLoaderManagerExtractor(NodeMetadataExtractor):
                 "node_id": node_id
             }
 
-class LoraTextLoaderManagerExtractor(NodeMetadataExtractor):
-    """Extract LoRA metadata from LoraTextLoaderLM (LoRA Text Loader).
-
-    The node accepts a `lora_syntax` STRING containing <lora:name:strength> tags
-    (same format as the ComfyUI prompt), plus an optional `lora_stack`.
-    This extractor parses the syntax string using the same regex as the node.
-    """
-    @staticmethod
-    def extract(node_id, inputs, outputs, metadata):
-        if not inputs:
-            return
-
-        active_loras = []
-
-        # Process lora_stack if available (optional input)
-        if "lora_stack" in inputs:
-            lora_stack = inputs.get("lora_stack", [])
-            for item in lora_stack:
-                # lora_stack entries are (path, model_strength, clip_strength) tuples
-                if isinstance(item, (list, tuple)) and len(item) >= 2:
-                    lora_path = item[0]
-                    model_strength = item[1]
-                    lora_name = os.path.splitext(os.path.basename(lora_path))[0]
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": round(float(model_strength), 2)
-                    })
-
-        # Process lora_syntax string input
-        if "lora_syntax" in inputs:
-            lora_syntax = inputs.get("lora_syntax", "")
-            if lora_syntax and isinstance(lora_syntax, str):
-                pattern = r"<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>"
-                matches = re.findall(pattern, lora_syntax, re.IGNORECASE)
-                for match in matches:
-                    lora_name = match[0]
-                    model_strength = float(match[1])
-                    active_loras.append({
-                        "name": lora_name,
-                        "strength": round(model_strength, 2)
-                    })
-
-        if active_loras:
-            metadata[LORAS][node_id] = {
-                "lora_list": active_loras,
-                "node_id": node_id
-            }
-
-
 class FluxGuidanceExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -1054,6 +577,8 @@ class SamplerCustomAdvancedExtractor(BaseSamplerExtractor):
         # Extract latent dimensions
         BaseSamplerExtractor.extract_latent_dimensions(node_id, inputs, metadata)
 
+import json
+
 class CLIPTextEncodeFluxExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -1174,12 +699,9 @@ NODE_EXTRACTORS = {
     "KSamplerSelect": KSamplerSelectExtractor,  # Add KSamplerSelect
     "BasicScheduler": BasicSchedulerExtractor,  # Add BasicScheduler
     "AlignYourStepsScheduler": BasicSchedulerExtractor,  # Add AlignYourStepsScheduler
-    # ComfyUI-Easy-Use pre-sampling / seed
-    "samplerSettings": EasyPreSamplingExtractor,  # easy preSampling
-    "easySeed": EasySeedExtractor,  # easy seed
     # Loaders
     "CheckpointLoaderSimple": CheckpointLoaderExtractor,
-    "comfyLoader": EasyComfyLoaderExtractor,  # ComfyUI-Easy-Use easy comfyLoader
+    "comfyLoader": CheckpointLoaderExtractor,  # easy comfyLoader
     "CheckpointLoaderSimpleWithImages": CheckpointLoaderExtractor,  # CheckpointLoader|pysssss
     "TSC_EfficientLoader": TSCCheckpointLoaderExtractor,  # Efficient Nodes
     "NunchakuFluxDiTLoader": NunchakuFluxDiTLoaderExtractor,  # ComfyUI-Nunchaku
@@ -1189,18 +711,12 @@ NODE_EXTRACTORS = {
     "GGUFLoaderKJ": KJNodesModelLoaderExtractor,  # KJNodes
     "DiffusionModelLoaderKJ": KJNodesModelLoaderExtractor,  # KJNodes
     "CheckpointLoaderKJ": CheckpointLoaderExtractor,  # KJNodes
-    "CheckpointLoaderLM": CheckpointLoaderExtractor,  # LoRA Manager
     "UNETLoader": UNETLoaderExtractor,          # Updated to use dedicated extractor
     "UnetLoaderGGUF": UNETLoaderExtractor,  # Updated to use dedicated extractor
-    "UNETLoaderLM": UNETLoaderExtractor,  # LoRA Manager
     "LoraLoader": LoraLoaderExtractor,
     "LoraLoaderLM": LoraLoaderManagerExtractor,
-    "LoraTextLoaderLM": LoraTextLoaderManagerExtractor,
-    "RgthreePowerLoraLoader": RgthreePowerLoraLoaderExtractor,
-    "TensorRTLoader": TensorRTLoaderExtractor,
     # Conditioning
     "CLIPTextEncode": CLIPTextEncodeExtractor,
-    "CLIPTextEncodeAttentionBias": CLIPTextEncodeExtractor,  # From https://github.com/silveroxides/ComfyUI_PromptAttention
     "PromptLM": CLIPTextEncodeExtractor,
     "CLIPTextEncodeFlux": CLIPTextEncodeFluxExtractor,  # Add CLIPTextEncodeFlux
     "WAS_Text_to_Conditioning": CLIPTextEncodeExtractor,
@@ -1208,12 +724,6 @@ NODE_EXTRACTORS = {
     "smZ_CLIPTextEncode": CLIPTextEncodeExtractor,  # From https://github.com/shiimizu/ComfyUI_smZNodes
     "CR_ApplyControlNetStack": CR_ApplyControlNetStackExtractor,  # Add CR_ApplyControlNetStack
     "PCTextEncode": CLIPTextEncodeExtractor,  # From https://github.com/asagi4/comfyui-prompt-control
-    "TextProvider": MyOriginalWaifuTextExtractor,  # ComfyUI-MyOriginalWaifu
-    "ClipProvider": MyOriginalWaifuClipExtractor,  # ComfyUI-MyOriginalWaifu
-    "ControlNetApplyAdvanced": ControlNetApplyAdvancedExtractor,
-    "ConditioningCombine": ConditioningCombineExtractor,
-    "SetNode": SetNodeExtractor,
-    "GetNode": GetNodeExtractor,
     # Latent
     "EmptyLatentImage": ImageSizeExtractor,
     # Flux

py/metadata_ops/__init__.py

@@ -1,233 +0,0 @@
-"""Metadata operations — thin in-process wrappers around LoRA Manager internal services.
-
-All functions are simple Python async functions that delegate to the
-appropriate internal service.  They use **relative imports** within the
-``py`` package, so ``sys.modules`` caching works normally and there is no
-risk of double import or circular dependencies.
-
-Usage (in-process, primary)::
-
-    from py.metadata_ops import list_base_models, read_metadata
-
-    models = await list_base_models()
-    meta   = await read_metadata("/path/to/model.safetensors")
-
-Usage (subprocess, debugging / external)::
-
-    python -m py.metadata_ops base-models list
-    python -m py.metadata_ops metadata read /path/to/model.safetensors
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-SCANNER_TYPE_MAP: dict[str, str] = {
-    "get_lora_scanner": "lora",
-    "get_checkpoint_scanner": "checkpoint",
-    "get_embedding_scanner": "embedding",
-}
-
-SCANNER_GETTER_NAMES = tuple(SCANNER_TYPE_MAP.keys())
-
-
-async def _find_model_entry(
-    model_path: str,
-) -> tuple[object, object, str | None] | tuple[None, None, None]:
-    """Iterate all scanners and return the first (scanner, entry, getter_name)
-    that owns *model_path*.  Returns ``(None, None, None)`` when no scanner
-    claims it.
-    """
-    from ..services.service_registry import ServiceRegistry
-
-    normalized = os.path.normpath(model_path)
-    for getter_name in SCANNER_GETTER_NAMES:
-        getter = getattr(ServiceRegistry, getter_name, None)
-        if getter is None:
-            continue
-        try:
-            scanner = await getter()
-            if scanner is None:
-                continue
-            cache = await scanner.get_cached_data()
-            for entry in cache.raw_data:
-                if os.path.normpath(entry.get("file_path", "")) == normalized:
-                    return scanner, entry, getter_name
-        except Exception as exc:
-            logger.debug(
-                "Scanner %s check failed for %s: %s",
-                getter_name, model_path, exc,
-            )
-    return None, None, None
-
-
-async def _find_scanner_for_model(
-    model_path: str,
-) -> tuple[object, object] | tuple[None, None]:
-    """Find the (scanner, cache_entry) responsible for *model_path*."""
-    scanner, entry, _ = await _find_model_entry(model_path)
-    return scanner, entry
-
-
-async def identify_model_type(model_path: str) -> str:
-    """Determine the model type (``\"lora\"``, ``\"checkpoint\"``, or
-    ``\"embedding\"``) for *model_path*.
-
-    Falls back to ``\"lora\"`` when unknown.
-    """
-    _, _, getter_name = await _find_model_entry(model_path)
-    return SCANNER_TYPE_MAP[getter_name] if getter_name else "lora"
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-
-async def list_base_models(limit: int = 0) -> List[str]:
-    """Return all valid CivitAI base model names.
-
-    Uses ``CivitaiBaseModelService.get_base_models()`` which merges a
-    hardcoded list (``SUPPORTED_DOWNLOAD_SKIP_BASE_MODELS``) with remote
-    models fetched from the CivitAI API.  Never empty — the hardcoded
-    fallback always provides a complete set.
-
-    The result is sorted alphabetically.  Pass *limit* = 0 for all models.
-    """
-    from ..services.civitai_base_model_service import (
-        CivitaiBaseModelService,
-    )
-
-    try:
-        service = await CivitaiBaseModelService.get_instance()
-        response = await service.get_base_models()
-        names: List[str] = response.get("models", [])
-    except Exception as exc:
-        logger.warning("list_base_models failed: %s", exc)
-        names = []
-    if limit > 0:
-        return names[:limit]
-    return names
-
-
-async def read_metadata(model_path: str) -> Dict[str, Any]:
-    """Load the full metadata payload for *model_path* from disk.
-
-    Returns an empty dict when the metadata file does not exist or cannot
-    be parsed — never raises.
-    """
-    from ..utils.metadata_manager import MetadataManager
-
-    try:
-        return await MetadataManager.load_metadata_payload(model_path) or {}
-    except Exception as exc:
-        logger.warning("read_metadata failed for %s: %s", model_path, exc)
-        return {}
-
-
-async def apply_metadata_updates(
-    model_path: str,
-    updates: Dict[str, Any],
-) -> List[str]:
-    """Merge *updates* into the model's on-disk metadata and persist.
-
-    Returns the list of field names that actually changed.
-    """
-    from ..utils.metadata_manager import MetadataManager
-
-    metadata = await read_metadata(model_path)
-    updated_fields: List[str] = []
-    for key, value in updates.items():
-        old = metadata.get(key)
-        if old != value:
-            metadata[key] = value
-            updated_fields.append(key)
-    if updated_fields:
-        await MetadataManager.save_metadata(model_path, metadata)
-    return updated_fields
-
-
-async def download_preview(
-    model_path: str,
-    url: str,
-    *,
-    target_width: int = 480,
-    quality: int = 85,
-) -> str | None:
-    """Download a preview image from *url*, optimise to .webp, and save it.
-
-    The output file is placed alongside the model file with a ``.webp``
-    extension.  Returns the local file path on success, ``None`` on failure.
-    """
-    from ..services.downloader import get_downloader
-    from ..utils.exif_utils import ExifUtils
-
-    if not url or not url.strip():
-        return None
-
-    base_name = os.path.splitext(os.path.basename(model_path))[0]
-    preview_dir = os.path.dirname(model_path)
-    output_path = os.path.join(preview_dir, base_name + ".webp")
-
-    downloader = await get_downloader()
-
-    # Try in-memory download + optimise first
-    success, content, _headers = await downloader.download_to_memory(
-        url, use_auth=False,
-    )
-    if success and content:
-        try:
-            optimized_data, _ = ExifUtils.optimize_image(
-                image_data=content,
-                target_width=target_width,
-                format="webp",
-                quality=quality,
-                preserve_metadata=False,
-            )
-            with open(output_path, "wb") as f:
-                f.write(optimized_data)
-            return output_path
-        except Exception as exc:
-            logger.warning("Preview optimisation failed, saving raw: %s", exc)
-            # Fall through to raw save
-
-    # Fallback: download directly to file
-    try:
-        ok, _ = await downloader.download_file(url, output_path, use_auth=False)
-        if ok:
-            return output_path
-    except Exception as exc:
-        logger.warning("Preview fallback download failed for %s: %s", model_path, exc)
-
-    return None
-
-
-async def refresh_cache(model_path: str) -> bool:
-    """Invalidate and reload the scanner cache entry for *model_path*.
-
-    Returns ``True`` when the model was found and the cache was refreshed.
-    """
-    scanner, entry = await _find_scanner_for_model(model_path)
-    if scanner is None:
-        logger.warning("refresh_cache: no scanner found for %s", model_path)
-        return False
-    try:
-        metadata = await read_metadata(model_path)
-        if not metadata:
-            logger.warning("refresh_cache: no metadata for %s", model_path)
-            return False
-        await scanner.update_single_model_cache(model_path, model_path, metadata)
-        return True
-    except Exception as exc:
-        logger.warning("refresh_cache failed for %s: %s", model_path, exc)
-        return False

py/metadata_ops/__main__.py

@@ -1,113 +0,0 @@
-"""Subprocess entry point for ``metadata_ops`` (debugging / external use).
-
-Usage::
-
-    python -m py.metadata_ops base-models list [--limit N]
-    python -m py.metadata_ops metadata read <path>
-    python -m py.metadata_ops metadata update <path> --json '{...}'
-    python -m py.metadata_ops preview download <path> --url <url>
-    python -m py.metadata_ops cache refresh <path>
-"""
-
-from __future__ import annotations
-
-import argparse
-import asyncio
-import json
-import sys
-from typing import Any, Dict, List
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="lmcli", description="LoRA Manager Agent CLI")
-    sub = parser.add_subparsers(dest="command", required=True)
-
-    # base-models list
-    base_models = sub.add_parser("base-models", aliases=["bm"])
-    base_models_cmds = base_models.add_subparsers(dest="subcommand", required=True)
-    base_models_list = base_models_cmds.add_parser("list")
-    base_models_list.add_argument(
-        "--limit", type=int, default=0, help="Max number of models (0 = all)"
-    )
-
-    # metadata read
-    meta = sub.add_parser("metadata", aliases=["md"])
-    meta_cmds = meta.add_subparsers(dest="subcommand", required=True)
-    meta_read = meta_cmds.add_parser("read")
-    meta_read.add_argument("path", type=str, help="Model file path")
-
-    # metadata update
-    meta_update = meta_cmds.add_parser("update")
-    meta_update.add_argument("path", type=str, help="Model file path")
-    meta_update.add_argument(
-        "--json",
-        type=str,
-        required=True,
-        help='JSON object of fields to update, e.g. \'{"base_model": "SDXL 1.0"}\'',
-    )
-
-    # preview download
-    prev = sub.add_parser("preview", aliases=["pv"])
-    prev_cmds = prev.add_subparsers(dest="subcommand", required=True)
-    prev_dl = prev_cmds.add_parser("download")
-    prev_dl.add_argument("path", type=str, help="Model file path")
-    prev_dl.add_argument("--url", type=str, required=True, help="Preview image URL")
-
-    # cache refresh
-    cache = sub.add_parser("cache")
-    cache_cmds = cache.add_subparsers(dest="subcommand", required=True)
-    cache_refresh = cache_cmds.add_parser("refresh")
-    cache_refresh.add_argument("path", type=str, help="Model file path")
-
-    return parser
-
-
-async def _run(args: argparse.Namespace) -> Any:
-    from . import (  # lazy import so startup is fast
-        list_base_models,
-        read_metadata,
-        apply_metadata_updates,
-        download_preview,
-        refresh_cache,
-    )
-
-    cmd = args.command
-    sub = args.subcommand
-
-    if cmd in ("base-models", "bm") and sub == "list":
-        return await list_base_models(limit=args.limit)
-
-    if cmd in ("metadata", "md") and sub == "read":
-        return await read_metadata(args.path)
-
-    if cmd in ("metadata", "md") and sub == "update":
-        updates: Dict[str, Any] = json.loads(args.json)
-        return await apply_metadata_updates(args.path, updates)
-
-    if cmd in ("preview", "pv") and sub == "download":
-        return await download_preview(args.path, args.url)
-
-    if cmd == "cache" and sub == "refresh":
-        return await refresh_cache(args.path)
-
-    raise ValueError(f"Unknown command: {cmd} {sub}")
-
-
-def main() -> None:
-    parser = _build_parser()
-    args = parser.parse_args()
-
-    result = asyncio.run(_run(args))
-    # Always print as JSON so callers can parse reliably
-    if isinstance(result, list):
-        for item in result:
-            print(item)
-    elif isinstance(result, dict):
-        json.dump(result, sys.stdout, ensure_ascii=False, indent=2)
-        print()
-    else:
-        print(json.dumps(result))
-
-
-if __name__ == "__main__":
-    main()

py/middleware/cache_middleware.py

@@ -16,8 +16,6 @@ IMG_EXTENSIONS = (
     ".tif",
     ".tiff",
     ".webp",
-    ".avif",
-    ".jxl",
     ".mp4"
 )
 

py/middleware/csp_middleware.py

@@ -4,21 +4,15 @@ from typing import Awaitable, Callable, Dict, List
 
 from aiohttp import web
 
-# Use wildcard for CivitAI to support their CDN subdomains (e.g., image-b2.civitai.com)
-# Security note: This is acceptable because:
-# 1. CSP img-src only controls image/video loading, not script execution
-# 2. All *.civitai.com subdomains are controlled by Civitai
-# 3. Explicit domain list would require constant updates as Civitai adds CDN nodes
 REMOTE_MEDIA_SOURCES = (
-    "https://*.civitai.com",
+    "https://image.civitai.com",
     "https://img.genur.art",
 )
 
 
 @web.middleware
 async def relax_csp_for_remote_media(
-    request: web.Request,
-    handler: Callable[[web.Request], Awaitable[web.StreamResponse]],
+    request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
 ) -> web.StreamResponse:
     """Allow LoRA Manager media previews to load from trusted remote domains.
 
@@ -49,9 +43,7 @@ async def relax_csp_for_remote_media(
             directive_order.append(name)
         directives[name] = values
 
-    def merge_sources(
-        name: str, sources: List[str], defaults: List[str] | None = None
-    ) -> None:
+    def merge_sources(name: str, sources: List[str], defaults: List[str] | None = None) -> None:
         existing = directives.get(name, list(defaults or []))
 
         for source in sources:

py/middleware/error_middleware.py

@@ -1,76 +0,0 @@
-"""JSON error middleware for API routes.
-
-Ensures all responses to /api/* requests return valid JSON that the
-browser-extension frontend can JSON.parse() without crashing, even when
-the route does not exist (404) or the handler raises an exception (500).
-
-Extension consumers call response.json() unconditionally — an HTML error
-page causes ``SyntaxError: unexpected end of data`` that leaks into the
-popup UI as a toast notification.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Awaitable, Callable
-
-from aiohttp import web
-
-logger = logging.getLogger(__name__)
-
-
-@web.middleware
-async def api_json_error(
-    request: web.Request,
-    handler: Callable[[web.Request], Awaitable[web.Response]],
-) -> web.Response:
-    """Return JSON ``{"success": false, "error": "..."}`` for API errors.
-
-    Only intercepts paths starting with ``/api/`` — all other routes
-    (frontend pages, static files, WebSocket upgrades) pass through
-    unchanged.
-    """
-    if not request.path.startswith("/api/"):
-        return await handler(request)
-
-    try:
-        response = await handler(request)
-        return response
-    except web.HTTPException as exc:
-        # Let redirects (301, 302, 307, 308) propagate — they are not errors.
-        if exc.status < 400:
-            raise
-
-        # Preview 404 is routine (file deleted from disk) — not worth a warning.
-        logger_method = logger.warning
-        if request.path.startswith("/api/lm/previews") and exc.status == 404:
-            logger_method = logger.debug
-
-        logger_method(
-            "API %s %s returned HTTP %d: %s",
-            request.method,
-            request.path,
-            exc.status,
-            exc.reason,
-        )
-
-        return web.json_response(
-            {"success": False, "error": f"{exc.status}: {exc.reason}"},
-            status=exc.status,
-        )
-    except Exception as exc:
-        logger.error(
-            "API %s %s raised unhandled exception: %s",
-            request.method,
-            request.path,
-            exc,
-            exc_info=True,
-        )
-
-        return web.json_response(
-            {
-                "success": False,
-                "error": f"500: Internal Server Error ({type(exc).__name__})",
-            },
-            status=500,
-        )

py/nodes/checkpoint_loader.py

@@ -1,118 +0,0 @@
-import logging
-from typing import List, Tuple
-import comfy.sd # type: ignore
-import folder_paths # type: ignore
-from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
-
-logger = logging.getLogger(__name__)
-
-
-class CheckpointLoaderLM:
-    """Checkpoint Loader with support for extra folder paths
-
-    Loads checkpoints from both standard ComfyUI folders and LoRA Manager's
-    extra folder paths, providing a unified interface for checkpoint loading.
-    """
-
-    NAME = "Checkpoint Loader (LoraManager)"
-    CATEGORY = "Lora Manager/loaders"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        # Get list of checkpoint names from scanner (includes extra folder paths)
-        checkpoint_names = s._get_checkpoint_names()
-        return {
-            "required": {
-                "ckpt_name": (
-                    checkpoint_names,
-                    {"tooltip": "The name of the checkpoint (model) to load."},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL", "CLIP", "VAE")
-    RETURN_NAMES = ("MODEL", "CLIP", "VAE")
-    OUTPUT_TOOLTIPS = (
-        "The model used for denoising latents.",
-        "The CLIP model used for encoding text prompts.",
-        "The VAE model used for encoding and decoding images to and from latent space.",
-    )
-    FUNCTION = "load_checkpoint"
-
-    @classmethod
-    def _get_checkpoint_names(cls) -> List[str]:
-        """Get list of checkpoint names from scanner cache in ComfyUI format (relative path with extension)"""
-        try:
-            from ..services.service_registry import ServiceRegistry
-            import asyncio
-
-            async def _get_names():
-                scanner = await ServiceRegistry.get_checkpoint_scanner()
-                cache = await scanner.get_cached_data()
-
-                # Get all model roots for calculating relative paths
-                model_roots = scanner.get_model_roots()
-
-                # Filter only checkpoint type (not diffusion_model) and format names
-                names = []
-                for item in cache.raw_data:
-                    if item.get("sub_type") == "checkpoint":
-                        file_path = item.get("file_path", "")
-                        if file_path:
-                            # Format using relative path with OS-native separator
-                            formatted_name = _format_model_name_for_comfyui(
-                                file_path, model_roots
-                            )
-                            if formatted_name:
-                                names.append(formatted_name)
-
-                return sorted(names)
-
-            try:
-                loop = asyncio.get_running_loop()
-                import concurrent.futures
-
-                def run_in_thread():
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    try:
-                        return new_loop.run_until_complete(_get_names())
-                    finally:
-                        new_loop.close()
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(run_in_thread)
-                    return future.result()
-            except RuntimeError:
-                return asyncio.run(_get_names())
-        except Exception as e:
-            logger.error(f"Error getting checkpoint names: {e}")
-            return []
-
-    def load_checkpoint(self, ckpt_name: str) -> Tuple:
-        """Load a checkpoint by name, supporting extra folder paths
-
-        Args:
-            ckpt_name: The name of the checkpoint to load (relative path with extension)
-
-        Returns:
-            Tuple of (MODEL, CLIP, VAE)
-        """
-        # Get absolute path from cache using ComfyUI-style name
-        ckpt_path, metadata = get_checkpoint_info_absolute(ckpt_name)
-
-        if metadata is None:
-            raise FileNotFoundError(
-                f"Checkpoint '{ckpt_name}' not found in LoRA Manager cache. "
-                "Make sure the checkpoint is indexed and try again."
-            )
-
-        # Load regular checkpoint using ComfyUI's API
-        logger.info(f"Loading checkpoint from: {ckpt_path}")
-        out = comfy.sd.load_checkpoint_guess_config(
-            ckpt_path,
-            output_vae=True,
-            output_clip=True,
-            embedding_directory=folder_paths.get_folder_paths("embeddings"),
-        )
-        return out[:3]

py/nodes/gguf_import_helper.py

@@ -1,161 +0,0 @@
-"""
-Helper module to safely import ComfyUI-GGUF modules.
-
-This module provides a robust way to import ComfyUI-GGUF functionality
-regardless of how ComfyUI loaded it.
-"""
-
-import sys
-import os
-import importlib.util
-import logging
-from typing import Optional, Tuple, Any
-
-logger = logging.getLogger(__name__)
-
-
-def _get_gguf_path() -> str:
-    """Get the path to ComfyUI-GGUF based on this file's location.
-
-    Since ComfyUI-Lora-Manager and ComfyUI-GGUF are both in custom_nodes/,
-    we can derive the GGUF path from our own location.
-    """
-    # This file is at: custom_nodes/ComfyUI-Lora-Manager/py/nodes/gguf_import_helper.py
-    # ComfyUI-GGUF is at: custom_nodes/ComfyUI-GGUF
-    current_file = os.path.abspath(__file__)
-    # Go up 4 levels: nodes -> py -> ComfyUI-Lora-Manager -> custom_nodes
-    custom_nodes_dir = os.path.dirname(
-        os.path.dirname(os.path.dirname(os.path.dirname(current_file)))
-    )
-    return os.path.join(custom_nodes_dir, "ComfyUI-GGUF")
-
-
-def _find_gguf_module() -> Optional[Any]:
-    """Find ComfyUI-GGUF module in sys.modules.
-
-    ComfyUI registers modules using the full path with dots replaced by _x_.
-    """
-    gguf_path = _get_gguf_path()
-    sys_module_name = gguf_path.replace(".", "_x_")
-
-    logger.debug(f"[GGUF Import] Looking for module '{sys_module_name}' in sys.modules")
-    if sys_module_name in sys.modules:
-        logger.info(f"[GGUF Import] Found module: '{sys_module_name}'")
-        return sys.modules[sys_module_name]
-
-    logger.debug(f"[GGUF Import] Module not found: '{sys_module_name}'")
-    return None
-
-
-def _load_gguf_modules_directly() -> Optional[Any]:
-    """Load ComfyUI-GGUF modules directly from file paths."""
-    gguf_path = _get_gguf_path()
-
-    logger.info(f"[GGUF Import] Direct Load: Attempting to load from '{gguf_path}'")
-
-    if not os.path.exists(gguf_path):
-        logger.warning(f"[GGUF Import] Path does not exist: {gguf_path}")
-        return None
-
-    try:
-        namespace = "ComfyUI_GGUF_Dynamic"
-        init_path = os.path.join(gguf_path, "__init__.py")
-
-        if not os.path.exists(init_path):
-            logger.warning(f"[GGUF Import] __init__.py not found at '{init_path}'")
-            return None
-
-        logger.debug(f"[GGUF Import] Loading from '{init_path}'")
-        spec = importlib.util.spec_from_file_location(namespace, init_path)
-        if not spec or not spec.loader:
-            logger.error(f"[GGUF Import] Failed to create spec for '{init_path}'")
-            return None
-
-        package = importlib.util.module_from_spec(spec)
-        package.__path__ = [gguf_path]
-        sys.modules[namespace] = package
-        spec.loader.exec_module(package)
-        logger.debug(f"[GGUF Import] Loaded main package '{namespace}'")
-
-        # Load submodules
-        loaded = []
-        for submod_name in ["loader", "ops", "nodes"]:
-            submod_path = os.path.join(gguf_path, f"{submod_name}.py")
-            if os.path.exists(submod_path):
-                submod_spec = importlib.util.spec_from_file_location(
-                    f"{namespace}.{submod_name}", submod_path
-                )
-                if submod_spec and submod_spec.loader:
-                    submod = importlib.util.module_from_spec(submod_spec)
-                    submod.__package__ = namespace
-                    sys.modules[f"{namespace}.{submod_name}"] = submod
-                    submod_spec.loader.exec_module(submod)
-                    setattr(package, submod_name, submod)
-                    loaded.append(submod_name)
-                    logger.debug(f"[GGUF Import] Loaded submodule '{submod_name}'")
-
-        logger.info(f"[GGUF Import] Direct Load success: {loaded}")
-        return package
-
-    except Exception as e:
-        logger.error(f"[GGUF Import] Direct Load failed: {e}", exc_info=True)
-        return None
-
-
-def get_gguf_modules() -> Tuple[Any, Any, Any]:
-    """Get ComfyUI-GGUF modules (loader, ops, nodes).
-
-    Returns:
-        Tuple of (loader_module, ops_module, nodes_module)
-
-    Raises:
-        RuntimeError: If ComfyUI-GGUF cannot be found or loaded.
-    """
-    logger.debug("[GGUF Import] Starting module search...")
-
-    # Try to find already loaded module first
-    gguf_module = _find_gguf_module()
-
-    if gguf_module is None:
-        logger.info("[GGUF Import] Not found in sys.modules, trying direct load...")
-        gguf_module = _load_gguf_modules_directly()
-
-    if gguf_module is None:
-        raise RuntimeError(
-            "ComfyUI-GGUF is not installed. "
-            "Please install from https://github.com/city96/ComfyUI-GGUF"
-        )
-
-    # Extract submodules
-    loader = getattr(gguf_module, "loader", None)
-    ops = getattr(gguf_module, "ops", None)
-    nodes = getattr(gguf_module, "nodes", None)
-
-    if loader is None or ops is None or nodes is None:
-        missing = [
-            name
-            for name, mod in [("loader", loader), ("ops", ops), ("nodes", nodes)]
-            if mod is None
-        ]
-        raise RuntimeError(f"ComfyUI-GGUF missing submodules: {missing}")
-
-    logger.debug("[GGUF Import] All modules loaded successfully")
-    return loader, ops, nodes
-
-
-def get_gguf_sd_loader():
-    """Get the gguf_sd_loader function from ComfyUI-GGUF."""
-    loader, _, _ = get_gguf_modules()
-    return getattr(loader, "gguf_sd_loader")
-
-
-def get_ggml_ops():
-    """Get the GGMLOps class from ComfyUI-GGUF."""
-    _, ops, _ = get_gguf_modules()
-    return getattr(ops, "GGMLOps")
-
-
-def get_gguf_model_patcher():
-    """Get the GGUFModelPatcher class from ComfyUI-GGUF."""
-    _, _, nodes = get_gguf_modules()
-    return getattr(nodes, "GGUFModelPatcher")

py/nodes/lora_cycler.py

@@ -8,7 +8,6 @@ and tracks the cycle progress which persists across workflow save/load.
 
 import logging
 import os
-
 from ..utils.utils import get_lora_info
 
 logger = logging.getLogger(__name__)
@@ -55,14 +54,8 @@ class LoraCyclerLM:
         current_index = cycler_config.get("current_index", 1)  # 1-based
         model_strength = float(cycler_config.get("model_strength", 1.0))
         clip_strength = float(cycler_config.get("clip_strength", 1.0))
-        use_same_clip_strength = cycler_config.get("use_same_clip_strength", True)
-        use_preset_strength = cycler_config.get("use_preset_strength", False)
-        preset_strength_scale = float(cycler_config.get("preset_strength_scale", 1.0))
         sort_by = "filename"
 
-        # Include "no lora" option
-        include_no_lora = cycler_config.get("include_no_lora", False)
-
         # Dual-index mechanism for batch queue synchronization
         execution_index = cycler_config.get("execution_index")  # Can be None
         # next_index_from_config = cycler_config.get("next_index")  # Not used on backend
@@ -78,10 +71,7 @@ class LoraCyclerLM:
 
         total_count = len(lora_list)
 
-        # Calculate effective total count (includes no lora option if enabled)
-        effective_total_count = total_count + 1 if include_no_lora else total_count
-
-        if total_count == 0 and not include_no_lora:
+        if total_count == 0:
             logger.warning("[LoraCyclerLM] No LoRAs available in pool")
             return {
                 "result": ([],),
@@ -103,31 +93,15 @@ class LoraCyclerLM:
         else:
             actual_index = current_index
 
-        # Clamp index to valid range (1-based, includes no lora if enabled)
-        clamped_index = max(1, min(actual_index, effective_total_count))
+        # Clamp index to valid range (1-based)
+        clamped_index = max(1, min(actual_index, total_count))
 
-        # Check if current index is the "no lora" option (last position when include_no_lora is True)
-        is_no_lora = include_no_lora and clamped_index == effective_total_count
-
-        if is_no_lora:
-            # "No LoRA" option - return empty stack
-            lora_stack = []
-            current_lora_name = "No LoRA"
-            current_lora_filename = "No LoRA"
-        else:
         # Get LoRA at current index (convert to 0-based for list access)
         current_lora = lora_list[clamped_index - 1]
-            current_lora_name = current_lora["file_name"]
-            current_lora_filename = current_lora["file_name"]
 
         # Build LORA_STACK with single LoRA
-            if current_lora["file_name"] == "None":
-                lora_path = None
-            else:
         lora_path, _ = get_lora_info(current_lora["file_name"])
-
         if not lora_path:
-                if current_lora["file_name"] != "None":
             logger.warning(
                 f"[LoraCyclerLM] Could not find path for LoRA: {current_lora['file_name']}"
             )
@@ -135,67 +109,26 @@ class LoraCyclerLM:
         else:
             # Normalize path separators
             lora_path = lora_path.replace("/", os.sep)
-
-                if use_preset_strength:
-                    lora_metadata = await lora_service.get_lora_metadata_by_filename(
-                        current_lora["file_name"]
-                    )
-                    if lora_metadata:
-                        recommended_strength = (
-                            lora_service.get_recommended_strength_from_lora_data(
-                                lora_metadata
-                            )
-                        )
-                        if recommended_strength is not None:
-                            model_strength = round(
-                                recommended_strength * preset_strength_scale, 2
-                            )
-
-                        if use_same_clip_strength:
-                            clip_strength = model_strength
-                        else:
-                            recommended_clip_strength = (
-                                lora_service.get_recommended_clip_strength_from_lora_data(
-                                    lora_metadata
-                                )
-                            )
-                            if recommended_clip_strength is not None:
-                                clip_strength = round(
-                                    recommended_clip_strength * preset_strength_scale, 2
-                                )
-                    elif use_same_clip_strength:
-                        clip_strength = model_strength
-                elif use_same_clip_strength:
-                    clip_strength = model_strength
-
             lora_stack = [(lora_path, model_strength, clip_strength)]
 
         # Calculate next index (wrap to 1 if at end)
         next_index = clamped_index + 1
-        if next_index > effective_total_count:
+        if next_index > total_count:
             next_index = 1
 
         # Get next LoRA for UI display (what will be used next generation)
-        is_next_no_lora = include_no_lora and next_index == effective_total_count
-        if is_next_no_lora:
-            next_display_name = "No LoRA"
-            next_lora_filename = "No LoRA"
-        else:
         next_lora = lora_list[next_index - 1]
         next_display_name = next_lora["file_name"]
-            next_lora_filename = next_lora["file_name"]
 
         return {
             "result": (lora_stack,),
             "ui": {
                 "current_index": [clamped_index],
                 "next_index": [next_index],
-                "total_count": [
-                    total_count
-                ],  # Return actual LoRA count, not effective_total_count
-                "current_lora_name": [current_lora_name],
-                "current_lora_filename": [current_lora_filename],
+                "total_count": [total_count],
+                "current_lora_name": [current_lora["file_name"]],
+                "current_lora_filename": [current_lora["file_name"]],
                 "next_lora_name": [next_display_name],
-                "next_lora_filename": [next_lora_filename],
+                "next_lora_filename": [next_lora["file_name"]],
             },
         }

py/nodes/lora_loader.py

@@ -1,130 +1,11 @@
-import importlib
 import logging
 import re
-
-import comfy.sd  # type: ignore
-import comfy.utils  # type: ignore
-
-from ..utils.utils import get_lora_info_absolute
-from .utils import (
-    FlexibleOptionalInputType,
-    any_type,
-    apply_lora_syntax_format,
-    detect_nunchaku_model_kind,
-    extract_lora_name,
-    get_loras_list,
-    nunchaku_load_lora,
-)
+from nodes import LoraLoader
+from ..utils.utils import get_lora_info
+from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list, nunchaku_load_lora
 
 logger = logging.getLogger(__name__)
 
-
-def _get_nunchaku_load_qwen_loras():
-    try:
-        module = importlib.import_module(".nunchaku_qwen", __package__)
-    except ImportError as exc:
-        raise RuntimeError(
-            "Qwen-Image LoRA loading requires the ComfyUI runtime with its torch dependency available."
-        ) from exc
-    return module.nunchaku_load_qwen_loras
-
-
-def _collect_stack_entries(lora_stack):
-    entries = []
-    if not lora_stack:
-        return entries
-
-    for lora_path, model_strength, clip_strength in lora_stack:
-        lora_name = extract_lora_name(lora_path)
-        absolute_lora_path, trigger_words = get_lora_info_absolute(lora_name)
-        entries.append({
-            "name": lora_name,
-            "absolute_path": absolute_lora_path,
-            "input_path": lora_path,
-            "model_strength": float(model_strength),
-            "clip_strength": float(clip_strength),
-            "trigger_words": trigger_words,
-        })
-    return entries
-
-
-def _collect_widget_entries(kwargs):
-    entries = []
-    for lora in get_loras_list(kwargs):
-        if not lora.get("active", False):
-            continue
-        lora_name = apply_lora_syntax_format(lora["name"])
-        model_strength = float(lora["strength"])
-        clip_strength = float(lora.get("clipStrength", model_strength))
-        lora_path, trigger_words = get_lora_info_absolute(lora_name)
-        entries.append({
-            "name": lora_name,
-            "absolute_path": lora_path,
-            "input_path": lora_path,
-            "model_strength": model_strength,
-            "clip_strength": clip_strength,
-            "trigger_words": trigger_words,
-        })
-    return entries
-
-
-def _format_loaded_loras(loaded_loras):
-    formatted_loras = []
-    for item in loaded_loras:
-        if item["include_clip_strength"]:
-            formatted_loras.append(
-                f"<lora:{item['name']}:{item['model_strength']}:{item['clip_strength']}>"
-            )
-        else:
-            formatted_loras.append(f"<lora:{item['name']}:{item['model_strength']}>")
-    return " ".join(formatted_loras)
-
-
-def _apply_entries(model, clip, lora_entries, nunchaku_model_kind):
-    loaded_loras = []
-    all_trigger_words = []
-
-    if nunchaku_model_kind == "qwen_image":
-        nunchaku_load_qwen_loras = _get_nunchaku_load_qwen_loras()
-        qwen_lora_configs = []
-        for entry in lora_entries:
-            qwen_lora_configs.append((entry["absolute_path"], entry["model_strength"]))
-            loaded_loras.append({
-                "name": entry["name"],
-                "model_strength": entry["model_strength"],
-                "clip_strength": entry["model_strength"],
-                "include_clip_strength": False,
-            })
-            all_trigger_words.extend(entry["trigger_words"])
-        if qwen_lora_configs:
-            model = nunchaku_load_qwen_loras(model, qwen_lora_configs)
-        return model, clip, loaded_loras, all_trigger_words
-
-    for entry in lora_entries:
-        if nunchaku_model_kind == "flux":
-            model = nunchaku_load_lora(model, entry["input_path"], entry["model_strength"])
-        else:
-            lora = comfy.utils.load_torch_file(entry["absolute_path"], safe_load=True)
-            model, clip = comfy.sd.load_lora_for_models(
-                model,
-                clip,
-                lora,
-                entry["model_strength"],
-                entry["clip_strength"],
-            )
-
-        include_clip_strength = nunchaku_model_kind is None and abs(entry["model_strength"] - entry["clip_strength"]) > 0.001
-        loaded_loras.append({
-            "name": entry["name"],
-            "model_strength": entry["model_strength"],
-            "clip_strength": entry["clip_strength"],
-            "include_clip_strength": include_clip_strength,
-        })
-        all_trigger_words.extend(entry["trigger_words"])
-
-    return model, clip, loaded_loras, all_trigger_words
-
-
 class LoraLoaderLM:
     NAME = "Lora Loader (LoraManager)"
     CATEGORY = "Lora Manager/loaders"
@@ -134,6 +15,7 @@ class LoraLoaderLM:
         return {
             "required": {
                 "model": ("MODEL",),
+                # "clip": ("CLIP",),
                 "text": ("AUTOCOMPLETE_TEXT_LORAS", {
                     "placeholder": "Search LoRAs to add...",
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
@@ -148,22 +30,103 @@ class LoraLoaderLM:
     
     def load_loras(self, model, text, **kwargs):
         """Loads multiple LoRAs based on the kwargs input and lora_stack."""
-        del text
-        clip = kwargs.get("clip", None)
-        lora_entries = _collect_stack_entries(kwargs.get("lora_stack", None))
-        lora_entries.extend(_collect_widget_entries(kwargs))
+        loaded_loras = []
+        all_trigger_words = []
         
-        nunchaku_model_kind = detect_nunchaku_model_kind(model)
-        if nunchaku_model_kind == "flux":
+        clip = kwargs.get('clip', None)
+        lora_stack = kwargs.get('lora_stack', None)
+        
+        # Check if model is a Nunchaku Flux model - simplified approach
+        is_nunchaku_model = False
+        
+        try:
+            model_wrapper = model.model.diffusion_model
+            # Check if model is a Nunchaku Flux model using only class name
+            if model_wrapper.__class__.__name__ == "ComfyFluxWrapper":
+                is_nunchaku_model = True
                 logger.info("Detected Nunchaku Flux model")
-        elif nunchaku_model_kind == "qwen_image":
-            logger.info("Detected Nunchaku Qwen-Image model")
+        except (AttributeError, TypeError):
+            # Not a model with the expected structure
+            pass
         
-        model, clip, loaded_loras, all_trigger_words = _apply_entries(model, clip, lora_entries, nunchaku_model_kind)
+        # First process lora_stack if available
+        if lora_stack:
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Apply the LoRA using the appropriate loader
+                if is_nunchaku_model:
+                    # Use our custom function for Flux models
+                    model = nunchaku_load_lora(model, lora_path, model_strength)
+                    # clip remains unchanged for Nunchaku models
+                else:
+                    # Use default loader for standard models
+                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                
+                # Extract lora name for trigger words lookup
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = get_lora_info(lora_name)
+                
+                all_trigger_words.extend(trigger_words)
+                # Add clip strength to output if different from model strength (except for Nunchaku models)
+                if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
+        
+        # Then process loras from kwargs with support for both old and new formats
+        loras_list = get_loras_list(kwargs)
+        for lora in loras_list:
+            if not lora.get('active', False):
+                continue
+                
+            lora_name = lora['name']
+            model_strength = float(lora['strength'])
+            # Get clip strength - use model strength as default if not specified
+            clip_strength = float(lora.get('clipStrength', model_strength))
+            
+            # Get lora path and trigger words
+            lora_path, trigger_words = get_lora_info(lora_name)
+            
+            # Apply the LoRA using the appropriate loader
+            if is_nunchaku_model:
+                # For Nunchaku models, use our custom function
+                model = nunchaku_load_lora(model, lora_path, model_strength)
+                # clip remains unchanged
+            else:
+                # Use default loader for standard models
+                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength and not a Nunchaku model
+            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
+            
+            # Add trigger words to collection
+            all_trigger_words.extend(trigger_words)
+        
+        # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-        formatted_loras_text = _format_loaded_loras(loaded_loras)
-        return (model, clip, trigger_words_text, formatted_loras_text)
         
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0]
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
+
+        return (model, clip, trigger_words_text, formatted_loras_text)
 
 class LoraTextLoaderLM:
     NAME = "LoRA Text Loader (LoraManager)"
@@ -176,13 +139,13 @@ class LoraTextLoaderLM:
                 "model": ("MODEL",),
                 "lora_syntax": ("STRING", {
                     "forceInput": True,
-                    "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
+                    "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation"
                 }),
             },
             "optional": {
                 "clip": ("CLIP",),
                 "lora_stack": ("LORA_STACK",),
-            },
+            }
         }
 
     RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING")
@@ -191,40 +154,113 @@ class LoraTextLoaderLM:
     
     def parse_lora_syntax(self, text):
         """Parse LoRA syntax from text input."""
-        pattern = r"<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>"
+        # Pattern to match <lora:name:strength> or <lora:name:model_strength:clip_strength>
+        pattern = r'<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>'
         matches = re.findall(pattern, text, re.IGNORECASE)
         
         loras = []
         for match in matches:
+            lora_name = match[0]
             model_strength = float(match[1])
+            clip_strength = float(match[2]) if match[2] else model_strength
+            
             loras.append({
-                "name": match[0],
-                "model_strength": model_strength,
-                "clip_strength": float(match[2]) if match[2] else model_strength,
+                'name': lora_name,
+                'model_strength': model_strength,
+                'clip_strength': clip_strength
             })
+        
         return loras
     
     def load_loras_from_text(self, model, lora_syntax, clip=None, lora_stack=None):
         """Load LoRAs based on text syntax input."""
-        lora_entries = _collect_stack_entries(lora_stack)
-        for lora in self.parse_lora_syntax(lora_syntax):
-            lora_path, trigger_words = get_lora_info_absolute(lora["name"])
-            lora_entries.append({
-                "name": lora["name"],
-                "absolute_path": lora_path,
-                "input_path": lora_path,
-                "model_strength": lora["model_strength"],
-                "clip_strength": lora["clip_strength"],
-                "trigger_words": trigger_words,
-            })
+        loaded_loras = []
+        all_trigger_words = []
         
-        nunchaku_model_kind = detect_nunchaku_model_kind(model)
-        if nunchaku_model_kind == "flux":
+        # Check if model is a Nunchaku Flux model - simplified approach
+        is_nunchaku_model = False
+        
+        try:
+            model_wrapper = model.model.diffusion_model
+            # Check if model is a Nunchaku Flux model using only class name
+            if model_wrapper.__class__.__name__ == "ComfyFluxWrapper":
+                is_nunchaku_model = True
                 logger.info("Detected Nunchaku Flux model")
-        elif nunchaku_model_kind == "qwen_image":
-            logger.info("Detected Nunchaku Qwen-Image model")
+        except (AttributeError, TypeError):
+            # Not a model with the expected structure
+            pass
         
-        model, clip, loaded_loras, all_trigger_words = _apply_entries(model, clip, lora_entries, nunchaku_model_kind)
+        # First process lora_stack if available
+        if lora_stack:
+            for lora_path, model_strength, clip_strength in lora_stack:
+                # Apply the LoRA using the appropriate loader
+                if is_nunchaku_model:
+                    # Use our custom function for Flux models
+                    model = nunchaku_load_lora(model, lora_path, model_strength)
+                    # clip remains unchanged for Nunchaku models
+                else:
+                    # Use default loader for standard models
+                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                
+                # Extract lora name for trigger words lookup
+                lora_name = extract_lora_name(lora_path)
+                _, trigger_words = get_lora_info(lora_name)
+                
+                all_trigger_words.extend(trigger_words)
+                # Add clip strength to output if different from model strength (except for Nunchaku models)
+                if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                    loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+                else:
+                    loaded_loras.append(f"{lora_name}: {model_strength}")
+        
+        # Parse and process LoRAs from text syntax
+        parsed_loras = self.parse_lora_syntax(lora_syntax)
+        for lora in parsed_loras:
+            lora_name = lora['name']
+            model_strength = lora['model_strength']
+            clip_strength = lora['clip_strength']
+            
+            # Get lora path and trigger words
+            lora_path, trigger_words = get_lora_info(lora_name)
+            
+            # Apply the LoRA using the appropriate loader
+            if is_nunchaku_model:
+                # For Nunchaku models, use our custom function
+                model = nunchaku_load_lora(model, lora_path, model_strength)
+                # clip remains unchanged
+            else:
+                # Use default loader for standard models
+                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+            
+            # Include clip strength in output if different from model strength and not a Nunchaku model
+            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
+                loaded_loras.append(f"{lora_name}: {model_strength},{clip_strength}")
+            else:
+                loaded_loras.append(f"{lora_name}: {model_strength}")
+            
+            # Add trigger words to collection
+            all_trigger_words.extend(trigger_words)
+        
+        # use ',, ' to separate trigger words for group mode
         trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
-        formatted_loras_text = _format_loaded_loras(loaded_loras)
+
+        # Format loaded_loras with support for both formats
+        formatted_loras = []
+        for item in loaded_loras:
+            parts = item.split(":")
+            lora_name = parts[0].strip()
+            strength_parts = parts[1].strip().split(",")
+            
+            if len(strength_parts) > 1:
+                # Different model and clip strengths
+                model_str = strength_parts[0].strip()
+                clip_str = strength_parts[1].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}:{clip_str}>")
+            else:
+                # Same strength for both
+                model_str = strength_parts[0].strip()
+                formatted_loras.append(f"<lora:{lora_name}:{model_str}>")
+                
+        formatted_loras_text = " ".join(formatted_loras)
+
         return (model, clip, trigger_words_text, formatted_loras_text)

py/nodes/lora_pool.py

@@ -82,7 +82,6 @@ class LoraPoolLM:
                 "folders": {"include": [], "exclude": []},
                 "favoritesOnly": False,
                 "license": {"noCreditRequired": False, "allowSelling": False},
-                "namePatterns": {"include": [], "exclude": [], "useRegex": False},
             },
             "preview": {"matchCount": 0, "lastUpdated": 0},
         }

py/nodes/lora_randomizer.py

@@ -7,8 +7,10 @@ and tracks the last used combination for reuse.
 """
 
 import logging
+import random
 import os
 from ..utils.utils import get_lora_info
+from .utils import extract_lora_name
 
 logger = logging.getLogger(__name__)
 

py/nodes/lora_stack_combiner.py

@@ -1,26 +0,0 @@
-class LoraStackCombinerLM:
-    NAME = "Lora Stack Combiner (LoraManager)"
-    CATEGORY = "Lora Manager/stackers"
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "lora_stack_a": ("LORA_STACK",),
-                "lora_stack_b": ("LORA_STACK",),
-            },
-        }
-
-    RETURN_TYPES = ("LORA_STACK",)
-    RETURN_NAMES = ("LORA_STACK",)
-    FUNCTION = "combine_stacks"
-
-    def combine_stacks(self, lora_stack_a, lora_stack_b):
-        combined_stack = []
-
-        if lora_stack_a:
-            combined_stack.extend(lora_stack_a)
-        if lora_stack_b:
-            combined_stack.extend(lora_stack_b)
-
-        return (combined_stack,)

py/nodes/lora_stacker.py

@@ -1,6 +1,6 @@
 import os
 from ..utils.utils import get_lora_info
-from .utils import FlexibleOptionalInputType, any_type, apply_lora_syntax_format, extract_lora_name, get_loras_list
+from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list
 
 import logging
 
@@ -48,7 +48,7 @@ class LoraStackerLM:
             if not lora.get('active', False):
                 continue
                 
-            lora_name = apply_lora_syntax_format(lora['name'])
+            lora_name = lora['name']
             model_strength = float(lora['strength'])
             # Get clip strength - use model strength as default if not specified
             clip_strength = float(lora.get('clipStrength', model_strength))

py/nodes/nunchaku_qwen.py

@@ -1,570 +0,0 @@
-from __future__ import annotations
-
-"""Qwen-Image LoRA support for Nunchaku models.
-
-Portions of the LoRA mapping/application logic in this file are adapted from
-ComfyUI-QwenImageLoraLoader by GitHub user ussoewwin:
-https://github.com/ussoewwin/ComfyUI-QwenImageLoraLoader
-
-The upstream project is licensed under Apache License 2.0.
-"""
-
-import copy
-import logging
-import os
-import re
-from collections import defaultdict
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-
-import comfy.utils  # type: ignore
-import folder_paths  # type: ignore
-import torch
-import torch.nn as nn
-from safetensors import safe_open
-
-from nunchaku.lora.flux.nunchaku_converter import (
-    pack_lowrank_weight,
-    unpack_lowrank_weight,
-)
-
-logger = logging.getLogger(__name__)
-
-KEY_MAPPING = [
-    (re.compile(r"^(layers)[._](\d+)[._]attention[._]to[._]([qkv])$"), r"\1.\2.attention.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(layers)[._](\d+)[._]feed_forward[._](w1|w3)$"), r"\1.\2.feed_forward.net.0.proj", "glu", lambda m: m.group(3)),
-    (re.compile(r"^(layers)[._](\d+)[._]feed_forward[._]w2$"), r"\1.\2.feed_forward.net.2", "regular", None),
-    (re.compile(r"^(layers)[._](\d+)[._](.*)$"), r"\1.\2.\3", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]to[._]([qkv])$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._](q|k|v)[._]proj$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]add[._](q|k|v)[._]proj$"), r"\1.\2.attn.add_qkv_proj", "add_qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]out[._]proj[._]context$"), r"\1.\2.attn.to_add_out", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]out[._]proj$"), r"\1.\2.attn.to_out.0", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]attn[._]to[._]out$"), r"\1.\2.attn.to_out.0", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]attn[._]to[._]([qkv])$"), r"\1.\2.attn.to_qkv", "qkv", lambda m: m.group(3).upper()),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]attn[._]to[._]out$"), r"\1.\2.attn.to_out", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff[._]net[._]0(?:[._]proj)?$"), r"\1.\2.mlp_fc1", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff[._]net[._]2$"), r"\1.\2.mlp_fc2", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff_context[._]net[._]0(?:[._]proj)?$"), r"\1.\2.mlp_context_fc1", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]ff_context[._]net[._]2$"), r"\1.\2.mlp_context_fc2", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mlp)[._](net)[._](0)[._](proj)$"), r"\1.\2.\3.\4.\5.\6", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mlp)[._](net)[._](2)$"), r"\1.\2.\3.\4.\5", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mlp)[._](net)[._](0)[._](proj)$"), r"\1.\2.\3.\4.\5.\6", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mlp)[._](net)[._](2)$"), r"\1.\2.\3.\4.\5", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](img_mod)[._](1)$"), r"\1.\2.\3.\4", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._](txt_mod)[._](1)$"), r"\1.\2.\3.\4", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]proj[._]out$"), r"\1.\2.proj_out", "single_proj_out", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]proj[._]mlp$"), r"\1.\2.mlp_fc1", "regular", None),
-    (re.compile(r"^(single_transformer_blocks)[._](\d+)[._]norm[._]linear$"), r"\1.\2.norm.linear", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]norm1[._]linear$"), r"\1.\2.norm1.linear", "regular", None),
-    (re.compile(r"^(transformer_blocks)[._](\d+)[._]norm1_context[._]linear$"), r"\1.\2.norm1_context.linear", "regular", None),
-    (re.compile(r"^(img_in)$"), r"\1", "regular", None),
-    (re.compile(r"^(txt_in)$"), r"\1", "regular", None),
-    (re.compile(r"^(proj_out)$"), r"\1", "regular", None),
-    (re.compile(r"^(norm_out)[._](linear)$"), r"\1.\2", "regular", None),
-    (re.compile(r"^(time_text_embed)[._](timestep_embedder)[._](linear_1)$"), r"\1.\2.\3", "regular", None),
-    (re.compile(r"^(time_text_embed)[._](timestep_embedder)[._](linear_2)$"), r"\1.\2.\3", "regular", None),
-]
-
-_RE_LORA_SUFFIX = re.compile(r"\.(?P<tag>lora(?:[._](?:A|B|down|up)))(?:\.[^.]+)*\.weight$")
-_RE_ALPHA_SUFFIX = re.compile(r"\.(?:alpha|lora_alpha)(?:\.[^.]+)*$")
-
-
-def _rename_layer_underscore_layer_name(old_name: str) -> str:
-    rules = [
-        (r"_(\d+)_attn_to_out_(\d+)", r".\1.attn.to_out.\2"),
-        (r"_(\d+)_img_mlp_net_(\d+)_proj", r".\1.img_mlp.net.\2.proj"),
-        (r"_(\d+)_txt_mlp_net_(\d+)_proj", r".\1.txt_mlp.net.\2.proj"),
-        (r"_(\d+)_img_mlp_net_(\d+)", r".\1.img_mlp.net.\2"),
-        (r"_(\d+)_txt_mlp_net_(\d+)", r".\1.txt_mlp.net.\2"),
-        (r"_(\d+)_img_mod_(\d+)", r".\1.img_mod.\2"),
-        (r"_(\d+)_txt_mod_(\d+)", r".\1.txt_mod.\2"),
-        (r"_(\d+)_attn_", r".\1.attn."),
-    ]
-    new_name = old_name
-    for pattern, replacement in rules:
-        new_name = re.sub(pattern, replacement, new_name)
-    return new_name
-
-
-def _is_indexable_module(module):
-    return isinstance(module, (nn.ModuleList, nn.Sequential, list, tuple))
-
-
-def _get_module_by_name(model: nn.Module, name: str) -> Optional[nn.Module]:
-    if not name:
-        return model
-    module = model
-    for part in name.split("."):
-        if not part:
-            continue
-        if hasattr(module, part):
-            module = getattr(module, part)
-        elif part.isdigit() and _is_indexable_module(module):
-            try:
-                module = module[int(part)]
-            except (IndexError, TypeError):
-                return None
-        else:
-            return None
-    return module
-
-
-def _resolve_module_name(model: nn.Module, name: str) -> Tuple[str, Optional[nn.Module]]:
-    module = _get_module_by_name(model, name)
-    if module is not None:
-        return name, module
-
-    replacements = [
-        (".attn.to_out.0", ".attn.to_out"),
-        (".attention.to_qkv", ".attention.qkv"),
-        (".attention.to_out.0", ".attention.out"),
-        (".feed_forward.net.0.proj", ".feed_forward.w13"),
-        (".feed_forward.net.2", ".feed_forward.w2"),
-        (".ff.net.0.proj", ".mlp_fc1"),
-        (".ff.net.2", ".mlp_fc2"),
-        (".ff_context.net.0.proj", ".mlp_context_fc1"),
-        (".ff_context.net.2", ".mlp_context_fc2"),
-    ]
-    for src, dst in replacements:
-        if src in name:
-            alt = name.replace(src, dst)
-            module = _get_module_by_name(model, alt)
-            if module is not None:
-                return alt, module
-    return name, None
-
-
-def _classify_and_map_key(key: str) -> Optional[Tuple[str, str, Optional[str], str]]:
-    normalized = key
-    if normalized.startswith("transformer."):
-        normalized = normalized[len("transformer."):]
-    if normalized.startswith("diffusion_model."):
-        normalized = normalized[len("diffusion_model."):]
-    if normalized.startswith("lora_unet_"):
-        normalized = _rename_layer_underscore_layer_name(normalized[len("lora_unet_"):])
-
-    match = _RE_LORA_SUFFIX.search(normalized)
-    if match:
-        tag = match.group("tag")
-        base = normalized[:match.start()]
-        ab = "A" if ("lora_A" in tag or tag.endswith(".A") or "down" in tag) else "B"
-    else:
-        match = _RE_ALPHA_SUFFIX.search(normalized)
-        if not match:
-            return None
-        base = normalized[:match.start()]
-        ab = "alpha"
-
-    for pattern, template, group, comp_fn in KEY_MAPPING:
-        key_match = pattern.match(base)
-        if key_match:
-            return group, key_match.expand(template), comp_fn(key_match) if comp_fn else None, ab
-    return None
-
-
-def _detect_lora_format(lora_state_dict: Dict[str, torch.Tensor]) -> bool:
-    standard_patterns = (
-        ".lora_up.",
-        ".lora_down.",
-        ".lora_A.",
-        ".lora_B.",
-        ".lora.up.",
-        ".lora.down.",
-        ".lora.A.",
-        ".lora.B.",
-    )
-    return any(pattern in key for key in lora_state_dict for pattern in standard_patterns)
-
-
-def _load_lora_state_dict(path_or_dict: Union[str, Path, Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
-    if isinstance(path_or_dict, dict):
-        return path_or_dict
-    path = Path(path_or_dict)
-    if path.suffix == ".safetensors":
-        state_dict: Dict[str, torch.Tensor] = {}
-        with safe_open(path, framework="pt", device="cpu") as handle:
-            for key in handle.keys():
-                state_dict[key] = handle.get_tensor(key)
-        return state_dict
-    return comfy.utils.load_torch_file(str(path), safe_load=True)
-
-
-def _fuse_glu_lora(glu_weights: Dict[str, torch.Tensor]) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]:
-    if "w1_A" not in glu_weights or "w3_A" not in glu_weights:
-        return None, None, None
-    a_w1, b_w1 = glu_weights["w1_A"], glu_weights["w1_B"]
-    a_w3, b_w3 = glu_weights["w3_A"], glu_weights["w3_B"]
-    if a_w1.shape[1] != a_w3.shape[1]:
-        return None, None, None
-    a_fused = torch.cat([a_w1, a_w3], dim=0)
-    out1, out3 = b_w1.shape[0], b_w3.shape[0]
-    rank1, rank3 = b_w1.shape[1], b_w3.shape[1]
-    b_fused = torch.zeros(out1 + out3, rank1 + rank3, dtype=b_w1.dtype, device=b_w1.device)
-    b_fused[:out1, :rank1] = b_w1
-    b_fused[out1:, rank1:] = b_w3
-    return a_fused, b_fused, glu_weights.get("w1_alpha")
-
-
-def _fuse_qkv_lora(qkv_weights: Dict[str, torch.Tensor], model: Optional[nn.Module] = None, base_key: Optional[str] = None) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]:
-    required_keys = ["Q_A", "Q_B", "K_A", "K_B", "V_A", "V_B"]
-    if not all(key in qkv_weights for key in required_keys):
-        return None, None, None
-    a_q, a_k, a_v = qkv_weights["Q_A"], qkv_weights["K_A"], qkv_weights["V_A"]
-    b_q, b_k, b_v = qkv_weights["Q_B"], qkv_weights["K_B"], qkv_weights["V_B"]
-    if not (a_q.shape == a_k.shape == a_v.shape):
-        return None, None, None
-    if not (b_q.shape[1] == b_k.shape[1] == b_v.shape[1]):
-        return None, None, None
-
-    out_features = None
-    if model is not None and base_key is not None:
-        _, module = _resolve_module_name(model, base_key)
-        out_features = getattr(module, "out_features", None) if module is not None else None
-
-    alpha_fused = None
-    alpha_q = qkv_weights.get("Q_alpha")
-    alpha_k = qkv_weights.get("K_alpha")
-    alpha_v = qkv_weights.get("V_alpha")
-    if alpha_q is not None and alpha_k is not None and alpha_v is not None and alpha_q.item() == alpha_k.item() == alpha_v.item():
-        alpha_fused = alpha_q
-
-    a_fused = torch.cat([a_q, a_k, a_v], dim=0)
-    rank = b_q.shape[1]
-    out_q, out_k, out_v = b_q.shape[0], b_k.shape[0], b_v.shape[0]
-    total_out = out_features if out_features is not None else out_q + out_k + out_v
-    b_fused = torch.zeros(total_out, 3 * rank, dtype=b_q.dtype, device=b_q.device)
-    b_fused[:out_q, :rank] = b_q
-    b_fused[out_q:out_q + out_k, rank:2 * rank] = b_k
-    b_fused[out_q + out_k:out_q + out_k + out_v, 2 * rank:] = b_v
-    return a_fused, b_fused, alpha_fused
-
-
-def _handle_proj_out_split(lora_dict: Dict[str, Dict[str, torch.Tensor]], base_key: str, model: nn.Module) -> Tuple[Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]], List[str]]:
-    result: Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]] = {}
-    consumed: List[str] = []
-    match = re.search(r"single_transformer_blocks\.(\d+)", base_key)
-    if not match or base_key not in lora_dict:
-        return result, consumed
-    block_idx = match.group(1)
-    block = _get_module_by_name(model, f"single_transformer_blocks.{block_idx}")
-    if block is None:
-        return result, consumed
-    a_full = lora_dict[base_key].get("A")
-    b_full = lora_dict[base_key].get("B")
-    alpha = lora_dict[base_key].get("alpha")
-    attn_to_out = getattr(getattr(block, "attn", None), "to_out", None)
-    mlp_fc2 = getattr(block, "mlp_fc2", None)
-    if a_full is None or b_full is None or attn_to_out is None or mlp_fc2 is None:
-        return result, consumed
-    attn_in = getattr(attn_to_out, "in_features", None)
-    mlp_in = getattr(mlp_fc2, "in_features", None)
-    if attn_in is None or mlp_in is None or a_full.shape[1] != attn_in + mlp_in:
-        return result, consumed
-    result[f"single_transformer_blocks.{block_idx}.attn.to_out"] = (a_full[:, :attn_in], b_full.clone(), alpha)
-    result[f"single_transformer_blocks.{block_idx}.mlp_fc2"] = (a_full[:, attn_in:], b_full.clone(), alpha)
-    consumed.append(base_key)
-    return result, consumed
-
-
-def _apply_lora_to_module(module: nn.Module, a_tensor: torch.Tensor, b_tensor: torch.Tensor, module_name: str, model: nn.Module) -> None:
-    if not hasattr(module, "in_features") or not hasattr(module, "out_features"):
-        raise ValueError(f"{module_name}: unsupported module without in/out features")
-    if a_tensor.shape[1] != module.in_features or b_tensor.shape[0] != module.out_features:
-        raise ValueError(f"{module_name}: LoRA shape mismatch")
-
-    if module.__class__.__name__ == "AWQW4A16Linear" and hasattr(module, "qweight"):
-        if not hasattr(module, "_lora_original_forward"):
-            module._lora_original_forward = module.forward
-        if not hasattr(module, "_nunchaku_lora_bundle"):
-            module._nunchaku_lora_bundle = []
-        module._nunchaku_lora_bundle.append((a_tensor, b_tensor))
-
-        def _awq_lora_forward(x, *args, **kwargs):
-            out = module._lora_original_forward(x, *args, **kwargs)
-            x_flat = x.reshape(-1, module.in_features)
-            for local_a, local_b in module._nunchaku_lora_bundle:
-                local_a = local_a.to(device=out.device, dtype=out.dtype)
-                local_b = local_b.to(device=out.device, dtype=out.dtype)
-                lora_term = (x_flat @ local_a.transpose(0, 1)) @ local_b.transpose(0, 1)
-                try:
-                    out = out + lora_term.reshape(out.shape)
-                except Exception:
-                    pass
-            return out
-
-        module.forward = _awq_lora_forward
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        model._lora_slots[module_name] = {"type": "awq_w4a16"}
-        return
-
-    if hasattr(module, "proj_down") and hasattr(module, "proj_up"):
-        proj_down = unpack_lowrank_weight(module.proj_down.data, down=True)
-        proj_up = unpack_lowrank_weight(module.proj_up.data, down=False)
-        base_rank = proj_down.shape[0] if proj_down.shape[1] == module.in_features else proj_down.shape[1]
-        if proj_down.shape[1] == module.in_features:
-            updated_down = torch.cat([proj_down, a_tensor], dim=0)
-            axis_down = 0
-        else:
-            updated_down = torch.cat([proj_down, a_tensor.T], dim=1)
-            axis_down = 1
-        updated_up = torch.cat([proj_up, b_tensor], dim=1)
-        module.proj_down.data = pack_lowrank_weight(updated_down, down=True)
-        module.proj_up.data = pack_lowrank_weight(updated_up, down=False)
-        module.rank = base_rank + a_tensor.shape[0]
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        model._lora_slots[module_name] = {
-            "type": "nunchaku",
-            "base_rank": base_rank,
-            "axis_down": axis_down,
-        }
-        return
-
-    if isinstance(module, nn.Linear):
-        if not hasattr(model, "_lora_slots"):
-            model._lora_slots = {}
-        if module_name not in model._lora_slots:
-            model._lora_slots[module_name] = {
-                "type": "linear",
-                "original_weight": module.weight.detach().cpu().clone(),
-            }
-        module.weight.data.add_((b_tensor @ a_tensor).to(dtype=module.weight.dtype, device=module.weight.device))
-        return
-
-    raise ValueError(f"{module_name}: unsupported module type {type(module)}")
-
-
-def reset_lora_v2(model: nn.Module) -> None:
-    slots = getattr(model, "_lora_slots", None)
-    if not slots:
-        return
-    for name, info in list(slots.items()):
-        module = _get_module_by_name(model, name)
-        if module is None:
-            continue
-        module_type = info.get("type", "nunchaku")
-        if module_type == "nunchaku":
-            base_rank = info["base_rank"]
-            proj_down = unpack_lowrank_weight(module.proj_down.data, down=True)
-            proj_up = unpack_lowrank_weight(module.proj_up.data, down=False)
-            if info.get("axis_down", 0) == 0:
-                proj_down = proj_down[:base_rank, :].clone()
-            else:
-                proj_down = proj_down[:, :base_rank].clone()
-            proj_up = proj_up[:, :base_rank].clone()
-            module.proj_down.data = pack_lowrank_weight(proj_down, down=True)
-            module.proj_up.data = pack_lowrank_weight(proj_up, down=False)
-            module.rank = base_rank
-        elif module_type == "linear" and "original_weight" in info:
-            module.weight.data.copy_(info["original_weight"].to(device=module.weight.device, dtype=module.weight.dtype))
-        elif module_type == "awq_w4a16":
-            if hasattr(module, "_lora_original_forward"):
-                module.forward = module._lora_original_forward
-            for attr in ("_lora_original_forward", "_nunchaku_lora_bundle"):
-                if hasattr(module, attr):
-                    delattr(module, attr)
-    model._lora_slots = {}
-
-
-def compose_loras_v2(model: nn.Module, lora_configs: List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]], apply_awq_mod: bool = True) -> bool:
-    del apply_awq_mod  # retained for interface compatibility
-    reset_lora_v2(model)
-    aggregated_weights: Dict[str, List[Dict[str, object]]] = defaultdict(list)
-    saw_supported_format = False
-    unresolved_targets = 0
-
-    for index, (path_or_dict, strength) in enumerate(lora_configs):
-        if abs(strength) < 1e-5:
-            continue
-        lora_name = str(path_or_dict) if not isinstance(path_or_dict, dict) else f"lora_{index}"
-        lora_state_dict = _load_lora_state_dict(path_or_dict)
-        if not lora_state_dict or not _detect_lora_format(lora_state_dict):
-            logger.warning("Skipping unsupported Qwen LoRA: %s", lora_name)
-            continue
-        saw_supported_format = True
-
-        grouped_weights: Dict[str, Dict[str, torch.Tensor]] = defaultdict(dict)
-        for key, value in lora_state_dict.items():
-            parsed = _classify_and_map_key(key)
-            if parsed is None:
-                continue
-            group, base_key, component, ab = parsed
-            if component and ab:
-                grouped_weights[base_key][f"{component}_{ab}"] = value
-            else:
-                grouped_weights[base_key][ab] = value
-
-        processed_groups: Dict[str, Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]] = {}
-        handled: set[str] = set()
-        for base_key, weights in grouped_weights.items():
-            if base_key in handled:
-                continue
-            a_tensor = b_tensor = alpha = None
-            if "qkv" in base_key or "add_qkv_proj" in base_key:
-                a_tensor, b_tensor, alpha = _fuse_qkv_lora(weights, model=model, base_key=base_key)
-            elif "w1_A" in weights or "w3_A" in weights:
-                a_tensor, b_tensor, alpha = _fuse_glu_lora(weights)
-            elif ".proj_out" in base_key and "single_transformer_blocks" in base_key:
-                split_map, consumed = _handle_proj_out_split(grouped_weights, base_key, model)
-                processed_groups.update(split_map)
-                handled.update(consumed)
-                continue
-            else:
-                a_tensor, b_tensor, alpha = weights.get("A"), weights.get("B"), weights.get("alpha")
-            if a_tensor is not None and b_tensor is not None:
-                processed_groups[base_key] = (a_tensor, b_tensor, alpha)
-
-        for module_name, (a_tensor, b_tensor, alpha) in processed_groups.items():
-            aggregated_weights[module_name].append({
-                "A": a_tensor,
-                "B": b_tensor,
-                "alpha": alpha,
-                "strength": strength,
-            })
-
-    for module_name, weight_list in aggregated_weights.items():
-        resolved_name, module = _resolve_module_name(model, module_name)
-        if module is None:
-            logger.warning("Skipping unresolved Qwen LoRA target: %s", module_name)
-            unresolved_targets += 1
-            continue
-        all_a = []
-        all_b_scaled = []
-        for item in weight_list:
-            a_tensor = item["A"]
-            b_tensor = item["B"]
-            alpha = item["alpha"]
-            strength = float(item["strength"])
-            rank = a_tensor.shape[0]
-            scale = strength * ((alpha / rank) if alpha is not None else 1.0)
-            if module.__class__.__name__ == "AWQW4A16Linear" and hasattr(module, "qweight"):
-                target_dtype = torch.float16
-                target_device = module.qweight.device
-            elif hasattr(module, "proj_down"):
-                target_dtype = module.proj_down.dtype
-                target_device = module.proj_down.device
-            elif hasattr(module, "weight"):
-                target_dtype = module.weight.dtype
-                target_device = module.weight.device
-            else:
-                target_dtype = torch.float16
-                target_device = "cuda" if torch.cuda.is_available() else "cpu"
-            all_a.append(a_tensor.to(dtype=target_dtype, device=target_device))
-            all_b_scaled.append((b_tensor * scale).to(dtype=target_dtype, device=target_device))
-        if not all_a:
-            continue
-        _apply_lora_to_module(module, torch.cat(all_a, dim=0), torch.cat(all_b_scaled, dim=1), resolved_name, model)
-
-    slot_count = len(getattr(model, "_lora_slots", {}) or {})
-    logger.info(
-        "Qwen LoRA composition finished: requested=%d supported=%s applied_targets=%d unresolved=%d",
-        len(lora_configs),
-        saw_supported_format,
-        slot_count,
-        unresolved_targets,
-    )
-    return saw_supported_format
-
-
-class ComfyQwenImageWrapperLM(nn.Module):
-    def __init__(self, model: nn.Module, config=None, apply_awq_mod: bool = True):
-        super().__init__()
-        self.model = model
-        self.config = {} if config is None else config
-        self.dtype = next(model.parameters()).dtype
-        self.loras: List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]] = []
-        self._applied_loras: Optional[List[Tuple[Union[str, Path, Dict[str, torch.Tensor]], float]]] = None
-        self.apply_awq_mod = apply_awq_mod
-
-    def __getattr__(self, name):
-        try:
-            inner = object.__getattribute__(self, "_modules").get("model")
-        except (AttributeError, KeyError):
-            inner = None
-        if inner is None:
-            raise AttributeError(f"{type(self).__name__!s} has no attribute {name}")
-        if name == "model":
-            return inner
-        return getattr(inner, name)
-
-    def process_img(self, *args, **kwargs):
-        return self.model.process_img(*args, **kwargs)
-
-    def _ensure_composed(self):
-        if self._applied_loras != self.loras or (not self.loras and getattr(self.model, "_lora_slots", None)):
-            is_supported_format = compose_loras_v2(self.model, self.loras, apply_awq_mod=self.apply_awq_mod)
-            self._applied_loras = self.loras.copy()
-            has_slots = bool(getattr(self.model, "_lora_slots", None))
-            if self.loras and is_supported_format and not has_slots:
-                logger.warning("Qwen LoRA compose produced 0 target modules. Resetting and retrying once.")
-                reset_lora_v2(self.model)
-                compose_loras_v2(self.model, self.loras, apply_awq_mod=self.apply_awq_mod)
-                has_slots = bool(getattr(self.model, "_lora_slots", None))
-                logger.info("Qwen LoRA retry result: applied_targets=%d", len(getattr(self.model, "_lora_slots", {}) or {}))
-
-            offload_manager = getattr(self.model, "offload_manager", None)
-            if offload_manager is not None:
-                offload_settings = {
-                    "num_blocks_on_gpu": getattr(offload_manager, "num_blocks_on_gpu", 1),
-                    "use_pin_memory": getattr(offload_manager, "use_pin_memory", False),
-                }
-                logger.info(
-                    "Rebuilding Qwen offload manager after LoRA compose: num_blocks_on_gpu=%s use_pin_memory=%s",
-                    offload_settings["num_blocks_on_gpu"],
-                    offload_settings["use_pin_memory"],
-                )
-                self.model.set_offload(False)
-                self.model.set_offload(True, **offload_settings)
-
-    def forward(self, *args, **kwargs):
-        self._ensure_composed()
-        return self.model(*args, **kwargs)
-
-
-def _get_qwen_wrapper_and_transformer(model):
-    model_wrapper = model.model.diffusion_model
-    if hasattr(model_wrapper, "model") and hasattr(model_wrapper, "loras"):
-        transformer = model_wrapper.model
-        if transformer.__class__.__name__.endswith("NunchakuQwenImageTransformer2DModel"):
-            return model_wrapper, transformer
-    if model_wrapper.__class__.__name__.endswith("NunchakuQwenImageTransformer2DModel"):
-        wrapped_model = ComfyQwenImageWrapperLM(model_wrapper, getattr(model_wrapper, "config", {}))
-        model.model.diffusion_model = wrapped_model
-        return wrapped_model, wrapped_model.model
-    raise TypeError(f"This LoRA loader only works with Nunchaku Qwen Image models, but got {type(model_wrapper).__name__}.")
-
-
-def nunchaku_load_qwen_loras(model, lora_configs: List[Tuple[str, float]], apply_awq_mod: bool = True):
-    model_wrapper, transformer = _get_qwen_wrapper_and_transformer(model)
-    model_wrapper.apply_awq_mod = apply_awq_mod
-
-    saved_config = None
-    if hasattr(model, "model") and hasattr(model.model, "model_config"):
-        saved_config = model.model.model_config
-        model.model.model_config = None
-
-    model_wrapper.model = None
-    try:
-        ret_model = copy.deepcopy(model)
-    finally:
-        if saved_config is not None:
-            model.model.model_config = saved_config
-        model_wrapper.model = transformer
-
-    ret_model_wrapper = ret_model.model.diffusion_model
-    if saved_config is not None:
-        ret_model.model.model_config = saved_config
-    ret_model_wrapper.model = transformer
-    ret_model_wrapper.apply_awq_mod = apply_awq_mod
-    ret_model_wrapper.loras = list(getattr(model_wrapper, "loras", []))
-
-    for lora_name, lora_strength in lora_configs:
-        lora_path = lora_name if os.path.isfile(lora_name) else folder_paths.get_full_path("loras", lora_name)
-        if not lora_path or not os.path.isfile(lora_path):
-            logger.warning("Skipping Qwen LoRA '%s' because it could not be found", lora_name)
-            continue
-        ret_model_wrapper.loras.append((lora_path, lora_strength))
-
-    return ret_model

py/nodes/prompt.py

@@ -1,39 +1,4 @@
-from __future__ import annotations
-
-from typing import Any
-import inspect
-
-from ..services.wildcard_service import (
-    contains_dynamic_syntax,
-    get_wildcard_service,
-    is_trigger_words_input,
-)
-
-
-class _PromptOptionalInputs:
-    """Lookup that preserves explicit optional inputs and dynamic trigger slots."""
-
-    def __init__(self, explicit_inputs: dict[str, tuple[str, dict[str, Any]]]) -> None:
-        self._explicit_inputs = explicit_inputs
-
-    def __contains__(self, item: object) -> bool:
-        if not isinstance(item, str):
-            return False
-        return item in self._explicit_inputs or is_trigger_words_input(item)
-
-    def __getitem__(self, key: str) -> tuple[str, dict[str, Any]]:
-        if key in self._explicit_inputs:
-            return self._explicit_inputs[key]
-        if is_trigger_words_input(key):
-            return (
-                "STRING",
-                {
-                    "forceInput": True,
-                    "tooltip": "Trigger words to prepend. Connect to add more inputs.",
-                },
-            )
-        raise KeyError(key)
-
+from typing import Any, Optional
 
 class PromptLM:
     """Encodes text (and optional trigger words) into CLIP conditioning."""
@@ -42,91 +7,52 @@ class PromptLM:
     CATEGORY = "Lora Manager/conditioning"
     DESCRIPTION = (
         "Encodes a text prompt using a CLIP model into an embedding that can be used "
-        "to guide the diffusion model towards generating specific images. "
-        "Supports dynamic trigger words inputs and runtime wildcard expansion."
+        "to guide the diffusion model towards generating specific images."
     )
 
     @classmethod
     def INPUT_TYPES(cls):
-        optional_inputs: dict[str, tuple[str, dict[str, Any]]] = {
-            "seed": (
-                "INT",
-                {
-                    "forceInput": True,
-                    "tooltip": "Optional seed for wildcard generation. Leave unconnected for non-deterministic wildcard expansion.",
-                },
-            ),
-            "trigger_words1": (
-                "STRING",
-                {
-                    "forceInput": True,
-                    "tooltip": "Trigger words to prepend. Connect to add more inputs.",
-                },
-            ),
-        }
-
-        stack = inspect.stack()
-        if len(stack) > 2 and stack[2].function == "get_input_info":
-            optional_inputs = _PromptOptionalInputs(optional_inputs)  # type: ignore[assignment]
-
         return {
             "required": {
                 "text": (
                     "AUTOCOMPLETE_TEXT_PROMPT,STRING",
                     {
                         "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
-                        "placeholder": "Enter prompt... /character, /artist, /wildcard for quick search",
-                        "tooltip": "The text to be encoded. Wildcard references inserted with /wildcard are expanded at runtime.",
+                        "placeholder": "Enter prompt... /char, /artist for quick tag search",
+                        "tooltip": "The text to be encoded.",
                     },
                 ),
                 "clip": (
-                    "CLIP",
+                    'CLIP',
                     {"tooltip": "The CLIP model used for encoding the text."},
                 ),
             },
-            "optional": optional_inputs,
+            "optional": {
+                "trigger_words": (
+                    'STRING',
+                    {
+                        "forceInput": True,
+                        "tooltip": (
+                            "Optional trigger words to prepend to the text before "
+                            "encoding."
+                        )
+                    },
+                )
+            },
         }
 
-    RETURN_TYPES = ("CONDITIONING", "STRING")
-    RETURN_NAMES = ("CONDITIONING", "PROMPT")
+    RETURN_TYPES = ('CONDITIONING', 'STRING',)
+    RETURN_NAMES = ('CONDITIONING', 'PROMPT',)
     OUTPUT_TOOLTIPS = (
         "A conditioning containing the embedded text used to guide the diffusion model.",
     )
     FUNCTION = "encode"
 
-    @classmethod
-    def IS_CHANGED(
-        cls,
-        text: str,
-        clip: Any | None = None,
-        seed: int | None = None,
-        **kwargs: Any,
-    ):
-        del clip, kwargs
-        if contains_dynamic_syntax(text) and seed is None:
-            return float("NaN")
-        return False
-
-    def encode(
-        self,
-        text: str,
-        clip: Any,
-        seed: int | None = None,
-        **kwargs: Any,
-    ):
-        expanded_text = get_wildcard_service().expand_text(text, seed=seed)
-
-        trigger_words = []
-        for key, value in kwargs.items():
-            if is_trigger_words_input(key) and value:
-                trigger_words.append(value)
-
+    def encode(self, text: str, clip: Any, trigger_words: Optional[str] = None):
+        prompt = text
         if trigger_words:
-            prompt = ", ".join(trigger_words + [expanded_text])
-        else:
-            prompt = expanded_text
+            prompt = ", ".join([trigger_words, text])
 
         from nodes import CLIPTextEncode  # type: ignore
-
         conditioning = CLIPTextEncode().encode(clip, prompt)[0]
-        return (conditioning, prompt)
+        return (conditioning, prompt,)

py/nodes/save_image.py

@@ -1,24 +1,17 @@
 import json
 import os
 import re
-import time
-import uuid
-from typing import Any, Dict, Optional
 import numpy as np
 import folder_paths # type: ignore
 from ..services.service_registry import ServiceRegistry
 from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
-from ..utils.constants import CARD_PREVIEW_WIDTH
-from ..utils.exif_utils import ExifUtils
-from ..utils.utils import calculate_recipe_fingerprint, sanitize_folder_name
 from PIL import Image, PngImagePlugin
 import piexif
 import logging
 
 logger = logging.getLogger(__name__)
 
-
 class SaveImageLM:
     NAME = "Save Image (LoraManager)"
     CATEGORY = "Lora Manager/utils"
@@ -39,65 +32,33 @@ class SaveImageLM:
         return {
             "required": {
                 "images": ("IMAGE",),
-                "filename_prefix": (
-                    "STRING",
-                    {
+                "filename_prefix": ("STRING", {
                     "default": "ComfyUI", 
-                        "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc.",
-                    },
-                ),
-                "file_format": (
-                    ["png", "jpeg", "webp"],
-                    {
+                    "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc."
+                }),
+                "file_format": (["png", "jpeg", "webp"], {
                     "tooltip": "Image format to save as. PNG preserves quality, JPEG is smaller, WebP balances size and quality."
-                    },
-                ),
+                }),
             },
             "optional": {
-                "lossless_webp": (
-                    "BOOLEAN",
-                    {
+                "lossless_webp": ("BOOLEAN", {
                     "default": False,
-                        "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss.",
-                    },
-                ),
-                "quality": (
-                    "INT",
-                    {
+                    "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss."
+                }),
+                "quality": ("INT", {
                     "default": 100, 
                     "min": 1, 
                     "max": 100,
-                        "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files.",
-                    },
-                ),
-                "embed_workflow": (
-                    "BOOLEAN",
-                    {
+                    "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files."
+                }),
+                "embed_workflow": ("BOOLEAN", {
                     "default": False,
-                        "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats.",
-                    },
-                ),
-                "save_with_metadata": (
-                    "BOOLEAN",
-                    {
+                    "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats."
+                }),
+                "add_counter_to_filename": ("BOOLEAN", {
                     "default": True,
-                        "tooltip": "When enabled, embeds generation parameters into the saved image metadata. Disable to skip writing generation metadata.",
-                    },
-                ),
-                "add_counter_to_filename": (
-                    "BOOLEAN",
-                    {
-                        "default": True,
-                        "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images.",
-                    },
-                ),
-                "save_as_recipe": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                        "tooltip": "Also saves each generated image as a LoRA Manager recipe.",
-                    },
-                ),
+                    "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images."
+                }),
             },
             "hidden": {
                 "id": "UNIQUE_ID",
@@ -116,7 +77,6 @@ class SaveImageLM:
         scanner = ServiceRegistry.get_service_sync("lora_scanner")
         
         # Use the new direct filename lookup method
-        if scanner is not None:
         hash_value = scanner.get_hash_by_filename(lora_name)
         if hash_value:
             return hash_value
@@ -135,7 +95,6 @@ class SaveImageLM:
         checkpoint_name = os.path.splitext(checkpoint_name)[0]
         
         # Try direct filename lookup first
-        if scanner is not None:
         hash_value = scanner.get_hash_by_filename(checkpoint_name)
         if hash_value:
             return hash_value
@@ -153,11 +112,11 @@ class SaveImageLM:
                 param_list.append(f"{label}: {value}")
         
         # Extract the prompt and negative prompt
-        prompt = metadata_dict.get("prompt", "")
-        negative_prompt = metadata_dict.get("negative_prompt", "")
+        prompt = metadata_dict.get('prompt', '')
+        negative_prompt = metadata_dict.get('negative_prompt', '')
         
         # Extract loras from the prompt if present
-        loras_text = metadata_dict.get("loras", "")
+        loras_text = metadata_dict.get('loras', '')
         lora_hashes = {}
         
         # If loras are found, add them on a new line after the prompt
@@ -165,7 +124,7 @@ class SaveImageLM:
             prompt_with_loras = f"{prompt}\n{loras_text}"
             
             # Extract lora names from the format <lora:name:strength>
-            lora_matches = re.findall(r"<lora:([^:]+):([^>]+)>", loras_text)
+            lora_matches = re.findall(r'<lora:([^:]+):([^>]+)>', loras_text)
             
             # Get hash for each lora
             for lora_name, strength in lora_matches:
@@ -186,43 +145,43 @@ class SaveImageLM:
         params = []
         
         # Add standard parameters in the correct order
-        if "steps" in metadata_dict:
-            add_param_if_not_none(params, "Steps", metadata_dict.get("steps"))
+        if 'steps' in metadata_dict:
+            add_param_if_not_none(params, "Steps", metadata_dict.get('steps'))
         
         # Combine sampler and scheduler information
         sampler_name = None
         scheduler_name = None
         
-        if "sampler" in metadata_dict:
-            sampler = metadata_dict.get("sampler")
+        if 'sampler' in metadata_dict:
+            sampler = metadata_dict.get('sampler')
             # Convert ComfyUI sampler names to user-friendly names
             sampler_mapping = {
-                "euler": "Euler",
-                "euler_ancestral": "Euler a",
-                "dpm_2": "DPM2",
-                "dpm_2_ancestral": "DPM2 a",
-                "heun": "Heun",
-                "dpm_fast": "DPM fast",
-                "dpm_adaptive": "DPM adaptive",
-                "lms": "LMS",
-                "dpmpp_2s_ancestral": "DPM++ 2S a",
-                "dpmpp_sde": "DPM++ SDE",
-                "dpmpp_sde_gpu": "DPM++ SDE",
-                "dpmpp_2m": "DPM++ 2M",
-                "dpmpp_2m_sde": "DPM++ 2M SDE",
-                "dpmpp_2m_sde_gpu": "DPM++ 2M SDE",
-                "ddim": "DDIM",
+                'euler': 'Euler',
+                'euler_ancestral': 'Euler a',
+                'dpm_2': 'DPM2',
+                'dpm_2_ancestral': 'DPM2 a',
+                'heun': 'Heun',
+                'dpm_fast': 'DPM fast',
+                'dpm_adaptive': 'DPM adaptive',
+                'lms': 'LMS',
+                'dpmpp_2s_ancestral': 'DPM++ 2S a',
+                'dpmpp_sde': 'DPM++ SDE',
+                'dpmpp_sde_gpu': 'DPM++ SDE',
+                'dpmpp_2m': 'DPM++ 2M',
+                'dpmpp_2m_sde': 'DPM++ 2M SDE',
+                'dpmpp_2m_sde_gpu': 'DPM++ 2M SDE',
+                'ddim': 'DDIM'
             }
             sampler_name = sampler_mapping.get(sampler, sampler)
         
-        if "scheduler" in metadata_dict:
-            scheduler = metadata_dict.get("scheduler")
+        if 'scheduler' in metadata_dict:
+            scheduler = metadata_dict.get('scheduler')
             scheduler_mapping = {
-                "normal": "Simple",
-                "karras": "Karras",
-                "exponential": "Exponential",
-                "sgm_uniform": "SGM Uniform",
-                "sgm_quadratic": "SGM Quadratic",
+                'normal': 'Simple',
+                'karras': 'Karras',
+                'exponential': 'Exponential',
+                'sgm_uniform': 'SGM Uniform',
+                'sgm_quadratic': 'SGM Quadratic'
             }
             scheduler_name = scheduler_mapping.get(scheduler, scheduler)
         
@@ -234,25 +193,25 @@ class SaveImageLM:
                 params.append(f"Sampler: {sampler_name}")
         
         # CFG scale (Use guidance if available, otherwise fall back to cfg_scale or cfg)
-        if "guidance" in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("guidance"))
-        elif "cfg_scale" in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg_scale"))
-        elif "cfg" in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg"))
+        if 'guidance' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('guidance'))
+        elif 'cfg_scale' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg_scale'))
+        elif 'cfg' in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg'))
         
         # Seed
-        if "seed" in metadata_dict:
-            add_param_if_not_none(params, "Seed", metadata_dict.get("seed"))
+        if 'seed' in metadata_dict:
+            add_param_if_not_none(params, "Seed", metadata_dict.get('seed'))
         
         # Size
-        if "size" in metadata_dict:
-            add_param_if_not_none(params, "Size", metadata_dict.get("size"))
+        if 'size' in metadata_dict:
+            add_param_if_not_none(params, "Size", metadata_dict.get('size'))
         
         # Model info
-        if "checkpoint" in metadata_dict:
+        if 'checkpoint' in metadata_dict:
             # Ensure checkpoint is a string before processing
-            checkpoint = metadata_dict.get("checkpoint")
+            checkpoint = metadata_dict.get('checkpoint')
             if checkpoint is not None:
                 # Get model hash
                 model_hash = self.get_checkpoint_hash(checkpoint)
@@ -264,9 +223,7 @@ class SaveImageLM:
                 
                 # Add model hash if available
                 if model_hash:
-                    params.append(
-                        f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}"
-                    )
+                    params.append(f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}")
                 else:
                     params.append(f"Model: {checkpoint_name}")
         
@@ -277,7 +234,7 @@ class SaveImageLM:
                 lora_hash_parts.append(f"{lora_name}: {hash_value[:10]}")
             
             if lora_hash_parts:
-                params.append(f'Lora hashes: "{", ".join(lora_hash_parts)}"')
+                params.append(f"Lora hashes: \"{', '.join(lora_hash_parts)}\"")
         
         # Combine all parameters with commas
         metadata_parts.append(", ".join(params))
@@ -297,37 +254,30 @@ class SaveImageLM:
             parts = segment.replace("%", "").split(":")
             key = parts[0]
             
-            if key == "seed" and "seed" in metadata_dict:
-                seed_value = metadata_dict.get("seed")
-                if seed_value is not None:
-                    filename = filename.replace(segment, str(seed_value))
-                else:
-                    # Fallback if seed was not captured by metadata collector
-                    filename = filename.replace(segment, "0")
-            elif key == "width" and "size" in metadata_dict:
-                size = metadata_dict.get("size", "x")
-                w = size.split("x")[0] if isinstance(size, str) else size[0]
+            if key == "seed" and 'seed' in metadata_dict:
+                filename = filename.replace(segment, str(metadata_dict.get('seed', '')))
+            elif key == "width" and 'size' in metadata_dict:
+                size = metadata_dict.get('size', 'x')
+                w = size.split('x')[0] if isinstance(size, str) else size[0]
                 filename = filename.replace(segment, str(w))
-            elif key == "height" and "size" in metadata_dict:
-                size = metadata_dict.get("size", "x")
-                h = size.split("x")[1] if isinstance(size, str) else size[1]
+            elif key == "height" and 'size' in metadata_dict:
+                size = metadata_dict.get('size', 'x')
+                h = size.split('x')[1] if isinstance(size, str) else size[1]
                 filename = filename.replace(segment, str(h))
-            elif key == "pprompt" and "prompt" in metadata_dict:
-                prompt = metadata_dict.get("prompt", "").replace("\n", " ")
-                prompt = sanitize_folder_name(prompt)
+            elif key == "pprompt" and 'prompt' in metadata_dict:
+                prompt = metadata_dict.get('prompt', '').replace("\n", " ")
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
-            elif key == "nprompt" and "negative_prompt" in metadata_dict:
-                prompt = metadata_dict.get("negative_prompt", "").replace("\n", " ")
-                prompt = sanitize_folder_name(prompt)
+            elif key == "nprompt" and 'negative_prompt' in metadata_dict:
+                prompt = metadata_dict.get('negative_prompt', '').replace("\n", " ")
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
             elif key == "model":
-                model_value = metadata_dict.get("checkpoint")
+                model_value = metadata_dict.get('checkpoint')
                 if isinstance(model_value, (bytes, os.PathLike)):
                     model_value = str(model_value)
 
@@ -335,14 +285,12 @@ class SaveImageLM:
                     model = "model_unavailable"
                 else:
                     model = os.path.splitext(os.path.basename(model_value))[0]
-                    model = sanitize_folder_name(model)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     model = model[:length]
                 filename = filename.replace(segment, model)
             elif key == "date":
                 from datetime import datetime
-
                 now = datetime.now()
                 date_table = {
                     "yyyy": f"{now.year:04d}",
@@ -366,218 +314,8 @@ class SaveImageLM:
                     
         return filename
 
-    @staticmethod
-    def _get_cached_model_by_name(scanner, name):
-        cache = getattr(scanner, "_cache", None)
-        if cache is None or not name:
-            return None
-
-        candidates = [
-            name,
-            os.path.basename(name),
-            os.path.splitext(os.path.basename(name))[0],
-        ]
-        for model in getattr(cache, "raw_data", []):
-            file_name = model.get("file_name")
-            if file_name in candidates:
-                return model
-        return None
-
-    def _build_recipe_loras(self, recipe_scanner, lora_stack):
-        lora_matches = re.findall(r"<lora:([^:]+):([^>]+)>", lora_stack or "")
-        lora_scanner = getattr(recipe_scanner, "_lora_scanner", None)
-        loras_data = []
-        base_model_counts = {}
-
-        for name, strength in lora_matches:
-            lora_info = self._get_cached_model_by_name(lora_scanner, name)
-            civitai = (lora_info or {}).get("civitai") or {}
-            civitai_model = civitai.get("model") or {}
-            try:
-                parsed_strength = float(strength)
-            except (TypeError, ValueError):
-                parsed_strength = 1.0
-
-            loras_data.append(
-                {
-                    "file_name": name,
-                    "strength": parsed_strength,
-                    "hash": ((lora_info or {}).get("sha256") or "").lower(),
-                    "modelVersionId": civitai.get("id", 0),
-                    "modelName": civitai_model.get("name", name) if lora_info else "",
-                    "modelVersionName": civitai.get("name", "") if lora_info else "",
-                    "isDeleted": False,
-                    "exclude": False,
-                }
-            )
-
-            base_model = (lora_info or {}).get("base_model")
-            if base_model:
-                base_model_counts[base_model] = base_model_counts.get(base_model, 0) + 1
-
-        return lora_matches, loras_data, base_model_counts
-
-    def _build_recipe_checkpoint(self, recipe_scanner, checkpoint_raw):
-        if not isinstance(checkpoint_raw, str) or not checkpoint_raw.strip():
-            return None
-
-        checkpoint_name = checkpoint_raw.strip()
-        file_name = os.path.splitext(os.path.basename(checkpoint_name))[0]
-        checkpoint_scanner = getattr(recipe_scanner, "_checkpoint_scanner", None)
-        checkpoint_info = self._get_cached_model_by_name(
-            checkpoint_scanner, checkpoint_name
-        )
-
-        if not checkpoint_info:
-            return {
-                "type": "checkpoint",
-                "name": checkpoint_name,
-                "file_name": file_name,
-                "hash": self.get_checkpoint_hash(checkpoint_name) or "",
-            }
-
-        civitai = checkpoint_info.get("civitai") or {}
-        civitai_model = civitai.get("model") or {}
-        file_path = checkpoint_info.get("file_path") or checkpoint_info.get("path") or ""
-        cached_file_name = (
-            checkpoint_info.get("file_name")
-            or (os.path.splitext(os.path.basename(file_path))[0] if file_path else "")
-            or file_name
-        )
-
-        return {
-            "type": "checkpoint",
-            "modelId": civitai_model.get("id", 0),
-            "modelVersionId": civitai.get("id", 0),
-            "name": civitai_model.get("name")
-            or checkpoint_info.get("model_name")
-            or checkpoint_name,
-            "version": civitai.get("name", ""),
-            "hash": (
-                checkpoint_info.get("sha256") or checkpoint_info.get("hash") or ""
-            ).lower(),
-            "file_name": cached_file_name,
-            "modelName": civitai_model.get("name", ""),
-            "modelVersionName": civitai.get("name", ""),
-            "baseModel": checkpoint_info.get("base_model")
-            or civitai.get("baseModel", ""),
-        }
-
-    @staticmethod
-    def _derive_recipe_name(lora_matches):
-        recipe_name_parts = [
-            f"{name.strip()}-{float(strength):.2f}" for name, strength in lora_matches[:3]
-        ]
-        return "_".join(recipe_name_parts) or "recipe"
-
-    @staticmethod
-    def _sync_recipe_cache(recipe_scanner, recipe_data, json_path):
-        cache = getattr(recipe_scanner, "_cache", None)
-        if cache is not None:
-            cache.raw_data.append(recipe_data)
-            cache.sorted_by_name = sorted(
-                cache.raw_data, key=lambda item: item.get("title", "").lower()
-            )
-            cache.sorted_by_date = sorted(
-                cache.raw_data,
-                key=lambda item: (
-                    item.get("modified", item.get("created_date", 0)),
-                    item.get("file_path", ""),
-                ),
-                reverse=True,
-            )
-            recipe_scanner._update_folder_metadata(cache)
-            recipe_scanner._update_fts_index_for_recipe(recipe_data, "add")
-
-        recipe_id = str(recipe_data.get("id", ""))
-        if recipe_id:
-            recipe_scanner._json_path_map[recipe_id] = json_path
-        persistent_cache = getattr(recipe_scanner, "_persistent_cache", None)
-        if persistent_cache:
-            persistent_cache.update_recipe(recipe_data, json_path)
-
-    def _save_image_as_recipe(self, file_path, metadata_dict):
-        if not metadata_dict:
-            raise ValueError("No generation metadata found")
-
-        recipe_scanner = ServiceRegistry.get_service_sync("recipe_scanner")
-        if recipe_scanner is None:
-            raise RuntimeError("Recipe scanner unavailable")
-
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir:
-            raise RuntimeError("Recipes directory unavailable")
-        os.makedirs(recipes_dir, exist_ok=True)
-
-        recipe_id = str(uuid.uuid4())
-        optimized_image, extension = ExifUtils.optimize_image(
-            image_data=file_path,
-            target_width=CARD_PREVIEW_WIDTH,
-            format="webp",
-            quality=85,
-            preserve_metadata=True,
-        )
-        image_path = os.path.normpath(os.path.join(recipes_dir, f"{recipe_id}{extension}"))
-        with open(image_path, "wb") as file_obj:
-            file_obj.write(optimized_image)
-
-        lora_stack = metadata_dict.get("loras", "")
-        lora_matches, loras_data, base_model_counts = self._build_recipe_loras(
-            recipe_scanner, lora_stack
-        )
-        checkpoint_entry = self._build_recipe_checkpoint(
-            recipe_scanner, metadata_dict.get("checkpoint")
-        )
-        most_common_base_model = (
-            max(base_model_counts.items(), key=lambda item: item[1])[0]
-            if base_model_counts
-            else ""
-        )
-        current_time = time.time()
-        recipe_data = {
-            "id": recipe_id,
-            "file_path": image_path,
-            "title": self._derive_recipe_name(lora_matches),
-            "modified": current_time,
-            "created_date": current_time,
-            "base_model": most_common_base_model
-            or (checkpoint_entry or {}).get("baseModel", ""),
-            "loras": loras_data,
-            "gen_params": {
-                key: value
-                for key, value in metadata_dict.items()
-                if key not in ["checkpoint", "loras"]
-            },
-            "loras_stack": lora_stack,
-            "fingerprint": calculate_recipe_fingerprint(loras_data),
-        }
-        if checkpoint_entry:
-            recipe_data["checkpoint"] = checkpoint_entry
-
-        json_path = os.path.normpath(
-            os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-        )
-        with open(json_path, "w", encoding="utf-8") as file_obj:
-            json.dump(recipe_data, file_obj, indent=4, ensure_ascii=False)
-
-        ExifUtils.append_recipe_metadata(image_path, recipe_data)
-        self._sync_recipe_cache(recipe_scanner, recipe_data, json_path)
-
-    def save_images(
-        self,
-        images,
-        filename_prefix,
-        file_format,
-        id,
-        prompt=None,
-        extra_pnginfo=None,
-        lossless_webp=True,
-        quality=100,
-        embed_workflow=False,
-        save_with_metadata=True,
-        add_counter_to_filename=True,
-        save_as_recipe=False,
-    ):
+    def save_images(self, images, filename_prefix, file_format, id, prompt=None, extra_pnginfo=None, 
+                   lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
         """Save images with metadata"""
         results = []
 
@@ -591,11 +329,9 @@ class SaveImageLM:
         filename_prefix = self.format_filename(filename_prefix, metadata_dict)
         
         # Get initial save path info once for the batch
-        full_output_folder, filename, counter, subfolder, processed_prefix = (
-            folder_paths.get_save_image_path(
+        full_output_folder, filename, counter, subfolder, processed_prefix = folder_paths.get_save_image_path(
             filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
         )
-        )
         
         # Create directory if it doesn't exist
         if not os.path.exists(full_output_folder):
@@ -604,20 +340,17 @@ class SaveImageLM:
         # Process each image with incrementing counter
         for i, image in enumerate(images):
             # Convert the tensor image to numpy array
-            img = 255.0 * image.cpu().numpy()
+            img = 255. * image.cpu().numpy()
             img = Image.fromarray(np.clip(img, 0, 255).astype(np.uint8))
             
             # Generate filename with counter if needed
-            base_filename = filename.replace("%batch_num%", str(i))
+            base_filename = filename
             if add_counter_to_filename:
                 # Use counter + i to ensure unique filenames for all images in batch
                 current_counter = counter + i
                 base_filename += f"_{current_counter:05}_"
                 
             # Set file extension and prepare saving parameters
-            file: str
-            save_kwargs: Dict[str, Any]
-            pnginfo: Optional[PngImagePlugin.PngInfo] = None
             if file_format == "png":
                 file = base_filename + ".png"
                 file_extension = ".png"
@@ -632,13 +365,7 @@ class SaveImageLM:
                 file = base_filename + ".webp" 
                 file_extension = ".webp"
                 # Add optimization param to control performance
-                save_kwargs = {
-                    "quality": quality,
-                    "lossless": lossless_webp,
-                    "method": 0,
-                }
-            else:
-                raise ValueError(f"Unsupported file format: {file_format}")
+                save_kwargs = {"quality": quality, "lossless": lossless_webp, "method": 0}
             
             # Full save path
             file_path = os.path.join(full_output_folder, file)
@@ -646,8 +373,7 @@ class SaveImageLM:
             # Save the image with metadata
             try:
                 if file_format == "png":
-                    assert pnginfo is not None
-                    if save_with_metadata and metadata:
+                    if metadata:
                         pnginfo.add_text("parameters", metadata)
                     if embed_workflow and extra_pnginfo is not None:
                         workflow_json = json.dumps(extra_pnginfo["workflow"])
@@ -656,14 +382,9 @@ class SaveImageLM:
                     img.save(file_path, format="PNG", **save_kwargs)
                 elif file_format == "jpeg":
                     # For JPEG, use piexif
-                    if save_with_metadata and metadata:
+                    if metadata:
                         try:
-                            exif_dict = {
-                                "Exif": {
-                                    piexif.ExifIFD.UserComment: b"UNICODE\0"
-                                    + metadata.encode("utf-16be")
-                                }
-                            }
+                            exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
                             exif_bytes = piexif.dump(exif_dict)
                             save_kwargs["exif"] = exif_bytes
                         except Exception as e:
@@ -674,19 +395,13 @@ class SaveImageLM:
                         # For WebP, use piexif for metadata
                         exif_dict = {}
 
-                        if save_with_metadata and metadata:
-                            exif_dict["Exif"] = {
-                                piexif.ExifIFD.UserComment: b"UNICODE\0"
-                                + metadata.encode("utf-16be")
-                            }
+                        if metadata:
+                            exif_dict['Exif'] = {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}
                         
                         # Add workflow if needed
                         if embed_workflow and extra_pnginfo is not None:
                             workflow_json = json.dumps(extra_pnginfo["workflow"]) 
-                            exif_dict["0th"] = {
-                                piexif.ImageIFD.ImageDescription: "Workflow:"
-                                + workflow_json
-                            }
+                            exif_dict['0th'] = {piexif.ImageIFD.ImageDescription: "Workflow:" + workflow_json}
                             
                         exif_bytes = piexif.dump(exif_dict)
                         save_kwargs["exif"] = exif_bytes
@@ -695,38 +410,19 @@ class SaveImageLM:
                     
                     img.save(file_path, format="WEBP", **save_kwargs)
                 
-                if save_as_recipe:
-                    try:
-                        self._save_image_as_recipe(file_path, metadata_dict)
-                    except Exception as e:
-                        logger.warning(
-                            "Failed to save image as recipe: %s", e, exc_info=True
-                        )
-
-                results.append(
-                    {"filename": file, "subfolder": subfolder, "type": self.type}
-                )
+                results.append({
+                    "filename": file,
+                    "subfolder": subfolder,
+                    "type": self.type
+                })
                 
             except Exception as e:
                 logger.error(f"Error saving image: {e}")
         
         return results
 
-    def process_image(
-        self,
-        images,
-        id,
-        filename_prefix="ComfyUI",
-        file_format="png",
-        prompt=None,
-        extra_pnginfo=None,
-        lossless_webp=True,
-        quality=100,
-        embed_workflow=False,
-        save_with_metadata=True,
-        add_counter_to_filename=True,
-        save_as_recipe=False,
-    ):
+    def process_image(self, images, id, filename_prefix="ComfyUI", file_format="png", prompt=None, extra_pnginfo=None,
+                     lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
         """Process and save image with metadata"""
         # Make sure the output directory exists
         os.makedirs(self.output_dir, exist_ok=True)
@@ -752,12 +448,7 @@ class SaveImageLM:
             lossless_webp,
             quality,
             embed_workflow,
-            save_with_metadata,
-            add_counter_to_filename,
-            save_as_recipe,
+            add_counter_to_filename
         )
         
-        return {
-            "result": (images,),
-            "ui": {"images": results},
-        }
+        return (images,)

py/nodes/text.py

@@ -1,15 +1,10 @@
-from __future__ import annotations
-
-from ..services.wildcard_service import contains_dynamic_syntax, get_wildcard_service
-
-
 class TextLM:
     """A simple text node with autocomplete support."""
 
     NAME = "Text (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = (
-        "A simple text input node with autocomplete support for tags, styles, and wildcard expansion."
+        "A simple text input node with autocomplete support for tags and styles."
     )
 
     @classmethod
@@ -20,17 +15,8 @@ class TextLM:
                     "AUTOCOMPLETE_TEXT_PROMPT,STRING",
                     {
                         "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
-                        "placeholder": "Enter text... /character, /artist, /wildcard for quick search",
-                        "tooltip": "The text output. Wildcard references inserted with /wildcard are expanded at runtime.",
-                    },
-                ),
-            },
-            "optional": {
-                "seed": (
-                    "INT",
-                    {
-                        "forceInput": True,
-                        "tooltip": "Optional seed for wildcard generation. Leave unconnected for non-deterministic wildcard expansion.",
+                        "placeholder": "Enter text... /char, /artist for quick tag search",
+                        "tooltip": "The text output.",
                     },
                 ),
             },
@@ -38,14 +24,10 @@ class TextLM:
 
     RETURN_TYPES = ("STRING",)
     RETURN_NAMES = ("STRING",)
-    OUTPUT_TOOLTIPS = ("The text output.",)
+    OUTPUT_TOOLTIPS = (
+        "The text output.",
+    )
     FUNCTION = "process"
 
-    @classmethod
-    def IS_CHANGED(cls, text: str, seed: int | None = None):
-        if contains_dynamic_syntax(text) and seed is None:
-            return float("NaN")
-        return False
-
-    def process(self, text: str, seed: int | None = None):
-        return (get_wildcard_service().expand_text(text, seed=seed),)
+    def process(self, text: str):
+        return (text,)

py/nodes/trigger_word_toggle.py

@@ -76,9 +76,6 @@ class TriggerWordToggleLM:
         # Filter out empty strings and return as set
         return set(word for word in words if word)
 
-    def _group_has_child_items(self, item):
-        return isinstance(item, dict) and isinstance(item.get("items"), list)
-
     def process_trigger_words(
         self,
         id,
@@ -115,11 +112,7 @@ class TriggerWordToggleLM:
 
                 if isinstance(trigger_data, list):
                     if group_mode:
-                        if any(self._group_has_child_items(item) for item in trigger_data):
-                            filtered_groups = self._process_group_items(
-                                trigger_data, allow_strength_adjustment
-                            )
-                        elif allow_strength_adjustment:
+                        if allow_strength_adjustment:
                             parsed_items = [
                                 self._parse_trigger_item(
                                     item, allow_strength_adjustment
@@ -181,41 +174,6 @@ class TriggerWordToggleLM:
 
         return (filtered_triggers,)
 
-    def _process_group_items(self, trigger_data, allow_strength_adjustment):
-        filtered_groups = []
-
-        for item in trigger_data:
-            group = self._parse_trigger_item(item, allow_strength_adjustment)
-            if not group["text"] or not group["active"]:
-                continue
-
-            raw_items = item.get("items") if isinstance(item, dict) else None
-            if isinstance(raw_items, list):
-                active_items = []
-                for raw_item in raw_items:
-                    child = self._parse_trigger_item(
-                        raw_item, allow_strength_adjustment=False
-                    )
-                    if child["text"] and child["active"]:
-                        active_items.append(child["text"])
-
-                if not active_items:
-                    continue
-
-                group_text = ", ".join(active_items)
-            else:
-                group_text = group["text"]
-
-            filtered_groups.append(
-                self._format_word_output(
-                    group_text,
-                    group["strength"],
-                    allow_strength_adjustment,
-                )
-            )
-
-        return filtered_groups
-
     def _parse_trigger_item(self, item, allow_strength_adjustment):
         text = (item.get("text") or "").strip()
         active = bool(item.get("active", False))

py/nodes/unet_loader.py

@@ -1,205 +0,0 @@
-import logging
-import os
-from typing import List, Tuple
-import comfy.sd # type: ignore
-from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
-
-logger = logging.getLogger(__name__)
-
-
-class UNETLoaderLM:
-    """UNET Loader with support for extra folder paths
-
-    Loads diffusion models/UNets from both standard ComfyUI folders and LoRA Manager's
-    extra folder paths, providing a unified interface for UNET loading.
-    Supports both regular diffusion models and GGUF format models.
-    """
-
-    NAME = "Unet Loader (LoraManager)"
-    CATEGORY = "Lora Manager/loaders"
-
-    @classmethod
-    def INPUT_TYPES(s):
-        # Get list of unet names from scanner (includes extra folder paths)
-        unet_names = s._get_unet_names()
-        return {
-            "required": {
-                "unet_name": (
-                    unet_names,
-                    {"tooltip": "The name of the diffusion model to load."},
-                ),
-                "weight_dtype": (
-                    ["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],
-                    {"tooltip": "The dtype to use for the model weights."},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL",)
-    RETURN_NAMES = ("MODEL",)
-    OUTPUT_TOOLTIPS = ("The model used for denoising latents.",)
-    FUNCTION = "load_unet"
-
-    @classmethod
-    def _get_unet_names(cls) -> List[str]:
-        """Get list of diffusion model names from scanner cache in ComfyUI format (relative path with extension)"""
-        try:
-            from ..services.service_registry import ServiceRegistry
-            import asyncio
-
-            async def _get_names():
-                scanner = await ServiceRegistry.get_checkpoint_scanner()
-                cache = await scanner.get_cached_data()
-
-                # Get all model roots for calculating relative paths
-                model_roots = scanner.get_model_roots()
-
-                # Filter only diffusion_model type and format names
-                names = []
-                for item in cache.raw_data:
-                    if item.get("sub_type") == "diffusion_model":
-                        file_path = item.get("file_path", "")
-                        if file_path:
-                            # Format using relative path with OS-native separator
-                            formatted_name = _format_model_name_for_comfyui(
-                                file_path, model_roots
-                            )
-                            if formatted_name:
-                                names.append(formatted_name)
-
-                return sorted(names)
-
-            try:
-                loop = asyncio.get_running_loop()
-                import concurrent.futures
-
-                def run_in_thread():
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    try:
-                        return new_loop.run_until_complete(_get_names())
-                    finally:
-                        new_loop.close()
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(run_in_thread)
-                    return future.result()
-            except RuntimeError:
-                return asyncio.run(_get_names())
-        except Exception as e:
-            logger.error(f"Error getting unet names: {e}")
-            return []
-
-    def load_unet(self, unet_name: str, weight_dtype: str) -> Tuple:
-        """Load a diffusion model by name, supporting extra folder paths
-
-        Args:
-            unet_name: The name of the diffusion model to load (relative path with extension)
-            weight_dtype: The dtype to use for model weights
-
-        Returns:
-            Tuple of (MODEL,)
-        """
-        import torch
-
-        # Get absolute path from cache using ComfyUI-style name
-        unet_path, metadata = get_checkpoint_info_absolute(unet_name)
-
-        if metadata is None:
-            raise FileNotFoundError(
-                f"Diffusion model '{unet_name}' not found in LoRA Manager cache. "
-                "Make sure the model is indexed and try again."
-            )
-
-        # Check if it's a GGUF model
-        if unet_path.endswith(".gguf"):
-            return self._load_gguf_unet(unet_path, unet_name, weight_dtype)
-
-        # Load regular diffusion model using ComfyUI's API
-        logger.info(f"Loading diffusion model from: {unet_path}")
-
-        # Build model options based on weight_dtype
-        model_options = {}
-        if weight_dtype == "fp8_e4m3fn":
-            model_options["dtype"] = torch.float8_e4m3fn
-        elif weight_dtype == "fp8_e4m3fn_fast":
-            model_options["dtype"] = torch.float8_e4m3fn
-            model_options["fp8_optimizations"] = True
-        elif weight_dtype == "fp8_e5m2":
-            model_options["dtype"] = torch.float8_e5m2
-
-        model = comfy.sd.load_diffusion_model(unet_path, model_options=model_options)
-        return (model,)
-
-    def _load_gguf_unet(
-        self, unet_path: str, unet_name: str, weight_dtype: str
-    ) -> Tuple:
-        """Load a GGUF format diffusion model
-
-        Args:
-            unet_path: Absolute path to the GGUF file
-            unet_name: Name of the model for error messages
-            weight_dtype: The dtype to use for model weights
-
-        Returns:
-            Tuple of (MODEL,)
-        """
-        import torch
-        from .gguf_import_helper import get_gguf_modules
-
-        # Get ComfyUI-GGUF modules using helper (handles various import scenarios)
-        try:
-            loader_module, ops_module, nodes_module = get_gguf_modules()
-            gguf_sd_loader = getattr(loader_module, "gguf_sd_loader")
-            GGMLOps = getattr(ops_module, "GGMLOps")
-            GGUFModelPatcher = getattr(nodes_module, "GGUFModelPatcher")
-        except RuntimeError as e:
-            raise RuntimeError(f"Cannot load GGUF model '{unet_name}'. {str(e)}")
-
-        logger.info(f"Loading GGUF diffusion model from: {unet_path}")
-
-        try:
-            # Load GGUF state dict
-            sd, extra = gguf_sd_loader(unet_path)
-
-            # Prepare kwargs for metadata if supported
-            kwargs = {}
-            import inspect
-
-            valid_params = inspect.signature(
-                comfy.sd.load_diffusion_model_state_dict
-            ).parameters
-            if "metadata" in valid_params:
-                kwargs["metadata"] = extra.get("metadata", {})
-
-            # Setup custom operations with GGUF support
-            ops = GGMLOps()
-
-            # Handle weight_dtype for GGUF models
-            if weight_dtype in ("default", None):
-                ops.Linear.dequant_dtype = None
-            elif weight_dtype in ["target"]:
-                ops.Linear.dequant_dtype = weight_dtype
-            else:
-                ops.Linear.dequant_dtype = getattr(torch, weight_dtype, None)
-
-            # Load the model
-            model = comfy.sd.load_diffusion_model_state_dict(
-                sd, model_options={"custom_operations": ops}, **kwargs
-            )
-
-            if model is None:
-                raise RuntimeError(
-                    f"Could not detect model type for GGUF diffusion model: {unet_path}"
-                )
-
-            # Wrap with GGUFModelPatcher
-            model = GGUFModelPatcher.clone(model)
-
-            return (model,)
-
-        except Exception as e:
-            logger.error(f"Error loading GGUF diffusion model '{unet_name}': {e}")
-            raise RuntimeError(
-                f"Failed to load GGUF diffusion model '{unet_name}': {str(e)}"
-            )

py/nodes/utils.py

@@ -4,7 +4,6 @@ class AnyType(str):
   def __ne__(self, __value: object) -> bool:
     return False
 
-
 # Credit to Regis Gaughan, III (rgthree)
 class FlexibleOptionalInputType(dict):
   """A special class to make flexible nodes that pass data to our python handlers.
@@ -21,12 +20,11 @@ class FlexibleOptionalInputType(dict):
 
   This should be forwards compatible unless more changes occur in the PR.
   """
-
   def __init__(self, type):
     self.type = type
 
   def __getitem__(self, key):
-        return (self.type,)
+    return (self.type, )
 
   def __contains__(self, key):
     return True
@@ -39,45 +37,25 @@ import os
 import logging
 import copy
 import sys
-import folder_paths  # type: ignore
+import folder_paths
 
 logger = logging.getLogger(__name__)
 
-
-def get_lora_syntax_format():
-    try:
-        from ..services.settings_manager import get_settings_manager
-        return get_settings_manager().get("lora_syntax_format", "legacy")
-    except Exception:
-        return "legacy"
-
-
-def apply_lora_syntax_format(name):
-    fmt = get_lora_syntax_format()
-    if fmt == "legacy":
-        return name.replace("\\", "/").rstrip("/").split("/")[-1]
-    return name
-
-
 def extract_lora_name(lora_path):
-    normalized = lora_path.replace("\\", "/")
-    basename = os.path.basename(normalized)
-    name_no_ext = os.path.splitext(basename)[0]
-    dirname = os.path.dirname(normalized)
-    if dirname and dirname not in (".", "/") and not normalized.startswith("/"):
-        return apply_lora_syntax_format(f"{dirname}/{name_no_ext}")
-    return apply_lora_syntax_format(name_no_ext)
-
+    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
+    # Get the basename without extension
+    basename = os.path.basename(lora_path)
+    return os.path.splitext(basename)[0]
 
 def get_loras_list(kwargs):
     """Helper to extract loras list from either old or new kwargs format"""
-    if "loras" not in kwargs:
+    if 'loras' not in kwargs:
         return []
         
-    loras_data = kwargs["loras"]
+    loras_data = kwargs['loras']
     # Handle new format: {'loras': {'__value__': [...]}}
-    if isinstance(loras_data, dict) and "__value__" in loras_data:
-        return loras_data["__value__"]
+    if isinstance(loras_data, dict) and '__value__' in loras_data:
+        return loras_data['__value__']
     # Handle old format: {'loras': [...]}
     elif isinstance(loras_data, list):
         return loras_data
@@ -86,25 +64,23 @@ def get_loras_list(kwargs):
         logger.warning(f"Unexpected loras format: {type(loras_data)}")
         return []
 
-
 def load_state_dict_in_safetensors(path, device="cpu", filter_prefix=""):
     """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""  
     import safetensors.torch
     
     state_dict = {}
-    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:  # type: ignore[attr-defined]
+    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:
         for k in f.keys():
             if filter_prefix and not k.startswith(filter_prefix):
                 continue
             state_dict[k.removeprefix(filter_prefix)] = f.get_tensor(k)
     return state_dict
 
-
 def to_diffusers(input_lora):
     """Simplified version of to_diffusers for Flux LoRA conversion"""
     import torch
     from diffusers.utils.state_dict_utils import convert_unet_state_dict_to_peft
-    from diffusers.loaders import FluxLoraLoaderMixin  # type: ignore[attr-defined]
+    from diffusers.loaders import FluxLoraLoaderMixin
     
     if isinstance(input_lora, str):
         tensors = load_state_dict_in_safetensors(input_lora, device="cpu")
@@ -121,15 +97,10 @@ def to_diffusers(input_lora):
 
     return new_tensors
 
-
 def nunchaku_load_lora(model, lora_name, lora_strength):
     """Load a Flux LoRA for Nunchaku model"""   
     # Get full path to the LoRA file. Allow both direct paths and registered LoRA names.
-    lora_path = (
-        lora_name
-        if os.path.isfile(lora_name)
-        else folder_paths.get_full_path("loras", lora_name)
-    )
+    lora_path = lora_name if os.path.isfile(lora_name) else folder_paths.get_full_path("loras", lora_name)
     if not lora_path or not os.path.isfile(lora_path):
         logger.warning("Skipping LoRA '%s' because it could not be found", lora_name)
         return model
@@ -147,9 +118,7 @@ def nunchaku_load_lora(model, lora_name, lora_strength):
         ret_model_wrapper.loras = [*model_wrapper.loras, (lora_path, lora_strength)]
     else:
         # Fallback to legacy logic
-        logger.warning(
-            "Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic."
-        )
+        logger.warning("Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic.")
         transformer = model_wrapper.model
         
         # Save the transformer temporarily
@@ -176,24 +145,3 @@ def nunchaku_load_lora(model, lora_name, lora_strength):
             ret_model.model.model_config.unet_config["in_channels"] = new_in_channels
     
     return ret_model
-
-
-def detect_nunchaku_model_kind(model):
-    """Return the supported Nunchaku model kind for a Comfy model, if any."""
-    try:
-        model_wrapper = model.model.diffusion_model
-    except (AttributeError, TypeError):
-        return None
-
-    wrapper_name = model_wrapper.__class__.__name__
-    if wrapper_name == "ComfyFluxWrapper":
-        return "flux"
-
-    inner_model = getattr(model_wrapper, "model", None)
-    inner_name = inner_model.__class__.__name__ if inner_model is not None else ""
-    if wrapper_name.endswith("NunchakuQwenImageTransformer2DModel"):
-        return "qwen_image"
-    if inner_name.endswith("NunchakuQwenImageTransformer2DModel"):
-        return "qwen_image"
-
-    return None

py/nodes/wanvideo_lora_select.py

@@ -1,22 +1,10 @@
-import os
-from ..utils.utils import get_lora_info_absolute
-from ..config import config
+import folder_paths # type: ignore
+from ..utils.utils import get_lora_info
 from .utils import FlexibleOptionalInputType, any_type, get_loras_list
 import logging
 
 logger = logging.getLogger(__name__)
 
-
-def _relpath_within_loras(abs_path):
-    """Return abs_path relative to the first matching lora root, or basename as fallback."""
-    all_roots = list(config.loras_roots or []) + list(config.extra_loras_roots or [])
-    for root in all_roots:
-        try:
-            return os.path.relpath(abs_path, root)
-        except ValueError:
-            continue
-    return os.path.basename(abs_path)
-
 class WanVideoLoraSelectLM:
     NAME = "WanVideo Lora Select (LoraManager)"
     CATEGORY = "Lora Manager/stackers"
@@ -68,13 +56,13 @@ class WanVideoLoraSelectLM:
             clip_strength = float(lora.get('clipStrength', model_strength))
             
             # Get lora path and trigger words
-            lora_path, trigger_words = get_lora_info_absolute(lora_name)
+            lora_path, trigger_words = get_lora_info(lora_name)
             
             # Create lora item for WanVideo format
             lora_item = {
-                "path": lora_path,
+                "path": folder_paths.get_full_path("loras", lora_path),
                 "strength": model_strength,
-                "name": os.path.splitext(_relpath_within_loras(lora_path))[0],
+                "name": lora_path.split(".")[0],
                 "blocks": selected_blocks,
                 "layer_filter": layer_filter,
                 "low_mem_load": low_mem_load,

py/nodes/wanvideo_lora_select_from_text.py

@@ -1,23 +1,11 @@
-import os
-from ..utils.utils import get_lora_info_absolute
-from ..config import config
+import folder_paths # type: ignore
+from ..utils.utils import get_lora_info
 from .utils import any_type 
 import logging
 
 # 初始化日志记录器
 logger = logging.getLogger(__name__)
 
-
-def _relpath_within_loras(abs_path):
-    """Return abs_path relative to the first matching lora root, or basename as fallback."""
-    all_roots = list(config.loras_roots or []) + list(config.extra_loras_roots or [])
-    for root in all_roots:
-        try:
-            return os.path.relpath(abs_path, root)
-        except ValueError:
-            continue
-    return os.path.basename(abs_path)
-
 # 定义新节点的类
 class WanVideoLoraTextSelectLM:
     # 节点在UI中显示的名称
@@ -99,12 +87,12 @@ class WanVideoLoraTextSelectLM:
             else:
                 continue
 
-            lora_path, trigger_words = get_lora_info_absolute(lora_name_raw)
+            lora_path, trigger_words = get_lora_info(lora_name_raw)
 
             lora_item = {
-                "path": lora_path,
+                "path": folder_paths.get_full_path("loras", lora_path),
                 "strength": model_strength,
-                "name": os.path.splitext(_relpath_within_loras(lora_path))[0],
+                "name": lora_path.split(".")[0],
                 "blocks": selected_blocks,
                 "layer_filter": layer_filter,
                 "low_mem_load": low_mem_load,

py/recipes/base.py

@@ -7,7 +7,7 @@ import re
 from typing import Dict, List, Any, Optional, Tuple
 from abc import ABC, abstractmethod
 from ..config import config
-from ..utils.constants import VALID_LORA_TYPES, VALID_CHECKPOINT_SUB_TYPES
+from ..utils.constants import VALID_LORA_TYPES
 from ..utils.civitai_utils import rewrite_preview_url
 
 logger = logging.getLogger(__name__)
@@ -58,50 +58,7 @@ class RecipeMetadataParser(ABC):
             civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
             
             if not civitai_info or error_msg == "Model not found":
-                # CivitAI may fail to resolve a hash that is still being
-                # computed (known CivitAI issue). Before marking as deleted,
-                # try to reconcile with a local model that has the same
-                # filename and matching AutoV3 hash.
-                reconciled = False
-                file_name = lora_entry.get("file_name")
-                if file_name and recipe_scanner and hash_value:
-                    lora_scanner = getattr(recipe_scanner, "_lora_scanner", None)
-                    if lora_scanner:
-                        try:
-                            # Local import to avoid circular dependency:
-                            # base.py → file_utils → settings_manager → ...
-                            #  → recipe_scanner → enrichment → base.py
-                            from ..utils.file_utils import calculate_autov3  # fmt: skip
-                            cache = await lora_scanner.get_cached_data()
-                            for item in getattr(cache, "raw_data", []):
-                                if item.get("file_name") == file_name:
-                                    local_path = item.get("file_path")
-                                    if local_path and os.path.exists(local_path):
-                                        local_autov3 = calculate_autov3(local_path)
-                                        if local_autov3 and local_autov3 == hash_value:
-                                            lora_entry["existsLocally"] = True
-                                            lora_entry["localPath"] = local_path
-                                            lora_entry["hash"] = item.get("sha256", hash_value)
-                                            if "preview_url" in item:
-                                                lora_entry["thumbnailUrl"] = config.get_preview_static_url(item["preview_url"])
-                                            civ = item.get("civitai") or {}
-                                            if isinstance(civ, dict):
-                                                if civ.get("id") is not None:
-                                                    lora_entry["id"] = civ["id"]
-                                                if civ.get("modelId") is not None:
-                                                    lora_entry["modelId"] = civ["modelId"]
-                                                if civ.get("name"):
-                                                    lora_entry["version"] = civ["name"]
-                                                # model_name is the CivitAI model display
-                                                # name stored directly in the cache column.
-                                                cached_model_name = item.get("model_name")
-                                                if cached_model_name:
-                                                    lora_entry["name"] = cached_model_name
-                                            reconciled = True
-                                            break
-                        except Exception:
-                            pass
-                if not reconciled:
+                # Model not found or deleted
                 lora_entry['isDeleted'] = True
                 lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
                 return lora_entry
@@ -216,20 +173,6 @@ class RecipeMetadataParser(ABC):
                 checkpoint['isDeleted'] = True
                 return checkpoint
 
-            # Validate that the model type is actually a checkpoint.
-            # Unlike populate_lora_from_civitai which has this check,
-            # this function was missing type validation — allowing LoRA
-            # version data to be saved as the recipe's checkpoint when the
-            # wrong version ID was passed downstream (fixed in v2.7+).
-            model_type = civitai_data.get('model', {}).get('type', '').lower()
-            if model_type not in VALID_CHECKPOINT_SUB_TYPES:
-                logger.warning(
-                    f"Cannot populate checkpoint: model version {civitai_data.get('id')} "
-                    f"has type '{model_type}', expected one of {VALID_CHECKPOINT_SUB_TYPES}. "
-                    f"Skipping checkpoint enrichment."
-                )
-                return checkpoint
-
             if 'model' in civitai_data and 'name' in civitai_data['model']:
                 checkpoint['name'] = civitai_data['model']['name']
 

py/recipes/constants.py

@@ -13,5 +13,4 @@ GEN_PARAM_KEYS = [
     'seed',
     'size',
     'clip_skip',
-    'denoising_strength',
 ]

py/recipes/enrichment.py

@@ -1,11 +1,11 @@
 import logging
 import json
+import re
 import os
 from typing import Any, Dict, Optional
 from .merger import GenParamsMerger
 from .base import RecipeMetadataParser
 from ..services.metadata_service import get_default_metadata_provider
-from ..utils.civitai_utils import extract_civitai_image_id
 
 logger = logging.getLogger(__name__)
 
@@ -16,9 +16,7 @@ class RecipeEnricher:
     async def enrich_recipe(
         recipe: Dict[str, Any],
         civitai_client: Any,
-        request_params: Optional[Dict[str, Any]] = None,
-        prefetched_civitai_meta_raw: Optional[Dict[str, Any]] = None,
-        prefetched_model_version_id: Optional[int] = None,
+        request_params: Optional[Dict[str, Any]] = None
     ) -> bool:
         """
         Enrich a recipe dictionary in-place with metadata from Civitai and embedded params.
@@ -27,9 +25,6 @@ class RecipeEnricher:
             recipe: The recipe dictionary to enrich. Must have 'gen_params' initialized.
             civitai_client: Authenticated Civitai client instance.
             request_params: (Optional) Parameters from a user request (e.g. import).
-            prefetched_civitai_meta_raw: (Optional) Pre-fetched raw meta from Civitai
-                get_image_info, avoiding a duplicate API call.
-            prefetched_model_version_id: (Optional) Pre-fetched model version ID.
             
         Returns:
             bool: True if the recipe was modified, False otherwise.
@@ -37,27 +32,20 @@ class RecipeEnricher:
         updated = False
         gen_params = recipe.get("gen_params", {})
         
-        # 1. Obtain Civitai metadata
+        # 1. Fetch Civitai Info if available
         civitai_meta = None
-        model_version_id = prefetched_model_version_id
+        model_version_id = None
         
-        source_path = recipe.get("source_path", "")
+        source_url = recipe.get("source_url") or recipe.get("source_path", "")
         
-        if prefetched_civitai_meta_raw is not None:
-            raw_meta = prefetched_civitai_meta_raw
-            if isinstance(raw_meta, dict):
-                if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
-                    civitai_meta = raw_meta["meta"]
-                else:
-                    civitai_meta = raw_meta
-        else:
-            image_id = extract_civitai_image_id(str(source_path))
-            if image_id:
+        # Check if it's a Civitai image URL
+        image_id_match = re.search(r'civitai\.com/images/(\d+)', str(source_url))
+        if image_id_match:
+            image_id = image_id_match.group(1)
             try:
-                    image_info = await civitai_client.get_image_info(
-                        image_id, source_url=str(source_path)
-                    )
+                image_info = await civitai_client.get_image_info(image_id)
                 if image_info:
+                    # Handle nested meta often found in Civitai API responses
                     raw_meta = image_info.get("meta")
                     if isinstance(raw_meta, dict):
                         if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
@@ -66,15 +54,16 @@ class RecipeEnricher:
                             civitai_meta = raw_meta
                     
                     model_version_id = image_info.get("modelVersionId")
-                except Exception as e:
-                    logger.warning(f"Failed to fetch Civitai image info: {e}")
                     
+                    # If not at top level, check resources in meta
                     if not model_version_id and civitai_meta:
                         resources = civitai_meta.get("civitaiResources", [])
                         for res in resources:
                             if res.get("type") == "checkpoint":
                                 model_version_id = res.get("modelVersionId")
                                 break
+            except Exception as e:
+                logger.warning(f"Failed to fetch Civitai image info: {e}")
 
         # 2. Merge Parameters
         # Priority: request_params > civitai_meta > embedded (existing gen_params)
@@ -190,40 +179,25 @@ class RecipeEnricher:
             existing_cp = recipe.get("checkpoint")
             if existing_cp is None:
                 existing_cp = {}
-
-            # Extract baseModel from raw civitai_info before populate_checkpoint_from_civitai
-            # (populate may reject non-checkpoint types and lose this data)
-            base_model_from_civitai: str = ""
-            if isinstance(civitai_info, dict):
-                base_model_from_civitai = civitai_info.get("baseModel", "") or ""
-            elif isinstance(civitai_info, tuple) and len(civitai_info) > 0 and isinstance(civitai_info[0], dict):
-                base_model_from_civitai = civitai_info[0].get("baseModel", "") or ""
-
             checkpoint_data = await RecipeMetadataParser.populate_checkpoint_from_civitai(existing_cp, civitai_info)
-
-            # 1. Resolve base_model from checkpoint_data first, then fall back to raw civitai_info
+            # 1. First, resolve base_model using full data before we format it away
             current_base_model = recipe.get("base_model")
-            resolved_base_model = checkpoint_data.get("baseModel") or base_model_from_civitai
+            resolved_base_model = checkpoint_data.get("baseModel")
             if resolved_base_model:
+                # Update if empty OR if it matches our generic prefix but is less specific
                 is_generic = not current_base_model or current_base_model.lower() in ["flux", "sdxl", "sd15"]
                 if is_generic and resolved_base_model != current_base_model:
                     recipe["base_model"] = resolved_base_model
             
-            # 2. Only format and save checkpoint if it has real data (not just type after type rejection)
-            has_checkpoint_data = any([
-                checkpoint_data.get("modelId"),
-                checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
-                checkpoint_data.get("name"),
-                checkpoint_data.get("version"),
-            ])
-            if has_checkpoint_data:
+            # 2. Format according to requirements: type, modelId, modelVersionId, modelName, modelVersionName
             formatted_checkpoint = {
                 "type": "checkpoint",
                 "modelId": checkpoint_data.get("modelId"),
                 "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
-                    "modelName": checkpoint_data.get("name"),
-                    "modelVersionName": checkpoint_data.get("version"),
+                "modelName": checkpoint_data.get("name"), # In base.py, 'name' is populated from civitai_data['model']['name']
+                "modelVersionName": checkpoint_data.get("version") # In base.py, 'version' is populated from civitai_data['name']
             }
+            # Remove None values
             recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
             
             return True

py/recipes/factory.py

@@ -6,19 +6,17 @@ from .parsers import (
     ComfyMetadataParser,
     MetaFormatParser,
     AutomaticMetadataParser,
-    CivitaiApiMetadataParser,
-    SuiImageParamsParser,
+    CivitaiApiMetadataParser
 )
 from .base import RecipeMetadataParser
 
 logger = logging.getLogger(__name__)
 
-
 class RecipeParserFactory:
     """Factory for creating recipe metadata parsers"""
     
     @staticmethod
-    def create_parser(metadata) -> RecipeMetadataParser | None:
+    def create_parser(metadata) -> RecipeMetadataParser:
         """
         Create appropriate parser based on the metadata content
         
@@ -40,7 +38,6 @@ class RecipeParserFactory:
             # Convert dict to string for other parsers that expect string input
             try:
                 import json
-
                 metadata_str = json.dumps(metadata)
             except Exception as e:
                 logger.debug(f"Failed to convert dict to JSON string: {e}")
@@ -56,13 +53,6 @@ class RecipeParserFactory:
             # If JSON parsing fails, move on to other parsers
             pass
         
-        # Try SuiImageParamsParser for SuiImage metadata format
-        try:
-            if SuiImageParamsParser().is_metadata_matching(metadata_str):
-                return SuiImageParamsParser()
-        except Exception:
-            pass
-
         # Check other parsers that expect string input
         if RecipeFormatParser().is_metadata_matching(metadata_str):
             return RecipeFormatParser()

py/recipes/merger.py

@@ -1,33 +1,27 @@
 from typing import Any, Dict, Optional
 import logging
 
-from .constants import GEN_PARAM_KEYS
-
 logger = logging.getLogger(__name__)
 
-
 class GenParamsMerger:
     """Utility to merge generation parameters from multiple sources with priority."""
 
-    ALLOWED_KEYS = set(GEN_PARAM_KEYS)
-
     BLACKLISTED_KEYS = {
         "id", "url", "userId", "username", "createdAt", "updatedAt", "hash", "meta",
         "draft", "extra", "width", "height", "process", "quantity", "workflow",
         "baseModel", "resources", "disablePoi", "aspectRatio", "Created Date",
         "experimental", "civitaiResources", "civitai_resources", "Civitai resources",
         "modelVersionId", "modelId", "hashes", "Model", "Model hash", "checkpoint_hash",
-        "checkpoint", "checksum", "model_checksum", "raw_metadata",
+        "checkpoint", "checksum", "model_checksum"
     }
     
     NORMALIZATION_MAPPING = {
-        "cfg": "cfg_scale",
+        # Civitai specific
         "cfgScale": "cfg_scale",
         "clipSkip": "clip_skip",
         "negativePrompt": "negative_prompt",
+        # Case variations
         "Sampler": "sampler",
-        "sampler_name": "sampler",
-        "scheduler": "sampler",
         "Steps": "steps",
         "Seed": "seed",
         "Size": "size",
@@ -42,40 +36,63 @@ class GenParamsMerger:
     def merge(
         request_params: Optional[Dict[str, Any]] = None,
         civitai_meta: Optional[Dict[str, Any]] = None,
-        embedded_metadata: Optional[Dict[str, Any]] = None,
+        embedded_metadata: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
         Merge generation parameters from three sources.
         
         Priority: request_params > civitai_meta > embedded_metadata
-        """
-        result: Dict[str, Any] = {}
         
+        Args:
+            request_params: Params provided directly in the import request
+            civitai_meta: Params from Civitai Image API 'meta' field
+            embedded_metadata: Params extracted from image EXIF/embedded metadata
+            
+        Returns:
+            Merged parameters dictionary
+        """
+        result = {}
+
+        # 1. Start with embedded metadata (lowest priority)
         if embedded_metadata:
-            if "gen_params" in embedded_metadata and isinstance(
-                embedded_metadata["gen_params"], dict
-            ):
+            # If it's a full recipe metadata, we use its gen_params
+            if "gen_params" in embedded_metadata and isinstance(embedded_metadata["gen_params"], dict):
                 GenParamsMerger._update_normalized(result, embedded_metadata["gen_params"])
             else:
+                # Otherwise assume the dict itself contains gen_params
                 GenParamsMerger._update_normalized(result, embedded_metadata)
 
+        # 2. Layer Civitai meta (medium priority)
         if civitai_meta:
             GenParamsMerger._update_normalized(result, civitai_meta)
 
+        # 3. Layer request params (highest priority)
         if request_params:
             GenParamsMerger._update_normalized(result, request_params)
 
-        return result
+        # Filter out blacklisted keys and also the original camelCase keys if they were normalized
+        final_result = {}
+        for k, v in result.items():
+            if k in GenParamsMerger.BLACKLISTED_KEYS:
+                continue
+            if k in GenParamsMerger.NORMALIZATION_MAPPING:
+                continue
+            final_result[k] = v
+            
+        return final_result
 
     @staticmethod
     def _update_normalized(target: Dict[str, Any], source: Dict[str, Any]) -> None:
-        """Update target dict with normalized, persistence-safe keys from source."""
-        for key, value in source.items():
-            if key in GenParamsMerger.BLACKLISTED_KEYS:
-                continue
-
-            normalized_key = GenParamsMerger.NORMALIZATION_MAPPING.get(key, key)
-            if normalized_key not in GenParamsMerger.ALLOWED_KEYS:
-                continue
-
-            target[normalized_key] = value
+        """Update target dict with normalized keys from source."""
+        for k, v in source.items():
+            normalized_key = GenParamsMerger.NORMALIZATION_MAPPING.get(k, k)
+            target[normalized_key] = v
+            # Also keep the original key for now if it's not the same, 
+            # so we can filter at the end or avoid losing it if it wasn't supposed to be renamed?
+            # Actually, if we rename it, we should probably NOT keep both in 'target' 
+            # because we want to filter them out at the end anyway.
+            if normalized_key != k:
+                # If we are overwriting an existing snake_case key with a camelCase one's value,
+                # that's fine because of the priority order of calls to _update_normalized.
+                pass
+            target[k] = v

py/recipes/parsers/__init__.py

@@ -5,7 +5,6 @@ from .comfy import ComfyMetadataParser
 from .meta_format import MetaFormatParser
 from .automatic import AutomaticMetadataParser
 from .civitai_image import CivitaiApiMetadataParser
-from .sui_image_params import SuiImageParamsParser
 
 __all__ = [
     'RecipeFormatParser',
@@ -13,5 +12,4 @@ __all__ = [
     'MetaFormatParser',
     'AutomaticMetadataParser',
     'CivitaiApiMetadataParser',
-    'SuiImageParamsParser',
 ]

py/recipes/parsers/automatic.py

@@ -123,38 +123,23 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         if model_hash_from_hashes:
                             metadata["model_hash"] = model_hash_from_hashes
                     
-                    # Extract Lora hashes in alternative format.
-                    # Run unconditionally (not just as fallback) so that
-                    # non-empty hashes from Lora hashes fill in the gaps left
-                    # by empty values in the Hashes JSON dict.  Some WebUI
-                    # builds write real hash values only to Lora hashes and
-                    # leave the Hashes JSON values empty.
+                    # Extract Lora hashes in alternative format
                     lora_hashes_match = re.search(self.LORA_HASHES_REGEX, params_section)
-                    if lora_hashes_match:
+                    if not hashes_match and lora_hashes_match:
                         try:
                             lora_hashes_str = lora_hashes_match.group(1)
                             lora_hash_entries = lora_hashes_str.split(', ')
                             
+                            # Initialize hashes dict if it doesn't exist
+                            if "hashes" not in metadata:
+                                metadata["hashes"] = {}
+                                
                             # Parse each lora hash entry (format: "name: hash")
                             for entry in lora_hash_entries:
                                 if ': ' in entry:
                                     lora_name, lora_hash = entry.split(': ', 1)
-                                    lora_hash = lora_hash.strip()
-                                    if not lora_hash:
-                                        # Skip entries without a hash value
-                                        continue
-                                    # Initialize hashes dict if it doesn't exist
-                                    if "hashes" not in metadata:
-                                        metadata["hashes"] = {}
-                                    # Add as lora type in the same format as
-                                    # regular hashes.  Only override an
-                                    # existing entry if its value is empty
-                                    # (Lora hashes is the more reliable
-                                    # source when Hashes JSON has blanks).
-                                    key = f"lora:{lora_name}"
-                                    existing = metadata["hashes"].get(key, "")
-                                    if not existing:
-                                        metadata["hashes"][key] = lora_hash
+                                    # Add as lora type in the same format as regular hashes
+                                    metadata["hashes"][f"lora:{lora_name}"] = lora_hash.strip()
                             
                             # Remove lora hashes from params section
                             params_section = params_section.replace(lora_hashes_match.group(0), '')
@@ -378,12 +363,6 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         if not hash_key.startswith(("lora:", "hypernet:")):
                             continue
                             
-                        # Skip entries without a hash value — they can't be
-                        # resolved via CivitAI and would only produce a
-                        # useless "Deleted" entry in the recipe.
-                        if not lora_hash:
-                            continue
-                            
                         lora_type, lora_name = hash_key.split(':', 1)
                         
                         # Get weight from extranet tags if available, else default to 1.0
@@ -408,7 +387,11 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         # Try to get info from Civitai
                         if metadata_provider:
                             try:
+                                if lora_hash:
+                                    # If we have hash, use it for lookup
                                     civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
+                                else:
+                                    civitai_info = None
                                 
                                 populated_entry = await self.populate_lora_from_civitai(
                                     lora_entry, 

py/recipes/parsers/civitai_image.py

@@ -6,11 +6,9 @@ from typing import Dict, Any, Union
 from ..base import RecipeMetadataParser
 from ..constants import GEN_PARAM_KEYS
 from ...services.metadata_service import get_default_metadata_provider
-from ...config import config
 
 logger = logging.getLogger(__name__)
 
-
 class CivitaiApiMetadataParser(RecipeMetadataParser):
     """Parser for Civitai image metadata format"""
     
@@ -42,8 +40,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                 "width",
                 "height",
                 "Model",
-                "Model hash",
-                "modelVersionIds",
+                "Model hash"
             )
             return any(key in payload for key in civitai_image_fields)
 
@@ -53,9 +50,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
         # Check for LoRA hash patterns
         hashes = metadata.get("hashes")
-        if isinstance(hashes, dict) and any(
-            str(key).lower().startswith("lora:") for key in hashes
-        ):
+        if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
             return True
 
         # Check nested meta object (common in CivitAI image responses)
@@ -66,31 +61,22 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
             # Also check for LoRA hash patterns in nested meta
             hashes = nested_meta.get("hashes")
-            if isinstance(hashes, dict) and any(
-                str(key).lower().startswith("lora:") for key in hashes
-            ):
+            if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
                 return True
 
         return False
     
-    async def parse_metadata(  # type: ignore[override]
-        self, user_comment, recipe_scanner=None, civitai_client=None,
-        local_cache: dict[str, Any] | None = None,
-    ) -> Dict[str, Any]:
+    async def parse_metadata(self, metadata, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
         """Parse metadata from Civitai image format
         
         Args:
-            user_comment: The metadata from the image (dict)
+            metadata: The metadata from the image (dict)
             recipe_scanner: Optional recipe scanner service
             civitai_client: Optional Civitai API client (deprecated, use metadata_provider instead)
-            local_cache: Optional dict mapping sha256/autov3 hash → scanner cache item.
-                         When provided, matching models skip CivitAI API calls.
             
         Returns:
             Dict containing parsed recipe data
         """
-        metadata: Dict[str, Any] = user_comment  # type: ignore[assignment]
-        metadata = user_comment
         try:
             # Get metadata provider instead of using civitai_client directly
             metadata_provider = await get_default_metadata_provider()
@@ -117,11 +103,11 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             
             # Initialize result structure
             result = {
-                "base_model": None,
-                "loras": [],
-                "model": None,
-                "gen_params": {},
-                "from_civitai_image": True,
+                'base_model': None,
+                'loras': [],
+                'model': None,
+                'gen_params': {},
+                'from_civitai_image': True
             }
             
             # Track already added LoRAs to prevent duplicates
@@ -162,25 +148,16 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                 result["base_model"] = metadata["baseModel"]
             elif "Model hash" in metadata and metadata_provider:
                 model_hash = metadata["Model hash"]
-                model_info, error = await metadata_provider.get_model_by_hash(
-                    model_hash
-                )
+                model_info, error = await metadata_provider.get_model_by_hash(model_hash)
                 if model_info:
                     result["base_model"] = model_info.get("baseModel", "")
             elif "Model" in metadata and isinstance(metadata.get("resources"), list):
                 # Try to find base model in resources
                 for resource in metadata.get("resources", []):
-                    if resource.get("type") == "model" and resource.get(
-                        "name"
-                    ) == metadata.get("Model"):
+                    if resource.get("type") == "model" and resource.get("name") == metadata.get("Model"):
                         # This is likely the checkpoint model
                         if metadata_provider and resource.get("hash"):
-                            (
-                                model_info,
-                                error,
-                            ) = await metadata_provider.get_model_by_hash(
-                                resource.get("hash")
-                            )
+                            model_info, error = await metadata_provider.get_model_by_hash(resource.get("hash"))
                             if model_info:
                                 result["base_model"] = model_info.get("baseModel", "")
             
@@ -189,77 +166,8 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             # Process standard resources array
             if "resources" in metadata and isinstance(metadata["resources"], list):
                 for resource in metadata["resources"]:
-                    resource_type = resource.get("type", "lora")
-
-                    # Track resources with type "model" — these are checkpoint models.
-                    # The resources array is the most reliable source for checkpoint
-                    # identification because it has an explicit type field and hash,
-                    # unlike modelVersionIds which is a flat list with no type info.
-                    if resource_type == "model":
-                        checkpoint_entry = {
-                            "id": 0,
-                            "modelId": 0,
-                            "name": resource.get("name", "Unknown Model"),
-                            "version": "",
-                            "type": resource.get("type", "model"),
-                            "existsLocally": False,
-                            "localPath": None,
-                            "file_name": resource.get("name", ""),
-                            "hash": resource.get("hash", "") or "",
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
-                            "baseModel": "",
-                            "size": 0,
-                            "downloadUrl": "",
-                            "isDeleted": False,
-                        }
-
-                        # Try to look up base model from the checkpoint hash
-                        cp_hash = checkpoint_entry.get("hash")
-                        if cp_hash and metadata_provider:
-                            local_cached = local_cache.get(cp_hash) if local_cache else None
-                            if local_cached:
-                                self._populate_entry_from_cache(
-                                    checkpoint_entry, local_cached
-                                )
-                                bm = checkpoint_entry.get("baseModel", "")
-                                if bm and not result["base_model"]:
-                                    result["base_model"] = bm
-                            else:
-                                try:
-                                    civitai_info = (
-                                        await metadata_provider.get_model_by_hash(
-                                            cp_hash
-                                        )
-                                    )
-                                    civitai_data, error_msg = (
-                                        (civitai_info, None)
-                                        if not isinstance(civitai_info, tuple)
-                                        else civitai_info
-                                    )
-                                    if civitai_data and error_msg != "Model not found":
-                                        if 'model' in civitai_data and 'name' in civitai_data['model']:
-                                            checkpoint_entry['name'] = civitai_data['model']['name']
-                                        checkpoint_entry['id'] = civitai_data.get('id', 0)
-                                        checkpoint_entry['modelId'] = civitai_data.get('modelId', 0)
-                                        if 'name' in civitai_data:
-                                            checkpoint_entry['version'] = civitai_data['name']
-                                        base_model = civitai_data.get('baseModel', '')
-                                        if base_model:
-                                            checkpoint_entry['baseModel'] = base_model
-                                            if not result['base_model']:
-                                                result['base_model'] = base_model
-                                except Exception as e:
-                                    logger.error(
-                                        f"Error fetching checkpoint info for hash "
-                                        f"{cp_hash}: {e}"
-                                    )
-
-                        if result["model"] is None:
-                            result["model"] = checkpoint_entry
-                        continue
-
                     # Modified to process resources without a type field as potential LoRAs
-                    if resource_type == "lora":
+                    if resource.get("type", "lora") == "lora":
                         lora_hash = resource.get("hash", "")
                         
                         # Try to get hash from the hashes field if not present in resource
@@ -268,9 +176,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                         
                         # Skip LoRAs without proper identification (hash or modelVersionId)
                         if not lora_hash and not resource.get("modelVersionId"):
-                            logger.debug(
-                                f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId"
-                            )
+                            logger.debug(f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId")
                             continue
                         
                         # Skip if we've already added this LoRA by hash
@@ -278,44 +184,31 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                             continue
                         
                         lora_entry = {
-                            "name": resource.get("name", "Unknown LoRA"),
-                            "type": "lora",
-                            "weight": float(resource.get("weight", 1.0)),
-                            "hash": lora_hash,
-                            "existsLocally": False,
-                            "localPath": None,
-                            "file_name": resource.get("name", "Unknown"),
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
-                            "baseModel": "",
-                            "size": 0,
-                            "downloadUrl": "",
-                            "isDeleted": False,
+                            'name': resource.get("name", "Unknown LoRA"),
+                            'type': "lora",
+                            'weight': float(resource.get("weight", 1.0)),
+                            'hash': lora_hash,
+                            'existsLocally': False,
+                            'localPath': None,
+                            'file_name': resource.get("name", "Unknown"),
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
+                            'baseModel': '',
+                            'size': 0,
+                            'downloadUrl': '',
+                            'isDeleted': False
                         }
                         
                         # Try to get info from Civitai if hash is available
-                        if lora_hash and metadata_provider:
-                            local_cached = local_cache.get(lora_hash) if local_cache else None
-                            if local_cached:
-                                self._populate_entry_from_cache(
-                                    lora_entry, local_cached
-                                )
-                                # Track by version ID for deduplication
-                                if lora_entry.get("id"):
-                                    added_loras[str(lora_entry["id"])] = len(
-                                        result["loras"]
-                                    )
-                            else:
+                        if lora_entry['hash'] and metadata_provider:
                             try:
-                                    civitai_info = (
-                                        await metadata_provider.get_model_by_hash(lora_hash)
-                                    )
+                                civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
                                 
                                 populated_entry = await self.populate_lora_from_civitai(
                                     lora_entry,
                                     civitai_info,
                                     recipe_scanner,
                                     base_model_counts,
-                                        lora_hash,
+                                    lora_hash
                                 )
                                 
                                 if populated_entry is None:
@@ -324,14 +217,10 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                                 lora_entry = populated_entry
                                 
                                 # If we have a version ID from Civitai, track it for deduplication
-                                    if "id" in lora_entry and lora_entry["id"]:
-                                        added_loras[str(lora_entry["id"])] = len(
-                                            result["loras"]
-                                        )
+                                if 'id' in lora_entry and lora_entry['id']:
+                                    added_loras[str(lora_entry['id'])] = len(result["loras"])
                             except Exception as e:
-                                    logger.error(
-                                        f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
-                                    )
+                                logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
                         
                         # Track by hash if we have it
                         if lora_hash:
@@ -340,9 +229,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                         result["loras"].append(lora_entry)
             
             # Process civitaiResources array
-            if "civitaiResources" in metadata and isinstance(
-                metadata["civitaiResources"], list
-            ):
+            if "civitaiResources" in metadata and isinstance(metadata["civitaiResources"], list):
                 for resource in metadata["civitaiResources"]:
                     # Get resource type and identifier
                     resource_type = str(resource.get("type") or "").lower()
@@ -350,39 +237,32 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                     if resource_type == "checkpoint":
                         checkpoint_entry = {
-                            "id": resource.get("modelVersionId", 0),
-                            "modelId": resource.get("modelId", 0),
-                            "name": resource.get("modelName", "Unknown Checkpoint"),
-                            "version": resource.get("modelVersionName", ""),
-                            "type": resource.get("type", "checkpoint"),
-                            "existsLocally": False,
-                            "localPath": None,
-                            "file_name": resource.get("modelName", ""),
-                            "hash": resource.get("hash", "") or "",
-                            "thumbnailUrl": "/loras_static/images/no-preview.png",
-                            "baseModel": "",
-                            "size": 0,
-                            "downloadUrl": "",
-                            "isDeleted": False,
+                            'id': resource.get("modelVersionId", 0),
+                            'modelId': resource.get("modelId", 0),
+                            'name': resource.get("modelName", "Unknown Checkpoint"),
+                            'version': resource.get("modelVersionName", ""),
+                            'type': resource.get("type", "checkpoint"),
+                            'existsLocally': False,
+                            'localPath': None,
+                            'file_name': resource.get("modelName", ""),
+                            'hash': resource.get("hash", "") or "",
+                            'thumbnailUrl': '/loras_static/images/no-preview.png',
+                            'baseModel': '',
+                            'size': 0,
+                            'downloadUrl': '',
+                            'isDeleted': False
                         }
 
                         if version_id and metadata_provider:
                             try:
-                                civitai_info = (
-                                    await metadata_provider.get_model_version_info(
-                                        version_id
-                                    )
-                                )
+                                civitai_info = await metadata_provider.get_model_version_info(version_id)
 
-                                checkpoint_entry = (
-                                    await self.populate_checkpoint_from_civitai(
-                                        checkpoint_entry, civitai_info
-                                    )
+                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
+                                    checkpoint_entry,
+                                    civitai_info
                                 )
                             except Exception as e:
-                                logger.error(
-                                    f"Error fetching Civitai info for checkpoint version {version_id}: {e}"
-                                )
+                                logger.error(f"Error fetching Civitai info for checkpoint version {version_id}: {e}")
 
                         if result["model"] is None:
                             result["model"] = checkpoint_entry
@@ -395,35 +275,31 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                     # Initialize lora entry
                     lora_entry = {
-                        "id": resource.get("modelVersionId", 0),
-                        "modelId": resource.get("modelId", 0),
-                        "name": resource.get("modelName", "Unknown LoRA"),
-                        "version": resource.get("modelVersionName", ""),
-                        "type": resource.get("type", "lora"),
-                        "weight": round(float(resource.get("weight", 1.0)), 2),
-                        "existsLocally": False,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
-                        "baseModel": "",
-                        "size": 0,
-                        "downloadUrl": "",
-                        "isDeleted": False,
+                        'id': resource.get("modelVersionId", 0),
+                        'modelId': resource.get("modelId", 0),
+                        'name': resource.get("modelName", "Unknown LoRA"),
+                        'version': resource.get("modelVersionName", ""),
+                        'type': resource.get("type", "lora"),
+                        'weight': round(float(resource.get("weight", 1.0)), 2),
+                        'existsLocally': False,
+                        'thumbnailUrl': '/loras_static/images/no-preview.png',
+                        'baseModel': '',
+                        'size': 0,
+                        'downloadUrl': '',
+                        'isDeleted': False
                     }
 
                     # Try to get info from Civitai if modelVersionId is available
                     if version_id and metadata_provider:
                         try:
                             # Use get_model_version_info instead of get_model_version
-                            civitai_info = (
-                                await metadata_provider.get_model_version_info(
-                                    version_id
-                                )
-                            )
+                            civitai_info = await metadata_provider.get_model_version_info(version_id)
 
                             populated_entry = await self.populate_lora_from_civitai(
                                 lora_entry,
                                 civitai_info,
                                 recipe_scanner,
-                                base_model_counts,
+                                base_model_counts
                             )
 
                             if populated_entry is None:
@@ -431,9 +307,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                             lora_entry = populated_entry
                         except Exception as e:
-                            logger.error(
-                                f"Error fetching Civitai info for model version {version_id}: {e}"
-                            )
+                            logger.error(f"Error fetching Civitai info for model version {version_id}: {e}")
 
                     # Track this LoRA in our deduplication dict
                     if version_id:
@@ -442,15 +316,10 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     result["loras"].append(lora_entry)
             
             # Process additionalResources array
-            if "additionalResources" in metadata and isinstance(
-                metadata["additionalResources"], list
-            ):
+            if "additionalResources" in metadata and isinstance(metadata["additionalResources"], list):
                 for resource in metadata["additionalResources"]:
                     # Skip resources that aren't LoRAs or LyCORIS
-                    if (
-                        resource.get("type") not in ["lora", "lycoris"]
-                        and "type" not in resource
-                    ):
+                    if resource.get("type") not in ["lora", "lycoris"] and "type" not in resource:
                         continue
                         
                     lora_type = resource.get("type", "lora")
@@ -468,35 +337,31 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                                 continue
                     
                     lora_entry = {
-                        "name": name,
-                        "type": lora_type,
-                        "weight": float(resource.get("strength", 1.0)),
-                        "hash": "",
-                        "existsLocally": False,
-                        "localPath": None,
-                        "file_name": name,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
-                        "baseModel": "",
-                        "size": 0,
-                        "downloadUrl": "",
-                        "isDeleted": False,
+                        'name': name,
+                        'type': lora_type,
+                        'weight': float(resource.get("strength", 1.0)),
+                        'hash': "",
+                        'existsLocally': False,
+                        'localPath': None,
+                        'file_name': name,
+                        'thumbnailUrl': '/loras_static/images/no-preview.png',
+                        'baseModel': '',
+                        'size': 0,
+                        'downloadUrl': '',
+                        'isDeleted': False
                     }
                     
                     # If we have a version ID and metadata provider, try to get more info
                     if version_id and metadata_provider:
                         try:
                             # Use get_model_version_info with the version ID
-                            civitai_info = (
-                                await metadata_provider.get_model_version_info(
-                                    version_id
-                                )
-                            )
+                            civitai_info = await metadata_provider.get_model_version_info(version_id)
                             
                             populated_entry = await self.populate_lora_from_civitai(
                                 lora_entry,
                                 civitai_info,
                                 recipe_scanner,
-                                base_model_counts,
+                                base_model_counts
                             )
                             
                             if populated_entry is None:
@@ -508,116 +373,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                             if version_id:
                                 added_loras[version_id] = len(result["loras"])
                         except Exception as e:
-                            logger.error(
-                                f"Error fetching Civitai info for model ID {version_id}: {e}"
-                            )
-
-                        result["loras"].append(lora_entry)
-
-            # Process modelVersionIds from Civitai image API.
-            # These are version IDs returned at root level of the API response.
-            # When resources or civitaiResources are already present in metadata
-            # (which they are when ?withMeta=true is passed), those sections have
-            # complete hash/type information — modelVersionIds is a fallback for
-            # when meta is null and only the flat ID list is available. Skipping
-            # it here avoids duplicates: the same file hash often resolves to
-            # different version IDs via hash lookup (resources) vs the original
-            # version ID in modelVersionIds, and both paths would create entries.
-            if (
-                "modelVersionIds" in metadata
-                and isinstance(metadata["modelVersionIds"], list)
-                and not result.get("loras")
-            ):
-
-                for version_id in metadata["modelVersionIds"]:
-                    version_id_str = str(version_id)
-
-                    # Skip if we've already added this LoRA by version ID
-                    if version_id_str in added_loras:
-                        continue
-
-                    # Skip if this version ID is already the recipe's checkpoint
-                    # (resolved earlier from embedded resources/Model hash,
-                    # avoiding a duplicate CivitAI API call).
-                    existing_model = result.get("model")
-                    if existing_model and str(existing_model.get("id")) == version_id_str:
-                        continue
-
-                    # Initialize lora entry with version ID
-                    lora_entry = {
-                        "id": version_id,
-                        "modelId": 0,
-                        "name": "Unknown LoRA",
-                        "version": "",
-                        "type": "lora",
-                        "weight": 1.0,
-                        "existsLocally": False,
-                        "thumbnailUrl": "/loras_static/images/no-preview.png",
-                        "baseModel": "",
-                        "size": 0,
-                        "downloadUrl": "",
-                        "isDeleted": False,
-                    }
-
-                    # Fetch model info from Civitai
-                    if metadata_provider and version_id_str:
-                        try:
-                            civitai_info = (
-                                await metadata_provider.get_model_version_info(
-                                    version_id_str
-                                )
-                            )
-
-                            populated_entry = await self.populate_lora_from_civitai(
-                                lora_entry,
-                                civitai_info,
-                                recipe_scanner,
-                                base_model_counts,
-                            )
-
-                            if populated_entry is None:
-                                # Not a LoRA — try as checkpoint (only if we
-                                # don't already have one).  Reuses the same
-                                # civitai_info from the API call above so no
-                                # extra query is made.
-                                if result["model"] is None:
-                                    checkpoint_entry = {
-                                        "id": version_id,
-                                        "modelId": 0,
-                                        "name": "Unknown Model",
-                                        "version": "",
-                                        "type": "checkpoint",
-                                        "existsLocally": False,
-                                        "localPath": None,
-                                        "file_name": "",
-                                        "hash": "",
-                                        "thumbnailUrl": (
-                                            "/loras_static/images/no-preview.png"
-                                        ),
-                                        "baseModel": "",
-                                        "size": 0,
-                                        "downloadUrl": "",
-                                        "isDeleted": False,
-                                    }
-                                    cp_populated = await (
-                                        self.populate_checkpoint_from_civitai(
-                                            checkpoint_entry, civitai_info
-                                        )
-                                    )
-                                    if cp_populated.get("modelId"):
-                                        result["model"] = cp_populated
-                                continue  # Not a LoRA, don't add to loras
-
-                            lora_entry = populated_entry
-
-                        except Exception as e:
-                            logger.error(
-                                f"Error fetching Civitai info for model version {version_id}: {e}"
-                            )
-
-                    # Track this LoRA for deduplication
-                    if version_id_str:
-                        added_loras[version_id_str] = len(result["loras"])
+                            logger.error(f"Error fetching Civitai info for model ID {version_id}: {e}")
                     
                         result["loras"].append(lora_entry)
 
@@ -634,32 +390,30 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     continue
 
                 lora_entry = {
-                    "name": lora_name,
-                    "type": "lora",
-                    "weight": 1.0,
-                    "hash": lora_hash,
-                    "existsLocally": False,
-                    "localPath": None,
-                    "file_name": lora_name,
-                    "thumbnailUrl": "/loras_static/images/no-preview.png",
-                    "baseModel": "",
-                    "size": 0,
-                    "downloadUrl": "",
-                    "isDeleted": False,
+                    'name': lora_name,
+                    'type': "lora",
+                    'weight': 1.0,
+                    'hash': lora_hash,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': lora_name,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
                 }
 
                 if metadata_provider:
                     try:
-                        civitai_info = await metadata_provider.get_model_by_hash(
-                            lora_hash
-                        )
+                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
 
                         populated_entry = await self.populate_lora_from_civitai(
                             lora_entry,
                             civitai_info,
                             recipe_scanner,
                             base_model_counts,
-                            lora_hash,
+                            lora_hash
                         )
 
                         if populated_entry is None:
@@ -667,27 +421,20 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                         lora_entry = populated_entry
 
-                        if "id" in lora_entry and lora_entry["id"]:
-                            added_loras[str(lora_entry["id"])] = len(result["loras"])
+                        if 'id' in lora_entry and lora_entry['id']:
+                            added_loras[str(lora_entry['id'])] = len(result["loras"])
                     except Exception as e:
-                        logger.error(
-                            f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}"
-                        )
+                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}")
 
                 added_loras[lora_hash] = len(result["loras"])
                 result["loras"].append(lora_entry)
 
             # Check for LoRA info in the format "Lora_0 Model hash", "Lora_0 Model name", etc.
             lora_index = 0
-            while (
-                f"Lora_{lora_index} Model hash" in metadata
-                and f"Lora_{lora_index} Model name" in metadata
-            ):
+            while f"Lora_{lora_index} Model hash" in metadata and f"Lora_{lora_index} Model name" in metadata:
                 lora_hash = metadata[f"Lora_{lora_index} Model hash"]
                 lora_name = metadata[f"Lora_{lora_index} Model name"]
-                lora_strength_model = float(
-                    metadata.get(f"Lora_{lora_index} Strength model", 1.0)
-                )
+                lora_strength_model = float(metadata.get(f"Lora_{lora_index} Strength model", 1.0))
                 
                 # Skip if we've already added this LoRA by hash
                 if lora_hash and lora_hash in added_loras:
@@ -695,33 +442,31 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     continue
                 
                 lora_entry = {
-                    "name": lora_name,
-                    "type": "lora",
-                    "weight": lora_strength_model,
-                    "hash": lora_hash,
-                    "existsLocally": False,
-                    "localPath": None,
-                    "file_name": lora_name,
-                    "thumbnailUrl": "/loras_static/images/no-preview.png",
-                    "baseModel": "",
-                    "size": 0,
-                    "downloadUrl": "",
-                    "isDeleted": False,
+                    'name': lora_name,
+                    'type': "lora",
+                    'weight': lora_strength_model,
+                    'hash': lora_hash,
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': lora_name,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
                 }
                 
                 # Try to get info from Civitai if hash is available
-                if lora_entry["hash"] and metadata_provider:
+                if lora_entry['hash'] and metadata_provider:
                     try:
-                        civitai_info = await metadata_provider.get_model_by_hash(
-                            lora_hash
-                        )
+                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
                         
                         populated_entry = await self.populate_lora_from_civitai(
                             lora_entry,
                             civitai_info,
                             recipe_scanner,
                             base_model_counts,
-                            lora_hash,
+                            lora_hash
                         )
                         
                         if populated_entry is None:
@@ -731,12 +476,10 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                         lora_entry = populated_entry
                         
                         # If we have a version ID from Civitai, track it for deduplication
-                        if "id" in lora_entry and lora_entry["id"]:
-                            added_loras[str(lora_entry["id"])] = len(result["loras"])
+                        if 'id' in lora_entry and lora_entry['id']:
+                            added_loras[str(lora_entry['id'])] = len(result["loras"])
                     except Exception as e:
-                        logger.error(
-                            f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
-                        )
+                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
                 
                 # Track by hash if we have it
                 if lora_hash:
@@ -748,50 +491,10 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             
             # If base model wasn't found earlier, use the most common one from LoRAs
             if not result["base_model"] and base_model_counts:
-                result["base_model"] = max(
-                    base_model_counts.items(), key=lambda x: x[1]
-                )[0]
+                result["base_model"] = max(base_model_counts.items(), key=lambda x: x[1])[0]
             
             return result
             
         except Exception as e:
             logger.error(f"Error parsing Civitai image metadata: {e}", exc_info=True)
             return {"error": str(e), "loras": []}
-
-    @staticmethod
-    def _populate_entry_from_cache(
-        entry: dict[str, Any],
-        cache_item: dict[str, Any],
-    ) -> None:
-        """Fill a lora/checkpoint entry from a scanner cache item.
-
-        Avoids CivitAI API calls for models that exist locally.
-        Mirrors the population logic in
-        ``RecipeMetadataParser.populate_lora_from_civitai()`` but operates
-        entirely on cached data.
-        """
-        civ = cache_item.get("civitai") or {}
-        if isinstance(civ, dict):
-            if civ.get("id") is not None:
-                entry["id"] = civ["id"]
-            if civ.get("modelId") is not None:
-                entry["modelId"] = civ["modelId"]
-            if civ.get("name"):
-                entry["version"] = civ["name"]
-            cached_name = cache_item.get("model_name")
-            if cached_name:
-                entry["name"] = cached_name
-        entry["existsLocally"] = True
-        local_path = cache_item.get("file_path")
-        if local_path:
-            entry["localPath"] = local_path
-        sha256 = cache_item.get("sha256")
-        if sha256:
-            entry["hash"] = sha256
-        if "preview_url" in cache_item:
-            entry["thumbnailUrl"] = config.get_preview_static_url(
-                cache_item["preview_url"]
-            )
-        base_model = cache_item.get("base_model", "")
-        if base_model:
-            entry["baseModel"] = base_model

py/recipes/parsers/sui_image_params.py

@@ -1,188 +0,0 @@
-"""Parser for SuiImage (Stable Diffusion WebUI) metadata format."""
-
-import json
-import logging
-from typing import Dict, Any, Optional, List
-from ..base import RecipeMetadataParser
-from ...services.metadata_service import get_default_metadata_provider
-
-logger = logging.getLogger(__name__)
-
-
-class SuiImageParamsParser(RecipeMetadataParser):
-    """Parser for SuiImage metadata JSON format.
-
-    This format is used by some Stable Diffusion WebUI variants.
-    Structure:
-    {
-        "sui_image_params": {
-            "prompt": "...",
-            "negativeprompt": "...",
-            "model": "...",
-            "seed": ...,
-            "steps": ...,
-            ...
-        },
-        "sui_models": [
-            {"name": "...", "param": "model", "hash": "..."},
-            ...
-        ],
-        "sui_extra_data": {...}
-    }
-    """
-
-    def is_metadata_matching(self, user_comment: str) -> bool:
-        """Check if the user comment matches the SuiImage metadata format"""
-        try:
-            data = json.loads(user_comment)
-            return isinstance(data, dict) and 'sui_image_params' in data
-        except (json.JSONDecodeError, TypeError):
-            return False
-
-    async def parse_metadata(self, user_comment: str, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
-        """Parse metadata from SuiImage metadata format"""
-        try:
-            metadata_provider = await get_default_metadata_provider()
-
-            data = json.loads(user_comment)
-            params = data.get('sui_image_params', {})
-            models = data.get('sui_models', [])
-
-            # Extract prompt and negative prompt
-            prompt = params.get('prompt', '')
-            negative_prompt = params.get('negativeprompt', '') or params.get('negative_prompt', '')
-
-            # Extract generation parameters
-            gen_params = {}
-            if prompt:
-                gen_params['prompt'] = prompt
-            if negative_prompt:
-                gen_params['negative_prompt'] = negative_prompt
-
-            # Map standard parameters
-            param_mapping = {
-                'steps': 'steps',
-                'seed': 'seed',
-                'cfgscale': 'cfg_scale',
-                'cfg_scale': 'cfg_scale',
-                'width': 'width',
-                'height': 'height',
-                'sampler': 'sampler',
-                'scheduler': 'scheduler',
-                'model': 'model',
-                'vae': 'vae',
-            }
-
-            for src_key, dest_key in param_mapping.items():
-                if src_key in params and params[src_key] is not None:
-                    gen_params[dest_key] = params[src_key]
-
-            # Add size info if available
-            if 'width' in gen_params and 'height' in gen_params:
-                gen_params['size'] = f"{gen_params['width']}x{gen_params['height']}"
-
-            # Process models - extract checkpoint and loras
-            loras: List[Dict[str, Any]] = []
-            checkpoint: Optional[Dict[str, Any]] = None
-
-            for model in models:
-                model_name = model.get('name', '')
-                param_type = model.get('param', '')
-                model_hash = model.get('hash', '')
-
-                # Remove .safetensors extension for cleaner name
-                clean_name = model_name.replace('.safetensors', '') if model_name else ''
-
-                # Check if this is a LoRA by looking at the name or param type
-                is_lora = 'lora' in model_name.lower() or param_type.lower().startswith('lora')
-
-                if is_lora:
-                    lora_entry = {
-                        'id': 0,
-                        'modelId': 0,
-                        'name': clean_name,
-                        'version': '',
-                        'type': 'lora',
-                        'weight': 1.0,
-                        'existsLocally': False,
-                        'localPath': None,
-                        'file_name': model_name,
-                        'hash': model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
-                    }
-
-                    # Try to get additional info from metadata provider
-                    if metadata_provider and model_hash:
-                        try:
-                            civitai_info = await metadata_provider.get_model_by_hash(
-                                model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash
-                            )
-                            if civitai_info:
-                                lora_entry = await self.populate_lora_from_civitai(
-                                    lora_entry, civitai_info, recipe_scanner
-                                )
-                        except Exception as e:
-                            logger.debug(f"Error fetching info for LoRA {clean_name}: {e}")
-
-                    if lora_entry:
-                        loras.append(lora_entry)
-                elif param_type == 'model' or 'lora' not in model_name.lower():
-                    # This is likely a checkpoint
-                    checkpoint_entry = {
-                        'id': 0,
-                        'modelId': 0,
-                        'name': clean_name,
-                        'version': '',
-                        'type': 'checkpoint',
-                        'hash': model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash,
-                        'existsLocally': False,
-                        'localPath': None,
-                        'file_name': model_name,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
-                    }
-
-                    # Try to get additional info from metadata provider
-                    if metadata_provider and model_hash:
-                        try:
-                            civitai_info = await metadata_provider.get_model_by_hash(
-                                model_hash.replace('0x', '') if model_hash.startswith('0x') else model_hash
-                            )
-                            if civitai_info:
-                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
-                                    checkpoint_entry, civitai_info
-                                )
-                        except Exception as e:
-                            logger.debug(f"Error fetching info for checkpoint {clean_name}: {e}")
-
-                    checkpoint = checkpoint_entry
-
-            # Determine base model from loras or checkpoint
-            base_model = None
-            if loras:
-                base_models = [lora.get('baseModel') for lora in loras if lora.get('baseModel')]
-                if base_models:
-                    from collections import Counter
-                    base_model_counts = Counter(base_models)
-                    base_model = base_model_counts.most_common(1)[0][0]
-            elif checkpoint and checkpoint.get('baseModel'):
-                base_model = checkpoint['baseModel']
-
-            return {
-                'base_model': base_model,
-                'loras': loras,
-                'checkpoint': checkpoint,
-                'gen_params': gen_params,
-                'from_sui_image_params': True
-            }
-
-        except Exception as e:
-            logger.error(f"Error parsing SuiImage metadata: {e}", exc_info=True)
-            return {"error": str(e), "loras": []}

py/routes/base_model_routes.py

@@ -204,7 +204,6 @@ class BaseModelRoutes(ABC):
             service=service,
             update_service=update_service,
             metadata_provider_selector=get_metadata_provider,
-            settings_service=self._settings,
             logger=logger,
         )
         return ModelHandlerSet(
@@ -251,7 +250,7 @@ class BaseModelRoutes(ABC):
 
     def _find_model_file(self, files):
         """Find the appropriate model file from the files list - can be overridden by subclasses."""
-        return next((file for file in files if file.get("type") in ("Model", "Diffusion Model") and file.get("primary") is True), None)
+        return next((file for file in files if file.get("type") == "Model" and file.get("primary") is True), None)
 
     def get_handler(self, name: str) -> Callable[[web.Request], web.StreamResponse]:
         """Expose handlers for subclasses or tests."""

py/routes/base_recipe_routes.py

@@ -1,5 +1,4 @@
 """Base infrastructure shared across recipe routes."""
-
 from __future__ import annotations
 
 import logging
@@ -17,14 +16,12 @@ from ..services.recipes import (
     RecipePersistenceService,
     RecipeSharingService,
 )
-from ..services.batch_import_service import BatchImportService
 from ..services.server_i18n import server_i18n
 from ..services.service_registry import ServiceRegistry
 from ..services.settings_manager import get_settings_manager
 from ..utils.constants import CARD_PREVIEW_WIDTH
 from ..utils.exif_utils import ExifUtils
 from .handlers.recipe_handlers import (
-    BatchImportHandler,
     RecipeAnalysisHandler,
     RecipeHandlerSet,
     RecipeListingHandler,
@@ -119,10 +116,7 @@ class BaseRecipeRoutes:
         recipe_scanner_getter = lambda: self.recipe_scanner
         civitai_client_getter = lambda: self.civitai_client
 
-        standalone_mode = (
-            os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-            or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-        )
+        standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
         if not standalone_mode:
             from ..metadata_collector import get_metadata  # type: ignore[import-not-found]
             from ..metadata_collector.metadata_processor import (  # type: ignore[import-not-found]
@@ -196,22 +190,6 @@ class BaseRecipeRoutes:
             sharing_service=sharing_service,
         )
 
-        from ..services.websocket_manager import ws_manager
-
-        batch_import_service = BatchImportService(
-            analysis_service=analysis_service,
-            persistence_service=persistence_service,
-            ws_manager=ws_manager,
-            logger=logger,
-        )
-        batch_import = BatchImportHandler(
-            ensure_dependencies_ready=self.ensure_dependencies_ready,
-            recipe_scanner_getter=recipe_scanner_getter,
-            civitai_client_getter=civitai_client_getter,
-            logger=logger,
-            batch_import_service=batch_import_service,
-        )
-
         return RecipeHandlerSet(
             page_view=page_view,
             listing=listing,
@@ -219,5 +197,4 @@ class BaseRecipeRoutes:
             management=management,
             analysis=analysis,
             sharing=sharing,
-            batch_import=batch_import,
         )

py/routes/checkpoint_routes.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Set
+from typing import Dict
 from aiohttp import web
 
 from .base_model_routes import BaseModelRoutes
@@ -82,22 +82,12 @@ class CheckpointRoutes(BaseModelRoutes):
             return web.json_response({"error": str(e)}, status=500)
     
     async def get_checkpoints_roots(self, request: web.Request) -> web.Response:
-        """Return the list of checkpoint roots from config (including extra paths)"""
+        """Return the list of checkpoint roots from config"""
         try:
-            # Merge checkpoints_roots with extra_checkpoints_roots, preserving order and removing duplicates
-            roots: List[str] = []
-            roots.extend(config.checkpoints_roots or [])
-            roots.extend(config.extra_checkpoints_roots or [])
-            # Remove duplicates while preserving order
-            seen: set = set()
-            unique_roots: List[str] = []
-            for root in roots:
-                if root and root not in seen:
-                    seen.add(root)
-                    unique_roots.append(root)
+            roots = config.checkpoints_roots
             return web.json_response({
                 "success": True,
-                "roots": unique_roots
+                "roots": roots
             })
         except Exception as e:
             logger.error(f"Error getting checkpoint roots: {e}", exc_info=True)
@@ -107,22 +97,12 @@ class CheckpointRoutes(BaseModelRoutes):
             }, status=500)
 
     async def get_unet_roots(self, request: web.Request) -> web.Response:
-        """Return the list of unet roots from config (including extra paths)"""
+        """Return the list of unet roots from config"""
         try:
-            # Merge unet_roots with extra_unet_roots, preserving order and removing duplicates
-            roots: List[str] = []
-            roots.extend(config.unet_roots or [])
-            roots.extend(config.extra_unet_roots or [])
-            # Remove duplicates while preserving order
-            seen: set = set()
-            unique_roots: List[str] = []
-            for root in roots:
-                if root and root not in seen:
-                    seen.add(root)
-                    unique_roots.append(root)
+            roots = config.unet_roots
             return web.json_response({
                 "success": True,
-                "roots": unique_roots
+                "roots": roots
             })
         except Exception as e:
             logger.error(f"Error getting unet roots: {e}", exc_info=True)

py/routes/handlers/agent_handlers.py

@@ -1,165 +0,0 @@
-"""HTTP route handlers for agent skill endpoints.
-
-These handlers expose the :class:`AgentService` via HTTP, allowing the
-frontend to list available skills and execute them on selected models.
-Progress is reported via WebSocket broadcast.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any, Dict
-
-from aiohttp import web
-
-from ...services.agent import AgentService, AgentProgressReporter
-from ...services.llm_service import LLMNotConfiguredError
-
-logger = logging.getLogger(__name__)
-
-
-class AgentHandler:
-    """HTTP handler for agent skill operations."""
-
-    def __init__(self, agent_service: AgentService | None = None) -> None:
-        self._agent_service = agent_service
-
-    async def _ensure_service(self) -> AgentService:
-        if self._agent_service is None:
-            self._agent_service = await AgentService.get_instance()
-        return self._agent_service
-
-    # ------------------------------------------------------------------
-    # GET /api/lm/agent/skills
-    # ------------------------------------------------------------------
-
-    async def get_agent_skills(self, request: web.Request) -> web.Response:
-        """Return a list of available agent skills."""
-
-        service = await self._ensure_service()
-        skills = await service.list_skills()
-        return web.json_response({"skills": skills})
-
-    # ------------------------------------------------------------------
-    # POST /api/lm/agent/execute/{skill_name}
-    # ------------------------------------------------------------------
-
-    async def execute_agent_skill(self, request: web.Request) -> web.Response:
-        """Execute an agent skill on the provided model paths.
-
-        Request body::
-
-            {"model_paths": ["/path/to/model1.safetensors", ...], "options": {}}
-
-        Returns immediately with a task ID.  Execution runs in the
-        background; progress and completion are pushed via WebSocket
-        events of type ``agent_progress``.
-        """
-
-        skill_name = request.match_info.get("skill_name", "")
-        if not skill_name:
-            return web.json_response(
-                {"error": "Skill name is required"}, status=400
-            )
-
-        try:
-            body = await request.json()
-        except Exception:
-            return web.json_response(
-                {"error": "Invalid JSON body"}, status=400
-            )
-
-        model_paths = body.get("model_paths", [])
-        if not model_paths or not isinstance(model_paths, list):
-            return web.json_response(
-                {"error": "model_paths must be a non-empty array"},
-                status=400,
-            )
-
-        service = await self._ensure_service()
-
-        # Validate LLM configuration early for skills that need it
-        # (fail fast rather than after starting background work)
-        try:
-            from ...services.llm_service import LLMService
-
-            llm = await LLMService.get_instance()
-            if not llm.is_configured():
-                return web.json_response(
-                    {
-                        "error": "LLM provider is not configured. "
-                        "Enable it in Settings → AI Provider.",
-                    },
-                    status=400,
-                )
-        except Exception as exc:
-            logger.error("Failed to check LLM configuration: %s", exc)
-
-        # Launch execution in the background
-        progress_reporter = AgentProgressReporter()
-        logger.info(
-            "LLM enrichment '%s' starting for %d model(s)",
-            skill_name, len(model_paths),
-        )
-
-        async def _run() -> None:
-            try:
-                result = await service.execute_skill(
-                    skill_name=skill_name,
-                    input_data={"model_paths": model_paths},
-                    progress_callback=progress_reporter,
-                )
-                logger.info(
-                    "LLM enrichment '%s' finished: success=%s, summary='%s', errors=%s",
-                    skill_name, result.success, result.summary, result.errors,
-                )
-            except LLMNotConfiguredError as exc:
-                logger.warning("LLM enrichment '%s' not configured: %s", skill_name, exc)
-                await progress_reporter.on_progress(
-                    {
-                        "type": "agent_progress",
-                        "skill": skill_name,
-                        "status": "error",
-                        "error": str(exc),
-                    }
-                )
-            except Exception as exc:
-                logger.error("LLM enrichment '%s' failed: %s", skill_name, exc, exc_info=True)
-                await progress_reporter.on_progress(
-                    {
-                        "type": "agent_progress",
-                        "skill": skill_name,
-                        "status": "error",
-                        "error": str(exc),
-                    }
-                )
-
-        # Fire and forget — progress comes via WebSocket
-        asyncio.create_task(_run())
-
-        return web.json_response(
-            {
-                "status": "started",
-                "skill": skill_name,
-                "model_count": len(model_paths),
-            }
-        )
-
-    # ------------------------------------------------------------------
-    # POST /api/lm/agent/cancel
-    # ------------------------------------------------------------------
-
-    async def cancel_agent_skill(self, request: web.Request) -> web.Response:
-        """Cancel a running agent skill.
-
-        NOTE: Cancellation is a stub for now — the AgentService processes
-        models sequentially and does not yet support mid-execution
-        cancellation.  This endpoint exists for API completeness.
-        """
-
-        # TODO: implement cooperative cancellation in AgentService
-        return web.json_response(
-            {"status": "acknowledged", "note": "Cancellation not yet implemented"},
-            status=200,
-        )

py/routes/handlers/base_model_handlers.py

@@ -1,141 +0,0 @@
-"""Handlers for base model related endpoints."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Awaitable, Callable, Dict
-
-from aiohttp import web
-
-from ...services.civitai_base_model_service import get_civitai_base_model_service
-
-logger = logging.getLogger(__name__)
-
-
-class BaseModelHandlerSet:
-    """Collection of handlers for base model operations."""
-
-    def __init__(
-        self,
-        base_model_service_factory: Callable[[], Any] = get_civitai_base_model_service,
-    ) -> None:
-        self._base_model_service_factory = base_model_service_factory
-
-    def to_route_mapping(
-        self,
-    ) -> Dict[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
-        """Return mapping of route names to handler methods."""
-        return {
-            "get_base_models": self.get_base_models,
-            "refresh_base_models": self.refresh_base_models,
-            "get_base_model_categories": self.get_base_model_categories,
-            "get_base_model_cache_status": self.get_base_model_cache_status,
-        }
-
-    async def get_base_models(self, request: web.Request) -> web.Response:
-        """Get merged base models (hardcoded + remote from Civitai).
-
-        Query Parameters:
-            refresh: If 'true', force refresh from API
-
-        Returns:
-            JSON response with:
-            - models: List of base model names
-            - source: 'cache', 'api', or 'fallback'
-            - last_updated: ISO timestamp
-            - counts: hardcoded_count, remote_count, merged_count
-        """
-        try:
-            service = await self._base_model_service_factory()
-
-            # Check for refresh parameter
-            force_refresh = request.query.get("refresh", "").lower() == "true"
-
-            result = await service.get_base_models(force_refresh=force_refresh)
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": result,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_models: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def refresh_base_models(self, request: web.Request) -> web.Response:
-        """Force refresh base models from Civitai API.
-
-        Returns:
-            JSON response with refreshed data
-        """
-        try:
-            service = await self._base_model_service_factory()
-            result = await service.refresh_cache()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": result,
-                    "message": "Base models cache refreshed successfully",
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in refresh_base_models: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def get_base_model_categories(self, request: web.Request) -> web.Response:
-        """Get categorized base models.
-
-        Returns:
-            JSON response with categorized models
-        """
-        try:
-            service = await self._base_model_service_factory()
-            categories = service.get_model_categories()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": categories,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_model_categories: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )
-
-    async def get_base_model_cache_status(self, request: web.Request) -> web.Response:
-        """Get cache status for base models.
-
-        Returns:
-            JSON response with cache status
-        """
-        try:
-            service = await self._base_model_service_factory()
-            status = service.get_cache_status()
-
-            return web.json_response(
-                {
-                    "success": True,
-                    "data": status,
-                }
-            )
-
-        except Exception as e:
-            logger.error(f"Error in get_base_model_cache_status: {e}")
-            return web.json_response(
-                {"success": False, "error": str(e)},
-                status=500,
-            )

py/routes/handlers/example_images_handlers.py

@@ -1,14 +1,11 @@
 """Handler set for example image routes."""
 from __future__ import annotations
 
-import logging
 from dataclasses import dataclass
 from typing import Callable, Mapping
 
 from aiohttp import web
 
-logger = logging.getLogger(__name__)
-
 from ...services.use_cases.example_images import (
     DownloadExampleImagesConfigurationError,
     DownloadExampleImagesInProgressError,
@@ -125,9 +122,6 @@ class ExampleImagesManagementHandler:
             return web.json_response({'success': False, 'error': str(exc)}, status=400)
         except ExampleImagesImportError as exc:
             return web.json_response({'success': False, 'error': str(exc)}, status=500)
-        except Exception as exc:
-            logger.exception("Unexpected error importing example images")
-            return web.json_response({'success': False, 'error': str(exc)}, status=500)
 
     async def delete_example_image(self, request: web.Request) -> web.StreamResponse:
         return await self._processor.delete_custom_image(request)

py/routes/handlers/hf_handlers.py

@@ -1,508 +0,0 @@
-"""Handlers for Hugging Face model listing and download.
-
-Minimal MVP implementation — uses direct HTTP to the HF API for file
-listing and the project's existing aiohttp-based Downloader for
-downloading.  No huggingface_hub dependency required.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-from typing import Any
-
-import aiohttp
-from aiohttp import web
-
-from ...config import config
-from ...services.downloader import (
-    DownloadProgress,
-    get_downloader,
-)
-from ...services.aria2_downloader import Aria2Downloader
-from ...services.settings_manager import get_settings_manager
-from ...services.service_registry import ServiceRegistry
-from ...services.websocket_manager import ws_manager
-from ...utils.constants import MODEL_FILE_EXTENSIONS
-from ...utils.metadata_manager import MetadataManager
-from ...utils.models import LoraMetadata, CheckpointMetadata, EmbeddingMetadata
-
-logger = logging.getLogger(__name__)
-
-_DEFAULT_MODEL_CLASS = LoraMetadata
-_DEFAULT_SCANNER_GETTER = "get_lora_scanner"
-
-# Shared aiohttp session for HF API calls (created on first use)
-_hf_api_session: aiohttp.ClientSession | None = None
-
-
-async def _get_hf_api_session() -> aiohttp.ClientSession:
-    """Get or create the shared aiohttp session for HF API calls."""
-    global _hf_api_session  # needed because we reassign the module-level name
-    if _hf_api_session is None or _hf_api_session.closed:
-        _hf_api_session = aiohttp.ClientSession(
-            headers={"User-Agent": "ComfyUI-LoRA-Manager/1.0"},
-            timeout=aiohttp.ClientTimeout(total=30),
-        )
-    return _hf_api_session
-
-
-async def close_hf_api_session() -> None:
-    """Close the shared HF API session, if it was ever created."""
-    global _hf_api_session
-    if _hf_api_session is not None and not _hf_api_session.closed:
-        await _hf_api_session.close()
-        _hf_api_session = None
-
-
-def _infer_model_type(model_root: str) -> tuple[Any, str]:
-    """Determine model class and scanner by matching ``model_root`` against the
-    configured root paths for each model type (from ``Config``).
-
-    The ``model_root`` value comes from the frontend's model-root dropdown,
-    which is populated from the current page's scanner roots.  By checking
-    which scanner's root list it belongs to, we avoid fragile heuristics
-    like substring-matching path names.
-    """
-    norm = os.path.normpath(model_root).replace(os.sep, "/")
-
-    # LoRA roots
-    for p in (config.loras_roots or []) + (config.extra_loras_roots or []):
-        if os.path.normpath(p).replace(os.sep, "/") == norm:
-            return LoraMetadata, "get_lora_scanner"
-
-    # Checkpoint / UNet roots
-    for p in (
-        (config.checkpoints_roots or [])
-        + (config.extra_checkpoints_roots or [])
-        + (config.unet_roots or [])
-        + (config.extra_unet_roots or [])
-    ):
-        if os.path.normpath(p).replace(os.sep, "/") == norm:
-            return CheckpointMetadata, "get_checkpoint_scanner"
-
-    # Embedding roots
-    for p in (config.embeddings_roots or []) + (config.extra_embeddings_roots or []):
-        if os.path.normpath(p).replace(os.sep, "/") == norm:
-            return EmbeddingMetadata, "get_embedding_scanner"
-
-    # Fallback — should not happen in normal use
-    logger.warning(
-        "Could not determine model type for root '%s'; defaulting to LoRA",
-        model_root,
-    )
-    return _DEFAULT_MODEL_CLASS, _DEFAULT_SCANNER_GETTER
-
-
-async def _save_hf_metadata(dest_path: str, repo: str, model_root: str) -> None:
-    """Create a proper .metadata.json and add the model to the scanner cache.
-
-    Uses ``MetadataManager.create_default_metadata()`` which computes the
-    SHA256 hash, extracts safetensors header metadata (base_model), and
-    produces a fully-populated ``LoraMetadata`` (or ``CheckpointMetadata`` /
-    ``EmbeddingMetadata``) object.  We then overlay HF-specific fields and
-    register the model in the in-memory scanner cache so it appears
-    immediately without a full filesystem walk.
-    """
-    try:
-        hf_url = f"https://huggingface.co/{repo}"
-        model_class, scanner_getter_name = _infer_model_type(model_root)
-
-        # 1. Create proper metadata (computes SHA256, reads safetensors headers)
-        metadata = await MetadataManager.create_default_metadata(
-            dest_path, model_class=model_class
-        )
-        if metadata is None:
-            logger.warning("create_default_metadata returned None for %s", dest_path)
-            return
-
-        # 2. Overlay HF-specific fields
-        metadata._unknown_fields["hf_url"] = hf_url
-        metadata.from_civitai = False  # HF models are not from CivitAI
-
-        metadata_dict = metadata.to_dict()
-        if "trainedWords" in metadata_dict and not metadata_dict["trainedWords"]:
-            del metadata_dict["trainedWords"]
-
-        # 3. Save metadata atomically
-        await MetadataManager.save_metadata(dest_path, metadata_dict)
-        logger.info("Saved HF metadata (with hf_url) for %s", dest_path)
-
-        # 4. Determine relative folder path for cache
-        #    model_root is an absolute path; dest_path is under it
-        folder = ""
-        if os.path.isabs(model_root) and dest_path.startswith(model_root):
-            rel = os.path.relpath(os.path.dirname(dest_path), model_root)
-            folder = rel.replace(os.sep, "/") if rel != "." else ""
-
-        # 5. Add to scanner cache (same as CivitAI's _execute_download does)
-        scanner_getter = getattr(ServiceRegistry, scanner_getter_name, None)
-        if scanner_getter is not None:
-            scanner = await scanner_getter()
-            if scanner is not None:
-                metadata_dict = metadata.to_dict()
-                metadata_dict["hf_url"] = hf_url
-                await scanner.add_model_to_cache(metadata_dict, folder)
-                logger.info("Added %s to scanner cache (folder=%s)", dest_path, folder)
-
-    except Exception as exc:
-        logger.warning("Failed to save HF metadata for %s: %s", dest_path, exc)
-
-
-def _find_matching_root(dest_dir: str) -> str | None:
-    """Walk up *dest_dir* to find which configured scanner root it belongs to."""
-    norm = os.path.normpath(dest_dir).replace(os.sep, "/")
-    all_roots = []
-    for root_list in (
-        config.loras_roots or [],
-        config.extra_loras_roots or [],
-        config.checkpoints_roots or [],
-        config.extra_checkpoints_roots or [],
-        config.unet_roots or [],
-        config.extra_unet_roots or [],
-        config.embeddings_roots or [],
-        config.extra_embeddings_roots or [],
-    ):
-        all_roots.extend([os.path.normpath(p).replace(os.sep, "/") for p in root_list])
-    # Find the longest matching prefix
-    match: str | None = None
-    for root in all_roots:
-        if norm.startswith(root):
-            if match is None or len(root) > len(match):
-                match = root
-    return match
-
-
-async def _add_to_scanner_cache(dest_path: str, metadata: dict[str, Any]) -> None:
-    model_dir = os.path.dirname(dest_path)
-    model_root = _find_matching_root(model_dir)
-    if not model_root:
-        raise ValueError(f"File path {dest_path} is not within any configured scanner root")
-    scanner_getter_name = _infer_model_type(model_root)[1]
-    scanner_getter = getattr(ServiceRegistry, scanner_getter_name, None)
-    if scanner_getter is None:
-        raise RuntimeError(f"Scanner getter '{scanner_getter_name}' not found in ServiceRegistry")
-    scanner = await scanner_getter()
-    if scanner is None:
-        raise RuntimeError(f"Scanner '{scanner_getter_name}' returned None")
-    await scanner.update_single_model_cache(dest_path, dest_path, metadata)
-
-
-class HfHandler:
-    """Handle Hugging Face model browsing and download."""
-
-    async def set_hf_url(self, request: web.Request) -> web.Response:
-        try:
-            payload: dict[str, Any] = await request.json()
-        except json.JSONDecodeError:
-            return web.json_response({"success": False, "error": "Invalid JSON"}, status=400)
-
-        file_path = (payload.get("file_path") or "").strip()
-        hf_url = (payload.get("hf_url") or "").strip()
-
-        if not file_path or not hf_url:
-            return web.json_response(
-                {"success": False, "error": "Missing required fields: 'file_path' and 'hf_url'"},
-                status=400,
-            )
-
-        m = re.match(r"^https?://huggingface\.co/([^/]+/[^/]+)/?$", hf_url)
-        if not m:
-            return web.json_response(
-                {
-                    "success": False,
-                    "error": "Invalid HuggingFace URL. Expected format: https://huggingface.co/user/repo",
-                },
-                status=400,
-            )
-
-        if not os.path.isfile(file_path):
-            return web.json_response(
-                {"success": False, "error": f"File not found: {file_path}"},
-                status=404,
-            )
-
-        model_root = _find_matching_root(os.path.dirname(file_path))
-        if not model_root:
-            return web.json_response(
-                {
-                    "success": False,
-                    "error": "File is not within any configured model directory. Cannot link to HuggingFace.",
-                },
-                status=400,
-            )
-
-        try:
-            existing = await MetadataManager.load_metadata_payload(file_path)
-            if existing.get("hf_url") == hf_url:
-                return web.json_response({
-                    "success": True,
-                    "message": "hf_url already set",
-                    "hf_url": hf_url,
-                })
-
-            existing["hf_url"] = hf_url
-            existing["from_civitai"] = False
-            await MetadataManager.save_metadata(file_path, existing)
-
-            await _add_to_scanner_cache(file_path, existing)
-
-            logger.info("Set hf_url=%s for %s", hf_url, file_path)
-            return web.json_response({
-                "success": True,
-                "message": f"hf_url set to {hf_url}",
-                "hf_url": hf_url,
-            })
-        except Exception as exc:
-            logger.error("Failed to set hf_url for %s: %s", file_path, exc)
-            return web.json_response(
-                {"success": False, "error": str(exc)},
-                status=500,
-            )
-
-    async def get_hf_repo_files(self, request: web.Request) -> web.Response:
-        """List model-weight files from a HF repo with real file sizes.
-
-        Uses the HF tree API endpoint which returns accurate file sizes
-        (including LFS-tracked files), unlike the model info endpoint.
-        """
-        repo = request.query.get("repo", "").strip()
-        if not repo or "/" not in repo:
-            return web.json_response(
-                {"error": "Missing or invalid 'repo' parameter (expected user/repo)"},
-                status=400,
-            )
-
-        url = f"https://huggingface.co/api/models/{repo}/tree/main"
-
-        try:
-            session = await _get_hf_api_session()
-            async with session.get(url) as resp:
-                if resp.status == 404:
-                    return web.json_response(
-                        {"error": f"Repo '{repo}' not found"}, status=404
-                    )
-                if resp.status != 200:
-                    text = await resp.text()
-                    return web.json_response(
-                        {"error": f"HF API error {resp.status}: {text[:200]}"},
-                        status=resp.status,
-                    )
-                tree: list[dict[str, Any]] = await resp.json()
-        except Exception as exc:
-            logger.error("Failed to fetch HF repo files: %s", exc)
-            return web.json_response({"error": str(exc)}, status=502)
-
-        files: list[dict[str, Any]] = []
-        for entry in tree:
-            path: str = entry.get("path", "")
-            ext = os.path.splitext(path)[1].lower()
-            if ext not in MODEL_FILE_EXTENSIONS:
-                continue
-            size = entry.get("size", 0) or 0
-            if size == 0 and "lfs" in entry:
-                size = entry["lfs"].get("size", 0) or 0
-            files.append({
-                "filename": path,
-                "size": size,
-            })
-
-        files.sort(key=lambda f: f["size"], reverse=True)
-        return web.json_response(files)
-
-    async def download_hf_model(self, request: web.Request) -> web.Response:
-        """Download a single file from Hugging Face into the model directory.
-
-        POST JSON body::
-
-            {
-              "repo": "dx8152/Flux2-Klein-9B-Consistency",
-              "filename": "Flux2-Klein-9B-consistency-V2.safetensors",
-              "revision": "main",
-              "model_root": "loras",
-              "relative_path": "",
-              "use_default_paths": false,
-              "download_id": "optional-batch-id"
-            }
-
-        If ``download_id`` is provided, real-time progress (bytes, speed,
-        percentage) is broadcast via the WebSocket progress system, matching
-        the CivitAI download experience.
-
-        Respects the ``download_backend`` setting (``aria2`` or ``default``).
-        """
-        try:
-            payload: dict[str, Any] = await request.json()
-        except json.JSONDecodeError:
-            return web.json_response({"error": "Invalid JSON"}, status=400)
-
-        repo = (payload.get("repo") or "").strip()
-        filename = (payload.get("filename") or "").strip()
-        revision = (payload.get("revision") or "main").strip()
-        model_root = (payload.get("model_root") or "").strip()
-        relative_path = (payload.get("relative_path") or "").strip()
-        use_default_paths = bool(payload.get("use_default_paths", False))
-        download_id: str | None = payload.get("download_id")
-
-        logger.info(
-            "download_hf_model: repo=%s file=%s root=%s download_id=%s",
-            repo, filename, model_root, download_id,
-        )
-
-        if not repo or not filename:
-            return web.json_response(
-                {"error": "Missing required fields: 'repo' and 'filename'"}, status=400
-            )
-
-        # Validate repo format — must be user/repo_name
-        if repo.count("/") != 1 or not re.match(r"^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$", repo):
-            return web.json_response({"error": f"Invalid repo format: {repo}"}, status=400)
-        author, repo_name = repo.split("/", 1)
-        if ".." in (author, repo_name) or "." in (author, repo_name):
-            return web.json_response({"error": f"Invalid repo format: {repo}"}, status=400)
-
-        # Validate filename — must not contain path traversal
-        if ".." in filename:
-            return web.json_response({"error": "Invalid filename"}, status=400)
-
-        # Validate relative_path — must not be absolute or escape base directory
-        if relative_path:
-            if os.path.isabs(relative_path):
-                return web.json_response({"error": "relative_path must not be absolute"}, status=400)
-            if ".." in relative_path.split("/") or "\\" in relative_path:
-                return web.json_response({"error": "Invalid relative_path"}, status=400)
-
-        # Use model_root directly as the base directory — same approach as
-        # CivitAI's download path (download_manager.py).  No realpath, no
-        # allowed-roots validation, no path-traversal check; those are
-        # unnecessary when the frontend sends the path from its own dropdown
-        # (populated from scanner roots).  Using the "business path" directly
-        # keeps dest_path consistent with scanner roots so that later folder
-        # derivation (in _save_hf_metadata) works correctly.
-        if os.path.isabs(model_root):
-            base_dir = os.path.normpath(model_root)
-        else:
-            base_dir = os.path.normpath(os.path.join(os.getcwd(), "models", model_root))
-
-        if use_default_paths:
-            target_dir = os.path.join(base_dir, "huggingface", author, repo_name)
-        elif relative_path:
-            target_dir = os.path.join(base_dir, relative_path)
-        else:
-            target_dir = base_dir
-
-        # Strip HF repo subdirectory — "diffusion_models/xxx.safetensors"
-        # is an HF repo convention, not meaningful for local storage.
-        file_base = os.path.basename(filename)
-
-        os.makedirs(target_dir, exist_ok=True)
-        dest_path = os.path.join(target_dir, file_base)
-
-        # Check if already exists (simple skip)
-        if os.path.exists(dest_path) and os.path.getsize(dest_path) > 0:
-            logger.info("download_hf_model: file already exists, skipping — %s", dest_path)
-            return web.json_response({
-                "success": True,
-                "message": f"File already exists: {dest_path}",
-                "path": dest_path,
-            })
-
-        # Build HF resolve URL
-        resolve_url = (
-            f"https://huggingface.co/{repo}/resolve/{revision}/{filename}"
-        )
-
-        # Set up progress callback if download_id is provided
-        progress_callback = None
-        if download_id:
-
-            async def _progress_callback(
-                progress: float | DownloadProgress,
-                snapshot: DownloadProgress | None = None,
-            ) -> None:
-                percent = 0.0
-                metrics = snapshot if isinstance(snapshot, DownloadProgress) else None
-
-                if isinstance(progress, DownloadProgress):
-                    percent = progress.percent_complete
-                    metrics = progress
-                elif isinstance(snapshot, DownloadProgress):
-                    percent = snapshot.percent_complete
-                else:
-                    percent = float(progress)
-
-                broadcast: dict[str, Any] = {
-                    "status": "progress",
-                    "progress": round(percent),
-                }
-                if metrics:
-                    broadcast["bytes_downloaded"] = metrics.bytes_downloaded
-                    broadcast["total_bytes"] = metrics.total_bytes
-                    broadcast["bytes_per_second"] = metrics.bytes_per_second
-
-                await ws_manager.broadcast_download_progress(download_id, broadcast)
-
-            progress_callback = _progress_callback
-
-        # Respect download backend setting (aria2 vs default)
-        download_backend = (
-            get_settings_manager().get("download_backend", "default")
-        )
-
-        if download_backend == "aria2":
-            aria2 = await Aria2Downloader.get_instance()
-            aid = download_id or f"hf_{repo}_{filename}"
-            try:
-                hf_success, hf_result = await aria2.download_file(
-                    url=resolve_url,
-                    save_path=dest_path,
-                    download_id=aid,
-                    progress_callback=progress_callback,
-                )
-                if hf_success:
-                    await _save_hf_metadata(dest_path, repo, model_root)
-                    return web.json_response({
-                        "success": True,
-                        "message": f"Downloaded to {dest_path}",
-                        "path": dest_path,
-                    })
-                else:
-                    return web.json_response(
-                        {"success": False, "error": hf_result or "aria2 download failed"},
-                        status=500,
-                    )
-            except Exception as exc:
-                logger.error("HF download (aria2) failed: %s", exc)
-                return web.json_response(
-                    {"success": False, "error": str(exc)}, status=500
-                )
-
-        # Default: use built-in aiohttp Downloader
-        downloader = await get_downloader()
-        try:
-            success, result = await downloader.download_file(
-                url=resolve_url,
-                save_path=dest_path,
-                use_auth=False,
-                allow_resume=True,
-                progress_callback=progress_callback,
-            )
-            if success:
-                await _save_hf_metadata(dest_path, repo, model_root)
-                return web.json_response({
-                    "success": True,
-                    "message": f"Downloaded to {result}",
-                    "path": result,
-                })
-            else:
-                return web.json_response(
-                    {"success": False, "error": result or "Download failed"},
-                    status=500,
-                )
-        except Exception as exc:
-            logger.error("HF download failed: %s", exc)
-            return web.json_response(
-                {"success": False, "error": str(exc)}, status=500
-            )

py/routes/handlers/preview_handlers.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
-import mimetypes
 import urllib.parse
 from pathlib import Path
 
@@ -14,12 +12,6 @@ from ...config import config as global_config
 
 logger = logging.getLogger(__name__)
 
-_CHUNK_SIZE = 1024 * 1024  # 1 MB — balance between streaming iteration overhead and per-chunk memory
-
-# Video file extensions that bypass native sendfile on Windows
-# to avoid IOCP/ProactorEventLoop crashes during client disconnect.
-_VIDEO_EXTENSIONS = frozenset({".mp4", ".webm", ".mov", ".avi", ".mkv"})
-
 
 class PreviewHandler:
     """Serve preview assets for the active library at request time."""
@@ -54,90 +46,10 @@ class PreviewHandler:
 
         if not resolved.is_file():
             logger.debug("Preview file not found at %s", str(resolved))
-            asyncio.create_task(self._cleanup_stale_preview_url(normalized))
             raise web.HTTPNotFound(text="Preview file not found")
 
-        # aiohttp's FileResponse handles range requests, content headers, and
-        # uses kernel sendfile (zero-copy DMA) on Linux/macOS. On Windows it
-        # uses IOCP-based _sendfile_native which can crash when the client
-        # disconnects mid-transfer during fast scrolling. The _stream_file()
-        # fallback is kept for a future compat toggle.
-        #
-        # Set explicit Cache-Control so the browser can cache video (and image)
-        # previews across VirtualScroller recycling cycles. Without this,
-        # Chrome does not cache 206 Partial Content responses for <video>
-        # elements, causing the same video to be re-downloaded on every scroll.
-        resp = web.FileResponse(path=resolved, chunk_size=_CHUNK_SIZE)
-        resp.headers["Cache-Control"] = "public, max-age=86400"
-        return resp
-
-    async def _cleanup_stale_preview_url(self, normalized_preview_path: str) -> None:
-        """Fire-and-forget: clear stale preview_url from all model caches.
-
-        When a preview file is no longer on disk, remove its reference from
-        every cached entry so subsequent list API responses return an empty
-        ``preview_url``, letting the frontend show the no-preview placeholder.
-        """
-        try:
-            from ...services.service_registry import ServiceRegistry
-
-            for service_name in ("lora_scanner", "checkpoint_scanner", "embedding_scanner"):
-                scanner = ServiceRegistry.get_service_sync(service_name)
-                if scanner is None or not hasattr(scanner, "_cache"):
-                    continue
-                cache = getattr(scanner, "_cache", None)
-                if cache is None or not hasattr(cache, "clear_preview_by_path"):
-                    continue
-                cleared = await cache.clear_preview_by_path(normalized_preview_path)
-                if cleared and hasattr(scanner, "_persist_current_cache"):
-                    await scanner._persist_current_cache()
-                    logger.info(
-                        "Cleared stale preview_url for %d %s entries (%s)",
-                        cleared,
-                        service_name,
-                        normalized_preview_path,
-                    )
-        except Exception as exc:
-            logger.debug("Failed to clean up stale preview_url: %s", exc)
-
-    async def _stream_file(
-        self, request: web.Request, path: Path
-    ) -> web.StreamResponse:
-        """Stream a file chunk-by-chunk, bypassing native sendfile.
-
-        This avoids the Windows IOCP ``_sendfile_native`` crash that occurs
-        when the client disconnects during a large file transfer.
-        """
-        content_type, _ = mimetypes.guess_type(str(path))
-        if content_type is None:
-            content_type = "application/octet-stream"
-
-        file_size = path.stat().st_size
-        resp = web.StreamResponse()
-        resp.content_type = content_type
-        resp.content_length = file_size
-
-        # Allow browser caching: video previews rarely change during a session.
-        # The frontend already appends ?t={version} to bust cache on update.
-        resp.headers["Cache-Control"] = "public, max-age=86400"
-
-        await resp.prepare(request)
-
-        try:
-            with open(path, "rb") as f:
-                while True:
-                    chunk = f.read(_CHUNK_SIZE)
-                    if not chunk:
-                        break
-                    await resp.write(chunk)
-        except (ConnectionResetError, ConnectionAbortedError):
-            # Client disconnected during streaming — expected when scrolling
-            # rapidly through a library with animated previews.
-            pass
-        except OSError as exc:
-            logger.debug("I/O error streaming preview %s: %s", path, exc)
-
-        return resp
+        # aiohttp's FileResponse handles range requests and content headers for us.
+        return web.FileResponse(path=resolved, chunk_size=256 * 1024)
 
 
 __all__ = ["PreviewHandler"]

py/routes/misc_route_registrar.py

@@ -22,19 +22,10 @@ class RouteDefinition:
 MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/settings", "get_settings"),
     RouteDefinition("POST", "/api/lm/settings", "update_settings"),
-    RouteDefinition("GET", "/api/lm/llm/models", "get_llm_models"),
-    RouteDefinition("GET", "/api/lm/llm/provider-models", "get_provider_models"),
-    RouteDefinition("GET", "/api/lm/doctor/diagnostics", "get_doctor_diagnostics"),
-    RouteDefinition("POST", "/api/lm/doctor/repair-cache", "repair_doctor_cache"),
-    RouteDefinition("POST", "/api/lm/doctor/resolve-filename-conflicts", "resolve_doctor_filename_conflicts"),
-    RouteDefinition("POST", "/api/lm/doctor/export-bundle", "export_doctor_bundle"),
     RouteDefinition("GET", "/api/lm/priority-tags", "get_priority_tags"),
     RouteDefinition("GET", "/api/lm/settings/libraries", "get_settings_libraries"),
     RouteDefinition("POST", "/api/lm/settings/libraries/activate", "activate_library"),
     RouteDefinition("GET", "/api/lm/health-check", "health_check"),
-    RouteDefinition("GET", "/api/lm/supporters", "get_supporters"),
-    RouteDefinition("GET", "/api/lm/wildcards/search", "search_wildcards"),
-    RouteDefinition("POST", "/api/lm/wildcards/open-location", "open_wildcards_location"),
     RouteDefinition("POST", "/api/lm/open-file-location", "open_file_location"),
     RouteDefinition("POST", "/api/lm/update-usage-stats", "update_usage_stats"),
     RouteDefinition("GET", "/api/lm/get-usage-stats", "get_usage_stats"),
@@ -45,77 +36,13 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/update-node-widget", "update_node_widget"),
     RouteDefinition("GET", "/api/lm/get-registry", "get_registry"),
     RouteDefinition("GET", "/api/lm/check-model-exists", "check_model_exists"),
-    RouteDefinition("GET", "/api/lm/check-models-exist", "check_models_exist"),
-    RouteDefinition(
-        "GET",
-        "/api/lm/model-version-download-status",
-        "get_model_version_download_status",
-    ),
-    RouteDefinition(
-        "POST",
-        "/api/lm/model-version-download-status",
-        "set_model_version_download_status",
-    ),
-    RouteDefinition(
-        "GET",
-        "/api/lm/set-model-version-download-status",
-        "set_model_version_download_status",
-    ),
     RouteDefinition("GET", "/api/lm/civitai/user-models", "get_civitai_user_models"),
-    RouteDefinition(
-        "POST", "/api/lm/download-metadata-archive", "download_metadata_archive"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"
-    ),
-    RouteDefinition("GET", "/api/lm/backup/status", "get_backup_status"),
-    RouteDefinition("POST", "/api/lm/backup/export", "export_backup"),
-    RouteDefinition("POST", "/api/lm/backup/import", "import_backup"),
-    RouteDefinition("POST", "/api/lm/backup/open-location", "open_backup_location"),
-    RouteDefinition(
-        "GET", "/api/lm/model-versions-status", "get_model_versions_status"
-    ),
+    RouteDefinition("POST", "/api/lm/download-metadata-archive", "download_metadata_archive"),
+    RouteDefinition("POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"),
+    RouteDefinition("GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"),
+    RouteDefinition("GET", "/api/lm/model-versions-status", "get_model_versions_status"),
     RouteDefinition("POST", "/api/lm/settings/open-location", "open_settings_location"),
     RouteDefinition("GET", "/api/lm/custom-words/search", "search_custom_words"),
-    RouteDefinition("GET", "/api/lm/example-workflows", "get_example_workflows"),
-    RouteDefinition(
-        "GET", "/api/lm/example-workflows/{filename}", "get_example_workflow"
-    ),
-    # Base model management routes
-    RouteDefinition("GET", "/api/lm/base-models", "get_base_models"),
-    RouteDefinition("POST", "/api/lm/base-models/refresh", "refresh_base_models"),
-    RouteDefinition(
-        "GET", "/api/lm/base-models/categories", "get_base_model_categories"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/base-models/cache-status", "get_base_model_cache_status"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/delete-model-version", "delete_model_version"
-    ),
-    # Hugging Face model endpoints
-    RouteDefinition(
-        "GET", "/api/lm/hf-repo-files", "get_hf_repo_files"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/download-hf-model", "download_hf_model"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/set-hf-url", "set_hf_url"
-    ),
-    # Agent skill endpoints
-    RouteDefinition(
-        "GET", "/api/lm/agent/skills", "get_agent_skills"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/agent/execute/{skill_name}", "execute_agent_skill"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/agent/cancel", "cancel_agent_skill"
-    ),
 )
 
 
@@ -139,11 +66,7 @@ class MiscRouteRegistrar:
         definitions: Iterable[RouteDefinition] = MISC_ROUTE_DEFINITIONS,
     ) -> None:
         for definition in definitions:
-            self._bind(
-                definition.method,
-                definition.path,
-                handler_lookup[definition.handler_name],
-            )
+            self._bind(definition.method, definition.path, handler_lookup[definition.handler_name])
 
     def _bind(self, method: str, path: str, handler: Callable) -> None:
         add_method_name = self._METHOD_MAP[method.upper()]

py/routes/misc_routes.py

@@ -19,12 +19,9 @@ from ..services.downloader import get_downloader
 from ..utils.usage_stats import UsageStats
 from .handlers.misc_handlers import (
     CustomWordsHandler,
-    DoctorHandler,
-    ExampleWorkflowsHandler,
     FileSystemHandler,
     HealthCheckHandler,
     LoraCodeHandler,
-    BackupHandler,
     MetadataArchiveHandler,
     MiscHandlerSet,
     ModelExampleFilesHandler,
@@ -32,23 +29,17 @@ from .handlers.misc_handlers import (
     NodeRegistry,
     NodeRegistryHandler,
     SettingsHandler,
-    SupportersHandler,
     TrainedWordsHandler,
     UsageStatsHandler,
-    WildcardsHandler,
     build_service_registry_adapter,
 )
-from .handlers.base_model_handlers import BaseModelHandlerSet
-from .handlers.hf_handlers import HfHandler
-from .handlers.agent_handlers import AgentHandler
 from .misc_route_registrar import MiscRouteRegistrar
 
 logger = logging.getLogger(__name__)
 
-standalone_mode = (
-    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
-    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
-)
+standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get(
+    "HF_HUB_DISABLE_TELEMETRY", "0"
+) == "0"
 
 
 class MiscRoutes:
@@ -83,9 +74,7 @@ class MiscRoutes:
         self._node_registry = node_registry or NodeRegistry()
         self._standalone_mode = standalone_mode_flag
 
-        self._handler_mapping: (
-            Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None
-        ) = None
+        self._handler_mapping: Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None = None
 
     @staticmethod
     def setup_routes(app: web.Application) -> None:
@@ -97,9 +86,7 @@ class MiscRoutes:
         registrar = self._registrar_factory(app)
         registrar.register_routes(self._ensure_handler_mapping())
 
-    def _ensure_handler_mapping(
-        self,
-    ) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
+    def _ensure_handler_mapping(self) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
         if self._handler_mapping is None:
             handler_set = self._create_handler_set()
             self._handler_mapping = handler_set.to_route_mapping()
@@ -121,7 +108,6 @@ class MiscRoutes:
             settings_service=self._settings,
             metadata_provider_updater=self._metadata_provider_updater,
         )
-        backup = BackupHandler()
         filesystem = FileSystemHandler(settings_service=self._settings)
         node_registry_handler = NodeRegistryHandler(
             node_registry=self._node_registry,
@@ -133,13 +119,6 @@ class MiscRoutes:
             metadata_provider_factory=self._metadata_provider_factory,
         )
         custom_words = CustomWordsHandler()
-        wildcards = WildcardsHandler()
-        supporters = SupportersHandler()
-        doctor = DoctorHandler(settings_service=self._settings)
-        example_workflows = ExampleWorkflowsHandler()
-        base_model = BaseModelHandlerSet()
-        hf_handler = HfHandler()
-        agent_handler = AgentHandler()
 
         return self._handler_set_factory(
             health=health,
@@ -151,16 +130,8 @@ class MiscRoutes:
             node_registry=node_registry_handler,
             model_library=model_library,
             metadata_archive=metadata_archive,
-            backup=backup,
             filesystem=filesystem,
             custom_words=custom_words,
-            wildcards=wildcards,
-            supporters=supporters,
-            doctor=doctor,
-            example_workflows=example_workflows,
-            base_model=base_model,
-            hf_handler=hf_handler,
-            agent_handler=agent_handler,
         )
 
 

py/routes/model_route_registrar.py

@@ -1,5 +1,4 @@
 """Route registrar for model endpoints."""
-
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -22,17 +21,12 @@ class RouteDefinition:
 
 COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/{prefix}/list", "get_models"),
-    RouteDefinition("GET", "/api/lm/{prefix}/excluded", "get_excluded_models"),
     RouteDefinition("POST", "/api/lm/{prefix}/delete", "delete_model"),
     RouteDefinition("POST", "/api/lm/{prefix}/exclude", "exclude_model"),
-    RouteDefinition("POST", "/api/lm/{prefix}/unexclude", "unexclude_model"),
     RouteDefinition("POST", "/api/lm/{prefix}/fetch-civitai", "fetch_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/fetch-all-civitai", "fetch_all_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/relink-civitai", "relink_civitai"),
     RouteDefinition("POST", "/api/lm/{prefix}/replace-preview", "replace_preview"),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/set-preview-from-url", "set_preview_from_url"
-    ),
     RouteDefinition("POST", "/api/lm/{prefix}/save-metadata", "save_metadata"),
     RouteDefinition("POST", "/api/lm/{prefix}/add-tags", "add_tags"),
     RouteDefinition("POST", "/api/lm/{prefix}/rename", "rename_model"),
@@ -42,9 +36,7 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/{prefix}/move_models_bulk", "move_models_bulk"),
     RouteDefinition("GET", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
     RouteDefinition("POST", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"),
     RouteDefinition("GET", "/api/lm/{prefix}/top-tags", "get_top_tags"),
     RouteDefinition("GET", "/api/lm/{prefix}/base-models", "get_base_models"),
     RouteDefinition("GET", "/api/lm/{prefix}/model-types", "get_model_types"),
@@ -52,95 +44,30 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/{prefix}/roots", "get_model_roots"),
     RouteDefinition("GET", "/api/lm/{prefix}/folders", "get_folders"),
     RouteDefinition("GET", "/api/lm/{prefix}/folder-tree", "get_folder_tree"),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"),
     RouteDefinition("GET", "/api/lm/{prefix}/find-duplicates", "find_duplicate_models"),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"),
     RouteDefinition("GET", "/api/lm/{prefix}/get-notes", "get_model_notes"),
     RouteDefinition("GET", "/api/lm/{prefix}/preview-url", "get_model_preview_url"),
     RouteDefinition("GET", "/api/lm/{prefix}/civitai-url", "get_model_civitai_url"),
     RouteDefinition("GET", "/api/lm/{prefix}/metadata", "get_model_metadata"),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/model-description", "get_model_description"
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/model-description", "get_model_description"),
     RouteDefinition("GET", "/api/lm/{prefix}/relative-paths", "get_relative_paths"),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"
-    ),
-    RouteDefinition(
-        "GET",
-        "/api/lm/{prefix}/civitai/model/version/{modelVersionId}",
-        "get_civitai_model_by_version",
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"
-    ),
-    RouteDefinition(
-        "POST",
-        "/api/lm/{prefix}/updates/fetch-missing-license",
-        "fetch_missing_civitai_license_data",
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"
-    ),
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"),
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/version/{modelVersionId}", "get_civitai_model_by_version"),
+    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"),
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"),
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/fetch-missing-license", "fetch_missing_civitai_license_data"),
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"),
+    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"),
+    RouteDefinition("GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"),
+    RouteDefinition("GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"),
     RouteDefinition("POST", "/api/lm/download-model", "download_model"),
     RouteDefinition("GET", "/api/lm/download-model-get", "download_model_get"),
     RouteDefinition("GET", "/api/lm/cancel-download-get", "cancel_download_get"),
-    RouteDefinition("GET", "/api/lm/skip-download", "skip_download_get"),
     RouteDefinition("GET", "/api/lm/pause-download", "pause_download_get"),
     RouteDefinition("GET", "/api/lm/resume-download", "resume_download_get"),
-    RouteDefinition(
-        "GET", "/api/lm/download-progress/{download_id}", "get_download_progress"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/queue", "get_download_queue"),
-    RouteDefinition("GET", "/api/lm/downloads/queue/add", "add_to_download_queue"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/remove", "remove_from_download_queue"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/move-to-top", "move_queue_item_to_top"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/move-to-end", "move_queue_item_to_end"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/clear", "clear_download_queue"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/history", "get_download_history"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/clear", "clear_download_history"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/delete", "delete_download_history_item"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/retry", "retry_download_from_history"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/history/retry-all", "retry_all_failed_downloads"
-    ),
-    RouteDefinition("GET", "/api/lm/downloads/stats", "get_download_stats"),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/complete", "complete_download_in_queue"
-    ),
-    RouteDefinition(
-        "GET", "/api/lm/downloads/queue/status", "update_download_queue_status"
-    ),
+    RouteDefinition("GET", "/api/lm/download-progress/{download_id}", "get_download_progress"),
     RouteDefinition("POST", "/api/lm/{prefix}/cancel-task", "cancel_task"),
     RouteDefinition("GET", "/{prefix}", "handle_models_page"),
 )
@@ -167,18 +94,12 @@ class ModelRouteRegistrar:
         definitions: Iterable[RouteDefinition] = COMMON_ROUTE_DEFINITIONS,
     ) -> None:
         for definition in definitions:
-            self._bind_route(
-                definition.method,
-                definition.build_path(prefix),
-                handler_lookup[definition.handler_name],
-            )
+            self._bind_route(definition.method, definition.build_path(prefix), handler_lookup[definition.handler_name])
 
     def add_route(self, method: str, path: str, handler: Callable) -> None:
         self._bind_route(method, path, handler)
 
-    def add_prefixed_route(
-        self, method: str, path_template: str, prefix: str, handler: Callable
-    ) -> None:
+    def add_prefixed_route(self, method: str, path_template: str, prefix: str, handler: Callable) -> None:
         self._bind_route(method, path_template.replace("{prefix}", prefix), handler)
 
     def _bind_route(self, method: str, path: str, handler: Callable) -> None:

py/routes/recipe_route_registrar.py

@@ -1,5 +1,4 @@
 """Route registrar for recipe endpoints."""
-
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -23,9 +22,7 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}", "get_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/import-remote", "import_remote_recipe"),
     RouteDefinition("POST", "/api/lm/recipes/analyze-image", "analyze_uploaded_image"),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/analyze-local-image", "analyze_local_image"
-    ),
+    RouteDefinition("POST", "/api/lm/recipes/analyze-local-image", "analyze_local_image"),
     RouteDefinition("POST", "/api/lm/recipes/save", "save_recipe"),
     RouteDefinition("DELETE", "/api/lm/recipe/{recipe_id}", "delete_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/top-tags", "get_top_tags"),
@@ -33,13 +30,9 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/recipes/roots", "get_roots"),
     RouteDefinition("GET", "/api/lm/recipes/folders", "get_folders"),
     RouteDefinition("GET", "/api/lm/recipes/folder-tree", "get_folder_tree"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"
-    ),
+    RouteDefinition("GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share", "share_recipe"),
-    RouteDefinition(
-        "GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"
-    ),
+    RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/syntax", "get_recipe_syntax"),
     RouteDefinition("PUT", "/api/lm/recipe/{recipe_id}/update", "update_recipe"),
     RouteDefinition("POST", "/api/lm/recipe/move", "move_recipe"),
@@ -47,40 +40,13 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/recipe/lora/reconnect", "reconnect_lora"),
     RouteDefinition("GET", "/api/lm/recipes/find-duplicates", "find_duplicates"),
     RouteDefinition("POST", "/api/lm/recipes/bulk-delete", "bulk_delete"),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/save-from-widget", "save_recipe_from_widget"
-    ),
+    RouteDefinition("POST", "/api/lm/recipes/save-from-widget", "save_recipe_from_widget"),
     RouteDefinition("GET", "/api/lm/recipes/for-lora", "get_recipes_for_lora"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/for-checkpoint", "get_recipes_for_checkpoint"
-    ),
     RouteDefinition("GET", "/api/lm/recipes/scan", "scan_recipes"),
     RouteDefinition("POST", "/api/lm/recipes/repair", "repair_recipes"),
     RouteDefinition("POST", "/api/lm/recipes/cancel-repair", "cancel_repair"),
     RouteDefinition("POST", "/api/lm/recipe/{recipe_id}/repair", "repair_recipe"),
-    RouteDefinition("POST", "/api/lm/recipes/repair-bulk", "repair_recipes_bulk"),
     RouteDefinition("GET", "/api/lm/recipes/repair-progress", "get_repair_progress"),
-    RouteDefinition("POST", "/api/lm/recipes/batch-import/start", "start_batch_import"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/batch-import/progress", "get_batch_import_progress"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/batch-import/cancel", "cancel_batch_import"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/batch-import/directory", "start_directory_import"
-    ),
-    RouteDefinition("POST", "/api/lm/recipes/browse-directory", "browse_directory"),
-    RouteDefinition(
-        "GET", "/api/lm/recipes/check-image-exists", "check_image_exists"
-    ),
-    RouteDefinition("GET", "/api/lm/recipes/import-from-url", "import_from_url"),
-    RouteDefinition(
-        "POST", "/api/lm/recipes/create-from-example", "create_from_example"
-    ),
-    RouteDefinition(
-        "POST", "/api/lm/recipe/{recipe_id}/reimport", "reimport_recipe"
-    ),
 )
 
 
@@ -97,9 +63,7 @@ class RecipeRouteRegistrar:
     def __init__(self, app: web.Application) -> None:
         self._app = app
 
-    def register_routes(
-        self, handler_lookup: Mapping[str, Callable[[web.Request], object]]
-    ) -> None:
+    def register_routes(self, handler_lookup: Mapping[str, Callable[[web.Request], object]]) -> None:
         for definition in ROUTE_DEFINITIONS:
             handler = handler_lookup[definition.handler_name]
             self._bind_route(definition.method, definition.path, handler)

py/routes/stats_routes.py

@@ -11,8 +11,6 @@ from ..config import config
 from ..services.settings_manager import get_settings_manager
 from ..services.server_i18n import server_i18n
 from ..services.service_registry import ServiceRegistry
-from ..services.model_query import normalize_sub_type, resolve_sub_type
-from ..utils.constants import VALID_LORA_SUB_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.usage_stats import UsageStats
 
 logger = logging.getLogger(__name__)
@@ -142,21 +140,6 @@ class StatsRoutes:
             # Get usage statistics
             usage_data = await self.usage_stats.get_stats()
             
-            # CivitAI model type distribution across all model types
-            # Use the same logic as the filter panel: normalize_sub_type(resolve_sub_type(entry))
-            # with sub-type validation per model type
-            model_types_counter: Counter[str] = Counter()
-            for entry in lora_cache.raw_data:
-                ntype = normalize_sub_type(resolve_sub_type(entry))
-                if ntype and ntype in VALID_LORA_SUB_TYPES:
-                    model_types_counter[ntype] += 1
-            for entry in checkpoint_cache.raw_data:
-                ntype = normalize_sub_type(resolve_sub_type(entry))
-                if ntype and ntype in VALID_CHECKPOINT_SUB_TYPES:
-                    model_types_counter[ntype] += 1
-            # Embeddings: always count as "embedding" regardless of CivitAI sub-type
-            model_types_counter['embedding'] = len(embedding_cache.raw_data)
-            
             return web.json_response({
                 'success': True,
                 'data': {
@@ -171,8 +154,7 @@ class StatsRoutes:
                     'total_generations': usage_data.get('total_executions', 0),
                     'unused_loras': self._count_unused_models(lora_cache.raw_data, usage_data.get('loras', {})),
                     'unused_checkpoints': self._count_unused_models(checkpoint_cache.raw_data, usage_data.get('checkpoints', {})),
-                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {})),
-                    'model_types_distribution': dict(model_types_counter.most_common())
+                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {}))
                 }
             })
             
@@ -227,80 +209,6 @@ class StatsRoutes:
                 'error': str(e)
             }, status=500)
 
-    async def get_model_usage_list(self, request: web.Request) -> web.Response:
-        """Get paginated model usage list for infinite scrolling"""
-        try:
-            await self.init_services()
-            
-            model_type = request.query.get('type', 'lora')
-            sort_order = request.query.get('sort', 'desc')
-            
-            try:
-                limit = int(request.query.get('limit', '50'))
-                offset = int(request.query.get('offset', '0'))
-            except ValueError:
-                limit = 50
-                offset = 0
-
-            # Get usage statistics
-            usage_data = await self.usage_stats.get_stats()
-            
-            # Select proper cache and usage dict based on type
-            if model_type == 'lora':
-                cache = await self.lora_scanner.get_cached_data()
-                type_usage_data = usage_data.get('loras', {})
-            elif model_type == 'checkpoint':
-                cache = await self.checkpoint_scanner.get_cached_data()
-                type_usage_data = usage_data.get('checkpoints', {})
-            elif model_type == 'embedding':
-                cache = await self.embedding_scanner.get_cached_data()
-                type_usage_data = usage_data.get('embeddings', {})
-            else:
-                return web.json_response({'success': False, 'error': f"Invalid model type: {model_type}"}, status=400)
-
-            # Create list of all models
-            all_models = []
-            for item in cache.raw_data:
-                sha256 = item.get('sha256')
-                usage_info = type_usage_data.get(sha256, {}) if sha256 else {}
-                usage_count = usage_info.get('total', 0) if isinstance(usage_info, dict) else 0
-                
-                all_models.append({
-                    'name': item.get('model_name', 'Unknown'),
-                    'usage_count': usage_count,
-                    'base_model': item.get('base_model', 'Unknown'),
-                    'preview_url': config.get_preview_static_url(item.get('preview_url', '')),
-                    'folder': item.get('folder', '')
-                })
-
-            # Sort the models
-            reverse = (sort_order == 'desc')
-            all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()), reverse=reverse)
-            if not reverse:
-                # If asc, sort by usage_count ascending, but keep name ascending
-                all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()))
-            else:
-                all_models.sort(key=lambda x: (-x['usage_count'], x['name'].lower()))
-
-            # Slice for pagination
-            paginated_models = all_models[offset:offset + limit]
-
-            return web.json_response({
-                'success': True,
-                'data': {
-                    'items': paginated_models,
-                    'total': len(all_models),
-                    'type': model_type
-                }
-            })
-
-        except Exception as e:
-            logger.error(f"Error getting model usage list: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
-
     async def get_base_model_distribution(self, request: web.Request) -> web.Response:
         """Get base model distribution statistics"""
         try:
@@ -477,12 +385,9 @@ class StatsRoutes:
                 if unused_lora_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedLoras.high',
-                        'params': {
-                            'percent': f'{unused_lora_percent:.1f}',
-                            'count': str(unused_loras),
-                            'total': str(total_loras)
-                        }
+                        'title': 'High Number of Unused LoRAs',
+                        'description': f'{unused_lora_percent:.1f}% of your LoRAs ({unused_loras}/{total_loras}) have never been used.',
+                        'suggestion': 'Consider organizing or archiving unused models to free up storage space.'
                     })
             
             if total_checkpoints > 0:
@@ -490,12 +395,9 @@ class StatsRoutes:
                 if unused_checkpoint_percent > 30:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedCheckpoints.detected',
-                        'params': {
-                            'percent': f'{unused_checkpoint_percent:.1f}',
-                            'count': str(unused_checkpoints),
-                            'total': str(total_checkpoints)
-                        }
+                        'title': 'Unused Checkpoints Detected',
+                        'description': f'{unused_checkpoint_percent:.1f}% of your checkpoints ({unused_checkpoints}/{total_checkpoints}) have never been used.',
+                        'suggestion': 'Review and consider removing checkpoints you no longer need.'
                     })
             
             if total_embeddings > 0:
@@ -503,12 +405,9 @@ class StatsRoutes:
                 if unused_embedding_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'key': 'insights.unusedEmbeddings.high',
-                        'params': {
-                            'percent': f'{unused_embedding_percent:.1f}',
-                            'count': str(unused_embeddings),
-                            'total': str(total_embeddings)
-                        }
+                        'title': 'High Number of Unused Embeddings',
+                        'description': f'{unused_embedding_percent:.1f}% of your embeddings ({unused_embeddings}/{total_embeddings}) have never been used.',
+                        'suggestion': 'Consider organizing or archiving unused embeddings to optimize your collection.'
                     })
             
             # Storage insights
@@ -519,20 +418,18 @@ class StatsRoutes:
             if total_size > 100 * 1024 * 1024 * 1024:  # 100GB
                 insights.append({
                     'type': 'info',
-                    'key': 'insights.collection.large',
-                    'params': {
-                        'size': self._format_size(total_size)
-                    }
+                    'title': 'Large Collection Detected',
+                    'description': f'Your model collection is using {self._format_size(total_size)} of storage.',
+                    'suggestion': 'Consider using external storage or cloud solutions for better organization.'
                 })
             
             # Recent activity insight
             if usage_data.get('total_executions', 0) > 100:
                 insights.append({
                     'type': 'success',
-                    'key': 'insights.activity.active',
-                    'params': {
-                        'count': str(usage_data['total_executions'])
-                    }
+                    'title': 'Active User',
+                    'description': f'You\'ve completed {usage_data["total_executions"]} generations so far!',
+                    'suggestion': 'Keep exploring and creating amazing content with your models.'
                 })
             
             return web.json_response({
@@ -633,7 +530,6 @@ class StatsRoutes:
         # Register API routes
         app.router.add_get('/api/lm/stats/collection-overview', self.get_collection_overview)
         app.router.add_get('/api/lm/stats/usage-analytics', self.get_usage_analytics)
-        app.router.add_get('/api/lm/stats/model-usage-list', self.get_model_usage_list)
         app.router.add_get('/api/lm/stats/base-model-distribution', self.get_base_model_distribution)
         app.router.add_get('/api/lm/stats/tag-analytics', self.get_tag_analytics)
         app.router.add_get('/api/lm/stats/storage-analytics', self.get_storage_analytics)

py/routes/update_routes.py

@@ -1,6 +1,7 @@
 import os
 import logging
 import toml
+import git
 import zipfile
 import shutil
 import tempfile
@@ -10,33 +11,11 @@ from typing import Dict, List
 
 from ..utils.settings_paths import ensure_settings_file
 from ..services.downloader import get_downloader
-from ..services.service_registry import ServiceRegistry
 
 logger = logging.getLogger(__name__)
 
 NETWORK_EXCEPTIONS = (ClientError, OSError, asyncio.TimeoutError)
 
-# User-managed directories that live inside the plugin folder (portable
-# mode) and must survive a Git-based update. ``git clean -fd`` would
-# otherwise delete them because they are untracked and, in released tags,
-# not listed in ``.gitignore``. ``-e`` excludes a path from cleaning
-# regardless of whether it is ignored.
-_PRESERVE_DIRS = ('settings.json', 'civitai', 'wildcards', 'backups', 'stats', 'logs', 'cache', 'model_cache')
-
-
-def _clean_excludes() -> List[str]:
-    """Build the ``-e`` arguments for ``git clean`` from :data:`_PRESERVE_DIRS`."""
-    excludes: List[str] = []
-    for name in _PRESERVE_DIRS:
-        excludes.append('-e')
-        excludes.append(name)
-        # For directories, also exclude nested matches explicitly
-        # (``-e dir`` alone matches the dir entry; ``-e dir/**`` guards
-        # contents under all git versions as defense-in-depth).
-        excludes.append('-e')
-        excludes.append(f'{name}/**')
-    return excludes
-
 
 class UpdateRoutes:
     """Routes for handling plugin update checks"""
@@ -233,19 +212,8 @@ class UpdateRoutes:
 
             zip_path = tmp_zip_path
 
-            # Close the downloaded-versions SQLite connection before cleaning,
-            # so that shutil.rmtree() does not fail on Windows (the process
-            # cannot delete a file with an outstanding open handle).
-            try:
-                history_svc = ServiceRegistry._services.get("downloaded_version_history_service")
-                if history_svc is not None:
-                    history_svc.close()
-                    logger.info("Closed downloaded-version history database connection")
-            except Exception:
-                logger.debug("Could not close downloaded-version history database", exc_info=True)
-
-            # Skip settings.json, civitai, model cache and runtime cache folders
-            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache', 'cache', 'wildcards', 'backups', 'stats'])
+            # Skip both settings.json, civitai and model cache folder
+            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache'])
 
             # Extract ZIP to temp dir
             with tempfile.TemporaryDirectory() as tmp_dir:
@@ -254,17 +222,16 @@ class UpdateRoutes:
                     # Find extracted folder (GitHub ZIP contains a root folder)
                     extracted_root = next(os.scandir(tmp_dir)).path
 
-                    # Copy files, skipping user data that should be preserved
-                    skip_items = {'settings.json', 'civitai', 'wildcards', 'backups', 'stats'}
+                    # Copy files, skipping settings.json and civitai folder
                     for item in os.listdir(extracted_root):
-                        if item in skip_items:
+                        if item == 'settings.json' or item == 'civitai':
                             continue
                         src = os.path.join(extracted_root, item)
                         dst = os.path.join(plugin_root, item)
                         if os.path.isdir(src):
                             if os.path.exists(dst):
                                 shutil.rmtree(dst)
-                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns(*skip_items))
+                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns('settings.json', 'civitai'))
                         else:
                             shutil.copy2(src, dst)
 
@@ -272,17 +239,15 @@ class UpdateRoutes:
                     # for ComfyUI Manager to work properly
                     tracking_info_file = os.path.join(plugin_root, '.tracking')
                     tracking_files = []
-                    skip_tracked = {'civitai', 'wildcards', 'backups', 'stats'}
                     for root, dirs, files in os.walk(extracted_root):
-                        # Skip user data directories and their contents
+                        # Skip civitai folder and its contents
                         rel_root = os.path.relpath(root, extracted_root)
-                        top_dir = rel_root.split(os.sep)[0] if rel_root != '.' else ''
-                        if top_dir in skip_tracked:
+                        if rel_root == 'civitai' or rel_root.startswith('civitai' + os.sep):
                             continue
                         for file in files:
                             rel_path = os.path.relpath(os.path.join(root, file), extracted_root)
-                            # Skip settings.json and any file under user data dirs
-                            if rel_path == 'settings.json' or rel_path.split(os.sep)[0] in skip_tracked:
+                            # Skip settings.json and any file under civitai
+                            if rel_path == 'settings.json' or rel_path.startswith('civitai' + os.sep):
                                 continue
                             tracking_files.append(rel_path.replace("\\", "/"))
                     with open(tracking_info_file, "w", encoding='utf-8') as file:
@@ -377,17 +342,6 @@ class UpdateRoutes:
         Returns:
             tuple: (success, new_version)
         """
-        try:
-            import git
-        except ImportError:
-            logger.error(
-                "GitPython is not available: the git executable was not found in PATH. "
-                "Install git or set $GIT_PYTHON_GIT_EXECUTABLE to the git binary path."
-            )
-            return False, ""
-
-        clean_excludes = _clean_excludes()
-
         try:
             # Open the Git repository
             repo = git.Repo(plugin_root)
@@ -399,9 +353,8 @@ class UpdateRoutes:
             if nightly:
                 # Reset to discard any local changes
                 repo.git.reset('--hard')
-                # Clean untracked files, but preserve user-managed directories
-                # (wildcards, backups, stats, civitai, caches, settings.json).
-                repo.git.clean('-fd', *clean_excludes)
+                # Clean untracked files
+                repo.git.clean('-fd')
                 
                 # Switch to main branch and pull latest
                 main_branch = 'main'
@@ -418,9 +371,8 @@ class UpdateRoutes:
             else:
                 # Reset to discard any local changes
                 repo.git.reset('--hard')
-                # Clean untracked files, but preserve user-managed directories
-                # (wildcards, backups, stats, civitai, caches, settings.json).
-                repo.git.clean('-fd', *clean_excludes)
+                # Clean untracked files
+                repo.git.clean('-fd')
                 
                 # Get latest release tag
                 tags = sorted(repo.tags, key=lambda t: t.commit.committed_datetime, reverse=True)
@@ -486,7 +438,6 @@ class UpdateRoutes:
             if not os.path.exists(os.path.join(plugin_root, '.git')):
                 return git_info
 
-            import git
             repo = git.Repo(plugin_root)
             commit = repo.head.commit
             git_info['commit_hash'] = commit.hexsha

py/services/agent/__init__.py

@@ -1,27 +0,0 @@
-"""LLM-powered metadata enrichment pipeline infrastructure.
-
-This package provides the orchestration layer for LLM-powered features.
-Skills define *what* to do (prompt template).  The :class:`AgentService`
-handles *how* (LLM calls, context gathering, validation, progress).
-
-NOTE: The current implementation is a code-driven pipeline, not a true
-agent loop.  Future agent orchestration (LLM-driven tool selection) will
-live alongside this package with its own namespace.
-"""
-
-from __future__ import annotations
-
-from .skill_definition import SkillDefinition, SkillPermissions
-from .skill_registry import SkillRegistry
-from .agent_service import AgentService, AgentProgressReporter, SkillResult
-from .post_processor import PostProcessor
-
-__all__ = [
-    "AgentProgressReporter",
-    "AgentService",
-    "PostProcessor",
-    "SkillDefinition",
-    "SkillPermissions",
-    "SkillRegistry",
-    "SkillResult",
-]

py/services/agent/agent_service.py

@@ -1,489 +0,0 @@
-"""Pipeline orchestration service.
-
-The :class:`AgentService` coordinates LLM-powered pipeline execution:
-
-1. Look up the pipeline definition in :class:`SkillRegistry`
-2. Validate input against its ``input_schema``
-3. Prepare context via :mod:`~py.metadata_ops` (read metadata, list base models, fetch HF README)
-4. If ``llm_required``: call :class:`LLMService` with the rendered prompt
-5. Post-process via :class:`PostProcessor` (delegates I/O to :mod:`~py.metadata_ops`)
-6. Broadcast progress and completion via :class:`WebSocketManager`
-
-Pipeline definitions (*skills*) describe *what* to do (prompt template).
-The AgentService handles *how* (LLM calls, context gathering, validation,
-progress).
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import re
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-import aiohttp
-
-import os
-
-from ...config import config
-from ..llm_service import LLMService
-from ..websocket_manager import ws_manager
-from .post_processor import PostProcessor
-from .skill_registry import SkillRegistry
-from .skills.enrich_hf_metadata.readme_processor import (
-    clean_readme_for_llm,
-    extract_relevant_section,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AgentProgressReporter:
-    """Protocol-compatible progress reporter backed by WebSocket broadcast."""
-
-    async def on_progress(self, payload: Dict[str, Any]) -> None:
-        await ws_manager.broadcast(payload)
-
-
-@dataclass
-class SkillResult:
-    """Outcome of a skill execution."""
-
-    success: bool
-    updated_models: List[Dict[str, Any]] = field(default_factory=list)
-    errors: List[str] = field(default_factory=list)
-    summary: str = ""
-
-
-def _validate_schema(data: Any, schema: Dict[str, Any], path: str = "") -> List[str]:
-    """Minimal JSON schema validator.
-
-    Supports a subset of JSON Schema: ``type``, ``properties``, ``required``,
-    ``items``, ``enum``.  Returns a list of error messages (empty = valid).
-    """
-
-    errors: List[str] = []
-    if not schema:
-        return errors
-
-    expected_type = schema.get("type")
-    if expected_type:
-        type_map = {
-            "string": str,
-            "number": (int, float),
-            "integer": int,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-        expected_py = type_map.get(expected_type)
-        if expected_py is not None and not isinstance(data, expected_py):
-            errors.append(f"{path or 'root'}: expected {expected_type}, got {type(data).__name__}")
-            return errors
-
-    if expected_type == "object" and isinstance(data, dict):
-        properties = schema.get("properties", {})
-        required = schema.get("required", [])
-        for req_key in required:
-            if req_key not in data:
-                errors.append(f"{path or 'root'}: missing required property '{req_key}'")
-        for key, value in data.items():
-            if key in properties:
-                errors.extend(_validate_schema(value, properties[key], f"{path}.{key}"))
-
-    if expected_type == "array" and isinstance(data, list):
-        items_schema = schema.get("items")
-        if items_schema:
-            for i, item in enumerate(data):
-                errors.extend(_validate_schema(item, items_schema, f"{path}[{i}]"))
-
-    if "enum" in schema and data not in schema["enum"]:
-        errors.append(f"{path or 'root'}: value '{data}' not in enum {schema['enum']}")
-
-    return errors
-
-
-# ------------------------------------------------------------------
-# Prompt template rendering
-# ------------------------------------------------------------------
-
-
-def _render_prompt(template: str, variables: Dict[str, Any]) -> str:
-    """Render a prompt template with ``{{variable}}`` placeholders.
-
-    Uses simple regex substitution — no Jinja2 dependency needed.
-    """
-
-    def replace(match: re.Match) -> str:
-        key = match.group(1).strip()
-        value = variables.get(key, "")
-        if isinstance(value, (dict, list)):
-            return json.dumps(value, ensure_ascii=False, indent=2)
-        return str(value)
-
-    return re.sub(r"\{\{(\w+)\}\}", replace, template)
-
-
-class AgentService:
-    """Orchestrate agent skill execution.
-
-    Usage::
-
-        service = await AgentService.get_instance()
-        result = await service.execute_skill(
-            skill_name="enrich_hf_metadata",
-            input_data={"model_paths": ["/path/to/model.safetensors"]},
-            progress_callback=AgentProgressReporter(),
-        )
-    """
-
-    _instance: Optional["AgentService"] = None
-    _lock: asyncio.Lock = asyncio.Lock()
-
-    def __init__(
-        self,
-        *,
-        skill_registry: Optional[SkillRegistry] = None,
-        llm_service: Optional[LLMService] = None,
-    ) -> None:
-        self._registry = skill_registry
-        self._llm_service = llm_service
-
-    @classmethod
-    async def get_instance(cls) -> "AgentService":
-        """Return the lazily-initialised global ``AgentService``."""
-
-        if cls._instance is None:
-            async with cls._lock:
-                if cls._instance is None:
-                    cls._instance = cls(
-                        skill_registry=await SkillRegistry.get_instance(),
-                        llm_service=await LLMService.get_instance(),
-                    )
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        """Reset the cached singleton — primarily for tests."""
-
-        cls._instance = None
-
-    async def _ensure_registry(self) -> SkillRegistry:
-        if self._registry is None:
-            self._registry = await SkillRegistry.get_instance()
-        return self._registry
-
-    async def _ensure_llm(self) -> LLMService:
-        if self._llm_service is None:
-            self._llm_service = await LLMService.get_instance()
-        return self._llm_service
-
-    async def list_skills(self) -> List[Dict[str, Any]]:
-        """Return a JSON-serialisable list of available skills."""
-
-        registry = await self._ensure_registry()
-        return [
-            {
-                "name": s.name,
-                "title": s.title,
-                "description": s.description,
-                "llm_required": s.llm_required,
-                "model_type_filter": s.model_type_filter,
-            }
-            for s in registry.list_skills()
-        ]
-
-    async def execute_skill(
-        self,
-        *,
-        skill_name: str,
-        input_data: Dict[str, Any],
-        progress_callback: Optional[AgentProgressReporter] = None,
-    ) -> SkillResult:
-        """Execute a pipeline (skill) on the given models.
-
-        Args:
-            skill_name: Name of the pipeline to execute
-            input_data: Input validated against the pipeline's ``input_schema``
-            progress_callback: Optional WebSocket progress reporter
-
-        Returns:
-            :class:`SkillResult` with success status and updated model info
-        """
-
-        registry = await self._ensure_registry()
-        skill = registry.get_skill(skill_name)
-        if skill is None:
-            return SkillResult(
-                success=False,
-                errors=[f"Skill not found: {skill_name}"],
-                summary=f"Skill '{skill_name}' does not exist",
-            )
-
-        input_errors = _validate_schema(input_data, skill.input_schema)
-        if input_errors:
-            return SkillResult(
-                success=False,
-                errors=input_errors,
-                summary=f"Invalid input: {'; '.join(input_errors)}",
-            )
-
-        model_paths = input_data.get("model_paths", [])
-        if not model_paths:
-            return SkillResult(
-                success=False,
-                errors=["No model_paths provided"],
-                summary="No models to process",
-            )
-
-        total = len(model_paths)
-        processed = 0
-        success_count = 0
-        skipped_count = 0
-        updated_models: List[Dict[str, Any]] = []
-        errors: List[str] = []
-        post_processor = PostProcessor()
-
-        await self._emit_progress(
-            progress_callback, skill_name, status="started",
-            total=total, processed=0, success=0,
-        )
-
-        llm = await self._ensure_llm()
-        llm_configured = llm.is_configured() if skill.llm_required else True
-
-        for model_path in model_paths:
-            model_filename = os.path.basename(model_path)
-            logger.info(
-                "[%s] [%d/%d] %s",
-                skill_name, processed + 1, total, model_filename,
-            )
-            updated_data: Dict[str, Any] = {}
-            skip_model = False
-            try:
-                from ...metadata_ops import read_metadata
-                metadata = await read_metadata(model_path)
-
-                # Fast-fail: enrich_hf_metadata requires hf_url to have HF README context
-                if skill_name == "enrich_hf_metadata" and not metadata.get("hf_url", ""):
-                    logger.info(
-                        "[%s] SKIP %s — no hf_url in metadata",
-                        skill_name, model_filename,
-                    )
-                    skipped_count += 1
-                    skip_model = True
-
-                if not skip_model:
-                    prompt_vars: Dict[str, Any] = {"model_path": model_path}
-                    if skill.llm_required and llm_configured:
-                        prompt_vars = await self._build_prompt_context(
-                            skill_name, model_path, metadata, registry, llm,
-                        )
-
-                    llm_response: Optional[Dict[str, Any]] = None
-                    if skill.llm_required and llm_configured:
-                        prompt_template = registry.load_prompt(skill_name)
-                        rendered = _render_prompt(prompt_template, prompt_vars)
-                        llm_response = await llm.chat_completion_json(
-                            system_prompt=prompt_vars.get(
-                                "system_prompt",
-                                "You are a helpful assistant that extracts structured metadata.",
-                            ),
-                            user_prompt=rendered,
-                        )
-                        if llm_response:
-                            logger.info(
-                                "[%s] [%d/%d] %s → base_model=%s confidence=%s",
-                                skill_name, processed + 1, total, model_filename,
-                                (llm_response.get("base_model") or "?")[:50],
-                                llm_response.get("confidence", "?"),
-                            )
-
-                    model_result = await post_processor.process(
-                        skill_name=skill_name,
-                        model_path=model_path,
-                        llm_output=llm_response or {},
-                        metadata=metadata,
-                        readme_content=prompt_vars.get("readme_content_full", ""),
-                    )
-
-                    if model_result.get("success", True):
-                        success_count += 1
-                        uf = model_result.get("updated_fields", [])
-                        if uf:
-                            updated_models.append({"path": model_path, "updated_fields": uf})
-                        updated_data = model_result.get("updates", {})
-                        if "preview_url" in updated_data and updated_data["preview_url"]:
-                            updated_data["preview_url"] = config.get_preview_static_url(
-                                updated_data["preview_url"]
-                            )
-                    else:
-                        errors.extend(
-                            model_result.get("errors", [model_result.get("error", "Unknown error")])
-                        )
-
-            except Exception as exc:
-                logger.error("Skill %s failed for %s: %s", skill_name, model_path, exc)
-                errors.append(f"{model_path}: {exc}")
-
-            processed += 1
-            await self._emit_progress(
-                progress_callback, skill_name, status="processing",
-                total=total, processed=processed, success=success_count,
-                skipped=skipped_count,
-                current_path=model_path,
-                updated_data=updated_data,
-            )
-
-        result = SkillResult(
-            success=success_count > 0,
-            updated_models=updated_models,
-            errors=errors,
-            summary=f"Processed {processed}/{total} models, {success_count} succeeded, {skipped_count} skipped",
-        )
-
-        await self._emit_progress(
-            progress_callback, skill_name, status="completed",
-            total=total, processed=processed, success=success_count,
-            skipped=skipped_count,
-            updated_models=updated_models, errors=errors, summary=result.summary,
-        )
-
-        return result
-
-    # ------------------------------------------------------------------
-    # Base model grouping (keeps the prompt compact)
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _format_base_models(models: List[str]) -> str:
-        """Format the base model list as a flat, one-per-line list.
-
-        Attempts to group by family consistently degraded LLM extraction
-        accuracy — the LLM finds individual model names harder to spot
-        in comma-separated groups than in a simple ``- Name`` list.
-        """
-        return "\n".join(f"- {m}" for m in models)
-
-    async def _build_prompt_context(
-        self,
-        skill_name: str,
-        model_path: str,
-        metadata: Dict[str, Any],
-        registry: SkillRegistry,
-        llm: Any,
-    ) -> Dict[str, Any]:
-        """Gather variables for the skill's prompt template.
-
-        Reads metadata, fetches the HF README (if applicable), lists available
-        base models, loads user priority tags, and returns a dict that maps to
-        ``{{variable}}`` placeholders in ``prompt.md``.
-        """
-        from ...metadata_ops import identify_model_type, list_base_models
-        from ..settings_manager import SettingsManager
-
-        context: Dict[str, Any] = {
-            "model_path": model_path,
-            "model_basename": "",
-            "hf_url": "",
-            "repo": "",
-            "readme_content": "",
-            "readme_content_full": "",
-            "current_metadata": {},
-            "base_models": [],
-            "priority_tags": "",
-        }
-
-        # Extract model basename (filename without extension) for the LLM
-        # to use when locating the matching section in collection repos.
-        raw_basename = os.path.splitext(os.path.basename(model_path))[0]
-        context["model_basename"] = raw_basename or ""
-
-        context["current_metadata"] = {
-            "file_name": metadata.get("file_name", ""),
-            "base_model": metadata.get("base_model", ""),
-            "tags": metadata.get("tags", []),
-            "modelDescription": metadata.get("modelDescription", ""),
-            "trainedWords": metadata.get("trainedWords", []),
-            "sha256": (metadata.get("sha256") or "")[:16] + "..." if metadata.get("sha256") else "",
-            "size": metadata.get("size", 0),
-        }
-
-        hf_url = metadata.get("hf_url", "")
-        context["hf_url"] = hf_url
-        repo = self._extract_repo_from_url(hf_url) if hf_url else ""
-        context["repo"] = repo or ""
-        if repo:
-            readme = await self._fetch_readme(repo)
-            # Trim README to the section relevant to this model file
-            # (collection repos often have multiple models in one README).
-            if readme and raw_basename:
-                trimmed = extract_relevant_section(readme, raw_basename)
-                cleaned = clean_readme_for_llm(trimmed) if trimmed else ""
-            else:
-                cleaned = clean_readme_for_llm(readme) if readme else ""
-            context["readme_content"] = cleaned if cleaned else "(README not available)"
-            context["readme_content_full"] = readme or ""
-
-        try:
-            raw_models = await list_base_models()
-            context["base_models"] = self._format_base_models(raw_models)
-        except Exception as exc:
-            logger.debug("Failed to list base models: %s", exc)
-            context["base_models"] = "</not available>"
-
-        # Determine model type and load the corresponding priority_tags
-        try:
-            model_type = await identify_model_type(model_path)
-            context["model_type"] = model_type
-            settings = SettingsManager()
-            priority_config = settings.get_priority_tag_config()
-            context["priority_tags"] = priority_config.get(model_type, "")
-        except Exception as exc:
-            logger.debug("Failed to load priority tags: %s", exc)
-            context["model_type"] = "lora"
-            context["priority_tags"] = ""
-
-        return context
-
-    @staticmethod
-    def _extract_repo_from_url(hf_url: str) -> Optional[str]:
-        """Extract ``user/repo`` from a HuggingFace URL."""
-        if not hf_url:
-            return None
-        m = re.match(r"https?://huggingface\.co/([^/]+/[^/]+)", hf_url)
-        return m.group(1) if m else None
-
-    @staticmethod
-    async def _fetch_readme(repo: str) -> str:
-        """Fetch README.md from HuggingFace (tries ``main``, then ``master``)."""
-        async with aiohttp.ClientSession(
-            headers={"User-Agent": "ComfyUI-LoRA-Manager/1.0"},
-            timeout=aiohttp.ClientTimeout(total=30),
-        ) as session:
-            for branch in ("main", "master"):
-                url = f"https://huggingface.co/{repo}/raw/{branch}/README.md"
-                try:
-                    async with session.get(url) as resp:
-                        if resp.status == 200:
-                            return await resp.text()
-                except Exception as exc:
-                    logger.debug("Failed to fetch README from %s: %s", url, exc)
-        return ""
-
-    async def _emit_progress(
-        self,
-        callback: Optional[AgentProgressReporter],
-        skill_name: str,
-        *,
-        status: str,
-        **extra: Any,
-    ) -> None:
-        """Send a progress update via WebSocket (if callback is set)."""
-        payload: Dict[str, Any] = {"type": "agent_progress", "skill": skill_name, "status": status}
-        payload.update(extra)
-        if callback is not None:
-            await callback.on_progress(payload)

py/services/agent/post_processor.py

@@ -1,336 +0,0 @@
-"""Post-processing engine for skill pipeline outputs.
-
-The :class:`PostProcessor` takes the LLM's structured JSON output and applies
-it to a model's on-disk metadata via the :mod:`~py.metadata_ops` functions.
-
-It handles all the skill-specific business logic — conditions, transformations,
-and orchestration of multiple side-effects (write metadata, download preview,
-refresh cache).  All actual I/O is delegated to :mod:`~py.metadata_ops`.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class PostProcessor:
-    """Deterministic post-processor for skill pipeline outputs.
-
-    Usage (called by :class:`~py.services.agent.agent_service.AgentService`)::
-
-        processor = PostProcessor()
-        result = await processor.process(
-            skill_name="enrich_hf_metadata",
-            model_path="/path/to/model.safetensors",
-            llm_output={...},
-            metadata={...},    # from metadata_ops.read_metadata()
-        )
-    """
-
-    async def process(
-        self,
-        *,
-        skill_name: str,
-        model_path: str,
-        llm_output: Dict[str, Any],
-        metadata: Dict[str, Any],
-        readme_content: str = "",
-    ) -> Dict[str, Any]:
-        """Route *llm_output* to the correct skill post-processor.
-
-        *readme_content* is optional raw markdown content (e.g. HF README)
-        that is converted to HTML and stored as ``modelDescription`` for
-        the description tab.
-
-        Returns a dict with keys ``success`` (bool), ``updated_fields`` (list),
-        ``preview_downloaded`` (bool), and ``errors`` (list).
-        """
-        if skill_name == "enrich_hf_metadata":
-            return await self._process_enrich_hf_metadata(
-                model_path, llm_output, metadata, readme_content,
-            )
-        return {
-            "success": False,
-            "updated_fields": [],
-            "errors": [f"No post-processor registered for skill: {skill_name}"],
-        }
-
-    # ------------------------------------------------------------------
-    # enrich_hf_metadata
-    # ------------------------------------------------------------------
-
-    async def _process_enrich_hf_metadata(
-        self,
-        model_path: str,
-        llm_output: Dict[str, Any],
-        metadata: Dict[str, Any],
-        readme_content: str = "",
-    ) -> Dict[str, Any]:
-        from ...metadata_ops import (
-            apply_metadata_updates,
-            download_preview,
-            refresh_cache,
-        )
-        from .skills.enrich_hf_metadata.readme_processor import (
-            convert_readme_to_html,
-            extract_gallery_images,
-            extract_gallery_table_images,
-            extract_relevant_section,
-            extract_simple_markdown_images,
-            extract_html_img_tags,
-            extract_repo_from_hf_url,
-        )
-
-        updated_fields: List[str] = []
-        preview_downloaded = False
-
-        # -- Determine whether this is an HF-sourced model -----------------
-        is_hf_model = not metadata.get("from_civitai", True)
-
-        # -- Collect updates -----------------------------------------------
-        updates: Dict[str, Any] = {}
-
-        # base_model
-        new_base = (llm_output.get("base_model") or "").strip()
-        current_base = metadata.get("base_model", "") or ""
-        if new_base and self._should_overwrite(current_base, is_hf_model):
-            updates["base_model"] = new_base
-
-        # trigger words → civitai.trainedWords
-        new_triggers = llm_output.get("trigger_words", [])
-        trigger_words_empty = True
-        if isinstance(new_triggers, list):
-            cleaned = [t.strip() for t in new_triggers if t.strip()]
-            cleaned = [t for t in cleaned if t.lower() not in ("none", "null", "n/a")]
-            trigger_words_empty = not cleaned
-            current_civitai = metadata.get("civitai") or {}
-            current_triggers = current_civitai.get("trainedWords") or []
-            if self._should_overwrite_list(current_triggers, is_hf_model):
-                trig_civitai = dict(current_civitai)
-                if "civitai" in updates and isinstance(updates["civitai"], dict):
-                    trig_civitai.update(updates["civitai"])
-                trig_civitai["trainedWords"] = cleaned
-                updates["civitai"] = trig_civitai
-
-        # modelDescription — from raw README content (converted to HTML)
-        if readme_content and is_hf_model:
-            converted = convert_readme_to_html(readme_content)
-            if converted:
-                updates["modelDescription"] = converted
-
-        # short_description → civitai.description (for "About this version")
-        short_desc = (llm_output.get("short_description") or "").strip()
-        if short_desc and is_hf_model:
-            current_civitai = metadata.get("civitai") or {}
-            desc_civitai = dict(current_civitai)
-            if "civitai" in updates and isinstance(updates["civitai"], dict):
-                desc_civitai.update(updates["civitai"])
-            desc_civitai["description"] = short_desc
-            updates["civitai"] = desc_civitai
-
-        # gallery images → civitai.images (from YAML frontmatter widget entries
-        # and Sample Gallery markdown tables in the README body)
-        gallery_images: List[Dict[str, Any]] = []
-        if readme_content and is_hf_model:
-            hf_url = metadata.get("hf_url", "") or ""
-            repo = extract_repo_from_hf_url(hf_url)
-            if repo:
-                rec_w = llm_output.get("recommended_width") or 0
-                rec_h = llm_output.get("recommended_height") or 0
-
-                # 1. Widget images (YAML frontmatter)
-                gallery = extract_gallery_images(
-                    readme_content, repo,
-                    default_width=rec_w, default_height=rec_h,
-                )
-
-                # 2. Sample Gallery table images (markdown body), deduplicated
-                existing_urls = {img["url"] for img in gallery if img.get("url")}
-                table_images = extract_gallery_table_images(
-                    readme_content, repo,
-                    existing_urls=existing_urls,
-                    default_width=rec_w, default_height=rec_h,
-                )
-                existing_urls.update(img["url"] for img in table_images if img.get("url"))
-
-                # 3. Simple markdown images `![alt](url)` in the body
-                simple_images = extract_simple_markdown_images(
-                    readme_content, repo,
-                    existing_urls=existing_urls,
-                    default_width=rec_w, default_height=rec_h,
-                )
-                existing_urls.update(img["url"] for img in simple_images if img.get("url"))
-
-                # 4. HTML `<img>` tags (used by many collection repos)
-                html_images = extract_html_img_tags(
-                    readme_content, repo,
-                    existing_urls=existing_urls,
-                    default_width=rec_w, default_height=rec_h,
-                )
-
-                all_images = gallery + table_images + simple_images + html_images
-                if all_images:
-                    gallery_images = all_images
-                    current_civitai = metadata.get("civitai") or {}
-                    gallery_civitai = dict(current_civitai)
-                    if "civitai" in updates and isinstance(updates["civitai"], dict):
-                        gallery_civitai.update(updates["civitai"])
-                    gallery_civitai["images"] = all_images
-                    updates["civitai"] = gallery_civitai
-
-        # tags
-        new_tags = llm_output.get("tags", [])
-        if isinstance(new_tags, list) and new_tags:
-            existing_tags = metadata.get("tags") or []
-            merged = self._merge_tags(existing_tags, new_tags)
-            if len(merged) > len(existing_tags) or is_hf_model:
-                updates["tags"] = merged
-
-        # metadata_source & llm_enriched_at (always set)
-        updates["metadata_source"] = "agent:enrich_hf_metadata"
-        updates["llm_enriched_at"] = datetime.now(timezone.utc).isoformat()
-
-        # Store LLM confidence in metadata so it's accessible for evaluation
-        raw_confidence = (llm_output.get("confidence") or "").strip()
-        if raw_confidence:
-            updates["_llm_confidence"] = raw_confidence
-
-        # Fallback: extract instance_prompt from YAML frontmatter when the LLM
-        # returned empty trigger words but the README has instance_prompt.
-        if trigger_words_empty:
-            instance_prompt = _extract_yaml_instance_prompt(readme_content)
-            if instance_prompt:
-                current_civitai = metadata.get("civitai") or {}
-                trig_civitai = dict(current_civitai)
-                if "civitai" in updates and isinstance(updates["civitai"], dict):
-                    trig_civitai.update(updates["civitai"])
-                trig_civitai["trainedWords"] = [instance_prompt]
-                updates["civitai"] = trig_civitai
-
-        preview_remote_url = (llm_output.get("preview_url") or "").strip()
-        # Fallback: if the LLM couldn't find a preview image in the cleaned
-        # README, find the first gallery image from the *model-specific
-        # section* of the README (not the repo-wide first image, which
-        # belongs to a different model in collection repos).
-        if not preview_remote_url and readme_content and is_hf_model:
-            model_basename = os.path.splitext(os.path.basename(model_path))[0]
-            relevant_section = extract_relevant_section(
-                readme_content, model_basename,
-            )
-            if relevant_section and relevant_section != readme_content:
-                for img in gallery_images:
-                    img_url = img.get("url", "")
-                    if img_url and img_url in relevant_section:
-                        preview_remote_url = img_url
-                        break
-        # Last resort: use the first gallery image from the full README.
-        if not preview_remote_url and gallery_images:
-            preview_remote_url = gallery_images[0].get("url", "")
-        current_preview = metadata.get("preview_url") or ""
-        if preview_remote_url and not (current_preview and os.path.exists(current_preview)):
-            local_path = await download_preview(model_path, preview_remote_url)
-            if local_path:
-                preview_downloaded = True
-                updates["preview_url"] = local_path
-
-        # notes — plain-text summary of usage info from the LLM
-        new_notes = (llm_output.get("notes") or "").strip()
-        if new_notes:
-            updates["notes"] = new_notes
-
-        # usage_tips — JSON string (e.g. {"strength_min":0.85,"strength_max":1.4})
-        raw_tips = (llm_output.get("usage_tips") or "").strip()
-        if raw_tips and raw_tips != "{}":
-            try:
-                json.loads(raw_tips)
-                updates["usage_tips"] = raw_tips
-            except (json.JSONDecodeError, TypeError):
-                logger.warning(
-                    "LLM returned invalid usage_tips JSON: %s", raw_tips[:200]
-                )
-
-        if updates:
-            updated_fields = await apply_metadata_updates(model_path, updates)
-
-        # -- Refresh scanner cache ------------------------------------------
-        if updated_fields or preview_downloaded:
-            await refresh_cache(model_path)
-
-        return {
-            "success": True,
-            "updated_fields": updated_fields,
-            "preview_downloaded": preview_downloaded,
-            "updates": updates,
-            "errors": [],
-        }
-
-    # ------------------------------------------------------------------
-    # Helpers
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _should_overwrite(current_value: str, is_hf_model: bool) -> bool:
-        """Return ``True`` when a scalar field should be overwritten."""
-        return is_hf_model or not current_value or current_value.lower() in (
-            "", "unknown",
-        )
-
-    @staticmethod
-    def _should_overwrite_list(current_list: List[str], is_hf_model: bool) -> bool:
-        """Return ``True`` when a list field should be overwritten."""
-        return is_hf_model or not current_list
-
-    @staticmethod
-    def _merge_tags(existing: List[str], new: List[str]) -> List[str]:
-        """Merge *new* tags into *existing*, all lowercased.
-
-        This matches the behaviour of :class:`TagUpdateService` which
-        normalises every tag to lowercase for case-insensitive dedup.
-        """
-        merged: List[str] = []
-        seen: set = set()
-        for tag in list(existing) + list(new):
-            t = tag.strip().lower()
-            if t and t not in seen:
-                merged.append(t)
-                seen.add(t)
-        return merged
-
-
-# ------------------------------------------------------------------
-# Module-level helpers
-# ------------------------------------------------------------------
-
-
-def _extract_yaml_instance_prompt(readme_content: str) -> str:
-    """Extract ``instance_prompt`` from the YAML frontmatter of a HF README.
-
-    Returns the prompt text, or empty string if not found.  Handles
-    ``null`` / ``~`` YAML null values by returning empty string.
-    """
-    if not readme_content or not readme_content.startswith("---"):
-        return ""
-
-    # Find end of frontmatter
-    end = readme_content.find("---", 3)
-    if end == -1:
-        return ""
-    frontmatter = readme_content[3:end]
-
-    for line in frontmatter.split("\n"):
-        line = line.strip()
-        m = re.match(r"^instance_prompt:\s*(.*)", line)
-        if m:
-            val = m.group(1).strip().strip('"').strip("'")
-            if val.lower() in ("null", "~", "none", ""):
-                return ""
-            return val
-
-    return ""

py/services/agent/skill_definition.py

@@ -1,45 +0,0 @@
-"""Skill definition data structures.
-
-Each skill is described by a :class:`SkillDefinition` that declares its
-input/output schemas, whether it needs an LLM call, and what permissions
-its post-processor has.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple
-
-
-@dataclass(frozen=True)
-class SkillPermissions:
-    """Declarative permission scope for a skill's post-processor.
-
-    These are auditable constraints — the :class:`AgentService` checks them
-    before invoking the handler.  They are defense-in-depth, not a sandbox.
-    """
-
-    write_metadata: bool = True
-    write_previews: bool = True
-    network_domains: Tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class SkillDefinition:
-    """Immutable description of an agent skill."""
-
-    name: str
-    title: str
-    description: str
-    llm_required: bool
-    input_schema: Dict[str, Any] = field(default_factory=dict)
-    output_schema: Dict[str, Any] = field(default_factory=dict)
-    model_type_filter: Optional[List[str]] = None
-    permissions: SkillPermissions = field(default_factory=SkillPermissions)
-
-    def applies_to_model_type(self, model_type: str) -> bool:
-        """Return ``True`` if this skill can run on the given model type."""
-
-        if self.model_type_filter is None:
-            return True
-        return model_type in self.model_type_filter

py/services/agent/skill_registry.py

@@ -1,210 +0,0 @@
-"""Discovery and loading of prompt-based skills.
-
-Skills live in ``py/services/agent/skills/<name>/`` directories.  Each
-directory must contain a ``prompt.md`` file with YAML frontmatter::
-
-    ---
-    name: my_skill
-    title: "My Skill"
-    description: "What this skill does"
-    llm_required: true
-    ---
-
-    Prompt template with ``{{variable}}`` placeholders.
-
-Legacy ``SKILL.md`` files are also supported for backward compatibility.
-
-The registry scans the skills directory on first access and caches results.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import re
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import yaml
-
-from .skill_definition import SkillDefinition, SkillPermissions
-
-logger = logging.getLogger(__name__)
-
-# Directory where built-in skills are stored
-_SKILLS_DIR = Path(__file__).parent / "skills"
-
-#: Preferred file names for prompt definition files (tried in order).
-#: ``prompt.md`` is the current convention; ``SKILL.md`` is the legacy name
-#: kept for backward compatibility.
-_PROMPT_FILE_NAMES: tuple[str, ...] = ("prompt.md", "SKILL.md")
-
-
-# ---------------------------------------------------------------------------
-# Frontmatter parser
-# ---------------------------------------------------------------------------
-
-_FRONTMATTER_RE = re.compile(
-    r"^---\s*\n(.*?\n)---\s*\n?(.*)", re.DOTALL
-)
-
-
-def _parse_skill_file(path: Path) -> tuple[dict, str]:
-    """Read a prompt definition file (``prompt.md`` or legacy ``SKILL.md``) and
-    return (frontmatter_dict, body_text).
-
-    Raises ``ValueError`` if the file lacks valid YAML frontmatter.
-    """
-    text = path.read_text(encoding="utf-8")
-    m = _FRONTMATTER_RE.match(text)
-    if not m:
-        raise ValueError(f"Missing or invalid YAML frontmatter in {path}")
-    frontmatter = yaml.safe_load(m.group(1))
-    if not isinstance(frontmatter, dict):
-        raise ValueError(f"Frontmatter in {path} is not a mapping")
-    body = m.group(2).strip()
-    return frontmatter, body
-
-
-class SkillRegistry:
-    """Discover and load agent skills from the filesystem."""
-
-    _instance: Optional["SkillRegistry"] = None
-    _lock: asyncio.Lock = asyncio.Lock()
-
-    def __init__(self, skills_dir: Path = _SKILLS_DIR) -> None:
-        self._skills_dir = skills_dir
-        self._skills: Dict[str, SkillDefinition] = {}
-        self._loaded: bool = False
-
-    # ------------------------------------------------------------------
-    # Singleton access
-    # ------------------------------------------------------------------
-
-    @classmethod
-    async def get_instance(cls) -> "SkillRegistry":
-        """Return the lazily-initialised global ``SkillRegistry``."""
-
-        if cls._instance is None:
-            async with cls._lock:
-                if cls._instance is None:
-                    registry = cls()
-                    registry._discover()
-                    cls._instance = registry
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        """Reset the cached singleton — primarily for tests."""
-
-        cls._instance = None
-
-    # ------------------------------------------------------------------
-    # Discovery
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _find_prompt_file(skill_dir: Path) -> Path | None:
-        """Return the first prompt definition file that exists in *skill_dir*.
-
-        Tries ``_PROMPT_FILE_NAMES`` in order so that new conventions
-        (``prompt.md``) take precedence while legacy ``SKILL.md`` files
-        still load without changes.
-        """
-        for name in _PROMPT_FILE_NAMES:
-            candidate = skill_dir / name
-            if candidate.exists():
-                return candidate
-        return None
-
-    def _discover(self) -> None:
-        """Scan the skills directory and load all valid skill definitions."""
-
-        self._skills.clear()
-        if not self._skills_dir.is_dir():
-            logger.warning("Skills directory does not exist: %s", self._skills_dir)
-            self._loaded = True
-            return
-
-        for entry in sorted(self._skills_dir.iterdir()):
-            if not entry.is_dir():
-                continue
-            prompt_file = self._find_prompt_file(entry)
-            if prompt_file is None:
-                continue
-            try:
-                definition = self._load_skill_definition(prompt_file)
-                if definition is not None:
-                    self._skills[definition.name] = definition
-                    logger.debug("Loaded skill: %s", definition.name)
-            except Exception as exc:
-                logger.warning("Failed to load skill from %s: %s", prompt_file, exc)
-
-        self._loaded = True
-        logger.info("Discovered %d prompt-based skills", len(self._skills))
-
-    def _load_skill_definition(self, path: Path) -> Optional[SkillDefinition]:
-        """Parse a prompt definition file's frontmatter into a
-        :class:`SkillDefinition`."""
-
-        try:
-            data, _body = _parse_skill_file(path)
-        except (ValueError, yaml.YAMLError) as exc:
-            logger.warning("Failed to parse prompt file %s: %s", path, exc)
-            return None
-
-        if "name" not in data:
-            logger.warning("Prompt file %s missing required 'name' field", path)
-            return None
-
-        perm_data = data.get("permissions", {})
-        permissions = SkillPermissions(
-            write_metadata=perm_data.get("write_metadata", True),
-            write_previews=perm_data.get("write_previews", True),
-            network_domains=tuple(perm_data.get("network_domains", [])),
-        )
-
-        return SkillDefinition(
-            name=data["name"],
-            title=data.get("title", data["name"]),
-            description=data.get("description", ""),
-            llm_required=data.get("llm_required", False),
-            input_schema=data.get("input_schema", {}),
-            output_schema=data.get("output_schema", {}),
-            model_type_filter=data.get("model_type_filter"),
-            permissions=permissions,
-        )
-
-    # ------------------------------------------------------------------
-    # Public API
-    # ------------------------------------------------------------------
-
-    def list_skills(self) -> List[SkillDefinition]:
-        """Return all discovered skill definitions."""
-
-        if not self._loaded:
-            self._discover()
-        return list(self._skills.values())
-
-    def get_skill(self, name: str) -> Optional[SkillDefinition]:
-        """Return the skill definition for ``name``, or ``None`` if not found."""
-
-        if not self._loaded:
-            self._discover()
-        return self._skills.get(name)
-
-    def load_prompt(self, name: str) -> str:
-        """Load and return the prompt template body for the named skill."""
-
-        skill_dir = self._skills_dir / name
-        skill_path = self._find_prompt_file(skill_dir)
-        if skill_path is None:
-            raise FileNotFoundError(
-                f"Prompt file not found for skill '{name}' in {skill_dir} "
-                f"(tried {list(_PROMPT_FILE_NAMES)})"
-            )
-        try:
-            _frontmatter, body = _parse_skill_file(skill_path)
-            return body
-        except (ValueError, yaml.YAMLError) as exc:
-            raise ValueError(f"Failed to parse prompt from {skill_path}: {exc}") from exc

py/services/agent/skills/enrich_hf_metadata/prompt.md

@@ -1,165 +0,0 @@
----
-name: enrich_hf_metadata
-title: "Enrich Metadata from HuggingFace"
-description: >
-  Parse the HuggingFace model card via LLM to extract description, trigger
-  words, base model, tags, and preview image URL.
-llm_required: true
----
-
-You are an expert assistant for AI image generation models. Your task is to extract structured metadata from a HuggingFace model card (README.md).
-
-## Model Information
-
-- **Repository**: {{hf_url}}
-- **Model file path**: {{model_path}}
-- **Model filename**: {{model_basename}}
-- **Repository ID**: {{repo}}
-
-## Current Metadata (may be incomplete)
-
-```json
-{{current_metadata}}
-```
-
-## User Priority Tags Reference
-
-The user has configured the following list of **meaningful tag categories** for this model type (`{{model_type}}`):
-
-```
-{{priority_tags}}
-```
-
-These are the subjects, styles, and concepts the user considers useful for categorization. Use this list as a **reference** when evaluating tags (see the **tags** section below).
-
-## Available Base Models
-
-The following base models are currently valid in this system.  Use the EXACT
-name listed — do not invent aliases or modify variant suffixes.
-
-{{base_models}}
-
-## HuggingFace README Content
-
-```
-{{readme_content}}
-```
-
-## Extraction Instructions
-
-Extract the following information from the README content above:
-
-### base_model
-The base model this model was trained on. Use EXACTLY one of the names from the **Available Base Models** list above. Do not invent new names or use aliases.
-
-Check the YAML frontmatter for ``base_model:`` first. If the frontmatter has no ``base_model:``, look at the **model filename** (``{{model_basename}}``), YAML ``tags:``, README title and first paragraph for clues — the base model family is often embedded in the name
-
-### trigger_words
-The trigger words or activation prompts needed to use this LoRA. Look for:
-- `instance_prompt:` in the YAML frontmatter
-- Phrases like "trigger word:", "trigger:", "use this prompt:", "activation prompt:"
-- In collection repos: the trigger section **specific to this model file** (look near matching download links or anchor IDs)
-- Example prompts at the start (usually the first word or phrase before any description)
-Return as an array of strings. If none found, return an empty array `[]`. **Never** return `["None"]` or any placeholder value — a truly empty list means no trigger words exist.
-
-### short_description
-A concise 1-2 sentence summary of what this model does. Extract from the "Model description" section or the first paragraph.  For collection repos, focus on the **specific model version** matching `{{model_basename}}`, not the repo as a whole.  Return empty string if the README is too minimal.
-
-### tags
-3-8 relevant tags for categorizing this model. **Quality over quantity.**
-
-Sources to consider:
-- The YAML frontmatter `tags:` list (filter out technical ones — see below)
-- The subject, style, character, or concept the model represents
-- The model filename itself may give clues (e.g. "pokemon", "anime", "pixelart")
-
-**Critical filtering rules — apply them strictly:**
-
-1. **Exclude technical/generic tags.** Reject any tag that describes the model's **training methodology, framework, architecture, or modality** rather than its content. Examples to exclude: `text-to-image`, `diffusers`, `lora`, `dreambooth`, `diffusers-training`, `flux`, `sdxl`, `checkpoint`, `pytorch`, `safetensors`, `fine-tuning`, `stable-diffusion`, and any variant of these.
-
-2. **Cross-reference against the priority_tags reference.** Only include a tag if it meaningfully describes what the model actually creates (subject, style, character type) and is semantically close to one of the priority_tags. If none of the README's tags match meaningful categories, prefer returning a smaller set or an empty array over including low-value tags.
-
-3. **All lowercase, no spaces, no hyphens** (use single words like `"photorealistic"`, `"anime"`, `"character"`).
-
-Return empty array if no meaningful content tags remain after filtering.
-
-### recommended_width, recommended_height
-The recommended image generation resolution for this model, in pixels. Look for sections like "Best Dimensions", "Recommended size", "Suggested resolution", or similar phrasing in the README. Prefer the explicitly marked "Best" or default resolution. If the table/list has multiple entries (e.g. "768 x 1024 (Best)" and "1024 x 1024 (Default)"), use the one marked "Best". Return integers. If no resolution can be determined, return 0 for both.
-
-### preview_url
-The URL of the most suitable preview image from the README. Look for:
-- Image tags near the section matching the model filename (`{{model_basename}}`)
-- The YAML frontmatter `widget:` section (which often has `output.url` fields)
-- In collection repos: the sample images listed **under the section** for this specific model version
-- Generic `![alt](url)` in the body
-Choose the first image that appears to be a generation example (not a logo or diagram). Construct the absolute URL as `https://huggingface.co/{{repo}}/resolve/main/{filename}`. If no suitable image is found, return an empty string.
-
-### notes
-A plain-text summary of the model card's key practical usage information. Combine trigger words, style modifiers, recommended parameters (steps, CFG, resolution, sampler), and any setup tips into a readable paragraph.  For collection repos, focus on the **specific model version** matching `{{model_basename}}`.  Return empty string if the README has no useful usage info.
-
-### usage_tips
-A JSON string with structured usage recommendations. Extract from the README any explicit ranges or recommended values (e.g. "Set LoRA strength: **0.85 - 1.4**", "CLIP strength: 0.5"). Possible fields (include only those you can determine):
-
-```json
-{
-  "strength_min": 0.85,
-  "strength_max": 1.4,
-  "strength_range": "0.85-1.4",
-  "strength": 0.6,
-  "clip_strength": 0.5,
-  "clip_skip": 2
-}
-```
-
-Return the JSON string (e.g. `'{"strength_min":0.85,"strength_max":1.4}'`). Return `"{}"` if nothing useful is found.
-
-### confidence
-Your confidence level in the extracted data:
-- "high" — most fields were explicitly stated in the README
-- "medium" — some fields were inferred from context
-- "low" — most fields are guesses based on limited information
-
-## Important: Handling Collection Repos (multiple model files)
-
-Many HuggingFace repos contain **multiple model files** in a single repository
-(e.g. a "LoRA collection" with different styles/characters in separate files).
-
-The model file currently being enriched is: **`{{model_basename}}`**
-
-To find the correct section in the README:
-
-1. **Search for download links** containing the filename — the surrounding paragraph is your section.
-2. **Search for anchor IDs** (`<a id="...">`) or section headings whose text matches words from the filename.
-3. **Search for HTML headings** (`<h1>`, `<h2>`, `<span>`) containing parts of the filename.
-4. If no match is found, use the full README as usual — the model may be the only one in the repo.
-
-When a matching section IS found, prefer metadata from that section.
-When no section matches (e.g. single-model repos or repos without per-file sections),
-extract metadata from the full README normally.  Do not return empty data just
-because the filename doesn't appear in the README.
-
-## Output Format
-
-Return ONLY a JSON object with exactly these fields (no markdown fences, no extra text):
-
-```json
-{
-  "model_path": "{{model_path}}",
-  "base_model": "<canonical name or empty string>",
-  "trigger_words": ["<word1>", "<word2>"],
-  "short_description": "<1-2 sentence summary>",
-  "tags": ["<tag1>", "<tag2>"],
-  "recommended_width": 768,
-  "recommended_height": 1024,
-  "preview_url": "<image URL or empty string>",
-  "notes": "<plain-text usage summary or empty string>",
-  "usage_tips": "<JSON string like '{\"strength_min\":0.85,\"strength_max\":1.4}' or '{}'>",
-  "confidence": "<high|medium|low>"
-}
-```
-
-Important:
-- Only include the JSON object, no other text
-- If a field cannot be determined, use an empty string or empty array
-- Do not fabricate information not supported by the README
-- Never use placeholder values like `"None"` or `"unknown"` for missing data — use empty string or empty array

py/services/aria2_downloader.py

@@ -1,679 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import os
-import secrets
-import shutil
-import socket
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
-
-import aiohttp
-
-from .downloader import DownloadProgress, get_downloader, is_ssl_cert_verify_error
-from .aria2_transfer_state import Aria2TransferStateStore
-from .settings_manager import get_settings_manager
-
-logger = logging.getLogger(__name__)
-
-def _try_certifi_ca_path() -> str | None:
-    """Return the certifi CA bundle path if available, else None."""
-    try:
-        import certifi  # type: ignore[import-untyped]
-
-        path = certifi.where()
-        if os.path.isfile(path):
-            logger.debug(
-                "aria2 --ca-certificate: using certifi CA bundle at %s", path
-            )
-            return path
-    except ImportError:
-        pass
-
-    logger.debug("aria2 --ca-certificate: certifi not available")
-    return None
-
-
-CIVITAI_DOWNLOAD_URL_PREFIXES = (
-    "https://civitai.com/api/download/",
-    "https://civitai.red/api/download/",
-)
-
-
-class Aria2Error(RuntimeError):
-    """Raised when aria2 integration fails."""
-
-
-@dataclass
-class Aria2Transfer:
-    """Track an aria2 download registered by the Python coordinator."""
-
-    gid: str
-    save_path: str
-
-
-class Aria2Downloader:
-    """Manage an aria2 RPC daemon for recommended model downloads."""
-
-    _instance = None
-    _lock = asyncio.Lock()
-
-    @classmethod
-    async def get_instance(cls) -> "Aria2Downloader":
-        async with cls._lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    def __init__(self) -> None:
-        if hasattr(self, "_initialized"):
-            return
-
-        self._initialized = True
-        self._process: Optional[asyncio.subprocess.Process] = None
-        self._rpc_port: Optional[int] = None
-        self._rpc_secret = ""
-        self._rpc_url = ""
-        self._rpc_session: Optional[aiohttp.ClientSession] = None
-        self._rpc_session_lock = asyncio.Lock()
-        self._process_lock = asyncio.Lock()
-        self._transfers: Dict[str, Aria2Transfer] = {}
-        self._poll_interval = 0.5
-        self._state_store = Aria2TransferStateStore()
-        self._stderr_reader_task: Optional[asyncio.Task] = None
-
-    @property
-    def is_running(self) -> bool:
-        return self._process is not None and self._process.returncode is None
-
-    async def download_file(
-        self,
-        url: str,
-        save_path: str,
-        *,
-        download_id: str,
-        progress_callback=None,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> Tuple[bool, str]:
-        """Download a file using aria2 RPC and wait for completion."""
-
-        await self._ensure_process()
-        save_path = os.path.abspath(save_path)
-        transfer = self._transfers.get(download_id)
-        if transfer is None or os.path.abspath(transfer.save_path) != save_path:
-            gid = await self._schedule_download(
-                url,
-                save_path,
-                download_id=download_id,
-                headers=headers,
-            )
-            transfer = Aria2Transfer(gid=gid, save_path=save_path)
-            self._transfers[download_id] = transfer
-
-        try:
-            while True:
-                status = await self._get_status_with_retry(download_id)
-                if status is None:
-                    return False, "aria2 download not found"
-
-                snapshot = self._build_progress_snapshot(status)
-                if progress_callback is not None:
-                    await self._dispatch_progress(progress_callback, snapshot)
-
-                state = status.get("status", "")
-                if state == "complete":
-                    completed_path = self._resolve_completed_path(status, save_path)
-                    return True, completed_path
-                if state == "error":
-                    return False, status.get("errorMessage") or "aria2 download failed"
-                if state == "removed":
-                    return False, "Download was cancelled"
-
-                await asyncio.sleep(self._poll_interval)
-        finally:
-            self._transfers.pop(download_id, None)
-
-    async def _get_status_with_retry(
-        self, download_id: str, *, max_retries: int = 4, retry_delay: float = 3.0
-    ) -> Optional[Dict[str, Any]]:
-        """Call get_status with retry for transient RPC failures.
-
-        Only retries on :exc:`Aria2Error` (RPC-level failure).  Returns
-        ``None`` immediately when the download_id is not tracked (a missing
-        transfer is not a transient condition, so retrying is pointless).
-
-        A single failed RPC call should not immediately fail the download,
-        because aria2 may be temporarily busy (e.g. finalizing multiple
-        concurrent downloads) and a retry will often succeed.
-        """
-        last_exc: Optional[Exception] = None
-        for attempt in range(max_retries):
-            try:
-                return await self.get_status(download_id)
-            except Aria2Error as exc:
-                last_exc = exc
-                if attempt < max_retries - 1:
-                    logger.warning(
-                        "aria2 get_status transient failure (attempt %d/%d) for %s: %s",
-                        attempt + 1, max_retries, download_id, exc,
-                    )
-                    await asyncio.sleep(retry_delay)
-        raise Aria2Error(
-            f"Failed to query aria2 download status after {max_retries} attempts: {last_exc}"
-        ) from last_exc
-
-    async def _schedule_download(
-        self,
-        url: str,
-        save_path: str,
-        *,
-        download_id: str,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> str:
-        save_dir = os.path.dirname(save_path)
-        out_name = os.path.basename(save_path)
-
-        Path(save_dir).mkdir(parents=True, exist_ok=True)
-
-        resolved_url = url
-        request_headers = headers
-        if headers and url.startswith(CIVITAI_DOWNLOAD_URL_PREFIXES):
-            resolved_url = await self._resolve_authenticated_redirect_url(url, headers)
-            if resolved_url != url:
-                request_headers = None
-                logger.debug(
-                    "Resolved Civitai download %s to signed URL for aria2",
-                    download_id,
-                )
-
-        options: Dict[str, str] = {
-            "dir": save_dir,
-            "out": out_name,
-            "continue": "true",
-            "max-connection-per-server": "4",
-            "split": "4",
-            "min-split-size": "1M",
-            "allow-overwrite": "true",
-            "auto-file-renaming": "false",
-            "file-allocation": "none",
-        }
-
-        # Pass proxy to aria2 so the actual file transfer goes through the
-        # same proxy used by the aiohttp-based URL resolution step above.
-        downloader = await get_downloader()
-        if downloader.proxy_url:
-            options["all-proxy"] = downloader.proxy_url
-
-        if request_headers:
-            options["header"] = [
-                f"{key}: {value}" for key, value in request_headers.items()
-            ]
-
-        logger.debug(
-            "Submitting aria2 download %s -> %s (auth=%s, civitai_signed=%s)",
-            download_id,
-            save_path,
-            bool(request_headers),
-            resolved_url != url,
-        )
-
-        try:
-            gid = await self._rpc_call("aria2.addUri", [[resolved_url], options])
-        except Exception as exc:
-            raise Aria2Error(f"Failed to schedule aria2 download: {exc}") from exc
-
-        logger.debug("aria2 accepted download %s with gid %s", download_id, gid)
-        await self._state_store.upsert(
-            download_id,
-            {
-                "gid": gid,
-                "save_path": save_path,
-                "status": "downloading",
-                "url": url,
-            },
-        )
-        return gid
-
-    async def get_status(self, download_id: str) -> Optional[Dict[str, Any]]:
-        """Return the raw aria2 status payload for a known download."""
-
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return None
-
-        keys = [
-            "gid",
-            "status",
-            "totalLength",
-            "completedLength",
-            "downloadSpeed",
-            "errorMessage",
-            "files",
-        ]
-        try:
-            status = await self._rpc_call("aria2.tellStatus", [transfer.gid, keys])
-        except Exception as exc:
-            raise Aria2Error(f"Failed to query aria2 download status: {exc}") from exc
-
-        if isinstance(status, dict):
-            return status
-        return None
-
-    async def get_status_by_gid(self, gid: str) -> Optional[Dict[str, Any]]:
-        keys = [
-            "gid",
-            "status",
-            "totalLength",
-            "completedLength",
-            "downloadSpeed",
-            "errorMessage",
-            "files",
-        ]
-        try:
-            status = await self._rpc_call("aria2.tellStatus", [gid, keys])
-        except Exception as exc:
-            message = str(exc)
-            if "cannot be found" in message.lower() or "not found" in message.lower():
-                return None
-            raise Aria2Error(f"Failed to query aria2 download status: {exc}") from exc
-
-        if isinstance(status, dict):
-            return status
-        return None
-
-    async def restore_transfer(self, download_id: str, gid: str, save_path: str) -> None:
-        await self._ensure_process()
-        self._transfers[download_id] = Aria2Transfer(
-            gid=gid,
-            save_path=os.path.abspath(save_path),
-        )
-
-    async def reassign_transfer(
-        self, from_download_id: str, to_download_id: str
-    ) -> Optional[Aria2Transfer]:
-        transfer = self._transfers.get(from_download_id)
-        if transfer is None:
-            return None
-
-        self._transfers[to_download_id] = transfer
-        if from_download_id != to_download_id:
-            self._transfers.pop(from_download_id, None)
-        return transfer
-
-    async def has_transfer(self, download_id: str) -> bool:
-        return download_id in self._transfers
-
-    async def pause_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.forcePause", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.upsert(download_id, {"status": "paused"})
-        return {"success": True, "message": "Download paused successfully"}
-
-    async def resume_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.unpause", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.upsert(download_id, {"status": "downloading"})
-        return {"success": True, "message": "Download resumed successfully"}
-
-    async def cancel_download(self, download_id: str) -> Dict[str, Any]:
-        transfer = self._transfers.get(download_id)
-        if transfer is None:
-            return {"success": False, "error": "Download task not found"}
-
-        try:
-            await self._rpc_call("aria2.forceRemove", [transfer.gid])
-        except Exception as exc:
-            return {"success": False, "error": str(exc)}
-
-        await self._state_store.remove(download_id)
-        return {"success": True, "message": "Download cancelled successfully"}
-
-    async def close(self) -> None:
-        """Shut down the RPC process and session."""
-
-        # Cancel the background stderr reader first so it stops reading
-        # from the pipe before the subprocess is terminated.
-        if self._stderr_reader_task is not None:
-            self._stderr_reader_task.cancel()
-            try:
-                await asyncio.wait_for(self._stderr_reader_task, timeout=2.0)
-            except (asyncio.CancelledError, asyncio.TimeoutError):
-                pass
-            self._stderr_reader_task = None
-
-        if self._rpc_session is not None:
-            await self._rpc_session.close()
-            self._rpc_session = None
-
-        process = self._process
-        self._process = None
-        self._transfers.clear()
-
-        if process is None:
-            return
-
-        if process.returncode is None:
-            process.terminate()
-            try:
-                await asyncio.wait_for(process.wait(), timeout=5.0)
-            except asyncio.TimeoutError:
-                process.kill()
-                await process.wait()
-
-    async def _drain_stderr(self) -> None:
-        """Continuously drain aria2's stderr pipe so it never blocks.
-
-        When the 64 KB pipe buffer fills up, aria2's ``write()`` to stderr
-        blocks, which freezes the entire ``aria2c`` process — including its
-        RPC handler.  This background task reads lines from stderr as they
-        arrive and forwards them to Python's logger.
-        """
-        try:
-            assert self._process is not None and self._process.stderr is not None
-            async for line in self._process.stderr:
-                text = line.decode("utf-8", errors="replace").rstrip()
-                if text:
-                    logger.debug("aria2 stderr: %s", text)
-        except Exception:
-            pass
-
-    async def _dispatch_progress(self, callback, snapshot: DownloadProgress) -> None:
-        try:
-            result = callback(snapshot, snapshot)
-        except TypeError:
-            result = callback(snapshot.percent_complete)
-
-        if asyncio.iscoroutine(result):
-            await result
-        elif hasattr(result, "__await__"):
-            await result
-
-    def _build_progress_snapshot(self, status: Dict[str, Any]) -> DownloadProgress:
-        completed = self._parse_int(status.get("completedLength"))
-        total = self._parse_int(status.get("totalLength"))
-        speed = float(self._parse_int(status.get("downloadSpeed")))
-        percent = 0.0
-        if total > 0:
-            percent = (completed / total) * 100.0
-
-        return DownloadProgress(
-            percent_complete=max(0.0, min(percent, 100.0)),
-            bytes_downloaded=completed,
-            total_bytes=total or None,
-            bytes_per_second=speed,
-            timestamp=datetime.now().timestamp(),
-        )
-
-    def _resolve_completed_path(self, status: Dict[str, Any], default_path: str) -> str:
-        files = status.get("files")
-        if isinstance(files, list) and files:
-            first = files[0]
-            if isinstance(first, dict):
-                candidate = first.get("path")
-                if isinstance(candidate, str) and candidate:
-                    return candidate
-        return default_path
-
-    @staticmethod
-    def _parse_int(value: Any) -> int:
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            return 0
-
-    async def _resolve_authenticated_redirect_url(
-        self,
-        url: str,
-        headers: Dict[str, str],
-    ) -> str:
-        downloader = await get_downloader()
-        session = await downloader.session
-        request_headers = dict(downloader.default_headers)
-        request_headers.update(headers)
-        request_headers["Accept-Encoding"] = "identity"
-
-        try:
-            async with session.get(
-                url,
-                headers=request_headers,
-                allow_redirects=False,
-                proxy=downloader.proxy_url,
-            ) as response:
-                if response.status in {301, 302, 303, 307, 308}:
-                    location = response.headers.get("Location")
-                    if location:
-                        return location
-                    raise Aria2Error(
-                        "Authenticated Civitai redirect did not include a Location header"
-                    )
-
-                if response.status == 200:
-                    return url
-
-                body = await response.text()
-                raise Aria2Error(
-                    f"Failed to resolve authenticated Civitai redirect: status={response.status} body={body[:300]}"
-                )
-        except aiohttp.ClientError as exc:
-            if is_ssl_cert_verify_error(exc):
-                logger.error(
-                    "SSL certificate verification failed during Civitai redirect "
-                    "resolution for %s. This is usually caused by an outdated CA "
-                    "certificate bundle. Recommended fixes:\n"
-                    "  1. pip install --upgrade certifi\n"
-                    "  2. pip install pip-system-certs",
-                    url,
-                )
-            raise Aria2Error(
-                f"Failed to resolve authenticated Civitai redirect: {exc}"
-            ) from exc
-
-    async def _ensure_process(self) -> None:
-        async with self._process_lock:
-            if self.is_running and await self._ping():
-                return
-
-            await self.close()
-
-            executable = self._resolve_executable()
-            self._rpc_port = self._find_free_port()
-            self._rpc_secret = secrets.token_hex(16)
-            self._rpc_url = f"http://127.0.0.1:{self._rpc_port}/jsonrpc"
-
-            command = [
-                executable,
-                "--enable-rpc=true",
-                "--rpc-listen-all=false",
-                f"--rpc-listen-port={self._rpc_port}",
-                f"--rpc-secret={self._rpc_secret}",
-                "--check-certificate=true",
-                # Point aria2 at certifi's CA bundle when available so it uses
-                # the same certificate store as Python downloads.
-                *((
-                    f"--ca-certificate={ca_cert}",
-                ) if (ca_cert := _try_certifi_ca_path()) else ()),
-                "--allow-overwrite=true",
-                "--auto-file-renaming=false",
-                "--file-allocation=none",
-                "--max-concurrent-downloads=5",
-                "--continue=true",
-                "--daemon=false",
-                "--quiet=true",
-                f"--stop-with-process={os.getpid()}",
-            ]
-
-            logger.info("Starting aria2 RPC daemon from %s", executable)
-            self._process = await asyncio.create_subprocess_exec(
-                *command,
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-            await self._wait_until_ready()
-
-            # Drain aria2's stderr in a background task so the pipe buffer
-            # never fills up.  If the pipe blocks, aria2 itself freezes and
-            # cannot respond to RPC — this was the root cause of the
-            # "Failed to query aria2 download status" timeout bug.
-            # Must start AFTER _wait_until_ready to avoid a race where the
-            # drain task consumes aria2's early-exit error message before
-            # _wait_until_ready can read it.
-            self._stderr_reader_task = asyncio.create_task(
-                self._drain_stderr()
-            )
-
-    def _resolve_executable(self) -> str:
-        settings = get_settings_manager()
-        configured_path = (settings.get("aria2c_path") or "").strip()
-        candidate = configured_path or "aria2c"
-
-        resolved = shutil.which(candidate)
-        if resolved:
-            return resolved
-
-        if configured_path and os.path.isfile(configured_path) and os.access(
-            configured_path, os.X_OK
-        ):
-            return configured_path
-
-        raise Aria2Error(
-            "aria2c executable was not found. Install aria2 or configure aria2c_path."
-        )
-
-    async def _wait_until_ready(self) -> None:
-        assert self._process is not None
-
-        start_time = asyncio.get_running_loop().time()
-        last_error = ""
-        while asyncio.get_running_loop().time() - start_time < 10.0:
-            if self._process.returncode is not None:
-                stderr_output = ""
-                if self._process.stderr is not None:
-                    try:
-                        stderr_output = (
-                            await asyncio.wait_for(self._process.stderr.read(), timeout=0.2)
-                        ).decode("utf-8", errors="replace")
-                    except Exception:
-                        stderr_output = ""
-                raise Aria2Error(
-                    f"aria2 RPC process exited early with code {self._process.returncode}: {stderr_output.strip()}"
-                )
-
-            try:
-                if await self._ping():
-                    return
-            except Exception as exc:  # pragma: no cover - startup race
-                last_error = str(exc)
-
-            await asyncio.sleep(0.2)
-
-        raise Aria2Error(
-            f"Timed out waiting for aria2 RPC to become ready{': ' + last_error if last_error else ''}"
-        )
-
-    async def _ping(self) -> bool:
-        try:
-            result = await self._rpc_call("aria2.getVersion", [])
-        except Exception:
-            return False
-
-        return isinstance(result, dict)
-
-    async def _rpc_call(self, method: str, params: list[Any]) -> Any:
-        if not self._rpc_url:
-            raise Aria2Error("aria2 RPC endpoint is not initialized")
-
-        session = await self._get_rpc_session()
-        payload = {
-            "jsonrpc": "2.0",
-            "id": secrets.token_hex(8),
-            "method": method,
-            "params": [f"token:{self._rpc_secret}", *params],
-        }
-
-        async with session.post(self._rpc_url, json=payload) as response:
-            text = await response.text()
-
-        try:
-            body = json.loads(text)
-        except json.JSONDecodeError:
-            body = None
-
-        if body is None:
-            if response.status != 200:
-                raise Aria2Error(
-                    f"aria2 RPC returned status {response.status} with non-JSON body: {text}"
-                )
-            raise Aria2Error(f"Invalid aria2 RPC response: {text}")
-
-        if "error" in body:
-            error = body["error"] or {}
-            code = error.get("code") if isinstance(error, dict) else None
-            message = error.get("message") if isinstance(error, dict) else str(error)
-            logger.error(
-                "aria2 RPC %s failed with HTTP %s, code=%s, message=%s",
-                method,
-                response.status,
-                code,
-                message,
-            )
-            status_message = (
-                f"aria2 RPC {method} failed with status {response.status}: {message}"
-                if response.status != 200
-                else message
-            )
-            raise Aria2Error(status_message or "Unknown aria2 RPC error")
-
-        if response.status != 200:
-            logger.error(
-                "aria2 RPC %s returned unexpected HTTP status %s without error payload: %s",
-                method,
-                response.status,
-                body,
-            )
-            raise Aria2Error(
-                f"aria2 RPC {method} returned unexpected status {response.status}"
-            )
-
-        return body.get("result")
-
-    async def _get_rpc_session(self) -> aiohttp.ClientSession:
-        if self._rpc_session is None or self._rpc_session.closed:
-            async with self._rpc_session_lock:
-                if self._rpc_session is None or self._rpc_session.closed:
-                    timeout = aiohttp.ClientTimeout(
-                        total=None, sock_connect=10, sock_read=60
-                    )
-                    self._rpc_session = aiohttp.ClientSession(timeout=timeout)
-        return self._rpc_session
-
-    @staticmethod
-    def _find_free_port() -> int:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.bind(("127.0.0.1", 0))
-            sock.listen(1)
-            return int(sock.getsockname()[1])
-
-
-async def get_aria2_downloader() -> Aria2Downloader:
-    """Get the singleton aria2 downloader."""
-
-    return await Aria2Downloader.get_instance()