Upload 6 files

__init__.py

@@ -0,0 +1,53 @@
+import traceback
+
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+
+def register_node(class_name, node_class, display_name):
+    NODE_CLASS_MAPPINGS[class_name] = node_class
+    NODE_DISPLAY_NAME_MAPPINGS[class_name] = display_name
+
+
+# 1. Wan Native Resize (이미지 -> WAN 해상도 리사이즈, 비율 유지 + 정렬)
+try:
+    from .wan_resizer import WanNativeResize_Dolphin
+    register_node("WanNativeResize_Dolphin", WanNativeResize_Dolphin,
+                  "🐬 Wan Native Resize (Dolphin)")
+except Exception:
+    print(f"\n❌ [Dolphin] Wan Resize 로드 실패:\n{traceback.format_exc()}")
+
+# 2. Story Splitter V32 (텍스트 서사 -> 4샷 프롬프트 분배)
+try:
+    from .promp_logic_v32_story import DolphinMultiActionPromptNode_V32
+    register_node("DolphinMultiActionPromptNode_V32", DolphinMultiActionPromptNode_V32,
+                  "🐬 Dolphin Story Splitter V32")
+except Exception:
+    print(f"\n❌ [Dolphin] V32 Story Splitter 로드 실패:\n{traceback.format_exc()}")
+
+# 3. Architect V16 (클립별 LoRA -> TripleKSampler, model-only)
+try:
+    from .arch_logic_v16 import DolphinTripleLoraMatrix as DolphinArchitectV16
+    register_node("DolphinArchitectV16", DolphinArchitectV16,
+                  "🐬 Dolphin Architect V16")
+except Exception:
+    print(f"\n❌ [Dolphin] Architect V16 로드 실패:\n{traceback.format_exc()}")
+
+# 4. Cinematic Director (올인원: 스토리 분배 + 클립별 로라 + 트리거 주입)
+try:
+    from .dolphin_director import DolphinCinematicDirector
+    register_node("DolphinCinematicDirector", DolphinCinematicDirector,
+                  "🎬 Dolphin Cinematic Director (All-in-One)")
+except Exception:
+    print(f"\n❌ [Dolphin] Cinematic Director 로드 실패:\n{traceback.format_exc()}")
+
+# 5. Vision Director (이미지 인식 + 필수동작 + 클립당 로라 4개)
+try:
+    from .dolphin_vision_director import DolphinVisionDirector
+    register_node("DolphinVisionDirector", DolphinVisionDirector,
+                  "🎬👁 Dolphin Vision Director (Image→4Clips)")
+except Exception:
+    print(f"\n❌ [Dolphin] Vision Director 로드 실패:\n{traceback.format_exc()}")
+
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

arch_logic_v16.py

@@ -0,0 +1,87 @@
+import os
+import comfy.sd
+import comfy.utils
+import folder_paths
+import json
+import urllib.request
+import urllib.parse
+
+_TRIPLE_LORA_CACHE = {}
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_lora_trigger_cache.json")
+
+def get_trigger_words(lora_name):
+    if lora_name == "None": return []
+    cache = {}
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r") as f: cache = json.load(f)
+        except: pass
+    if lora_name in cache: return cache[lora_name]
+
+    try:
+        # 💡 요청하신 civitaired.com 도메인 API로 변경
+        # API 구조가 civitai.com과 동일하다는 가정하에 쿼리 매개변수 적용
+        query = urllib.parse.quote(lora_name.replace(".safetensors", ""))
+        url = f"https://civitaired.com/api/v1/model-versions/by-file?query={query}"
+        
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=5) as res:
+            data = json.load(res)
+            # trainedWords 키는 동일하게 유지
+            triggers = data.get("trainedWords", [])
+            cache[lora_name] = triggers
+            with open(CACHE_FILE, "w") as f: json.dump(cache, f)
+            return triggers
+    except Exception as e:
+        print(f"⚠️ [Dolphin] civitaired.com 트리거 워드 조회 실패: {e}")
+        return []
+
+class DolphinTripleLoraMatrix:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        inputs = {
+            "model_base": ("MODEL",), "clip_base": ("CLIP",),
+            "model_high": ("MODEL",), "clip_high": ("CLIP",),
+            "model_low": ("MODEL",),  "clip_low": ("CLIP",),
+        }
+        for i in range(1, 7):
+            inputs[f"lora_{i}"] = (loras, {"default": "None"})
+            inputs[f"weights_{i}"] = ("STRING", {"default": "0.0, 0.0, 0.0"})
+        return {"required": inputs}
+
+    RETURN_TYPES = ("MODEL", "CLIP", "MODEL", "CLIP", "MODEL", "CLIP", "STRING")
+    RETURN_NAMES = ("M_BASE", "C_BASE", "M_HIGH", "C_HIGH", "M_LOW", "C_LOW", "trigger_words")
+    FUNCTION = "apply_matrix"
+    CATEGORY = "Dolphin"
+
+    def apply_matrix(self, model_base, clip_base, model_high, clip_high, model_low, clip_low, **kwargs):
+        m_b, c_b = model_base, clip_base
+        m_h, c_h = model_high, clip_high
+        m_l, c_l = model_low, clip_low
+        all_triggers = []
+
+        for i in range(1, 7):
+            lora_name = kwargs.get(f"lora_{i}")
+            w_str = kwargs.get(f"weights_{i}")
+            
+            if lora_name == "None": continue
+            
+            # 트리거 워드 수집 (civitaired.com 연동)
+            all_triggers.extend(get_trigger_words(lora_name))
+            
+            try:
+                parts = [float(x.strip()) for x in w_str.split(',')]
+                wb, wh, wl = parts[0], parts[1], parts[2]
+            except: continue
+
+            if lora_name not in _TRIPLE_LORA_CACHE:
+                path = folder_paths.get_full_path("loras", lora_name)
+                _TRIPLE_LORA_CACHE[lora_name] = comfy.utils.load_torch_file(path)
+            data = _TRIPLE_LORA_CACHE[lora_name]
+
+            if wb != 0: m_b, c_b = comfy.sd.load_lora_for_models(m_b, c_b, data, wb, wb)
+            if wh != 0: m_h, c_h = comfy.sd.load_lora_for_models(m_h, c_h, data, wh, wh)
+            if wl != 0: m_l, c_l = comfy.sd.load_lora_for_models(m_l, c_l, data, wl, wl)
+        
+        return (m_b, c_b, m_h, c_h, m_l, c_l, ", ".join(list(set(all_triggers))))

dolphin_director.py

@@ -0,0 +1,93 @@
+import os
+import re
+import json
+import hashlib
+import urllib.request
+import urllib.error
+
+import folder_paths
+import comfy.sd
+import comfy.lora
+import comfy.utils
+from safetensors import safe_open
+
+try:
+    from .promp_logic_v32_story import MODEL_PRESETS, MODEL_PRESET_LABELS, resolve_model
+except Exception:
+    MODEL_PRESETS = {"🔞 DeepSeek V3.2": "deepseek/deepseek-v3.2"}
+    MODEL_PRESET_LABELS = list(MODEL_PRESETS.keys())
+    def resolve_model(p, c): return c if p == "custom" else "deepseek/deepseek-v3.2"
+
+class DolphinCinematicDirector:
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + folder_paths.get_filename_list("loras")
+        return {
+            "required": {
+                "model_base": ("MODEL",), "model_high": ("MODEL",), "model_low": ("MODEL",),
+                "mode": (["🤖 Auto LLM (Story Splitter)", "✍️ Manual"], {"default": "🤖 Auto LLM (Story Splitter)"}),
+                "master_story": ("STRING", {"multiline": True}),
+                "tagger_context": ("STRING", {"multiline": True}),
+                "openrouter_api_key": ("STRING", {"default": ""}),
+            },
+            "optional": {
+                "external_triggers": ("STRING", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "MODEL", "MODEL", "STRING") * 4 + ("STRING",)
+    RETURN_NAMES = tuple([f"c{i}_{n}" for i in range(1, 5) for n in ["base", "high", "low", "prompt"]] + ["debug_info"])
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def _build_final(self, action, tags, master_scene, name, trigger_str):
+        # 1. 트리거 워드(trigger_str)와 캐릭터 이름(name)만 상단에 배치
+        header = []
+        if name: header.append(name)
+        if trigger_str: header.append(trigger_str)
+        
+        # 2. 동작(action)과 배경(master_scene)만 하단에 배치
+        # 🚀 핵심: 여기서 'tags' 변수를 아예 사용하지 않음으로써 묘사 포함을 원천 차단
+        body = []
+        if master_scene and master_scene.strip():
+            body.append(master_scene.strip())
+        if action and action.strip():
+            body.append(action.strip())
+        
+        # 결과값 결합
+        header_str = ", ".join(header)
+        body_str = " ".join(body)
+        
+        if header_str and body_str:
+            return f"{header_str}\n{body_str}"
+        return header_str or body_str
+
+    def _llm_split(self, story, name, tags, key, model):
+        # 🚀 수정: LLM에게는 묘사를 보내되, 출력 JSON에서는 동작만 뽑도록 강제
+       sys_p = (
+    "You are an action-only generator. "
+    "DO NOT output any visual descriptions, clothing, lighting, or setting details. "
+    "Your output must ONLY be the physical movement of the character. "
+    "If you include any adjective-heavy descriptions, you will be penalized. "
+    "Strictly output only the kinetic action in the JSON fields."
+)
+
+    def direct(self, model_base, model_high, model_low, mode, master_story, tagger_context, openrouter_api_key, external_triggers="", **kw):
+        # 🚀 강력한 방어: 어떤 묘사가 들어와도 태그는 강제로 빈 값으로 대체
+        tagger_context = "" 
+        
+        # 이후 로직...
+        # 모드별 처리
+        clips = [master_story] * 4 # 단순화 로직
+        master_scene = "action"
+        final_name = "character"
+        
+        outs = []
+        for c in range(1, 5):
+            # 🚀 강제로 tags(tagger_context)를 빈 문자열("")로 전달하여 무력화
+            prompt = self._build_final(clips[c-1], "", master_scene, final_name, external_triggers)
+            outs.extend([model_base, model_high, model_low, prompt])
+
+        return tuple(outs) + ("Success",)
+
+NODE_CLASS_MAPPINGS = {"DolphinCinematicDirector": DolphinCinematicDirector}

dolphin_vision_director.py

@@ -0,0 +1,788 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import io
+import json
+import base64
+import hashlib
+import sqlite3
+import urllib.request
+import urllib.error
+
+import numpy as np
+import folder_paths
+import comfy.sd
+import comfy.lora
+import comfy.utils
+from safetensors import safe_open
+from comfy_execution.graph_utils import ExecutionBlocker
+
+try:
+    from PIL import Image
+    _HAS_PIL = True
+except Exception:
+    _HAS_PIL = False
+
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "dolphin_tags_cache.json")
+
+
+# ======================================================================
+#  모델 프리셋 (텍스트 LLM = 4샷 분배 / 비전 VLM = 이미지 인식)
+# ======================================================================
+LLM_PRESETS = {
+    "🔞 DeepSeek V3.2 (무삭제·JSON안정·추천)": "deepseek/deepseek-v3.2",
+    "🔞 Magnum v4 72B (표현 자연스러움)": "anthracite-org/magnum-v4-72b",
+    "🔞 Cydonia 24B v4.1 (경량·빠름)": "thedrummer/cydonia-24b-v4.1",
+    "🔞 Dolphin Mistral Venice (무료)": "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
+    "⚙️ custom (아래 텍스트 사용)": "__custom__",
+}
+LLM_PRESET_LABELS = list(LLM_PRESETS.keys())
+
+# 비전 모델: 특수 상황 이해 + 다국어. Qwen2.5-VL 계열이 포즈/맥락 파악에 강함.
+VLM_PRESETS = {
+    "👁 Qwen2.5-VL 72B (특수상황·추천)": "qwen/qwen2.5-vl-72b-instruct",
+    "👁 Qwen2.5-VL 32B (균형)": "qwen/qwen2.5-vl-32b-instruct",
+    "👁 Qwen2.5-VL 32B (무료)": "qwen/qwen2.5-vl-32b-instruct:free",
+    "👁 Mistral Small 3.1 24B (Pixtral)": "mistralai/mistral-small-3.1-24b-instruct",
+    "👁 Gemma 3 27B (경량)": "google/gemma-3-27b-it",
+    "⚙️ custom (아래 텍스트 사용)": "__custom__",
+}
+VLM_PRESET_LABELS = list(VLM_PRESETS.keys())
+
+
+def resolve_slug(table, label, custom_text, default):
+    slug = table.get(label, "__custom__")
+    if slug == "__custom__":
+        return custom_text.strip() or default
+    return slug
+
+
+def resolve_api_key(widget_value):
+    """위젯에 키가 있으면 그대로 사용. 비어있으면 OPENROUTER_API_KEY 환경변수로 폴백.
+    -> 워크플로우 JSON(공유/백업 시 유출 위험)에 실키를 박아둘 필요가 없어짐."""
+    key = (widget_value or "").strip()
+    if key:
+        return key
+    return os.environ.get("OPENROUTER_API_KEY", "").strip()
+
+
+# ======================================================================
+#  캐시 & 트리거 (검증된 로직 재사용)
+# ======================================================================
+def _load_cache():
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save_cache(cache):
+    try:
+        with open(CACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(cache, f, indent=4, ensure_ascii=False)
+    except OSError:
+        pass
+
+
+def _file_sig(path):
+    st = os.stat(path)
+    return f"{os.path.basename(path)}::{st.st_size}::{int(st.st_mtime)}"
+
+
+def _sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(4096 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+# CivitAI 및 미러(civitaired) 해시 조회 엔드포인트. 앞에서부터 순서대로 시도.
+TRIGGER_HASH_APIS = [
+    "https://civitai.com/api/v1/model-versions/by-hash/{h}",
+    "https://civitaired.com/api/v1/model-versions/by-hash/{h}",
+]
+
+# LoRA Manager(comfyui-lora-manager)가 스캔 시 만들어두는 로컬 SQLite 캐시.
+# sha256으로 trained_words를 즉시 조회 가능 -> 네트워크 호출 없이 트리거워드 확보.
+LORA_MANAGER_DB = os.path.join(
+    os.environ.get("LOCALAPPDATA", ""), "ComfyUI-LoRA-Manager", "cache", "model", "comfyui.sqlite")
+
+
+def _query_lora_manager_db(digest):
+    """LoRA Manager SQLite 캐시에서 sha256으로 trained_words 조회. 실패/미발견 시 None."""
+    if not digest or not os.path.exists(LORA_MANAGER_DB):
+        return None
+    try:
+        uri = f"file:{LORA_MANAGER_DB}?mode=ro"
+        con = sqlite3.connect(uri, uri=True, timeout=3)
+        try:
+            cur = con.cursor()
+            cur.execute(
+                "SELECT trained_words FROM models WHERE model_type='lora' AND sha256=? LIMIT 1",
+                (digest,))
+            row = cur.fetchone()
+        finally:
+            con.close()
+        if not row or not row[0]:
+            return None
+        tw = json.loads(row[0])
+        return tw if isinstance(tw, list) else None
+    except (sqlite3.Error, OSError, ValueError, json.JSONDecodeError) as e:
+        print(f"⚠️ [Director] LoRA Manager DB 조회 실패: {type(e).__name__}: {e}")
+        return None
+
+
+def _query_trigger_api(url):
+    """단일 해시 조회 엔드포인트에서 trainedWords 리스트를 반환. 실패 시 ([], 사유)."""
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=8) as r:
+            data = json.loads(r.read().decode('utf-8'))
+            return (data.get("trainedWords", []) or []), None
+    except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError,
+            OSError, ValueError, json.JSONDecodeError) as e:
+        return [], f"{type(e).__name__}: {e}"
+
+
+def get_triggers(lora_name, cache):
+    if lora_name == "None":
+        return []
+    path = folder_paths.get_full_path("loras", lora_name)
+    if not path or not os.path.exists(path):
+        return []
+    try:
+        with safe_open(path, framework="pt", device="cpu") as f:
+            m = f.metadata()
+            if m and "modelspec.trigger_words" in m:
+                tw = json.loads(m["modelspec.trigger_words"])
+                if isinstance(tw, list):
+                    return tw
+                if isinstance(tw, str):
+                    return [tw]
+    except (OSError, ValueError, json.JSONDecodeError):
+        pass
+    try:
+        sig = _file_sig(path)
+    except OSError:
+        sig = lora_name
+    # 캐시에 '비어있지 않은' 결과가 있을 때만 신뢰. 과거에 실패로 저장된 빈 값은
+    # 무시하고 재조회한다 (빈 값 영구화 회귀 방지).
+    cached = cache.get(sig)
+    if cached:
+        return cached
+
+    # 해시는 1회만 계산해서 LoRA Manager DB -> CivitAI -> civitaired 순으로 조회.
+    result, base = [], os.path.basename(path)
+    try:
+        digest = _sha256(path)
+    except OSError as e:
+        print(f"⚠️ [Director] 해시 계산 실패({base}): {e}")
+        digest = None
+    if digest:
+        found = _query_lora_manager_db(digest)
+        if found:
+            print(f"✅ [Director] 트리거 조회 성공({base}) @ LoRA Manager DB: {found}")
+            result = found
+    if digest and not result:
+        for tmpl in TRIGGER_HASH_APIS:
+            host = tmpl.split('/')[2]
+            found, err = _query_trigger_api(tmpl.format(h=digest))
+            if found:
+                print(f"✅ [Director] 트리거 조회 성공({base}) @ {host}: {found}")
+                result = found
+                break
+            print(f"⚠️ [Director] 트리거 조회 실패({base}) @ {host}: {err or 'no trainedWords'}")
+
+    # 성공(비어있지 않음)일 때만 캐싱. 빈 결과는 저장하지 않아 다음 실행에서 재시도됨.
+    if result:
+        cache[sig] = result
+        _save_cache(cache)
+    return result
+
+
+def apply_model_lora(model, lora_data, weight):
+    try:
+        return comfy.sd.load_lora_for_models(model, None, lora_data, weight, 0)[0]
+    except (AttributeError, TypeError):
+        new_model = model.clone()
+        key_map = comfy.lora.model_lora_keys_unet(new_model.model)
+        loaded = comfy.lora.load_lora(lora_data, key_map)
+        new_model.add_patches(loaded, weight)
+        return new_model
+
+
+def tensor_to_base64(image_tensor, max_side=1024):
+    """ComfyUI IMAGE 텐서(B,H,W,C, 0~1 float) 첫 프레임을 JPEG base64 data URI로."""
+    if not _HAS_PIL:
+        print("❌ [Director] PIL(Pillow) 없음 - 비전 불가. `pip install Pillow` 필요.")
+        return None
+    if image_tensor is None:
+        print("❌ [Director] image 입력이 None - IMAGE 연결 확인.")
+        return None
+    try:
+        img = image_tensor
+        if hasattr(img, "cpu"):
+            img = img.cpu().numpy()
+        img = np.asarray(img)
+        if img.ndim == 4:
+            img = img[0]
+        arr = np.clip(img * 255.0, 0, 255).astype(np.uint8)
+        pil = Image.fromarray(arr)
+        w, h = pil.size
+        if max(w, h) > max_side:
+            scale = max_side / float(max(w, h))
+            pil = pil.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+        buf = io.BytesIO()
+        pil.convert("RGB").save(buf, format="JPEG", quality=90)
+        b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+        print(f"🖼 [Director] image encoded ok: {w}x{h} -> {pil.size}, {len(b64)//1024}KB base64")
+        return f"data:image/jpeg;base64,{b64}"
+    except Exception as e:
+        print(f"❌ [Director] image encode failed: {type(e).__name__}: {e}")
+        return None
+
+
+# ======================================================================
+#  Vision Director: 이미지 인식 + 필수동작 실행 + 클립당 4로라
+# ======================================================================
+class DolphinVisionDirector:
+    """
+    이미지 하나와 '필수 동작'과 로라만 넣으면 4개 연속 클립이 완성되는 올인원 노드.
+
+      1) IMAGE -> 비전 VLM 이 상황(캐릭터 상태/자세/환경)만 앵커로 파악
+      2) 그 맥락 위에서 '내가 준 필수 동작(essential_actions)'만 4샷으로 분배
+      3) 클립마다 로라 4개씩 개별 적용(웨이트도 개별) + 트리거 자동 주입
+    """
+
+    @classmethod
+    def INPUT_TYPES(s):
+        loras = ["None"] + (folder_paths.get_filename_list("loras") or [])
+        req = {
+            "image": ("IMAGE",),
+            "model_base": ("MODEL",),
+            "model_high": ("MODEL",),
+            "model_low": ("MODEL",),
+            "essential_actions": ("STRING", {"multiline": True,
+                "default": ("돌진한다, 검을 휘둘러 적을 쓰러뜨린다, 총알을 튕겨낸다, 숨통을 끊는다")}),
+            "num_clips": (["4 (20s)", "3 (15s)", "2 (10s)"], {"default": "4 (20s)",
+                "tooltip": "실제로 렌더링할 클립 수. Extend range(Fast Groups Bypasser) 토글과 맞춰서 "
+                           "설정해야 스토리가 그 길이에 맞게 배분됨. 나머지 클립 슬롯은 마지막 클립 내용을 반복."}),
+            "character_name": ("STRING", {"default": "AUTO"}),
+            "artistic_vibe": ("STRING", {"multiline": True,
+                                         "default": "cinematic lighting, dynamic motion"}),
+            "pacing": (["auto", "slow-burn (1 beat)", "balanced (multi beat)", "rapid (4 distinct)"],
+                       {"default": "auto"}),
+            "detail_level": (["짧게(간결)", "필수+앵커만", "상세"], {"default": "필수+앵커만"}),
+            "inject_triggers": ("BOOLEAN", {"default": True,
+                                            "label_on": "TRIGGERS ON", "label_off": "TRIGGERS OFF"}),
+            "use_vision": ("BOOLEAN", {"default": True,
+                                       "label_on": "VISION ON", "label_off": "VISION OFF (text only)"}),
+            "openrouter_api_key": ("STRING", {"default": ""}),
+            "vlm_preset": (VLM_PRESET_LABELS, {"default": "👁 Qwen2.5-VL 72B (특수상황·추천)"}),
+            "vlm_model": ("STRING", {"default": "qwen/qwen2.5-vl-72b-instruct"}),
+            "llm_preset": (LLM_PRESET_LABELS, {"default": "🔞 DeepSeek V3.2 (무삭제·JSON안정·추천)"}),
+            "llm_model": ("STRING", {"default": "deepseek/deepseek-v3.2"}),
+            "creativity": ("FLOAT", {"default": 0.7, "min": 0.1, "max": 1.5, "step": 0.05}),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+        }
+        opt = {}
+        for c in range(1, 5):
+            for n in range(1, 5):
+                opt[f"c{c}_lora_{n}"] = (loras, {"default": "None"})
+                opt[f"c{c}_w_{n}"] = ("STRING", {"default": "1.0, 1.0, 1.0", "multiline": False})
+        opt["manual_triggers"] = ("STRING", {"default": "", "multiline": True})
+        opt["vision_caption"] = ("STRING", {"multiline": True, "default": "",
+                                            "forceInput": True})
+        return {"required": req, "optional": opt}
+
+    RETURN_TYPES = (
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "MODEL", "MODEL", "MODEL", "STRING",
+        "STRING", "STRING", "STRING",
+        "BOOLEAN", "BOOLEAN", "BOOLEAN", "BOOLEAN",
+    )
+    RETURN_NAMES = (
+        "c1_base", "c1_high", "c1_low", "c1_prompt",
+        "c2_base", "c2_high", "c2_low", "c2_prompt",
+        "c3_base", "c3_high", "c3_low", "c3_prompt",
+        "c4_base", "c4_high", "c4_low", "c4_prompt",
+        "triggers", "scene_analysis", "debug_info",
+        "c1_is_final", "c2_is_final", "c3_is_final", "c4_is_final",
+    )
+    FUNCTION = "direct"
+    CATEGORY = "Dolphin"
+
+    def _build_final(self, action, master_scene, name, trigger_str):
+        head = ", ".join([p for p in [name, trigger_str] if p])
+        body = " ".join([p for p in [master_scene.strip().strip(",. "), action.strip()] if p])
+        if head and body:
+            return f"{head}\n{body}"
+        return head or body
+
+    def _pacing_hint(self, p):
+        return {
+            "auto": "Decide pacing yourself based on how many distinct beats the actions contain.",
+            "slow-burn (1 beat)": "One climactic beat: clips 1-3 build tension, clip 4 detonates.",
+            "balanced (multi beat)": "Early clips build, later clips deliver; keep motion continuous.",
+            "rapid (4 distinct)": "Four distinct consecutive actions, one per clip, each kinetic.",
+        }.get(p, "Decide pacing yourself.")
+
+    def _detail_hint(self, d):
+        return {
+            "짧게(간결)": "Keep each clip to a short punchy motion phrase. Pure movement verbs only.",
+            "필수+앵커만": "Each clip is one concise continuous motion. No description, only movement.",
+            "상세": "Motion may be described in more detail, but ONLY body movement — no scenery.",
+        }.get(d, "Motion only, no description.")
+
+    def _extract_json(self, text):
+        if not text:
+            return None
+        text = re.sub(r'```(?:json)?', '', text).strip()
+        a, b = text.find('{'), text.rfind('}')
+        if a == -1 or b <= a:
+            return None
+        blob = text[a:b + 1]
+        try:
+            return json.loads(blob)
+        except json.JSONDecodeError:
+            try:
+                return json.loads(re.sub(r',\s*([}\]])', r'\1', blob))
+            except json.JSONDecodeError:
+                return None
+
+    def _call_or(self, messages, model, key, temp, timeout=120, force_json=False):
+        payload = {"model": model.strip(), "messages": messages, "temperature": temp}
+        if force_json:
+            payload["response_format"] = {"type": "json_object"}
+        req = urllib.request.Request(
+            "https://openrouter.ai/api/v1/chat/completions",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={'Authorization': f'Bearer {key}', 'Content-Type': 'application/json'})
+        raw = json.loads(urllib.request.urlopen(req, timeout=timeout).read().decode('utf-8'))
+        if "choices" not in raw:
+            err = raw.get("error") or raw
+            msg = err.get("message") if isinstance(err, dict) else str(err)
+            code = err.get("code") if isinstance(err, dict) else "?"
+            raise ValueError(f"API error (code={code}): {msg}")
+        return raw['choices'][0]['message']['content'].strip()
+
+    def _vision_analyze(self, data_uri, vlm_model, key, temp):
+        sys = ("You are a visual scene analyst for a video pipeline. "
+               "Look at the image and extract ONLY concrete anchors, no storytelling. "
+               "Report exactly these lines:\n"
+               "(1) character appearance & clothing.\n"
+               "(2) current pose/posture (sitting, crouched, standing, balance, limb positions).\n"
+               "(3) SUPPORT & CONTACT: what the character is on top of, sitting on, holding, "
+               "leaning against, or touching (e.g. 'seated balanced on a yoga ball', "
+               "'gripping a sword', 'kneeling on the floor'). This is critical for physics — "
+               "state it explicitly even if obvious.\n"
+               "(4) environment & lighting (brief).\n"
+               "Be terse, one short line each. English only. "
+               "Do not invent actions or narrative. If content is mature, describe it plainly and factually.")
+        messages = [
+            {"role": "system", "content": sys},
+            {"role": "user", "content": [
+                {"type": "text", "text": "Extract the anchors from this image."},
+                {"type": "image_url", "image_url": {"url": data_uri}},
+            ]},
+        ]
+        import time
+        last_err = "vision error"
+        for attempt in range(1, 4):
+            try:
+                resp = self._call_or(messages, vlm_model, key, temp, timeout=90).strip()
+                if not resp:
+                    print(f"⚠️ [Director] VLM({vlm_model}) 응답이 비었음 (거부 or 빈 반환)")
+                    return "", "vision empty response"
+                print(f"👁 [Director] VLM({vlm_model}) anchors (attempt {attempt}):\n{resp[:300]}")
+                return resp, None
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                print(f"❌ [Director] VLM HTTP {e.code} (attempt {attempt}): {body}")
+                last_err = f"vision HTTP {e.code}"
+                if e.code in (429, 503) and attempt < 3:
+                    wait = 2 ** attempt
+                    print(f"⏳ [Director] rate limited, {wait}s 후 재시도...")
+                    time.sleep(wait)
+                    continue
+                return "", last_err
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                print(f"❌ [Director] VLM error (attempt {attempt}): {type(e).__name__}: {e}")
+                last_err = f"vision error: {e}"
+                if attempt < 3:
+                    time.sleep(2 ** attempt)
+                    continue
+                return "", last_err
+        return "", last_err
+
+    def _fallback_name(self, anchors):
+        import random
+        a = (anchors or "").lower()
+        east = ["asian", "east asian", "japanese", "korean", "chinese", "anime",
+                "kimono", "hanbok", "qipao", "oriental"]
+        western = ["western", "european", "caucasian", "american", "blonde", "redhead"]
+        east_names = ["Yuna", "Kaede", "Jin", "Mei", "Haruka", "Rin", "Sora", "Aoi"]
+        west_names = ["Elena", "Ryan", "Ava", "Lucas", "Mila", "Ethan", "Nora", "Leo"]
+        if any(k in a for k in east):
+            pool = east_names
+        elif any(k in a for k in western):
+            pool = west_names
+        else:
+            pool = east_names + west_names
+        return random.choice(pool)
+
+    def _split_actions_to_clips(self, actions, num_clips=4):
+        parts = re.split(r'(?<=[.!?。])\s+|[,、]|\n+', actions)
+        parts = [p.strip() for p in parts if len(p.strip()) > 1]
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+        last = num_clips
+        assign = {c: [] for c in range(1, num_clips + 1)}
+        if num_clips == 1:
+            assign[1] = parts
+            return assign
+        build_labels = ["(build-up toward)", "(begin)", "(escalate)", "(continue escalating)"]
+        if n == 1:
+            for c in range(1, last):
+                label = build_labels[min(c - 1, len(build_labels) - 1)]
+                assign[c] = [f"{label} {parts[0]}"]
+            assign[last] = [parts[0]]
+        elif n <= num_clips:
+            assign[last] = [parts[-1]]
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                assign[min(i + 1, last - 1)].append(ph)
+            for c in range(1, last):
+                if not assign[c]:
+                    nxt = parts[min(c, n - 1)]
+                    assign[c] = [f"(move toward) {nxt}"]
+        else:
+            assign[last] = [parts[-1]]
+            rest = parts[:-1]
+            k, m = divmod(len(rest), last - 1)
+            idx = 0
+            for c in range(1, last):
+                end = idx + k + (1 if (c - 1) < m else 0)
+                assign[c] = rest[idx:end]
+                idx = end
+        return assign
+
+    def _plan_shots(self, anchors, actions, name, vibe, pacing, detail, llm_model, key, temp, seed, num_clips=4):
+        assign = self._split_actions_to_clips(actions, num_clips)
+        assign_block = "\n".join(
+            f"  clip_{c}: {', '.join(assign[c]) if assign[c] else '(continue previous motion)'}"
+            for c in range(1, num_clips + 1))
+
+        last_clip = num_clips
+        total_seconds = num_clips * 5
+        if num_clips >= 3:
+            chain = " and ".join(f"clip_{c}<-clip_{c-1}" for c in range(3, num_clips + 1))
+            continuity_middle = (f". The same applies {chain}: each clip picks up exactly where the "
+                                  f"previous clip's body position left off")
+        else:
+            continuity_middle = ""
+            
+        continuity_rule = ""
+        if num_clips >= 2:
+            continuity_rule = (
+                "3) INTER-CLIP CONTINUITY. clip_2 MUST begin from the exact physical end-state of "
+                "clip_1's action (same position, body orientation, and momentum) — it continues the "
+                "motion, it does not restart from a neutral stance" + continuity_middle +
+                f", as one unbroken {total_seconds}-second performance rather than {num_clips} separate poses. Do "
+                "NOT explicitly narrate the hand-off (no phrases like 'continuing from', 'still', 'as "
+                "before', 'picking up where') — simply choreograph the new action so it is kinematically "
+                "consistent with how the previous action would have left the body positioned. This is a "
+                "physical-continuity constraint, not a scripted transition line.\n"
+            )
+
+        json_clip_fields = ",".join(
+            f'"clip_{i}":"<only clip_{i} action{", the finisher" if i == last_clip else ""}, '
+            f'continuous & fast>"' for i in range(1, num_clips + 1))
+
+        sys = (
+            f"You are an elite fight/action choreographer for a {total_seconds}-second video made of "
+            f"{num_clips} consecutive 5-second clip{'s' if num_clips != 1 else ''}. You are given SCENE ANCHORS "
+            "(the character's starting look/pose/place from an image) and a STRICT per-clip action "
+            "assignment.\n"
+            "\n"
+            "ABSOLUTE RULES:\n"
+            "1) FOLLOW THE ASSIGNMENT EXACTLY. Each clip animates ONLY the action(s) assigned "
+            "to it below. You MUST NOT move a later clip's action into an earlier clip. "
+            f"clip_1 must NOT contain clip_{last_clip}'s action. The final action happens ONLY in "
+            f"clip_{last_clip}. "
+            "This is the most important rule - violating the order is a failure. "
+            "(ONE exception: clip_1 may prepend a brief transition OUT of the starting physics from "
+            "rule 2 — e.g. leaving the yoga ball — before its assigned action. This is not borrowing "
+            "a later action; it is grounding the first one.)\n"
+            "2) STARTING PHYSICS (use the anchors here). Read the character's CURRENT pose AND "
+            "what they are supported by / in contact with from the SCENE ANCHORS (e.g. seated on a "
+            "yoga ball, kneeling, gripping a weapon, leaning on a wall). clip_1 MUST begin the first "
+            "action FROM that exact physical situation and honor its constraints. If the support is "
+            "unstable or unusual (a yoga ball, a ledge, a moving surface), the motion MUST account "
+            "for it — e.g. anchor 'seated balanced on a yoga ball' -> clip_1 = 'pushing off the "
+            "wobbling ball and rising to their feet as it rolls away' BEFORE any further action. "
+            "Never ignore or contradict the starting support (do not stand if seated on the ball "
+            "without first leaving it; do not assume a weapon is drawn if the anchor shows it "
+            "sheathed). This makes the motion physically continuous with the input image. Reference "
+            "the support ONLY to ground how the motion STARTS — do NOT describe its appearance, "
+            "color, or the wider environment.\n"
+            + continuity_rule +
+            "4) ACTION ONLY. Write physical body movement. NO scenery, NO lighting, NO clothing, "
+            "NO mood, NO camera talk. If a word is not a movement or body part, delete it. "
+            "(Referring to the starting pose in clip_1 per rule 2, or to the prior clip's ending "
+            "position per rule 3, is allowed since it describes how the body moves.)\n"
+            "5) FILL 5 SECONDS. Expand the assigned action into a single continuous flow of motion "
+            "that occupies the whole clip (use 'then', 'immediately', 'without pausing'). "
+            "Do not borrow the next action to fill time - elaborate the CURRENT action instead.\n"
+            "6) ANTI-SLOW-MOTION: real-time speed, kinetic adverbs (swiftly, rapidly, explosively, "
+            "in a split second). NO slow motion, NO freeze, NO holding a pose.\n"
+            "7) CHARACTER NAME: study the SCENE ANCHORS. Judge the character's apparent ethnicity/"
+            "setting (East Asian, Western, etc.) and INVENT a specific fitting first name that "
+            "matches it (e.g. East Asian -> 'Yuna','Kaede','Jin'; Western -> 'Elena','Ryan'). "
+            "NEVER output 'AUTO' or an empty name. If a NAME is given below (not 'AUTO'), use it.\n"
+            f"8) {detail}\n"
+            "9) MOTION ENERGY: a MOTION STYLE cue is given below (e.g. 'cinematic lighting, dynamic "
+            "motion'). Use it ONLY to calibrate how forceful/graceful/frantic the movement FEELS "
+            "(word choice, verb intensity). Do NOT quote it and do NOT let any scenery/lighting/mood "
+            "words from it leak into the output — rule 4 still applies.\n"
+            "\n"
+            "master_scene: leave it EMPTY.\n"
+            "\n"
+            'OUTPUT ONLY JSON: {"character":"<a real name, never AUTO>","master_scene":"",'
+            + json_clip_fields + "}"
+        )
+        usr = (f"NAME: {name}\nPACING: {self._pacing_hint(pacing)}\n\n"
+               f"MOTION STYLE (kinetic energy cue only, per rule 9 — do not describe scenery/"
+               f"lighting/mood from this): {vibe.strip() or '(none)'}\n\n"
+               f"SCENE ANCHORS (use the POSE to start clip_1's motion per rule 2; "
+               f"use overall look only for naming — do NOT copy look into the clips):\n"
+               f"{anchors or '(none — assume a neutral ready stance)'}\n\n"
+               f"STRICT PER-CLIP ACTION ASSIGNMENT (animate ONLY what is listed per clip, "
+               f"in this order, finisher in clip_{last_clip}):\n{assign_block}\n")
+        messages = [{"role": "system", "content": sys}, {"role": "user", "content": usr}]
+        t = temp
+        last = "⚠️ plan failed (no attempts ran)"
+        for attempt in (1, 2):
+            try:
+                content = self._call_or(messages, llm_model, key, t, force_json=True)
+                parsed = self._extract_json(content)
+                if parsed and all(parsed.get(f"clip_{i}") for i in range(1, num_clips + 1)):
+                    return parsed, f"✅ plan ok (attempt {attempt})"
+                last = f"⚠️ incomplete JSON (attempt {attempt}): {content[:150]!r}"
+                print(f"⚠️ [Director] plan attempt {attempt} returned incomplete JSON: {content[:300]}")
+            except urllib.error.HTTPError as e:
+                body = ""
+                try:
+                    body = e.read().decode('utf-8')[:200]
+                except Exception:
+                    pass
+                last = f"❌ plan HTTP {e.code} (attempt {attempt}): {body}"
+                print(f"❌ [Director] plan {last}")
+            except (urllib.error.URLError, TimeoutError, KeyError, ValueError) as e:
+                last = f"❌ plan error (attempt {attempt}): {type(e).__name__}: {e}"
+                print(f"❌ [Director] {last}")
+            t = min(temp, 0.4)
+        return None, last
+
+    def _local_split(self, actions, num_clips=4):
+        parts = re.split(r'(?<=[.!?。])\s+|[,、]|\n+', actions)
+        parts = [p.strip() for p in parts if len(p.strip()) > 1]
+        if not parts:
+            parts = [actions.strip()]
+        n = len(parts)
+        last = num_clips - 1
+
+        def fast(phrase, lead="swiftly"):
+            p = phrase.strip()
+            return f"{lead} {p}, continuous real-time motion, no slow motion" if p else ""
+
+        if num_clips == 1:
+            return [fast(", ".join(parts), "explosively")]
+
+        if n == 1:
+            a = parts[0]
+            templates = [
+                f"rapidly moves into position toward {a}, no pause",
+                f"immediately begins {a}, brisk continuous motion, no slow motion",
+                f"presses {a} without stopping, fast decisive movement",
+            ]
+            out = [templates[min(i, len(templates) - 1)] for i in range(num_clips - 1)]
+            out.append(f"explosively completes {a} at real-time speed, no slow motion, no freeze")
+        elif n <= num_clips:
+            out = [""] * num_clips
+            out[last] = fast(parts[-1], "explosively")
+            head = parts[:-1]
+            for i, ph in enumerate(head):
+                s = min(i, num_clips - 2)
+                out[s] = (out[s] + ", then " + fast(ph)).strip(", ") if out[s] else fast(ph)
+            for i in range(num_clips - 1):
+                if not out[i]:
+                    key = parts[min(i, n - 1)]
+                    out[i] = f"rapidly moves toward {key}, brisk continuous motion, no slow motion"
+        else:
+            k, m = divmod(n - 1, num_clips - 1)
+            idx, chunks = 0, []
+            for i in range(num_clips - 1):
+                end = idx + k + (1 if i < m else 0)
+                seg = parts[idx:end]
+                idx = end
+                chunks.append(", then ".join(fast(p) for p in seg) if seg else "")
+            out = chunks + [fast(parts[-1], "explosively")]
+        return out[:num_clips]
+
+    def _load(self, name):
+        return comfy.utils.load_torch_file(folder_paths.get_full_path("loras", name))
+
+    @staticmethod
+    def _parse_weights(text):
+        try:
+            nums = [float(x) for x in re.split(r'[,\s]+', text.strip()) if x != ""]
+        except (ValueError, AttributeError):
+            nums = []
+        if not nums:
+            return 1.0, 1.0, 1.0
+        if len(nums) == 1:
+            return nums[0], nums[0], nums[0]
+        if len(nums) == 2:
+            return nums[0], nums[1], nums[1]
+        return nums[0], nums[1], nums[2]
+
+    def _patch_clip(self, mb, mh, ml, slots, cache, inject):
+        cb, ch, cl = mb, mh, ml
+        used = []
+        for (name, w_str) in slots:
+            if name == "None":
+                continue
+            w_b, w_h, w_l = self._parse_weights(w_str)
+            if w_b == 0.0 and w_h == 0.0 and w_l == 0.0:
+                continue
+            data = self._load(name)
+            if w_b != 0.0:
+                cb = apply_model_lora(cb, data, w_b)
+            if w_h != 0.0:
+                ch = apply_model_lora(ch, data, w_h)
+            if w_l != 0.0:
+                cl = apply_model_lora(cl, data, w_l)
+            used.append(name)
+        trig = []
+        trig_dbg = []
+        for n in dict.fromkeys(used):
+            found = get_triggers(n, cache)
+            trig.extend(found)
+            trig_dbg.append(f"{os.path.basename(n)}:{len(found)}")
+        self._last_trig_dbg = trig_dbg
+        trig_str = ", ".join(dict.fromkeys(t for t in trig if t))
+        prompt_trig = trig_str if inject else ""
+        return cb, ch, cl, prompt_trig, trig_str
+
+    def direct(self, image, model_base, model_high, model_low, essential_actions, num_clips,
+               character_name, artistic_vibe, pacing, detail_level, inject_triggers,
+               use_vision, openrouter_api_key, vlm_preset, vlm_model, llm_preset, llm_model,
+               creativity, seed, **kw):
+
+        n_clips = int(str(num_clips).split()[0])
+        vlm = resolve_slug(VLM_PRESETS, vlm_preset, vlm_model, "qwen/qwen2.5-vl-72b-instruct")
+        llm = resolve_slug(LLM_PRESETS, llm_preset, llm_model, "deepseek/deepseek-v3.2")
+        user_name = "" if character_name.strip().upper() in ["AUTO", ""] else character_name.strip()
+        key = resolve_api_key(openrouter_api_key)
+
+        vision_caption = str(kw.get("vision_caption", "") or "").strip()
+        anchors, dbg_v = "", ""
+        if vision_caption:
+            anchors = vision_caption
+            dbg_v = "vision ok (local caption node)"
+            print(f"👁 [Director] 로컬 캡션 입력 사용 (JoyCaption 등):\n{anchors[:300]}")
+        elif not use_vision:
+            dbg_v = "vision OFF (토글 확인)"
+            print("ℹ️ [Director] use_vision=OFF - 비전 건너뜀")
+        elif not key:
+            dbg_v = "no api key"
+            print("❌ [Director] openrouter_api_key 비어있음 (위젯도, OPENROUTER_API_KEY 환경변수도 없음) - 비전/LLM 불가")
+        elif image is None:
+            dbg_v = "no image"
+            print("❌ [Director] image 입력 없음 - IMAGE 연결 확인")
+        else:
+            data_uri = tensor_to_base64(image)
+            if data_uri:
+                anchors, err = self._vision_analyze(data_uri, vlm, key, min(creativity, 0.5))
+                dbg_v = err or "vision ok"
+            else:
+                dbg_v = "image encode failed / PIL missing"
+        if not vision_caption and use_vision and key and image is not None and not anchors:
+            print(f"⚠️ [Director] 비전 앵커가 비었음 -> 이름/씬 근거 없음. 원인: {dbg_v}")
+
+        if key:
+            parsed, dbg_p = self._plan_shots(anchors, essential_actions, character_name,
+                                             artistic_vibe, pacing, self._detail_hint(detail_level),
+                                             llm, key, creativity, seed, num_clips=n_clips)
+            if parsed:
+                clips = [str(parsed[f"clip_{i}"]).strip() for i in range(1, n_clips + 1)]
+                master = str(parsed.get("master_scene", "")).strip()
+                cand = str(parsed.get("character", "")).strip()
+                if not cand or cand.upper() == "AUTO":
+                    cand = self._fallback_name(anchors)
+                final_name = user_name or cand
+            else:
+                clips = self._local_split(essential_actions, num_clips=n_clips)
+                master = anchors.replace("\n", " ")[:160]
+                final_name = user_name or self._fallback_name(anchors)
+        else:
+            parsed, dbg_p = None, "no api key"
+            clips = self._local_split(essential_actions, num_clips=n_clips)
+            master = anchors.replace("\n", " ")[:160]
+            final_name = user_name
+
+        if len(clips) < 4:
+            clips = clips + [clips[-1]] * (4 - len(clips))
+
+        cache = _load_cache()
+        manual_list = [t.strip() for t in kw.get("manual_triggers", "").split(',') if t.strip()]
+        outs = []
+        all_trigs_collected = []
+        for c in range(1, 5):
+            if c > n_clips:
+                cb = ch = cl = ExecutionBlocker(None)
+                prompt = self._build_final(clips[c - 1], master, final_name, "")
+                outs.extend([cb, ch, cl, prompt])
+                print(f"  [clip{c}] SKIPPED (num_clips={n_clips}) - ExecutionBlocker 반환")
+                continue
+            slots = [(kw.get(f"c{c}_lora_{n}", "None"),
+                      kw.get(f"c{c}_w_{n}", "1.0, 1.0, 1.0")) for n in range(1, 5)]
+            cb, ch, cl, prompt_trig, always_trig = self._patch_clip(
+                model_base, model_high, model_low, slots, cache, inject_triggers)
+            all_trig = ", ".join(dict.fromkeys(
+                ([prompt_trig] if prompt_trig else []) + manual_list)) \
+                if (prompt_trig or manual_list) else ""
+            if always_trig:
+                all_trigs_collected.extend(t.strip() for t in always_trig.split(',') if t.strip())
+            prompt = self._build_final(clips[c - 1], master, final_name, all_trig)
+            outs.extend([cb, ch, cl, prompt])
+            print(f"  [clip{c}] loras/triggers: {getattr(self, '_last_trig_dbg', [])} "
+                  f"inject={inject_triggers}")
+
+        triggers_out = ", ".join(dict.fromkeys(
+            [t for t in all_trigs_collected if t] + manual_list))
+
+        debug = f"vlm={dbg_v} | plan={dbg_p} | char={final_name} | clips={n_clips} ({n_clips*5}s)"
+        print(f"\n🎬 [Dolphin Vision Director] {debug}\nANCHORS: {anchors[:120]}")
+        for i in range(4):
+            print(f"  CLIP {i+1}: {outs[i*4+3][:90]}")
+
+        is_final = tuple(c == n_clips for c in range(1, 5))
+
+        return tuple(outs) + (triggers_out, anchors, debug) + is_final
+
+
+NODE_CLASS_MAPPINGS = {"DolphinVisionDirector": DolphinVisionDirector}
+NODE_DISPLAY_NAME_MAPPINGS = {"DolphinVisionDirector": "🎬👁 Dolphin Vision Director (Image→4Clips)"}

promp_logic_v32_vision.py

@@ -0,0 +1,247 @@
+import os
+import random
+import re
+import json
+import urllib.request
+import urllib.error
+import base64
+import io
+import time
+import numpy as np
+from PIL import Image
+import torch
+
+
+class DolphinMultiActionPromptNode_V32:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["🤖 Auto Vision+LLM", "✍️ Manual Override"], {"default": "🤖 Auto Vision+LLM"}),
+                "character_name": ("STRING", {"multiline": False, "default": "AUTO"}),
+                "artistic_vibe": ("STRING", {"multiline": True, "default": "cinematic lighting, high-speed action, dark fantasy"}),
+
+                "master_story": ("STRING", {
+                    "multiline": True,
+                    "default": "어두운 골목길. 갑자기 나타난 적들을 향해 돌진한다, 화려하게 검을 휘둘러 적을 쓰러뜨린다, 날아오는 총알을 튕겨낸다, 적에게 다가가 숨통을 끊는다."
+                }),
+
+                "openrouter_api_key": ("STRING", {"multiline": False, "default": ""}),
+                "openrouter_model": ("STRING", {"multiline": False, "default": "qwen/qwen-2-vl-72b-instruct"}),
+                "creativity": ("FLOAT", {"default": 0.85, "min": 0.1, "max": 1.5, "step": 0.05}),
+                "max_tokens": ("INT", {"default": 1500, "min": 256, "max": 8192, "step": 64}),
+                "retries": ("INT", {"default": 2, "min": 0, "max": 5}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING", "STRING")
+    RETURN_NAMES = (
+        "prompt_1 (Clip 1: 0-5s)",
+        "prompt_2 (Clip 2: 0-5s)",
+        "prompt_3 (Clip 3: 0-5s)",
+        "prompt_4 (Clip 4: 0-5s)",
+        "raw_llm_output",
+    )
+    FUNCTION = "generate_sequence"
+    CATEGORY = "Dolphin"
+
+    # -----------------------------------------------------------------
+    def _encode_image(self, image):
+        img_tensor = image[0]
+        i = 255. * img_tensor.cpu().numpy()
+        img_pil = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        if img_pil.mode != "RGB":
+            img_pil = img_pil.convert("RGB")
+        buffered = io.BytesIO()
+        img_pil.save(buffered, format="JPEG", quality=90)
+        b64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+        return f"data:image/jpeg;base64,{b64}"
+
+    def _split_sentences(self, master_story):
+        clean_story = re.sub(r'([.!?,\n])', r'\1|', master_story)
+        raw_sentences = clean_story.split('|')
+        return [s.strip() for s in raw_sentences if len(s.strip()) > 1]
+
+    def _build_chunks(self, sentences):
+        n = len(sentences)
+        if n == 0:
+            base = "dynamic high-speed action"
+            return (base, base, base, base)
+        if n == 1:
+            s = sentences[0]
+            return (
+                f"Phase 1: Rapid approach and high-speed dynamic movement. DO NOT stand still. (Target: {s})",
+                f"Phase 2: Swift, explosive execution of the action. (Target: {s})",
+                f"Phase 3: The climax at full 1x real-time speed. Lightning fast! (Target: {s})",
+                f"Phase 4: Fast-paced completion and quick recovery. (Target: {s})",
+            )
+        if n == 2:
+            return (
+                f"Phase 1: High-speed buildup and rapid preparation. (Target: {sentences[0]})",
+                f"Phase 2: Explosively execute -> {sentences[0]}",
+                f"Phase 3: Rapid transition, sprinting or moving quickly. (Target: {sentences[1]})",
+                f"Phase 4: Lightning-fast execution -> {sentences[1]}",
+            )
+        if n == 3:
+            return (
+                f"Phase 1: Start this action rapidly -> {sentences[0]}",
+                f"Phase 2: Explosively complete -> {sentences[0]}",
+                sentences[1],
+                sentences[2],
+            )
+        # n >= 4: 균등 분배
+        k, m = divmod(n, 4)
+        chunks = []
+        start = 0
+        for idx in range(4):
+            end = start + k + (1 if idx < m else 0)
+            chunks.append(" ".join(sentences[start:end]))
+            start = end
+        return tuple(chunks)
+
+    def _call_llm(self, url, payload, api_key, retries, timeout=120):
+        last_err = None
+        for attempt in range(retries + 1):
+            try:
+                req = urllib.request.Request(
+                    url,
+                    data=json.dumps(payload).encode('utf-8'),
+                    headers={'Authorization': f'Bearer {api_key}', 'Content-Type': 'application/json'}
+                )
+                response = urllib.request.urlopen(req, timeout=timeout)
+                body = json.loads(response.read().decode('utf-8'))
+                return body['choices'][0]['message']['content'].strip(), None
+            except Exception as e:
+                last_err = e
+                if attempt < retries:
+                    time.sleep(1.5 * (attempt + 1))
+        return None, last_err
+
+    # -----------------------------------------------------------------
+    def generate_sequence(self, image, mode, character_name, artistic_vibe, master_story,
+                          openrouter_api_key, openrouter_model, creativity, max_tokens, retries, seed):
+
+        user_defined_name = "" if character_name.upper() in ["AUTO", ""] else character_name.strip()
+
+        def build_final(action, master_scene, name):
+            tags_list = []
+            if name:
+                tags_list.append(name)
+            tag_block = ", ".join(tags_list)
+
+            sentence_list = []
+            if master_scene.strip():
+                sentence_list.append(master_scene.strip().strip(",. "))
+            if action.strip():
+                sentence_list.append(action.strip())
+            sentence_block = " ".join(sentence_list)
+
+            if tag_block and sentence_block:
+                return f"{tag_block}\n{sentence_block}"
+            elif tag_block:
+                return tag_block
+            return sentence_block
+
+        # ---- Manual Override ----
+        if mode == "✍️ Manual Override":
+            fp = build_final(master_story, "", user_defined_name)
+            return (fp, fp, fp, fp, "[Manual Override]")
+
+        random.seed(seed)
+
+        base64_image = self._encode_image(image)
+        sentences = self._split_sentences(master_story)
+        chunk_1, chunk_2, chunk_3, chunk_4 = self._build_chunks(sentences)
+
+        sys_prompt = (
+            "You are an Elite Action Director prioritizing RAW SPEED and KINETIC ENERGY.\n"
+            f"1. CHARACTER: If NAME is 'AUTO', assign a name. If '{user_defined_name}', use it.\n"
+            "2. VISUAL ANALYSIS: You MUST base your descriptions EXACTLY on the character's clothing and weapons in the attached IMAGE.\n"
+            "3. MASTER SCENE: Write a 1-sentence environment description (lighting, weather).\n"
+            "4. SPEED-FOCUSED CHOREOGRAPHY (CRITICAL):\n"
+            "   - 🚫 BAN SLOW-MOTION TRIGGERS: NEVER use words like 'micro-expressions', 'muscle tension', 'slowly turning', 'floating', or 'gradually'. These cause AI video models to render in slow-motion.\n"
+            "   - ✅ FORCE 1x REAL-TIME SPEED: Describe large, sweeping, high-velocity movements. Use aggressive verbs (dashing, sprinting, whipping, snapping).\n"
+            "   - ✅ KINETIC ADVERBS: Inject phrases like 'in a flash', 'at lightning speed', 'with explosive real-time velocity' into EVERY part.\n"
+            "   - Example: 'suddenly dashes forward at full speed and delivers a lightning-fast horizontal strike, moving so quickly the rain splatters'.\n"
+            "   - Strictly confine the actions. DO NOT animate future events early.\n"
+            "   - 🔥 OUTPUT RULE: DO NOT quote the Korean text. Only output English.\n"
+            "Format EXACTLY:\nCHARACTER: [Name]\nMASTER SCENE: [Description]\n"
+            "PART 1: [0-1s] [Action A] [2-3s] [Action B] [4-5s] [Action C]\n"
+            "PART 2: [0-1s] [Action D] [2-3s] [Action E] [4-5s] [Action F]\n"
+            "PART 3: [0-1s] [Action G] [2-3s] [Action H] [4-5s] [Action I]\n"
+            "PART 4: [0-1s] [Action J] [2-3s] [Action K] [4-5s] [Action L]"
+        )
+
+        usr_text = (
+            f"NAME: {character_name}\n"
+            f"VIBE: {artistic_vibe}\n\n"
+            "=== HIGH-SPEED ACTION SCRIPT ===\n"
+            f"▶ For PART 1 (0-5s), ONLY animate this: \"{chunk_1}\"\n"
+            f"▶ For PART 2 (5-10s), ONLY animate this: \"{chunk_2}\"\n"
+            f"▶ For PART 3 (10-15s), ONLY animate this: \"{chunk_3}\"\n"
+            f"▶ For PART 4 (15-20s), ONLY animate this: \"{chunk_4}\"\n"
+            "CRITICAL: Keep the action moving FAST. Avoid still poses or micro-details that look like slow-mo!"
+        )
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {
+            "model": openrouter_model.strip(),
+            "messages": [
+                {"role": "system", "content": sys_prompt},
+                {"role": "user", "content": [
+                    {"type": "text", "text": usr_text},
+                    {"type": "image_url", "image_url": {"url": base64_image}}
+                ]}
+            ],
+            "temperature": creativity,
+            "max_tokens": max_tokens,
+        }
+
+        if not openrouter_api_key.strip():
+            err_msg = "⚠️ API Error: OpenRouter API key is empty."
+            return (err_msg, err_msg, err_msg, err_msg, err_msg)
+
+        llm_prompt, err = self._call_llm(url, payload, openrouter_api_key, retries)
+        if llm_prompt:
+            print(f"\n✅ [Dolphin V32 - Action Speed Optimized]\n{llm_prompt}\n")
+        else:
+            print(f"❌ [에러] API 호출 실패: {err}")
+            llm_prompt = ""
+
+        final_char_name = user_defined_name
+        r_master = ""
+        p1 = p2 = p3 = p4 = ""
+
+        if llm_prompt and "[removed]" not in llm_prompt:
+            cl = re.sub(r'[*#]', '', llm_prompt)
+            m_char = re.search(r'CHARACTER:\s*(.*?)(?=MASTER SCENE|$)', cl, re.I | re.S)
+            m_master = re.search(r'MASTER SCENE:\s*(.*?)(?=PART 1|$)', cl, re.I | re.S)
+
+            m1 = re.search(r'PART 1:\s*(.*?)(?=PART 2|$)', cl, re.I | re.S)
+            m2 = re.search(r'PART 2:\s*(.*?)(?=PART 3|$)', cl, re.I | re.S)
+            m3 = re.search(r'PART 3:\s*(.*?)(?=PART 4|$)', cl, re.I | re.S)
+            m4 = re.search(r'PART 4:\s*(.*?)(?=\n\n|===|Note:|$)', cl, re.I | re.S)
+
+            if not user_defined_name and m_char:
+                final_char_name = m_char.group(1).strip()
+
+            r_master = m_master.group(1).strip() if m_master else ""
+
+            # 파싱 실패 시 해당 청크(영문 지시문)를 폴백으로 사용해 비디오 프롬프트가 비지 않도록 함
+            p1 = m1.group(1).strip() if m1 else chunk_1
+            p2 = m2.group(1).strip() if m2 else chunk_2
+            p3 = m3.group(1).strip() if m3 else chunk_3
+            p4 = m4.group(1).strip() if m4 else chunk_4
+        else:
+            # API 실패 시에도 스크립트 청크를 폴백으로 반환 (완전 실패보다 유용)
+            p1, p2, p3, p4 = chunk_1, chunk_2, chunk_3, chunk_4
+
+        return (
+            build_final(p1, r_master, final_char_name),
+            build_final(p2, r_master, final_char_name),
+            build_final(p3, r_master, final_char_name),
+            build_final(p4, r_master, final_char_name),
+            llm_prompt if llm_prompt else "⚠️ API Error / empty response",
+        )

wan_resizer.py

@@ -0,0 +1,56 @@
+import math
+import torch
+import comfy.utils
+
+class WanNativeResize_Dolphin:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "target_model": (["480P (832x480)", "720P (1280x720)", "1080P (1920x1080)"], {"default": "720P (1280x720)"}),
+                "upscale_method": (["nearest-exact", "bilinear", "area", "bicubic", "lanczos"], {"default": "lanczos"}),
+                "alignment": ("INT", {"default": 16, "min": 8, "max": 64, "step": 8}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT")
+    RETURN_NAMES = ("IMAGE", "width", "height")
+    FUNCTION = "resize_for_wan"
+    CATEGORY = "Dolphin Node/Wan Video" 
+
+    def resize_for_wan(self, image, target_model, upscale_method, alignment):
+        # 1. ComfyUI 이미지 텐서의 형태를 가져옵니다: (Batch/Frames, Height, Width, Channels)
+        b, h, w, c = image.shape
+        
+        # 2. 타겟 모델에 따른 총 픽셀 면적(Area) 세팅
+        if "480P" in target_model:
+            target_area = 832 * 480
+        elif "720P" in target_model:
+            target_area = 1280 * 720
+        else:
+            target_area = 1920 * 1080
+            
+        # 3. Byungjoo님의 수학 로직 (비율 유지 계산)
+        aspect_ratio = w / h
+        new_h = math.sqrt(target_area / aspect_ratio)
+        new_w = new_h * aspect_ratio
+        
+        # 4. [핵심] VAE가 좋아하는 배수(Alignment, 보통 16)로 반올림 처리
+        new_w = int(round(new_w / alignment) * alignment)
+        new_h = int(round(new_h / alignment) * alignment)
+
+        # 5. [최적화] 이미 목표 해상도와 일치한다면, 무거운 연산 없이 원본 통과 (패스스루)
+        if w == new_w and h == new_h:
+            return (image, new_w, new_h)
+
+        # 6. [핵심] 텐서 차원 변경: ComfyUI (B, H, W, C) -> 리사이즈 엔진용 (B, C, H, W)
+        image = image.movedim(-1, 1)
+
+        # 7. ComfyUI 내장 엔진을 사용해 초고화질 리사이즈 (Lanczos 지원)
+        resized_image = comfy.utils.common_upscale(image, new_w, new_h, upscale_method, "disabled")
+
+        # 8. 텐서 차원 원상 복구: (B, C, H, W) -> ComfyUI (B, H, W, C)
+        resized_image = resized_image.movedim(1, -1)
+
+        return (resized_image, new_w, new_h)