Add files using upload-large-folder tool

ragen/__init__.py

@@ -0,0 +1,6 @@
+"""RAGEN package initialisation."""
+
+from ragen.patches import apply_omega_conf_patch
+
+# Ensure VERL config instantiation accepts RAGEN-specific extensions.
+apply_omega_conf_patch()

ragen/demo/__init__.py

@@ -0,0 +1 @@
+# Give an instant demo about LLM rollout and how they process the environment

ragen/demo/run.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from ragen.llm_agent.agent_proxy import LLMAgentProxy, VllmWrapperWg
+from verl import DataProto
+from transformers import AutoTokenizer
+import hydra
+import os
+import time
+import asyncio
+
+# --- Global agent object
+agent_proxy = None
+
+# --- Initialization function
+@hydra.main(version_base=None, config_path="../../config", config_name="stream")
+def init_agent(config):
+    global agent_proxy
+    os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn"
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(config.system.CUDA_VISIBLE_DEVICES)
+    tokenizer = AutoTokenizer.from_pretrained(config.actor_rollout_ref.model.path)
+    actor_wg = VllmWrapperWg(config, tokenizer)
+    agent_proxy = LLMAgentProxy(config, actor_wg, tokenizer)
+
+# --- Streaming rollout generator
+def rollout_stream():
+    lm_inputs = DataProto(batch=None, non_tensor_batch=None, meta_info={
+        'eos_token_id': 151645,
+        'pad_token_id': 151643,
+        'recompute_log_prob': False,
+        'do_sample': True,
+        'validate': True
+    })
+    env_outputs = agent_proxy.val_es_manager.reset()
+    assert len(env_outputs) == 1
+
+    for turn_idx in range(agent_proxy.config.agent_proxy.max_turn):
+        lm_inputs = agent_proxy.val_ctx_manager.get_lm_inputs(env_outputs, prepare_for_update=False)
+        lm_inputs.meta_info = {'eos_token_id': 151645, 'pad_token_id': 151643, 'recompute_log_prob': False, 'do_sample': True, 'validate': True}
+        lm_outputs = agent_proxy.generate_sequences(lm_inputs)
+
+        response_texts = lm_outputs.non_tensor_batch['response_texts']
+        yield f"\n--- Turn {turn_idx + 1} ---\n"
+        yield response_texts[0]
+
+        env_inputs = agent_proxy.val_ctx_manager.get_env_inputs(lm_outputs)
+        env_outputs = agent_proxy.val_es_manager.step(env_inputs)
+        if len(env_outputs) == 0:
+            break
+        yield env_outputs[0]['history'][-1]['state']
+
+# --- Gradio Streaming Setup
+async def streaming_demo():
+    stream = rollout_stream()
+    output = ""
+    for chunk in stream:
+        output += chunk
+        yield output
+
+def main():
+    init_agent()
+
+    with gr.Blocks() as demo:
+        output_box = gr.Textbox(label="Agent Output", lines=20)
+        run_button = gr.Button("Run Agent")
+
+        run_button.click(fn=streaming_demo, inputs=[], outputs=output_box)
+
+    demo.queue()
+    demo.launch()
+
+if __name__ == "__main__":
+    main()

ragen/env/__init__.py

@@ -0,0 +1,59 @@
+# from .alfworld.config import AlfredEnvConfig
+# from .alfworld.env import AlfredTXTEnv
+from .bandit.config import BanditEnvConfig
+from .bandit.env import BanditEnv
+from .countdown.config import CountdownEnvConfig
+from .countdown.env import CountdownEnv
+from .sokoban.config import SokobanEnvConfig
+from .sokoban.env import SokobanEnv
+from .frozen_lake.config import FrozenLakeEnvConfig
+from .frozen_lake.env import FrozenLakeEnv
+from .metamathqa.env import MetaMathQAEnv
+from .metamathqa.config import MetaMathQAEnvConfig
+from .lean.config import LeanEnvConfig
+from .lean.env import LeanEnv
+from .game_2048.config import Game2048EnvConfig
+from .game_2048.env import Game2048Env
+from .blackjack.config import BlackjackEnvConfig
+from .blackjack.env import BlackjackEnv
+from .rubikscube.config import RubiksCube2x2Config
+from .rubikscube.env import RubiksCube2x2Env
+from .sudoku.config import SudokuEnvConfig
+from .sudoku.env import SudokuEnv
+
+
+REGISTERED_ENVS = {
+    'bandit': BanditEnv,
+    'countdown': CountdownEnv,
+    'sokoban': SokobanEnv,
+    'frozen_lake': FrozenLakeEnv,
+    # 'alfworld': AlfredTXTEnv,
+    'metamathqa': MetaMathQAEnv,
+    'lean': LeanEnv,
+    'game_2048': Game2048Env,
+    'blackjack': BlackjackEnv,
+    'rubikscube': RubiksCube2x2Env,
+    'sudoku': SudokuEnv,
+}
+
+REGISTERED_ENV_CONFIGS = {
+    'bandit': BanditEnvConfig,
+    'countdown': CountdownEnvConfig,
+    'sokoban': SokobanEnvConfig,
+    'frozen_lake': FrozenLakeEnvConfig,
+    # 'alfworld': AlfredEnvConfig,
+    'metamathqa': MetaMathQAEnvConfig,
+    'lean': LeanEnvConfig,
+    'game_2048': Game2048EnvConfig,
+    'blackjack': BlackjackEnvConfig,
+    'rubikscube': RubiksCube2x2Config,
+    'sudoku': SudokuEnvConfig,
+}
+
+try:
+    from .webshop.env import WebShopEnv
+    from .webshop.config import WebShopEnvConfig
+    REGISTERED_ENVS['webshop'] = WebShopEnv
+    REGISTERED_ENV_CONFIGS['webshop'] = WebShopEnvConfig
+except ImportError:
+    pass

ragen/env/alfworld_old/alfworld_config.yaml

@@ -0,0 +1,145 @@
+dataset:
+  data_path: '$ALFWORLD_DATA/json_2.1.1/train'
+  eval_id_data_path: '$ALFWORLD_DATA/json_2.1.1/valid_seen'    # null/None to disable
+  eval_ood_data_path: '$ALFWORLD_DATA/json_2.1.1/valid_unseen' # null/None to disable
+  num_train_games: -1                                          # max training games (<=0 indicates full dataset)
+  num_eval_games: -1                                           # max evaluation games (<=0 indicates full dataset)
+
+logic:
+  domain: '$ALFWORLD_DATA/logic/alfred.pddl'                   # PDDL domain file that defines the world dynamics
+  grammar: '$ALFWORLD_DATA/logic/alfred.twl2'                  # Grammar file that defines the text feedbacks
+
+env:
+  type: 'AlfredTWEnv'                                          # 'AlfredTWEnv' or 'AlfredThorEnv' or 'AlfredHybrid'
+  # regen_game_files: False                                    # [Deprecated] Use script `alfworld-generate` instead.
+  domain_randomization: False                                  # shuffle Textworld print order and object id nums
+  task_types: [1, 2, 3, 4, 5, 6]                               # task-type ids: 1 - Pick & Place, 2 - Examine in Light, 3 - Clean & Place, 4 - Heat & Place, 5 - Cool & Place, 6 - Pick Two & Place
+  expert_timeout_steps: 150                                    # max steps before timeout for expert to solve the task
+  expert_type: "handcoded"                                     # 'handcoded' or 'planner'. Note: the planner is very slow for real-time use
+  goal_desc_human_anns_prob: 0.0                               # prob of using human-annotated goal language instead of templated goals (1.0 indicates all human annotations from ALFRED)
+
+  hybrid:
+    start_eps: 100000                                          # starting episode of hybrid training, tw-only training upto this point
+    thor_prob: 0.5                                             # prob of AlfredThorEnv during hybrid training
+    eval_mode: "tw"                                            # 'tw' or 'thor' - env used for evaluation during hybrid training
+
+  thor:
+    screen_width: 300                                          # width of THOR window
+    screen_height: 300                                         # height of THOR window
+    smooth_nav: False                                          # smooth rotations, looks, and translations during navigation (very slow)
+    save_frames_to_disk: False                                 # save frame PNGs to disk (useful for making videos)
+    save_frames_path: './videos/'                              # path to save frame PNGs
+
+controller:
+  type: 'oracle'                                               # 'oracle' or 'oracle_astar' or 'mrcnn' or 'mrcnn_astar' (aka BUTLER)
+  debug: False
+  load_receps: True                                            # load receptacle locations from precomputed dict (if available)
+
+mask_rcnn:
+  pretrained_model_path: '$ALFWORLD_DATA/detectors/mrcnn.pth'
+
+general:
+  random_seed: 42
+  use_cuda: True                                               # disable this when running on machine without cuda
+  visdom: False                                                # plot training/eval curves, run with visdom server
+  task: 'alfred'
+  training_method: 'dagger'                                    # 'dqn' or 'dagger'
+  save_path: './training/'                                     # path to save pytorch models
+  observation_pool_capacity: 3                                 # k-size queue, 0 indicates no observation
+  hide_init_receptacles: False                                 # remove initial observation containing navigable receptacles
+
+  training:
+    batch_size: 10
+    max_episode: 50000
+    smoothing_eps: 0.1
+    optimizer:
+      learning_rate: 0.001
+      clip_grad_norm: 5
+
+  evaluate:
+    run_eval: True
+    batch_size: 10
+    env:
+      type: "AlfredTWEnv"
+
+  checkpoint:
+    report_frequency: 1000                                    # report every N episode
+    experiment_tag: 'test'                                    # name of experiment
+    load_pretrained: False                                    # during test, enable this so that the agent load your pretrained model
+    load_from_tag: 'not loading anything'                     # name of pre-trained model to load in save_path
+
+  model:
+    encoder_layers: 1
+    decoder_layers: 1
+    encoder_conv_num: 5
+    block_hidden_dim: 64
+    n_heads: 1
+    dropout: 0.1
+    block_dropout: 0.1
+    recurrent: True
+
+rl:
+  action_space: "admissible"                                  # 'admissible' (candidates from text engine) or 'generation' (seq2seq-style generation) or 'beam_search_choice' or 'exhaustive' (not working)
+  max_target_length: 20                                       # max token length for seq2seq generation
+  beam_width: 10                                              # 1 means greedy
+  generate_top_k: 3
+
+  training:
+    max_nb_steps_per_episode: 50                              # terminate after this many steps
+    learn_start_from_this_episode: 0                          # delay updates until this epsiode
+    target_net_update_frequency: 500                          # sync target net with online net per this many epochs
+
+  replay:
+    accumulate_reward_from_final: True
+    count_reward_lambda: 0.0                                  # 0 to disable
+    novel_object_reward_lambda: 0.0                           # 0 to disable
+    discount_gamma_game_reward: 0.9
+    discount_gamma_count_reward: 0.5
+    discount_gamma_novel_object_reward: 0.5
+    replay_memory_capacity: 500000                            # adjust this depending on your RAM size
+    replay_memory_priority_fraction: 0.5
+    update_per_k_game_steps: 5
+    replay_batch_size: 64
+    multi_step: 3
+    replay_sample_history_length: 4
+    replay_sample_update_from: 2
+
+  epsilon_greedy:
+    noisy_net: False                                          # if this is true, then epsilon greedy is disabled
+    epsilon_anneal_episodes: 1000                             # -1 if not annealing
+    epsilon_anneal_from: 0.3
+    epsilon_anneal_to: 0.1
+
+dagger:
+  action_space: "generation"                                  # 'admissible' (candidates from text engine) or 'generation' (seq2seq-style generation) or 'exhaustive' (not working)
+  max_target_length: 20                                       # max token length for seq2seq generation
+  beam_width: 10                                              # 1 means greedy
+  generate_top_k: 5
+  unstick_by_beam_search: False                               # use beam-search for failed actions, set True during evaluation
+
+  training:
+    max_nb_steps_per_episode: 50                              # terminate after this many steps
+
+  fraction_assist:
+    fraction_assist_anneal_episodes: 50000
+    fraction_assist_anneal_from: 1.0
+    fraction_assist_anneal_to: 0.01
+
+  fraction_random:
+    fraction_random_anneal_episodes: 0
+    fraction_random_anneal_from: 0.0
+    fraction_random_anneal_to: 0.0
+
+  replay:
+    replay_memory_capacity: 500000
+    update_per_k_game_steps: 5
+    replay_batch_size: 64
+    replay_sample_history_length: 4
+    replay_sample_update_from: 2
+
+vision_dagger:
+  model_type: "resnet"                                        # 'resnet' (whole image features) or 'maskrcnn_whole' (whole image MaskRCNN feats) or 'maskrcnn' (top k MaskRCNN detection feats) or 'no_vision' (zero vision input)
+  resnet_fc_dim: 64
+  maskrcnn_top_k_boxes: 10                                    # top k box features
+  use_exploration_frame_feats: False                          # append feats from initial exploration (memory intensive!)
+  sequence_aggregation_method: "average"                      # 'sum' or 'average' or 'rnn'

ragen/env/alfworld_old/config.py

@@ -0,0 +1,26 @@
+from ragen.env.base import BaseEnvConfig
+from dataclasses import dataclass, field
+from typing import Dict
+
+@dataclass
+class AlfredEnvConfig(BaseEnvConfig):
+    """configuration for text world AlfredEnv"""
+    config_file: str = "./ragen/env/alfworld/alfworld_config.yaml"
+    action_lookup: Dict[int, str] = field(default_factory=lambda: {
+        1: "look",
+        2: "inventory",
+        3: "go to <receptacle>",
+        4: "open <receptacle>",
+        5: "close <receptacle>",
+        6: "take <object> from <receptacle>",
+        7: "move <object> to <receptacle>",
+        8: "examine <something>",
+        9: "use <object>",
+        10: "heat <object> with <receptacle>",
+        11: "clean <object> with <receptacle>",
+        12: "cool <object> with <receptacle>",
+        13: "slice <object> with <object>"
+    })
+    format_score: float = 0.1
+    score: float = 1.0
+    render_mode: str = "text"

ragen/env/alfworld_old/env.py

@@ -0,0 +1,158 @@
+"""
+This is the environment for the ALFRED dataset.
+author: Qineng Wang
+date: 2025-03-30
+"""
+import os
+import random
+import textworld
+import textworld.gym
+import numpy as np
+import alfworld.agents.modules.generic as generic
+from alfworld.agents.environment.alfred_tw_env import AlfredTWEnv, AlfredDemangler, AlfredInfos
+from ragen.env.base import BaseLanguageBasedEnv
+from ragen.env.alfworld.config import AlfredEnvConfig
+from ragen.env.alfworld.utils import load_config, check_format
+
+class AlfredTXTEnv(BaseLanguageBasedEnv):
+
+    # raw_env: AlfredTWEnv = AlfredTWEnv(config=load_config(AlfredEnvConfig().config_file), train_eval="train")
+    # print("initializing alfworld env")
+    # NOTE Currently raw_env cannot customize config.
+
+    def __init__(self, config: AlfredEnvConfig = AlfredEnvConfig(), mode='eval_in_distribution'):
+        # mode: "train", "eval_in_distribution" or "eval_out_of_distribution"
+        super().__init__()
+        self.config = config
+        self.ACTION_LOOKUP = self.config.action_lookup
+        raw_env_config = load_config(self.config.config_file)
+        self.raw_env = AlfredTWEnv(config=raw_env_config, train_eval=mode)
+        self.num_games = self.raw_env.num_games
+        self.game_files = self.raw_env.game_files
+        print(f"Overall we have {len(self.game_files)} games in split={self.raw_env.train_eval}")
+        self.alfred_env = self.raw_env.init_env(batch_size=1)
+        self.current_game_file = None
+        self.render_cache = None
+        self.available_actions = None
+        self.render_mode = self.config.render_mode
+        assert self.render_mode == 'text'
+    
+    def reset(self, seed=None, mode=None):
+        """
+        Reset the environment with a specific seed.
+        If seed is provided, it deterministically selects a specific game file.
+        """
+        try:
+            if mode == "test":
+                if seed is None:
+                    raise ValueError("Seed must be provided in test mode.")
+                selected_game = self.game_files[seed]
+            else:
+                if seed is not None:
+                    np.random.seed(seed)
+                    random.seed(seed)
+                    game_idx = seed % len(self.game_files)
+                    selected_game = self.game_files[game_idx]
+                else:
+                    selected_game = random.choice(self.game_files)
+            
+            self.current_game_file = selected_game
+            
+            if hasattr(self, 'alfred_env') and self.alfred_env is not None:
+                self.alfred_env.close()
+            
+            request_infos = textworld.EnvInfos(won=True, admissible_commands=True, extras=["gamefile"])
+            config = load_config(self.config.config_file)
+            wrappers = [AlfredDemangler(), AlfredInfos()]
+            max_steps = config["rl"]["training"]["max_nb_steps_per_episode"]
+            
+            env_id = textworld.gym.register_game(
+                selected_game, 
+                request_infos=request_infos,
+                batch_size=1,
+                asynchronous=False,
+                max_episode_steps=max_steps,
+                wrappers=wrappers
+            )
+            
+            self.alfred_env = textworld.gym.make(env_id)
+            
+            obs, info = self.alfred_env.reset()
+            self.render_cache = obs[0]
+            self.available_actions = info["admissible_commands"][0]
+            self.instruction_text = obs[0]
+            return self.render_cache
+            
+        except (RuntimeError, RuntimeWarning) as e:
+            print(f"Error in reset: {e}")
+            next_seed = abs(hash(str(seed))) % (2 ** 32) if seed is not None else None
+            return self.reset(next_seed)
+    
+    def compute_score(self, base_reward, valid_action, done):
+        """
+        Compute the score based on the base reward, format reward, and completion status.
+        
+        Args:
+            base_reward: The reward from the environment
+            valid_action: Whether the action format is valid
+            done: Whether the episode is finished
+            
+        Returns:
+            The computed score
+        """
+        if done:
+            return self.config.score + self.config.format_score + base_reward
+        elif valid_action:
+            return base_reward + self.config.format_score
+        else:
+            return 0.0
+    
+    def step(self, action: str):
+        """
+        Take a step in the environment using the provided action string.
+        The action must match one of the templates in ACTION_LOOKUP.
+        """
+        valid_action = check_format(action, self.ACTION_LOOKUP.values())
+        action_is_available = True if action in self.available_actions else False
+        if not valid_action:
+            return f"Invalid action format: {action}", 0, False, {"action_is_effective": False, "action_is_valid": False, "success": False}
+        
+        obs, rewards, dones, infos = self.alfred_env.step([action])  # BatchEnv expects a list of commands
+        observation = obs[0]
+        self.available_actions = infos["admissible_commands"][0]
+        self.render_cache = observation
+        base_reward = rewards[0]
+        done = dones[0]
+        info = {"action_is_effective": True, "action_is_valid": action_is_available, "success": infos["won"][0]}
+        
+        reward = self.compute_score(base_reward, valid_action, done)
+        
+        return self.render_cache, reward, done, info
+    
+    def render(self):
+        return self.render_cache
+    
+    def close(self):
+        self.render_cache = None
+        self.alfred_env.close()
+
+if __name__ == "__main__":
+    import os
+    os.environ["ALFWORLD_DATA"] = "./data/alfworld"
+    env = AlfredTXTEnv()
+    
+    # Test resetting environment with same seed
+    print("\n\n=== Testing environment reset with same seed ===")
+    seed = 42
+    obs1 = env.reset(seed)
+    for i in range(52):
+        print("Observation:", obs1)
+        action = "go to shelf 2"
+        if action.lower() == "exit":
+            break
+        obs1, reward, done, info = env.step(action)
+        
+        print(f"Reward: {reward}, Done: {done}, Info: {info}")
+        if done:
+            break
+    

ragen/env/alfworld_old/utils.py

@@ -0,0 +1,53 @@
+import argparse
+import os
+import yaml
+import re
+from typing import List, Any
+
+def load_config(config_file: str, params: List[str] = []):
+    assert os.path.exists(config_file), f"Invalid config file: {config_file}"
+    with open(config_file) as reader:
+        config = yaml.safe_load(reader)
+    # Parse overriden params.
+    for param in params:
+        fqn_key, value = param.split("=")
+        entry_to_change = config
+        keys = fqn_key.split(".")
+        for k in keys[:-1]:
+            entry_to_change = entry_to_change[k]
+        entry_to_change[keys[-1]] = value
+    return config
+
+def check_format(action: str, templates: Any) -> bool:
+    """
+    Validate that the action matches one of our action templates.
+    Returns True if valid, False otherwise.
+    """
+    if "None" in action:
+        return False
+    
+    # Skip validation for basic actions that don't have placeholders
+    basic_actions = ["look", "inventory"]
+    if action in basic_actions:
+        return True
+        
+    # Check if the action follows any of our templates
+    for template in templates:
+        # Skip "None" and basic actions we already checked
+        if template == "None" or template in basic_actions:
+            continue
+            
+        # Convert template to regex pattern
+        # Replace <something> with regex that matches any word(s)
+        pattern = template.replace("<receptacle>", "([\\w\\s]+)") \
+                        .replace("<object>", "([\\w\\s]+)") \
+                        .replace("<something>", "([\\w\\s]+)")
+        pattern = f"^{pattern}$"  # Match the entire string
+        
+        if re.match(pattern, action):
+            return True
+            
+    return False
+
+def check_correctness(action: str, target: str) -> bool:
+    ...

ragen/env/bandit/__init__.py

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

ragen/env/bandit/config.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Dict
+
+@dataclass
+class BanditEnvConfig:
+    split: str = "train"
+    action_space_start: int = 1
+    lo_arm_score: float = 0.1
+    hi_arm_loscore: float = 0.0
+    hi_arm_hiscore: float = 1.0
+    hi_arm_hiscore_prob: float = 0.25
+    render_mode: str = "text"
+    action_lookup: Dict[int, str] = None # defined in env.py
+
+
+ARM_NAMES = {
+    "train": [
+        ("Teacher", "Trader"),
+        ("Nurse", "StartupFounder"),
+        ("Librarian", "Investor"),
+        ("Accountant", "StockBroker"),
+        ("Engineer", "RealEstateAgent"),
+        ("Pharmacist", "Musician"),
+        ("Clerk", "Freelancer"),
+        ("Technician", "Youtuber"),
+        ("Planner", "Artist"),
+        ("Postman", "Pilot"),
+        ("Banker", "VentureCapitalist"),
+        ("Gardener", "Cryptominer"),
+    ],
+    "test": [
+        ("Receptionist", "Explorer"),
+        ("Archivist", "Filmmaker"),
+        ("Bookkeeper", "Consultant"),
+        ("SocialWorker", "Photographer"),
+        ("Mechanic", "GameDesigner"),
+        ("Secretary", "Entrepreneur"),
+        ("Cashier", "DataScientist"),
+        ("CivilServant", "StartupAccelerator"),
+    ],
+}

ragen/env/bandit/env.py

@@ -0,0 +1,144 @@
+import gymnasium as gym
+import numpy as np
+from ragen.env.base import BaseDiscreteActionEnv
+from .config import BanditEnvConfig, ARM_NAMES
+
+INIT_PROMPT = """You are playing a bandit game. Goal: Maximize your total reward by choosing which arm to pull. 
+Game Rules: 
+1. There are 2 arms, named {name_a} and {name_b}
+2. Each arm has its own reward distribution, related to their names. 
+3. Analyze the symbolic meaning of each arm's name to guess how their reward distribution might behave.
+4. Based on the symbolic meaning of their names, which arm do you think is more likely to give higher rewards on average? Choose between {name_a} and {name_b}, and output like <answer> {name_a} </answer> or <answer> {name_b} </answer>.
+"""
+
+# INIT_PROMPT = """You are playing a bandit game. Goal: Maximize your total reward by choosing which arm to pull.
+# Game Rules:
+# 1. There are 2 arms, named {name_a} and {name_b}.
+# 2. Each arm has its own reward distribution, related to their names.
+# 3. You need to analyze the symbolic meaning of each arm's name to guess their reward potential.
+
+# Example answer format:
+# <think>
+# <observation>
+# Arm A is named \"{name_a}\". Symbolically, this implies [analysis of name A].
+# Arm B is named \"{name_b}\". Symbolically, this implies [analysis of name B].
+# </observation>
+# Based on the analysis, {name_a} seems to represent risk/low value, while {name_b} implies wealth/stability.
+# <prediction>
+# If I pull {name_b}, I expect a higher average reward because [reasoning].
+# </prediction>
+# </think>
+# <answer> {name_b} </answer>
+
+# A sample full output is as follows:
+# <think>
+# <observation>
+# Arm A is named "Rotten Apple". Symbolically, this implies decay and zero value.
+# Arm B is named "Golden Chalice". Symbolically, this implies treasure and high value.
+# </observation>
+# Comparing the two, the Golden Chalice is clearly superior in potential value.
+# <prediction>
+# Pulling "Golden Chalice" will likely yield a high positive reward, whereas "Rotten Apple" might give zero or negative reward.
+# </prediction>
+# </think>
+# <answer> Golden Chalice </answer>"""
+
+class BanditEnv(BaseDiscreteActionEnv, gym.Env):
+    class_counter = 0
+
+    def __init__(self, config = None):
+        BaseDiscreteActionEnv.__init__(self)
+        self.config = config if config is not None else BanditEnvConfig()
+        self.ACTION_SPACE = gym.spaces.discrete.Discrete(2, start=self.config.action_space_start)
+        self.split = self.config.split
+        self.render_cache = None
+        self.render_mode = self.config.render_mode
+        self.internal_seed = BanditEnv.class_counter
+        BanditEnv.class_counter += 1
+        assert self.render_mode == 'text'
+        
+    def _randomize_arms(self):
+        start = self.config.action_space_start
+        if self.np_random.random() < 0.5:
+            self.ACTION_LOOKUP = {
+                start: self.lo_arm_name,
+                start + 1: self.hi_arm_name,
+            }
+        else:
+            self.ACTION_LOOKUP = {
+                start: self.hi_arm_name,
+                start + 1: self.lo_arm_name,
+            }
+        self.config.action_lookup = self.ACTION_LOOKUP
+        self.ARM_IDX_TO_NAME = self.ACTION_LOOKUP
+        self.NAME_TO_ARM_IDX = {name: idx for idx, name in self.ACTION_LOOKUP.items()}
+
+    def _lo_arm_reward(self):
+        return self.config.lo_arm_score
+
+    def _hi_arm_reward(self):
+        if self.np_random.random() < self.config.hi_arm_hiscore_prob:
+            return self.config.hi_arm_hiscore
+        return self.config.hi_arm_loscore
+
+    def render(self):
+        return self.render_cache
+
+    def reset(self, seed=None, mode=None):
+        if seed is not None:
+            gym.Env.reset(self, seed=seed + self.internal_seed) # add internal seed to differ random reward generator inside the same group
+        else:
+            gym.Env.reset(self, seed=seed)
+        index = int(self.np_random.random() * len(ARM_NAMES[self.split]))
+        self.lo_arm_name, self.hi_arm_name = ARM_NAMES[self.split][index]
+        self._randomize_arms()
+        pos1 = self.config.action_space_start
+        pos2 = pos1 + 1
+        machine1 = self.ARM_IDX_TO_NAME[pos1]
+        machine2 = self.ARM_IDX_TO_NAME[pos2]
+        self.render_cache = INIT_PROMPT.format(name_a=machine1, name_b=machine2)
+        return self.render_cache
+
+    def step(self, action: int):
+        assert action in self.ACTION_LOOKUP, f"Invalid action: {action}"
+        reward = self.compute_reward(action)
+        arm_name = self.ARM_IDX_TO_NAME[action]
+        next_obs = f"{arm_name}: {reward} points"
+        self.render_cache = next_obs
+        done, info = True, {"action_is_effective": True, "action_is_valid": True, "success": arm_name == self.hi_arm_name}
+        return next_obs, reward, done, info
+    
+    def compute_reward(self, action):
+        arm_name = self.ARM_IDX_TO_NAME[action]
+        if arm_name == self.lo_arm_name:
+            return self._lo_arm_reward()
+        else:
+            return self._hi_arm_reward()
+
+    def get_all_actions(self):
+        return [self.ACTION_SPACE.start, self.ACTION_SPACE.start + 1]
+
+    def render(self):
+        return self.render_cache
+
+    def close(self):
+        self.render_cache = None
+
+if __name__ == "__main__":
+    def run_simulation(env, n_episodes=1000, action=1, start_seed=500):
+        rewards = []
+        for i in range(start_seed, start_seed + n_episodes):
+            env.reset(seed=i)
+            reward = env.step(action)[1]
+            rewards.append(reward)
+        
+        return {
+            'mean_reward': np.mean(rewards),
+            'std_reward': np.std(rewards),
+            'n_episodes': n_episodes,
+            'action': env.ARM_IDX_TO_NAME[action]
+        }
+
+    env = BanditEnv()
+    stats = run_simulation(env)
+    print(f"Arm: {stats['action']}, Reward: {stats['mean_reward']:.3f} ± {stats['std_reward']:.3f}")

ragen/env/base.py

@@ -0,0 +1,100 @@
+from abc import ABC, abstractmethod
+import re
+from typing import Optional, List, Tuple, Any, Dict
+
+class BaseEnv(ABC):
+    """
+    Abstract base class for all environments.
+    The class needs to handle text-based input, input may be invalid
+        - Environment will track the total reward for the trajectory
+
+    """
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def reset(self, seed=None, **kwargs) -> Any:
+        """
+        Reset the environment.
+        NOTE: the environment should be same for the same seed
+        Returns:
+            rendered environment
+        """
+        pass
+
+    @abstractmethod
+    def step(self, action) -> Tuple[Any, float, bool, Dict]:
+        """
+        Execute one step in the environment.
+        NOTE should also handle predefined invalid action (0)
+        Args:
+            action: Action to take, must be in action space, or default invalid action
+            
+        Returns:
+            observation (rendered environment), reward, done, info
+        """
+        pass
+
+    # below are optional methods
+
+    def render(self, mode: str = 'text') -> Any:
+        """Render the environment. Optional method."""
+        pass
+
+    def compute_reward(self, action, **kwargs) -> float:
+        """Compute reward for the action."""
+        pass
+
+    def close(self):
+        """Close the environment."""
+        pass
+
+
+class BaseDiscreteActionEnv(BaseEnv, ABC):
+    """
+    Abstract base class for environments with discrete action spaces
+    This class provides common functionality for environments like FrozenLakeEnv and SokobanEnv.
+    """
+
+    @abstractmethod
+    def step(self, action: int) -> Tuple[Any, float, bool, Dict]:
+        """
+        Execute one step in the environment.
+        Args:
+            action: Action to take, must be in action space, or default invalid action
+        Returns:
+            observation (rendered environment), reward, done, info
+        """
+        pass
+
+    @abstractmethod
+    def get_all_actions(self) -> List[int]:
+        """Get list of all valid actions."""
+        pass
+
+
+class BaseLanguageBasedEnv(BaseEnv, ABC):
+    """
+    Abstract base class for environments with language-based action space environment
+    This class provides common functionality for environments like countdown from TinyZero
+    """
+
+    @abstractmethod
+    def step(self, action: str) -> Tuple[Any, float, bool, Dict]:
+        """
+        Execute one step in the environment.
+        Args:
+            action: Action to take, must be in action space, or default invalid action
+        Returns:
+            observation (rendered environment), reward, done, info
+        """
+        pass
+
+
+class BaseEnvConfig(ABC):
+    """
+    Abstract base class for environment configurations.
+    """
+    def __init__(self):
+        self.invalid_act = ""
+        self.invalid_act_score = 0

ragen/env/blackjack/__init__.py

@@ -0,0 +1,2 @@
+from .config import BlackjackEnvConfig
+from .env import BlackjackEnv

ragen/env/blackjack/config.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+import gymnasium as gym
+from ragen.env.base import BaseEnvConfig
+
+
+@dataclass
+class BlackjackEnvConfig(BaseEnvConfig):
+    render_mode: str = "text"
+    action_lookup: dict = None
+
+    def __post_init__(self):
+        if self.action_lookup is None:
+            # 1: Stick, 2: Hit
+            self.action_lookup = {1: "Stick", 2: "Hit"}
+        self.invalid_act = 0
+        self.invalid_act_score = 0.0
+        self.ACTION_SPACE = gym.spaces.discrete.Discrete(2, start=1)

ragen/env/blackjack/env.py

@@ -0,0 +1,129 @@
+import gymnasium as gym
+import numpy as np
+from typing import Tuple, Any, Dict, List
+from ragen.env.base import BaseDiscreteActionEnv
+from .config import BlackjackEnvConfig
+from ragen.utils import all_seed
+
+def draw_card(rng: np.random.Generator) -> int:
+    # 1 is Ace, 2-9 as is, 10 represents 10/J/Q/K
+    card_vals = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    weights = [1, 1, 1, 1, 1, 1, 1, 1, 1, 4]
+    probs = np.array(weights, dtype=np.float64)
+    probs /= probs.sum()
+    return int(rng.choice(card_vals, p=probs))
+
+def usable_ace(hand: List[int]) -> bool:
+    return 1 in hand and sum(hand) + 10 <= 21
+
+def hand_sum(hand: List[int]) -> int:
+    total = sum(hand)
+    if 1 in hand and total + 10 <= 21:
+        return total + 10
+    return total
+
+class BlackjackEnv(BaseDiscreteActionEnv, gym.Env):
+    def __init__(self, config: BlackjackEnvConfig | None = None):
+        BaseDiscreteActionEnv.__init__(self)
+        self.config = config or BlackjackEnvConfig()
+        self.ACTION_LOOKUP = self.config.action_lookup
+        self.ACTION_SPACE = gym.spaces.discrete.Discrete(2, start=1)
+        self.render_mode = self.config.render_mode
+        self.rng = np.random.default_rng()
+        self.player = []
+        self.dealer = []
+    
+    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.player = [draw_card(self.rng), draw_card(self.rng)]
+            self.dealer = [draw_card(self.rng), draw_card(self.rng)]
+        
+        # 即使起手21点，Gym的reset也不能返回done，只能通过Observation提示
+        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}
+        
+        # 1: Stick, 2: Hit
+        if action == 2:  # Hit
+            self.player.append(draw_card(self.rng))
+            if hand_sum(self.player) > 21:
+                # 爆牌 (Bust)
+                done = True
+                reward = -1.0
+                info["success"] = False
+                # 爆牌时，render需要知道游戏结束，不再请求动作
+                next_obs = self.render(done=True, result_msg="You Busted! (Sum > 21)")
+                return next_obs, reward, done, info
+            
+            # 继续游戏
+            next_obs = self.render(done=False)
+            return next_obs, 0.0, False, info
+            
+        else:  # Stick
+            # Dealer policy: hit to 17 or more
+            while hand_sum(self.dealer) < 17:
+                self.dealer.append(draw_card(self.rng))
+            
+            reward = self._settle()
+            done = True
+            info["success"] = reward > 0
+            
+            # 生成结算信息
+            if reward > 0: res = "You Won!"
+            elif reward < 0: res = "You Lost."
+            else: res = "Draw."
+            
+            next_obs = self.render(done=True, result_msg=res)
+            return next_obs, float(reward), done, info
+
+    def _settle(self) -> float:
+        p = hand_sum(self.player)
+        d = hand_sum(self.dealer)
+        if p > 21: return -1.0
+        if d > 21: return 1.0
+        if p > d: return 1.0
+        if p < d: return -1.0
+        return 0.0
+
+    def render(self, mode: str | None = None, done: bool = False, result_msg: str = "") -> str:
+        p_sum = hand_sum(self.player)
+        ua = usable_ace(self.player)
+        
+        lines = []
+        lines.append("=== Blackjack Game State ===")
+        lines.append(f"Your Hand: {self.player} (Total: {p_sum}).")
+        if ua:
+            lines.append("Note: You possess a usable Ace.")
+        
+        if not done:
+            # 游戏进行中，只显示庄家的一张牌
+            lines.append(f"Dealer's Visible Card: {self.dealer[0]}.")
+            lines.append("")
+            lines.append("Available Actions:")
+            lines.append("- Action 1: Stick (Stop)")
+            lines.append("- Action 2: Hit (Add card)")
+            
+            # 增加策略提示，防止起手21点还Hit
+            if p_sum == 21:
+                lines.append("\nWait! You have 21. It is strongly recommended to Stick (Action 1).")
+            
+            lines.append("\nWhat is your next move?")
+        else:
+            # 游戏结束，显示全貌
+            d_sum = hand_sum(self.dealer)
+            lines.append(f"Dealer's Hand: {self.dealer} (Total: {d_sum}).")
+            lines.append("")
+            lines.append(f"=== Game Over: {result_msg} ===")
+            # 此时不再询问 Next move
+            
+        return "\n".join(lines)
+
+    def close(self):
+        pass
+
+    def get_all_actions(self):
+        return list(self.ACTION_LOOKUP.keys())

ragen/env/countdown/__init__.py

@@ -0,0 +1,9 @@
+"""
+Adapted from the nicely written code from TinyZero and veRL
+We plan to generalize this environment to support any sort of static problem sets
+"""
+
+from .env import CountdownEnv
+from .config import CountdownEnvConfig
+
+__all__ = ["CountdownEnv", "CountdownEnvConfig"]

ragen/env/countdown/config.py

@@ -0,0 +1,11 @@
+
+from ragen.env.base import BaseEnvConfig
+from dataclasses import dataclass
+
+@dataclass
+class CountdownEnvConfig:
+    train_path: str = "data/countdown/train.parquet"
+    max_instances: int = 20000
+    render_mode: str = "text"
+    score = 1
+    format_score = 0.1

ragen/env/countdown/env.py

@@ -0,0 +1,93 @@
+import gymnasium as gym
+from ragen.env.base import BaseLanguageBasedEnv
+import datasets
+import re
+import itertools
+from .config import CountdownEnvConfig
+
+
+def check_format(equation, nums):
+    try:
+        nums_in_eq = [int(n) for n in re.findall(r'\d+', equation)]
+        return sorted(nums_in_eq) == sorted(nums)
+    except:
+        return False
+
+def check_correctness(equation_str, target):
+    try:
+        result = eval(equation_str, {"__builtins__": None}, {})
+        return abs(result - target) < 1e-5
+    except:
+        return False
+
+def has_solution(nums, target):
+    """Check if there is a valid equation using each number exactly once."""
+    # pad nums all to 4 numbers
+    length = 4
+    nums = nums + [0] * (length - len(nums))
+    # +- num1 +- num2 +- num3 +- num4 = target, try all
+    combinations = list(itertools.product([1, -1], repeat=length))
+    for combination in combinations:
+        if sum(combination[i] * nums[i] for i in range(length)) == target:
+            return True
+    return False
+
+
+class CountdownEnv(BaseLanguageBasedEnv, gym.Env):
+    def __init__(self, config=None):
+        BaseLanguageBasedEnv.__init__(self)
+        self.config = config if config is not None else CountdownEnvConfig()
+        self.data = self._get_data_from_parquet(self.config.train_path)
+        self.index = None
+        self.render_cache = None
+        self.render_mode = self.config.render_mode
+        assert self.render_mode == 'text'
+        
+    def _get_data_from_parquet(self, path):
+        df = datasets.load_dataset("parquet", data_files=path)['train'].select(range(self.config.max_instances))
+        df = df.filter(lambda x: has_solution(x['nums'], x['target']))
+        return df
+
+    def reset(self, seed=None, mode=None):
+        gym.Env.reset(self, seed=seed)
+        self.index = seed % len(self.data)
+        data = self.data[self.index]
+        self.render_cache = f"Target: {data['target']}, nums: {data['nums']}"
+        return self.render_cache
+
+    def step(self, action):
+        reward = self.compute_reward(action, self.data[self.index])
+        next_obs, done, info = f"Your answer get {reward} points.", True, {"action_is_effective": reward > 0, "action_is_valid": True, "success": reward == self.config.score}
+        self.render_cache = next_obs
+        return next_obs, reward, done, info
+    
+    def render(self):
+        return self.render_cache
+    
+    
+
+    def compute_reward(self, action, ground_truth):
+        """Score the countdown task solution."""
+        target = ground_truth['target']
+        nums = ground_truth['nums']
+        if not check_format(action, nums):
+            return 0
+        if not check_correctness(action, target):
+            return self.config.format_score
+        else:
+            return self.config.score
+
+    def close(self):
+        pass
+
+if __name__ == "__main__":
+    def test(path, seed=43):
+        config = CountdownEnvConfig(train_path=path)
+        env = CountdownEnv(config)
+        obs = env.reset(seed=seed)
+        problem = env.data[env.index]
+        solution = f"- {problem['nums'][0]} + {problem['nums'][1]} + {problem['nums'][2]}"
+        _, reward, _, _ = env.step(solution)
+        print(f"{obs}\nSolution: {solution}, Reward: {reward}")
+    
+    test("data/countdown/train.parquet")

ragen/env/frozen_lake/__init__.py

@@ -0,0 +1,45 @@
+"""
+Adapted from the nicely written code from gymnasium.envs.toy_text.frozen_lake.generate_random_map
+Modify it so that the start and end points are random
+
+## Description
+The game starts with the player at random location of the frozen lake grid world with the
+goal located at another random location for the 4x4 environment.
+
+## Action Space
+The action shape is `(1,)` in the range `{0, 3}` indicating
+which direction to move the player.
+NOTE the action space is different from gymnasium.envs.toy_text.frozen_lake.FrozenLakeEnv, start from 1
+- 0: Still
+- 1: Left
+- 2: Down
+- 3: Right
+- 4: Up
+
+## Starting State
+The episode starts with the player at random location
+
+## Rewards
+NOTE added -0.1 as penalty for invalid action
+Reward schedule:
+- Reach goal: +1
+- Reach hole: 0
+- Reach frozen: 0
+
+## Arguments
+`is_slippery`: if action is left and is_slippery is True, then:
+- P(move left)=1/3
+- P(move up)=1/3
+- P(move down)=1/3
+
+## Example
+P   _   _   _
+_   _   _   O
+O   _   O   _
+O   _   _   G
+"""
+
+from .env import FrozenLakeEnv
+from .config import FrozenLakeEnvConfig
+
+__all__ = ["FrozenLakeEnv", "FrozenLakeEnvConfig"]