Deploy DualSpace H3 Clip Conditioner (Comfy2API)

README.md

@@ -1,13 +1,27 @@
 ---
-title: Dualspace H3 Clip
-emoji: 👁
-colorFrom: purple
-colorTo: purple
+title: DualSpace MiniMax-H3 Clip
+emoji: 🧠
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.29.1
-python_version: '3.12'
+sdk_version: 5.44.1
 app_file: app.py
 pinned: false
+license: apache-2.0
+tags:
+  - comfyui
+  - zerogpu
+  - minimax-h3
+  - clip
+  - text-encoder
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧠 DualSpace MiniMax-H3 — Text/Vision Conditioner Service (I2V)
+
+Layanan backend berarsitektur **Hot-Standby Thin Wire** untuk memproses visual keyframe dan prompt menggunakan **Qwen3-VL 32B NVFP4/AWQ** dan **Video VAE INT8 ConvRot** via ComfyUI Core Native.
+
+## 🚀 Fitur:
+- **Thin Wire Protocol**: Mengemas tensor embedding Qwen3-VL, token tags, dan keyframe latent ke dalam file `.safetensors` ramping tanpa overhead memindahkan canvas kosong.
+- **Pure ComfyUI Core Native**: Bebas custom nodes eksternal, memaksimalkan stabilitas dan kompatibilitas ComfyUI.
+- **Zero-Overhead GPU Forward**: Waktu GPU 100% dialokasikan murni untuk inferensi forward pass.
+- **Root Startup Pre-Warming**: Model dan engine ComfyUI sudah diinisialisasi ke RAM sebelum request pertama masuk.

app.py

@@ -0,0 +1,642 @@
+from __future__ import annotations
+
+import os
+import sys
+import subprocess
+import pathlib
+import shutil
+import re
+import uuid
+import json
+import glob
+import time
+import asyncio
+from typing import Any
+
+# ============================================================
+# 1. HUGGINGFACE_HUB SELF-HEALING REPAIR
+# ============================================================
+def _hf_hub_version() -> str:
+    try:
+        from importlib.metadata import version as _pkg_version
+        return _pkg_version("huggingface_hub")
+    except Exception:
+        return ""
+
+def _hf_hub_is_broken() -> bool:
+    import importlib
+    import importlib.util
+    for module_name in ("huggingface_hub._snapshot_download", "huggingface_hub._tree_cache"):
+        try:
+            if importlib.util.find_spec(module_name) is None:
+                continue
+        except Exception:
+            return True
+        try:
+            importlib.import_module(module_name)
+        except ImportError:
+            return True
+        except Exception:
+            continue
+    return False
+
+def _hf_hub_reinstall(upgrade: bool) -> None:
+    cmd = [
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "--no-cache-dir",
+        "--force-reinstall",
+        "--no-deps",
+    ]
+    if upgrade:
+        cmd += ["--upgrade", "huggingface_hub"]
+    else:
+        pinned = _hf_hub_version()
+        cmd.append(f"huggingface_hub=={pinned}" if pinned else "huggingface_hub")
+    print(f"[hf-repair] {' '.join(cmd)}", flush=True)
+    subprocess.run(cmd, check=False)
+
+def _repair_huggingface_hub_and_restart() -> None:
+    stage = int(os.environ.get("_HF_HUB_REPAIR_STAGE", "0") or "0")
+    if stage >= 2 or not _hf_hub_is_broken():
+        return
+    _hf_hub_reinstall(upgrade=stage == 1)
+    os.environ["_HF_HUB_REPAIR_STAGE"] = str(stage + 1)
+    os.execv(sys.executable, [sys.executable, *sys.argv])
+
+_repair_huggingface_hub_and_restart()
+
+# ============================================================
+# 2. IMPORTS UTAMA (SPACES WAJIB PERTAMA SEBELUM TORCH)
+# ============================================================
+import spaces  # WAJIB PERTAMA sebelum torch!
+import torch
+
+# ============================================================
+# ZEROGPU COMPATIBILITY PATCH FOR PYTORCH CUDA MOCK PROPERTIES
+# ============================================================
+if hasattr(torch, "cuda") and hasattr(torch.cuda, "get_device_properties"):
+    _orig_cuda_get_device_properties = torch.cuda.get_device_properties
+    def _safe_cuda_get_device_properties(device=None):
+        props = _orig_cuda_get_device_properties(device)
+        if not hasattr(props, "is_integrated"):
+            try:
+                setattr(props, "is_integrated", False)
+            except Exception:
+                class _PropsProxy:
+                    def __init__(self, p):
+                        self._p = p
+                        self.is_integrated = False
+                    def __getattr__(self, name):
+                        return getattr(self._p, name)
+                return _PropsProxy(props)
+        return props
+    torch.cuda.get_device_properties = _safe_cuda_get_device_properties
+
+import gradio as gr
+import gradio_client.utils
+from huggingface_hub import hf_hub_download
+
+# ============================================================
+# 2.1 MONKEY-PATCH GRADIO_CLIENT OPENAPI SCHEMA BUG
+# ============================================================
+_orig_get_type = gradio_client.utils.get_type
+def _safe_get_type(schema):
+    if isinstance(schema, bool):
+        return "boolean"
+    if not isinstance(schema, dict):
+        return "str"
+    return _orig_get_type(schema)
+gradio_client.utils.get_type = _safe_get_type
+
+_orig_json_schema = gradio_client.utils._json_schema_to_python_type
+def _safe_json_schema(schema, defs=None):
+    if isinstance(schema, bool):
+        return "bool"
+    if not isinstance(schema, dict):
+        return "str"
+    return _orig_json_schema(schema, defs)
+gradio_client.utils._json_schema_to_python_type = _safe_json_schema
+
+# ============================================================
+# 3. KONFIGURASI PATH & DIREKTORI
+# ============================================================
+ROOT = pathlib.Path(__file__).resolve().parent
+COMFY = ROOT / "ComfyUI"
+MODELS = COMFY / "models"
+INPUT = COMFY / "input"
+OUTPUT = COMFY / "output"
+LOCAL_CUSTOM_NODES = ROOT / "custom_nodes"
+
+WORKFLOW_FILE = ROOT / "workflow_clip.json"
+NODE_OUTPUT_ID = "save_h3_cond"
+
+# ============================================================
+# 4. DAFTAR MODEL KONDISIONER MINIMAX-H3 (INT8 OPTIMIZED)
+# ============================================================
+DOWNLOADS = [
+    {
+        "repo": "Comfy-Org/MiniMax-H3",
+        "file": "text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "dest": MODELS / "text_encoders" / "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "alt_dest": MODELS / "clip" / "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "label": "Text Encoder (Qwen3-VL 32B NVFP4/AWQ ~15.7GB)",
+    },
+    {
+        "repo": "Comfy-Org/MiniMax-H3",
+        "file": "vae/minimax_h3_video_vae_int8_convrot.safetensors",
+        "dest": MODELS / "vae" / "minimax_h3_video_vae_int8_convrot.safetensors",
+        "alt_dest": None,
+        "label": "Video VAE INT8 ConvRot (~2.6GB)",
+    },
+]
+
+CUSTOM_NODES: list[tuple[str, str]] = []
+
+_comfy_ready = False
+_nodes_ready = False
+server_instance = None
+
+# ============================================================
+# 5. HELPER & MODEL DOWNLOADER
+# ============================================================
+def _run_cmd(cmd: list[str], cwd: pathlib.Path = ROOT, check: bool = True) -> None:
+    print(f"[*] Menjalankan: {' '.join(cmd)} di {cwd}", flush=True)
+    subprocess.run(cmd, cwd=cwd, check=check)
+
+def _link_or_copy(src: pathlib.Path, dest: pathlib.Path) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.is_symlink():
+        dest.unlink()
+    if dest.exists() and dest.stat().st_size > 1000:
+        return
+    try:
+        os.link(src, dest)
+        return
+    except OSError:
+        pass
+    shutil.copy2(src, dest)
+
+def _download_to_dest(repo: str, file_path: str, dest: pathlib.Path, token: str | None) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.is_symlink():
+        dest.unlink()
+    if dest.exists() and dest.stat().st_size > 1000:
+        return
+
+    p = pathlib.Path(file_path)
+    filename = p.name
+    subfolder = str(p.parent) if str(p.parent) != "." else None
+
+    print(f"[*] Mengunduh {filename} dari {repo} ke {dest.parent}...", flush=True)
+    downloaded_str = hf_hub_download(
+        repo_id=repo,
+        filename=filename,
+        subfolder=subfolder,
+        local_dir=str(dest.parent),
+        token=token,
+    )
+    downloaded = pathlib.Path(downloaded_str)
+
+    if downloaded.resolve() == dest.resolve():
+        return
+
+    if dest.exists() or dest.is_symlink():
+        dest.unlink()
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.replace(downloaded, dest)
+    except OSError:
+        shutil.copy2(downloaded, dest)
+        if downloaded.exists():
+            downloaded.unlink()
+
+    sub_dir = dest.parent / "split_files"
+    if sub_dir.exists():
+        shutil.rmtree(sub_dir, ignore_errors=True)
+
+def _install_filtered_requirements(req_path: pathlib.Path, cwd: pathlib.Path) -> None:
+    if not req_path.exists():
+        return
+    blocked = {"torch", "torchvision", "torchaudio", "transformers", "huggingface-hub", "accelerate", "xformers"}
+    safe: list[str] = []
+    for line in req_path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        item = line.strip()
+        if not item or item.startswith("#"):
+            continue
+        low = item.lower().replace("_", "-")
+        package = re.split(r"[<>=!~;\[\s]", low, maxsplit=1)[0]
+        if package in blocked:
+            continue
+        safe.append(item)
+    if safe:
+        filtered_file = cwd / "requirements_filtered.txt"
+        filtered_file.write_text("\n".join(safe) + "\n", encoding="utf-8")
+        _run_cmd([sys.executable, "-m", "pip", "install", "-r", "requirements_filtered.txt", "--no-cache-dir"], cwd=cwd, check=False)
+
+def _apply_comfy_utils_namespace_fix() -> None:
+    utils_path = COMFY / "utils"
+    utilities_path = COMFY / "utilities"
+    if utils_path.exists() and not utilities_path.exists():
+        try:
+            utils_path.rename(utilities_path)
+        except OSError:
+            pass
+
+    replacements = [
+        (re.compile(r"(^|\n)(\s*)from utils(\s|\.)"), r"\1\2from utilities\3"),
+        (re.compile(r"(^|\n)(\s*)import utils(\s|\.|$)"), r"\1\2import utilities\3"),
+    ]
+    for path in COMFY.rglob("*.py"):
+        if "__pycache__" in path.parts:
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        updated = text
+        for pattern, repl in replacements:
+            updated = pattern.sub(repl, updated)
+        updated = updated.replace("from utils import", "from utilities import")
+        if updated != text:
+            path.write_text(updated, encoding="utf-8")
+
+def _ensure_comfy() -> None:
+    global _comfy_ready
+    if _comfy_ready:
+        return
+
+    print("[1/3] Menyiapkan ComfyUI Runtime untuk H3 Conditioner...", flush=True)
+    if not COMFY.exists():
+        _run_cmd(["git", "clone", "--depth", "1", "--branch", "v0.38.2", "https://github.com/comfyanonymous/ComfyUI.git", str(COMFY)])
+        _install_filtered_requirements(COMFY / "requirements.txt", COMFY)
+
+    custom_root = COMFY / "custom_nodes"
+    custom_root.mkdir(parents=True, exist_ok=True)
+
+    # Pasang local thin wire node: save_h3_conditioning
+    if LOCAL_CUSTOM_NODES.exists():
+        for src_node in LOCAL_CUSTOM_NODES.iterdir():
+            if src_node.is_dir() and not src_node.name.startswith("."):
+                target_node = custom_root / src_node.name
+                if target_node.exists():
+                    shutil.rmtree(target_node, ignore_errors=True)
+                shutil.copytree(src_node, target_node)
+                print(f"[*] Terpasang local custom node: {src_node.name}", flush=True)
+
+    _apply_comfy_utils_namespace_fix()
+
+    for folder in ("text_encoders", "clip", "vae"):
+        (MODELS / folder).mkdir(parents=True, exist_ok=True)
+    INPUT.mkdir(parents=True, exist_ok=True)
+    OUTPUT.mkdir(parents=True, exist_ok=True)
+
+    _comfy_ready = True
+    print("[1/3] ComfyUI Runtime H3 Conditioner Siap.", flush=True)
+
+def _ensure_models(progress=None) -> None:
+    print("[2/3] Memeriksa & Mengunduh Model Conditioner MiniMax-H3...", flush=True)
+    token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    for row in DOWNLOADS:
+        dest = pathlib.Path(row["dest"])
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        if dest.is_symlink():
+            dest.unlink()
+        if not (dest.exists() and dest.stat().st_size > 1000):
+            print(f"[*] Mengunduh {row['label']}...", flush=True)
+            _download_to_dest(row["repo"], row["file"], dest, token)
+
+        alt = row.get("alt_dest")
+        if alt is not None:
+            alt_path = pathlib.Path(alt)
+            if dest.exists() and dest.stat().st_size > 1000:
+                _link_or_copy(dest, alt_path)
+    print("[2/3] Semua model conditioner MiniMax-H3 telah siap.", flush=True)
+
+def _init_comfy_nodes() -> None:
+    global _nodes_ready, server_instance
+    if _nodes_ready:
+        return
+
+    print("[3/3] Menginisialisasi Engine ComfyUI Conditioner (Full Standby)...", flush=True)
+    comfy_path = str(COMFY)
+    sys.path = [p for p in sys.path if p != comfy_path]
+    sys.path.insert(0, comfy_path)
+    for module_name in list(sys.modules):
+        if module_name in ("utils", "app") or module_name.startswith(("utils.", "app.")):
+            del sys.modules[module_name]
+
+    os.chdir(COMFY)
+
+    import execution
+    import nodes
+    import server
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    import inspect
+    sig = inspect.signature(server.PromptServer.__init__)
+    if "asset_manager" in sig.parameters:
+        try:
+            from app.assets.manager import default_asset_manager
+            asset_mgr = default_asset_manager()
+        except Exception:
+            class DummyAssetManager:
+                enabled = False
+                def startup(self): pass
+                def shutdown(self): pass
+                def register_routes(self, app, user_manager=None): pass
+                def ensure_scan_started(self): pass
+                def pause_background_scan(self): pass
+                def queue_output_scan(self): pass
+                def resume_background_scan(self): pass
+                def register_upload(self, *args, **kwargs): return None
+                def register_executed_output(self, *args, **kwargs): return None
+                def register_cached_output(self, *args, **kwargs): return None
+                def set_event_sink(self, sink): pass
+            asset_mgr = DummyAssetManager()
+        server_instance = server.PromptServer(loop, asset_mgr)
+    else:
+        server_instance = server.PromptServer(loop)
+
+    try:
+        execution.PromptQueue(server_instance)
+    except Exception:
+        pass
+
+    res = nodes.init_extra_nodes()
+    if asyncio.iscoroutine(res):
+        loop.run_until_complete(res)
+
+    _nodes_ready = True
+    print("[3/3] Engine ComfyUI Conditioner Siap & Berada dalam Mode Hot-Standby.", flush=True)
+
+executor_instance = None
+
+def _get_or_create_executor():
+    global executor_instance
+    if executor_instance is None:
+        import execution
+        executor_instance = execution.PromptExecutor(
+            server_instance,
+            cache_type=execution.CacheType.RAM_PRESSURE,
+            cache_args={"lru": 32, "ram": 60.0, "ram_inactive": 60.0},
+        )
+    return executor_instance
+
+def _preload_models_to_ram():
+    """Me-load Qwen3-VL 32B (~15.7GB) dan Video VAE INT8 (~2.6GB) ke RAM saat boot."""
+    print("[*] Pre-loading Text Encoder (Qwen3-VL 32B) & Video VAE INT8 ke RAM...", flush=True)
+    try:
+        import nodes
+        clip_loader = nodes.CLIPLoader()
+        vae_loader = nodes.VAELoader()
+
+        print("[*] Pre-loading Qwen3-VL 32B...", flush=True)
+        clip_loader.load_clip("qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors", type="minimax", device="default")
+
+        print("[*] Pre-loading Video VAE INT8...", flush=True)
+        vae_loader.load_vae("minimax_h3_video_vae_int8_convrot.safetensors")
+
+        print("[*] Pre-load Qwen3-VL & VAE ke RAM berhasil! (Zero Disk Reload).", flush=True)
+    except Exception as e:
+        print(f"[!] Warning saat pre-load model: {e}", flush=True)
+
+# ============================================================
+# 6. ROOT STARTUP PRE-WARMING (HOT-STANDBY OPTIMIZATION)
+# ============================================================
+def _startup_prewarm():
+    print("=" * 60, flush=True)
+    print("[startup] Memulai Pre-Warming Engine H3 Conditioner...", flush=True)
+    _ensure_comfy()
+    _ensure_models()
+    _init_comfy_nodes()
+    _get_or_create_executor()
+    _preload_models_to_ram()
+    print("[startup] Pre-Warming Selesai. Siap Melayani Permintaan Thin Wire.", flush=True)
+    print("=" * 60, flush=True)
+
+_startup_prewarm()
+
+# ============================================================
+# 7. EKSEKUSI WORKFLOW COMFYUI
+# ============================================================
+def _load_base_workflow() -> dict[str, Any]:
+    with open(WORKFLOW_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def _run_comfy_workflow(workflow: dict[str, Any]) -> str:
+    """Eksekusi workflow ComfyUI menggunakan persistent PromptExecutor dengan Profiler."""
+    import execution
+
+    executor = _get_or_create_executor()
+    prompt_id = str(uuid.uuid4())
+
+    node_durations: list[tuple[str, str, float]] = []
+    orig_get_output_data = execution.get_output_data
+
+    def _profiling_get_output_data(obj, input_data_all, *args, **kwargs):
+        if isinstance(obj, str):
+            node_id = obj
+            node_info = workflow.get(node_id, {})
+            class_type = node_info.get("class_type", "UnknownNode")
+            node_title = node_info.get("_meta", {}).get("title", class_type)
+            label = f"[Node {node_id}: {node_title}]"
+        else:
+            node_id = "?"
+            class_type = obj.__class__.__name__
+            label = f"[{class_type}]"
+
+        t0 = time.time()
+        print(f"🚀 {label} Mulai dieksekusi...", flush=True)
+        try:
+            res = orig_get_output_data(obj, input_data_all, *args, **kwargs)
+            dur = time.time() - t0
+            node_durations.append((node_id, label, dur))
+            print(f"⏱️ {label} Selesai dalam: {dur:.2f}s", flush=True)
+            return res
+        except Exception as e:
+            dur = time.time() - t0
+            print(f"❌ {label} Gagal setelah: {dur:.2f}s ({e})", flush=True)
+            raise
+
+    execution.get_output_data = _profiling_get_output_data
+    t_workflow_start = time.time()
+
+    try:
+        executor.execute(
+            workflow,
+            prompt_id,
+            extra_data={},
+            execute_outputs=[NODE_OUTPUT_ID],
+        )
+    finally:
+        execution.get_output_data = orig_get_output_data
+        t_workflow_total = time.time() - t_workflow_start
+        print("\n" + "=" * 70, flush=True)
+        print("📊 REKAPITULASI PROFILING WAKTU SPACE 1 (CONDITIONER):", flush=True)
+        print("=" * 70, flush=True)
+        sorted_nodes = sorted(node_durations, key=lambda x: x[2], reverse=True)
+        for nid, label, dur in sorted_nodes:
+            pct = (dur / t_workflow_total * 100) if t_workflow_total > 0 else 0
+            bar = "█" * int(pct // 5)
+            print(f" {label:<45} : {dur:>6.2f}s ({pct:>5.1f}%) {bar}", flush=True)
+        print("-" * 70, flush=True)
+        print(f" ⏱️ TOTAL DURASI ENCODE CONDITIONING : {t_workflow_total:.2f} detik", flush=True)
+        print("=" * 70 + "\n", flush=True)
+
+    if not executor.success:
+        err = (
+            executor.status_messages[-1]
+            if hasattr(executor, "status_messages") and executor.status_messages
+            else "ComfyUI execution gagal"
+        )
+        raise RuntimeError(str(err))
+
+    # Cari file safetensors terbaru di OUTPUT
+    files = [
+        pathlib.Path(p)
+        for p in glob.glob(str(OUTPUT / "**" / "*.safetensors"), recursive=True)
+    ]
+    if not files:
+        raise RuntimeError("Encoding selesai tetapi file .safetensors tidak ditemukan di output.")
+
+    latest_file = sorted(files, key=lambda p: p.stat().st_mtime, reverse=True)[0]
+    return str(latest_file)
+
+# ============================================================
+# 8. LOGIKA RUNNER ZERO-OVERHEAD @SPACES.GPU (DYNAMIC DURATION)
+# ============================================================
+def get_conditioner_duration(
+    prompt: str = "",
+    first_frame_path: str = "",
+    last_frame_path: str = "",
+    duration: float | str = "5s",
+    megapixels: float = 0.4,
+    aspect_ratio: str = "",
+) -> int:
+    """
+    Kalkulasi alokasi ZeroGPU dinamis dan aman untuk Space 1.
+    - Hanya First Frame: 45 detik (aktual ~11.6s, reserve: 67.5s)
+    - First Frame + Last Frame: 60 detik (aktual ~20-25s, reserve: 90s)
+    """
+    has_last = bool(last_frame_path and str(last_frame_path).strip())
+    return 60 if has_last else 45
+
+@spaces.GPU(duration=get_conditioner_duration)
+def encode_h3_conditioning(
+    prompt: str = "",
+    first_frame_path: str = "",
+    last_frame_path: str = "",
+    duration: float | str = "5s",
+    megapixels: float = 0.4,
+    aspect_ratio: str = "",
+) -> str:
+    """
+    Eksekusi forward pass untuk encode Qwen3-VL 32B conditioning + Video VAE Keyframes.
+    Hasilnya berupa file .safetensors (Thin Wire) berisi cond_embed, token tags, & keyframe latents.
+    """
+    if not first_frame_path or not os.path.exists(first_frame_path):
+        raise ValueError("First Frame wajib diunggah untuk mode Image-to-Video (I2V) MiniMax-H3.")
+
+    try:
+        dur_val = float(str(duration).replace("s", "").strip())
+    except Exception:
+        dur_val = 5.0
+
+    wf = _load_base_workflow()
+
+    # 1. Handle Keyframe First Frame (Wajib)
+    first_ext = pathlib.Path(first_frame_path).suffix or ".png"
+    first_name = f"first_{uuid.uuid4().hex[:8]}{first_ext}"
+    shutil.copy2(first_frame_path, INPUT / first_name)
+    wf["122"]["inputs"]["image"] = first_name
+
+    # 2. Handle Keyframe Last Frame (Opsional)
+    if last_frame_path and os.path.exists(last_frame_path):
+        last_ext = pathlib.Path(last_frame_path).suffix or ".png"
+        last_name = f"last_{uuid.uuid4().hex[:8]}{last_ext}"
+        shutil.copy2(last_frame_path, INPUT / last_name)
+        wf["123"]["inputs"]["image"] = last_name
+        wf["105_104"]["inputs"]["last_frame"] = ["123", 0]
+    else:
+        if "last_frame" in wf["105_104"]["inputs"]:
+            del wf["105_104"]["inputs"]["last_frame"]
+        if "123" in wf:
+            del wf["123"]
+
+    # 3. Inject Megapixels (dikunci 0.4 MP), Durasi, Prompt
+    prefix = f"h3_{uuid.uuid4().hex[:8]}"
+    wf["119"]["inputs"]["megapixels"] = 0.4
+    wf["105_111"]["inputs"]["value"] = dur_val
+    wf["105_104"]["inputs"]["prompt"] = str(prompt) if prompt else ""
+    wf["save_h3_cond"]["inputs"]["filename_prefix"] = prefix
+    wf["save_h3_cond"]["inputs"]["prompt_text"] = str(prompt) if prompt else ""
+
+    print(f"[*] [GPU] Menjalankan MiniMax-H3 I2V Conditioning (0.4 MP, {dur_val}s, has_last_frame={bool(last_frame_path)})", flush=True)
+
+    target_file = _run_comfy_workflow(wf)
+    size_kb = os.path.getsize(target_file) / 1024.0
+    print(f"[*] [GPU Selesai] File conditioning: {target_file} ({size_kb:.2f} KB)", flush=True)
+
+    return target_file
+
+def get_system_info() -> str:
+    info = []
+    info.append("### 🧠 Status Conditioner Service (Space 1 - Hot Standby)")
+    info.append(f"- **PyTorch Version:** `{torch.__version__}`")
+    info.append(f"- **CUDA Available:** `{torch.cuda.is_available()}`")
+    if torch.cuda.is_available():
+        info.append(f"- **CUDA Version:** `{torch.version.cuda}`")
+        info.append(f"- **Device Name:** `{torch.cuda.get_device_name(0)}`")
+        props = torch.cuda.get_device_properties(0)
+        info.append(f"- **VRAM:** `{props.total_memory / (1024**3):.2f} GB`")
+        info.append(f"- **Compute Capability:** `{props.major}.{props.minor}`")
+    info.append("- **Model Loaded:** `Qwen3-VL 32B NVFP4/AWQ` (~15.7 GB)")
+    info.append("- **Model VAE:** `minimax_h3_video_vae_int8_convrot` (~2.6 GB)")
+    info.append("- **Mode:** `Image-to-Video (I2V) Hot-Standby Pre-Warmed Engine`")
+    info.append("- **Dynamic Duration:** `20s (5s) | 25s (10s/15s)`")
+    info.append("- **Custom Nodes:** `0 External Repos (Pure ComfyUI Core Native)`")
+    info.append("- **Wire Output:** `.safetensors` binary format")
+    return "\n".join(info)
+
+# ============================================================
+# 9. ANTARMUKA GRADIO & API ENDPOINT
+# ============================================================
+with gr.Blocks(title="DualSpace MiniMax-H3 Conditioner Service") as demo:
+    gr.Markdown(
+        """
+        # 🧠 DualSpace MiniMax-H3 — Text/Vision Conditioner Service (I2V)
+        Space ini berfungsi sebagai **Conditioner as a Service** (Backend) untuk memproses Qwen3-VL 32B Text/Vision Encoder dan Video VAE Keyframes.
+        Mengembalikan file `.safetensors` (Thin Wire Protocol) untuk di-stream ke Space Generator.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column():
+            first_frame_in = gr.Image(type="filepath", label="First Frame (Wajib)")
+            last_frame_in = gr.Image(type="filepath", label="Last Frame (Opsional)")
+            prompt_in = gr.Textbox(label="Prompt (Opsional)", value="A cinematic video with smooth motion, high aesthetic quality")
+            dur_in = gr.Radio(choices=["5s", "10s", "15s"], value="5s", label="Durasi Video")
+            btn_encode = gr.Button("⚡ Encode Conditioning (GPU)", variant="primary")
+        
+        with gr.Column():
+            file_out = gr.File(label="Output .safetensors (Thin Wire)")
+
+    btn_encode.click(
+        fn=encode_h3_conditioning,
+        inputs=[prompt_in, first_frame_in, last_frame_in, dur_in],
+        outputs=[file_out],
+        api_name="encode",
+    )
+
+    with gr.Accordion("🛠️ Info Hardware & Status", open=False):
+        info_btn = gr.Button("🔍 Cek Status Sistem")
+        info_markdown = gr.Markdown(value=get_system_info())
+        info_btn.click(fn=get_system_info, outputs=[info_markdown])
+
+if __name__ == "__main__":
+    demo.queue(max_size=20).launch(show_error=True)

custom_nodes/save_h3_conditioning/__init__.py

@@ -0,0 +1,3 @@
+from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

custom_nodes/save_h3_conditioning/nodes.py

@@ -0,0 +1,91 @@
+import os
+import uuid
+import json
+import torch
+import safetensors.torch as st
+import folder_paths
+
+class SaveH3ConditioningSafetensors:
+    """
+    Menyimpan tensor ComfyUI CONDITIONING hasil MiniMaxH3ImageToVideo (Qwen3-VL + Keyframes)
+    ke file .safetensors (Thin Wire Protocol: embedding multimodal + keyframe latents).
+    """
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "conditioning": ("CONDITIONING",),
+                "filename_prefix": ("STRING", {"default": "h3_cond"}),
+                "width": ("INT", {"default": 896}),
+                "height": ("INT", {"default": 504}),
+                "length": ("INT", {"default": 97}),
+            },
+            "optional": {
+                "prompt_text": ("STRING", {"default": ""}),
+            }
+        }
+
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    FUNCTION = "save"
+    CATEGORY = "conditioning/minimax_h3"
+
+    def save(self, conditioning, filename_prefix="h3_cond", width=896, height=504, length=97, prompt_text=""):
+        output_dir = folder_paths.get_output_directory()
+        filename = f"{filename_prefix}_{uuid.uuid4().hex[:10]}.safetensors"
+        filepath = os.path.join(output_dir, filename)
+
+        # ComfyUI CONDITIONING: list of tuples [[embed_tensor, extra_dict]]
+        cond_embed = conditioning[0][0].contiguous().cpu()
+        extra_dict = conditioning[0][1] if len(conditioning[0]) > 1 else {}
+        pooled = extra_dict.get("pooled_output", None)
+
+        tensors = {
+            "cond_embed": cond_embed,
+        }
+
+        # Simpan minimax_token_tags jika ada
+        token_tags = extra_dict.get("minimax_token_tags", None)
+        if token_tags is not None and isinstance(token_tags, torch.Tensor):
+            tensors["minimax_token_tags"] = token_tags.contiguous().cpu()
+
+        # Simpan minimax_keyframes latents jika ada
+        keyframes_meta = []
+        raw_keyframes = extra_dict.get("minimax_keyframes", None)
+        if raw_keyframes is not None and isinstance(raw_keyframes, list):
+            for i, kf in enumerate(raw_keyframes):
+                kf_entry = {
+                    "resolved_frame_index": int(kf.get("resolved_frame_index", 0))
+                }
+                latent_val = kf.get("latent", None)
+                if latent_val is not None and isinstance(latent_val, torch.Tensor):
+                    tensor_key = f"kf_{i}_latent"
+                    tensors[tensor_key] = latent_val.contiguous().cpu()
+                    kf_entry["tensor_key"] = tensor_key
+                keyframes_meta.append(kf_entry)
+
+        if pooled is not None and isinstance(pooled, torch.Tensor):
+            tensors["cond_pooled"] = pooled.contiguous().cpu()
+
+        metadata = {
+            "prompt": str(prompt_text),
+            "width": str(width),
+            "height": str(height),
+            "length": str(length),
+            "keyframes_meta": json.dumps(keyframes_meta),
+            "shape": str(list(cond_embed.shape)),
+            "format": "comfyui_h3_conditioning_v2",
+        }
+
+        st.save_file(tensors, filepath, metadata=metadata)
+        size_kb = os.path.getsize(filepath) / 1024.0
+        print(f"[*] [Space 1] Safetensors tersimpan: {filepath} ({size_kb:.2f} KB, keyframes: {len(keyframes_meta)})", flush=True)
+
+        return {"ui": {"safetensors_file": [filename]}}
+
+NODE_CLASS_MAPPINGS = {
+    "SaveH3ConditioningSafetensors": SaveH3ConditioningSafetensors
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SaveH3ConditioningSafetensors": "Save H3 Conditioning Safetensors"
+}

requirements.txt

@@ -0,0 +1,28 @@
+--extra-index-url https://download.pytorch.org/whl/cu130
+--extra-index-url https://download.pytorch.org/whl/cu128
+torch
+torchvision
+torchaudio
+torchsde
+spaces
+gradio>=5,<6
+gradio_client>=1.0.0
+huggingface_hub>=0.34.0
+transformers>=4.48.0
+accelerate>=0.26.0
+safetensors
+einops
+scipy
+numpy
+pillow
+psutil
+websocket-client
+spandrel
+kornia
+av
+color-matcher
+matplotlib
+mss
+opencv-python-headless
+imageio
+imageio-ffmpeg

workflow_clip.json

@@ -0,0 +1,152 @@
+{
+  "122": {
+    "inputs": {
+      "image": "first_frame.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "Load First Frame"
+    }
+  },
+  "123": {
+    "inputs": {
+      "image": "last_frame.png"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "Load Last Frame"
+    }
+  },
+  "119": {
+    "inputs": {
+      "upscale_method": "nearest-exact",
+      "megapixels": 0.4,
+      "resolution_steps": 32,
+      "image": [
+        "122",
+        0
+      ]
+    },
+    "class_type": "ImageScaleToTotalPixels",
+    "_meta": {
+      "title": "Scale Image to Total Pixels"
+    }
+  },
+  "120": {
+    "inputs": {
+      "image": [
+        "119",
+        0
+      ]
+    },
+    "class_type": "GetImageSize",
+    "_meta": {
+      "title": "Get Image Size"
+    }
+  },
+  "105_111": {
+    "inputs": {
+      "value": 5.0
+    },
+    "class_type": "PrimitiveFloat",
+    "_meta": {
+      "title": "Float (duration)"
+    }
+  },
+  "105_107": {
+    "inputs": {
+      "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17",
+      "values.a": [
+        "105_111",
+        0
+      ]
+    },
+    "class_type": "ComfyMathExpression",
+    "_meta": {
+      "title": "Math Expression"
+    }
+  },
+  "105_13": {
+    "inputs": {
+      "clip_name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+      "type": "minimax",
+      "device": "default"
+    },
+    "class_type": "CLIPLoader",
+    "_meta": {
+      "title": "Load CLIP"
+    }
+  },
+  "105_11": {
+    "inputs": {
+      "vae_name": "minimax_h3_video_vae_int8_convrot.safetensors"
+    },
+    "class_type": "VAELoader",
+    "_meta": {
+      "title": "Load Video VAE INT8"
+    }
+  },
+  "105_104": {
+    "inputs": {
+      "prompt": "",
+      "width": [
+        "120",
+        0
+      ],
+      "height": [
+        "120",
+        1
+      ],
+      "length": [
+        "105_107",
+        1
+      ],
+      "clip": [
+        "105_13",
+        0
+      ],
+      "vae": [
+        "105_11",
+        0
+      ],
+      "first_frame": [
+        "122",
+        0
+      ],
+      "last_frame": [
+        "123",
+        0
+      ]
+    },
+    "class_type": "MiniMaxH3ImageToVideo",
+    "_meta": {
+      "title": "MiniMax H3 Image to Video"
+    }
+  },
+  "save_h3_cond": {
+    "inputs": {
+      "conditioning": [
+        "105_104",
+        0
+      ],
+      "filename_prefix": "h3_cond",
+      "width": [
+        "120",
+        0
+      ],
+      "height": [
+        "120",
+        1
+      ],
+      "length": [
+        "105_107",
+        1
+      ],
+      "prompt_text": ""
+    },
+    "class_type": "SaveH3ConditioningSafetensors",
+    "_meta": {
+      "title": "Save H3 Conditioning Safetensors"
+    }
+  }
+}