fix: sync DiT Linear precision diagnostics from PR #28

Sync the final precision-reporting changes from upstream ca17e1d. Report
installed FP8 Linear counts and configured base precision, preserve lazy
conversion states, and use one post-denoise reporting hook for eager and
CUDA graph execution. Keep the existing ZeroGPU entry point and integration.

Validation outside the repository:
- 10 CPU/runtime checks passed.
- All four image/text FP8 flag combinations passed small-model CUDA
forwards and CUDA graph capture/replay; logging preserved eager output.
- Changed files match upstream byte-for-byte; syntax and diff checks pass.

No test files are included in this commit.

xvideo/fp8_status.py

@@ -0,0 +1,66 @@
+"""Dependency-free helpers for reporting DiT Linear quantization state."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+
+_STREAMS = ("img", "txt")
+
+
+def fp8_precision_status(
+    transformer: Any,
+    requested_by_stream: Mapping[str, bool],
+    *,
+    base_precision: str,
+) -> dict[str, dict[str, Any]]:
+    """Return requested and installed FP8 Linear state for each DiT stream.
+
+    FP8 weights are installed lazily during block forwards, so a requested
+    stream with no converted blocks is pending. Unconverted streams use the
+    configured base precision; this does not describe every DiT operator.
+    """
+    blocks = tuple(getattr(transformer, "double_blocks", ()))
+    total_blocks = len(blocks)
+    result: dict[str, dict[str, Any]] = {}
+
+    for stream in _STREAMS:
+        requested = bool(requested_by_stream.get(stream, False))
+        installed_blocks = sum(
+            bool(getattr(block, f"_fp8_{stream}_installed", False))
+            for block in blocks
+        )
+        if total_blocks == 0:
+            effective = "unknown"
+        elif installed_blocks == total_blocks:
+            effective = "fp8"
+        elif installed_blocks:
+            effective = "mixed"
+        elif requested:
+            effective = "pending"
+        else:
+            effective = base_precision
+        result[stream] = {
+            "requested": requested,
+            "effective": effective,
+            "installed_blocks": installed_blocks,
+            "total_blocks": total_blocks,
+        }
+
+    return result
+
+
+def format_fp8_precision_status(status: Mapping[str, Mapping[str, Any]]) -> str:
+    """Format per-stream status for a concise runtime log line."""
+    parts = []
+    for stream in _STREAMS:
+        item = status[stream]
+        effective = item["effective"]
+        requested = "yes" if item["requested"] else "no"
+        installed = item["installed_blocks"]
+        total = item["total_blocks"]
+        parts.append(
+            f"{stream}={effective} (requested={requested}; FP8 blocks={installed}/{total})"
+        )
+    return "DiT Linear precision: " + ", ".join(parts)

xvideo/models/dit/dit.py

@@ -9,6 +9,8 @@ import torch.nn as nn
 import torch.nn.functional as F
 from torch.nn.attention import SDPBackend, sdpa_kernel
 
+from xvideo.fp8_status import format_fp8_precision_status, fp8_precision_status
+
 
 from diffusers.models import ModelMixin
 from diffusers.configuration_utils import ConfigMixin, register_to_config
@@ -103,6 +105,16 @@ def _fp8_stream_enabled(block, stream: str) -> bool:
     return bool(getattr(block, f"_fp8_{stream}_installed", False))
 
 
+def fp8_precision_report(transformer, *, base_precision: str) -> tuple[dict, str]:
+    """Return DiT Linear FP8 state and its runtime summary."""
+    status = fp8_precision_status(
+        transformer,
+        {stream: _fp8_stream_wanted(stream) for stream in ("img", "txt")},
+        base_precision=base_precision,
+    )
+    return status, format_fp8_precision_status(status)
+
+
 
 from xvideo.models.dit import sgl_fused_ops as _sgl_fused
 

xvideo/serving/joyomni_streaming.py

@@ -206,6 +206,25 @@ class JoyOmniRuntime:
         self.lossless_output = False
         self.graph_runners: dict[tuple, StreamingGraphRunner] = {}
         self.graph_capture_failures: dict[tuple, int] = {}
+        self._last_dit_precision_summary: str | None = None
+        self._dit_precision_settled = False
+
+    def _log_dit_precision(self) -> None:
+        if self._dit_precision_settled:
+            return
+
+        from xvideo.models.dit.dit import fp8_precision_report
+
+        status, summary = fp8_precision_report(
+            self.pipeline.transformer, base_precision=self.cfg.dit_precision,
+        )
+        if summary != self._last_dit_precision_summary:
+            print(f"#####[STREAM] {summary}", flush=True)
+            self._last_dit_precision_summary = summary
+        self._dit_precision_settled = all(
+            stream_status["effective"] in {"fp8", self.cfg.dit_precision}
+            for stream_status in status.values()
+        )
 
     @classmethod
     def load(
@@ -358,6 +377,8 @@ class JoyOmniRuntime:
             for (_wh, _ww) in _orientations:
                 runtime.warmup_full_pipeline(height=_wh, width=_ww)
 
+        runtime._log_dit_precision()
+
         if device_obj.type == "cuda":
             _free_b, _total_b = torch.cuda.mem_get_info(device_obj)
             print(
@@ -1471,6 +1492,7 @@ class JoyOmniV2VStreamingSession:
                             chunk_idx=encoded.job.chunk_idx,
                             frozen_anchor_id=encoded.job.frozen_anchor_id,
                         )
+                        self.runtime._log_dit_precision()
                         self._evict_after_store(
                             encoded.job.chunk_idx,
                             frozen_anchor_id=encoded.job.frozen_anchor_id,