kaggle-environments 1.16.11__tar.gz → 1.17.2__tar.gz

{kaggle-environments-1.16.11/kaggle_environments.egg-info → kaggle_environments-1.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.16.11
+Version: 1.17.2
 Summary: Kaggle Environments
 Home-page: https://github.com/Kaggle/kaggle-environments
 Author: Kaggle
@@ -10,6 +10,29 @@ Keywords: Kaggle
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: jsonschema>=3.0.1
+Requires-Dist: Flask>=1.1.2
+Requires-Dist: numpy>=1.19.5
+Requires-Dist: requests>=2.25.1
+Requires-Dist: pettingzoo==1.24.0
+Requires-Dist: gymnasium==0.29.0
+Requires-Dist: stable-baselines3==2.1.0
+Requires-Dist: transformers>=4.33.1
+Requires-Dist: scipy>=1.11.2
+Requires-Dist: shimmy>=1.2.1
+Requires-Dist: Chessnut>=0.4.1
+Requires-Dist: open_spiel>=1.5.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # [<img src="https://kaggle.com/static/images/site-logo.png" height="50" style="margin-bottom:-15px" />](https://kaggle.com) Environments
 

{kaggle-environments-1.16.11 → kaggle_environments-1.17.2}/kaggle_environments/__init__.py

@@ -20,7 +20,7 @@ from .core import *
 from .main import http_request
 from . import errors
 
-__version__ = "1.16.11"
+__version__ = "1.17.2"
 
 __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
            "make", "register", "utils", "__version__",
@@ -31,13 +31,23 @@ __all__ = ["Agent", "environments", "errors", "evaluate", "http_request",
 for name in listdir(utils.envs_path):
     try:
         env = import_module(f".envs.{name}.{name}", __name__)
-        register(name, {
-            "agents": getattr(env, "agents", []),
-            "html_renderer": getattr(env, "html_renderer", None),
-            "interpreter": getattr(env, "interpreter"),
-            "renderer": getattr(env, "renderer"),
-            "specification": getattr(env, "specification"),
-        })
+        if name == "open_spiel":
+            for env_name, env_dict in env.registered_open_spiel_envs.items():
+                register(env_name, {
+                    "agents": env_dict.get("agents"),
+                    "html_renderer": env_dict.get("html_renderer"),
+                    "interpreter": env_dict.get("interpreter"),
+                    "renderer": env_dict.get("renderer"),
+                    "specification": env_dict.get("specification"),
+                })
+        else:
+          register(name, {
+              "agents": getattr(env, "agents", []),
+              "html_renderer": getattr(env, "html_renderer", None),
+              "interpreter": getattr(env, "interpreter"),
+              "renderer": getattr(env, "renderer"),
+              "specification": getattr(env, "specification"),
+          })
     except Exception as e:
         if "football" not in name:
             print("Loading environment %s failed: %s" % (name, e))

{kaggle-environments-1.16.11 → kaggle_environments-1.17.2}/kaggle_environments/envs/lux_ai_s3/luxai_s3/env.py

@@ -148,6 +148,11 @@ class LuxAIS3Env(environment.Environment):
                     i : max_sensor_range * 2 + 1 - i,
                     i : max_sensor_range * 2 + 1 - i,
                 ].set(val)
+            # vision of position at center of update has an extra 10
+            update = update.at[
+                max_sensor_range,
+                max_sensor_range,
+            ].add(10)
             vision_power_map = jax.lax.dynamic_update_slice(
                 vision_power_map,
                 update=update + existing_vision_power,
@@ -227,6 +232,10 @@ class LuxAIS3Env(environment.Environment):
         state = state.replace(
             units_mask=(state.units.energy[..., 0] >= 0) & state.units_mask
         )
+        
+        """spawn relic nodes based on schedule"""
+        relic_nodes_mask = (state.steps >= state.relic_spawn_schedule) & (state.relic_spawn_schedule != -1)
+        state = state.replace(relic_nodes_mask=relic_nodes_mask)
 
         """ process unit movement """
         # 0 is do nothing, 1 is move up, 2 is move right, 3 is move down, 4 is move left, 5 is sap
@@ -646,11 +655,10 @@ class LuxAIS3Env(environment.Environment):
             axis=(0, 1),
         )
         new_tile_types_map = jnp.where(
-            state.steps * params.nebula_tile_drift_speed % 1 == 0,
+            (state.steps - 1) * abs(params.nebula_tile_drift_speed) % 1 > state.steps * abs(params.nebula_tile_drift_speed) % 1,
             new_tile_types_map,
             state.map_features.tile_type,
         )
-        # new_energy_nodes = state.energy_nodes + jnp.array([1 * jnp.sign(params.energy_node_drift_speed), -1 * jnp.sign(params.energy_node_drift_speed)])
 
         energy_node_deltas = jnp.round(
             jax.random.uniform(
@@ -663,8 +671,6 @@ class LuxAIS3Env(environment.Environment):
         energy_node_deltas_symmetric = jnp.stack(
             [-energy_node_deltas[:, 1], -energy_node_deltas[:, 0]], axis=-1
         )
-        # TODO symmetric movement
-        # energy_node_deltas = jnp.round(jax.random.uniform(key=key, shape=(params.max_energy_nodes // 2, 2), minval=-params.energy_node_drift_magnitude, maxval=params.energy_node_drift_magnitude)).astype(jnp.int16)
         energy_node_deltas = jnp.concatenate(
             (energy_node_deltas, energy_node_deltas_symmetric)
         )
@@ -677,7 +683,7 @@ class LuxAIS3Env(environment.Environment):
             ),
         )
         new_energy_nodes = jnp.where(
-            state.steps * params.energy_node_drift_speed % 1 == 0,
+            (state.steps - 1) * abs(params.energy_node_drift_speed) % 1 > state.steps * abs(params.energy_node_drift_speed) % 1,
             new_energy_nodes,
             state.energy_nodes,
         )
@@ -688,7 +694,9 @@ class LuxAIS3Env(environment.Environment):
 
         # Compute relic scores
         def team_relic_score(unit_counts_map):
-            scores = (unit_counts_map > 0) & (state.relic_nodes_map_weights > 0)
+            # not all relic nodes are spawned in yet, but relic nodes map ids are precomputed for all to be spawned relic nodes
+            # for efficiency. So we check if the relic node (by id) is spawned in yet. relic nodes mask is always increasing so we can do a simple trick below
+            scores = (unit_counts_map > 0) & (state.relic_nodes_map_weights <= state.relic_nodes_mask.sum() // 2) & (state.relic_nodes_map_weights > 0)
             return jnp.sum(scores, dtype=jnp.int32)
 
         # note we need to recompue unit counts since units can get removed due to collisions
@@ -771,7 +779,6 @@ class LuxAIS3Env(environment.Environment):
         )
         state = self.compute_energy_features(state, params)
         state = self.compute_sensor_masks(state, params)
-
         return self.get_obs(state, params=params, key=key), state
 
     @functools.partial(jax.jit, static_argnums=(0,))

{kaggle-environments-1.16.11 → kaggle_environments-1.17.2}/kaggle_environments/envs/lux_ai_s3/luxai_s3/params.py

@@ -46,6 +46,7 @@ class EnvParams:
     min_energy_per_tile: int = -20
 
     max_relic_nodes: int = 6
+    """max relic nodes in the entire map. This number should be tuned carefully as relic node spawning code is hardcoded against this number 6"""
     relic_config_size: int = 5
     fog_of_war: bool = True
     """
@@ -87,15 +88,15 @@ class EnvParams:
 env_params_ranges = dict(
     # map_type=[1],
     unit_move_cost=list(range(1, 6)),
-    unit_sensor_range=list(range(2, 5)),
-    nebula_tile_vision_reduction=list(range(0, 4)),
-    nebula_tile_energy_reduction=[0, 0, 10, 25],
+    unit_sensor_range=[1, 2, 3, 4],
+    nebula_tile_vision_reduction=list(range(0, 8)),
+    nebula_tile_energy_reduction=[0, 1, 2, 3, 5, 25],
     unit_sap_cost=list(range(30, 51)),
     unit_sap_range=list(range(3, 8)),
     unit_sap_dropoff_factor=[0.25, 0.5, 1],
     unit_energy_void_factor=[0.0625, 0.125, 0.25, 0.375],
     # map randomizations
-    nebula_tile_drift_speed=[-0.05, -0.025, 0.025, 0.05],
+    nebula_tile_drift_speed=[-0.15, -0.1, -0.05, -0.025, 0.025, 0.05, 0.1, 0.15],
     energy_node_drift_speed=[0.01, 0.02, 0.03, 0.04, 0.05],
     energy_node_drift_magnitude=list(range(3, 6)),
 )

{kaggle-environments-1.16.11 → kaggle_environments-1.17.2}/kaggle_environments/envs/lux_ai_s3/luxai_s3/state.py

@@ -66,7 +66,10 @@ class EnvState:
     relic_nodes_mask: chex.Array
     """Mask of relic nodes in the environment with shape (N, ) for N max relic nodes"""
     relic_nodes_map_weights: chex.Array
-    """Map of relic nodes in the environment with shape (H, W) for H height, W width. True if a relic node is present, False otherwise. This is generated from other state"""
+    """Map of relic nodes in the environment with shape (H, W) for H height, W width. Each element is equal to the 1-indexed id of the relic node. This is generated from other state"""
+    
+    relic_spawn_schedule: chex.Array
+    """Relic spawn schedule in the environment with shape (N, ) for N max relic nodes. Elements are the game timestep at which the relic node spawns"""
 
     map_features: MapTile
     """Map features in the environment with shape (W, H, 2) for W width, H height
@@ -121,7 +124,7 @@ class EnvObs:
 
 def serialize_env_states(env_states: list[EnvState]):
     def serialize_array(root: EnvState, arr, key_path: str = ""):
-        if key_path in ["sensor_mask", "relic_nodes_mask", "energy_nodes_mask", "energy_node_fns", "relic_nodes_map_weights"]:
+        if key_path in ["sensor_mask", "relic_nodes_mask", "energy_nodes_mask", "energy_node_fns", "relic_nodes_map_weights", "relic_spawn_schedule"]:
             return None
         if key_path == "relic_nodes":
             return root.relic_nodes[root.relic_nodes_mask].tolist()
@@ -186,9 +189,10 @@ def gen_state(key: chex.PRNGKey, env_params: EnvParams, max_units: int, num_team
 
     # TODO (this could be optimized better)
     def update_relic_node(relic_nodes_map_weights, relic_data):
-        relic_node, relic_node_config, mask = relic_data
+        relic_node, relic_node_config, mask, relic_node_id = relic_data
         start_y = relic_node[1] - relic_config_size // 2
         start_x = relic_node[0] - relic_config_size // 2
+        
         for dy in range(relic_config_size):
             for dx in range(relic_config_size):
                 y, x = start_y + dy, start_x + dx
@@ -196,14 +200,20 @@ def gen_state(key: chex.PRNGKey, env_params: EnvParams, max_units: int, num_team
                     jnp.logical_and(y >= 0, x >= 0),
                     jnp.logical_and(y < map_height, x < map_width),
                 )
+                # ensure we don't override previous spawns
+                has_points = jnp.logical_and(
+                    relic_nodes_map_weights > 0,
+                    relic_nodes_map_weights <= relic_node_id + 1
+                )
                 relic_nodes_map_weights = jnp.where(
-                    valid_pos & mask,
-                    relic_nodes_map_weights.at[x, y].add(relic_node_config[dx, dy].astype(jnp.int16)),
+                    valid_pos & mask & jnp.logical_not(has_points) & relic_node_config[dx, dy],
+                    relic_nodes_map_weights.at[x, y].set(relic_node_config[dx, dy].astype(jnp.int16) * (relic_node_id + 1)),
                     relic_nodes_map_weights,
                 )
         return relic_nodes_map_weights, None
 
     # this is really slow...
+    
     relic_nodes_map_weights, _ = jax.lax.scan(
         update_relic_node,
         relic_nodes_map_weights,
@@ -211,8 +221,10 @@ def gen_state(key: chex.PRNGKey, env_params: EnvParams, max_units: int, num_team
             generated["relic_nodes"],
             generated["relic_node_configs"],
             generated["relic_nodes_mask"],
+            jnp.arange(max_relic_nodes, dtype=jnp.int16) % (max_relic_nodes // 2),
         ),
     )
+    
     state = EnvState(
         units=UnitState(position=jnp.zeros(shape=(num_teams, max_units, 2), dtype=jnp.int16), energy=jnp.zeros(shape=(num_teams, max_units, 1), dtype=jnp.int16)),
         units_mask=jnp.zeros(
@@ -225,9 +237,10 @@ def gen_state(key: chex.PRNGKey, env_params: EnvParams, max_units: int, num_team
         energy_nodes_mask=generated["energy_nodes_mask"],
         # energy_field=jnp.zeros(shape=(params.map_height, params.map_width), dtype=jnp.int16),
         relic_nodes=generated["relic_nodes"],
-        relic_nodes_mask=generated["relic_nodes_mask"],
+        relic_nodes_mask=jnp.zeros(shape=(max_relic_nodes), dtype=jnp.bool), # as relic nodes are spawn in, we start with them all invisible.
         relic_node_configs=generated["relic_node_configs"],
         relic_nodes_map_weights=relic_nodes_map_weights,
+        relic_spawn_schedule=generated["relic_spawn_schedule"],
         sensor_mask=jnp.zeros(
             shape=(num_teams, map_height, map_width),
             dtype=jnp.bool,
@@ -276,7 +289,7 @@ def gen_map(key: chex.PRNGKey, params: EnvParams, map_type: int, map_height: int
         flat_indices = jnp.argsort(noise.ravel())[-max_relic_nodes // 2:]  # Get indices of two highest values
         highest_positions = jnp.column_stack(jnp.unravel_index(flat_indices, noise.shape))
 
-        # relic nodes have a fixed density of 25% nearby tiles can yield points
+        # relic nodes have a fixed density of 20% nearby tiles can yield points
         relic_node_configs = (
             jax.random.randint(
                 key,
@@ -291,18 +304,15 @@ def gen_map(key: chex.PRNGKey, params: EnvParams, map_type: int, map_height: int
             >= 7.5
         )
         highest_positions = highest_positions.astype(jnp.int16)
-        relic_nodes_mask = relic_nodes_mask.at[0].set(True)
-        relic_nodes_mask = relic_nodes_mask.at[1].set(True)
         mirrored_positions = jnp.stack([map_width - highest_positions[:, 1] - 1, map_height - highest_positions[:, 0] - 1], dtype=jnp.int16, axis=-1)
         relic_nodes = jnp.concat([highest_positions, mirrored_positions], axis=0)
         
         key, subkey = jax.random.split(key)
-        relic_nodes_mask_half = jax.random.randint(key, (max_relic_nodes // 2, ), minval=0, maxval=2).astype(jnp.bool)
-        relic_nodes_mask_half = relic_nodes_mask_half.at[0].set(True)
-        relic_nodes_mask = relic_nodes_mask.at[:max_relic_nodes // 2].set(relic_nodes_mask_half)
-        relic_nodes_mask = relic_nodes_mask.at[max_relic_nodes // 2:].set(relic_nodes_mask_half)
-        # import ipdb;ipdb.set_trace()
+        num_spawned_relic_nodes = jax.random.randint(key, (1, ), minval=1, maxval=(max_relic_nodes // 2) + 1)
+        relic_nodes_mask_half = jnp.arange(max_relic_nodes // 2) < num_spawned_relic_nodes
+        relic_nodes_mask = jnp.concat([relic_nodes_mask_half, relic_nodes_mask_half], axis=0)
         relic_node_configs = relic_node_configs.at[max_relic_nodes // 2:].set(relic_node_configs[:max_relic_nodes // 2].transpose(0, 2, 1)[:, ::-1, ::-1])
+        # note that relic nodes mask is always increasing.
         
         ### Generate energy nodes ###
         key, subkey = jax.random.split(key)
@@ -318,7 +328,6 @@ def gen_map(key: chex.PRNGKey, params: EnvParams, map_type: int, map_height: int
         energy_nodes_mask = energy_nodes_mask.at[:max_energy_nodes // 2].set(energy_nodes_mask_half)
         energy_nodes_mask = energy_nodes_mask.at[max_energy_nodes // 2:].set(energy_nodes_mask_half)
         
-        # TODO (stao): provide more randomization options for energy node functions.
         energy_node_fns = jnp.array(
             [
                 [0, 1.2, 1, 4],
@@ -331,8 +340,14 @@ def gen_map(key: chex.PRNGKey, params: EnvParams, map_type: int, map_height: int
                 # [1, 4, 0, 0]
             ]
         )
-        # import ipdb; ipdb.set_trace()
-        # energy_node_fns = jnp.concat([energy_node_fns, jnp.zeros((params.max_energy_nodes - 2, 4), dtype=jnp.float32)], axis=0)
+        
+        # generate a random relic spawn schedule
+        # if number is -1, then relic node is never spawned, otherwise spawn at that game timestep
+        assert max_relic_nodes == 6, "random map generation is hardcoded to use 6 relic nodes at most per map"
+        key, subkey = jax.random.split(key)
+        relic_spawn_schedule_half = jax.random.randint(key, (max_relic_nodes //2, ), minval=0, maxval=params.max_steps_in_match // 2) + jnp.arange(3) * (params.max_steps_in_match + 1)
+        relic_spawn_schedule = jnp.concat([relic_spawn_schedule_half, relic_spawn_schedule_half], axis=0)
+        relic_spawn_schedule = jnp.where(relic_nodes_mask, relic_spawn_schedule, -1)
         
         
     return dict(
@@ -343,6 +358,7 @@ def gen_map(key: chex.PRNGKey, params: EnvParams, map_type: int, map_height: int
         energy_nodes_mask=energy_nodes_mask,
         relic_nodes_mask=relic_nodes_mask,
         relic_node_configs=relic_node_configs,
+        relic_spawn_schedule=relic_spawn_schedule,
     )
 def interpolant(t):
     return t*t*t*(t*(t*6 - 15) + 10)

kaggle_environments-1.17.2/kaggle_environments/envs/open_spiel/open_spiel.py

@@ -0,0 +1,354 @@
+"""Kaggle environment wrapper for OpenSpiel games."""
+
+import copy
+import random
+from typing import Any
+
+from kaggle_environments import core
+from kaggle_environments import utils
+import numpy as np
+import pyspiel
+
+
+DEFAULT_ACT_TIMEOUT = 5
+DEFAULT_RUN_TIMEOUT = 1200
+DEFAULT_EPISODE_STEP_BUFFER = 100  # To account for timeouts, retrys, etc...
+
+BASE_SPEC_TEMPLATE = {
+    "name": "PLACEHOLDER_NAME",
+    "title": "PLACEHOLDER_TITLE",
+    "description": "PLACEHOLDER_DESCRIPTION",
+    "version": "0.1.0",
+    "agents": ["PLACEHOLDER_NUM_AGENTS"],
+
+    "configuration": {
+        "episodeSteps": -1,
+        "actTimeout": DEFAULT_ACT_TIMEOUT,
+        "runTimeout": DEFAULT_RUN_TIMEOUT,
+        "openSpielGameString": {
+            "description": "The full game string including parameters.",
+            "type": "string",
+            "default": "PLACEHOLDER_GAME_STRING"
+        },
+        "openSpielGameName": {
+            "description": "The short_name of the OpenSpiel game to load.",
+            "type": "string",
+            "default": "PLACEHOLDER_GAME_SHORT_NAME"
+        },
+    },
+    "observation": {
+        "properties": {
+            "openSpielGameString": {
+                "description": "Full game string including parameters.",
+                "type": "string"
+            },
+            "openSpielGameName": {
+                "description": "Short name of the OpenSpiel game.",
+                "type": "string"
+            },
+            "observation_string": {
+                "description": "String representation of state.",
+                "type": "string"
+            },
+            # TODO(jhtschultz): add legal action strings
+            "legal_actions": {
+                "description": "List of OpenSpiel legal actions.",
+                "type": "array",
+                "items": {
+                    "type": "integer"
+                }
+            },
+            "chance_outcome_probs": {
+                "description": "List of probabilities for chance outcomes.",
+                "type": "array",
+                "items": {
+                    "type": "float"
+                }
+            },
+            "current_player": {
+                "description": "ID of player whose turn it is.",
+                "type": "integer"
+            },
+            "is_terminal": {
+                "description": "Boolean indicating game end.",
+                "type": "boolean"
+            },
+            "player_id": {
+                "description": "ID of the agent receiving this observation.",
+                "type": "integer"
+            },
+            "remainingOverageTime": 60,
+            "step": 0
+        },
+        "default": {}
+    },
+    "action": {
+        "type": ["integer"],
+        "minimum": -1,
+        "default": -1
+    },
+    "reward": {
+        "type": ["number"],
+        "default": 0.0
+    },
+}
+
+
+_OS_GLOBAL_GAME = None
+_OS_GLOBAL_STATE = None
+
+
+def _get_open_spiel_game(env_config: utils.Struct) -> pyspiel.Game:
+  global _OS_GLOBAL_GAME
+  game_string = env_config.get("openSpielGameString")
+  if game_string == str(_OS_GLOBAL_GAME):
+    return _OS_GLOBAL_GAME
+  if _OS_GLOBAL_GAME is not None:
+    print(
+      f"WARNING: Overwriting game. Old: {_OS_GLOBAL_GAME}. New {game_string}"
+    )
+  _OS_GLOBAL_GAME = pyspiel.load_game(game_string)
+  return _OS_GLOBAL_GAME
+
+
+def interpreter(
+  state: list[utils.Struct],
+  env: core.Environment,
+) -> list[utils.Struct]:
+  """Updates environment using player responses and returns new observations."""
+  global _OS_GLOBAL_GAME, _OS_GLOBAL_STATE
+  kaggle_state = state
+  del state
+
+  if env.done:
+    return kaggle_state
+
+  # --- Get Game Info ---
+  game = _get_open_spiel_game(env.configuration)
+  num_players = game.num_players()
+  statuses = [
+      kaggle_state[os_current_player].status
+      for os_current_player in range(num_players)
+  ]
+  if not any(status == "ACTIVE" for status in statuses):
+    raise ValueError("Environment not done and no active agents.")
+
+  # --- Initialization / Reset ---
+  # TODO(jhtschultz): test this behavior.
+  is_initial_step = len(env.steps) == 1
+  if _OS_GLOBAL_STATE is None or (not is_initial_step and env.done):
+    _OS_GLOBAL_STATE = game.new_initial_state()
+
+  # --- Maybe apply agent action ---
+  os_current_player = _OS_GLOBAL_STATE.current_player()
+  action_applied = None
+  if is_initial_step:
+    pass
+  elif 0 <= os_current_player < num_players:
+    if kaggle_state[os_current_player].status != "ACTIVE":
+      pass
+    else:
+      action_submitted = kaggle_state[os_current_player].action
+      legal = _OS_GLOBAL_STATE.legal_actions()
+      if action_submitted in legal:
+        try:
+          _OS_GLOBAL_STATE.apply_action(action_submitted)
+          action_applied = action_submitted
+        except Exception:  # pylint: disable=broad-exception-caught
+          kaggle_state[os_current_player].status = "ERROR"
+      else:
+        kaggle_state[os_current_player].status = "INVALID"
+  elif os_current_player == pyspiel.PlayerId.SIMULTANEOUS:
+    raise NotImplementedError
+  elif os_current_player == pyspiel.PlayerId.TERMINAL:
+    pass
+  elif os_current_player == pyspiel.PlayerId.CHANCE:
+    raise ValueError("Interpreter should not be called at chance nodes.")
+  else:
+    raise ValueError(f"Unknown OpenSpiel player ID: {os_current_player}")
+
+  # --- Update state info ---
+  while _OS_GLOBAL_STATE.is_chance_node():
+    chance_outcomes = _OS_GLOBAL_STATE.chance_outcomes
+    outcomes = _OS_GLOBAL_STATE.chance_outcomes()
+    legal_actions, chance_outcome_probs = zip(*outcomes)
+    action = np.random.choice(legal_actions, p=chance_outcome_probs)
+    _OS_GLOBAL_STATE.apply_action(action)
+  is_terminal = _OS_GLOBAL_STATE.is_terminal()
+  agent_returns = _OS_GLOBAL_STATE.returns() + [None]
+  next_agent = _OS_GLOBAL_STATE.current_player()
+
+  for i, agent_state in enumerate(kaggle_state):
+    input_status = agent_state.status
+    status = ""
+    reward = None
+
+    if input_status in ["TIMEOUT", "ERROR", "INVALID"]:
+      status = input_status
+      reward = None
+    elif is_terminal:
+      status = "DONE"
+      reward = agent_returns[i]
+    elif next_agent == i:
+      status = "ACTIVE"
+      reward = agent_returns[i]
+    else:
+      status = "INACTIVE"
+      reward = agent_returns[i]
+
+    info_dict = {}
+    # Store the applied action in info for potential debugging/analysis
+    if os_current_player == i and action_applied is not None:
+      info_dict["action_applied"] = action_applied
+
+    game_type = _OS_GLOBAL_GAME.get_type()
+    obs_str = str(_OS_GLOBAL_STATE)
+    legal_actions = _OS_GLOBAL_STATE.legal_actions(i)
+
+    if status == "ACTIVE" and not legal_actions:
+      raise ValueError(
+        f"Active agent {i} has no legal actions in state {_OS_GLOBAL_STATE}."
+      )
+
+    # Apply updates
+    obs_update_dict = {
+      "observation_string": obs_str,
+      "legal_actions": legal_actions,
+      "current_player": next_agent,
+      "is_terminal": is_terminal,
+      "player_id": i,
+    }
+    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
+
+  return kaggle_state
+
+
+def renderer(state: list[utils.Struct], env: core.Environment) -> str:
+  """Kaggle renderer function."""
+  try:
+    obs_str = state[-1].observation["observation_string"]
+    return obs_str if obs_str else "<Empty observation string>"
+  except Exception as e:  # pylint: disable=broad-exception-caught
+    print(f"Error rendering {env.name} at state: {state}.")
+    raise e
+
+
+def html_renderer():
+  """Provides the simplest possible HTML/JS renderer for OpenSpiel text observations."""
+  return """
+function renderer(context) {
+    const { parent, environment, step } = context;
+    parent.innerHTML = ''; // Clear previous rendering
+
+    // Get the current step's data
+    const currentStepData = environment.steps[step];
+    const numAgents = currentStepData.length
+    const gameMasterIndex = numAgents - 1
+    let obsString = "Observation not available for this step.";
+
+    // Try to get the raw observation string from the game master agent.
+    if (currentStepData && currentStepData[gameMasterIndex] && currentStepData[gameMasterIndex].observation && currentStepData[gameMasterIndex].observation.observation_string !== undefined) {
+        obsString = currentStepData[gameMasterIndex].observation.observation_string;
+    } else if (step === 0 && environment.steps[0] && environment.steps[0][gameMasterIndex] && environment.steps[0][gameMasterIndex].observation && environment.steps[0][gameMasterIndex].observation.observation_string !== undefined) {
+        // Fallback for initial state if current step data is missing
+        obsString = environment.steps[0][gameMasterIndex].observation.observation_string;
+    }
+
+    // Create a <pre> element to preserve formatting
+    const pre = document.createElement("pre");
+    pre.style.fontFamily = "monospace"; // Ensure monospace font
+    pre.style.margin = "10px";        // Add some padding
+    pre.style.border = "1px solid #ccc";
+    pre.style.padding = "5px";
+    pre.style.backgroundColor = "#f0f0f0";
+
+    // Set the text content (safer than innerHTML for plain text)
+    pre.textContent = `Step: ${step}\\n\\n${obsString}`; // Add step number for context
+
+    parent.appendChild(pre);
+}
+"""
+
+
+# --- Agents ---
+def random_agent(
+  observation: dict[str, Any],
+  configuration: dict[str, Any],
+) -> int:
+  """A built-in random agent specifically for OpenSpiel environments."""
+  del configuration
+  legal_actions = observation.get("legal_actions")
+  if not legal_actions:
+    return None
+  action = random.choice(legal_actions)
+  return int(action)
+
+
+agents = {
+  "random": random_agent,
+}
+
+
+def _register_open_spiel_envs(
+  games_list: list[str] | None = None,
+) -> dict[str, Any]:
+  successfully_loaded_games = []
+  skipped_games = []
+  registered_envs = {}
+  if games_list is None:
+    games_list = pyspiel.registered_names()
+  for short_name in games_list:
+    try:
+      game = pyspiel.load_game(short_name)
+      game_type = game.get_type()
+      if not any([
+        game_type.provides_information_state_string,
+        game_type.provides_observation_string,
+      ]):
+        continue
+      game_spec = copy.deepcopy(BASE_SPEC_TEMPLATE)
+      env_name = f"open_spiel_{short_name.replace('-', '_').replace('.', '_')}"
+      game_spec["name"] = env_name
+      game_spec["title"] = f"Open Spiel: {short_name}"
+      game_spec["description"] = """
+Kaggle environment wrapper for OpenSpiel games.
+For game implementation details see:
+https://github.com/google-deepmind/open_spiel/tree/master/open_spiel/games
+""".strip()
+      game_spec["agents"] = [game.num_players()]
+      game_spec["configuration"]["episodeSteps"] = (
+          game.max_history_length() + DEFAULT_EPISODE_STEP_BUFFER
+      )
+      game_spec["configuration"]["openSpielGameString"]["default"] = str(game)
+      game_spec["configuration"]["openSpielGameName"]["default"] = short_name
+      game_spec["observation"]["properties"]["openSpielGameString"][
+          "default"] = str(game)
+      game_spec["observation"]["properties"]["openSpielGameName"][
+          "default"] = short_name
+
+      registered_envs[env_name] = {
+          "specification": game_spec,
+          "interpreter": interpreter,
+          "renderer": renderer,
+          "html_renderer": html_renderer,
+          "agents": agents,
+      }
+      successfully_loaded_games.append(short_name)
+
+    except Exception:  # pylint: disable=broad-exception-caught
+      skipped_games.append(short_name)
+      continue
+
+  print(f"""
+Successfully loaded OpenSpiel environments: {len(successfully_loaded_games)}.
+OpenSpiel games skipped: {len(skipped_games)}.
+""".strip())
+
+  return registered_envs
+
+
+registered_open_spiel_envs = _register_open_spiel_envs()