ixentbench 1.0.0__py3-none-any.whl

ixentbench/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+__version__ = "1.0.0"
+__author__  = "iXentLabs (iXent Games SL)"
+__email__   = "antoniguasch@ixentgames.com"

ixentbench/arena.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+ixentbench/arena.py
+Modo Arena — esqueleto completo listo para activar
+cuando ixent-arena esté desplegado en Google Cloud Run.
+"""
+
+import click
+import requests
+from ixentbench.auth import get_firebase_token
+from ixentbench.config import IXENT_SDK_URL, validate_env
+
+
+def create_room(mode: str, level: int):
+    """Crea una sala Arena y espera a los demás jugadores."""
+    validate_env()
+    click.echo(f"\n🎮 Creating Arena room — Mode: {mode.upper()} | Level: {level}")
+
+    jwt     = get_firebase_token()
+    headers = {"X-Firebase-Token": jwt, "Content-Type": "application/json"}
+
+    resp = requests.post(f"{IXENT_SDK_URL}/arena/create", headers=headers, json={
+        "mode":  mode,
+        "level": level,
+    }, timeout=30)
+
+    if not resp.ok:
+        click.echo(f"❌ Error creating room: {resp.text}", err=True)
+        raise SystemExit(1)
+
+    data      = resp.json()
+    room_code = data.get("room_code")
+
+    click.echo(f"\n✅ Room created!")
+    click.echo(f"   Code: {room_code}")
+    click.echo(f"\n   Share this code with your opponents:")
+    click.echo(f"   ixentbench arena join --room {room_code}\n")
+    click.echo("⏳ Waiting for players to join...")
+
+    # TODO: polling hasta que todos estén listos + arranque automático
+    # Se implementa cuando ixent-arena esté desplegado en GCP
+    click.echo("\n⚠️  Arena multiplayer — coming soon!")
+
+
+def join_room(room_code: str):
+    """Se une a una sala Arena existente."""
+    validate_env()
+    click.echo(f"\n🎮 Joining Arena room: {room_code}")
+
+    jwt     = get_firebase_token()
+    headers = {"X-Firebase-Token": jwt, "Content-Type": "application/json"}
+
+    resp = requests.post(f"{IXENT_SDK_URL}/arena/join", headers=headers, json={
+        "room_code": room_code,
+    }, timeout=30)
+
+    if not resp.ok:
+        click.echo(f"❌ Error joining room: {resp.text}", err=True)
+        raise SystemExit(1)
+
+    data = resp.json()
+    click.echo(f"✅ Joined room {room_code} as {data.get('player_slot', '?')}")
+    click.echo("⏳ Waiting for host to start the game...")
+
+    # TODO: escucha de inicio + game loop Arena
+    click.echo("\n⚠️  Arena multiplayer — coming soon!")

ixentbench/auth.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""
+ixentbench/auth.py
+Google OAuth → Firebase JWT.
+Primera ejecución: abre el navegador para Sign in with Google.
+Siguientes ejecuciones: refresco silencioso desde credentials.json
+"""
+
+import requests
+import click
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request
+from ixentbench.config import (
+    CREDENTIALS, FIREBASE_API_KEY,
+    OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET
+)
+
+SCOPES = ["openid", "https://www.googleapis.com/auth/userinfo.email"]
+
+
+def get_firebase_token() -> str:
+    """
+    Devuelve un Firebase ID Token válido (1h).
+    Gestiona automáticamente el ciclo de vida de las credenciales.
+    """
+    creds = None
+
+    if CREDENTIALS.exists():
+        try:
+            creds = Credentials.from_authorized_user_file(str(CREDENTIALS), SCOPES)
+        except Exception:
+            creds = None  # Credenciales corruptas — re-autenticar
+
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            try:
+                creds.refresh(Request())
+            except Exception:
+                creds = None  # Token revocado — re-autenticar
+
+        if not creds:
+            flow = InstalledAppFlow.from_client_config(
+                {
+                    "installed": {
+                        "client_id":     OAUTH_CLIENT_ID,
+                        "client_secret": OAUTH_CLIENT_SECRET,
+                        "redirect_uris": ["urn:ietf:wg:oauth:2.0:oob", "http://localhost"],
+                        "auth_uri":      "https://accounts.google.com/o/oauth2/auth",
+                        "token_uri":     "https://oauth2.googleapis.com/token",
+                    }
+                },
+                SCOPES
+            )
+            creds = flow.run_local_server(port=0, open_browser=True)
+
+        CREDENTIALS.parent.mkdir(parents=True, exist_ok=True)
+        CREDENTIALS.write_text(creds.to_json())
+
+    # Intercambiar Google token → Firebase ID token
+    url = (
+        f"https://identitytoolkit.googleapis.com/v1/"
+        f"accounts:signInWithIdp?key={FIREBASE_API_KEY}"
+    )
+    resp = requests.post(url, json={
+        "postBody":            f"access_token={creds.token}&providerId=google.com",
+        "requestUri":          "http://localhost",
+        "returnSecureToken":   True,
+        "returnIdpCredential": True,
+    }, timeout=15)
+    resp.raise_for_status()
+    return resp.json().get("idToken")
+
+
+def force_login():
+    """Elimina las credenciales guardadas y fuerza re-autenticación."""
+    if CREDENTIALS.exists():
+        CREDENTIALS.unlink()
+        click.echo("🗑️  Credentials cleared.")
+    click.echo("🔐 Opening browser for Google Sign-In...")
+    token = get_firebase_token()
+    if token:
+        click.echo("✅ Login successful. Credentials saved.")
+    else:
+        click.echo("❌ Login failed.", err=True)

ixentbench/cli.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+ixentbench/cli.py
+Punto de entrada CLI — comando `ixentbench`
+"""
+
+import click
+from ixentbench import __version__
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="ixentbench")
+def main():
+    """
+    iXentBench — The AI benchmark beyond memorization.
+
+    Causal spatial reasoning at 4×10⁸⁵ scale.
+    Developed by iXentLabs (iXent Games S.L.)
+    """
+    pass
+
+
+# =============================================================================
+# ixentbench play
+# =============================================================================
+@main.command()
+@click.option("--session",       required=True,  help="Session ID from iXentLabs web portal")
+@click.option("--prompt-file",   default=None,   help="Prompt Injection .txt (added to SYSTEM PROMPT)")
+@click.option("--strategy-file", default=None,   help="Strategy .txt (logged for Talent Hub, NOT sent to AI)")
+@click.option("--local-url",     default=None,   help="Local model URL — e.g. http://localhost:11434/v1")
+@click.option("--agent-script",  default=None,   help="Custom agent .py script path")
+def play(session, prompt_file, strategy_file, local_url, agent_script):
+    """Run iXentBench Solo (BYOK, Local model, Custom agent or Sponsored)."""
+    from ixentbench.play import run_play
+    run_play(
+        session_id    = session,
+        prompt_file   = prompt_file,
+        strategy_file = strategy_file,
+        local_url     = local_url,
+        agent_script  = agent_script,
+    )
+
+
+# =============================================================================
+# ixentbench arena
+# =============================================================================
+@main.group()
+def arena():
+    """iXentBench Arena — Multiplayer mode (1v1, 2v2, 4v4, Human vs AI)."""
+    pass
+
+
+@arena.command("create")
+@click.option("--mode",  default="1v1",
+              type=click.Choice(["1v1", "2v2", "4v4", "human"], case_sensitive=False),
+              help="Game mode")
+@click.option("--level", default=1, type=click.IntRange(1, 4), help="Level (1-4)")
+def arena_create(mode, level):
+    """Create a new Arena room. You become the host."""
+    from ixentbench.arena import create_room
+    create_room(mode=mode, level=level)
+
+
+@arena.command("join")
+@click.option("--room", required=True, help="Room code — e.g. IXENT-4X7K")
+def arena_join(room):
+    """Join an existing Arena room."""
+    from ixentbench.arena import join_room
+    join_room(room_code=room)
+
+
+# =============================================================================
+# ixentbench login / status / prompts
+# =============================================================================
+@main.command()
+def login():
+    """Force Google re-authentication."""
+    from ixentbench.auth import force_login
+    force_login()
+
+
+@main.command()
+def status():
+    """Show current credentials and session status."""
+    from ixentbench.config import show_status
+    show_status()
+
+
+@main.group()
+def prompts():
+    """Manage your saved Prompt Injection files."""
+    pass
+
+
+@prompts.command("list")
+def prompts_list():
+    """List all saved prompt injection files."""
+    from ixentbench.config import list_prompts
+    list_prompts()
+
+
+if __name__ == "__main__":
+    main()

ixentbench/config.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""
+ixentbench/config.py
+Constantes, carga del .env y utilidades de estado.
+"""
+
+import os
+import pathlib
+import click
+from dotenv import load_dotenv
+
+# ── Directorios locales ────────────────────────────────────────────────────
+IXENT_HOME     = pathlib.Path.home() / "ixentbench"
+PROMPTS_DIR    = IXENT_HOME / "prompts"
+STRATEGIES_DIR = IXENT_HOME / "strategies"
+CREDENTIALS    = IXENT_HOME / "credentials.json"
+
+for _d in [PROMPTS_DIR, STRATEGIES_DIR]:
+    _d.mkdir(parents=True, exist_ok=True)
+
+# ── Credenciales de iXentLabs — hardcodeadas en el paquete ────────────────
+# Estas son credenciales PÚBLICAS de tipo "Desktop App" en Google Cloud.
+# El CLIENT_ID y FIREBASE_API_KEY son identificadores de la aplicación,
+# no secretos del usuario. El OAUTH_CLIENT_SECRET de tipo Desktop App
+# es seguro hardcodear según el estándar OAuth 2.0 (RFC 8252).
+# El usuario NUNCA necesita configurar estos valores.
+FIREBASE_API_KEY    = "AIzaSyDXEL47mO93BA8W1TTXHHdWOIK4tFUnamo"
+OAUTH_CLIENT_ID     = "874064710861-dds7gf6e1qinl8c4lurs47od9cc5b0ll.apps.googleusercontent.com"
+OAUTH_CLIENT_SECRET = "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"
+
+# ── Cargar .env — solo secretos BYOK del usuario ──────────────────────────
+load_dotenv()
+
+GOOGLE_API_KEY    = os.getenv("GOOGLE_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+OPENAI_API_KEY    = os.getenv("OPENAI_API_KEY")
+LOCAL_MODEL_URL   = os.getenv("LOCAL_MODEL_URL")
+IXENT_SDK_URL     = os.getenv("IXENT_SDK_URL",
+    "https://ixent-solo-sdk-874064710861.us-central1.run.app")
+VISUALIZER_URL    = os.getenv("VISUALIZER_URL",
+    "https://project-8b3bc726-e144-49eb-a7e.web.app")
+
+
+def validate_env():
+    """Valida que las credenciales BYOK mínimas estén presentes."""
+    # Las credenciales de iXentLabs están hardcodeadas — no hay nada que validar.
+    # Solo verificamos que el usuario haya puesto al menos una API Key.
+    if not any([GOOGLE_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY, LOCAL_MODEL_URL]):
+        click.echo("❌ No API Key found in .env file.", err=True)
+        click.echo("   Add at least one of: GOOGLE_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY", err=True)
+        click.echo("   Or set LOCAL_MODEL_URL for a local model.", err=True)
+        raise SystemExit(1)
+
+
+def show_status():
+    """Muestra el estado actual de credenciales y sesión."""
+    click.echo("\n📊 iXentBench Status")
+    click.echo("─" * 40)
+    click.echo(f"  iXentLabs Auth:    ✅ Integrated")
+    click.echo(f"  Google API Key:    {'✅ Set' if GOOGLE_API_KEY    else '— Not set'}")
+    click.echo(f"  Anthropic API Key: {'✅ Set' if ANTHROPIC_API_KEY else '— Not set'}")
+    click.echo(f"  OpenAI API Key:    {'✅ Set' if OPENAI_API_KEY    else '— Not set'}")
+    click.echo(f"  Local Model URL:   {LOCAL_MODEL_URL or '— Not set'}")
+    click.echo(f"  Credentials:       {'✅ Saved' if CREDENTIALS.exists() else '⚠️  Run: ixentbench login'}")
+    click.echo(f"  SDK URL:           {IXENT_SDK_URL}")
+    click.echo(f"  Prompts saved:     {len(list(PROMPTS_DIR.glob('*.txt')))}")
+    click.echo(f"  Strategies saved:  {len(list(STRATEGIES_DIR.glob('*.txt')))}")
+    click.echo()
+
+
+def list_prompts():
+    """Lista los prompts guardados localmente."""
+    files = list(PROMPTS_DIR.glob("*.txt"))
+    if not files:
+        click.echo("📭 No saved prompts. Use --prompt-file to load one.")
+        return
+    click.echo(f"\n📄 Saved Prompt Injections ({len(files)}):")
+    for f in sorted(files):
+        click.echo(f"  → {f.name} ({f.stat().st_size} bytes)")
+    click.echo(f"\n  Folder: {PROMPTS_DIR}\n")

ixentbench/play.py

@@ -0,0 +1,455 @@
+# -*- coding: utf-8 -*-
+"""
+ixentbench/play.py
+Modo Solo — BYOK, Modelo Local, Agente Custom y Sponsored.
+"""
+
+import json
+import time
+import hashlib
+import pathlib
+import subprocess
+import webbrowser
+import sys
+import click
+import requests
+from ixentbench.auth import get_firebase_token
+from ixentbench.config import (
+    GOOGLE_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY,
+    LOCAL_MODEL_URL, IXENT_SDK_URL, VISUALIZER_URL,
+    PROMPTS_DIR, STRATEGIES_DIR, validate_env
+)
+
+
+# =============================================================================
+# HELPER: Carga de archivos opcionales
+# =============================================================================
+
+def _load_text_file(path: str, label: str, save_dir: pathlib.Path) -> str:
+    p = pathlib.Path(path)
+    if not p.exists():
+        click.echo(f"❌ File not found: {path}", err=True)
+        click.echo(f"   Tip: Your saved {label} files are in {save_dir}", err=True)
+        raise SystemExit(1)
+    content = p.read_text(encoding="utf-8").strip()
+    click.echo(f"📄 {label} loaded: {p.name} ({len(content)} chars)")
+    saved = save_dir / p.name
+    if not saved.exists():
+        saved.write_text(content, encoding="utf-8")
+        click.echo(f"   💾 Saved to: {saved}")
+    return content
+
+
+# =============================================================================
+# HELPER: Limpiar bloques markdown del JSON
+# =============================================================================
+
+def _strip_markdown(raw: str) -> str:
+    if raw.startswith("```"):
+        lines = raw.split("\n")
+        if lines[0].startswith("```"):  lines = lines[1:]
+        if lines[-1].startswith("```"): lines = lines[:-1]
+        raw = "\n".join(lines)
+    return raw.strip()
+
+
+# =============================================================================
+# MOTOR A: BYOK — API Key local del usuario
+# Soporta Gemini (Google), Claude (Anthropic) y GPT (OpenAI)
+# =============================================================================
+
+def _get_move_byok(model_name: str, system_prompt: str,
+                   state: dict, session: dict) -> tuple:
+    context_json = json.dumps({
+        "meta":           state["meta"],
+        "inventory":      state["data"]["inventory"],
+        "mice":           state["data"]["mice"],
+        "board_encoding": state["data"]["board_encoding"],
+        "history_full":   state["data"]["history"],
+    }, ensure_ascii=False)
+
+    user_msg = (
+        f"--- CURRENT SITUATION (TURN {state['meta']['turn']}) ---\n"
+        f"{context_json}\n"
+        f"TASK: Generate JSON response with your best move."
+    )
+
+    provider = session.get("provider", "google")
+    t0 = time.time()
+
+    try:
+        if provider == "google":
+            from google import genai
+            from google.genai import types
+            client   = genai.Client(api_key=GOOGLE_API_KEY)
+            response = client.models.generate_content(
+                model    = model_name,
+                contents = [system_prompt + "\n\n" + user_msg],
+                config   = types.GenerateContentConfig(
+                    response_mime_type="application/json"
+                )
+            )
+            raw     = response.text.strip()
+            usage   = response.usage_metadata
+            in_t    = getattr(usage, "prompt_token_count",     0) or 0
+            out_t   = getattr(usage, "candidates_token_count", 0) or 0
+            tot_t   = getattr(usage, "total_token_count",      0) or 0
+            think_t = max(0, tot_t - in_t - out_t)
+
+        elif provider == "anthropic":
+            import anthropic
+            client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+            msg    = client.messages.create(
+                model      = model_name,
+                max_tokens = 4096,
+                system     = system_prompt,
+                messages   = [{"role": "user", "content": user_msg}],
+            )
+            raw     = msg.content[0].text.strip()
+            in_t    = msg.usage.input_tokens
+            out_t   = msg.usage.output_tokens
+            tot_t   = in_t + out_t
+            think_t = 0
+
+        elif provider == "openai":
+            from openai import OpenAI
+            client = OpenAI(api_key=OPENAI_API_KEY)
+            resp   = client.chat.completions.create(
+                model    = model_name,
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user",   "content": user_msg},
+                ],
+                response_format={"type": "json_object"},
+            )
+            raw     = resp.choices[0].message.content.strip()
+            in_t    = resp.usage.prompt_tokens
+            out_t   = resp.usage.completion_tokens
+            tot_t   = resp.usage.total_tokens
+            think_t = 0
+
+        else:
+            click.echo(f"❌ Unknown provider: {provider}", err=True)
+            return None, "Unknown provider", None
+
+    except Exception as e:
+        click.echo(f"\n🛑 CRITICAL AI ERROR: {type(e).__name__}: {e}", err=True)
+        raise SystemExit(1)
+
+    inference_sec = round(time.time() - t0, 2)
+    gen_t = out_t + think_t
+    tps   = round(gen_t / inference_sec, 2) if inference_sec > 0 else 0
+    click.echo(f"   ⏱️  {inference_sec}s | {tps} TPS")
+
+    token_data = {
+        "input_tokens": in_t, "output_tokens": out_t,
+        "thinking_tokens": think_t, "total": tot_t,
+        "turn_inference_sec": inference_sec, "turn_tps": tps,
+        "is_local_hardware": False,
+    }
+
+    raw = _strip_markdown(raw)
+    try:
+        decision = json.loads(raw)
+        return decision.get("command"), decision.get("reasoning"), token_data
+    except json.JSONDecodeError as e:
+        click.echo(f"⚠️  JSON parse error: {e}")
+        return None, "Invalid Format", None
+
+
+# =============================================================================
+# MOTOR B: MODELO LOCAL — Ollama, LM Studio, llama.cpp...
+# Compatible con cualquier servidor que implemente la API de OpenAI
+# No requiere API Key. is_local_hardware=True excluye TPS del leaderboard
+# =============================================================================
+
+def _get_move_local(model_name: str, system_prompt: str,
+                    state: dict, local_url: str) -> tuple:
+    context_json = json.dumps({
+        "meta":           state["meta"],
+        "inventory":      state["data"]["inventory"],
+        "mice":           state["data"]["mice"],
+        "board_encoding": state["data"]["board_encoding"],
+        "history_full":   state["data"]["history"],
+    }, ensure_ascii=False)
+
+    user_msg = (
+        f"--- CURRENT SITUATION (TURN {state['meta']['turn']}) ---\n"
+        f"{context_json}\n"
+        f"TASK: Generate JSON response with your best move."
+    )
+
+    t0 = time.time()
+    try:
+        resp = requests.post(
+            f"{local_url}/chat/completions",
+            json={
+                "model":    model_name,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user",   "content": user_msg},
+                ],
+                "response_format": {"type": "json_object"},
+            },
+            timeout=610
+        )
+        resp.raise_for_status()
+        data    = resp.json()
+        raw     = data["choices"][0]["message"]["content"].strip()
+        in_t    = data.get("usage", {}).get("prompt_tokens", 0)
+        out_t   = data.get("usage", {}).get("completion_tokens", 0)
+        tot_t   = data.get("usage", {}).get("total_tokens", 0)
+        think_t = 0
+    except Exception as e:
+        click.echo(f"⚠️  Local model error: {e}")
+        return None, "Local model error", None
+
+    inference_sec = round(time.time() - t0, 2)
+    tps = round(out_t / inference_sec, 2) if inference_sec > 0 else 0
+    click.echo(f"   ⏱️  {inference_sec}s | {tps} TPS (local — excluded from leaderboard)")
+
+    token_data = {
+        "input_tokens": in_t, "output_tokens": out_t,
+        "thinking_tokens": think_t, "total": tot_t,
+        "turn_inference_sec": inference_sec, "turn_tps": tps,
+        "is_local_hardware": True,
+    }
+
+    raw = _strip_markdown(raw)
+    try:
+        decision = json.loads(raw)
+        return decision.get("command"), decision.get("reasoning"), token_data
+    except json.JSONDecodeError as e:
+        click.echo(f"⚠️  JSON parse error: {e}")
+        return None, "Invalid Format", None
+
+
+# =============================================================================
+# MOTOR C: AGENTE CUSTOM — Script Python del usuario
+# El script recibe el estado por stdin (JSON) y devuelve la jugada
+# por stdout (JSON): {"command": "...", "reasoning": "..."}
+# No requiere API Key ni conexión a internet
+# =============================================================================
+
+def _get_move_agent(agent_script: str, state: dict) -> tuple:
+    state_json = json.dumps(state, ensure_ascii=False)
+    t0 = time.time()
+    try:
+        result = subprocess.run(
+            [sys.executable, agent_script],
+            input          = state_json,
+            capture_output = True,
+            text           = True,
+            timeout        = 120
+        )
+        if result.returncode != 0:
+            click.echo(f"⚠️  Agent script error:\n{result.stderr[:300]}")
+            return None, "Agent error", None
+
+        raw           = result.stdout.strip()
+        inference_sec = round(time.time() - t0, 2)
+        click.echo(f"   ⏱️  Agent: {inference_sec}s (local script)")
+
+        token_data = {
+            "input_tokens": 0, "output_tokens": 0,
+            "thinking_tokens": 0, "total": 0,
+            "turn_inference_sec": inference_sec, "turn_tps": 0,
+            "is_local_hardware": True,
+        }
+        decision = json.loads(raw)
+        return decision.get("command"), decision.get("reasoning"), token_data
+
+    except subprocess.TimeoutExpired:
+        click.echo("⚠️  Agent script timed out (120s)")
+        return None, "Timeout", None
+    except json.JSONDecodeError as e:
+        click.echo(f"⚠️  Agent JSON parse error: {e}")
+        return None, "Invalid Format", None
+
+
+# =============================================================================
+# FUNCIÓN PRINCIPAL
+# =============================================================================
+
+def run_play(session_id: str, prompt_file: str | None,
+             strategy_file: str | None, local_url: str | None,
+             agent_script: str | None):
+
+    validate_env()
+
+    # ── Validaciones de flags ─────────────────────────────────────────────────
+    if prompt_file and strategy_file:
+        click.echo("❌ --prompt-file and --strategy-file are mutually exclusive.", err=True)
+        raise SystemExit(1)
+    if agent_script and (local_url or prompt_file):
+        click.echo("❌ --agent-script cannot be combined with --local-url or --prompt-file.", err=True)
+        raise SystemExit(1)
+
+    # ── Cargar archivos opcionales ────────────────────────────────────────────
+    prompt_text   = _load_text_file(prompt_file,   "Prompt Injection", PROMPTS_DIR)    if prompt_file   else None
+    strategy_text = _load_text_file(strategy_file, "Strategy",         STRATEGIES_DIR) if strategy_file else None
+    prompt_hash   = hashlib.sha256(prompt_text.encode()).hexdigest() if prompt_text else None
+
+    # ── Autenticación ─────────────────────────────────────────────────────────
+    click.echo("\n🔐 Authenticating with iXentLabs...")
+    jwt     = get_firebase_token()
+    headers = {"X-Firebase-Token": jwt, "Content-Type": "application/json"}
+    click.echo("✅ Login successful.")
+
+    # ── Iniciar partida ───────────────────────────────────────────────────────
+    click.echo(f"\n🎮 Validating session {session_id}...")
+    resp = requests.post(f"{IXENT_SDK_URL}/play", headers=headers, json={
+        "session_id":        session_id,
+        "prompt_injection":  prompt_text,
+        "prompt_hash":       prompt_hash,
+        "agent_description": strategy_text,
+        "is_local_model":    bool(local_url or agent_script),
+        "is_custom_agent":   bool(agent_script),
+    }, timeout=30)
+
+    if not resp.ok:
+        click.echo(f"❌ Server error: {resp.text}", err=True)
+        raise SystemExit(1)
+
+    game_data = resp.json()
+    if not game_data.get("success"):
+        click.echo(f"❌ {game_data.get('msg')}", err=True)
+        raise SystemExit(1)
+
+    game_player_id = game_data["game_player_id"]
+    current_state  = game_data["state"]
+    motor_url      = game_data["motor_url"]
+    model_name     = game_data.get("model", "AI Agent")
+    session_info   = game_data.get("session", {})
+    system_prompt  = game_data.get("system_prompt", "")
+    is_sponsored   = game_data.get("is_sponsored", False)
+    max_turns      = current_state.get("meta", {}).get("max_moves", 200) + 20
+
+    click.echo(f"✅ Game started — ID: {game_player_id}")
+    click.echo(f"   Model: {model_name} | Level: {game_data.get('level', '?')}")
+    if is_sponsored:
+        click.echo("   💳 Mode: iXentLabs Sponsored")
+    elif agent_script:
+        click.echo(f"   🤖 Mode: Custom Agent ({agent_script})")
+    elif local_url:
+        click.echo(f"   💻 Mode: Local Model ({local_url})")
+    else:
+        click.echo(f"   🔑 Mode: BYOK ({session_info.get('provider', 'google').capitalize()})")
+
+    # ── Abrir visualizador ────────────────────────────────────────────────────
+    game_id = current_state.get("meta", {}).get("live_game_id", "")
+    vis_url = f"{VISUALIZER_URL}?game_id={game_id}" if game_id else VISUALIZER_URL
+    webbrowser.open(vis_url)
+    click.echo(f"🌐 Visualizer: {vis_url}")
+
+    # ── Acumuladores de sesión ────────────────────────────────────────────────
+    s_tokens = s_input = s_output = s_thinking = s_secs = s_gen = 0
+
+    # ── Game loop ─────────────────────────────────────────────────────────────
+    click.echo("\n🚀 Game starting...\n")
+    turn          = 0
+    entropy_shown = False
+
+    while turn < max_turns:
+        turn += 1
+        click.echo(f"\n🧠 [TURN {turn}] {model_name} thinking...")
+
+        # Seleccionar motor
+        if agent_script:
+            cmd, reasoning, td = _get_move_agent(agent_script, current_state)
+        elif local_url:
+            cmd, reasoning, td = _get_move_local(model_name, system_prompt,
+                                                  current_state, local_url)
+        else:
+            # BYOK o Sponsored — en sponsored el servidor devuelve la jugada
+            cmd, reasoning, td = _get_move_byok(model_name, system_prompt,
+                                                 current_state, session_info)
+
+        if not cmd:
+            click.echo("⚠️  No valid move. Retrying...")
+            time.sleep(2)
+            continue
+
+        # Acumular métricas
+        if td:
+            s_tokens   += td["total"]
+            s_input    += td.get("input_tokens", 0)
+            s_output   += td.get("output_tokens", 0)
+            s_thinking += td.get("thinking_tokens", 0)
+            s_secs     += td.get("turn_inference_sec", 0)
+            s_gen      += td.get("output_tokens", 0) + td.get("thinking_tokens", 0)
+
+        avg_tps = round(s_gen / s_secs, 2) if s_secs > 0 else 0
+        click.echo(f"   📊 Tokens: {td['total'] if td else 0} (Session: {s_tokens})")
+        click.echo(f"   💭 {(reasoning or '—')[:120]}")
+        click.echo(f"   ⚡ {cmd}")
+
+        # Enviar jugada
+        try:
+            move_resp = requests.post(
+                f"{IXENT_SDK_URL}/move",
+                headers = headers,
+                json    = {
+                    "game_player_id": game_player_id,
+                    "command":        cmd,
+                    "reasoning":      reasoning,
+                    "motor_url":      motor_url,
+                    "token_usage": {
+                        "total":                 s_tokens,
+                        "total_input_tokens":    s_input,
+                        "total_output_tokens":   s_output,
+                        "total_thinking_tokens": s_thinking,
+                        "total_inference_sec":   round(s_secs, 2),
+                        "average_tps":           avg_tps,
+                        "turn_input_tokens":     td.get("input_tokens", 0)     if td else 0,
+                        "turn_output_tokens":    td.get("output_tokens", 0)    if td else 0,
+                        "turn_thinking_tokens":  td.get("thinking_tokens", 0)  if td else 0,
+                        "turn_inference_sec":    td.get("turn_inference_sec", 0) if td else 0,
+                        "turn_tps":              td.get("turn_tps", 0)         if td else 0,
+                        "is_local_hardware":     td.get("is_local_hardware", False) if td else False,
+                    }
+                },
+                timeout = 610
+            )
+            move_resp.raise_for_status()
+            data = move_resp.json()
+        except Exception as e:
+            click.echo(f"❌ Move error: {e}")
+            time.sleep(2)
+            continue
+
+        if not data.get("success", True):
+            click.echo(f"   🚫 REJECTED: {data.get('msg')}")
+            time.sleep(2)
+            continue
+
+        click.echo("   👍 ACCEPTED")
+        current_state = data.get("state", {})
+        gym           = data.get("gym_metrics", {})
+
+        # Detectar entropía
+        if not entropy_shown:
+            for entry in current_state.get("data", {}).get("history", []):
+                if "[EVENT]" in str(entry):
+                    click.echo(f"\n   ⚠️  ENTROPY EVENT: {entry}\n")
+                    entropy_shown = True
+                    break
+
+        # Detectar fin de partida
+        if (gym.get("terminated") or gym.get("truncated") or
+                current_state.get("status", {}).get("game_over")):
+            st     = current_state.get("status", {})
+            result = st.get("result", "UNKNOWN")
+            score  = current_state.get("scoring", {}).get("benchmark_score", {}).get("P1", 0)
+            mice   = st.get("mice_rescued", {}).get("P1", 0)
+            total  = st.get("total_mice_per_player", 0)
+            click.echo(f"\n{'🏆' if result == 'VICTORY' else '💀'} GAME OVER: {result}")
+            click.echo(f"   Score:   {score}")
+            click.echo(f"   Mice:    {mice}/{total}")
+            click.echo(f"   Turns:   {turn}")
+            click.echo(f"   Tokens:  {s_tokens}")
+            click.echo(f"   Time:    {round(s_secs, 1)}s")
+            click.echo(f"   Avg TPS: {avg_tps}")
+            break
+
+    click.echo("\n✅ Session complete.")

ixentbench-1.0.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: ixentbench
+Version: 1.0.0
+Summary: The AI benchmark beyond memorization — Causal spatial reasoning at 4×10⁸⁵ scale
+Author-email: iXentLabs <contact@ixentlabs.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://ixentlabs.com
+Project-URL: Repository, https://github.com/ixentlabs/ixentbench
+Project-URL: Documentation, https://github.com/ixentlabs/ixentbench#readme
+Keywords: ai,benchmark,reasoning,llm,evaluation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: requests>=2.31
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: google-genai>=1.0
+Requires-Dist: google-auth>=2.28
+Requires-Dist: google-auth-oauthlib>=1.2
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.25; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.30; extra == "openai"
+
+# iXentBench — The AI Benchmark Beyond Memorization
+
+Causal spatial reasoning at 4×10⁸⁵ scale, powered by **Caps i Caps** — the game that makes memorization impossible. 
+Developed by [iXentLabs](https://ixentlabs.com) (iXent Games S.L.)
+
+---
+
+## Installation
+
+```bash
+pip install ixentbench
+```
+
+---
+
+## Quick Start
+
+**1. Configure your session** at [ixentlabs.com](https://ixentlabs.com)  
+Login with Google, select benchmark type, level and AI model.  
+Download your `.env` file and add your API Key.
+
+**2. Run your session:**
+
+```bash
+ixentbench play --session YOUR_SESSION_ID
+```
+
+The visualizer opens automatically in your browser.
+
+---
+
+## Play Modes
+
+There are four ways to play iXentBench, designed for every type of participant — from AI engineers to pure mathematicians and AI enthusiasts.
+
+| Flag | A — BYOK | B — Local Model | C — Custom Agent | D — Sponsored |
+|---|---|---|---|---|
+| Uses LLM | ✅ Cloud API | ✅ Local | ❌ Pure code | ✅ iXentLabs |
+| API Key needed | ✅ Yours | ❌ No | ❌ No | ❌ No |
+| `--prompt-file` (optional) | ✅ Yes | ✅ Yes | ❌ No | ✅ Yes |
+| `--strategy-file` (optional)| ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
+
+---
+
+### A — BYOK (Bring Your Own Key)
+Use your own API Key from Gemini, Claude, GPT, ...  
+Your key **never leaves your machine** — it is read locally and never sent to our servers.
+
+```bash
+ixentbench play --session IQWUWP
+```
+
+`.env` file:
+```
+GOOGLE_API_KEY=your_key_here
+```
+
+---
+
+### B — Local Open Source Model
+Run any open source model (Llama, Mistral, Qwen...) locally using Ollama, LM Studio or llama.cpp.  
+No API Key required. Full privacy — no data leaves your machine.  
+⚠️ Inference speed metrics are excluded from global leaderboards (hardware-dependent).
+
+```bash
+# First start your local model, then:
+ixentbench play --session IQWUWP --local-url http://localhost:11434/v1
+```
+
+---
+
+### C — Custom Agent Script
+For engineers and researchers who want to solve iXentBench using **pure code** — no LLM required.  
+Write your own Python script using any algorithm you choose: Minimax, MCTS, A*, heuristics, neural networks trained from scratch — anything goes.
+
+Your script receives the full board state via `stdin` (JSON) and must return a move via `stdout` (JSON). It runs entirely on your machine.
+
+```bash
+ixentbench play --session IQWUWP --agent-script ./my_agent.py
+```
+
+Your script must output:
+```json
+{"command": "G4@P21(b=0)+90", "reasoning": "Explanation of your decision"}
+```
+
+> 💡 **Tip:** Even if your agent uses pure code, we strongly recommend adding a `--strategy-file` to explain your approach. Top results are presented to AI companies for talent opportunities (see Talent Hub below).
+
+---
+
+### D — iXentLabs Sponsored
+Select "Use iXentLabs credits" on the web — we provide the API Key.  
+No `.env` file needed. The cloud handles everything.
+
+```bash
+ixentbench play --session IQWUWP
+```
+
+---
+
+## Arena Mode (Multiplayer)
+
+```bash
+# Create a room (you become the host)
+ixentbench arena create --mode 4v4 --level 2
+
+# Join an existing room
+ixentbench arena join --room IXENT-4X7K
+```
+
+Supported modes: `1v1`, `2v2`, `4v4`, `human` (Human vs AI).
+
+---
+
+## Prompt Injection & Strategy Files
+
+### Prompt Injection (`--prompt-file`) — Optional
+Inject your own strategic prompt directly into the AI's System Prompt before the game starts.  
+Applies to modes **A, B and D** (LLM-based). Not applicable to mode C.
+
+```bash
+ixentbench play --session IQWUWP --prompt-file my_prompt.txt
+```
+
+> 💡 A well-crafted Prompt Injection can dramatically improve your AI's performance. Experiment freely — your injection is recorded alongside your results.
+
+### Strategy File (`--strategy-file`) — Optional
+A written description of your approach — how you designed your agent, what techniques you used, what insights guided your decisions.  
+**It is never sent to the AI.** It is stored securely and linked to your results for the Talent Hub.
+
+Applies to **all modes (A, B, C and D)**.
+
+```bash
+ixentbench play --session IQWUWP --strategy-file my_strategy.txt
+```
+
+> 💡 We strongly recommend always adding a Strategy File, especially for Custom Agents (mode C). It is your opportunity to showcase your thinking to the world's leading AI companies.
+
+---
+
+## 🏆 iXentLabs Talent Hub
+
+iXentBench is more than a benchmark — it is a **talent discovery platform**.
+
+With your explicit prior consent, iXentLabs will present the top results of each benchmark category to leading AI companies and research labs. This includes your performance metrics, your Prompt Injection (if any), and your Strategy File — giving organizations a rare window into the reasoning and engineering skills behind the results.
+
+> Your personal data (name, email, payment details) is always protected and never shared.  
+> Only anonymized benchmark data is presented, identified solely by your chosen nickname and avatar, unless you opt in to full visibility.
+
+If you achieve an exceptional result and want your work to be seen by the teams building the future of AI — **iXentBench is your stage**.
+
+---
+
+## Utility Commands
+
+```bash
+ixentbench login          # Force Google re-authentication
+ixentbench status         # Show credentials and session status
+ixentbench prompts list   # List your locally saved prompt files
+ixentbench --version      # Show version
+```
+
+---
+
+## Security
+
+- API Keys are **always read from your local `.env`** — never passed as arguments
+- Google authentication uses **OAuth 2.0** — credentials saved locally in `~/ixentbench/`
+- Game data (moves, reasoning, metrics) is stored by iXentLabs per our [Terms of Service](https://ixentlabs.com/terms)
+- Personal data (name, email) is protected per [Privacy Policy](https://ixentlabs.com/privacy)
+
+---
+
+## License
+
+Proprietary — © 2026 iXentLabs (iXent Games S.L.)  
+Contact: contact@ixentlabs.com

ixentbench-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ixentbench/__init__.py,sha256=V60_0fzMxT0e7CYtHjLHQfc7Weg-ngTf1WdlGqB6xJY,132
+ixentbench/arena.py,sha256=S58sCdwjZFza-VkAI4Cp6GqLD27s9ZzrB_o0tU7pTZc,2208
+ixentbench/auth.py,sha256=NWp3izjHASQCzzspnK7ZLBWsn2eBJOuO0_6qbCF2YEw,2954
+ixentbench/cli.py,sha256=geG1Zz41ZGIgycPhzEfdtEX5wzhIahhdQh3QunR5Gcs,3262
+ixentbench/config.py,sha256=ObuWFqk9U2PNimr_C3TPqufgp7i8mAEkYeyuK775HNo,3812
+ixentbench/play.py,sha256=AeFZGbJrcEkkNeX3YHQTM28wt0BhYnA3JfXbA41gbSQ,19382
+ixentbench-1.0.0.dist-info/METADATA,sha256=uToz1CxWyyEgfZnXtxxw14Rvapl_0OYNDoLrIQNAuLI,7202
+ixentbench-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ixentbench-1.0.0.dist-info/entry_points.txt,sha256=ItlV5TLM2OAxxpQMxUj8RCY6Tmw7ragofeul8nx3R0Y,51
+ixentbench-1.0.0.dist-info/top_level.txt,sha256=dPivHNeijwMN1FSGBgfUMCwYfJhG4YPV949EK4MjX_I,11
+ixentbench-1.0.0.dist-info/RECORD,,

ixentbench-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ixentbench-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ixentbench = ixentbench.cli:main

ixentbench-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ixentbench