Update ui/chat_engine.py

ui/chat_engine.py

@@ -25,9 +25,10 @@ counts.
 import random
 import threading
 import time
+import traceback
 
 from ui.constants import SONIC_QUOTES
-from ui.gpu import ON_ZEROGPU, vectorize_on_gpu
+from ui.gpu import ON_ZEROGPU, cuda_state, vectorize_on_gpu
 from ui.papers import resolve_and_download_pdf
 from ui.sonic import SONIC_DATA_URI
 
@@ -48,6 +49,34 @@ def _quote_at(quotes, start):
     return quotes[int((time.time() - start) // 4) % len(quotes)]
 
 
+# --- error reporting --------------------------------------------------------
+
+def describe_exception(e: BaseException) -> str:
+    """Flatten a whole exception chain into one readable line.
+
+    `f"{type(e).__name__}: {e}"` is lossy the moment anything wraps anything,
+    and that is precisely what cost us a debugging session: ZeroGPU marshals a
+    worker-side failure back to the caller as a `gradio.exceptions.Error` whose
+    payload is just the *name* of the original class. The naive format rendered
+    that as the useless string
+
+        Couldn't read this paper: Error: 'RuntimeError'
+
+    — a wrapper around a wrapper, with the real traceback discarded. Walking
+    __cause__/__context__ keeps the causal chain, and the callers below print
+    the traceback too, since only that names the failing frame.
+    """
+    parts: list[str] = []
+    seen: set[int] = set()
+    current: BaseException | None = e
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        text = str(current).strip()
+        parts.append(f"{type(current).__name__}: {text}" if text else type(current).__name__)
+        current = current.__cause__ or current.__context__
+    return "  <-  ".join(parts)
+
+
 # --- phase workers (touch no UI) -------------------------------------------
 
 def _download_blocking(record: dict, holder: dict):
@@ -59,14 +88,21 @@ def _download_blocking(record: dict, holder: dict):
             return
         holder["pdf_path"] = pdf_path
     except Exception as e:
-        holder["error"] = f"Couldn't fetch this paper: {type(e).__name__}: {e}"
+        traceback.print_exc()
+        holder["error"] = f"Couldn't fetch this paper: {describe_exception(e)}"
 
 
 def _vectorize_blocking(pdf_path: str, holder: dict):
+    # The decisive log line. If CUDA is already initialised *here*, in the
+    # parent, the ZeroGPU fork about to happen is already doomed — see the
+    # CUDA-VIRGINITY RULE in ui/gpu.py.
+    print(cuda_state("pre-gpu-call"), flush=True)
     try:
         vectorize_on_gpu(pdf_path)
     except Exception as e:
-        holder["error"] = f"Couldn't read this paper: {type(e).__name__}: {e}"
+        traceback.print_exc()
+        print(cuda_state("post-gpu-failure"), flush=True)
+        holder["error"] = f"Couldn't read this paper: {describe_exception(e)}"
 
 
 def _assemble_session(pdf_path: str) -> dict:
@@ -142,7 +178,8 @@ def prepare_chat_stream(record: dict):
     try:
         session = _assemble_session(pdf_path)
     except Exception as e:
-        yield fail(f"Couldn't prepare this paper for chat: {type(e).__name__}: {e}")
+        traceback.print_exc()
+        yield fail(f"Couldn't prepare this paper for chat: {describe_exception(e)}")
         return
 
     yield vec_loading_html(quotes[0], "Ready.", 100), True, session, None