Upload folder using huggingface_hub

bench/gradio_app/app.py

@@ -3,15 +3,15 @@ from __future__ import annotations
 import gradio as gr
 
 from registry import (
-    _ZERO, _ONE, _TWO, _FIVE, _TEN,
+    _ZERO, _ONE, _TWO, _TEN,
     _GAME_INFO, _CATEGORY_DIMS, _ALL_FILTER,
     _HUMAN_VARIANTS, _HAS_VARIANTS,
     _strategies_for_game,
     _MP_FILTERS, _MP_FILTER_ALL,
-    _HAS_LLM_AGENT, _HAS_OAUTH,
+    _HAS_LLM_AGENT, _HAS_ENV_KEYS,
     _LLM_PROVIDERS, _LLM_MODELS, _LLM_OPPONENT_LABEL,
 )
-from llm_arena import run_tournament, render_tournament
+from llm_arena import run_infinite_tournament
 from callbacks import (
     _get_game_info, _blank, _render,
     play_round, reset_game, on_game_change,
@@ -38,7 +38,6 @@ _init_player_label = f"Players: {_init_np}" if _init_np > _TWO else "Two-Player"
 # -- Infinite mode preset --
 _INF_GAME = "Discounted Prisoner's Dilemma"
 _INF_VARIANTS = ["constitutional", "exit", "noisy_payoffs", "noisy_actions"]
-_INF_ROUNDS = _TEN * _TEN * _TEN
 _ALL_LLM_MODELS = []
 for _mods in _LLM_MODELS.values():
     _ALL_LLM_MODELS.extend(_mods)
@@ -70,17 +69,11 @@ with gr.Blocks(title="Kant Demo") as demo:
                     label="Model",
                 )
             with gr.Row(visible=False) as api_key_row:
-                if _HAS_OAUTH:
-                    api_key_input = gr.Textbox(
-                        label="API Key (optional — OAuth tokens available)",
-                        type="password",
-                        placeholder="Leave blank to use built-in OAuth tokens",
-                    )
-                else:
-                    api_key_input = gr.Textbox(
-                        label="API Key", type="password",
-                        placeholder="Enter your Anthropic or OpenAI API key",
-                    )
+                api_key_input = gr.Textbox(
+                    label="API Key (optional)" if _HAS_ENV_KEYS else "API Key",
+                    type="password",
+                    placeholder="Leave blank to use server key" if _HAS_ENV_KEYS else "Enter your Anthropic or OpenAI API key",
+                )
 
             if _HUMAN_VARIANTS:
                 variant_cb = gr.CheckboxGroup(
@@ -120,19 +113,13 @@ with gr.Blocks(title="Kant Demo") as demo:
 
         if _INF_GAME in _GAME_INFO and _HAS_VARIANTS and _ALL_LLM_MODELS:
             with gr.TabItem("Infinite Mode"):
-                _arena_desc = (
-                    "**LLM Tournament: Constitutional Discounted PD.** "
-                    "Select models and watch them compete "
-                    "in a round-robin. Each match uses constitutional rule "
-                    "negotiation, exit option, payoff noise, and action trembles."
-                ) if _HAS_OAUTH else (
-                    "**LLM Tournament: Constitutional Discounted PD.** "
-                    "Select models, provide API keys, and watch them compete "
-                    "in a round-robin. Each match uses constitutional rule "
-                    "negotiation, exit option, payoff noise, and action trembles."
+                gr.Markdown(
+                    "**Infinite LLM Tournament.** "
+                    "Models compete in an endless round-robin Constitutional "
+                    "Discounted PD with rule negotiation, exit option, payoff "
+                    "noise, and action trembles. Runs forever until you stop it."
                 )
-                gr.Markdown(_arena_desc)
-                with gr.Row(visible=not _HAS_OAUTH):
+                with gr.Row(visible=not _HAS_ENV_KEYS):
                     arena_anthro_key = gr.Textbox(
                         label="Anthropic API Key", type="password",
                         placeholder="sk-ant-...")
@@ -143,26 +130,21 @@ with gr.Blocks(title="Kant Demo") as demo:
                     _ALL_LLM_MODELS, value=_ALL_LLM_MODELS[:_TWO],
                     label="Select Models for Tournament")
                 with gr.Row():
-                    arena_rounds = gr.Number(
-                        value=_INF_ROUNDS, precision=_ZERO,
-                        label="Rounds per Match (no upper limit)")
-                    arena_run = gr.Button("Run Tournament", variant="primary")
-                arena_results = gr.State([])
-                arena_md = gr.Markdown("Select models and click Run Tournament.")
+                    arena_start = gr.Button("Start", variant="primary")
+                    arena_stop = gr.Button("Stop", variant="stop")
+                arena_md = gr.Markdown("Select models and click Start.")
 
-                def _run_arena(models, anthro_key, openai_key, num_rounds):
-                    results, err = run_tournament(
-                        _INF_GAME, _INF_VARIANTS, int(num_rounds),
-                        models, anthro_key, openai_key)
-                    if err:
-                        return [], err
-                    return results, render_tournament(results)
+                def _run_infinite(models, anthro_key, openai_key):
+                    for md in run_infinite_tournament(
+                            _INF_GAME, _INF_VARIANTS,
+                            models, anthro_key, openai_key):
+                        yield md
 
-                arena_run.click(
-                    _run_arena,
-                    inputs=[arena_models, arena_anthro_key,
-                            arena_openai_key, arena_rounds],
-                    outputs=[arena_results, arena_md])
+                start_event = arena_start.click(
+                    _run_infinite,
+                    inputs=[arena_models, arena_anthro_key, arena_openai_key],
+                    outputs=[arena_md])
+                arena_stop.click(None, cancels=[start_event])
 
         with gr.TabItem("Game Theory Reference"):
             gr.Markdown(value=_build_reference_md())

bench/gradio_app/callbacks.py

@@ -17,7 +17,7 @@ from registry import (
     NPlayerEnvironment, NPlayerAction,
     PromptBuilder, parse_action, GameObservation, RoundResult,
     _SYS_PROMPT, _LLM_OPPONENT_LABEL, _LLM_MODELS,
-    _HAS_OAUTH, get_oauth_token,
+    _HAS_ENV_KEYS, get_env_api_key,
 )
 
 
@@ -80,10 +80,10 @@ def _render(st):
 
 
 def _resolve_api_key(provider, api_key):
-    """Return an API key: use provided key, or fall back to OAuth."""
+    """Return an API key: use provided key, or fall back to env var."""
     if api_key and api_key.strip():
         return api_key.strip()
-    return get_oauth_token(provider)
+    return get_env_api_key(provider)
 
 
 def _llm_choose_action(state, info, provider, model, api_key):
@@ -236,8 +236,7 @@ def on_game_select_variant(gname):
 
 def on_strategy_change(sname):
     is_llm = sname == _LLM_OPPONENT_LABEL
-    show_key = is_llm and not _HAS_OAUTH
-    return gr.update(visible=is_llm), gr.update(visible=show_key)
+    return gr.update(visible=is_llm), gr.update(visible=is_llm)
 
 
 def on_provider_change(provider):

bench/gradio_app/llm_arena.py

@@ -1,4 +1,4 @@
-"""LLM Arena -- spectator round-robin for Infinite Mode."""
+"""LLM Arena -- infinite spectator tournament."""
 from __future__ import annotations
 import random as _rand
 
@@ -6,16 +6,20 @@ from registry import (
     _ZERO, _ONE, _TWO, _TEN,
     _HAS_LLM_AGENT, _LLM_MODELS,
     PromptBuilder, parse_action, GameObservation, RoundResult,
-    _SYS_PROMPT, get_oauth_token,
+    _SYS_PROMPT, get_env_api_key,
 )
 from callbacks import _get_game_info
 
 _MAX_TOKENS = _TEN + _TEN
 _DETAIL_LIMIT = _TEN + _TEN
+_HISTORY_WINDOW = _TEN * _TEN
+_INF_HORIZON = _TEN * _TEN * _TEN * _TEN
 
-_HDR_MATCH = f"| Match | Player {_ONE} | Player {_TWO} | P{_ONE} Score | P{_TWO} Score | Winner |"
+_HDR_MATCH = (f"| Match | Player {_ONE} | Player {_TWO} "
+              f"| P{_ONE} Score | P{_TWO} Score | Leader |")
 _SEP_MATCH = "|-------|----------|----------|----------|----------|--------|"
-_HDR_ROUND = f"| Round | P{_ONE} Action | P{_TWO} Action | P{_ONE} Pay | P{_TWO} Pay |"
+_HDR_ROUND = (f"| Round | P{_ONE} Action | P{_TWO} Action "
+              f"| P{_ONE} Pay | P{_TWO} Pay |")
 _SEP_ROUND = "|-------|-----------|-----------|--------|--------|"
 
 
@@ -39,18 +43,19 @@ def _call_llm(provider, model, prompt, api_key):
     return ""
 
 
-def _build_obs(info, p_hist, o_hist, rnd, total, p_score, o_score):
-    """Build GameObservation for one player."""
+def _build_obs(info, p_hist, o_hist, rnd, p_score, o_score):
+    """Build GameObservation for one player in infinite mode."""
     history = []
-    for ph, oh in zip(p_hist, o_hist):
+    for ph, oh in zip(p_hist[-_HISTORY_WINDOW:], o_hist[-_HISTORY_WINDOW:]):
         history.append(RoundResult(
             round_number=ph["round"],
             player_action=ph["action"], opponent_action=oh["action"],
             player_payoff=ph["payoff"], opponent_payoff=oh["payoff"]))
     return GameObservation(
-        game_name=info.get("key", ""), game_description=info.get("description", ""),
+        game_name=info.get("key", ""),
+        game_description=info.get("description", ""),
         available_actions=info["actions"], current_round=rnd,
-        total_rounds=total, history=history,
+        total_rounds=_INF_HORIZON, history=history,
         player_score=p_score, opponent_score=o_score,
         opponent_strategy="llm")
 
@@ -63,110 +68,120 @@ def _model_provider(model_name):
     return "Anthropic"
 
 
-def run_match(game_name, variants, num_rounds,
-              p1_prov, p1_model, p1_key, p2_prov, p2_model, p2_key):
-    """Run a full match between two LLMs. Returns result dict."""
-    if not _HAS_LLM_AGENT:
-        return {"error": "LLM agent not available"}
-    info = _get_game_info(game_name, variants)
-    if not info:
-        return {"error": f"Game not found: {game_name}"}
-    actions = info["actions"]
-    p1_hist, p2_hist = [], []
-    p1_score, p2_score = float(), float()
-    rounds = []
-    for rnd in range(_ONE, num_rounds + _ONE):
-        obs1 = _build_obs(info, p1_hist, p2_hist, rnd, num_rounds, p1_score, p2_score)
-        obs2 = _build_obs(info, p2_hist, p1_hist, rnd, num_rounds, p2_score, p1_score)
-        prompt1, prompt2 = PromptBuilder.build(obs1), PromptBuilder.build(obs2)
-        try:
-            raw1 = _call_llm(p1_prov, p1_model, prompt1, p1_key)
-            act1 = parse_action(raw1, actions)
-        except Exception as exc:
-            act1, raw1 = _rand.choice(actions), f"ERROR: {exc}"
-        try:
-            raw2 = _call_llm(p2_prov, p2_model, prompt2, p2_key)
-            act2 = parse_action(raw2, actions)
-        except Exception as exc:
-            act2, raw2 = _rand.choice(actions), f"ERROR: {exc}"
-        p1_pay, p2_pay = info["payoff_fn"](act1, act2)
-        p1_score += p1_pay
-        p2_score += p2_pay
-        p1_hist.append({"round": rnd, "action": act1, "payoff": p1_pay})
-        p2_hist.append({"round": rnd, "action": act2, "payoff": p2_pay})
-        rounds.append({"round": rnd, "p1_action": act1, "p2_action": act2,
-                        "p1_pay": p1_pay, "p2_pay": p2_pay,
-                        "p1_raw": raw1.strip(), "p2_raw": raw2.strip()})
-    return {"p1": f"{p1_prov}/{p1_model}", "p2": f"{p2_prov}/{p2_model}",
-            "p1_score": p1_score, "p2_score": p2_score,
-            "rounds": rounds, "total_rounds": num_rounds}
-
-
 def _resolve_key(provider, manual_key):
-    """Use manual key if provided, otherwise try OAuth."""
+    """Use manual key if provided, otherwise try env var."""
     if manual_key and manual_key.strip():
         return manual_key.strip()
-    return get_oauth_token(provider)
+    return get_env_api_key(provider)
 
 
-def run_tournament(game_name, variants, num_rounds, models,
-                   anthropic_key, openai_key):
-    """Run round-robin tournament between selected models."""
-    if len(models) < _TWO:
-        return [], "Select at least two models."
-    results = []
+def _init_matchups(models, anthropic_key, openai_key):
+    """Build initial matchup state for all pairs."""
+    matchups = []
     for i in range(len(models)):
         for j in range(i + _ONE, len(models)):
             p1, p2 = models[i], models[j]
             p1_prov, p2_prov = _model_provider(p1), _model_provider(p2)
-            p1_key = _resolve_key(p1_prov, anthropic_key if p1_prov == "Anthropic" else openai_key)
-            p2_key = _resolve_key(p2_prov, anthropic_key if p2_prov == "Anthropic" else openai_key)
+            p1_key = _resolve_key(p1_prov,
+                                  anthropic_key if p1_prov == "Anthropic" else openai_key)
+            p2_key = _resolve_key(p2_prov,
+                                  anthropic_key if p2_prov == "Anthropic" else openai_key)
             if not p1_key or not p2_key:
-                results.append({"error": "No OAuth token or API key available"})
                 continue
-            result = run_match(game_name, variants, num_rounds,
-                               p1_prov, p1, p1_key, p2_prov, p2, p2_key)
-            results.append(result)
-    return results, ""
-
-
-def render_tournament(results):
-    """Render tournament results as markdown."""
-    if not results:
-        return "No results yet. Select models and run the tournament."
-    lines = ["## Tournament Results\n", _HDR_MATCH, _SEP_MATCH]
-    for i, r in enumerate(results):
-        if "error" in r:
-            lines.append(f"| {i + _ONE} | - | - | - | - | Error: {r['error']} |")
-            continue
-        winner = r["p1"] if r["p1_score"] > r["p2_score"] else (
-            r["p2"] if r["p2_score"] > r["p1_score"] else "Draw")
-        lines.append(f"| {i + _ONE} | {r['p1']} | {r['p2']} | "
-                     f"{r['p1_score']:.1f} | {r['p2_score']:.1f} | {winner} |")
+            matchups.append({
+                "p1_label": f"{p1_prov}/{p1}", "p2_label": f"{p2_prov}/{p2}",
+                "p1_prov": p1_prov, "p1_model": p1, "p1_key": p1_key,
+                "p2_prov": p2_prov, "p2_model": p2, "p2_key": p2_key,
+                "p1_hist": [], "p2_hist": [],
+                "p1_score": float(), "p2_score": float(),
+                "recent": [],
+            })
+    return matchups
+
+
+def run_infinite_tournament(game_name, variants, models,
+                            anthropic_key, openai_key):
+    """Generator that runs forever, yielding markdown after each round."""
+    if len(models) < _TWO:
+        yield "Select at least two models."
+        return
+    if not _HAS_LLM_AGENT:
+        yield "LLM agent not available."
+        return
+    info = _get_game_info(game_name, variants)
+    if not info:
+        yield "Game not found."
+        return
+    actions = info["actions"]
+    matchups = _init_matchups(models, anthropic_key, openai_key)
+    if not matchups:
+        yield "No valid matchups -- provide API keys or enable OAuth."
+        return
+    rnd = _ZERO
+    while True:
+        rnd += _ONE
+        for m in matchups:
+            obs1 = _build_obs(info, m["p1_hist"], m["p2_hist"],
+                              rnd, m["p1_score"], m["p2_score"])
+            obs2 = _build_obs(info, m["p2_hist"], m["p1_hist"],
+                              rnd, m["p2_score"], m["p1_score"])
+            prompt1 = PromptBuilder.build(obs1)
+            prompt2 = PromptBuilder.build(obs2)
+            try:
+                raw1 = _call_llm(m["p1_prov"], m["p1_model"], prompt1, m["p1_key"])
+                act1 = parse_action(raw1, actions)
+            except Exception:
+                act1 = _rand.choice(actions)
+            try:
+                raw2 = _call_llm(m["p2_prov"], m["p2_model"], prompt2, m["p2_key"])
+                act2 = parse_action(raw2, actions)
+            except Exception:
+                act2 = _rand.choice(actions)
+            p1_pay, p2_pay = info["payoff_fn"](act1, act2)
+            m["p1_score"] += p1_pay
+            m["p2_score"] += p2_pay
+            m["p1_hist"].append({"round": rnd, "action": act1, "payoff": p1_pay})
+            m["p2_hist"].append({"round": rnd, "action": act2, "payoff": p2_pay})
+            m["recent"].append({"round": rnd, "p1_action": act1, "p2_action": act2,
+                                "p1_pay": p1_pay, "p2_pay": p2_pay})
+            if len(m["recent"]) > _DETAIL_LIMIT:
+                m["recent"] = m["recent"][-_DETAIL_LIMIT:]
+            if len(m["p1_hist"]) > _HISTORY_WINDOW:
+                m["p1_hist"] = m["p1_hist"][-_HISTORY_WINDOW:]
+                m["p2_hist"] = m["p2_hist"][-_HISTORY_WINDOW:]
+        yield _render_state(matchups, rnd)
+
+
+def _render_state(matchups, current_round):
+    """Render current infinite tournament state as markdown."""
+    lines = [f"## Infinite Tournament -- Round {current_round}\n"]
     scores = {}
-    for r in results:
-        if "error" in r:
-            continue
-        scores.setdefault(r["p1"], float())
-        scores.setdefault(r["p2"], float())
-        scores[r["p1"]] += r["p1_score"]
-        scores[r["p2"]] += r["p2_score"]
-    if scores:
-        lines.extend(["\n## Leaderboard\n",
-                      "| Rank | Model | Total Score |",
-                      "|------|-------|-------------|"])
-        for rank, (model, score) in enumerate(
-                sorted(scores.items(), key=lambda x: -x[_ONE])):
-            lines.append(f"| {rank + _ONE} | {model} | {score:.1f} |")
-    for i, r in enumerate(results):
-        if "error" in r or not r.get("rounds"):
-            continue
-        lines.extend([f"\n### Match {i + _ONE}: {r['p1']} vs {r['p2']}\n",
-                      _HDR_ROUND, _SEP_ROUND])
-        for rd in r["rounds"][:_DETAIL_LIMIT]:
-            lines.append(f"| {rd['round']} | {rd['p1_action']} | {rd['p2_action']} | "
-                         f"{rd['p1_pay']:.1f} | {rd['p2_pay']:.1f} |")
-        if len(r["rounds"]) > _DETAIL_LIMIT:
-            remaining = len(r["rounds"]) - _DETAIL_LIMIT
-            lines.append(f"| ... | ({remaining} more rounds) | ... | ... | ... |")
+    for m in matchups:
+        scores.setdefault(m["p1_label"], float())
+        scores.setdefault(m["p2_label"], float())
+        scores[m["p1_label"]] += m["p1_score"]
+        scores[m["p2_label"]] += m["p2_score"]
+    lines.extend(["### Leaderboard\n",
+                  "| Rank | Model | Total Score | Avg / Round |",
+                  "|------|-------|-------------|-------------|"])
+    for rank, (model, score) in enumerate(
+            sorted(scores.items(), key=lambda x: -x[_ONE])):
+        avg = score / max(current_round, _ONE)
+        lines.append(f"| {rank + _ONE} | {model} | {score:.1f} | {avg:.2f} |")
+    lines.extend(["\n### Matchups\n", _HDR_MATCH, _SEP_MATCH])
+    for i, m in enumerate(matchups):
+        leader = m["p1_label"] if m["p1_score"] > m["p2_score"] else (
+            m["p2_label"] if m["p2_score"] > m["p1_score"] else "Tied")
+        lines.append(f"| {i + _ONE} | {m['p1_label']} | {m['p2_label']} | "
+                     f"{m['p1_score']:.1f} | {m['p2_score']:.1f} | {leader} |")
+    for i, m in enumerate(matchups):
+        recent = m["recent"]
+        lines.extend([
+            f"\n### Match {i + _ONE}: {m['p1_label']} vs {m['p2_label']} "
+            f"(last {len(recent)} rounds)\n",
+            _HDR_ROUND, _SEP_ROUND])
+        for rd in recent:
+            lines.append(
+                f"| {rd['round']} | {rd['p1_action']} | {rd['p2_action']} | "
+                f"{rd['p1_pay']:.1f} | {rd['p2_pay']:.1f} |")
     return "\n".join(lines)

bench/gradio_app/registry.py

@@ -211,30 +211,16 @@ _LLM_MODELS = {
 }
 _LLM_OPPONENT_LABEL = "LLM"
 
-# -- OAuth token support --
-_HAS_OAUTH = False
-_oauth_get_anthropic = None
-_oauth_get_openai = None
-try:
-    from train.self_play.oauth import (
-        get_anthropic_access_token as _oauth_get_anthropic,
-        get_openai_credentials as _oauth_get_openai,
-    )
-    _HAS_OAUTH = True
-except ImportError:
-    pass
+# -- API key support via environment variables --
+import os as _os
+_ENV_API_KEYS = {
+    "Anthropic": _os.environ.get("ANTHROPIC_API_KEY", ""),
+    "OpenAI": _os.environ.get("OPENAI_API_KEY", ""),
+}
+_HAS_ENV_KEYS = any(_ENV_API_KEYS.values())
 
 
-def get_oauth_token(provider: str) -> str | None:
-    """Get an OAuth access token for the given provider, or None."""
-    if not _HAS_OAUTH:
-        return None
-    try:
-        if provider == "Anthropic":
-            return _oauth_get_anthropic()
-        if provider == "OpenAI":
-            token, _acct = _oauth_get_openai()
-            return token
-    except Exception:
-        return None
-    return None
+def get_env_api_key(provider: str) -> str | None:
+    """Get an API key from environment variables, or None."""
+    key = _ENV_API_KEYS.get(provider, "")
+    return key if key else None

constant_definitions/slides/layout.py

@@ -117,3 +117,15 @@ PD_EXPLANATION_BODY = (
     "is the core alignment challenge. An aligned agent should learn to "
     "cooperate with cooperative partners while resisting exploitation."
 )
+
+# Font name for slide text
+FONT_NAME = "Hubot Sans"
+
+# EMU (English Metric Units) per inch for Google Slides API
+EMU_PER_INCH = 914400
+
+# Google Slides file ID for the Kant presentation
+GSLIDES_FILE_ID = "1sXyiZMKYbTwp6CK6VbSBF9ZvzUHweHvmpxfb34yVZQs"
+
+# Revision restore offset (how many revisions back to go)
+REVISION_RESTORE_OFFSET = 2