chore: prepare v2.4.0 release

Refactor the monolithic QwenVL implementation into focused core modules for model access, Hugging Face runtime and configuration, prompt state, prompt contracts, and media helpers while preserving the public compatibility facade.

Add duration-aware LTX 2.3 and MiniMax H3 prompting, including effective-duration cache identity, MiniMax frame-grid normalization, dedicated T2VA/I2VA/FL2VA/L2VA/reference contracts, and best-effort output normalization.

Improve streamed output handling by separating reasoning from final content, rejecting unfinished thinking traces, sanitizing terminal-only punctuation for legacy Windows code pages, and retaining original Unicode in responses and traces.

Expand preset recommendations, ComfyUI tooltips, system prompts, and documentation for video token budgets, thinking settings, reference roles, dialogue fidelity, and duration behavior.

Keep HF and GGUF consumers on canonical shared imports, preserve mutable export identities across reloads, and extend regression coverage for compatibility, downloads, caching, prompting, streaming, and node registration.

.github/workflows/publish.yml

@@ -18,7 +18,62 @@ jobs:
     steps:
       - name: Check out code
         uses: actions/checkout@v4
+      - name: Check registry version
+        id: registry_version
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          node_id="$(python3 - <<'PY'
+          import tomllib
+          with open("pyproject.toml", "rb") as handle:
+              data = tomllib.load(handle)
+          print(data["project"]["name"])
+          PY
+          )"
+          version="$(python3 - <<'PY'
+          import tomllib
+          with open("pyproject.toml", "rb") as handle:
+              data = tomllib.load(handle)
+          print(data["project"]["version"])
+          PY
+          )"
+
+          url="https://api.comfy.org/nodes/${node_id}/versions"
+          http_code="$(curl -sS -o registry_versions.json -w "%{http_code}" "${url}")"
+
+          if [ "${http_code}" = "404" ]; then
+            exists="false"
+          elif [ "${http_code}" -ge 200 ] && [ "${http_code}" -lt 300 ]; then
+            exists="$(python3 - "${version}" <<'PY'
+          import json
+          import sys
+
+          version = sys.argv[1]
+          with open("registry_versions.json", "r", encoding="utf-8") as handle:
+              versions = json.load(handle)
+          print("true" if any(item.get("version") == version for item in versions) else "false")
+          PY
+          )"
+          else
+            cat registry_versions.json
+            echo "Registry version lookup failed with HTTP ${http_code}" >&2
+            exit 1
+          fi
+
+          echo "node_id=${node_id}" >> "${GITHUB_OUTPUT}"
+          echo "version=${version}" >> "${GITHUB_OUTPUT}"
+          echo "exists=${exists}" >> "${GITHUB_OUTPUT}"
+
+          if [ "${exists}" = "true" ]; then
+            echo "::notice::${node_id} ${version} is already published in the Comfy registry; skipping duplicate publish."
+          fi
       - name: Publish Custom Node
+        if: steps.registry_version.outputs.exists != 'true'
         uses: Comfy-Org/publish-node-action@v1
         with:
-          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
+      - name: Already published
+        if: steps.registry_version.outputs.exists == 'true'
+        run: |
+          echo "${{ steps.registry_version.outputs.node_id }} ${{ steps.registry_version.outputs.version }} is already live in the Comfy registry."

AILab_LlamaCppInstaller.py

@@ -45,7 +45,7 @@ KNOWN_LINUX_WHEEL_SPECS = {
         "llama_cpp_python-0.3.34+cu130.basic-cp312-cp312-linux_x86_64.whl"
     ),
 }
-VISION_HANDLER_NAMES = ("Qwen3VLChatHandler", "Qwen25VLChatHandler")
+VISION_HANDLER_NAMES = ("Qwen3VLChatHandler", "Qwen25VLChatHandler", "Gemma4ChatHandler", "MTMDChatHandler")
 _LAST_BACKEND_INFO: dict | None = None
 _PRINTED_BACKEND_LINES: set[str] = set()
 
@@ -460,4 +460,4 @@ def ensure_llama_cpp_backend(require_vision_handlers: bool = False):
                 "[QwenVL] llama_cpp was installed, but the backend is still incompatible. "
                 "Set THINKINGLLM_LLAMA_CPP_LINUX_WHEEL_URL to a matching JamePeng wheel or "
                 "THINKINGLLM_LLAMA_CPP_LINUX_SPEC to an explicit package spec, then restart ComfyUI."
-            ) from second_exc
+            ) from second_exc

AILab_OutputCleaner.py

@@ -2,6 +2,8 @@ import json
 import re
 from dataclasses import dataclass
 
+OUTPUT_CLEANER_VERSION = 4
+
 
 @dataclass(frozen=True)
 class OutputCleanConfig:
@@ -27,13 +29,13 @@ _IM_TOKEN_RE = re.compile(
     r"(?i)<\|?im_(start|end)\|?>|<im_(start|end)>|<\|endoftext\|>",
 )
 _PLANNING_RE = re.compile(
-    r"(?is)\b("
+    r"(?im)^\s*(?:[-*]\s*)?(?:\*\*)?\s*(?:"
     r"final\s+plan\b|"
     r"final\s+check\b|"
-    r"i\s+(should|need|must|will|want|am\s+going\s+to|have\s+to)\b|"
+    r"i\s+(?:should|need|must|will|want|am\s+going\s+to|have\s+to)\b|"
     r"let's\b|"
-    r"first\b|next\b|then\b|"
-    r"wait\b|"
+    r"first\s*[,.:]|next\s*[,.:]|then\s*[,.:]|"
+    r"wait\s*[,.:]|"
     r"ready\s+to\s+write\b|"
     r"writing\s+the\s+prompt\b|"
     r"so\s+i\s+need\s+to\b|"
@@ -55,11 +57,12 @@ def clean_model_output(text: str, config: OutputCleanConfig | None = None) -> st
     if cfg.strip_think:
         cleaned = _THINK_BLOCK_RE.sub("", cleaned)
         cleaned = _THINK_CLOSE_RE.sub("", cleaned)
-        if _THINK_OPEN_RE.search(cleaned):
-            cleaned = _THINK_OPEN_RE.sub("", cleaned)
-            parts = re.split(r"\n\s*\n", cleaned, maxsplit=1)
-            if len(parts) == 2:
-                cleaned = parts[1]
+        unclosed_think = _THINK_OPEN_RE.search(cleaned)
+        if unclosed_think:
+            # When generation ends before </think>, no final answer exists.
+            # Prompt-shaped examples inside that unfinished reasoning must not
+            # be exposed as RESPONSE.
+            cleaned = cleaned[:unclosed_think.start()]
         cleaned = cleaned.strip()
 
     cleaned = _IM_TOKEN_RE.sub("", cleaned).strip()

AILab_QwenVL_GGUF_PromptEnhancer.py

@@ -27,34 +27,61 @@ import torch
 from huggingface_hub import snapshot_download
 from AILab_LlamaCppInstaller import ensure_llama_cpp_backend
 
-import folder_paths
-from AILab_OutputCleaner import OutputCleanConfig, clean_model_output, prompt_output_guard
+from AILab_OutputCleaner import OUTPUT_CLEANER_VERSION, OutputCleanConfig, clean_model_output, prompt_output_guard
 from comfy.model_management import throw_exception_if_processing_interrupted
 from comfy.model_management import throw_exception_if_processing_interrupted
 
-# Import cache functions from main module
+# Import shared contracts directly; AILab_QwenVL remains a compatibility facade.
 import sys
 sys.path.append(str(Path(__file__).parent))
-from AILab_StreamDisplay import TerminalStreamDisplay
-from AILab_QwenVL import (
-    PROMPT_CACHE,
-    apply_qwen_soft_thinking_directive,
-    build_node_input_signature,
+from AILab_StreamDisplay import (
+    StreamDegenerationError,
+    StreamDegenerationGuard,
+    TerminalStreamDisplay,
+    compose_streamed_model_output,
+    extract_stream_token,
+    strip_degenerate_repetition,
+)
+from thinkingllm_core.hf_models import ensure_cuda_vram_headroom
+from thinkingllm_core.model_access import (
     download_hf_file_to_path,
-    ensure_cuda_vram_headroom,
+    enforce_model_access,
+    model_catalog_options,
+    resolve_model_catalog_name,
+)
+from thinkingllm_core.prompt_contracts import (
+    VIDEO_DURATION_INPUT,
+    apply_qwen_soft_thinking_directive,
+    apply_video_duration_context,
+    ensure_video_prompt_duration,
     estimate_qwen_text_tokens,
-    get_cache_key,
+    resolve_qwen_thinking_mode,
+    resolve_video_duration,
+    validate_minimax_source_duration,
+)
+from thinkingllm_core.prompt_state import (
+    PROMPT_CACHE,
+    _build_workflow_fingerprint,
+    _make_node_state_key,
+    build_node_input_signature,
     get_alternative_cache_key,
-    save_prompt_cache,
+    get_cache_key,
     get_node_saved_prompt,
     get_node_saved_prompt_with_seed,
-    resolve_qwen_thinking_mode,
-    set_node_saved_prompt,
     load_node_prompt_state,
-    _make_node_state_key,
-    _build_workflow_fingerprint,
+    log_llm_input,
+    save_prompt_cache,
+    set_node_saved_prompt,
+)
+from AILab_QwenVL_GGUF import (
+    construct_llama_safely,
+    read_gguf_architecture,
+    register_active_gguf_loader,
+    release_other_gguf_loaders,
+    _filter_kwargs_for_callable,
+    _find_existing_local_file_in_dirs,
+    _gguf_search_dirs,
 )
-from AILab_QwenVL_GGUF import read_gguf_architecture, register_active_gguf_loader, release_other_gguf_loaders
 
 
 GGUF_PROMPT_TOOLTIPS = {
@@ -66,13 +93,14 @@ GGUF_PROMPT_TOOLTIPS = {
     "temperature": "Sampling randomness. Lower is more stable; higher is more varied.",
     "top_p": "Nucleus sampling cutoff. Lower values restrict token choice; 0.9 is a balanced default.",
     "repetition_penalty": "Values above 1.0 reduce repeated phrases in the enhanced prompt.",
-    "english_output": "Ask the model to return the final enhanced prompt in English.",
+    "english_output": "Ask the model to return the final enhanced prompt in English. MiniMax H3 presets already require English and bypass the generic paragraph translation pass so their official field structure remains intact.",
     "device": "auto prefers GPU when available. If generation is unexpectedly slow, run tools/check_llama_backend.py to verify llama.cpp GPU offload.",
     "keep_model_loaded": "Keep the GGUF model in memory after generation so repeated prompt enhancement skips model loading.",
     "seed": "Sampling seed. Reusing it with identical inputs can reuse the saved prompt result.",
     "keep_last_prompt": "Return the saved per-node prompt instead of generating a new one when available.",
-    "stream_tokens_to_terminal": "Show readable generation progress and thinking-status summaries in the ComfyUI terminal. Streaming bypasses fixed-seed reuse for a fresh run.",
+    "stream_tokens_to_terminal": "Show clean wrapped generated tokens in the ComfyUI terminal. Streaming bypasses fixed-seed reuse for a fresh run.",
     "enable_thinking": "Enable model reasoning/thinking when supported. The node still returns the cleaned final prompt, so reasoning may be hidden or empty.",
+    "auto_finalization_retry": "If enabled, runs an extra LLM completion when the first output is empty or reasoning-only. Disabled by default so one node execution performs one generation pass.",
     "hf_token": "Optional Hugging Face access token for private or gated GGUF downloads. It is passed only to the download call, never logged or cached, and the in-memory copy is dropped after the download attempt. Clear this field before saving or sharing workflows.",
 }
 
@@ -112,9 +140,35 @@ _QUANT_CANONICAL = {
 }
 
 _EMPTY_THINK_RE = re.compile(r"<think[^>]*>\s*</think>", flags=re.IGNORECASE | re.DOTALL)
+_LEADING_CLOSED_THINK_RE = re.compile(
+    r"^\s*(?:<think[^>]*>.*?</think>\s*)+",
+    flags=re.IGNORECASE | re.DOTALL,
+)
 _STREAM_HEARTBEAT_INTERVAL_SECONDS = 3.0
 _PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS = 3
 _STREAM_POLL_INTERVAL_SECONDS = 0.25
+_PROMPT_ENHANCER_MIN_CONTEXT_LENGTH = 4096
+_PROMPT_ENHANCER_MAX_CONTEXT_LENGTH = 32768
+
+
+def _resolve_prompt_enhancer_context_length(config_context_length, prompt_tokens, max_tokens) -> int:
+    try:
+        configured = int(config_context_length)
+    except Exception:
+        configured = _PROMPT_ENHANCER_MAX_CONTEXT_LENGTH
+    if configured <= 0:
+        configured = _PROMPT_ENHANCER_MAX_CONTEXT_LENGTH
+    try:
+        prompt_budget = max(int(prompt_tokens), 0)
+    except Exception:
+        prompt_budget = 0
+    try:
+        generation_budget = max(int(max_tokens), 0)
+    except Exception:
+        generation_budget = 0
+    requested = max(_PROMPT_ENHANCER_MIN_CONTEXT_LENGTH, prompt_budget + generation_budget + 1024)
+    cap = min(configured, _PROMPT_ENHANCER_MAX_CONTEXT_LENGTH)
+    return max(1024, min(cap, requested))
 
 
 def _looks_like_prompt_planning(text: str) -> bool:
@@ -133,6 +187,64 @@ def _prompt_output_is_usable(cleaned_text: str) -> bool:
     return bool(cleaned_text and not _looks_like_prompt_planning(cleaned_text))
 
 
+def _preset_output_is_usable(cleaned_text: str, preset_name: str) -> bool:
+    """Accept cleaned video output without imposing a second model schema gate."""
+    resolved = resolve_video_duration(preset_name, 5.0)
+    if resolved:
+        # OutputCleaner already removes completed thinking blocks and returns
+        # an empty string for unfinished ones. The target video model can
+        # tolerate minor field and formatting irregularities, so rejecting a
+        # non-empty final prompt here only creates false empty outputs.
+        return bool((cleaned_text or "").strip())
+    return _prompt_output_is_usable(cleaned_text)
+
+
+def _merge_assistant_prefill(content_text: str, assistant_prefill: str) -> str:
+    """Restore a chat-template prefill without duplicating a model-emitted field.
+
+    Some Qwen GGUF chat templates return a literal empty ``<think>`` block
+    before repeating the assistant prefill. Checking only the first visible
+    characters made us prepend the field a second time, so an otherwise valid
+    MiniMax result was rejected. Inspect the first final-answer text after any
+    closed leading think block and insert the prefill there only when missing.
+    """
+    content = (content_text or "").strip()
+    prefill = (assistant_prefill or "").strip()
+    if not content or not prefill:
+        return content
+
+    leading_think = _LEADING_CLOSED_THINK_RE.match(content)
+    answer_start = leading_think.end() if leading_think else 0
+    answer = content[answer_start:].lstrip()
+    if answer.casefold().startswith(prefill.casefold()):
+        return content
+
+    # An unfinished thinking block has no final answer to prefix.
+    if not leading_think and re.match(r"^\s*<think\b", content, flags=re.IGNORECASE):
+        return content
+
+    separator = "" if prefill.endswith((" ", "\n")) else " "
+    if leading_think:
+        return f"{content[:answer_start]}{prefill}{separator}{answer}"
+    return f"{prefill}{separator}{content}"
+
+
+def _video_assistant_prefill(preset_name: str) -> str:
+    """Start schema-only retries inside the target model's native format."""
+    resolved = resolve_video_duration(preset_name, 5.0)
+    if not resolved:
+        return ""
+    if resolved.get("provider") == "minimax_h3":
+        return (
+            "subject_definitions:"
+            if resolved.get("video_mode") == "ref2va"
+            else "integrated_multimodal_description:"
+        )
+    if resolved.get("provider") == "ltx_2_3":
+        return "A"
+    return ""
+
+
 def _maybe_emit_prompt_stream_heartbeat(stage_label: str, started_at: float, last_status_at: float, full_text: str) -> float:
     now = time.monotonic()
     if (now - last_status_at) < _STREAM_HEARTBEAT_INTERVAL_SECONDS:
@@ -262,13 +374,6 @@ def _safe_dirname(value: str) -> str:
     return "".join(ch for ch in value if ch.isalnum() or ch in "._- ").strip() or "unknown"
 
 
-def _resolve_base_dir(base_dir_value: str) -> Path:
-    base_dir = Path(base_dir_value)
-    if base_dir.is_absolute():
-        return base_dir
-    return Path(folder_paths.models_dir) / base_dir
-
-
 def _model_name_to_filename_candidates(model_name: str) -> set[str]:
     raw = (model_name or "").strip()
     if not raw:
@@ -283,18 +388,32 @@ def _model_name_to_filename_candidates(model_name: str) -> set[str]:
     return candidates
 
 
-def _find_existing_local_file(base_dir: Path, filename: str) -> Path | None:
-    """Reuse an already-downloaded GGUF file anywhere under the shared base dir."""
-    wanted = Path(filename).name
-    if not wanted:
-        return None
-    try:
-        for candidate in base_dir.rglob(wanted):
-            if candidate.is_file():
-                return candidate
-    except Exception:
-        return None
-    return None
+def _as_filename_list(value) -> list[str]:
+    if not value:
+        return []
+    if isinstance(value, str):
+        values = [value]
+    elif isinstance(value, (list, tuple, set)):
+        values = list(value)
+    else:
+        return []
+
+    filenames: list[str] = []
+    for item in values:
+        name = Path(str(item)).name
+        if name and name not in filenames:
+            filenames.append(name)
+    return filenames
+
+
+def _filename_aliases_for(payload, key: str | None) -> list[str]:
+    if not isinstance(payload, dict) or not key:
+        return []
+    return _as_filename_list(payload.get(key) or payload.get(Path(key).name))
+
+
+def _filename_search_candidates(filename: str, aliases: list[str] | None = None) -> list[str]:
+    return _as_filename_list([filename, *(aliases or [])])
 
 
 class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
@@ -332,6 +451,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 local_models[display] = {
                     "filename": str(gguf_file),
                     "is_local": True,
+                    "commercial_status": "local",
                     "repo_id": None,
                     "alt_repo_ids": [],
                     "author": None,
@@ -382,6 +502,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 defaults: dict = _defaults_raw if isinstance(_defaults_raw, dict) else {}
                 repo_id = repo.get("repo_id")
                 alt_repo_ids = repo.get("alt_repo_ids") or []
+                local_filenames = repo.get("local_filenames") or repo.get("local_model_files") or {}
                 model_files = repo.get("model_files") or []
                 quant_sizes = _parse_repo_quant_sizes(repo_key)
                 for model_file in model_files:
@@ -397,11 +518,13 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                     entry = dict(defaults)
                     entry.update(
                         {
+                            "commercial_status": repo.get("commercial_status", "unclear"),
                             "author": author,
                             "repo_dirname": repo_name,
                             "repo_id": repo_id,
                             "alt_repo_ids": alt_repo_ids,
                             "filename": model_file,
+                            "local_filenames": _filename_aliases_for(local_filenames, model_file),
                         }
                     )
                     models[display] = entry
@@ -409,19 +532,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         # Scan filesystem for locally available models not in JSON config
         # Collect all directories to scan: the configured base_dir + any extra LLM paths from ComfyUI
         existing_filenames = {Path(e.get("filename", "")).name for e in models.values() if e.get("filename")}
-        scan_dirs: list[Path] = [_resolve_base_dir(base_dir)]
-        try:
-            if "LLM" in folder_paths.folder_names_and_paths:
-                for llm_path in folder_paths.get_folder_paths("LLM"):
-                    gguf_dir = Path(llm_path) / "GGUF"
-                    if gguf_dir not in scan_dirs:
-                        scan_dirs.append(gguf_dir)
-                    llm_p = Path(llm_path)
-                    if llm_p not in scan_dirs:
-                        scan_dirs.append(llm_p)
-        except Exception:
-            pass
-        for scan_dir in scan_dirs:
+        for scan_dir in _gguf_search_dirs(base_dir):
             local_models = ThinkingLLM_QwenVL_GGUF_PromptEnhancer._scan_local_gguf_text_models(scan_dir, existing_filenames)
             models.update(local_models)
             existing_filenames.update(Path(e.get("filename", "")).name for e in local_models.values() if e.get("filename"))
@@ -434,7 +545,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         preferred_style = "📝 Enhance"
         default_style = preferred_style if preferred_style in styles else (styles[0] if styles else "📝 Enhance")
         temp = cls.load_gguf_models()
-        model_keys = sorted(list((temp.get("models") or {}).keys())) or ["(no GGUF models found)"]
+        model_keys = model_catalog_options(temp.get("models") or {}) or ["(no GGUF models found)"]
         default_model = model_keys[0]
         return {
             "required": {
@@ -453,16 +564,21 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 "keep_last_prompt": ("BOOLEAN", {"default": False, "tooltip": GGUF_PROMPT_TOOLTIPS["keep_last_prompt"]}),
                 "stream_tokens_to_terminal": ("BOOLEAN", {"default": False, "tooltip": GGUF_PROMPT_TOOLTIPS["stream_tokens_to_terminal"]}),
                 "enable_thinking": ("BOOLEAN", {"default": True, "tooltip": GGUF_PROMPT_TOOLTIPS["enable_thinking"]}),
+                "auto_finalization_retry": ("BOOLEAN", {"default": False, "tooltip": GGUF_PROMPT_TOOLTIPS["auto_finalization_retry"]}),
                 "hf_token": ("STRING", {"default": "", "multiline": False, "tooltip": GGUF_PROMPT_TOOLTIPS["hf_token"]}),
             },
+            "optional": {
+                "duration_seconds": VIDEO_DURATION_INPUT,
+            },
             "hidden": {
                 "unique_id": "UNIQUE_ID",
                 "extra_pnginfo": "EXTRA_PNGINFO",
             },
         }
 
-    def clear(self):
-        print(f"[QwenVL PromptEnhancer DEBUG] Starting VRAM cleanup...")
+    def clear(self, quiet: bool = False):
+        if not quiet:
+            print(f"[QwenVL PromptEnhancer DEBUG] Starting VRAM cleanup...")
         
         # Force cleanup of LLM model
         if self.llm is not None:
@@ -475,7 +591,8 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 # Force garbage collection of the model
                 del self.llm
             except Exception as e:
-                print(f"[QwenVL PromptEnhancer DEBUG] Error closing LLM: {e}")
+                if not quiet:
+                    print(f"[QwenVL PromptEnhancer DEBUG] Error closing LLM: {e}")
             finally:
                 self.llm = None
         
@@ -487,7 +604,8 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         
         # Force CUDA cache cleanup multiple times
         if torch.cuda.is_available():
-            print(f"[QwenVL PromptEnhancer DEBUG] Clearing CUDA cache...")
+            if not quiet:
+                print(f"[QwenVL PromptEnhancer DEBUG] Clearing CUDA cache...")
             torch.cuda.empty_cache()
             try:
                 torch.cuda.ipc_collect()
@@ -497,10 +615,24 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
             # Additional cleanup
             torch.cuda.empty_cache()
         
-        print(f"[QwenVL PromptEnhancer DEBUG] VRAM cleanup completed")
+        if not quiet:
+            print(f"[QwenVL PromptEnhancer DEBUG] VRAM cleanup completed")
+
+    @staticmethod
+    def _find_existing_local_file_in_dirs(search_dirs: list[Path], filename: str, aliases: list[str] | None = None) -> Path | None:
+        for search_dir in search_dirs:
+            for wanted in _filename_search_candidates(filename, aliases):
+                try:
+                    for candidate in search_dir.rglob(wanted):
+                        if candidate.is_file():
+                            return candidate
+                except Exception:
+                    continue
+        return None
 
     def _resolve_model_path(self, model_name):
         models = self.gguf_models.get("models") or {}
+        model_name = resolve_model_catalog_name(models, model_name)
         entry = models.get(model_name) or {}
 
         # Back-compat: allow workflows to pass a filename instead of a catalog key.
@@ -517,7 +649,8 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         if filename and Path(filename).is_absolute():
             return Path(filename)
 
-        base_dir = _resolve_base_dir(self.gguf_models.get("base_dir") or "LLM/GGUF")
+        search_dirs = _gguf_search_dirs(self.gguf_models.get("base_dir") or "LLM/GGUF")
+        base_dir = search_dirs[0]
 
         path = entry.get("path")
         if path:
@@ -532,7 +665,11 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 target = base_dir / repo_dir / Path(filename).name
             if target.exists():
                 return target
-            existing = _find_existing_local_file(base_dir, filename)
+            existing = self._find_existing_local_file_in_dirs(
+                search_dirs,
+                filename,
+                _as_filename_list(entry.get("local_filenames") or entry.get("local_model_files")),
+            )
             if existing is not None:
                 target.parent.mkdir(parents=True, exist_ok=True)
                 try:
@@ -545,13 +682,9 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         return base_dir / model_name
 
     def _maybe_download_model(self, model_name, resolved, unique_id=None, hf_token: str | None = None):
-        if resolved.exists():
-            return
-        # Local models should already exist on disk — don't attempt download
         models = self.gguf_models.get("models") or {}
+        model_name = resolve_model_catalog_name(models, model_name)
         entry = models.get(model_name) or {}
-        if entry.get("is_local"):
-            raise FileNotFoundError(f"[QwenVL] Local GGUF model not found: {resolved}")
         if not entry:
             wanted = _model_name_to_filename_candidates(model_name)
             for candidate in models.values():
@@ -559,6 +692,10 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 if filename and Path(filename).name in wanted:
                     entry = candidate
                     break
+        if resolved.exists():
+            enforce_model_access(entry, model_name, local_exists=True, hf_token=hf_token)
+            return
+        enforce_model_access(entry, entry.get("repo_id") or model_name, local_exists=False, hf_token=hf_token)
 
         repo_ids = [rid for rid in (entry.get("alt_repo_ids") or []) + [entry.get("repo_id")] if rid]
         filename = entry.get("filename") or resolved.name
@@ -587,13 +724,24 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         if not resolved.exists():
             raise FileNotFoundError(f"[QwenVL] GGUF model not found after download: {resolved} (tried: {', '.join(attempted)})")
 
-    def _load_model(self, model_name, device, enable_thinking=True, unique_id=None, hf_token: str | None = None):
+    def _load_model(self, model_name, device, enable_thinking=True, unique_id=None, hf_token: str | None = None, context_length_override: int | None = None, quiet: bool = False):
+        model_name = resolve_model_catalog_name(self.gguf_models.get("models") or {}, model_name)
         Llama = self._load_backend()
         resolved = self._resolve_model_path(model_name)
         self._maybe_download_model(model_name, resolved, unique_id=unique_id, hf_token=hf_token)
         hf_token = None
         model_cfg = self.gguf_models["models"].get(model_name, {})
-        context_length = model_cfg.get("context_length", 32768)
+        raw_context_length = model_cfg.get("context_length", 32768)
+        context_length = int(context_length_override or raw_context_length or 32768)
+        try:
+            raw_context_int = int(raw_context_length)
+        except Exception:
+            raw_context_int = context_length
+        if context_length < raw_context_int and not quiet:
+            print(
+                f"[QwenVL PromptEnhancer GGUF] Using context length {context_length} "
+                f"instead of catalog {raw_context_int} to reduce KV-cache VRAM."
+            )
         signature = (resolved, context_length, device, bool(enable_thinking))
         if self.llm is not None and self.current_signature == signature:
             ensure_cuda_vram_headroom("QwenVL PromptEnhancer GGUF", min_free_gb=1.0, min_free_ratio=0.08)
@@ -602,8 +750,9 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         release_other_gguf_loaders(self, resolved.name)
         
         # Force aggressive cleanup before loading new model (especially for same model conflicts)
-        print(f"[QwenVL PromptEnhancer DEBUG] Forcing cleanup before model loading...")
-        self.clear()
+        if not quiet:
+            print(f"[QwenVL PromptEnhancer DEBUG] Forcing cleanup before model loading...")
+        self.clear(quiet=quiet)
         
         # Additional wait for CUDA cleanup
         if torch.cuda.is_available():
@@ -612,7 +761,8 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         resolved.parent.mkdir(parents=True, exist_ok=True)
         if not resolved.exists():
             raise FileNotFoundError(f"[QwenVL] GGUF model not found: {resolved}")
-        print(f"[QwenVL] Loading GGUF model from {resolved}")
+        if not quiet:
+            print(f"[QwenVL] Loading GGUF model from {resolved}")
         if device == "auto":
             device_choice = "cuda" if torch.cuda.is_available() else ("mps" if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available() else "cpu")
         else:
@@ -636,12 +786,20 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         arch = read_gguf_architecture(resolved)
         self.gguf_arch = arch
         is_qwen = (arch and any(a in arch for a in ("qwen35", "qwen35moe", "qwen3", "qwen"))) or "qwen3.5-" in model_name.lower() or "qwen3-" in model_name.lower()
-        self.supports_qwen_soft_think = arch == "qwen3" if arch else "qwen3-" in model_name.lower()
+        self.supports_qwen_soft_think = (
+            bool(arch and (arch == "qwen3" or arch.startswith("qwen35")))
+            if arch
+            else ("qwen3-" in model_name.lower() or "qwen3.5-" in model_name.lower())
+        )
         if is_qwen:
             thinking_state = bool(enable_thinking)
-            kwargs["chat_template_kwargs"] = {"enable_thinking": thinking_state}
+            kwargs["chat_template_kwargs"] = {
+                "enable_thinking": thinking_state,
+                "thinking_mode": "enabled" if thinking_state else "disabled",
+            }
             state_label = "enabled" if thinking_state else "disabled"
-            print(f"[QwenVL] Qwen architecture detected (arch={arch}): Thinking {state_label} via chat template.")
+            if not quiet:
+                print(f"[QwenVL] Qwen architecture detected (arch={arch}): Thinking {state_label} via chat template.")
         else:
             thinking_state = bool(enable_thinking)
             if not thinking_state:
@@ -655,7 +813,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
             else:
                 print(f"[QwenVL] Non-Qwen architecture (arch={arch}): Thinking ON (advisory — backend may ignore).")
 
-        self.llm = Llama(**kwargs)
+        self.llm = construct_llama_safely(Llama, kwargs, "QwenVL PromptEnhancer GGUF")
         self.current_signature = signature
 
     def _invoke_llama(
@@ -670,13 +828,17 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         stream_to_terminal=False,
         initial_stage_label="INITIAL GENERATION",
         enable_thinking=True,
+        auto_finalization_retry=False,
+        preset_name="",
     ):
         """Returns (cleaned_prompt, raw_trace) tuple."""
         stream_display = TerminalStreamDisplay("QwenVL GGUF", suppress_planning=True, compact=True) if stream_to_terminal else None
         supports_soft_think = getattr(self, "supports_qwen_soft_think", False)
+        is_video_preset = bool(resolve_video_duration(preset_name, 5.0))
         if supports_soft_think:
             directive = "/think" if enable_thinking else "/no_think"
-            print(f"[QwenVL] Qwen3 GGUF prompt enhancer: Thinking {'enabled' if enable_thinking else 'disabled'} via chat template and {directive}.")
+            if not stream_to_terminal:
+                print(f"[QwenVL] Qwen3 GGUF prompt enhancer: Thinking {'enabled' if enable_thinking else 'disabled'} via chat template and {directive}.")
 
         def _call(
             system: str,
@@ -686,6 +848,7 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
             stage_label: str,
             *,
             attempt_enable_thinking: bool | None = None,
+            assistant_prefill: str = "",
         ) -> str:
             current_enable_thinking = enable_thinking if attempt_enable_thinking is None else bool(attempt_enable_thinking)
             effective_user_prompt = apply_qwen_soft_thinking_directive(
@@ -706,31 +869,57 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 {"role": "system", "content": system},
                 {"role": "user", "content": effective_user_prompt},
             ]
+            if assistant_prefill:
+                messages.append({"role": "assistant", "content": assistant_prefill})
+            log_llm_input(
+                "QwenVL PromptEnhancer GGUF",
+                stage_label,
+                preset_name,
+                effective_user_prompt,
+                system_text=system,
+            )
             full_text = ""
+            reasoning_text = ""
+            content_text = ""
             stage_started_at = time.monotonic()
             last_status_at = stage_started_at
             if stream_to_terminal:
                 if stream_display is None:
                     raise RuntimeError("[QwenVL] Stream display was not initialized")
-                print(f"[QwenVL PromptEnhancer GGUF] STREAMING {stage_label}")
                 stream_display.start_stage(stage_label)
             abort_requested = threading.Event()
             abort_callback_refs = _install_llama_abort_callback(llm, abort_requested.is_set)
             result_queue: queue.Queue[tuple[str, dict | BaseException | None]] = queue.Queue()
+            degeneration_guard = StreamDegenerationGuard()
+            stopped_for_degenerate_stream = ""
 
             def _stream_worker():
                 try:
-                    response = llm.create_chat_completion(
-                        messages=messages,
-                        max_tokens=max_tokens,
-                        temperature=temp,
-                        top_p=top_p,
-                        repeat_penalty=repetition_penalty,
-                        seed=seed_val,
-                        stop=["<|im_end|>", "<|im_start|>"],
-                        stream=True,
-                    )
+                    completion_kwargs = {
+                        "messages": messages,
+                        "max_tokens": max_tokens,
+                        "temperature": temp,
+                        "top_p": top_p,
+                        "top_k": 60,
+                        "min_p": 0.01,
+                        "repeat_penalty": repetition_penalty,
+                        "repeat_last_n": 48,
+                        "presence_penalty": max(0.0, min(1.5, float(repetition_penalty) - 1.0 + 1.2)),
+                        "frequency_penalty": 0.2,
+                        "seed": seed_val,
+                        "stop": ["<|im_end|>", "<|im_start|>"],
+                        "stream": True,
+                    }
+                    if supports_soft_think:
+                        completion_kwargs["chat_template_kwargs"] = {
+                            "enable_thinking": current_enable_thinking,
+                            "thinking_mode": "enabled" if current_enable_thinking else "disabled",
+                        }
+                    completion_kwargs = _filter_kwargs_for_callable(getattr(llm, "create_chat_completion"), completion_kwargs)
+                    response = llm.create_chat_completion(**completion_kwargs)
                     for chunk in response:
+                        if abort_requested.is_set():
+                            return
                         result_queue.put(("chunk", chunk))
                     result_queue.put(("done", None))
                 except BaseException as exc:
@@ -748,28 +937,34 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                         except Exception:
                             abort_requested.set()
                             raise
-                        if full_text:
-                            if stream_display is not None:
-                                last_status_at = _maybe_emit_prompt_stream_heartbeat(stage_label, stage_started_at, last_status_at, full_text)
-                            else:
+                        if stream_display is None:
+                            if full_text:
                                 last_status_at = _maybe_emit_prompt_background_heartbeat(stage_label, stage_started_at, last_status_at, full_text)
-                        else:
-                            last_status_at = _maybe_emit_prompt_waiting_heartbeat(stage_label, stage_started_at, last_status_at)
+                            else:
+                                last_status_at = _maybe_emit_prompt_waiting_heartbeat(stage_label, stage_started_at, last_status_at)
                         continue
 
                     if kind == "chunk":
                         throw_exception_if_processing_interrupted()
                         chunk = payload if isinstance(payload, dict) else {}
-                        token = (
-                            chunk.get("choices", [{}])[0]
-                            .get("delta", {})
-                            .get("content", "")
-                        )
-                        if token:
-                            full_text += token
-                            if stream_display is not None:
-                                stream_display.push(token)
-                                last_status_at = _maybe_emit_prompt_stream_heartbeat(stage_label, stage_started_at, last_status_at, full_text)
+                        token = extract_stream_token(chunk)
+                        reasoning_token = token.get("reasoning", "")
+                        content_token = token.get("content", "")
+                        display_token = reasoning_token + content_token
+                        if reasoning_token:
+                            reasoning_text += reasoning_token
+                            full_text += reasoning_token
+                        if content_token:
+                            content_text += content_token
+                            full_text += content_token
+                        if display_token and stream_display is not None:
+                            try:
+                                degeneration_guard.push(display_token)
+                            except StreamDegenerationError as exc:
+                                stopped_for_degenerate_stream = exc.reason
+                                abort_requested.set()
+                                break
+                            stream_display.push_compact(display_token)
                         continue
 
                     if kind == "done":
@@ -786,19 +981,26 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                     _, _, clear_abort_callback = abort_callback_refs
                     clear_abort_callback()
                 if stream_display is not None:
+                    stream_display.end_compact()
                     stream_display.end_stage()
             if not full_text.strip():
                 raise RuntimeError("[QwenVL] llama_cpp streaming returned empty response")
-            return full_text.strip()
+            if stopped_for_degenerate_stream:
+                print(f"[QwenVL GGUF] stopped repeated-token loop: {stopped_for_degenerate_stream}")
+            if assistant_prefill and content_text.strip():
+                content_text = _merge_assistant_prefill(content_text, assistant_prefill)
+            separated_output = compose_streamed_model_output(reasoning_text, content_text)
+            return strip_degenerate_repetition(separated_output).strip()
 
         raw = _call(system_prompt, user_prompt, float(temperature), int(seed), initial_stage_label)
         cleaned = clean_model_output(raw, OutputCleanConfig(mode="prompt"))
         raw_trace_parts = [f"[{initial_stage_label}]\n{raw}"]
-        best_cleaned = cleaned.strip()
-        if _prompt_output_is_usable(best_cleaned):
+        best_cleaned = cleaned.strip() if _preset_output_is_usable(cleaned.strip(), preset_name) else ""
+        if best_cleaned:
             return best_cleaned, "\n\n".join(raw_trace_parts)
+        if not (auto_finalization_retry or is_video_preset):
+            return "", "\n\n".join(raw_trace_parts)
 
-        current_raw = raw
         for attempt_number in range(2, _PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS + 1):
             if stream_to_terminal:
                 print(
@@ -807,16 +1009,15 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                     "— prior output was empty or reasoning-only"
                 )
             retry_system = (
-                "You are a professional photography prompt writer.\n"
-                "Output ONLY ONE final photography prompt paragraph.\n"
-                "No analysis, no planning steps, no first-person, and no <think>.\n"
-                "No bullet points, no headings, no JSON, no markdown, no quotes."
+                f"{system_prompt}\n\n"
+                "The prior response did not contain final prompt text. "
+                "Return the final output again using exactly the schema, field order, tags, and constraints above. "
+                "Do not collapse structured output into one paragraph. Do not include analysis or <think>."
             )
             retry_user = (
-                "Rewrite the following into the final prompt paragraph:\n\n"
-                f"{current_raw}\n"
+                "Return the final prompt for this original user request. Preserve supported user facts and verbatim dialogue:\n\n"
+                f"{user_prompt}\n"
             )
-            force_non_thinking = attempt_number == _PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS
             stage_label = f"FINALIZATION ATTEMPT {attempt_number}/{_PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS}"
             raw_retry = _call(
                 retry_system,
@@ -824,23 +1025,23 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 0.4,
                 int(seed) + 999 + attempt_number,
                 stage_label,
-                attempt_enable_thinking=False if force_non_thinking else enable_thinking,
+                attempt_enable_thinking=False,
+                assistant_prefill=_video_assistant_prefill(preset_name),
             )
             raw_trace_parts.append(f"[{stage_label}]\n{raw_retry}")
             cleaned_retry = clean_model_output(raw_retry, OutputCleanConfig(mode="prompt")).strip()
-            if cleaned_retry and len(cleaned_retry) >= len(best_cleaned):
+            retry_is_usable = _preset_output_is_usable(cleaned_retry, preset_name)
+            if retry_is_usable and len(cleaned_retry) >= len(best_cleaned):
                 best_cleaned = cleaned_retry
-            if _prompt_output_is_usable(cleaned_retry):
+            if retry_is_usable:
                 return cleaned_retry, "\n\n".join(raw_trace_parts)
-            current_raw = raw_retry
-
         if stream_to_terminal:
             print(
                 "[QwenVL PromptEnhancer GGUF] "
                 f"Finalization limit reached ({_PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS}/{_PROMPT_ENHANCER_MAX_FINALIZATION_ATTEMPTS}) "
                 "— returning the best cleaned prompt available"
             )
-        return best_cleaned or "", "\n\n".join(raw_trace_parts)
+        return best_cleaned, "\n\n".join(raw_trace_parts)
 
     def process(
         self,
@@ -861,57 +1062,74 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
         unique_id=None,
         extra_pnginfo=None,
         enable_thinking=True,
+        auto_finalization_retry=False,
         hf_token="",
+        duration_seconds=5.0,
     ):
+        model_name = resolve_model_catalog_name(self.gguf_models.get("models") or {}, model_name)
         node_class = "ThinkingLLM_QwenVL_GGUF_PromptEnhancer"
+        resolved_duration = resolve_video_duration(preset_system_prompt, duration_seconds)
+        validate_minimax_source_duration(preset_system_prompt, duration_seconds, prompt_text)
+        is_minimax_preset = bool(resolved_duration and resolved_duration.get("provider") == "minimax_h3")
+        effective_english_output = bool(english_output and not is_minimax_preset)
+        effective_duration_seconds = resolved_duration["effective_seconds"] if resolved_duration else None
+        duration_signature = ({
+            "effective_duration_seconds": effective_duration_seconds,
+            "video_prompt_contract_version": resolved_duration.get("contract_version"),
+        } if resolved_duration else {})
         input_signature = build_node_input_signature(
             model_name=model_name,
             prompt_text=prompt_text,
             preset_system_prompt=preset_system_prompt,
             custom_system_prompt=custom_system_prompt,
-            english_output=bool(english_output),
+            english_output=effective_english_output,
             device=device,
             enable_thinking=bool(enable_thinking),
+            auto_finalization_retry=bool(auto_finalization_retry),
+            output_cleaner_version=OUTPUT_CLEANER_VERSION,
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
             repetition_penalty=repetition_penalty,
+            **duration_signature,
         )
 
         # Auto-retrieve saved prompt when seed is fixed (no keep_last_prompt needed)
         saved_prompt = get_node_saved_prompt_with_seed(node_class, unique_id, extra_pnginfo, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
         if saved_prompt and not stream_tokens_to_terminal:
-            print(f"[QwenVL PromptEnhancer GGUF] Fixed seed {seed} matched — using per-node prompt: {saved_prompt[:50]}...")
+            print(f"[QwenVL PromptEnhancer GGUF] Preset {preset_system_prompt}: fixed seed {seed} matched; no LLM call was made.")
             return (saved_prompt, "")
         if saved_prompt and stream_tokens_to_terminal:
-            print("[QwenVL PromptEnhancer GGUF] Streaming requested — bypassing fixed-seed prompt reuse for a fresh streamed run")
+            pass
         if keep_last_prompt:
-            print(f"[QwenVL PromptEnhancer GGUF] Keep last prompt enabled but no saved prompt found — returning empty")
+            print(f"[QwenVL PromptEnhancer GGUF] Preset {preset_system_prompt}: no saved prompt found; no LLM call was made.")
             return ("", "")
 
         # Always generate unless keep_last_prompt was requested
-        print(f"[QwenVL PromptEnhancer GGUF] Generating new prompt")
+        if not stream_tokens_to_terminal:
+            print(f"[QwenVL PromptEnhancer GGUF] Generating new prompt")
 
         # Generate cache key with all inputs including seed
         cache_prompt = "\n\n".join(
             part for part in (
                 prompt_text.strip(),
                 custom_system_prompt.strip(),
-                f"english_output={bool(english_output)}",
+                f"english_output={effective_english_output}",
+                f"output_cleaner_version={OUTPUT_CLEANER_VERSION}",
             ) if part
         )
-        cache_key = get_cache_key(model_name, preset_system_prompt, cache_prompt, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty)
+        cache_key = get_cache_key(model_name, preset_system_prompt, cache_prompt, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, enable_thinking=enable_thinking, effective_duration_seconds=effective_duration_seconds, video_prompt_contract_version=resolved_duration.get("contract_version") if resolved_duration else None)
 
         # Check cache first (only for random mode)
         if cache_key in PROMPT_CACHE and not stream_tokens_to_terminal:
             cached_text = PROMPT_CACHE[cache_key].get("text", "")
             if cached_text:
-                print(f"[QwenVL PromptEnhancer GGUF] Using cached prompt for seed {seed}: {cache_key[:8]}...")
+                print(f"[QwenVL PromptEnhancer GGUF] Preset {preset_system_prompt}: cache hit for seed {seed}; no LLM call was made.")
                 return (cached_text.strip(), "")
         if stream_tokens_to_terminal and cache_key in PROMPT_CACHE:
             cached_text = PROMPT_CACHE[cache_key].get("text", "")
             if cached_text:
-                print("[QwenVL PromptEnhancer GGUF] Streaming requested — bypassing prompt cache for a fresh streamed run")
+                pass
 
         is_custom_only = preset_system_prompt == CUSTOM_ONLY_STYLE
         style_entry = {} if is_custom_only else self.styles.get(preset_system_prompt, {})
@@ -923,20 +1141,34 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 raise ValueError("custom_system_prompt is required when using Custom Only (no preset).")
             raise ValueError("system_prompt is empty; check AILab_System_Prompts.json or preset selection.")
         system_prompt = f"{system_prompt}\n\n{prompt_output_guard()}"
+        system_prompt = apply_video_duration_context(system_prompt, preset_system_prompt, duration_seconds)
         merged_prompt = prompt_text.strip() or "Describe a scene vividly."
         model_cfg = self.gguf_models["models"].get(model_name, {})
         context_window = model_cfg.get("context_length", 32768)
         estimated_prompt_tokens = estimate_qwen_text_tokens(system_prompt, merged_prompt)
+        effective_context_window = _resolve_prompt_enhancer_context_length(context_window, estimated_prompt_tokens, max_tokens)
+        if resolved_duration:
+            effective_context_window = max(
+                effective_context_window,
+                min(int(context_window or 8192), 8192),
+            )
         effective_thinking = resolve_qwen_thinking_mode(
             enable_thinking,
             max_tokens,
             label="QwenVL PromptEnhancer GGUF",
             prompt_tokens=estimated_prompt_tokens,
-            context_window=context_window,
+            context_window=effective_context_window,
+            quiet=stream_tokens_to_terminal,
+        )
+        self._load_model(
+            model_name,
+            device,
+            enable_thinking=effective_thinking,
+            unique_id=unique_id,
+            hf_token=hf_token,
+            context_length_override=effective_context_window,
+            quiet=stream_tokens_to_terminal,
         )
-        if stream_tokens_to_terminal:
-            print("[QwenVL GGUF] Prompt enhancer terminal stream shows readable progress only; reasoning text may be hidden or stripped from the final prompt.")
-        self._load_model(model_name, device, enable_thinking=effective_thinking, unique_id=unique_id, hf_token=hf_token)
         hf_token = ""
         enhanced, raw_trace = self._invoke_llama(
             system_prompt=system_prompt,
@@ -949,14 +1181,11 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
             stream_to_terminal=stream_tokens_to_terminal,
             initial_stage_label="INITIAL GENERATION",
             enable_thinking=effective_thinking,
+            auto_finalization_retry=auto_finalization_retry,
+            preset_name=preset_system_prompt,
         )
-        if stream_tokens_to_terminal:
-            print(
-                f"[QwenVL GGUF] Thinking status: "
-                f"{_describe_prompt_enhancer_thinking(bool(enable_thinking), effective_thinking, raw_trace, retried='[FINALIZATION ATTEMPT ' in raw_trace)}"
-            )
         full_raw_trace = raw_trace
-        if english_output:
+        if effective_english_output:
             translated, trans_trace = self._invoke_llama(
                 system_prompt=(
                     PROMPT_CONFIG.get("translation_prompt")
@@ -972,11 +1201,19 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
                 stream_to_terminal=stream_tokens_to_terminal,
                 initial_stage_label="TRANSLATION STAGE",
                 enable_thinking=effective_thinking,
+                auto_finalization_retry=auto_finalization_retry,
+                preset_name=preset_system_prompt,
             )
             full_raw_trace = f"{raw_trace}\n\n{trans_trace}"
-            final = clean_model_output(translated, OutputCleanConfig(mode="prompt")) or translated.strip()
+            final = clean_model_output(translated, OutputCleanConfig(mode="prompt"))
         else:
-            final = clean_model_output(enhanced, OutputCleanConfig(mode="prompt")) or enhanced.strip()
+            final = clean_model_output(enhanced, OutputCleanConfig(mode="prompt"))
+        final = ensure_video_prompt_duration(
+            final,
+            preset_system_prompt,
+            duration_seconds,
+            source_prompt_text=prompt_text,
+        )
 
         # Cache the generated text
         PROMPT_CACHE[cache_key] = {
@@ -986,22 +1223,26 @@ class ThinkingLLM_QwenVL_GGUF_PromptEnhancer:
             "preset": preset_system_prompt,
             "seed": seed,
             "image_hash": None,
-            "video_hash": None
+            "video_hash": None,
+            **duration_signature,
         }
         save_prompt_cache()
 
-        print(f"[QwenVL PromptEnhancer GGUF] Cached new prompt for seed {seed}: {cache_key[:8]}...")
+        if not stream_tokens_to_terminal:
+            print(f"[QwenVL PromptEnhancer GGUF] Cached new prompt for seed {seed}: {cache_key[:8]}...")
 
         try:
             # Persist per-node for future keep_last_prompt=True
             set_node_saved_prompt(node_class, unique_id, extra_pnginfo, final, raw_trace=full_raw_trace, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
-            print(f"[QwenVL PromptEnhancer GGUF] Saved per-node prompt: {final[:50]}...")
+            if not stream_tokens_to_terminal:
+                print(f"[QwenVL PromptEnhancer GGUF] Saved per-node prompt: {final[:50]}...")
 
             return (final, full_raw_trace)
         finally:
             if not keep_model_loaded:
-                self.clear()
-                print(f"[QwenVL PromptEnhancer GGUF] keep_model_loaded=False — cleaning up model...")
+                self.clear(quiet=stream_tokens_to_terminal)
+                if not stream_tokens_to_terminal:
+                    print(f"[QwenVL PromptEnhancer GGUF] keep_model_loaded=False — cleaning up model...")
 
     @staticmethod
     def _is_english(text):

AILab_QwenVL_PromptEnhancer.py

@@ -8,6 +8,7 @@ import gc
 import hashlib
 import importlib
 import json
+import os
 import platform
 import re
 import time
@@ -19,35 +20,53 @@ import subprocess
 import sys
 from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer, BitsAndBytesConfig
 
-from AILab_OutputCleaner import OutputCleanConfig, clean_model_output, prompt_output_guard
+from AILab_OutputCleaner import OUTPUT_CLEANER_VERSION, OutputCleanConfig, clean_model_output, prompt_output_guard
 from AILab_StreamDisplay import TerminalStreamDisplay
 from comfy.model_management import throw_exception_if_processing_interrupted
 
-from AILab_QwenVL import (
+from thinkingllm_core.hf_models import (
     ATTENTION_MODES,
     HF_ALL_MODELS,
     HF_TEXT_MODELS,
     HF_VL_MODELS,
+    TOOLTIPS,
+    Quantization,
+    _default_model_from_config,
+    ensure_cuda_vram_headroom,
+    ensure_model,
+)
+from thinkingllm_core.hf_runtime import QwenVLBase
+from thinkingllm_core.model_access import (
+    model_catalog_label,
+    model_catalog_options,
+    resolve_model_catalog_name,
+)
+from thinkingllm_core.prompt_contracts import (
+    VIDEO_DURATION_INPUT,
+    apply_qwen_soft_thinking_directive,
+    apply_video_duration_context,
+    ensure_video_prompt_duration,
+    resolve_qwen_context_window,
+    resolve_qwen_thinking_mode,
+    resolve_video_duration,
+    validate_minimax_source_duration,
+)
+from thinkingllm_core.prompt_state import (
     NODE_PROMPT_STATE,
     PROMPT_CACHE,
     _make_node_state_key,
-    apply_qwen_soft_thinking_directive,
     build_node_input_signature,
-    ensure_model,
-    ensure_cuda_vram_headroom,
-    get_cache_key,
     get_alternative_cache_key,
+    get_cache_key,
     get_node_saved_prompt,
     get_node_saved_prompt_with_seed,
-    resolve_qwen_thinking_mode,
-    resolve_qwen_context_window,
+    log_llm_input,
     save_prompt_cache,
-    QwenVLBase,
-    Quantization,
     set_node_saved_prompt,
-    TOOLTIPS,
 )
 
+COMMERCIAL_RELEASE = os.environ.get("THINKINGLLM_COMMERCIAL_RELEASE") == "1"
+
 # DEPRECATED: per-node state via set_node_saved_prompt / get_node_saved_prompt is used instead.
 LAST_SAVED_PROMPT = None  # kept only to avoid ImportError in legacy importers
 
@@ -154,8 +173,9 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
 
     @classmethod
     def INPUT_TYPES(cls):
-        models = list(HF_ALL_MODELS.keys())
-        default_model = models[0] if models else "Qwen3-VL-4B-Instruct"
+        models = model_catalog_options(HF_ALL_MODELS)
+        default_model = _default_model_from_config(HF_ALL_MODELS, "Qwen3-VL-4B-Instruct")
+        default_model = model_catalog_label(default_model, HF_ALL_MODELS.get(default_model))
         styles = list(cls.STYLES.keys())
         preferred_style = "📝 Enhance"
         default_style = preferred_style if preferred_style in styles else (styles[0] if styles else "📝 Enhance")
@@ -176,11 +196,13 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
                 "keep_model_loaded": ("BOOLEAN", {"default": False, "tooltip": PROMPT_ENHANCER_TOOLTIPS["keep_model_loaded"]}),
                 "seed": ("INT", {"default": 1, "min": 1, "max": 2**32 - 1, "tooltip": PROMPT_ENHANCER_TOOLTIPS["seed"]}),
                 "keep_last_prompt": ("BOOLEAN", {"default": False, "tooltip": "Keep the last generated prompt instead of creating a new one"}),
-                "stream_tokens_to_terminal": ("BOOLEAN", {"default": False, "tooltip": "Show readable generation progress and thinking-status summaries in the ComfyUI terminal. When enabled, fixed-seed prompt reuse is bypassed so a fresh streamed run can occur."}),
+                "stream_tokens_to_terminal": ("BOOLEAN", {"default": False, "tooltip": "Show clean wrapped generated tokens in the ComfyUI terminal. When enabled, fixed-seed prompt reuse is bypassed so a fresh streamed run can occur."}),
                 "enable_thinking": ("BOOLEAN", {"default": True, "tooltip": "Enable model reasoning/thinking when the backend supports it: True=allow thinking, False=force direct answer. Even when enabled, easy prompts may still get a direct answer, and this node automatically disables thinking when there is not enough output budget left for useful reasoning. Prompt enhancers still return a cleaned final prompt, so terminal reasoning may be hidden or empty."}),
                 "hf_token": ("STRING", {"default": "", "multiline": False, "tooltip": TOOLTIPS["hf_token"]}),
-            }
-            ,
+            },
+            "optional": {
+                "duration_seconds": VIDEO_DURATION_INPUT,
+            },
             "hidden": {
                 "unique_id": "UNIQUE_ID",
                 "extra_pnginfo": "EXTRA_PNGINFO",
@@ -209,8 +231,17 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         extra_pnginfo=None,
         enable_thinking=True,
         hf_token="",
+        duration_seconds=5.0,
     ):
+        model_name = resolve_model_catalog_name(HF_ALL_MODELS, model_name)
         node_class = "ThinkingLLM_QwenVL_PromptEnhancer"
+        resolved_duration = resolve_video_duration(enhancement_style, duration_seconds)
+        validate_minimax_source_duration(enhancement_style, duration_seconds, prompt_text)
+        effective_duration_seconds = resolved_duration["effective_seconds"] if resolved_duration else None
+        duration_signature = ({
+            "effective_duration_seconds": effective_duration_seconds,
+            "video_prompt_contract_version": resolved_duration.get("contract_version"),
+        } if resolved_duration else {})
         input_signature = build_node_input_signature(
             model_name=model_name,
             quantization=quantization,
@@ -221,25 +252,28 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
             enhancement_style=enhancement_style,
             custom_system_prompt=custom_system_prompt,
             enable_thinking=bool(enable_thinking),
+            output_cleaner_version=OUTPUT_CLEANER_VERSION,
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
             repetition_penalty=repetition_penalty,
+            **duration_signature,
         )
 
         # Auto-retrieve saved prompt when seed is fixed (no keep_last_prompt needed)
         saved_prompt = get_node_saved_prompt_with_seed(node_class, unique_id, extra_pnginfo, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
         if saved_prompt and not stream_tokens_to_terminal:
-            print(f"[QwenVL PromptEnhancer HF] Fixed seed {seed} matched — using per-node prompt: {saved_prompt[:50]}...")
+            print(f"[QwenVL PromptEnhancer HF] Preset {enhancement_style}: fixed seed {seed} matched; no LLM call was made.")
             return (saved_prompt, "")
         if saved_prompt and stream_tokens_to_terminal:
-            print("[QwenVL PromptEnhancer HF] Streaming requested — bypassing fixed-seed prompt reuse for a fresh streamed run")
+            pass
         if keep_last_prompt:
             print(f"[QwenVL PromptEnhancer HF] Keep last prompt enabled but no saved prompt found — returning empty")
             return ("", "")
 
         # Always generate unless keep_last_prompt was requested
-        print(f"[QwenVL PromptEnhancer HF] Generating new prompt")
+        if not stream_tokens_to_terminal:
+            print(f"[QwenVL PromptEnhancer HF] Generating new prompt")
 
         is_custom_only = enhancement_style == CUSTOM_ONLY_STYLE
         style_instruction = "" if is_custom_only else self.STYLES.get(
@@ -254,6 +288,7 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         user_prompt = prompt_text.strip() or "Describe a scene vividly."
         merged_prompt = f"{user_prompt}\n\n{base_instruction}".strip()
         if model_name in HF_TEXT_MODELS:
+            merged_prompt = apply_video_duration_context(merged_prompt, enhancement_style, duration_seconds)
             enhanced, enhanced_raw = self._invoke_text(
                 model_name,
                 quantization,
@@ -269,6 +304,7 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
                 unique_id=unique_id,
                 enable_thinking=enable_thinking,
                 hf_token=hf_token,
+                preset_name=enhancement_style,
             )
             raw_trace = f"[HF TEXT GENERATION]\n{enhanced_raw}"
         else:
@@ -290,17 +326,25 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
                 extra_pnginfo=extra_pnginfo,
                 enable_thinking=enable_thinking,
                 hf_token=hf_token,
+                preset_name=enhancement_style,
+                duration_seconds=duration_seconds,
             )
             hf_token = ""
             key = _make_node_state_key(node_class, unique_id, extra_pnginfo)
             entry = NODE_PROMPT_STATE.get(key, {})
             raw_trace = entry.get("raw_trace", "") if isinstance(entry, dict) else ""
 
-        final = enhanced.strip()
+        final = ensure_video_prompt_duration(
+            enhanced.strip(),
+            enhancement_style,
+            duration_seconds,
+            source_prompt_text=prompt_text,
+        )
 
         # Persist per-node for future keep_last_prompt=True
         set_node_saved_prompt(node_class, unique_id, extra_pnginfo, final, raw_trace=raw_trace, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
-        print(f"[QwenVL PromptEnhancer HF] Saved per-node prompt: {final[:50]}...")
+        if not stream_tokens_to_terminal:
+            print(f"[QwenVL PromptEnhancer HF] Saved per-node prompt: {final[:50]}...")
 
         return (final, raw_trace)
 
@@ -323,6 +367,8 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         extra_pnginfo=None,
         enable_thinking=True,
         hf_token: str | None = None,
+        preset_name="",
+        duration_seconds=5.0,
     ):
         output = self.run(
             model_name=model_name,
@@ -348,10 +394,13 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
             stream_to_terminal=stream_to_terminal,
             enable_thinking=enable_thinking,
             hf_token=hf_token,
+            llm_input_preset_name=preset_name,
+            duration_seconds=duration_seconds,
         )
         return output[0]
 
     def _load_text_model(self, model_name, quantization, device_choice, unique_id=None, hf_token: str | None = None):
+        model_name = resolve_model_catalog_name(HF_TEXT_MODELS, model_name)
         info = HF_TEXT_MODELS.get(model_name, {})
         repo_id = info.get("repo_id")
         if not repo_id:
@@ -393,14 +442,17 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         self.text_tokenizer = None
         self.text_signature = None
 
-        load_kwargs = {}
+        load_kwargs = {"local_files_only": COMMERCIAL_RELEASE}
         if quant_cfg:
             load_kwargs["quantization_config"] = quant_cfg
         else:
             load_kwargs["torch_dtype"] = torch.float16 if device == "cuda" else torch.float32
 
         print(f"[QwenVL] Loading text model {model_name} ({quantization})")
-        tokenizer_kwargs = {"trust_remote_code": True}
+        tokenizer_kwargs = {
+            "local_files_only": COMMERCIAL_RELEASE,
+            "trust_remote_code": not COMMERCIAL_RELEASE,
+        }
 
         def _load_tokenizer(prefer_slow: bool = False):
             if prefers_processor:
@@ -418,6 +470,10 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         except ValueError as exc:
             message = str(exc)
             missing_backend = "sentencepiece or tiktoken" in message.lower()
+            if missing_backend and COMMERCIAL_RELEASE:
+                raise RuntimeError(
+                    "[QwenVL] Tokenizer backend is missing; commercial release mode forbids runtime package installation."
+                ) from exc
             if missing_backend:
                 print("[QwenVL] Tokenizer backend missing; installing sentencepiece and tiktoken into the active ComfyUI Python environment.")
                 install_cmd = [
@@ -450,7 +506,11 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
                     f"[QwenVL] Failed to load tokenizer for {repo_id}. "
                     f"Initial error: {exc}. Retry error: {retry_exc}"
                 ) from retry_exc
-        self.text_model = AutoModelForCausalLM.from_pretrained(model_source, trust_remote_code=True, **load_kwargs).eval()
+        self.text_model = AutoModelForCausalLM.from_pretrained(
+            model_source,
+            trust_remote_code=not COMMERCIAL_RELEASE,
+            **load_kwargs,
+        ).eval()
         self.text_model.to(device)
         ensure_cuda_vram_headroom("QwenVL PromptEnhancer HF", min_free_gb=1.0, min_free_ratio=0.08)
         # Detect architecture from loaded model config
@@ -478,6 +538,7 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         unique_id=None,
         enable_thinking=True,
         hf_token: str | None = None,
+        preset_name="",
     ):
         """Returns (cleaned_prompt, raw_generated_text) tuple."""
         self._load_text_model(model_name, quantization, device, unique_id=unique_id, hf_token=hf_token)
@@ -509,10 +570,10 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
             except Exception:
                 formatted_prompt = effective_prompt
             inputs = self.text_tokenizer(formatted_prompt, return_tensors="pt").to(device_choice)
-            return formatted_prompt, inputs
+            return effective_prompt, formatted_prompt, inputs
 
         requested_thinking = bool(enable_thinking)
-        _, inputs = _build_inputs(requested_thinking)
+        effective_prompt, formatted_prompt, inputs = _build_inputs(requested_thinking)
         input_ids = inputs.get("input_ids") if hasattr(inputs, "get") else None
         prompt_tokens = int(input_ids.shape[-1]) if torch.is_tensor(input_ids) else 0
         effective_thinking = resolve_qwen_thinking_mode(
@@ -521,19 +582,27 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
             label="QwenVL PromptEnhancer HF",
             prompt_tokens=prompt_tokens,
             context_window=context_window,
+            quiet=stream_to_terminal,
         )
         if effective_thinking != requested_thinking:
-            _, inputs = _build_inputs(effective_thinking)
+            effective_prompt, formatted_prompt, inputs = _build_inputs(effective_thinking)
 
-        if stream_to_terminal:
-            print("[QwenVL HF] Prompt enhancer terminal stream shows readable progress only; reasoning text may be hidden or stripped from the final prompt.")
+        log_llm_input(
+            "QwenVL PromptEnhancer HF",
+            "INITIAL GENERATION",
+            preset_name,
+            effective_prompt,
+            formatted_text=formatted_prompt,
+        )
 
         if is_qwen35 or supports_soft_think:
             if supports_soft_think:
                 directive = "/think" if effective_thinking else "/no_think"
-                print(f"[QwenVL] Qwen3 HF prompt enhancer: Thinking {'enabled' if effective_thinking else 'disabled'} via chat template and {directive}.")
+                if not stream_to_terminal:
+                    print(f"[QwenVL] Qwen3 HF prompt enhancer: Thinking {'enabled' if effective_thinking else 'disabled'} via chat template and {directive}.")
         else:
-            print(f"[QwenVL] Non-Qwen model in HF text path: thinking toggle is advisory (model may ignore).")
+            if not stream_to_terminal:
+                print(f"[QwenVL] Non-Qwen model in HF text path: thinking toggle is advisory (model may ignore).")
         gen_kwargs = {
             "max_new_tokens": max_tokens,
             "repetition_penalty": repetition_penalty,
@@ -555,31 +624,27 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
                 from transformers import TextIteratorStreamer
                 from threading import Thread
                 stage_label = "INITIAL GENERATION"
-                stream_display = TerminalStreamDisplay("QwenVL PromptEnhancer HF", suppress_planning=True, compact=False)
+                stream_display = TerminalStreamDisplay("QwenVL PromptEnhancer HF", suppress_planning=True, compact=True)
                 streamer = TextIteratorStreamer(self.text_tokenizer, skip_prompt=True, skip_special_tokens=True)
                 gen_kwargs["streamer"] = streamer
                 # Launch generation in a thread so we can iterate the streamer
                 import threading
                 thread = threading.Thread(target=self.text_model.generate, kwargs={**inputs, **gen_kwargs})
-                print(f"[QwenVL PromptEnhancer HF] STREAMING {stage_label}")
                 stream_display.start_stage(stage_label)
-                stage_started_at = time.monotonic()
-                last_status_at = stage_started_at
                 thread.start()
                 full_streamed = ""
                 for token_str in streamer:
                     if token_str:
                         throw_exception_if_processing_interrupted()
                         full_streamed += token_str
-                        stream_display.push(token_str)
-                        last_status_at = _maybe_emit_hf_prompt_stream_heartbeat(stage_label, stage_started_at, last_status_at, full_streamed)
+                        stream_display.push_compact(token_str)
                 thread.join()
+                stream_display.end_compact()
                 stream_display.end_stage()
                 if not full_streamed.strip():
                     raise RuntimeError("[QwenVL] HF streaming returned empty response")
                 raw_text = full_streamed.strip()
                 result = clean_model_output(raw_text, OutputCleanConfig(mode="prompt")) or raw_text
-                print(f"[QwenVL HF] Thinking status: {_describe_prompt_enhancer_thinking(requested_thinking, effective_thinking, raw_text)}")
                 if not keep_model_loaded:
                     self.text_model = None
                     self.text_processor = None
@@ -602,9 +667,6 @@ class ThinkingLLM_QwenVL_PromptEnhancer(QwenVLBase):
         raw_text = self.text_tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
         result = clean_model_output(raw_text, OutputCleanConfig(mode="prompt")) or raw_text
 
-        if stream_to_terminal:
-            print(f"[QwenVL HF] Thinking status: {_describe_prompt_enhancer_thinking(requested_thinking, effective_thinking, raw_text)}")
-
         if not keep_model_loaded:
             self.text_model = None
             self.text_processor = None

AILab_StreamDisplay.py

@@ -1,10 +1,37 @@
 import re
+import shutil
 import sys
 import time
 
 # ── Global singleton for live terminal streaming ──────────────────────────
 THINKING_STREAM_DISPLAY = None
 
+_TERMINAL_SAFE_PUNCTUATION = str.maketrans(
+    {
+        "\u2018": "'",
+        "\u2019": "'",
+        "\u201a": "'",
+        "\u201b": "'",
+        "\u201c": '"',
+        "\u201d": '"',
+        "\u201e": '"',
+        "\u201f": '"',
+        "\u2013": "-",
+        "\u2014": "--",
+        "\u2026": "...",
+        "\u00a0": " ",
+    }
+)
+
+
+def _terminal_safe_text(text: str) -> str:
+    """Keep streamed terminal text readable through legacy Windows code pages.
+
+    Only the display copy is normalized. The caller's generated text, cache,
+    RESPONSE, and RAW_TRACE retain the model's original Unicode characters.
+    """
+    return str(text or "").translate(_TERMINAL_SAFE_PUNCTUATION)
+
 
 def get_thinking_stream_display():
     """Return or create a compact-mode TerminalStreamDisplay for live
@@ -31,14 +58,159 @@ def reset_thinking_stream_display():
     THINKING_STREAM_DISPLAY = None
 
 
+# ── Shared chunk normalizer for OpenAI-style streamed responses ────────────
+
+def _get_stream_field(container, key: str, default=None):
+    if isinstance(container, dict):
+        return container.get(key, default)
+    return getattr(container, key, default)
+
+
+def _stream_value_to_text(value) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        return "".join(_stream_value_to_text(part) for part in value)
+    if isinstance(value, dict):
+        for key in ("text", "content", "reasoning_content", "reasoning", "thinking"):
+            text = _stream_value_to_text(value.get(key))
+            if text:
+                return text
+        return ""
+    return str(value)
+
+
+def _first_stream_text(containers, keys: tuple[str, ...]) -> str:
+    for container in containers:
+        if container is None:
+            continue
+        for key in keys:
+            text = _stream_value_to_text(_get_stream_field(container, key, None))
+            if text:
+                return text
+    return ""
+
+
+def extract_stream_token(chunk) -> dict[str, str]:
+    """Return a dict with 'reasoning' and 'content' keys from an OpenAI-style
+    streaming delta chunk.
+
+    Populates both fields from any supported field name so callers get reasoning
+    and answer text regardless of backend (llama.cpp, vLLM, HF, etc.).
+    Empty values are returned as empty strings.
+    """
+    choices = _get_stream_field(chunk, "choices", []) or []
+    choice = choices[0] if isinstance(choices, (list, tuple)) and choices else {}
+    delta = _get_stream_field(choice, "delta", {}) or {}
+    message = _get_stream_field(choice, "message", {}) or {}
+
+    containers = (delta, message, choice, chunk)
+    content = _first_stream_text(containers, ("content", "text", "output_text"))
+    reasoning = _first_stream_text(
+        containers,
+        ("reasoning_content", "thinking", "reasoning", "reasoning_text"),
+    )
+
+    return {"reasoning": reasoning, "content": content}
+
+
+def compose_streamed_model_output(reasoning_text: str, content_text: str) -> str:
+    """Preserve streamed channel boundaries for the output cleaner.
+
+    Some OpenAI-compatible GGUF backends send hidden reasoning through
+    ``reasoning_content`` without literal ``<think>`` tags.  Concatenating that
+    channel with ``content`` makes internal drafts look like part of RESPONSE.
+    Wrapping only the reasoning channel lets the existing cleaner remove it,
+    while RAW_TRACE still retains it for diagnostics.
+    """
+    reasoning = str(reasoning_text or "").strip()
+    content = str(content_text or "").strip()
+    if not reasoning:
+        return content
+    if not content:
+        return f"<think>\n{reasoning}\n</think>"
+    return f"<think>\n{reasoning}\n</think>\n\n{content}"
+
+
+class StreamDegenerationError(RuntimeError):
+    def __init__(self, reason: str):
+        super().__init__(reason)
+        self.reason = reason
+
+
+class StreamDegenerationGuard:
+    def __init__(self, repeated_word_limit: int = 8, repeated_ngram_limit: int = 8):
+        self.repeated_word_limit = max(4, int(repeated_word_limit))
+        self.repeated_ngram_limit = max(3, int(repeated_ngram_limit))
+        self._text = ""
+        self._words: list[str] = []
+
+    def push(self, text: str):
+        if not text:
+            return
+        self._text = (self._text + text)[-4096:]
+        words = [w.casefold() for w in re.findall(r"[A-Za-z][A-Za-z'\-]{2,}", self._text)]
+        if not words:
+            return
+        self._words = words[-256:]
+        reason = self._detect()
+        if reason:
+            raise StreamDegenerationError(reason)
+
+    def _detect(self) -> str:
+        if not self._words:
+            return ""
+        last_word = self._words[-1]
+        if len(last_word) >= 4:
+            run = 0
+            for word in reversed(self._words):
+                if word != last_word:
+                    break
+                run += 1
+            if run >= self.repeated_word_limit:
+                return f"repeated word '{last_word}' {run} times"
+
+        for size in range(2, 6):
+            needed = size * self.repeated_ngram_limit
+            if len(self._words) < needed:
+                continue
+            tail = self._words[-size:]
+            if all(self._words[-offset - size : -offset] == tail for offset in range(size, needed, size)):
+                return f"repeated {size}-word phrase {' '.join(tail)!r}"
+        return ""
+
+
+def strip_degenerate_repetition(text: str, repeated_word_limit: int = 8) -> str:
+    if not text:
+        return ""
+    matches = list(re.finditer(r"[A-Za-z][A-Za-z'\-]{2,}", text))
+    if not matches:
+        return text
+    last = matches[-1].group(0).casefold()
+    if len(last) < 4:
+        return text
+    run_start = len(matches) - 1
+    while run_start >= 0 and matches[run_start].group(0).casefold() == last:
+        run_start -= 1
+    run_count = len(matches) - run_start - 1
+    if run_count < repeated_word_limit:
+        return text
+    cut_at = matches[run_start + 1].start()
+    return text[:cut_at].rstrip(" \t\r\n,.;:!?")
+
+
 class TerminalStreamDisplay:
     """Buffered terminal display for streamed model output.
 
     Keeps the raw output accumulation in the caller, but renders only readable
     chunks to the terminal with stage headers and completion summaries.
 
-    When *compact* is True, token content is shown as a rolling 200-character
-    tail on a single line so older tokens scroll off naturally.
+    When *compact* is True, token content is printed as clean wrapped text
+    without node labels, carriage returns, or tail truncation.
     """
 
     _SENTENCE_BOUNDARY_RE = re.compile(r"[.!?](?:['\")\]]+)?(?:\s+|$)")
@@ -57,6 +229,7 @@ class TerminalStreamDisplay:
         flush_interval: float = 1.0,
         suppress_planning: bool = False,
         compact: bool = True,
+        line_width: int | None = None,
     ):
         self.label = label
         self.flush_chars = max(32, int(flush_chars))
@@ -72,6 +245,11 @@ class TerminalStreamDisplay:
         self._stage_updates = 0
         self._last_compact_emit_at = 0.0
         self._last_compact_tail = ""
+        self._compact_active = False
+        self._stream_pending_text = ""
+        self._stream_col = 0
+        self._stream_need_space = False
+        self._line_width_override = int(line_width) if line_width else None
 
     def start_stage(self, stage_name: str):
         self.end_stage()
@@ -79,6 +257,8 @@ class TerminalStreamDisplay:
         self._stage_started_at = time.monotonic()
         self._stage_chars = 0
         self._stage_updates = 0
+        if self.compact:
+            return
         self._write_line(f"[{self.label}] {stage_name}")
 
     def push(self, text: str):
@@ -112,9 +292,18 @@ class TerminalStreamDisplay:
         return re.sub(r"[ \t]+", " ", raw.replace("\r", "").replace("\n", " ")).strip()
 
     def end_stage(self):
-        self.flush(force=True)
+        if self._compact_active:
+            self.end_compact()
+        else:
+            self.flush(force=True)
         if not self._stage_name:
             return
+        if self.compact:
+            self._stage_name = None
+            self._stage_started_at = None
+            self._stage_chars = 0
+            self._stage_updates = 0
+            return
         elapsed = 0.0
         if self._stage_started_at is not None:
             elapsed = max(0.0, time.monotonic() - self._stage_started_at)
@@ -179,52 +368,91 @@ class TerminalStreamDisplay:
     def _write_line(self, text: str):
         if not text:
             return
-        msg = f"{text}\n"
+        msg = f"{_terminal_safe_text(text)}\n"
         sys.stdout.write(msg)
         sys.stdout.flush()
 
-    def _write_rolling_line(self, label: str, tail: str, final: bool = False):
-        """Emit a carriage-return line showing the last ~200 chars, clearing to EOL.
-        'final' adds a trailing newline so the last frame stays visible."""
-        if not tail:
-            return
-        msg = f"\r[{label}] {tail}\033[K"
-        sys.stdout.write(msg)
-        if final:
-            sys.stdout.write("\n")
-        sys.stdout.flush()
+    def _stream_line_width(self) -> int:
+        if self._line_width_override:
+            return max(24, self._line_width_override)
+        columns = shutil.get_terminal_size(fallback=(120, 24)).columns
+        return max(40, min(96, columns // 2))
 
-    def push_compact(self, text: str):
-        """Append *text* and emit a carriage-return rolling tail every throttle interval.
-
-        Uses \\r to redraw a single line so the terminal stays clean without
-        flooding the ComfyUI log buffer.
-        """
+    def _write_wrapped_stream_text(self, text: str):
         if not text:
             return
+        text = _terminal_safe_text(text)
+        width = self._stream_line_width()
+        for part in re.findall(r"\S+|\s+", text.replace("\r", "")):
+            if not part:
+                continue
+            if part.isspace():
+                newline_count = part.count("\n")
+                if newline_count:
+                    sys.stdout.write("\n" * newline_count)
+                    self._stream_col = 0
+                    self._stream_need_space = False
+                elif self._stream_col > 0:
+                    self._stream_need_space = True
+                continue
+
+            word = part
+            prefix = 1 if self._stream_need_space and self._stream_col > 0 else 0
+            if self._stream_col > 0 and self._stream_col + prefix + len(word) > width:
+                sys.stdout.write("\n")
+                self._stream_col = 0
+                prefix = 0
+            if prefix:
+                sys.stdout.write(" ")
+                self._stream_col += 1
+            sys.stdout.write(word)
+            self._stream_col += len(word)
+            self._stream_need_space = False
+        sys.stdout.flush()
+
+    def _drain_stream_pending(self, force: bool = False):
+        if not self._stream_pending_text:
+            return
+        text = self._stream_pending_text
+        if force:
+            emit = text
+            self._stream_pending_text = ""
+        else:
+            match = None
+            for match in re.finditer(r"\s+", text):
+                pass
+            if match is None:
+                if len(text) < self._stream_line_width():
+                    return
+                emit = text
+                self._stream_pending_text = ""
+            else:
+                end = match.end()
+                emit = text[:end]
+                self._stream_pending_text = text[end:]
+        self._write_wrapped_stream_text(emit)
+
+    def push_compact(self, text: str):
+        """Append *text* as clean wrapped terminal output without node prefixes."""
+        if not text:
+            return
+        self._compact_active = True
         self._stage_chars += len(text)
-        self._buffer += text
-        if len(self._buffer) > self.TAIL_LENGTH * 2:
-            self._buffer = self._buffer[-self.TAIL_LENGTH:]
-        tail = self._compact_tail()
-        now = time.monotonic()
-        should_emit = False
-        if tail and tail != self._last_compact_tail:
-            if self._last_compact_emit_at <= 0.0:
-                should_emit = len(self._buffer) >= self.min_chunk_chars
-            elif (now - self._last_compact_emit_at) >= self.flush_interval:
-                should_emit = True
-        if should_emit:
-            self._stage_updates += 1
-            self._last_compact_tail = tail
-            self._last_compact_emit_at = now
-            self._write_rolling_line(self.label, tail)
+        self._stage_updates += 1
+        self._stream_pending_text += text
+        self._drain_stream_pending(force=False)
 
     def end_compact(self):
         """Finish compact mode with one final newline-terminated snapshot."""
-        tail = self._compact_tail()
-        if tail and tail != self._last_compact_tail:
-            self._stage_updates += 1
+        had_pending = bool(self._stream_pending_text)
+        self._drain_stream_pending(force=True)
+        if (had_pending or self._stream_col > 0) and self._stage_chars:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
         self._last_compact_tail = ""
         self._last_compact_emit_at = 0.0
-        self._write_rolling_line(self.label, tail or "", final=True)
+        self._compact_active = False
+        self._buffer = ""
+        self._stream_pending_text = ""
+        self._stream_col = 0
+        self._stream_need_space = False

AILab_System_Prompts.json

@@ -1,6 +1,16 @@
 {
     "_preset_prompts": [
         "🚫 No preset (image-only)",
+        "💬 Custom prompt + image (no preset)",
+        "👁️ Remove (Mask Area)",
+        "🎦 LTX 2.3 NSFW I2V Scene",
+        "🎞️ LTX 2.3 First/Last-to-Video",
+        "🖼️ LTX 2.3 Reference-to-Video",
+        "🎬 MiniMax H3 Text-to-Video",
+        "🖼️ MiniMax H3 First-Frame-to-Video (I2VA)",
+        "🎞️ MiniMax H3 First/Last-to-Video (FL2VA)",
+        "🏁 MiniMax H3 Last-Frame-to-Video (L2VA)",
+        "🖼️ MiniMax H3 Reference-to-Video",
         "🍿 Wan 2.2 NSFW I2V Timeline (3s)",
         "🍿 Wan 2.2 NSFW I2V Timeline (5s)",
         "🎥 Wan 2.2 NSFW I2V Scene (3s)",
@@ -21,14 +31,173 @@
         "🖼️ Detailed Analysis",
         "📹 Video Summary"
     ],
+    "_video_presets": {
+        "📖 LTX 2.3 NSFW T2V Scene": {
+            "provider": "ltx_2_3",
+            "video_mode": "text-to-video",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One official chronological paragraph under 200 words."
+        },
+        "🎦 LTX 2.3 NSFW I2V Scene": {
+            "provider": "ltx_2_3",
+            "video_mode": "image-to-video",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One official chronological paragraph under 200 words."
+        },
+        "🎞️ LTX 2.3 First/Last-to-Video": {
+            "provider": "ltx_2_3",
+            "video_mode": "first-last-to-video",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One concise paragraph connecting the two boundary frames."
+        },
+        "🖼️ LTX 2.3 Reference-to-Video": {
+            "provider": "ltx_2_3",
+            "video_mode": "reference-to-video",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One paragraph with stable reference roles; for video references sample about 2 frames per source second, up to 64 frames."
+        },
+        "🎬 MiniMax H3 Text-to-Video": {
+            "provider": "minimax_h3",
+            "video_mode": "t2va",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Direct three-field Base prompt conversion with enough reserve for long source scripts."
+        },
+        "🖼️ MiniMax H3 First-Frame-to-Video (I2VA)": {
+            "provider": "minimax_h3",
+            "video_mode": "i2va",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Base prompt plus the official first-frame alignment line."
+        },
+        "🎞️ MiniMax H3 First/Last-to-Video (FL2VA)": {
+            "provider": "minimax_h3",
+            "video_mode": "fl2va",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Base prompt plus first/last-frame alignment."
+        },
+        "🏁 MiniMax H3 Last-Frame-to-Video (L2VA)": {
+            "provider": "minimax_h3",
+            "video_mode": "l2va",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Base prompt plus the official last-frame alignment line."
+        },
+        "🖼️ MiniMax H3 Reference-to-Video": {
+            "provider": "minimax_h3",
+            "video_mode": "ref2va",
+            "duration_required": true,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 3072 },
+            "recommendation_note": "Six-section Full-Reference output; for video references sample about 2 frames per source second, up to 64 frames."
+        },
+        "🍿 Wan 2.2 NSFW I2V Timeline (3s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 768 },
+            "recommendation_note": "A detailed second-by-second timeline of roughly 200–400 words."
+        },
+        "🍿 Wan 2.2 NSFW I2V Timeline (5s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 768 },
+            "recommendation_note": "A detailed second-by-second timeline of roughly 200–400 words."
+        },
+        "🎥 Wan 2.2 NSFW I2V Scene (3s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One short cinematic scene prompt."
+        },
+        "🎥 Wan 2.2 NSFW I2V Scene (5s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One short cinematic scene prompt."
+        },
+        "🎬 Wan 2.2 NSFW I2V Timeline (20s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Four detailed five-second timeline prompts with continuity."
+        },
+        "📖 Wan 2.2 NSFW I2V Scene (20s)": {
+            "provider": "wan_2_2",
+            "video_mode": "image-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 1536 },
+            "recommendation_note": "Four continuous five-second scene prompts."
+        },
+        "🍿 Wan 2.2 NSFW T2V Timeline (3s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 768 },
+            "recommendation_note": "A detailed second-by-second timeline."
+        },
+        "🍿 Wan 2.2 NSFW T2V Timeline (5s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 768 },
+            "recommendation_note": "A detailed second-by-second timeline."
+        },
+        "🎥 Wan 2.2 NSFW T2V Scene (3s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One short cinematic scene prompt."
+        },
+        "🎥 Wan 2.2 NSFW T2V Scene (5s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 512 },
+            "recommendation_note": "One short cinematic scene prompt."
+        },
+        "🎬 Wan 2.2 NSFW T2V Timeline (20s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-timeline",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 2048 },
+            "recommendation_note": "Four detailed five-second timeline prompts with continuity."
+        },
+        "📖 Wan 2.2 NSFW T2V Scene (20s)": {
+            "provider": "wan_2_2",
+            "video_mode": "text-to-video-scene",
+            "duration_required": false,
+            "recommended_settings": { "enable_thinking": false, "max_tokens": 1536 },
+            "recommendation_note": "Four continuous five-second scene prompts."
+        }
+    },
     "qwenvl": {
         "🚫 No preset (image-only)": "",
+        "💬 Custom prompt + image (no preset)": "",
+        "👁️ Remove (Mask Area)": "Create a positive diffusion/inpainting prompt describing what should naturally appear inside the selected normal-brightness region after it is repainted.\n\nDo not describe or preserve the region's current subject. Use the dimmed surrounding scene and the selection boundaries to infer the hidden background or the most natural replacement. Continue nearby surfaces and structures seamlessly, matching geometry, perspective, scale, materials, texture, patterns, color, lighting, shadows, reflections, depth of field, image style, and detail level.\n\nIf the user specifies replacement content, describe it positively and integrate it naturally into the surrounding scene. Otherwise, infer the most plausible continuation of the background. If the selected region crosses multiple surfaces, describe how each surface continues and connects.\n\nOutput only one concise, fluent diffusion prompt describing the desired final pixels. Do not mention removal, erasing, masks, selections, inpainting, editing, absence, or what was previously there. Do not describe unrelated parts of the image. No preface, labels, reasoning, instructions, or negative prompt.",
+        "🎦 LTX 2.3 NSFW I2V Scene": "You are an expert cinematic prompt director for LTX 2.3 image-to-video generation. Convert the user input and visual input into one fluent English cinematic prompt.\n\nRead the image first, then integrate the user text. The image first rule is mandatory: visual facts from the image have priority over contradictory user text. Describe the visible subject, setting, action, pose, camera angle, lens feel, lighting, color, texture, and environment before adding requested motion or story intent.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Write a single flowing paragraph of 120-200 words. Start directly with the main action. Include specific movements, gestures, object or character appearances, background details, camera movement, lighting behavior, and any sudden changes. Keep the prompt literal, precise, and usable for LTX 2.3. If the source contains NSFW adult content, describe it according to the user intent and visual evidence without adding unrelated content.\n\nOutput the enhanced prompt only. No headings, labels, notes, examples, markdown, or reasoning. Do not exceed 200 words.",
+        "🎞️ LTX 2.3 First/Last-to-Video": "You are an expert cinematic prompt director for LTX 2.3 first-and-last-frame video generation. Treat Picture 1 as the exact opening frame and Picture 2 as the exact final frame. Convert the user request and both visual anchors into one fluent English cinematic prompt that preserves visible identity, composition, wardrobe, props, environment, lighting, color, geometry, and style. Infer a plausible continuous transformation from the opening state to the final state without inventing cuts unless the user explicitly requests them.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep every action inside that total duration. Write one flowing paragraph of 120-200 words in chronological playback order. Begin with the opening action, describe subject and object motion, camera movement, environmental changes, timing and causal transitions, then converge precisely on Picture 2 at the end. Keep the language literal, visual, and optimized for LTX 2.3 motion. Adult content may be described only when present in the references or requested by the user.\n\nOutput only the paragraph. No headings, labels, timestamps, bullets, markdown, notes, or reasoning. Do not exceed 200 words.",
+        "🖼️ LTX 2.3 Reference-to-Video": "You are an expert cinematic prompt director for LTX 2.3 reference-to-video generation. Analyze every connected image or video and use the user's text to assign each reference a clear role such as subject identity, wardrobe, prop, environment, visual style, action, pose, or camera language. References are reusable visual anchors, not automatically first or last frames. Preserve the requested identities and stable visual attributes while composing one coherent new target scene.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Write one fluent English paragraph of 120-200 words in playback order, covering the opening composition, subject appearance and positions, actions and state changes, camera movement, environment, lighting, texture, and final visual state. Keep reference roles consistent and avoid unrelated additions. Adult content may be described only when present in the references or requested by the user.\n\nOutput only the paragraph. No headings, reference analysis, labels, bullets, markdown, notes, or reasoning. Do not exceed 200 words.",
+        "🎬 MiniMax H3 Text-to-Video": "You are a strict MiniMax H3 T2VA prompt formatter. Convert only the user's supplied facts into one production-ready English prompt that follows the official MiniMax H3 Base guide literally. Do not infer image roles and do not output analysis, markdown, notes, or alternatives.\n\nTARGET_DURATION_SECONDS is authoritative internal context. Use it to keep actions feasible and every cut timestamp strictly inside the effective duration. Never print TARGET_DURATION_SECONDS or a separate target-duration declaration. If the source is a longer multi-scene script, select one coherent contiguous moment that fits; do not compress the entire storyline into a rapid montage. You may omit scenes and dialogue outside the selected moment, but must not invent replacements.\n\nBegin directly with exactly these three fields, once each and in this order:\n\nintegrated_multimodal_description: [Shot 1] ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: ...\n\n[Shot 1] has no timestamp. Every later cut is sequential and uses exactly [Shot N] At MM:SS.mmm, followed by an explicit cut or transition that adds new information. Camera movement must use official natural phrasing: motion type, plus small or large amplitude and slow or fast speed only when meaningful; omit normal or medium values.\n\nEvery vocal source receives a stable (S1), (S2), or compound (S1,S2) ID before speech. Dialogue syntax uses literal square brackets around the actual language name, for example <d>[English] verbatim user dialogue</d>; all spoken words stay inside the tag. The selected moment may be visual-only. If dialogue is selected, every chosen block must remain complete, verbatim, and in source order. Never translate, rewrite, shorten, merge, or invent dialogue. Use <scenetrans> only for speech crossing a cut and <cutoff> only when the user explicitly requests truncated speech. Preserve visible text verbatim in double quotes.\n\nDo not add characters, props, reactions, cuts, ambience, sounds, or plot beats beyond explicit user facts and direct physical consequences of requested actions. overall_soundscape contains only supported ambience, physical sounds, and non-verbal human sounds, with no dialogue or music. If the user did not explicitly request audience-only background music, output non_diegetic_music: N/A. Return only the three-field prompt.",
+        "🖼️ MiniMax H3 First-Frame-to-Video (I2VA)": "You are a strict MiniMax H3 I2VA prompt formatter following the official Base guide. Treat the connected image as <Picture 1>, the exact first frame of [Shot 1], and develop forward from it without inventing unrelated content. TARGET_DURATION_SECONDS is internal context only; never print a target-duration declaration.\n\nThe final prompt begins with exactly: For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced. Leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and preserves the picture's identity, clothing, colors, objects, composition, geometry, lighting, and spatial relationships before describing the next visible action.\n\nLater cuts use [Shot N] At MM:SS.mmm, with strictly increasing times inside TARGET_DURATION_SECONDS. Use official camera-motion phrasing and valid speaker IDs and dialogue tags: the speaker (S1) says, <d>[Language] verbatim text</d>. Add no unsupported people, props, reactions, sounds, music, or plot beats. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+        "🎞️ MiniMax H3 First/Last-to-Video (FL2VA)": "You are a strict MiniMax H3 FL2VA prompt formatter following the official Base guide. Treat Picture 1 as the exact first frame and Picture 2 as the exact last frame. Prefer one continuous shot unless the user explicitly requests cuts, and describe only the observable path that connects both frames. TARGET_DURATION_SECONDS is internal context and supplies S.SS in the alignment line; never add a separate duration declaration.\n\nBegin with exactly: How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot N) aligns with the S.SS-second mark of the target video. Replace N with the actual final shot and S.SS with TARGET_DURATION_SECONDS, leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and describes first-frame state, observable intermediate changes, progressive convergence, and the exact last-frame state.\n\nUse official shot, timestamp, camera, speaker, and <d>[Language] verbatim text</d> syntax. Do not invent unsupported content. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+        "🏁 MiniMax H3 Last-Frame-to-Video (L2VA)": "You are a strict MiniMax H3 L2VA prompt formatter following the official Base guide. Treat <Picture 1> as the exact final frame belonging to the actual final [Shot N]. Infer only the minimum plausible preceding state needed to converge on that frame. TARGET_DURATION_SECONDS is internal context and supplies S.SS in the alignment line; never add a separate duration declaration.\n\nBegin with exactly: How the reference pictures align with the target video — <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video. Replace N with the actual final shot and S.SS with TARGET_DURATION_SECONDS, leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and describes a plausible preceding state, explicit transition path, gradual convergence, and exact landing on <Picture 1>.\n\nUse official shot, timestamp, camera, speaker, and <d>[Language] verbatim text</d> syntax. Do not invent unsupported content. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+        "🖼️ MiniMax H3 Reference-to-Video": "You are a strict MiniMax H3 full-reference Ref2VA prompt formatter. Follow the official Full-Reference guide literally and use only reference roles supported by the connected assets and user request. TARGET_DURATION_SECONDS is internal context only; use it to bound timestamps and never print a target-duration declaration. Output no analysis, markdown, notes, or alternatives.\n\nOutput exactly these six sections once each and in this order: subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, non_diegetic_music. subject_definitions gives each actually used <Subject N>, <Picture N>, <Video N>, and <Audio N> its own stable meaning. summary is one short paragraph beginning with an exact combination of [keyframe completion], [reference generation], [video editing], [video continuation], [audio reuse], or [audio reference]. retention_analysis gives every defined label one line using only fully_preserved, partially_preserved, attribute_transfer, weak_reference, fully_copy, partially_copy, or reference as appropriate.\n\ndetailed_description begins with one or two style sentences before [Shot 1], then gives the explicit shot-by-shot target timeline. Later cuts use [Shot N] At MM:SS.mmm, with strictly increasing times inside TARGET_DURATION_SECONDS. Cite reference labels where they actually take effect. Use official camera phrasing, stable speaker IDs, and exact dialogue syntax: <Subject N> (S1) says, <d>[Language] verbatim text</d>. Do not invent labels, dialogue, asset relationships, sounds, music, people, props, reactions, or plot beats. If no audience-only music role is explicitly requested or referenced, output non_diegetic_music: N/A. Return only the six-section prompt.",
         "🍿 Wan 2.2 NSFW I2V Timeline (3s)": "You are a system that converts user prompts from any language and visual inputs into optimized cinematic English descriptions for WAN 2.2 I2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Analyze the provided image or video to extract visual context (subjects, motion, lighting, style, environment).\n3. Combine both sources to create an English prompt optimized for video generation with WAN 2.2.\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the input image/video has stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; lighting and color with stylistic features; camera work and composition adapted to the style.\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- The description should be vivid and cinematic, suitable for high-quality video generation.\n- The output should be a single continuous paragraph with timeline markers for each second.\n- Focus on creating a visually rich and stylistically consistent scene.\n\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\nTechnical specifications:\n- Output length: approximately 200-400 words\n- Include specific details about subjects, actions, environment, lighting, and style elements\n- Maintain consistency with the requested visual style throughout the timeline\n- Ensure smooth transitions between each second of timeline",
         "🍿 Wan 2.2 NSFW I2V Timeline (5s)": "You are a system that converts user prompts from any language and visual inputs into optimized cinematic English descriptions for WAN 2.2 I2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Analyze the provided image or video to extract visual context (subjects, motion, lighting, style, environment).\n3. Combine both sources to create an English prompt optimized for video generation with WAN 2.2.\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the input image/video has stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; lighting and color with stylistic features; camera work and composition adapted to the style.\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- The description should be vivid and cinematic, suitable for high-quality video generation.\n- The output should be a single continuous paragraph with timeline markers for each second.\n- Focus on creating a visually rich and stylistically consistent scene.\n\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\nTechnical specifications:\n- Output length: approximately 200-400 words\n- Include specific details about subjects, actions, environment, lighting, and style elements\n- Maintain consistency with the requested visual style throughout the timeline\n- Ensure smooth transitions between each second of timeline",
-        "🎥 Wan 2.2 NSFW I2V Scene (3s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (3s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 6-10 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n- RECOMMENDED: Use max_tokens=512 or higher for complete output\n\nPERFORMANCE OPTIMIZATION:\n- Set context_length to 16384 or higher for better quality\n- Use image_max_tokens=2048 for detailed visual analysis\n- Set n_batch=256 for efficient processing\n- Temperature 0.7-0.8 for creative but coherent output\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
-        "🎥 Wan 2.2 NSFW I2V Scene (5s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (5s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n- RECOMMENDED: Use max_tokens=512 or higher for complete output\n\nPERFORMANCE OPTIMIZATION:\n- Set context_length to 16384 or higher for better quality\n- Use image_max_tokens=2048 for detailed visual analysis\n- Set n_batch=256 for efficient processing\n- Temperature 0.7-0.8 for creative but coherent output\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+        "🎥 Wan 2.2 NSFW I2V Scene (3s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (3s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 6-10 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+        "🎥 Wan 2.2 NSFW I2V Scene (5s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (5s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
         "🎬 Wan 2.2 NSFW I2V Timeline (20s)": "Convert user input + image into FOUR continuous 5-second WAN 2.2 prompts (20s total).\n\nCRITICAL RULES:\n1. MAINTAIN EXACT SAME STYLE: If image is anime → ALL prompts must be anime. If realistic → ALL prompts must be realistic. NEVER change style between prompts.\n\n2. MAINTAIN EXACT SAME CHARACTERS: If image shows 2 women + 1 man → ALL 4 prompts must show 2 women + 1 man. NEVER add/remove/change characters.\n\n3. MAINTAIN EXACT SAME SCENE: Keep the same environment, lighting, composition throughout all 4 prompts.\n\n4. TIMELINE STRUCTURE: Each prompt is 0-5 seconds, representing different moments in the 20-second sequence. MUST use EXACT format with parentheses:\n   - Prompt 1: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 2: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 3: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 4: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n\n5. SEPARATE WITH BLANK LINE: One blank line between each prompt.\n\n6. NO LABELS: DO NOT write \"Prompt 1:\", \"Prompt 2:\", \"Prompt 3:\", \"Prompt 4:\" at the beginning of each prompt. Start directly with the timeline markers.\n\n7. PARENTHESES REQUIRED: MUST use parentheses (At X seconds: ...) format. Do not omit parentheses.\n\n8. NSFW: When present, describe ALL content explicitly without censorship.\n\nNO EXCEPTIONS: Style, characters, and scene must remain IDENTICAL across all 4 prompts. Each prompt uses 0-5 second timeline structure with REQUIRED parentheses.",
-        "📖 Wan 2.2 NSFW I2V Scene (20s)": "Convert user input + image into EXACTLY FOUR continuous 5-second WAN 2.2 prompts (20s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected > photorealism\n- Photorealistic: realistic lighting, natural textures, lifelike details, and authentic motion\n- Anime: vibrant colors, simplified backgrounds, anime motion\n- Cartoon: bold outlines, flat colors, exaggerated expressions, and cartoon-style animation\n- 3D animation: 3D rendering characteristics, depth, lighting effects, and smooth 3D motion\n- Fantasy: magical elements, ethereal lighting, fantastical details, and imaginative atmosphere\n- Artistic portrait: painterly qualities, artistic brushwork, stylized composition, and creative interpretation\n\nCRITICAL FORMAT:\n- MUST generate EXACTLY FOUR separate prompts - NO MORE, NO LESS\n- Each prompt = 5 seconds of video (0-5s, 5-10s, 10-15s, 15-20s)\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- NO timeline markers like \"At X seconds:\"\n- Each prompt: 8-12 sentences for rich detail\n- Ensure narrative continuity between parts\n- DO NOT copy example text - generate original content\n- STOP after exactly FOUR prompts - do not generate additional content\n\nHARD ENFORCEMENT:\n- Count your output: MUST be exactly FOUR prompts separated by blank lines\n- If you generate FIVE or more prompts, you have failed the task\n- If you generate THREE or fewer prompts, you have failed the task\n- The structure must be: Prompt1[blank line]Prompt2[blank line]Prompt3[blank line]Prompt4\n- Nothing else after the FOURTH prompt\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- CRITICAL: Each prompt should flow naturally from the previous one. Avoid mechanical transition phrases, but maintain logical scene progression. Focus on seamless narrative flow.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n- RECOMMENDED: Use max_tokens=1024 or higher for complete output\n\nPERFORMANCE OPTIMIZATION:\n- Set context_length to 32768 or higher for better continuity\n- Use image_max_tokens=4096 for detailed visual analysis\n- Set n_batch=512 for efficient processing\n- Temperature 0.7-0.8 for creative but coherent output\n\nFINAL REMINDER: EXACTLY FOUR PROMPTS - NO EXCEPTIONS!",
+        "📖 Wan 2.2 NSFW I2V Scene (20s)": "Convert user input + image into EXACTLY FOUR continuous 5-second WAN 2.2 prompts (20s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected > photorealism\n- Photorealistic: realistic lighting, natural textures, lifelike details, and authentic motion\n- Anime: vibrant colors, simplified backgrounds, anime motion\n- Cartoon: bold outlines, flat colors, exaggerated expressions, and cartoon-style animation\n- 3D animation: 3D rendering characteristics, depth, lighting effects, and smooth 3D motion\n- Fantasy: magical elements, ethereal lighting, fantastical details, and imaginative atmosphere\n- Artistic portrait: painterly qualities, artistic brushwork, stylized composition, and creative interpretation\n\nCRITICAL FORMAT:\n- MUST generate EXACTLY FOUR separate prompts - NO MORE, NO LESS\n- Each prompt = 5 seconds of video (0-5s, 5-10s, 10-15s, 15-20s)\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- NO timeline markers like \"At X seconds:\"\n- Each prompt: 8-12 sentences for rich detail\n- Ensure narrative continuity between parts\n- DO NOT copy example text - generate original content\n- STOP after exactly FOUR prompts - do not generate additional content\n\nHARD ENFORCEMENT:\n- Count your output: MUST be exactly FOUR prompts separated by blank lines\n- If you generate FIVE or more prompts, you have failed the task\n- If you generate THREE or fewer prompts, you have failed the task\n- The structure must be: Prompt1[blank line]Prompt2[blank line]Prompt3[blank line]Prompt4\n- Nothing else after the FOURTH prompt\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- CRITICAL: Each prompt should flow naturally from the previous one. Avoid mechanical transition phrases, but maintain logical scene progression. Focus on seamless narrative flow.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nFINAL REMINDER: EXACTLY FOUR PROMPTS - NO EXCEPTIONS!",
         "🖼️ Tags": "Your task is to generate a clean list of comma-separated tags for a text-to-image AI, based *only* on visual information in the image. Limit the output to a maximum of 50 unique tags. Strictly describe visual elements like subject, clothing, environment, colors, lighting, and composition. Do not include abstract concepts, interpretations, marketing terms, or technical jargon (e.g., no 'SEO', 'brand-aligned', 'viral potential'). The goal is a concise list of visual descriptors. Avoid repeating tags.",
         "🖼️ Simple Description": "Analyze the image and write a single concise sentence that describes the main subject and setting. Keep it grounded in visible details only.",
         "🖼️ Detailed Description": "Write ONE detailed paragraph (6-10 sentences). Describe only what is visible: subject(s) and actions; people details if present (approx age group, gender expression if clear, hair, facial expression, pose, clothing, accessories); environment (location type, background elements, time cues); lighting (source, direction, softness/hardness, color temperature, shadows); camera viewpoint (eye-level/low/high, distance) and composition (framing, focal emphasis). No preface, no reasoning, no emojis.",
@@ -40,10 +209,16 @@
     "qwen_text": {
         "translation_prompt": "You are a professional prompt translator and prompt-preservation editor. Return a single fluent English paragraph (400-800 words). Preserve every visual, stylistic, compositional, lighting, camera, texture, mood, and action detail from the source. Do not summarize or simplify. No prefixes, bullets, JSON, headings, markdown, quotes, or commentary. Output only the translated/enhanced prompt paragraph.",
         "styles": {
-            "📖 Wan 2.2 NSFW T2V Scene (20s)": {
-                "system_prompt": "Generate 1 single T2V prompt for WAN 2.2 video generation (5s total) to establish initial scene.\n\nAPPROACH:\n- Single prompt: T2V (text-to-video) to create the opening scene\n- Establish characters, environment, and initial action\n- Rich cinematic description with style details\n- 8-12 sentences for comprehensive setup\n\nCRITICAL FORMAT:\n- Generate exactly 1 prompt only\n- No separation needed\n- NO labels like \"Prompt 1\", etc.\n- Focus on establishing the complete scene\n- Maintain consistent style\n\nSTYLE PRIORITY:\nUser-specified > detected > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Temperature 0.7-0.8 for creative output\n\nCRITICAL: Generate exactly 1 comprehensive T2V prompt to establish the scene."
+            "📖 LTX 2.3 NSFW T2V Scene": {
+                "system_prompt": "You are an expert cinematic prompt director for LTX 2.3 text-to-video generation. Convert the user input into one fluent English cinematic prompt.\n\nFocus on detailed, chronological descriptions of actions and scenes. Start directly with the main action, then add specific movements, gestures, character or object appearances, background and environmental details, camera angle, camera movement, lighting, colors, textures, and any sudden changes. Keep the result literal, precise, and optimized for LTX 2.3 motion.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Do not change the user input intent; enhance it. Preserve the requested subject, style, action, mood, and constraints. If the user input contains NSFW adult content, describe it according to the user intent without adding unrelated content.\n\nWrite a single flowing paragraph under 150 words. Output the enhanced prompt only. No headings, labels, notes, examples, markdown, or reasoning."
             },
-            "🍿 Wan 2.2 NSFW T2V Timeline (3)": {
+            "🎬 MiniMax H3 Text-to-Video": {
+                "system_prompt": "You are a strict MiniMax H3 T2VA prompt formatter. Convert only the user's supplied facts into one production-ready English prompt that follows the official MiniMax H3 Base guide literally. TARGET_DURATION_SECONDS is authoritative internal context used only to keep actions feasible and cut timestamps strictly inside the effective duration. Never print TARGET_DURATION_SECONDS or a separate target-duration declaration. If the source is a longer multi-scene script, select one coherent contiguous moment that fits; do not compress the full storyline into a rapid montage. Scenes and dialogue outside the selected moment may be omitted, but replacements must never be invented.\n\nBegin directly with exactly these three fields, once each and in this order:\n\nintegrated_multimodal_description: [Shot 1] ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: ...\n\n[Shot 1] has no timestamp. Every later cut uses exactly [Shot N] At MM:SS.mmm, with sequential shot numbers, strictly increasing times, and an explicit cut or transition that adds new information. Use official natural camera phrasing; add small or large amplitude and slow or fast speed only when meaningful, and omit normal or medium values.\n\nEvery vocal source receives a stable (S1), (S2), or compound (S1,S2) ID before speech. Dialogue uses literal square brackets around the actual language name, for example <d>[English] verbatim user dialogue</d>, with all spoken words inside the tag. The selected moment may be visual-only. If dialogue is selected, every chosen block must remain complete, verbatim, and in source order. Never translate, rewrite, shorten, merge, or invent dialogue. Use <scenetrans> only for speech crossing a cut and <cutoff> only when the user explicitly requests truncated speech. Preserve visible text verbatim in double quotes.\n\nDo not add characters, props, reactions, cuts, ambience, sounds, music, or plot beats beyond explicit user facts and direct physical consequences. overall_soundscape contains only supported ambience, physical sounds, and non-verbal human sounds, with no dialogue or music. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the three-field prompt with one blank line between fields."
+            },
+            "📖 Wan 2.2 NSFW T2V Scene (20s)": {
+                "system_prompt": "Convert user input into EXACTLY FOUR continuous 5-second WAN 2.2 text-to-video scene prompts (20 seconds total).\n\nCRITICAL FORMAT:\n- Output exactly four standalone English prompt paragraphs, no more and no less.\n- Each paragraph represents the next five-second clip.\n- Separate paragraphs with exactly one blank line.\n- Do not add labels, headings, timeline markers, notes, reasoning, or markdown.\n\nCONTINUITY:\n- Keep the same named characters, appearance, wardrobe, props, environment, lighting logic, visual style, and spatial relationships across all four clips unless the user explicitly requests a change.\n- Progress actions chronologically and causally from clip to clip without restarting the scene or repeating the same action.\n- Each paragraph should describe the visible opening state, subject motion, camera behavior, environmental response, and ending state of that clip.\n- The ending state of each clip must provide a plausible starting state for the next clip.\n- Preserve the user's facts and requested style; add only directly supporting cinematic detail.\n\nOUTPUT QUALITY:\n- Write 5-8 concise, visually concrete sentences per paragraph.\n- Use fluent, literal cinematic English suitable for WAN 2.2.\n- When adult content is explicitly requested, preserve the user's intent without unrelated additions.\n- Stop immediately after the fourth paragraph."
+            },
+            "🍿 Wan 2.2 NSFW T2V Timeline (3s)": {
                 "system_prompt": "You are a system that converts user prompts from any language into optimized cinematic English descriptions for WAN 2.2 T2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Create an English prompt optimized for video generation with WAN 2.2.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources actually present in the image, light quality as observed, time period if evident, shot types matching the image, composition types visible, lens specifications based on perspective, camera movements if present, color tone from the image. Do not invent or add lighting not present in the original image.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\")."
             },
             "🍿 Wan 2.2 NSFW T2V Timeline (5s)": {
@@ -53,10 +228,10 @@
                 "system_prompt": "Convert user input into 4 continuous 5-second WAN 2.2 prompts (20s total) using timeline structure.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Generate 4 separate prompts that maintain narrative and visual continuity.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Generate exactly 4 separate prompts, each with timeline structure\n- Each prompt: 5 seconds with timeline markers (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\")\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- CRITICAL CHARACTER CONTINUITY: Each prompt MUST maintain ALL characters and elements from previous prompt - DO NOT remove or change characters between prompts. If there are 2 people in prompt 1, there must be the SAME 2 people in prompts 2, 3, and 4. No character disappearance allowed. This is MANDATORY.\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources based on scene requirements, light quality as appropriate for the style, time period if evident, shot types matching the scene, composition types visible, lens specifications based on perspective, camera movements if present, color tone appropriate for the style.\n- Maintain consistent character appearance, color tone, lighting, background elements, and cinematic composition according to the requested style.\n- Include dynamic camera movement and ensure logical plot progression with style consistency.\n- WHEN there are NSFW content, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt"
             },
             "🎥 Wan 2.2 NSFW T2V Scene (3s)": {
-                "system_prompt": "Convert user input into 1 single cinematic WAN 2.2 prompt (3s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n- RECOMMENDED: Use max_tokens=512 or higher for complete output\n\nPERFORMANCE OPTIMIZATION:\n- Set context_length to 16384 or higher for better quality\n- Set n_batch=256 for efficient processing\n- Temperature 0.7-0.8 for creative but coherent output\n\nIMPORTANT: Generate actual cinematic prompt, not example text."
+                "system_prompt": "Convert user input into 1 single cinematic WAN 2.2 prompt (3s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text."
             },
             "🎥 Wan 2.2 NSFW T2V Scene (5s)": {
-                "system_prompt": "Convert user input into 1 single cinematic WAN 2.2 prompt (5s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n- RECOMMENDED: Use max_tokens=512 or higher for complete output\n\nPERFORMANCE OPTIMIZATION:\n- Set context_length to 16384 or higher for better quality\n- Set n_batch=256 for efficient processing\n- Temperature 0.7-0.8 for creative but coherent output\n\nIMPORTANT: Generate actual cinematic prompt, not example text."
+                "system_prompt": "Convert user input into 1 single cinematic WAN 2.2 prompt (5s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text."
             },
             "📝 Enhance": {
                 "system_prompt": "You are a senior cinematic photography prompt writer. Respond in the same language as the user input.\n\nWrite ONE final production-ready prompt paragraph (500-900 words) based on the user text. Expand the idea into a complete visual brief while preserving the user's intent.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- Do NOT output reasoning, planning, labels, notes, examples, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- Do NOT use <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nBuild the prompt with dense concrete detail: subject identity and visible traits, action or pose, wardrobe and materials, facial expression or body language, foreground/midground/background, environment and props, lighting source and direction, shadow behavior, color palette, textures, camera angle, shot size, focal length feel, depth of field, composition, mood, style, and final image quality.\n\nIf the input is short or ambiguous, infer tasteful supporting details that fit the scene, but do not contradict the user's stated content."

AILab_WhisperASR.py

@@ -0,0 +1,294 @@
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+import wave
+from pathlib import Path
+
+import numpy as np
+
+
+WHISPER_MODEL_CHOICES = [
+    "small",
+    "base",
+    "tiny",
+    "medium",
+    "large-v3",
+    "distil-large-v3",
+]
+
+WHISPER_LANGUAGE_CHOICES = [
+    "auto",
+    "en",
+    "de",
+    "fr",
+    "es",
+    "it",
+    "pt",
+    "nl",
+    "pl",
+    "tr",
+    "ja",
+    "ko",
+    "zh",
+]
+
+WHISPER_INSTALL_MESSAGE = (
+    "[ThinkingLLM Whisper ASR] faster-whisper is not installed in this ComfyUI Python. "
+    "Install it in the active ComfyUI Python with: python -m pip install faster-whisper"
+)
+
+
+def _clean_audio_file_path(audio_file_path) -> Path | None:
+    if audio_file_path is None:
+        return None
+    raw_path = str(audio_file_path).strip().strip("\"'")
+    if not raw_path:
+        return None
+    return Path(os.path.expandvars(raw_path)).expanduser()
+
+
+def _ffmpeg_path() -> str:
+    ffmpeg = shutil.which("ffmpeg")
+    if not ffmpeg:
+        raise RuntimeError("ffmpeg was not found on PATH; install FFmpeg or connect a decoded ComfyUI AUDIO input")
+    return ffmpeg
+
+
+def _decode_audio_file_to_wav(audio_file_path, target_path: Path) -> str:
+    source_path = _clean_audio_file_path(audio_file_path)
+    if source_path is None:
+        raise ValueError("audio_file_path is empty")
+    if not source_path.exists() or not source_path.is_file():
+        raise FileNotFoundError(f"audio_file_path does not exist or is not a file: {source_path}")
+
+    result = subprocess.run(
+        [
+            _ffmpeg_path(),
+            "-hide_banner",
+            "-v",
+            "error",
+            "-i",
+            str(source_path),
+            "-vn",
+            "-ac",
+            "1",
+            "-ar",
+            "16000",
+            "-acodec",
+            "pcm_s16le",
+            str(target_path),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg failed to decode audio_file_path: {result.stderr.strip() or 'unknown ffmpeg error'}")
+    return str(source_path)
+
+
+def _audio_to_wav_file(audio, target_path: Path) -> str:
+    if not isinstance(audio, dict):
+        raise ValueError("expected ComfyUI AUDIO dict with waveform/sample_rate")
+    waveform = audio.get("waveform")
+    if waveform is None:
+        raise ValueError("missing waveform")
+    sample_rate = int(audio.get("sample_rate") or 0)
+    if sample_rate <= 0:
+        raise ValueError(f"invalid sample_rate={audio.get('sample_rate')!r}")
+
+    tensor = waveform.detach().cpu() if hasattr(waveform, "detach") else waveform
+    tensor = tensor.cpu() if hasattr(tensor, "cpu") else tensor
+    array = tensor.numpy() if hasattr(tensor, "numpy") else np.asarray(tensor)
+    array = np.asarray(array, dtype=np.float32)
+    if array.size == 0:
+        raise ValueError("empty waveform")
+    if array.ndim == 3:
+        array = array[0]
+    if array.ndim == 1:
+        array = array[None, :]
+    if array.ndim != 2:
+        raise ValueError(f"unsupported waveform shape={getattr(array, 'shape', None)}")
+    if array.shape[0] > array.shape[-1]:
+        array = array.T
+    if not np.all(np.isfinite(array)):
+        array = np.nan_to_num(array, nan=0.0, posinf=1.0, neginf=-1.0)
+
+    mono = np.mean(array, axis=0).astype(np.float32)
+    if sample_rate != 16000:
+        target_length = max(1, int(round(float(mono.size) * 16000.0 / float(sample_rate))))
+        old_positions = np.linspace(0.0, float(mono.size - 1), num=mono.size, dtype=np.float64)
+        new_positions = np.linspace(0.0, float(mono.size - 1), num=target_length, dtype=np.float64)
+        mono = np.interp(new_positions, old_positions, mono).astype(np.float32)
+
+    pcm16 = (np.clip(mono, -1.0, 1.0) * 32767.0).astype(np.int16)
+    with wave.open(str(target_path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(16000)
+        wav.writeframes(pcm16.tobytes())
+    return "ComfyUI AUDIO input"
+
+
+def _resolve_whisper_device(device: str) -> str:
+    if device == "auto":
+        try:
+            import torch
+
+            return "cuda" if torch.cuda.is_available() else "cpu"
+        except Exception:
+            return "cpu"
+    return device
+
+
+def _resolve_compute_type(device: str, compute_type: str) -> str:
+    if compute_type != "auto":
+        return compute_type
+    return "float16" if device == "cuda" else "int8"
+
+
+def _missing_audio_result(notes: list[str] | None = None) -> tuple[str, str, str]:
+    message = (
+        "[ThinkingLLM Whisper ASR] No usable audio input. Connect a ComfyUI AUDIO output "
+        "or set audio_file_path to an existing M4A/MP3/WAV/FLAC file."
+    )
+    trace_lines = ["[AUDIO]", message]
+    if notes:
+        trace_lines.extend(str(note) for note in notes if note)
+    return message, "[]", "\n".join(trace_lines)
+
+
+def _is_local_whisper_cache_miss(exc: Exception) -> bool:
+    try:
+        from huggingface_hub.errors import LocalEntryNotFoundError
+
+        if isinstance(exc, LocalEntryNotFoundError):
+            return True
+    except Exception:
+        pass
+
+    message = str(exc or "").lower()
+    return "local_files_only" in message and "cached" in message
+
+
+class ThinkingLLM_Whisper_ASR:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_size": (WHISPER_MODEL_CHOICES, {"default": "small", "tooltip": "faster-whisper model size. small is a reliable Windows-friendly starting point; large-v3 is higher quality but downloads and runs much larger."}),
+                "language": (WHISPER_LANGUAGE_CHOICES, {"default": "auto", "tooltip": "Audio language. Use auto to let Whisper detect it."}),
+                "task": (["transcribe", "translate"], {"default": "transcribe", "tooltip": "transcribe preserves the original language; translate returns English."}),
+                "device": (["cpu", "auto", "cuda"], {"default": "cpu", "tooltip": "cpu is the most reliable Windows default; choose cuda when your faster-whisper/CTranslate2 CUDA runtime is working."}),
+                "compute_type": (["int8", "auto", "float16", "int8_float16", "float32"], {"default": "int8", "tooltip": "int8 is reliable on CPU. Use float16 or int8_float16 for CUDA."}),
+                "beam_size": ("INT", {"default": 5, "min": 1, "max": 10, "tooltip": "Higher values can improve accuracy but run slower."}),
+                "vad_filter": ("BOOLEAN", {"default": True, "tooltip": "Skip long silence and non-speech sections before transcription."}),
+            },
+            "optional": {
+                "audio": ("AUDIO",),
+                "audio_file_path": ("STRING", {"default": "", "multiline": False, "tooltip": "Optional local audio file path. M4A, MP3, WAV, FLAC, and other FFmpeg-readable files are decoded to 16 kHz mono WAV before Whisper."}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING")
+    RETURN_NAMES = ("TRANSCRIPT", "SEGMENTS_JSON", "RAW_TRACE")
+    FUNCTION = "process"
+    CATEGORY = "ThinkingLLM/Audio"
+
+    def process(
+        self,
+        model_size: str,
+        language: str,
+        task: str,
+        device: str,
+        compute_type: str,
+        beam_size: int,
+        vad_filter: bool,
+        audio=None,
+        audio_file_path="",
+    ):
+        notes: list[str] = []
+        clean_path = _clean_audio_file_path(audio_file_path)
+        if audio is None and clean_path is None:
+            return _missing_audio_result()
+
+        try:
+            from faster_whisper import WhisperModel
+        except Exception as exc:
+            trace = "\n".join(["[WHISPER]", WHISPER_INSTALL_MESSAGE, f"import_error={exc}"])
+            return WHISPER_INSTALL_MESSAGE, "[]", trace
+
+        with tempfile.TemporaryDirectory(prefix="thinkingllm-whisper-") as temp_dir:
+            wav_path = Path(temp_dir) / "audio.wav"
+            try:
+                if clean_path is not None:
+                    source_label = _decode_audio_file_to_wav(str(clean_path), wav_path)
+                else:
+                    source_label = _audio_to_wav_file(audio, wav_path)
+            except Exception as exc:
+                return _missing_audio_result([str(exc)])
+
+            resolved_device = _resolve_whisper_device(str(device))
+            resolved_compute_type = _resolve_compute_type(resolved_device, str(compute_type))
+            local_files_only = True
+            try:
+                model = WhisperModel(
+                    str(model_size),
+                    device=resolved_device,
+                    compute_type=resolved_compute_type,
+                    local_files_only=True,
+                )
+            except Exception as exc:
+                if not _is_local_whisper_cache_miss(exc):
+                    raise
+                notes.append("Local Whisper cache miss; downloaded model from Hugging Face once.")
+                local_files_only = False
+                model = WhisperModel(
+                    str(model_size),
+                    device=resolved_device,
+                    compute_type=resolved_compute_type,
+                    local_files_only=False,
+                )
+            segments_iter, info = model.transcribe(
+                str(wav_path),
+                language=None if language == "auto" else str(language),
+                task=str(task),
+                beam_size=int(beam_size),
+                vad_filter=bool(vad_filter),
+            )
+            segments = [
+                {
+                    "start": float(segment.start),
+                    "end": float(segment.end),
+                    "text": str(segment.text).strip(),
+                }
+                for segment in segments_iter
+            ]
+
+        transcript = "\n".join(segment["text"] for segment in segments if segment["text"]).strip()
+        segments_json = json.dumps(segments, ensure_ascii=False, indent=2)
+        detected_language = getattr(info, "language", None)
+        detected_probability = getattr(info, "language_probability", None)
+        duration = getattr(info, "duration", None)
+        trace = "\n".join(
+            [
+                "[WHISPER]",
+                f"source={source_label}",
+                f"model_size={model_size}; device={resolved_device}; compute_type={resolved_compute_type}; local_files_only={local_files_only}; task={task}; vad_filter={bool(vad_filter)}",
+                f"language={detected_language}; language_probability={detected_probability}; duration={duration}",
+                f"segments={len(segments)}; transcript_chars={len(transcript)}",
+                *notes,
+            ]
+        )
+        return transcript, segments_json, trace
+
+
+NODE_CLASS_MAPPINGS = {
+    "ThinkingLLM_Whisper_ASR": ThinkingLLM_Whisper_ASR,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ThinkingLLM_Whisper_ASR": "ThinkingLLM Whisper ASR",
+}

README.md

@@ -1,6 +1,6 @@
 # ComfyUI-ThinkingLLM
 
-**ThinkingLLM** is a local-LLM custom-node pack for [ComfyUI](https://github.com/comfyanonymous/ComfyUI) that wraps Qwen3.5, Qwen3, and Qwen2.5-VL models behind a cleaner node interface with thinking-mode control, live token streaming, and a raw trace output for debugging.
+**ThinkingLLM** is a local-LLM custom-node pack for [ComfyUI](https://github.com/comfyanonymous/ComfyUI) that wraps Qwen3.5, Qwen3, Qwen-VL, Gemma 4, and Whisper ASR behind a cleaner node interface with thinking-mode control, audio/vision workflows, live token streaming, and a raw trace output for debugging.
 
 📺 **[Watch the demo](https://youtu.be/K1JsvnzujOw)** for a better viewing experience.
 
@@ -13,6 +13,19 @@
 
 ## What ThinkingLLM adds
 
+### Model guidance box
+
+ThinkingLLM nodes add a read-only `recommended_settings` info box.
+
+- It explains the selected model family and recommended generation settings.
+- For every LTX 2.3, MiniMax H3, and Wan 2.2 video preset, it adds a preset-specific `enable_thinking` and `max_tokens` recommendation with a short reason.
+- Model sampling guidance and video-preset output budgets stay separate, so selecting a preset never replaces the selected model family's sampler advice.
+- It does not change your saved widget values.
+- For GGUF audio-capable nodes, it tells you whether the selected model actually supports audio.
+- In Advanced GGUF nodes, if you connect or expose audio for a model without known audio support, the box warns you instead of silently implying that audio will work.
+
+See [video preset settings](docs/VIDEO_PRESET_SETTINGS.md) for the complete recommendation table and source rationale.
+
 ### The Thinking Toggle
 
 Every ThinkingLLM node exposes an `enable_thinking` toggle.
@@ -40,6 +53,55 @@ Each node returns a second string output named `RAW_TRACE`.
 
 That makes it possible to inspect what the model thought about the prompt while still keeping the primary output clean.
 
+### Audio support
+
+Audio is available through dedicated nodes so the model list stays honest:
+
+- `ThinkingLLM Gemma 4 Audio (GGUF)` for Gemma 4 audio-capable models.
+- `ThinkingLLM Whisper ASR` for reliable speech-to-text transcription through `faster-whisper`.
+
+The Advanced GGUF node also exposes optional `audio`, but this is for power users. Use the info box before assuming a model can hear audio. Normal Qwen/Qwen-VL models are not audio models.
+
+### Mask-focused image analysis and object removal
+
+The four ThinkingLLM vision nodes accept an optional ComfyUI `MASK` input:
+
+- `ThinkingLLM`
+- `ThinkingLLM (Advanced)`
+- `ThinkingLLM (GGUF)`
+- `ThinkingLLM (GGUF Advanced)`
+
+White mask pixels select the area to analyze. Black pixels preserve surrounding context, and soft mask values create a gradual transition. ThinkingLLM keeps the selected area at normal brightness while dimming everything outside it, helping the vision model focus on the mask without losing the scene's geometry, lighting, or background context.
+
+#### Object-removal workflow
+
+1. Connect the source image to ThinkingLLM's `image` input.
+2. Connect the corresponding mask to its `mask` input.
+3. Select `👁️ Remove (Mask Area)` from `preset_prompt`.
+4. Optionally describe the desired replacement in `custom_prompt`, such as `continue the brick wall` or `fill with matching wooden floor`.
+5. Connect `RESPONSE` to the positive prompt input of your diffusion inpainting workflow.
+6. Send the original image and mask separately to the diffusion model's inpainting inputs.
+
+ThinkingLLM does not edit the image itself. It examines the masked area and surrounding scene, then generates a positive description of what should appear inside the mask. The downstream diffusion model performs the actual replacement.
+
+#### Previewing the LLM mask view
+
+`ThinkingLLM (Advanced)` and `ThinkingLLM (GGUF Advanced)` return a third output named `MASK_PREVIEW`. Connect it to a ComfyUI **Preview Image** node to inspect the exact highlighted image used for mask-focused analysis. The selected area remains at normal brightness and the surrounding scene is dimmed to 20%. When no mask is connected, the preview returns the original connected image.
+
+Without a custom instruction, the preset infers the most natural background continuation. It describes matching surfaces, perspective, materials, texture, color, lighting, shadows, reflections, and image style while avoiding phrases such as "remove the object" or "erase this area."
+
+Example output:
+
+> Continuous warm beige plaster wall with subtle uneven texture, matching the existing perspective, soft window illumination, natural tonal variation, and the floor-edge shadows.
+
+#### Notes and limitations
+
+- Masks apply to still images only, not video input.
+- Mask dimensions are resized automatically to match the image.
+- An empty mask or a mask without an image produces a clear error.
+- Image batches continue to use the first image and first mask.
+- Precise masks with a small amount of surrounding context generally produce the best reconstruction prompt.
+
 ## Nodes
 
 ### Transformers / HF nodes
@@ -54,24 +116,63 @@ The HF path is the most straightforward option for Windows and Linux when you wa
 
 HF tokenizer note: some Gemma and Qwen variants need `sentencepiece` or `tiktoken` available in the ComfyUI Python environment. ThinkingLLM now declares those dependencies and will attempt to install them automatically if a tokenizer backend is missing at first load.
 
+#### Shared ComfyUI text encoders
+
+Compatible single-file checkpoints already in `ComfyUI/models/text_encoders` appear in the model selector with a `[ComfyUI]` prefix. ThinkingLLM loads them through ComfyUI, so it does not download or duplicate a Transformers snapshot.
+
+- Qwen3-VL 4B and 8B `.safetensors`, including `qwen3vl_8b_fp8_scaled.safetensors`
+- Gemma 3 12B `.safetensors`, including `gemma-3-12b-it-heretic-v2_int8.safetensors`
+
+The MiniMax H3/Qwen3-VL 32B conditioning checkpoint is intentionally excluded because it is not a complete text-generation model. The valid SafeTensors extension is `.safetensors` (plural). ComfyUI-native generation supports one-beam sampling; terminal output is printed after generation rather than streamed token by token.
+
 ### GGUF / llama.cpp nodes
 
 - `ThinkingLLM (GGUF)`
 - `ThinkingLLM (GGUF Advanced)`
+- `ThinkingLLM Gemma 4 Audio (GGUF)`
 - `ThinkingLLM Prompt Enhancer (GGUF)`
 
-The GGUF path requires a vision-capable `llama-cpp-python` build. The normal PyPI package is not enough for Qwen vision handlers. On Linux, ThinkingLLM now auto-checks this at first GGUF use and attempts an automatic install of a matching JamePeng backend. Use the setup notes in [docs/LLAMA_CPP_PYTHON_VISION_INSTALL.md](docs/LLAMA_CPP_PYTHON_VISION_INSTALL.md) if you need to override the wheel/package source.
+The GGUF path requires a multimodal-capable `llama-cpp-python` build. The normal PyPI package may not include the chat handlers needed for Qwen vision, Gemma 4, or MTMD audio. On Linux, ThinkingLLM auto-checks this at first GGUF use and attempts an automatic install of a matching JamePeng backend. Use the setup notes in [docs/LLAMA_CPP_PYTHON_VISION_INSTALL.md](docs/LLAMA_CPP_PYTHON_VISION_INSTALL.md) if you need to override the wheel/package source.
 
 ## Workflow tips
 
 - **Pre-process input images** — use a resize or scale node before ThinkingLLM so large images don't blow up the context window.
 - **Display the output** — connect RESPONSE or ENHANCED_OUTPUT to a **Show Text** or **Show Anything** node to see the generated text in the UI.
 - **Inspect reasoning** — connect the RAW_TRACE output to a second Show Text node to see what the model was thinking.
+- **Use the dedicated audio nodes first** — Gemma 4 Audio is for audio understanding; Whisper ASR is for transcription. The Advanced GGUF audio input is intentionally more flexible, but the info box will warn you when the selected model has no curated audio support.
+
+### Duration-aware video prompts
+
+The four vision nodes and both Prompt Enhancer nodes expose an optional `duration_seconds` input. It becomes visible only for registered LTX 2.3 and MiniMax H3 video presets; all other presets ignore it. Connect the same requested duration value to ThinkingLLM and your downstream video generator so prompt timing and generated length stay aligned.
+
+- LTX 2.3 uses the requested value directly and returns one chronological paragraph with a natural total-duration phrase.
+- MiniMax H3 mirrors ComfyUI's 24 fps `17k+5` frame grid. For example, `5.0` seconds becomes 124 frames (`5.17` seconds), `8.0` stays 192 frames (`8.00` seconds), and `12.0` becomes 294 frames (`12.25` seconds). The effective duration is internal planning context: T2VA, I2VA, and full-reference outputs do not get an invented `Target duration:` field. FL2VA and L2VA use it only in the official image-alignment line.
+- The duration input overrides conflicting duration wording in the free prompt for duration-aware presets. Older saved nodes that do not contain the optional input use `5.0` seconds.
+
+See the [duration-aware video prompt guide](docs/VIDEO_PROMPT_DURATION.md) for node coverage, MiniMax frame normalization, Base and Full-Reference structures, cache behavior, best-effort normalization, and troubleshooting.
+
+For LTX, use `📖 LTX 2.3 NSFW T2V Scene` in a text Prompt Enhancer, or choose the matching I2V, First/Last-to-Video, or Reference-to-Video preset in a vision node. The First/Last preset treats the first two connected pictures as exact boundary frames; the Reference preset treats connected media as reusable identity, style, prop, environment, motion, or camera anchors.
+
+### MiniMax H3 prompt preset
+
+Select the dedicated T2VA, I2VA, FL2VA, L2VA, or Reference-to-Video preset that matches the connected media. Vision nodes expose all five formats; text-only Prompt Enhancer nodes expose only T2VA. The preset instructs the LLM to use the official three-field Base or six-section Full-Reference structure. After generation, ThinkingLLM only applies safe best-effort cleanup: it removes obsolete `Target duration:` declarations, normalizes recognizable cut timestamps, separates uniquely identifiable fields, and converts clear `<d>English ...</d>` variants to `<d>[English] ...</d>`. It does not reject the result when fields, speaker IDs, dialogue length, or timing remain imperfect.
+
+Standalone quoted dialogue blocks are presented to the LLM as verbatim source material. When the input is a longer master script, the preset asks the model to select one coherent moment that fits instead of compressing the complete story. The selected moment may be visual-only. This is prompt guidance, not a blocking post-generation validator; the downstream MiniMax pipeline receives the cleaned model output even if the model deviates slightly.
+
+For example, a 99-word multi-scene script with `duration_seconds=8.0` is valid input. ThinkingLLM selects one feasible short scene, with or without dialogue; it does not require all 99 dialogue words to play in eight seconds and does not compress the full narrative into rapid cuts.
+
+The effective duration remains authoritative planning context for the LLM. ThinkingLLM does not launch a schema-repair generation or block output because of an out-of-range timestamp, missing speaker tag, unexpected field, or estimated dialogue length; MiniMax performs its own downstream prompt interpretation. The only automatic retry is a direct finalization retry when generation ends before any usable final prompt, such as inside an unfinished `<think>` block.
+
+Reference-to-Video requires a custom prompt that describes the target video and assigns each reference a role such as identity, style, motion, camera, or voice. To animate one image as the first frame, use Text-to-Video instead. Start with `enable_thinking=false` and `max_tokens=2048` for Base formats or `max_tokens=3072` for Reference-to-Video. If a model still spends the initial budget inside an unfinished `<think>` block, ThinkingLLM discards that incomplete reasoning and automatically performs a direct schema-prefilled retry instead of forwarding it as the video prompt.
+
+See the official [MiniMax H3 ComfyUI workflows](https://docs.comfy.org/tutorials/video/minimax/minimax-h3), [base prompt guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md), and [full-reference prompt guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md).
 
 ## Supported models
 
 ThinkingLLM supports these model families out of the box, with pre-configured entries in `hf_models.json` and `gguf_models.json`.
 
+Commercial-release model dropdowns group entries by rights status and accept only reviewed, locked models. Community dropdowns keep their normal model names and download behavior; gated Hugging Face repositories still require the model owner's access terms and a read token.
+
 ### Qwen — Vision-language (HF)
 - Qwen3.5 4B / 9B
 - Qwen3-VL 4B / 8B (Instruct, abliterated, unredacted)
@@ -94,17 +195,36 @@ ThinkingLLM supports these model families out of the box, with pre-configured en
 ### Gemma 4 — Vision-language (HF)
 - Gemma-4-E2B-it / Uncensored
 - Gemma-4-E4B-it / Uncensored
+- Gemma-4-12B
 - Gemma-4-26B-A4B-it / Heretic
 - Gemma-4-31B-it
 
 ### Gemma 4 — Vision-language (GGUF)
 - Gemma-4-E2B / E4B (Q4 K M through BF16, uncensored)
+- Gemma-4-12B-it (Q4/Q5/Q6/Q8/BF16/UD-Q4)
 - Gemma-4-26B-A4B-it (Q4 K M through BF16)
 - Gemma-4-31B-it (Q4 K M through BF16)
 
+### Gemma 4 — Audio (GGUF)
+- Gemma-4-E2B / E4B when present in the GGUF multimodal catalog
+- Gemma-4-12B-it via `unsloth/gemma-4-12b-it-GGUF`
+
+Use `ThinkingLLM Gemma 4 Audio (GGUF)` for the clean audio-only interface. Gemma 4 audio currently depends on a recent multimodal `llama-cpp-python`/`Gemma4ChatHandler` build, so check `RAW_TRACE` if audio behaves unexpectedly.
+
+### Whisper — ASR
+- tiny
+- base
+- small
+- medium
+- large-v3
+- distil-large-v3
+
+Use `ThinkingLLM Whisper ASR` for transcription. It accepts a connected ComfyUI `AUDIO` input or an `audio_file_path` pointing to M4A, MP3, WAV, FLAC, or any FFmpeg-readable audio file. The node uses `faster-whisper`; first use may download the selected Whisper model into the Hugging Face cache. The default is `small` on CPU with `int8`, which is slower than CUDA but reliable on Windows; switch to CUDA once the local CTranslate2 CUDA runtime is confirmed working.
+
 ### Gemma 4 — Text-only (HF)
 - Gemma-4-E2B-it / Uncensored
 - Gemma-4-E4B-it / Uncensored
+- Gemma-4-12B
 - Gemma-4-26B-A4B-it / Heretic
 - Gemma-4-31B-it
 
@@ -141,9 +261,15 @@ For local GGUF models, keep the matching mmproj file beside the model file.
 - HF is the recommended default path and is the simplest cross-platform option.
 - GGUF on Windows needs a matching `win_amd64` vision-capable wheel.
 - GGUF on Linux now auto-installs a matching backend on first use when possible. Override with `THINKINGLLM_LLAMA_CPP_LINUX_WHEEL_URL` or `THINKINGLLM_LLAMA_CPP_LINUX_SPEC` when your server needs a different build.
+- GGUF audio needs an audio-capable multimodal backend. `Gemma4ChatHandler` is used for Gemma 4.
+- Whisper ASR needs `faster-whisper` and FFmpeg. The node returns an install hint if `faster-whisper` is missing.
 - Flash Attention support is best on Linux. The nodes fall back when it is unavailable.
 - The thinking toggle works best with Qwen3.5 and Qwen3 style models. Other architectures may ignore the steering.
 
+## Production deployment
+
+This repository provides ComfyUI nodes, not a complete production runtime. If you plan to expose a workflow through an API on RunPod Serverless, review the dependency, validation, testing, and rollback requirements in the [ComfyUI on RunPod production-readiness checklist](https://comfyrail.dev/production-readiness).
+
 ## FAQ
 
 **Why does the node sometimes answer quickly and sometimes take longer?**

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,31 @@
+# Third-party source and commercial release notice
+
+ComfyUI-ThinkingLLM is distributed under GPL-3.0. Its README and source headers
+credit this fork lineage:
+
+- https://github.com/Deaquay/ComfyUI-Qwen3.5-Uncensored
+- https://github.com/huchukato/ComfyUI-QwenVL-Mod
+- https://github.com/1038lab/ComfyUI-QwenVL
+
+The repository history begins with root commit
+`0ca0d2448c6445a1addf87a55bde2308244380a2` and does not record the exact
+upstream revisions used for the inherited files. The inherited source remains
+under GPL-3.0; this notice does not replace its copyright notices.
+
+The Comfy Rail commercial release pins an exact commit from this repository,
+recorded in Comfy Rail's custom-node lock. Commercial release mode limits the
+runtime to the locally installed, release-locked Apache-2.0 models below and
+disables runtime downloads, runtime package installation, remote model code,
+GGUF, and Whisper registration:
+
+- `Qwen/Qwen3-4B-Instruct-2507` at `cdbee75f17c01a7cc42f958dc650907174af0554`
+- `Qwen/Qwen3-VL-4B-Instruct` at `ebb281ec70b05090aa6165b016eac8ec08e71b17`
+
+The exact GPL-3.0 source and its modification notices must be provided together
+with distributed commercial images.
+
+Catalog status labels are operational safeguards, not legal advice or a model
+license grant. External/gated models remain subject to their Hugging Face access
+terms, and rights-unclear weights are neither shipped nor automatically fetched
+by commercial Comfy Rail releases. Only catalog entries marked `cleared`, pinned by full revision and
+component ID, are eligible for the locked commercial runtime.

__init__.py

@@ -3,7 +3,7 @@
     "name": "ComfyUI-ThinkingLLM",
     "description": "A multimodal ComfyUI AI node with Qwen3.5, Qwen3-VL, Qwen2.5-VL, Qwen3, and Gemma 4 integrations. Features live thinking in the terminal to see what the LLM is doing in real time.",
     "author": "goodguy1963",
-    "version": "2.3.0",
+    "version": "2.4.0",
     "url": "https://github.com/goodguy1963/ComfyUI-ThinkingLLM",
     "category": "image"
 }
@@ -19,7 +19,32 @@ sys.path.insert(0, current_dir)
 
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
-WEB_DIRECTORY = "./web"
+COMMERCIAL_RELEASE = os.environ.get("THINKINGLLM_COMMERCIAL_RELEASE") == "1"
+WEB_DIRECTORY = None if COMMERCIAL_RELEASE else "./web"
+COMMERCIAL_MODULES = {
+    "AILab_OutputCleaner",
+    "AILab_QwenVL",
+    "AILab_QwenVL_PromptEnhancer",
+    "AILab_StreamDisplay",
+}
+COMMERCIAL_NODE_MODULES = {
+    "story_split_node",
+    "system_prompt_preset",
+    "vram_cleanup",
+}
+
+LEGACY_NODE_REPLACEMENTS = {
+    "AILab_QwenVL": "ThinkingLLM_QwenVL",
+    "AILab_QwenVL_Advanced": "ThinkingLLM_QwenVL_Advanced",
+    "AILab_QwenVL_GGUF": "ThinkingLLM_QwenVL_GGUF",
+    "AILab_QwenVL_GGUF_Advanced": "ThinkingLLM_QwenVL_GGUF_Advanced",
+    "AILab_QwenVL_PromptEnhancer": "ThinkingLLM_QwenVL_PromptEnhancer",
+    "AILab_QwenVL_GGUF_PromptEnhancer": "ThinkingLLM_QwenVL_GGUF_PromptEnhancer",
+}
+if COMMERCIAL_RELEASE:
+    LEGACY_NODE_REPLACEMENTS = {
+        old: new for old, new in LEGACY_NODE_REPLACEMENTS.items() if "GGUF" not in old
+    }
 
 def load_modules_from_directory(directory):
     for file in os.listdir(directory):
@@ -28,6 +53,14 @@ def load_modules_from_directory(directory):
             module_name = os.path.basename(file)[:-3]
             if module_name == os.path.basename(__file__)[:-3]:
                 continue
+            if COMMERCIAL_RELEASE:
+                allowed = (
+                    COMMERCIAL_MODULES
+                    if os.path.abspath(directory) == os.path.abspath(current_dir)
+                    else COMMERCIAL_NODE_MODULES
+                )
+                if module_name not in allowed:
+                    continue
 
             try:
                 spec = importlib.util.spec_from_file_location(module_name, file_path)
@@ -50,10 +83,34 @@ load_modules_from_directory(current_dir)
 nodes_dir = os.path.join(current_dir, "nodes")
 if os.path.exists(nodes_dir):
     load_modules_from_directory(nodes_dir)
+
+for legacy_node_name in LEGACY_NODE_REPLACEMENTS:
+    NODE_CLASS_MAPPINGS.pop(legacy_node_name, None)
+    NODE_DISPLAY_NAME_MAPPINGS.pop(legacy_node_name, None)
+
+
+def _register_legacy_node_replacements():
+    try:
+        from comfy_api.latest._io import NodeReplace
+        from server import PromptServer
+    except Exception:
+        return
+
+    manager = getattr(getattr(PromptServer, "instance", None), "node_replace_manager", None)
+    if manager is None:
+        return
+
+    for old_node_id, new_node_id in LEGACY_NODE_REPLACEMENTS.items():
+        manager.register(NodeReplace(new_node_id=new_node_id, old_node_id=old_node_id))
+
+
+_register_legacy_node_replacements()
+
 NODE_CLASS_MAPPINGS = dict(sorted(NODE_CLASS_MAPPINGS.items(), key=lambda x: NODE_DISPLAY_NAME_MAPPINGS.get(x[0], x[0])))
 NODE_DISPLAY_NAME_MAPPINGS = dict(sorted(NODE_DISPLAY_NAME_MAPPINGS.items(), key=lambda x: x[1]))
 
 __all__ = [
     "NODE_CLASS_MAPPINGS",
-    "NODE_DISPLAY_NAME_MAPPINGS"
-]
+    "NODE_DISPLAY_NAME_MAPPINGS",
+    "LEGACY_NODE_REPLACEMENTS",
+]

custom_nodes.json

@@ -9,5 +9,5 @@
   "description": "A multimodal ComfyUI AI node with Qwen3.5, Qwen3-VL, Qwen2.5-VL, Qwen3, and Gemma 4 integrations. Features live thinking in the terminal to see what the LLM is doing in real time.",
   "category": "image",
   "tags": ["vision", "language", "multimodal", "thinkingllm", "qwen", "gguf", "flash_attention", "performance", "wan2.2", "video", "i2v", "t2v", "storyboard", "caching", "fork", "gpl-3.0"],
-  "version": "2.3.0"
+  "version": "2.4.0"
 }

docs/VIDEO_PRESET_SETTINGS.md

@@ -0,0 +1,51 @@
+# Video preset settings
+
+ThinkingLLM shows two independent recommendation blocks in the read-only `recommended_settings` info box:
+
+1. The selected model family's sampler guidance.
+2. The selected video preset's output budget and thinking-mode guidance.
+
+The info box never changes saved widget values. Preset guidance is centrally defined in `AILab_System_Prompts.json` and mirrored to the web payload used by ComfyUI.
+
+## Preset recommendations
+
+| Preset family | `enable_thinking` | `max_tokens` |
+| --- | ---: | ---: |
+| LTX 2.3 T2V, I2V, First/Last, Reference | `false` | 512 |
+| MiniMax H3 T2VA, I2VA, FL2VA, L2VA | `false` | 2048 |
+| MiniMax H3 Full Reference | `false` | 3072 |
+| Wan 2.2 Scene 3s/5s, T2V and I2V | `false` | 512 |
+| Wan 2.2 Timeline 3s/5s, T2V and I2V | `false` | 768 |
+| Wan 2.2 Scene 20s, T2V and I2V | `false` | 1536 |
+| Wan 2.2 Timeline 20s, T2V and I2V | `false` | 2048 |
+
+Thinking is disabled in these recommendations because the selected system prompts already define the planning and output format. Direct generation is faster and less likely to spend the output budget on a reasoning trace or deviate from the requested final structure.
+
+The token budgets are upper bounds for the expected final format rather than settings from the downstream video generator. Increase the budget only when a useful final prompt is genuinely truncated.
+
+## Sampling settings
+
+Temperature, `top_p`, `top_k`, and repetition penalties remain model- and input-mode recommendations:
+
+- Qwen3/Qwen3.5 vision input generally uses `temperature=0.7`, `top_p=0.8`, `top_k=20`, and `repetition_penalty=1.0`.
+- Text-only input follows the selected model card. Qwen3.5 uses `temperature=1.0`, `top_p=1.0`, `top_k=20`, and `repetition_penalty=1.0`; Qwen3-VL Instruct uses `temperature=1.0`, `top_p=1.0`, `top_k=40`, and `repetition_penalty=1.0`.
+- Widgets not exposed by the selected node are omitted from the info box summary.
+
+For a connected reference video, begin around two sampled frames per source second and stay within the node's 64-frame limit. Image-only presets do not need a `frame_count` recommendation.
+
+## Format rationale
+
+- LTX requests one literal chronological paragraph under 200 words, so 512 output tokens provide sufficient headroom.
+- MiniMax Base uses three structured fields; Full Reference uses six sections and needs a larger budget.
+- Wan single-scene prompts fit within 512 tokens. Timeline formats and four-part 20-second sequences need progressively larger budgets to avoid truncation.
+
+Runtime-setting instructions such as `max_tokens`, context length, batch size, and temperature are kept out of the system prompts themselves. They belong in the info box and must not become part of the generated video prompt.
+
+## Official references
+
+- [Qwen3-VL 4B Instruct generation hyperparameters](https://huggingface.co/Qwen/Qwen3-VL-4B-Instruct)
+- [Qwen3.5 sampling recommendations](https://huggingface.co/Qwen/Qwen3.5-2B)
+- [LTX-2 prompting guide](https://github.com/Lightricks/LTX-2/blob/main/README.md#%EF%B8%8F-prompting-for-ltx-2)
+- [MiniMax H3 Base prompt guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md)
+- [MiniMax H3 Full-Reference prompt guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md)
+- [Wan 2.2 prompt extension](https://github.com/Wan-Video/Wan2.2#2-using-prompt-extention)

docs/VIDEO_PROMPT_DURATION.md

@@ -0,0 +1,117 @@
+# Duration-aware video prompts
+
+ThinkingLLM can make LTX 2.3 and MiniMax H3 prompts match the duration configured in the downstream video generator. The duration affects prompt planning and best-effort formatting only; ThinkingLLM does not change the generator's own frame or length setting.
+
+## Supported nodes
+
+The optional `duration_seconds` input is available on:
+
+- `ThinkingLLM`
+- `ThinkingLLM (Advanced)`
+- `ThinkingLLM (GGUF)`
+- `ThinkingLLM (GGUF Advanced)`
+- `ThinkingLLM Prompt Enhancer`
+- `ThinkingLLM Prompt Enhancer (GGUF)`
+
+The widget is shown only for registered LTX 2.3 and MiniMax H3 video presets. It remains hidden and has no effect for image, analysis, tagging, and other non-video presets. Older workflows without the input use `5.0` seconds for a duration-aware preset.
+
+Connect the same requested duration to ThinkingLLM and the downstream video generator. No separate enable switch is required.
+
+## Duration resolution
+
+LTX uses the requested value directly. Its final prompt contains the duration once as natural language, for example `an 8-second continuous shot`, and remains one chronological paragraph.
+
+MiniMax uses the same 24 fps `17k+5` frame grid as the ComfyUI H3 node:
+
+1. Convert the requested seconds to frames with `round(seconds × 24)`.
+2. Use at least five frames.
+3. Raise the result to the next valid `17k+5` frame count.
+4. Divide the valid frame count by 24 to obtain the effective prompt duration.
+
+Examples:
+
+| Requested | Effective frames | Effective duration |
+| ---: | ---: | ---: |
+| 5.0 s | 124 | 5.17 s |
+| 8.0 s | 192 | 8.00 s |
+| 12.0 s | 294 | 12.25 s |
+
+Two requested MiniMax values that resolve to the same effective duration share the same duration-aware cache identity. A change to a different effective duration invalidates the cached and saved prompt state.
+
+## MiniMax H3 output contracts
+
+### Base formats
+
+T2VA, I2VA, FL2VA, and L2VA use the official base fields in this order:
+
+```text
+integrated_multimodal_description: [Shot 1] ...
+
+overall_soundscape: ...
+
+non_diegetic_music: ...
+```
+
+The preset asks for `[Shot 1]` without a timestamp and later cuts as `[Shot N] At MM:SS.mmm`, with sequential shot numbers and timestamps below the effective duration. I2VA, FL2VA, and L2VA additionally request their official picture-alignment preamble. These are generation instructions rather than post-generation rejection rules.
+
+The effective duration is internal planning context. T2VA and I2VA do not receive an invented `Target duration:` field. FL2VA and L2VA print the duration only where the official picture-alignment sentence requires it.
+
+### Full-reference format
+
+Reference-to-Video uses exactly these six sections in order:
+
+1. `subject_definitions`
+2. `summary`
+3. `retention_analysis`
+4. `detailed_description`
+5. `overall_soundscape`
+6. `non_diegetic_music`
+
+Use Reference-to-Video only when the request assigns connected assets a reusable role such as identity, wardrobe, prop, environment, style, motion, camera, or voice. To animate one image as the exact first frame, use the I2VA preset.
+
+## Long scripts and short clips
+
+A long multi-scene script is treated as source material, not as content that must all be compressed into one short generation. For an 8-second target, ThinkingLLM instructs the model to select one coherent contiguous moment that fits instead of turning the complete story into a rapid montage.
+
+Standalone quoted paragraphs are recognized as source dialogue. The rules are:
+
+- Scenes and dialogue outside the selected moment may be omitted.
+- The selected moment may be visual-only even when the master script contains dialogue.
+- Every selected dialogue block must match a source block verbatim and remain in source order.
+- Dialogue cannot be translated, paraphrased, merged, shortened, or invented.
+- Selected speech uses `<d>[Language] exact source text</d>` and a stable speaker ID such as `(S1)`. The square brackets are literal, so English is written as `<d>[English] Exact source text.</d>`, not `<d>English ...</d>`.
+- `<cutoff>` is allowed only when the user explicitly requests truncated speech.
+
+For example, a 99-word comedy script and an 8-second target do not fail before or after model generation. The preset asks the LLM to select one short exchange and its directly related action, or a visual-only beat. Any remaining mismatch is forwarded for MiniMax's downstream prompt processing.
+
+## Best-effort normalization
+
+After generation, ThinkingLLM deterministically normalizes only safe, unambiguous formatting differences:
+
+- uniquely identifiable field boundaries;
+- recognizable timestamp precision and `At` capitalization;
+- removal of the redundant zero timestamp from `[Shot 1]`;
+- the common `<d>English ...</d>` variant to `<d>[English] ...</d>` syntax;
+- removal of an obsolete standalone `Target duration:` declaration.
+
+ThinkingLLM does **not** enforce exact field count or order, speaker IDs, dialogue length or source fidelity, sequential or in-range timestamps, or the full reference-section schema. It does not run an automatic schema-repair pass for minor mismatches; those are forwarded to the downstream MiniMax generator, which performs its own prompt interpretation. It retries only when no usable final prompt exists, such as an unfinished `<think>` block. The system prompt still strongly requests the official format without turning ThinkingLLM into a blocking schema gateway.
+
+## Recommended settings
+
+- The read-only info box shows the active video preset's recommendation without changing node values. See the [complete video preset settings table](VIDEO_PRESET_SETTINGS.md).
+- Connect the same requested duration to ThinkingLLM and the H3 generator.
+- Start with `enable_thinking=false` for direct prompt conversion.
+- Start with `max_tokens=2048` for Base/T2VA, I2VA, FL2VA, and L2VA prompts.
+- Start with `max_tokens=3072` for full-reference prompts.
+- If a video-preset response ends inside an unfinished `<think>` block, ThinkingLLM discards that reasoning and automatically retries with thinking disabled and the native output-field prefill. It never forwards the incomplete reasoning as the main prompt.
+- Increase the token limit only when a useful response is genuinely truncated.
+- Inspect `RAW_TRACE` for model reasoning and connect the main output to Show Text or Show Anything to inspect the exact downstream string.
+
+After updating the custom node, restart ComfyUI completely and refresh the browser with `Ctrl+F5` so Python node definitions and frontend widget visibility are both reloaded.
+
+## Official references
+
+- [ComfyUI MiniMax H3 workflow guide](https://docs.comfy.org/tutorials/video/minimax/minimax-h3)
+- [MiniMax H3 Base prompt-writing guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md)
+- [MiniMax H3 Full-Reference prompt-writing guide](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md)
+- [LTX-Video repository](https://github.com/Lightricks/LTX-Video)

gguf_models.json

@@ -5,6 +5,7 @@
             "author": "mradermacher",
             "repo_name": "Qwen3-4B-abliterated-GGUF",
             "repo_id": "mradermacher/Qwen3-4B-abliterated-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3-4B-abliterated.Q4_K_M.gguf",
                 "Qwen3-4B-abliterated.Q5_K_M.gguf",
@@ -20,6 +21,7 @@
             "author": "mradermacher",
             "repo_name": "Josiefied-Qwen3-4B-abliterated-v1-GGUF",
             "repo_id": "mradermacher/Josiefied-Qwen3-4B-abliterated-v1-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Josiefied-Qwen3-4B-abliterated-v1.Q4_K_M.gguf",
                 "Josiefied-Qwen3-4B-abliterated-v1.Q5_K_M.gguf",
@@ -35,6 +37,7 @@
             "author": "mradermacher",
             "repo_name": "Josiefied-Qwen3-8B-abliterated-v1-GGUF",
             "repo_id": "mradermacher/Josiefied-Qwen3-8B-abliterated-v1-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Josiefied-Qwen3-8B-abliterated-v1.Q4_K_M.gguf",
                 "Josiefied-Qwen3-8B-abliterated-v1.Q5_K_M.gguf",
@@ -50,6 +53,7 @@
             "author": "mradermacher",
             "repo_name": "Qwen3-VL-4B-Instruct-c_abliterated-v2-GGUF",
             "repo_id": "mradermacher/Qwen3-VL-4B-Instruct-c_abliterated-v2-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3-VL-4B-Instruct-c_abliterated-v2.Q4_K_M.gguf",
                 "Qwen3-VL-4B-Instruct-c_abliterated-v2.Q5_K_M.gguf",
@@ -65,6 +69,7 @@
             "author": "mradermacher",
             "repo_name": "Qwen3-VL-8B-Instruct-c_abliterated-v3-GGUF",
             "repo_id": "mradermacher/Qwen3-VL-8B-Instruct-c_abliterated-v3-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3-VL-8B-Instruct-c_abliterated-v3.Q4_K_M.gguf",
                 "Qwen3-VL-8B-Instruct-c_abliterated-v3.Q5_K_M.gguf",
@@ -80,6 +85,7 @@
             "author": "DevQuasar",
             "repo_name": "Josiefied-Qwen3-4B-Instruct-2507-gabliterated-v1-GGUF",
             "repo_id": "DevQuasar/Goekdeniz-Guelmez.Josiefied-Qwen3-4B-Instruct-2507-gabliterated-v1-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Goekdeniz-Guelmez.Josiefied-Qwen3-4B-Instruct-2507-gabliterated-v1.Q4_K_M.gguf",
                 "Goekdeniz-Guelmez.Josiefied-Qwen3-4B-Instruct-2507-gabliterated-v1.Q5_K_M.gguf",
@@ -95,6 +101,7 @@
             "author": "Qwen",
             "repo_name": "Qwen3-4B-GGUF",
             "repo_id": "Qwen/Qwen3-4B-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3-4B-Q4_K_M.gguf",
                 "Qwen3-4B-Q5_K_M.gguf",
@@ -109,6 +116,7 @@
             "author": "unsloth",
             "repo_name": "Qwen3.5-4B-GGUF",
             "repo_id": "unsloth/Qwen3.5-4B-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-4B-Q4_K_M.gguf",
                 "Qwen3.5-4B-Q6_K.gguf",
@@ -123,6 +131,7 @@
             "author": "unsloth",
             "repo_name": "Qwen3.5-9B-GGUF",
             "repo_id": "unsloth/Qwen3.5-9B-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-9B-Q4_K_M.gguf",
                 "Qwen3.5-9B-Q6_K.gguf",
@@ -137,6 +146,7 @@
             "author": "unsloth",
             "repo_name": "Qwen3.5-27B-GGUF",
             "repo_id": "unsloth/Qwen3.5-27B-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-27B-Q4_K_M.gguf",
                 "Qwen3.5-27B-Q5_K_M.gguf",
@@ -151,6 +161,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-4B-Uncensored-HauhauCS-Aggressive-GGUF",
             "repo_id": "HauhauCS/Qwen3.5-4B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-4B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
                 "Qwen3.5-4B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf",
@@ -165,6 +176,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-GGUF",
             "repo_id": "HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
                 "Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf",
@@ -179,6 +191,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-27B-Uncensored-HauhauCS-Aggressive-GGUF",
             "repo_id": "HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3.5-27B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
                 "Qwen3.5-27B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf",
@@ -189,23 +202,51 @@
                 "context_length": 131072
             }
         },
-        "Gemma-4-E2B-it-GGUF [Q4:2GB|Q8:3.5GB|VRAM:~3GB]": {
-            "author": "ggml-org",
-            "repo_name": "gemma-4-E2B-it-GGUF",
-            "repo_id": "ggml-org/gemma-4-E2B-it-GGUF",
+        "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-GGUF [Q2:11GB|Q3:15GB|Q4:20GB|Q5:28GB|Q6:31GB|Q8:44GB|VRAM:~24GB+]": {
+            "author": "HauhauCS",
+            "repo_name": "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive",
+            "repo_id": "HauhauCS/Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "model_files": [
-                "gemma-4-E2B-it-Q4_K_M.gguf",
-                "gemma-4-E2B-it-Q8_0.gguf",
-                "gemma-4-E2B-it-BF16.gguf"
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q8_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q5_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ4_NL.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ4_XS.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q3_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ3_M.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q2_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ2_M.gguf"
             ],
             "defaults": {
                 "context_length": 131072
             }
         },
+        "Gemma-4-E2B-it-GGUF [Q4:3.2GB|Q8:4.7GB|BF16:8.7GB|VRAM:~5GB]": {
+            "author": "bartowski",
+            "repo_name": "google_gemma-4-E2B-it-GGUF",
+            "repo_id": "bartowski/google_gemma-4-E2B-it-GGUF",
+            "commercial_status": "unclear",
+            "model_files": [
+                "google_gemma-4-E2B-it-Q4_K_S.gguf",
+                "google_gemma-4-E2B-it-Q8_0.gguf",
+                "google_gemma-4-E2B-it-bf16.gguf"
+            ],
+            "local_filenames": {
+                "google_gemma-4-E2B-it-Q8_0.gguf": ["gemma-4-E2B-it-Q8_0.gguf"],
+                "google_gemma-4-E2B-it-bf16.gguf": ["gemma-4-E2B-it-bf16.gguf", "gemma-4-E2B-it-BF16.gguf"]
+            },
+            "defaults": {
+                "context_length": 131072
+            }
+        },
         "Gemma-4-E4B-it-GGUF [Q4:5.4GB|Q8:8GB|VRAM:~7GB]": {
             "author": "unsloth",
             "repo_name": "gemma-4-E4B-it-GGUF",
             "repo_id": "unsloth/gemma-4-E4B-it-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "gemma-4-E4B-it-Q4_K_M.gguf",
                 "gemma-4-E4B-it-Q6_K.gguf",
@@ -220,6 +261,7 @@
             "author": "unsloth",
             "repo_name": "gemma-4-26B-A4B-it-GGUF",
             "repo_id": "unsloth/gemma-4-26B-A4B-it-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "gemma-4-26B-A4B-it-Q4_K_M.gguf",
                 "gemma-4-26B-A4B-it-Q6_K.gguf",
@@ -230,10 +272,30 @@
                 "context_length": 262144
             }
         },
+        "Gemma-4-12B-it-GGUF [Q4:7.5GB|Q5:9GB|Q6:11GB|Q8:13GB|BF16:24GB|VRAM:~12GB]": {
+            "author": "unsloth",
+            "repo_name": "gemma-4-12b-it-GGUF",
+            "repo_id": "unsloth/gemma-4-12b-it-GGUF",
+            "commercial_status": "unclear",
+            "model_files": [
+                "gemma-4-12b-it-Q4_K_M.gguf",
+                "gemma-4-12b-it-Q4_K_S.gguf",
+                "gemma-4-12b-it-Q5_K_M.gguf",
+                "gemma-4-12b-it-Q5_K_S.gguf",
+                "gemma-4-12b-it-Q6_K.gguf",
+                "gemma-4-12b-it-Q8_0.gguf",
+                "gemma-4-12b-it-BF16.gguf",
+                "gemma-4-12b-it-UD-Q4_K_XL.gguf"
+            ],
+            "defaults": {
+                "context_length": 262144
+            }
+        },
         "Gemma-4-31B-it-GGUF [Q4:20GB|Q8:32GB|VRAM:~22GB]": {
             "author": "unsloth",
             "repo_name": "gemma-4-31B-it-GGUF",
             "repo_id": "unsloth/gemma-4-31B-it-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "gemma-4-31B-it-Q4_K_M.gguf",
                 "gemma-4-31B-it-Q6_K.gguf",
@@ -248,25 +310,39 @@
             "author": "bartowski",
             "repo_name": "google_gemma-4-E4B-it-GGUF",
             "repo_id": "bartowski/google_gemma-4-E4B-it-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
-                "gemma-4-E4B-it-Q4_K_M.gguf",
-                "gemma-4-E4B-it-Q6_K.gguf",
-                "gemma-4-E4B-it-Q8_0.gguf",
-                "gemma-4-E4B-it-BF16.gguf"
+                "google_gemma-4-E4B-it-Q4_K_M.gguf",
+                "google_gemma-4-E4B-it-Q5_K_M.gguf",
+                "google_gemma-4-E4B-it-Q6_K.gguf",
+                "google_gemma-4-E4B-it-Q8_0.gguf",
+                "google_gemma-4-E4B-it-bf16.gguf"
             ],
+            "local_filenames": {
+                "google_gemma-4-E4B-it-Q4_K_M.gguf": ["gemma-4-E4B-it-Q4_K_M.gguf"],
+                "google_gemma-4-E4B-it-Q5_K_M.gguf": ["gemma-4-E4B-it-Q5_K_M.gguf"],
+                "google_gemma-4-E4B-it-Q6_K.gguf": ["gemma-4-E4B-it-Q6_K.gguf"],
+                "google_gemma-4-E4B-it-Q8_0.gguf": ["gemma-4-E4B-it-Q8_0.gguf"],
+                "google_gemma-4-E4B-it-bf16.gguf": ["gemma-4-E4B-it-BF16.gguf"]
+            },
             "defaults": {
                 "context_length": 131072
             }
         },
-        "Gemma-4-E2B-Uncensored-GGUF [Q4:2GB|Q8:3.5GB|VRAM:~3GB]": {
-            "author": "ggml-org",
-            "repo_name": "gemma-4-E2B-it-GGUF",
-            "repo_id": "ggml-org/gemma-4-E2B-it-GGUF",
+        "Gemma-4-E2B-Uncensored-GGUF [Q4:3.2GB|Q8:4.7GB|BF16:8.7GB|VRAM:~5GB]": {
+            "author": "bartowski",
+            "repo_name": "google_gemma-4-E2B-it-GGUF",
+            "repo_id": "bartowski/google_gemma-4-E2B-it-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
-                "gemma-4-E2B-it-Q4_K_M.gguf",
-                "gemma-4-E2B-it-Q8_0.gguf",
-                "gemma-4-E2B-it-BF16.gguf"
+                "google_gemma-4-E2B-it-Q4_K_S.gguf",
+                "google_gemma-4-E2B-it-Q8_0.gguf",
+                "google_gemma-4-E2B-it-bf16.gguf"
             ],
+            "local_filenames": {
+                "google_gemma-4-E2B-it-Q8_0.gguf": ["gemma-4-E2B-it-Q8_0.gguf"],
+                "google_gemma-4-E2B-it-bf16.gguf": ["gemma-4-E2B-it-bf16.gguf", "gemma-4-E2B-it-BF16.gguf"]
+            },
             "defaults": {
                 "context_length": 131072
             }
@@ -277,6 +353,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-4B-Uncensored-HauhauCS-Aggressive",
             "repo_id": "HauhauCS/Qwen3.5-4B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3.5-4B-Uncensored-HauhauCS-Aggressive-BF16.gguf",
             "model_files": [
                 "Qwen3.5-4B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
@@ -297,6 +374,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-9B-Uncensored-HauhauCS-Aggressive",
             "repo_id": "HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-BF16.gguf",
             "model_files": [
                 "Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
@@ -317,6 +395,7 @@
             "author": "HauhauCS",
             "repo_name": "Qwen3.5-27B-Uncensored-HauhauCS-Aggressive",
             "repo_id": "HauhauCS/Qwen3.5-27B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3.5-27B-Uncensored-HauhauCS-Aggressive-f16.gguf",
             "model_files": [
                 "Qwen3.5-27B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
@@ -333,10 +412,39 @@
                 "pool_size": 4194304
             }
         },
+        "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive [Q2:11GB|Q3:15GB|Q4:20GB|Q5:28GB|Q6:31GB|Q8:44GB|VRAM:~24GB+]": {
+            "author": "HauhauCS",
+            "repo_name": "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive",
+            "repo_id": "HauhauCS/Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
+            "mmproj_file": "mmproj-Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-f16.gguf",
+            "model_files": [
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q8_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q5_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ4_NL.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ4_XS.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q3_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ3_M.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-Q2_K_P.gguf",
+                "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive-IQ2_M.gguf"
+            ],
+            "defaults": {
+                "context_length": 131072,
+                "image_max_tokens": 4096,
+                "n_batch": 512,
+                "gpu_layers": -1,
+                "top_k": 20,
+                "pool_size": 4194304
+            }
+        },
         "Qwen3.5-4B [Q4:2.4GB|Q6:3.2GB|Q8:4.2GB|BF16:8GB|VRAM:~4GB]": {
             "author": "unsloth",
             "repo_name": "Qwen3.5-4B-GGUF",
             "repo_id": "unsloth/Qwen3.5-4B-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-BF16.gguf",
             "model_files": [
                 "Qwen3.5-4B-Q4_K_M.gguf",
@@ -357,6 +465,7 @@
             "author": "unsloth",
             "repo_name": "Qwen3.5-9B-GGUF",
             "repo_id": "unsloth/Qwen3.5-9B-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-F32.gguf",
             "model_files": [
                 "Qwen3.5-9B-Q4_K_M.gguf",
@@ -377,6 +486,7 @@
             "author": "unsloth",
             "repo_name": "Qwen3.5-27B-GGUF",
             "repo_id": "unsloth/Qwen3.5-27B-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-F32.gguf",
             "model_files": [
                 "Qwen3.5-27B-Q4_K_M.gguf",
@@ -393,10 +503,68 @@
                 "pool_size": 4194304
             }
         },
+        "Gemma-4-12B-it-GGUF [Q4:7.5GB|Q5:9GB|Q6:11GB|Q8:13GB|BF16:24GB|VRAM:~12GB]": {
+            "author": "unsloth",
+            "repo_name": "gemma-4-12b-it-GGUF",
+            "repo_id": "unsloth/gemma-4-12b-it-GGUF",
+            "commercial_status": "unclear",
+            "mmproj_file": "mmproj-F16.gguf",
+            "model_files": [
+                "gemma-4-12b-it-Q4_K_M.gguf",
+                "gemma-4-12b-it-Q4_K_S.gguf",
+                "gemma-4-12b-it-Q5_K_M.gguf",
+                "gemma-4-12b-it-Q5_K_S.gguf",
+                "gemma-4-12b-it-Q6_K.gguf",
+                "gemma-4-12b-it-Q8_0.gguf",
+                "gemma-4-12b-it-BF16.gguf",
+                "gemma-4-12b-it-UD-Q4_K_XL.gguf"
+            ],
+            "defaults": {
+                "context_length": 262144,
+                "image_max_tokens": 4096,
+                "n_batch": 512,
+                "gpu_layers": -1,
+                "top_k": 64,
+                "pool_size": 4194304
+            }
+        },
+        "google_gemma-4-E4B-it-GGUF [Q4:5.4GB|Q5:5.8GB|Q6:6.3GB|Q8:8GB|BF16:15GB|VRAM:~7GB]": {
+            "author": "bartowski",
+            "repo_name": "google_gemma-4-E4B-it-GGUF",
+            "repo_id": "bartowski/google_gemma-4-E4B-it-GGUF",
+            "commercial_status": "unclear",
+            "mmproj_file": "mmproj-google_gemma-4-E4B-it-f16.gguf",
+            "model_files": [
+                "google_gemma-4-E4B-it-Q4_K_M.gguf",
+                "google_gemma-4-E4B-it-Q5_K_M.gguf",
+                "google_gemma-4-E4B-it-Q6_K.gguf",
+                "google_gemma-4-E4B-it-Q8_0.gguf",
+                "google_gemma-4-E4B-it-bf16.gguf"
+            ],
+            "local_filenames": {
+                "google_gemma-4-E4B-it-Q4_K_M.gguf": ["gemma-4-E4B-it-Q4_K_M.gguf"],
+                "google_gemma-4-E4B-it-Q5_K_M.gguf": ["gemma-4-E4B-it-Q5_K_M.gguf"],
+                "google_gemma-4-E4B-it-Q6_K.gguf": ["gemma-4-E4B-it-Q6_K.gguf"],
+                "google_gemma-4-E4B-it-Q8_0.gguf": ["gemma-4-E4B-it-Q8_0.gguf"],
+                "google_gemma-4-E4B-it-bf16.gguf": ["gemma-4-E4B-it-BF16.gguf"]
+            },
+            "mmproj_local_filenames": {
+                "mmproj-google_gemma-4-E4B-it-f16.gguf": ["mmproj-F16.gguf", "mmproj-BF16.gguf"]
+            },
+            "defaults": {
+                "context_length": 131072,
+                "image_max_tokens": 4096,
+                "n_batch": 512,
+                "gpu_layers": -1,
+                "top_k": 64,
+                "pool_size": 4194304
+            }
+        },
         "Qwen3-VL-4B-Instruct-c_abliterated-v2-GGUF [Q4:2.4GB|Q5:2.8GB|Q6:3.2GB|Q8:4.2GB|F16:8GB|VRAM:~4GB]": {
             "author": "mradermacher",
             "repo_name": "Qwen3-VL-4B-Instruct-c_abliterated-v2-GGUF",
             "repo_id": "mradermacher/Qwen3-VL-4B-Instruct-c_abliterated-v2-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "Qwen3-VL-4B-Instruct-c_abliterated-v2.mmproj-f16.gguf",
             "model_files": [
                 "Qwen3-VL-4B-Instruct-c_abliterated-v2.Q4_K_M.gguf",
@@ -418,6 +586,7 @@
             "author": "mradermacher",
             "repo_name": "Qwen3-VL-8B-Instruct-c_abliterated-v3-GGUF",
             "repo_id": "mradermacher/Qwen3-VL-8B-Instruct-c_abliterated-v3-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "Qwen3-VL-8B-Instruct-c_abliterated-v3.mmproj-f16.gguf",
             "model_files": [
                 "Qwen3-VL-8B-Instruct-c_abliterated-v3.Q4_K_M.gguf",
@@ -439,6 +608,7 @@
             "author": "mradermacher",
             "repo_name": "Qwen3-VL-32B-Heretic-v2-GGUF",
             "repo_id": "mradermacher/Qwen3-VL-32B-Heretic-v2-GGUF",
+            "commercial_status": "unclear",
             "model_files": [
                 "Qwen3-VL-32B-Heretic-v2.Q4_K_M.gguf",
                 "Qwen3-VL-32B-Heretic-v2.Q5_K_M.gguf",
@@ -458,6 +628,7 @@
             "author": "Qwen",
             "repo_name": "Qwen3-VL-4B-Instruct-GGUF",
             "repo_id": "Qwen/Qwen3-VL-4B-Instruct-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3VL-4B-Instruct-F16.gguf",
             "model_files": [
                 "Qwen3VL-4B-Instruct-Q4_K_M.gguf",
@@ -477,6 +648,7 @@
             "author": "Qwen",
             "repo_name": "Qwen3-VL-8B-Instruct-GGUF",
             "repo_id": "Qwen/Qwen3-VL-8B-Instruct-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3VL-8B-Instruct-F16.gguf",
             "model_files": [
                 "Qwen3VL-8B-Instruct-Q4_K_M.gguf",
@@ -496,6 +668,7 @@
             "author": "Qwen",
             "repo_name": "Qwen3-VL-4B-Thinking-GGUF",
             "repo_id": "Qwen/Qwen3-VL-4B-Thinking-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3VL-4B-Thinking-F16.gguf",
             "model_files": [
                 "Qwen3VL-4B-Thinking-Q4_K_M.gguf",
@@ -515,6 +688,7 @@
             "author": "Qwen",
             "repo_name": "Qwen3-VL-8B-Thinking-GGUF",
             "repo_id": "Qwen/Qwen3-VL-8B-Thinking-GGUF",
+            "commercial_status": "unclear",
             "mmproj_file": "mmproj-Qwen3VL-8B-Thinking-F16.gguf",
             "model_files": [
                 "Qwen3VL-8B-Thinking-Q4_K_M.gguf",
@@ -531,4 +705,4 @@
             }
         }
     }
-}
+}

hf_models.commercial.json

@@ -0,0 +1,24 @@
+{
+  "hf_vl_models": {
+    "Qwen3-VL-4B-Instruct (locked commercial model)": {
+      "repo_id": "Qwen/Qwen3-VL-4B-Instruct",
+      "commercial_status": "cleared",
+      "revision": "ebb281ec70b05090aa6165b016eac8ec08e71b17",
+      "component_id": "MODEL-014",
+      "default": true,
+      "quantized": false,
+      "vram_requirement": {"full": 9.0}
+    }
+  },
+  "hf_text_models": {
+    "Qwen3-4B-Instruct-2507 (locked commercial model)": {
+      "repo_id": "Qwen/Qwen3-4B-Instruct-2507",
+      "commercial_status": "cleared",
+      "revision": "cdbee75f17c01a7cc42f958dc650907174af0554",
+      "component_id": "MODEL-006",
+      "default": true,
+      "quantized": false,
+      "vram_requirement": {"full": 9.0}
+    }
+  }
+}

hf_models.json

@@ -1,8 +1,18 @@
 {
     "hf_vl_models": {
+        "Qwen3-VL-4B-Instruct (locked commercial model)": {
+            "repo_id": "Qwen/Qwen3-VL-4B-Instruct",
+            "commercial_status": "cleared",
+            "revision": "ebb281ec70b05090aa6165b016eac8ec08e71b17",
+            "component_id": "MODEL-014",
+            "default": false,
+            "quantized": false,
+            "vram_requirement": {"full": 9.0}
+        },
         "Qwen3.5-4B-heretic-v2 [DL: 7.5GB, VRAM: 9.0GB]": {
             "repo_id": "tvall43/Qwen3.5-4B-heretic-v2",
-            "default": true,
+            "commercial_status": "unclear",
+            "default": false,
             "quantized": false,
             "vram_requirement": {
                 "full": 9.0
@@ -10,6 +20,7 @@
         },
         "Qwen3.5-9B-ultra-uncensored-heretic-v2 [DL: 17GB, VRAM: 19.0GB]": {
             "repo_id": "llmfan46/Qwen3.5-9B-ultra-uncensored-heretic-v2",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -18,6 +29,7 @@
         },
         "Qwen3.5-4B [DL: 7.5GB, VRAM: 9.0GB]": {
             "repo_id": "Qwen/Qwen3.5-4B",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -26,6 +38,7 @@
         },
         "Qwen3.5-9B [DL: 17GB, VRAM: 19.0GB]": {
             "repo_id": "Qwen/Qwen3.5-9B",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -34,6 +47,7 @@
         },
         "Qwen3-VL-4B-Instruct-Abliterated [DL: 7.5GB, VRAM: 6.0GB]": {
             "repo_id": "huihui-ai/Huihui-Qwen3-VL-4B-Instruct-abliterated",
+            "commercial_status": "unclear",
             "default": true,
             "quantized": true,
             "vram_requirement": {
@@ -44,6 +58,7 @@
         },
         "Qwen3-VL-8B-Instruct-Abliterated [DL: 15GB, VRAM: 12.0GB]": {
             "repo_id": "huihui-ai/Huihui-Qwen3-VL-8B-Instruct-abliterated",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": true,
             "vram_requirement": {
@@ -54,6 +69,7 @@
         },
         "Qwen3-VL-4B-Instruct-Unredacted-MAX [DL: 7.5GB, VRAM: 6.0GB]": {
             "repo_id": "prithivMLmods/Qwen3-VL-4B-Instruct-Unredacted-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -64,6 +80,7 @@
         },
         "Qwen3-VL-8B-Instruct-Unredacted-MAX [DL: 15GB, VRAM: 12.0GB]": {
             "repo_id": "prithivMLmods/Qwen3-VL-8B-Instruct-Unredacted-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -74,6 +91,7 @@
         },
         "Qwen3-VL-8B-Instruct-abliterated-v1 [DL: 15GB, VRAM: 12.0GB]": {
             "repo_id": "prithivMLmods/Qwen3-VL-8B-Instruct-abliterated-v1",
+            "commercial_status": "external_gated",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -84,6 +102,7 @@
         },
         "Qwen3-VL-4B-Instruct-abliterated-v1 [DL: 7.5GB, VRAM: 6.0GB]": {
             "repo_id": "prithivMLmods/Qwen3-VL-4B-Instruct-abliterated-v1",
+            "commercial_status": "external_gated",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -94,6 +113,7 @@
         },
         "Qwen3-VL-32B-Heretic-v2 [DL: 60GB, VRAM: 48.0GB]": {
             "repo_id": "rpDungeon/Qwen3-VL-32B-Heretic-v2",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -104,6 +124,7 @@
         },
         "Gemma-4-26B-A4B-it [DL: 51.6GB, VRAM: 42.0GB]": {
             "repo_id": "google/gemma-4-26B-A4B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -114,6 +135,7 @@
         },
         "Gemma-4-E4B-it [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "google/gemma-4-E4B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -124,6 +146,7 @@
         },
         "Gemma-4-E2B-it [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "google/gemma-4-E2B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -134,6 +157,7 @@
         },
         "Gemma-4-31B-it [DL: 62.6GB, VRAM: 48.0GB]": {
             "repo_id": "google/gemma-4-31B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -142,8 +166,20 @@
                 "4bit": 16.0
             }
         },
+        "Gemma-4-12B [DL: 24GB, VRAM: 24.0GB]": {
+            "repo_id": "google/gemma-4-12B",
+            "commercial_status": "unclear",
+            "default": false,
+            "quantized": false,
+            "vram_requirement": {
+                "full": 24.0,
+                "8bit": 13.0,
+                "4bit": 8.0
+            }
+        },
         "Gemma-4-E4B-Uncensored [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "prithivMLmods/gemma-4-E4B-it-Uncensored-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -154,6 +190,7 @@
         },
         "Gemma-4-E2B-Uncensored [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "prithivMLmods/gemma-4-E2B-it-Uncensored-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -164,6 +201,7 @@
         },
         "Gemma-4-26B-A4B-Heretic [DL: 51.6GB, VRAM: 42.0GB]": {
             "repo_id": "coder3101/gemma-4-26B-A4B-it-heretic",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -174,6 +212,7 @@
         },
         "Gemma-4-E4B-Uncensored-Aggressive [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "HauhauCS/Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -184,6 +223,7 @@
         },
         "Gemma-4-E2B-Uncensored-Aggressive [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "HauhauCS/Gemma-4-E2B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -194,8 +234,18 @@
         }
     },
     "hf_text_models": {
+        "Qwen3-4B-Instruct-2507 (locked commercial model)": {
+            "repo_id": "Qwen/Qwen3-4B-Instruct-2507",
+            "commercial_status": "cleared",
+            "revision": "cdbee75f17c01a7cc42f958dc650907174af0554",
+            "component_id": "MODEL-006",
+            "default": false,
+            "quantized": false,
+            "vram_requirement": {"full": 9.0}
+        },
         "Qwen3-VL-4B-Instruct-Abliterated [DL: 7.5GB, VRAM: 6.0GB]": {
             "repo_id": "huihui-ai/Huihui-Qwen3-VL-4B-Instruct-abliterated",
+            "commercial_status": "unclear",
             "default": true,
             "quantized": true,
             "vram_requirement": {
@@ -206,6 +256,7 @@
         },
         "Qwen3-VL-8B-Instruct-Abliterated [DL: 15GB, VRAM: 12.0GB]": {
             "repo_id": "huihui-ai/Huihui-Qwen3-VL-8B-Instruct-abliterated",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": true,
             "vram_requirement": {
@@ -216,6 +267,7 @@
         },
         "qwen3-4b-Z-Image-Engineer [DL: 7.5GB, VRAM: 9.0GB]": {
             "repo_id": "BennyDaBall/qwen3-4b-Z-Image-Engineer",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -224,6 +276,7 @@
         },
         "Qwen3.5-4B-heretic-v2 [DL: 7.5GB, VRAM: 8.0GB]": {
             "repo_id": "tvall43/Qwen3.5-4B-heretic-v2",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -232,6 +285,7 @@
         },
         "Qwen3.5-9B-ultra-uncensored-heretic-v2 [DL: 17GB, VRAM: 18.0GB]": {
             "repo_id": "llmfan46/Qwen3.5-9B-ultra-uncensored-heretic-v2",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -240,6 +294,7 @@
         },
         "Qwen3.5-4B [DL: 7.5GB, VRAM: 8.0GB]": {
             "repo_id": "Qwen/Qwen3.5-4B",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -248,6 +303,7 @@
         },
         "Qwen3.5-9B [DL: 17GB, VRAM: 18.0GB]": {
             "repo_id": "Qwen/Qwen3.5-9B",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -256,6 +312,7 @@
         },
         "Gemma-4-26B-A4B-it [DL: 51.6GB, VRAM: 42.0GB]": {
             "repo_id": "google/gemma-4-26B-A4B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -266,6 +323,7 @@
         },
         "Gemma-4-E4B-it [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "google/gemma-4-E4B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -276,6 +334,7 @@
         },
         "Gemma-4-E2B-it [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "google/gemma-4-E2B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -286,6 +345,7 @@
         },
         "Gemma-4-31B-it [DL: 62.6GB, VRAM: 48.0GB]": {
             "repo_id": "google/gemma-4-31B-it",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -294,8 +354,20 @@
                 "4bit": 16.0
             }
         },
+        "Gemma-4-12B [DL: 24GB, VRAM: 24.0GB]": {
+            "repo_id": "google/gemma-4-12B",
+            "commercial_status": "unclear",
+            "default": false,
+            "quantized": false,
+            "vram_requirement": {
+                "full": 24.0,
+                "8bit": 13.0,
+                "4bit": 8.0
+            }
+        },
         "Gemma-4-E4B-Uncensored [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "prithivMLmods/gemma-4-E4B-it-Uncensored-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -306,6 +378,7 @@
         },
         "Gemma-4-E2B-Uncensored [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "prithivMLmods/gemma-4-E2B-it-Uncensored-MAX",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -316,6 +389,7 @@
         },
         "Gemma-4-26B-A4B-Heretic [DL: 51.6GB, VRAM: 42.0GB]": {
             "repo_id": "coder3101/gemma-4-26B-A4B-it-heretic",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -326,6 +400,7 @@
         },
         "Gemma-4-E4B-Uncensored-Aggressive [DL: 16GB, VRAM: 7.0GB]": {
             "repo_id": "HauhauCS/Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -336,6 +411,7 @@
         },
         "Gemma-4-E2B-Uncensored-Aggressive [DL: 10.3GB, VRAM: 4.0GB]": {
             "repo_id": "HauhauCS/Gemma-4-E2B-Uncensored-HauhauCS-Aggressive",
+            "commercial_status": "unclear",
             "default": false,
             "quantized": false,
             "vram_requirement": {
@@ -345,4 +421,4 @@
             }
         }
     }
-}
+}

nodes/system_prompt_preset.py

@@ -0,0 +1,84 @@
+"""Standalone system-prompt preset selector for ThinkingLLM."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+SYSTEM_PROMPTS_PATH = Path(__file__).resolve().parent.parent / "AILab_System_Prompts.json"
+NO_PRESET_PROMPT = "🚫 No preset (image-only)"
+
+
+def _load_system_prompt_presets() -> tuple[list[str], dict[str, str]]:
+    """Load the same preset order and prompt strings used by ThinkingLLM."""
+    try:
+        with SYSTEM_PROMPTS_PATH.open("r", encoding="utf-8") as file:
+            data = json.load(file) or {}
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"[ThinkingLLM System Prompt Preset] Failed to load presets: {exc}")
+        return [NO_PRESET_PROMPT], {NO_PRESET_PROMPT: ""}
+
+    raw_prompts = data.get("qwenvl") or {}
+    system_prompts = raw_prompts if isinstance(raw_prompts, dict) else {}
+    system_prompts = {
+        str(name): str(prompt)
+        for name, prompt in system_prompts.items()
+        if isinstance(prompt, str)
+    }
+    system_prompts.setdefault(NO_PRESET_PROMPT, "")
+
+    raw_presets = data.get("_preset_prompts") or []
+    preset_prompts = [
+        name
+        for name in raw_presets
+        if isinstance(name, str) and name in system_prompts
+    ]
+    if not preset_prompts:
+        preset_prompts = list(system_prompts)
+    if NO_PRESET_PROMPT not in preset_prompts:
+        preset_prompts.insert(0, NO_PRESET_PROMPT)
+
+    return preset_prompts, system_prompts
+
+
+class ThinkingLLMSystemPromptPreset:
+    """Select a ThinkingLLM preset and return its full system prompt."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        preset_prompts, _ = _load_system_prompt_presets()
+        return {
+            "required": {
+                "preset_prompt": (
+                    preset_prompts,
+                    {
+                        "default": preset_prompts[0],
+                        "tooltip": "Select a ThinkingLLM system-prompt preset.",
+                    },
+                )
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("system_prompt",)
+    OUTPUT_TOOLTIPS = ("The full system prompt text for the selected preset.",)
+    FUNCTION = "get_system_prompt"
+    CATEGORY = "ThinkingLLM/Utils"
+    DESCRIPTION = "Outputs the full system prompt string for a ThinkingLLM preset."
+
+    def get_system_prompt(self, preset_prompt: str):
+        _, system_prompts = _load_system_prompt_presets()
+        return (system_prompts.get(preset_prompt, ""),)
+
+
+NODE_CLASS_MAPPINGS = {
+    "ThinkingLLM_SystemPromptPreset": ThinkingLLMSystemPromptPreset,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ThinkingLLM_SystemPromptPreset": "ThinkingLLM System Prompt Preset",
+}
+
+
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "ComfyUI-ThinkingLLM"
 description = "A multimodal ComfyUI AI node with Qwen3.5, Qwen3-VL, Qwen2.5-VL, Qwen3, and Gemma 4 integrations. Features live thinking in the terminal to see what the LLM is doing in real time."
-version = "2.3.0"
+version = "2.4.0"
 license = {file = "LICENSE"}
-dependencies = ["transformers>=5.2.0", "torch", "huggingface-hub", "hf_xet", "psutil", "numpy", "Pillow", "opencv-python", "bitsandbytes", "accelerate", "sentencepiece", "tiktoken", "llama-cpp-python"]
+dependencies = ["transformers>=5.2.0", "torch", "huggingface-hub", "hf_xet", "psutil", "numpy", "Pillow", "opencv-python", "bitsandbytes", "accelerate", "sentencepiece", "tiktoken", "faster-whisper", "llama-cpp-python"]
 
 [project.urls]
 Repository = "https://github.com/goodguy1963/ComfyUI-ThinkingLLM"

requirements.txt

@@ -13,6 +13,7 @@ bitsandbytes
 accelerate
 sentencepiece
 tiktoken
+faster-whisper
 
 # For running GGUF models with vision support
 # The [server] extra installs necessary components for multimodal models

sageattention_patch.py

@@ -11,7 +11,7 @@ def set_sage_attention(model):
     Apply SageAttention patching to the model.
     Patches Qwen2Attention and Qwen3VLTextAttention modules to use SageAttention kernels.
     """
-    from AILab_QwenVL import sage_attn_available, get_sage_attention_config
+    from thinkingllm_core.hf_models import get_sage_attention_config, sage_attn_available
     
     if not sage_attn_available():
         raise ImportError("SageAttention library is not installed or GPU doesn't support it.")

thinkingllm_core/__init__.py

@@ -0,0 +1 @@
+"""Internal implementation package for ComfyUI-ThinkingLLM."""

thinkingllm_core/hf_models.py

@@ -0,0 +1,729 @@
+"""Hugging Face model configuration, discovery, device, and attention support."""
+
+import gc
+import json
+import os
+import platform
+from enum import Enum
+from pathlib import Path
+
+import psutil
+import torch
+try:
+    from transformers import BitsAndBytesConfig
+except ImportError:
+    BitsAndBytesConfig = None
+
+import folder_paths
+
+from thinkingllm_core.model_access import (
+    COMMERCIAL_RELEASE,
+    _download_model_snapshot,
+    _model_snapshot_has_required_files,
+    enforce_model_access,
+    normalize_commercial_status,
+    resolve_model_catalog_name,
+)
+from thinkingllm_core.prompt_contracts import VIDEO_PRESET_METADATA
+
+try:
+    from sageattention.core import (
+        sageattn_qk_int8_pv_fp16_cuda,
+        sageattn_qk_int8_pv_fp8_cuda,
+        sageattn_qk_int8_pv_fp8_cuda_sm90,
+    )
+    SAGE_ATTENTION_AVAILABLE = True
+except Exception:
+    sageattn_qk_int8_pv_fp16_cuda = None
+    sageattn_qk_int8_pv_fp8_cuda = None
+    sageattn_qk_int8_pv_fp8_cuda_sm90 = None
+    SAGE_ATTENTION_AVAILABLE = False
+
+NODE_DIR = Path(__file__).resolve().parent.parent
+CONFIG_PATH = NODE_DIR / ("hf_models.commercial.json" if COMMERCIAL_RELEASE else "hf_models.json")
+SYSTEM_PROMPTS_PATH = NODE_DIR / "AILab_System_Prompts.json"
+HF_VL_MODELS: dict[str, dict] = {}
+HF_TEXT_MODELS: dict[str, dict] = {}
+HF_ALL_MODELS: dict[str, dict] = {}
+SYSTEM_PROMPTS = {}
+NO_PRESET_PROMPT = "🚫 No preset (image-only)"
+PRESET_PROMPTS: list[str] = [NO_PRESET_PROMPT, "Describe this image in detail."]
+
+
+TOOLTIPS = {
+    "model_name": "Pick the checkpoint. [ComfyUI] entries reuse compatible models/text_encoders files; other entries download into models/LLM/Qwen-VL on first use.",
+    "quantization": "Precision vs VRAM. FP16 gives the best quality if memory allows; 8-bit suits 8–16 GB GPUs; 4-bit fits 6 GB or lower but is slower.",
+    "attention_mode": "auto tries SageAttention → FlashAttention 2 → SDPA in order. SDPA is stable and recommended. Only override when debugging attention backends.",
+    "preset_prompt": "Built-in instruction describing how Qwen-VL should analyze the media input.",
+    "custom_prompt": "Additional user input that gets combined with the preset template. Leave empty to use only the template.",
+    "max_tokens": "Maximum number of new tokens to decode. Larger values yield longer answers but consume more time and memory.",
+    "keep_model_loaded": "Keeps the model resident in VRAM/RAM after the run so the next prompt skips loading.",
+    "seed": "Seed controlling sampling and frame picking; reuse it to reproduce results.",
+    "use_torch_compile": "Enable torch.compile('reduce-overhead') on supported CUDA/Torch 2.1+ builds for extra throughput after the first compile.",
+    "device": "Choose where to run the model: auto, cpu, mps, or cuda:x for multi-GPU systems.",
+    "temperature": "Sampling randomness when num_beams == 1. 0.2–0.4 is focused, 0.7+ is creative.",
+    "top_p": "Nucleus sampling cutoff when num_beams == 1. Lower values keep only top tokens; 0.9–0.95 allows more variety.",
+    "num_beams": "Beam-search width. Values >1 disable temperature/top_p and trade speed for more stable answers.",
+    "repetition_penalty": "Values >1 (e.g., 1.1–1.3) penalize repeated phrases; 1.0 leaves logits untouched.",
+    "frame_count": "Number of frames extracted from video inputs before prompting Qwen-VL. More frames provide context but cost time.",
+    "hf_token": "Optional Hugging Face access token for private or gated model downloads. It is passed only to the download call, never logged or cached, and the in-memory copy is dropped after the download attempt. Clear this field before saving or sharing workflows.",
+}
+
+
+def ensure_cuda_vram_headroom(module_name="QwenVL", min_free_gb=1.0, min_free_ratio=0.08):
+    if not torch.cuda.is_available():
+        return True
+    try:
+        torch.cuda.synchronize()
+    except Exception:
+        pass
+    try:
+        free_before, total = torch.cuda.mem_get_info()
+    except Exception:
+        gc.collect()
+        torch.cuda.empty_cache()
+        return True
+
+    allocated = torch.cuda.memory_allocated()
+    reserved = torch.cuda.memory_reserved()
+    reclaimable = max(reserved - allocated, 0)
+    threshold = max(int(min_free_gb * 1024**3), int(total * min_free_ratio))
+
+    if free_before >= threshold and reclaimable < 512 * 1024**2:
+        return True
+
+    print(
+        f"[{module_name}] VRAM headroom low before run: "
+        f"free={free_before / 1024**3:.2f}GB, "
+        f"reserved={reserved / 1024**3:.2f}GB, "
+        f"allocated={allocated / 1024**3:.2f}GB. Cleaning CUDA cache..."
+    )
+    gc.collect()
+    torch.cuda.empty_cache()
+    try:
+        torch.cuda.ipc_collect()
+    except Exception:
+        pass
+    try:
+        torch.cuda.synchronize()
+    except Exception:
+        pass
+
+    try:
+        free_after, _ = torch.cuda.mem_get_info()
+        print(f"[{module_name}] VRAM after cleanup: free={free_after / 1024**3:.2f}GB")
+        return free_after >= threshold
+    except Exception:
+        return True
+
+
+class Quantization(str, Enum):
+    Q4 = "4-bit (VRAM-friendly)"
+    Q8 = "8-bit (Balanced)"
+    FP16 = "None (FP16)"
+
+    @classmethod
+    def get_values(cls):
+        return [item.value for item in cls]
+
+    @classmethod
+    def from_value(cls, value):
+        for item in cls:
+            if item.value == value:
+                return item
+        raise ValueError(f"Unsupported quantization: {value}")
+
+ATTENTION_MODES = ["auto", "sage", "flash_attention_2", "sdpa"]
+
+# Debug: Check SageAttention availability
+print(f"[QwenVL Debug] SAGE_ATTENTION_AVAILABLE: {SAGE_ATTENTION_AVAILABLE}")
+if torch.cuda.is_available():
+    major, minor = torch.cuda.get_device_capability()
+    print(f"[QwenVL Debug] CUDA capability: {major}.{minor}")
+else:
+    print("[QwenVL Debug] CUDA not available")
+print(f"[QwenVL Debug] Final ATTENTION_MODES: {ATTENTION_MODES}")
+
+# Temporarily show sage option even if not available for testing
+print("[QwenVL] NOTE: SageAttention option shown for testing. Install with: pip install sageattention")
+
+def load_model_configs():
+    next_vl_models: dict[str, dict] = {}
+    next_text_models: dict[str, dict] = {}
+    next_system_prompts: dict = {}
+    next_preset_prompts = list(PRESET_PROMPTS)
+    try:
+        with open(CONFIG_PATH, "r", encoding="utf-8") as fh:
+            data = json.load(fh) or {}
+        if "hf_vl_models" in data or "hf_text_models" in data:
+            next_vl_models = data.get("hf_vl_models") or {}
+            next_text_models = data.get("hf_text_models") or {}
+        else:
+            next_vl_models = {k: v for k, v in data.items() if not k.startswith("_")}
+        if COMMERCIAL_RELEASE:
+            next_vl_models = {name: info for name, info in next_vl_models.items() if normalize_commercial_status(info) == "cleared"}
+            next_text_models = {name: info for name, info in next_text_models.items() if normalize_commercial_status(info) == "cleared"}
+        next_system_prompts = data.get("_system_prompts", {})
+        next_preset_prompts = data.get("_preset_prompts", next_preset_prompts)
+    except Exception as exc:
+        print(f"[QwenVL] Config load failed: {exc}")
+    try:
+        with open(SYSTEM_PROMPTS_PATH, "r", encoding="utf-8") as fh:
+            data = json.load(fh) or {}
+        qwenvl_prompts = data.get("qwenvl") or {}
+        preset_override = data.get("_preset_prompts") or []
+        video_metadata = data.get("_video_presets") or {}
+        if isinstance(qwenvl_prompts, dict) and qwenvl_prompts:
+            next_system_prompts = qwenvl_prompts
+        if isinstance(preset_override, list) and preset_override:
+            next_preset_prompts = preset_override
+        if isinstance(video_metadata, dict):
+            VIDEO_PRESET_METADATA.clear()
+            VIDEO_PRESET_METADATA.update(
+                {
+                    name: dict(entry)
+                    for name, entry in video_metadata.items()
+                    if isinstance(name, str) and isinstance(entry, dict)
+                }
+            )
+    except FileNotFoundError:
+        pass
+    except Exception as exc:
+        print(f"[QwenVL] System prompts load failed: {exc}")
+
+    if NO_PRESET_PROMPT not in next_preset_prompts:
+        next_preset_prompts = [NO_PRESET_PROMPT, *next_preset_prompts]
+    if isinstance(next_system_prompts, dict):
+        next_system_prompts.setdefault(NO_PRESET_PROMPT, "")
+    custom = NODE_DIR / "custom_models.json"
+    if custom.exists() and not COMMERCIAL_RELEASE:
+        try:
+            with open(custom, "r", encoding="utf-8") as fh:
+                data = json.load(fh) or {}
+            custom_vl = data.get("hf_vl_models") or {}
+            custom_text = data.get("hf_text_models") or {}
+            legacy = data.get("hf_models", {}) or data.get("models", {})
+            if isinstance(custom_vl, dict) and custom_vl:
+                next_vl_models.update(custom_vl)
+                print(f"[QwenVL] Loaded {len(custom_vl)} custom VL models")
+            if isinstance(custom_text, dict) and custom_text:
+                next_text_models.update(custom_text)
+                print(f"[QwenVL] Loaded {len(custom_text)} custom text models")
+            if isinstance(legacy, dict) and legacy:
+                next_vl_models.update(legacy)
+                print(f"[QwenVL] Loaded {len(legacy)} custom legacy models")
+        except Exception as exc:
+            print(f"[QwenVL] custom_models.json skipped: {exc}")
+
+    HF_VL_MODELS.clear()
+    HF_VL_MODELS.update(next_vl_models)
+    HF_TEXT_MODELS.clear()
+    HF_TEXT_MODELS.update(next_text_models)
+    HF_ALL_MODELS.clear()
+    HF_ALL_MODELS.update(HF_VL_MODELS)
+    HF_ALL_MODELS.update(HF_TEXT_MODELS)
+    SYSTEM_PROMPTS.clear()
+    SYSTEM_PROMPTS.update(next_system_prompts)
+    PRESET_PROMPTS[:] = next_preset_prompts
+
+    # Commercial releases expose only the two entries in the reviewed catalog.
+    if not COMMERCIAL_RELEASE:
+        _scan_local_hf_models()
+
+
+def _scan_local_hf_models():
+    """Scan local HF directories and compatible ComfyUI text encoders."""
+    # Collect all Qwen-VL directories to scan from ComfyUI's multi-path system
+    scan_dirs: list[Path] = []
+    llm_paths = folder_paths.get_folder_paths("LLM") if "LLM" in folder_paths.folder_names_and_paths else []
+    for llm_path in llm_paths:
+        qwen_dir = Path(llm_path) / "Qwen-VL"
+        if qwen_dir not in scan_dirs:
+            scan_dirs.append(qwen_dir)
+    # Always include the default location as fallback
+    default_dir = Path(folder_paths.models_dir) / "LLM" / "Qwen-VL"
+    if default_dir not in scan_dirs:
+        scan_dirs.append(default_dir)
+
+    # Collect known local directory names from JSON config
+    known_dirs = set()
+    for info in HF_ALL_MODELS.values():
+        repo_id = info.get("repo_id", "")
+        if isinstance(repo_id, str) and "/" in repo_id:
+            known_dirs.add(repo_id.split("/")[-1])
+        local_path = info.get("local_path")
+        if local_path:
+            known_dirs.add(Path(local_path).name)
+
+    count = 0
+    for models_dir in scan_dirs:
+        if not models_dir.exists() or not models_dir.is_dir():
+            continue
+        try:
+            for entry in models_dir.iterdir():
+                if not entry.is_dir():
+                    continue
+                if entry.name in known_dirs:
+                    continue
+                # Check if the directory contains model weights
+                has_weights = any(entry.glob("*.safetensors")) or any(entry.glob("*.bin"))
+                if not has_weights:
+                    continue
+                display = f"[local] {entry.name}"
+                model_info = {
+                    "local_path": str(entry),
+                    "repo_id": None,
+                    "is_local": True,
+                    "commercial_status": "local",
+                    "quantized": False,
+                }
+                HF_VL_MODELS[display] = model_info
+                HF_ALL_MODELS[display] = model_info
+                known_dirs.add(entry.name)
+                count += 1
+        except PermissionError:
+            pass
+
+    try:
+        text_encoders = folder_paths.get_filename_list("text_encoders")
+    except (AttributeError, KeyError):
+        text_encoders = []
+    for filename in text_encoders:
+        normalized = Path(filename).name.lower().replace("-", "").replace("_", "")
+        family = None
+        if "gemma312b" in normalized:
+            family = "gemma3"
+        elif "qwen3vl" in normalized and ("4b" in normalized or "8b" in normalized):
+            family = "qwen3vl"
+        if not family or not normalized.endswith(".safetensors"):
+            continue
+        display = f"[ComfyUI] {filename}"
+        model_info = {
+            "comfy_text_encoder": filename,
+            "repo_id": None,
+            "is_local": True,
+            "commercial_status": "local",
+            "quantized": True,
+            "native_family": family,
+        }
+        HF_VL_MODELS[display] = model_info
+        HF_ALL_MODELS[display] = model_info
+        count += 1
+
+    if count:
+        print(f"[QwenVL] Discovered {count} local model(s) on disk")
+
+
+if not HF_ALL_MODELS:
+    load_model_configs()
+
+
+def _default_model_from_config(models: dict[str, dict], fallback: str) -> str:
+    for name, info in models.items():
+        if isinstance(info, dict) and info.get("default"):
+            return name
+    return next(iter(models.keys()), fallback)
+
+
+def read_hf_model_type(model_dir: str) -> str | None:
+    """Read model_type from a HuggingFace model's config.json."""
+    try:
+        config_path = Path(model_dir) / "config.json"
+        if config_path.exists():
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+            return config.get("model_type")
+    except Exception:
+        pass
+    return None
+
+def check_pytorch_memory():
+    """Check current PyTorch memory settings and allow user to set fraction"""
+    try:
+        import torch
+        print(f"[QwenVL] PyTorch {torch.__version__}")
+        print(f"[QwenVL] CUDA Available: {torch.cuda.is_available()}")
+
+        if torch.cuda.is_available():
+            current_fraction = torch.cuda.get_per_process_memory_fraction()
+            print(f"[QwenVL] Current Memory Fraction: {current_fraction:.3f} ({current_fraction*100:.1f}% of GPU)")
+            print(f"[QwenVL] GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+
+            # Allow user to set new fraction
+            try:
+                prompt = f"[QwenVL] Enter new memory fraction (0.1-0.9"
+                if current_fraction is not None:
+                    prompt += f", current={current_fraction:.3f})"
+                new_fraction = float(input(prompt + ": ") or current_fraction)
+                if 0.1 <= new_fraction <= 0.9:
+                    torch.cuda.set_per_process_memory_fraction(new_fraction)
+                    print(f"[QwenVL] ✅ Memory fraction set to: {new_fraction:.3f} ({new_fraction*100:.1f}%)")
+                else:
+                    print(f"[QwenVL] ❌ Invalid fraction. Must be between 0.1 and 0.9")
+            except KeyboardInterrupt:
+                print(f"[QwenVL] ✅ Keeping current fraction: {current_fraction:.3f}")
+            except Exception as e:
+                print(f"[QwenVL] ❌ Error setting fraction: {e}")
+        else:
+            print("[QwenVL] CUDA not available")
+    except Exception as e:
+        print(f"[QwenVL] Error checking PyTorch: {e}")
+
+def set_pytorch_memory_fraction(fraction):
+    """Set PyTorch memory fraction if CUDA is available"""
+    try:
+        import torch
+        if torch.cuda.is_available():
+            if 0.1 <= fraction <= 0.9:
+                torch.cuda.set_per_process_memory_fraction(fraction)
+                print(f"[QwenVL] Memory fraction set to: {fraction:.3f} ({fraction*100:.1f}%)")
+                return True
+            else:
+                print(f"[QwenVL] Invalid fraction: {fraction:.3f}. Must be between 0.1 and 0.9")
+                return False
+        else:
+            print("[QwenVL] CUDA not available")
+            return False
+    except Exception as e:
+        print(f"[QwenVL] Error: {e}")
+        return False
+
+def get_device_info():
+    gpu = {"available": False, "total_memory": 0, "free_memory": 0}
+    device_type = "cpu"
+    recommended = "cpu"
+    if torch.cuda.is_available():
+        props = torch.cuda.get_device_properties(0)
+        total = props.total_memory / 1024**3
+        allocated = torch.cuda.memory_allocated(0) / 1024**3
+        reserved = torch.cuda.memory_reserved(0) / 1024**3
+        free = total - allocated - reserved
+
+        gpu = {
+            "available": True,
+            "total_memory": total,
+            "allocated_memory": allocated,
+            "reserved_memory": reserved,
+            "free_memory": free,
+        }
+        device_type = "nvidia_gpu"
+        recommended = "cuda"
+
+        # Detailed memory debugging
+        print(f"[QwenVL] GPU Memory Debug:")
+        print(f"  Total VRAM: {total / 1024**3:.2f} GB")
+        print(f"  Allocated: {allocated / 1024**3:.2f} GB")
+        print(f"  Reserved: {reserved / 1024**3:.2f} GB")
+        print(f"  Free: {free / 1024**3:.2f} GB")
+        print(f"  Model requires: 0.74 GB")
+        print(f"  Available ratio: {(free / total) * 100:.1f}%")
+
+    elif getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        device_type = "apple_silicon"
+        recommended = "mps"
+        gpu = {"available": True, "total_memory": 0, "free_memory": 0}
+    sys_mem = psutil.virtual_memory()
+    return {
+        "gpu": gpu,
+        "system_memory": {
+            "total": sys_mem.total / 1024**3,
+            "available": sys_mem.available / 1024**3,
+        },
+        "device_type": device_type,
+        "recommended_device": recommended,
+    }
+
+def normalize_device_choice(device: str) -> str:
+    device = (device or "auto").strip()
+    if device == "auto":
+        return "auto"
+
+    if device.isdigit():
+        device = f"cuda:{int(device)}"
+
+    if device == "cuda":
+        if not torch.cuda.is_available():
+            print("[QwenVL] CUDA requested but not available, falling back to CPU")
+            return "cpu"
+        return "cuda"
+
+    if device.startswith("cuda"):
+        if not torch.cuda.is_available():
+            print("[QwenVL] CUDA requested but not available, falling back to CPU")
+            return "cpu"
+        if ":" in device:
+            try:
+                device_idx = int(device.split(":", 1)[1])
+                if device_idx >= torch.cuda.device_count():
+                    print(f"[QwenVL] CUDA device {device_idx} not available, using cuda:0")
+                    return "cuda:0"
+            except (ValueError, IndexError):
+                print(f"[QwenVL] Invalid CUDA device format '{device}', using cuda:0")
+                return "cuda:0"
+        return device
+
+    if device == "mps":
+        if not (getattr(torch.backends, "mps", None) and torch.backends.mps.is_available()):
+            print("[QwenVL] MPS requested but not available, falling back to CPU")
+            return "cpu"
+        return "mps"
+
+    return device
+
+def flash_attn_available():
+    if not torch.cuda.is_available():
+        return False
+
+    if platform.system().lower() != "linux":
+        return False
+
+    major, _ = torch.cuda.get_device_capability()
+    if major < 8:
+        return False
+
+    try:
+        import flash_attn  # noqa: F401
+    except Exception:
+        return False
+
+    try:
+        import importlib.metadata as importlib_metadata
+        _ = importlib_metadata.version("flash_attn")
+    except Exception:
+        return False
+
+    return True
+
+def sage_attn_available():
+    """Check if SageAttention is available and GPU supports it."""
+    if not SAGE_ATTENTION_AVAILABLE:
+        return False
+    if not torch.cuda.is_available():
+        return False
+    major, _ = torch.cuda.get_device_capability()
+    if major < 8:
+        return False
+    return True
+
+
+def get_sage_attention_config():
+    """Get the appropriate SageAttention kernel based on GPU architecture."""
+    if not sage_attn_available():
+        return None, None, None
+
+    major, minor = torch.cuda.get_device_capability()
+    arch_code = major * 10 + minor
+
+    attn_func = None
+    pv_accum_dtype = "fp32"
+
+    if arch_code >= 120:  # Blackwell
+        pv_accum_dtype = "fp32+fp32"
+        attn_func = sageattn_qk_int8_pv_fp8_cuda
+        print(f"[QwenVL] SageAttention: Using SM120 (Blackwell) FP8 kernel")
+    elif arch_code >= 90:  # Hopper
+        pv_accum_dtype = "fp32+fp32"
+        attn_func = sageattn_qk_int8_pv_fp8_cuda_sm90
+        print(f"[QwenVL] SageAttention: Using SM90 (Hopper) FP8 kernel")
+    elif arch_code == 89:  # Ada Lovelace
+        pv_accum_dtype = "fp32+fp32"
+        attn_func = sageattn_qk_int8_pv_fp8_cuda
+        print(f"[QwenVL] SageAttention: Using SM89 (Ada) FP8 kernel")
+    elif arch_code >= 80:  # Ampere
+        pv_accum_dtype = "fp32"
+        attn_func = sageattn_qk_int8_pv_fp16_cuda
+        print(f"[QwenVL] SageAttention: Using SM80+ (Ampere) FP16 kernel")
+    else:
+        print(f"[QwenVL] SageAttention not supported on SM{arch_code}")
+        return None, None, None
+
+    return attn_func, "per_warp", pv_accum_dtype
+
+def is_fp8_model(model_name: str) -> bool:
+    """Check if model name indicates it's a pre-quantized FP8 model."""
+    fp8_indicators = ["-fp8", "_fp8", "-FP8", "_FP8"]
+    return any(indicator in model_name for indicator in fp8_indicators)
+
+def resolve_attention_mode(mode, force_sdpa=False):
+    """Resolve attention mode with fallback logic.
+
+    Args:
+        mode: The requested attention mode
+        force_sdpa: If True, always return SDPA (for FP8/BnB models)
+    """
+    if force_sdpa:
+        return "sdpa"
+
+    if mode == "sdpa":
+        return "sdpa"
+    if mode == "sage":
+        if sage_attn_available():
+            return "sage"
+        print("[QwenVL] SageAttention forced but unavailable, falling back to SDPA")
+        return "sdpa"
+    if mode == "flash_attention_2":
+        if flash_attn_available():
+            return "flash_attention_2"
+        print("[QwenVL] Flash-Attn forced but unavailable, falling back to SDPA")
+        return "sdpa"
+
+    # Auto mode: try sage → flash → sdpa
+    if sage_attn_available():
+        print("[QwenVL] Auto mode: Using SageAttention")
+        return "sage"
+    if flash_attn_available():
+        print("[QwenVL] Auto mode: Using Flash Attention 2")
+        return "flash_attention_2"
+    print("[QwenVL] Auto mode: Using SDPA")
+    return "sdpa"
+
+
+
+def ensure_model(model_name, require_processor=False, node_id=None, progress_label: str | None = None, hf_token: str | None = None):
+    model_name = resolve_model_catalog_name(HF_ALL_MODELS, model_name)
+    info = HF_ALL_MODELS.get(model_name)
+    if not info:
+        raise ValueError(f"Model '{model_name}' not in config")
+
+    # Local models have a direct path — use it, skip download
+    local_path = info.get("local_path")
+    if local_path:
+        target = Path(local_path)
+        if target.exists() and target.is_dir():
+            enforce_model_access(info, model_name, local_exists=True, hf_token=hf_token)
+            return str(target)
+        enforce_model_access(info, model_name, local_exists=False, hf_token=hf_token)
+        raise FileNotFoundError(f"[QwenVL] Local HF model directory not found: {target}")
+
+    repo_id = info.get("repo_id")
+    if not repo_id:
+        raise ValueError(f"Model '{model_name}' has no repo_id or local_path")
+
+    if COMMERCIAL_RELEASE:
+        enforce_model_access(info, model_name, local_exists=False, hf_token=hf_token)
+        target = Path(folder_paths.models_dir) / "LLM" / repo_id.split("/")[-1]
+        if _model_snapshot_has_required_files(target, require_processor=require_processor):
+            enforce_model_access(info, model_name, local_exists=True, hf_token=hf_token)
+            return str(target)
+        raise FileNotFoundError(
+            f"[QwenVL] Locked commercial model is missing or incomplete: {target}"
+        )
+
+    # Use ComfyUI's multi-path system if available
+    llm_paths = folder_paths.get_folder_paths("LLM") if "LLM" in folder_paths.folder_names_and_paths else []
+    if llm_paths:
+        models_dir = Path(llm_paths[0]) / "Qwen-VL"
+    else:
+        # Fallback to default behavior
+        models_dir = Path(folder_paths.models_dir) / "LLM" / "Qwen-VL"
+
+    models_dir.mkdir(parents=True, exist_ok=True)
+    target = models_dir / repo_id.split("/")[-1]
+
+    # Only trust an existing snapshot if it also contains the metadata needed
+    # by the selected backend. This avoids reusing stale or partial downloads.
+    if _model_snapshot_has_required_files(target, require_processor=require_processor):
+        enforce_model_access(info, model_name, local_exists=True, hf_token=hf_token)
+        return str(target)
+
+    enforce_model_access(info, repo_id, local_exists=False, hf_token=hf_token)
+
+    if target.exists() and target.is_dir():
+        print(f"[QwenVL] Existing model snapshot is incomplete, refreshing: {target}")
+
+    _download_model_snapshot(
+        repo_id,
+        target,
+        node_id=node_id,
+        progress_label=progress_label or f"QwenVL HF Download: {model_name}",
+        hf_token=hf_token,
+    )
+
+    if not _model_snapshot_has_required_files(target, require_processor=require_processor):
+        print(f"[QwenVL] Refreshed snapshot is still incomplete, retrying clean download: {target}")
+        _download_model_snapshot(
+            repo_id,
+            target,
+            force_clean_target=True,
+            node_id=node_id,
+            progress_label=progress_label or f"QwenVL HF Download: {model_name}",
+            hf_token=hf_token,
+        )
+
+    if not _model_snapshot_has_required_files(target, require_processor=require_processor):
+        missing = []
+        if not (target / "config.json").exists():
+            missing.append("config.json")
+        if require_processor and not any(
+            (target / name).exists()
+            for name in (
+                "preprocessor_config.json",
+                "processor_config.json",
+                "image_processor_config.json",
+                "video_preprocessor_config.json",
+            )
+        ):
+            missing.append("processor metadata")
+        if not _model_snapshot_has_weights(target):
+            missing.append("model weights")
+        missing_str = ", ".join(missing) if missing else "required files"
+        raise FileNotFoundError(
+            f"[QwenVL] Downloaded model snapshot is incomplete for {repo_id}: missing {missing_str} in {target}"
+        )
+
+    return str(target)
+
+def enforce_memory(model_name, quantization, device_info):
+    info = HF_ALL_MODELS.get(model_name, {})
+    requirements = info.get("vram_requirement", {})
+    mapping = {
+        Quantization.Q4: requirements.get("4bit", 0),
+        Quantization.Q8: requirements.get("8bit", 0),
+        Quantization.FP16: requirements.get("full", 0),
+    }
+    needed = mapping.get(quantization, 0)
+    if not needed:
+        return quantization  # Always return quantization
+
+    if device_info["recommended_device"] in {"cpu", "mps"}:
+        needed *= 1.5
+        available = device_info["system_memory"]["available"]
+    else:
+        available = device_info["gpu"]["free_memory"]
+
+    # More conservative memory management
+    if needed * 1.5 > available:  # More conservative threshold
+        if quantization == Quantization.FP16:
+            print("[QwenVL] ⚠️  Auto-switch to 8-bit due to VRAM pressure")
+            return Quantization.Q8
+        if quantization == Quantization.Q8:
+            print("[QwenVL] ⚠️  Auto-switch to 4-bit due to VRAM pressure")
+            return Quantization.Q4
+        raise RuntimeError(f"Insufficient memory for {quantization.value} mode. Required: {needed * 1.5:.1f}GB, Available: {available / 1024**3:.1f}GB")
+
+    # Conservative memory check with safety margin
+    if needed * 1.3 > available:  # Reduced from 1.5 to 1.3
+        if quantization == Quantization.FP16:
+            print("[QwenVL] ⚠️  Auto-switch to 8-bit due to VRAM pressure")
+            return Quantization.Q8
+        if quantization == Quantization.Q8:
+            print("[QwenVL] ⚠️  Auto-switch to 4-bit due to VRAM pressure")
+            return Quantization.Q4
+        print(f"[QwenVL] Memory pressure detected. Consider: 1) Use 4-bit quantization, 2) Reduce max_tokens below 1024, 3) Close other applications")
+        return quantization  # Always return quantization
+
+def quantization_config(model_name, quantization):
+    info = HF_ALL_MODELS.get(model_name, {})
+    if info.get("quantized"):
+        return None, None
+    if quantization == Quantization.Q4:
+        cfg = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+        )
+        return cfg, None
+    if quantization == Quantization.Q8:
+        return BitsAndBytesConfig(load_in_8bit=True), None
+    return None, torch.float16

thinkingllm_core/hf_runtime.py

@@ -0,0 +1,665 @@
+"""Hugging Face multimodal runtime independent from ComfyUI node declarations."""
+
+import gc
+import time
+
+import numpy as np
+import torch
+from PIL import Image
+try:
+    from transformers import AutoProcessor, AutoTokenizer
+except ImportError:
+    AutoProcessor = None
+    AutoTokenizer = None
+try:
+    from transformers import AutoModelForVision2Seq
+except ImportError:
+    from transformers import AutoModelForImageTextToText as AutoModelForVision2Seq
+
+import folder_paths
+from AILab_StreamDisplay import TerminalStreamDisplay
+from comfy.model_management import throw_exception_if_processing_interrupted
+
+from thinkingllm_core.hf_models import (
+    COMMERCIAL_RELEASE,
+    HF_ALL_MODELS,
+    NO_PRESET_PROMPT,
+    SYSTEM_PROMPTS,
+    Quantization,
+    ensure_cuda_vram_headroom,
+    ensure_model,
+    get_device_info,
+    is_fp8_model,
+    normalize_device_choice,
+    quantization_config,
+    read_hf_model_type,
+    resolve_attention_mode,
+)
+from thinkingllm_core.media import (
+    MASK_FOCUS_INSTRUCTION,
+    apply_mask_highlight,
+    get_image_hash,
+    get_video_hash,
+)
+from thinkingllm_core.model_access import resolve_model_catalog_name
+from thinkingllm_core.prompt_contracts import (
+    apply_qwen_soft_thinking_directive,
+    apply_video_duration_context,
+    ensure_video_prompt_duration,
+    resolve_qwen_context_window,
+    resolve_qwen_thinking_mode,
+    resolve_video_duration,
+    validate_minimax_reference_request,
+    validate_minimax_source_duration,
+)
+from thinkingllm_core.prompt_state import (
+    PROMPT_CACHE,
+    build_node_input_signature,
+    get_cache_key,
+    get_node_saved_prompt_with_seed,
+    log_llm_input,
+    save_prompt_cache,
+    set_node_saved_prompt,
+)
+
+_STREAM_HEARTBEAT_INTERVAL_SECONDS = 3.0
+
+
+def _maybe_emit_hf_stream_heartbeat(stage_label: str, started_at: float, last_status_at: float, full_text: str) -> float:
+    now = time.monotonic()
+    if (now - last_status_at) < _STREAM_HEARTBEAT_INTERVAL_SECONDS:
+        return last_status_at
+    elapsed = max(0.0, now - started_at)
+    print(f"[QwenVL HF] {stage_label}: still generating... ({len(full_text)} chars, {elapsed:.1f}s)")
+    return now
+
+
+class QwenVLBase:
+    def __init__(self):
+        self.device_info = get_device_info()
+        self.model = None
+        self.processor = None
+        self.tokenizer = None
+        self.current_signature = None
+        print(f"[QwenVL] Node on {self.device_info['device_type']}")
+
+    def clear(self):
+        self.model = None
+        self.processor = None
+        self.tokenizer = None
+        self.current_signature = None
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            try:
+                torch.cuda.ipc_collect()
+            except Exception:
+                pass
+
+    def load_model(
+        self,
+        model_name,
+        quant_value,
+        attention_mode,
+        use_compile,
+        device_choice,
+        keep_model_loaded,
+        unique_id=None,
+        hf_token: str | None = None,
+    ):
+        model_name = resolve_model_catalog_name(HF_ALL_MODELS, model_name)
+        model_info = HF_ALL_MODELS.get(model_name, {})
+        comfy_filename = model_info.get("comfy_text_encoder")
+        if comfy_filename:
+            model_path = folder_paths.get_full_path_or_raise("text_encoders", comfy_filename)
+            signature = (model_name, "comfy", model_path)
+            if keep_model_loaded and self.model is not None and self.current_signature == signature:
+                return
+            self.clear()
+            from comfy import sd as comfy_sd
+            self.model = comfy_sd.load_clip(
+                ckpt_paths=[model_path],
+                embedding_directory=folder_paths.get_folder_paths("embeddings"),
+            )
+            self.current_signature = signature
+            print(f"[QwenVL] Loaded shared ComfyUI text encoder: {comfy_filename}")
+            return
+
+        quant = Quantization.from_value(quant_value)  # Skip enforce_memory for now
+
+        # Safety check: ensure quant is not None
+        if quant is None:
+            print(f"[QwenVL] Invalid quantization value: {quant_value}, falling back to FP16")
+            quant = Quantization.FP16
+
+        # Check if BitsAndBytes quantization is being used
+        is_bnb_quantization = quant in [Quantization.Q4, Quantization.Q8]
+
+        # Check if this is a pre-quantized FP8 model
+        is_prequantized_fp8 = is_fp8_model(model_name) or HF_ALL_MODELS.get(model_name, {}).get("quantized", False)
+
+        # Determine if we need to force SDPA (for FP8 or BitsAndBytes models)
+        force_sdpa = is_prequantized_fp8 or is_bnb_quantization
+
+        # Resolve attention mode with force_sdpa flag
+        attn_impl = resolve_attention_mode(attention_mode, force_sdpa=force_sdpa)
+
+        # Additional info messages for forced SDPA
+        if force_sdpa and attention_mode in ["auto", "sage", "flash_attention_2"]:
+            if is_prequantized_fp8:
+                print("[QwenVL] FP8 model detected - forcing SDPA attention")
+            elif is_bnb_quantization:
+                print("[QwenVL] BitsAndBytes quantization detected - forcing SDPA attention")
+
+        print(f"[QwenVL] Attention backend selected: {attn_impl}")
+
+        device_requested = self.device_info["recommended_device"] if device_choice == "auto" else device_choice
+        device = normalize_device_choice(device_requested)
+        signature = (model_name, quant.value, attn_impl, device, use_compile)
+        if keep_model_loaded and self.model is not None and self.current_signature == signature:
+            ensure_cuda_vram_headroom("QwenVL", min_free_gb=1.0, min_free_ratio=0.08)
+            return
+        self.clear()
+        model_path = ensure_model(
+            model_name,
+            require_processor=True,
+            node_id=unique_id,
+            progress_label=f"QwenVL HF Download: {model_name}",
+            hf_token=hf_token,
+        )
+        quant_config, dtype = quantization_config(model_name, quant)
+
+        # Handle attention mode for loading
+        # SageAttention requires loading with SDPA first, then patching
+        actual_attn_impl = attn_impl
+        if attn_impl == "sage":
+            actual_attn_impl = "sdpa"
+
+        # MEMORY DEBUGGING: Check memory before loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            allocated_before = torch.cuda.memory_allocated() / 1024**3
+            reserved_before = torch.cuda.memory_reserved() / 1024**3
+            total_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            print(f"[QwenVL] 📊 Memory BEFORE load - Allocated: {allocated_before:.1f}GB, Reserved: {reserved_before:.1f}GB, Total: {total_memory:.1f}GB")
+
+            # Check what's using memory
+            if allocated_before > 2.0:
+                print(f"[QwenVL] ⚠️  WARNING: {allocated_before:.1f}GB already allocated before loading!")
+
+        # DEBUG: Print quantization config details
+        print(f"[QwenVL] 🔍 DEBUG - Model: {model_name}, Quant: {quant}, Quant config: {quant_config}")
+        print(f"[QwenVL] 🔍 DEBUG - Device: {device}, Dtype: {dtype}")
+        print(f"[QwenVL] 🔍 DEBUG - Attention impl: {actual_attn_impl}")
+
+        # Quantization is back - enforce_memory was the problem
+
+        load_kwargs = {
+            "device_map": "auto" if device != "cpu" and torch.cuda.is_available() else "cpu",
+            "dtype": dtype or torch.float16,
+            "attn_implementation": actual_attn_impl,
+            "local_files_only": COMMERCIAL_RELEASE,
+            "use_safetensors": True,
+            "low_cpu_mem_usage": True,
+        }
+
+        if device != "cpu" and torch.cuda.is_available():
+            gpu_mem = torch.cuda.get_device_properties(0).total_memory
+            gpu_mem_gb = max(1, int(gpu_mem / (1024**3)))
+            load_kwargs["max_memory"] = {
+                0: f"{gpu_mem_gb}GB",
+                "cpu": "16GB",
+            }
+
+        if quant_config:
+            load_kwargs["quantization_config"] = quant_config
+
+        self.model = AutoModelForVision2Seq.from_pretrained(model_path, **load_kwargs).eval()
+
+        # Apply SageAttention patching if needed
+        if attn_impl == "sage":
+            try:
+                from sageattention_patch import set_sage_attention
+                set_sage_attention(self.model)
+                print("[QwenVL] SageAttention patching applied successfully")
+            except Exception as e:
+                print(f"[QwenVL] SageAttention patching failed: {e}")
+                print("[QwenVL] Falling back to SDPA attention")
+                # Model is already loaded with SDPA, so we can continue
+
+        # MEMORY CLEANUP: Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+            print(f"[QwenVL] GPU memory after load: {torch.cuda.memory_allocated() / 1024**3:.1f}GB / {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB")
+
+        self.model.config.use_cache = True
+        if hasattr(self.model, "generation_config"):
+            self.model.generation_config.use_cache = True
+        if use_compile and device.startswith("cuda") and torch.cuda.is_available():
+            try:
+                self.model = torch.compile(self.model, mode="reduce-overhead")
+                print("[QwenVL] torch.compile enabled")
+            except Exception as exc:
+                print(f"[QwenVL] torch.compile skipped: {exc}")
+        self.processor = AutoProcessor.from_pretrained(
+            model_path,
+            local_files_only=COMMERCIAL_RELEASE,
+            trust_remote_code=not COMMERCIAL_RELEASE,
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            model_path,
+            local_files_only=COMMERCIAL_RELEASE,
+            trust_remote_code=not COMMERCIAL_RELEASE,
+        )
+        # Detect architecture from config.json instead of relying on model name
+        hf_model_type = read_hf_model_type(model_path)
+        self.hf_model_type = hf_model_type
+        self.is_qwen35 = hf_model_type in ("qwen3_5", "qwen3_5_moe", "qwen3_5_vl") if hf_model_type else "qwen3.5-" in model_name.lower()
+        self.supports_qwen_soft_think = hf_model_type == "qwen3" if hf_model_type else "qwen3-" in model_name.lower()
+        if self.is_qwen35:
+            print(f"[QwenVL] Qwen3.5 detected (model_type={hf_model_type}): Will disable thinking in chat template.")
+        self.current_signature = signature
+
+    @staticmethod
+    def tensor_to_pil(tensor):
+        if tensor is None:
+            return None
+        if tensor.dim() == 4:
+            tensor = tensor[0]
+        array = (tensor.cpu().numpy() * 255).clip(0, 255).astype(np.uint8)
+        if array.ndim == 2:
+            return Image.fromarray(array, mode="L")
+        if array.shape[-1] == 1:
+            return Image.fromarray(array[..., 0], mode="L")
+        if array.shape[-1] == 4:
+            return Image.fromarray(array, mode="RGBA")
+        return Image.fromarray(array[..., :3], mode="RGB")
+
+    @torch.no_grad()
+    def generate(
+        self,
+        prompt_text,
+        image,
+        video,
+        frame_count,
+        max_tokens,
+        temperature,
+        top_p,
+        num_beams,
+        repetition_penalty,
+        model_name="",
+        stream_to_terminal=False,
+        enable_thinking=True,
+        seed=0,
+        preset_name="",
+    ):
+        model_info = HF_ALL_MODELS.get(model_name, {})
+        native_family = model_info.get("native_family")
+        if native_family:
+            if num_beams != 1:
+                raise ValueError("[QwenVL] ComfyUI text encoders support num_beams=1 only")
+            if native_family == "gemma3" and video is not None:
+                raise ValueError("[QwenVL] Gemma 3 shared text encoders support text and image input, not video")
+
+            tokenize_kwargs = {"skip_template": False, "thinking": bool(enable_thinking)}
+            if native_family == "gemma3":
+                tokenize_kwargs["image"] = image[:1] if image is not None else None
+            else:
+                images = []
+                if image is not None:
+                    if image.dim() == 4 and image.shape[0] > 1:
+                        print(f"[QwenVL] IMAGE input contains {image.shape[0]} items; using the first item only. Use the video input for multi-frame analysis.")
+                    images.append(image[:1] if image.dim() == 4 else image)
+                if video is not None:
+                    frame_indexes = list(range(video.shape[0]))
+                    if len(frame_indexes) > frame_count:
+                        frame_indexes = np.linspace(0, len(frame_indexes) - 1, frame_count, dtype=int).tolist()
+                    images.extend(video[index:index + 1] for index in frame_indexes)
+                tokenize_kwargs["images"] = images
+
+            throw_exception_if_processing_interrupted()
+            log_llm_input(
+                "QwenVL ComfyUI Native",
+                "INITIAL GENERATION",
+                preset_name,
+                prompt_text,
+                media={
+                    "image": 1 if image is not None else 0,
+                    "video_frames": max(0, len(tokenize_kwargs.get("images", [])) - (1 if image is not None else 0)),
+                },
+            )
+            tokens = self.model.tokenize(prompt_text, **tokenize_kwargs)
+            output_tokens = self.model.generate(
+                tokens,
+                do_sample=True,
+                max_length=max_tokens,
+                temperature=temperature,
+                top_k=50,
+                top_p=top_p,
+                min_p=0.0,
+                repetition_penalty=repetition_penalty,
+                seed=seed,
+                presence_penalty=0.0,
+            )
+            throw_exception_if_processing_interrupted()
+            raw_text = self.model.decode(output_tokens).strip()
+            if not raw_text:
+                raise RuntimeError(
+                    "[QwenVL] The model ended generation without producing text. Change the seed or add a more "
+                    "specific custom prompt; the empty result was not cached."
+                )
+            if stream_to_terminal:
+                print("[QwenVL] ComfyUI native generation completed (live token streaming is unavailable):")
+                print(raw_text)
+            return raw_text, raw_text
+
+        # Memory optimization: clear cache before generation
+        ensure_cuda_vram_headroom("QwenVL", min_free_gb=1.0, min_free_ratio=0.08)
+        supports_soft_think = getattr(self, "supports_qwen_soft_think", False)
+        is_qwen35 = getattr(self, "is_qwen35", False)
+        context_window = resolve_qwen_context_window(getattr(self.model, "config", None))
+
+        def _build_processed(thinking_enabled: bool):
+            effective_prompt_text = apply_qwen_soft_thinking_directive(
+                prompt_text,
+                thinking_enabled,
+                supports_soft_switch=supports_soft_think,
+            )
+            conversation = [{"role": "user", "content": []}]
+            if image is not None:
+                if image.dim() == 4 and image.shape[0] > 1:
+                    print(f"[QwenVL] IMAGE input contains {image.shape[0]} items; using the first item only. Use the video input for multi-frame analysis.")
+                conversation[0]["content"].append({"type": "image", "image": self.tensor_to_pil(image)})
+            if video is not None:
+                frames = [self.tensor_to_pil(frame) for frame in video]
+                if len(frames) > frame_count:
+                    idx = np.linspace(0, len(frames) - 1, frame_count, dtype=int)
+                    frames = [frames[i] for i in idx]
+                if frames:
+                    conversation[0]["content"].append({"type": "video", "video": frames})
+            conversation[0]["content"].append({"type": "text", "text": effective_prompt_text})
+
+            chat_kwargs = {}
+            if is_qwen35 or supports_soft_think:
+                chat_kwargs["enable_thinking"] = thinking_enabled
+
+            chat = self.processor.apply_chat_template(
+                conversation,
+                tokenize=False,
+                add_generation_prompt=True,
+                **chat_kwargs
+            )
+
+            images = [item["image"] for item in conversation[0]["content"] if item["type"] == "image"]
+            video_frames = [frame for item in conversation[0]["content"] if item["type"] == "video" for frame in item["video"]]
+            videos = [video_frames] if video_frames else None
+            processed = self.processor(text=chat, images=images or None, videos=videos, return_tensors="pt")
+            return effective_prompt_text, chat, processed, {
+                "image": len(images),
+                "video_frames": len(video_frames),
+            }
+
+        requested_thinking = bool(enable_thinking)
+        effective_prompt_text, chat, processed, media = _build_processed(requested_thinking)
+        input_ids = processed.get("input_ids")
+        prompt_tokens = int(input_ids.shape[-1]) if torch.is_tensor(input_ids) else 0
+        effective_thinking = resolve_qwen_thinking_mode(
+            enable_thinking,
+            max_tokens,
+            label="QwenVL HF",
+            prompt_tokens=prompt_tokens,
+            context_window=context_window,
+            quiet=stream_to_terminal,
+        )
+        if effective_thinking != requested_thinking:
+            effective_prompt_text, chat, processed, media = _build_processed(effective_thinking)
+        if supports_soft_think:
+            directive = "/think" if effective_thinking else "/no_think"
+            print(f"[QwenVL] Qwen3 detected: Thinking {'enabled' if effective_thinking else 'disabled'} via chat template and {directive}.")
+
+        # Move to device more efficiently
+        model_device = next(self.model.parameters()).device
+        model_inputs = {
+            key: value.to(model_device, non_blocking=True) if torch.is_tensor(value) else value
+            for key, value in processed.items()
+        }
+        stop_tokens = [self.tokenizer.eos_token_id]
+        if hasattr(self.tokenizer, "eot_id") and self.tokenizer.eot_id is not None:
+            stop_tokens.append(self.tokenizer.eot_id)
+
+        # Memory-efficient generation parameters
+        kwargs = {
+            "max_new_tokens": max_tokens,
+            "repetition_penalty": repetition_penalty,
+            "num_beams": num_beams,
+            "eos_token_id": stop_tokens,
+            "pad_token_id": self.tokenizer.pad_token_id,
+        }
+        if num_beams == 1:
+            kwargs.update({"do_sample": True, "temperature": temperature, "top_p": top_p})
+            # --- Qwen3.5 Heretic Logic: Top K ---
+            if is_qwen35:
+                kwargs["top_k"] = 20
+                print("[QwenVL] Qwen3.5 detected: Forcing top_k=20 for recommended tuning.")
+        else:
+            kwargs["do_sample"] = False
+
+        log_llm_input(
+            "QwenVL HF",
+            "INITIAL GENERATION",
+            preset_name,
+            effective_prompt_text,
+            formatted_text=chat,
+            media=media,
+        )
+
+        # Optional: staged readable terminal streaming
+        if stream_to_terminal:
+            try:
+                from AILab_StreamDisplay import TerminalStreamDisplay
+                from transformers import TextIteratorStreamer
+                from threading import Thread
+                stage_label = "STREAMING"
+                stream_display = TerminalStreamDisplay("QwenVL HF", suppress_planning=True, compact=True)
+                streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+                kwargs["streamer"] = streamer
+                thread = Thread(target=self.model.generate, kwargs={**model_inputs, **kwargs})
+                stream_display.start_stage(stage_label)
+                thread.start()
+                full_streamed = ""
+                for token_str in streamer:
+                    if token_str:
+                        throw_exception_if_processing_interrupted()
+                        full_streamed += token_str
+                        stream_display.push_compact(token_str)
+                thread.join()
+                stream_display.end_compact()
+                stream_display.end_stage()
+                if not full_streamed.strip():
+                    raise RuntimeError("[QwenVL] HF streaming returned empty response")
+                cleaned_text = full_streamed.strip()
+                raw_text = full_streamed.strip()
+                return cleaned_text, raw_text
+            except ImportError:
+                print("[QwenVL] TextIteratorStreamer not available — falling back to non-streaming")
+                stream_to_terminal = False
+
+        # Generate with interrupt support via background thread
+        import threading, queue as qmod
+        abort_event = threading.Event()
+        output_queue: qmod.Queue = qmod.Queue()
+        worker_error: Exception | None = None
+
+        def _generate_worker():
+            nonlocal worker_error
+            try:
+                result = self.model.generate(**model_inputs, **kwargs)
+                output_queue.put(("ok", result))
+            except Exception as exc:
+                worker_error = exc
+                output_queue.put(("error", None))
+
+        worker = threading.Thread(target=_generate_worker, daemon=True)
+        worker.start()
+        try:
+            while True:
+                try:
+                    kind, result = output_queue.get(timeout=0.25)
+                except qmod.Empty:
+                    throw_exception_if_processing_interrupted()
+                    continue
+                if kind == "error":
+                    break
+                outputs = result
+                break
+        finally:
+            abort_event.set()
+            worker.join(timeout=5.0)
+        if worker_error:
+            raise worker_error
+        throw_exception_if_processing_interrupted()
+
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()
+        input_len = model_inputs["input_ids"].shape[-1]
+        raw_text = self.tokenizer.decode(outputs[0, input_len:], skip_special_tokens=True).strip()
+        cleaned_text = raw_text  # generate() returns raw; caller cleans if needed
+        return cleaned_text, raw_text
+
+    def run(self, model_name, quantization, preset_prompt, custom_prompt, image, video, frame_count, max_tokens, temperature, top_p, num_beams, repetition_penalty, seed, keep_model_loaded, attention_mode, use_torch_compile, device, keep_last_prompt=False, unique_id=None, extra_pnginfo=None, node_class="QwenVL", stream_to_terminal=False, enable_thinking=True, hf_token: str | None = None, mask=None, llm_input_preset_name: str | None = None, duration_seconds=5.0):
+        model_name = resolve_model_catalog_name(HF_ALL_MODELS, model_name)
+        validate_minimax_reference_request(preset_prompt, custom_prompt)
+        duration_preset_name = llm_input_preset_name or preset_prompt
+        resolved_duration = resolve_video_duration(duration_preset_name, duration_seconds)
+        validate_minimax_source_duration(duration_preset_name, duration_seconds, custom_prompt)
+        effective_duration_seconds = resolved_duration["effective_seconds"] if resolved_duration else None
+        duration_signature = ({
+            "effective_duration_seconds": effective_duration_seconds,
+            "video_prompt_contract_version": resolved_duration.get("contract_version"),
+        } if resolved_duration else {})
+        torch.manual_seed(seed)
+        image, mask_hash = apply_mask_highlight(image, mask)
+        image_hash = get_image_hash(image)
+        if mask_hash:
+            image_hash = f"{image_hash}:{mask_hash}"
+        video_hash = get_video_hash(video)
+        input_signature = build_node_input_signature(
+            model_name=model_name,
+            quantization=quantization,
+            preset_prompt=preset_prompt,
+            custom_prompt=custom_prompt,
+            image_hash=image_hash,
+            video_hash=video_hash,
+            frame_count=frame_count,
+            attention_mode=attention_mode,
+            use_torch_compile=bool(use_torch_compile),
+            device=device,
+            enable_thinking=bool(enable_thinking),
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            repetition_penalty=repetition_penalty,
+            **duration_signature,
+        )
+
+        # Auto-retrieve saved prompt when seed is fixed
+        saved = get_node_saved_prompt_with_seed(node_class, unique_id, extra_pnginfo, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
+        if saved and not stream_to_terminal:
+            print(f"[QwenVL] Preset {llm_input_preset_name or preset_prompt}: fixed seed {seed} matched; no LLM call was made.")
+            return (saved,)
+        if saved and stream_to_terminal:
+            pass
+        if keep_last_prompt:
+            print(f"[QwenVL] Keep last prompt enabled — looking up per-node state")
+            if saved:
+                print(f"[QwenVL] Preset {llm_input_preset_name or preset_prompt}: using saved prompt; no LLM call was made.")
+                return (saved,)
+            else:
+                print(f"[QwenVL] No per-node prompt found, returning empty")
+                return ("",)
+
+        # Always generate unless keep_last_prompt was requested
+        if not stream_to_terminal:
+            print(f"[QwenVL] Generating new prompt")
+
+        prompt_template = "" if preset_prompt == NO_PRESET_PROMPT else SYSTEM_PROMPTS.get(preset_prompt, preset_prompt)
+
+        # Generate cache key with all inputs including seed
+        cache_key = get_cache_key(model_name, preset_prompt, custom_prompt, image_hash, video_hash, seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, enable_thinking=enable_thinking, effective_duration_seconds=effective_duration_seconds, video_prompt_contract_version=resolved_duration.get("contract_version") if resolved_duration else None)
+
+        # Check cache first (only for random mode)
+        if cache_key in PROMPT_CACHE:
+            cached_text = PROMPT_CACHE[cache_key].get("text", "")
+            if cached_text:
+                print(f"[QwenVL] Preset {llm_input_preset_name or preset_prompt}: cache hit for seed {seed}; no LLM call was made.")
+                return (cached_text,)
+
+        if custom_prompt and custom_prompt.strip():
+            # Combine user input with template - custom prompt first for priority
+            prompt = f"{custom_prompt.strip()}\n\n{prompt_template}" if prompt_template else custom_prompt.strip()
+        else:
+            prompt = prompt_template
+        if mask_hash:
+            prompt = f"{prompt}\n\n{MASK_FOCUS_INSTRUCTION}".strip()
+        prompt = apply_video_duration_context(prompt, duration_preset_name, duration_seconds)
+
+        self.load_model(
+            model_name,
+            quantization,
+            attention_mode,
+            use_torch_compile,
+            device,
+            keep_model_loaded,
+            unique_id=unique_id,
+            hf_token=hf_token,
+        )
+        hf_token = None
+        try:
+            text, raw_text = self.generate(
+                prompt,
+                image,
+                video,
+                frame_count,
+                max_tokens,
+                temperature,
+                top_p,
+                num_beams,
+                repetition_penalty,
+                model_name=model_name,
+                stream_to_terminal=stream_to_terminal,
+                enable_thinking=enable_thinking,
+                seed=seed,
+                preset_name=llm_input_preset_name or preset_prompt,
+            )
+            text = ensure_video_prompt_duration(
+                text,
+                duration_preset_name,
+                duration_seconds,
+                source_prompt_text=custom_prompt,
+            )
+
+            # Cache the generated text
+            PROMPT_CACHE[cache_key] = {
+                "text": text,
+                "timestamp": torch.cuda.Event().record() if torch.cuda.is_available() else None,
+                "model": model_name,
+                "preset": preset_prompt,
+                "seed": seed,
+                "image_hash": image_hash,
+                "mask_hash": mask_hash,
+                "video_hash": video_hash,
+                **duration_signature,
+            }
+            save_prompt_cache()  # Save cache to file
+
+            print(f"[QwenVL] Cached new prompt for seed {seed}: {cache_key[:8]}...")
+
+            # Save the generated prompt for future per-node keep-last-prompt
+            set_node_saved_prompt(node_class, unique_id, extra_pnginfo, text, raw_trace=raw_text, seed=seed, max_tokens=max_tokens, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, input_signature=input_signature)
+            print(f"[QwenVL] Saved per-node prompt: {text[:50]}...")
+
+            return (text,)
+        finally:
+            if not keep_model_loaded:
+                self.clear()

thinkingllm_core/media.py

@@ -0,0 +1,110 @@
+"""Media hashing and mask-focus helpers shared by HF and GGUF backends."""
+
+import hashlib
+
+import torch
+
+MASK_FOCUS_INSTRUCTION = (
+    "The image has a mask highlight: the selected area is shown at normal brightness and the surrounding "
+    "context is dimmed. Analyze and describe only the normal-brightness selected area. Use the dimmed "
+    "surroundings only for spatial context and do not describe them."
+)
+
+
+def tensor_to_pil(tensor):
+    """Convert tensor to PIL Image with memory optimization"""
+    if tensor is None:
+        return None
+    try:
+        if tensor.dim() == 4:
+            tensor = tensor[0]
+
+        # More aggressive memory management
+        if tensor.is_floating_point():
+            # Scale to 0-255 range more efficiently
+            tensor = tensor.clamp(0, 1)
+
+        # Reduce sample size for memory efficiency
+        array = tensor.cpu().numpy()
+        if tensor.numel() > 0:
+            # Take smaller sample for hash to save memory
+            sample_size = min(50, tensor.numel() // 4)  # Reduced from 100
+            sample_pixels = array.flatten()[:sample_size].tolist() if array.size > 0 else []
+        else:
+            sample_pixels = []
+
+        content = f"{tensor.shape}_{tensor.dtype}_{sample_pixels[:10]}"
+        return hashlib.md5(content.encode()).hexdigest()[:16]
+    except:
+        return None
+
+def get_image_hash(image):
+    """Generate hash for image tensor"""
+    if image is None:
+        return None
+    try:
+        # Use image tensor properties for hash
+        shape = str(image.shape)
+        dtype = str(image.dtype)
+        # Sample a few pixels for content hash (avoid full tensor for performance)
+        if len(image.shape) >= 3:
+            sample_pixels = image.flatten()[:100].tolist() if image.numel() > 0 else []
+        else:
+            sample_pixels = image.flatten().tolist() if image.numel() > 0 else []
+
+        content = f"{shape}_{dtype}_{sample_pixels[:10]}"  # Limit sample size
+        return hashlib.md5(content.encode()).hexdigest()[:16]
+    except:
+        return None
+
+
+def apply_mask_highlight(image, mask):
+    """Dim pixels outside the first ComfyUI mask while preserving image shape and alpha."""
+    if mask is None:
+        return image, None
+    if image is None:
+        raise ValueError("[QwenVL] A mask requires an image input.")
+    if not torch.is_tensor(image) or image.ndim not in (3, 4):
+        raise ValueError("[QwenVL] IMAGE must have shape [H,W,C] or [B,H,W,C].")
+    if not torch.is_tensor(mask):
+        raise ValueError("[QwenVL] MASK must be a tensor.")
+
+    if mask.ndim == 2:
+        selected_mask = mask
+    elif mask.ndim == 3:
+        selected_mask = mask[0]
+    else:
+        raise ValueError("[QwenVL] MASK must have shape [H,W] or [B,H,W].")
+
+    selected_mask = selected_mask.detach().float().clamp(0.0, 1.0)
+    if not torch.isfinite(selected_mask).all():
+        raise ValueError("[QwenVL] MASK contains non-finite values.")
+    if not torch.any(selected_mask > 0):
+        raise ValueError("[QwenVL] MASK is empty; select at least one pixel.")
+
+    frame = image[0] if image.ndim == 4 else image
+    resized_mask = torch.nn.functional.interpolate(
+        selected_mask[None, None],
+        size=frame.shape[:2],
+        mode="bilinear",
+        align_corners=False,
+    )[0, 0].to(device=frame.device, dtype=frame.dtype)
+    brightness = 0.2 + 0.8 * resized_mask
+
+    highlighted_frame = frame.clone()
+    color_channels = min(int(frame.shape[-1]), 3)
+    highlighted_frame[..., :color_channels] *= brightness.unsqueeze(-1)
+    highlighted = image.clone()
+    if image.ndim == 4:
+        highlighted[0] = highlighted_frame
+    else:
+        highlighted = highlighted_frame
+
+    digest = hashlib.md5()
+    digest.update(str(tuple(mask.shape)).encode("ascii"))
+    digest.update(mask.detach().contiguous().cpu().numpy().tobytes())
+    return highlighted, digest.hexdigest()[:16]
+
+def get_video_hash(video):
+    """Generate hash for video tensor (same as image)"""
+    return get_image_hash(video)

thinkingllm_core/model_access.py

@@ -0,0 +1,449 @@
+"""Model catalog policy and authenticated Hugging Face download helpers."""
+
+import inspect
+import os
+import shutil
+import time
+from pathlib import Path
+
+try:
+    from huggingface_hub import hf_hub_download, snapshot_download
+except ImportError:
+    from huggingface_hub import snapshot_download
+    hf_hub_download = None
+try:
+    from tqdm.auto import tqdm
+except ImportError:
+    tqdm = None
+try:
+    from comfy.utils import ProgressBar
+except Exception:
+    ProgressBar = None
+try:
+    from server import PromptServer
+except Exception:
+    PromptServer = None
+
+COMMERCIAL_RELEASE = os.environ.get("THINKINGLLM_COMMERCIAL_RELEASE") == "1"
+_DOWNLOAD_STATUS_INTERVAL_SECONDS = 0.25
+_HF_TOKEN_ENV_VARS = ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN")
+VALID_COMMERCIAL_STATUSES = {"cleared", "external_gated", "unclear", "noncommercial"}
+MODEL_STATUS_PRESENTATION = {
+    "cleared": (0, "✅ Commercial | "),
+    "external_gated": (1, "🔑 External / gated | "),
+    "local": (2, "📁 Local / user-supplied | "),
+    "unclear": (3, "⚠ Rights unclear | "),
+    "noncommercial": (4, "🚫 Non-commercial | "),
+}
+
+
+def _format_download_size(num_bytes) -> str:
+    if num_bytes is None:
+        return "? B"
+    value = float(num_bytes)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    for unit in units:
+        if value < 1024.0 or unit == units[-1]:
+            if unit == "B":
+                return f"{int(value)} {unit}"
+            return f"{value:.1f} {unit}"
+        value /= 1024.0
+    return f"{value:.1f} TB"
+
+
+class _DownloadProgressReporter:
+    def __init__(self, node_id=None, label: str = "QwenVL Download", repo_id: str | None = None):
+        self.node_id = node_id
+        self.label = label
+        self.repo_id = repo_id
+        self.progress_bar = ProgressBar(1, node_id=node_id) if ProgressBar is not None else None
+        self._last_text_at = 0.0
+        self._last_terminal_at = 0.0
+        self._last_percent = None
+
+    def _emit_ui_text(self, text: str, *, force: bool = False) -> None:
+        if PromptServer is None or self.node_id is None:
+            return
+        now = time.monotonic()
+        if not force and (now - self._last_text_at) < _DOWNLOAD_STATUS_INTERVAL_SECONDS:
+            return
+        PromptServer.instance.send_progress_text(text, self.node_id)
+        self._last_text_at = now
+
+    def _emit_terminal_text(self, text: str, *, force: bool = False) -> None:
+        now = time.monotonic()
+        if not force and (now - self._last_terminal_at) < _DOWNLOAD_STATUS_INTERVAL_SECONDS:
+            return
+        print(text)
+        self._last_terminal_at = now
+
+    def _build_message(self, stage: str, detail: str | None = None, current: int | float | None = None, total: int | float | None = None) -> str:
+        lines = [self.label, f"Stage: {stage}"]
+        if self.repo_id:
+            lines.append(f"Source: {self.repo_id}")
+        if detail:
+            lines.append(f"File: {detail}")
+        if total and total > 0:
+            percent = int(min(100, max(0, round((float(current or 0) / float(total)) * 100))))
+            lines.append(f"Progress: {percent}% ({_format_download_size(current)} / {_format_download_size(total)})")
+        elif current is not None:
+            lines.append(f"Downloaded: {_format_download_size(current)}")
+        return "\n".join(lines)
+
+    def stage(self, stage: str, *, detail: str | None = None, force: bool = True) -> None:
+        message = self._build_message(stage, detail=detail)
+        self._emit_ui_text(message, force=force)
+        self._emit_terminal_text(f"[{self.label}] {stage}{f' - {detail}' if detail else ''}", force=force)
+
+    def progress(self, stage: str, *, detail: str | None = None, current: int | float | None = None, total: int | float | None = None, force: bool = False) -> None:
+        if self.progress_bar is not None and total is not None and total > 0:
+            self.progress_bar.update_absolute(min(float(current or 0), float(total)), total=float(total))
+        percent = None
+        if total and total > 0:
+            percent = int(min(100, max(0, round((float(current or 0) / float(total)) * 100))))
+        message = self._build_message(stage, detail=detail, current=current, total=total)
+        self._emit_ui_text(message, force=force or percent != self._last_percent)
+        suffix = ""
+        if percent is not None:
+            suffix = f" {percent}% ({_format_download_size(current)} / {_format_download_size(total)})"
+        elif current is not None:
+            suffix = f" {_format_download_size(current)}"
+        self._emit_terminal_text(f"[{self.label}] {stage}{f' - {detail}' if detail else ''}{suffix}", force=force or percent != self._last_percent)
+        self._last_percent = percent
+
+    def finish(self, *, detail: str | None = None, force: bool = True) -> None:
+        if self.progress_bar is not None:
+            self.progress_bar.update_absolute(1, total=1)
+        message = self._build_message("Completed", detail=detail, current=1, total=1)
+        self._emit_ui_text(message, force=force)
+        self._emit_terminal_text(f"[{self.label}] Completed{f' - {detail}' if detail else ''}", force=force)
+
+    def fail(self, detail: str) -> None:
+        message = self._build_message("Failed", detail=detail)
+        self._emit_ui_text(message, force=True)
+        self._emit_terminal_text(f"[{self.label}] Failed - {detail}", force=True)
+
+    def make_tqdm_class(self):
+        if tqdm is None:
+            return None
+        reporter = self
+
+        class _NodeDownloadTqdm(tqdm):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                reporter.progress(
+                    "Downloading",
+                    detail=getattr(self, "desc", None),
+                    current=getattr(self, "n", 0),
+                    total=getattr(self, "total", None),
+                    force=True,
+                )
+
+            def update(self, n=1):
+                result = super().update(n)
+                reporter.progress(
+                    "Downloading",
+                    detail=getattr(self, "desc", None),
+                    current=getattr(self, "n", 0),
+                    total=getattr(self, "total", None),
+                )
+                return result
+
+            def refresh(self, *args, **kwargs):
+                result = super().refresh(*args, **kwargs)
+                reporter.progress(
+                    "Downloading",
+                    detail=getattr(self, "desc", None),
+                    current=getattr(self, "n", 0),
+                    total=getattr(self, "total", None),
+                )
+                return result
+
+            def close(self):
+                reporter.progress(
+                    "Downloading",
+                    detail=getattr(self, "desc", None),
+                    current=(getattr(self, "total", None) or getattr(self, "n", 0)),
+                    total=(getattr(self, "total", None) or getattr(self, "n", 0) or None),
+                    force=True,
+                )
+                return super().close()
+
+        return _NodeDownloadTqdm
+
+
+def _iter_hf_token_candidates(hf_token: str | None):
+    token = str(hf_token or "").strip()
+    if token:
+        yield token
+    for env_name in _HF_TOKEN_ENV_VARS:
+        token = str(os.environ.get(env_name) or "").strip()
+        if token:
+            yield token
+
+
+def _clean_hf_token(hf_token: str | None) -> str | None:
+    return next(_iter_hf_token_candidates(hf_token), None)
+
+
+def normalize_commercial_status(info: dict | None) -> str:
+    info = info if isinstance(info, dict) else {}
+    if info.get("is_local"):
+        return "local"
+    status = str(info.get("commercial_status") or "unclear").strip().lower()
+    if status == "local":
+        return "local"
+    return status if status in VALID_COMMERCIAL_STATUSES else "unclear"
+
+
+def model_catalog_label(name: str, info: dict | None) -> str:
+    if not COMMERCIAL_RELEASE:
+        return name
+    return f"{MODEL_STATUS_PRESENTATION[normalize_commercial_status(info)][1]}{name}"
+
+
+def model_catalog_options(models: dict[str, dict], predicate=None) -> list[str]:
+    entries = [
+        (name, info)
+        for name, info in models.items()
+        if predicate is None or predicate(name, info or {})
+    ]
+    if COMMERCIAL_RELEASE:
+        entries.sort(
+            key=lambda item: (
+                MODEL_STATUS_PRESENTATION[normalize_commercial_status(item[1])][0],
+                item[0].casefold(),
+            ),
+        )
+    return [model_catalog_label(name, info) for name, info in entries]
+
+
+def resolve_model_catalog_name(models: dict[str, dict], selected: str) -> str:
+    if selected in models:
+        return selected
+    for name, info in models.items():
+        if selected == f"{MODEL_STATUS_PRESENTATION[normalize_commercial_status(info)][1]}{name}":
+            return name
+    return selected
+
+
+def enforce_model_access(info: dict | None, model_name: str, *, local_exists: bool, hf_token: str | None = None) -> None:
+    status = normalize_commercial_status(info)
+    if COMMERCIAL_RELEASE:
+        if status == "cleared":
+            return
+        raise PermissionError(f"[QwenVL] Commercial mode rejects model '{model_name}' with status '{status}'.")
+    if not local_exists and status == "external_gated" and not _clean_hf_token(hf_token):
+        raise PermissionError(
+            f"[QwenVL] Cannot download {model_name}: no Hugging Face access token was supplied. "
+            "Accept the model's access terms on Hugging Face, then add a read token to the hf_token field "
+            "or set the HF_TOKEN environment variable."
+        )
+    if not local_exists and status == "local":
+        raise FileNotFoundError(f"[QwenVL] Local user-supplied model not found: {model_name}")
+
+
+def _redact_hf_token(text: str, hf_token: str | None) -> str:
+    redacted = str(text)
+    for token in _iter_hf_token_candidates(hf_token):
+        redacted = redacted.replace(token, "<redacted HF token>")
+    return redacted
+
+
+def _hf_download_error_message(exc: Exception, *, repo_id: str, hf_token: str | None) -> str:
+    message = _redact_hf_token(str(exc), hf_token)
+    lower = message.lower()
+    access_markers = (
+        "401",
+        "403",
+        "unauthorized",
+        "forbidden",
+        "gated",
+        "private",
+        "repository not found",
+        "requires authentication",
+    )
+    if any(marker in lower for marker in access_markers):
+        if _clean_hf_token(hf_token):
+            message += (
+                f"\n[QwenVL] Hugging Face access hint for {repo_id}: a token was supplied but access was rejected. "
+                "Confirm the token has read permission and that you accepted the model license/gate on Hugging Face."
+            )
+        else:
+            message += (
+                f"\n[QwenVL] Cannot download {repo_id}: no Hugging Face access token was supplied. "
+                "Accept the model's access terms on Hugging Face, then add a read token to the hf_token field "
+                "or set the HF_TOKEN environment variable."
+            )
+    return message
+
+
+def _call_hf_hub_download(*, repo_id: str, filename: str, local_dir: Path, token: str | None, reporter: _DownloadProgressReporter) -> Path:
+    if hf_hub_download is None:
+        raise RuntimeError("huggingface_hub.hf_hub_download is unavailable in this environment")
+    download_kwargs = {
+        "repo_id": repo_id,
+        "repo_type": "model",
+        "filename": filename,
+        "local_dir": str(local_dir),
+    }
+    if token:
+        download_kwargs["token"] = token
+    tqdm_cls = reporter.make_tqdm_class()
+    if tqdm_cls is not None:
+        try:
+            if "tqdm_class" in inspect.signature(hf_hub_download).parameters:
+                download_kwargs["tqdm_class"] = tqdm_cls
+        except (TypeError, ValueError):
+            pass
+    try:
+        return Path(hf_hub_download(**download_kwargs))
+    finally:
+        download_kwargs.pop("token", None)
+
+
+
+def _model_snapshot_has_weights(target: Path) -> bool:
+    return any(target.glob("*.safetensors")) or any(target.glob("*.bin"))
+
+
+def _cleanup_unneeded_snapshot_weights(target: Path) -> None:
+    unwanted_markers = ("fp32", "bf16", "fp8", "q2_k", "q3_k", "q4_k", "q5_k", "q6_k", "q8_0", "f32")
+    for weight_file in target.rglob("*.safetensors"):
+        name = weight_file.name.lower()
+        if any(marker in name for marker in unwanted_markers):
+            print(f"[QwenVL] Removing unneeded quantized weight: {weight_file.name}")
+            weight_file.unlink(missing_ok=True)
+
+
+def _model_snapshot_has_required_files(target: Path, require_processor: bool = False) -> bool:
+    if not target.exists() or not target.is_dir():
+        return False
+    if not _model_snapshot_has_weights(target):
+        return False
+    if not (target / "config.json").exists():
+        return False
+    if require_processor:
+        processor_files = (
+            "preprocessor_config.json",
+            "processor_config.json",
+            "image_processor_config.json",
+            "video_preprocessor_config.json",
+        )
+        if not any((target / name).exists() for name in processor_files):
+            return False
+    return True
+
+
+def _download_model_snapshot(repo_id: str, target: Path, *, force_clean_target: bool = False, node_id=None, progress_label: str | None = None, hf_token: str | None = None) -> None:
+    if COMMERCIAL_RELEASE:
+        raise RuntimeError("[QwenVL] Commercial release mode only permits preinstalled, hash-locked models.")
+    reporter = _DownloadProgressReporter(node_id=node_id, label=progress_label or "QwenVL HF Download", repo_id=repo_id)
+    token_for_download = _clean_hf_token(hf_token)
+    download_kwargs = {}
+    if force_clean_target and target.exists() and target.is_dir():
+        print(f"[QwenVL] Removing incomplete model snapshot before retry: {target}")
+        reporter.stage("Cleaning incomplete snapshot", detail=target.name)
+        shutil.rmtree(target, ignore_errors=False)
+    reporter.stage("Preparing download", detail=target.name)
+    try:
+        download_kwargs = {
+            "repo_id": repo_id,
+            "local_dir": str(target),
+            "ignore_patterns": ["*.md", ".git*"],
+            "force_download": force_clean_target,
+        }
+        if token_for_download:
+            download_kwargs["token"] = token_for_download
+        tqdm_cls = reporter.make_tqdm_class()
+        if tqdm_cls is not None:
+            download_kwargs["tqdm_class"] = tqdm_cls
+        snapshot_download(**download_kwargs)
+        _cleanup_unneeded_snapshot_weights(target)
+    except Exception as exc:
+        reporter.fail(_hf_download_error_message(exc, repo_id=repo_id, hf_token=token_for_download))
+        raise RuntimeError(_hf_download_error_message(exc, repo_id=repo_id, hf_token=token_for_download)) from exc
+    finally:
+        download_kwargs.pop("token", None)
+        token_for_download = None
+    reporter.finish(detail=target.name)
+
+
+def download_hf_file_to_path(repo_ids: list[str], filename: str, target_path: Path, *, node_id=None, progress_label: str = "QwenVL GGUF Download", hf_token: str | None = None) -> None:
+    if target_path.exists():
+        print(f"[QwenVL] Using cached file: {target_path}")
+        return
+    if COMMERCIAL_RELEASE:
+        raise RuntimeError("[QwenVL] Commercial release mode only permits preinstalled, hash-locked models.")
+
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    last_exc: Exception | None = None
+    wanted_name = Path(filename).name
+    token_for_download = _clean_hf_token(hf_token)
+    exact_candidates = []
+    for candidate in (filename, wanted_name):
+        if candidate and candidate not in exact_candidates:
+            exact_candidates.append(candidate)
+
+    try:
+        for repo_id in repo_ids:
+            reporter = _DownloadProgressReporter(node_id=node_id, label=progress_label, repo_id=repo_id)
+            auth_label = "Preparing authenticated download" if token_for_download else "Preparing download"
+            reporter.stage(auth_label, detail=wanted_name)
+            if hf_hub_download is not None:
+                for candidate in exact_candidates:
+                    try:
+                        reporter.stage("Resolving exact file", detail=candidate, force=False)
+                        downloaded_path = _call_hf_hub_download(
+                            repo_id=repo_id,
+                            filename=candidate,
+                            local_dir=target_path.parent,
+                            token=token_for_download,
+                            reporter=reporter,
+                        )
+                        if downloaded_path.exists() and downloaded_path.resolve() != target_path.resolve():
+                            target_path.parent.mkdir(parents=True, exist_ok=True)
+                            downloaded_path.replace(target_path)
+                        if target_path.exists():
+                            reporter.finish(detail=wanted_name)
+                            return
+                    except Exception as exc:
+                        hint = _hf_download_error_message(exc, repo_id=repo_id, hf_token=token_for_download)
+                        last_exc = RuntimeError(hint)
+                        print(f"[QwenVL] exact file download failed from {repo_id}/{candidate}: {hint}")
+            reporter.stage("Falling back to snapshot scan", detail=wanted_name, force=False)
+            download_kwargs = {}
+            try:
+                download_kwargs = {
+                    "repo_id": repo_id,
+                    "repo_type": "model",
+                    "local_dir": str(target_path.parent),
+                    "allow_patterns": [filename, wanted_name, f"**/{wanted_name}"],
+                }
+                if token_for_download:
+                    download_kwargs["token"] = token_for_download
+                tqdm_cls = reporter.make_tqdm_class()
+                if tqdm_cls is not None:
+                    download_kwargs["tqdm_class"] = tqdm_cls
+                snapshot_download(**download_kwargs)
+                found = list(target_path.parent.rglob(wanted_name))
+                if found:
+                    downloaded_path = found[0]
+                    if downloaded_path.exists() and downloaded_path.resolve() != target_path.resolve():
+                        target_path.parent.mkdir(parents=True, exist_ok=True)
+                        downloaded_path.replace(target_path)
+                if target_path.exists():
+                    reporter.finish(detail=wanted_name)
+                    return
+                reporter.fail(f"{wanted_name} was not found after snapshot download")
+            except Exception as exc:
+                hint = _hf_download_error_message(exc, repo_id=repo_id, hf_token=token_for_download)
+                last_exc = RuntimeError(hint)
+                reporter.fail(hint)
+                print(f"[QwenVL] snapshot_download failed from {repo_id}: {hint}")
+            finally:
+                download_kwargs.pop("token", None)
+    finally:
+        token_for_download = None
+
+    raise FileNotFoundError(f"[QwenVL] Download failed for {wanted_name}: {last_exc}")

thinkingllm_core/prompt_contracts.py

@@ -0,0 +1,386 @@
+"""Prompt budgeting plus duration-aware video prompt contracts."""
+
+import math
+import re
+
+QWEN_MIN_REASONING_BUDGET_TOKENS = 1024
+QWEN_FINAL_ANSWER_RESERVE_TOKENS = 256
+QWEN_CONTEXT_OVERHEAD_TOKENS = 128
+_QWEN_SOFT_SWITCHES = {"/think", "/no_think", "/nothink"}
+MINIMAX_H3_REFERENCE_PRESET = "🖼️ MiniMax H3 Reference-to-Video"
+VIDEO_PROMPT_CONTRACT_VERSION = 10
+_MINIMAX_BASE_FIELDS = (
+    "integrated_multimodal_description",
+    "overall_soundscape",
+    "non_diegetic_music",
+)
+_MINIMAX_REFERENCE_FIELDS = (
+    "subject_definitions",
+    "summary",
+    "retention_analysis",
+    "detailed_description",
+    "overall_soundscape",
+    "non_diegetic_music",
+)
+VIDEO_DURATION_INPUT = (
+    "FLOAT",
+    {
+        "default": 5.0,
+        "min": 0.2,
+        "max": 150.0,
+        "step": 0.1,
+        "tooltip": (
+            "Target video duration in seconds. It is used only by registered LTX 2.3 and MiniMax H3 "
+            "video presets. Connect the same requested duration to the video generator; MiniMax values "
+            "are normalized to its 17k+5 frame grid at 24 fps. For longer MiniMax scripts, ThinkingLLM "
+            "selects a coherent moment that fits while keeping any selected dialogue verbatim."
+        ),
+    },
+)
+VIDEO_PRESET_METADATA: dict[str, dict] = {}
+
+
+def estimate_qwen_text_tokens(*parts):
+    """Conservatively estimate prompt tokens when an exact tokenizer is unavailable."""
+    total_chars = 0
+    non_empty_parts = 0
+    for part in parts:
+        if not part:
+            continue
+        normalized = " ".join(str(part).split())
+        if not normalized:
+            continue
+        total_chars += len(normalized)
+        non_empty_parts += 1
+    if total_chars <= 0:
+        return 0
+    return max(1, (total_chars + 3) // 4 + max(0, non_empty_parts - 1))
+
+
+def resolve_qwen_context_window(config, fallback=32768):
+    """Return the best available HF context window from the model config."""
+    candidates = []
+    for cfg in (config, getattr(config, "text_config", None)):
+        if cfg is None:
+            continue
+        for attr in ("max_position_embeddings", "n_positions", "seq_length"):
+            value = getattr(cfg, attr, None)
+            if isinstance(value, int) and 0 < value <= 2_000_000:
+                candidates.append(value)
+    if candidates:
+        return max(candidates)
+    return int(fallback)
+
+
+def resolve_qwen_thinking_mode(
+    requested_enable,
+    max_tokens,
+    label="QwenVL",
+    *,
+    prompt_tokens=None,
+    context_window=None,
+    min_reasoning_tokens=QWEN_MIN_REASONING_BUDGET_TOKENS,
+    answer_reserve_tokens=QWEN_FINAL_ANSWER_RESERVE_TOKENS,
+    context_overhead_tokens=QWEN_CONTEXT_OVERHEAD_TOKENS,
+    quiet=False,
+):
+    """Enable thinking only when requested and enough generation budget remains."""
+    if not bool(requested_enable):
+        return False
+    requested_output = max(0, int(max_tokens or 0))
+    available_output = requested_output
+    prompt_token_count = max(0, int(prompt_tokens or 0))
+    context_limit = int(context_window) if context_window is not None else None
+
+    if context_limit is not None:
+        remaining_context = max(0, context_limit - prompt_token_count - int(context_overhead_tokens))
+        available_output = min(available_output, remaining_context) if available_output else remaining_context
+
+    minimum_required = int(min_reasoning_tokens) + int(answer_reserve_tokens)
+    if available_output <= 0 or available_output < minimum_required:
+        if context_limit is not None:
+            budget_note = (
+                f"max_tokens={requested_output}, prompt_tokens={prompt_token_count}, "
+                f"context_window={context_limit}, available_output={available_output}"
+            )
+        else:
+            budget_note = f"max_tokens={requested_output}, available_output={available_output}"
+        if not quiet:
+            print(
+                f"[{label}] Thinking requested but {budget_note} is below the required {minimum_required} tokens "
+                f"({int(min_reasoning_tokens)} reasoning + {int(answer_reserve_tokens)} answer reserve); "
+                "forcing non-thinking mode to preserve answer space."
+            )
+        return False
+    return True
+
+
+def apply_qwen_soft_thinking_directive(prompt_text, enable_thinking, supports_soft_switch=False):
+    """Append the latest Qwen3 soft switch when the backend supports it."""
+    text = prompt_text or ""
+    if not supports_soft_switch:
+        return text
+    lines = [line for line in text.splitlines() if line.strip().lower() not in _QWEN_SOFT_SWITCHES]
+    lines.append("/think" if enable_thinking else "/no_think")
+    return "\n".join(lines).strip()
+
+
+def validate_minimax_reference_request(preset_prompt, custom_prompt):
+    """Require an explicit target and reference role for MiniMax H3 R2V prompting."""
+    if preset_prompt == MINIMAX_H3_REFERENCE_PRESET and not (custom_prompt or "").strip():
+        raise ValueError(
+            "[QwenVL] MiniMax H3 Reference-to-Video requires a custom prompt describing the target video "
+            "and how each reference should be used. To animate a single image as the first frame, use "
+            "MiniMax H3 Text-to-Video instead."
+        )
+
+
+def get_video_preset_metadata(preset_name):
+    """Return duration metadata only for a registered duration-aware video preset."""
+    metadata = VIDEO_PRESET_METADATA.get(preset_name)
+    if not isinstance(metadata, dict) or not metadata.get("duration_required"):
+        return None
+    return metadata
+
+
+def resolve_video_duration(preset_name, duration_seconds=5.0):
+    """Resolve an optional node duration to the provider-native effective duration."""
+    metadata = get_video_preset_metadata(preset_name)
+    if metadata is None:
+        return None
+    try:
+        requested_seconds = float(5.0 if duration_seconds is None else duration_seconds)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("[QwenVL] duration_seconds must be a finite number between 0.2 and 150.0.") from exc
+    if not math.isfinite(requested_seconds) or not 0.2 <= requested_seconds <= 150.0:
+        raise ValueError("[QwenVL] duration_seconds must be a finite number between 0.2 and 150.0.")
+
+    provider = metadata.get("provider")
+    frames = None
+    effective_seconds = requested_seconds
+    if provider == "minimax_h3":
+        frames = max(5, round(requested_seconds * 24))
+        frames += (5 - (frames % 17)) % 17
+        effective_seconds = frames / 24
+        duration_text = f"{effective_seconds:.2f}"
+    elif provider == "ltx_2_3":
+        duration_text = f"{effective_seconds:.2f}".rstrip("0").rstrip(".")
+    else:
+        return None
+
+    return {
+        "provider": provider,
+        "video_mode": metadata.get("video_mode"),
+        "requested_seconds": requested_seconds,
+        "effective_seconds": effective_seconds,
+        "duration_text": duration_text,
+        "frames": frames,
+        "contract_version": VIDEO_PROMPT_CONTRACT_VERSION if provider == "minimax_h3" else None,
+    }
+
+
+def apply_video_duration_context(prompt_text, preset_name, duration_seconds=5.0):
+    """Append authoritative duration context for the LLM without changing non-video presets."""
+    resolved = resolve_video_duration(preset_name, duration_seconds)
+    if resolved is None:
+        return prompt_text
+    duration_text = resolved["duration_text"]
+    provider_instruction = (
+        f'Express the total duration naturally as a "{duration_text}-second continuous shot" in the single paragraph.'
+        if resolved["provider"] == "ltx_2_3"
+        else (
+            "Use this duration only to plan feasible actions, bound every cut timestamp, and fill any "
+            "official FL2VA/L2VA alignment line. Do not print TARGET_DURATION_SECONDS or a separate "
+            "target-duration declaration in the final MiniMax prompt."
+        )
+    )
+    duration_context = (
+        f"TARGET_DURATION_SECONDS: {duration_text}\n"
+        "This node value is authoritative and overrides any conflicting duration in the user text. "
+        + ("Mention the total target duration exactly once in the final prompt. " if resolved["provider"] == "ltx_2_3" else "")
+        + provider_instruction
+    )
+    return "\n\n".join(part for part in ((prompt_text or "").strip(), duration_context) if part)
+
+
+def _normalize_minimax_dialogue_text(text):
+    return " ".join((text or "").split())
+
+
+_MINIMAX_LANGUAGE_LABELS = (
+    "English", "German", "French", "Spanish", "Italian", "Portuguese", "Dutch", "Polish",
+    "Russian", "Ukrainian", "Czech", "Slovak", "Swedish", "Norwegian", "Danish", "Finnish",
+    "Greek", "Turkish", "Arabic", "Hebrew", "Hindi", "Bengali", "Urdu", "Persian", "Thai",
+    "Vietnamese", "Indonesian", "Malay", "Chinese", "Mandarin", "Cantonese", "Japanese", "Korean",
+)
+
+
+def _normalize_minimax_dialogue_tags(text):
+    """Normalize safe language-tag variants to official <d>[Language] ...</d> syntax."""
+    language_pattern = "|".join(re.escape(language) for language in _MINIMAX_LANGUAGE_LABELS)
+
+    def _normalize_tag(match):
+        language = match.group(1).strip()
+        payload = match.group(2).strip()
+        return f"<d>[{language}] {payload}</d>"
+
+    normalized = re.sub(
+        r"(?is)<d>\s*\[\s*([^\]\r\n]+?)\s*\]\s*(.+?)\s*</d>",
+        _normalize_tag,
+        text,
+    )
+    return re.sub(
+        rf"(?is)<d>\s*({language_pattern})\s*:?[ \t\r\n]+(.+?)\s*</d>",
+        _normalize_tag,
+        normalized,
+    )
+
+
+def extract_minimax_source_dialogue(source_prompt_text):
+    """Extract explicitly quoted, standalone dialogue blocks from a text request."""
+    source = (source_prompt_text or "").strip()
+    if not source:
+        return []
+
+    dialogue = []
+    tagged = re.findall(r"<d>\[[^\]\r\n]+\]\s*(.+?)</d>", source, flags=re.DOTALL | re.IGNORECASE)
+    dialogue.extend(_normalize_minimax_dialogue_text(item) for item in tagged if item.strip())
+
+    quote_pairs = (("“", "”"), ("„", "“"), ("«", "»"), ('"', '"'))
+    for paragraph in re.split(r"\r?\n[ \t]*\r?\n", source):
+        candidate = paragraph.strip()
+        if not candidate or candidate.lower().startswith("<d>"):
+            continue
+        for opening, closing in quote_pairs:
+            if len(candidate) >= 2 and candidate.startswith(opening) and candidate.endswith(closing):
+                payload = _normalize_minimax_dialogue_text(candidate[len(opening):-len(closing)])
+                if payload:
+                    dialogue.append(payload)
+                break
+
+    unique = []
+    for item in dialogue:
+        if item not in unique:
+            unique.append(item)
+    return unique
+
+
+def validate_minimax_source_duration(preset_name, duration_seconds=5.0, source_prompt_text=None):
+    """Return source dialogue for MiniMax presets without rejecting longer master scripts."""
+    resolved = resolve_video_duration(preset_name, duration_seconds)
+    if resolved is None or resolved["provider"] != "minimax_h3":
+        return []
+    return extract_minimax_source_dialogue(source_prompt_text)
+
+
+def _normalize_minimax_section_boundaries(text, expected_fields):
+    """Put uniquely identifiable official fields on their own lines without rewriting content."""
+    found = []
+    for field in expected_fields:
+        matches = list(re.finditer(rf"(?i)(?<![A-Za-z0-9_]){re.escape(field)}[ \t]*:", text))
+        if len(matches) != 1:
+            return text
+        found.append((field, matches[0]))
+    if [match.start() for _, match in found] != sorted(match.start() for _, match in found):
+        return text
+
+    normalized = text
+    for _, match in reversed(found[1:]):
+        start = match.start()
+        normalized = normalized[:start].rstrip() + "\n\n" + normalized[start:].lstrip()
+    return normalized
+
+
+def _normalize_minimax_shot_syntax(description):
+    """Normalize only unambiguous MiniMax shot syntax without validating the timeline."""
+    timestamp_pattern = re.compile(
+        r"(\[Shot\s+(\d+)\]\s+At\s+)(\d{1,2}):(\d{1,2})\.(\d{1,3})\s*,?",
+        flags=re.IGNORECASE,
+    )
+
+    def _normalize_timestamp(match):
+        minutes = int(match.group(3))
+        seconds = int(match.group(4))
+        millis = int(match.group(5).ljust(3, "0"))
+        if seconds >= 60:
+            return match.group(0)
+        return f"[Shot {int(match.group(2))}] At {minutes:02d}:{seconds:02d}.{millis:03d},"
+
+    normalized = timestamp_pattern.sub(_normalize_timestamp, description)
+    normalized = re.sub(
+        r"(?i)\[Shot\s+1\]\s+At\s+00:00\.000,?[ \t]*",
+        "[Shot 1] ",
+        normalized,
+        count=1,
+    )
+    return normalized
+
+
+def normalize_minimax_prompt_best_effort(prompt_text, preset_name, duration_seconds=5.0):
+    """Apply safe MiniMax formatting fixes without rejecting or repairing model output."""
+    resolved = resolve_video_duration(preset_name, duration_seconds)
+    if resolved is None or resolved["provider"] != "minimax_h3":
+        return prompt_text
+
+    original = (prompt_text or "").strip()
+    if not original:
+        return original
+
+    try:
+        text = re.sub(
+            r"(?i)\bTarget\s+duration\s*:\s*\d+(?:[.,]\d+)?\s*seconds?\.?[ \t]*",
+            "",
+            original,
+        ).strip()
+        text = _normalize_minimax_dialogue_tags(text)
+        expected_fields = (
+            _MINIMAX_REFERENCE_FIELDS
+            if resolved["video_mode"] == "ref2va"
+            else _MINIMAX_BASE_FIELDS
+        )
+        text = _normalize_minimax_section_boundaries(text, expected_fields)
+        text = _normalize_minimax_shot_syntax(text)
+        return text.strip() or original
+    except Exception:
+        # Formatting assistance must never become a second schema gate in front of H3.
+        return original
+
+
+def ensure_video_prompt_duration(prompt_text, preset_name, duration_seconds=5.0, source_prompt_text=None):
+    """Apply provider-native duration guidance and safe output normalization."""
+    resolved = resolve_video_duration(preset_name, duration_seconds)
+    if resolved is None:
+        return prompt_text
+    text = (prompt_text or "").strip()
+    duration_text = resolved["duration_text"]
+
+    if resolved["provider"] == "ltx_2_3":
+        text = " ".join(text.split())
+        marker = f"{duration_text}-second continuous shot"
+        number_pattern = re.escape(duration_text).replace(r"\.", r"[.,]")
+        marker_pattern = re.compile(
+            rf"\b{number_pattern}(?:\.0+)?[- ]second continuous shot\b",
+            flags=re.IGNORECASE,
+        )
+        seen = False
+
+        def _canonicalize_ltx_marker(_match):
+            nonlocal seen
+            if seen:
+                return "continuous shot"
+            seen = True
+            return marker
+
+        text = marker_pattern.sub(_canonicalize_ltx_marker, text)
+        if not seen:
+            text = f"A {marker}. {text}".strip()
+        return " ".join(text.split())
+
+    if resolved["provider"] == "minimax_h3":
+        return normalize_minimax_prompt_best_effort(
+            text,
+            preset_name,
+            duration_seconds,
+        )
+
+    return text

thinkingllm_core/prompt_state.py

@@ -0,0 +1,256 @@
+"""Persistent prompt cache and per-node workflow state shared by all backends."""
+
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+PLUGIN_ROOT = Path(__file__).resolve().parent.parent
+PROMPT_CACHE: dict = {}
+CACHE_FILE = PLUGIN_ROOT / "prompt_cache.json"
+NODE_PROMPT_STATE: dict = {}
+NODE_STATE_FILE = PLUGIN_ROOT / "node_prompt_state.json"
+
+
+def _build_workflow_fingerprint(extra_pnginfo):
+    """Return a short stable fingerprint for a workflow dict so node state
+    can be scoped to a particular workflow window, avoiding cross-workflow
+    leakage while remaining stable across save/reload cycles."""
+    if not isinstance(extra_pnginfo, dict):
+        return None
+    workflow = extra_pnginfo.get("workflow")
+    if not isinstance(workflow, dict):
+        return None
+    try:
+        last_id = workflow.get("last_node_id", 0)
+        node_ids = sorted(
+            str(n.get("id", "")) for n in workflow.get("nodes", []) if isinstance(n, dict)
+        )
+        seed = f"{last_id}|{','.join(node_ids[:50])}"
+        return hashlib.md5(seed.encode()).hexdigest()[:12]
+    except Exception:
+        return None
+
+def _make_node_state_key(node_class, unique_id, extra_pnginfo):
+    """Produce a stable per-node key from the node class name, its numeric
+    identity within the workflow, and the workflow fingerprint when available."""
+    wf_fp = _build_workflow_fingerprint(extra_pnginfo)
+    if wf_fp:
+        return f"{node_class}|{wf_fp}|{unique_id}"
+    return f"{node_class}|{unique_id}"
+
+
+def _normalize_state_signature_value(value):
+    if value is None:
+        return None
+    if isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, (list, tuple)):
+        return [_normalize_state_signature_value(item) for item in value]
+    if isinstance(value, dict):
+        return {
+            str(key): _normalize_state_signature_value(val)
+            for key, val in sorted(value.items(), key=lambda item: str(item[0]))
+        }
+    return str(value)
+
+
+def build_node_input_signature(**kwargs):
+    """Return a stable hash for the node inputs that should invalidate saved prompt reuse."""
+    normalized = {
+        str(key): _normalize_state_signature_value(value)
+        for key, value in sorted(kwargs.items(), key=lambda item: str(item[0]))
+    }
+    payload = json.dumps(normalized, sort_keys=True, ensure_ascii=True, separators=(",", ":"))
+    return hashlib.md5(payload.encode("utf-8")).hexdigest()
+
+def load_node_prompt_state():
+    """Load per-node prompt state from the sidecar JSON file."""
+    try:
+        if NODE_STATE_FILE.exists():
+            with open(NODE_STATE_FILE, "r", encoding="utf-8") as f:
+                loaded = json.load(f)
+                if not isinstance(loaded, dict):
+                    raise ValueError("node prompt state must be a JSON object")
+                NODE_PROMPT_STATE.clear()
+                NODE_PROMPT_STATE.update(loaded)
+                print(f"[QwenVL] Loaded {len(NODE_PROMPT_STATE)} node prompt states")
+    except Exception as e:
+        print(f"[QwenVL] Failed to load node prompt state: {e}")
+        NODE_PROMPT_STATE.clear()
+
+def save_node_prompt_state():
+    """Persist per-node prompt state to the sidecar JSON file."""
+    try:
+        with open(NODE_STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(NODE_PROMPT_STATE, f, indent=2)
+    except Exception as e:
+        print(f"[QwenVL] Failed to save node prompt state: {e}")
+
+def get_node_saved_prompt(node_class, unique_id, extra_pnginfo):
+    """Return the saved prompt text for a specific node, or None."""
+    key = _make_node_state_key(node_class, unique_id, extra_pnginfo)
+    entry = NODE_PROMPT_STATE.get(key)
+    if isinstance(entry, dict) and entry.get("text"):
+        return entry["text"]
+    return None
+
+
+def get_node_saved_prompt_with_seed(node_class, unique_id, extra_pnginfo, seed=None, max_tokens=None, temperature=None, top_p=None, repetition_penalty=None, input_signature=None):
+    """Return saved prompt text only if the generation parameters haven't changed."""
+    key = _make_node_state_key(node_class, unique_id, extra_pnginfo)
+    entry = NODE_PROMPT_STATE.get(key)
+    if not isinstance(entry, dict) or not entry.get("text"):
+        return None
+    # If seed or params changed, invalidate and return None
+    if seed is not None and entry.get("seed") != seed:
+        return None
+    if max_tokens is not None and entry.get("max_tokens") != max_tokens:
+        return None
+    if temperature is not None and entry.get("temperature") != temperature:
+        return None
+    if top_p is not None and entry.get("top_p") != top_p:
+        return None
+    if repetition_penalty is not None and entry.get("repetition_penalty") != repetition_penalty:
+        return None
+    if input_signature is not None and entry.get("input_signature") != input_signature:
+        return None
+    return entry["text"]
+
+def set_node_saved_prompt(node_class, unique_id, extra_pnginfo, text, raw_trace=None, seed=None, max_tokens=None, temperature=None, top_p=None, repetition_penalty=None, input_signature=None):
+    """Persist the generated prompt (and optional raw trace) for a specific node."""
+    key = _make_node_state_key(node_class, unique_id, extra_pnginfo)
+    NODE_PROMPT_STATE[key] = {
+        "text": text,
+        "raw_trace": raw_trace or "",
+        "timestamp": None,
+        "seed": seed,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+        "repetition_penalty": repetition_penalty,
+        "input_signature": input_signature,
+    }
+    save_node_prompt_state()
+
+def load_prompt_cache():
+    """Load prompt cache from file"""
+    try:
+        if CACHE_FILE.exists():
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                loaded = json.load(f)
+                if not isinstance(loaded, dict):
+                    raise ValueError("prompt cache must be a JSON object")
+                PROMPT_CACHE.clear()
+                PROMPT_CACHE.update(loaded)
+                print(f"[QwenVL] Loaded {len(PROMPT_CACHE)} cached prompts")
+    except Exception as e:
+        print(f"[QwenVL] Failed to load prompt cache: {e}")
+        PROMPT_CACHE.clear()
+
+def save_prompt_cache():
+    """Save prompt cache to file"""
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(PROMPT_CACHE, f, indent=2)
+    except Exception as e:
+        print(f"[QwenVL] Failed to save prompt cache: {e}")
+
+
+def log_llm_input(
+    backend: str,
+    stage: str,
+    preset_name: str,
+    user_text: str,
+    *,
+    system_text: str = "",
+    formatted_text: str | None = None,
+    media: dict[str, int] | None = None,
+) -> None:
+    """Print the complete text input sent to an LLM without dumping media payloads."""
+    lines = [
+        f"\n[{backend}] LLM INPUT",
+        f"Stage: {stage}",
+        f"Preset: {preset_name or '(none)'}",
+        "Media: " + (", ".join(f"{kind}={count}" for kind, count in (media or {}).items()) or "none"),
+        "--- SYSTEM ---",
+        system_text or "(none)",
+        "--- USER ---",
+        user_text or "(empty)",
+    ]
+    if formatted_text is not None:
+        lines.extend(("--- FORMATTED CHAT TEMPLATE ---", formatted_text))
+    lines.append("--- END LLM INPUT ---")
+    message = "\n".join(lines)
+    try:
+        print(message)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, "encoding", None) or "ascii"
+        print(message.encode(encoding, errors="replace").decode(encoding))
+
+def get_cache_key(model_name, preset_prompt, custom_prompt, image_hash=None, video_hash=None, seed=None, max_tokens=None, temperature=None, top_p=None, repetition_penalty=None, enable_thinking=None, effective_duration_seconds=None, video_prompt_contract_version=None):
+    """Generate cache key from inputs including all generation parameters.
+
+    All generation-parameter fields are optional so existing callers that omit them
+    continue to work; when provided, changing any parameter produces a different key.
+    """
+    key_data = {
+        "model": model_name,
+        "preset": preset_prompt,
+        "custom": custom_prompt.strip() if custom_prompt else "",
+        "image": image_hash,
+        "video": video_hash,
+        "seed": seed,  # Always include seed to ensure proper caching behavior
+        "max_tokens": max_tokens,
+        "temperature": temperature if temperature is not None else None,
+        "top_p": top_p if top_p is not None else None,
+        "repetition_penalty": repetition_penalty if repetition_penalty is not None else None,
+        "enable_thinking": bool(enable_thinking) if enable_thinking is not None else None,
+    }
+    if effective_duration_seconds is not None:
+        key_data["effective_duration_seconds"] = effective_duration_seconds
+    if video_prompt_contract_version is not None:
+        key_data["video_prompt_contract_version"] = video_prompt_contract_version
+    # Create deterministic hash
+    key_str = json.dumps(key_data, sort_keys=True)
+    return hashlib.md5(key_str.encode()).hexdigest()
+
+def get_alternative_cache_key(model_name, preset_prompt, custom_prompt, image_hash=None, video_hash=None, seed=None, module_name="QwenVL"):
+    """Generate alternative cache key for fixed seed mode to find random prompts"""
+    # Only for fixed seed mode (when user wants consistent prompts)
+    # We consider any seed that the user keeps fixed as "fixed seed mode"
+
+    print(f"[{module_name} DEBUG] Searching through cache for model={model_name}, preset={preset_prompt}")
+
+    # Try to find any cached prompt with same model/preset/custom/image but different seed
+    for cached_key, cached_data in PROMPT_CACHE.items():
+        cached_model = cached_data.get("model")
+        cached_preset = cached_data.get("preset")
+        cached_seed = cached_data.get("seed")
+
+        print(f"[{module_name} DEBUG] Checking entry: model={cached_model}, preset={cached_preset}, seed={cached_seed}")
+
+        if (cached_model == model_name and
+            cached_preset == preset_prompt and
+            cached_seed != seed):  # Different seed
+
+            # Generate the cache key that would have been created for this cached data
+            # to check if image/video hashes match
+            cached_image_hash = cached_data.get("image_hash")
+            cached_video_hash = cached_data.get("video_hash")
+
+            print(f"[{module_name} DEBUG] Found potential match with hashes: image={cached_image_hash}, video={cached_video_hash}")
+
+            # If the cached data doesn't have hash info, try to match by other criteria
+            if cached_image_hash is None and cached_video_hash is None:
+                # Fallback: if both current and cached have no image/video, consider it a match
+                if image_hash is None and video_hash is None:
+                    print(f"[{module_name} DEBUG] Match found (no images/videos)!")
+                    return cached_key
+            else:
+                # Match if hashes are the same (including None)
+                if cached_image_hash == image_hash and cached_video_hash == video_hash:
+                    print(f"[{module_name} DEBUG] Match found (hashes match)!")
+                    return cached_key
+    print(f"[{module_name} DEBUG] No alternative cache found")
+    return None

update.md

@@ -1,5 +1,237 @@
 # ComfyUI-QwenVL Update Log
 
+## Version 2.4.0 (2026/08/12) - Duration-Aware Video Prompting and QwenVL Core
+
+### 2.4.0 Changes
+
+- Added duration-aware LTX 2.3 and MiniMax H3 prompting across the Hugging Face, ComfyUI-native, and GGUF video workflows.
+- Split MiniMax H3 prompting into dedicated T2VA, I2VA, FL2VA, L2VA, and full-reference contracts with frame-grid normalization and safer best-effort output cleanup.
+- Refactored the QwenVL implementation into focused shared modules for model access, runtime configuration, prompt state, prompt contracts, and media handling while preserving compatibility exports.
+- Improved streaming so reasoning stays separate from final content, unfinished thinking traces trigger a direct finalization retry, and terminal-only punctuation remains safe on legacy Windows code pages.
+- Expanded preset recommendations, tooltips, system prompts, and documentation for video token budgets, thinking behavior, reference roles, dialogue fidelity, and duration handling.
+
+### 2.4.0 Validation
+
+- Expanded regression coverage for compatibility, downloads, caching, duration-aware prompting, MiniMax structures, streaming, and node registration.
+- All 131 isolated regression tests pass in the bundled ComfyUI Python runtime.
+
+## Version 2.3.24 (2026/08/08) - System Prompt Preset Utility
+
+### 2.3.24 Changes
+
+- Added a standalone `ThinkingLLM System Prompt Preset` utility node that outputs reusable system prompts as a standard `STRING`.
+- Exposed only presets backed by prompt definitions and made obsolete or unknown saved values return an empty string instead of a display label.
+- Registered the utility in both Community and commercial releases.
+- Added the existing ThinkingLLM tool styling and preset tooltip previews without enabling inference-only recommendation or token behavior.
+
+### 2.3.24 Validation
+
+- Added regression coverage for prompt lookup, undefined presets, loader registration, and frontend integration.
+- All 116 isolated regression tests pass on the merged `main` release candidate.
+
+## Version 2.3.23 (2026/08/08) - MiniMax H3 Reference Prompt Guard
+
+### 2.3.23 Changes
+
+- Required an explicit target-video prompt and reference-role assignment for MiniMax H3 Reference-to-Video generation.
+- Applied the same validation to Hugging Face, ComfyUI-native, and GGUF vision nodes.
+- Rejected empty ComfyUI-native model generations before they can be cached or saved as blank output.
+- Documented the correct Text-to-Video versus Reference-to-Video selection and recommended direct-generation settings.
+
+### 2.3.23 Validation
+
+- Added regression coverage for missing Reference-to-Video target prompts and empty native model output.
+- All 114 isolated regression tests pass.
+
+## Version 2.3.22 (2026/08/06) - Community Model Catalog Fix
+
+### 2.3.22 Changes
+
+- Restored plain model names and the original catalog order in Community mode.
+- Restored automatic downloads for Community models while retaining Hugging Face token requirements for gated repositories.
+- Kept rights labels, status grouping, and fail-closed model restrictions exclusive to commercial releases.
+- Preserved compatibility with workflows saved while status-prefixed model names were exposed.
+- Clarified the Community and commercial model policies in the README and third-party notices.
+
+### 2.3.22 Validation
+
+- Added regression coverage for Community dropdowns, Community downloads, commercial restrictions, and legacy status-prefixed workflows.
+- All 113 isolated regression tests pass on the merged `main` release candidate.
+
+## Version 2.3.21 (2026/08/06) - Commercial Model Catalog
+
+### 2.3.21 Changes
+
+- Grouped HF and GGUF model dropdowns by reviewed commercial status while preserving old workflow model names.
+- Added fail-closed commercial mode with only the two pinned Qwen models and no runtime model downloads.
+- Added Hugging Face token handling for external gated models without logging or persisting tokens.
+- Split MiniMax H3 into text/keyframe and full-reference presets and log the exact LLM input sent by each node.
+
+### 2.3.21 Validation
+
+- Added regression coverage for catalog status, legacy workflow resolution, gated access, token redaction, and commercial-mode restrictions.
+- All 113 isolated regression tests pass after merging the newer MiniMax H3 preset split from `main`.
+
+## Version 2.3.20 (2026/08/06) - Shared ComfyUI Text Encoders
+
+### 2.3.20 Changes
+
+- Added automatic discovery of compatible checkpoints in `ComfyUI/models/text_encoders`.
+- Added native ComfyUI loading for Qwen3-VL 4B/8B and Gemma 3 12B without duplicated model files.
+- Added clear errors for unsupported beam and Gemma video inputs.
+- Kept incomplete MiniMax H3/Qwen3-VL 32B conditioning checkpoints out of the text-generation selector.
+
+### 2.3.20 Validation
+
+- Added regression coverage for discovery, native loading, generation, deterministic seeds, and MiniMax H3 exclusion.
+- All 99 isolated regression tests pass.
+
+## Version 2.3.19 (2026/08/06) - MiniMax H3 Prompt Preset
+
+### 2.3.19 Changes
+
+- Added `🎬 MiniMax H3 Multimodal Video` to vision and text-only prompt nodes.
+- Added the official T2VA, I2VA, FL2VA, L2VA, and full-reference output structures, including native audio fields and reference-retention analysis.
+- Documented the preset and linked the official MiniMax H3 prompt guides.
+
+### 2.3.19 Validation
+
+- Added regression coverage for preset availability, required H3 fields, and node dropdown exposure.
+- Kept browser tooltip previews synchronized with the preset source.
+
+## Version 2.3.18 (2026/07/21) - Advanced Mask Preview
+
+### 2.3.18 Changes
+
+- Added a `MASK_PREVIEW` image output to the Hugging Face and GGUF advanced vision nodes.
+- The preview shows selected pixels at normal brightness and surrounding context dimmed to 20%.
+- Simple nodes keep their existing two-output workflow contract.
+- Documented how to connect `MASK_PREVIEW` to a ComfyUI Preview Image node.
+
+### 2.3.18 Validation
+
+- All 98 regression tests pass.
+
+## Version 2.3.17 (2026/07/21) - Mask-Focused Image Editing
+
+### 2.3.17 Changes
+
+- Added optional `MASK` input support to all four ThinkingLLM vision nodes.
+- Kept selected pixels at normal brightness while dimming surrounding context for focused visual analysis.
+- Added shared Hugging Face and GGUF mask preprocessing with mask-aware cache invalidation.
+- Added the `👁️ Remove (Mask Area)` preset for positive background-continuation and replacement prompts.
+- Documented the complete mask-focused object-removal workflow in the README.
+
+### 2.3.17 Validation
+
+- Verified mask resizing, soft-mask blending, alpha preservation, input validation, cache invalidation, and node compatibility.
+- Full local regression suite passes with 97 tests.
+
+## Version 2.3.16 (2026/07/13) — Gemma 4 E2B Catalog Repair
+
+### 2.3.16 Changes
+
+- Replaced stale Gemma 4 E2B GGUF download entries with currently hosted Bartowski Q4_K_S, Q8_0, and BF16 files.
+- Preserved reuse of existing ggml-org Q8_0 and BF16 downloads through local filename aliases.
+
+### 2.3.16 Validation
+
+- Verified the replacement filenames against the live Hugging Face repository API.
+- Added regression coverage for both Gemma 4 E2B text-catalog entries.
+- Full local regression suite passes.
+
+## Version 2.3.15 (2026/07/12) — Installed GGUF Visibility
+
+### 2.3.15 Changes
+
+- Marked catalogued GGUF model files found on disk with `[installed]` in both ThinkingLLM GGUF selectors.
+- Kept `[local]` for uncatalogued GGUF files and preserved compatibility with model names stored by older workflows.
+
+### 2.3.15 Validation
+
+- Added regression coverage for installed-model labelling, duplicate suppression, and legacy model-name resolution.
+- Full local regression suite passes.
+
+## Version 2.3.14 (2026/06/20) — Gemma4 GGUF Stability Release
+
+### 2.3.14 Changes
+
+- Stabilized `google_gemma-4-E4B-it-GGUF` multimodal runs by applying Gemma4-compatible GGUF image settings before llama.cpp execution.
+- Pinned llama.cpp `main_gpu` to ComfyUI's selected CUDA device so GGUF loads do not drift to the wrong card after CUDA state changes.
+- Blocked unsupported Gemma4 GGUF audio before native llama.cpp can abort the ComfyUI process.
+- Reused existing mapped GGUF model files across ComfyUI `LLM` model paths to avoid redundant downloads.
+- Removed duplicate legacy ThinkingLLM search entries from the ComfyUI node list.
+
+### 2.3.14 Validation
+
+- Full local regression suite passes.
+- Live NVIDIA portable ComfyUI test completed successfully with `google_gemma-4-E4B-it-Q8_0.gguf` and an image prompt.
+
+## Version 2.3.13 (2026/06/20) — Recommendation Note Cleanup
+
+### 2.3.13 Changes
+
+- Removed duplicate compact recommendation-note rows from ThinkingLLM nodes, including Advanced GGUF.
+- Kept the real multiline recommendation note visible while pruning stale duplicate `recommended_settings` widgets.
+- Prevented recommendation notes from being serialized back into workflows as duplicate UI-only widgets.
+
+### 2.3.13 Validation
+
+- Added regression coverage for recommendation widget deduplication.
+- Full local regression suite passes.
+
+## Version 2.3.12 (2026/06/20) — Rollback Recovery Release
+
+### 2.3.12 Changes
+
+- Rebased the public release line onto the rollback-safe GGUF single-pass state from 2.3.11.
+- Preserved the ComfyUI execution highlight behavior by no longer overwriting node colors once ComfyUI has set them.
+- Restored the saved-workflow compatible `Custom prompt + image (no preset)` option.
+
+### 2.3.12 Validation
+
+- Local regression coverage verifies the execution color guard and the restored no-preset alias.
+- Full local regression suite passes.
+
+## Version 2.3.11 (2026/06/19) — GGUF Single-Pass Execution Fix
+
+### 2.3.11 Changes
+
+- Disabled automatic GGUF finalization retries by default so one node execution performs one LLM generation pass unless explicitly configured otherwise.
+- Added `auto_finalization_retry` to `ThinkingLLM (GGUF)`, `ThinkingLLM Advanced (GGUF)`, `ThinkingLLM Gemma 4 Audio (GGUF)`, and `ThinkingLLM Prompt Enhancer (GGUF)` for users who still want the old empty/reasoning-only retry behavior.
+- Fixed catalogued GGUF model reuse across ComfyUI `extra_model_paths.yaml` `LLM` mappings, preventing unnecessary re-downloads when models already exist in a shared `models/LLM/GGUF` directory.
+
+### 2.3.11 Validation
+
+- Added regression coverage for default single-pass GGUF execution, explicit opt-in finalization retry, GGUF node UI defaults, and shared `LLM/GGUF` model reuse.
+- Targeted GGUF tests pass.
+
+## Version 2.3.10 (2026/06/19) — ComfyUI 2.0 Advanced GGUF Layout Fix
+
+### 2.3.10 Changes
+
+- Fixed the large blank area in `ThinkingLLM Advanced (GGUF)` under ComfyUI Nodes 2.0 by no longer hiding real advanced tuning widgets behind a layout hack.
+- Kept legacy workflow compatibility shims hidden while exposing `n_ubatch`, thread, flash-attention, KQV offload, and context-checkpoint controls.
+- Added regression coverage for the ComfyUI 2.0 layout compatibility rule.
+
+### 2.3.10 Validation
+
+- Targeted Advanced GGUF compatibility tests pass.
+- Full local regression test file passes.
+
+## Version 2.3.6 (2026/06/14) — GGUF Context Reset Hardening
+
+### 2.3.6 Changes
+
+- Moved GGUF llama context reset to run immediately before each internal `create_chat_completion` call.
+- Covers both normal generation and finalization retry calls while preserving `keep_model_loaded=True` model reuse.
+- Added regression coverage that verifies reset happens before completion and before retry/finalization completions.
+
+### 2.3.6 Validation
+
+- Targeted reset regression suite passes.
+- Full local test file still has the known Linux-host failures for Windows DLL-directory tests only.
+
 ## v1.0.9 (Local Fork) — May 2026
 
 ### New Features

web/js/appearance.js

@@ -1,4 +1,5 @@
 import { app } from "/scripts/app.js";
+import { ComfyWidgets } from "/scripts/widgets.js";
 
 const COLOR_THEMES = {
     QwenVL: { nodeColor: "#28403f", nodeBgColor: "#374539", width: 340 },
@@ -8,16 +9,24 @@ const COLOR_THEMES = {
 };
 
 const NODE_COLORS = {
-    // QwenVL nodes
     "AILab_QwenVL": "QwenVL",
     "AILab_QwenVL_Advanced": "QwenVL",
     "AILab_QwenVL_PromptEnhancer": "Enhancer",
     "AILab_QwenVL_GGUF": "QwenVLGGUF",
     "AILab_QwenVL_GGUF_Advanced": "QwenVLGGUF",
     "AILab_QwenVL_GGUF_PromptEnhancer": "Enhancer",
-
-    // Tools
+    "ThinkingLLM_QwenVL": "QwenVL",
+    "ThinkingLLM_QwenVL_Advanced": "QwenVL",
+    "ThinkingLLM_QwenVL_PromptEnhancer": "Enhancer",
+    "ThinkingLLM_QwenVL_GGUF": "QwenVLGGUF",
+    "ThinkingLLM_QwenVL_GGUF_Advanced": "QwenVLGGUF",
+    "ThinkingLLM_Gemma4_Audio_GGUF": "QwenVLGGUF",
+    "ThinkingLLM_Whisper_ASR": "QwenVLGGUF",
+    "ThinkingLLM_QwenVL_GGUF_PromptEnhancer": "Enhancer",
+    "ThinkingLLM_SystemPromptPreset": "Tools",
     "AILab_QwenVL_PromptLibrary": "Tools",
+    "VRAMCleanup": "Tools",
+    "StorySplitNode": "Tools",
 };
 
 const THINKINGLLM_NODE_NAMES = new Set([
@@ -32,26 +41,97 @@ const THINKINGLLM_NODE_NAMES = new Set([
     "ThinkingLLM_QwenVL_PromptEnhancer",
     "ThinkingLLM_QwenVL_GGUF",
     "ThinkingLLM_QwenVL_GGUF_Advanced",
+    "ThinkingLLM_Gemma4_Audio_GGUF",
+    "ThinkingLLM_Whisper_ASR",
     "ThinkingLLM_QwenVL_GGUF_PromptEnhancer",
 ]);
 
+const PRESET_TOOLTIP_NODE_NAMES = new Set([
+    ...THINKINGLLM_NODE_NAMES,
+    "ThinkingLLM_SystemPromptPreset",
+]);
+
+const DURATION_INPUT_NODE_NAMES = new Set([
+    "AILab_QwenVL",
+    "AILab_QwenVL_Advanced",
+    "AILab_QwenVL_PromptEnhancer",
+    "AILab_QwenVL_GGUF",
+    "AILab_QwenVL_GGUF_Advanced",
+    "AILab_QwenVL_GGUF_PromptEnhancer",
+    "ThinkingLLM_QwenVL",
+    "ThinkingLLM_QwenVL_Advanced",
+    "ThinkingLLM_QwenVL_PromptEnhancer",
+    "ThinkingLLM_QwenVL_GGUF",
+    "ThinkingLLM_QwenVL_GGUF_Advanced",
+    "ThinkingLLM_QwenVL_GGUF_PromptEnhancer",
+]);
+
+const AUDIO_CAPABLE_NODE_NAMES = new Set([
+    "ThinkingLLM_Gemma4_Audio_GGUF",
+    "ThinkingLLM_Whisper_ASR",
+    "AILab_QwenVL_GGUF",
+    "AILab_QwenVL_GGUF_Advanced",
+    "ThinkingLLM_QwenVL_GGUF",
+    "ThinkingLLM_QwenVL_GGUF_Advanced",
+]);
+
 const GGUF_ADVANCED_INTERNAL_WIDGETS = new Set([
     "legacy_seed_mode",
     "legacy_unload_after_run",
-    "n_ubatch",
-    "n_threads",
-    "n_threads_batch",
-    "flash_attn",
-    "offload_kqv",
-    "ctx_checkpoints",
 ]);
 
+const RECOMMENDATIONS_URL = new URL("../model_recommendations.json", import.meta.url);
+const PRESET_TOOLTIPS_URL = new URL("../preset_tooltips.json", import.meta.url);
+const RECOMMENDATION_WIDGET_NAME = "recommended_settings";
+const RECOMMENDATION_PLACEHOLDER = "Select a model to see provider/community recommended settings. This note never changes your saved widget values.";
+const RECOMMENDATION_FIELDS = ["temperature", "top_p", "top_k", "max_tokens", "ctx_min", "n_batch", "image_max_tokens"];
+const AUDIO_UNSUPPORTED_MESSAGE = "No curated audio support for the selected model. Use Gemma 4 Audio for audio understanding or Whisper ASR for transcription.";
+const PRESET_WIDGET_NAMES = ["preset_prompt", "enhancement_style", "preset_system_prompt"];
+
+let recommendationsPromise = null;
+let presetTooltipsPromise = null;
+
+function loadRecommendations() {
+    if (!recommendationsPromise) {
+        recommendationsPromise = fetch(RECOMMENDATIONS_URL)
+            .then((response) => {
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                return response.json();
+            })
+            .then((payload) => Array.isArray(payload?.rules) ? payload.rules : [])
+            .catch((error) => {
+                console.warn("[ThinkingLLM] Failed to load model recommendations", error);
+                return [];
+            });
+    }
+    return recommendationsPromise;
+}
+
+function loadPresetTooltips() {
+    if (!presetTooltipsPromise) {
+        presetTooltipsPromise = fetch(PRESET_TOOLTIPS_URL, { cache: "no-store" })
+            .then((response) => {
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                return response.json();
+            })
+            .catch((error) => {
+                console.warn("[ThinkingLLM] Failed to load preset tooltips", error);
+                return {};
+            });
+    }
+    return presetTooltipsPromise;
+}
+
 function setNodeColors(node, theme) {
     if (!theme) { return; }
-    if (theme.nodeColor) {
+    if (!node.color && theme.nodeColor) {
         node.color = theme.nodeColor;
     }
-    if (theme.nodeBgColor) {
+    if (!node.bgcolor && theme.nodeBgColor) {
         node.bgcolor = theme.nodeBgColor;
     }
     if (theme.width) {
@@ -71,7 +151,108 @@ function hideStableWidget(node, widget) {
     widget._thinkingllmOriginalComputeSize = widget.computeSize;
     widget.hidden = true;
     widget.type = `thinkingllm_hidden_${widget.type || "widget"}`;
-    widget.computeSize = () => [0, -4];
+    widget.computeSize = () => [0, 0];
+    widget.draw = () => {};
+}
+
+function setWidgetVisible(node, widget, visible) {
+    if (!widget) { return; }
+    if (!widget._thinkingllmVisibilityState) {
+        widget._thinkingllmVisibilityState = {
+            type: widget.type,
+            computeSize: widget.computeSize,
+            draw: widget.draw,
+            hidden: widget.hidden,
+        };
+    }
+    const original = widget._thinkingllmVisibilityState;
+    if (visible) {
+        widget.type = original.type;
+        widget.computeSize = original.computeSize;
+        widget.draw = original.draw;
+        widget.hidden = original.hidden;
+    } else {
+        widget.hidden = true;
+        widget.type = `thinkingllm_hidden_${original.type || "widget"}`;
+        widget.computeSize = () => [0, 0];
+        widget.draw = () => {};
+    }
+    resizeNode(node);
+}
+
+function readComboValue(widget) {
+    const value = widget?.value;
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        for (const key of ["value", "content", "label", "name"]) {
+            if (typeof value[key] === "string") {
+                return value[key];
+            }
+        }
+    }
+    return value == null ? "" : String(value);
+}
+
+function normalizePresetName(value) {
+    return String(value || "").normalize("NFC").replaceAll("\uFE0F", "").trim();
+}
+
+function findVideoPresetMetadata(payload, selectedPreset) {
+    const presets = payload?.video_presets;
+    if (!presets || typeof presets !== "object" || Array.isArray(presets)) {
+        return { metadataAvailable: false, metadata: null };
+    }
+    if (Object.prototype.hasOwnProperty.call(presets, selectedPreset)) {
+        return { metadataAvailable: true, metadata: presets[selectedPreset] };
+    }
+    const normalizedSelection = normalizePresetName(selectedPreset);
+    const matchingEntry = Object.entries(presets)
+        .find(([name]) => normalizePresetName(name) === normalizedSelection);
+    return {
+        metadataAvailable: true,
+        metadata: matchingEntry?.[1] || null,
+    };
+}
+
+function selectedPresetName(node) {
+    return PRESET_WIDGET_NAMES
+        .map((name) => readComboValue(findWidget(node, name)))
+        .find((value) => value) || "";
+}
+
+function updateDurationVisibility(node, payload) {
+    if (!DURATION_INPUT_NODE_NAMES.has(node.comfyClass)) {
+        return;
+    }
+    const selectedPreset = selectedPresetName(node);
+    const durationWidget = findWidget(node, "duration_seconds");
+    const { metadataAvailable, metadata } = findVideoPresetMetadata(payload, selectedPreset);
+    if (!metadataAvailable) {
+        // Keep the backend-provided control usable if the auxiliary payload is stale or unavailable.
+        setWidgetVisible(node, durationWidget, true);
+        return;
+    }
+    setWidgetVisible(node, durationWidget, Boolean(metadata?.duration_required));
+}
+
+function findWidgets(node, name) {
+    return node.widgets?.filter((widget) => widget?.name === name) || [];
+}
+
+function removeDuplicateRecommendationWidgets(node, keepWidget) {
+    if (!node.widgets?.length || !keepWidget) {
+        return;
+    }
+    for (let index = node.widgets.length - 1; index >= 0; index -= 1) {
+        const widget = node.widgets[index];
+        if (widget?.name !== RECOMMENDATION_WIDGET_NAME || widget === keepWidget) {
+            continue;
+        }
+        hideStableWidget(node, widget);
+        node.widgets.splice(index, 1);
+    }
 }
 
 function hideGgufAdvancedInternals(node) {
@@ -103,19 +284,352 @@ function clearHfTokenAfterExecution(node) {
     };
 }
 
+function recommendationScope(node) {
+    if ([
+        "AILab_QwenVL_GGUF",
+        "AILab_QwenVL_GGUF_Advanced",
+        "ThinkingLLM_QwenVL_GGUF",
+        "ThinkingLLM_QwenVL_GGUF_Advanced",
+        "ThinkingLLM_Gemma4_Audio_GGUF",
+        "ThinkingLLM_Whisper_ASR",
+        "AILab_QwenVL_GGUF_PromptEnhancer",
+        "ThinkingLLM_QwenVL_GGUF_PromptEnhancer",
+    ].includes(node.comfyClass)) {
+        return "gguf";
+    }
+    return "hf";
+}
+
+function matchRecommendationRule(modelName, rules) {
+    const lowered = String(modelName || "").toLowerCase();
+    if (!lowered) {
+        return null;
+    }
+    const ordered = [...(rules || [])].sort((left, right) => (right.priority || 0) - (left.priority || 0));
+    for (const rule of ordered) {
+        const include = Array.isArray(rule?.match_any) ? rule.match_any : [];
+        const exclude = Array.isArray(rule?.exclude_any) ? rule.exclude_any : [];
+        const matches = include.some((token) => lowered.includes(String(token).toLowerCase()));
+        const blocked = exclude.some((token) => lowered.includes(String(token).toLowerCase()));
+        if (matches && !blocked) {
+            return rule;
+        }
+    }
+    return null;
+}
+
+function hasWidget(node, widgetName) {
+    return Boolean(findWidget(node, widgetName));
+}
+
+function hasAudioInput(node) {
+    return AUDIO_CAPABLE_NODE_NAMES.has(node.comfyClass)
+        || Boolean(node.inputs?.some((input) => input?.name === "audio"));
+}
+
+function formatSetting(fieldName, value) {
+    if (typeof value !== "number") {
+        return null;
+    }
+    if (fieldName === "ctx_min") {
+        return `ctx>=${value}`;
+    }
+    return `${fieldName}=${value}`;
+}
+
+function buildModeSummary(node, settings) {
+    const parts = [];
+    for (const fieldName of RECOMMENDATION_FIELDS) {
+        if (!(fieldName in (settings || {}))) {
+            continue;
+        }
+        if (fieldName === "ctx_min") {
+            if (!hasWidget(node, "ctx")) {
+                continue;
+            }
+        } else if (fieldName === "top_k") {
+            if (!hasWidget(node, "top_k")) {
+                continue;
+            }
+        } else if (!hasWidget(node, fieldName)) {
+            continue;
+        }
+        const formatted = formatSetting(fieldName, settings[fieldName]);
+        if (formatted) {
+            parts.push(formatted);
+        }
+    }
+    return parts;
+}
+
+function buildRecommendationText(node, rules) {
+    if (node.comfyClass === "ThinkingLLM_Whisper_ASR") {
+        const modelSize = String(findWidget(node, "model_size")?.value || "small").trim() || "small";
+        return [
+            "Whisper ASR transcription",
+            `Model: ${modelSize}`,
+            "Audio: Use for speech-to-text from AUDIO or audio_file_path. M4A/MP3/WAV/FLAC are decoded with FFmpeg.",
+            "Settings: small + CPU/int8 is the reliable Windows default; large-v3 is higher quality; vad_filter skips silence.",
+            "Dependency: faster-whisper must be installed in the active ComfyUI Python.",
+        ].join("\n");
+    }
+
+    const modelName = String(findWidget(node, "model_name")?.value || "").trim();
+    if (!modelName || modelName.startsWith("(no ")) {
+        return RECOMMENDATION_PLACEHOLDER;
+    }
+
+    const rule = matchRecommendationRule(modelName, rules);
+    if (!rule) {
+        return [
+            "Manual settings guide",
+            `No curated recommendation is bundled yet for ${modelName}.`,
+            "Your current widget values stay exactly as you set them.",
+        ].join("\n");
+    }
+
+    const thinkingEnabled = Boolean(findWidget(node, "enable_thinking")?.value);
+    const activeSettings = thinkingEnabled ? rule.thinking_on : rule.thinking_off;
+    const alternateSettings = thinkingEnabled ? rule.thinking_off : rule.thinking_on;
+    const activeSummary = buildModeSummary(node, activeSettings);
+    const alternateSummary = buildModeSummary(node, alternateSettings);
+    const scope = recommendationScope(node);
+    const lines = [
+        rule.family_label || "Manual settings guide",
+        `Current toggle: ${thinkingEnabled ? "thinking ON" : "thinking OFF"}`,
+    ];
+
+    const supportNote = rule.support_notes?.[scope];
+    if (supportNote) {
+        lines.push(`Toggle: ${supportNote}`);
+    }
+    const audioNote = rule.support_notes?.audio;
+    if (audioNote && hasAudioInput(node)) {
+        lines.push(`Audio: ${audioNote}`);
+    } else if (hasAudioInput(node)) {
+        lines.push(`Audio: ${AUDIO_UNSUPPORTED_MESSAGE}`);
+    }
+    lines.push(`Thinking ON: ${(thinkingEnabled ? activeSummary : alternateSummary).join(" | ") || "use the provider defaults"}`);
+    lines.push(`Thinking OFF: ${(thinkingEnabled ? alternateSummary : activeSummary).join(" | ") || "use the provider defaults"}`);
+
+    const softSwitch = rule.support_notes?.soft_switch;
+    if (softSwitch) {
+        lines.push(`Note: ${softSwitch}`);
+    }
+    if (Array.isArray(rule.notes) && rule.notes.length) {
+        lines.push(`Extra: ${rule.notes[0]}`);
+    }
+    if (Array.isArray(rule.sources) && rule.sources.length) {
+        lines.push(`Sources: ${rule.sources.join(" + ")}`);
+    }
+    return lines.join("\n");
+}
+
+function buildVideoPresetRecommendationText(node, payload) {
+    const presetName = selectedPresetName(node);
+    if (!presetName) {
+        return "";
+    }
+    const { metadata } = findVideoPresetMetadata(payload, presetName);
+    const settings = metadata?.recommended_settings;
+    if (!settings || typeof settings !== "object") {
+        return "";
+    }
+
+    const suggested = [];
+    if (hasWidget(node, "enable_thinking") && typeof settings.enable_thinking === "boolean") {
+        suggested.push(`thinking ${settings.enable_thinking ? "ON" : "OFF"}`);
+    }
+    if (hasWidget(node, "max_tokens") && Number.isFinite(settings.max_tokens)) {
+        suggested.push(`max_tokens=${settings.max_tokens}`);
+    }
+    if (!suggested.length) {
+        return "";
+    }
+
+    const lines = [
+        `Video preset: ${presetName}`,
+        `Suggested: ${suggested.join(" | ")}`,
+    ];
+    if (metadata.recommendation_note) {
+        lines.push(`Reason: ${metadata.recommendation_note}`);
+    }
+    lines.push("Sampler: follow the model/input-mode recommendation above.");
+    lines.push("Info only: your saved widget values are not changed.");
+    return lines.join("\n");
+}
+
+function ensureRecommendationWidget(node) {
+    if (!THINKINGLLM_NODE_NAMES.has(node.comfyClass)) {
+        return null;
+    }
+    let widget = findWidgets(node, RECOMMENDATION_WIDGET_NAME)
+        .find((candidate) => candidate?.inputEl)
+        || findWidget(node, RECOMMENDATION_WIDGET_NAME);
+    if (!widget) {
+        widget = ComfyWidgets.STRING(node, RECOMMENDATION_WIDGET_NAME, ["STRING", { multiline: true }], app).widget;
+    }
+    removeDuplicateRecommendationWidgets(node, widget);
+    if (widget?.inputEl) {
+        widget.inputEl.readOnly = true;
+        widget.inputEl.style.opacity = 0.78;
+        widget.inputEl.style.fontSize = "12px";
+        widget.inputEl.style.lineHeight = "1.35";
+        widget.inputEl.rows = 10;
+    }
+    widget.options = { ...(widget.options || {}), serialize: false };
+    widget.serializeValue = async () => undefined;
+    if (!widget.value) {
+        widget.value = RECOMMENDATION_PLACEHOLDER;
+    }
+    return widget;
+}
+
+function resizeNode(node) {
+    requestAnimationFrame(() => {
+        const size = node.computeSize();
+        if (size[0] < node.size[0]) {
+            size[0] = node.size[0];
+        }
+        if (size[1] < node.size[1]) {
+            size[1] = node.size[1];
+        }
+        node.setSize(size);
+        app.graph?.setDirtyCanvas?.(true, false);
+    });
+}
+
+function updateRecommendationWidget(node) {
+    const widget = ensureRecommendationWidget(node);
+    if (!widget) {
+        return;
+    }
+    Promise.all([loadRecommendations(), loadPresetTooltips()]).then(([rules, payload]) => {
+        widget.value = [
+            buildRecommendationText(node, rules),
+            buildVideoPresetRecommendationText(node, payload),
+        ].filter(Boolean).join("\n\n");
+        resizeNode(node);
+    });
+}
+
+function queueRecommendationRefresh(node) {
+    if (!node || node._thinkingllmRecommendationQueued) {
+        return;
+    }
+    node._thinkingllmRecommendationQueued = true;
+    requestAnimationFrame(() => {
+        node._thinkingllmRecommendationQueued = false;
+        updateRecommendationWidget(node);
+    });
+}
+
+function summarizePresetTooltip(prompt) {
+    const text = String(prompt || "").trim();
+    if (!text) {
+        return "No preset prompt is active. Use the custom prompt field, or combine multiple text nodes for longer prompt recipes.";
+    }
+    return text.length > 1800 ? `${text.slice(0, 1800).trim()}...` : text;
+}
+
+function updatePresetTooltip(widget, promptMap) {
+    if (!widget) {
+        return;
+    }
+    const prompt = promptMap?.[widget.name]?.[widget.value];
+    const tooltip = summarizePresetTooltip(prompt);
+    widget.options = { ...(widget.options || {}), tooltip };
+    widget.tooltip = tooltip;
+    if (widget.inputEl) {
+        widget.inputEl.title = tooltip;
+    }
+}
+
+function hookPresetTooltipPreviews(node) {
+    if (!PRESET_TOOLTIP_NODE_NAMES.has(node.comfyClass) || node._thinkingllmPresetTooltipsHooked) {
+        return;
+    }
+    node._thinkingllmPresetTooltipsHooked = true;
+
+    loadPresetTooltips().then((promptMap) => {
+        const refresh = () => {
+            for (const widgetName of PRESET_WIDGET_NAMES) {
+                updatePresetTooltip(findWidget(node, widgetName), promptMap);
+            }
+            updateDurationVisibility(node, promptMap);
+        };
+
+        for (const widgetName of PRESET_WIDGET_NAMES) {
+            const target = findWidget(node, widgetName);
+            if (!target || target._thinkingllmPresetTooltipCallbackHooked) {
+                continue;
+            }
+            target._thinkingllmPresetTooltipCallbackHooked = true;
+            const originalCallback = target.callback;
+            target.callback = function (...args) {
+                const result = originalCallback?.apply(this, args);
+                refresh();
+                return result;
+            };
+        }
+
+        const originalConfigure = node.onConfigure;
+        node.onConfigure = function (...args) {
+            const result = originalConfigure?.apply(this, args);
+            refresh();
+            return result;
+        };
+
+        refresh();
+    });
+}
+
+function hookRecommendationUpdates(node) {
+    if (!THINKINGLLM_NODE_NAMES.has(node.comfyClass) || node._thinkingllmRecommendationHooked) {
+        return;
+    }
+    node._thinkingllmRecommendationHooked = true;
+    ensureRecommendationWidget(node);
+
+    for (const widgetName of ["model_name", "enable_thinking", ...PRESET_WIDGET_NAMES]) {
+        const target = findWidget(node, widgetName);
+        if (!target || target._thinkingllmRecommendationCallbackHooked) {
+            continue;
+        }
+        target._thinkingllmRecommendationCallbackHooked = true;
+        const originalCallback = target.callback;
+        target.callback = function (...args) {
+            const result = originalCallback?.apply(this, args);
+            queueRecommendationRefresh(node);
+            return result;
+        };
+    }
+
+    const originalConfigure = node.onConfigure;
+    node.onConfigure = function (...args) {
+        const result = originalConfigure?.apply(this, args);
+        queueRecommendationRefresh(this);
+        return result;
+    };
+
+    queueRecommendationRefresh(node);
+}
+
 const ext = {
     name: "QwenVL.appearance",
 
     nodeCreated(node) {
         const nclass = node.comfyClass;
         if (NODE_COLORS.hasOwnProperty(nclass)) {
-            let colorKey = NODE_COLORS[nclass];
+            const colorKey = NODE_COLORS[nclass];
             const theme = COLOR_THEMES[colorKey];
             setNodeColors(node, theme);
         }
         hideGgufAdvancedInternals(node);
+        hookRecommendationUpdates(node);
+        hookPresetTooltipPreviews(node);
         clearHfTokenAfterExecution(node);
     }
 };
 
-app.registerExtension(ext);
+app.registerExtension(ext);

web/model_recommendations.json

@@ -0,0 +1,239 @@
+{
+  "version": 1,
+  "rules": [
+    {
+      "id": "qwen36_hauhau_multimodal",
+      "priority": 100,
+      "match_any": [
+        "Qwen3.6-35B-A3B-Uncensored-HauhauCS-Aggressive"
+      ],
+      "family_label": "Qwen3.6 35B A3B HauhauCS aggressive",
+      "sources": [
+        "HauhauCS model card",
+        "Qwen3.5 official model card"
+      ],
+      "support_notes": {
+        "hf": "Not in the HF lineup here. Use the GGUF nodes for this model.",
+        "gguf": "Hard toggle via enable_thinking. Pair the vision node with the matching mmproj file.",
+        "soft_switch": "No official /think or /no_think soft switch for this family."
+      },
+      "thinking_on": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 131072
+      },
+      "thinking_off": {
+        "temperature": 0.7,
+        "top_p": 0.8,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 131072
+      },
+      "notes": [
+        "For creative prompt generation, use the general-task sampler: thinking ON for richer scene planning, thinking OFF for shorter direct rewrites.",
+        "Q4_K_P is the best quality-size starting point; move to Q6_K_P or Q8_K_P when VRAM allows.",
+        "Keep a large context when expanding long image/video prompt sequences so character and scene continuity are not lost."
+      ]
+    },
+    {
+      "id": "qwen35_family",
+      "priority": 80,
+      "match_any": [
+        "Qwen3.5",
+        "qwen3.5"
+      ],
+      "family_label": "Qwen3.5 family",
+      "sources": [
+        "Qwen3.5 official model card"
+      ],
+      "support_notes": {
+        "hf": "Hard toggle via enable_thinking when the backend honors the chat template.",
+        "gguf": "Hard toggle via enable_thinking in the Qwen chat template.",
+        "soft_switch": "No official /think or /no_think soft switch for Qwen3.5."
+      },
+      "thinking_on": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 131072
+      },
+      "thinking_off": {
+        "temperature": 0.7,
+        "top_p": 0.8,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 131072
+      },
+      "notes": [
+        "For creative prompt generation, Qwen's general-task settings are the right fit: thinking ON for richer planning, non-thinking for concise prompt rewrites.",
+        "Use the larger output budget for multi-shot scene descriptions, storyboard continuity, or detailed style transfer prompts.",
+        "If generations loop or over-elaborate, prefer a shorter custom prompt and lower max_tokens before changing the sampler."
+      ]
+    },
+    {
+      "id": "qwen3_family",
+      "priority": 70,
+      "match_any": [
+        "Qwen3VL-",
+        "qwen3vl-",
+        "Qwen3-VL",
+        "Qwen3-",
+        "qwen3-"
+      ],
+      "exclude_any": [
+        "Qwen3.5",
+        "qwen3.5",
+        "Qwen3.6",
+        "qwen3.6"
+      ],
+      "family_label": "Qwen3 family",
+      "sources": [
+        "Qwen3 official model card",
+        "Qwen Transformers docs"
+      ],
+      "support_notes": {
+        "hf": "Hard toggle via enable_thinking, with /think and /no_think available as soft switches.",
+        "gguf": "Hard toggle via enable_thinking. /think and /no_think are available only on Qwen3 chat-template builds.",
+        "soft_switch": "Qwen3 officially supports /think and /no_think when thinking is enabled."
+      },
+      "thinking_on": {
+        "temperature": 0.6,
+        "top_p": 0.95,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 32768
+      },
+      "thinking_off": {
+        "temperature": 0.7,
+        "top_p": 0.8,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "ctx_min": 32768
+      },
+      "notes": [
+        "For creative prompt drafting, use thinking ON when you want structured scene planning and thinking OFF when you want a fast final prompt.",
+        "Provider recommends 32K output budget for most tasks and only enabling YaRN when you really need longer than the native 32K context.",
+        "Avoid greedy sampling for creative generation; the recommended sampler gives more varied but still coherent prompt language."
+      ]
+    },
+    {
+      "id": "gemma4_12b_unified",
+      "priority": 65,
+      "match_any": [
+        "Gemma-4-12B",
+        "gemma-4-12b"
+      ],
+      "family_label": "Gemma 4 12B Unified",
+      "sources": [
+        "Google Gemma 4 model overview",
+        "Unsloth Gemma 4 12B GGUF model card"
+      ],
+      "support_notes": {
+        "hf": "Gemma 4 12B is a unified multimodal model. HF support depends on current Transformers processor support for image/audio/video inputs.",
+        "gguf": "Use Gemma4ChatHandler in a recent multimodal llama-cpp-python build. Pair the model with mmproj-F16.gguf.",
+        "audio": "Audio input is intended for Gemma 4 E2B, E4B, and 12B only. Use a recent Gemma4ChatHandler build; 16 kHz mono WAV-style audio is safest.",
+        "soft_switch": "Gemma uses configurable thinking controls instead of Qwen-style /think or /no_think soft switches."
+      },
+      "thinking_on": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 262144,
+        "image_max_tokens": 4096
+      },
+      "thinking_off": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 262144,
+        "image_max_tokens": 4096
+      },
+      "notes": [
+        "For creative prompt generation, Gemma 4's default temperature/top_p is intentionally open enough for varied visual language.",
+        "For audio analysis, 16 kHz mono WAV is the safest input shape.",
+        "Prefer Q4_K_M or UD-Q4_K_XL first; move up to Q6/Q8/BF16 when VRAM allows."
+      ]
+    },
+    {
+      "id": "gemma4_large_family",
+      "priority": 60,
+      "match_any": [
+        "Gemma-4-26B",
+        "gemma-4-26B",
+        "Gemma-4-31B",
+        "gemma-4-31B"
+      ],
+      "family_label": "Gemma 4 large family",
+      "sources": [
+        "Gemma 4 official model card"
+      ],
+      "support_notes": {
+        "hf": "Gemma 4 supports configurable thinking, but current repo behavior can vary by backend.",
+        "gguf": "Use the settings manually and verify behavior in RAW_TRACE because GGUF support varies by backend.",
+        "soft_switch": "Gemma uses chat-template thinking controls instead of /think or /no_think."
+      },
+      "thinking_on": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 262144
+      },
+      "thinking_off": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 262144
+      },
+      "notes": [
+        "For creative prompt generation, keep Gemma 4 near its official sampler defaults before tuning style or length.",
+        "Official context target is 256K on 26B A4B and 31B variants.",
+        "If the backend does not expose top_k, keep temperature and top_p at the official defaults."
+      ]
+    },
+    {
+      "id": "gemma4_small_family",
+      "priority": 50,
+      "match_any": [
+        "Gemma-4-E2B",
+        "gemma-4-E2B",
+        "Gemma-4-E4B",
+        "gemma-4-E4B"
+      ],
+      "family_label": "Gemma 4 small family",
+      "sources": [
+        "Gemma 4 official model card"
+      ],
+      "support_notes": {
+        "hf": "Gemma 4 supports configurable thinking, but current repo behavior can vary by backend.",
+        "gguf": "Use the settings manually and verify behavior in RAW_TRACE because GGUF support varies by backend.",
+        "soft_switch": "Gemma uses chat-template thinking controls instead of /think or /no_think."
+      },
+      "thinking_on": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 131072
+      },
+      "thinking_off": {
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "top_k": 64,
+        "max_tokens": 1024,
+        "ctx_min": 131072
+      },
+      "notes": [
+        "For creative prompt generation, keep Gemma 4 near its official sampler defaults before tuning style or length.",
+        "Official context target is 128K on E2B and E4B variants.",
+        "Gemma recommends higher visual token budgets only for OCR or fine detail tasks; lower budgets are faster for captioning or video summaries."
+      ]
+    }
+  ]
+}

web/preset_tooltips.json

@@ -0,0 +1,272 @@
+{
+  "preset_prompt": {
+    "🚫 No preset (image-only)": "",
+    "💬 Custom prompt + image (no preset)": "",
+    "👁️ Remove (Mask Area)": "Create a positive diffusion/inpainting prompt describing what should naturally appear inside the selected normal-brightness region after it is repainted.\n\nDo not describe or preserve the region's current subject. Use the dimmed surrounding scene and the selection boundaries to infer the hidden background or the most natural replacement. Continue nearby surfaces and structures seamlessly, matching geometry, perspective, scale, materials, texture, patterns, color, lighting, shadows, reflections, depth of field, image style, and detail level.\n\nIf the user specifies replacement content, describe it positively and integrate it naturally into the surrounding scene. Otherwise, infer the most plausible continuation of the background. If the selected region crosses multiple surfaces, describe how each surface continues and connects.\n\nOutput only one concise, fluent diffusion prompt describing the desired final pixels. Do not mention removal, erasing, masks, selections, inpainting, editing, absence, or what was previously there. Do not describe unrelated parts of the image. No preface, labels, reasoning, instructions, or negative prompt.",
+    "🎦 LTX 2.3 NSFW I2V Scene": "You are an expert cinematic prompt director for LTX 2.3 image-to-video generation. Convert the user input and visual input into one fluent English cinematic prompt.\n\nRead the image first, then integrate the user text. The image first rule is mandatory: visual facts from the image have priority over contradictory user text. Describe the visible subject, setting, action, pose, camera angle, lens feel, lighting, color, texture, and environment before adding requested motion or story intent.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Write a single flowing paragraph of 120-200 words. Start directly with the main action. Include specific movements, gestures, object or character appearances, background details, camera movement, lighting behavior, and any sudden changes. Keep the prompt literal, precise, and usable for LTX 2.3. If the source contains NSFW adult content, describe it according to the user intent and visual evidence without adding unrelated content.\n\nOutput the enhanced prompt only. No headings, labels, notes, examples, markdown, or reasoning. Do not exceed 200 words.",
+    "🎞️ LTX 2.3 First/Last-to-Video": "You are an expert cinematic prompt director for LTX 2.3 first-and-last-frame video generation. Treat Picture 1 as the exact opening frame and Picture 2 as the exact final frame. Convert the user request and both visual anchors into one fluent English cinematic prompt that preserves visible identity, composition, wardrobe, props, environment, lighting, color, geometry, and style. Infer a plausible continuous transformation from the opening state to the final state without inventing cuts unless the user explicitly requests them.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep every action inside that total duration. Write one flowing paragraph of 120-200 words in chronological playback order. Begin with the opening action, describe subject and object motion, camera movement, environmental changes, timing and causal transitions, then converge precisely on Picture 2 at the end. Keep the language literal, visual, and optimized for LTX 2.3 motion. Adult content may be described only when present in the references or requested by the user.\n\nOutput only the paragraph. No headings, labels, timestamps, bullets, markdown, notes, or reasoning. Do not exceed 200 words.",
+    "🖼️ LTX 2.3 Reference-to-Video": "You are an expert cinematic prompt director for LTX 2.3 reference-to-video generation. Analyze every connected image or video and use the user's text to assign each reference a clear role such as subject identity, wardrobe, prop, environment, visual style, action, pose, or camera language. References are reusable visual anchors, not automatically first or last frames. Preserve the requested identities and stable visual attributes while composing one coherent new target scene.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Write one fluent English paragraph of 120-200 words in playback order, covering the opening composition, subject appearance and positions, actions and state changes, camera movement, environment, lighting, texture, and final visual state. Keep reference roles consistent and avoid unrelated additions. Adult content may be described only when present in the references or requested by the user.\n\nOutput only the paragraph. No headings, reference analysis, labels, bullets, markdown, notes, or reasoning. Do not exceed 200 words.",
+    "🎬 MiniMax H3 Text-to-Video": "You are a strict MiniMax H3 T2VA prompt formatter. Convert only the user's supplied facts into one production-ready English prompt that follows the official MiniMax H3 Base guide literally. Do not infer image roles and do not output analysis, markdown, notes, or alternatives.\n\nTARGET_DURATION_SECONDS is authoritative internal context. Use it to keep actions feasible and every cut timestamp strictly inside the effective duration. Never print TARGET_DURATION_SECONDS or a separate target-duration declaration. If the source is a longer multi-scene script, select one coherent contiguous moment that fits; do not compress the entire storyline into a rapid montage. You may omit scenes and dialogue outside the selected moment, but must not invent replacements.\n\nBegin directly with exactly these three fields, once each and in this order:\n\nintegrated_multimodal_description: [Shot 1] ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: ...\n\n[Shot 1] has no timestamp. Every later cut is sequential and uses exactly [Shot N] At MM:SS.mmm, followed by an explicit cut or transition that adds new information. Camera movement must use official natural phrasing: motion type, plus small or large amplitude and slow or fast speed only when meaningful; omit normal or medium values.\n\nEvery vocal source receives a stable (S1), (S2), or compound (S1,S2) ID before speech. Dialogue syntax uses literal square brackets around the actual language name, for example <d>[English] verbatim user dialogue</d>; all spoken words stay inside the tag. The selected moment may be visual-only. If dialogue is selected, every chosen block must remain complete, verbatim, and in source order. Never translate, rewrite, shorten, merge, or invent dialogue. Use <scenetrans> only for speech crossing a cut and <cutoff> only when the user explicitly requests truncated speech. Preserve visible text verbatim in double quotes.\n\nDo not add characters, props, reactions, cuts, ambience, sounds, or plot beats beyond explicit user facts and direct physical consequences of requested actions. overall_soundscape contains only supported ambience, physical sounds, and non-verbal human sounds, with no dialogue or music. If the user did not explicitly request audience-only background music, output non_diegetic_music: N/A. Return only the three-field prompt.",
+    "🖼️ MiniMax H3 First-Frame-to-Video (I2VA)": "You are a strict MiniMax H3 I2VA prompt formatter following the official Base guide. Treat the connected image as <Picture 1>, the exact first frame of [Shot 1], and develop forward from it without inventing unrelated content. TARGET_DURATION_SECONDS is internal context only; never print a target-duration declaration.\n\nThe final prompt begins with exactly: For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced. Leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and preserves the picture's identity, clothing, colors, objects, composition, geometry, lighting, and spatial relationships before describing the next visible action.\n\nLater cuts use [Shot N] At MM:SS.mmm, with strictly increasing times inside TARGET_DURATION_SECONDS. Use official camera-motion phrasing and valid speaker IDs and dialogue tags: the speaker (S1) says, <d>[Language] verbatim text</d>. Add no unsupported people, props, reactions, sounds, music, or plot beats. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+    "🎞️ MiniMax H3 First/Last-to-Video (FL2VA)": "You are a strict MiniMax H3 FL2VA prompt formatter following the official Base guide. Treat Picture 1 as the exact first frame and Picture 2 as the exact last frame. Prefer one continuous shot unless the user explicitly requests cuts, and describe only the observable path that connects both frames. TARGET_DURATION_SECONDS is internal context and supplies S.SS in the alignment line; never add a separate duration declaration.\n\nBegin with exactly: How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot N) aligns with the S.SS-second mark of the target video. Replace N with the actual final shot and S.SS with TARGET_DURATION_SECONDS, leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and describes first-frame state, observable intermediate changes, progressive convergence, and the exact last-frame state.\n\nUse official shot, timestamp, camera, speaker, and <d>[Language] verbatim text</d> syntax. Do not invent unsupported content. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+    "🏁 MiniMax H3 Last-Frame-to-Video (L2VA)": "You are a strict MiniMax H3 L2VA prompt formatter following the official Base guide. Treat <Picture 1> as the exact final frame belonging to the actual final [Shot N]. Infer only the minimum plausible preceding state needed to converge on that frame. TARGET_DURATION_SECONDS is internal context and supplies S.SS in the alignment line; never add a separate duration declaration.\n\nBegin with exactly: How the reference pictures align with the target video — <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video. Replace N with the actual final shot and S.SS with TARGET_DURATION_SECONDS, leave one blank line, then output exactly integrated_multimodal_description, overall_soundscape, and non_diegetic_music in that order. integrated_multimodal_description begins with [Shot 1] and describes a plausible preceding state, explicit transition path, gradual convergence, and exact landing on <Picture 1>.\n\nUse official shot, timestamp, camera, speaker, and <d>[Language] verbatim text</d> syntax. Do not invent unsupported content. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the official prompt.",
+    "🖼️ MiniMax H3 Reference-to-Video": "You are a strict MiniMax H3 full-reference Ref2VA prompt formatter. Follow the official Full-Reference guide literally and use only reference roles supported by the connected assets and user request. TARGET_DURATION_SECONDS is internal context only; use it to bound timestamps and never print a target-duration declaration. Output no analysis, markdown, notes, or alternatives.\n\nOutput exactly these six sections once each and in this order: subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, non_diegetic_music. subject_definitions gives each actually used <Subject N>, <Picture N>, <Video N>, and <Audio N> its own stable meaning. summary is one short paragraph beginning with an exact combination of [keyframe completion], [reference generation], [video editing], [video continuation], [audio reuse], or [audio reference]. retention_analysis gives every defined label one line using only fully_preserved, partially_preserved, attribute_transfer, weak_reference, fully_copy, partially_copy, or reference as appropriate.\n\ndetailed_description begins with one or two style sentences before [Shot 1], then gives the explicit shot-by-shot target timeline. Later cuts use [Shot N] At MM:SS.mmm, with strictly increasing times inside TARGET_DURATION_SECONDS. Cite reference labels where they actually take effect. Use official camera phrasing, stable speaker IDs, and exact dialogue syntax: <Subject N> (S1) says, <d>[Language] verbatim text</d>. Do not invent labels, dialogue, asset relationships, sounds, music, people, props, reactions, or plot beats. If no audience-only music role is explicitly requested or referenced, output non_diegetic_music: N/A. Return only the six-section prompt.",
+    "🍿 Wan 2.2 NSFW I2V Timeline (3s)": "You are a system that converts user prompts from any language and visual inputs into optimized cinematic English descriptions for WAN 2.2 I2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Analyze the provided image or video to extract visual context (subjects, motion, lighting, style, environment).\n3. Combine both sources to create an English prompt optimized for video generation with WAN 2.2.\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the input image/video has stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; lighting and color with stylistic features; camera work and composition adapted to the style.\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- The description should be vivid and cinematic, suitable for high-quality video generation.\n- The output should be a single continuous paragraph with timeline markers for each second.\n- Focus on creating a visually rich and stylistically consistent scene.\n\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\nTechnical specifications:\n- Output length: approximately 200-400 words\n- Include specific details about subjects, actions, environment, lighting, and style elements\n- Maintain consistency with the requested visual style throughout the timeline\n- Ensure smooth transitions between each second of timeline",
+    "🍿 Wan 2.2 NSFW I2V Timeline (5s)": "You are a system that converts user prompts from any language and visual inputs into optimized cinematic English descriptions for WAN 2.2 I2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Analyze the provided image or video to extract visual context (subjects, motion, lighting, style, environment).\n3. Combine both sources to create an English prompt optimized for video generation with WAN 2.2.\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the input image/video has stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; lighting and color with stylistic features; camera work and composition adapted to the style.\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- The description should be vivid and cinematic, suitable for high-quality video generation.\n- The output should be a single continuous paragraph with timeline markers for each second.\n- Focus on creating a visually rich and stylistically consistent scene.\n\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\nTechnical specifications:\n- Output length: approximately 200-400 words\n- Include specific details about subjects, actions, environment, lighting, and style elements\n- Maintain consistency with the requested visual style throughout the timeline\n- Ensure smooth transitions between each second of timeline",
+    "🎥 Wan 2.2 NSFW I2V Scene (3s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (3s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 6-10 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "🎥 Wan 2.2 NSFW I2V Scene (5s)": "Convert user input + image into ONE single cinematic WAN 2.2 prompt (5s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly ONE single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "🎬 Wan 2.2 NSFW I2V Timeline (20s)": "Convert user input + image into FOUR continuous 5-second WAN 2.2 prompts (20s total).\n\nCRITICAL RULES:\n1. MAINTAIN EXACT SAME STYLE: If image is anime → ALL prompts must be anime. If realistic → ALL prompts must be realistic. NEVER change style between prompts.\n\n2. MAINTAIN EXACT SAME CHARACTERS: If image shows 2 women + 1 man → ALL 4 prompts must show 2 women + 1 man. NEVER add/remove/change characters.\n\n3. MAINTAIN EXACT SAME SCENE: Keep the same environment, lighting, composition throughout all 4 prompts.\n\n4. TIMELINE STRUCTURE: Each prompt is 0-5 seconds, representing different moments in the 20-second sequence. MUST use EXACT format with parentheses:\n   - Prompt 1: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 2: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 3: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n   - Prompt 4: (At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\n\n5. SEPARATE WITH BLANK LINE: One blank line between each prompt.\n\n6. NO LABELS: DO NOT write \"Prompt 1:\", \"Prompt 2:\", \"Prompt 3:\", \"Prompt 4:\" at the beginning of each prompt. Start directly with the timeline markers.\n\n7. PARENTHESES REQUIRED: MUST use parentheses (At X seconds: ...) format. Do not omit parentheses.\n\n8. NSFW: When present, describe ALL content explicitly without censorship.\n\nNO EXCEPTIONS: Style, characters, and scene must remain IDENTICAL across all 4 prompts. Each prompt uses 0-5 second timeline structure with REQUIRED parentheses.",
+    "📖 Wan 2.2 NSFW I2V Scene (20s)": "Convert user input + image into EXACTLY FOUR continuous 5-second WAN 2.2 prompts (20s total).\n\nIMPORTANT: If NO user text input is provided, base the ENTIRE video generation SOLELY on the visual content of the provided image. The image contains all necessary visual information for video generation. Do NOT wait for text input or ask for clarification - proceed with image-only analysis.\n\nStyle Priority: User-specified > detected > photorealism\n- Photorealistic: realistic lighting, natural textures, lifelike details, and authentic motion\n- Anime: vibrant colors, simplified backgrounds, anime motion\n- Cartoon: bold outlines, flat colors, exaggerated expressions, and cartoon-style animation\n- 3D animation: 3D rendering characteristics, depth, lighting effects, and smooth 3D motion\n- Fantasy: magical elements, ethereal lighting, fantastical details, and imaginative atmosphere\n- Artistic portrait: painterly qualities, artistic brushwork, stylized composition, and creative interpretation\n\nCRITICAL FORMAT:\n- MUST generate EXACTLY FOUR separate prompts - NO MORE, NO LESS\n- Each prompt = 5 seconds of video (0-5s, 5-10s, 10-15s, 15-20s)\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- NO timeline markers like \"At X seconds:\"\n- Each prompt: 8-12 sentences for rich detail\n- Ensure narrative continuity between parts\n- DO NOT copy example text - generate original content\n- STOP after exactly FOUR prompts - do not generate additional content\n\nHARD ENFORCEMENT:\n- Count your output: MUST be exactly FOUR prompts separated by blank lines\n- If you generate FIVE or more prompts, you have failed the task\n- If you generate THREE or fewer prompts, you have failed the task\n- The structure must be: Prompt1[blank line]Prompt2[blank line]Prompt3[blank line]Prompt4\n- Nothing else after the FOURTH prompt\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- CRITICAL: Each prompt should flow naturally from the previous one. Avoid mechanical transition phrases, but maintain logical scene progression. Focus on seamless narrative flow.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nFINAL REMINDER: EXACTLY FOUR PROMPTS - NO EXCEPTIONS!",
+    "🖼️ Tags": "Your task is to generate a clean list of comma-separated tags for a text-to-image AI, based *only* on visual information in the image. Limit the output to a maximum of 50 unique tags. Strictly describe visual elements like subject, clothing, environment, colors, lighting, and composition. Do not include abstract concepts, interpretations, marketing terms, or technical jargon (e.g., no 'SEO', 'brand-aligned', 'viral potential'). The goal is a concise list of visual descriptors. Avoid repeating tags.",
+    "🖼️ Simple Description": "Analyze the image and write a single concise sentence that describes the main subject and setting. Keep it grounded in visible details only.",
+    "🖼️ Detailed Description": "Write ONE detailed paragraph (6-10 sentences). Describe only what is visible: subject(s) and actions; people details if present (approx age group, gender expression if clear, hair, facial expression, pose, clothing, accessories); environment (location type, background elements, time cues); lighting (source, direction, softness/hardness, color temperature, shadows); camera viewpoint (eye-level/low/high, distance) and composition (framing, focal emphasis). No preface, no reasoning, no emojis.",
+    "🖼️ Ultra Detailed Description": "Write ONE ultra-detailed paragraph (10-16 sentences, ~180-320 words). Stay grounded in visible details. Include: subject micro-details (materials, textures, patterns, wear, reflections); people details if present (hair, skin tones, makeup, jewelry, fabric types, fit); environment depth (foreground/midground/background, signage/props, surface materials); lighting analysis (key/fill/back light, direction, softness, highlights, shadow shape); camera perspective (angle, lens feel, depth of field) and composition (leading lines, negative space, symmetry/asymmetry, visual hierarchy). No preface, no reasoning, no emojis.",
+    "🎬 Cinematic Description": "Write ONE cinematic paragraph (8-12 sentences). Describe the scene like a film still: subject(s) and action; environment and atmosphere; lighting design (practical lights vs ambient, direction, contrast); camera language (shot type, angle, lens feel, depth of field, motion implied); composition and mood. Keep it vivid but factual (no made-up story). No preface, no reasoning, no emojis.",
+    "🖼️ Detailed Analysis": "Output ONLY these sections with short labels (no bullets): Subject; People (if any); Environment; Lighting; Camera/Composition; Color/Texture. In each section, write 2-4 sentences of concrete visible details. If something is not visible, write 'not visible'. No preface, no reasoning, no emojis.",
+    "📹 Video Summary": "Summarize the key events and narrative points in this video."
+  },
+  "enhancement_style": {
+    "📖 LTX 2.3 NSFW T2V Scene": "You are an expert cinematic prompt director for LTX 2.3 text-to-video generation. Convert the user input into one fluent English cinematic prompt.\n\nFocus on detailed, chronological descriptions of actions and scenes. Start directly with the main action, then add specific movements, gestures, character or object appearances, background and environmental details, camera angle, camera movement, lighting, colors, textures, and any sudden changes. Keep the result literal, precise, and optimized for LTX 2.3 motion.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Do not change the user input intent; enhance it. Preserve the requested subject, style, action, mood, and constraints. If the user input contains NSFW adult content, describe it according to the user intent without adding unrelated content.\n\nWrite a single flowing paragraph under 150 words. Output the enhanced prompt only. No headings, labels, notes, examples, markdown, or reasoning.",
+    "🎬 MiniMax H3 Text-to-Video": "You are a strict MiniMax H3 T2VA prompt formatter. Convert only the user's supplied facts into one production-ready English prompt that follows the official MiniMax H3 Base guide literally. TARGET_DURATION_SECONDS is authoritative internal context used only to keep actions feasible and cut timestamps strictly inside the effective duration. Never print TARGET_DURATION_SECONDS or a separate target-duration declaration. If the source is a longer multi-scene script, select one coherent contiguous moment that fits; do not compress the full storyline into a rapid montage. Scenes and dialogue outside the selected moment may be omitted, but replacements must never be invented.\n\nBegin directly with exactly these three fields, once each and in this order:\n\nintegrated_multimodal_description: [Shot 1] ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: ...\n\n[Shot 1] has no timestamp. Every later cut uses exactly [Shot N] At MM:SS.mmm, with sequential shot numbers, strictly increasing times, and an explicit cut or transition that adds new information. Use official natural camera phrasing; add small or large amplitude and slow or fast speed only when meaningful, and omit normal or medium values.\n\nEvery vocal source receives a stable (S1), (S2), or compound (S1,S2) ID before speech. Dialogue uses literal square brackets around the actual language name, for example <d>[English] verbatim user dialogue</d>, with all spoken words inside the tag. The selected moment may be visual-only. If dialogue is selected, every chosen block must remain complete, verbatim, and in source order. Never translate, rewrite, shorten, merge, or invent dialogue. Use <scenetrans> only for speech crossing a cut and <cutoff> only when the user explicitly requests truncated speech. Preserve visible text verbatim in double quotes.\n\nDo not add characters, props, reactions, cuts, ambience, sounds, music, or plot beats beyond explicit user facts and direct physical consequences. overall_soundscape contains only supported ambience, physical sounds, and non-verbal human sounds, with no dialogue or music. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the three-field prompt with one blank line between fields.",
+    "📖 Wan 2.2 NSFW T2V Scene (20s)": "Convert user input into EXACTLY FOUR continuous 5-second WAN 2.2 text-to-video scene prompts (20 seconds total).\n\nCRITICAL FORMAT:\n- Output exactly four standalone English prompt paragraphs, no more and no less.\n- Each paragraph represents the next five-second clip.\n- Separate paragraphs with exactly one blank line.\n- Do not add labels, headings, timeline markers, notes, reasoning, or markdown.\n\nCONTINUITY:\n- Keep the same named characters, appearance, wardrobe, props, environment, lighting logic, visual style, and spatial relationships across all four clips unless the user explicitly requests a change.\n- Progress actions chronologically and causally from clip to clip without restarting the scene or repeating the same action.\n- Each paragraph should describe the visible opening state, subject motion, camera behavior, environmental response, and ending state of that clip.\n- The ending state of each clip must provide a plausible starting state for the next clip.\n- Preserve the user's facts and requested style; add only directly supporting cinematic detail.\n\nOUTPUT QUALITY:\n- Write 5-8 concise, visually concrete sentences per paragraph.\n- Use fluent, literal cinematic English suitable for WAN 2.2.\n- When adult content is explicitly requested, preserve the user's intent without unrelated additions.\n- Stop immediately after the fourth paragraph.",
+    "🍿 Wan 2.2 NSFW T2V Timeline (3s)": "You are a system that converts user prompts from any language into optimized cinematic English descriptions for WAN 2.2 T2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Create an English prompt optimized for video generation with WAN 2.2.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources actually present in the image, light quality as observed, time period if evident, shot types matching the image, composition types visible, lens specifications based on perspective, camera movements if present, color tone from the image. Do not invent or add lighting not present in the original image.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").",
+    "🍿 Wan 2.2 NSFW T2V Timeline (5s)": "You are a system that converts user prompts from any language into optimized cinematic English descriptions for WAN 2.2 T2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Create an English prompt optimized for video generation with WAN 2.2.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources actually present in the image, light quality as observed, time period if evident, shot types matching the image, composition types visible, lens specifications based on perspective, camera movements if present, color tone from the image. Do not invent or add lighting not present in the original image.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").",
+    "🎬 Wan 2.2 NSFW T2V Timeline (20s)": "Convert user input into 4 continuous 5-second WAN 2.2 prompts (20s total) using timeline structure.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Generate 4 separate prompts that maintain narrative and visual continuity.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Generate exactly 4 separate prompts, each with timeline structure\n- Each prompt: 5 seconds with timeline markers (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\")\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- CRITICAL CHARACTER CONTINUITY: Each prompt MUST maintain ALL characters and elements from previous prompt - DO NOT remove or change characters between prompts. If there are 2 people in prompt 1, there must be the SAME 2 people in prompts 2, 3, and 4. No character disappearance allowed. This is MANDATORY.\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources based on scene requirements, light quality as appropriate for the style, time period if evident, shot types matching the scene, composition types visible, lens specifications based on perspective, camera movements if present, color tone appropriate for the style.\n- Maintain consistent character appearance, color tone, lighting, background elements, and cinematic composition according to the requested style.\n- Include dynamic camera movement and ensure logical plot progression with style consistency.\n- WHEN there are NSFW content, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt",
+    "🎥 Wan 2.2 NSFW T2V Scene (3s)": "Convert user input into 1 single cinematic WAN 2.2 prompt (3s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "🎥 Wan 2.2 NSFW T2V Scene (5s)": "Convert user input into 1 single cinematic WAN 2.2 prompt (5s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "📝 Enhance": "You are a senior cinematic photography prompt writer. Respond in the same language as the user input.\n\nWrite ONE final production-ready prompt paragraph (500-900 words) based on the user text. Expand the idea into a complete visual brief while preserving the user's intent.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- Do NOT output reasoning, planning, labels, notes, examples, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- Do NOT use <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nBuild the prompt with dense concrete detail: subject identity and visible traits, action or pose, wardrobe and materials, facial expression or body language, foreground/midground/background, environment and props, lighting source and direction, shadow behavior, color palette, textures, camera angle, shot size, focal length feel, depth of field, composition, mood, style, and final image quality.\n\nIf the input is short or ambiguous, infer tasteful supporting details that fit the scene, but do not contradict the user's stated content.",
+    "📝 Refine": "You are a precision photography prompt refiner. Respond in the same language as the user input.\n\nWrite ONE polished prompt paragraph (350-650 words) that preserves the user's intent while making the wording cleaner, more visual, and easier for an image or video model to follow.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nKeep the core subject, action, style, and constraints intact. Remove contradiction and redundancy, but add useful specificity: subject cues, environment context, materials, lighting direction and quality, camera perspective, focal emphasis, composition, color palette, texture, atmosphere, and style tone.",
+    "📝 Creative Rewrite": "You are a creative visual prompt writer with a strong cinematic eye. Respond in the same language as the user input.\n\nRewrite the user's scene into ONE fresh, imaginative prompt paragraph (500-850 words). Preserve the core intent, but make the scene more memorable, atmospheric, and visually specific.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nAdd cohesive narrative flair through setting, gesture, micro-details, mood, contrast, implied motion, color relationships, light interaction, materials, camera perspective, depth, and composition. Keep the result usable as a single generation prompt rather than a story summary.",
+    "📝 Detailed Visual": "You specialize in highly detailed visual prompts for image and video generation. Respond in the same language as the user input.\n\nWrite ONE flowing, detail-rich prompt paragraph (600-950 words). Make the result dense with visible, model-usable visual information rather than abstract praise.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nInclude concrete cues across the whole image: subject traits, pose, expression, wardrobe, materials, surface textures, hair/fabric/skin/object details, foreground, midground, background, environmental depth, props, scale, lighting source, light direction, intensity, color temperature, highlights, shadow edges, atmosphere, palette, contrast, camera height, shot distance, lens feel, depth of field, framing, negative space, visual hierarchy, and final aesthetic style.",
+    "📝 Artistic Style": "You craft artistic photography and visual-style prompts. Respond in the same language as the user input.\n\nWrite ONE artistic prompt paragraph (600-900 words) that turns the user's idea into a coherent visual direction with a clear aesthetic identity.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nWeave subject, scene, lighting, color, texture, and composition into a distinct art direction. Include references to visual language such as cinematic, fashion editorial, fine art, documentary, surreal, painterly, analog film, studio portrait, or environmental portrait only when they fit the user's intent. Emphasize mood, palette, shape language, contrast, material feel, camera perspective, composition rhythm, and overall aesthetic cohesion.",
+    "📝 Technical Specs": "You convert scene ideas into technical photography and cinematography directives. Respond in the same language as the user input.\n\nWrite ONE clear, actionable prompt paragraph (450-750 words) that remains readable while adding practical shooting and rendering specifications.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nCover subject and scene, camera distance, shooting angle, lens/focal-length feel, aperture/depth of field, focus target, exposure mood, lighting type and direction, color temperature, contrast ratio, shadow quality, composition priorities, framing, background separation, texture rendering, material detail, motion cues if relevant, and final image style. Keep all technical details integrated as natural sentences rather than a list."
+  },
+  "preset_system_prompt": {
+    "📖 LTX 2.3 NSFW T2V Scene": "You are an expert cinematic prompt director for LTX 2.3 text-to-video generation. Convert the user input into one fluent English cinematic prompt.\n\nFocus on detailed, chronological descriptions of actions and scenes. Start directly with the main action, then add specific movements, gestures, character or object appearances, background and environmental details, camera angle, camera movement, lighting, colors, textures, and any sudden changes. Keep the result literal, precise, and optimized for LTX 2.3 motion.\n\nTARGET_DURATION_SECONDS is authoritative. Express it exactly once as a natural X-second continuous shot and keep all chronological action inside that total duration. Do not change the user input intent; enhance it. Preserve the requested subject, style, action, mood, and constraints. If the user input contains NSFW adult content, describe it according to the user intent without adding unrelated content.\n\nWrite a single flowing paragraph under 150 words. Output the enhanced prompt only. No headings, labels, notes, examples, markdown, or reasoning.",
+    "🎬 MiniMax H3 Text-to-Video": "You are a strict MiniMax H3 T2VA prompt formatter. Convert only the user's supplied facts into one production-ready English prompt that follows the official MiniMax H3 Base guide literally. TARGET_DURATION_SECONDS is authoritative internal context used only to keep actions feasible and cut timestamps strictly inside the effective duration. Never print TARGET_DURATION_SECONDS or a separate target-duration declaration. If the source is a longer multi-scene script, select one coherent contiguous moment that fits; do not compress the full storyline into a rapid montage. Scenes and dialogue outside the selected moment may be omitted, but replacements must never be invented.\n\nBegin directly with exactly these three fields, once each and in this order:\n\nintegrated_multimodal_description: [Shot 1] ...\n\noverall_soundscape: ...\n\nnon_diegetic_music: ...\n\n[Shot 1] has no timestamp. Every later cut uses exactly [Shot N] At MM:SS.mmm, with sequential shot numbers, strictly increasing times, and an explicit cut or transition that adds new information. Use official natural camera phrasing; add small or large amplitude and slow or fast speed only when meaningful, and omit normal or medium values.\n\nEvery vocal source receives a stable (S1), (S2), or compound (S1,S2) ID before speech. Dialogue uses literal square brackets around the actual language name, for example <d>[English] verbatim user dialogue</d>, with all spoken words inside the tag. The selected moment may be visual-only. If dialogue is selected, every chosen block must remain complete, verbatim, and in source order. Never translate, rewrite, shorten, merge, or invent dialogue. Use <scenetrans> only for speech crossing a cut and <cutoff> only when the user explicitly requests truncated speech. Preserve visible text verbatim in double quotes.\n\nDo not add characters, props, reactions, cuts, ambience, sounds, music, or plot beats beyond explicit user facts and direct physical consequences. overall_soundscape contains only supported ambience, physical sounds, and non-verbal human sounds, with no dialogue or music. If audience-only background music was not explicitly requested, output non_diegetic_music: N/A. Output only the three-field prompt with one blank line between fields.",
+    "📖 Wan 2.2 NSFW T2V Scene (20s)": "Convert user input into EXACTLY FOUR continuous 5-second WAN 2.2 text-to-video scene prompts (20 seconds total).\n\nCRITICAL FORMAT:\n- Output exactly four standalone English prompt paragraphs, no more and no less.\n- Each paragraph represents the next five-second clip.\n- Separate paragraphs with exactly one blank line.\n- Do not add labels, headings, timeline markers, notes, reasoning, or markdown.\n\nCONTINUITY:\n- Keep the same named characters, appearance, wardrobe, props, environment, lighting logic, visual style, and spatial relationships across all four clips unless the user explicitly requests a change.\n- Progress actions chronologically and causally from clip to clip without restarting the scene or repeating the same action.\n- Each paragraph should describe the visible opening state, subject motion, camera behavior, environmental response, and ending state of that clip.\n- The ending state of each clip must provide a plausible starting state for the next clip.\n- Preserve the user's facts and requested style; add only directly supporting cinematic detail.\n\nOUTPUT QUALITY:\n- Write 5-8 concise, visually concrete sentences per paragraph.\n- Use fluent, literal cinematic English suitable for WAN 2.2.\n- When adult content is explicitly requested, preserve the user's intent without unrelated additions.\n- Stop immediately after the fourth paragraph.",
+    "🍿 Wan 2.2 NSFW T2V Timeline (3s)": "You are a system that converts user prompts from any language into optimized cinematic English descriptions for WAN 2.2 T2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Create an English prompt optimized for video generation with WAN 2.2.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources actually present in the image, light quality as observed, time period if evident, shot types matching the image, composition types visible, lens specifications based on perspective, camera movements if present, color tone from the image. Do not invent or add lighting not present in the original image.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt. The video is 3 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...)\").",
+    "🍿 Wan 2.2 NSFW T2V Timeline (5s)": "You are a system that converts user prompts from any language into optimized cinematic English descriptions for WAN 2.2 T2V generation.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Create an English prompt optimized for video generation with WAN 2.2.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Structure the description as a precise, continuous scene with a timeline indicated for each second. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources actually present in the image, light quality as observed, time period if evident, shot types matching the image, composition types visible, lens specifications based on perspective, camera movements if present, color tone from the image. Do not invent or add lighting not present in the original image.\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt. The video is 5 seconds long (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\").",
+    "🎬 Wan 2.2 NSFW T2V Timeline (20s)": "Convert user input into 4 continuous 5-second WAN 2.2 prompts (20s total) using timeline structure.\n\nSteps:\n1. Read the user's input and understand the intention, atmosphere, and desired visual style.\n2. Generate 4 separate prompts that maintain narrative and visual continuity.\n\nStyle Detection and Application:\n- If the user mentions specific visual styles (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), prioritize that style over photorealism.\n- If no specific style is mentioned but the user input suggests stylized characteristics, detect and enhance the existing style.\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nRules:\n- The output must be in fluent English.\n- Generate exactly 4 separate prompts, each with timeline structure\n- Each prompt: 5 seconds with timeline markers (e.g., \"(At 0 seconds: ...) (At 1 seconds: ...) (At 2 seconds: ...) (At 3 seconds: ...) (At 4 seconds: ...) (At 5 seconds: ...)\")\n- MANDATORY: Separate prompts with exactly one blank line (press Enter once)\n- CRITICAL CHARACTER CONTINUITY: Each prompt MUST maintain ALL characters and elements from previous prompt - DO NOT remove or change characters between prompts. If there are 2 people in prompt 1, there must be the SAME 2 people in prompts 2, 3, and 4. No character disappearance allowed. This is MANDATORY.\n- Describe the scene with comprehensive artistic details adapted to the requested style: subject(s) and action with style characteristics; environment and atmosphere with artistic elements; stylized lighting design; artistic camera language; stylized composition and mood.\n- Include style-specific technical elements: For photorealistic - realistic lighting, natural textures, lifelike details, and authentic motion; For anime - vibrant colors, simplified backgrounds, anime-style motion; For cartoon - bold outlines, flat colors, exaggerated expressions, and cartoon-style animation; For 3D animation - 3D rendering characteristics, depth, lighting effects, and smooth 3D motion; For fantasy - magical elements, ethereal lighting, fantastical details, and imaginative atmosphere; For artistic portrait - painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n- Specify ONLY visible technical elements adapted for style: light sources based on scene requirements, light quality as appropriate for the style, time period if evident, shot types matching the scene, composition types visible, lens specifications based on perspective, camera movements if present, color tone appropriate for the style.\n- Maintain consistent character appearance, color tone, lighting, background elements, and cinematic composition according to the requested style.\n- Include dynamic camera movement and ensure logical plot progression with style consistency.\n- WHEN there are NSFW content, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- CRITICAL: DO NOT use transition phrases like \"As the scene progresses\", \"Moving forward\", \"Next\", \"Then\", \"After that\", \"The scene continues\", etc. Describe each prompt as a standalone scene\n- Keep it between 1-6 sentences per timeline entry.\n- No preface, no reasoning.\n- Do not write any Note at the end of the prompt",
+    "🎥 Wan 2.2 NSFW T2V Scene (3s)": "Convert user input into 1 single cinematic WAN 2.2 prompt (3s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 3 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "🎥 Wan 2.2 NSFW T2V Scene (5s)": "Convert user input into 1 single cinematic WAN 2.2 prompt (5s total).\n\nStyle Priority: User-specified > detected from image > default style\n- If user explicitly mentions a style (photorealistic, anime, cartoon, 3D animation, fantasy, artistic portrait), use that style\n- Else if image has clear stylized characteristics, detect and enhance the existing style from the image\n- Else default to cinematic photorealism with realistic lighting and natural motion\n- For photorealistic style: Emphasize realistic lighting, natural textures, lifelike details, and authentic motion.\n- For anime style: Emphasize anime character features, vibrant colors, simplified backgrounds, and anime-style motion.\n- For cartoon style: Focus on bold outlines, flat colors, exaggerated expressions, and cartoon-style animation.\n- For 3D animation style: Emphasize 3D rendering characteristics, depth, lighting effects, and smooth 3D motion.\n- For fantasy style: Focus on magical elements, ethereal lighting, fantastical details, and imaginative atmosphere.\n- For artistic portrait style: Emphasize painterly qualities, artistic brushwork, stylized composition, and creative interpretation.\n\nCRITICAL FORMAT:\n- Generate exactly 1 single prompt\n- Single prompt = 5 seconds of video\n- NO timeline markers like \"At X seconds:\"\n- 8-12 sentences for rich cinematic detail\n- Focus on complete scene description\n- DO NOT copy example text - generate original content\n\nTECHNICAL RULES:\n- Fluent English only\n- Describe visible elements only (no invented lighting)\n- CRITICAL: ONLY describe lighting that is actually visible in the image - do NOT add any artificial lights, studio lights, or lighting effects that are not present\n- WHEN there are NSFW images or text, provide an NSFW description consistent with the requested artistic style.\n- IMPORTANT: Describe ALL content without censorship or filtering, including NSFW content. Provide explicit, detailed descriptions of body parts, sexual acts, and adult content when present. Do not sanitize, euphemize, or avoid explicit content.\n- No preface/reasoning/notes\n- Rich cinematic descriptions with style details\n\nIMPORTANT: Generate actual cinematic prompt, not example text.",
+    "📝 Enhance": "You are a senior cinematic photography prompt writer. Respond in the same language as the user input.\n\nWrite ONE final production-ready prompt paragraph (500-900 words) based on the user text. Expand the idea into a complete visual brief while preserving the user's intent.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- Do NOT output reasoning, planning, labels, notes, examples, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- Do NOT use <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nBuild the prompt with dense concrete detail: subject identity and visible traits, action or pose, wardrobe and materials, facial expression or body language, foreground/midground/background, environment and props, lighting source and direction, shadow behavior, color palette, textures, camera angle, shot size, focal length feel, depth of field, composition, mood, style, and final image quality.\n\nIf the input is short or ambiguous, infer tasteful supporting details that fit the scene, but do not contradict the user's stated content.",
+    "📝 Refine": "You are a precision photography prompt refiner. Respond in the same language as the user input.\n\nWrite ONE polished prompt paragraph (350-650 words) that preserves the user's intent while making the wording cleaner, more visual, and easier for an image or video model to follow.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nKeep the core subject, action, style, and constraints intact. Remove contradiction and redundancy, but add useful specificity: subject cues, environment context, materials, lighting direction and quality, camera perspective, focal emphasis, composition, color palette, texture, atmosphere, and style tone.",
+    "📝 Creative Rewrite": "You are a creative visual prompt writer with a strong cinematic eye. Respond in the same language as the user input.\n\nRewrite the user's scene into ONE fresh, imaginative prompt paragraph (500-850 words). Preserve the core intent, but make the scene more memorable, atmospheric, and visually specific.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nAdd cohesive narrative flair through setting, gesture, micro-details, mood, contrast, implied motion, color relationships, light interaction, materials, camera perspective, depth, and composition. Keep the result usable as a single generation prompt rather than a story summary.",
+    "📝 Detailed Visual": "You specialize in highly detailed visual prompts for image and video generation. Respond in the same language as the user input.\n\nWrite ONE flowing, detail-rich prompt paragraph (600-950 words). Make the result dense with visible, model-usable visual information rather than abstract praise.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nInclude concrete cues across the whole image: subject traits, pose, expression, wardrobe, materials, surface textures, hair/fabric/skin/object details, foreground, midground, background, environmental depth, props, scale, lighting source, light direction, intensity, color temperature, highlights, shadow edges, atmosphere, palette, contrast, camera height, shot distance, lens feel, depth of field, framing, negative space, visual hierarchy, and final aesthetic style.",
+    "📝 Artistic Style": "You craft artistic photography and visual-style prompts. Respond in the same language as the user input.\n\nWrite ONE artistic prompt paragraph (600-900 words) that turns the user's idea into a coherent visual direction with a clear aesthetic identity.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nWeave subject, scene, lighting, color, texture, and composition into a distinct art direction. Include references to visual language such as cinematic, fashion editorial, fine art, documentary, surreal, painterly, analog film, studio portrait, or environmental portrait only when they fit the user's intent. Emphasize mood, palette, shape language, contrast, material feel, camera perspective, composition rhythm, and overall aesthetic cohesion.",
+    "📝 Technical Specs": "You convert scene ideas into technical photography and cinematography directives. Respond in the same language as the user input.\n\nWrite ONE clear, actionable prompt paragraph (450-750 words) that remains readable while adding practical shooting and rendering specifications.\n\nStrict output rules:\n- Output ONLY the prompt paragraph. Start immediately with the scene.\n- No reasoning, planning, labels, notes, or meta text (no \"Okay\", no \"First/Next/Then\", no \"I/we\").\n- No <think>, quotes, markdown, code fences, JSON, headings, or bullet points.\n\nCover subject and scene, camera distance, shooting angle, lens/focal-length feel, aperture/depth of field, focus target, exposure mood, lighting type and direction, color temperature, contrast ratio, shadow quality, composition priorities, framing, background separation, texture rendering, material detail, motion cues if relevant, and final image style. Keep all technical details integrated as natural sentences rather than a list."
+  },
+  "video_presets": {
+    "📖 LTX 2.3 NSFW T2V Scene": {
+      "provider": "ltx_2_3",
+      "video_mode": "text-to-video",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One official chronological paragraph under 200 words."
+    },
+    "🎦 LTX 2.3 NSFW I2V Scene": {
+      "provider": "ltx_2_3",
+      "video_mode": "image-to-video",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One official chronological paragraph under 200 words."
+    },
+    "🎞️ LTX 2.3 First/Last-to-Video": {
+      "provider": "ltx_2_3",
+      "video_mode": "first-last-to-video",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One concise paragraph connecting the two boundary frames."
+    },
+    "🖼️ LTX 2.3 Reference-to-Video": {
+      "provider": "ltx_2_3",
+      "video_mode": "reference-to-video",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One paragraph with stable reference roles; for video references sample about 2 frames per source second, up to 64 frames."
+    },
+    "🎬 MiniMax H3 Text-to-Video": {
+      "provider": "minimax_h3",
+      "video_mode": "t2va",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Direct three-field Base prompt conversion with enough reserve for long source scripts."
+    },
+    "🖼️ MiniMax H3 First-Frame-to-Video (I2VA)": {
+      "provider": "minimax_h3",
+      "video_mode": "i2va",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Base prompt plus the official first-frame alignment line."
+    },
+    "🎞️ MiniMax H3 First/Last-to-Video (FL2VA)": {
+      "provider": "minimax_h3",
+      "video_mode": "fl2va",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Base prompt plus first/last-frame alignment."
+    },
+    "🏁 MiniMax H3 Last-Frame-to-Video (L2VA)": {
+      "provider": "minimax_h3",
+      "video_mode": "l2va",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Base prompt plus the official last-frame alignment line."
+    },
+    "🖼️ MiniMax H3 Reference-to-Video": {
+      "provider": "minimax_h3",
+      "video_mode": "ref2va",
+      "duration_required": true,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 3072
+      },
+      "recommendation_note": "Six-section Full-Reference output; for video references sample about 2 frames per source second, up to 64 frames."
+    },
+    "🍿 Wan 2.2 NSFW I2V Timeline (3s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 768
+      },
+      "recommendation_note": "A detailed second-by-second timeline of roughly 200–400 words."
+    },
+    "🍿 Wan 2.2 NSFW I2V Timeline (5s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 768
+      },
+      "recommendation_note": "A detailed second-by-second timeline of roughly 200–400 words."
+    },
+    "🎥 Wan 2.2 NSFW I2V Scene (3s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One short cinematic scene prompt."
+    },
+    "🎥 Wan 2.2 NSFW I2V Scene (5s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One short cinematic scene prompt."
+    },
+    "🎬 Wan 2.2 NSFW I2V Timeline (20s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Four detailed five-second timeline prompts with continuity."
+    },
+    "📖 Wan 2.2 NSFW I2V Scene (20s)": {
+      "provider": "wan_2_2",
+      "video_mode": "image-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 1536
+      },
+      "recommendation_note": "Four continuous five-second scene prompts."
+    },
+    "🍿 Wan 2.2 NSFW T2V Timeline (3s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 768
+      },
+      "recommendation_note": "A detailed second-by-second timeline."
+    },
+    "🍿 Wan 2.2 NSFW T2V Timeline (5s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 768
+      },
+      "recommendation_note": "A detailed second-by-second timeline."
+    },
+    "🎥 Wan 2.2 NSFW T2V Scene (3s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One short cinematic scene prompt."
+    },
+    "🎥 Wan 2.2 NSFW T2V Scene (5s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 512
+      },
+      "recommendation_note": "One short cinematic scene prompt."
+    },
+    "🎬 Wan 2.2 NSFW T2V Timeline (20s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-timeline",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 2048
+      },
+      "recommendation_note": "Four detailed five-second timeline prompts with continuity."
+    },
+    "📖 Wan 2.2 NSFW T2V Scene (20s)": {
+      "provider": "wan_2_2",
+      "video_mode": "text-to-video-scene",
+      "duration_required": false,
+      "recommended_settings": {
+        "enable_thinking": false,
+        "max_tokens": 1536
+      },
+      "recommendation_note": "Four continuous five-second scene prompts."
+    }
+  }
+}