Add files using upload-large-folder tool

ragen/env/metamathqa/__init__.py

@@ -0,0 +1,12 @@
+"""
+MetaMathQA environment for mathematical reasoning.
+
+Dataset: MetaMathQA (https://huggingface.co/datasets/meta-math/MetaMathQA)
+Citation: Yu et al. (2023). MetaMath: Bootstrap Your Own Mathematical Questions for Large Language Models
+Paper: https://arxiv.org/abs/2309.12284
+License: MIT
+"""
+from .env import MetaMathQAEnv
+from .config import MetaMathQAEnvConfig
+
+__all__ = ["MetaMathQAEnv", "MetaMathQAEnvConfig"]

ragen/env/metamathqa/config.py

@@ -0,0 +1,10 @@
+from typing import Optional, List, Dict
+from dataclasses import dataclass, field
+
+@dataclass
+class MetaMathQAEnvConfig:
+    """Configuration for FrozenLake environment"""
+    # Map config
+    dataset_path: str = field(default="meta-math/MetaMathQA")
+    cache_dir:str = field(default="./data")
+    split: str = field(default="train")

ragen/env/metamathqa/env.py

@@ -0,0 +1,68 @@
+import gym
+from gym import spaces
+import numpy as np
+from datasets import load_dataset
+import re
+import random
+from ragen.env.base import BaseLanguageBasedEnv
+from ragen.utils import all_seed
+from .config import MetaMathQAEnvConfig
+class MetaMathQAEnv(BaseLanguageBasedEnv):
+    def __init__(self, config: MetaMathQAEnvConfig):
+        super(MetaMathQAEnv, self).__init__()
+        
+        self.config = config
+        self.dataset = load_dataset(path=self.config.dataset_path, cache_dir=self.config.cache_dir)
+        self.current_question_idx = None
+        self.current_question = None
+        self.correct_answer = None
+        self.step_num = None
+        self.render_cache = None
+        
+        
+    def _extract_answer(self, response):
+        match = re.search(r"The answer is: (.*?)$", response, re.DOTALL)
+        if match:
+            return match.group(1).strip()
+        return None
+        
+    def reset(self,seed=None, mode=None):
+        dataset = self.dataset[self.config.split]
+        with all_seed(seed):
+            self.current_question_idx = random.randint(0, len(dataset) - 1)
+        question_data = dataset[self.current_question_idx]
+        self.current_question = question_data['query']
+        self.correct_answer = self._extract_answer(question_data['response'])
+        self.step_num = 0
+        self.render_cache = self.current_question
+        return self.render_cache
+        
+    def step(self, action):
+        is_correct, is_valid = self._check_answer(action)
+        reward = 1.0 / (2 ** self.step_num) if is_correct else 0.0
+        if is_correct:
+            observation = "Correct!"
+            done = True
+        else:
+            observation = "Incorrect. Please think again."
+            done = False
+        self.step_num += 1
+        info = {"action_is_valid": is_valid, "success": is_correct}
+        self.render_cache = observation
+        return self.render_cache, reward, done, info
+    
+    def _check_answer(self, user_answer):
+        """Check if the user's answer matches the correct answer."""
+        user_answer = user_answer.strip()
+        normalized_answer = re.sub(r'\s+', '', user_answer.lower())
+        if self.correct_answer:
+            normalized_label = re.sub(r'\s+', '', self.correct_answer.lower())
+            is_correct = normalized_answer == normalized_label
+        else:
+            is_correct = False
+        is_valid = normalized_answer != ""
+        return is_correct, is_valid
+
+    def render(self):
+        return self.render_cache
+

ragen/env/rubikscube/env.py

@@ -0,0 +1,248 @@
+import gymnasium as gym
+import numpy as np
+from typing import Tuple, Any, Dict, List
+from ragen.env.base import BaseDiscreteActionEnv
+from .config import RubiksCube2x2Config
+from ragen.utils import all_seed
+
+class RubiksCube2x2Env(BaseDiscreteActionEnv, gym.Env):
+    """
+    2x2 Pocket Cube Environment for LLM-based RL.
+    State: 24 integers representing the stickers.
+    Reward: +1.0 for solved, 0.0 otherwise.
+    """
+    def __init__(self, config: RubiksCube2x2Config | None = None):
+        BaseDiscreteActionEnv.__init__(self)
+        self.config = config or RubiksCube2x2Config()
+        self.ACTION_LOOKUP = self.config.action_lookup
+        self.ACTION_SPACE = gym.spaces.discrete.Discrete(12, start=1)
+        self.render_mode = self.config.render_mode
+        self.rng = np.random.default_rng()
+        
+        # 6 faces, 4 stickers per face.
+        # Order: U(0), L(1), F(2), R(3), B(4), D(5)
+        # Colors: 0:White, 1:Orange, 2:Green, 3:Red, 4:Blue, 5:Yellow
+        self.state = np.zeros(24, dtype=int)
+        self.solved_state = np.zeros(24, dtype=int)
+        self._init_solved_state()
+        
+        self.current_step = 0
+        
+    def _init_solved_state(self):
+        # Initialize solved state: 4 of color 0, 4 of color 1, ...
+        for i in range(6):
+            self.solved_state[i*4 : (i+1)*4] = i
+
+    def reset(self, seed=None, mode=None):
+        gym.Env.reset(self, seed=seed)
+        with all_seed(seed):
+            self.rng = np.random.default_rng(seed)
+            # 重置为还原状态
+            self.state = self.solved_state.copy()
+            self.current_step = 0
+            
+            # 打乱 (Scramble)
+            # 随机执行 N 个有效动作
+            depth = self.config.scramble_depth
+            for _ in range(depth):
+                action = self.rng.integers(1, 13) # 1 to 12
+                self._apply_action(action)
+                
+        return self.render(done=False)
+
+    def step(self, action: int) -> Tuple[Any, float, bool, Dict]:
+        assert action in self.ACTION_LOOKUP, f"Invalid action: {action}"
+        info = {"action_is_effective": True, "action_is_valid": True, "success": False}
+        
+        # 执行动作
+        self._apply_action(action)
+        self.current_step += 1
+        
+        # 检查是否还原
+        is_solved = True
+        for i in range(6):
+            # 获取当前面的 4 个色块
+            face_stickers = self.state[i*4 : (i+1)*4]
+            # 如果这 4 个色块里包含不只 1 种颜色，说明没还原
+            if len(set(face_stickers)) > 1:
+                is_solved = False
+                break
+
+        truncated = self.current_step >= self.config.max_steps
+        
+        done = is_solved or truncated
+        
+        if is_solved:
+            reward = 1.0
+            info["success"] = True
+            msg = "Cube Solved!"
+        elif truncated:
+            # reward = -1.0 # 超时未解出给惩罚
+            reward = 0.0
+            info["success"] = False
+            msg = "Max steps reached."
+        else:
+            reward = 0.0
+            msg = ""
+            
+        next_obs = self.render(done=done, result_msg=msg)
+
+        return next_obs, float(reward), done, info
+
+    def _rotate_face_clockwise(self, face_idx):
+
+        base = face_idx * 4
+        s = self.state
+        tmp = s[base + 0]
+        s[base + 0] = s[base + 2]
+        s[base + 2] = s[base + 3]
+        s[base + 3] = s[base + 1]
+        s[base + 1] = tmp
+
+    def _apply_action(self, action: int):
+        if action % 2 == 0: # Even actions are primes (inverses)
+            turns = 3
+            base_act = action - 1
+        else:
+            turns = 1
+            base_act = action
+        
+        for _ in range(turns):
+            if base_act == 1: self._move_U()
+            elif base_act == 3: self._move_D()
+            elif base_act == 5: self._move_L()
+            elif base_act == 7: self._move_R()
+            elif base_act == 9: self._move_F()
+            elif base_act == 11: self._move_B()
+    
+    def _move_U(self):
+        self._rotate_face_clockwise(0)
+        s = self.state
+        t0, t1 = s[8], s[9]
+        s[8], s[9] = s[12], s[13]
+        s[12], s[13] = s[16], s[17]
+        s[16], s[17] = s[4], s[5]
+        s[4], s[5] = t0, t1
+
+    def _move_D(self):
+        self._rotate_face_clockwise(5) 
+        s = self.state
+        t0, t1 = s[10], s[11]
+        s[10], s[11] = s[6], s[7]
+        s[6], s[7] = s[18], s[19]
+        s[18], s[19] = s[14], s[15]
+        s[14], s[15] = t0, t1
+
+    def _move_L(self):
+        self._rotate_face_clockwise(1) 
+        s = self.state
+        t0, t2 = s[0], s[2]
+        s[0], s[2] = s[19], s[17]
+        s[19], s[17] = s[20], s[22]
+        s[20], s[22] = s[8], s[10]
+        s[8], s[10] = t0, t2
+
+    def _move_R(self):
+        self._rotate_face_clockwise(3) 
+        s = self.state
+        t1, t3 = s[1], s[3]
+        s[1], s[3] = s[9], s[11]
+        s[9], s[11] = s[21], s[23]
+        s[21], s[23] = s[18], s[16]
+        s[18], s[16] = t1, t3
+
+    def _move_F(self):
+        self._rotate_face_clockwise(2) 
+        s = self.state
+        t2, t3 = s[2], s[3]
+        s[2], s[3] = s[7], s[5]
+        s[7], s[5] = s[21], s[20]
+        s[21], s[20] = s[12], s[14]
+        s[12], s[14] = t2, t3
+
+    def _move_B(self):
+        self._rotate_face_clockwise(4) 
+        s = self.state
+        t0, t1 = s[0], s[1]
+        s[0], s[1] = s[13], s[15]
+        s[13], s[15] = s[22], s[23]
+        s[22], s[23] = s[6], s[4]
+        s[6], s[4] = t0, t1
+
+    def render(self, mode: str | None = None, done: bool = False, result_msg: str = "") -> str:
+        # Color Mapping
+        colors = {0: 'W', 1: 'O', 2: 'G', 3: 'R', 4: 'B', 5: 'Y'}
+        
+        def get_face_str(face_idx):
+            base = face_idx * 4
+            c = [colors[self.state[base+i]] for i in range(4)]
+            return f"[{c[0]}, {c[1]}]\n       [{c[2]}, {c[3]}]"
+
+        lines = []
+        lines.append("=== Rubik's Cube 2x2 State ===")
+        lines.append(f"Step: {self.current_step}/{self.config.max_steps}")
+        lines.append("")
+        lines.append(f"Up (U):    {get_face_str(0).strip().replace('       ', ' ')}")
+        lines.append(f"Left (L):  {get_face_str(1).strip().replace('       ', ' ')}")
+        lines.append(f"Front (F): {get_face_str(2).strip().replace('       ', ' ')}")
+        lines.append(f"Right (R): {get_face_str(3).strip().replace('       ', ' ')}")
+        lines.append(f"Back (B):  {get_face_str(4).strip().replace('       ', ' ')}")
+        lines.append(f"Down (D):  {get_face_str(5).strip().replace('       ', ' ')}")
+        
+        if not done:
+            lines.append("")
+            lines.append("Available Actions:")
+            # 列出部分动作作为提示，或者全部列出
+            lines.append("U, U', D, D', L, L', R, R', F, F', B, B'")
+            # lines.append("Format: Action <id> (e.g., Action 1 for U, Action 2 for U')")
+            lines.append("\nWhat is your next move?")
+        else:
+            lines.append("")
+            lines.append(f"=== Game Over: {result_msg} ===")
+
+        return "\n".join(lines)
+
+    def close(self):
+        pass
+
+    def get_all_actions(self):
+        return list(self.ACTION_LOOKUP.keys())
+
+if __name__ == "__main__":
+    config = RubiksCube2x2Config(scramble_depth=1, max_steps=50)
+    env = RubiksCube2x2Env(config)
+
+    print(f"Action Lookup: {env.ACTION_LOOKUP}")
+    
+    # 重置并打印初始状态
+    obs = env.reset()
+    print(obs)
+    
+    while True:
+        # 提示输入
+        keyboard = input("\nEnter action (1-12) or 'q' to quit: ")
+        if keyboard == 'q':
+            break
+        
+        try:
+            action = int(keyboard)
+        except ValueError:
+            print("Please enter a valid integer.")
+            continue
+
+        if action not in env.ACTION_LOOKUP:
+            print(f"Invalid action: {action}. Please input 1-12.")
+            continue
+            
+        # 执行动作
+        obs, reward, done, info = env.step(action)
+        
+        # 打印状态和奖励信息
+        print(obs) # 这里打印的就是 render 返回的文本 Prompt
+        print(f"Reward: {reward}, Done: {done}, Info: {info}")
+        
+        # 如果游戏结束（还原或超时），自动重置
+        if done:
+            print("\n=== Episode Ended. Resetting... ===")
+            obs = env.reset()
+            print(obs)

ragen/env/search/README.md

@@ -0,0 +1,120 @@
+# Search Environment (HotpotQA + Dense Retrieval)
+
+A multi-turn search environment for training LLM agents on multi-hop question answering. The agent interacts with a retrieval server to search Wikipedia and answer questions from HotpotQA.
+
+## Overview
+
+The agent receives a question and can take two types of actions:
+- `search[query]` — retrieve relevant Wikipedia passages via dense retrieval (E5 + FAISS)
+- `finish[answer]` — submit a final answer
+
+Reward is computed using F1 / exact match against the HotpotQA ground truth.
+
+## Components
+
+| Component | Description |
+|-----------|-------------|
+| `env.py` | Gym environment: parses actions, calls retrieval server, computes reward |
+| `config.py` | Dataclass config (`SearchEnvConfig`) |
+| `reward.py` | F1 / EM reward computation |
+| `retrieval_client.py` | HTTP client for the retrieval server |
+| `scripts/retrieval/server.py` | Flask server: E5 encoder + FAISS index over Wikipedia |
+
+## Setup
+
+### 1. Prepare data
+
+```bash
+# Download HotpotQA → data/search/{train,val}.parquet
+python scripts/prepare_search_data.py
+
+# Download Wikipedia corpus + FAISS index (~74GB) → search_data/prebuilt_indices/
+python scripts/download_search_index.py
+```
+
+### 2. Start the retrieval server
+
+The retrieval server provides dense retrieval over ~21M Wikipedia passages using E5-base-v2 embeddings and a FAISS Flat index.
+
+```bash
+python scripts/retrieval/server.py \
+    --data_dir ./search_data/prebuilt_indices \
+    --port 8000 --host 127.0.0.1 \
+    --device cuda:0 --gpu_memory_limit_mb 6144
+```
+
+Loading the 61GB FAISS index takes 2-5 minutes. Verify with:
+
+```bash
+curl http://127.0.0.1:8000/health
+```
+
+**Important: GPU deployment recommendation**
+
+We recommend running the retrieval server on a **dedicated GPU** separate from training. In our experiments, placing the E5 server on the same GPU as training (e.g., GPU 0) caused CUDA OOM errors — vLLM rollout and training both compete for GPU memory, squeezing out the retrieval server process.
+
+Run the server on a GPU not used by training (e.g., `--device cuda:7`, train on GPUs 0-6). During rollout, hundreds of environments issue concurrent retrieval requests (e.g., 256 env groups can produce 1000+ requests). Running on CPU cannot keep up with this concurrency and causes timeouts. A dedicated GPU with `threading.Lock` serialization handles this load reliably.
+
+### 3. Run training
+
+```bash
+# PPO, no filtering (baseline)
+bash scripts/runs/run_search_benchmark.sh \
+    --algos PPO \
+    --gpus 0,1,2,3,4,5,6,7 --gpus-per-exp 8
+
+# PPO, top_k filtering (keep top 25% by reward variance)
+bash scripts/runs/run_search_benchmark.sh \
+    --algos PPO --filter-strategy top_k --filter-value 0.25 \
+    --gpus 0,1,2,3,4,5,6,7 --gpus-per-exp 8
+
+# PPO, top_p filtering (keep 90% by reward variance)
+bash scripts/runs/run_search_benchmark.sh \
+    --algos PPO --filter-strategy top_p --filter-value 0.9 \
+    --gpus 0,1,2,3,4,5,6,7 --gpus-per-exp 8
+```
+
+Key training parameters (pass via `run_search_benchmark.sh` flags):
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--algos` | Algorithm: PPO or GRPO | PPO |
+| `--filter-strategy` | Rollout filter strategy: `top_p`, `top_k`, etc. | `top_p` |
+| `--filter-value` | Filter value (1.0 = no filtering) | `1.0` |
+| `--gpus` | Comma-separated GPU IDs | auto-detect |
+| `--gpus-per-exp` | GPUs per experiment | 1 |
+| `--gpu-memory-utilization` | vLLM KV cache memory fraction | 0.6 |
+| `--micro-batch` | Micro batch size per GPU | config default |
+| `--mini-batch` | PPO mini batch size | config default |
+| `--save-freq` | Checkpoint save frequency | -1 (disabled) |
+| `--steps` | Total training steps | 200 |
+| `--retrieval-port` | Retrieval server port | 8000 |
+
+## Config
+
+The search environment config is at `config/_9_search.yaml`. Key settings:
+
+```yaml
+micro_batch_size_per_gpu: 4
+ppo_mini_batch_size: 32
+
+agent_proxy:
+  max_turn: 5              # up to 5 search rounds
+  max_actions_per_turn: 1  # one action per response
+
+actor_rollout_ref:
+  rollout:
+    max_model_len: 5000
+    max_num_batched_tokens: 5000
+
+es_manager:
+  train:
+    env_groups: 16
+    group_size: 8           # 16 × 8 = 128 samples per batch
+```
+
+Note: when using `top_k` filtering with a small value (e.g., 0.25), the effective batch size after filtering is `env_groups × group_size × filter_value`. Ensure `ppo_mini_batch_size` does not exceed this value, or training will fail with an assertion error.
+
+## Acknowledgment
+
+The search environment is adapted from the [RLLM](https://github.com/rllm-org/rllm) project. We thank the RLLM authors for their open-source contributions.

ragen/env/search/__init__.py

@@ -0,0 +1,4 @@
+from .env import SearchEnv
+from .config import SearchEnvConfig
+
+__all__ = ["SearchEnv", "SearchEnvConfig"]

ragen/env/search/config.py

@@ -0,0 +1,38 @@
+"""
+Configuration for the Search (HotpotQA) environment.
+
+The search environment is adapted from the RLLM project:
+  https://github.com/rllm-org/rllm
+  License: Apache-2.0
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchEnvConfig:
+    """Configuration for SearchEnv.
+
+    Fields under env_config in config/envs.yaml map directly to these fields.
+    """
+
+    # --- Data ---
+    dataset_name: str = "hotpotqa"
+    train_path: str = "data/search/train.parquet"
+    max_instances: int = 20000
+
+    # --- Retrieval server ---
+    retrieval_server_url: str = "http://127.0.0.1:8000"
+    retrieval_timeout: float = 30.0
+    max_search_results: int = 5
+    max_total_chars: int = 4000  # total char limit for all docs combined (~1k tokens)
+
+    # --- Environment ---
+    max_steps: int = 10       # max search rounds before forced termination
+    render_mode: str = "text"
+    mock_mode: bool = False   # True = use MockRetrievalClient (no server needed)
+
+    # --- Reward ---
+    correct_reward: float = 1.0
+    incorrect_reward: float = 0.0
+    f1_threshold: float = 0.3

ragen/env/search/env.py

@@ -0,0 +1,253 @@
+"""
+Search environment for HotpotQA-style multi-hop question answering.
+
+This code is adapted from the RLLM project:
+  https://github.com/rllm-org/rllm
+  Original source: rllm/examples/search/ (ToolEnvironment + search example)
+  License: Apache-2.0
+
+Architecture follows RAGEN's WebShop pattern:
+- Inherits BaseLanguageBasedEnv + gym.Env
+- Actions are text strings: search[query] / finish[answer]
+- Multi-turn: agent can search multiple times before answering
+- Requires a running retrieval server (or mock_mode for testing)
+"""
+
+import logging
+import re
+from typing import Any, Dict, Optional, Tuple
+
+import gymnasium as gym
+import datasets
+
+from ragen.env.base import BaseLanguageBasedEnv
+from .config import SearchEnvConfig
+from .reward import SearchRewardFn
+from .retrieval_client import RetrievalClient, MockRetrievalClient
+
+logger = logging.getLogger(__name__)
+
+
+class SearchEnv(BaseLanguageBasedEnv, gym.Env):
+    """
+    Search-based QA environment.
+
+    The agent receives a question and can:
+    - search[query]: search for information via the retrieval server
+    - finish[answer]: submit a final answer and receive a reward
+
+    Reward is computed using F1/EM against the ground truth (HotpotQA standard).
+    """
+
+    def __init__(self, config: Optional[SearchEnvConfig] = None):
+        BaseLanguageBasedEnv.__init__(self)
+        self.config = config if config is not None else SearchEnvConfig()
+
+        # Reward function
+        self.reward_fn = SearchRewardFn(
+            correct_reward=self.config.correct_reward,
+            incorrect_reward=self.config.incorrect_reward,
+            f1_threshold=self.config.f1_threshold,
+        )
+
+        # Retrieval client
+        if self.config.mock_mode:
+            self.client = MockRetrievalClient()
+        else:
+            self.client = RetrievalClient(
+                server_url=self.config.retrieval_server_url,
+                timeout=self.config.retrieval_timeout,
+                max_results=self.config.max_search_results,
+                max_total_chars=self.config.max_total_chars,
+            )
+
+        # Load dataset
+        self.data = self._load_data()
+
+        # Per-episode state
+        self.index = None
+        self.ground_truth = None
+        self.question = None
+        self.step_count = 0
+        self.render_cache = None
+
+    def _load_data(self):
+        """Load HotpotQA data from parquet file."""
+        try:
+            df = datasets.load_dataset(
+                "parquet",
+                data_files=self.config.train_path,
+            )["train"]
+            if self.config.max_instances and len(df) > self.config.max_instances:
+                df = df.select(range(self.config.max_instances))
+            logger.info(f"Loaded {len(df)} search questions from {self.config.train_path}")
+            return df
+        except Exception as e:
+            logger.error(f"Failed to load data from {self.config.train_path}: {e}")
+            raise
+
+    def reset(self, seed: Optional[int] = None, mode: Optional[str] = None) -> str:
+        """
+        Reset the environment with a new question.
+
+        Args:
+            seed: Deterministic seed for question selection.
+            mode: Unused, kept for interface compatibility.
+
+        Returns:
+            Initial observation string containing the question.
+        """
+        gym.Env.reset(self, seed=seed)
+
+        # Deterministic question selection (same pattern as CountdownEnv)
+        self.index = seed % len(self.data) if seed is not None else 0
+        item = self.data[self.index]
+
+        self.question = item["question"]
+        self.ground_truth = item["ground_truth"]
+        self.step_count = 0
+
+        # Build initial observation (question only, no ground_truth exposed)
+        self.render_cache = (
+            f"Question: {self.question}\n"
+            f"Available actions: search[<query>], finish[<answer>]"
+        )
+        return self.render()
+
+    def step(self, action: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        """
+        Execute one step in the environment.
+
+        Args:
+            action: One of:
+                - "search[query text]" — perform a retrieval search
+                - "finish[answer text]" — submit final answer
+                - anything else — treated as a direct answer (fallback)
+
+        Returns:
+            (observation, reward, done, info)
+        """
+        self.step_count += 1
+        action = action.strip() if action else ""
+
+        # --- Parse action ---
+        if action.startswith("search[") and action.endswith("]"):
+            return self._handle_search(action[7:-1])
+        elif action.startswith("finish[") and action.endswith("]"):
+            return self._handle_finish(action[7:-1])
+        else:
+            # Fallback: treat as a direct answer attempt
+            return self._handle_fallback(action)
+
+    def _handle_search(self, query: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        """Handle a search[query] action."""
+        results = self.client.search(query, top_k=self.config.max_search_results)
+
+        # Check if max steps reached
+        done = self.step_count >= self.config.max_steps
+        reward = 0.0
+
+        if done:
+            # Forced termination — no answer provided
+            self.render_cache = (
+                f"Search results for '{query}':\n{results}\n\n"
+                f"Maximum search steps reached. Episode ended without an answer."
+            )
+        else:
+            self.render_cache = (
+                f"Search results for '{query}':\n{results}\n\n"
+                f"Available actions: search[<query>], finish[<answer>]"
+            )
+
+        info = {
+            "action_is_effective": True,
+            "action_is_valid": True,
+            "success": False,
+            "action_type": "search",
+            "query": query,
+        }
+        return self.render(), reward, done, info
+
+    def _handle_finish(self, answer: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        """Handle a finish[answer] action."""
+        reward, metadata = self.compute_reward(answer, self.ground_truth)
+        done = True
+
+        self.render_cache = f"Your answer: {answer}. Reward: {reward:.2f}"
+
+        info = {
+            "action_is_effective": True,
+            "action_is_valid": True,
+            "success": metadata.get("exact_match", False) or reward > 0,
+            "action_type": "finish",
+            "answer": answer,
+            "reward_metadata": metadata,
+        }
+        return self.render(), reward, done, info
+
+    def _handle_fallback(self, action: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        """Handle unrecognized action format — try to extract an answer from it."""
+        if not action:
+            # Empty action — invalid
+            done = self.step_count >= self.config.max_steps
+            self.render_cache = (
+                "Invalid action. Use search[<query>] to search or finish[<answer>] to answer.\n"
+                "Available actions: search[<query>], finish[<answer>]"
+            )
+            return self.render(), 0.0, done, {
+                "action_is_effective": False,
+                "action_is_valid": False,
+                "success": False,
+                "action_type": "invalid",
+            }
+
+        # Try to extract an answer from free-form text
+        extracted = self.reward_fn.extract_answer_from_response(action)
+        reward, metadata = self.compute_reward(extracted, self.ground_truth)
+        done = True
+
+        self.render_cache = f"Your answer (extracted): {extracted}. Reward: {reward:.2f}"
+
+        info = {
+            "action_is_effective": True,
+            "action_is_valid": False,  # not in correct format
+            "success": metadata.get("exact_match", False) or reward > 0,
+            "action_type": "fallback",
+            "raw_action": action,
+            "extracted_answer": extracted,
+            "reward_metadata": metadata,
+        }
+        return self.render(), reward, done, info
+
+    def compute_reward(self, answer: str, ground_truth) -> Tuple[float, dict]:
+        """Compute reward using F1/EM evaluation."""
+        return self.reward_fn.compute_reward(answer, ground_truth)
+
+    def render(self, mode: Optional[str] = None) -> str:
+        """Return cached render output."""
+        return self.render_cache
+
+    def close(self):
+        """Clean up resources."""
+        pass
+
+
+if __name__ == "__main__":
+    # Quick smoke test with mock mode
+    config = SearchEnvConfig(
+        train_path="data/search/train.parquet",
+        mock_mode=True,
+        max_steps=5,
+    )
+    try:
+        env = SearchEnv(config)
+        obs = env.reset(seed=42)
+        print(f"=== Reset ===\n{obs}\n")
+
+        obs, reward, done, info = env.step("search[test query]")
+        print(f"=== Search ===\n{obs}\nReward: {reward}, Done: {done}\n")
+
+        obs, reward, done, info = env.step("finish[test answer]")
+        print(f"=== Finish ===\n{obs}\nReward: {reward}, Done: {done}, Info: {info}\n")
+    except Exception as e:
+        print(f"Smoke test failed (expected if no data): {e}")

ragen/env/search/retrieval_client.py

@@ -0,0 +1,166 @@
+"""
+Retrieval client for connecting to the dense retrieval server.
+
+This code is adapted from the RLLM project:
+  https://github.com/rllm-org/rllm
+  Original source: rllm/examples/search/local_retrieval_tool.py
+  License: Apache-2.0
+
+The retrieval server (scripts/retrieval/server.py) must be running before use.
+Uses `requests` instead of rllm's `httpx` to minimize new dependencies.
+"""
+
+import logging
+import os
+from typing import Any, List, Optional
+
+logger = logging.getLogger(__name__)
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+
+class RetrievalClient:
+    """
+    HTTP client for the dense retrieval server (E5 + FAISS).
+
+    Connects to the Flask server at scripts/retrieval/server.py.
+    Designed to be fault-tolerant: logs warnings instead of crashing
+    when the server is unavailable.
+    """
+
+    def __init__(
+        self,
+        server_url: Optional[str] = None,
+        timeout: float = 30.0,
+        max_results: int = 10,
+        max_total_chars: int = 4000,
+    ):
+        if not HAS_REQUESTS:
+            logger.warning("requests package not installed. RetrievalClient will not work.")
+
+        if server_url is None:
+            server_url = os.environ.get("RETRIEVAL_SERVER_URL", "http://127.0.0.1:8000")
+
+        self.server_url = server_url.rstrip("/")
+        self.timeout = timeout
+        self.max_results = max_results
+        self.max_total_chars = max_total_chars
+        self.available = False
+
+        self._test_connection()
+
+    def _test_connection(self) -> bool:
+        """Test connection to the retrieval server. Warning only, never crashes."""
+        if not HAS_REQUESTS:
+            return False
+        try:
+            response = requests.get(f"{self.server_url}/health", timeout=5)
+            if response.status_code == 200:
+                logger.info(f"Connected to retrieval server at {self.server_url}")
+                self.available = True
+                return True
+            else:
+                logger.warning(f"Retrieval server returned status {response.status_code}")
+                return False
+        except Exception as e:
+            logger.warning(f"Could not connect to retrieval server at {self.server_url}: {e}")
+            return False
+
+    def search(self, query: str, top_k: Optional[int] = None) -> str:
+        """
+        Execute a search query against the retrieval server.
+
+        Args:
+            query: The search query string.
+            top_k: Number of results to return (default: self.max_results).
+
+        Returns:
+            Formatted search results as a string, or an error message.
+        """
+        if not HAS_REQUESTS:
+            return "Search service unavailable: requests package not installed."
+
+        top_k = top_k or self.max_results
+
+        try:
+            payload = {
+                "query": query,
+                "top_k": min(top_k, 50),
+            }
+
+            response = requests.post(
+                f"{self.server_url}/retrieve",
+                json=payload,
+                timeout=self.timeout,
+            )
+
+            if not response.ok:
+                error_msg = f"Retrieval server error (status {response.status_code})"
+                try:
+                    error_data = response.json()
+                    error_msg += f": {error_data.get('error', 'Unknown error')}"
+                except Exception:
+                    pass
+                return error_msg
+
+            response_data = response.json()
+            results = response_data.get("results", [])
+
+            if not results:
+                return "No relevant documents found for the query."
+
+            return self._format_results(results)
+
+        except requests.exceptions.Timeout:
+            return f"Search request timed out after {self.timeout} seconds."
+        except requests.exceptions.ConnectionError:
+            return f"Could not connect to retrieval server at {self.server_url}. Is it running?"
+        except Exception as e:
+            return f"Search error: {str(e)}"
+
+    def _format_results(self, results: List[dict]) -> str:
+        """Format search results for LLM consumption. Truncates long documents."""
+        formatted = []
+        for i, result in enumerate(results[:self.max_results], 1):
+            doc_id = result.get("id", f"doc_{i}")
+            content = result.get("content", "")
+            score = result.get("score", 0.0)
+
+            # Truncate content to 300 chars (same as rllm)
+            if len(content) > 800:
+                content = content[:800] + "..."
+
+            formatted.append(f"[Document {i}] (ID: {doc_id}, Score: {score:.3f})\n{content}")
+
+        output = "\n\n".join(formatted)
+
+        # Cap total output to max_total_chars (~1k tokens) to prevent context overflow
+        if len(output) > self.max_total_chars:
+            output = output[:self.max_total_chars] + "..."
+
+        return output
+
+
+class MockRetrievalClient:
+    """
+    Mock retrieval client for development/testing without a running server.
+    Returns placeholder results so the environment can be tested end-to-end.
+    """
+
+    def __init__(self, **kwargs):
+        self.available = True
+        logger.info("Using MockRetrievalClient (no real retrieval server)")
+
+    def search(self, query: str, top_k: Optional[int] = None) -> str:
+        return (
+            f"[Document 1] (ID: mock_1, Score: 0.900)\n"
+            f"Mock search result for query: '{query}'. "
+            f"This is a placeholder document for testing purposes.\n\n"
+            f"[Document 2] (ID: mock_2, Score: 0.750)\n"
+            f"Another mock document related to: '{query}'. "
+            f"Replace with real retrieval server for actual training."
+        )

ragen/env/search/reward.py

@@ -0,0 +1,199 @@
+"""
+Search reward function for HotpotQA-style question answering.
+
+This code is adapted from the RLLM project:
+  https://github.com/rllm-org/rllm
+  Original source: rllm/rewards/search_reward.py
+  License: Apache-2.0
+
+RLLM-specific dependencies have been removed.
+
+Evaluation uses:
+- Exact Match (EM): normalized string comparison
+- F1 Score: token-level precision/recall
+
+Reference: HotpotQA / SQuAD evaluation standards.
+"""
+
+import re
+import string
+from collections import Counter
+from typing import Any, List, Tuple, Union
+
+
+class SearchRewardFn:
+    """Reward function for search-based QA tasks using F1 and Exact Match."""
+
+    def __init__(self, correct_reward: float = 1.0, incorrect_reward: float = 0.0, f1_threshold: float = 0.3):
+        self.correct_reward = correct_reward
+        self.incorrect_reward = incorrect_reward
+        self.f1_threshold = f1_threshold
+
+    def normalize_answer(self, s: str) -> str:
+        """Normalize answer text for evaluation (following HotpotQA/SQuAD standards)."""
+
+        def remove_articles(text):
+            return re.sub(r"\b(a|an|the)\b", " ", text)
+
+        def white_space_fix(text):
+            return " ".join(text.split())
+
+        def remove_punc(text):
+            exclude = set(string.punctuation)
+            return "".join(ch for ch in text if ch not in exclude)
+
+        def lower(text):
+            return text.lower()
+
+        return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+    def f1_score(self, prediction: str, ground_truth: str) -> Tuple[float, float, float]:
+        """Calculate token-level F1 score between prediction and ground truth."""
+        normalized_prediction = self.normalize_answer(prediction)
+        normalized_ground_truth = self.normalize_answer(ground_truth)
+
+        ZERO_METRIC = (0.0, 0.0, 0.0)
+
+        if normalized_prediction in ["yes", "no", "noanswer"] and normalized_prediction != normalized_ground_truth:
+            return ZERO_METRIC
+        if normalized_ground_truth in ["yes", "no", "noanswer"] and normalized_prediction != normalized_ground_truth:
+            return ZERO_METRIC
+
+        prediction_tokens = normalized_prediction.split()
+        ground_truth_tokens = normalized_ground_truth.split()
+        common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
+        num_same = sum(common.values())
+        if num_same == 0:
+            return ZERO_METRIC
+        precision = 1.0 * num_same / len(prediction_tokens)
+        recall = 1.0 * num_same / len(ground_truth_tokens)
+        f1 = (2 * precision * recall) / (precision + recall)
+        return f1, precision, recall
+
+    def exact_match_score(self, prediction: str, ground_truth: str) -> bool:
+        """Calculate exact match score after normalization."""
+        return self.normalize_answer(prediction) == self.normalize_answer(ground_truth)
+
+    def extract_answer_from_response(self, response: str) -> str:
+        """
+        Fallback: extract answer from free-form LLM response text.
+        Used when the agent doesn't follow the finish[...] format.
+        Migrated from rllm's RewardSearchFn.extract_answer_from_response().
+        """
+        response = response.strip()
+
+        # Remove thinking tags
+        response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL)
+        response = re.sub(r"\s+", " ", response).strip()
+
+        if not response:
+            return ""
+
+        # 1. Look for \boxed{} content (rllm format)
+        boxed_match = re.search(r"\\boxed\{([^}]+)\}", response)
+        if boxed_match:
+            return boxed_match.group(1).strip()
+
+        # 2. Bold text
+        bold_patterns = [r"\*\*([^*]+)\*\*", r"\*([^*]+)\*"]
+        for pattern in bold_patterns:
+            matches = re.findall(pattern, response)
+            substantive = [m.strip() for m in matches if len(m.strip()) > 2 and not re.match(r"^[^\w]*$", m.strip())]
+            if substantive:
+                return substantive[0]
+
+        # 3. Direct answer patterns
+        answer_patterns = [
+            r"(?:the\s+)?(?:correct\s+)?answer\s+is\s*:?\s*([^.!?]+)",
+            r"(?:therefore|thus|so|hence)\s*,?\s*([^.!?]+)",
+        ]
+        for pattern in answer_patterns:
+            match = re.search(pattern, response, re.IGNORECASE)
+            if match:
+                answer = match.group(1).strip()
+                answer = re.sub(r"^\W+|\W+$", "", answer)
+                if len(answer) > 3:
+                    return answer
+
+        # 4. Fallback: first substantial sentence
+        sentences = [s.strip() for s in re.split(r"[.!?]+", response) if len(s.strip()) > 5]
+        if sentences:
+            return sentences[0]
+
+        return response[:100].strip()
+
+    def evaluate_answer(self, model_answer: str, ground_truth: Union[str, List[str]]) -> Tuple[bool, float, dict]:
+        """
+        Evaluate model answer against ground truth(s).
+
+        Returns:
+            (is_correct, max_f1, metadata_dict)
+        """
+        if isinstance(ground_truth, str):
+            ground_truths = [ground_truth]
+        else:
+            ground_truths = ground_truth
+
+        max_f1 = 0.0
+        max_em = False
+        best_match = ""
+        best_precision = 0.0
+        best_recall = 0.0
+        eval_method = None
+
+        for gt in ground_truths:
+            gt_str = str(gt).strip()
+
+            em = self.exact_match_score(model_answer, gt_str)
+            if em:
+                max_em = True
+                max_f1 = 1.0
+                best_match = gt_str
+                best_precision = 1.0
+                best_recall = 1.0
+                eval_method = "exact_match"
+                break
+
+            f1, precision, recall = self.f1_score(model_answer, gt_str)
+            if f1 > max_f1:
+                max_f1 = f1
+                best_match = gt_str
+                best_precision = precision
+                best_recall = recall
+                eval_method = "f1_score"
+
+        is_correct = max_em or max_f1 >= self.f1_threshold
+
+        metadata = {
+            "extracted_answer": model_answer,
+            "ground_truths": ground_truths,
+            "best_match": best_match,
+            "f1_score": max_f1,
+            "precision": best_precision,
+            "recall": best_recall,
+            "exact_match": max_em,
+            "evaluation_method": eval_method,
+            "f1_threshold": self.f1_threshold,
+        }
+
+        return is_correct, max_f1, metadata
+
+    def compute_reward(self, model_answer: str, ground_truth: Union[str, List[str]]) -> Tuple[float, dict]:
+        """
+        Compute reward for a model answer.
+
+        Returns:
+            (reward_float, metadata_dict)
+        """
+        is_correct, f1, metadata = self.evaluate_answer(model_answer, ground_truth)
+
+        if is_correct:
+            if metadata.get("exact_match", False):
+                reward = self.correct_reward
+            else:
+                reward = self.correct_reward * f1
+        else:
+            reward = self.incorrect_reward
+
+        metadata["reward"] = reward
+        return reward, metadata

ragen/env/sokoban/__init__.py

@@ -0,0 +1,14 @@
+"""
+Sokoban grid puzzle environment for multi-turn planning with irreversible dynamics.
+
+Original Source: gym-sokoban (https://github.com/mpSchrader/gym-sokoban)
+Citation: Schrader, M. P. B. (2018). gym_sokoban
+License: MIT
+
+Modifications: Added text-based observation format and custom reward shaping
+for LLM agent reinforcement learning.
+"""
+from .env import SokobanEnv
+from .config import SokobanEnvConfig
+
+__all__ = ["SokobanEnv", "SokobanEnvConfig"]

ragen/env/sokoban/config.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+from typing import Tuple, Optional, Dict
+
+@dataclass
+class SokobanEnvConfig:
+    dim_room: Tuple[int, int] = (6, 6)
+    max_steps: int = 100
+    num_boxes: int = 3
+    search_depth: int = 300
+    grid_lookup: Optional[Dict[int, str]] = field(default_factory=lambda: {0:"#", 1:"_", 2:"O", 3:"√", 4:"X", 5:"P", 6:"S"})
+    grid_vocab: Optional[Dict[str, str]] = field(default_factory=lambda: {"#": "wall", "_": "empty", "O": "target", "√": "box on target", "X": "box", "P": "player", "S": "player on target"})
+    action_lookup: Optional[Dict[int, str]] = field(default_factory=lambda: {1:"Up", 2:"Down", 3:"Left", 4:"Right"})
+    dim_x: Optional[int] = None
+    dim_y: Optional[int] = None
+    render_mode: str = "text"
+    observation_format: str = "grid"
+
+    def __post_init__(self):
+        if self.dim_x is not None and self.dim_y is not None:
+            self.dim_room = (self.dim_x, self.dim_y)
+            delattr(self, 'dim_x')
+            delattr(self, 'dim_y')
+        if self.observation_format not in {"grid", "coord", "grid_coord"}:
+            raise ValueError(f"Unsupported observation_format: {self.observation_format}")

ragen/env/sokoban/env.py

@@ -0,0 +1,104 @@
+import gym
+from gym_sokoban.envs.sokoban_env import SokobanEnv as GymSokobanEnv
+import numpy as np
+from .utils import (
+    generate_room,
+    collect_entity_coordinates,
+    format_coordinate_render,
+)
+# from gym_sokoban.envs.sokoban_env.utils import generate_room
+from ragen.env.base import BaseDiscreteActionEnv
+from ragen.env.sokoban.config import SokobanEnvConfig
+from ragen.utils import all_seed
+
+class SokobanEnv(BaseDiscreteActionEnv, GymSokobanEnv):
+    def __init__(self, config=None, **kwargs):
+        self.config = config or SokobanEnvConfig()
+        self.GRID_LOOKUP = self.config.grid_lookup
+        self.ACTION_LOOKUP = self.config.action_lookup
+        self.search_depth = self.config.search_depth
+        self.ACTION_SPACE = gym.spaces.discrete.Discrete(4, start=1)
+        self.render_mode = self.config.render_mode
+        self.observation_format = self.config.observation_format
+
+        BaseDiscreteActionEnv.__init__(self)
+        GymSokobanEnv.__init__(
+            self,
+            dim_room=self.config.dim_room, 
+            max_steps=self.config.max_steps,
+            num_boxes=self.config.num_boxes,
+            **kwargs
+        )
+
+    def reset(self, seed=None, mode=None):
+        try:
+            with all_seed(seed):
+                self.room_fixed, self.room_state, self.box_mapping, action_sequence = generate_room(
+                    dim=self.dim_room,
+                    num_steps=self.num_gen_steps,
+                    num_boxes=self.num_boxes,
+                    search_depth=self.search_depth
+                )
+            self.num_env_steps, self.reward_last, self.boxes_on_target = 0, 0, 0
+            self.player_position = np.argwhere(self.room_state == 5)[0]
+            return self.render()
+        except (RuntimeError, RuntimeWarning) as e:
+            next_seed = abs(hash(str(seed))) % (2 ** 32) if seed is not None else None
+            return self.reset(next_seed)
+        
+    def step(self, action: int):
+        previous_pos = self.player_position
+        _, reward, done, _ = GymSokobanEnv.step(self, action) 
+        next_obs = self.render()
+        action_effective = not np.array_equal(previous_pos, self.player_position)
+        info = {"action_is_effective": action_effective, "action_is_valid": True, "success": self.boxes_on_target == self.num_boxes}
+        return next_obs, reward, done, info
+
+    def render(self, mode=None):
+        if mode in {'grid', 'coord', 'grid_coord'}:
+            return self._render_text(mode)
+
+        render_mode = mode if mode is not None else self.render_mode
+        if render_mode == 'text':
+            return self._render_text(self.observation_format)
+        if render_mode == 'rgb_array':
+            return self.get_image(mode='rgb_array', scale=1)
+        raise ValueError(f"Invalid mode: {render_mode}")
+
+    def _render_text(self, observation_format: str) -> str:
+        if observation_format == 'grid':
+            room = np.where((self.room_state == 5) & (self.room_fixed == 2), 6, self.room_state)
+            return '\n'.join(''.join(self.GRID_LOOKUP.get(cell, "?") for cell in row) for row in room.tolist())
+        if observation_format == 'coord':
+            entity_coords = collect_entity_coordinates(self.room_state, self.room_fixed)
+            return format_coordinate_render(entity_coords, self.dim_room)
+        if observation_format == 'grid_coord':
+            entity_coords = collect_entity_coordinates(self.room_state, self.room_fixed)
+            return "Coordinates: \n" + format_coordinate_render(entity_coords, self.dim_room) + "\n" + "Grid Map: \n" + self._render_text('grid')
+        raise ValueError(f"Invalid observation_format: {observation_format}")
+    
+    def get_all_actions(self):
+        return list([k for k in self.ACTION_LOOKUP.keys()])
+    
+    def close(self):
+        self.render_cache = None
+        super(SokobanEnv, self).close()
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    config = SokobanEnvConfig(dim_room=(6, 6), num_boxes=1, max_steps=100, search_depth=10)
+    env = SokobanEnv(config)
+    for i in range(10):
+        print(env.reset(seed=1010 + i))
+        print()
+    while True:
+        keyboard = input("Enter action: ")
+        if keyboard == 'q':
+            break
+        action = int(keyboard)
+        assert action in env.ACTION_LOOKUP, f"Invalid action: {action}"
+        obs, reward, done, info = env.step(action)
+        print(obs, reward, done, info)
+    np_img = env.get_image('rgb_array')
+    # save the image
+    plt.imsave('sokoban1.png', np_img)

ragen/env/sokoban/utils.py

@@ -0,0 +1,655 @@
+# these code are adapted from the gym_sokoban repo at https://github.com/mpSchrader/gym-sokoban
+import random
+import numpy as np
+import marshal
+import copy
+from collections import deque
+from typing import Dict, List, Tuple
+
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+
+
+CoordDict = Dict[str, List[Tuple[int, int]]]
+
+
+def _to_tuple_list(array: np.ndarray, index_origin: int = 0) -> List[Tuple[int, int]]:
+    if array.size == 0:
+        return []
+    return [(int(r) + index_origin, int(c) + index_origin) for r, c in array]
+
+
+def collect_entity_coordinates(room_state: np.ndarray, room_fixed: np.ndarray, index_origin: int = 0) -> CoordDict:
+    """Collect coordinates for key Sokoban entities using the given origin."""
+
+    coords: CoordDict = {
+        # "walls": _to_tuple_list(np.argwhere(room_fixed == 0), index_origin), # do not render wall since it's too heavy
+        "targets": _to_tuple_list(np.argwhere(room_fixed == 2), index_origin),
+        "boxes_on_target": _to_tuple_list(np.argwhere(room_state == 3), index_origin),
+        "boxes": _to_tuple_list(np.argwhere(room_state == 4), index_origin),
+    }
+
+    player_positions = np.argwhere(room_state == 5)
+    player_on_target = []
+    player_regular = []
+    for pos in player_positions:
+        r, c = int(pos[0]), int(pos[1])
+        if room_fixed[r, c] == 2:
+            player_on_target.append((r + index_origin, c + index_origin))
+        else:
+            player_regular.append((r + index_origin, c + index_origin))
+
+    coords["player"] = player_regular
+    coords["player_on_target"] = player_on_target
+    return coords
+
+
+def format_coordinate_render(entity_coords: CoordDict, board_shape: Tuple[int, int], index_origin: int = 0) -> str:
+    """Format Sokoban entities as a coordinate-based description."""
+
+    rows, cols = board_shape
+    origin_str = "zero-indexed" if index_origin == 0 else f"origin at {index_origin}"
+    lines = [f"Board size: {rows} rows x {cols} cols ({origin_str})."]
+    ordered_labels = [
+        ("walls", "Walls"),
+        ("targets", "Targets"),
+        ("boxes", "Boxes"),
+        ("boxes_on_target", "Boxes on target"),
+        ("player", "Player"),
+        ("player_on_target", "Player on target"),
+    ]
+
+    for key, label in ordered_labels:
+        coords = entity_coords.get(key, [])
+        if not coords:
+            continue
+        coord_str = ", ".join(f"({r}, {c})" for r, c in coords)
+        lines.append(f"{label}: {coord_str}")
+
+    return "\n".join(lines)
+
+def get_shortest_action_path(room_fixed, room_state, MAX_DEPTH=100):
+        """
+        Get the shortest action path to push all boxes to the target spots.
+        Use BFS to find the shortest path.
+        NOTE currently only support one player, only one shortest solution
+        =========================================================
+        Parameters:
+            room_state (np.ndarray): the state of the room
+                - 0: wall
+                - 1: empty space
+                - 2: box target
+                - 3: box on target
+                - 4: box not on target
+                - 5: player
+            room_fixed (np.ndarray): the fixed part of the room
+                - 0: wall
+                - 1: empty space
+                - 2: box target
+            MAX_DEPTH (int): the maximum depth of the search
+        =========================================================
+        Returns:
+            action_sequence (list): the action sequence to push all boxes to the target spots
+        """
+        
+        # BFS queue stores (room_state, path)
+        queue = deque([(copy.deepcopy(room_state), [])])
+        explored_states = set()
+        
+        # Possible moves: up, down, left, right
+        moves = [(-1,0), (1,0), (0,-1), (0,1)]
+        actions = [1, 2, 3, 4] # Corresponding action numbers
+        
+        while queue:
+            room_state, path = queue.popleft()
+            if len(path) > MAX_DEPTH:
+                return [] # No solution found
+
+            # reduce the search space by checking if the state has been explored
+            state_tohash = marshal.dumps(room_state)
+            if state_tohash in explored_states:
+                continue
+            explored_states.add(state_tohash)
+            
+
+            # get information of the room
+            player_pos = tuple(np.argwhere(room_state == 5)[0])
+            boxes_on_target = set(map(tuple, np.argwhere((room_state == 3))))
+            boxes_not_on_target = set(map(tuple, np.argwhere((room_state == 4))))
+            boxes = boxes_on_target | boxes_not_on_target
+
+
+            # Check if all boxes are on targets
+            if not boxes_not_on_target:
+                return path
+                
+            # Try each direction
+            for move, action in zip(moves, actions):
+                new_room_state = copy.deepcopy(room_state)
+                new_player_pos = (player_pos[0] + move[0], player_pos[1] + move[1])
+                
+                # Check is new player position is wall or out of bound
+                if new_player_pos[0] < 0 or new_player_pos[0] >= room_fixed.shape[0] \
+                    or new_player_pos[1] < 0 or new_player_pos[1] >= room_fixed.shape[1] \
+                    or room_fixed[new_player_pos] == 0:
+                    continue
+                    
+                # If there's a box, check if we can push it
+                if new_player_pos in boxes:
+                    box_pos = new_player_pos # the original box position
+                    new_box_pos = (new_player_pos[0] + move[0], new_player_pos[1] + move[1])
+                    
+                    # Can't push if hitting wall or another box or out of bound
+                    if room_fixed[new_box_pos] == 0 or new_box_pos in boxes \
+                        or new_box_pos[0] < 0 or new_box_pos[0] >= room_fixed.shape[0] \
+                        or new_box_pos[1] < 0 or new_box_pos[1] >= room_fixed.shape[1]:
+                        continue
+                        
+                    # move the box
+                    
+                    new_room_state[box_pos] = room_fixed[box_pos]
+                    if room_fixed[new_box_pos] == 2:
+                        new_room_state[new_box_pos] = 3
+                    else:
+                        new_room_state[new_box_pos] = 4
+                
+                # player moves
+                new_room_state[player_pos] = room_fixed[player_pos]
+                new_room_state[new_player_pos] = 5
+                queue.append((new_room_state, path + [action]))
+                        
+        return [] # No solution found
+
+# def plot_animation(imgs):
+#     fig, ax = plt.subplots()
+#     im = ax.imshow(imgs[0])
+#     def init():
+#         im.set_data(imgs[0])
+#         return [im]
+#     def update(i):
+#         im.set_data(imgs[i])
+#         return [im]
+#     ani = animation.FuncAnimation(fig, update, frames=len(imgs), init_func=init, blit=True)
+#     return ani
+
+def plot_animation(imgs):
+    height, width = imgs[0].shape[:2]
+    fig = plt.figure(figsize=(width/100, height/100), dpi=500)
+    
+    ax = fig.add_axes([0, 0, 1, 1])
+    
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_frame_on(False)
+    
+    im = ax.imshow(imgs[0])
+    def init():
+        im.set_data(imgs[0])
+        return [im]
+    def update(i):
+        im.set_data(imgs[i])
+        return [im]
+    ani = animation.FuncAnimation(fig, update, frames=len(imgs), init_func=init, blit=True)
+    return ani
+
+def solve_sokoban(env, saved_animation_path):
+    """
+    Solve the given sokoban environment and save the animation
+    """
+    actions = get_shortest_action_path(env.room_fixed, env.room_state)
+    print(f"Found {len(actions)} actions: {actions}")
+    imgs = []
+    img_before_action = env.render('rgb_array')
+    imgs.append(img_before_action)
+    for action in actions:
+        env.step(action)
+        img_after_action = env.render('rgb_array')
+        imgs.append(img_after_action)
+    ani = plot_animation(imgs)
+    ani.save(saved_animation_path)
+
+
+def add_random_player_movement(room_state, room_structure, move_probability=0.5, continue_probability=0.5, max_steps=3):
+    """
+    Randomly move the player after reverse_playing to make the level more challenging, also fix the problem that in generated map, the player is always adjacent to the box
+    
+    Parameters:
+        room_state (np.ndarray): Current state of the room
+        room_structure (np.ndarray): Fixed structure of the room
+        move_probability (float): Probability of moving the player at all (0.0-1.0)
+        continue_probability (float): Probability of continuing to move after each step (0.0-1.0)
+        max_steps (int): Maximum number of steps the player can move (1-3)
+    
+    Returns:
+        np.ndarray: Updated room state with randomly moved player
+    """
+    # Check if we should move the player at all
+    if random.random() > move_probability:
+        return room_state
+    
+    # Find player position
+    player_pos = np.where(room_state == 5)
+    player_pos = np.array([player_pos[0][0], player_pos[1][0]])
+    
+    # Keep track of previous positions to avoid moving back
+    previous_positions = [tuple(player_pos)]
+    
+    # Make 1-3 random moves
+    steps_taken = 0
+    while steps_taken < max_steps:
+        # Get all valid moves (can't move into walls or boxes)
+        valid_moves = []
+        for action in range(4):  # 0: up, 1: down, 2: left, 3: right
+            change = CHANGE_COORDINATES[action]
+            next_pos = player_pos + change
+            
+            # Check if next position is valid (empty space or target) and not a previous position
+            if (room_state[next_pos[0], next_pos[1]] in [1, 2] and 
+                tuple(next_pos) not in previous_positions):
+                valid_moves.append((action, next_pos))
+        
+        # If no valid moves, break
+        if not valid_moves:
+            break
+        
+        # Choose a random valid move
+        chosen_action, next_pos = random.choice(valid_moves)
+        # print(f"player_pos: {player_pos}, next_pos: {next_pos}")
+        
+        # Move player
+        room_state[player_pos[0], player_pos[1]] = room_structure[player_pos[0], player_pos[1]]
+        room_state[next_pos[0], next_pos[1]] = 5
+        
+        # Update player position and track previous position
+        player_pos = next_pos
+        previous_positions.append(tuple(player_pos))
+        
+        steps_taken += 1
+        
+        # Decide whether to continue moving
+        if steps_taken >= max_steps or random.random() > continue_probability:
+            break
+    
+    return room_state
+
+
+
+"""
+Following code is adapted from the nicely written gym_sokoban repo
+"""
+
+def generate_room(dim=(13, 13), p_change_directions=0.35, num_steps=25, num_boxes=3, tries=4, second_player=False, search_depth=100):
+    """
+    Generates a Sokoban room, represented by an integer matrix. The elements are encoded as follows:
+    wall = 0
+    empty space = 1
+    box target = 2
+    box not on target = 3
+    box on target = 4
+    player = 5
+
+    :param dim:
+    :param p_change_directions:
+    :param num_steps:
+    :param num_boxes:
+    :param tries:
+    :param second_player:
+    :return: Numpy 2d Array, box mapping, action sequence
+    """
+    room_state = np.zeros(shape=dim)
+    room_structure = np.zeros(shape=dim)
+
+    # Some times rooms with a score == 0 are the only possibility.
+    # In these case, we try another model.
+    for t in range(tries):
+        room = room_topology_generation(dim, p_change_directions, num_steps)
+        room = place_boxes_and_player(room, num_boxes=num_boxes, second_player=second_player)
+
+        # Room fixed represents all not movable parts of the room
+        room_structure = np.copy(room)
+        room_structure[room_structure == 5] = 1
+
+        # Room structure represents the current state of the room including movable parts
+        room_state = room.copy()
+        room_state[room_state == 2] = 4
+
+        room_state, box_mapping, action_sequence = reverse_playing(room_state, room_structure, search_depth)
+        room_state[room_state == 3] = 4
+
+        if box_displacement_score(box_mapping) > 0:
+            break
+
+    if box_displacement_score(box_mapping) == 0:
+        raise RuntimeWarning('Generated Model with score == 0')
+
+    # Add random player movement after reverse_playing
+    if box_displacement_score(box_mapping) == 1:
+        move_probability = 0.8
+    else:
+        move_probability = 0.5
+    room_state = add_random_player_movement(
+        room_state, 
+        room_structure,
+        move_probability=move_probability,       # 50% chance the player will move
+        continue_probability=0.5,   # 50% chance to continue moving after each step
+        max_steps=3                 # Maximum of 3 steps
+    )
+
+    return room_structure, room_state, box_mapping, action_sequence
+
+
+def room_topology_generation(dim=(10, 10), p_change_directions=0.35, num_steps=15):
+    """
+    Generate a room topology, which consits of empty floors and walls.
+
+    :param dim:
+    :param p_change_directions:
+    :param num_steps:
+    :return:
+    """
+    dim_x, dim_y = dim
+
+    # The ones in the mask represent all fields which will be set to floors
+    # during the random walk. The centered one will be placed over the current
+    # position of the walk.
+    masks = [
+        [
+            [0, 0, 0],
+            [1, 1, 1],
+            [0, 0, 0]
+        ],
+        [
+            [0, 1, 0],
+            [0, 1, 0],
+            [0, 1, 0]
+        ],
+        [
+            [0, 0, 0],
+            [1, 1, 0],
+            [0, 1, 0]
+        ],
+        [
+            [0, 0, 0],
+            [1, 1, 0],
+            [1, 1, 0]
+        ],
+        [
+            [0, 0, 0],
+            [0, 1, 1],
+            [0, 1, 0]
+        ]
+    ]
+
+    # Possible directions during the walk
+    directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+    direction = random.sample(directions, 1)[0]
+
+    # Starting position of random walk
+    position = np.array([
+        random.randint(1, dim_x - 1),
+        random.randint(1, dim_y - 1)]
+    )
+
+    level = np.zeros(dim, dtype=int)
+
+    for s in range(num_steps):
+
+        # Change direction randomly
+        if random.random() < p_change_directions:
+            direction = random.sample(directions, 1)[0]
+
+        # Update position
+        position = position + direction
+        position[0] = max(min(position[0], dim_x - 2), 1)
+        position[1] = max(min(position[1], dim_y - 2), 1)
+
+        # Apply mask
+        mask = random.sample(masks, 1)[0]
+        mask_start = position - 1
+        level[mask_start[0]:mask_start[0] + 3, mask_start[1]:mask_start[1] + 3] += mask
+
+    level[level > 0] = 1
+    level[:, [0, dim_y - 1]] = 0
+    level[[0, dim_x - 1], :] = 0
+
+    return level
+
+
+def place_boxes_and_player(room, num_boxes, second_player):
+    """
+    Places the player and the boxes into the floors in a room.
+
+    :param room:
+    :param num_boxes:
+    :return:
+    """
+    # Get all available positions
+    possible_positions = np.where(room == 1)
+    num_possible_positions = possible_positions[0].shape[0]
+    num_players = 2 if second_player else 1
+
+    if num_possible_positions <= num_boxes + num_players:
+        raise RuntimeError('Not enough free spots (#{}) to place {} player and {} boxes.'.format(
+            num_possible_positions,
+            num_players,
+            num_boxes)
+        )
+
+    # Place player(s)
+    ind = np.random.randint(num_possible_positions)
+    player_position = possible_positions[0][ind], possible_positions[1][ind]
+    room[player_position] = 5
+
+    if second_player:
+        ind = np.random.randint(num_possible_positions)
+        player_position = possible_positions[0][ind], possible_positions[1][ind]
+        room[player_position] = 5
+
+    # Place boxes
+    for n in range(num_boxes):
+        possible_positions = np.where(room == 1)
+        num_possible_positions = possible_positions[0].shape[0]
+
+        ind = np.random.randint(num_possible_positions)
+        box_position = possible_positions[0][ind], possible_positions[1][ind]
+        room[box_position] = 2
+
+    return room
+
+
+# Global variables used for reverse playing.
+explored_states = set()
+num_boxes = 0
+best_room_score = -1
+best_room = None
+best_box_mapping = None
+
+
+def reverse_playing(room_state, room_structure, search_depth=100):
+    """
+    This function plays Sokoban reverse in a way, such that the player can
+    move and pull boxes.
+    It ensures a solvable level with all boxes not being placed on a box target.
+    :param room_state:
+    :param room_structure:
+    :param search_depth:
+    :return: 2d array, box mapping, action sequence
+    """
+    global explored_states, num_boxes, best_room_score, best_room, best_box_mapping, best_action_sequence
+
+    # Box_Mapping is used to calculate the box displacement for every box
+    box_mapping = {}
+    box_locations = np.where(room_structure == 2)
+    num_boxes = len(box_locations[0])
+    for l in range(num_boxes):
+        box = (box_locations[0][l], box_locations[1][l])
+        box_mapping[box] = box
+
+    # explored_states globally stores the best room state and score found during search
+    explored_states = set()
+    best_room_score = -1
+    best_room = None
+    best_box_mapping = box_mapping
+    best_action_sequence = []
+
+    depth_first_search(room_state, room_structure, box_mapping, box_swaps=0, last_pull=(-1, -1), ttl=search_depth, action_sequence=[])
+
+    return best_room, best_box_mapping, best_action_sequence
+
+
+def depth_first_search(room_state, room_structure, box_mapping, box_swaps=0, last_pull=(-1, -1), ttl=300, action_sequence=None):
+    """
+    Searches through all possible states of the room.
+    This is a recursive function, which stops if the ttl is reduced to 0 or
+    over 1.000.000 states have been explored.
+    :param room_state:
+    :param room_structure:
+    :param box_mapping:
+    :param box_swaps:
+    :param last_pull:
+    :param ttl:
+    :param action_sequence:
+    :return:
+    """
+    if action_sequence is None:
+        action_sequence = []
+    global explored_states, num_boxes, best_room_score, best_room, best_box_mapping, best_action_sequence
+
+    ttl -= 1
+    if ttl <= 0 or len(explored_states) >= 300000:
+        return
+
+    state_tohash = marshal.dumps(room_state)
+
+    # Only search this state, if it not yet has been explored
+    if not (state_tohash in explored_states):
+
+        # Add current state and its score to explored states
+        room_score = box_swaps * box_displacement_score(box_mapping)
+        if np.where(room_state == 2)[0].shape[0] != num_boxes:
+            room_score = 0
+
+        if room_score > best_room_score:
+            best_room = room_state.copy()
+            best_room_score = room_score
+            best_box_mapping = box_mapping.copy()
+            best_action_sequence = action_sequence.copy()
+
+        explored_states.add(state_tohash)
+
+        for action in ACTION_LOOKUP.keys():
+            # The state and box mapping need to be copied to ensure
+            # every action starts from a similar state.
+
+            # TODO: A tentitive try here to make less moves
+            if action >= 4:
+                continue
+
+            room_state_next = room_state.copy()
+            box_mapping_next = box_mapping.copy()
+
+            room_state_next, box_mapping_next, last_pull_next = \
+                reverse_move(room_state_next, room_structure, box_mapping_next, last_pull, action)
+
+            box_swaps_next = box_swaps
+            if last_pull_next != last_pull:
+                box_swaps_next += 1
+            
+            action_sequence_next = action_sequence + [action]
+            # action_sequence_next = action_sequence + [(action, box_mapping_next != box_mapping)] # add whether a box is moved
+            depth_first_search(room_state_next, room_structure, box_mapping_next, box_swaps_next, last_pull_next, ttl, action_sequence_next)
+            
+
+def reverse_move(room_state, room_structure, box_mapping, last_pull, action):
+    """
+    Perform reverse action. Where all actions in the range [0, 3] correspond to
+    push actions and the ones greater 3 are simmple move actions.
+    :param room_state:
+    :param room_structure:
+    :param box_mapping:
+    :param last_pull:
+    :param action:
+    :return:
+    """
+    player_position = np.where(room_state == 5)
+    player_position = np.array([player_position[0][0], player_position[1][0]])
+
+    change = CHANGE_COORDINATES[action % 4]
+    next_position = player_position + change
+
+    # Check if next position is an empty floor or an empty box target
+    if room_state[next_position[0], next_position[1]] in [1, 2]:
+
+        # Move player, independent of pull or move action.
+        room_state[player_position[0], player_position[1]] = room_structure[player_position[0], player_position[1]]
+        room_state[next_position[0], next_position[1]] = 5
+
+        # In addition try to pull a box if the action is a pull action
+        if action < 4:
+            possible_box_location = change[0] * -1, change[1] * -1
+            possible_box_location += player_position
+
+            if room_state[possible_box_location[0], possible_box_location[1]] in [3, 4]:
+                # Perform pull of the adjacent box
+                room_state[player_position[0], player_position[1]] = 3
+                room_state[possible_box_location[0], possible_box_location[1]] = room_structure[
+                    possible_box_location[0], possible_box_location[1]]
+
+                # Update the box mapping
+                for k in box_mapping.keys():
+                    if box_mapping[k] == (possible_box_location[0], possible_box_location[1]):
+                        box_mapping[k] = (player_position[0], player_position[1])
+                        last_pull = k
+
+    return room_state, box_mapping, last_pull
+
+
+def box_displacement_score(box_mapping):
+    """
+    Calculates the sum of all Manhattan distances, between the boxes
+    and their origin box targets.
+    :param box_mapping:
+    :return:
+    """
+    score = 0
+    
+    for box_target in box_mapping.keys():
+        box_location = np.array(box_mapping[box_target])
+        box_target = np.array(box_target)
+        dist = np.sum(np.abs(box_location - box_target))
+        score += dist
+
+    return score
+
+
+TYPE_LOOKUP = {
+    0: 'wall',
+    1: 'empty space',
+    2: 'box target',
+    3: 'box on target',
+    4: 'box not on target',
+    5: 'player'
+}
+
+ACTION_LOOKUP = {
+    0: 'push up',
+    1: 'push down',
+    2: 'push left',
+    3: 'push right',
+    4: 'move up',
+    5: 'move down',
+    6: 'move left',
+    7: 'move right',
+}
+
+# Moves are mapped to coordinate changes as follows
+# 0: Move up
+# 1: Move down
+# 2: Move left
+# 3: Move right
+CHANGE_COORDINATES = {
+    0: (-1, 0),
+    1: (1, 0),
+    2: (0, -1),
+    3: (0, 1)
+}

ragen/env/spatial/config.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, Tuple
+from ragen.env.spatial.Base.tos_base.evaluation.task_types import EvalTaskType
+
+@dataclass
+class SpatialGymConfig:
+    """
+    Configuration for the SpatialGym environment.
+    """
+    # Environment specific configuration
+    name: str = 'unnamed_env'
+    render_mode: str = "text"
+
+    # Room configuration
+    room_size: List[int] = field(default_factory=lambda: [10, 10])
+    n_objects: int = 3
+    level: int = 0
+    main: int = 6
+
+    # Exploration configuration
+    max_exp_steps: int = 10
+    
+    # Evaluation configuration
+    eval_tasks: List[str] = field(default_factory=lambda: [
+        "dir", "rot", "rot_dual", "pov", "bwd_pov", 
+        "e2a", "fwd_loc", "bwd_loc", "fwd_fov", "bwd_nav"
+    ])
+
+    prompt_config: Dict[str, Any] = field(default_factory=lambda: {"topdown": False, "oblique": False, "type": "shorter"})
+
+    def __post_init__(self):
+        """Validate configuration parameters."""
+        # Validate room size
+        assert self.room_size[0] > 0 and self.room_size[1] > 0, "room_size must be positive"
+        self._validate_eval_tasks()
+        assert self.render_mode == 'text', "Only text render mode is supported in RAGEN"
+
+    def _validate_eval_tasks(self):
+        """Validate eval_tasks parameter."""
+        valid_eval_tasks = EvalTaskType.get_short_names()
+        
+        if not self.eval_tasks:
+            raise ValueError("eval_tasks must be non-empty")
+
+        for task_name in self.eval_tasks:
+            if not isinstance(task_name, str):
+                raise ValueError(f"eval_tasks must be a list of strings, got {type(task_name)}")
+            if task_name not in valid_eval_tasks:
+                raise ValueError(f"task_type '{task_name}' must be one of {valid_eval_tasks}")

ragen/env/spatial/env.py

@@ -0,0 +1,180 @@
+import gymnasium as gym
+import numpy as np
+from typing import Any, Dict, Tuple, Optional, List
+
+from ragen.env.base import BaseLanguageBasedEnv
+from ragen.env.spatial.config import SpatialGymConfig
+from ragen.env.spatial.Base.tos_base.utils.room_utils import RoomGenerator
+from ragen.env.spatial.Base.tos_base.actions.actions import ActionSequence, ACTION_REMINDER
+from ragen.env.spatial.Base.tos_base.evaluation.task_types import EvalTaskType
+from ragen.env.spatial.Base.tos_base.managers.exploration_manager import ExplorationManager
+from ragen.env.spatial.prompter import SpatialPrompter
+
+class SpatialGym(BaseLanguageBasedEnv, gym.Env):
+    def __init__(self, config: SpatialGymConfig = None):
+        super().__init__()
+        self.config = config or SpatialGymConfig()
+        print(f"Config: {self.config}")
+        self.render_mode = self.config.render_mode
+        # User requirement: max steps should be 1 step more than max exp steps
+        self.max_steps = self.config.max_exp_steps + 1
+        
+        self.room = None
+        self.agent = None
+        self.current_answer = None
+        self.current_step_count = 0
+        self.last_obs = ""
+        self.last_info = {}
+        
+        self.exploration_manager = None
+        self.prompter = SpatialPrompter(self.config, np.random.RandomState(42))
+        self._rendered = False
+
+    def reset(self, seed: Optional[int] = None, mode=None) -> str:
+        gym.Env.reset(self, seed=seed) # Sets self.np_random
+        
+        self.prompter.np_random = self.np_random
+        
+        # Convert eval_tasks (List[str]) to List[Dict] for RoomGenerator validation
+        eval_tasks_dicts = [{"task_type": t} for t in self.config.eval_tasks]
+        
+        # Generate room
+        self.room, self.agent = RoomGenerator.generate_room(
+            room_size=self.config.room_size,
+            n_objects=self.config.n_objects,
+            np_random=self.np_random,
+            level=self.config.level,
+            main=self.config.main,
+            eval_tasks=eval_tasks_dicts,
+            same_room_size=True
+        )
+        
+        # Initialize ExplorationManager
+        self.exploration_manager = ExplorationManager(self.room, self.agent)
+        
+        # Select evaluation task
+        task_name = self.np_random.choice(self.config.eval_tasks)
+        
+        # Create task
+        current_task = EvalTaskType.create_task(
+            task_name, 
+            np_random=self.np_random, 
+            room=self.room, 
+            agent=self.agent
+        )
+        
+        # Generate question
+        current_question = current_task.generate_question()
+        self.current_answer = current_task.answer
+        
+        # Generate initial prompt
+        obs_dict = self.prompter.get_initial_observation_prompt(
+            self.room, 
+            self.agent, 
+            question=current_question
+        )
+        prompt = obs_dict['obs_str'] + "\n" + ACTION_REMINDER
+        
+        self.current_step_count = 0
+        self.last_obs = prompt
+        self.last_info = {}
+        self._rendered = False
+        return prompt
+        
+    def step(self, action: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        self._rendered = False
+        self.current_step_count += 1
+        
+        # Parse action
+        seq = ActionSequence.parse(action)
+        if seq is None:
+            return self._step_result(
+                obs="Invalid action format." + "\n" + ACTION_REMINDER,
+                reward=-1.0,
+                done=False,
+                info={"error": "Invalid action format", "success": False}
+            )
+            
+        # Execute actions
+        results = self.exploration_manager.execute_action_sequence(seq)
+        feedback_list = [res.message for res in results]
+        
+        terminated = False
+        term_answer = None
+        
+        # Check for TermAction
+        for res in results:
+            if res.success and res.action_type == 'term':
+                terminated = True
+                term_answer = res.data.get('answer')
+                break
+
+        # Calculate reward and done
+        reward = -0.1
+        done = False
+        info = {}
+        
+        if terminated:
+            done = True
+            if term_answer == self.current_answer:
+                reward = 10.0
+                info["success"] = True
+            else:
+                reward = -1
+                info["success"] = False
+            info["answer"] = term_answer
+            info["correct_answer"] = self.current_answer
+        
+        if self.current_step_count >= self.max_steps:
+            done = True
+            
+        obs = "\n".join(feedback_list) + "\n" + ACTION_REMINDER
+
+            
+        return self._step_result(obs, reward, done, info)
+
+    def _step_result(self, obs, reward, done, info):
+        self.last_obs = obs
+        self.last_info = info
+        return obs, reward, done, info
+
+    def render(self, mode=None):
+        if self._rendered:
+            return "invalid format" + "\n" + ACTION_REMINDER
+        self._rendered = True
+        return self.last_obs
+        
+    def close(self):
+        pass
+
+if __name__ == "__main__":
+    config = SpatialGymConfig(room_size=[20, 20], n_objects=5, level=0, main=6)
+    env = SpatialGym(config)
+    obs = env.reset(seed=42)
+    print("Initial Observation:")
+    print(obs)
+
+    from ragen.env.spatial.Base.tos_base.utils.room_utils import RoomPlotter
+    RoomPlotter.plot(env.room, env.agent, mode='img', save_path='room.png')
+    
+    # Test a few steps
+    print("\nStep 0: Invalid action")
+    obs, reward, done, info = env.step("Actions: [Rotate(45)]")
+    obs = env.render()
+    print(f"Reward: {reward}, Done: {done}, Info: {info}, Obs: {obs}")
+
+    print("\nStep 1: Rotate and Observe")
+    obs, reward, done, info = env.step("Actions: [Rotate(90), Observe()]")
+    obs = env.render()
+    print(f"Reward: {reward}, Done: {done}, Info: {info}, Obs: {obs}")
+    
+    print("\nStep 2: Jump to red door and Observe")
+    obs, reward, done, info = env.step("Actions: [JumpTo(red door), Observe()]")
+    obs = env.render()
+    print(f"Reward: {reward}, Done: {done}, Info: {info}, Obs: {obs}")
+    
+    print("\nStep 3: Terminate with answer")
+    obs, reward, done, info = env.step("Actions: [Term(C)]")
+    obs = env.render()
+    print(f"Reward: {reward}, Done: {done}, Info: {info}, Obs: {obs}")
+    

ragen/env/spatial/env_old.py

@@ -0,0 +1,335 @@
+import gymnasium as gym
+import numpy as np
+from typing import List, Dict, Any
+
+from vagen.env.spatial.env_config import SpatialGymConfig
+from vagen.env.spatial.Base.tos_base import (
+    EvaluationManager,
+    ActionSequence,
+    ExplorationManager,
+    HistoryManager,
+    RoomGenerator,
+    BaseAction,
+    EvalTaskType,
+)
+from vagen.env.spatial.Base.tos_base.managers.agent_proxy import get_agent_proxy
+from vagen.env.spatial.Base.tos_base.prompts import Prompter
+from vagen.env.spatial.Base.tos_base.utils.action_utils import action_results_to_text
+from vagen.env.spatial.Base.tos_base.utils.room_utils import initialize_room_from_json
+from vagen.env.spatial.Base.tos_base.utils.env_logger import EnvTurnLog
+from vagen.env.spatial.Base.tos_base.utils.utils import parse_llm_response
+from vagen.env.spatial.Base.tos_base.utils.image_handler import ImageHandler
+from vagen.env.spatial.Base.tos_base.actions.actions import ForcedTermAction, ActionSequence
+
+
+class SpatialGym(gym.Env):
+    """
+    Spatial Gym Environment with exploration and evaluation phases.
+
+    This environment uses an EvaluationManager to handle all evaluation tasks,
+    separating evaluation logic from the main environment logic.
+    """
+    def __init__(self, config: SpatialGymConfig):
+        super().__init__()
+        self.config = config
+        self.prompter: Prompter = None
+
+        self.is_exploration_phase = None
+        self.remaining_exp_steps = None
+        self.render_cache = None
+
+        # Room state management
+        self.initial_room = None
+        self.initial_agent = None
+
+        # Managers
+        self.exploration_manager = None
+        self.evaluation_manager = None
+        self.cognitive_map_manager = None
+        self.history_manager = None
+
+        # Turn logging
+        self.turn_logs: List[EnvTurnLog] = None
+        self.current_turn_number = None
+        self.observed_image_paths: List[str] = None
+
+    def _generate_initial_observation(self) -> str:
+        """Generate initial observation based on exploration type."""
+        exp_history = {}
+        images = []
+        if self.config.exp_type == 'passive' and not self.config.prompt_config['topdown']:
+            proxy = get_agent_proxy(
+                self.config.proxy_agent,
+                self.initial_room,
+                self.agent,
+                grid_size=self.config.grid_size if hasattr(self.config, 'grid_size') else None,
+            )            
+            proxy.run()
+            # Only collect multi-modal data if render_mode is vision
+            if self.config.render_mode == 'vision':
+                obs_str = proxy.to_text(self.config.image_placeholder)
+                for t in proxy.turns:
+                    if any('observe' in result.action_type for result in t.actions):
+                        image, image_path = self._get_multi_modal_data(proxy.mgr, t.pos, t.ori)
+                        images.append(image)
+                        self.observed_image_paths.append(image_path)
+                assert images is not []
+                exp_history['multi_modal_data'] = {self.config.image_placeholder: images}
+            else:
+                obs_str = proxy.to_text()
+            exp_history['obs_str'] = obs_str
+            # expose proxy manager so metrics are available via env.get_exp_summary()
+            self.exploration_manager = proxy.mgr
+
+        return self.prompter.get_initial_observation_prompt(
+            room=self.initial_room,
+            agent=self.agent,
+            eval_manager=self.evaluation_manager,
+            exp_history=exp_history,
+        )
+
+    def system_prompt(self) -> str:
+        return "You are an AI assistant that answers visual questions based on images."
+
+    def reset(self, seed: int = None):
+        """Reset environment for a new episode."""
+        super().reset(seed=seed)
+
+        self.image_handler = ImageHandler(self.config.data_dir, seed, self.config.image_size)
+        self.json_data = self.image_handler.json_data
+
+        self.prompter = Prompter(self.config, self.np_random, self.image_handler)
+        # Generate initial room
+        # self.initial_room, self.agent = RoomGenerator.generate_room(
+        #     **self.config.get_room_config(),
+        #     np_random=self.np_random,
+        # )
+        self.initial_room, self.agent = initialize_room_from_json(self.json_data)
+        self.initial_agent = self.agent.copy()
+
+        # Initialize episode state
+        self.remaining_exp_steps = self.config.max_exp_steps
+
+        # Initialize turn logs
+        self.turn_logs = []
+        self.current_turn_number = 0
+        self.observed_image_paths = []
+        # Set exploration phase
+        self.is_exploration_phase = self.config.exp_type == 'active'
+
+        # Set field of view for all actions
+        BaseAction.set_field_of_view(self.config.field_of_view)
+        self.exploration_manager = ExplorationManager(
+            self.initial_room, self.agent,
+            grid_size=(self.config.grid_size if hasattr(self.config, 'grid_size') else None),
+        )
+        self.history_manager = HistoryManager(
+            self.config.get_observation_config(), self.config.get_model_config(),
+            self.initial_room.to_dict(), self.agent.to_dict(),
+            image_dir=self.image_handler.image_dir,
+            output_dir=self.config.kwargs['output_dir'],
+            eval_override=self._should_eval_override(),
+            all_override=self.config.kwargs.get('all_override', False),
+            task_type=EvalTaskType.from_short_name(self.config.eval_tasks[0]['task_type']).class_name
+        )
+        # Initialize EvaluationManager with knowledge of existing eval counts
+        self.evaluation_manager = EvaluationManager(
+            self.config.eval_tasks, self.np_random, self.initial_room, self.agent, history_manager=self.history_manager, seed=seed
+        ) if len(self.config.eval_tasks) > 0 else None
+        info = {}
+        if self.history_manager:
+            info['history'] = self.history_manager.get_responses()
+        # If evaluation tasks already fully completed per config, indicate finish
+        if self.evaluation_manager and self.config.exp_type == 'passive':
+            info['finish'] = self.evaluation_manager.check_and_prune_completed_tasks()
+            
+        obs = self._generate_initial_observation() if not info.get('finish', False) else {"obs_str":"Task finished"}
+        self.render_cache = obs
+        return obs, info
+
+    def _should_eval_override(self) -> bool:
+        """Decide if we should override evaluation logs for this specific task."""
+        override_flag = self.config.kwargs.get('eval_override', False)
+        if not override_flag:
+            return False
+        selected = set(self.config.kwargs.get('eval_override_tasks', []) or [])
+        if not selected:
+            return True
+        # Accept both short names and class names
+        current_short = self.config.eval_tasks[0]['task_type']
+        current_class = EvalTaskType.from_short_name(current_short).class_name
+        return (current_short in selected) or (current_class in selected)
+
+    def _step_exploration(self, action: str):
+        """
+        Handle exploration phase step with parsed result and shared info.
+        """
+        obs_str = ""
+        reward = -0.1 
+        self.remaining_exp_steps -= 1
+        exp_log = None
+        obs={}
+        info = {'is_valid_action': True}
+        action_sequence = ActionSequence.parse(action)
+        if self.remaining_exp_steps < 0:
+            action_sequence = ActionSequence(motion_actions=[], final_action=ForcedTermAction())
+        if not action:
+            obs_str += "Invalid action. You should provide only one final action\n"
+            info['is_valid_action'] = False
+            reward += -0.5 # invalid action penalty
+        elif not action_sequence:
+            obs_str += "Invalid output format.\n"
+            info['is_valid_action'] = False
+            reward += -0.5 # invalid action penalty
+        else:
+            # execute action
+            action_results = self.exploration_manager.execute_action_sequence(action_sequence)
+            obs_str += action_results_to_text(action_results, self.config.image_placeholder if self.config.render_mode == 'vision' else None)
+            exp_log = self.exploration_manager.turn_logs[-1]
+            if action_sequence.final_action and action_sequence.final_action.is_term():
+                self.is_exploration_phase = False
+                # to ensure cogmap override working correctly
+                if self.evaluation_manager.check_and_prune_completed_tasks():
+                    return {'obs_str': "Task finished"}, 0, True, info, exp_log
+                obs_str += self.prompter.get_evaluation_prompt(self.evaluation_manager)
+            else:
+                obs_str += f"\nYou have a maximum of {self.remaining_exp_steps} exploration steps left."
+                # Only get multi-modal data if render_mode is vision
+                if self.config.render_mode == 'vision':
+                    image, image_path = self._get_multi_modal_data(self.exploration_manager, self.exploration_manager.agent.pos, self.exploration_manager.agent.ori)
+                    obs = {'multi_modal_data': {self.config.image_placeholder: [image]}}
+                    self.observed_image_paths.append(image_path)
+        return {**obs, 'obs_str': obs_str}, reward, False, info, exp_log
+
+    def _get_multi_modal_data(self, room: ExplorationManager, pos: np.ndarray, ori: np.ndarray):
+        """Get multi-modal data (images) for current state."""
+        # Find position: which object is at same location as agent
+        position_name = None if not np.allclose(room.init_pos, pos) else 'agent'
+        if position_name is None:
+            for obj in room.base_room.all_objects:
+                if np.allclose(obj.pos, pos):
+                    position_name = obj.name
+                    break
+        assert position_name is not None, "Agent position not found"
+        
+        direction = {(0, 1): 'north', (-1, 0): 'west', (0, -1): 'south', (1, 0): 'east'}[tuple(ori)]
+        
+        img = self.image_handler.get_image(position_name, direction)
+        img_path = self.image_handler.get_image_path(position_name, direction)
+        return img, img_path
+            
+
+    def _step_evaluation(self, action: str):
+        """Handle evaluation phase step with parsed result and shared info."""
+        correct, _ = self.evaluation_manager.evaluate_answer(action)
+        eval_log = self.evaluation_manager.turn_logs[-1]
+        reward = 1 if correct else 0
+
+        return {'obs_str': "Task finished"}, reward, True, {}, eval_log
+
+    def step(self, llm_response: str):
+        """Process agent actions in the spatial gym environment."""
+        self.current_turn_number += 1
+        exp_log, eval_log = None, None
+        think_content, action, parsed_ok = parse_llm_response(
+            llm_response, enable_think=bool(self.config.prompt_config.get('enable_think', True))
+        ) 
+        room_state = None
+        agent_state = None
+
+        # Log turn at start with current state
+        current_obs = self.render_cache
+        is_exploration_phase = self.is_exploration_phase # so termiante action is included in exploration log
+        # step the environment
+        if self.is_exploration_phase:
+            obs, reward, done, step_info, exp_log = self._step_exploration(action)
+            if exp_log:
+                room_state, agent_state = exp_log.room_state, exp_log.agent_state
+                exp_log.room_state = None
+                exp_log.agent_state = None
+        else:
+            obs, reward, done, step_info, eval_log = self._step_evaluation(action)
+            room_state, agent_state = eval_log.room_state, eval_log.agent_state
+            eval_log.room_state = None
+            eval_log.agent_state = None
+
+        obs['obs_str'] += '\n' + self.prompter.get_format_footer(self.is_exploration_phase)
+        self.render_cache = obs
+
+        turn_log = EnvTurnLog(
+            turn_number=self.current_turn_number,
+            user_message=current_obs['obs_str'],
+            assistant_raw_message=llm_response,
+            assistant_think_message=think_content,
+            assistant_parsed_message=action,
+            is_exploration_phase=is_exploration_phase,
+            is_last_exp=is_exploration_phase != self.is_exploration_phase,
+            exploration_log=exp_log,
+            evaluation_log=eval_log,
+            room_state=room_state,
+            agent_state=agent_state,
+            message_images=self.observed_image_paths,
+            info={"reward": reward, "is_done": done, **step_info}
+        )
+        if is_exploration_phase:
+            if not self.history_manager.has_exploration(self.current_turn_number - 1):
+                self.history_manager.update_turn_log(turn_log.to_dict())
+                self.history_manager.save_exploration()
+        else:
+            self.history_manager.update_turn_log(turn_log.to_dict())
+            self.history_manager.save()
+        self.observed_image_paths = []
+        self.turn_logs.append(turn_log)
+        return obs, reward, done, step_info
+
+    def render(self):
+        return self.render_cache
+
+    def close(self):
+        return
+
+
+    
+
+
+    # =================== Analysis ===================
+    
+    def get_exp_summary(self):
+        """Get exploration efficiency metrics."""
+        return self.exploration_manager.get_exp_summary() if self.exploration_manager else ExplorationManager.DEFAULT_EXP_SUMMARY
+    
+    def get_eval_summary(self):
+        """Get evaluation performance metrics."""
+        return self.evaluation_manager.get_eval_summary() if self.evaluation_manager else EvaluationManager.DEFAULT_EVAL_SUMMARY.copy()
+    
+    def get_env_summary(self) -> Dict[str, Any]:
+        """Aggregate environment metrics from all turns."""
+
+        return {
+            'env_info': self._get_env_info(),
+            'env_turn_logs': [turn_log.to_dict() for turn_log in self.turn_logs],
+        }
+
+    def _get_env_info(self):
+        """Get environment state information."""
+        return {
+            "config": self.config.to_dict(),
+            "initial_room": self.initial_room.to_dict(),
+            "initial_agent": self.initial_agent.to_dict(),
+        }
+
+
+
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    # Simple test cases for SpatialGym environment
+
+    # TODO: add test cases
+    pass

ragen/env/spatial/prompter.py

@@ -0,0 +1,74 @@
+import numpy as np
+from typing import Optional, Any
+from ragen.env.spatial.Base.tos_base.prompts.prompter import Prompter
+from ragen.env.spatial.Base.tos_base.actions.actions import ActionSequence
+from ragen.env.spatial.Base.tos_base.utils.room_utils import get_room_description
+from ragen.env.spatial.Base.tos_base.core.relationship import (
+    PairwiseRelationship, PairwiseRelationshipDiscrete, ProximityRelationship, DegreeRel, OrientationRel
+)
+from .prompts import (
+    INSTRUCTION_TEMPLATE_TEXT, SHARED_INTRO_TEXT,
+    SHARED_MULTIROOM_RULES, SHARED_RULES_COMMON, ACTIVE_RULES_EXTRA
+)
+
+class SpatialPrompter(Prompter):
+    def __init__(self, config, np_random: np.random.RandomState):
+        # Initialize without image_handler
+        super().__init__(config, np_random, image_handler=None)
+
+    def get_initial_observation_prompt(
+            self,
+            room,
+            agent,
+            question: str,
+            exp_history = None
+        ) -> dict:
+        """
+        Generates the initial observation prompt.
+        Forces active exploration instructions and sets the goal to answering the evaluation question.
+        Removes all vision-related logic.
+        """
+        obs = {}
+        topdown = self.config.prompt_config['topdown']
+
+        room_desc = get_room_description(room, agent, with_topdown=topdown)
+
+        observation_instructions = (
+            PairwiseRelationship.prompt()
+            + f"\n{DegreeRel.prompt()}"
+            + f"\n{OrientationRel.prompt()}"
+            + f"\n{PairwiseRelationshipDiscrete.prompt()}"
+            + f"\n{ProximityRelationship.prompt()}"
+        )
+
+        # Always include action instructions (text only)
+        exp_instructions = f"Action Instructions:\n{ActionSequence.get_usage_instructions(vision=False)}"
+
+
+        template = INSTRUCTION_TEMPLATE_TEXT
+
+        # Custom goal
+        goal_lines = "Explore the environment with given actions to answer the evaluation question."
+
+        fmt_kwargs = {
+            'title': 'Spatial Exploration Task',
+            'intro': SHARED_INTRO_TEXT,
+            'goal_lines': goal_lines,
+            'format_rules': "", # No format rules
+            'observation_instructions': observation_instructions,
+            'exp_instructions': exp_instructions,
+            'room_info': room_desc,
+            'multiroom_rules': SHARED_MULTIROOM_RULES if self.config.level != 0 else "",
+            'active_rules_extra': ACTIVE_RULES_EXTRA,
+            'rules_common': SHARED_RULES_COMMON,
+            'exp_history': "", # Initial prompt has no history
+        }
+
+        obs_str = template.format(**fmt_kwargs)
+        
+        # Append evaluation question
+        if question:
+             obs_str += f"\n## Evaluation Question\n{question}"
+
+        obs['obs_str'] = obs_str
+        return obs

ragen/env/spatial/prompts.py

@@ -0,0 +1,71 @@
+# ragen/env/spatial/prompts.py
+
+SHARED_INTRO_TEXT = "You are a spatial reasoner in indoor environment, a 2D, text-only N×M grid. Every object including you is a point at integer (x, y) coordinates."
+
+SHARED_INTRO_VISION = (
+    "You are a spatial reasoner in a 3D simulated environment. "
+    "The world is rendered in 3D but abstracted into a discrete 2D grid of size N×M. "
+    "Every entity, including yourself, is represented by integer coordinates (x, y) on this grid."
+)
+
+SHARED_MULTIROOM_RULES = """\
+Multi-room rules (may exist multiple rooms):
+- Your vision is confined to your current room.
+- Doors block vision between rooms.
+- Exception: When located in a doorway, door is open and invisible, you can see into both connected rooms.
+- Rooms connect via doors on vertical (front/back) or horizontal (left/right) walls.
+"""
+
+SHARED_RULES_COMMON = """\
+- Field of view: 90°
+"""
+
+# Optimized: Emphasize answering evaluation question, remove coverage goals.
+ACTIVE_RULES_EXTRA = ""
+
+VISION_EXAMPLE = """\
+Here is an example of your observation: blue cylinder 1 m straight ahead; red cylinder 2 m straight ahead; yellow cylinder 2 m at 45° to your front-left; green cylinder 3 m at 22.5° to your front-slight-right:
+{image_placeholder}
+
+The image shows all objects in the room. Each tile is numbered (1-N) in the top-left, matching the object order in the room layout.
+For items with a facing direction, two copies are shown side-by-side: the left copy has its front facing the camera; the right copy has its front facing left.
+Items without a meaningful facing direction are shown once.
+{image_placeholder}
+"""
+
+_BASE_TEMPLATE = """\
+# {title}
+
+{intro}
+
+{goal_lines}
+
+{multiroom_rules}
+
+Relationship instructions:
+{observation_instructions}
+
+{exp_instructions}
+
+{format_rules}
+
+Rules:
+{active_rules_extra}{rules_common}
+
+Room Layout and initial state:
+{room_info}
+"""
+
+INSTRUCTION_TEMPLATE_TEXT = _BASE_TEMPLATE + """
+{exp_history}
+"""
+
+INSTRUCTION_TEMPLATE_VISION = _BASE_TEMPLATE + """
+{vision_example}
+
+{exp_history}
+"""
+
+EVALUATION_INSTRUCTION = "{eval_question}"
+SHORT_EXPLORATION_PROMPT = "Please respond with valid actions to explore the rooms."
+SHORT_EVALUATION_PROMPT = "Please respond with a valid answer to the question."

ragen/env/static/config.py

@@ -0,0 +1,10 @@
+from typing import Optional, List, Dict
+from dataclasses import dataclass, field
+
+@dataclass
+class StaticEnvConfig:
+    """Configuration for StaticEnv environment"""
+    # Dataset config
+    dataset_name: str = field(default="metamathqa") #metamathqa, gsm8k,theoremqa,mmlu
+    cache_dir: str = field(default="./data")
+    split: Optional[str] = field(default=None)

ragen/env/static/env.py

@@ -0,0 +1,111 @@
+import numpy as np
+from datasets import load_dataset
+import re
+import random
+from typing import Dict, Any, Optional, List, Tuple, Callable
+from ragen.env.base import BaseLanguageBasedEnv
+from ragen.utils import all_seed
+from .config import StaticEnvConfig
+from .utils import REGISTERD_STATIC_ENV
+class StaticEnv(BaseLanguageBasedEnv):
+    """
+    A general environment for evaluating language models on Hugging Face datasets.
+    Supports multiple datasets: MetaMathQA, TheoremQA, MATH, MMLU-STEM, GSM8K, etc.
+    """
+    def __init__(self, config: StaticEnvConfig):
+        super(StaticEnv, self).__init__()
+        
+        self.config = config
+        dataset_config=getattr(config, "dataset_config", None)
+        if dataset_config is None:
+            dataset_config=REGISTERD_STATIC_ENV[self.config.dataset_name]["config"]
+        self.dataset = load_dataset(**dataset_config, cache_dir=self.config.cache_dir)
+        
+        if self.config.split is None:
+            self.split = list(self.dataset.keys())[0]
+        else:
+            self.split = self.config.split
+            
+        self.current_question_idx = None
+        self.current_question = None
+        self.correct_answer = None
+        self.step_num = None
+        
+        self.processor = REGISTERD_STATIC_ENV[self.config.dataset_name]["processor"]
+        self.compute_score= REGISTERD_STATIC_ENV[self.config.dataset_name]["compute_score"]
+        
+    def reset(self, seed=None, mode=None):
+        """Reset the environment and get a new question."""
+        dataset_split = self.dataset[self.split]
+        with all_seed(seed):
+            self.current_question_idx = random.randint(0, len(dataset_split) - 1)
+        question_data = dataset_split[self.current_question_idx]
+        self.current_question, self.correct_answer = self.processor(question_data)
+        self.step_num = 0
+        
+        return self.current_question
+        
+    def step(self, action):
+        """Take a step in the environment with the given action (answer)."""
+        score_result = self.compute_score(action,self.correct_answer)
+        is_correct = score_result["is_correct"]
+        is_valid = score_result["is_valid"]
+        reward = 1.0 / (2 ** self.step_num) if is_correct else 0.0
+        if is_correct:
+            observation = "Correct!"
+            done = True
+        else:
+            observation = "Incorrect. Please think again."
+            done = False
+            
+        self.step_num += 1
+        info = {
+            "success": is_correct,
+            "is_valid": is_valid,
+        }
+        
+        return observation, reward, done, info
+
+
+if __name__ == "__main__":
+    # Example usage
+    
+    
+    
+    for dataset_name in REGISTERD_STATIC_ENV.keys():
+        config = StaticEnvConfig(
+            dataset_name=dataset_name,
+            cache_dir="./data",
+        )
+        
+        # Initialize the environment
+        env = StaticEnv(config)
+        
+        # Reset the environment to get the first question
+        print("\n--- New Question ---")
+        obs = env.reset(seed=42)
+        print(obs)
+        
+        print("\n--- Correct Answer ---")
+        print(env.correct_answer)
+        
+        # Interactive loop for testing
+        while True:
+            user_answer = input("\nEnter your answer (or 'q' to quit): ")
+            if user_answer.lower() == 'q':
+                break
+            
+            # Take a step in the environment with the user's answer
+            obs, reward, done, info = env.step(user_answer)
+            
+            # Print the results
+            print(f"\n{obs}")
+            
+            # If the episode is done, reset the environment for a new question
+            if done:
+                print(f"\ntotal step: {env.step_num}, reward: {reward}")
+                print("\n--- New Question ---")
+                question = env.reset()
+                print(question)
+                print("\n--- Correct Answer ---")
+                print(env.correct_answer)

ragen/env/static/utils.py

@@ -0,0 +1,176 @@
+import re
+import string
+from typing import Dict, Any, Optional, List, Tuple, Callable
+
+
+############################Tool Fuctions############################
+def normalize_text(text: str) -> str:
+    """Normalize text by removing whitespace, punctuation, and converting to lowercase."""
+    text = text.lower()
+    text = re.sub(r'\s+', '', text)
+    text = text.translate(str.maketrans('', '', string.punctuation))
+    return text
+
+def extract_answer_from_text(text: str) -> str:
+    """Extract answer from text with various patterns."""
+    patterns = [
+        r"The answer is:?\s*(.*?)(?:\n|$)",
+        r"Answer:?\s*(.*?)(?:\n|$)",
+        r"Final answer:?\s*(.*?)(?:\n|$)",
+        r"Therefore,\s*(.*?)(?:\n|$)",
+        r"Thus,\s*(.*?)(?:\n|$)",
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, text, re.DOTALL)
+        if match:
+            return match.group(1).strip()
+    
+    # If no pattern matches, return the last line as a fallback
+    lines = text.strip().split('\n')
+    return lines[-1].strip()
+# ====== Dataset Processors ======
+
+def process_metamathqa(item: Dict[str, Any]) -> Tuple[str, str]:
+    """Process MetaMathQA dataset item."""
+    question = item["query"]
+    answer = extract_answer_from_text(item["response"])
+    return question, answer
+
+def process_gsm8k(item: Dict[str, Any]) -> Tuple[str, str]:
+    """Process GSM8K dataset item."""
+    question = item["question"]
+    answer = item["answer"]
+    answer=answer.split("####")[1].strip().lower()
+    return question, answer
+
+def process_theoremqa(item: Dict[str, Any]) -> Tuple[str, str]:
+    """Process TheoremQA dataset item."""
+    question = item["Question"]
+    answer = str(item["Answer"])
+    return question, answer
+
+def process_mmlu(item: Dict[str, Any]) -> Tuple[str, str]:
+    """Process MMLU dataset with multiple choice format."""
+    question = item['question']
+    choices = [item['choices'][i] for i in range(len(item['choices']))]
+    formatted_question = question + "\n" + "\n".join([f"{chr(65+i)}. {choice}" for i, choice in enumerate(choices)])
+    answer = chr(65 + item['answer'])  # Convert to A, B, C, D format
+    return formatted_question, answer
+
+def process_gpqa(item: Dict[str, Any]) -> Tuple[str, str]:
+    """Process GPQA dataset item."""
+    question = item["Question"]
+    answer = extract_answer_from_text(item["Correct Answer"])
+    return question, answer
+
+# ====== Scoring Functions ======
+
+def compute_score_exact_match(prediction: str, label: str) -> Dict[str, Any]:
+    """Basic exact match after normalization."""
+    norm_pred = normalize_text(prediction)
+    norm_label = normalize_text(label)
+    
+    is_correct = norm_pred == norm_label
+    is_valid = len(norm_pred) > 0  # Simple validity check
+    
+    return {
+        "is_correct": is_correct,
+        "is_valid": is_valid,
+        "normalized_prediction": norm_pred,
+        "normalized_label": norm_label
+    }
+
+def compute_score_numeric(prediction: str, label: str) -> Dict[str, Any]:
+    """Extract numeric values and compare them."""
+    # Extract the first numeric value from both prediction and label
+    pred_match = re.search(r'(\d+(?:\.\d+)?)', prediction)
+    label_match = re.search(r'(\d+(?:\.\d+)?)', label)
+    
+    is_valid = pred_match is not None
+    
+    if pred_match and label_match:
+        pred_answer = pred_match.group(0)
+        label_answer = label_match.group(0)
+        
+        try:
+            is_correct = float(pred_answer) == float(label_answer)
+        except ValueError:
+            is_correct = False
+    else:
+        is_correct = False
+    
+    # Also try text match as fallback
+    text_match = normalize_text(prediction) == normalize_text(label)
+    is_correct = is_correct or text_match
+    
+    return {
+        "is_correct": is_correct,
+        "is_valid": is_valid,
+        "numeric_match": is_correct and not text_match,
+        "text_match": text_match
+    }
+
+def compute_score_multiple_choice(prediction: str, label: str) -> Dict[str, Any]:
+    """Score multiple choice answers (A, B, C, D)."""
+    pred_match = re.search(r'([A-D])', prediction.upper())
+    label_match = re.search(r'([A-D])', label.upper())
+    
+    is_valid = pred_match is not None
+    
+    if pred_match and label_match:
+        pred_choice = pred_match.group(0)
+        label_choice = label_match.group(0)
+        is_correct = pred_choice == label_choice
+    else:
+        # Fallback to text comparison
+        is_correct = normalize_text(prediction) == normalize_text(label)
+    
+    return {
+        "is_correct": is_correct,
+        "is_valid": is_valid,
+        "extracted_prediction": pred_match.group(0) if pred_match else None,
+        "extracted_label": label_match.group(0) if label_match else None
+    }
+    
+##########################registration###########################
+REGISTERD_STATIC_ENV = {
+    "metamathqa": {
+        "config": {
+            "path": "meta-math/MetaMathQA",
+        },
+        "processor": process_metamathqa,
+        "compute_score": compute_score_exact_match
+    },
+    "gsm8k": {
+        "config": {
+            "path": "openai/gsm8k",
+            "name":"main"
+        },
+        "processor": process_gsm8k,
+        "compute_score": compute_score_numeric
+    },
+    # "theoremqa": {
+    #     "config": {
+    #         "path": "TIGER-Lab/TheoremQA",
+    #     },
+    #     "processor": process_theoremqa,
+    #     "compute_score": compute_score_numeric
+    # },
+    "mmlu": {
+        "config": {
+            "path": "cais/mmlu",
+            "name": "abstract_algebra",
+        },
+        "processor": process_mmlu,
+        "compute_score": compute_score_multiple_choice
+    },
+    # "gpqa":{
+    #     "config": {
+    #         "path": "Idavidrein/gpqa",
+    #         "name": "gpqa_main",
+    #     },
+    #     "processor": process_gpqa,
+    #     "compute_score": compute_score_exact_match
+    # }
+}

ragen/env/sudoku/__init__.py

@@ -0,0 +1,4 @@
+from .env import SudokuEnv
+from .config import SudokuEnvConfig
+
+__all__ = ['SudokuEnv', 'SudokuEnvConfig']

ragen/env/sudoku/config.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class SudokuEnvConfig:
+    """Configuration for Sudoku environment with enhanced feedback."""
+    grid_size: int = 9  # Standard 9x9 Sudoku
+    max_steps: int = 81  # Maximum number of steps (one per cell)
+    difficulty: str = "easy"  # Difficulty level: easy, medium, hard
+    render_mode: str = "text"
+    show_conflicts: bool = True  # Show row/column/box conflicts in render
+    show_valid_numbers: bool = True  # Show valid numbers for each empty cell
+    show_candidates: bool = False  # Show all candidate numbers for empty cells
+    render_format: str = "detailed"  # "simple", "detailed", "with_feedback"
+
+    # Scoring
+    correct_placement_score: float = 1.0
+    invalid_action_score: float = -0.1  # Penalty for invalid placements
+    completion_bonus: float = 10.0  # Bonus for solving the puzzle
+
+    def __post_init__(self):
+        if self.grid_size not in {4, 9, 16}:
+            raise ValueError(f"Unsupported grid_size: {self.grid_size}. Must be 4, 9, or 16.")
+        if self.render_format not in {"simple", "detailed", "with_feedback"}:
+            raise ValueError(f"Unsupported render_format: {self.render_format}")
+        if self.difficulty not in {"easy", "medium", "hard"}:
+            raise ValueError(f"Unsupported difficulty: {self.difficulty}")

ragen/env/sudoku/env.py

@@ -0,0 +1,348 @@
+import gymnasium as gym
+import numpy as np
+import re
+from typing import Tuple, Dict, Any
+from ragen.env.base import BaseLanguageBasedEnv
+from .config import SudokuEnvConfig
+from .utils import (
+    generate_sudoku_puzzle,
+    is_valid_placement,
+    get_valid_numbers,
+    find_conflicts,
+    is_solved,
+    format_grid_simple,
+    format_grid_with_conflicts,
+)
+
+
+class SudokuEnv(BaseLanguageBasedEnv, gym.Env):
+    """
+    Sudoku environment with enhanced feedback for better exploration efficiency.
+
+    Key features to address low exploration efficiency:
+    1. Clear feedback on valid vs invalid moves
+    2. Conflict detection and visualization
+    3. Valid number suggestions for each cell
+    4. Detailed action validation info
+    """
+
+    def __init__(self, config=None):
+        BaseLanguageBasedEnv.__init__(self)
+        self.config = config if config is not None else SudokuEnvConfig()
+        self.grid_size = self.config.grid_size
+        self.max_steps = self.config.max_steps
+
+        # State variables
+        self.current_grid = None
+        self.initial_grid = None
+        self.solution_grid = None
+        self.num_steps = 0
+        self.render_cache = None
+        self.last_action_feedback = ""
+
+        self.render_mode = self.config.render_mode
+        assert self.render_mode == 'text'
+
+    def reset(self, seed=None, mode=None):
+        """Reset the environment with a new Sudoku puzzle."""
+        gym.Env.reset(self, seed=seed)
+
+        # Generate a new puzzle
+        self.initial_grid, self.solution_grid = generate_sudoku_puzzle(
+            grid_size=self.grid_size,
+            difficulty=self.config.difficulty,
+            seed=seed
+        )
+        self.current_grid = self.initial_grid.copy()
+        self.num_steps = 0
+        self.last_action_feedback = ""
+
+        return self.render()
+
+    def parse_action(self, action: str) -> Tuple[bool, int, int, int, str]:
+        """
+        Parse action string into (success, row, col, number, error_msg).
+
+        Supported formats:
+        - "place 5 at row 2 col 3"
+        - "place 5 at (2,3)"
+        - "place 5 at 2,3"
+        - "5 at 2,3"
+        - "(2,3,5)"
+        - "2,3,5"
+
+        Returns:
+            Tuple of (success, row, col, number, error_message)
+        """
+        action = action.strip().lower()
+
+        # Try different patterns
+        patterns = [
+            r'place\s+(\d+)\s+at\s+row\s+(\d+)\s+col\s+(\d+)',
+            r'place\s+(\d+)\s+at\s+\((\d+),\s*(\d+)\)',
+            r'place\s+(\d+)\s+at\s+(\d+),\s*(\d+)',
+            r'(\d+)\s+at\s+(\d+),\s*(\d+)',
+            r'\((\d+),\s*(\d+),\s*(\d+)\)',
+            r'(\d+),\s*(\d+),\s*(\d+)',
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, action)
+            if match:
+                groups = match.groups()
+                if len(groups) == 3:
+                    # Determine if first number is the value or row
+                    # For "place NUM at ROW,COL", first is number
+                    if 'place' in action or 'at' in action:
+                        num, row, col = map(int, groups)
+                    else:
+                        # For "ROW,COL,NUM", assume positional format
+                        row, col, num = map(int, groups)
+
+                    # Convert to 0-indexed
+                    row -= 1
+                    col -= 1
+
+                    # Validate ranges
+                    if not (0 <= row < self.grid_size):
+                        return False, -1, -1, -1, f"Row {row+1} is out of range (1-{self.grid_size})"
+                    if not (0 <= col < self.grid_size):
+                        return False, -1, -1, -1, f"Column {col+1} is out of range (1-{self.grid_size})"
+                    if not (1 <= num <= self.grid_size):
+                        return False, -1, -1, -1, f"Number {num} is out of range (1-{self.grid_size})"
+
+                    return True, row, col, num, ""
+
+        return False, -1, -1, -1, f"Could not parse action: '{action}'. Expected format: 'place 5 at row 2 col 3' or '2,3,5'"
+
+    def step(self, action: str) -> Tuple[str, float, bool, Dict[str, Any]]:
+        """
+        Execute one step in the environment.
+
+        Returns:
+            Tuple of (observation, reward, done, info)
+        """
+        self.num_steps += 1
+
+        # Parse the action
+        success, row, col, num, error_msg = self.parse_action(action)
+
+        if not success:
+            self.last_action_feedback = f"❌ Invalid action format: {error_msg}"
+            reward = self.config.invalid_action_score
+            info = {
+                "action_is_effective": False,
+                "action_is_valid": False,
+                "success": False,
+                "error": error_msg
+            }
+            return self.render(), reward, False, info
+
+        # Check if cell is modifiable (not part of initial puzzle)
+        if self.initial_grid[row, col] != 0:
+            self.last_action_feedback = f"�� Cannot modify initial cell at ({row+1},{col+1})"
+            reward = self.config.invalid_action_score
+            info = {
+                "action_is_effective": False,
+                "action_is_valid": False,
+                "success": False,
+                "error": "Cannot modify initial cells"
+            }
+            return self.render(), reward, False, info
+
+        # Check if placement is valid according to Sudoku rules
+        if not is_valid_placement(self.current_grid, row, col, num):
+            # Get the specific conflict reason
+            conflicts = []
+            if num in self.current_grid[row, :]:
+                conflicts.append(f"row {row+1}")
+            if num in self.current_grid[:, col]:
+                conflicts.append(f"column {col+1}")
+
+            # Check box
+            box_size = int(np.sqrt(self.grid_size))
+            box_row = (row // box_size) * box_size
+            box_col = (col // box_size) * box_size
+            if num in self.current_grid[box_row:box_row+box_size, box_col:box_col+box_size]:
+                conflicts.append(f"box ({box_row//box_size+1},{box_col//box_size+1})")
+
+            conflict_str = ", ".join(conflicts)
+            self.last_action_feedback = f"❌ Invalid placement: {num} conflicts with {conflict_str}"
+
+            # Get valid numbers for this cell
+            valid_nums = get_valid_numbers(self.current_grid, row, col)
+            if valid_nums:
+                self.last_action_feedback += f"\n   Valid numbers for ({row+1},{col+1}): {sorted(valid_nums)}"
+
+            reward = self.config.invalid_action_score
+            info = {
+                "action_is_effective": False,
+                "action_is_valid": False,
+                "success": False,
+                "error": f"Number {num} conflicts with {conflict_str}",
+                "valid_numbers": sorted(valid_nums)
+            }
+            return self.render(), reward, False, info
+
+        # Place the number
+        old_value = self.current_grid[row, col]
+        self.current_grid[row, col] = num
+
+        # Check if the placement is correct according to solution
+        correct_placement = (num == self.solution_grid[row, col])
+
+        if correct_placement:
+            self.last_action_feedback = f"✓ Correct! Placed {num} at ({row+1},{col+1})"
+            reward = self.config.correct_placement_score
+        else:
+            self.last_action_feedback = f"⚠ Placed {num} at ({row+1},{col+1}) - Valid but not optimal"
+            reward = self.config.correct_placement_score * 0.5
+
+        # Check if puzzle is solved
+        solved = is_solved(self.current_grid)
+        if solved:
+            self.last_action_feedback += "\n🎉 Congratulations! Puzzle solved!"
+            reward += self.config.completion_bonus
+
+        # Check for max steps
+        done = solved or (self.num_steps >= self.max_steps)
+
+        info = {
+            "action_is_effective": True,
+            "action_is_valid": True,
+            "success": solved,
+            "correct_placement": correct_placement,
+            "steps_remaining": self.max_steps - self.num_steps,
+            "cells_filled": np.count_nonzero(self.current_grid),
+            "cells_remaining": np.count_nonzero(self.current_grid == 0)
+        }
+
+        return self.render(), reward, done, info
+
+    def render(self) -> str:
+        """
+        Render the current state with enhanced feedback.
+
+        The render function provides:
+        1. Current grid state with visual distinction between:
+           - Initial cells [N]
+           - User-placed valid cells N
+           - Conflicting cells *N*
+           - Empty cells .
+        2. Last action feedback
+        3. Current conflicts (if any)
+        4. Valid numbers for empty cells (if enabled)
+        """
+        if self.config.render_format == "simple":
+            return self._render_simple()
+        elif self.config.render_format == "detailed":
+            return self._render_detailed()
+        else:  # "with_feedback"
+            return self._render_with_feedback()
+
+    def _render_simple(self) -> str:
+        """Simple grid rendering."""
+        return format_grid_simple(self.current_grid)
+
+    def _render_detailed(self) -> str:
+        """Detailed rendering with conflicts highlighted."""
+        conflicts = find_conflicts(self.current_grid, self.initial_grid)
+        grid_str = format_grid_with_conflicts(self.current_grid, self.initial_grid, conflicts)
+
+        output = ["=" * 50]
+        output.append("SUDOKU PUZZLE")
+        output.append("=" * 50)
+        output.append(grid_str)
+        output.append("")
+        output.append("Legend: [N]=initial cell, N=user-placed, *N*=conflict, .=empty")
+
+        if self.last_action_feedback:
+            output.append("")
+            output.append(self.last_action_feedback)
+
+        return "\n".join(output)
+
+    def _render_with_feedback(self) -> str:
+        """Full rendering with conflicts and valid numbers."""
+        conflicts = find_conflicts(self.current_grid, self.initial_grid)
+        grid_str = format_grid_with_conflicts(self.current_grid, self.initial_grid, conflicts)
+
+        output = ["=" * 50]
+        output.append("SUDOKU PUZZLE")
+        output.append("=" * 50)
+        output.append(grid_str)
+        output.append("")
+        output.append("Legend: [N]=initial cell, N=user-placed, *N*=conflict, .=empty")
+
+        if self.last_action_feedback:
+            output.append("")
+            output.append(self.last_action_feedback)
+
+        # Show conflicts if any
+        if self.config.show_conflicts:
+            all_conflicts = set(conflicts['row'] + conflicts['col'] + conflicts['box'])
+            if all_conflicts:
+                output.append("")
+                output.append("⚠ CONFLICTS DETECTED:")
+                for r, c in sorted(all_conflicts):
+                    output.append(f"  - Cell ({r+1},{c+1}): {self.current_grid[r,c]}")
+
+        # Show valid numbers for empty cells
+        if self.config.show_valid_numbers:
+            empty_cells = list(zip(*np.where(self.current_grid == 0)))
+            if empty_cells and len(empty_cells) <= 10:  # Only show for first 10 empty cells
+                output.append("")
+                output.append("💡 VALID NUMBERS FOR EMPTY CELLS:")
+                for row, col in empty_cells[:10]:
+                    if self.initial_grid[row, col] == 0:  # Only show for non-initial cells
+                        valid = get_valid_numbers(self.current_grid, row, col)
+                        if valid:
+                            output.append(f"  - ({row+1},{col+1}): {sorted(valid)}")
+
+        # Show statistics
+        cells_filled = np.count_nonzero(self.current_grid)
+        cells_total = self.grid_size * self.grid_size
+        initial_filled = np.count_nonzero(self.initial_grid)
+        output.append("")
+        output.append(f"Progress: {cells_filled}/{cells_total} cells filled ({initial_filled} initial, {cells_filled - initial_filled} placed)")
+        output.append(f"Steps: {self.num_steps}/{self.max_steps}")
+
+        return "\n".join(output)
+
+    def close(self):
+        """Clean up resources."""
+        pass
+
+
+if __name__ == "__main__":
+    # Test the environment
+    config = SudokuEnvConfig(
+        grid_size=9,
+        difficulty="easy",
+        render_format="with_feedback"
+    )
+    env = SudokuEnv(config)
+
+    print("Testing Sudoku Environment")
+    print("=" * 50)
+
+    obs = env.reset(seed=42)
+    print(obs)
+    print("\n")
+
+    # Test some actions
+    test_actions = [
+        "place 5 at row 1 col 1",  # This might be valid or invalid depending on puzzle
+        "1,2,3",  # Positional format
+        "place 9 at (3,3)",  # Another format
+    ]
+
+    for action in test_actions:
+        print(f"\nAction: {action}")
+        obs, reward, done, info = env.step(action)
+        print(obs)
+        print(f"Reward: {reward}, Done: {done}")
+        print(f"Info: {info}")
+
+        if done:
+            break

ragen/env/sudoku/utils.py

@@ -0,0 +1,250 @@
+import numpy as np
+import random
+from typing import Set, Tuple, List, Dict
+
+
+def get_box_size(grid_size: int) -> int:
+    """Get the box size for a given grid size."""
+    return int(np.sqrt(grid_size))
+
+
+def get_box_index(row: int, col: int, grid_size: int) -> Tuple[int, int]:
+    """Get the box indices for a given cell."""
+    box_size = get_box_size(grid_size)
+    return row // box_size, col // box_size
+
+
+def is_valid_placement(grid: np.ndarray, row: int, col: int, num: int) -> bool:
+    """
+    Check if placing a number at (row, col) is valid according to Sudoku rules.
+
+    Returns:
+        True if placement is valid, False otherwise
+    """
+    grid_size = grid.shape[0]
+    box_size = get_box_size(grid_size)
+
+    # Check if number already exists in row
+    if num in grid[row, :]:
+        return False
+
+    # Check if number already exists in column
+    if num in grid[:, col]:
+        return False
+
+    # Check if number already exists in box
+    box_row, box_col = get_box_index(row, col, grid_size)
+    box_start_row = box_row * box_size
+    box_start_col = box_col * box_size
+    if num in grid[box_start_row:box_start_row + box_size, box_start_col:box_start_col + box_size]:
+        return False
+
+    return True
+
+
+def get_valid_numbers(grid: np.ndarray, row: int, col: int) -> Set[int]:
+    """
+    Get all valid numbers that can be placed at (row, col).
+
+    Returns:
+        Set of valid numbers (1 to grid_size)
+    """
+    if grid[row, col] != 0:
+        return set()
+
+    grid_size = grid.shape[0]
+    all_numbers = set(range(1, grid_size + 1))
+
+    # Remove numbers in same row
+    all_numbers -= set(grid[row, :]) - {0}
+
+    # Remove numbers in same column
+    all_numbers -= set(grid[:, col]) - {0}
+
+    # Remove numbers in same box
+    box_size = get_box_size(grid_size)
+    box_row, box_col = get_box_index(row, col, grid_size)
+    box_start_row = box_row * box_size
+    box_start_col = box_col * box_size
+    box_numbers = grid[box_start_row:box_start_row + box_size, box_start_col:box_start_col + box_size]
+    all_numbers -= set(box_numbers.flatten()) - {0}
+
+    return all_numbers
+
+
+def find_conflicts(grid: np.ndarray, initial_grid: np.ndarray) -> Dict[str, List[Tuple[int, int]]]:
+    """
+    Find all conflicts in the current grid state.
+
+    Returns:
+        Dictionary with 'row', 'col', 'box' keys mapping to lists of conflicting cells
+    """
+    conflicts = {'row': [], 'col': [], 'box': []}
+    grid_size = grid.shape[0]
+    box_size = get_box_size(grid_size)
+
+    # Check row conflicts
+    for i in range(grid_size):
+        row = grid[i, :]
+        for num in range(1, grid_size + 1):
+            positions = np.where(row == num)[0]
+            if len(positions) > 1:
+                for pos in positions:
+                    conflicts['row'].append((i, pos))
+
+    # Check column conflicts
+    for j in range(grid_size):
+        col = grid[:, j]
+        for num in range(1, grid_size + 1):
+            positions = np.where(col == num)[0]
+            if len(positions) > 1:
+                for pos in positions:
+                    conflicts['col'].append((pos, j))
+
+    # Check box conflicts
+    for box_row in range(box_size):
+        for box_col in range(box_size):
+            start_row = box_row * box_size
+            start_col = box_col * box_size
+            box = grid[start_row:start_row + box_size, start_col:start_col + box_size]
+            for num in range(1, grid_size + 1):
+                positions = np.argwhere(box == num)
+                if len(positions) > 1:
+                    for pos in positions:
+                        conflicts['box'].append((start_row + pos[0], start_col + pos[1]))
+
+    # Remove duplicates
+    conflicts['row'] = list(set(conflicts['row']))
+    conflicts['col'] = list(set(conflicts['col']))
+    conflicts['box'] = list(set(conflicts['box']))
+
+    return conflicts
+
+
+def is_solved(grid: np.ndarray) -> bool:
+    """Check if the Sudoku puzzle is completely solved."""
+    grid_size = grid.shape[0]
+
+    # Check if all cells are filled
+    if np.any(grid == 0):
+        return False
+
+    # Check if there are any conflicts
+    conflicts = find_conflicts(grid, grid)
+    return len(conflicts['row']) == 0 and len(conflicts['col']) == 0 and len(conflicts['box']) == 0
+
+
+def generate_sudoku_puzzle(grid_size: int = 9, difficulty: str = "easy", seed: int = None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generate a Sudoku puzzle with a unique solution.
+
+    Args:
+        grid_size: Size of the grid (4, 9, or 16)
+        difficulty: Difficulty level ("easy", "medium", "hard")
+        seed: Random seed for reproducibility
+
+    Returns:
+        Tuple of (puzzle_grid, solution_grid) where puzzle_grid has some cells filled
+        and solution_grid is the complete solution
+    """
+    if seed is not None:
+        random.seed(seed)
+        np.random.seed(seed)
+
+    # Create a solved grid first
+    solution_grid = np.zeros((grid_size, grid_size), dtype=int)
+
+    # Fill the grid using backtracking
+    def fill_grid(grid):
+        empty_cells = list(zip(*np.where(grid == 0)))
+        if not empty_cells:
+            return True
+
+        row, col = empty_cells[0]
+        numbers = list(range(1, grid_size + 1))
+        random.shuffle(numbers)
+
+        for num in numbers:
+            if is_valid_placement(grid, row, col, num):
+                grid[row, col] = num
+                if fill_grid(grid):
+                    return True
+                grid[row, col] = 0
+
+        return False
+
+    fill_grid(solution_grid)
+
+    # Create puzzle by removing numbers based on difficulty
+    puzzle_grid = solution_grid.copy()
+    cells_to_remove = {
+        "easy": int(grid_size * grid_size * 0.4),    # Remove 40% of cells
+        "medium": int(grid_size * grid_size * 0.5),  # Remove 50% of cells
+        "hard": int(grid_size * grid_size * 0.6),    # Remove 60% of cells
+    }
+
+    num_to_remove = cells_to_remove.get(difficulty, cells_to_remove["easy"])
+    cells = [(i, j) for i in range(grid_size) for j in range(grid_size)]
+    random.shuffle(cells)
+
+    for i in range(num_to_remove):
+        row, col = cells[i]
+        puzzle_grid[row, col] = 0
+
+    return puzzle_grid, solution_grid
+
+
+def format_grid_simple(grid: np.ndarray) -> str:
+    """Format the grid as a simple string representation."""
+    grid_size = grid.shape[0]
+    box_size = get_box_size(grid_size)
+    lines = []
+
+    for i, row in enumerate(grid):
+        if i > 0 and i % box_size == 0:
+            lines.append("-" * (grid_size * 2 + box_size - 1))
+
+        row_str = ""
+        for j, val in enumerate(row):
+            if j > 0 and j % box_size == 0:
+                row_str += "| "
+            row_str += (str(val) if val != 0 else ".") + " "
+        lines.append(row_str.rstrip())
+
+    return "\n".join(lines)
+
+
+def format_grid_with_conflicts(grid: np.ndarray, initial_grid: np.ndarray,
+                                 conflicts: Dict[str, List[Tuple[int, int]]]) -> str:
+    """Format the grid with conflict markers."""
+    grid_size = grid.shape[0]
+    box_size = get_box_size(grid_size)
+    lines = []
+
+    # Collect all conflicting cells
+    all_conflicts = set(conflicts['row'] + conflicts['col'] + conflicts['box'])
+
+    for i, row in enumerate(grid):
+        if i > 0 and i % box_size == 0:
+            lines.append("-" * (grid_size * 3 + box_size - 1))
+
+        row_str = ""
+        for j, val in enumerate(row):
+            if j > 0 and j % box_size == 0:
+                row_str += "| "
+
+            if val == 0:
+                row_str += " . "
+            elif initial_grid[i, j] != 0:
+                # Initial cell (immutable)
+                row_str += f"[{val}]"
+            elif (i, j) in all_conflicts:
+                # Conflict cell
+                row_str += f"*{val}*"
+            else:
+                # User-placed cell (valid)
+                row_str += f" {val} "
+
+        lines.append(row_str.rstrip())
+
+    return "\n".join(lines)

ragen/env/webshop/__init__.py

@@ -0,0 +1,15 @@
+"""
+WebShop environment for interactive e-commerce task.
+
+Original Source: WebShop (https://github.com/princeton-nlp/WebShop)
+Citation: Yao et al. (2022). WebShop: Towards Scalable Real-World Web Interaction with Grounded Language Agents
+Paper: https://arxiv.org/abs/2207.01206
+License: MIT
+
+This implementation uses a minimal version of the WebShop environment
+adapted for the RAGEN framework.
+"""
+from .env import WebShopEnv
+from .config import WebShopEnvConfig
+
+__all__ = ["WebShopEnv", "WebShopEnvConfig"]

ragen/env/webshop/config.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from webshop_minimal.utils import (
+    DEFAULT_FILE_PATH,
+)
+
+@dataclass
+class WebShopEnvConfig:
+    """Configuration for WebAgentText environment"""
+    dataset: str = field(
+        default="small",
+        metadata={"description": "Small or full dataset"}
+    )
+    observation_mode: str = field(
+        default="text", 
+        metadata={"choices": ["html", "text"]}
+    )
+    file_path: str = field(
+        default=DEFAULT_FILE_PATH, 
+        metadata={"description": "File path for SimServer"}
+    )  # TODO: Remove hardcoded file path
+    server: Any = field(
+        default=None, 
+        metadata={"description": "If None, use SimServer"}
+    )
+    filter_goals: Any = field(
+        default=None, 
+        metadata={"description": "SimServer arg: Custom function to filter specific goals for consideration"}
+    )
+    limit_goals: int = field(
+        default=-1, 
+        metadata={"description": "SimServer arg: Limit the number of goals available"}
+    )
+    num_products: int = field(
+        default=None, 
+        metadata={"description": "SimServer arg: Number of products to search across"}
+    )
+    human_goals: bool = field(
+        default=False, 
+        metadata={"description": "SimServer arg: Load human goals if True, otherwise synthetic goals"}
+    )
+    show_attrs: bool = field(
+        default=False, 
+        metadata={"description": "SimServer arg: Whether to show additional attributes"}
+    )

ragen/env/webshop/env.py

@@ -0,0 +1,202 @@
+from ragen.env.base import BaseLanguageBasedEnv
+from ragen.env.webshop.config import WebShopEnvConfig
+from webshop_minimal import WebAgentTextEnv, init_basedir
+from webshop_minimal.engine import parse_action
+from typing import Optional, Union
+from ragen.utils import all_seed
+import random
+import string
+import uuid
+
+
+# Define global constant for render instructions
+RENDER_INSTRUCTIONS = [
+    "We must buy a product within 10 actions. It doesn't have to match perfectly with description.",
+    "Search term should not include details like size, color.",
+    "Never search for more than 2 times.",
+    "Do not be too strict about the description, it's more important to buy one that is close enough within action limit.",
+    "Prioritize click a product in the current page over going to next page.",
+    "Almost never click[next >] for more than 2 times.",
+    "Almost never click[< prev] unless you are sure the product is on one of the previous pages.",
+    "If you have less than 3 actions left, just buy the first product you see in the current page.",
+    "If an matching option exists, make sure to click[size] then click[color], one at a time, before click[buy now], but don't have to if only 1 action left, in that case you just click[buy now]. Never click description."
+]
+
+
+class WebShopEnv(BaseLanguageBasedEnv, WebAgentTextEnv):
+    def __init__(self, config: Optional[WebShopEnvConfig] = None, **kwargs: any) -> None:
+        """
+        Adapter for WebAgentTextEnv to conform to the BaseLanguageBasedEnv interface.
+        """
+        self.config = config or WebShopEnvConfig()
+        self.observation_mode = self.config.observation_mode
+        self.file_path = self.config.file_path
+        self.server = self.config.server
+        self.filter_goals = self.config.filter_goals
+        self.limit_goals = self.config.limit_goals
+        self.num_products = self.config.num_products
+        self.human_goals = self.config.human_goals
+        self.show_attrs = self.config.show_attrs
+        self.render_cache = None
+        if self.config.dataset:
+            init_basedir(self.config.dataset)
+
+        BaseLanguageBasedEnv.__init__(self)
+        WebAgentTextEnv.__init__(
+            self,
+            observation_mode=self.observation_mode,
+            file_path=self.file_path,
+            server=self.server,
+            filter_goals=self.filter_goals,
+            limit_goals=self.limit_goals,
+            num_products=self.num_products,
+            human_goals=self.human_goals,
+            show_attrs=self.show_attrs,
+            session_prefix=str(uuid.uuid4().hex), # we use a random session prefix to avoid collision
+            **kwargs
+        )
+
+    def _get_permuted_index(self, idx, seed=42):
+        """Map index to a deterministically permuted index in the same range.
+        
+        Args:
+            idx: The original index
+            seed: Random seed to ensure deterministic permutation
+            
+        Returns:
+            int: The permuted index
+        """
+        # Create a cache key based on goals length and seed
+        cache_key = f"perm_{len(self.server.goals)}_{seed}"
+        
+        # Create or retrieve the permutation map
+        if not hasattr(self, cache_key):
+            # Initialize with fixed seed
+            rng = random.Random(seed)
+            
+            # Generate the full permutation
+            indices = list(range(len(self.server.goals)))
+            rng.shuffle(indices)
+            
+            # Store the permutation as an instance attribute
+            setattr(self, cache_key, indices)
+        
+        # Look up the permuted index
+        permutation = getattr(self, cache_key)
+        return permutation[idx]
+
+    def reset(self, seed=None, mode="train", session: Optional[Union[str, int]] = None, instruction_text: Optional[str] = None) -> any:
+        """
+        Reset the environment and return the initial observation.
+
+        Args:
+            session (str|int|None): The new session ID.
+            instruction_text (str|None): Optional new instruction text.
+
+        Returns:
+            The initial observation.
+        """
+        if seed is None:
+            # This is from within webshop_minimal. Need to reset with seed later.
+            return None
+        if mode == "test":
+            goal_idx = seed % 500
+        elif mode == "val":
+            goal_idx = seed % 1000 + 500
+        elif mode == "train":
+            goal_idx = seed % (len(self.server.goals) - 1500) + 1500
+        session = self._get_permuted_index(goal_idx) if session is None else session
+        obs, _ = WebAgentTextEnv.reset(self, session=session, instruction_text=instruction_text)
+        self.prepare_render_cache(WebAgentTextEnv.get_instruction_text(self))
+        return obs
+
+    def step(self, action):
+        """
+        Take an action in the environment and return the next observation, reward, done, and info.
+        """
+        orig_available_actions = WebAgentTextEnv.get_available_actions(self)
+        action_name, action_arg = parse_action(action)
+        if action_arg is not None:
+            action_arg = action_arg.lower()
+        action_is_valid = (
+            action_name == "search"
+            and orig_available_actions["has_search_bar"]
+            and action_arg is not None
+            and action_arg != ""
+        ) or (
+            action_name == "click"
+            and action_arg in orig_available_actions["clickables"]
+            and action_arg != "search"
+        )
+        last_observation = self.observation
+        state, raw_reward, done, info = WebAgentTextEnv.step(self, action)
+        reward = 1.0 if raw_reward >= 1.0 else 0.0
+        self.prepare_render_cache(self.observation)
+            
+        info = (info or {}).copy()
+        info.update({
+            "reward": reward,
+            "raw_reward": raw_reward,
+            "action_is_effective": self.observation != last_observation,
+            "action_is_valid": action_is_valid,
+            "success": 1 if reward == 1 else 0,
+            "success_purchase": 1 if done else 0,
+            "success_find": 1 if reward == 1 else 0,
+            "end_of_page": 1 if tuple(self.get_available_actions()) == ('click[back to search]', 'click[< prev]') else 0,
+        })
+        return self.observation, reward, done, info
+
+    def render(self, mode=None):
+        """
+        Render the environment.
+        """
+        return self.render_cache
+
+    def close(self):
+        """
+        Close the environment.
+        """
+        WebAgentTextEnv.close(self)
+
+    def prepare_render_cache(self, observation: str):
+        """
+        Prepare the render cache for the environment.
+        """
+        available_actions = self.get_available_actions()
+        self.render_cache = observation + "."
+        self.render_cache += "\n".join(RENDER_INSTRUCTIONS)
+        self.render_cache += "\n You must choose from these actions:" + ", ".join(available_actions) + "."
+        
+
+    def get_available_actions(self):
+        """
+        Parse the available actions in the environment to a list of strings.
+        """
+        orig_available_actions = WebAgentTextEnv.get_available_actions(self)
+        available_actions = []
+
+        if orig_available_actions['has_search_bar']:
+            available_actions.append('search[<content>]')
+
+        for clickable in orig_available_actions['clickables']:
+            if clickable != 'search':
+                available_actions.append(f'click[{clickable}]')
+        # TODO: we may need to purge the case when available_actions == ['click[back to search]', 'click[< prev]', 'click[next >]']
+        is_end_of_page = tuple(available_actions) == ('click[back to search]', 'click[< prev]', 'click[next >]')
+        if is_end_of_page:
+            available_actions.remove('click[next >]')
+        return available_actions
+
+if __name__ == '__main__':
+    env = WebShopEnv()
+    print(env.reset())
+    while True:
+        print(env.observation)
+        print(env.server.user_sessions[env.session]['goal']['asin'])
+        print(f"Available actions: {env.get_available_actions()}")
+        action = input("Enter action: ")
+        if action == 'q':
+            break
+        obs, reward, done, info = env.step(action)
+        print(obs, reward, done, info)
+    env.close()