Wire Epic Errands V1 Modal model smoke

.gitattributes

@@ -41,3 +41,9 @@ frontend/assets/sc2-hero-scene-clean.png filter=lfs diff=lfs merge=lfs -text
 frontend/assets/sc2-hero-scene-only.png filter=lfs diff=lfs merge=lfs -text
 frontend/assets/source-sc1.png filter=lfs diff=lfs merge=lfs -text
 frontend/assets/source-sc2.png filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-audio-1-clean-up-my-room-before-dinner-56693c13.wav filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-audio-2-finish-my-class-project-outline-62a0674b.wav filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-audio-3-read-for-20-minutes-5e944b16.wav filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-hero-1-clean-up-my-room-before-dinner-07b300bc.png filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-hero-2-finish-my-class-project-outline-4a8a06bc.png filter=lfs diff=lfs merge=lfs -text
+frontend/assets/generated-hero-3-read-for-20-minutes-3781199a.png filter=lfs diff=lfs merge=lfs -text

epic_errands_space/quest_generation.py

@@ -21,6 +21,18 @@ ASSETS_DIR = FRONTEND_ROOT / "assets"
 CACHE_MANIFEST = ASSETS_DIR / "generated-hero-manifest.json"
 FALLBACK_HERO = "sc2-hero-scene-clean.png"
 MODEL_ID = "black-forest-labs/FLUX.2-klein-9B"
+MINICPM_MODEL_ID = "openbmb/MiniCPM4.1-8B"
+NEMOTRON3_MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+VOXCPM2_MODEL_ID = "openbmb/VoxCPM2"
+NEMOTRON_SPEECH_MODEL_ID = "nvidia/nemotron-speech-streaming-en-0.6b"
+
+THEME_ALIASES = {
+    "quest": "magical",
+    "magical": "magical",
+    "class": "classroom",
+    "classroom": "classroom",
+    "comic": "comic",
+}
 
 STEP_LIBRARY = {
     "project": [
@@ -54,6 +66,11 @@ def default_goal_payload() -> list[dict[str, str]]:
     return [{"id": goal.id, "text": goal.text} for goal in DEFAULT_GOALS]
 
 
+def _theme(value: Any, fallback: str = "magical") -> str:
+    normalized = str(value or fallback).strip().lower()
+    return THEME_ALIASES.get(normalized, fallback)
+
+
 def normalize_goals(raw_goals: Any) -> list[dict[str, str]]:
     goals: list[dict[str, str]] = []
     if isinstance(raw_goals, list):
@@ -66,15 +83,17 @@ def normalize_goals(raw_goals: Any) -> list[dict[str, str]]:
             goals.append({
                 "id": str(item.get("id") or f"goal-{index + 1}"),
                 "text": text,
+                "theme": _theme(item.get("theme") or item.get("style_id"), "magical"),
             })
             if len(goals) == 3:
                 break
 
-    for fallback in default_goal_payload():
+    fallback_themes = ["magical", "classroom", "comic"]
+    for fallback_index, fallback in enumerate(default_goal_payload()):
         if len(goals) == 3:
             break
         if not any(goal["text"].casefold() == fallback["text"].casefold() for goal in goals):
-            goals.append(fallback)
+            goals.append({**fallback, "theme": fallback_themes[fallback_index % len(fallback_themes)]})
 
     return goals[:3]
 
@@ -85,6 +104,12 @@ def generated_file_name(goal: dict[str, str], index: int) -> str:
     return f"generated-hero-{index + 1}-{slug}-{digest}.png"
 
 
+def generated_audio_file_name(goal: dict[str, str], index: int) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", goal["text"].lower()).strip("-")[:36] or f"goal-{index + 1}"
+    digest = hashlib.sha1(f"audio:{goal['id']}:{goal['text']}".encode("utf-8")).hexdigest()[:8]
+    return f"generated-audio-{index + 1}-{slug}-{digest}.wav"
+
+
 def _asset_to_data_uri(file_name: str) -> str:
     path = ASSETS_DIR / file_name
     mime_type = mimetypes.guess_type(path.name)[0] or "image/png"
@@ -119,8 +144,14 @@ def _step_key(goal_text: str) -> str:
     return "default"
 
 
-def _quest_title(goal_text: str, tone: str) -> str:
+def _quest_title(goal_text: str, tone: str, theme: str = "magical") -> str:
     lowered = goal_text.lower()
+    if theme == "classroom":
+        noun = "Quest"
+    elif theme == "comic":
+        noun = "Mission"
+    else:
+        noun = "Quest"
     tone_word = {
         "cozy": "Cozy",
         "brave": "Brave",
@@ -129,12 +160,14 @@ def _quest_title(goal_text: str, tone: str) -> str:
         "epic": "Epic",
     }.get(tone, "Cozy")
     if "project" in lowered or "class" in lowered:
-        return f"{tone_word} Bridge of Bright Ideas"
+        return f"{noun}: Bright Idea Bridge"
     if "read" in lowered:
-        return f"{tone_word} Reading Lantern Quest"
+        return f"{noun}: Reading Lantern"
     if "laundry" in lowered or "clothes" in lowered:
-        return f"{tone_word} Laundry Kingdom Rescue"
-    return f"{tone_word} Quest for {goal_text[:28]}"
+        return f"{noun}: Laundry Launch"
+    if "room" in lowered or "clean" in lowered:
+        return f"{noun}: Tidy Room Rescue"
+    return f"{tone_word} {noun} for {goal_text[:28]}"
 
 
 def _why_it_helps(goal_text: str) -> str:
@@ -145,12 +178,27 @@ def _why_it_helps(goal_text: str) -> str:
 
 
 def _prompt_for_goal(goal: dict[str, str], tone: str) -> str:
+    theme = _theme(goal.get("theme"), "magical")
+    visual_direction = {
+        "magical": (
+            "premium storybook quest card, warm paper, gentle fantasy props, "
+            "earned crest, no monsters or threats"
+        ),
+        "classroom": (
+            "cozy classroom adventure, stickers, notebooks, pencils, sunny desk, "
+            "teacher-approved kid-safe energy"
+        ),
+        "comic": (
+            "bright comic mission panel, bold shapes, action burst composition, "
+            "playful but calm, no readable text"
+        ),
+    }[theme]
     return (
         "A delightful family questbook hero image for a children's "
-        "goal-planning app. Warm handcrafted illustration, parchment storybook "
-        "mood, clear everyday adventure, no readable text, no UI, "
+        "goal-planning app. Warm handcrafted illustration, clear everyday adventure, no readable text, no UI, "
         "kid-safe, expressive, polished. "
-        f"Tone: {tone}. Ordinary goal transformed visually: {goal['text']}."
+        f"Theme: {theme}. Tone: {tone}. Visual direction: {visual_direction}. "
+        f"Ordinary goal transformed visually: {goal['text']}."
     )
 
 
@@ -169,6 +217,44 @@ def _fallback_image_result(goal: dict[str, str], index: int, reason: str) -> dic
     }
 
 
+def _fallback_card_text(goal: dict[str, str], tone: str, reason: str) -> dict[str, Any]:
+    steps = [label for label, _icon in STEP_LIBRARY[_step_key(goal["text"])]][:3]
+    return {
+        "goal_id": goal["id"],
+        "ordinary_goal": goal["text"],
+        "theme": _theme(goal.get("theme"), "magical"),
+        "model_key": "deterministic_fallback",
+        "model_id": "none",
+        "schema_valid": True,
+        "raw_text": "",
+        "card_text": {
+            "title": _quest_title(goal["text"], tone, _theme(goal.get("theme"), "magical")),
+            "narration": f"Your goal card is ready: {goal['text']}. Take it one small step at a time.",
+            "steps": steps,
+            "reward_label": "Quest Hero",
+            "completion_check": "Done when the ordinary goal is truly finished.",
+        },
+        "runtime_metadata": _runtime_metadata(fallback_used=True, fallback_reason=reason),
+    }
+
+
+def _fallback_audio_result(goal: dict[str, str], index: int, reason: str) -> dict[str, Any]:
+    return {
+        "goal_id": goal["id"],
+        "ordinary_goal": goal["text"],
+        "theme": _theme(goal.get("theme"), "magical"),
+        "audio_asset_name": "",
+        "audio_src": "",
+        "spoken_text": "",
+        "runtime_metadata": _runtime_metadata(
+            model_backend="modal_http",
+            model_id=VOXCPM2_MODEL_ID,
+            fallback_used=True,
+            fallback_reason=reason,
+        ),
+    }
+
+
 def _load_manifest() -> dict[str, Any]:
     try:
         return json.loads(CACHE_MANIFEST.read_text(encoding="utf-8"))
@@ -225,7 +311,7 @@ def _cached_images_for(goals: list[dict[str, str]]) -> list[dict[str, Any]] | No
 
 
 def _call_modal(goals: list[dict[str, str]], tone: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-    base_url = os.environ.get("APP_MODAL_BASE_URL", "").strip()
+    base_url = os.environ.get("EPIC_MODAL_IMAGE_URL", "").strip() or os.environ.get("APP_MODAL_BASE_URL", "").strip()
     token = os.environ.get("APP_MODAL_AUTH_TOKEN", "").strip()
     timeout = float(os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "180"))
     if not base_url or not token:
@@ -236,6 +322,7 @@ def _call_modal(goals: list[dict[str, str]], tone: str) -> tuple[list[dict[str,
             {
                 "goal_id": goal["id"],
                 "ordinary_goal": goal["text"],
+                "theme": _theme(goal.get("theme"), "magical"),
                 "prompt": _prompt_for_goal(goal, tone),
                 "seed": 26000 + index,
             }
@@ -300,29 +387,221 @@ def _call_modal(goals: list[dict[str, str]], tone: str) -> tuple[list[dict[str,
     return saved, metadata
 
 
-def _quest_for_goal(goal: dict[str, str], image_result: dict[str, Any], index: int, tone: str) -> dict[str, Any]:
+def _modal_json(url: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
+    token = os.environ.get("APP_MODAL_AUTH_TOKEN", "").strip()
+    if not url or not token:
+        raise RuntimeError("Modal URL and APP_MODAL_AUTH_TOKEN are required.")
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=timeout) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _call_text_model(goals: list[dict[str, str]], model_key: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    base_url = os.environ.get("EPIC_MODAL_TEXT_URL", "").strip()
+    timeout = float(os.environ.get("EPIC_MODAL_TEXT_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
+    if not base_url:
+        raise RuntimeError("EPIC_MODAL_TEXT_URL is required for Modal text generation.")
+    started = time.monotonic()
+    body = _modal_json(
+        base_url,
+        {
+            "model": model_key,
+            "items": [
+                {
+                    "goal_id": goal["id"],
+                    "ordinary_goal": goal["text"],
+                    "theme": _theme(goal.get("theme"), "magical"),
+                }
+                for goal in goals
+            ],
+            "max_new_tokens": 260,
+        },
+        timeout,
+    )
+    latency_ms = int((time.monotonic() - started) * 1000)
+    outputs = body.get("outputs")
+    if not isinstance(outputs, list) or len(outputs) < len(goals):
+        raise RuntimeError(f"Modal text response missing outputs for {model_key}.")
+    metadata = {
+        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
+        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
+        "model_runtime": "modal",
+        "model_backend": body.get("model_backend", "modal_http"),
+        "inference_engine": body.get("inference_engine", "transformers"),
+        "model_artifact_format": body.get("model_artifact_format", "safetensors"),
+        "quantization": body.get("quantization", "bf16"),
+        "model_id": body.get("model_id", MINICPM_MODEL_ID if model_key == "minicpm" else NEMOTRON3_MODEL_ID),
+        "latency_ms": body.get("latency_ms", latency_ms),
+        "fallback_used": bool(body.get("fallback_used", False)),
+    }
+    return outputs[: len(goals)], metadata
+
+
+def _call_voxcpm2(goals: list[dict[str, str]], card_texts: dict[str, dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    base_url = os.environ.get("EPIC_MODAL_VOXCPM2_URL", "").strip()
+    timeout = float(os.environ.get("EPIC_MODAL_SPEECH_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
+    if not base_url:
+        raise RuntimeError("EPIC_MODAL_VOXCPM2_URL is required for Modal VoxCPM2 generation.")
+    started = time.monotonic()
+    body = _modal_json(
+        base_url,
+        {
+            "items": [
+                {
+                    "goal_id": goal["id"],
+                    "ordinary_goal": goal["text"],
+                    "theme": _theme(goal.get("theme"), "magical"),
+                    "narration": str(card_texts.get(goal["id"], {}).get("narration") or ""),
+                }
+                for goal in goals
+            ],
+            "cfg_value": 2.0,
+            "inference_timesteps": 10,
+        },
+        timeout,
+    )
+    latency_ms = int((time.monotonic() - started) * 1000)
+    outputs = body.get("outputs")
+    if not isinstance(outputs, list) or len(outputs) < len(goals):
+        raise RuntimeError("Modal VoxCPM2 response missing outputs.")
+
+    saved: list[dict[str, Any]] = []
+    metadata = {
+        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
+        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
+        "model_runtime": "modal",
+        "model_backend": body.get("model_backend", "modal_http"),
+        "inference_engine": body.get("inference_engine", "voxcpm"),
+        "model_artifact_format": body.get("model_artifact_format", "safetensors"),
+        "quantization": body.get("quantization", "bf16"),
+        "model_id": body.get("model_id", VOXCPM2_MODEL_ID),
+        "latency_ms": body.get("latency_ms", latency_ms),
+        "fallback_used": bool(body.get("fallback_used", False)),
+    }
+    for index, goal in enumerate(goals):
+        output = outputs[index]
+        audio_b64 = output.get("audio_wav_base64")
+        if not audio_b64:
+            raise RuntimeError("Modal VoxCPM2 output missing audio_wav_base64.")
+        audio_bytes = base64.b64decode(audio_b64)
+        asset_name = generated_audio_file_name(goal, index)
+        (ASSETS_DIR / asset_name).write_bytes(audio_bytes)
+        saved.append({
+            "goal_id": goal["id"],
+            "ordinary_goal": goal["text"],
+            "theme": _theme(goal.get("theme"), "magical"),
+            "audio_asset_name": asset_name,
+            "audio_src": f"data:audio/wav;base64,{base64.b64encode(audio_bytes).decode('ascii')}",
+            "audio_wav_base64": audio_b64,
+            "spoken_text": output.get("spoken_text", ""),
+            "sample_rate": output.get("sample_rate"),
+            "runtime_metadata": metadata,
+        })
+    return saved, metadata
+
+
+def _call_nemotron_speech(audio_results: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    base_url = os.environ.get("EPIC_MODAL_NEMOTRON_SPEECH_URL", "").strip()
+    timeout = float(os.environ.get("EPIC_MODAL_ASR_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
+    if not base_url:
+        raise RuntimeError("EPIC_MODAL_NEMOTRON_SPEECH_URL is required for Modal Nemotron Speech ASR.")
+    started = time.monotonic()
+    body = _modal_json(
+        base_url,
+        {
+            "items": [
+                {
+                    "goal_id": item["goal_id"],
+                    "ordinary_goal": item["ordinary_goal"],
+                    "audio_wav_base64": item.get("audio_wav_base64", ""),
+                }
+                for item in audio_results
+            ],
+        },
+        timeout,
+    )
+    latency_ms = int((time.monotonic() - started) * 1000)
+    outputs = body.get("outputs")
+    if not isinstance(outputs, list):
+        raise RuntimeError("Modal Nemotron Speech response missing outputs.")
+    metadata = {
+        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
+        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
+        "model_runtime": "modal",
+        "model_backend": body.get("model_backend", "modal_http"),
+        "inference_engine": body.get("inference_engine", "nemo"),
+        "model_artifact_format": body.get("model_artifact_format", "nemo_archive"),
+        "quantization": body.get("quantization", "bf16"),
+        "model_id": body.get("model_id", NEMOTRON_SPEECH_MODEL_ID),
+        "latency_ms": body.get("latency_ms", latency_ms),
+        "fallback_used": bool(body.get("fallback_used", False)),
+    }
+    return outputs, metadata
+
+
+def _quest_for_goal(
+    goal: dict[str, str],
+    image_result: dict[str, Any],
+    index: int,
+    tone: str,
+    text_results: dict[str, dict[str, Any]] | None = None,
+    secondary_text_results: dict[str, dict[str, Any]] | None = None,
+    audio_results: dict[str, dict[str, Any]] | None = None,
+    asr_results: dict[str, dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     steps = [
         {"id": f"{goal['id']}-step-{step_index + 1}", "label": label, "icon": icon}
         for step_index, (label, icon) in enumerate(STEP_LIBRARY[_step_key(goal["text"])])
     ]
+    theme = _theme(goal.get("theme"), "magical")
+    primary_text = (text_results or {}).get(goal["id"], {})
+    secondary_text = (secondary_text_results or {}).get(goal["id"], {})
+    card_text = primary_text.get("card_text") or _fallback_card_text(goal, tone, "Primary text model did not return card_text.")["card_text"]
+    if isinstance(card_text.get("steps"), list) and card_text["steps"]:
+        steps = [
+            {"id": f"{goal['id']}-step-{step_index + 1}", "label": str(label), "icon": "flag"}
+            for step_index, label in enumerate(card_text["steps"][:4])
+        ]
+    audio = (audio_results or {}).get(goal["id"], {})
+    asr = (asr_results or {}).get(goal["id"], {})
     return {
         "id": f"quest-{goal['id']}",
         "source_goal_id": goal["id"],
         "ordinary_goal": goal["text"],
-        "title": _quest_title(goal["text"], tone),
+        "theme": theme,
+        "title": str(card_text.get("title") or _quest_title(goal["text"], tone, theme)),
         "subtitle": f"Quest {index + 1} of 3",
         "hero_asset_name": image_result["asset_name"],
         "hero_src": image_result.get("hero_src", ""),
         "hero_alt": f"Storybook classroom adventure for {goal['text']}",
         "reward": {
-            "label": ["Idea Builder", "Lantern Reader", "Tidy Hero"][index] if index < 3 else "Quest Hero",
-            "description": "Reward earned after all steps are complete.",
+            "label": str(card_text.get("reward_label") or (["Idea Builder", "Lantern Reader", "Tidy Hero"][index] if index < 3 else "Quest Hero")),
+            "description": str(card_text.get("completion_check") or "Reward earned after all steps are complete."),
         },
         "steps": steps,
+        "narration": str(card_text.get("narration") or ""),
         "why_it_helps": _why_it_helps(goal["text"]),
         "image_origin": image_result.get("origin", "unknown"),
         "prompt_summary": image_result.get("prompt_summary", ""),
         "runtime_metadata": image_result.get("runtime_metadata", _runtime_metadata()),
+        "text_models": {
+            "primary": primary_text,
+            "secondary": secondary_text,
+        },
+        "audio_asset_name": audio.get("audio_asset_name", ""),
+        "audio_src": audio.get("audio_src", ""),
+        "spoken_text": audio.get("spoken_text", ""),
+        "speech_runtime_metadata": audio.get("runtime_metadata", _runtime_metadata()),
+        "asr_transcript": asr.get("transcript", ""),
+        "asr_runtime_metadata": asr.get("runtime_metadata", _runtime_metadata()),
     }
 
 
@@ -352,13 +631,110 @@ def build_quest_pack(payload: dict[str, Any] | None = None, *, use_cache: bool =
             images = [_fallback_image_result(goal, index, blocker) for index, goal in enumerate(goals)]
             metadata = _runtime_metadata(fallback_used=True, fallback_reason=blocker)
 
-    quests = [_quest_for_goal(goal, images[index], index, tone) for index, goal in enumerate(goals)]
+    text_blocker = ""
+    minicpm_results = [_fallback_card_text(goal, tone, "Live text generation is disabled.") for goal in goals]
+    nemotron3_results = [_fallback_card_text(goal, tone, "Live text generation is disabled.") for goal in goals]
+    text_metadata: dict[str, Any] = {}
+    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1":
+        try:
+            minicpm_results, text_metadata["minicpm"] = _call_text_model(goals, "minicpm")
+        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
+            text_blocker = f"MiniCPM {type(exc).__name__}: {exc}"
+            minicpm_results = [_fallback_card_text(goal, tone, text_blocker) for goal in goals]
+        try:
+            nemotron3_results, text_metadata["nemotron3"] = _call_text_model(goals, "nemotron3")
+        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
+            extra = f"Nemotron3 {type(exc).__name__}: {exc}"
+            text_blocker = f"{text_blocker}; {extra}" if text_blocker else extra
+            nemotron3_results = [_fallback_card_text(goal, tone, extra) for goal in goals]
+
+    minicpm_by_id = {item["goal_id"]: item for item in minicpm_results}
+    nemotron3_by_id = {item["goal_id"]: item for item in nemotron3_results}
+
+    audio_blocker = ""
+    audio_results = [_fallback_audio_result(goal, index, "Live speech generation is disabled.") for index, goal in enumerate(goals)]
+    speech_metadata: dict[str, Any] = {}
+    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1":
+        primary_card_texts = {
+            goal_id: result.get("card_text") or {}
+            for goal_id, result in minicpm_by_id.items()
+            if isinstance(result, dict)
+        }
+        try:
+            audio_results, speech_metadata["voxcpm2"] = _call_voxcpm2(goals, primary_card_texts)
+        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
+            audio_blocker = f"VoxCPM2 {type(exc).__name__}: {exc}"
+            audio_results = [_fallback_audio_result(goal, index, audio_blocker) for index, goal in enumerate(goals)]
+
+    asr_results: list[dict[str, Any]] = []
+    asr_blocker = ""
+    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1" and any(item.get("audio_wav_base64") for item in audio_results):
+        try:
+            asr_results, speech_metadata["nemotron_speech"] = _call_nemotron_speech(audio_results)
+        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
+            asr_blocker = f"Nemotron Speech {type(exc).__name__}: {exc}"
+
+    audio_by_id = {item["goal_id"]: item for item in audio_results}
+    asr_by_id = {
+        item["goal_id"]: {
+            **item,
+            "runtime_metadata": speech_metadata.get("nemotron_speech", _runtime_metadata(
+                model_backend="modal_http",
+                model_id=NEMOTRON_SPEECH_MODEL_ID,
+                fallback_used=True,
+                fallback_reason=asr_blocker or "Nemotron Speech ASR was not run.",
+            )),
+        }
+        for item in asr_results
+        if isinstance(item, dict) and item.get("goal_id")
+    }
+
+    quests = [
+        _quest_for_goal(
+            goal,
+            images[index],
+            index,
+            tone,
+            text_results=minicpm_by_id,
+            secondary_text_results=nemotron3_by_id,
+            audio_results=audio_by_id,
+            asr_results=asr_by_id,
+        )
+        for index, goal in enumerate(goals)
+    ]
+    any_text_fallback = any(
+        bool(item.get("runtime_metadata", {}).get("fallback_used", False))
+        or bool(item.get("validation_error"))
+        for item in [*minicpm_results, *nemotron3_results]
+        if isinstance(item, dict)
+    )
+    any_audio_fallback = any(
+        bool(item.get("runtime_metadata", {}).get("fallback_used", False))
+        for item in audio_results
+        if isinstance(item, dict)
+    )
+    any_asr_fallback = bool(asr_blocker) or (
+        os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1"
+        and bool(audio_results)
+        and not asr_results
+    )
+
     return {
         "goals": goals,
         "quests": quests,
         "runtime_metadata": metadata,
-        "fallback_used": any(bool(quest["runtime_metadata"].get("fallback_used", True)) for quest in quests),
-        "blocker": blocker,
+        "model_runs": {
+            "image": metadata,
+            "text": text_metadata,
+            "speech": speech_metadata,
+        },
+        "fallback_used": (
+            any(bool(quest["runtime_metadata"].get("fallback_used", True)) for quest in quests)
+            or any_text_fallback
+            or any_audio_fallback
+            or any_asr_fallback
+        ),
+        "blocker": "; ".join(part for part in [blocker, text_blocker, audio_blocker, asr_blocker] if part),
         "generated_at": datetime.now(timezone.utc).isoformat(),
     }
 

frontend/assets/generated-audio-1-clean-up-my-room-before-dinner-56693c13.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52b5cef22f4556f7cb181a6dec7383f5df848cf7bb4d8b97780a0ffe8d91682b
+size 445484

frontend/assets/generated-audio-2-finish-my-class-project-outline-62a0674b.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d91ef4c89158b69585ce0d457a784fd9664e0c5b1f8889159678d9e9259fd69b
+size 568364

frontend/assets/generated-audio-3-read-for-20-minutes-5e944b16.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:425f6bc70db9b75fdd6b4c0209737ea59181dfd72fd50fc6a1cea249f764490b
+size 537644