Trim prefetch to 1 pack, log model-pack failures, JSON-constrained cards, rotate fallback names

ai_runtime.py

@@ -43,7 +43,7 @@ def local_ai_env(card_port: int = DEFAULT_CARD_PORT) -> dict[str, str]:
             "TABRAS_CARD_ENDPOINT": chat_endpoint(card_port),
             "TABRAS_CARD_MODEL": "minicpm-v-4.6-q4",
             "TABRAS_CARD_TEMPERATURE": "0.7",
-            "TABRAS_CARD_MAX_TOKENS": "192",
+            "TABRAS_CARD_MAX_TOKENS": "256",
             "TABRAS_AI_BOSS": "1",
             "TABRAS_BOSS_BACKEND": "mlx",
             "TABRAS_BOSS_MODEL": DEFAULT_BOSS_MODEL,

clients.py

@@ -51,7 +51,7 @@ def configure_mode() -> str:
         os.environ.setdefault("TABRAS_ART_MODEL", DEFAULT_ART_MODEL)
     os.environ.setdefault("TABRAS_AI_BOSS", "1")
     os.environ.setdefault("TABRAS_CARD_TEMPERATURE", "0.7")
-    os.environ.setdefault("TABRAS_CARD_MAX_TOKENS", "192")
+    os.environ.setdefault("TABRAS_CARD_MAX_TOKENS", "256")
     os.environ.setdefault("TABRAS_BOSS_MAX_TOKENS", "96")
     os.environ.setdefault("TABRAS_ART_STEPS", "4")
     return mode
@@ -61,13 +61,12 @@ def configure_mode() -> str:
 def card_client_from_env() -> CardPackClient | None:
     if os.environ.get("TABRAS_CARD_BACKEND") == "llamacpp":
         return LlamaCppCardClient(
-            LocalChatClient(
+            LocalJsonChatClient(
                 endpoint=os.environ.get("TABRAS_CARD_ENDPOINT", DEFAULT_LLAMA_CARD_ENDPOINT),
                 model=os.environ.get("TABRAS_CARD_MODEL", DEFAULT_CARD_MODEL),
                 timeout_seconds=int(os.environ.get("TABRAS_CARD_TIMEOUT", "60")),
                 temperature=float(os.environ.get("TABRAS_CARD_TEMPERATURE", "0.0")),
                 max_tokens=int(os.environ.get("TABRAS_CARD_MAX_TOKENS", "320")),
-                enable_thinking=False,
             )
         )
     if os.environ.get("TABRAS_CARD_BACKEND") == "transformers":

generator.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any, Protocol, Sequence
 
 from budget import Card, CardSpec, EffectPlan, cost_card
-from local_llm import LocalChatClient
+from local_llm import ChatCompleter
 from primitives import PrimitiveId, School, school_bias, school_primitives
 
 
@@ -57,7 +57,7 @@ class CodexCardClient:
 
 @dataclass(frozen=True)
 class MiniCPMCardClient:
-    chat: LocalChatClient
+    chat: ChatCompleter
 
     # Return one raw card payload from a local MiniCPM endpoint.
     def create_card(self, payload: dict[str, Any]) -> dict[str, Any]:
@@ -74,7 +74,7 @@ class MiniCPMCardClient:
 
 @dataclass(frozen=True)
 class LlamaCppCardClient:
-    chat: LocalChatClient
+    chat: ChatCompleter
 
     # Return one raw card payload from a llama.cpp MiniCPM endpoint.
     def create_card(self, payload: dict[str, Any]) -> dict[str, Any]:
@@ -399,7 +399,7 @@ def llamacpp_card_prompt(payload: dict[str, Any], pack_cards: Sequence[dict[str,
 
 
 # Generate one llama.cpp card with one corrective retry; quick mode takes the first card.
-def generate_llamacpp_card(chat: LocalChatClient, payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]], focus: str = "") -> dict[str, Any]:
+def generate_llamacpp_card(chat: ChatCompleter, payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]], focus: str = "") -> dict[str, Any]:
     prompt = llamacpp_card_prompt(payload, pack_cards, focus)
     card = parse_llamacpp_card_text(chat.complete(card_system_prompt(), prompt), payload, pack_cards, discard_bad_text=False)
     need = llama_candidate_need(payload, pack_summary(pack_cards))
@@ -855,14 +855,42 @@ def fallback_art_prompt(payload: dict[str, Any]) -> str:
 # Extract the first JSON object from model text.
 def extract_json_object(text: str) -> str:
     start = text.find("{")
-    end = text.rfind("}")
-    if start == -1 or end == -1 or end < start:
+    if start == -1:
         raise ValueError("Codex response did not contain a JSON object")
-    candidate = balance_json_closers(text[start : end + 1])
+    end = json_object_end(text, start)
+    candidate = balance_json_closers(text[start:end])
     json.loads(candidate)
     return candidate
 
 
+# Return the end offset of the first balanced JSON object.
+def json_object_end(text: str, start: int) -> int:
+    stack: list[str] = []
+    in_string = False
+    escaped = False
+    for index, char in enumerate(text[start:], start):
+        if escaped:
+            escaped = False
+            continue
+        if char == "\\" and in_string:
+            escaped = True
+            continue
+        if char == "\"":
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if char == "{":
+            stack.append("}")
+        elif char == "[":
+            stack.append("]")
+        elif stack and char == stack[-1]:
+            stack.pop()
+            if not stack:
+                return index + 1
+    return len(text)
+
+
 # Append missing JSON object or array closers.
 def balance_json_closers(text: str) -> str:
     stack: list[str] = []

local_llm.py

@@ -51,6 +51,9 @@ class LocalJsonChatClient:
             return parse_chat_response(json.loads(response.read().decode("utf-8")))
 
 
+ChatCompleter = LocalChatClient | LocalJsonChatClient
+
+
 @dataclass(frozen=True)
 class LocalCompletionClient:
     endpoint: str

tests/test_ai_runtime.py

@@ -24,7 +24,7 @@ def test_local_ai_env(monkeypatch) -> None:
     env = local_ai_env(9001)
     assert env["TABRAS_CARD_BACKEND"] == "llamacpp"
     assert env["TABRAS_CARD_ENDPOINT"] == "http://127.0.0.1:9001/v1/chat/completions"
-    assert env["TABRAS_CARD_MAX_TOKENS"] == "192"
+    assert env["TABRAS_CARD_MAX_TOKENS"] == "256"
     assert env["TABRAS_CARD_TEMPERATURE"] == "0.7"
     assert env["TABRAS_AI_BOSS"] == "1"
     assert env["TABRAS_BOSS_BACKEND"] == "mlx"

tests/test_clients.py

@@ -2,7 +2,7 @@ from clients import art_client_from_env, boss_client_from_env, card_client_from_
 from art import DiffusersImageClient, LazyArtClient
 from boss import NemotronBossClient
 from generator import LlamaCppCardClient, MiniCPMCardClient
-from local_llm import LocalChatClient, LocalCompletionClient, nemotron_prompt
+from local_llm import LocalCompletionClient, LocalJsonChatClient, nemotron_prompt
 
 
 class FakeChat:
@@ -50,11 +50,10 @@ def test_card_client_from_env_llamacpp(monkeypatch) -> None:
     monkeypatch.setenv("TABRAS_CARD_MODEL", "mini-q4")
     client = card_client_from_env()
     assert isinstance(client, LlamaCppCardClient)
-    assert isinstance(client.chat, LocalChatClient)
+    assert isinstance(client.chat, LocalJsonChatClient)
     assert client.chat.endpoint == "http://cards"
     assert client.chat.model == "mini-q4"
     assert client.chat.max_tokens == 320
-    assert client.chat.enable_thinking is False
 
 
 # Verify boss client is disabled unless enabled.

tests/test_generator.py

@@ -399,6 +399,12 @@ def test_extract_json_object() -> None:
         extract_json_object("no json")
 
 
+# Verify JSON extraction ignores later objects in chatty model output.
+def test_extract_json_object_uses_first_balanced_object() -> None:
+    text = 'first {"name": "A", "effects": []} then {"name": "B"}'
+    assert extract_json_object(text) == '{"name": "A", "effects": []}'
+
+
 # Verify JSON extraction repairs missing closing delimiters.
 def test_extract_json_object_repairs_missing_closer() -> None:
     assert extract_json_object('{"cards": [{"name": "A"}]') == '{"cards": [{"name": "A"}]}'

tests/test_ui.py

@@ -15,6 +15,7 @@ from ui import (
     fallback_pack,
     finish_opening_draft,
     log_html,
+    make_pack,
     mana_html,
     new_run,
     new_run_shell,
@@ -22,6 +23,7 @@ from ui import (
     pass_turn_steps,
     pending_tokens_html,
     play_hand_card,
+    prefetch_pack_limit,
     queue_next_pack,
     refresh_art,
 )
@@ -57,6 +59,15 @@ def test_fire_fallback_pack_rotates_names() -> None:
     assert all("card" not in card.art_prompt.lower() for card in first + second)
 
 
+# Verify model pack failures are visible in server logs before fallback.
+def test_make_pack_logs_model_failure(capsys) -> None:
+    pack = make_pack(BrokenPackClient(), None, "fire", "dark fantasy", (), 1)
+    captured = capsys.readouterr()
+    assert len(pack) == CARD_PANEL_COUNT
+    assert "Tabras model pack failed" in captured.err
+    assert "RuntimeError: bad json" in captured.err
+
+
 # Verify a new run starts in draft state with three clickable cards.
 def test_new_run_starts_draft() -> None:
     state = new_run("Ada", "anime", "ice", seed=1)
@@ -446,6 +457,12 @@ class ForgePackClient:
         return {"cards": [card(i) for i in range(payload["pack_size"])]}
 
 
+class BrokenPackClient:
+    # Raise like a model response that cannot be parsed or costed.
+    def create_pack(self, payload):
+        raise RuntimeError("bad json")
+
+
 class FakeArtClient:
     # Return a stable URI for each generated art prompt.
     def create_art(self, prompt: str) -> str:
@@ -464,18 +481,27 @@ class GatedArtClient:
 
 
 # Verify a new run pre-forges candidate packs and the boss deck in the background.
-def test_new_run_warms_forge() -> None:
+def test_new_run_warms_forge(monkeypatch) -> None:
+    monkeypatch.delenv("TABRAS_PREFETCH_PACKS", raising=False)
     forge.reset()
     client = ForgePackClient()
     state = new_run("Ada", "anime", "ice", client, seed=3)
     forge.drain()
-    # pack 1 + three speculative next packs; the boss deck is deferred (draft_step >= 2)
+    # pack 1 + one speculative next pack; the boss deck is deferred (draft_step >= 2)
     # so it no longer competes with the first visible pack.
-    assert client.calls == 4
+    assert client.calls == 2
     picked = choose_draft_card(state, 0, client)
     assert all(card.name.startswith("Forged") for card in picked.current_pack)
 
 
+# Verify the speculative draft fanout can be tuned without crashing.
+def test_prefetch_pack_limit_env(monkeypatch) -> None:
+    monkeypatch.setenv("TABRAS_PREFETCH_PACKS", "0")
+    assert prefetch_pack_limit() == 0
+    monkeypatch.setenv("TABRAS_PREFETCH_PACKS", "bad")
+    assert prefetch_pack_limit() == 1
+
+
 # Verify battle start consumes the pre-forged boss deck.
 def test_battle_uses_forged_boss_deck() -> None:
     forge.reset()

ui.py

@@ -1,6 +1,8 @@
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass, replace
+import os
 from random import Random
+import sys
 from typing import Sequence
 
 import forge
@@ -281,11 +283,11 @@ def pack_maker(
     return lambda: make_pack(client, None, state.school, state.world, state.player_deck, cost, state.draft_anchors)
 
 
-# Pre-generate every candidate next pack while the player reads the current one.
+# Pre-generate a bounded number of next-pack branches while the player reads.
 def prefetch_next_packs(state: RunState, client: CardPackClient | None, art_client: ArtClient | None) -> None:
     if client is None or state.draft_step >= len(state.draft_order):
         return
-    for index in range(len(state.current_pack)):
+    for index in range(min(len(state.current_pack), prefetch_pack_limit())):
         nxt = apply_pick(state, index)
         if nxt.draft_step >= len(nxt.draft_order):
             continue
@@ -293,6 +295,14 @@ def prefetch_next_packs(state: RunState, client: CardPackClient | None, art_clie
         forge.submit(pack_key(nxt), pack_maker(client, art_client, nxt, cost))
 
 
+# Return how many possible next draft branches to forge speculatively.
+def prefetch_pack_limit() -> int:
+    try:
+        return max(0, int(os.environ.get("TABRAS_PREFETCH_PACKS", "1")))
+    except ValueError:
+        return 1
+
+
 # Return the forge key for the boss deck of one run.
 def enemy_deck_key(state: RunState) -> tuple:
     return ("enemy", state.enemy_school, state.world, state.enemy_seed)
@@ -444,8 +454,8 @@ def make_pack(
         try:
             pack = generate_pack(client, school, world, current_deck, cost, draft_anchors=anchors, quick=quick)
             return collect_ready_cards(pack)
-        except Exception:
-            pass
+        except Exception as exc:
+            print(f"Tabras model pack failed; using fallback: {type(exc).__name__}: {exc}", file=sys.stderr, flush=True)
     pack = fallback_pack(school, world, cost, anchors, current_deck)
     return collect_ready_cards(pack)