Bridge Troll: prompt-first playable loop on Qwen2.5-7B

app.py

@@ -0,0 +1,131 @@
+"""Bridge Troll — Gradio app (Weekend-1, prompt-first playable loop).
+
+Run locally with no GPU / no download:
+    BRIDGE_TROLL_MOCK=1 python app.py
+
+Run the real model (GPU; on a ZeroGPU Space this is automatic):
+    python app.py
+
+This is the FUNCTIONAL pass. The hand-drawn woodcut UI + win animation come in
+the polish phase (Weekend 2) via gr.Server / custom CSS for the Off-Brand badge.
+"""
+
+from __future__ import annotations
+
+import gradio as gr
+
+from troll_engine import GameState, START_RESOLVE, build_messages, parse_judgment
+from models import get_backend
+
+# ZeroGPU decorator — no-op locally so the same file runs anywhere.
+# Supports both @gpu and @gpu(duration=...).
+try:
+    import spaces
+
+    gpu = spaces.GPU
+except Exception:  # not on a Space / spaces not installed
+
+    def gpu(*args, **_kwargs):
+        if args and callable(args[0]):
+            return args[0]
+        return lambda fn: fn
+
+
+_backend = get_backend()
+
+
+# Declared duration must cover worst-case generation but stay tight: ZeroGPU
+# pre-checks it against remaining daily quota, and a smaller value queues faster.
+@gpu(duration=30)
+def _generate(messages: list[dict]) -> str:
+    return _backend.generate(messages)
+
+
+INTRO = (
+    "A mossy troll heaves himself upright across the only bridge over the Mirebeck. "
+    "*\"None cross Gorm's bridge for free, traveller. Give me a reason — a *good* one.\"*"
+)
+
+
+def _meter_html(resolve: int, won: bool) -> str:
+    pct = max(0, min(100, round(resolve / START_RESOLVE * 100)))
+    if won:
+        return (
+            "<div class='resolve-wrap'><div class='resolve-label'>GORM HAS STEPPED ASIDE 🌉</div>"
+            "<div class='resolve-bar'><div class='resolve-fill won' style='width:0%'></div></div></div>"
+        )
+    # green when his resolve is high, warming toward gold as it drops
+    hue = 90 + (1 - pct / 100) * 30  # 90 (green) -> 120ish; tweak in polish
+    return (
+        "<div class='resolve-wrap'>"
+        f"<div class='resolve-label'>Gorm's Resolve — {resolve}</div>"
+        f"<div class='resolve-bar'><div class='resolve-fill' "
+        f"style='width:{pct}%;background:hsl({hue},55%,42%)'></div></div></div>"
+    )
+
+
+def on_submit(user_text: str, chat: list, state: GameState):
+    user_text = (user_text or "").strip()
+    if not user_text or state.won:
+        return chat, state, _meter_html(state.resolve, state.won), "", gr.update()
+
+    messages = build_messages(state, user_text)
+    raw = _generate(messages)
+    j = parse_judgment(raw)
+
+    state.history.append({"role": "user", "content": user_text})
+    state.history.append({"role": "assistant", "content": j.reply})
+    state.apply(j)
+
+    chat = chat + [
+        {"role": "user", "content": user_text},
+        {"role": "assistant", "content": j.reply},
+    ]
+    why = f"*{j.tactic.value}* · {j.reason}" + (f" · persuasiveness {j.persuasiveness}/5"
+                                                if j.tactic.value == "genuine" else "")
+    if state.won:
+        why = "🌉 You crossed. " + why
+    # disable input on win
+    box_update = gr.update(interactive=not state.won,
+                           placeholder="The bridge is yours." if state.won else "Speak to Gorm…")
+    return chat, state, _meter_html(state.resolve, state.won), why, box_update
+
+
+def on_reset():
+    state = GameState()
+    chat = [{"role": "assistant", "content": INTRO}]
+    return (chat, state, _meter_html(state.resolve, False), "",
+            gr.update(interactive=True, value="", placeholder="Speak to Gorm…"))
+
+
+CSS = """
+.resolve-wrap { margin: 6px 0 14px; }
+.resolve-label { font-family: Georgia, serif; font-size: 14px; letter-spacing:.04em; margin-bottom:4px; }
+.resolve-bar { height: 16px; background:#2a2118; border:1px solid #5a4a32; border-radius:9px; overflow:hidden; }
+.resolve-fill { height:100%; transition: width .5s ease, background .5s ease; }
+.resolve-fill.won { background:#caa54a; }
+#why { font-family: Georgia, serif; opacity:.8; min-height:1.4em; }
+"""
+
+with gr.Blocks(title="Bridge Troll") as demo:
+    gr.Markdown("## 🧌🌉 Bridge Troll\n*Talk your way across — if your argument is actually good.*")
+    meter = gr.HTML(_meter_html(START_RESOLVE, False))
+    chatbot = gr.Chatbot(value=[{"role": "assistant", "content": INTRO}],
+                         height=420, show_label=False)
+    why = gr.Markdown("", elem_id="why")
+    with gr.Row():
+        box = gr.Textbox(placeholder="Speak to Gorm…", show_label=False, scale=8, autofocus=True)
+        send = gr.Button("Say it", variant="primary", scale=1)
+    reset = gr.Button("New traveller", size="sm")
+
+    state = gr.State(GameState())
+
+    send.click(on_submit, [box, chatbot, state], [chatbot, state, meter, why, box]).then(
+        lambda: "", None, box)
+    box.submit(on_submit, [box, chatbot, state], [chatbot, state, meter, why, box]).then(
+        lambda: "", None, box)
+    reset.click(on_reset, None, [chatbot, state, meter, why, box])
+
+
+if __name__ == "__main__":
+    demo.launch(css=CSS, theme=gr.themes.Soft())

models.py

@@ -0,0 +1,101 @@
+"""Model backends for Bridge Troll.
+
+Two interchangeable backends exposing the same `generate(messages) -> str`:
+
+* TransformersTroll — Qwen2.5-7B-Instruct. Loaded EAGERLY at construction so it
+                      follows the ZeroGPU rule (instantiate at module scope,
+                      .to('cuda') eagerly; ZeroGPU maps the device transparently).
+* MockTroll        — deterministic canned judgments. No GPU, no download.
+                     Lets you build and test the whole game loop + UI instantly.
+
+Device selection:
+  * On a Hugging Face Space (env SPACE_ID is set) -> force 'cuda' and load eagerly.
+    Do NOT gate on torch.cuda.is_available(): on ZeroGPU it reports False at import
+    time, so gating would wrongly pin the model to CPU.
+  * Locally -> mps on Apple Silicon, else cpu. (You should NOT run the real model
+    on your laptop for real play — it's a ~15GB download and slow. Use mock locally;
+    run the real model on the Space.)
+
+Swap to a fine-tuned checkpoint by changing BRIDGE_TROLL_MODEL. Swap to llama.cpp
+later by writing a third backend with the same `.generate` signature.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+MODEL_ID = os.environ.get("BRIDGE_TROLL_MODEL", "Qwen/Qwen2.5-7B-Instruct")
+ON_SPACE = bool(os.environ.get("SPACE_ID"))  # HF sets this when running on a Space
+
+
+class MockTroll:
+    """Heuristic stand-in so the loop is testable with zero infra. NOT the game's
+    intelligence — just scaffolding so the UI/meter are exercised before the real
+    model is wired in."""
+
+    _FLATTERY = ("great", "wonderful", "amazing", "best", "handsome", "wise", "kind troll")
+    _THREAT = ("kill", "destroy", "smash", "burn", "or else", "make you", "force")
+    _MANIP = ("the king sent", "i am your", "you must", "it is the law", "actually you")
+
+    def generate(self, messages: list[dict]) -> str:
+        last = messages[-1]["content"].lower()
+        if any(w in last for w in self._THREAT):
+            tactic, p, reason, reply = "threat", 0, "tried to scare me", "Threats? Three hundred years of them. Cross elsewhere."
+        elif any(w in last for w in self._MANIP):
+            tactic, p, reason, reply = "manipulation", 0, "false authority", "I smell a lie under that fine talk. No."
+        elif any(w in last for w in self._FLATTERY):
+            tactic, p, reason, reply = "flattery", 0, "buttering me up", "Flattery slides off moss, traveller."
+        elif "please" in last or "need" in last or "family" in last or "sick" in last:
+            tactic, p, reason, reply = "genuine", 3, "a real appeal", "Hm. You speak plainly, at least. Go on."
+        else:
+            tactic, p, reason, reply = "smalltalk", 0, "no real argument", "Pleasant. Irrelevant. The bridge stays shut."
+        return json.dumps({"tactic": tactic, "persuasiveness": p, "reason": reason, "reply": reply})
+
+
+def _local_device():
+    import torch
+    if torch.cuda.is_available():
+        return "cuda"
+    if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        return "mps"
+    return "cpu"
+
+
+class TransformersTroll:
+    """Qwen2.5-7B via HF transformers. Loads eagerly at construction (module scope)."""
+
+    def __init__(self, model_id: str = MODEL_ID):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        self.device = "cuda" if ON_SPACE else _local_device()
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            torch_dtype=torch.bfloat16,
+        ).to(self.device)  # eager .to('cuda') on a Space — ZeroGPU handles mapping
+
+    def generate(self, messages: list[dict]) -> str:
+        import torch
+
+        inputs = self.tokenizer.apply_chat_template(
+            messages, add_generation_prompt=True, return_tensors="pt"
+        ).to(self.model.device)
+        with torch.no_grad():
+            out = self.model.generate(
+                inputs,
+                max_new_tokens=220,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.9,
+                pad_token_id=self.tokenizer.eos_token_id,
+            )
+        return self.tokenizer.decode(out[0][inputs.shape[1]:], skip_special_tokens=True)
+
+
+def get_backend():
+    """MockTroll when BRIDGE_TROLL_MOCK=1, else the real model (loads eagerly)."""
+    if os.environ.get("BRIDGE_TROLL_MOCK") == "1":
+        return MockTroll()
+    return TransformersTroll()

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=6.0
+transformers>=4.45
+torch
+accelerate
+sentencepiece
+spaces

troll_engine.py

@@ -0,0 +1,183 @@
+"""Bridge Troll — core engine.
+
+Model-agnostic. Holds the troll's character, the judgment schema the model must
+emit each turn, robust parsing, and the Resolve-meter bookkeeping.
+
+Design principle: the MODEL makes the judgment (how persuasive a line is, and what
+tactic it used). This module only does deterministic bookkeeping on top of that
+judgment, so the AI stays load-bearing while the meter stays reliable.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+# --------------------------------------------------------------------------- #
+# Tuning knobs — this is the "fairness" surface you'll calibrate during the
+# fine-tune. Keep them here so the eval harness can import and sweep them.
+# --------------------------------------------------------------------------- #
+
+START_RESOLVE: int = 100
+WIN_AT: int = 0
+MAX_RESOLVE: int = 130  # he can get *more* entrenched if you annoy him
+
+
+class Tactic(str, Enum):
+    GENUINE = "genuine"            # a real, good-faith argument
+    FLATTERY = "flattery"          # buttering him up
+    THREAT = "threat"              # intimidation
+    MANIPULATION = "manipulation"  # trickery, lies, false premises
+    REPETITION = "repetition"      # rephrasing something already tried
+    SMALLTALK = "smalltalk"        # chit-chat, no argument at all
+
+
+# How much each tactic moves Resolve. Negative = troll softens (good for player).
+# `genuine` scales with persuasiveness; the rest are flat penalties/no-ops.
+GENUINE_SCALE: dict[int, int] = {0: 0, 1: -2, 2: -6, 3: -12, 4: -20, 5: -30}
+
+TACTIC_FLAT_DELTA: dict[Tactic, int] = {
+    Tactic.FLATTERY: +4,       # offended, digs in a little
+    Tactic.THREAT: +10,        # absolutely not
+    Tactic.MANIPULATION: +8,   # he sees through it
+    Tactic.REPETITION: +5,     # "you said that already"
+    Tactic.SMALLTALK: +1,      # mildly stalls
+}
+
+
+@dataclass
+class Judgment:
+    """What the model emits each turn."""
+    persuasiveness: int          # 0..5, only meaningful for GENUINE
+    tactic: Tactic
+    reason: str                  # one short line — shown to the player as the "why"
+    reply: str                   # the troll's in-character dialogue
+
+    def resolve_delta(self) -> int:
+        if self.tactic is Tactic.GENUINE:
+            p = max(0, min(5, self.persuasiveness))
+            return GENUINE_SCALE[p]
+        return TACTIC_FLAT_DELTA.get(self.tactic, 0)
+
+
+@dataclass
+class GameState:
+    resolve: int = START_RESOLVE
+    turns: int = 0
+    won: bool = False
+    history: list[dict] = field(default_factory=list)  # chat-template messages
+
+    def apply(self, j: Judgment) -> None:
+        self.resolve = max(0, min(MAX_RESOLVE, self.resolve + j.resolve_delta()))
+        self.turns += 1
+        if self.resolve <= WIN_AT:
+            self.won = True
+
+
+# --------------------------------------------------------------------------- #
+# The character + the rubric. During prompt-first this lives in the system
+# prompt. After fine-tuning, the model internalises it and emits cleaner JSON.
+# --------------------------------------------------------------------------- #
+
+SYSTEM_PROMPT = """You are GORM, an old bridge troll. You have guarded the same \
+mossy stone bridge over the Mirebeck for three hundred years. You are proud, \
+gruff, and weary — but underneath it, lonely, and you secretly respect a clever \
+or kind-hearted traveller. You will NOT move for flattery, threats, bribes, or \
+trickery; those make you dig in. You step aside ONLY for an argument you find \
+genuinely convincing or unexpectedly touching.
+
+Every time the traveller speaks, you do TWO things:
+
+1. Judge their line honestly using this rubric.
+   - tactic — exactly one of:
+       "genuine"      a real, good-faith argument or appeal
+       "flattery"     compliments meant to win you over
+       "threat"       intimidation or force
+       "manipulation" lies, tricks, false premises, fake authority
+       "repetition"   something they have already tried, reworded
+       "smalltalk"    chit-chat with no argument
+   - persuasiveness — an integer 0-5. ONLY for "genuine" lines; use 0 otherwise.
+       0 weak/empty   1 thin   2 has a point   3 solid   4 strong   5 the kind of
+       thing that actually moves a three-hundred-year-old heart.
+     Be a tough but fair judge. Most lines are 1-2. A 4 or 5 is rare and earned.
+     Do not reward length or fancy words — reward genuine reasoning or feeling.
+
+2. Reply IN CHARACTER as Gorm — short (1-3 sentences), gruff, textured. React to
+   what they actually said. Never break character. Never mention the rubric, the
+   meter, or that you are an AI.
+
+Respond with ONLY a single JSON object, nothing else, in this exact shape:
+{"tactic": "...", "persuasiveness": 0, "reason": "<=10 words on why", "reply": "Gorm's words"}"""
+
+
+def build_messages(state: GameState, user_text: str) -> list[dict]:
+    """Assemble chat-template messages for this turn."""
+    msgs: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
+    msgs.extend(state.history)
+    msgs.append({"role": "user", "content": user_text})
+    return msgs
+
+
+# --------------------------------------------------------------------------- #
+# Robust parsing — a prompted 7B will occasionally wrap JSON in prose or fences.
+# Never crash the game on a bad parse; fall back to a neutral smalltalk judgment.
+# --------------------------------------------------------------------------- #
+
+_JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
+
+
+def parse_judgment(raw: str) -> Judgment:
+    text = raw.strip()
+    # strip code fences if present
+    if text.startswith("```"):
+        text = re.sub(r"^```(?:json)?|```$", "", text, flags=re.MULTILINE).strip()
+    match = _JSON_RE.search(text)
+    if match:
+        try:
+            obj = json.loads(match.group(0))
+            tactic = _coerce_tactic(obj.get("tactic"))
+            persuasiveness = _coerce_int(obj.get("persuasiveness"), 0, 0, 5)
+            reason = str(obj.get("reason", "")).strip()[:120]
+            reply = str(obj.get("reply", "")).strip() or _fallback_reply()
+            return Judgment(persuasiveness, tactic, reason, reply)
+        except (json.JSONDecodeError, ValueError, TypeError):
+            pass
+    # Total fallback: treat the raw text as the troll's reply, no progress.
+    return Judgment(0, Tactic.SMALLTALK, "unparseable judgment", text or _fallback_reply())
+
+
+def _coerce_tactic(value) -> Tactic:
+    try:
+        return Tactic(str(value).strip().lower())
+    except ValueError:
+        return Tactic.SMALLTALK
+
+
+def _coerce_int(value, default: int, lo: int, hi: int) -> int:
+    try:
+        return max(lo, min(hi, int(value)))
+    except (TypeError, ValueError):
+        return default
+
+
+def _fallback_reply() -> str:
+    return "Gorm scratches his mossy chin and says nothing useful."
+
+
+# --------------------------------------------------------------------------- #
+# Convenience for the eval harness (Day 2): score a single line given a model fn.
+# --------------------------------------------------------------------------- #
+
+def play_turn(state: GameState, user_text: str, generate_fn) -> Judgment:
+    """generate_fn(messages: list[dict]) -> str (raw model output)."""
+    messages = build_messages(state, user_text)
+    raw = generate_fn(messages)
+    judgment = parse_judgment(raw)
+    state.history.append({"role": "user", "content": user_text})
+    state.history.append({"role": "assistant", "content": judgment.reply})
+    state.apply(judgment)
+    return judgment