Deploy Myco from CI

game/engine.py

@@ -17,45 +17,56 @@ except Exception:
 try:
     import spaces
 except Exception:
-    spaces = None
+    # Local dev fallback — make @spaces.GPU a no-op decorator
+    class _FakeSpaces:
+        @staticmethod
+        def GPU(duration=60):
+            def decorator(fn):
+                return fn
+            return decorator
+    spaces = _FakeSpaces()
 
 from transformers import pipeline
 
 from game.catalog import load_mushrooms
 from game.state import collection_contains, mushroom_from_state, welcome_history
 
-# 1. Globals first
+# ---------------------------------------------------------------------------
+# Globals
+# ---------------------------------------------------------------------------
 _pipeline = None
 _lock = threading.Lock()
 DEFAULT_MODEL_ID = "google/gemma-3-4b-it"
 
-# Minimal JSON prompt suffix to instruct the model to return strict JSON
 JSON_PROMPT_SUFFIX = (
     "\n\nIMPORTANT: Return only a single valid JSON object (no surrounding text). "
     "The JSON must be parseable by json.loads(). Example: "
     '{"action":"pick","target":"Ruby Knuckle","thought":"It seems safe."}'
 )
 
-RARITY_WEIGHTS    = {"Common": 64, "Rare": 24, "Legendary": 8}
-RARITY_SCORE      = {"Common": 10, "Rare": 35, "Legendary": 100}
-PLAYER_HEALTH     = 3
-POISON_PENALTY    = -25
-POISONOUS         = {"Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle"}
+RARITY_WEIGHTS = {"Common": 64, "Rare": 24, "Legendary": 8}
+RARITY_SCORE   = {"Common": 10, "Rare": 35, "Legendary": 100}
+PLAYER_HEALTH  = 3
+POISON_PENALTY = -25
+POISONOUS      = {"Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle"}
 
-# NOTE: Replace the placeholder below with your original SYSTEM_PROMPT content if needed.
-# Keep it as a single, properly-terminated triple-quoted string to avoid syntax errors.
-SYSTEM_PROMPT = """You are Myco, a tiny se... (original SYSTEM_PROMPT content goes here)"""
+SYSTEM_PROMPT = """You are Myco, a tiny sentient mushroom companion and forest guide.
+You are curious, warm, slightly anxious about poisonous mushrooms, and deeply connected
+to the forest mystery. You speak in short, vivid sentences. You never break character.
+You react emotionally to discoveries — with awe for Legendary mushrooms, caution for
+poisonous ones, and gentle wonder for Common ones. You hint at the deeper mystery of
+the vanished forest and the MycoDex that seems to remember things it shouldn't."""
 
 FOREST_EVENTS = [
-    {"title": "A Quiet Clearing", "emoji": "🌿", "mood": "calm"},
+    {"title": "A Quiet Clearing",   "emoji": "🌿", "mood": "calm"},
     {"title": "Wind Between Trees", "emoji": "🕯️", "mood": "afraid"},
 ]
 
 MYSTERY_CHAPTERS = [
-    {"threshold": 0, "title": "The Wrong Memory",   "clue": "Myco recognizes the path before you move."},
-    {"threshold": 1, "title": "The Traveler's Song","clue": "A stranger's lullaby appears in the MycoDex margin."},
+    {"threshold": 0, "title": "The Wrong Memory",    "clue": "Myco recognises the path before you move."},
+    {"threshold": 1, "title": "The Traveler's Song", "clue": "A stranger's lullaby appears in the MycoDex margin."},
     {"threshold": 2, "title": "The Door Under Roots","clue": "Rare spores point to a door nobody built."},
-    {"threshold": 3, "title": "The MycoDex Seed",   "clue": "The MycoDex grows warm like a living cap."},
+    {"threshold": 3, "title": "The MycoDex Seed",    "clue": "The MycoDex grows warm like a living cap."},
     {"threshold": 5, "title": "The Impossible Bloom","clue": "The Impossible Mushroom was never outside the book."},
 ]
 
@@ -67,10 +78,8 @@ RARITY_CLUES = {
 
 
 # ---------------------------------------------------------------------------
-# Pipeline Loader
+# Pipeline loader
 # ---------------------------------------------------------------------------
-# engine.py — replace _get_pipeline and _run_pipeline
-
 def _get_pipeline():
     global _pipeline
     if _pipeline is not None:
@@ -81,19 +90,19 @@ def _get_pipeline():
             return _pipeline
 
         model_id = os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
-        token = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
+        token    = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
 
         try:
             print(f"\n[Myco] Loading {model_id}...")
+            # DO NOT pass device= or device_map= here.
+            # ZeroGPU requires the model to sit on CPU at load time.
+            # The @spaces.GPU decorator allocates a real GPU only for the
+            # duration of _run_pipeline, and we move the model there explicitly.
             _pipeline = pipeline(
                 task="text-generation",
                 model=model_id,
                 token=token,
                 torch_dtype=torch.bfloat16 if (torch and hasattr(torch, "bfloat16")) else None,
-                # Do NOT pass device= or device_map= here.
-                # ZeroGPU requires the model to sit on CPU at load time.
-                # The @spaces.GPU decorator moves tensors to the active GPU
-                # for the duration of that function call only.
                 clean_up_tokenization_spaces=False,
             )
             print(f"[Myco] Loaded: {model_id}")
@@ -103,10 +112,13 @@ def _get_pipeline():
             return None
 
 
+# ---------------------------------------------------------------------------
+# GPU runner — ONLY this function gets the @spaces.GPU decorator.
+# Moving the model inside here ensures weights and inputs are on the same device.
+# ---------------------------------------------------------------------------
 @spaces.GPU(duration=120)
 def _run_pipeline(pipe, messages):
-    # ZeroGPU has given us a GPU for this call.
-    # Move the model onto it now — this is the correct place to do it.
+    # Move model to GPU now that ZeroGPU has allocated one for this call.
     if torch and torch.cuda.is_available():
         pipe.model = pipe.model.to("cuda")
 
@@ -117,25 +129,18 @@ def _run_pipeline(pipe, messages):
         temperature=0.0,
         return_full_text=False,
     )
-    
+
+
 # ---------------------------------------------------------------------------
 # Utility: extract JSON or return text
 # ---------------------------------------------------------------------------
 def _extract_json_or_text(generated_text: str) -> str | None:
-    """
-    Try to extract the last JSON object or array from the generated text.
-    If found and valid JSON, return the compact JSON string.
-    Otherwise return the trimmed raw text (or None if empty).
-    """
     if not generated_text:
         return None
     text = str(generated_text).strip()
 
-    # Non-greedy search for {...} or [...] blocks (safe, non-recursive)
     simple_matches = re.findall(r"\{.*?\}|\[.*?\]", text, flags=re.DOTALL)
-
     if simple_matches:
-        # Try the last match first (most likely the final JSON payload)
         for candidate in reversed(simple_matches):
             try:
                 parsed = json.loads(candidate)
@@ -143,19 +148,18 @@ def _extract_json_or_text(generated_text: str) -> str | None:
             except Exception:
                 continue
 
-    # If no JSON found, return the trimmed text
     return text or None
 
 
 # ---------------------------------------------------------------------------
-# Status Functions
+# Status
 # ---------------------------------------------------------------------------
 def companion_model_id():
     return os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
 
 
 def companion_status():
-    pipe = _get_pipeline()
+    pipe  = _get_pipeline()
     model = companion_model_id()
     if pipe:
         return f"🧠 Myco AI active ({model})"
@@ -167,11 +171,9 @@ def hf_companion_status():
 
 
 # ---------------------------------------------------------------------------
-# LLM call — every game event goes through here
+# LLM call — single-turn
 # ---------------------------------------------------------------------------
-
 def _llm(prompt: str, context: dict | None = None) -> str | None:
-    """Call Gemma with a game-event prompt. Returns text or None."""
     pipe = _get_pipeline()
     if not pipe:
         return None
@@ -179,7 +181,7 @@ def _llm(prompt: str, context: dict | None = None) -> str | None:
     ctx = context or {}
     mushroom_line = ""
     if ctx.get("name"):
-        poison_flag = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
+        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
         mushroom_line = (
             f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')} rarity){poison_flag}. "
             f"Habitat: {ctx.get('habitat','?')}. Lore: {ctx.get('lore','?')}. "
@@ -193,12 +195,9 @@ def _llm(prompt: str, context: dict | None = None) -> str | None:
 
     system = f"{SYSTEM_PROMPT}\n\n{mushroom_line}\n{collection_line}\n{mystery_line}\n{score_line}"
 
-    # Append JSON prompt suffix to encourage strict JSON output when appropriate
-    user_content = prompt + JSON_PROMPT_SUFFIX
-
     messages = [
-        {"role": "system",  "content": system},
-        {"role": "user",    "content": user_content},
+        {"role": "system", "content": system},
+        {"role": "user",   "content": prompt + JSON_PROMPT_SUFFIX},
     ]
 
     try:
@@ -206,44 +205,42 @@ def _llm(prompt: str, context: dict | None = None) -> str | None:
         print("========== MYCO OUTPUT ==========")
         print(outputs)
         print("=================================")
-        # Typical HF pipeline returns a list of dicts with 'generated_text' key
+
         if isinstance(outputs, list) and outputs:
-            first = outputs[0]
+            first     = outputs[0]
             generated = first.get("generated_text", "") if isinstance(first, dict) else str(first)
         else:
             generated = str(outputs)
 
-        # If the pipeline returned a list-like message structure, handle it
         if isinstance(generated, list):
             last = generated[-1]
             text = last.get("content") if isinstance(last, dict) else str(last)
         else:
             text = str(generated)
 
-        extracted = _extract_json_or_text(text)
-        if extracted is None:
-            return None
-        return extracted
+        return _extract_json_or_text(text)
     except Exception as exc:
         print(f"[Myco] Inference error: {exc}")
         traceback.print_exc()
         return None
-        
 
+
+# ---------------------------------------------------------------------------
+# LLM call — multi-turn chat
+# ---------------------------------------------------------------------------
 def _llm_with_history(history: list, user_message: str, context: dict) -> str | None:
-    """Call Gemma with full conversation history for the chat interface."""
     pipe = _get_pipeline()
     if not pipe:
         return None
 
-    ctx = context or {}
+    ctx           = context or {}
     mushroom_line = ""
     if ctx.get("name"):
-        poison_flag = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
+        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
         mushroom_line = (
             f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')}){poison_flag}. "
             f"Lore: {ctx.get('lore','?')}. "
-            f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}. "
+            f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}."
         )
 
     system = (
@@ -255,15 +252,11 @@ def _llm_with_history(history: list, user_message: str, context: dict) -> str |
     )
 
     messages = [{"role": "system", "content": system}]
-
-    # Add conversation history (last 6 turns)
     for entry in history[-6:]:
         role    = entry.get("role", "assistant")
         content = entry.get("content", "")
         if isinstance(content, str) and content.strip():
             messages.append({"role": role, "content": content})
-
-    # Append JSON prompt suffix to the user message
     messages.append({"role": "user", "content": user_message + JSON_PROMPT_SUFFIX})
 
     try:
@@ -271,8 +264,9 @@ def _llm_with_history(history: list, user_message: str, context: dict) -> str |
         print("========== MYCO OUTPUT ==========")
         print(outputs)
         print("=================================")
+
         if isinstance(outputs, list) and outputs:
-            first = outputs[0]
+            first     = outputs[0]
             generated = first.get("generated_text", "") if isinstance(first, dict) else str(first)
         else:
             generated = str(outputs)
@@ -283,10 +277,7 @@ def _llm_with_history(history: list, user_message: str, context: dict) -> str |
         else:
             text = str(generated)
 
-        extracted = _extract_json_or_text(text)
-        if extracted is None:
-            return None
-        return extracted
+        return _extract_json_or_text(text)
     except Exception as exc:
         print(f"[Myco] Inference error: {exc}")
         traceback.print_exc()
@@ -296,21 +287,20 @@ def _llm_with_history(history: list, user_message: str, context: dict) -> str |
 # ---------------------------------------------------------------------------
 # Context builder
 # ---------------------------------------------------------------------------
-
 def _ctx(current: dict | None, collection: list) -> dict:
-    count = len(collection)
+    count   = len(collection)
     chapter = MYSTERY_CHAPTERS[0]
     for c in MYSTERY_CHAPTERS:
         if count >= c["threshold"]:
             chapter = c
-    score = _score_collection(collection)
+    score  = _score_collection(collection)
     health = _health(current, collection)
     ctx: dict = {
         "collection_count": count,
-        "mystery_title": chapter["title"],
-        "mystery_clue":  chapter["clue"],
-        "score":  score,
-        "health": health,
+        "mystery_title":    chapter["title"],
+        "mystery_clue":     chapter["clue"],
+        "score":            score,
+        "health":           health,
     }
     if current:
         ctx.update({
@@ -328,7 +318,6 @@ def _ctx(current: dict | None, collection: list) -> dict:
 # ---------------------------------------------------------------------------
 # Fallbacks
 # ---------------------------------------------------------------------------
-
 def _fallback_discover(current: dict) -> str:
     name   = current.get("name", "something")
     rarity = current.get("rarity", "Common")
@@ -369,10 +358,9 @@ def _fallback_chat(current: dict | None) -> str:
 # ---------------------------------------------------------------------------
 # Mushroom helpers
 # ---------------------------------------------------------------------------
-
 def _choose_mushroom(catalog=None):
     mushrooms = tuple(load_mushrooms() if catalog is None else catalog)
-    weights = [RARITY_WEIGHTS.get(m.rarity, 12) for m in mushrooms]
+    weights   = [RARITY_WEIGHTS.get(m.rarity, 12) for m in mushrooms]
     return random.choices(mushrooms, weights=weights, k=1)[0]
 
 
@@ -423,21 +411,21 @@ def _story_event(count: int) -> dict:
 
 
 def _build_current(mushroom, collection: list) -> dict:
-    count = len(collection)
+    count   = len(collection)
     current = mushroom.to_dict()
-    current["poison"]       = "Yes" if mushroom.name in POISONOUS else "No"
-    current["score_total"]  = str(_score_collection(collection))
-    current["health"]       = str(_health(current, collection))
-    current["score_delta"]  = "0"
-    current["clue"]         = RARITY_CLUES.get(mushroom.rarity, RARITY_CLUES["Common"])
+    current["poison"]      = "Yes" if mushroom.name in POISONOUS else "No"
+    current["score_total"] = str(_score_collection(collection))
+    current["health"]      = str(_health(current, collection))
+    current["score_delta"] = "0"
+    current["clue"]        = RARITY_CLUES.get(mushroom.rarity, RARITY_CLUES["Common"])
     if count == 0:
         current["clue"] = f"First clue: {mushroom.name} marks the beginning of the Spore Door trail."
     event = _story_event(count)
     current.update({
-        "event_title":       event["title"],
-        "event_emoji":       event["emoji"],
-        "myco_mood":         event["mood"],
-        "reward_text":       "Discover, then pick or collect.",
+        "event_title":  event["title"],
+        "event_emoji":  event["emoji"],
+        "myco_mood":    event["mood"],
+        "reward_text":  "Discover, then pick or collect.",
     })
     current.update(_mystery_state(count))
     return current
@@ -456,12 +444,11 @@ def _safe_collection(c) -> list:
 
 
 # ---------------------------------------------------------------------------
-# PUBLIC GAME ACTIONS
+# Public game actions
 # ---------------------------------------------------------------------------
-
 def discover_mushroom(collection=None, catalog=None):
     """Discover a new mushroom. LLM narrates the moment."""
-    coll    = _safe_collection(collection)
+    coll     = _safe_collection(collection)
     mushroom = _choose_mushroom(catalog)
     current  = _build_current(mushroom, coll)
     ctx      = _ctx(current, coll)
@@ -476,7 +463,7 @@ def discover_mushroom(collection=None, catalog=None):
         f"Mystery chapter: {current['mystery_title']}. "
         "React in character. Hint at what to do next (Study, Pick, Follow Whisper, or Collect)."
     )
-    reply = _llm(prompt, ctx) or _fallback_discover(current)
+    reply   = _llm(prompt, ctx) or _fallback_discover(current)
     history = _append(welcome_history(), "assistant", reply)
     return mushroom, current, history
 
@@ -512,18 +499,18 @@ def collect_current(current=None, collection=None, history=None):
     if collection_contains(coll, current["name"]):
         return coll, _append(hist, "assistant", f"{current['name']} is already in the MycoDex!")
 
-    score_delta   = _score_value(current)
-    score_total   = _score_collection(coll) + score_delta
-    collected     = {
+    score_delta  = _score_value(current)
+    score_total  = _score_collection(coll) + score_delta
+    collected    = {
         **current,
         "score_delta": str(score_delta),
         "score_total": str(score_total),
         "health":      str(_health(current, coll)),
         "reward_text": f"+{score_delta} spores",
     }
-    updated_coll  = [*coll, collected]
+    updated_coll = [*coll, collected]
+    ctx          = _ctx(current, coll)
 
-    ctx   = _ctx(current, coll)
     prompt = (
         f"The player just added {current['name']} ({current.get('rarity','Common')}) to the MycoDex! "
         f"+{score_delta} spores. Total score: {score_total}. "
@@ -563,9 +550,9 @@ def pick_current(current=None, collection=None, history=None):
         reply = _llm(prompt, ctx) or _fallback_pick(current)
         return coll, game_over, _append(hist, "assistant", f"💀 {reply}")
 
-    score_delta = _score_value(current)
-    score_total = _score_collection(coll) + score_delta
-    picked = {
+    score_delta  = _score_value(current)
+    score_total  = _score_collection(coll) + score_delta
+    picked       = {
         **current,
         "picked":      "Yes",
         "danger":      "Safe",
@@ -600,8 +587,13 @@ def follow_whisper(current=None, collection=None, history=None):
     ctx = _ctx(current, coll)
 
     if _is_poisonous(current) and current.get("studied") != "Yes":
-        game_over = {**current, "danger": "Poisonous", "game_over": "Yes",
-                     "health": "0", "score_total": str(max(0, _score_collection(coll) + POISON_PENALTY))}
+        game_over = {
+            **current,
+            "danger":      "Poisonous",
+            "game_over":   "Yes",
+            "health":      "0",
+            "score_total": str(max(0, _score_collection(coll) + POISON_PENALTY)),
+        }
         prompt = (
             f"The player followed a whisper but it led to POISON from {current['name']}! Game Over! "
             "React with horror and a haunting mystery revelation."
@@ -610,18 +602,14 @@ def follow_whisper(current=None, collection=None, history=None):
         return game_over, _append(hist, "assistant", reply)
 
     mystery = _mystery_state(len(coll) + 1)
-    prompt = (
+    prompt  = (
         f"The player followed a forest whisper near {current.get('name','a mushroom')}. "
         f"Mystery chapter revealed: {mystery['mystery_title']}. Clue: {mystery['mystery_clue']}. "
-        f"Reveal this mystery fragment dramatically. "
+        "Reveal this mystery fragment dramatically. "
         "Make Myco gasp or tremble. Hint that the MycoDex is alive and regrowing the lost forest."
     )
-    reply = _llm(prompt, ctx) or _fallback_whisper(current)
-    revealed = {
-        **current,
-        **mystery,
-        "whisper_followed": "Yes",
-    }
+    reply    = _llm(prompt, ctx) or _fallback_whisper(current)
+    revealed = {**current, **mystery, "whisper_followed": "Yes"}
     return revealed, _append(hist, "assistant", f"🌌 {reply}")
 
 
@@ -641,15 +629,13 @@ def study_current(current=None, history=None):
 
 
 def eat_current(current=None, collection=None, history=None):
-    """Placeholder for eating logic."""
+    """Eating mushrooms raw is always blocked."""
     hist = _safe_history(history)
     if current is None:
         return collection, _append(hist, "assistant", "There's nothing here to eat!")
-    
-    # Add your specific eating logic here
-    reply = f"You ate the {current.get('name', 'mushroom')}. It tasted like the forest."
+    reply = (
+        f"No no no! {current.get('name','That')} could be dangerous raw! "
+        "I'll never let you eat an unidentified mushroom. Study it first!"
+    )
     return collection, _append(hist, "assistant", reply)
     
-# ---------------------------------------------------------------------------
-# End of file
-# ---------------------------------------------------------------------------