completion batch: arcprize__ARC-AGI

arcprize__ARC-AGI/arc_agi/__init__.py

@@ -0,0 +1,31 @@
+"""ARC-AGI package."""
+
+from .api import RestAPI
+from .base import Arcade, OperationMode
+from .local_wrapper import LocalEnvironmentWrapper
+from .models import APIError, EnvironmentInfo
+from .remote_wrapper import RemoteEnvironmentWrapper
+from .scorecard import (
+    EnvironmentScore,
+    EnvironmentScoreCalculator,
+    EnvironmentScorecard,
+    EnvironmentScoreList,
+    ScorecardManager,
+)
+from .wrapper import EnvironmentWrapper
+
+__all__ = [
+    "Arcade",
+    "EnvironmentInfo",
+    "EnvironmentWrapper",
+    "EnvironmentScore",
+    "EnvironmentScoreList",
+    "EnvironmentScoreCalculator",
+    "EnvironmentScorecard",
+    "LocalEnvironmentWrapper",
+    "OperationMode",
+    "RemoteEnvironmentWrapper",
+    "ScorecardManager",
+    "RestAPI",
+    "APIError",
+]

arcprize__ARC-AGI/arc_agi/api.py

@@ -0,0 +1,501 @@
+import json
+import os
+import threading
+import time
+import uuid
+from typing import Any, Callable, Optional, Tuple
+
+from arcengine import ActionInput, FrameData, FrameDataRaw, GameAction
+from flask import Response, jsonify, request
+from pydantic import ValidationError
+
+from .base import Arcade
+from .local_wrapper import LocalEnvironmentWrapper
+from .models import APIError
+from .scorecard import EnvironmentScorecard
+from .wrapper import EnvironmentWrapper
+
+MAX_OPAQUE_BYTES = 16 * 1024  # 16KiB (16384 bytes)
+
+
+class RestAPI:
+    def __init__(
+        self,
+        arcade: Arcade,
+        competition_mode: bool = False,
+        save_all_recordings: bool = False,
+        include_frame_data: bool = True,
+        add_cookie: Optional[Callable[[Response, str], Response]] = None,
+        on_scorecard_close: Optional[Callable[[EnvironmentScorecard], None]] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> None:
+        self.arcade = arcade
+        self.competition_mode = competition_mode
+        self.save_all_recordings = save_all_recordings
+        self.include_frame_data = include_frame_data
+        self.add_cookie = add_cookie
+        self.on_scorecard_close = on_scorecard_close
+        self._environmentCache: dict[str, EnvironmentWrapper] = {}
+        self._cache_lock = threading.Lock()
+        self.renderer = renderer
+        self.scorecard_openned = False
+        self.level_reset_only = os.getenv("ONLY_RESET_LEVELS") == "true"
+
+    def _json_with_cookie(
+        self,
+        data: Any,
+        *,
+        api_key: Optional[str] = None,
+    ) -> Response:
+        """Return JSON response with 200; optionally wrap response with add_cookie(response, api_key)."""
+        resp = jsonify(data)
+        if self.add_cookie is not None and api_key is not None:
+            resp = self.add_cookie(resp, api_key)
+        return resp
+
+    def get_games(self) -> Tuple[Response, int]:
+        out = [
+            e.model_dump(
+                mode="json",
+                exclude={"private_tags", "level_tags", "baseline_actions"},
+            )
+            for e in self.arcade.available_environments
+        ]
+        return jsonify(out), 200
+
+    def get_game_info(self, game_id: str) -> Tuple[Response, int]:
+        for env in self.arcade.available_environments:
+            if env.game_id == game_id or env.game_id.startswith(f"{game_id}-"):
+                return jsonify(
+                    env.model_dump(
+                        mode="json",
+                        exclude={
+                            "private_tags",
+                            "level_tags",
+                            "baseline_actions",
+                        },
+                    )
+                ), 200
+        return jsonify(
+            {
+                "error": APIError.SERVER_ERROR,
+                "message": f"game {game_id} not found",
+            }
+        ), 404
+
+    def get_scorecard(
+        self, card_id: Optional[str] = None, game_id: Optional[str] = None
+    ) -> Tuple[Response, int]:
+        api_key = request.headers.get("X-API-Key", "1234")
+        scorecard = (
+            self.arcade.scorecard_manager.get_scorecard(card_id, api_key)
+            if card_id
+            else None
+        )
+        if scorecard is None:
+            return jsonify(
+                {
+                    "error": APIError.SERVER_ERROR,
+                    "message": f"card_id `{card_id}` not found",
+                }
+            ), 404
+
+        if scorecard.competition_mode:
+            return jsonify(
+                {
+                    "error": APIError.SERVER_ERROR,
+                    "message": "cannot get scorecard that is in competition mode",
+                }
+            ), 403
+
+        if game_id is not None:
+            return self._json_with_cookie(
+                scorecard.get_json_for(game_id),
+                api_key=api_key,
+            ), 200
+        else:
+            envs = self.arcade.available_environments
+            if envs is None:
+                return jsonify(
+                    {
+                        "error": APIError.SERVER_ERROR,
+                        "message": "no environments available",
+                    }
+                ), 500
+            out = EnvironmentScorecard.from_scorecard(scorecard, envs)
+            out.api_key = None  # do not expose api_key
+            return self._json_with_cookie(
+                out.model_dump(exclude_none=True),
+                api_key=api_key,
+            ), 200
+
+    def new_scorecard(self) -> Tuple[Response, int]:
+        with self._cache_lock:
+            if self.competition_mode and self.scorecard_openned:
+                return jsonify(
+                    {
+                        "error": APIError.SERVER_ERROR,
+                        "message": "cannot open multiple scorecards in competition mode",
+                    }
+                ), 409
+            self.scorecard_openned = True
+
+        data = request.get_json()
+        if not isinstance(data, dict):
+            return jsonify({"error": "request body must be a JSON object"}), 400
+
+        # ----- opaque guard-rail -----------------------------------------
+        opaque = data.get("opaque")
+        try:
+            # stringify exactly the bytes we’ll send to Postgres
+            opaque_bytes = json.dumps(opaque, separators=(",", ":")).encode("utf-8")
+        except (TypeError, ValueError):
+            return jsonify({"error": "opaque must be JSON-serialisable"}), 400
+
+        if len(opaque_bytes) > MAX_OPAQUE_BYTES:
+            return jsonify({"error": "opaque exceeds 8 KB limit"}), 400
+        # -----------------------------------------------------------------
+
+        tags = data.get("tags", [])
+        if "human" not in tags and "agent" not in tags:
+            tags.append("agent")
+
+        source_url = data.get("source_url")
+        api_key = request.headers.get("X-API-Key", "1234")
+        competition_mode_raw = data.get("competition_mode")
+
+        competition_mode: bool | None = None
+
+        # if the server is in competition mode or the client is in competition mode, set competition_mode to True
+        if self.competition_mode or competition_mode_raw is not None:
+            competition_mode = True
+
+        card_id = self.arcade.scorecard_manager.new_scorecard(
+            source_url=source_url,
+            tags=tags,
+            api_key=api_key,
+            opaque=opaque,  # original Python value
+            competition_mode=competition_mode,
+        )
+        return self._json_with_cookie(
+            {"card_id": card_id},
+            api_key=api_key,
+        ), 200
+
+    def close_scorecard(self) -> Tuple[Response, int]:
+        data = request.get_json()
+        if not isinstance(data, dict) or "card_id" not in data:
+            return jsonify(
+                {
+                    "error": APIError.VALIDATION_ERROR.name,
+                    "message": "missing `card_id` in action data",
+                }
+            ), 400
+
+        api_key = request.headers.get("X-API-Key", "1234")
+
+        envs = self.arcade.available_environments
+
+        scorecard = self.arcade.scorecard_manager.get_scorecard(
+            data["card_id"], api_key
+        )
+        # IF this is a competition scorecard, we need to create all the environments for it
+        if (
+            scorecard is not None
+            and scorecard.competition_mode is not None
+            and scorecard.competition_mode
+        ):
+            for env in envs:
+                if not scorecard.has_environment(env.game_id):
+                    self.arcade.make(
+                        env.game_id,
+                        scorecard_id=scorecard.card_id,
+                        save_recording=self.save_all_recordings,
+                        include_frame_data=self.include_frame_data,
+                    )
+
+        api_key = request.headers.get("X-API-Key", "1234")
+        scorecard, guids, _ = self.arcade.scorecard_manager.close_scorecard(
+            data["card_id"], api_key
+        )
+        if scorecard is None:
+            return jsonify(
+                {
+                    "error": APIError.VALIDATION_ERROR.name,
+                    "message": f"scorecard {data['card_id']} not found",
+                }
+            ), 404
+
+        if envs is None:
+            return jsonify(
+                {
+                    "error": APIError.SERVER_ERROR,
+                    "message": "no environments available",
+                }
+            ), 500
+
+        out_internal = EnvironmentScorecard.from_scorecard(
+            scorecard, envs, do_private_tags=True
+        )
+        out = EnvironmentScorecard.from_scorecard(scorecard, envs)
+        if self.on_scorecard_close is not None:
+            self.on_scorecard_close(out_internal)
+        if guids is not None:
+            for guid in guids:
+                self.cleanup_environment(guid)
+        out.api_key = None  # do not expose api_key
+        return self._json_with_cookie(
+            out.model_dump(exclude_none=True),
+            api_key=api_key,
+        ), 200
+
+    def cmd(self, action: GameAction) -> Tuple[Response, int]:
+        data = request.get_json()
+
+        if not isinstance(data, dict) or "game_id" not in data:
+            return jsonify(
+                {
+                    "error": APIError.VALIDATION_ERROR.name,
+                    "message": "missing `game_id` in action data",
+                }
+            ), 400
+
+        try:
+            action.validate_data(data)
+        except ValidationError:
+            return jsonify(
+                {"error": APIError.VALIDATION_ERROR.name, "message": "{e}}"}
+            ), 400
+
+        out = {}
+        for field, model in action.action_type.model_fields.items():
+            out[field] = data[field]
+
+        api_key = request.headers.get("X-API-Key", "1234")
+        game_id = data["game_id"]
+
+        game, full_reset = self._get_or_create_environment(
+            game_id=game_id,
+            scorecard_id=data.get("card_id", None),
+            guid=data.get("guid", None),
+            api_key=api_key,
+        )
+
+        if game:
+            if game.api_key != api_key:  # type: ignore[attr-defined]
+                return jsonify(
+                    {
+                        "error": APIError.VALIDATION_ERROR.name,
+                        "message": f"game {game_id} with guid {data.get('guid', '')} does not match API key {api_key}",
+                    }
+                ), 400
+
+            guid = data.get("guid")
+            if action == GameAction.RESET:
+                if not guid:
+                    guid = game._guid
+
+            if not guid:
+                return jsonify(
+                    {
+                        "error": APIError.VALIDATION_ERROR.name,
+                        "message": "missing `guid` for any action other than RESET",
+                    }
+                ), 400
+
+            g = game
+
+            try:
+                input_action = ActionInput(
+                    id=action,
+                    data=out,
+                    reasoning=data.get("reasoning"),
+                )
+                # Only send the action if not a full reset (brand new game)
+
+                if not full_reset:
+                    if (
+                        action == GameAction.RESET
+                        and isinstance(g, LocalEnvironmentWrapper)
+                        and g._game is not None
+                    ):
+                        scorecard = self.arcade.scorecard_manager.get_scorecard(
+                            data.get("card_id", self.arcade.scorecard_manager.get_scorecard_from_guid(guid).card_id), api_key
+                        )
+                        # This is quite hacky as we have to look inside the underlying ARCBaseGame
+                        # to check if this is the first action of the level and would cause a full reset,
+                        if (
+                            scorecard is not None
+                            and scorecard.competition_mode
+                            and g._game._action_count == 0
+                        ):
+                            response = g.observation_space
+                            if response is not None:
+                                scorecard.update_scorecard(guid, response, full_reset)
+                        else:
+                            response = g.step(
+                                action=input_action.id,
+                                data=input_action.data,
+                                reasoning=input_action.reasoning,
+                            )
+                    else:
+                        response = g.step(
+                            action=input_action.id,
+                            data=input_action.data,
+                            reasoning=input_action.reasoning,
+                        )
+                else:
+                    response = g.observation_space
+                    if self.level_reset_only:
+                        scorecard = self.arcade.scorecard_manager.get_scorecard(
+                            data.get("card_id", None), api_key
+                        )
+                        if scorecard is not None and response is not None:
+                            scorecard.update_scorecard(guid, response, True)
+
+                if response is None:
+                    return jsonify(
+                        {
+                            "error": APIError.GAME_NOT_STARTED_ERROR.name,
+                            "message": f"game {game_id} is available but has not been started, send {GameAction.RESET.name} to begin playing",
+                        }
+                    ), 400
+                update = {
+                    "game_id": game_id,
+                    "levels_completed": response.levels_completed,
+                    "win_levels": response.win_levels,
+                    "frame": response.frame,
+                    "state": response.state,
+                    "guid": guid,
+                    "action_input": response.action_input,
+                    "available_actions": response.available_actions,
+                }
+                update["action_input"] = response.action_input
+                python_frame = FrameData(**update)
+
+                self._save_to_environment_cache(g, guid)
+
+                if python_frame.is_empty():
+                    return jsonify(
+                        {
+                            "error": APIError.GAME_NOT_STARTED_ERROR.name,
+                            "message": f"game {data['game_id']} is available but has not been started, send {GameAction.RESET.name} to begin playing",
+                        }
+                    ), 400
+
+                out = python_frame.model_dump()
+                out["state"] = out["state"].name
+                out["action_input"]["id"] = out["action_input"]["id"].value
+                return self._json_with_cookie(out, api_key=api_key), 200
+            except ValidationError as exc:
+                return jsonify(
+                    {
+                        "error": APIError.VALIDATION_ERROR.name,
+                        "message": f"error creating ActionInput: {exc}",
+                    }
+                ), 400
+
+        return jsonify(
+            {
+                "error": APIError.SERVER_ERROR.name,
+                "message": f"game {game_id} not found",
+            }
+        ), 400
+
+    def _get_or_create_environment(
+        self, game_id: str, scorecard_id: str | None, guid: str | None, api_key: str
+    ) -> tuple[EnvironmentWrapper | None, bool]:
+        with self._cache_lock:
+            game: Optional[EnvironmentWrapper] = None
+            # if there is a guid, try and find it from our cache
+            if guid and guid in self._environmentCache:
+                game = self._environmentCache.get(guid)
+                if game and game.environment_info.game_id == game_id:
+                    return game, False
+
+            if not scorecard_id:
+                return None, False
+
+            scorecard = self.arcade.scorecard_manager.get_scorecard(
+                scorecard_id, api_key
+            )
+            if scorecard is None:
+                return None, False
+            if scorecard.competition_mode and scorecard.has_environment(game_id):
+                return None, False
+
+            game = self.arcade.make(
+                game_id,
+                scorecard_id=scorecard_id,
+                save_recording=self.save_all_recordings,
+                include_frame_data=self.include_frame_data,
+                renderer=self.renderer,
+            )
+            if game is None:
+                return None, False
+            setattr(game, "api_key", api_key)
+            return game, True
+
+    def _save_to_environment_cache(
+        self, environment: EnvironmentWrapper, guid: str
+    ) -> None:
+        with self._cache_lock:
+            self._environmentCache[guid] = environment
+
+    def scorecard_cleanup_loop(self) -> None:
+        """Wake up every minute and close stale scorecards."""
+        while True:
+            time.sleep(60)
+            stale_ids = self.arcade.scorecard_manager.get_stale_cards()
+            mgr = self.arcade.scorecard_manager
+            for cid in stale_ids:
+                if not mgr.should_auto_close_scorecard(cid):
+                    self.arcade.logger.info(
+                        "[auto-close] scorecard %s no longer eligible for auto-close, skipping",
+                        cid,
+                    )
+                    continue
+                idle = mgr.idle_duration_for(cid)
+                idle_sec = idle.total_seconds() if idle is not None else -1.0
+                self.arcade.logger.info(
+                    "[auto-close] closing scorecard card_id=%s idle_seconds=%.1f "
+                    "threshold_seconds=%.1f",
+                    cid,
+                    idle_sec,
+                    mgr.idle_for.total_seconds(),
+                )
+                scorecard, guids, _ = self.arcade.scorecard_manager.close_scorecard(
+                    cid, None
+                )
+                if scorecard is not None:
+                    if self.arcade._on_scorecard_close is not None:
+                        env_scorecard = EnvironmentScorecard.from_scorecard(
+                            scorecard,
+                            self.arcade.available_environments,
+                            do_private_tags=True,
+                        )
+                        cb = self.arcade._on_scorecard_close
+                        log = self.arcade.logger
+
+                        def _run_close_hook() -> None:
+                            try:
+                                cb(env_scorecard)
+                            except Exception:
+                                log.exception(
+                                    "[auto-close] on_scorecard_close failed for card_id=%s",
+                                    env_scorecard.card_id,
+                                )
+
+                        threading.Thread(
+                            target=_run_close_hook,
+                            daemon=True,
+                            name=f"scorecard-close-{cid[:8]}",
+                        ).start()
+                    if guids is not None:
+                        for guid in guids:
+                            self.cleanup_environment(guid)
+
+    def cleanup_environment(self, guid: str) -> None:
+        with self._cache_lock:
+            if guid in self._environmentCache:
+                del self._environmentCache[guid]

arcprize__ARC-AGI/arc_agi/base.py

@@ -0,0 +1,1126 @@
+"""Base class for ARC-AGI-3 environments."""
+
+import logging
+import os
+import sys
+import threading
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import requests
+from arcengine import FrameDataRaw
+from dotenv import load_dotenv
+from flask import Flask, Response
+from pydantic import ValidationError
+
+from .local_wrapper import LocalEnvironmentWrapper
+from .models import EnvironmentInfo
+from .remote_wrapper import RemoteEnvironmentWrapper
+from .rendering import render_frames, render_frames_terminal
+from .scorecard import EnvironmentScorecard, ScorecardManager
+from .wrapper import EnvironmentWrapper
+
+# Load environment variables from .env and then .env.example
+# Handle missing files and permission errors gracefully
+try:
+    load_dotenv(dotenv_path=".env")
+except (OSError, PermissionError, FileNotFoundError):
+    pass
+
+
+try:
+    load_dotenv(dotenv_path=".env.example")
+except (OSError, PermissionError, FileNotFoundError):
+    pass
+
+
+class OperationMode(str, Enum):
+    """Mode for environment discovery and usage.
+
+    - NORMAL: Use both local environments and API (default).
+    - ONLINE: Use only remote environments via API.
+    - OFFLINE: Use only locally available environments.
+    """
+
+    NORMAL = "normal"
+    ONLINE = "online"
+    OFFLINE = "offline"
+    COMPETITION = "competition"
+
+
+class Arcade:
+    """Base class for ARC-AGI-3 environments.
+
+    This class handles configuration loading from environment variables and
+    constructor parameters. Environment variables are loaded from .env.example
+    and .env files using python-dotenv.
+    """
+
+    def __init__(
+        self,
+        arc_api_key: str = "",
+        arc_base_url: str = "https://three.arcprize.org",
+        operation_mode: OperationMode = OperationMode.NORMAL,
+        environments_dir: str = "environment_files",
+        recordings_dir: str = "recordings",
+        logger: Optional[logging.Logger] = None,
+    ) -> None:
+        """Initialize ARCAGI3 instance.
+
+        Args:
+            arc_api_key: API key for ARC API. Defaults to empty string.
+                Can be overridden by ARC_API_KEY environment variable.
+            arc_base_url: Base URL for ARC API. Defaults to "https://three.arcprize.org".
+                Can be overridden by ARC_BASE_URL environment variable.
+            operation_mode: NORMAL (local + API), ONLINE (API only), or OFFLINE (local only).
+                Defaults to NORMAL. Can be overridden by OPERATION_MODE env var
+                ("normal", "online", "offline", "competition").
+            environments_dir: Directory to scan for metadata.json files. Defaults to "environment_files".
+                Can be overridden by ENVIRONMENTS_DIR environment variable.
+            recordings_dir: Directory to save recordings. Defaults to "recordings".
+                Can be overridden by RECORDINGS_DIR environment variable.
+            logger: Optional logger instance. Defaults to a logger that logs to STDOUT.
+        """
+        # Priority order: constructor args > env vars > defaults
+
+        # arc_api_key: constructor arg > env var > default ""
+        if arc_api_key != "":
+            self.arc_api_key = arc_api_key
+        else:
+            self.arc_api_key = os.getenv("ARC_API_KEY", "")
+
+        # arc_base_url: constructor arg > env var > default URL
+        default_base_url = "https://three.arcprize.org"
+        if arc_base_url != default_base_url:
+            self.arc_base_url = arc_base_url
+        else:
+            self.arc_base_url = os.getenv("ARC_BASE_URL", default_base_url)
+
+        # Priority order for competition mode is different, the env var takes precedence over the constructor arg
+        env_operation_mode = self._parse_operation_mode_from_env()
+
+        self.operation_mode: OperationMode = operation_mode
+
+        # operation_mode: constructor arg > env var > default NORMAL
+        if (
+            env_operation_mode == OperationMode.COMPETITION
+            or self.operation_mode == OperationMode.NORMAL
+        ):
+            self.operation_mode = env_operation_mode
+
+        # environments_dir: constructor arg > env var > default
+        default_environments_dir = "environment_files"
+        if environments_dir != default_environments_dir:
+            self.environments_dir = environments_dir
+        else:
+            self.environments_dir = os.getenv(
+                "ENVIRONMENTS_DIR", default_environments_dir
+            )
+
+        # recordings_dir: constructor arg > env var > default
+        default_recordings_dir = "recordings"
+        if recordings_dir != default_recordings_dir:
+            self.recordings_dir = recordings_dir
+        else:
+            self.recordings_dir = os.getenv("RECORDINGS_DIR", default_recordings_dir)
+
+        # Set up logger - default to STDOUT if not provided
+        if logger is not None:
+            self.logger = logger
+        else:
+            self.logger = logging.getLogger(__name__)
+            self.logger.setLevel(logging.INFO)
+            # Remove existing handlers to avoid duplicates
+            self.logger.handlers.clear()
+            # Create STDOUT handler
+            stdout_handler = logging.StreamHandler(sys.stdout)
+            stdout_handler.setLevel(logging.INFO)
+            formatter = logging.Formatter(
+                "%(asctime)s | %(levelname)s | %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+            stdout_handler.setFormatter(formatter)
+            self.logger.addHandler(stdout_handler)
+
+        # Create scorecard manager
+        self.scorecard_manager = ScorecardManager(recordings_dir=self.recordings_dir)
+
+        # Store default scorecard_id (will be created on first make() call if needed)
+        self._default_scorecard_id: Optional[str] = None
+
+        # Scan for available environments
+        self.available_environments: list[EnvironmentInfo] = []
+        self._scan_for_environments()
+
+        if (
+            self.operation_mode == OperationMode.ONLINE
+            or self.operation_mode == OperationMode.COMPETITION
+        ):
+            self.headers = {
+                "X-API-Key": self.arc_api_key,
+                "Accept": "application/json",
+            }
+            self._session = requests.Session()
+            self._session.headers.update(self.headers)
+            self._master_cookie_jar = requests.cookies.RequestsCookieJar()
+
+        self._lock = threading.Lock()
+        self._cookie_lock = threading.Lock()
+
+        if self.arc_api_key == "" or self.arc_api_key is None:
+            if self.operation_mode != OperationMode.OFFLINE:
+                self.arc_api_key = self._get_anonymous_api_key()
+
+        # Fetch from API if not in offline mode
+        if self.operation_mode != OperationMode.OFFLINE:
+            self._fetch_from_api()
+
+        # Callback for when a scorecard is closed, defaults to None
+        # Set by listen_and_serve()
+        self.on_scorecard_close: Optional[Callable[[EnvironmentScorecard], None]] = None
+
+    def _parse_operation_mode_from_env(self) -> OperationMode:
+        """Resolve operation mode from env: OPERATION_MODE"""
+        env_op = os.getenv("OPERATION_MODE", "").strip().lower()
+        if env_op in ("normal", "online", "offline", "competition"):
+            return OperationMode(env_op)
+        return OperationMode.NORMAL
+
+    def _get_anonymous_api_key(self) -> str:
+        """Get an anonymous API key."""
+        url = f"{self.arc_base_url}/api/games/anonkey"
+        headers = {
+            "Accept": "application/json",
+        }
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        json_data = response.json()
+        if "api_key" in json_data:
+            key = json_data["api_key"]
+            self.logger.info(f"Got anonymous API key: {key}")
+            self.logger.info(f"You can register for an API key at {self.arc_base_url}")
+            return str(key)
+        return ""
+
+    def _scan_for_environments(self) -> None:
+        """Scan environments_dir for metadata.json files and load them as EnvironmentInfo."""
+        if self.environments_dir is None:
+            return
+
+        environments_path = Path(self.environments_dir)
+        if not environments_path.exists() or not environments_path.is_dir():
+            return
+
+        # Recursively find all metadata.json files
+        for metadata_file in environments_path.rglob("metadata.json"):
+            try:
+                # Read and parse the JSON file
+                json_data = metadata_file.read_text(encoding="utf-8")
+                env_info = EnvironmentInfo.model_validate_json(json_data)
+                # Set local_dir to the parent directory of metadata.json
+                env_info.local_dir = str(metadata_file.parent)
+                self.available_environments.append(env_info)
+            except Exception as e:
+                # Skip files that fail to load (invalid JSON, missing fields, etc.)
+                self.logger.warning(
+                    f"Failed to load metadata.json from {metadata_file}: {e}",
+                    exc_info=True,
+                )
+                continue
+
+    def _fetch_from_api(self) -> None:
+        """Fetch available environments from the API and merge with local environments."""
+        if not self.arc_api_key:
+            # Skip API call if no API key is provided
+            return
+
+        try:
+            url = f"{self.arc_base_url}/api/games"
+            headers = {
+                "X-Api-Key": self.arc_api_key,
+                "Accept": "application/json",
+            }
+
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+
+            # Parse response
+            games_data = response.json()
+
+            # Convert API response to EnvironmentInfo objects
+            api_environments: list[EnvironmentInfo] = []
+            for game_data in games_data:
+                try:
+                    # API may return different structure, adapt as needed
+                    # Assuming API returns list of dicts with at least game_id and title
+                    env_info = EnvironmentInfo(
+                        game_id=game_data.get("game_id", ""),
+                        title=game_data.get("title", ""),
+                        tags=game_data.get("tags", []),
+                        baseline_actions=game_data.get("baseline_actions", []),
+                        date_downloaded=game_data.get("date_downloaded"),
+                        class_name=game_data.get("class_name"),
+                    )
+                    api_environments.append(env_info)
+                except Exception as e:
+                    # Skip invalid entries
+                    game_id = game_data.get("game_id", "unknown")
+                    self.logger.warning(
+                        f"Failed to parse API environment entry (game_id: {game_id}): {e}",
+                        exc_info=True,
+                    )
+                    continue
+
+            # Merge with existing environments, removing duplicates by game_id
+            existing_game_ids = {env.game_id for env in self.available_environments}
+            for api_env in api_environments:
+                if api_env.game_id not in existing_game_ids:
+                    self.available_environments.append(api_env)
+                    existing_game_ids.add(api_env.game_id)
+
+            if api_environments:
+                self.logger.info(
+                    f"Successfully fetched {len(api_environments)} environment(s) from API"
+                )
+
+        except requests.exceptions.RequestException as e:
+            # Network or HTTP errors
+            self.logger.error(
+                f"Failed to fetch environments from API ({self.arc_base_url}/api/games): {e}",
+                exc_info=True,
+            )
+        except Exception as e:
+            # Other errors (invalid JSON, unexpected response format, etc.)
+            self.logger.error(
+                f"Unexpected error while fetching environments from API: {e}",
+                exc_info=True,
+            )
+
+    def get_environments(self) -> list[EnvironmentInfo]:
+        """Get the list of available environments.
+
+        Returns:
+            List of EnvironmentInfo objects representing available environments.
+        """
+        return self.available_environments
+
+    def _create_renderer_from_mode(
+        self,
+        render_mode: Optional[str],
+        renderer: Optional[Callable[[int, FrameDataRaw], None]],
+        environment_info: EnvironmentInfo,
+    ) -> Optional[Callable[[int, FrameDataRaw], None]]:
+        """Create a renderer callable from render_mode if needed.
+
+        Args:
+            render_mode: Optional render mode string ("human", "terminal", "terminal-fast").
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+            environment_info: EnvironmentInfo to get default_fps from.
+
+        Returns:
+            Renderer callable if render_mode or renderer is provided, None otherwise.
+        """
+        # If renderer is provided, use it directly
+        if renderer is not None:
+            return renderer
+
+        # If render_mode is provided, create a callable from it
+        if render_mode is not None:
+            default_fps = environment_info.default_fps
+            if render_mode == "terminal":
+                return lambda steps, frame_data: render_frames_terminal(
+                    steps=steps,
+                    frame_data=frame_data,
+                    default_fps=default_fps,
+                    scale=1,
+                )
+            if render_mode == "terminal-fast":
+                return lambda steps, frame_data: render_frames_terminal(
+                    steps=steps,
+                    frame_data=frame_data,
+                    default_fps=default_fps,
+                    scale=1,
+                    skip_deplay=True,
+                )
+            elif render_mode == "human":
+                return lambda steps, frame_data: render_frames(
+                    steps=steps,
+                    frame_data=frame_data,
+                    default_fps=default_fps,
+                    scale=4,
+                )
+            else:
+                self.logger.warning(
+                    f"Unknown render_mode: {render_mode}. No renderer will be used."
+                )
+                return None
+
+        return None
+
+    def open_scorecard(
+        self,
+        source_url: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        opaque: Optional[Any] = None,
+    ) -> str:
+        """Open a scorecard by ID.
+
+        Args:
+            scorecard_id: The ID of the scorecard to open.
+
+        Returns:
+            The EnvironmentScorecard object.
+        """
+        return self.create_scorecard(source_url, tags, opaque)
+
+    def create_scorecard(
+        self,
+        source_url: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        opaque: Optional[Any] = None,
+    ) -> str:
+        """Create a new scorecard.
+
+        Args:
+            source_url: Optional source URL for the scorecard.
+            tags: Optional list of tags for the scorecard.
+            opaque: Optional opaque data for the scorecard.
+
+        Returns:
+            The ID of the newly created scorecard.
+        """
+        with self._lock:
+            return self._create_scorecard_no_lock(source_url, tags, opaque)
+
+    def _create_scorecard_no_lock(
+        self,
+        source_url: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        opaque: Optional[Any] = None,
+    ) -> str:
+        """Create a new scorecard.
+
+        Args:
+            source_url: Optional source URL for the scorecard.
+            tags: Optional list of tags for the scorecard.
+            opaque: Optional opaque data for the scorecard.
+
+        Returns:
+            The ID of the newly created scorecard.
+        """
+        if (
+            self.operation_mode == OperationMode.ONLINE
+            or self.operation_mode == OperationMode.COMPETITION
+        ):
+            url = f"{self.arc_base_url}/api/scorecard/open"
+            headers = {
+                "X-API-Key": self.arc_api_key,
+                "Accept": "application/json",
+            }
+            payload: dict[str, Any] = {}
+            if tags is not None:
+                payload["tags"] = tags
+            else:
+                payload["tags"] = ["wrapper"]
+            if source_url is not None:
+                payload["source_url"] = source_url
+            if opaque is not None:
+                payload["opaque"] = opaque
+            if self.operation_mode == OperationMode.COMPETITION:
+                payload["competition_mode"] = True
+
+            with self._cookie_lock:
+                self._session.cookies.update(self._master_cookie_jar)  # type: ignore[no-untyped-call]
+
+            response = self._session.post(
+                url, headers=headers, json=payload, timeout=10
+            )
+
+            with self._cookie_lock:
+                self._master_cookie_jar.update(self._session.cookies)  # type: ignore[no-untyped-call]
+
+            response.raise_for_status()
+            card_id = response.json()["card_id"]
+            self.logger.info(f"Created new scorecard: {card_id}")
+            return str(card_id)
+
+        # Local scorecard (NORMAL or OFFLINE)
+        card_id = self.scorecard_manager.new_scorecard(
+            source_url=source_url,
+            tags=tags,
+            api_key=self.arc_api_key,
+            opaque=opaque,
+        )
+        self.logger.info(f"Created new scorecard: {card_id}")
+        return str(card_id)
+
+    def close_scorecard(
+        self, scorecard_id: Optional[str] = None
+    ) -> Optional[EnvironmentScorecard]:
+        with self._lock:
+            if scorecard_id is None:
+                scorecard_id = self._default_scorecard_id
+
+            if scorecard_id is None:
+                return None
+
+            if (
+                self.operation_mode == OperationMode.ONLINE
+                or self.operation_mode == OperationMode.COMPETITION
+            ):
+                url = f"{self.arc_base_url}/api/scorecard/close"
+                headers = {
+                    "X-API-Key": self.arc_api_key,
+                    "Accept": "application/json",
+                }
+                data = {
+                    "card_id": scorecard_id,
+                }
+
+                with self._cookie_lock:
+                    self._session.cookies.update(self._master_cookie_jar)  # type: ignore[no-untyped-call]
+
+                response = self._session.post(
+                    url, headers=headers, json=data, timeout=10
+                )
+
+                with self._cookie_lock:
+                    self._master_cookie_jar.update(self._session.cookies)  # type: ignore[no-untyped-call]
+
+                response.raise_for_status()
+                if scorecard_id == self._default_scorecard_id:
+                    self._default_scorecard_id = None
+                self.logger.info(f"Closed scorecard: {scorecard_id}")
+                return self._convert_scorecard_to_environment_scorecard(response.json())
+
+            scorecard, _, _ = self.scorecard_manager.close_scorecard(
+                scorecard_id, self.arc_api_key
+            )
+            if scorecard is None:
+                return None
+
+            # Convert to EnvironmentScorecard using available environments
+            out = EnvironmentScorecard.from_scorecard(
+                scorecard, self.available_environments
+            )
+            out.api_key = None
+            if scorecard_id == self._default_scorecard_id:
+                self._default_scorecard_id = None
+
+            self.logger.info(f"Closed scorecard: {scorecard_id}")
+            return out
+
+    def get_scorecard(
+        self, scorecard_id: Optional[str] = None
+    ) -> Optional[EnvironmentScorecard]:
+        """Get a scorecard by ID, converted to EnvironmentScorecard.
+
+        Args:
+            scorecard_id: Optional scorecard ID. If not provided, returns the default scorecard.
+
+        Returns:
+            EnvironmentScorecard object if found, None otherwise.
+        """
+        with self._lock:
+            if scorecard_id is None:
+                if self._default_scorecard_id is None:
+                    # Create default scorecard if it doesn't exist
+                    self._default_scorecard_id = self._create_scorecard_no_lock()
+                scorecard_id = self._default_scorecard_id
+
+            if (
+                self.operation_mode == OperationMode.ONLINE
+                or self.operation_mode == OperationMode.COMPETITION
+            ):
+                url = f"{self.arc_base_url}/api/scorecard/{scorecard_id}"
+                headers = {
+                    "X-API-Key": self.arc_api_key,
+                    "Accept": "application/json",
+                }
+                with self._cookie_lock:
+                    self._session.cookies.update(self._master_cookie_jar)  # type: ignore[no-untyped-call]
+
+                response = self._session.get(url, headers=headers, timeout=10)
+
+                with self._cookie_lock:
+                    self._master_cookie_jar.update(self._session.cookies)  # type: ignore[no-untyped-call]
+
+                response.raise_for_status()
+                return self._convert_scorecard_to_environment_scorecard(response.json())
+
+            # Get scorecard from manager
+            scorecard = self.scorecard_manager.get_scorecard(
+                scorecard_id, self.arc_api_key
+            )
+            if scorecard is None:
+                return None
+
+            # Convert to EnvironmentScorecard using available environments
+            out = EnvironmentScorecard.from_scorecard(
+                scorecard, self.available_environments
+            )
+            out.api_key = None
+            return out
+
+    def _convert_scorecard_to_environment_scorecard(
+        self, data: dict[str, Any]
+    ) -> EnvironmentScorecard:
+        """Convert a scorecard from the API to an EnvironmentScorecard."""
+        try:
+            if "open_at" in data:
+                del data["open_at"]
+            if "last_update" in data:
+                del data["last_update"]
+            out = EnvironmentScorecard.model_validate(data)
+        except ValidationError as e:
+            raise ValueError(f"Invalid EnvironmentScorecard from {data}: {e}") from e
+
+        out.api_key = None
+        return out
+
+    def make(
+        self,
+        game_id: str,
+        seed: int = 0,
+        scorecard_id: Optional[str] = None,
+        save_recording: bool = False,
+        include_frame_data: bool = True,
+        render_mode: Optional[str] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> Optional[EnvironmentWrapper]:
+        """Make (download and prepare) an environment.
+
+        Args:
+            game_id: Game identifier in format 'ls20' or 'ls20-1234abcd'.
+                The first 4 characters are the game_id, everything after '-' is the version.
+            scorecard_id: Optional scorecard ID for tracking runs. If not provided,
+                a new scorecard will be created and stored for subsequent calls.
+            save_recording: Whether to save recordings to JSONL file.
+            render_mode: Optional render mode string ("human", "terminal"). If provided,
+                creates a renderer callable automatically.
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+                If both render_mode and renderer are provided, renderer takes precedence.
+
+        Returns:
+            LocalEnvironmentWrapper object if successful, None otherwise.
+        """
+        with self._lock:
+            # If scorecard_id not provided, use or create default
+            if scorecard_id is None:
+                if self._default_scorecard_id is None:
+                    scorecard_id = self._create_scorecard_no_lock()
+                    self._default_scorecard_id = scorecard_id
+                scorecard_id = self._default_scorecard_id
+
+            # Split game_id into base_id and version
+            if "-" in game_id:
+                base_id, version = game_id.split("-", 1)
+            else:
+                base_id = game_id
+                version = None
+
+            # OFFLINE mode: search in scanned environments only
+            if self.operation_mode == OperationMode.OFFLINE:
+                return self._find_local_game(
+                    base_id,
+                    version,
+                    scorecard_id,
+                    save_recording,
+                    include_frame_data,
+                    seed,
+                    render_mode,
+                    renderer,
+                )
+
+            # NORMAL mode: download game and run locally
+            if self.operation_mode == OperationMode.NORMAL:
+                return self._download_game(
+                    base_id,
+                    version,
+                    scorecard_id,
+                    save_recording,
+                    include_frame_data,
+                    seed,
+                    render_mode,
+                    renderer,
+                )
+
+            # ONLINE mode: create remote wrapper
+            return self._create_remote_wrapper(
+                base_id,
+                version,
+                scorecard_id,
+                save_recording,
+                include_frame_data,
+                render_mode,
+                renderer,
+            )
+
+    def _find_local_game(
+        self,
+        game_id: str,
+        version: Optional[str],
+        scorecard_id: str,
+        save_recording: bool,
+        include_frame_data: bool,
+        seed: int = 0,
+        render_mode: Optional[str] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> Optional[LocalEnvironmentWrapper]:
+        """Find a local game from scanned environments.
+
+        Args:
+            game_id: 4-character game identifier.
+            version: Optional version string. If None, returns the latest downloaded version.
+            scorecard_id: Scorecard ID for tracking runs.
+
+        Returns:
+            LocalEnvironmentWrapper if found, None otherwise.
+        """
+        # Filter environments by base game_id (first 4 characters)
+        matching_envs = []
+        for env in self.available_environments:
+            # Extract base_id from env.game_id (e.g. "ls20" or "ls20-1234abcd")
+            env_base_id = env.game_id.split("-", 1)[0]
+            if env_base_id == game_id:
+                matching_envs.append(env)
+
+        if not matching_envs:
+            self.logger.error(
+                f"Game {game_id} not found in scanned environments. "
+                f"Available games: {sorted(set(e.game_id.split('-', 1)[0] for e in self.available_environments))}"
+            )
+            return None
+
+        # If version is specified, find exact match
+        if version:
+            for env in matching_envs:
+                # Extract version from env.game_id (everything after '-')
+                env_version = (
+                    env.game_id.split("-", 1)[1] if "-" in env.game_id else None
+                )
+                if env_version == version:
+                    if env.local_dir is None:
+                        self.logger.error(
+                            f"Found game {game_id}-{version} but local_dir is None"
+                        )
+                        return None
+                    return self._create_wrapper(
+                        env,
+                        scorecard_id,
+                        save_recording,
+                        include_frame_data,
+                        seed,
+                        render_mode,
+                        renderer,
+                    )
+
+            self.logger.error(
+                f"Game {game_id} with version {version} not found. "
+                f"Available versions: {[e.game_id.split('-')[1] if '-' in e.game_id else 'default' for e in matching_envs]}"
+            )
+            return None
+
+        # No version specified - return the latest downloaded one
+        # Sort by date_downloaded (most recent first)
+        matching_envs.sort(
+            key=lambda e: e.date_downloaded
+            or datetime.min.replace(tzinfo=timezone.utc),
+            reverse=True,
+        )
+        latest_env = matching_envs[0]
+
+        if latest_env.local_dir is None:
+            self.logger.error(f"Found game {game_id} but local_dir is None")
+            return None
+
+        self.logger.info(
+            f"Found latest version of {game_id}: {latest_env.game_id} "
+            f"(downloaded: {latest_env.date_downloaded})"
+        )
+        return self._create_wrapper(
+            latest_env,
+            scorecard_id,
+            save_recording,
+            include_frame_data,
+            seed,
+            render_mode,
+            renderer,
+        )
+
+    def _create_wrapper(
+        self,
+        env_info: EnvironmentInfo,
+        scorecard_id: str,
+        save_recording: bool,
+        include_frame_data: bool,
+        seed: int = 0,
+        render_mode: Optional[str] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> Optional[LocalEnvironmentWrapper]:
+        """Create a LocalEnvironmentWrapper from EnvironmentInfo.
+
+        Args:
+            env_info: EnvironmentInfo to wrap.
+            scorecard_id: Scorecard ID for tracking runs.
+            save_recording: Whether to save recordings.
+            render_mode: Optional render mode string ("human", "terminal").
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+
+        Returns:
+            LocalEnvironmentWrapper if successful, None otherwise.
+        """
+        # Create renderer callable from render_mode if needed
+        final_renderer = self._create_renderer_from_mode(
+            render_mode, renderer, env_info
+        )
+
+        try:
+            wrapper = LocalEnvironmentWrapper(
+                environment_info=env_info,
+                seed=seed,
+                logger=self.logger,
+                scorecard_id=scorecard_id,
+                save_recording=save_recording,
+                include_frame_data=include_frame_data,
+                recordings_dir=self.recordings_dir,
+                scorecard_manager=self.scorecard_manager,
+                renderer=final_renderer,
+            )
+            return wrapper
+        except Exception as e:
+            self.logger.error(
+                f"Failed to create LocalEnvironmentWrapper for {env_info.game_id}: {e}",
+                exc_info=True,
+            )
+            return None
+
+    def _fetch_metadata(
+        self,
+        game_id: str,
+    ) -> Optional[dict[str, Any]]:
+        """Fetch game metadata from the API.
+
+        Returns:
+            Metadata dictionary if successful, None otherwise.
+        """
+        if not self.arc_api_key:
+            self.logger.error("Cannot fetch metadata: no API key provided")
+            return None
+
+        metadata_url = f"{self.arc_base_url}/api/games/{game_id}"
+        headers = {
+            "X-Api-Key": self.arc_api_key,
+            "Accept": "application/json",
+        }
+
+        try:
+            response = requests.get(metadata_url, headers=headers, timeout=10)
+
+            if not response.ok:
+                self.logger.warning(
+                    "Failed to fetch metadata for game %s (status=%s): %s",
+                    game_id,
+                    response.status_code,
+                    response.text,
+                )
+                return None
+
+            metadata: dict[str, Any] = response.json()
+            self.logger.info("Successfully fetched metadata for game %s", game_id)
+            return metadata
+
+        except requests.exceptions.RequestException as e:
+            # Network errors, timeouts, DNS, connection refused, etc.
+            self.logger.error(
+                "Request error while fetching metadata for game %s: %s",
+                game_id,
+                e,
+                exc_info=True,
+            )
+            return None
+
+        except ValueError as e:
+            # JSON decode errors
+            self.logger.error(
+                "Invalid JSON returned for game %s: %s",
+                game_id,
+                e,
+                exc_info=True,
+            )
+            return None
+
+    def _create_remote_wrapper(
+        self,
+        game_id: str,
+        version: Optional[str],
+        scorecard_id: str,
+        save_recording: bool,
+        include_frame_data: bool,
+        render_mode: Optional[str] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> Optional[RemoteEnvironmentWrapper]:
+        """Create a RemoteEnvironmentWrapper for online-only mode.
+
+        Args:
+            game_id: 4-character game identifier.
+            version: Optional version string. If None, fetches from API.
+            scorecard_id: Scorecard ID for tracking runs.
+
+        Returns:
+            RemoteEnvironmentWrapper if successful, None otherwise.
+        """
+        if not self.arc_api_key:
+            self.logger.error("Cannot create remote wrapper: no API key provided")
+            return None
+
+        try:
+            # Fetch metadata to get exact game_id with version
+            metadata = self._fetch_metadata(game_id)
+            if metadata is None:
+                return None
+
+            # Get full game_id with version from metadata
+            full_game_id = metadata.get("game_id", game_id)
+            if version and full_game_id != f"{game_id}-{version}":
+                # If version was provided, construct full_game_id
+                full_game_id = f"{game_id}-{version}"
+            elif not version and "-" not in full_game_id:
+                # If no version in metadata, we need to get it from the API response
+                # For now, use the game_id from metadata
+                self.logger.warning(
+                    f"Could not determine version for {game_id}, using {full_game_id}"
+                )
+
+            # Create EnvironmentInfo from metadata
+            env_info = EnvironmentInfo(
+                game_id=metadata.get("game_id", full_game_id),
+                title=metadata.get("title", game_id),
+                tags=metadata.get("tags", []),
+                baseline_actions=metadata.get("baseline_actions", []),
+                date_downloaded=metadata.get("date_downloaded"),
+                class_name=metadata.get("class_name"),
+            )
+            # local_dir is None for remote environments
+            env_info.local_dir = None
+
+            # Create renderer callable from render_mode if needed
+            final_renderer = self._create_renderer_from_mode(
+                render_mode, renderer, env_info
+            )
+
+            # Create RemoteEnvironmentWrapper
+            wrapper = RemoteEnvironmentWrapper(
+                base_url=self.arc_base_url,
+                environment_info=env_info,
+                arc_api_key=self.arc_api_key,
+                logger=self.logger,
+                scorecard_id=scorecard_id,
+                save_recording=save_recording,
+                include_frame_data=include_frame_data,
+                recordings_dir=self.recordings_dir,
+                scorecard_manager=self.scorecard_manager,
+                renderer=final_renderer,
+                master_cookie_jar=self._session.cookies,
+                cookie_lock=self._cookie_lock,
+            )
+            return wrapper
+
+        except Exception as e:
+            self.logger.error(
+                f"Unexpected error while creating remote wrapper for {game_id}: {e}",
+                exc_info=True,
+            )
+            return None
+
+    def _download_game(
+        self,
+        game_id: str,
+        version: Optional[str],
+        scorecard_id: str,
+        save_recording: bool,
+        include_frame_data: bool,
+        seed: int = 0,
+        render_mode: Optional[str] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> Optional[LocalEnvironmentWrapper]:
+        """Download game metadata and source from API.
+
+        Args:
+            game_id: 4-character game identifier.
+            version: Optional version string.
+            scorecard_id: Scorecard ID for tracking runs.
+
+        Returns:
+            LocalEnvironmentWrapper if successful, None otherwise.
+        """
+        if not self.arc_api_key:
+            self.logger.error("Cannot download game: no API key provided")
+            return None
+
+        try:
+            # Fetch metadata
+            metadata = self._fetch_metadata(game_id)
+            if metadata is None:
+                return self._find_local_game(
+                    game_id,
+                    version,
+                    scorecard_id,
+                    save_recording,
+                    include_frame_data,
+                    seed,
+                    render_mode,
+                    renderer,
+                )
+
+            # Get version from metadata if not provided
+            if version is None:
+                version = (
+                    metadata.get("version")
+                    or metadata.get("game_id", "").split("-")[-1]
+                    if "-" in metadata.get("game_id", "")
+                    else None
+                )
+
+            # Create directory structure: {environment_files}/{game_id}/{version}
+            env_dir = Path(self.environments_dir) / game_id
+            if version:
+                env_dir = env_dir / version
+            env_dir.mkdir(parents=True, exist_ok=True)
+
+            # Add date_downloaded to metadata before saving
+            date_downloaded = datetime.now(timezone.utc)
+            metadata["tags"] = metadata.get("tags", [])
+            metadata["baseline_actions"] = metadata.get("baseline_actions", [])
+            metadata["local_dir"] = str(env_dir)
+            metadata["date_downloaded"] = date_downloaded.isoformat()
+
+            # Save metadata.json
+            metadata_file = env_dir / "metadata.json"
+            import json
+
+            # Get class_name from metadata or default to game_id
+            class_name = metadata.get("class_name")
+            if not class_name:
+                # Generate from game_id (first 4 chars, capitalize first letter)
+                class_name = game_id[0].upper() + game_id[1:] if game_id else "Game"
+
+            # Create EnvironmentInfo
+            env_info = EnvironmentInfo(
+                game_id=metadata.get(
+                    "game_id", f"{game_id}-{version}" if version else game_id
+                ),
+                title=metadata.get("title", game_id),
+                tags=metadata.get("tags", []),
+                baseline_actions=metadata.get("baseline_actions", []),
+                date_downloaded=date_downloaded,
+                class_name=class_name,
+            )
+            env_info.local_dir = str(env_dir)
+
+            metadata_file.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+
+            # Check if game_class is already in the directory
+            game_class_file = env_dir / f"{class_name.lower()}.py"
+            if game_class_file.exists():
+                return self._create_wrapper(
+                    env_info,
+                    scorecard_id,
+                    save_recording,
+                    include_frame_data,
+                    seed,
+                    render_mode,
+                    renderer,
+                )
+
+            # Download source code
+            source_url = f"{self.arc_base_url}/api/games/{game_id}-{version}/source"
+            headers = {
+                "X-Api-Key": self.arc_api_key,
+                "Accept": "application/json",
+            }
+            source_response = requests.get(source_url, headers=headers, timeout=10)
+            source_response.raise_for_status()
+            source_code = source_response.text
+
+            # Determine Python filename from class_name in metadata
+            class_name = metadata.get("class_name")
+            if not class_name:
+                # Generate from game_id (first 4 chars, capitalize first letter)
+                class_name = game_id[0].upper() + game_id[1:] if game_id else "Game"
+
+            # Save source code
+            source_file = env_dir / f"{class_name.lower()}.py"
+            source_file.write_text(source_code, encoding="utf-8")
+
+            self.logger.info(
+                f"Successfully downloaded game {game_id} (version: {version}) to {env_dir}"
+            )
+
+            # Create and return LocalEnvironmentWrapper
+            return self._create_wrapper(
+                env_info,
+                scorecard_id,
+                save_recording,
+                include_frame_data,
+                seed,
+                render_mode,
+                renderer,
+            )
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(
+                f"Failed to download game {game_id} from API: {e}",
+                exc_info=True,
+            )
+            return None
+        except Exception as e:
+            self.logger.error(
+                f"Unexpected error while downloading game {game_id}: {e}",
+                exc_info=True,
+            )
+            return None
+
+    def listen_and_serve(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8001,
+        competition_mode: bool = False,
+        save_all_recordings: bool = False,
+        include_frame_data: bool = True,
+        add_cookie: Optional[Callable[[Response, str], Response]] = None,
+        scorecard_timeout: Optional[int] = None,
+        on_scorecard_close: Optional[Callable[[EnvironmentScorecard], None]] = None,
+        extra_api_routes: Optional[Callable[["Arcade", Flask], None]] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Spin up a Flask server (blocking). Uses arc_agi.server.create_app()."""
+        from .server import create_app
+
+        app, api = create_app(
+            self,
+            competition_mode=competition_mode,
+            save_all_recordings=save_all_recordings,
+            include_frame_data=include_frame_data,
+            add_cookie=add_cookie,
+            on_scorecard_close=on_scorecard_close,
+            renderer=renderer,
+        )
+        app.debug = False
+        app.threaded = True  # False increases stability
+
+        if on_scorecard_close is not None:
+            self._on_scorecard_close = on_scorecard_close
+            cleaner = threading.Thread(target=api.scorecard_cleanup_loop, daemon=True)
+            cleaner.start()
+
+        if extra_api_routes is not None:
+            extra_api_routes(self, app)
+
+        if scorecard_timeout is not None:
+            self.scorecard_manager.set_idle_for(scorecard_timeout)
+
+        app.run(host=host, port=port, **kwargs)

arcprize__ARC-AGI/arc_agi/local_wrapper.py

@@ -0,0 +1,251 @@
+"""Local environment wrapper for ARC-AGI-3 environments."""
+
+import importlib.util
+import inspect
+import logging
+import threading
+import uuid
+from pathlib import Path
+from typing import Any, Callable, Optional, Type, cast
+
+from arcengine import ARCBaseGame, FrameDataRaw, GameAction
+
+from .models import EnvironmentInfo
+from .wrapper import EnvironmentWrapper
+
+# Resolved game file + class name -> ARCBaseGame subclass (avoid repeated exec per process)
+_game_class_cache: dict[str, Type[ARCBaseGame]] = {}
+_game_class_cache_lock = threading.Lock()
+
+
+class LocalEnvironmentWrapper(EnvironmentWrapper):
+    """Wrapper for running ARC-AGI-3 environments locally.
+
+    This wrapper dynamically loads and instantiates game classes from local files.
+    """
+
+    def __init__(
+        self,
+        environment_info: EnvironmentInfo,
+        logger: logging.Logger,
+        scorecard_id: str,
+        seed: int = 0,
+        save_recording: bool = False,
+        include_frame_data: bool = True,
+        recordings_dir: str = "recordings",
+        scorecard_manager: Optional[Any] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> None:
+        """Initialize the local environment wrapper.
+
+        Args:
+            environment_info: Information about the environment.
+            logger: Logger instance for logging.
+            scorecard_id: Scorecard ID for tracking runs.
+            save_recording: Whether to save recordings to JSONL file.
+            include_frame_data: Whether to include frame data in the recording file.
+            recordings_dir: Directory to save recordings.
+            scorecard_manager: Optional scorecard manager for tracking.
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+        """
+        super().__init__(
+            environment_info,
+            logger,
+            scorecard_id,
+            save_recording,
+            include_frame_data,
+            recordings_dir,
+            scorecard_manager,
+            renderer,
+        )
+
+        # Generate UUID for guid (local environments don't get guid from API)
+        self._guid = str(uuid.uuid4())
+
+        # Setup recording file now that guid is set
+        if self.save_recording:
+            self._setup_recording_file()
+
+        self._game: Optional[ARCBaseGame] = None
+        self._game_class: Optional[Type[ARCBaseGame]] = None
+
+        # Load the game class
+        if self.environment_info.local_dir is None:
+            self.logger.error(
+                f"Cannot load local environment {self.environment_info.game_id}: "
+                "local_dir is None"
+            )
+            return
+
+        self._load_game_class(seed)
+        self.reset()
+
+    def _load_game_class(self, seed: int = 0) -> None:
+        """Dynamically load the game class from the local directory."""
+        if self.environment_info.local_dir is None:
+            return
+
+        local_dir = Path(self.environment_info.local_dir)
+        class_name = self.environment_info.class_name
+
+        if not class_name:
+            self.logger.error(
+                f"Cannot load game class: class_name is not set for {self.environment_info.game_id}"
+            )
+            return
+
+        # Find the Python file (try both class_name and lowercase version)
+        candidates = [
+            local_dir / f"{class_name.lower()}.py",
+            local_dir / f"{class_name}.py",
+        ]
+
+        game_file = next((p for p in candidates if p.exists()), None)
+        if game_file is None:
+            self.logger.error(
+                f"Game source file not found. Looked in: {', '.join(str(p) for p in candidates)}"
+            )
+            return
+
+        cache_key = f"{game_file.resolve()}::{class_name}"
+
+        with _game_class_cache_lock:
+            cls = _game_class_cache.get(cache_key)
+
+        loaded_from_cache = cls is not None
+
+        if cls is None:
+            try:
+                source_code = game_file.read_text(encoding="utf-8")
+            except Exception as e:
+                self.logger.exception(
+                    f"Failed to read game source from {game_file}: {e}"
+                )
+                return
+
+            module_name = f"arc_agi_3.{self.environment_info.game_id}"
+            spec = importlib.util.spec_from_loader(module_name, loader=None)
+            if spec is None:
+                self.logger.error(f"Could not create module spec for {module_name}")
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            try:
+                exec(source_code, module.__dict__)
+            except Exception as e:
+                self.logger.exception(
+                    f"Error executing game source for {self.environment_info.game_id}: {e}"
+                )
+                return
+
+            loaded: Any | None = getattr(module, class_name, None)
+            if loaded is None or not isinstance(loaded, type):
+                self.logger.error(
+                    f"Expected class `{class_name}` not found in {game_file}"
+                )
+                return
+
+            if not issubclass(loaded, ARCBaseGame):
+                self.logger.error(
+                    f"Class `{class_name}` exists but is not a subclass of ARCBaseGame"
+                )
+                return
+
+            with _game_class_cache_lock:
+                cls = _game_class_cache.get(cache_key)
+                if cls is None:
+                    _game_class_cache[cache_key] = loaded
+                    cls = loaded
+                # else: another thread populated the cache first; use cached class
+
+        self._game_class = cls
+
+        sig = inspect.signature(cls)
+        if seed is not None and "seed" in sig.parameters:
+            kwargs = {"seed": seed}
+        else:
+            kwargs = {}
+
+        self._game = cls(**kwargs)  # type: ignore[arg-type]
+        if loaded_from_cache:
+            self.logger.debug(
+                "Instantiated %s from game class cache (%s)",
+                class_name,
+                cache_key,
+            )
+        else:
+            self.logger.info(
+                f"Successfully loaded game class {class_name} from {game_file}"
+            )
+
+    def reset(self) -> Optional[FrameDataRaw]:
+        """Reset the environment and return the initial frame data.
+
+        Returns:
+            FrameDataRaw object with initial game state, or None if reset failed.
+        """
+        if self._game is None:
+            self.logger.error("Cannot reset: game not loaded")
+            return None
+
+        try:
+            from arcengine import ActionInput
+
+            # Perform reset action and get frame data
+            reset_action = ActionInput(id=GameAction.RESET)
+            frame_data = cast(
+                FrameDataRaw, self._game.perform_action(reset_action, raw=True)
+            )
+            # Set guid in frame_data for local environments
+            frame_data.guid = self._guid
+            frame_data.game_id = self.environment_info.game_id
+            self._set_last_response(frame_data)
+            return frame_data
+
+        except Exception as e:
+            self.logger.exception(
+                f"Error resetting game {self.environment_info.game_id}: {e}"
+            )
+            return None
+
+    def step(
+        self,
+        action: GameAction,
+        data: Optional[dict[str, Any]] = None,
+        reasoning: Optional[dict[str, Any]] = None,
+    ) -> Optional[FrameDataRaw]:
+        """Perform a step in the environment.
+
+        Args:
+            action: The game action to perform.
+            data: Optional action data dictionary.
+            reasoning: Optional reasoning dictionary.
+
+        Returns:
+            FrameDataRaw object with updated game state, or None if step failed.
+        """
+        if self._game is None:
+            self.logger.error("Cannot step: game not initialized. Call reset() first.")
+            return None
+
+        try:
+            from arcengine import ActionInput
+
+            # Create ActionInput from GameAction with data
+            action_input = ActionInput(id=action, data=data or {}, reasoning=reasoning)
+
+            # Perform the action
+            frame_data = cast(
+                FrameDataRaw, self._game.perform_action(action_input, raw=True)
+            )
+            # Set guid in frame_data for local environments
+            frame_data.guid = self._guid
+            frame_data.game_id = self.environment_info.game_id
+            self._set_last_response(frame_data, reasoning=reasoning)
+            return frame_data
+
+        except Exception as e:
+            self.logger.exception(
+                f"Error performing step with action {action.name}: {e}"
+            )
+            return None

arcprize__ARC-AGI/arc_agi/models.py

@@ -0,0 +1,84 @@
+"""Pydantic models for ARC-AGI-3 environments."""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class APIError(str, Enum):
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+    GAME_NOT_AVAILABLE_ERROR = "GAME_NOT_AVAILABLE_ERROR"
+    SERVER_ERROR = "SERVER_ERROR"
+    GAME_NOT_STARTED_ERROR = "GAME_NOT_STARTED_ERROR"
+
+
+class EnvironmentInfo(BaseModel):
+    """Information about an ARC-AGI-3 environment.
+
+    This class can be serialized to and deserialized from JSON.
+    Note: local_dir is excluded from JSON serialization as it's runtime-only.
+    """
+
+    game_id: str
+    title: Optional[str] = None
+    default_fps: Optional[int] = None
+    tags: Optional[list[str]] = None
+    private_tags: Optional[list[str]] = None
+    level_tags: Optional[list[list[str]]] = None
+    baseline_actions: Optional[list[int]] = None
+    date_downloaded: Optional[datetime] = None
+    class_name: Optional[str] = None
+    local_dir: Optional[str] = Field(default=None, exclude=True)
+
+    @model_validator(mode="after")
+    def set_defaults(self) -> "EnvironmentInfo":
+        """Set default values for date_downloaded and class_name if not provided."""
+        # Set date_downloaded to now if not provided
+        if self.date_downloaded is None:
+            self.date_downloaded = datetime.now(timezone.utc)
+
+        if self.default_fps is None:
+            self.default_fps = 5
+
+        # Set class_name from game_id if not provided
+        if self.class_name is None:
+            # Take first 4 characters and capitalize first letter only
+            if len(self.game_id) >= 4:
+                first_four = self.game_id[:4]
+                self.class_name = first_four[0].upper() + first_four[1:]
+            else:
+                # If game_id is shorter than 4 characters, capitalize first letter only
+                if self.game_id:
+                    self.class_name = self.game_id[0].upper() + self.game_id[1:]
+                else:
+                    self.class_name = ""
+
+        return self
+
+    def model_dump_json(self, **kwargs: Any) -> str:
+        """Serialize to JSON string.
+
+        Note: local_dir is automatically excluded from serialization.
+        """
+        return super().model_dump_json(**kwargs)
+
+    @classmethod
+    def model_validate_json(
+        cls,
+        json_data: str | bytes | bytearray,
+        *,
+        strict: bool | None = None,
+        context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
+    ) -> "EnvironmentInfo":
+        """Deserialize from JSON string."""
+        return super().model_validate_json(
+            json_data,
+            strict=strict,
+            context=context,
+            by_alias=by_alias,
+            by_name=by_name,
+        )

arcprize__ARC-AGI/arc_agi/remote_wrapper.py

@@ -0,0 +1,261 @@
+"""Remote environment wrapper for ARC-AGI-3 environments."""
+
+import json
+import logging
+import threading
+from typing import Any, Callable, Optional
+
+import numpy as np
+import requests
+from arcengine import FrameData, FrameDataRaw, GameAction
+from requests.cookies import RequestsCookieJar
+
+from .models import EnvironmentInfo
+from .wrapper import EnvironmentWrapper
+
+
+class RemoteEnvironmentWrapper(EnvironmentWrapper):
+    """Wrapper for running ARC-AGI-3 environments remotely via API.
+
+    This wrapper makes HTTP requests to the ARC-AGI-3 API to interact with
+    environments that are hosted remotely.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        environment_info: EnvironmentInfo,
+        arc_api_key: str,
+        logger: logging.Logger,
+        scorecard_id: str,
+        save_recording: bool = False,
+        include_frame_data: bool = True,
+        recordings_dir: str = "recordings",
+        scorecard_manager: Optional[Any] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+        master_cookie_jar: Optional[RequestsCookieJar] = None,
+        cookie_lock: Optional[threading.Lock] = None,
+    ) -> None:
+        """Initialize the remote environment wrapper.
+
+        Args:
+            base_url: Base URL for the ARC-AGI-3 API (e.g., "https://three.arcprize.org").
+            environment_info: EnvironmentInfo object with game metadata.
+            arc_api_key: API key for authentication.
+            logger: Logger instance for logging.
+            scorecard_id: Scorecard ID for tracking runs.
+            save_recording: Whether to save recordings to JSONL file.
+            include_frame_data: Whether to include frame data in the recording file.
+            recordings_dir: Directory to save recordings.
+            scorecard_manager: Optional scorecard manager for tracking.
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+        """
+        super().__init__(
+            environment_info,
+            logger,
+            scorecard_id,
+            save_recording,
+            include_frame_data,
+            recordings_dir,
+            scorecard_manager,
+            renderer,
+        )
+        self.base_url = base_url
+        self.arc_api_key = arc_api_key
+        self.headers = {
+            "X-API-Key": arc_api_key,
+            "Accept": "application/json",
+        }
+        self._session = requests.Session()
+        self._session.headers.update(self.headers)
+
+        self._master_cookie_jar = (
+            master_cookie_jar if master_cookie_jar is not None else RequestsCookieJar()
+        )
+        self._cookie_lock = cookie_lock if cookie_lock is not None else threading.Lock()
+
+        self.reset()
+
+    def reset(self) -> Optional[FrameDataRaw]:
+        """Reset the environment and return the initial frame data.
+
+        Returns:
+            FrameDataRaw object with initial game state, or None if reset failed.
+        """
+        try:
+            url = f"{self.base_url}/api/cmd/RESET"
+            headers = {
+                "X-Api-Key": self.arc_api_key,
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "card_id": self.scorecard_id,
+                "game_id": self.environment_info.game_id,
+            }
+            if self._guid:
+                payload["guid"] = self._guid
+
+            with self._cookie_lock:
+                self._session.cookies.update(self._master_cookie_jar)  # type: ignore[no-untyped-call]
+
+            response = self._session.post(
+                url, json=payload, headers=headers, timeout=10
+            )
+
+            with self._cookie_lock:
+                self._master_cookie_jar.update(self._session.cookies)  # type: ignore[no-untyped-call]
+
+            response.raise_for_status()
+            response_data = response.json()
+
+            # Convert API response to FrameDataRaw
+            frame_data_raw = self._convert_to_frame_data_raw(response_data)
+            if frame_data_raw:
+                # Store guid from response
+                self._guid = response_data.get("guid")
+                # Setup recording file now that guid is set
+                if self.save_recording and self._guid:
+                    self._setup_recording_file()
+                self._set_last_response(frame_data_raw)
+                self.logger.info(
+                    f"Successfully reset game {self.environment_info.game_id}, guid={self._guid}, scorecard_id={self.scorecard_id}"
+                )
+                return frame_data_raw
+
+            return None
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(
+                f"Failed to reset game {self.environment_info.game_id}: {e}",
+                exc_info=True,
+            )
+            return None
+        except Exception as e:
+            self.logger.exception(
+                f"Unexpected error while resetting game {self.environment_info.game_id}: {e}"
+            )
+            return None
+
+    def step(
+        self,
+        action: GameAction,
+        data: Optional[dict[str, Any]] = None,
+        reasoning: Optional[dict[str, Any]] = None,
+    ) -> Optional[FrameDataRaw]:
+        """Perform a step in the environment.
+
+        Args:
+            action: The game action to perform.
+            data: Optional action data dictionary (for complex actions, should contain "x" and "y").
+            reasoning: Optional reasoning dictionary.
+
+        Returns:
+            FrameDataRaw object with updated game state, or None if step failed.
+        """
+        if self._guid is None:
+            self.logger.error("Cannot step: game not reset. Call reset() first.")
+            return None
+
+        try:
+            # Determine action endpoint
+            if action == GameAction.RESET:
+                action_name = "RESET"
+            else:
+                action_name = f"ACTION{action.value}"
+
+            url = f"{self.base_url}/api/cmd/{action_name}"
+            headers = {
+                "X-Api-Key": self.arc_api_key,
+                "Content-Type": "application/json",
+            }
+
+            # Build payload
+            payload = {
+                "game_id": self.environment_info.game_id,
+                "guid": self._guid,
+            }
+
+            # Add x, y coordinates for complex actions
+            if data:
+                if "x" in data:
+                    payload["x"] = data["x"]
+                if "y" in data:
+                    payload["y"] = data["y"]
+
+            # Add reasoning if provided
+            if reasoning:
+                payload["reasoning"] = json.dumps(reasoning)
+
+            with self._cookie_lock:
+                self._session.cookies.update(self._master_cookie_jar)  # type: ignore[no-untyped-call]
+
+            response = self._session.post(
+                url, json=payload, headers=headers, timeout=10
+            )
+
+            with self._cookie_lock:
+                self._master_cookie_jar.update(self._session.cookies)  # type: ignore[no-untyped-call]
+
+            response.raise_for_status()
+            response_data = response.json()
+
+            # Convert API response to FrameDataRaw
+            frame_data_raw = self._convert_to_frame_data_raw(response_data)
+            if frame_data_raw:
+                self._set_last_response(frame_data_raw, reasoning=reasoning)
+                return frame_data_raw
+
+            return None
+
+        except requests.exceptions.RequestException as e:
+            response_text = e.response.text if e.response is not None else ""
+            response_body = f" Response body: {response_text}" if response_text else ""
+            self.logger.error(
+                f"Failed to perform action {action.name} for game {self.environment_info.game_id}: {e}{response_body}",
+                exc_info=True,
+            )
+            return None
+        except Exception as e:
+            self.logger.exception(
+                f"Unexpected error while performing action {action.name}: {e}"
+            )
+            return None
+
+    def _convert_to_frame_data_raw(
+        self, response_data: dict[str, Any]
+    ) -> Optional[FrameDataRaw]:
+        """Convert API response dictionary to FrameDataRaw.
+
+        Args:
+            response_data: Dictionary from API response.
+
+        Returns:
+            FrameDataRaw object if successful, None otherwise.
+        """
+        try:
+            # First, try to parse as FrameData (Pydantic model)
+            frame_data = FrameData.model_validate(response_data)
+
+            # Convert FrameData to FrameDataRaw
+            frame_data_raw = FrameDataRaw()
+            frame_data_raw.game_id = frame_data.game_id
+            # Convert frame from list of lists of lists to list of ndarrays
+            frame_data_raw.frame = [
+                np.array(frame_layer, dtype=np.int8) for frame_layer in frame_data.frame
+            ]
+            frame_data_raw.state = frame_data.state
+            frame_data_raw.levels_completed = frame_data.levels_completed
+            frame_data_raw.win_levels = frame_data.win_levels
+            frame_data_raw.action_input = frame_data.action_input
+            frame_data_raw.guid = frame_data.guid
+            frame_data_raw.full_reset = getattr(frame_data, "full_reset", False)
+            frame_data_raw.available_actions = frame_data.available_actions
+
+            return frame_data_raw
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to convert API response to FrameDataRaw: {e}",
+                exc_info=True,
+            )
+            return None

arcprize__ARC-AGI/arc_agi/rendering.py

@@ -0,0 +1,294 @@
+"""Rendering utilities for ARC-AGI-3 environments."""
+
+import sys
+import time
+from typing import Any, Optional, Tuple
+
+try:
+    import matplotlib.animation as animation
+    import matplotlib.pyplot as plt
+
+    HAS_MATPLOTLIB = True
+except ImportError:
+    plt = None
+    animation = None
+    HAS_MATPLOTLIB = False
+
+from arcengine import FrameDataRaw
+from numpy import ndarray
+
+# Color mapping for frame values (0-15)
+COLOR_MAP: dict[int, str] = {
+    0: "#FFFFFFFF",  # White
+    1: "#CCCCCCFF",  # Off-white
+    2: "#999999FF",  # neutral Light
+    3: "#666666FF",  # neutral
+    4: "#333333FF",  # Off Black
+    5: "#000000FF",  # Black
+    6: "#E53AA3FF",  # Magenta
+    7: "#FF7BCCFF",  # Magenta Light
+    8: "#F93C31FF",  # Red
+    9: "#1E93FFFF",  # Blue
+    10: "#88D8F1FF",  # Blue Light
+    11: "#FFDC00FF",  # Yellow
+    12: "#FF851BFF",  # Orange
+    13: "#921231FF",  # Maroon
+    14: "#4FCC30FF",  # Green
+    15: "#A356D6FF",  # Purple
+}
+
+
+def hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    """Convert hex color string to RGB tuple.
+
+    Args:
+        hex_color: Hex color string (e.g., "#FFFFFFFF").
+
+    Returns:
+        RGB tuple (r, g, b).
+    """
+    # Remove '#' and convert to int
+    hex_color = hex_color.lstrip("#")
+    # Parse RGBA hex (8 chars) or RGB hex (6 chars)
+    if len(hex_color) == 8:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+        # Alpha is ignored for display
+    else:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+    return (r, g, b)
+
+
+def frame_to_rgb_array(
+    steps: int,
+    frame: ndarray,
+    scale: int = 4,
+    color_map: Optional[dict[int, str]] = None,
+) -> ndarray:
+    """Convert a frame to an RGB numpy array for matplotlib.
+
+    Args:
+        frame: 2D numpy array (64x64) with values 0-15.
+        scale: Upscaling factor (default 4, so 64x64 -> 256x256).
+        color_map: Optional color mapping dict. Uses default if None.
+
+    Returns:
+        3D numpy array (height, width, 3) with RGB values.
+    """
+    import numpy as np
+
+    if color_map is None:
+        color_map = COLOR_MAP
+
+    height, width = frame.shape
+    upscaled_height = height * scale
+    upscaled_width = width * scale
+
+    # Create RGB array
+    rgb_array = np.zeros((upscaled_height, upscaled_width, 3), dtype=np.uint8)
+
+    # Fill pixels
+    for y in range(height):
+        for x in range(width):
+            value = int(frame[y, x])
+            hex_color = color_map.get(value, "#000000FF")
+            rgb = hex_to_rgb(hex_color)
+
+            # Fill the scaled block
+            for dy in range(scale):
+                for dx in range(scale):
+                    rgb_array[y * scale + dy, x * scale + dx] = rgb
+
+    return rgb_array
+
+
+def render_frames(
+    steps: int,
+    frame_data: FrameDataRaw,
+    default_fps: Optional[int] = None,
+    scale: int = 4,
+    color_map: Optional[dict[int, str]] = None,
+) -> None:
+    """Render multiple frames with optional FPS control using matplotlib.
+
+    Args:
+        frame_data: FrameDataRaw object containing frame data and other information.
+        default_fps: Optional FPS for frame timing. If None, displays immediately.
+        scale: Upscaling factor (default 4, so 64x64 -> 256x256).
+        color_map: Optional color mapping dict. Uses default if None.
+    """
+    if not HAS_MATPLOTLIB or plt is None or animation is None:
+        raise ImportError(
+            "matplotlib is required for rendering. Install with: pip install matplotlib"
+        )
+
+    frames = frame_data.frame
+    if not frames:
+        return
+
+    # Convert frames to RGB arrays
+    frame_images = [
+        frame_to_rgb_array(steps, frame, scale, color_map) for frame in frames
+    ]
+
+    # Calculate interval between frames if FPS is specified
+    interval = (1000.0 / default_fps) if default_fps and default_fps > 0 else 100
+
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.axis("off")
+    ax.set_title("ARC-AGI-3 Environment")
+
+    # Display first frame
+    im = ax.imshow(frame_images[0], interpolation="nearest")
+    plt.tight_layout()
+
+    def update_frame(frame_num: int) -> Tuple[Any, ...]:
+        """Update the displayed frame."""
+        if frame_num < len(frame_images):
+            im.set_array(frame_images[frame_num])
+            return (im,)
+        return (im,)
+
+    # Create animation that plays automatically
+    # Keep reference to prevent garbage collection
+    anim = animation.FuncAnimation(
+        fig,
+        update_frame,
+        frames=len(frame_images),
+        interval=interval,
+        blit=False,
+        repeat=False,
+    )
+
+    # Show the plot - animation will play automatically
+    # Use non-blocking mode so frames play and code continues
+    plt.ion()  # Turn on interactive mode
+    plt.show(block=False)
+
+    # Wait for animation to complete (frames * interval + small buffer)
+    if interval > 0:
+        total_time = len(frame_images) * interval / 1000.0
+    else:
+        total_time = len(frame_images) * 0.1  # Default 100ms per frame
+
+    # Small initial pause to ensure window appears and animation starts
+    time.sleep(0.1)
+
+    # Use plt.pause to process events and let animation play
+    # This ensures the animation actually renders
+    plt.pause(total_time + 0.1)
+
+    # Keep animation reference alive until we're done
+    # Close the figure after animation completes
+    plt.close(fig)
+    plt.ioff()  # Turn off interactive mode
+
+    # Explicitly delete animation after closing to avoid warnings
+    del anim
+
+
+def rgb_to_ansi(rgb: tuple[int, int, int]) -> str:
+    """Convert RGB tuple to ANSI color code.
+
+    Args:
+        rgb: RGB tuple (r, g, b).
+
+    Returns:
+        ANSI escape sequence for the color.
+    """
+    r, g, b = rgb
+    return f"\033[38;2;{r};{g};{b}m"
+
+
+def render_frames_terminal(
+    steps: int,
+    frame_data: FrameDataRaw,
+    default_fps: Optional[int] = None,
+    scale: int = 1,
+    color_map: Optional[dict[int, str]] = None,
+    skip_deplay: bool = False,
+) -> None:
+    """Render frames in the terminal using ANSI color codes, overwriting in place.
+
+    Args:
+        frame_data: FrameDataRaw object containing frame data and other information.
+        default_fps: Optional FPS for frame timing. If None, displays immediately.
+        scale: Scaling factor (default 1, terminal uses 2 chars per pixel for better visibility).
+        color_map: Optional color mapping dict. Uses default if None.
+    """
+    frames = frame_data.frame
+    if not frames:
+        return
+
+    if color_map is None:
+        color_map = COLOR_MAP
+
+    # Check if terminal supports colors
+    if not sys.stdout.isatty():
+        print(
+            "Warning: Not a terminal, colors may not display correctly", file=sys.stderr
+        )
+
+    # Calculate delay between frames (default 5 FPS if not specified)
+    fps = default_fps if default_fps and default_fps > 0 else 5
+    delay = 1.0 / fps
+
+    # ANSI codes
+    RESET = "\033[0m"
+    HOME = "\033[H"  # Move cursor to home position (top-left)
+    HIDE_CURSOR = "\033[?25l"  # Hide cursor
+    SHOW_CURSOR = "\033[?25h"  # Show cursor
+    # Use block character for better visibility (2 chars wide)
+    BLOCK = "██"
+
+    # Get frame dimensions
+    height, width = frames[0].shape
+
+    # Build frame strings for all frames (as single strings to reduce flicker)
+    frame_strings = []
+    for frame_idx, frame in enumerate(frames):
+        # Build entire frame as one string
+        frame_str = f"Step: {steps} - State: {frame_data.state.name}\n\n"
+
+        # Frame content - build all lines first, then join
+        frame_lines = []
+        for y in range(height):
+            line_parts = []
+            for x in range(width):
+                value = int(frame[y, x])
+                hex_color = color_map.get(value, "#000000FF")
+                rgb = hex_to_rgb(hex_color)
+                ansi_color = rgb_to_ansi(rgb)
+                # Use block character (2 chars) for better visibility
+                line_parts.append(f"{ansi_color}{BLOCK}{RESET}")
+            frame_lines.append("".join(line_parts))
+
+        frame_str += "\n".join(frame_lines)
+        frame_strings.append(frame_str)
+
+    # Hide cursor to reduce flicker
+    print(HIDE_CURSOR, end="", flush=True)
+
+    try:
+        # First frame: clear screen and display in single operation to reduce flicker
+        print(f"{HOME}\033[2J{frame_strings[0]}", end="", flush=True)
+
+        # Update frames in place - single operation per frame to minimize flicker
+        for frame_idx in range(1, len(frames)):
+            # Single operation: move home + print new frame (no separate operations)
+            print(f"{HOME}{frame_strings[frame_idx]}", end="", flush=True)
+            # Sleep for 1/fps seconds between frames
+            if not skip_deplay:
+                time.sleep(delay)
+    finally:
+        # Always show cursor again
+        print(SHOW_CURSOR, end="", flush=True)
+
+    # Reset terminal colors and move cursor below the frame
+    print(f"\n{RESET}", end="", flush=True)
+    if not skip_deplay:
+        time.sleep(delay)

arcprize__ARC-AGI/arc_agi/scorecard.py

@@ -0,0 +1,1012 @@
+import logging
+import os
+import sys
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import Any, List, Optional, Tuple
+
+from arcengine import FrameDataRaw, GameState
+from pydantic import BaseModel, Field, computed_field
+
+from .models import EnvironmentInfo
+
+logger = logging.getLogger(__name__)
+
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.INFO)
+    handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(message)s"))
+    logger.addHandler(handler)
+
+logger.setLevel(logging.INFO)
+logger.propagate = False
+
+DEFAULT_STALE_MINUTES = 15  # hard-coded fallback
+DEFAULT_MAX_OPEN_FOR_MINUTES = 4320  # hard-coded fallback - 3 days (72 hours)
+
+
+_MIN, _MAX = 1, 60  # sanity window (optional)
+
+
+def _get_stale_minutes() -> int:
+    """Read STALE_MINUTES from the environment, fall back to default,
+    and clamp to a safe range.
+    """
+    raw = os.getenv("STALE_MINUTES", str(DEFAULT_STALE_MINUTES))
+    try:
+        value = int(raw)
+    except ValueError:
+        logging.warning(
+            "STALE_MINUTES=%r is not an int; using default=%d",
+            raw,
+            DEFAULT_STALE_MINUTES,
+        )
+        value = DEFAULT_STALE_MINUTES
+
+    if not _MIN <= value <= _MAX:
+        logging.warning("STALE_MINUTES=%d outside %d–%d; clamping", value, _MIN, _MAX)
+        value = max(_MIN, min(_MAX, value))
+
+    return value
+
+
+STALE_MINUTES = _get_stale_minutes()
+
+
+def _max_open_for_minutes() -> int:
+    """Read MAX_OPEN_F1OR_MINUTES from the environment, fall back to default,
+    and clamp to a safe range.
+    """
+    raw = os.getenv("MAX_OPEN_FOR_MINUTES", str(DEFAULT_MAX_OPEN_FOR_MINUTES))
+    try:
+        value = int(raw)
+    except ValueError:
+        logger.warning(
+            "MAX_OPEN_FOR_MINUTES=%r is not an int; using default=%d",
+            raw,
+            DEFAULT_MAX_OPEN_FOR_MINUTES,
+        )
+        value = DEFAULT_MAX_OPEN_FOR_MINUTES
+
+    if not _MAX <= value <= _MAX * 24 * 7:
+        logger.warning(
+            "MAX_OPEN_FOR_MINUTES=%d outside %d–%d; clamping",
+            value,
+            _MAX,
+            _MAX * 24 * 7,
+        )
+        value = max(_MAX, min(_MAX * 24 * 7, value))
+
+    return value
+
+
+MAX_OPEN_FOR_MINUTES = _max_open_for_minutes()
+
+
+class EnvironmentScore(BaseModel):
+    """Score for an environment run."""
+
+    id: Optional[str] = None
+    guid: Optional[str] = None
+    score: float
+    levels_completed: int
+    actions: int
+    resets: Optional[int] = None
+    state: Optional[GameState] = None
+    completed: Optional[bool] = None
+    level_scores: Optional[list[float]] = None
+    level_actions: Optional[list[int]] = None
+    level_baseline_actions: Optional[list[int]] = None
+    number_of_levels: Optional[int] = None
+    number_of_environments: Optional[int] = 0
+    message: Optional[str] = None
+
+    def model_dump_json(self, *, exclude_none: bool = True, **kwargs: Any) -> str:
+        """Serialize to JSON string, excluding None fields by default.
+
+        Args:
+            exclude_none: If True, exclude fields that are None. Defaults to True.
+            **kwargs: Additional arguments passed to parent model_dump_json.
+
+        Returns:
+            JSON string representation of the model.
+        """
+        return super().model_dump_json(exclude_none=exclude_none, **kwargs)
+
+
+class EnvironmentScoreCalculator:
+    """Calculator for environment scores."""
+
+    def __init__(
+        self,
+        id: Optional[str] = None,
+        resets: Optional[int] = None,
+        state: Optional[GameState] = None,
+        guid: Optional[str] = None,
+    ) -> None:
+        """Initialize the calculator.
+
+        Args:
+            id: Identifier for the environment run.
+            resets: Optional number of resets.
+        """
+        self.id = id
+        self.guid = guid
+        self.resets = resets
+        self.level_indices: list[int] = []
+        self.level_scores: list[float] = []
+        self.levels_completed: int = 0
+        self.actions: int = 0
+        self.environments: set[str] = set()
+        self.state: Optional[GameState] = state
+        self.completed: Optional[bool] = None
+        self.level_actions: list[int] = []
+        self.level_baseline_actions: list[int] = []
+
+    def add_level(
+        self,
+        level_index: int,
+        completed: bool,
+        actions_taken: int,
+        baseline_actions: int,
+        game_id: Optional[str] = None,
+    ) -> None:
+        """Add a level to the score calculation.
+
+        Args:
+            completed: Whether the level was completed.
+            actions_taken: Number of actions taken to complete the level.
+            baseline_actions: Baseline number of actions for the level.
+        """
+        self.actions += actions_taken
+
+        if game_id:
+            self.environments.add(game_id)
+
+        if completed:
+            self.levels_completed += 1
+            # Calculate score as ((baseline_actions / actions_taken)^2 * 100) max 100
+            if actions_taken > 0:
+                score = ((baseline_actions / actions_taken) ** 2) * 100
+                score = min(score, 115.0)  # Cap at 115
+            else:
+                score = 0.0
+            self.level_indices.append(level_index)
+            self.level_scores.append(score)
+            self.level_actions.append(actions_taken)
+            self.level_baseline_actions.append(baseline_actions)
+        else:
+            # Not completed, append 0
+            self.level_indices.append(level_index)
+            self.level_scores.append(0.0)
+            self.level_actions.append(actions_taken)
+            self.level_baseline_actions.append(baseline_actions)
+
+    def to_score(self, include_levels: bool = True) -> EnvironmentScore:
+        """Convert the calculator to an EnvironmentScore.
+
+        Returns:
+            EnvironmentScore with average of level_scores as the score.
+        """
+        # Calculate average of level_scores
+        max_weights = 0
+        if len(self.level_scores) > 0:
+            total_score = 0.0
+            total_weights = 0
+            for i in range(len(self.level_scores)):
+                weight = self.level_indices[i]
+                total_score += self.level_scores[i] * weight
+                total_weights += weight
+                if self.level_scores[i] > 0:
+                    max_weights += weight
+
+            # Calculate average of level_scores
+            score = total_score / total_weights
+            max_score = max_weights / total_weights * 100
+            score = min(score, max_score)
+        else:
+            score = 0.0
+
+        return EnvironmentScore(
+            id=self.id,
+            guid=self.guid,
+            score=score,
+            levels_completed=self.levels_completed,
+            actions=self.actions,
+            resets=self.resets,
+            state=self.state,
+            completed=self.completed,
+            level_scores=self.level_scores if include_levels else None,
+            level_actions=self.level_actions if include_levels else None,
+            level_baseline_actions=self.level_baseline_actions
+            if include_levels
+            else None,
+            number_of_levels=len(self.level_scores) if not include_levels else None,
+            number_of_environments=len(self.environments)
+            if not include_levels
+            else None,
+        )
+
+
+class EnvironmentScoreList(BaseModel):
+    """List of EnvironmentScore objects."""
+
+    id: str
+    runs: List[EnvironmentScore] = Field(default_factory=list)
+
+    @computed_field(return_type=float)  # type: ignore[prop-decorator]# type:
+    @property
+    def score(self) -> float:
+        """Return the average score of the runs."""
+        return max(run.score for run in self.runs)
+
+    @computed_field(return_type=int)  # type: ignore[prop-decorator]# type:
+    @property
+    def actions(self) -> int:
+        """Return the total number of actions."""
+        return sum(run.actions for run in self.runs)
+
+    @computed_field(return_type=int)  # type: ignore[prop-decorator]# type:
+    @property
+    def levels_completed(self) -> int:
+        """Return the total number of levels completed."""
+        return max(run.levels_completed for run in self.runs)
+
+    @computed_field(return_type=bool)  # type: ignore[prop-decorator]# type:
+    @property
+    def completed(self) -> bool:
+        """Return True if all runs are completed."""
+        return any(run.completed for run in self.runs)
+
+    @computed_field(return_type=int)  # type: ignore[prop-decorator]# type:
+    @property
+    def level_count(self) -> int:
+        """Return the total number of levels."""
+        return max(
+            len(run.level_scores) if run.level_scores else 0 for run in self.runs
+        )
+
+    @computed_field(return_type=int)  # type: ignore[prop-decorator]# type:
+    @property
+    def resets(self) -> int:
+        """Return the total number of resets."""
+        return sum(run.resets if run.resets else 0 for run in self.runs)
+
+
+class EnvironmentScorecard(BaseModel):
+    """Scorecard with computed environment scores."""
+
+    source_url: Optional[str] = None
+    tags: Optional[list[str]] = None
+    opaque: Optional[Any] = None
+    card_id: str
+    api_key: Optional[str] = None
+    score: float = 0.0
+    environments: List[EnvironmentScoreList] = Field(default_factory=list)
+    tags_scores: List[EnvironmentScore] = Field(default_factory=list)
+    open_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        exclude=True,
+    )
+    last_update: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        exclude=True,
+    )
+    competition_mode: Optional[bool] = False
+
+    def get(self, game_id: Optional[str] = None) -> dict[str, Any]:
+        if game_id is not None:
+            for environment in self.environments:
+                for run in environment.runs:
+                    if run.id == game_id:
+                        return run.model_dump()
+            return {}
+        return self.model_dump()
+
+    def __str__(self) -> str:
+        return self.model_dump_json(indent=2)
+
+    @computed_field(return_type=int)
+    def total_environments_completed(self) -> int:
+        """Return the number of environments that are completed."""
+        return sum(1 if env.completed else 0 for env in self.environments)
+
+    @computed_field(return_type=int)
+    def total_environments(self) -> int:
+        """Return the total number of environments."""
+        return len(self.environments)
+
+    @computed_field(return_type=int)
+    def total_levels_completed(self) -> int:
+        """Return the total number of levels completed."""
+        return sum(env.levels_completed for env in self.environments)
+
+    @computed_field(return_type=int)
+    def total_levels(self) -> int:
+        """Return the total number of levels."""
+        return sum(env.level_count for env in self.environments)
+
+    @computed_field(return_type=int)
+    def total_actions(self) -> int:
+        """Return the total number of resets."""
+        return sum(env.actions for env in self.environments)
+
+    def find_environment(self, id_prefix: str) -> Optional[EnvironmentScoreList]:
+        for environment in self.environments:
+            if environment.id.startswith(id_prefix):
+                return environment
+        return None
+
+    def model_dump_json(self, *, exclude_none: bool = True, **kwargs: Any) -> str:
+        """Serialize to JSON string, excluding None fields by default.
+
+        Args:
+            exclude_none: If True, exclude fields that are None. Defaults to True.
+            **kwargs: Additional arguments passed to parent model_dump_json.
+
+        Returns:
+            JSON string representation of the model.
+        """
+        return super().model_dump_json(exclude_none=exclude_none, **kwargs)
+
+    @classmethod
+    def _raw_scores_from_card(
+        self, card: "Card", idx: int
+    ) -> tuple[list[int], list[float], list[int]]:
+        """Return the raw score from the card."""
+        actions_by_level = (
+            card.actions_by_level[idx] if idx < len(card.actions_by_level) else []
+        )
+        prev_actions = 0
+        actions: list[int] = []
+        scores: list[float] = []
+        baseline_actions: list[int] = []
+        for level_idx in range(len(actions_by_level)):
+            actions_at_level = actions_by_level[level_idx]
+            level_actions = actions_at_level[1] - prev_actions
+            actions.append(level_actions)
+            scores.append(0.0)
+            baseline_actions.append(-1)  # indicate not available
+            prev_actions = actions_at_level[1]
+
+        if card.states[idx] != GameState.WIN:
+            actions.append(card.actions[idx] - prev_actions)
+            scores.append(0.0)
+            baseline_actions.append(-1)  # indicate not available
+
+        return actions, scores, baseline_actions
+
+    @classmethod
+    def _calculate_score(
+        cls,
+        card: "Card",
+        game_id: str,
+        idx: int,
+        env_info: EnvironmentInfo | None,
+        tags_scores: dict[str, EnvironmentScoreCalculator] | None,
+        do_private_tags: bool = False,
+    ) -> EnvironmentScore:
+        """Calculate the score for a single card."""
+        levels_completed = card.levels_completed[idx]
+        guid = card.guids[idx]
+        actions = card.actions[idx] if idx < len(card.actions) else 0
+        resets = card.resets[idx] if idx < len(card.resets) else 0
+        state = card.states[idx] if idx < len(card.states) else GameState.NOT_PLAYED
+        completed = state == GameState.WIN
+
+        # Find matching EnvironmentInfo
+        if not env_info:
+            only_level_actions, scores, baseline_actions = cls._raw_scores_from_card(
+                card, idx
+            )
+            return EnvironmentScore(
+                id=card.game_id,
+                guid=guid,
+                score=0.0,
+                levels_completed=levels_completed,
+                actions=actions,
+                resets=resets,
+                state=state,
+                completed=completed,
+                level_actions=only_level_actions,
+                level_baseline_actions=baseline_actions,
+                level_scores=scores,
+                message=f"No Matching EnvironmentInfo found for {game_id}",
+            )
+
+        # Check if baseline_actions are available
+        if env_info.baseline_actions is None or len(env_info.baseline_actions) == 0:
+            # No baseline actions available
+            only_level_actions, scores, baseline_actions = cls._raw_scores_from_card(
+                card, idx
+            )
+            return EnvironmentScore(
+                id=card.game_id,
+                guid=guid,
+                score=0.0,
+                levels_completed=levels_completed,
+                actions=actions,
+                resets=resets,
+                state=state,
+                completed=completed,
+                level_actions=only_level_actions,
+                level_baseline_actions=baseline_actions,
+                level_scores=scores,
+                message="Human baseline actions are not available for this environment",
+            )
+        elif len(env_info.baseline_actions) < len(card.actions_by_level[idx]):
+            # No baseline actions available
+            only_level_actions, scores, baseline_actions = cls._raw_scores_from_card(
+                card, idx
+            )
+            return EnvironmentScore(
+                id=card.game_id,
+                guid=guid,
+                score=0.0,
+                levels_completed=levels_completed,
+                actions=actions,
+                resets=resets,
+                state=state,
+                completed=completed,
+                level_actions=only_level_actions,
+                level_baseline_actions=baseline_actions,
+                level_scores=scores,
+                message="Human baseline actions size mismatch",
+            )
+        else:
+            # Calculate score using EnvironmentScoreCalculator
+            calculator = EnvironmentScoreCalculator(
+                resets=resets, guid=guid, state=state
+            )
+            calculator.completed = completed
+
+            # Process each level
+            # We need to determine how many levels were attempted and completed
+            # The actions_by_level list contains tuples of (level, actions) when level changed
+            actions_by_level = (
+                card.actions_by_level[idx] if idx < len(card.actions_by_level) else []
+            )
+
+            # If we have actions_by_level, use that to determine level progression
+            # if actions_by_level:
+            # actions_by_level contains (level_completed, actions_at_that_point)
+            # We need to calculate actions per level
+            prev_actions = 0
+            for level_idx in range(len(env_info.baseline_actions)):
+                baseline = env_info.baseline_actions[level_idx]
+                if level_idx < len(actions_by_level):
+                    level, actions_at_level = actions_by_level[level_idx]
+                    level_actions = actions_at_level - prev_actions
+                    level_completed = level_idx < len(actions_by_level) or completed
+                    prev_actions = actions_at_level
+                else:
+                    level_completed = False
+                    level_actions = card.actions[idx] - prev_actions
+                    prev_actions = card.actions[idx]
+                calculator.add_level(
+                    level_index=level_idx + 1,
+                    completed=level_completed,
+                    actions_taken=level_actions,
+                    baseline_actions=baseline,
+                )
+                if tags_scores is not None:
+                    if env_info.tags:
+                        for tag in env_info.tags:
+                            tag_score = tags_scores.get(tag)
+                            if not tag_score:
+                                tag_score = EnvironmentScoreCalculator(id=tag)
+                                tags_scores[tag] = tag_score
+                            tag_score.add_level(
+                                level_index=level_idx + 1,
+                                completed=level_completed,
+                                actions_taken=level_actions,
+                                baseline_actions=baseline,
+                                game_id=game_id,
+                            )
+                    if do_private_tags:
+                        if env_info.private_tags is not None:
+                            for tag in env_info.private_tags:
+                                tag = f"private_{tag}"
+                                tag_score = tags_scores.get(tag)
+                                if not tag_score:
+                                    tag_score = EnvironmentScoreCalculator(id=tag)
+                                    tags_scores[tag] = tag_score
+                                tag_score.add_level(
+                                    level_index=level_idx + 1,
+                                    completed=level_completed,
+                                    actions_taken=level_actions,
+                                    baseline_actions=baseline,
+                                    game_id=game_id,
+                                )
+                        if env_info.level_tags and level_idx < len(env_info.level_tags):
+                            level_tags = env_info.level_tags[level_idx]
+                            for tag in level_tags:
+                                tag = f"private_{tag}"
+                                tag_score = tags_scores.get(tag)
+                                if not tag_score:
+                                    tag_score = EnvironmentScoreCalculator(id=tag)
+                                    tags_scores[tag] = tag_score
+                                tag_score.add_level(
+                                    level_index=level_idx + 1,
+                                    completed=level_completed,
+                                    actions_taken=level_actions,
+                                    baseline_actions=baseline,
+                                    game_id=game_id,
+                                )
+
+            return calculator.to_score()
+
+    @classmethod
+    def from_scorecard(
+        cls,
+        scorecard: "Scorecard",
+        environment_infos: List[EnvironmentInfo],
+        do_private_tags: bool = False,
+    ) -> "EnvironmentScorecard":
+        """Create EnvironmentScorecard from Scorecard and EnvironmentInfos.
+
+        Args:
+            scorecard: The Scorecard to compute from.
+            environment_infos: List of EnvironmentInfo objects to match against.
+
+        Returns:
+            EnvironmentScorecard with computed scores.
+        """
+        # Create a mapping of game_id to EnvironmentInfo
+        # Match by full game_id (which may include version)
+        env_info_map: dict[str, EnvironmentInfo] = {}
+        for env_info in environment_infos:
+            # Use full game_id as key (e.g., "bt11" or "bt11-fd9df0622a1a")
+            env_info_map[env_info.game_id] = env_info
+
+        # Compute environment scores from cards
+        # For each game_id, we'll track the best score (highest levels_completed)
+        game_scores: dict[str, EnvironmentScoreList] = {}
+        tags_scores: dict[str, EnvironmentScoreCalculator] = {}
+
+        for game_id, card in scorecard.cards.items():
+            # Find the idx with the highest levels_completed
+            best_idx = -1
+            best_levels_completed = -1
+            for idx, levels_completed in enumerate(card.levels_completed):
+                if levels_completed > best_levels_completed:
+                    best_levels_completed = levels_completed
+                    best_idx = idx
+
+            # If no valid play found, skip this card
+            if best_idx == -1 or best_idx >= len(card.guids):
+                continue
+
+            all_scores: List[EnvironmentScore] = []
+            for idx, levels_completed in enumerate(card.levels_completed):
+                if idx == best_idx:
+                    score = cls._calculate_score(
+                        card,
+                        game_id,
+                        best_idx,
+                        env_info_map.get(game_id),
+                        tags_scores,
+                        do_private_tags,
+                    )
+                else:
+                    score = cls._calculate_score(
+                        card,
+                        game_id,
+                        idx,
+                        env_info_map.get(game_id),
+                        None,
+                        do_private_tags,
+                    )
+                all_scores.append(score)
+
+            if all_scores and len(all_scores) > 0:
+                game_scores[game_id] = EnvironmentScoreList(id=game_id, runs=all_scores)
+
+        # Convert dict to list
+        environment_list = list(game_scores.values())
+        tags_list = [
+            calculator.to_score(include_levels=False)
+            for calculator in tags_scores.values()
+        ]
+
+        # Calculate average score
+        if len(environment_list) > 0:
+            avg_score = sum(env_score.score for env_score in environment_list) / len(
+                environment_list
+            )
+        else:
+            avg_score = 0.0
+
+        return cls(
+            source_url=scorecard.source_url,
+            tags=scorecard.tags,
+            opaque=scorecard.opaque,
+            card_id=scorecard.card_id,
+            api_key=scorecard.api_key,
+            score=avg_score,
+            environments=environment_list,
+            tags_scores=tags_list,
+            open_at=scorecard.open_at,
+            last_update=scorecard.last_update,
+            competition_mode=scorecard.competition_mode,
+        )
+
+
+class Card(BaseModel):
+    """
+    A single scorecard for a single game. A game can be played more than
+    once, we track each play with lists of card properties (scores, states, actions)
+    """
+
+    game_id: str
+    total_plays: int = 0
+
+    guids: list[str] = Field(default_factory=list)
+    levels_completed: list[int] = Field(default_factory=list)
+    states: list[GameState] = Field(default_factory=list)
+    actions: list[int] = Field(default_factory=list)
+    actions_by_level: list[list[tuple[int, int]]] = Field(
+        default_factory=list, exclude=False
+    )
+    resets: list[int] = Field(default_factory=list)
+
+    @property
+    def idx(self) -> int:
+        # lists are zero indexed by play_count starts at 1
+        return self.total_plays - 1
+
+    @property
+    def started(self) -> bool:
+        return self.total_plays > 0
+
+    @property
+    def level_completed(self) -> Optional[int]:
+        return self.levels_completed[self.idx] if self.started else None
+
+    @property
+    def most_levels_completed(self) -> int:
+        return max(self.levels_completed) if self.started else 0
+
+    @property
+    def state(self) -> GameState:
+        return self.states[self.idx] if self.started else GameState.NOT_PLAYED
+
+    @property
+    def action_count(self) -> Optional[int]:
+        return self.actions[self.idx] if self.started else None
+
+    @computed_field(return_type=int)
+    def total_actions(self) -> int:
+        return sum(self.actions)
+
+    def get_total_actions(self) -> int:
+        return sum(self.actions)
+
+    def index_of_guid(self, match: str) -> int:
+        # Iterate backwards since a guid can be reused and we want the most recent
+        for idx in range(len(self.guids) - 1, -1, -1):
+            if self.guids[idx] == match:
+                return idx
+        return self.total_plays - 1
+
+    def inc_play_count(self, guid: str) -> None:
+        self.total_plays += 1
+        self.guids.append(guid)
+        self.levels_completed.append(0)
+        self.states.append(GameState.NOT_FINISHED)
+        self.actions.append(0)
+        self.resets.append(0)
+        self.actions_by_level.append([])
+
+    def inc_reset_count(self, guid: str) -> None:
+        if self.started:
+            self.resets[self.index_of_guid(guid)] += 1
+            self.actions[self.index_of_guid(guid)] += 1
+
+    def set_levels_completed(self, guid: str, current_levels_completed: int) -> None:
+        if self.started:
+            index = self.index_of_guid(guid)
+            existing_levels_completed = self.levels_completed[index]
+            if current_levels_completed != existing_levels_completed:
+                self.actions_by_level[index].append(
+                    (current_levels_completed, self.actions[index])
+                )
+            self.levels_completed[index] = current_levels_completed
+
+    def set_state(self, guid: str, state: GameState) -> None:
+        if self.started:
+            self.states[self.index_of_guid(guid)] = state
+
+    def inc_action_count(self, guid: str) -> None:
+        if self.started:
+            self.actions[self.index_of_guid(guid)] += 1
+
+    # def to_json(self) -> dict[str, Union[str, int, list[int], list[str]]]:
+    #     return {
+    #         "game_id": self.game_id,
+    #         "total_plays": self.play_count,
+    #         "total_actions": self.total_action_count,
+    #         "scores": self.scores,
+    #         "states": [s.name for s in self.states],
+    #         "actions": self.action_counts,
+    #     }
+
+
+class Scorecard(BaseModel):
+    """
+    Tracks and holds the scorecard for all games
+    """
+
+    games: list[str] = Field(default_factory=list, exclude=True)
+    cards: dict[str, Card] = Field(default_factory=dict)
+    source_url: Optional[str] = None
+    tags: Optional[list[str]] = None
+    opaque: Optional[Any] = Field(default=None)
+    card_id: str = ""
+    api_key: str = ""
+    open_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        exclude=True,
+    )
+
+    last_update: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        exclude=True,
+    )
+    competition_mode: Optional[bool] = False
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.cards:
+            self.cards = {}
+
+    def new_play(self, game_id: str, guid: str) -> None:
+        if game_id not in self.cards:
+            self.cards[game_id] = Card.model_validate({"game_id": game_id})
+        if game_id in self.cards:
+            self.cards[game_id].inc_play_count(guid)
+
+    def reset(self, game_id: str, guid: str) -> None:
+        if game_id in self.cards:
+            self.cards[game_id].inc_reset_count(guid)
+
+    def take_action(self, game_id: str, guid: str) -> None:
+        if game_id in self.cards:
+            self.cards[game_id].inc_action_count(guid)
+
+    def win(self, game_id: str, guid: str) -> None:
+        if game_id in self.cards:
+            self.cards[game_id].set_state(
+                guid,
+                GameState.WIN,
+            )
+
+    def game_over(self, game_id: str, guid: str) -> None:
+        if game_id in self.cards:
+            self.cards[game_id].set_state(guid, GameState.GAME_OVER)
+
+    def set_levels_completed(
+        self, game_id: str, guid: str, level_completed: int
+    ) -> None:
+        if game_id in self.cards:
+            self.cards[game_id].set_levels_completed(guid, level_completed)
+
+    def get(self, game_id: Optional[str] = None) -> dict[str, Any]:
+        if game_id is not None:
+            card = self.cards.get(game_id)
+            return {game_id: card.model_dump()} if card else {}
+        return {k: v.model_dump() for k, v in self.cards.items()}
+
+    def get_card(self, game_id: str) -> Card:
+        return self.cards[game_id]
+
+    @computed_field(return_type=int)
+    def won(self) -> int:
+        return sum([GameState.WIN in g.states for k, g in self.cards.items()])
+
+    @computed_field(return_type=int)
+    def played(self) -> int:
+        return sum([len(g.states) > 0 for k, g in self.cards.items()])
+
+    @computed_field(return_type=int)
+    def total_actions(self) -> int:
+        return sum([g.get_total_actions() for k, g in self.cards.items()])
+
+    @computed_field(return_type=int)
+    def levels_completed(self) -> int:
+        return sum([g.most_levels_completed for k, g in self.cards.items()])
+
+    def get_json_for(self, game_id: str) -> dict[str, Any]:
+        card = self.cards.get(game_id)
+        return {
+            "won": self.won,
+            "played": self.played,
+            "total_actions": self.total_actions,
+            "levels_completed": self.levels_completed,
+            "cards": {game_id: card.model_dump()} if card else {},
+        }
+
+    def has_environment(self, game_id: str) -> bool:
+        for key, _ in self.cards.items():
+            if key.startswith(game_id):
+                return True
+        return False
+
+    def update_scorecard(
+        self, guid: str, data: FrameDataRaw, full_reset: bool
+    ) -> GameState:
+        game_id = data.game_id
+        # Needs to happen first
+        if data.action_input and data.action_input.id.value in [0]:
+            if full_reset:
+                self.new_play(game_id, guid)
+            else:
+                self.reset(game_id, guid)
+        if data.action_input and data.action_input.id.value in [1, 2, 3, 4, 5, 6, 7]:
+            self.take_action(game_id, guid)
+        if data.state:
+            if data.state == GameState.GAME_OVER:
+                self.game_over(game_id, guid)
+            elif data.state == GameState.WIN:
+                self.win(game_id, guid)
+        self.set_levels_completed(game_id, guid, data.levels_completed)
+
+        self.last_update = datetime.now(timezone.utc)
+
+        card = self.cards.get(game_id)
+        return (
+            card.states[card.index_of_guid(guid)]
+            if card and card.started
+            else GameState.NOT_PLAYED
+        )
+
+
+class ScorecardManager:
+    """
+    Manages the scorecard for all games
+    """
+
+    scorecards: dict[str, Scorecard]
+    guids: dict[str, str]
+    games: list[str]
+    idle_for: timedelta
+    max_open_for: timedelta
+
+    def __init__(
+        self,
+        games: list[str] = [],
+        recordings_dir: Optional[str] = None,
+    ) -> None:
+        self.scorecards = {}
+        self.guids = {}
+        self.games = games
+        self.idle_for = timedelta(minutes=STALE_MINUTES)
+        self.max_open_for = timedelta(minutes=MAX_OPEN_FOR_MINUTES)
+        self.recordings_dir = recordings_dir or os.getenv(
+            "RECORDINGS_DIR", "recordings"
+        )
+        logger.info(
+            f"Initialized ScorecardManager with idle_for={self.idle_for} and max_open_for={self.max_open_for}"
+        )
+
+    def set_idle_for(self, idle_for: int) -> None:
+        self.idle_for = timedelta(minutes=idle_for)
+        logger.info(f"Updated idle_for to {self.idle_for}")
+
+    def idle_duration_for(self, card_id: str) -> Optional[timedelta]:
+        """Return how long since last_update for this scorecard, or None if unknown."""
+        sc = self.scorecards.get(card_id)
+        if sc is None:
+            return None
+        return datetime.now(timezone.utc) - sc.last_update
+
+    def should_auto_close_scorecard(self, card_id: str) -> bool:
+        """True if this scorecard still matches auto-close rules (same logic as get_stale_cards)."""
+        sc = self.scorecards.get(card_id)
+        if sc is None:
+            return False
+        now = datetime.now(timezone.utc)
+        idle = now - sc.last_update
+        open_for = now - sc.open_at
+        return idle >= self.idle_for or open_for >= self.max_open_for
+
+    def get_stale_cards(self) -> List[str]:
+        now = datetime.now(timezone.utc)
+        stale_ids: List[str] = []
+        for cid, sc in self.scorecards.items():
+            idle = now - sc.last_update
+            open_for = now - sc.open_at
+            if idle >= self.idle_for:
+                stale_ids.append(cid)
+                logger.info(
+                    "[get_stale_cards] stale scorecard card_id=%s idle=%s (%.1fs) "
+                    "threshold=%s (%.1fs)",
+                    cid,
+                    idle,
+                    idle.total_seconds(),
+                    self.idle_for,
+                    self.idle_for.total_seconds(),
+                )
+            elif open_for >= self.max_open_for:
+                stale_ids.append(cid)
+                logger.info(
+                    "[get_stale_cards] scorecard open too long card_id=%s open_for=%s (%.1fs) "
+                    "threshold=%s (%.1fs)",
+                    cid,
+                    open_for,
+                    open_for.total_seconds(),
+                    self.max_open_for,
+                    self.max_open_for.total_seconds(),
+                )
+        return stale_ids
+
+    def new_scorecard(
+        self,
+        source_url: Optional[str],
+        tags: Optional[list[str]],
+        api_key: str,
+        opaque: Any | None,
+        competition_mode: bool | None = None,
+    ) -> str:
+        card_id = str(uuid.uuid4())
+        self.scorecards[card_id] = Scorecard.model_validate(
+            {
+                "games": self.games,
+                "source_url": source_url,
+                "tags": tags,
+                "card_id": card_id,
+                "api_key": api_key,
+                "opaque": opaque,
+                "competition_mode": competition_mode,
+            }
+        )
+        return card_id
+
+    def get_dummy_scorecard(self) -> Scorecard:
+        return Scorecard.model_validate({"games": self.games})
+
+    def close_scorecard(
+        self, card_id: str, api_key: str | None
+    ) -> Tuple[Scorecard, list[str], list[str]] | Tuple[None, None, None]:
+        guids: list[str] = []
+        game_id_with_guids: list[str] = []
+        scorecard = self.scorecards.get(card_id)
+        if scorecard and (api_key is None or scorecard.api_key == api_key):
+            for card in scorecard.cards.values():
+                guids.extend(card.guids)
+                game_id_with_guids.extend(f"{g}.{card.game_id}" for g in card.guids)
+            del self.scorecards[card_id]
+            for guid in guids:
+                if guid in self.guids:
+                    del self.guids[guid]
+
+            return scorecard, guids, list(set(game_id_with_guids))
+
+        return None, None, None
+
+    def get_scorecard(self, card_id: str, api_key: str) -> Scorecard | None:
+        scorecard = self.scorecards.get(card_id)
+        if scorecard and scorecard.api_key == api_key:
+            return scorecard
+        return None
+
+    def get_scorecard_from_guid(self, guid: str) -> Scorecard | None:
+        card_id = self.guids.get(guid)
+        if card_id is not None:
+            return self.scorecards.get(card_id)
+        return None
+
+    def add_game(self, card_id: str, guid: str) -> None:
+        scorecard = self.scorecards.get(card_id)
+        if scorecard:
+            self.guids[guid] = card_id
+
+    def update_scorecard(
+        self, guid: str, data: FrameDataRaw, full_reset: bool = True
+    ) -> GameState:
+        card_id = self.guids.get(guid)
+        if not card_id:
+            return GameState.NOT_PLAYED
+        scorecard = self.scorecards.get(card_id)
+        if scorecard is None:
+            return GameState.NOT_PLAYED
+        return scorecard.update_scorecard(guid, data, full_reset)

arcprize__ARC-AGI/arc_agi/server.py

@@ -0,0 +1,130 @@
+from typing import Callable, Optional, Tuple
+
+from arcengine import FrameDataRaw, GameAction
+from flask import Flask, Response
+
+from .api import RestAPI
+from .base import Arcade
+from .scorecard import EnvironmentScorecard
+
+
+def create_app(
+    arcade: Arcade,
+    competition_mode: bool = False,
+    save_all_recordings: bool = False,
+    include_frame_data: bool = True,
+    add_cookie: Optional[Callable[[Response, str], Response]] = None,
+    on_scorecard_close: Optional[Callable[[EnvironmentScorecard], None]] = None,
+    renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+) -> Tuple[Flask, RestAPI]:
+    """Create and configure the Flask application."""
+    app = Flask(__name__)
+    api = RestAPI(
+        arcade=arcade,
+        competition_mode=competition_mode,
+        save_all_recordings=save_all_recordings,
+        include_frame_data=include_frame_data,
+        add_cookie=add_cookie,
+        on_scorecard_close=on_scorecard_close,
+        renderer=renderer,
+    )
+
+    app.api = api
+
+    # api routes
+    app.add_url_rule(
+        "/api/games",
+        methods=["GET"],
+        view_func=lambda: api.get_games(),
+        endpoint="games",
+    )
+    app.add_url_rule(
+        "/api/games/<game_id>",
+        methods=["GET"],
+        view_func=lambda game_id: api.get_game_info(game_id=game_id),
+        endpoint="game_by_id",
+    )
+
+    app.add_url_rule(
+        "/api/scorecard/open",
+        methods=["POST"],
+        view_func=lambda: api.new_scorecard(),
+        endpoint="open_scorecard",
+    )
+    app.add_url_rule(
+        "/api/scorecard/close",
+        methods=["POST"],
+        view_func=lambda: api.close_scorecard(),
+        endpoint="close_scorecard",
+    )
+    app.add_url_rule(
+        "/api/scorecard/<card_id>",
+        methods=["GET"],
+        view_func=lambda card_id: api.get_scorecard(card_id=card_id),
+        endpoint="scorecard",
+    )
+    app.add_url_rule(
+        "/api/scorecard/<card_id>/<game_id>",
+        methods=["GET"],
+        view_func=lambda card_id, game_id: api.get_scorecard(
+            card_id=card_id, game_id=game_id
+        ),
+        endpoint="scorecard_with_gameid",
+    )
+
+    app.add_url_rule(
+        "/api/cmd/RESET",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.RESET),
+        endpoint="reset",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION1",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION1),
+        endpoint="action1",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION2",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION2),
+        endpoint="action2",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION3",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION3),
+        endpoint="action3",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION4",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION4),
+        endpoint="action4",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION5",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION5),
+        endpoint="action5",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION6",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION6),
+        endpoint="action6",
+    )
+    app.add_url_rule(
+        "/api/cmd/ACTION7",
+        methods=["POST"],
+        view_func=lambda: api.cmd(action=GameAction.ACTION7),
+        endpoint="action7",
+    )
+    app.add_url_rule(
+        "/api/healthcheck",
+        methods=["GET"],
+        view_func=lambda: ("okay", 200, {"Content-Type": "text/plain"}),
+        endpoint="healthcheck",
+    )
+
+    return app, api

arcprize__ARC-AGI/arc_agi/wrapper.py

@@ -0,0 +1,236 @@
+"""Environment wrapper for ARC-AGI-3 environments."""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from arcengine import FrameDataRaw, GameAction
+
+from .models import EnvironmentInfo
+from .scorecard import ScorecardManager
+
+
+class EnvironmentWrapper:
+    """Base wrapper class for ARC-AGI-3 environments.
+
+    This class provides a common interface for interacting with environments,
+    whether they are local or remote. Subclasses should implement the `reset`
+    and `step` methods to provide environment-specific behavior.
+    """
+
+    def __init__(
+        self,
+        environment_info: EnvironmentInfo,
+        logger: logging.Logger,
+        scorecard_id: str,
+        save_recording: bool = False,
+        include_frame_data: bool = True,
+        recordings_dir: str = "recordings",
+        scorecard_manager: Optional[ScorecardManager] = None,
+        renderer: Optional[Callable[[int, FrameDataRaw], None]] = None,
+    ) -> None:
+        """Initialize the environment wrapper.
+
+        Args:
+            environment_info: Information about the environment.
+            logger: Logger instance for logging.
+            scorecard_id: Optional scorecard ID for tracking runs.
+            save_recording: Whether to save recordings to JSONL file.
+            include_frame_data: Whether to include frame data in the recording file.
+            recordings_dir: Directory to save recordings.
+            scorecard_manager: Optional scorecard manager for tracking.
+            renderer: Optional callable that accepts FrameDataRaw and performs custom rendering.
+        """
+        self.environment_info = environment_info
+        self.logger = logger
+        self.scorecard_id = scorecard_id
+        self.save_recording = save_recording
+        self.include_frame_data = include_frame_data
+        self.recordings_dir = recordings_dir
+        self.scorecard_manager = scorecard_manager
+        self.renderer = renderer
+        self._last_response: Optional[FrameDataRaw] = None
+        self._guid: Optional[str] = None
+        self._recording_filename: Optional[Path] = None
+        self._steps: int = 0
+        # Note: _setup_recording_file() should be called after guid is set
+
+    def reset(self) -> Optional[FrameDataRaw]:
+        """Reset the environment.
+
+        This method should be overridden by subclasses to provide
+        environment-specific reset behavior.
+        """
+        return None
+
+    def step(
+        self,
+        action: GameAction,
+        data: Optional[dict[str, Any]] = None,
+        reasoning: Optional[dict[str, Any]] = None,
+    ) -> Optional[FrameDataRaw]:
+        """Perform a step in the environment.
+
+        This method should be overridden by subclasses to provide
+        environment-specific step behavior.
+        """
+        return None
+
+    def _setup_recording_file(self) -> None:
+        """Set up the recording file path for JSONL output."""
+        if not self._guid:
+            self.logger.warning("Cannot setup recording file: guid not set")
+            return
+
+        try:
+            # Create directory structure: {recordings_dir}/{scorecard_id}/
+            recording_dir = Path(self.recordings_dir) / self.scorecard_id
+            recording_dir.mkdir(parents=True, exist_ok=True)
+
+            # Create filename: {game_id}-{guid}.jsonl
+            filename = f"{self.environment_info.game_id}-{self._guid}.jsonl"
+            self._recording_filename = recording_dir / filename
+
+            self.logger.info(f"Recording to {self._recording_filename}")
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to setup recording file: {e}",
+                exc_info=True,
+            )
+            self._recording_filename = None
+
+    def _record(self, data: dict[str, Any]) -> None:
+        """Records an event to the file.
+
+        Args:
+            data: Dictionary (JSON-serializable) to record.
+        """
+        if not self.save_recording or not self._recording_filename:
+            return
+
+        try:
+            event: dict[str, Any] = {}
+            event["timestamp"] = datetime.now(timezone.utc).isoformat()
+            event["data"] = data
+
+            with open(self._recording_filename, "a", encoding="utf-8") as f:
+                json.dump(event, f)
+                f.write("\n")
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to write to recording file: {e}",
+                exc_info=True,
+            )
+
+    def _set_last_response(
+        self, resp: FrameDataRaw, reasoning: Optional[dict[str, Any]] = None
+    ) -> None:
+        """Set the last response from the environment.
+
+        Args:
+            resp: The FrameDataRaw response from the environment.
+            reasoning: Optional reasoning dictionary to include in recording.
+        """
+        self._last_response = resp
+
+        # Save to recording file if enabled
+        if self.save_recording:
+            # Convert FrameDataRaw to JSON-serializable dict
+            data: dict[str, Any] = {
+                "game_id": resp.game_id,
+                "state": resp.state.name
+                if hasattr(resp.state, "name")
+                else str(resp.state),
+                "levels_completed": resp.levels_completed,
+                "win_levels": resp.win_levels,
+                "action_input": {
+                    "id": resp.action_input.id.name
+                    if hasattr(resp.action_input.id, "name")
+                    else str(resp.action_input.id),
+                    "data": resp.action_input.data,
+                    "reasoning": reasoning
+                    if reasoning
+                    else resp.action_input.reasoning,
+                }
+                if resp.action_input
+                else None,
+                "guid": resp.guid,
+                "full_reset": getattr(resp, "full_reset", False),
+                "available_actions": resp.available_actions,
+            }
+            if self.include_frame_data:
+                data["frame"] = [
+                    frame_layer.tolist()
+                    if hasattr(frame_layer, "tolist")
+                    else frame_layer
+                    for frame_layer in resp.frame
+                ]
+
+            self._record(data)
+
+        # Render frames if renderer is set
+        self._steps += 1
+        if self.renderer is not None and resp.frame:
+            try:
+                self.renderer(self._steps, resp)
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to render frames: {e}",
+                    exc_info=True,
+                )
+
+        # Update scorecard if manager is available
+        if self.scorecard_manager and resp.guid and len(resp.frame) > 0:
+            try:
+                # Register guid with scorecard if not already registered
+                self.scorecard_manager.add_game(self.scorecard_id, resp.guid)
+
+                # Update scorecard
+                self.scorecard_manager.update_scorecard(
+                    resp.guid, resp, resp.full_reset
+                )
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to update scorecard: {e}",
+                    exc_info=True,
+                )
+
+    @property
+    def observation_space(self) -> Optional[FrameDataRaw]:
+        """Get the observation space (last response data).
+
+        Returns:
+            The FrameDataRaw object from the last response, or None if no
+            response has been set yet.
+        """
+        return self._last_response
+
+    @property
+    def action_space(self) -> list[GameAction]:
+        """Get the action space (available actions).
+
+        Returns:
+            A list of GameAction objects converted from the available_actions
+            in the last response. Returns an empty list if no response has
+            been set yet or if available_actions is empty.
+        """
+        if self._last_response is None or not self._last_response.available_actions:
+            return []
+
+        return [
+            GameAction.from_id(action_id)
+            for action_id in self._last_response.available_actions
+        ]
+
+    @property
+    def info(self) -> EnvironmentInfo:
+        """Get the environment information.
+
+        Returns:
+            The EnvironmentInfo object for this environment.
+        """
+        return self.environment_info

arcprize__ARC-AGI/test_environment_files/game1/bt11.py

@@ -0,0 +1,111 @@
+from arcengine import (
+    ARCBaseGame,
+    Camera,
+    GameAction,
+    Level,
+    Sprite,
+)
+
+# Create sprites dictionary with all sprite definitions
+sprites = {
+    "bad": Sprite(
+        pixels=[
+            [8],
+        ],
+        name="bad",
+        visible=True,
+        collidable=True,
+    ),
+    "good": Sprite(
+        pixels=[
+            [14],
+        ],
+        name="good",
+        visible=True,
+        collidable=True,
+    ),
+}
+
+# Create levels array with all level definitions
+levels = [
+    # Level 1
+    Level(
+        sprites=[],
+        grid_size=(8, 8),
+    ),
+    # Level 2
+    Level(
+        sprites=[],
+        grid_size=(16, 16),
+    ),
+    # Level 3
+    Level(
+        sprites=[],
+        grid_size=(32, 32),
+    ),
+    # Level 4
+    Level(
+        sprites=[],
+        grid_size=(40, 40),
+    ),
+    # Level 5
+    Level(
+        sprites=[],
+        grid_size=(48, 48),
+    ),
+]
+
+BACKGROUND_COLOR = 5
+
+PADDING_COLOR = 3
+
+
+class Bt11(ARCBaseGame):
+    _won: bool = True
+    _depth: int = 0
+    _position: int = 0
+
+    def __init__(self) -> None:
+        # Create camera
+        camera = Camera(
+            background=BACKGROUND_COLOR,
+            letter_box=PADDING_COLOR,
+        )
+
+        # Initialize the base game
+        super().__init__(
+            game_id="bt11", levels=levels, camera=camera, available_actions=[3, 4]
+        )
+
+    def step(self) -> None:
+        # Add here any logic you want
+        if self.action.id == GameAction.ACTION3:  # Move Left
+            if self._depth > 0:
+                self._position -= 1
+            sprite_name = "good"
+            if not self._won:
+                sprite_name = "bad"
+            self.current_level.add_sprite(
+                sprites[sprite_name].clone().set_position(self._position, self._depth)
+            )
+            self._depth += 1
+        elif self.action.id == GameAction.ACTION4:  # Move Right
+            self._position += 1
+            self.current_level.add_sprite(
+                sprites["bad"].clone().set_position(self._position, self._depth)
+            )
+            self._won = False
+            self._depth += 1
+
+        if self._depth >= self.camera.width // 2:
+            if self._won:
+                self.next_level()
+            else:
+                self.lose()
+
+        self.complete_action()
+
+    def on_set_level(self, level: Level) -> None:
+        self._won = True
+        self._depth = 0
+        self._position = self.camera.width // 2 - 1

arcprize__ARC-AGI/test_environment_files/game1/metadata.json

@@ -0,0 +1,9 @@
+{
+    "game_id": "bt11-fd9df0622a1a",
+    "title": "BT11",
+    "tags": ["tag1", "tag2"],
+    "private_tags": ["private_tag1", "private_tag2"],
+    "level_tags": [["level_tag1"], ["level_tag2"], ["level_tag3"], ["level_tag4"], ["level_tag5"]],
+    "baseline_actions": [4, 8, 16, 20, 24],
+    "date_downloaded": "2024-01-20T12:00:00Z"
+}

arcprize__ARC-AGI/test_environment_files/game2/subdir/bt33.py

@@ -0,0 +1,166 @@
+from arcengine import (
+    ARCBaseGame,
+    Camera,
+    GameAction,
+    Level,
+    Sprite,
+)
+
+# Create sprites dictionary with all sprite definitions
+sprites = {
+    "bad": Sprite(
+        pixels=[
+            [8],
+        ],
+        name="bad",
+        visible=True,
+        collidable=True,
+        scale=1,
+    ),
+    "good": Sprite(
+        pixels=[
+            [14],
+        ],
+        name="good",
+        visible=True,
+        collidable=True,
+        scale=1,
+    ),
+    "left": Sprite(
+        pixels=[
+            [14, 14],
+            [14, -1],
+        ],
+        name="left",
+        visible=True,
+        collidable=True,
+        tags=["sys_click"],
+    ),
+    "right": Sprite(
+        pixels=[
+            [8, 8],
+            [-1, 8],
+        ],
+        name="right",
+        visible=True,
+        collidable=True,
+        tags=["sys_click"],
+    ),
+}
+
+# Create levels array with all level definitions
+levels = [
+    # Level 1
+    Level(
+        sprites=[],
+        grid_size=(8, 8),
+    ),
+    # Level 2
+    Level(
+        sprites=[],
+        grid_size=(16, 16),
+    ),
+    # Level 3
+    Level(
+        sprites=[],
+        grid_size=(32, 32),
+    ),
+    # Level 4
+    Level(
+        sprites=[],
+        grid_size=(40, 40),
+    ),
+    # Level 5
+    Level(
+        sprites=[],
+        grid_size=(48, 48),
+    ),
+]
+
+BACKGROUND_COLOR = 5
+
+PADDING_COLOR = 3
+
+
+class Bt33(ARCBaseGame):
+    _won: bool = True
+    _depth: int = 0
+    _placement: int = 0
+
+    def __init__(self) -> None:
+        # Create camera
+        camera = Camera(
+            background=BACKGROUND_COLOR,
+            letter_box=PADDING_COLOR,
+        )
+
+        # Initialize the base game
+        super().__init__(
+            game_id="bt33", levels=levels, camera=camera, available_actions=[6]
+        )
+
+    def step(self) -> None:
+        # Add here any logic you want
+        if self.action.id == GameAction.ACTION6:
+            x = self.action.data.get("x", 0)
+            y = self.action.data.get("y", 0)
+
+            coords = self.camera.display_to_grid(x, y)
+            if coords:
+                sprite = self.current_level.get_sprite_at(coords[0], coords[1])
+                if sprite and sprite.name == "left":
+                    if self._depth > 0:
+                        self._placement -= 1
+                    sprite_name = "good"
+                    if not self._won:
+                        sprite_name = "bad"
+                    self.current_level.add_sprite(
+                        sprites[sprite_name]
+                        .clone()
+                        .set_position(self._placement, self._depth)
+                    )
+
+                    self._depth += 1
+                elif sprite and sprite.name == "right":
+                    self._placement += 1
+                    self.current_level.add_sprite(
+                        sprites["bad"]
+                        .clone()
+                        .set_position(self._placement, self._depth)
+                    )
+                    self._won = False
+                    self._depth += 1
+
+        if self._depth >= self.camera.width // 2:
+            if self._won:
+                self.next_level()
+            else:
+                self.lose()
+
+        self.complete_action()
+
+    def on_set_level(self, level: Level) -> None:
+        self._depth = 0
+        self._placement = self.camera.width // 2 - 1
+        self._won = True
+        scale = self._current_level_index
+        if scale == 0:
+            self.current_level.add_sprite(
+                sprites["left"].clone().set_position(0, 0).set_scale(1)
+            )
+            self.current_level.add_sprite(
+                sprites["right"]
+                .clone()
+                .set_position(self.camera.width - 2, 0)
+                .set_scale(1)
+            )
+        else:
+            self.current_level.add_sprite(
+                sprites["left"].clone().set_position(0, 0).set_scale(scale)
+            )
+            self.current_level.add_sprite(
+                sprites["right"]
+                .clone()
+                .set_position(self.camera.width - (2 * scale), 0)
+                .set_scale(scale)
+            )

arcprize__ARC-AGI/test_environment_files/game2/subdir/metadata.json

@@ -0,0 +1,10 @@
+{
+    "game_id": "bt33-a7c3f9d18b4e",
+    "title": "BT33",
+    "tags": ["tag3", "tag4"],
+    "private_tags": ["private_tag3", "private_tag4"],
+    "level_tags": [["level_tag3"], ["level_tag4"], ["level_tag5"]],
+    "baseline_actions": [10, 15, 20],
+    "class_name": "Bt33",
+    "date_downloaded": "2024-01-19T10:00:00Z"
+}

arcprize__ARC-AGI/tests/__init__.py

@@ -0,0 +1,29 @@
+"""Tests for ARC-AGI"""
+
+from .test_base import (
+    TestARCAGI3BooleanParsing,
+    TestARCAGI3Defaults,
+    TestARCAGI3EdgeCases,
+    TestARCAGI3EnvironmentVariables,
+)
+from .test_listen_and_serve import TestListenAndServe
+from .test_local_wrapper import TestLocalEnvironmentWrapper
+from .test_models import TestEnvironmentInfo
+from .test_scorecard import (
+    TestEnvironmentScore,
+    TestEnvironmentScorecard,
+    TestScorecard,
+)
+
+__all__ = [
+    "TestARCAGI3Defaults",
+    "TestARCAGI3EnvironmentVariables",
+    "TestARCAGI3BooleanParsing",
+    "TestARCAGI3EdgeCases",
+    "TestEnvironmentInfo",
+    "TestLocalEnvironmentWrapper",
+    "TestEnvironmentScore",
+    "TestEnvironmentScorecard",
+    "TestScorecard",
+    "TestListenAndServe",
+]

arcprize__ARC-AGI/tests/test_base.py

@@ -0,0 +1,639 @@
+"""Tests for the ARCAGI3 base class using unittest."""
+
+import logging
+import os
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+
+import requests
+
+# Create a mock dotenv module before any imports
+_mock_dotenv = MagicMock()
+_mock_dotenv.load_dotenv = MagicMock()
+sys.modules["dotenv"] = _mock_dotenv
+
+# Now import arcagi3 - the mock will be used instead of real dotenv
+from arc_agi import Arcade, OperationMode  # noqa: E402
+
+
+class TestARCAGI3Defaults(unittest.TestCase):
+    """Test ARCAGI3 with default values."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OPERATION_MODE",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_default_initialization(self):
+        """Test that default values are used when no parameters are provided."""
+        client = Arcade()
+
+        self.assertEqual(client.arc_api_key, "test-key-123")
+        self.assertEqual(client.arc_base_url, "https://three.arcprize.org")
+        self.assertEqual(client.operation_mode, OperationMode.NORMAL)
+        self.assertEqual(client.environments_dir, "environment_files")
+
+    def test_constructor_parameters(self):
+        """Test that constructor parameters are used correctly."""
+        client = Arcade(
+            arc_api_key="test-key-123",
+            arc_base_url="https://custom.example.com",
+            operation_mode=OperationMode.OFFLINE,
+        )
+
+        self.assertEqual(client.arc_api_key, "test-key-123")
+        self.assertEqual(client.arc_base_url, "https://custom.example.com")
+        self.assertEqual(client.operation_mode, OperationMode.OFFLINE)
+
+    def test_default_logger_created(self):
+        """Test that a default logger is created when None is passed."""
+        client = Arcade()
+
+        self.assertIsNotNone(client.logger)
+        self.assertIsInstance(client.logger, logging.Logger)
+        # Check that logger has a StreamHandler pointing to stdout
+        handlers = client.logger.handlers
+        self.assertGreater(len(handlers), 0)
+        stdout_handlers = [h for h in handlers if isinstance(h, logging.StreamHandler)]
+        self.assertGreater(len(stdout_handlers), 0)
+
+    def test_custom_logger_used(self):
+        """Test that a custom logger is used when provided."""
+        custom_logger = logging.getLogger("custom_test_logger")
+        custom_logger.setLevel(logging.DEBUG)
+        client = Arcade(logger=custom_logger)
+
+        self.assertEqual(client.logger, custom_logger)
+        self.assertEqual(client.logger.name, "custom_test_logger")
+        self.assertEqual(client.logger.level, logging.DEBUG)
+
+
+class TestARCAGI3EnvironmentVariables(unittest.TestCase):
+    """Test ARCAGI3 with environment variable overrides."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OPERATION_MODE",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_arc_api_key_from_env(self):
+        """Test that constructor argument overrides environment variable."""
+        os.environ["ARC_API_KEY"] = "env-key-456"
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE, arc_api_key="constructor-key"
+        )
+
+        self.assertEqual(client.arc_api_key, "constructor-key")
+
+    def test_arc_base_url_from_env(self):
+        """Test that constructor argument overrides environment variable."""
+        os.environ["ARC_BASE_URL"] = "https://env.example.com"
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            arc_base_url="https://constructor.example.com",
+        )
+
+        self.assertEqual(client.arc_base_url, "https://constructor.example.com")
+
+    def test_operation_mode_from_constructor_overrides_env(self):
+        """Test that constructor argument overrides OPERATION_MODE env var."""
+        os.environ["OPERATION_MODE"] = "normal"
+        client = Arcade(operation_mode=OperationMode.OFFLINE)
+
+        self.assertEqual(client.operation_mode, OperationMode.OFFLINE)
+
+    def test_operation_mode_from_env_when_normal_passed(self):
+        """Test that when NORMAL is passed (default), env var is still checked."""
+        os.environ["OPERATION_MODE"] = "offline"
+        client = Arcade(operation_mode=OperationMode.NORMAL)
+
+        self.assertEqual(client.operation_mode, OperationMode.OFFLINE)
+
+    def test_operation_mode_online_from_constructor_overrides_env(self):
+        """Test that constructor ONLINE overrides env var."""
+        os.environ["OPERATION_MODE"] = "normal"
+        client = Arcade(operation_mode=OperationMode.ONLINE)
+
+        self.assertEqual(client.operation_mode, OperationMode.ONLINE)
+
+    def test_operation_mode_from_env_when_default(self):
+        """Test that OPERATION_MODE env is used when default NORMAL is used."""
+        os.environ["OPERATION_MODE"] = "online"
+        client = Arcade()
+
+        self.assertEqual(client.operation_mode, OperationMode.ONLINE)
+
+    def test_operation_mode_competition(self):
+        """Test that constructor ONLINE overrides env var."""
+        os.environ["OPERATION_MODE"] = "competition"
+        client = Arcade()
+
+        self.assertEqual(client.operation_mode, OperationMode.COMPETITION)
+
+    def test_operation_mode_competition_from_env_overrides_constructor(self):
+        """Test that constructor ONLINE overrides env var."""
+        os.environ["OPERATION_MODE"] = "competition"
+        client = Arcade(operation_mode=OperationMode.ONLINE)
+
+        self.assertEqual(client.operation_mode, OperationMode.COMPETITION)
+
+
+class TestARCAGI3BooleanParsing(unittest.TestCase):
+    """Test boolean/enum parsing from environment variables."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = [
+            "OPERATION_MODE",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_operation_mode_env_normal_when_offline_false(self):
+        """Test that OFFLINE_ONLY=false yields NORMAL when no other env set."""
+        os.environ["OFFLINE_ONLY"] = "false"
+        client = Arcade()
+        self.assertEqual(client.operation_mode, OperationMode.NORMAL)
+
+    def test_operation_mode_env_online_false_yields_normal(self):
+        """Test that ONLINE_ONLY=false with no OPERATION_MODE yields NORMAL."""
+        os.environ["ONLINE_ONLY"] = "false"
+        client = Arcade()
+        self.assertEqual(client.operation_mode, OperationMode.NORMAL)
+
+
+class TestARCAGI3EdgeCases(unittest.TestCase):
+    """Test edge cases and special scenarios."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OPERATION_MODE",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_empty_string_api_key(self):
+        """Test that empty string API key is handled correctly."""
+        client = Arcade(arc_api_key="")
+
+        self.assertEqual(client.arc_api_key, "test-key-123")
+
+    def test_constructor_overrides_when_env_not_set(self):
+        """Test that constructor values are used when env vars are not set."""
+        client = Arcade(
+            arc_api_key="constructor-key",
+            arc_base_url="https://constructor.url",
+            operation_mode=OperationMode.ONLINE,
+        )
+
+        self.assertEqual(client.arc_api_key, "constructor-key")
+        self.assertEqual(client.arc_base_url, "https://constructor.url")
+        self.assertEqual(client.operation_mode, OperationMode.ONLINE)
+
+    def test_all_env_vars_set(self):
+        """Test that all environment variables can be set simultaneously."""
+        os.environ["ARC_API_KEY"] = "env-api-key"
+        os.environ["ARC_BASE_URL"] = "https://env.url"
+        os.environ["OPERATION_MODE"] = "online"
+
+        client = Arcade()
+
+        self.assertEqual(client.arc_api_key, "env-api-key")
+        self.assertEqual(client.arc_base_url, "https://env.url")
+        self.assertEqual(client.operation_mode, OperationMode.ONLINE)
+
+
+class TestARCAGI3EnvironmentsDirScanning(unittest.TestCase):
+    """Test environments_dir scanning functionality."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = ["ENVIRONMENTS_DIR"]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_environments_dir_scanning(self):
+        """Test that environments_dir scanning finds metadata.json files."""
+        import tempfile
+        from pathlib import Path
+
+        # Create a temporary directory structure
+        with tempfile.TemporaryDirectory() as tmpdir:
+            environments_dir = Path(tmpdir) / "environments"
+            environments_dir.mkdir()
+
+            # Create environment1 with metadata.json
+            env1_dir = environments_dir / "env1"
+            env1_dir.mkdir()
+            metadata1 = env1_dir / "metadata.json"
+            metadata1.write_text(
+                '{"game_id": "test1", "title": "Test1", "tags": ["tag1"], "baseline_actions": [10]}',
+                encoding="utf-8",
+            )
+
+            # Create environment2 in subdirectory
+            env2_dir = environments_dir / "env2" / "subdir"
+            env2_dir.mkdir(parents=True)
+            metadata2 = env2_dir / "metadata.json"
+            metadata2.write_text(
+                '{"game_id": "test2", "title": "Test2", "tags": ["tag2"], "baseline_actions": [20]}',
+                encoding="utf-8",
+            )
+
+            # Create invalid metadata file (should be skipped)
+            env3_dir = environments_dir / "env3"
+            env3_dir.mkdir()
+            metadata3 = env3_dir / "metadata.json"
+            metadata3.write_text("invalid json", encoding="utf-8")
+
+            # Initialize ARCAGI3 with environments_dir
+            client = Arcade(environments_dir=str(environments_dir))
+
+            # Should have found 2 valid environments
+            self.assertEqual(len(client.available_environments), 2)
+            # Check that both environments were found (order may vary)
+            environment_ids = {env.game_id for env in client.available_environments}
+            self.assertEqual(environment_ids, {"test1", "test2"})
+
+    def test_environments_dir_none(self):
+        """Test that environments_dir can be explicitly set to None."""
+        client = Arcade(environments_dir=None)
+
+        self.assertIsNone(client.environments_dir)
+        self.assertEqual(len(client.available_environments), 0)
+
+    def test_environments_dir_default(self):
+        """Test that environments_dir defaults to 'environment_files'."""
+        client = Arcade()
+
+        self.assertEqual(client.environments_dir, "environment_files")
+
+    def test_environments_dir_nonexistent(self):
+        """Test that non-existent environments_dir is handled gracefully."""
+        client = Arcade(environments_dir="/nonexistent/path")
+
+        self.assertEqual(client.environments_dir, "/nonexistent/path")
+        self.assertEqual(len(client.available_environments), 0)
+
+    def test_environments_dir_from_env(self):
+        """Test that environments_dir can be set from environment variable when constructor uses default."""
+        import tempfile
+        from pathlib import Path
+
+        # Create a temporary directory with metadata
+        with tempfile.TemporaryDirectory() as tmpdir:
+            environments_dir = Path(tmpdir) / "environments"
+            environments_dir.mkdir()
+            env_dir = environments_dir / "env1"
+            env_dir.mkdir()
+            metadata = env_dir / "metadata.json"
+            metadata.write_text(
+                '{"game_id": "env-test", "title": "EnvTest", "tags": ["tag1"], "baseline_actions": [10]}',
+                encoding="utf-8",
+            )
+
+            os.environ["ENVIRONMENTS_DIR"] = str(environments_dir)
+            try:
+                # No constructor arg, should use env var
+                client = Arcade()
+
+                self.assertEqual(client.environments_dir, str(environments_dir))
+                self.assertEqual(len(client.available_environments), 1)
+                self.assertEqual(client.available_environments[0].game_id, "env-test")
+            finally:
+                os.environ.pop("ENVIRONMENTS_DIR", None)
+
+    def test_environments_dir_empty_directory(self):
+        """Test that empty environments_dir results in no environments."""
+        import tempfile
+        from pathlib import Path
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            environments_dir = Path(tmpdir) / "environments"
+            environments_dir.mkdir()
+
+            client = Arcade(environments_dir=str(environments_dir))
+
+            self.assertEqual(len(client.available_environments), 0)
+
+    def test_environments_dir_with_test_files(self):
+        """Test scanning the test_environment_files directory."""
+        from pathlib import Path
+
+        test_environments_dir = Path(__file__).parent.parent / "test_environment_files"
+        if test_environments_dir.exists():
+            client = Arcade(environments_dir=str(test_environments_dir))
+
+            # Should find at least 2 metadata.json files
+            self.assertGreaterEqual(len(client.available_environments), 2)
+            # Check that the expected environments are found
+            environment_ids = {env.game_id for env in client.available_environments}
+            self.assertIn("bt11-fd9df0622a1a", environment_ids)
+            self.assertIn("tg62-12345678", environment_ids)
+
+
+class TestARCAGI3APIFetching(unittest.TestCase):
+    """Test API fetching functionality."""
+
+    def setUp(self):
+        """Clear environment variables before each test."""
+        self.env_vars_to_clear = [
+            "ENVIRONMENTS_DIR",
+            "OPERATION_MODE",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "ARC_API_KEY",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up environment variables after each test."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_fetch_when_not_offline(self, mock_get):
+        """Test that API is called when not in OFFLINE mode."""
+        # Mock API response
+        mock_response = MagicMock()
+        mock_response.json.return_value = [
+            {
+                "game_id": "api-game-1",
+                "title": "API Game 1",
+                "tags": ["api-tag"],
+                "baseline_actions": [10, 20],
+            }
+        ]
+        mock_response.raise_for_status = MagicMock()
+        mock_get.return_value = mock_response
+
+        client = Arcade(
+            arc_api_key="test-api-key",
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,  # No local scanning
+        )
+
+        # Verify API was called
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[0][0], "https://three.arcprize.org/api/games")
+        self.assertEqual(call_args[1]["headers"]["X-API-Key"], "test-api-key")
+
+        # Verify environment was added
+        self.assertEqual(len(client.available_environments), 1)
+        self.assertEqual(client.available_environments[0].game_id, "api-game-1")
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_not_fetched_when_offline(self, mock_get):
+        """Test that API is not called when in OFFLINE mode."""
+        _ = Arcade(
+            arc_api_key="test-api-key",
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=None,
+        )
+
+        # Verify API was not called
+        mock_get.assert_not_called()
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_merge_with_local_environments(self, mock_get):
+        """Test that API environments are merged with local environments."""
+        import tempfile
+        from pathlib import Path
+
+        # Mock API response
+        mock_response = MagicMock()
+        mock_response.json.return_value = [
+            {
+                "game_id": "api-game-1",
+                "title": "API Game 1",
+                "tags": ["api-tag"],
+                "baseline_actions": [10],
+            }
+        ]
+        mock_response.raise_for_status = MagicMock()
+        mock_get.return_value = mock_response
+
+        # Create local environment with different game_id
+        with tempfile.TemporaryDirectory() as tmpdir:
+            environments_dir = Path(tmpdir) / "environments"
+            environments_dir.mkdir()
+            env_dir = environments_dir / "env1"
+            env_dir.mkdir()
+            metadata = env_dir / "metadata.json"
+            metadata.write_text(
+                '{"game_id": "local-game-1", "title": "Local Game 1", "tags": ["local-tag"], "baseline_actions": [5]}',
+                encoding="utf-8",
+            )
+
+            client = Arcade(
+                arc_api_key="test-api-key",
+                operation_mode=OperationMode.NORMAL,
+                environments_dir=str(environments_dir),
+            )
+
+            # Should have both local and API environments
+            self.assertEqual(len(client.available_environments), 2)
+            game_ids = {env.game_id for env in client.available_environments}
+            self.assertEqual(game_ids, {"local-game-1", "api-game-1"})
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_removes_duplicate_game_ids(self, mock_get):
+        """Test that duplicate game_ids from API are not added if they exist locally."""
+        import tempfile
+        from pathlib import Path
+
+        # Mock API response with same game_id as local
+        mock_response = MagicMock()
+        mock_response.json.return_value = [
+            {
+                "game_id": "duplicate-game",
+                "title": "API Version",
+                "tags": ["api-tag"],
+                "baseline_actions": [10],
+            }
+        ]
+        mock_response.raise_for_status = MagicMock()
+        mock_get.return_value = mock_response
+
+        # Create local environment with same game_id
+        with tempfile.TemporaryDirectory() as tmpdir:
+            environments_dir = Path(tmpdir) / "environments"
+            environments_dir.mkdir()
+            env_dir = environments_dir / "env1"
+            env_dir.mkdir()
+            metadata = env_dir / "metadata.json"
+            metadata.write_text(
+                '{"game_id": "duplicate-game", "title": "Local Version", "tags": ["local-tag"], "baseline_actions": [5]}',
+                encoding="utf-8",
+            )
+
+            client = Arcade(
+                arc_api_key="test-api-key",
+                operation_mode=OperationMode.NORMAL,
+                environments_dir=str(environments_dir),
+            )
+
+            # Should only have one environment (local version, API duplicate ignored)
+            self.assertEqual(len(client.available_environments), 1)
+            self.assertEqual(client.available_environments[0].game_id, "duplicate-game")
+            # Should be the local version (scanned first)
+            self.assertEqual(client.available_environments[0].title, "Local Version")
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_no_key_skips_fetch(self, mock_get):
+        """Test that API is not called when no API key is provided."""
+        _ = Arcade(
+            arc_api_key="",  # Empty API key
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,
+        )
+
+        # Verify API was not called
+        mock_get.assert_not_called()
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_error_handled_gracefully(self, mock_get):
+        """Test that API errors are handled gracefully."""
+        # Mock API error
+        mock_get.side_effect = requests.exceptions.RequestException("Network error")
+
+        client = Arcade(
+            arc_api_key="test-api-key",
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,
+        )
+
+        # Should not raise exception, just have no environments
+        self.assertEqual(len(client.available_environments), 0)
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_http_error_handled_gracefully(self, mock_get):
+        """Test that HTTP errors are handled gracefully."""
+        # Mock HTTP error response
+        mock_response = MagicMock()
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(
+            "404 Not Found"
+        )
+        mock_get.return_value = mock_response
+
+        client = Arcade(
+            arc_api_key="test-api-key",
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,
+        )
+
+        # Should not raise exception, just have no environments
+        self.assertEqual(len(client.available_environments), 0)
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_invalid_response_handled_gracefully(self, mock_get):
+        """Test that invalid API responses are handled gracefully."""
+        # Mock invalid JSON response
+        mock_response = MagicMock()
+        mock_response.json.side_effect = ValueError("Invalid JSON")
+        mock_response.raise_for_status = MagicMock()
+        mock_get.return_value = mock_response
+
+        client = Arcade(
+            arc_api_key="test-api-key",
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,
+        )
+
+        # Should not raise exception, just have no environments
+        self.assertEqual(len(client.available_environments), 0)
+
+    @patch("arc_agi.base.requests.get")
+    def test_api_custom_base_url(self, mock_get):
+        """Test that API uses custom base_url."""
+        # Mock API response
+        mock_response = MagicMock()
+        mock_response.json.return_value = []
+        mock_response.raise_for_status = MagicMock()
+        mock_get.return_value = mock_response
+
+        _ = Arcade(
+            arc_api_key="test-api-key",
+            arc_base_url="https://custom.example.com",
+            operation_mode=OperationMode.NORMAL,
+            environments_dir=None,
+        )
+
+        # Verify API was called with custom URL
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[0][0], "https://custom.example.com/api/games")
+
+
+if __name__ == "__main__":
+    unittest.main()

arcprize__ARC-AGI/tests/test_listen_and_serve.py

@@ -0,0 +1,652 @@
+"""Tests for listen_and_serve: offline server with online client."""
+
+import logging
+import os
+import socket
+import sys
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from requests.exceptions import HTTPError
+
+_mock_dotenv = MagicMock()
+_mock_dotenv.load_dotenv = MagicMock()
+sys.modules["dotenv"] = _mock_dotenv
+
+from arcengine import GameAction  # noqa: E402
+
+from arc_agi import (  # noqa: E402
+    Arcade,
+    OperationMode,
+)
+
+
+def _find_free_port() -> int:
+    """Bind to port 0 to get an OS-assigned free port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class TestListenAndServe(unittest.TestCase):
+    """Test listen_and_serve with offline server and online client."""
+
+    def setUp(self) -> None:
+        """Set up test fixtures."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+        self.logger = logging.getLogger("test")
+        self.logger.setLevel(logging.INFO)
+
+        test_dir = Path(__file__).parent.parent / "test_environment_files"
+        self.environments_dir = str(test_dir)
+
+    def tearDown(self) -> None:
+        """Clean up after tests."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_offline_server_online_client_four_action3_levels_completed_one(
+        self,
+    ) -> None:
+        """Spin up Arcade in offline mode with test_environment_files, serve backend,
+        then use online client to play bt11: four ACTION3 steps yield levels_completed=1."""
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        # Server: offline Arcade with test_environment_files
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        # Run server in background thread (blocking listen_and_serve)
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        # Give server time to bind
+        time.sleep(1.5)
+
+        try:
+            # Client: online Arcade pointing at localhost
+            client_arc = Arcade(
+                operation_mode=OperationMode.ONLINE,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            # Open scorecard on server (POST /api/scorecard/open)
+            card_id = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id, "Should get card_id from server")
+
+            # Make remote wrapper for bt11
+            env = client_arc.make(game_id="bt11", scorecard_id=card_id)
+            self.assertIsNotNone(env, "Should create remote environment")
+
+            # get starting frame and play four ACTION3 steps
+            start_frame = env.observation_space
+            self.assertIsNotNone(start_frame, "Reset should return frame")
+            initial_level = start_frame.levels_completed
+
+            for i in range(4):
+                frame = env.step(GameAction.ACTION3)
+                self.assertIsNotNone(frame, f"Step {i + 1} should return frame")
+
+            final_frame = env.observation_space
+            self.assertIsNotNone(final_frame)
+            self.assertEqual(
+                final_frame.levels_completed,
+                1,
+                "Four ACTION3 steps should result in levels_completed=1",
+            )
+            self.assertGreater(
+                final_frame.levels_completed,
+                initial_level,
+                "levels_completed should have increased",
+            )
+
+            result = client_arc.close_scorecard(scorecard_id=card_id)
+            self.assertIsNotNone(result, "Close should return scorecard")
+            self.assertIs(
+                result.competition_mode,
+                False,
+                "Scorecard should not have a competition_mode",
+            )
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_on_client_can_open_multiple_scorecards(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc = Arcade(
+                operation_mode=OperationMode.COMPETITION,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            card_id_1 = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id_1, "Should get card_id from server")
+
+            card_id_2 = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id_2, "Should get card_id from server")
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_on_sever_can_not_open_multiple_scorecards(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                    competition_mode=True,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc = Arcade(
+                operation_mode=OperationMode.COMPETITION,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            card_id_1 = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id_1, "Should get card_id from server")
+
+            with self.assertRaises(HTTPError):
+                client_arc.create_scorecard()
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_scorecard_create_and_close_when_client_is_competition(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc = Arcade(
+                operation_mode=OperationMode.COMPETITION,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            card_id = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id, "Should get card_id from server")
+
+            result = client_arc.close_scorecard(scorecard_id=card_id)
+            self.assertIsNotNone(result, "Close should return scorecard")
+            self.assertIs(
+                result.competition_mode,
+                True,
+                "Scorecard should have competition_mode=True",
+            )
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_scorecard_create_and_close_when_server_is_competition(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                    competition_mode=True,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc = Arcade(
+                operation_mode=OperationMode.ONLINE,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            card_id = client_arc.create_scorecard()
+            self.assertIsNotNone(card_id, "Should get card_id from server")
+
+            # This should throw an exception from the rest server
+            with self.assertRaises(HTTPError):
+                client_arc.get_scorecard(scorecard_id=card_id)
+
+            result = client_arc.close_scorecard(scorecard_id=card_id)
+            self.assertIsNotNone(result, "Close should return scorecard")
+            self.assertIs(
+                result.competition_mode,
+                True,
+                "Scorecard should have competition_mode=True",
+            )
+
+            # Make sure the scoreard has all the environments
+            self.assertIsNotNone(
+                result.find_environment("bt11"), "Should have bt11 in the scorecard"
+            )
+            self.assertIsNotNone(
+                result.find_environment("bt33"), "Should have bt33 in the scorecard"
+            )
+
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_can_only_create_one_instance_of_an_environment(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc_normal = Arcade(
+                operation_mode=OperationMode.ONLINE,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            normal_card_id = client_arc_normal.create_scorecard()
+            self.assertIsNotNone(normal_card_id, "Should get card_id from server")
+
+            normal_env_1 = client_arc_normal.make(
+                game_id="bt11", scorecard_id=normal_card_id
+            )
+            self.assertIsNotNone(normal_env_1, "Should get emv from server")
+            normal_env_2 = client_arc_normal.make(
+                game_id="bt11", scorecard_id=normal_card_id
+            )
+            self.assertIsNotNone(normal_env_2, "Should get card_id from server")
+
+            normal_scorecard = client_arc_normal.close_scorecard(
+                scorecard_id=normal_card_id
+            )
+            normal_env_score = normal_scorecard.find_environment("bt11")
+            self.assertIsNotNone(normal_env_score, "Should get a environment")
+            self.assertEqual(len(normal_env_score.runs), 2, "Should have 2 runs")
+
+            client_arc_comp = Arcade(
+                operation_mode=OperationMode.COMPETITION,
+                arc_base_url=base_url,
+                arc_api_key="test-key-987",
+                logger=self.logger,
+            )
+            comp_card_id = client_arc_comp.create_scorecard()
+            self.assertIsNotNone(comp_card_id, "Should get card_id from server")
+
+            comp_env_1 = client_arc_comp.make(game_id="bt11", scorecard_id=comp_card_id)
+            self.assertIsNotNone(comp_env_1, "Should get env from server")
+            comp_env_2 = client_arc_comp.make(
+                game_id="bt11", scorecard_id=comp_card_id
+            )  # This should raise an error
+            self.assertIsNotNone(comp_env_2, "should get an env")
+            self.assertIsNone(
+                comp_env_2.observation_space, "Should not get a observation space"
+            )
+
+            comp_scorecard = client_arc_comp.close_scorecard(scorecard_id=comp_card_id)
+            comp_env_score = comp_scorecard.find_environment("bt11")
+            self.assertIsNotNone(comp_env_score, "Should get a environment")
+            self.assertEqual(len(comp_env_score.runs), 1, "Should have 1 runs")
+
+        finally:
+            if server_error:
+                raise server_error[0]
+
+    def test_competition_mode_can_only_reset_levels(
+        self,
+    ) -> None:
+        if not Path(self.environments_dir).exists():
+            self.skipTest("test_environment_files not found")
+
+        port = _find_free_port()
+        base_url = f"http://127.0.0.1:{port}"
+
+        server_arc = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            arc_api_key="test-key-123",
+            logger=self.logger,
+        )
+        self.assertGreater(
+            len(server_arc.available_environments),
+            0,
+            "Server should have at least one environment from test_environment_files",
+        )
+
+        server_error: list[Exception] = []
+
+        def run_server() -> None:
+            try:
+                server_arc.listen_and_serve(
+                    host="127.0.0.1",
+                    port=port,
+                    use_reloader=False,
+                )
+            except Exception as e:
+                server_error.append(e)
+
+        server_thread = threading.Thread(target=run_server, daemon=True)
+        server_thread.start()
+
+        time.sleep(1.5)
+
+        try:
+            client_arc_normal = Arcade(
+                operation_mode=OperationMode.ONLINE,
+                arc_base_url=base_url,
+                arc_api_key="test-key-123",
+                logger=self.logger,
+            )
+
+            normal_card_id = client_arc_normal.create_scorecard()
+            self.assertIsNotNone(normal_card_id, "Should get card_id from server")
+
+            normal_env_1 = client_arc_normal.make(
+                game_id="bt11", scorecard_id=normal_card_id
+            )
+            self.assertIsNotNone(normal_env_1, "Should get env from server")
+
+            for i in range(4):
+                frame = normal_env_1.step(GameAction.ACTION3)
+                self.assertIsNotNone(frame, f"Step {i + 1} should return frame")
+
+            normal_final_frame = normal_env_1.observation_space
+            self.assertIsNotNone(normal_final_frame)
+            self.assertEqual(
+                normal_final_frame.levels_completed,
+                1,
+                "Four ACTION3 steps should result in levels_completed=1",
+            )
+
+            normal_reset_frame = normal_env_1.reset()
+            self.assertIsNotNone(normal_reset_frame)
+            self.assertEqual(
+                normal_reset_frame.levels_completed,
+                0,
+                "Full reset should have put us back to the starting level",
+            )
+
+            # Full reset should have 2 runs
+            normal_scorecard = client_arc_normal.close_scorecard(
+                scorecard_id=normal_card_id
+            )
+            normal_env_score = normal_scorecard.find_environment("bt11")
+            self.assertIsNotNone(normal_env_score, "Should get a environment")
+            self.assertEqual(len(normal_env_score.runs), 2, "Should have 2 runs")
+
+            client_arc_comp = Arcade(
+                operation_mode=OperationMode.COMPETITION,
+                arc_base_url=base_url,
+                arc_api_key="test-key-987",
+                logger=self.logger,
+            )
+            comp_card_id = client_arc_comp.create_scorecard()
+            self.assertIsNotNone(comp_card_id, "Should get card_id from server")
+
+            comp_env_1 = client_arc_comp.make(game_id="bt11", scorecard_id=comp_card_id)
+            self.assertIsNotNone(comp_env_1, "Should get env from server")
+
+            for i in range(4):
+                frame = comp_env_1.step(GameAction.ACTION3)
+                self.assertIsNotNone(frame, f"Step {i + 1} should return frame")
+
+            comp_final_frame = comp_env_1.observation_space
+            self.assertIsNotNone(comp_final_frame)
+            self.assertEqual(
+                comp_final_frame.levels_completed,
+                1,
+                "Four ACTION3 steps should result in levels_completed=1",
+            )
+
+            comp_reset_frame = comp_env_1.step(GameAction.RESET)
+            self.assertIsNotNone(comp_reset_frame)
+            self.assertEqual(
+                comp_reset_frame.levels_completed,
+                1,
+                "Full reset not have happend and thuse levels_completed should be 1",
+            )
+
+            # a second level reset shouldn't reset the game either
+            comp_reset_frame = comp_env_1.step(GameAction.RESET)
+            self.assertIsNotNone(comp_reset_frame)
+            self.assertEqual(
+                comp_reset_frame.levels_completed,
+                1,
+                "Full reset not have happend and thuse levels_completed should be 1",
+            )
+
+            # a third level reset shouldn't reset the game either, this time via reset()
+            comp_reset_frame = comp_env_1.reset()
+            self.assertIsNotNone(comp_reset_frame)
+            self.assertEqual(
+                comp_reset_frame.levels_completed,
+                1,
+                "Full reset not have happend and thuse levels_completed should be 1",
+            )
+            # a fourth level reset shouldn't reset the game either, this time via reset()
+            comp_reset_frame = comp_env_1.reset()
+            self.assertIsNotNone(comp_reset_frame)
+            self.assertEqual(
+                comp_reset_frame.levels_completed,
+                1,
+                "Full reset not have happend and thuse levels_completed should be 1",
+            )            
+
+            # No full reset should happen and thus we should have 1 run
+            comp_scorecard = client_arc_comp.close_scorecard(scorecard_id=comp_card_id)
+            comp_env_score = comp_scorecard.find_environment("bt11")
+            self.assertIsNotNone(comp_env_score, "Should get a environment")
+            self.assertEqual(len(comp_env_score.runs), 1, "Should have 1 runs")
+            self.assertEqual(
+                comp_env_score.runs[0].actions,
+                8,
+                "Should have 8 actions, even the failed reset counts as an action",
+            )
+
+        finally:
+            if server_error:
+                raise server_error[0]
+
+
+if __name__ == "__main__":
+    unittest.main()

arcprize__ARC-AGI/tests/test_local_wrapper.py

@@ -0,0 +1,288 @@
+"""Tests for LocalEnvironmentWrapper using unittest."""
+
+import logging
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+_mock_dotenv = MagicMock()
+_mock_dotenv.load_dotenv = MagicMock()
+sys.modules["dotenv"] = _mock_dotenv
+
+from arcengine import GameAction, GameState  # noqa: E402
+
+from arc_agi import Arcade, OperationMode  # noqa: E402
+
+
+class TestLocalEnvironmentWrapper(unittest.TestCase):
+    """Test LocalEnvironmentWrapper functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+        # Set up logger
+        self.logger = logging.getLogger("test")
+        self.logger.setLevel(logging.INFO)
+
+        # Set environments_dir to test_environment_files
+        test_dir = Path(__file__).parent.parent / "test_environment_files"
+        self.environments_dir = str(test_dir)
+
+    def tearDown(self):
+        """Clean up after tests."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_make_bt11_without_version(self):
+        """Test making bt11 game without version (should find latest)."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="bt11", scorecard_id="test-scorecard-1")
+
+        self.assertIsNotNone(wrapper, "Wrapper should be created")
+        self.assertEqual(wrapper.environment_info.game_id, "bt11-fd9df0622a1a")
+        self.assertEqual(wrapper.scorecard_id, "test-scorecard-1")
+        self.assertIsNotNone(wrapper.environment_info.local_dir)
+
+    def test_make_bt11_with_version(self):
+        """Test making bt11 game with specific version."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(
+            game_id="bt11-fd9df0622a1a", scorecard_id="test-scorecard-2"
+        )
+
+        self.assertIsNotNone(wrapper, "Wrapper should be created")
+        self.assertEqual(wrapper.environment_info.game_id, "bt11-fd9df0622a1a")
+        self.assertEqual(wrapper.scorecard_id, "test-scorecard-2")
+        self.assertIsNotNone(wrapper.environment_info.local_dir)
+
+    def test_make_bt11_reset(self):
+        """Test that reset() works and returns FrameDataRaw."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="bt11", scorecard_id="test-reset")
+
+        self.assertIsNotNone(wrapper)
+
+        # Test reset
+        frame_data = wrapper.reset()
+        self.assertIsNotNone(frame_data, "Reset should return FrameDataRaw")
+        self.assertEqual(frame_data.game_id, "bt11-fd9df0622a1a")
+        self.assertEqual(frame_data.state, GameState.NOT_FINISHED)
+
+        # Check observation_space
+        obs = wrapper.observation_space
+        self.assertIsNotNone(obs)
+        self.assertEqual(obs.game_id, "bt11-fd9df0622a1a")
+
+    def test_make_bt11_four_action3_steps(self):
+        """Test that four ACTION3 (move left) steps get past the first level."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="bt11", scorecard_id="test-action3")
+
+        self.assertIsNotNone(wrapper)
+
+        # Reset the game
+        reset_frame = wrapper.reset()
+        self.assertIsNotNone(reset_frame)
+        self.assertEqual(reset_frame.state, GameState.NOT_FINISHED)
+        initial_level = reset_frame.levels_completed
+
+        # Perform four ACTION3 (move left) actions
+        for i in range(4):
+            frame_data = wrapper.step(GameAction.ACTION3)
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        # After 4 ACTION3 steps, should have advanced to next level
+        # Score should have increased (level completion increases score)
+        final_frame = wrapper.observation_space
+        self.assertIsNotNone(final_frame)
+        self.assertGreater(
+            final_frame.levels_completed,
+            initial_level,
+            "Score should increase after completing first level",
+        )
+        self.assertNotEqual(
+            final_frame.state,
+            GameState.GAME_OVER,
+            "Game should not be over after 4 ACTION3 steps",
+        )
+
+        # Verify we can see the action space
+        action_space = wrapper.action_space
+        self.assertGreater(len(action_space), 0, "Action space should have actions")
+        self.assertIn(GameAction.ACTION3, action_space, "ACTION3 should be available")
+
+    def test_make_bt11_that_command_at_game_over_does_not_add_to_scorecard(self):
+        """Test that four ACTION3 (move left) steps get past the first level."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        card_id = client.create_scorecard()
+
+        wrapper = client.make(game_id="bt11", scorecard_id=card_id)
+
+        self.assertIsNotNone(wrapper)
+
+        # Perform four ACTION3 (move left) actions, this gets us past the first level
+        for i in range(4):
+            frame_data = wrapper.step(GameAction.ACTION3)
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        # Perform eight ACTION4 (move right) actions to get to game over
+        for i in range(8):
+            frame_data = wrapper.step(GameAction.ACTION4)
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        self.assertEqual(frame_data.state, GameState.GAME_OVER)
+
+        # Perform one ACTION4 (move left) action to get send a game over to a bad game
+        frame_data = wrapper.step(GameAction.ACTION4)
+        self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+        self.assertEqual(len(frame_data.frame), 0)
+
+        wrapper.reset()
+
+        # Perform eight ACTION3 (move left) actions, this gets us past the second level
+        for i in range(8):
+            frame_data = wrapper.step(GameAction.ACTION3)
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        scorecard = client.get_scorecard(card_id)
+
+        # Step count for level 2 should be 17, 8 ACTION4s for Game Over, 1 RESET, 8 ACTION3s for Level 2
+        self.assertEqual(scorecard.environments[0].runs[0].level_actions[1], 17)
+
+    def test_make_invalid_game_id(self):
+        """Test that invalid game_id format returns None."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="invalid", scorecard_id="test")
+        self.assertIsNone(wrapper, "Invalid game_id should return None")
+
+    def test_make_game_not_found(self):
+        """Test that non-existent game returns None."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="xxxx", scorecard_id="test")
+        self.assertIsNone(wrapper, "Non-existent game should return None")
+
+    def test_make_with_wrong_version(self):
+        """Test that wrong version returns None."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="bt11-wrongversion", scorecard_id="test")
+        self.assertIsNone(wrapper, "Wrong version should return None")
+
+    def test_make_bt11_fd9df0622a1b_with_action6(self):
+        """Test that bt33-a7c3f9d18b4e loads and four ACTION6 (GLICK) actions with x=1, y=1 get past the first level."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        wrapper = client.make(game_id="bt33-a7c3f9d18b4e", scorecard_id="test-action6")
+
+        self.assertIsNotNone(wrapper, "Wrapper should be created")
+        self.assertEqual(wrapper.environment_info.game_id, "bt33-a7c3f9d18b4e")
+        self.assertEqual(wrapper.scorecard_id, "test-action6")
+        self.assertIsNotNone(wrapper.environment_info.local_dir)
+
+        # Reset the game
+        reset_frame = wrapper.reset()
+        self.assertIsNotNone(reset_frame)
+        self.assertEqual(reset_frame.state, GameState.NOT_FINISHED)
+        initial_level = reset_frame.levels_completed
+
+        # Perform four ACTION6 (GLICK) actions with x=1, y=1
+        for i in range(4):
+            frame_data = wrapper.step(GameAction.ACTION6, data={"x": 1, "y": 1})
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        # After 4 ACTION6 steps, should have advanced to next level
+        # Score should have increased (level completion increases score)
+        final_frame = wrapper.observation_space
+        self.assertIsNotNone(final_frame)
+        self.assertGreater(
+            final_frame.levels_completed,
+            initial_level,
+            "Score should increase after completing first level",
+        )
+        self.assertNotEqual(
+            final_frame.state,
+            GameState.GAME_OVER,
+            "Game should not be over after 4 ACTION6 steps",
+        )
+
+        # Verify we can see the action space
+        action_space = wrapper.action_space
+        self.assertGreater(len(action_space), 0, "Action space should have actions")
+        self.assertIn(GameAction.ACTION6, action_space, "ACTION6 should be available")
+
+
+if __name__ == "__main__":
+    unittest.main()

arcprize__ARC-AGI/tests/test_models.py

@@ -0,0 +1,483 @@
+"""Tests for the EnvironmentInfo model using unittest."""
+
+import json
+import unittest
+from datetime import datetime, timezone
+
+from pydantic import ValidationError
+
+from arc_agi import EnvironmentInfo
+
+
+class TestEnvironmentInfo(unittest.TestCase):
+    """Test EnvironmentInfo model."""
+
+    def test_create_from_dict(self):
+        """Test creating EnvironmentInfo from a dictionary."""
+        data = {
+            "game_id": "tg61-28585068",
+            "title": "TG61",
+            "tags": ["tag1", "tag2"],
+            "baseline_actions": [12, 17, 18, 22, 50],
+        }
+        env_info = EnvironmentInfo(**data)
+
+        self.assertEqual(env_info.game_id, "tg61-28585068")
+        self.assertEqual(env_info.title, "TG61")
+        self.assertEqual(env_info.tags, ["tag1", "tag2"])
+        self.assertEqual(env_info.baseline_actions, [12, 17, 18, 22, 50])
+        # date_downloaded should default to now
+        self.assertIsNotNone(env_info.date_downloaded)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+        # class_name should default to first 4 chars of game_id capitalized
+        self.assertEqual(env_info.class_name, "Tg61")
+
+    def test_create_from_keyword_args(self):
+        """Test creating EnvironmentInfo from keyword arguments."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1", "tag2"],
+            baseline_actions=[12, 17, 18, 22, 50],
+        )
+
+        self.assertEqual(env_info.game_id, "tg61-28585068")
+        self.assertEqual(env_info.title, "TG61")
+        self.assertEqual(env_info.tags, ["tag1", "tag2"])
+        self.assertEqual(env_info.baseline_actions, [12, 17, 18, 22, 50])
+        # date_downloaded should default to now
+        self.assertIsNotNone(env_info.date_downloaded)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+        # class_name should default to first 4 chars of game_id capitalized
+        self.assertEqual(env_info.class_name, "Tg61")
+
+    def test_serialize_to_json(self):
+        """Test serializing EnvironmentInfo to JSON string."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1", "tag2"],
+            baseline_actions=[12, 17, 18, 22, 50],
+        )
+
+        json_str = env_info.model_dump_json()
+        self.assertIsInstance(json_str, str)
+
+        # Parse JSON to verify structure
+        parsed = json.loads(json_str)
+        self.assertEqual(parsed["game_id"], "tg61-28585068")
+        self.assertEqual(parsed["title"], "TG61")
+        self.assertEqual(parsed["tags"], ["tag1", "tag2"])
+        self.assertEqual(parsed["baseline_actions"], [12, 17, 18, 22, 50])
+        # Defaults should be set
+        self.assertIsNotNone(parsed["date_downloaded"])
+        self.assertEqual(parsed["class_name"], "Tg61")
+
+    def test_deserialize_from_json_string(self):
+        """Test deserializing EnvironmentInfo from JSON string."""
+        json_str = '{"game_id": "tg61-28585068", "title": "TG61", "tags": ["tag1", "tag2"], "baseline_actions": [12, 17, 18, 22, 50]}'
+
+        env_info = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertEqual(env_info.game_id, "tg61-28585068")
+        self.assertEqual(env_info.title, "TG61")
+        self.assertEqual(env_info.tags, ["tag1", "tag2"])
+        self.assertEqual(env_info.baseline_actions, [12, 17, 18, 22, 50])
+
+    def test_deserialize_from_json_bytes(self):
+        """Test deserializing EnvironmentInfo from JSON bytes."""
+        json_bytes = b'{"game_id": "tg61-28585068", "title": "TG61", "tags": ["tag1", "tag2"], "baseline_actions": [12, 17, 18, 22, 50]}'
+
+        env_info = EnvironmentInfo.model_validate_json(json_bytes)
+
+        self.assertEqual(env_info.game_id, "tg61-28585068")
+        self.assertEqual(env_info.title, "TG61")
+        self.assertEqual(env_info.tags, ["tag1", "tag2"])
+        self.assertEqual(env_info.baseline_actions, [12, 17, 18, 22, 50])
+
+    def test_round_trip_json(self):
+        """Test round-trip serialization: object -> JSON -> object."""
+        original = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1", "tag2"],
+            baseline_actions=[12, 17, 18, 22, 50],
+        )
+
+        json_str = original.model_dump_json()
+        restored = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertEqual(original.game_id, restored.game_id)
+        self.assertEqual(original.title, restored.title)
+        self.assertEqual(original.tags, restored.tags)
+        self.assertEqual(original.baseline_actions, restored.baseline_actions)
+
+    def test_empty_tags(self):
+        """Test EnvironmentInfo with empty tags list."""
+        env_info = EnvironmentInfo(
+            game_id="test-game",
+            title="Test",
+            tags=[],
+            baseline_actions=[10, 20],
+        )
+
+        self.assertEqual(env_info.tags, [])
+
+    def test_empty_baseline_actions(self):
+        """Test EnvironmentInfo with empty baseline_actions list."""
+        env_info = EnvironmentInfo(
+            game_id="test-game",
+            title="Test",
+            tags=["tag1"],
+            baseline_actions=[],
+        )
+
+        self.assertEqual(env_info.baseline_actions, [])
+
+    def test_missing_game_id(self):
+        """Test that missing game_id raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                title="TG61",
+                tags=["tag1"],
+                baseline_actions=[12],
+            )
+
+    def test_invalid_game_id_type(self):
+        """Test that invalid game_id type raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id=12345,  # Should be string
+                title="TG61",
+                tags=["tag1"],
+                baseline_actions=[12],
+            )
+
+    def test_invalid_title_type(self):
+        """Test that invalid title type raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id="tg61-28585068",
+                title=12345,  # Should be string
+                tags=["tag1"],
+                baseline_actions=[12],
+            )
+
+    def test_invalid_tags_type(self):
+        """Test that invalid tags type raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id="tg61-28585068",
+                title="TG61",
+                tags="not-a-list",  # Should be list
+                baseline_actions=[12],
+            )
+
+    def test_invalid_baseline_actions_type(self):
+        """Test that invalid baseline_actions type raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id="tg61-28585068",
+                title="TG61",
+                tags=["tag1"],
+                baseline_actions="not-a-list",  # Should be list
+            )
+
+    def test_baseline_actions_with_numeric_strings(self):
+        """Test that baseline_actions with numeric strings are coerced to integers."""
+        # Pydantic v2 auto-coerces numeric strings to integers
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=["12", "17"],  # Will be coerced to [12, 17]
+        )
+        self.assertEqual(env_info.baseline_actions, [12, 17])
+        self.assertIsInstance(env_info.baseline_actions[0], int)
+        self.assertIsInstance(env_info.baseline_actions[1], int)
+
+    def test_baseline_actions_with_non_numeric_strings(self):
+        """Test that baseline_actions with non-numeric strings raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id="tg61-28585068",
+                title="TG61",
+                tags=["tag1"],
+                baseline_actions=["not-a-number", "also-not-a-number"],
+            )
+
+    def test_tags_with_non_strings(self):
+        """Test that tags with non-strings raises ValidationError."""
+        with self.assertRaises(ValidationError):
+            EnvironmentInfo(
+                game_id="tg61-28585068",
+                title="TG61",
+                tags=[1, 2, 3],  # Should be strings
+                baseline_actions=[12],
+            )
+
+    def test_model_dump(self):
+        """Test model_dump returns dictionary."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1", "tag2"],
+            baseline_actions=[12, 17, 18, 22, 50],
+        )
+
+        dumped = env_info.model_dump()
+        self.assertIsInstance(dumped, dict)
+        self.assertEqual(dumped["game_id"], "tg61-28585068")
+        self.assertEqual(dumped["title"], "TG61")
+        self.assertEqual(dumped["tags"], ["tag1", "tag2"])
+        self.assertEqual(dumped["baseline_actions"], [12, 17, 18, 22, 50])
+
+    def test_model_validate_from_dict(self):
+        """Test model_validate creates instance from dictionary."""
+        data = {
+            "game_id": "tg61-28585068",
+            "title": "TG61",
+            "tags": ["tag1", "tag2"],
+            "baseline_actions": [12, 17, 18, 22, 50],
+        }
+
+        env_info = EnvironmentInfo.model_validate(data)
+
+        self.assertEqual(env_info.game_id, "tg61-28585068")
+        self.assertEqual(env_info.title, "TG61")
+        self.assertEqual(env_info.tags, ["tag1", "tag2"])
+        self.assertEqual(env_info.baseline_actions, [12, 17, 18, 22, 50])
+
+    def test_date_downloaded_defaults_to_now(self):
+        """Test that date_downloaded defaults to current time if not provided."""
+        from datetime import datetime, timezone
+
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+        )
+
+        # Should be set to a datetime (approximately now)
+        self.assertIsNotNone(env_info.date_downloaded)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+        # Should be recent (within last minute)
+        now = datetime.now(timezone.utc)
+        time_diff = abs((now - env_info.date_downloaded).total_seconds())
+        self.assertLess(time_diff, 60)
+
+    def test_date_downloaded_with_datetime(self):
+        """Test that date_downloaded can be set to a datetime object."""
+        download_date = datetime.now(timezone.utc)
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            date_downloaded=download_date,
+        )
+
+        self.assertEqual(env_info.date_downloaded, download_date)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+
+    def test_date_downloaded_json_serialization(self):
+        """Test that date_downloaded is serialized to ISO format in JSON."""
+        download_date = datetime(2024, 1, 15, 10, 30, 45, tzinfo=timezone.utc)
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            date_downloaded=download_date,
+        )
+
+        json_str = env_info.model_dump_json()
+        parsed = json.loads(json_str)
+
+        self.assertIn("date_downloaded", parsed)
+        # Pydantic v2 serializes UTC as 'Z' format
+        self.assertEqual(parsed["date_downloaded"], "2024-01-15T10:30:45Z")
+
+    def test_date_downloaded_json_deserialization(self):
+        """Test that date_downloaded can be deserialized from ISO format string."""
+        json_str = '{"game_id": "tg61-28585068", "title": "TG61", "tags": ["tag1"], "baseline_actions": [12], "date_downloaded": "2024-01-15T10:30:45+00:00"}'
+
+        env_info = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertIsNotNone(env_info.date_downloaded)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+        self.assertEqual(env_info.date_downloaded.year, 2024)
+        self.assertEqual(env_info.date_downloaded.month, 1)
+        self.assertEqual(env_info.date_downloaded.day, 15)
+
+    def test_date_downloaded_round_trip(self):
+        """Test round-trip serialization with date_downloaded."""
+        download_date = datetime.now(timezone.utc)
+        original = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            date_downloaded=download_date,
+        )
+
+        json_str = original.model_dump_json()
+        restored = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertEqual(original.date_downloaded, restored.date_downloaded)
+        self.assertIsInstance(restored.date_downloaded, datetime)
+
+    def test_date_downloaded_from_dict(self):
+        """Test creating EnvironmentInfo with date_downloaded from dictionary."""
+        download_date = datetime.now(timezone.utc)
+        data = {
+            "game_id": "tg61-28585068",
+            "title": "TG61",
+            "tags": ["tag1"],
+            "baseline_actions": [12],
+            "date_downloaded": download_date,
+        }
+
+        env_info = EnvironmentInfo(**data)
+
+        self.assertEqual(env_info.date_downloaded, download_date)
+
+    def test_class_name_defaults_from_game_id(self):
+        """Test that class_name defaults to first 4 characters of game_id capitalized."""
+        # Test with game_id that has 4+ characters
+        env_info = EnvironmentInfo(
+            game_id="ls20-ajk315135",
+            title="Test",
+            tags=["tag1"],
+            baseline_actions=[12],
+        )
+
+        self.assertEqual(env_info.class_name, "Ls20")
+
+        # Test with shorter game_id
+        env_info2 = EnvironmentInfo(
+            game_id="ab1",
+            title="Test",
+            tags=["tag1"],
+            baseline_actions=[12],
+        )
+
+        self.assertEqual(env_info2.class_name, "Ab1")
+
+    def test_class_name_with_value(self):
+        """Test that class_name can be set to a string."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            class_name="MyGameClass",
+        )
+
+        self.assertEqual(env_info.class_name, "MyGameClass")
+        self.assertIsInstance(env_info.class_name, str)
+
+    def test_class_name_json_serialization(self):
+        """Test that class_name is serialized correctly in JSON."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            class_name="MyGameClass",
+        )
+
+        json_str = env_info.model_dump_json()
+        parsed = json.loads(json_str)
+
+        self.assertIn("class_name", parsed)
+        self.assertEqual(parsed["class_name"], "MyGameClass")
+
+    def test_class_name_json_deserialization(self):
+        """Test that class_name can be deserialized from JSON string."""
+        json_str = '{"game_id": "tg61-28585068", "title": "TG61", "tags": ["tag1"], "baseline_actions": [12], "class_name": "MyGameClass"}'
+
+        env_info = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertEqual(env_info.class_name, "MyGameClass")
+        self.assertIsInstance(env_info.class_name, str)
+
+    def test_class_name_round_trip(self):
+        """Test round-trip serialization with class_name."""
+        original = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            class_name="MyGameClass",
+        )
+
+        json_str = original.model_dump_json()
+        restored = EnvironmentInfo.model_validate_json(json_str)
+
+        self.assertEqual(original.class_name, restored.class_name)
+
+    def test_class_name_from_dict(self):
+        """Test creating EnvironmentInfo with class_name from dictionary."""
+        data = {
+            "game_id": "tg61-28585068",
+            "title": "TG61",
+            "tags": ["tag1"],
+            "baseline_actions": [12],
+            "class_name": "MyGameClass",
+        }
+
+        env_info = EnvironmentInfo(**data)
+
+        self.assertEqual(env_info.class_name, "MyGameClass")
+
+    def test_class_name_empty_string(self):
+        """Test that class_name can be an empty string (explicit override)."""
+        env_info = EnvironmentInfo(
+            game_id="tg61-28585068",
+            title="TG61",
+            tags=["tag1"],
+            baseline_actions=[12],
+            class_name="",
+        )
+
+        self.assertEqual(env_info.class_name, "")
+
+    def test_class_name_various_game_ids(self):
+        """Test class_name generation from various game_id formats."""
+        test_cases = [
+            ("ls20-ajk315135", "Ls20"),
+            ("tg61-28585068", "Tg61"),
+            ("dr44", "Dr44"),
+            ("ab1", "Ab1"),
+            ("a", "A"),
+            ("ABCD-123", "ABCD"),  # Capitalize first letter only, keep rest as-is
+        ]
+
+        for game_id, expected_class_name in test_cases:
+            with self.subTest(game_id=game_id):
+                env_info = EnvironmentInfo(
+                    game_id=game_id,
+                    title="Test",
+                    tags=["tag1"],
+                    baseline_actions=[12],
+                )
+                self.assertEqual(env_info.class_name, expected_class_name)
+
+    def test_date_downloaded_and_class_name_both_default(self):
+        """Test that both defaults work together."""
+        env_info = EnvironmentInfo(
+            game_id="ls20-test",
+            title="Test",
+            tags=["tag1"],
+            baseline_actions=[12],
+        )
+
+        self.assertIsNotNone(env_info.date_downloaded)
+        self.assertIsInstance(env_info.date_downloaded, datetime)
+        self.assertEqual(env_info.class_name, "Ls20")
+
+
+if __name__ == "__main__":
+    unittest.main()

arcprize__ARC-AGI/tests/test_scorecard.py

@@ -0,0 +1,1058 @@
+"""Tests for scorecard functionality using unittest."""
+
+import logging
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+# Create a mock dotenv module before any imports
+_mock_dotenv = MagicMock()
+_mock_dotenv.load_dotenv = MagicMock()
+sys.modules["dotenv"] = _mock_dotenv
+
+# Now import arcagi3 - the mock will be used instead of real dotenv
+from arcengine import GameAction, GameState  # noqa: E402
+
+from arc_agi import (  # noqa: E402
+    Arcade,
+    EnvironmentInfo,
+    EnvironmentScore,
+    EnvironmentScoreCalculator,
+    EnvironmentScorecard,
+    OperationMode,  # noqa: E402
+)
+
+
+class TestScorecard(unittest.TestCase):
+    """Test scorecard functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+        # Set up logger
+        self.logger = logging.getLogger("test")
+        self.logger.setLevel(logging.INFO)
+
+        # Set environments_dir to test_environment_files
+        test_dir = Path(__file__).parent.parent / "test_environment_files"
+        self.environments_dir = str(test_dir)
+
+    def tearDown(self):
+        """Clean up after tests."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_scorecard_bt11_four_action3(self):
+        """Test that playing bt11 with 4 Action3 actions results in levels_completed = 1."""
+        client = Arcade(
+            operation_mode=OperationMode.OFFLINE,
+            environments_dir=self.environments_dir,
+            logger=self.logger,
+        )
+
+        # Create a scorecard
+        scorecard_id = client.create_scorecard()
+        self.assertIsNotNone(scorecard_id)
+        self.logger.info(f"Created scorecard: {scorecard_id}")
+
+        # Make the environment
+        wrapper = client.make(game_id="bt11", scorecard_id=scorecard_id)
+        self.assertIsNotNone(wrapper)
+
+        # Reset the game
+        self.assertIsNotNone(wrapper.observation_space)
+        self.assertEqual(wrapper.observation_space.state, GameState.NOT_FINISHED)
+
+        # Perform four ACTION3 (move left) actions
+        for i in range(4):
+            frame_data = wrapper.step(GameAction.ACTION3)
+            self.assertIsNotNone(frame_data, f"Step {i + 1} should return FrameDataRaw")
+            self.logger.info(
+                f"Step {i + 1}: state={frame_data.state}, level={frame_data.levels_completed}"
+            )
+
+        # Get the scorecard and verify levels_completed
+        scorecard = client.get_scorecard(scorecard_id)
+        self.assertIsNotNone(scorecard)
+
+        # Get the card for bt11
+        bt11_card = scorecard.environments[0]
+        self.assertEqual(bt11_card.id, "bt11-fd9df0622a1a")
+
+        # Verify levels_completed is 1
+        # The card should have one guid (one play)
+        self.assertEqual(4, bt11_card.actions)
+
+        # Check levels_completed for this guid
+        self.assertEqual(
+            bt11_card.levels_completed,
+            1,
+            "levels_completed should be 1 after completing first level",
+        )
+
+        # Verify the final frame also shows level 1
+        final_frame = wrapper.observation_space
+        self.assertIsNotNone(final_frame)
+        self.assertEqual(
+            final_frame.levels_completed,
+            1,
+            "Final frame should show levels_completed = 1",
+        )
+
+
+class TestEnvironmentScore(unittest.TestCase):
+    """Test EnvironmentScore and EnvironmentScoreCalculator."""
+
+    def test_environment_score_creation(self):
+        """Test that EnvironmentScore can be created with all fields."""
+        score = EnvironmentScore(
+            id="test-id",
+            score=85.5,
+            levels_completed=3,
+            actions=42,
+            resets=2,
+            completed=True,
+            message="Test message",
+        )
+        self.assertEqual(score.id, "test-id")
+        self.assertEqual(score.score, 85.5)
+        self.assertEqual(score.levels_completed, 3)
+        self.assertEqual(score.actions, 42)
+        self.assertEqual(score.resets, 2)
+        self.assertEqual(score.completed, True)
+        self.assertEqual(score.message, "Test message")
+
+    def test_environment_score_optional_fields(self):
+        """Test that EnvironmentScore optional fields work correctly."""
+        # Test with all optional fields None
+        score = EnvironmentScore(
+            id="test-id",
+            score=50.0,
+            levels_completed=1,
+            actions=10,
+        )
+        self.assertIsNone(score.resets)
+        self.assertIsNone(score.completed)
+        self.assertIsNone(score.message)
+
+        # Test with resets but no completed
+        score2 = EnvironmentScore(
+            id="test-id-2",
+            score=75.0,
+            levels_completed=2,
+            actions=20,
+            resets=1,
+        )
+        self.assertEqual(score2.resets, 1)
+        self.assertIsNone(score2.completed)
+
+        # Test with completed but no resets
+        score3 = EnvironmentScore(
+            id="test-id-3",
+            score=90.0,
+            levels_completed=3,
+            actions=30,
+            completed=False,
+        )
+        self.assertIsNone(score3.resets)
+        self.assertEqual(score3.completed, False)
+
+    def test_environment_score_calculator_initialization(self):
+        """Test that EnvironmentScoreCalculator initializes correctly."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=2)
+        self.assertEqual(calculator.id, "test-id")
+        self.assertEqual(calculator.resets, 2)
+        self.assertEqual(calculator.level_scores, [])
+        self.assertEqual(calculator.levels_completed, 0)
+        self.assertEqual(calculator.actions, 0)
+        self.assertIsNone(calculator.completed)
+
+    def test_environment_score_calculator_optional_resets(self):
+        """Test that EnvironmentScoreCalculator can be initialized without resets."""
+        calculator = EnvironmentScoreCalculator(id="test-id")
+        self.assertEqual(calculator.id, "test-id")
+        self.assertIsNone(calculator.resets)
+
+    def test_add_level_completed(self):
+        """Test add_level with completed=True calculates score correctly."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        # Baseline: 10 actions, taken: 5 actions -> score = (10/5) * 100 = 200, capped at 115
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=5, baseline_actions=10
+        )
+        self.assertEqual(calculator.levels_completed, 1)
+        self.assertEqual(calculator.actions, 5)
+        self.assertEqual(len(calculator.level_scores), 1)
+        self.assertEqual(calculator.level_scores[0], 115.0)  # Capped at 100
+
+    def test_add_level_completed_exact_baseline(self):
+        """Test add_level with actions_taken equal to baseline."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        # Baseline: 10 actions, taken: 10 actions -> score = (10/10) * 100 = 100
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=10, baseline_actions=10
+        )
+        self.assertEqual(calculator.levels_completed, 1)
+        self.assertEqual(calculator.actions, 10)
+        self.assertEqual(calculator.level_scores[0], 100.0)
+
+    def test_add_level_completed_below_baseline(self):
+        """Test add_level with actions_taken below baseline."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        # Baseline: 10 actions, taken: 8 actions -> score = (10/8) * 100 = 125, capped at 115
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=8, baseline_actions=10
+        )
+        self.assertEqual(calculator.level_scores[0], 115.0)  # Capped at 115
+
+    def test_add_level_completed_above_baseline(self):
+        """Test add_level with actions_taken above baseline."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        # Baseline: 10 actions, taken: 20 actions -> score = (10/20) * 100 = 50
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=20, baseline_actions=10
+        )
+        self.assertEqual(calculator.level_scores[0], 25.0)
+
+    def test_add_level_not_completed(self):
+        """Test add_level with completed=False appends 0."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        calculator.add_level(
+            level_index=1, completed=False, actions_taken=15, baseline_actions=10
+        )
+        self.assertEqual(calculator.levels_completed, 0)  # Not incremented
+        self.assertEqual(calculator.actions, 15)  # Still added to total
+        self.assertEqual(len(calculator.level_scores), 1)
+        self.assertEqual(calculator.level_scores[0], 0.0)
+
+    def test_add_level_zero_actions(self):
+        """Test add_level with zero actions_taken."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=0, baseline_actions=10
+        )
+        self.assertEqual(calculator.levels_completed, 1)
+        self.assertEqual(calculator.actions, 0)
+        self.assertEqual(
+            calculator.level_scores[0], 0.0
+        )  # Should be 0 if actions_taken is 0
+
+    def test_add_level_multiple_levels(self):
+        """Test adding multiple levels."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=0)
+
+        # Level 1: completed with 8 actions (baseline 10) -> score = 125, capped at 115
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=8, baseline_actions=10
+        )
+
+        # Level 2: completed with 12 actions (baseline 10) -> score = (10/12) * 100 = 83.33 ^ 2 = 69.44444444444444
+        calculator.add_level(
+            level_index=2, completed=True, actions_taken=12, baseline_actions=10
+        )
+
+        # Level 3: not completed
+        calculator.add_level(
+            level_index=3, completed=False, actions_taken=5, baseline_actions=10
+        )
+
+        self.assertEqual(calculator.levels_completed, 2)
+        self.assertEqual(calculator.actions, 25)  # 8 + 12 + 5
+        self.assertEqual(len(calculator.level_scores), 3)
+        self.assertEqual(calculator.level_scores[0], 115.0)
+        self.assertAlmostEqual(calculator.level_scores[1], 69.44444444444444, places=5)
+        self.assertEqual(calculator.level_scores[2], 0.0)
+
+    def test_to_score_average(self):
+        """Test that to_score calculates average of level_scores."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=2)
+
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=10, baseline_actions=10
+        )  # score = 100
+        calculator.add_level(
+            level_index=2, completed=True, actions_taken=20, baseline_actions=10
+        )  # score = 50
+        calculator.add_level(
+            level_index=3, completed=False, actions_taken=5, baseline_actions=10
+        )  # score = 0
+        calculator.completed = True  # Set completed flag
+
+        score = calculator.to_score()
+        self.assertIsInstance(score, EnvironmentScore)
+        self.assertEqual(score.id, "test-id")
+        self.assertEqual(score.resets, 2)
+        self.assertEqual(score.completed, True)
+        self.assertEqual(score.levels_completed, 2)
+        self.assertEqual(score.actions, 35)  # 10 + 20 + 5
+        # Average: (100 + 25*2 + 0*3) / (1+2+3) = 50.0
+        self.assertAlmostEqual(score.score, 25.0, places=5)
+
+    def test_to_score_empty_levels(self):
+        """Test to_score with no levels added."""
+        calculator = EnvironmentScoreCalculator(id="test-id")
+
+        score = calculator.to_score()
+        self.assertEqual(score.id, "test-id")
+        self.assertEqual(score.score, 0.0)
+        self.assertEqual(score.levels_completed, 0)
+        self.assertEqual(score.actions, 0)
+        self.assertIsNone(score.resets)
+        self.assertIsNone(score.completed)
+
+    def test_to_score_single_level(self):
+        """Test to_score with single level."""
+        calculator = EnvironmentScoreCalculator(id="test-id", resets=1)
+
+        calculator.add_level(
+            level_index=1, completed=True, actions_taken=15, baseline_actions=10
+        )
+        calculator.completed = False  # Set completed flag
+
+        score = calculator.to_score()
+        self.assertEqual(
+            score.score, ((10 / 15) ** 2) * 100
+        )  # Should be exact value, not average of one
+        self.assertEqual(score.levels_completed, 1)
+        self.assertEqual(score.actions, 15)
+        self.assertEqual(score.resets, 1)
+        self.assertEqual(score.completed, False)
+
+
+class TestEnvironmentScorecard(unittest.TestCase):
+    """Test EnvironmentScorecard functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.env_vars_to_clear = [
+            "ARC_API_KEY",
+            "ARC_BASE_URL",
+            "OFFLINE_ONLY",
+            "ONLINE_ONLY",
+            "COMPETITION_MODE",
+            "LISTEN_BINDINGS",
+            "ENVIRONMENTS_DIR",
+        ]
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def tearDown(self):
+        """Clean up after tests."""
+        for var in self.env_vars_to_clear:
+            os.environ.pop(var, None)
+        os.environ["ARC_API_KEY"] = "test-key-123"
+
+    def test_from_scorecard_basic(self):
+        """Test basic EnvironmentScorecard creation."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create a simple scorecard with one game
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[10],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10],
+            tags=["test"],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+
+        self.assertEqual(scorecard_result.card_id, "test-card")
+        self.assertEqual(scorecard_result.api_key, "test-key")
+        self.assertEqual(len(scorecard_result.environments), 1)
+        self.assertEqual(scorecard_result.environments[0].id, "bt11")
+        self.assertEqual(scorecard_result.environments[0].levels_completed, 1)
+        # Score should be (10/10) * 100 = 100
+        self.assertAlmostEqual(scorecard_result.environments[0].score, 100.0, places=5)
+        self.assertEqual(scorecard_result.score, 100.0)  # Average of one score
+
+    def test_max_score_is_last_level_beaten(self):
+        """Test basic EnvironmentScorecard creation."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create a simple scorecard with one game
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[28],
+            resets=[0],
+            states=[GameState.NOT_FINISHED],
+            actions_by_level=[[(1, 8)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 10, 10, 10, 10, 10],
+            tags=["test"],
+        )
+
+        for i in range(1, 7):
+            card.levels_completed[0] = i
+            card.actions[0] = i * 8 + 10
+            card.actions_by_level[0] = []
+            for j in range(1, i + 1):
+                card.actions_by_level[0].append((j, j * 8))
+
+            expected_score = 0
+            match i:
+                case 1:
+                    expected_score = 4.76190  # 1/21
+                case 2:
+                    expected_score = 14.28571  # 3/21
+                case 3:
+                    expected_score = 28.57143  # 6/21
+                case 4:
+                    expected_score = 47.61905  # 10/21
+                case 5:
+                    expected_score = 71.42857  # 15/21
+                case 6:
+                    expected_score = 100.0  # 21/21
+
+            print(f"card {i}: {card}")
+
+            scorecard_result = EnvironmentScorecard.from_scorecard(
+                scorecard, [env_info]
+            )
+
+            print(f"scorecard_result {i}: {scorecard_result}")
+            self.assertEqual(scorecard_result.environments[0].id, "bt11")
+            self.assertEqual(scorecard_result.environments[0].levels_completed, i)
+            self.assertAlmostEqual(
+                scorecard_result.environments[0].score, expected_score, places=3
+            )
+            self.assertAlmostEqual(scorecard_result.score, expected_score, places=3)
+
+    def test_from_scorecard_with_level_tags(self):
+        """Test basic EnvironmentScorecard creation."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create a simple scorecard with one game
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[5],
+            actions=[50],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10), (2, 20), (3, 30), (4, 40), (5, 45)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 5, 5, 5, 5],
+            tags=["test"],
+            level_tags=[[], ["new_mechanic"], [], ["new_mechanic"], ["new_mechanic"]],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(
+            scorecard, [env_info], do_private_tags=True
+        )
+
+        # Score should be (10/10) * 100 = 100
+        self.assertAlmostEqual(scorecard_result.environments[0].score, 55.0, places=5)
+        self.assertAlmostEqual(scorecard_result.score, 55.0)  # Average of one score
+
+        tags_by_id = {s.id: s for s in scorecard_result.tags_scores}
+
+        # Check that shared tag has aggregated scores from both games
+        if "private_new_mechanic" in tags_by_id:
+            tag_score = tags_by_id["private_new_mechanic"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(tag_score.levels_completed, 3)
+            # new_mechanic score should be (25*2 + 25*4 + 100*5) / 11
+            self.assertAlmostEqual(tag_score.score, 59.09090909, places=5)
+        else:
+            self.fail("private_new_mechanic tag not found")
+
+    def test_from_scorecard_highest_levels_completed(self):
+        """Test that only the play with highest levels_completed is used."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create a card with multiple plays, where second has higher levels_completed
+        card = Card(
+            game_id="bt11",
+            total_plays=2,
+            guids=["guid1", "guid2"],
+            levels_completed=[1, 2],  # guid2 has higher levels_completed
+            actions=[10, 20],
+            resets=[0, 0],
+            states=[GameState.WIN, GameState.WIN],
+            actions_by_level=[[(1, 10)], [(1, 10), (2, 20)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 15],
+            tags=["test"],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+        # Should only have one environment score (for guid2)
+        self.assertEqual(len(scorecard_result.environments), 1)
+        self.assertEqual(scorecard_result.environments[0].id, "bt11")
+        self.assertEqual(scorecard_result.environments[0].levels_completed, 2)
+        self.assertEqual(scorecard_result.environments[0].runs[1].guid, "guid2")
+
+    def test_from_scorecard_multiple_games(self):
+        """Test EnvironmentScorecard with multiple games."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card1 = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[10],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10)]],
+        )
+
+        card2 = Card(
+            game_id="am92",
+            total_plays=1,
+            guids=["guid2"],
+            levels_completed=[2],
+            actions=[30],
+            resets=[1],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 15), (2, 30)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card1, "am92": card2},
+        )
+
+        env_info1 = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10],
+            tags=["tag1"],
+        )
+
+        env_info2 = EnvironmentInfo(
+            game_id="am92",
+            title="AM92",
+            baseline_actions=[15, 20],
+            tags=["tag2"],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(
+            scorecard, [env_info1, env_info2]
+        )
+
+        self.assertEqual(len(scorecard_result.environments), 2)
+        # Find scores by id
+        scores_by_id = {s.id: s for s in scorecard_result.environments}
+        self.assertIn("bt11", scores_by_id)
+        self.assertIn("am92", scores_by_id)
+
+        # bt11 score: (10/10) * 100 = 100
+        self.assertAlmostEqual(scores_by_id["bt11"].score, 100.0, places=5)
+        # am92 score: average of level 1 ((15/15)*100=100) and level 2 ((20/15)*100=133.33, capped at 100)
+        # Actually wait, let me recalculate: level 1 took 15 actions (baseline 15) = 100, level 2 took 15 actions (baseline 20) = (20/15)*100 = 133.33 capped at 100
+        # So average = (100 + 100) / 2 = 100
+        self.assertAlmostEqual(scores_by_id["am92"].score, 100.0, places=5)
+
+        # Average score should be (100 + 100) / 2 = 100
+        self.assertAlmostEqual(scorecard_result.score, 100.0, places=5)
+
+    def test_from_scorecard_missing_baseline_actions(self):
+        """Test handling of missing baseline_actions."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[10],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        # EnvironmentInfo without baseline_actions
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=None,
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+
+        self.assertEqual(len(scorecard_result.environments), 1)
+        score = scorecard_result.environments[0]
+        self.assertEqual(score.score, 0.0)
+        self.assertEqual(
+            score.runs[0].message,
+            "Human baseline actions are not available for this environment",
+        )
+        self.assertEqual(score.levels_completed, 1)
+
+    def test_from_scorecard_baseline_size_mismatch(self):
+        """Test handling of baseline_actions size mismatch."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[3],  # Completed 3 levels
+            actions=[30],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10), (2, 20), (3, 30)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        # EnvironmentInfo with fewer baseline_actions than levels_completed
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 15],  # Only 2 baselines, but 3 levels completed
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+
+        self.assertEqual(len(scorecard_result.environments), 1)
+        score = scorecard_result.environments[0]
+        self.assertEqual(score.score, 0.0)
+        self.assertEqual(score.runs[0].message, "Human baseline actions size mismatch")
+        self.assertEqual(score.levels_completed, 3)
+
+    def test_from_scorecard_tags_scores(self):
+        """Test that tags_scores are computed correctly."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card1 = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[10],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 20)]],
+        )
+
+        card2 = Card(
+            game_id="am92",
+            total_plays=1,
+            guids=["guid2"],
+            levels_completed=[1],
+            actions=[15],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 25)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card1, "am92": card2},
+        )
+
+        env_info1 = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10],
+            tags=["tag1", "shared"],  # Has shared tag
+            private_tags=["secret"],
+            level_tags=[["new_mechanic"]],
+        )
+
+        env_info2 = EnvironmentInfo(
+            game_id="am92",
+            title="AM92",
+            baseline_actions=[15],
+            tags=["tag2", "shared"],  # Also has shared tag
+            private_tags=["secret"],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(
+            scorecard, [env_info1, env_info2], do_private_tags=True
+        )
+
+        # Should have tag scores for tag1, tag2, and shared
+        self.assertGreater(len(scorecard_result.tags_scores), 0)
+        tags_by_id = {s.id: s for s in scorecard_result.tags_scores}
+
+        # Check that shared tag has aggregated scores from both games
+        if "shared" in tags_by_id:
+            shared_score = tags_by_id["shared"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 2)
+            # Score should be average of both: bt11 (10/10)*100=100, am92 (15/15)*100=100, avg=100
+            self.assertAlmostEqual(shared_score.score, 30.5, places=5)
+        else:
+            self.fail("shared tag not found")
+        if "tag1" in tags_by_id:
+            shared_score = tags_by_id["tag1"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 1)
+            # Score should be average of both: bt11 (10/10)*100=100, am92 (15/15)*100=100, avg=100
+            self.assertAlmostEqual(shared_score.score, 25.0, places=5)
+        else:
+            self.fail("tag1 tag not found")
+        if "tag2" in tags_by_id:
+            shared_score = tags_by_id["tag2"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 1)
+            # Score should be average of both: bt11 (10/10)*100=100, am92 (15/15)*100=100, avg=100
+            self.assertAlmostEqual(shared_score.score, 36.0, places=5)
+        else:
+            self.fail("tag2 tag not found")
+        if "private_secret" in tags_by_id:
+            shared_score = tags_by_id["private_secret"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 2)
+            # Score should be average of both: bt11 (10/10)*100=100, am92 (15/15)*100=100, avg=100
+            self.assertAlmostEqual(shared_score.score, 30.5, places=5)
+        else:
+            self.fail("private_secret tag not found")
+
+    def test_not_completed_games(self):
+        """Test that tags_scores are computed correctly."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card1 = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[1000],
+            resets=[0],
+            states=[GameState.GAME_OVER],
+            actions_by_level=[[(1, 20)]],
+        )
+
+        card2 = Card(
+            game_id="am92",
+            total_plays=1,
+            guids=["guid2"],
+            levels_completed=[1],
+            actions=[1000],
+            resets=[0],
+            states=[GameState.GAME_OVER],
+            actions_by_level=[[(1, 25)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card1, "am92": card2},
+        )
+
+        env_info1 = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 20],
+            tags=["tag1", "shared"],  # Has shared tag
+        )
+
+        env_info2 = EnvironmentInfo(
+            game_id="am92",
+            title="AM92",
+            baseline_actions=[15, 30, 45],
+            tags=["tag2", "shared"],  # Also has shared tag
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(
+            scorecard, [env_info1, env_info2]
+        )
+
+        # Should have tag scores for tag1, tag2, and shared
+        self.assertGreater(len(scorecard_result.tags_scores), 0)
+        tags_by_id = {s.id: s for s in scorecard_result.tags_scores}
+
+        # Check that shared tag has aggregated scores from both games
+        if "shared" in tags_by_id:
+            shared_score = tags_by_id["shared"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 2)
+            self.assertAlmostEqual(shared_score.score, 6.7777777, places=5)
+            self.assertEqual(shared_score.number_of_levels, 5)
+            self.assertEqual(shared_score.number_of_environments, 2)
+        if "tag1" in tags_by_id:
+            shared_score = tags_by_id["tag1"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 1)
+            self.assertAlmostEqual(shared_score.score, 8.33333333334, places=5)
+            self.assertEqual(shared_score.number_of_levels, 2)
+            self.assertEqual(shared_score.number_of_environments, 1)
+        if "tag2" in tags_by_id:
+            shared_score = tags_by_id["tag2"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(shared_score.levels_completed, 1)
+            self.assertAlmostEqual(shared_score.score, 6.0, places=5)
+            self.assertEqual(shared_score.number_of_levels, 3)
+            self.assertEqual(shared_score.number_of_environments, 1)
+
+    def test_completed_games_average_score_calculation(self):
+        """Test that top-level score is correctly calculated as average."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card1 = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[20],  # 20 actions for baseline of 10 = 50% score
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 20)]],
+        )
+
+        card2 = Card(
+            game_id="am92",
+            total_plays=1,
+            guids=["guid2"],
+            levels_completed=[1],
+            actions=[10],  # 10 actions for baseline of 10 = 100% score
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card1, "am92": card2},
+        )
+
+        env_info1 = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10],
+        )
+
+        env_info2 = EnvironmentInfo(
+            game_id="am92",
+            title="AM92",
+            baseline_actions=[10],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(
+            scorecard, [env_info1, env_info2]
+        )
+
+        # bt11: (10/20)**2 * 100 = 20
+        # am92: (10/10) * 100 = 100
+        # Average: (25 + 100) / 2 = 75
+        self.assertAlmostEqual(scorecard_result.score, 62.5, places=5)
+
+    def test_from_scorecard_empty_scorecard(self):
+        """Test EnvironmentScorecard with empty scorecard."""
+        from arc_agi.scorecard import Scorecard
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={},
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [])
+
+        self.assertEqual(len(scorecard_result.environments), 0)
+        self.assertEqual(len(scorecard_result.tags_scores), 0)
+        self.assertEqual(scorecard_result.score, 0.0)
+
+    def test_from_scorecard_no_matching_env_info(self):
+        """Test EnvironmentScorecard when no matching EnvironmentInfo exists."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        card = Card(
+            game_id="bt11",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[1],
+            actions=[10],
+            resets=[0],
+            states=[GameState.WIN],
+            actions_by_level=[[(1, 10)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        # No matching EnvironmentInfo
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [])
+
+        self.assertEqual(len(scorecard_result.environments), 1)
+        score = scorecard_result.environments[0]
+        self.assertEqual(score.score, 0.0)
+        self.assertEqual(
+            score.runs[0].message,
+            "No Matching EnvironmentInfo found for bt11",
+        )
+
+    def test_from_scorecard_multiple_plays_same_game(self):
+        """Test that only best play is selected when multiple plays exist."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create card with 3 plays, middle one has highest levels_completed
+        card = Card(
+            game_id="bt11",
+            total_plays=3,
+            guids=["guid1", "guid2", "guid3"],
+            levels_completed=[1, 3, 2],  # guid2 has highest (3)
+            actions=[10, 30, 20],
+            resets=[0, 0, 0],
+            states=[GameState.WIN, GameState.WIN, GameState.WIN],
+            actions_by_level=[
+                [(1, 10)],
+                [(1, 10), (2, 20), (3, 30)],
+                [(1, 10), (2, 20)],
+            ],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11",
+            title="BT11",
+            baseline_actions=[10, 15, 20],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+        # Should only have one environment score (for guid2)
+        self.assertEqual(len(scorecard_result.environments), 1)
+        self.assertEqual(scorecard_result.environments[0].id, "bt11")
+        self.assertEqual(scorecard_result.environments[0].levels_completed, 3)
+
+    def test_realistic_scorecard_for_bt11(self):
+        """Test that only best play is selected when multiple plays exist."""
+        from arc_agi.scorecard import Card, Scorecard
+
+        # Create card with 3 plays, middle one has highest levels_completed
+        card = Card(
+            game_id="bt11-fd9df0622a1a",
+            total_plays=1,
+            guids=["guid1"],
+            levels_completed=[2],  # guid2 has highest (3)
+            actions=[118],
+            resets=[6],
+            states=[GameState.NOT_FINISHED],
+            actions_by_level=[[(1, 4), (2, 12)]],
+        )
+
+        scorecard = Scorecard(
+            card_id="test-card",
+            api_key="test-key",
+            cards={"bt11-fd9df0622a1a": card},
+        )
+
+        env_info = EnvironmentInfo(
+            game_id="bt11-fd9df0622a1a",
+            title="BT11",
+            tags=["tag1", "shared"],
+            baseline_actions=[4, 8, 16, 20, 24],
+        )
+
+        scorecard_result = EnvironmentScorecard.from_scorecard(scorecard, [env_info])
+
+        # Should only have one environment score (for guid2)
+        self.assertEqual(len(scorecard_result.environments), 1)
+        self.assertEqual(scorecard_result.environments[0].id, "bt11-fd9df0622a1a")
+        self.assertEqual(scorecard_result.environments[0].levels_completed, 2)
+
+        envs_by_id = {s.id: s for s in scorecard_result.environments}
+
+        # Check that shared tag has aggregated scores from both games
+        if "bt11-fd9df0622a1a" in envs_by_id:
+            game_score = envs_by_id["bt11-fd9df0622a1a"]
+            # Should have 2 levels completed (one from each game)
+            self.assertEqual(game_score.levels_completed, 2)
+            self.assertAlmostEqual(game_score.score, 20.0, places=5)
+            self.assertEqual(game_score.actions, 118)
+            self.assertEqual(game_score.resets, 6)
+            self.assertEqual(game_score.completed, False)
+        else:
+            self.fail("bt11 environment not found")
+
+
+if __name__ == "__main__":
+    unittest.main()