Upload app.py with huggingface_hub

app.py

@@ -269,15 +269,19 @@ def _threaded_broadcast(system_prompt: str, should_continue, **kwargs):
         yield item
 
 
-def _stream_model_cached(cache_key: str, system_prompt: str, should_continue=None, **kwargs):
+def _stream_model_cached(
+    cache_key: str, system_prompt: str, should_continue=None, use_prebaked=True, **kwargs
+):
     def superseded():
         return should_continue is not None and not should_continue()
 
     # Pre-baked broadcasts are served instantly, no model call, no cold wait.
-    prebaked = _PREBAKED.get(cache_key)
-    if prebaked:
-        yield from _stream_fixed(prebaked, char_delay=0.018, should_continue=should_continue)
-        return
+    # Live mode passes use_prebaked=False to force a fresh generation instead.
+    if use_prebaked:
+        prebaked = _PREBAKED.get(cache_key)
+        if prebaked:
+            yield from _stream_fixed(prebaked, char_delay=0.018, should_continue=should_continue)
+            return
 
     cached = _broadcast_cache.get(cache_key)
     if cached:
@@ -321,19 +325,30 @@ def _norm_variant(variant) -> int:
 # queue (that froze "the other stations" when retuning fast). Real generation
 # stays serialized by model._gen_lock.
 @app.api(name="tune", concurrency_limit=2, stream_every=0.02)
-def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
+def tune(frequency: float, language: str = "es", variant: float = 0, live: float = 0) -> str:
     """Tunes a frequency and streams the broadcast (SSE).
 
     `variant` is a per-listener session nonce. For the encrypted station it
-    drives that listener's unique cipher (kept fully per-session). For the
-    spoken stations and the cursed signal it selects one of POOL_SIZE pre-baked
-    editions (`pool`), so different visitors still hear different wordings while
-    every edition is served instantly from the pre-baked cache.
+    drives that listener's unique cipher (kept fully per-session).
+
+    `live` is the UI mode toggle. When off (default), the spoken stations and
+    the cursed signal are served from the pre-baked pool (`pool`): instant, and
+    different visitors still get different editions. When on, the broadcast is
+    generated fresh by the model right now, using the real per-listener variant,
+    so a visitor can watch the AI write the transmission token by token.
     """
     frequency = float(frequency)
     lang = normalize_lang(language)
     var = _norm_variant(variant)
     pool = var % POOL_SIZE
+    try:
+        live_mode = bool(float(live))
+    except (TypeError, ValueError):
+        live_mode = False
+    # Live mode: generate fresh (real variant, skip the pre-baked pool).
+    # Fast mode: pooled key that hits the pre-baked cache instantly.
+    key_var = var if live_mode else pool
+    use_prebaked = not live_mode
     my_epoch = _next_tune_epoch()
 
     def still_current():
@@ -347,12 +362,13 @@ def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
     # The unsolvable station: the model broadcasts, the frontend never cleans it.
     if abs(frequency - CURSED_FREQUENCY) <= STATION_TOLERANCE:
         yield from _stream_model_cached(
-            f"cursed:{CURSED_FREQUENCY}:{lang}:{pool}",
+            f"cursed:{CURSED_FREQUENCY}:{lang}:{key_var}",
             localized_system_prompt(CURSED_SYSTEM_PROMPT, "es", lang),
             should_continue=still_current,
             user_prompt=localized_user_prompt(None, lang),
-            seed=_mix_seed(station_seed(CURSED_FREQUENCY), pool),
+            seed=_mix_seed(station_seed(CURSED_FREQUENCY), key_var),
             max_tokens=160,
+            use_prebaked=use_prebaked,
         )
         return
 
@@ -370,11 +386,12 @@ def tune(frequency: float, language: str = "es", variant: float = 0) -> str:
         return
 
     yield from _stream_model_cached(
-        f"station:{canonical}:{lang}:{pool}",
+        f"station:{canonical}:{lang}:{key_var}",
         station_system_prompt(canonical, lang),
         should_continue=still_current,
         user_prompt=localized_user_prompt(station, lang),
-        seed=_mix_seed(station_seed(canonical), pool),
+        seed=_mix_seed(station_seed(canonical), key_var),
+        use_prebaked=use_prebaked,
     )