kaggle-environments 1.17.6__tar.gz → 1.17.8__tar.gz

{kaggle_environments-1.17.6/kaggle_environments.egg-info → kaggle_environments-1.17.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.17.6
+Version: 1.17.8
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle

{kaggle_environments-1.17.6 → kaggle_environments-1.17.8}/kaggle_environments/__init__.py

@@ -20,7 +20,7 @@ from .core import *
 from .main import http_request
 from . import errors
 
-__version__ = "1.17.6"
+__version__ = "1.17.8"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",

{kaggle_environments-1.17.6 → kaggle_environments-1.17.8}/kaggle_environments/envs/chess/chess.js

@@ -4045,14 +4045,14 @@ async function renderer(context) {
 
   // Create the Download PGN button
   let downloadButton = parent.querySelector("#copy-pgn");
-  if (!downloadButton) {
+  if (!downloadButton && environment.steps.length) {
     try {
       const board = environment.steps[0][0].observation.board;
       const info = environment.info;
       const agent1 = info?.TeamNames?.[0] || "Agent 1";
       const agent2 = info?.TeamNames?.[1] || "Agent 2";
       const game = new Chess();
-      let result = environment.rewards;
+      let result = environment.rewards ?? [];
       if (result.some((r) => r === undefined || r === null)) {
         result = result.map((r) => (r === undefined || r === null ? 0 : 1));
       }
@@ -4103,7 +4103,9 @@ async function renderer(context) {
       downloadButton.style.top = "10px";
       downloadButton.style.left = "10px";
       downloadButton.style.zIndex = 1;
-      parent.appendChild(downloadButton);
+      if(!environment.viewer) {
+        parent.appendChild(downloadButton);
+      }
 
       downloadButton.addEventListener("click", async () => {
         try {
@@ -4179,26 +4181,28 @@ async function renderer(context) {
     }
   }
   // Draw the team names and game status
-  const info = environment.info;
-  const agent1 = info?.TeamNames?.[0] || "Agent 1";
-  const agent2 = info?.TeamNames?.[1] || "Agent 2";
-  const firstGame = environment.steps[step][0].observation.mark == "white";
-  const fontSize = Math.round(0.33 * offset);
-  c.font = `${fontSize}px sans-serif`;
-  c.fillStyle = "#FFFFFF";
-  const agent1Reward = environment.steps[step][0].reward;
-  const agent2Reward = environment.steps[step][1].reward;
-  const charCount = agent1.length + agent2.length + 12;
-  const title = `${
-    firstGame ? "\u25A0" : "\u25A1"
-  }${agent1} (${agent1Reward}) vs ${
-    firstGame ? "\u25A1" : "\u25A0"
-  }${agent2} (${agent2Reward})`;
-  c.fillText(
-    title,
-    offset + 4 * squareSize - Math.floor((charCount * fontSize) / 4),
-    40
-  );
+  if (!environment.viewer) {
+    const info = environment.info;
+    const agent1 = info?.TeamNames?.[0] || "Agent 1";
+    const agent2 = info?.TeamNames?.[1] || "Agent 2";
+    const firstGame = environment.steps[step][0].observation.mark == "white";
+    const fontSize = Math.round(0.33 * offset);
+    c.font = `${fontSize}px sans-serif`;
+    c.fillStyle = "#FFFFFF";
+    const agent1Reward = environment.steps[step][0].reward;
+    const agent2Reward = environment.steps[step][1].reward;
+    const charCount = agent1.length + agent2.length + 12;
+    const title = `${
+      firstGame ? "\u25A0" : "\u25A1"
+    }${agent1} (${agent1Reward}) vs ${
+      firstGame ? "\u25A1" : "\u25A0"
+    }${agent2} (${agent2Reward})`;
+    c.fillText(
+      title,
+      offset + 4 * squareSize - Math.floor((charCount * fontSize) / 4),
+      40
+    );
+  }
 
   // Draw the Pieces
   const board = environment.steps[step][0].observation.board;

{kaggle_environments-1.17.6 → kaggle_environments-1.17.8}/kaggle_environments/envs/open_spiel/games/chess/chess.js

@@ -1,5 +1,5 @@
 function renderer(options) {
-    const { environment, step, parent, interactive, isInteractive } = options;
+    const { environment, step, parent, width = 400, height = 400 } = options;
 
     // Chess-specific constants
     const DEFAULT_NUM_ROWS = 8;
@@ -28,6 +28,7 @@ function renderer(options) {
     let currentMessageBoxElement = typeof document !== 'undefined' ? document.getElementById('messageBox') : null;
     let currentRendererContainer = null;
     let currentTitleElement = null;
+    let squareSize = 50;
 
     function _showMessage(message, type = 'info', duration = 3000) {
         if (typeof document === 'undefined' || !document.body) return;
@@ -74,25 +75,30 @@ function renderer(options) {
             fontFamily: "'Inter', sans-serif"
         });
 
-        currentTitleElement = document.createElement('h1');
-        currentTitleElement.textContent = 'Chess';
-        // Identical styling to the Connect Four renderer's title
-        Object.assign(currentTitleElement.style, {
+        if (!environment.viewer) {
+          currentTitleElement = document.createElement('h1');
+          currentTitleElement.textContent = 'Chess';
+          // Identical styling to the Connect Four renderer's title
+          Object.assign(currentTitleElement.style, {
             fontSize: '1.875rem',
             fontWeight: 'bold',
             marginBottom: '1rem',
             textAlign: 'center',
             color: '#2563eb'
-        });
-        currentRendererContainer.appendChild(currentTitleElement);
+          });
+          currentRendererContainer.appendChild(currentTitleElement);
+        }
+        parentElementToClear.appendChild(currentRendererContainer);
 
+        const smallestParentEdge = Math.min(width, height);
+        squareSize = Math.floor(smallestParentEdge / DEFAULT_NUM_COLS);
         currentBoardElement = document.createElement('div');
         Object.assign(currentBoardElement.style, {
             display: 'grid',
-            gridTemplateColumns: `repeat(${cols}, 50px)`,
-            gridTemplateRows: `repeat(${rows}, 50px)`,
-            width: `${cols * 50}px`,
-            height: `${rows * 50}px`,
+            gridTemplateColumns: `repeat(${cols}, ${squareSize}px)`,
+            gridTemplateRows: `repeat(${rows}, ${squareSize}px)`,
+            width: `${cols * squareSize}px`,
+            height: `${rows * squareSize}px`,
             border: '2px solid #333'
         });
 
@@ -101,8 +107,8 @@ function renderer(options) {
                 const square = document.createElement('div');
                 square.id = `cell-${r}-${c}`;
                 Object.assign(square.style, {
-                    width: '50px',
-                    height: '50px',
+                    width: `${squareSize}px`,
+                    height: `${squareSize}px`,
                     backgroundColor: (r + c) % 2 === 0 ? LIGHT_SQUARE_COLOR : DARK_SQUARE_COLOR,
                     display: 'flex',
                     alignItems: 'center',
@@ -126,7 +132,9 @@ function renderer(options) {
             maxWidth: '90vw',
             marginTop: '20px'
         });
-        currentRendererContainer.appendChild(statusContainer);
+        if (!environment.viewer) {
+          currentRendererContainer.appendChild(statusContainer);
+        }
 
         currentStatusTextElement = document.createElement('p');
         Object.assign(currentStatusTextElement.style, {
@@ -144,14 +152,39 @@ function renderer(options) {
         });
         statusContainer.appendChild(currentWinnerTextElement);
 
-        parentElementToClear.appendChild(currentRendererContainer);
-
         if (typeof document !== 'undefined' && !document.body.hasAttribute('data-renderer-initialized')) {
             document.body.setAttribute('data-renderer-initialized', 'true');
         }
         return true;
     }
 
+    // White is in position 1, Black is in position 0
+    function _getTeamNameForColor(color, teamNames) {
+        if (!teamNames || teamNames.length < 2) return null;
+        return color.toLowerCase() === 'white' ? teamNames[1] : teamNames[0];
+    }
+
+    function _deriveWinnerFromRewards(currentStepAgents, teamNames) {
+        if (!currentStepAgents || currentStepAgents.length < 2) return null;
+        
+        const player0Reward = currentStepAgents[0].reward;
+        const player1Reward = currentStepAgents[1].reward;
+        
+        if (player0Reward === player1Reward) {
+            return 'draw';
+        }
+        
+        const winnerPlayerIndex = player0Reward === 1 ? 0 : 1;
+        const color = winnerPlayerIndex === 0 ? 'Black' : 'White';
+        
+        if (teamNames) {
+            const teamName = _getTeamNameForColor(color, teamNames);
+            return `${color} (${teamName})`;
+        }
+        
+        return color.toLowerCase();
+    }
+
     function _parseFen(fen) {
         if (!fen || typeof fen !== 'string') return null;
 
@@ -204,8 +237,9 @@ function renderer(options) {
         }
 
 
-        const { board, activeColor, is_terminal, winner } = gameStateToDisplay;
+        const { board, activeColor, isTerminal, winner } = gameStateToDisplay;
 
+        const pieceSize = Math.floor(squareSize * 0.9);
         for (let r_data = 0; r_data < displayRows; r_data++) {
             for (let c_data = 0; c_data < displayCols; c_data++) {
                 const piece = board[r_data][c_data];
@@ -213,8 +247,8 @@ function renderer(options) {
                 if (squareElement && piece) {
                     const pieceImg = document.createElement('img');
                     pieceImg.src = PIECE_SVG_URLS[piece];
-                    pieceImg.style.width = '45px';
-                    pieceImg.style.height = '45px';
+                    pieceImg.style.width = `${pieceSize}px`;
+                    pieceImg.style.height = `${pieceSize}px`;
                     squareElement.appendChild(pieceImg);
                 }
             }
@@ -222,21 +256,23 @@ function renderer(options) {
 
         currentStatusTextElement.innerHTML = '';
         currentWinnerTextElement.innerHTML = '';
-        if (is_terminal) {
+        if (isTerminal) {
             currentStatusTextElement.textContent = "Game Over!";
             if (winner) {
                  if (String(winner).toLowerCase() === 'draw') {
                     currentWinnerTextElement.textContent = "It's a Draw!";
                  } else {
-                    const winnerColor = String(winner).toLowerCase() === 'white' ? 'White' : 'Black';
-                    currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winnerColor}</span>`;
+                    currentWinnerTextElement.innerHTML = `Winner: <span style="font-weight: bold;">${winner}</span>`;
                  }
             } else {
                  currentWinnerTextElement.textContent = "Game ended.";
             }
         } else {
-            const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
-            currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${playerColor}</span>`;
+          const playerColor = String(activeColor).toLowerCase() === 'w' ? 'White' : 'Black';
+          const teamName = _getTeamNameForColor(playerColor, environment.info?.TeamNames);
+          const currentPlayerText = teamName ? `${playerColor} (${teamName})` : playerColor;
+          
+          currentStatusTextElement.innerHTML = `Current Player: <span style="font-weight: bold;">${currentPlayerText}</span>`;
         }
     }
 
@@ -278,11 +314,12 @@ function renderer(options) {
             const fen = observationForRenderer.observationString;
             const parsedFen = _parseFen(fen);
             if (parsedFen) {
-                // Assuming `is_terminal` and `winner` are provided in the top-level observation
+                const winner = observationForRenderer.isTerminal ? 
+                    _deriveWinnerFromRewards(currentStepAgents, environment.info?.TeamNames) : null;
                 gameSpecificState = { 
                     ...parsedFen,
-                    is_terminal: observationForRenderer.isTerminal,
-                    winner: observationForRenderer.winner
+                    isTerminal: observationForRenderer.isTerminal,
+                    winner: winner
                 };
             }
         } catch (e) {
@@ -291,4 +328,4 @@ function renderer(options) {
     }
 
     _renderBoardDisplay(gameSpecificState, DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS);
-}
+}

{kaggle_environments-1.17.6 → kaggle_environments-1.17.8}/kaggle_environments/envs/open_spiel/open_spiel.py

@@ -19,6 +19,7 @@ DONE = "DONE"
 INACTIVE = "INACTIVE"
 ACTIVE = "ACTIVE"
 TIMEOUT = "TIMEOUT"
+INVALID = "INVALID"
 
 _log = logging.getLogger(__name__) 
 _log.setLevel(logging.INFO) 
@@ -41,8 +42,16 @@ for proxy_file in GAMES_DIR.glob("**/*_proxy.py"):
 
 
 # --- Constants ---
-DEFAULT_ACT_TIMEOUT = 120
-DEFAULT_RUN_TIMEOUT = 1200
+# TODO(jhtschultz): Make this configurable per-game. For instance, in poker, a
+# invalid action would likely result in a fold, forfeiting the player's
+# contribution to the pot.
+DEFAULT_INVALID_ACTION_REWARD = -1
+
+# Can be used by agents to signal an internal error to the environement.
+AGENT_ERROR_ACTION = -2
+
+DEFAULT_ACT_TIMEOUT = 60 * 60 # sixty minutes
+DEFAULT_RUN_TIMEOUT = 60 * 60 * 30 # thirty hours
 # Buffer in addition to max game length to account for timeouts, retrys, etc.
 DEFAULT_STEP_BUFFER = 100
 # TODO(jhtschultz): Add individual game descriptions.
@@ -71,6 +80,11 @@ CONFIGURATION_SPEC_TEMPLATE = {
         "type": "object",
         "default": {}
     },
+    "metadata": {
+        "description": "Arbitrary metadata.",
+        "type": "object",
+        "default": {}
+    },
 }
 
 OBSERVATION_SPEC_TEMPLATE = {
@@ -113,6 +127,10 @@ OBSERVATION_SPEC_TEMPLATE = {
             "description": "Boolean indicating game end.",
             "type": "boolean"
         },
+        "serializedGameAndState": {
+            "description": "Enables reconstructing the Game and State objects.",
+            "type": "string"
+        },
         "remainingOverageTime": 60,
         "step": 0
     },
@@ -171,19 +189,6 @@ def interpreter(
   os_game = env.os_game
   os_state = env.os_state
   num_players = os_game.num_players()
-  statuses = [
-      kaggle_state[player_id].status for player_id in range(num_players)
-  ]
-  if not any(status == ACTIVE for status in statuses):
-    for player_id in range(num_players):
-      p = kaggle_state[player_id]
-      if p.status in [ERROR, TIMEOUT]:
-        # TODO: properly set the reward per game
-        p.reward = -1
-      elif p.status in [INACTIVE]:
-        p.reward = 1
-        p.status = DONE
-    return;
 
   # TODO(jhtschultz): Test reset behavior.
   is_initial_step = len(env.steps) == 1
@@ -193,31 +198,36 @@ def interpreter(
 
   # --- Apply agent action ---
   acting_agent = os_state.current_player()
-  action_submitted = None
-  action_applied = None
+  action_submitted: int | None = None
+  action_submitted_to_string: str | None = None
+  action_applied: int | None = None
+  move_duration: float | None = None
   if is_initial_step:
     pass
   elif 0 <= acting_agent < num_players:
-    if kaggle_state[acting_agent].status != "ACTIVE":
+    if kaggle_state[acting_agent]["status"] != "ACTIVE":
       pass
     else:
-      action_submitted = kaggle_state[acting_agent].action["submission"]
+      action_submitted = kaggle_state[acting_agent]["action"]["submission"]
       if action_submitted in os_state.legal_actions():
-        try:
-          os_state.apply_action(action_submitted)
-          action_applied = action_submitted
-          env.info['actionHistory'].append(str(action_applied))
-          env.info['stateHistory'].append(str(os_state))
-        except Exception as e:  # pylint: disable=broad-exception-caught
-          _log.debug(e)
-          kaggle_state[acting_agent].status = "ERROR"
-      else:
-        kaggle_state[acting_agent].status = "INVALID"
-      if "duration" in logs[acting_agent]:
-        move_duration = round(logs[acting_agent]["duration"], 3)
-        env.info["moveDurations"].append(move_duration)
+        action_submitted_to_string = os_state.action_to_string(action_submitted)
+        os_state.apply_action(action_submitted)
+        action_applied = action_submitted
+        env.info['actionHistory'].append(str(action_applied))
+        env.info['stateHistory'].append(str(os_state))
+      elif action_submitted == AGENT_ERROR_ACTION:
+        kaggle_state[acting_agent]["status"] = "ERROR"
       else:
-        env.info["moveDurations"].append(None)
+        kaggle_state[acting_agent]["status"] = "INVALID"
+      try:
+        if "duration" in logs[acting_agent]:
+          move_duration = round(logs[acting_agent]["duration"], 3)
+          env.info["moveDurations"].append(move_duration)
+        else:
+          env.info["moveDurations"].append(None)
+      except Exception:
+        pass  # No logs when stepping the env manually.
+
   elif acting_agent == pyspiel.PlayerId.SIMULTANEOUS:
     raise NotImplementedError
   elif acting_agent == pyspiel.PlayerId.TERMINAL:
@@ -236,10 +246,36 @@ def interpreter(
     env.info['stateHistory'].append(str(os_state))
 
   # --- Update agent states ---
+  agent_error = any(
+    kaggle_state[player_id]["status"] in ["TIMEOUT", "ERROR"]
+    for player_id in range(num_players)
+  )
+  if agent_error:
+    _log.info("AGENT ERROR DETECTED")
+  
+  invalid_action = any(
+    kaggle_state[player_id]["status"] == "INVALID"
+    for player_id in range(num_players)
+  )
+  if invalid_action:
+    _log.info("INVALID ACTION DETECTED")
+
+  status: str | None = None
   for player_id, agent_state in enumerate(kaggle_state):
     reward = None
-    if agent_state.status in ["TIMEOUT", "ERROR", "INVALID"]:
-      status = agent_state.status
+    if agent_error:
+      # Set all agent statuses to ERROR in order not to score episode. Preserve
+      # TIMEOUT which has the same effect.
+      if agent_state["status"] == "TIMEOUT":
+        status = "TIMEOUT"
+      else:
+        status = "ERROR"
+    elif invalid_action:
+      if agent_state["status"] == "INVALID":
+        reward = DEFAULT_INVALID_ACTION_REWARD
+      else:
+        reward = -DEFAULT_INVALID_ACTION_REWARD
+      status = "DONE"
     elif os_state.is_terminal():
       status = "DONE"
       reward = os_state.returns()[player_id]
@@ -251,11 +287,17 @@ def interpreter(
         )
     else:
       status = "INACTIVE"
+    assert status is not None
 
     info_dict = {}
     if acting_agent == player_id:
       info_dict["actionSubmitted"] = action_submitted
+      info_dict["actionSubmittedToString"] = action_submitted_to_string
       info_dict["actionApplied"] = action_applied
+      info_dict["timeTaken"] = move_duration
+      info_dict[
+        "agentSelfReportedStatus"
+      ] = kaggle_state[acting_agent]["action"].get("status") if kaggle_state[acting_agent]["action"] else "unknown"
 
     obs_update_dict = {
       "observationString": os_state.observation_string(player_id),
@@ -267,14 +309,17 @@ def interpreter(
       "currentPlayer": os_state.current_player(),
       "playerId": player_id,
       "isTerminal": os_state.is_terminal(),
+      "serializedGameAndState": pyspiel.serialize_game_and_state(
+          os_game, os_state
+      ),
     }
 
     # Apply updates
     for k, v in obs_update_dict.items():
       setattr(agent_state.observation, k, v)
-    agent_state.reward = reward
-    agent_state.info = info_dict
-    agent_state.status = status
+    agent_state["reward"] = reward
+    agent_state["info"] = info_dict
+    agent_state["status"] = status
 
   return kaggle_state
 
@@ -400,14 +445,13 @@ def _build_env(game_string: str) -> dict[str, Any]:
   env_spec["title"] = f"Open Spiel: {short_name}"
   env_spec["agents"] = [game.num_players()]
 
-  env_config = copy.deepcopy(CONFIGURATION_SPEC_TEMPLATE)
-  env_spec["configuration"] = env_config
+  env_config = env_spec["configuration"]
   env_config["episodeSteps"] = game.max_history_length() + DEFAULT_STEP_BUFFER
   env_config["openSpielGameString"]["default"] = str(game)
   env_config["openSpielGameName"]["default"] = short_name
+  env_config["openSpielGameParameters"]["default"] = game.get_parameters()
 
-  env_obs = copy.deepcopy(OBSERVATION_SPEC_TEMPLATE)
-  env_spec["observation"] = env_obs
+  env_obs = env_spec["observation"]
   env_obs["properties"]["openSpielGameString"]["default"] = str(game)
   env_obs["properties"]["openSpielGameName"]["default"] = short_name
 

kaggle_environments-1.17.8/kaggle_environments/envs/open_spiel/test_open_spiel.py

@@ -0,0 +1,96 @@
+from absl.testing import absltest
+import sys
+from kaggle_environments import make
+import pyspiel
+from . import open_spiel as open_spiel_env
+
+
+# Expected that not all pyspiel registered games can be registered as Kaggle
+# envs (e.g. does not yet support simultaneous move games), but should register
+# at least this many
+_REGISTERED_GAMES_THRESHOLD = 50
+
+
+class OpenSpielEnvTest(absltest.TestCase):
+
+  def test_envs_load(self):
+    envs = open_spiel_env._register_game_envs(
+        [game_type.short_name for game_type in pyspiel.registered_games()]
+    )
+    self.assertTrue(len(envs) > _REGISTERED_GAMES_THRESHOLD)
+
+  def test_tic_tac_toe_agent_playthrough(self):
+    envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+    env = make("open_spiel_tic_tac_toe", debug=True)
+    env.run(["random", "random"])
+    json = env.toJSON()
+    self.assertEqual(json["name"], "open_spiel_tic_tac_toe")
+    self.assertTrue(all([status == "DONE" for status in json["statuses"]]))
+
+  def test_tic_tac_toe_manual_playthrough(self):
+    envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+    env = make("open_spiel_tic_tac_toe", debug=True)
+    env.reset()
+    env.step([{"submission": -1}, {"submission": -1}])  # Initial setup step.
+    env.step([{"submission": 0}, {"submission": -1}])
+    env.step([{"submission": -1}, {"submission": 1}])
+    env.step([{"submission": 3}, {"submission": -1}])
+    env.step([{"submission": -1}, {"submission": 4}])
+    env.step([{"submission": 6}, {"submission": -1}])
+    self.assertTrue(env.done)
+    self.assertEqual(env.toJSON()["rewards"], [1, -1])
+
+  def test_invalid_action(self):
+    envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+    env = make("open_spiel_tic_tac_toe", debug=True)
+    env.reset()
+    for i in range(5):  # Try repeatedly applying an illegal action
+      env.step([
+          {"submission": pyspiel.INVALID_ACTION},
+          {"submission": pyspiel.INVALID_ACTION},
+      ])
+      if env.done:
+        break
+    self.assertEqual(i, 1)  # Zeroth step is setup step, should fail next step.
+    json = env.toJSON()
+    self.assertTrue(all([status == "DONE" for status in json["statuses"]]))
+    self.assertEqual(
+        json["rewards"],
+        [
+            open_spiel_env.DEFAULT_INVALID_ACTION_REWARD,
+            -open_spiel_env.DEFAULT_INVALID_ACTION_REWARD,
+        ]
+    )
+
+  def test_serialized_game_and_state(self):
+    envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+    env = make("open_spiel_tic_tac_toe", debug=True)
+    env.reset()
+    env.step([{"submission": -1}, {"submission": -1}])  # Initial setup step.
+    kaggle_state = env.step([{"submission": 0}, {"submission": -1}])
+    serialize_game_and_state = kaggle_state[1]["observation"]["serializedGameAndState"]
+    game, state = pyspiel.deserialize_game_and_state(serialize_game_and_state)
+    self.assertEqual(game.get_type().short_name, "tic_tac_toe_proxy")
+    self.assertEqual(state.history(), [0])
+
+  def test_agent_error(self):
+    envs = open_spiel_env._register_game_envs(["tic_tac_toe"])
+    env = make("open_spiel_tic_tac_toe", debug=True)
+    env.reset()
+    # Setup step
+    env.step([
+        {"submission": pyspiel.INVALID_ACTION},
+        {"submission": pyspiel.INVALID_ACTION},
+    ])
+    env.step([
+        {"submission": open_spiel_env.AGENT_ERROR_ACTION},
+        {"submission": pyspiel.INVALID_ACTION},
+    ])
+    self.assertTrue(env.done)
+    json = env.toJSON()
+    self.assertEqual(json["rewards"], [None, None])
+    self.assertEqual(json["statuses"], ["ERROR", "ERROR"])
+
+
+if __name__ == '__main__':
+  absltest.main()