hanuscode 1.0.0__py3-none-any.whl

hanus/plugins/arena.py

@@ -0,0 +1,630 @@
+# plugins/arena.py — Model Arena: Compare multiple models with a judge
+"""
+Plugin para comparar múltiples modelos en la misma tarea.
+Un modelo "juez" evalúa las respuestas de todos los modelos participantes.
+
+Uso:
+  /arena config                          — Ver configuración actual
+  /arena add <provider/model> [alias]   — Añadir modelo participante
+  /arena remove <alias>                  — Eliminar modelo participante
+  /arena judge <provider/model>          — Configurar modelo juez
+  /arena task <prompt>                   — Ejecutar tarea en todos los modelos
+  /arena run <prompt>                    — Ejecutar y evaluar con el juez
+  /arena compare <prompt>                — Ejecutar y mostrar comparación
+  /arena list                            — Listar modelos configurados
+  /arena clear                           — Limpiar configuración
+"""
+from __future__ import annotations
+import json
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+NAME = "arena"
+DESCRIPTION = "Model Arena: Compara múltiples modelos con un juez evaluador"
+USAGE = "<comando> [args...] | add <model> | judge <model> | run <prompt> | results"
+AGENT_DOC = """
+Plugin para comparar respuestas de múltiples modelos de IA.
+
+Comandos disponibles:
+- config                        — Ver configuración actual
+- add <provider/model> [alias]  — Añadir modelo participante (ej: add openai/gpt-4 gpt4)
+- remove <alias>                — Eliminar modelo participante
+- judge <provider/model>        — Configurar modelo juez (evalúa todas las respuestas)
+- task <prompt>                 — Ejecutar tarea en todos los modelos (sin juez)
+- run <prompt>                  — Ejecutar tarea y evaluar con el juez
+- compare <prompt>              — Ejecutar y mostrar comparación detallada
+- results                       — Ver últimos resultados guardados
+- list                          — Listar modelos configurados
+- clear                         — Limpiar toda la configuración
+
+Ejemplos:
+<run_plugin name="arena" args="add anthropic/claude-sonnet-4-6 claude"/>
+<run_plugin name="arena" args="add openai/gpt-4o gpt4"/>
+<run_plugin name="arena" args="judge anthropic/claude-opus-4-7"/>
+<run_plugin name="arena" args="run Explain quantum computing in 3 sentences"/>
+<run_plugin name="arena" args="results"/>
+"""
+
+# Configuración guardada
+CONFIG_FILE = Path.home() / ".hanus" / "arena_config.json"
+
+# System prompt para el juez
+JUDGE_PROMPT = """You are an expert judge evaluating AI model responses.
+
+You will receive:
+1. A task/prompt that was given to multiple AI models
+2. Responses from each model (identified by alias)
+
+Your job is to:
+1. Evaluate each response based on: accuracy, completeness, clarity, usefulness
+2. Rank the responses from best to worst
+3. Provide a brief justification for your ranking
+4. Assign a score (1-10) to each response
+
+Output your evaluation in this JSON format:
+{
+  "rankings": [
+    {"alias": "model_alias", "rank": 1, "score": 9.5, "strengths": ["..."], "weaknesses": ["..."]},
+    ...
+  ],
+  "best": "model_alias",
+  "summary": "Brief overall comparison..."
+}
+
+Be fair, objective, and thorough in your evaluation."""
+
+
+class ModelConfig:
+    """Configuración de un modelo participante."""
+
+    def __init__(self, provider: str, model_id: str, alias: str = ""):
+        self.provider = provider
+        self.model_id = model_id
+        self.alias = alias or f"{provider}/{model_id}"
+
+    def to_dict(self) -> dict:
+        return {
+            "provider": self.provider,
+            "model_id": self.model_id,
+            "alias": self.alias
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ModelConfig":
+        return cls(
+            provider=data.get("provider", ""),
+            model_id=data.get("model_id", ""),
+            alias=data.get("alias", "")
+        )
+
+    def __repr__(self) -> str:
+        return f"ModelConfig({self.alias}: {self.provider}/{self.model_id})"
+
+
+class ArenaConfig:
+    """Configuración del Arena."""
+
+    def __init__(self):
+        self.models: List[ModelConfig] = []
+        self.judge: Optional[ModelConfig] = None
+        self.last_results: List[dict] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "models": [m.to_dict() for m in self.models],
+            "judge": self.judge.to_dict() if self.judge else None,
+            "last_results": self.last_results
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ArenaConfig":
+        config = cls()
+        for m in data.get("models", []):
+            config.models.append(ModelConfig.from_dict(m))
+        if data.get("judge"):
+            config.judge = ModelConfig.from_dict(data["judge"])
+        config.last_results = data.get("last_results", [])
+        return config
+
+    def save(self):
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(self.to_dict(), indent=2), encoding="utf-8")
+
+    @classmethod
+    def load(cls) -> "ArenaConfig":
+        if not CONFIG_FILE.exists():
+            return cls()
+        try:
+            data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            return cls.from_dict(data)
+        except Exception:
+            return cls()
+
+
+# Estado global
+_config: Optional[ArenaConfig] = None
+
+
+def _get_config() -> ArenaConfig:
+    """Obtiene la configuración (desde cache o archivo)."""
+    global _config
+    if _config is None:
+        _config = ArenaConfig.load()
+    return _config
+
+
+def _get_connector(provider: str, model_id: str):
+    """Obtiene un conector para el modelo especificado."""
+    import sys
+    from hanus.connectors.registry import ConnectorRegistry
+    from hanus.config import HanusConfig
+
+    print(f"[Arena] 🔧 Creando conector para {provider}/{model_id}...", file=sys.stderr, flush=True)
+
+    config = HanusConfig.load()
+    config.provider = provider
+    config.model_id = model_id
+
+    try:
+        connector = ConnectorRegistry.get(provider, config.get_connector_config())
+        print(f"[Arena] ✓ Conector creado: {connector.__class__.__name__}", file=sys.stderr, flush=True)
+        return connector
+    except Exception as e:
+        print(f"[Arena] ❌ Error creando conector: {e}", file=sys.stderr, flush=True)
+        raise
+
+
+def _run_model(model: ModelConfig, prompt: str, system_prompt: str = "") -> dict:
+    """Ejecuta un prompt en un modelo y retorna el resultado."""
+    import sys
+    start_time = time.time()
+
+    # Print para indicar que el modelo está trabajando
+    print(f"\n[Arena] 🔄 Modelo {model.alias} ({model.provider}/{model.model_id}) está procesando...", file=sys.stderr, flush=True)
+
+    try:
+        connector = _get_connector(model.provider, model.model_id)
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        print(f"[Arena] 📤 Enviando prompt a {model.alias}...", file=sys.stderr, flush=True)
+        response = connector.chat(messages=messages)
+
+        elapsed = time.time() - start_time
+        print(f"[Arena] ✅ {model.alias} completado en {elapsed:.2f}s ({response.output_tokens} tokens)", file=sys.stderr, flush=True)
+
+        return {
+            "alias": model.alias,
+            "provider": model.provider,
+            "model_id": model.model_id,
+            "response": response.text,
+            "tokens_in": response.input_tokens,
+            "tokens_out": response.output_tokens,
+            "elapsed": elapsed,
+            "success": True,
+            "error": None
+        }
+
+    except Exception as e:
+        elapsed = time.time() - start_time
+        print(f"[Arena] ❌ Error en {model.alias}: {e}", file=sys.stderr, flush=True)
+        return {
+            "alias": model.alias,
+            "provider": model.provider,
+            "model_id": model.model_id,
+            "response": "",
+            "tokens_in": 0,
+            "tokens_out": 0,
+            "elapsed": elapsed,
+            "success": False,
+            "error": str(e)
+        }
+
+
+def _format_response(result: dict, max_lines: int = 20) -> str:
+    """Formatea una respuesta para mostrar."""
+    lines = []
+    lines.append(f"{'='*60}")
+    lines.append(f"Modelo: {result['alias']} ({result['provider']}/{result['model_id']})")
+
+    if not result['success']:
+        lines.append(f"ERROR: {result['error']}")
+        return "\n".join(lines)
+
+    lines.append(f"Tokens: {result['tokens_in']} in / {result['tokens_out']} out")
+    lines.append(f"Tiempo: {result['elapsed']:.2f}s")
+    lines.append(f"{'='*60}")
+
+    response_text = result['response']
+    response_lines = response_text.split('\n')
+
+    if len(response_lines) > max_lines:
+        shown = response_lines[:max_lines]
+        hidden = len(response_lines) - max_lines
+        lines.append('\n'.join(shown))
+        lines.append(f"\n... ({hidden} líneas omitidas)")
+    else:
+        lines.append(response_text)
+
+    return "\n".join(lines)
+
+
+def _format_judge_response(response: str) -> str:
+    """Formatea la respuesta del juez."""
+    import sys
+    lines = []
+    lines.append("=" * 60)
+    lines.append("JUICIO DEL MODELO JUEZ")
+    lines.append("=" * 60)
+
+    print(f"[Arena] 📋 Formateando respuesta del juez ({len(response)} chars)...", file=sys.stderr, flush=True)
+
+    # Si la respuesta está vacía
+    if not response or not response.strip():
+        lines.append("\n⚠️ El juez no devolvió respuesta.")
+        return "\n".join(lines)
+
+    # Limpiar respuesta: quitar bloques de código markdown
+    clean_response = response.strip()
+    if clean_response.startswith("```"):
+        # Quitar ```json o ``` del inicio
+        first_newline = clean_response.find('\n')
+        if first_newline != -1:
+            clean_response = clean_response[first_newline + 1:]
+        # Quitar ``` del final
+        if clean_response.endswith("```"):
+            clean_response = clean_response[:-3].strip()
+
+    # Intentar parsear JSON si es posible
+    try:
+        data = json.loads(clean_response)
+        print(f"[Arena] ✅ JSON parseado correctamente", file=sys.stderr, flush=True)
+        if "rankings" in data:
+            lines.append("\nRANKING FINAL:")
+            lines.append("-" * 40)
+            for r in data.get("rankings", []):
+                lines.append(f"\n{r.get('rank', '?')}. {r.get('alias', '?')} (Score: {r.get('score', '?')})")
+                if r.get("strengths"):
+                    lines.append(f"   Fortalezas: {', '.join(r['strengths'][:3])}")
+                if r.get("weaknesses"):
+                    lines.append(f"   Debilidades: {', '.join(r['weaknesses'][:3])}")
+
+            if data.get("best"):
+                lines.append(f"\n🏆 MEJOR: {data['best']}")
+
+            if data.get("summary"):
+                lines.append(f"\nRESUMEN: {data['summary']}")
+
+            return "\n".join(lines)
+    except (json.JSONDecodeError, TypeError) as e:
+        print(f"[Arena] ⚠️ JSON no válido, mostrando respuesta raw: {e}", file=sys.stderr, flush=True)
+
+    # Si no es JSON, mostrar respuesta completa sin truncar
+    lines.append("\nRespuesta del juez:")
+    lines.append("-" * 40)
+    lines.append(response)
+
+    return "\n".join(lines)
+
+
+def run(args: str = "") -> str:
+    """Punto de entrada del plugin."""
+    global _config
+
+    if not args.strip():
+        return f"Uso: {USAGE}\n\n{AGENT_DOC}"
+
+    parts = args.strip().split(maxsplit=2)
+    cmd = parts[0].lower()
+    cmd_args = parts[1:] if len(parts) > 1 else []
+
+    config = _get_config()
+
+    # ── CONFIG ──────────────────────────────────────────────────────────
+    if cmd == "config":
+        output = ["Configuración del Arena", "=" * 50]
+
+        if config.judge:
+            output.append(f"\nJuez: {config.judge.alias} ({config.judge.provider}/{config.judge.model_id})")
+        else:
+            output.append("\nJuez: No configurado")
+
+        if config.models:
+            output.append(f"\nModelos participantes ({len(config.models)}):")
+            for m in config.models:
+                output.append(f"  • {m.alias}: {m.provider}/{m.model_id}")
+        else:
+            output.append("\nModelos participantes: Ninguno")
+
+        output.append(f"\nArchivo: {CONFIG_FILE}")
+        return "\n".join(output)
+
+    # ── ADD ────────────────────────────────────────────────────────────
+    if cmd == "add":
+        if len(cmd_args) < 1:
+            return "Uso: arena add <provider/model> [alias]\nEjemplo: arena add anthropic/claude-sonnet-4-6 claude"
+
+        model_str = cmd_args[0]
+        alias = cmd_args[1] if len(cmd_args) > 1 else ""
+
+        if "/" not in model_str:
+            return "Formato inválido. Usa: provider/model (ej: anthropic/claude-sonnet-4-6)"
+
+        provider, model_id = model_str.split("/", 1)
+        if not alias:
+            alias = model_id.split("/")[-1] if "/" in model_id else model_id
+            alias = alias.replace("-", "_")[:20]
+
+        # Verificar que no exista
+        for m in config.models:
+            if m.alias == alias:
+                return f"Ya existe un modelo con alias '{alias}'. Usa: arena remove {alias} primero."
+
+        model = ModelConfig(provider=provider, model_id=model_id, alias=alias)
+        config.models.append(model)
+        config.save()
+
+        return f"✓ Modelo añadido: {alias} ({provider}/{model_id})\nTotal: {len(config.models)} modelos"
+
+    # ── REMOVE ─────────────────────────────────────────────────────────
+    if cmd == "remove":
+        if len(cmd_args) < 1:
+            return "Uso: arena remove <alias>"
+
+        alias = cmd_args[0]
+        original_count = len(config.models)
+        config.models = [m for m in config.models if m.alias != alias]
+
+        if len(config.models) == original_count:
+            return f"No se encontró modelo con alias '{alias}'"
+
+        config.save()
+        return f"✓ Modelo eliminado: {alias}\nTotal: {len(config.models)} modelos"
+
+    # ── JUDGE ───────────────────────────────────────────────────────────
+    if cmd == "judge":
+        if len(cmd_args) < 1:
+            if config.judge:
+                return f"Juez actual: {config.judge.alias} ({config.judge.provider}/{config.judge.model_id})\n\nPara cambiar: arena judge <provider/model>"
+            return "No hay juez configurado.\nUsa: arena judge <provider/model>"
+
+        model_str = cmd_args[0]
+
+        if "/" not in model_str:
+            return "Formato inválido. Usa: provider/model (ej: anthropic/claude-opus-4-7)"
+
+        provider, model_id = model_str.split("/", 1)
+        config.judge = ModelConfig(provider=provider, model_id=model_id, alias="judge")
+        config.save()
+
+        return f"✓ Juez configurado: {provider}/{model_id}"
+
+    # ── LIST ───────────────────────────────────────────────────────────
+    if cmd == "list":
+        output = ["Modelos en el Arena", "=" * 50]
+
+        if config.judge:
+            output.append(f"\n[JUEZ] {config.judge.alias}: {config.judge.provider}/{config.judge.model_id}")
+
+        if config.models:
+            output.append("\nParticipantes:")
+            for i, m in enumerate(config.models, 1):
+                output.append(f"  {i}. {m.alias}: {m.provider}/{m.model_id}")
+        else:
+            output.append("\nNo hay modelos participantes.")
+            output.append("Añade con: arena add <provider/model> [alias]")
+
+        return "\n".join(output)
+
+    # ── RESULTS ─────────────────────────────────────────────────────────
+    if cmd == "results":
+        if not config.last_results:
+            return "No hay resultados anteriores.\nUsa: arena run <prompt> o arena task <prompt>"
+
+        output = []
+
+        # Separar modelos participantes del juez
+        model_results = []
+        judge_result = None
+
+        for result in config.last_results:
+            if isinstance(result, dict) and "judge" in result:
+                judge_result = result["judge"]
+            elif isinstance(result, dict) and result.get("alias") == "judge":
+                judge_result = result
+            else:
+                model_results.append(result)
+
+        # Mostrar resultados de modelos participantes
+        if model_results:
+            output.append("=" * 60)
+            output.append("RESULTADOS DE MODELOS PARTICIPANTES")
+            output.append("=" * 60)
+            for i, result in enumerate(model_results, 1):
+                output.append(f"\n[{i}] {result.get('alias', 'Unknown')}")
+                output.append(f"    Status: {'✓ OK' if result.get('success') else '✗ Error'}")
+                output.append(f"    Tiempo: {result.get('elapsed', 0):.2f}s")
+                output.append(f"    Tokens: {result.get('tokens_out', 0)} out")
+
+        # Mostrar resultado del juez (esto es lo importante)
+        if judge_result:
+            output.append("\n" + "=" * 60)
+            output.append("EVALUACIÓN DEL JUEZ")
+            output.append("=" * 60)
+
+            if judge_result.get("success"):
+                output.append(_format_judge_response(judge_result.get("response", "")))
+            else:
+                output.append(f"\n❌ Error del juez: {judge_result.get('error', 'Unknown error')}")
+        else:
+            output.append("\n⚠️ No hay evaluación del juez guardada.")
+            output.append("Usa: arena run <prompt> para ejecutar con evaluación")
+
+        return "\n".join(output)
+
+    # ── JUDGE RESULT ─────────────────────────────────────────────────────
+    if cmd in ("judge_result", "juez"):
+        """Mostrar solo la respuesta del juez."""
+        if not config.last_results:
+            return "No hay resultados guardados.\nUsa: arena run <prompt> para ejecutar una evaluación."
+
+        judge_result = None
+        for result in config.last_results:
+            if isinstance(result, dict) and "judge" in result:
+                judge_result = result["judge"]
+                break
+            elif isinstance(result, dict) and result.get("alias") == "judge":
+                judge_result = result
+                break
+
+        if not judge_result:
+            return "No hay resultado del juez.\nUsa: arena run <prompt> para ejecutar con evaluación."
+
+        output = ["=" * 60]
+        output.append("RESPUESTA COMPLETA DEL JUEZ")
+        output.append("=" * 60)
+
+        if judge_result.get("success"):
+            output.append(f"\nModelo: {judge_result.get('provider', '?')}/{judge_result.get('model_id', '?')}")
+            output.append(f"Tiempo: {judge_result.get('elapsed', 0):.2f}s")
+            output.append(f"Tokens: {judge_result.get('tokens_out', 0)}")
+            output.append("")
+            output.append(_format_judge_response(judge_result.get("response", "")))
+        else:
+            output.append(f"\n❌ Error: {judge_result.get('error', 'Unknown error')}")
+
+        return "\n".join(output)
+
+    # ── CLEAR ───────────────────────────────────────────────────────────
+    if cmd == "clear":
+        config.models = []
+        config.judge = None
+        config.last_results = []
+        config.save()
+        return "✓ Configuración limpiada.\nUsa 'arena add' y 'arena judge' para configurar."
+
+    # ── TASK (solo ejecutar, sin juez) ───────────────────────────────────
+    if cmd == "task":
+        import sys
+        if len(cmd_args) < 1:
+            return "Uso: arena task <prompt>\nEjemplo: arena task Explain quantum computing"
+
+        if not config.models:
+            return "No hay modelos configurados.\nUsa: arena add <provider/model> [alias]"
+
+        prompt = " ".join(cmd_args)
+
+        print(f"\n[Arena] 🚀 Iniciando tarea en {len(config.models)} modelo(s)...", file=sys.stderr, flush=True)
+        print(f"[Arena] 📝 Prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}", file=sys.stderr, flush=True)
+
+        output = [f"Ejecutando tarea en {len(config.models)} modelos...", "=" * 50]
+        output.append(f"\nPrompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}")
+        output.append("")
+
+        results = []
+        for i, model in enumerate(config.models, 1):
+            print(f"[Arena] [{i}/{len(config.models)}] Preparando {model.alias}...", file=sys.stderr, flush=True)
+            output.append(f"\nEjecutando {model.alias}...")
+            result = _run_model(model, prompt)
+            results.append(result)
+            output.append(_format_response(result))
+
+        print(f"\n[Arena] ✅ Tarea completada en {len(config.models)} modelo(s)", file=sys.stderr, flush=True)
+
+        # Guardar resultados
+        config.last_results = results
+        config.save()
+
+        return "\n".join(output)
+
+    # ── RUN (ejecutar y evaluar con juez) ───────────────────────────────
+    if cmd in ("run", "compare"):
+        import sys
+        if len(cmd_args) < 1:
+            return f"Uso: arena {cmd} <prompt>\nEjemplo: arena run Explain quantum computing"
+
+        if not config.models:
+            return "No hay modelos configurados.\nUsa: arena add <provider/model> [alias]"
+
+        if not config.judge:
+            return "No hay juez configurado.\nUsa: arena judge <provider/model>"
+
+        prompt = " ".join(cmd_args)
+
+        print(f"\n[Arena] 🚀 ARENA MODE: Ejecutando en {len(config.models)} modelo(s) + juez", file=sys.stderr, flush=True)
+        print(f"[Arena] 📝 Prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}", file=sys.stderr, flush=True)
+
+        output = [f"Arena: Ejecutando tarea en {len(config.models)} modelos", "=" * 50]
+        output.append(f"\nPrompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}")
+
+        # Ejecutar en todos los modelos
+        results = []
+        for i, model in enumerate(config.models, 1):
+            print(f"[Arena] [{i}/{len(config.models)}] Ejecutando {model.alias} ({model.provider}/{model.model_id})...", file=sys.stderr, flush=True)
+            output.append(f"\n⏳ {model.alias} ({model.provider}/{model.model_id})...")
+            result = _run_model(model, prompt)
+            results.append(result)
+            status = "✓" if result['success'] else "✗"
+            output.append(f"  {status} Completado en {result['elapsed']:.2f}s ({result['tokens_out']} tokens)")
+
+        # Preparar input para el juez
+        print(f"[Arena] 📊 Preparando evaluación del juez...", file=sys.stderr, flush=True)
+        judge_input = f"""Task: {prompt}
+
+Responses from {len(results)} models:
+
+"""
+        for r in results:
+            judge_input += f"\n--- {r['alias']} ---\n{r['response']}\n"
+
+        judge_input += "\n\nEvaluate all responses and provide your ranking in JSON format."
+
+        # Ejecutar el juez
+        print(f"[Arena] ⚖️  Ejecutando juez ({config.judge.provider}/{config.judge.model_id})...", file=sys.stderr, flush=True)
+        output.append(f"\n{'='*50}")
+        output.append(f" Evaluando con el juez ({config.judge.provider}/{config.judge.model_id})...")
+        output.append(f"{'='*50}")
+
+        judge_result = _run_model(config.judge, judge_input, JUDGE_PROMPT)
+
+        if judge_result['success']:
+            print(f"[Arena] ✅ Evaluación completada", file=sys.stderr, flush=True)
+            output.append(_format_judge_response(judge_result['response']))
+        else:
+            print(f"[Arena] ❌ Error en evaluación: {judge_result['error']}", file=sys.stderr, flush=True)
+            output.append(f"Error del juez: {judge_result['error']}")
+
+        # Guardar resultados
+        config.last_results = results + [{"judge": judge_result}]
+        config.save()
+
+        print(f"\n[Arena] ✅ ARENA completado", file=sys.stderr, flush=True)
+        return "\n".join(output)
+
+    # Comando no reconocido
+    return f"""Comando desconocido: {cmd}
+
+Comandos disponibles:
+  config                        — Ver configuración actual
+  add <provider/model> [alias]  — Añadir modelo participante
+  remove <alias>                — Eliminar modelo participante
+  judge <provider/model>        — Configurar modelo juez
+  task <prompt>                 — Ejecutar tarea en todos los modelos (sin juez)
+  run <prompt>                  — Ejecutar y evaluar con el juez
+  compare <prompt>              — Ejecutar y mostrar comparación detallada
+  results                       — Ver últimos resultados (modelos + juez)
+  judge_result                  — Ver solo la respuesta del juez
+  list                          — Listar modelos configurados
+  clear                         — Limpiar configuración
+
+Ejemplo de uso:
+  arena add anthropic/claude-sonnet-4-6 claude
+  arena add openai/gpt-4o gpt4
+  arena judge anthropic/claude-opus-4-7
+  arena run Explain quantum computing in 3 sentences
+  arena judge_result              — Ver respuesta del juez"""