Intial demo release.

app.py

@@ -0,0 +1,370 @@
+import re
+import json
+import gradio as gr
+from glob import glob
+
+from chatarena.arena import Arena
+from chatarena.backends import BACKEND_REGISTRY
+from chatarena.backends.human import HumanBackendError
+from chatarena.config import ArenaConfig
+from chatarena.environments import ENV_REGISTRY
+from chatarena.database import log_arena, log_messages, SupabaseDB, supabase_available
+
+css = """#col-container {max-width: 90%; margin-left: auto; margin-right: auto; display: flex; flex-direction: column;}
+#header {text-align: center;}
+#col-chatbox {flex: 1; max-height: min(650px, 100%); display: flex;}
+#chatbox {height: min(650px, 100%); max-height: 650px; display:flex;}
+#label {font-size: 2em; padding: 0.5em; margin: 0;}
+.message {font-size: 1.2em;}
+.wrap.svelte-18ha8kq {flex: 1}
+.wrap.svelte-18ha8kq.svelte-18ha8kq {max-height: min(600px, 100vh);}
+.message-wrap {max-height: min(600px, 100vh);}
+"""
+
+DEBUG = False
+
+DEFAULT_BACKEND = "openai-chat"
+DEFAULT_ENV = "conversation"
+MAX_NUM_PLAYERS = 6
+DEFAULT_NUM_PLAYERS = 2
+
+
+def load_examples():
+    example_configs = {}
+    # Load json config files from examples folder
+    example_files = glob("examples/*.json")
+    for example_file in example_files:
+        with open(example_file, 'r') as f:
+            example = json.load(f)
+            example_configs[example["name"]] = example
+    return example_configs
+
+
+EXAMPLE_REGISTRY = load_examples()
+
+DB = SupabaseDB() if supabase_available else None
+
+
+def get_moderator_components(visible=True):
+    name = "Moderator"
+    with gr.Row():
+        with gr.Column():
+            role_desc = gr.Textbox(label="Moderator role", lines=1, visible=visible, interactive=True,
+                                   placeholder=f"Enter the role description for {name}")
+            terminal_condition = gr.Textbox(show_label=False, lines=1, visible=visible, interactive=True,
+                                            placeholder="Enter the end criteria for the conversation")
+        with gr.Column():
+            backend_type = gr.Dropdown(show_label=False, visible=visible, interactive=True,
+                                       choices=list(BACKEND_REGISTRY.keys()), value=DEFAULT_BACKEND)
+            with gr.Accordion(f"{name} Parameters", open=False, visible=visible) as accordion:
+                temperature = gr.Slider(minimum=0, maximum=2.0, step=0.1, interactive=True, visible=visible,
+                                        label=f"temperature", value=0.7)
+                max_tokens = gr.Slider(minimum=10, maximum=500, step=10, interactive=True, visible=visible,
+                                       label=f"max tokens", value=200)
+
+    return [role_desc, terminal_condition, backend_type, accordion, temperature, max_tokens]
+
+
+def get_player_components(name, visible):
+    with gr.Row():
+        with gr.Column():
+            role_desc = gr.Textbox(label=name, lines=3, interactive=True, visible=visible,
+                                   placeholder=f"Enter the role description for {name}")
+        with gr.Column():
+            backend_type = gr.Dropdown(show_label=False, choices=list(BACKEND_REGISTRY.keys()),
+                                       interactive=True, visible=visible, value=DEFAULT_BACKEND)
+            with gr.Accordion(f"{name} Parameters", open=False, visible=visible) as accordion:
+                temperature = gr.Slider(minimum=0, maximum=2.0, step=0.1, interactive=True, visible=visible,
+                                        label=f"temperature", value=0.7)
+                max_tokens = gr.Slider(minimum=10, maximum=500, step=10, interactive=True, visible=visible,
+                                       label=f"max tokens", value=200)
+
+    return [role_desc, backend_type, accordion, temperature, max_tokens]
+
+
+def get_empty_state():
+    return gr.State({"arena": None})
+
+
+with gr.Blocks(css=css) as demo:
+    state = get_empty_state()
+    all_components = []
+
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown("""# 🏟 Chat Arena️<br>
+Prompting multiple AI agents to play games in a language-driven environment. 
+[Chat Arena Homepage](https://github.com/chatarena/chatarena)""", elem_id="header")
+
+        with gr.Row():
+            env_selector = gr.Dropdown(choices=list(ENV_REGISTRY.keys()), value=DEFAULT_ENV, interactive=True,
+                                       label="Environment Type", show_label=True)
+            example_selector = gr.Dropdown(choices=list(EXAMPLE_REGISTRY.keys()), interactive=True,
+                                           label="Select Example", show_label=True)
+
+        # Environment configuration
+        env_desc_textbox = gr.Textbox(show_label=True, lines=2, visible=True, label="Environment Description",
+                                      placeholder="Enter a description of a scenario or the game rules.")
+
+        all_components += [env_selector, example_selector, env_desc_textbox]
+
+        with gr.Row():
+            with gr.Column(elem_id="col-chatbox"):
+                with gr.Tab("All"):
+                    chatbot = gr.Chatbot(elem_id="chatbox", visible=True, label="Chat Arena")
+
+                player_chatbots = []
+                for i in range(MAX_NUM_PLAYERS):
+                    player_name = f"Player {i + 1}"
+                    with gr.Tab(player_name, visible=(i < DEFAULT_NUM_PLAYERS)):
+                        player_chatbot = gr.Chatbot(elem_id=f"chatbox-{i}", visible=i < DEFAULT_NUM_PLAYERS,
+                                                    label=player_name)
+                        player_chatbots.append(player_chatbot)
+
+            all_components += [chatbot, *player_chatbots]
+
+            with gr.Column(elem_id="col-config"):  # Player Configuration
+                # gr.Markdown("Player Configuration")
+                parallel_checkbox = gr.Checkbox(label="Parallel Actions", value=False, visible=True)
+                with gr.Accordion("Moderator", open=False, visible=True):
+                    moderator_components = get_moderator_components(True)
+                all_components += [parallel_checkbox, *moderator_components]
+
+                all_players_components, players_idx2comp = [], {}
+                with gr.Blocks():
+                    num_player_slider = gr.Slider(2, MAX_NUM_PLAYERS, value=DEFAULT_NUM_PLAYERS, step=1,
+                                                  label="Number of players:")
+                    for i in range(MAX_NUM_PLAYERS):
+                        player_name = f"Player {i + 1}"
+                        with gr.Tab(player_name, visible=(i < DEFAULT_NUM_PLAYERS)) as tab:
+                            player_comps = get_player_components(player_name, visible=(i < DEFAULT_NUM_PLAYERS))
+
+                        players_idx2comp[i] = player_comps + [tab]
+                        all_players_components += player_comps + [tab]
+
+                all_components += [num_player_slider] + all_players_components
+
+
+                def variable_players(k):
+                    k = int(k)
+                    update_dict = {}
+                    for i in range(MAX_NUM_PLAYERS):
+                        if i < k:
+                            for comp in players_idx2comp[i]:
+                                update_dict[comp] = gr.update(visible=True)
+                            update_dict[player_chatbots[i]] = gr.update(visible=True)
+                        else:
+                            for comp in players_idx2comp[i]:
+                                update_dict[comp] = gr.update(visible=False)
+                            update_dict[player_chatbots[i]] = gr.update(visible=False)
+                    return update_dict
+
+
+                num_player_slider.change(variable_players, num_player_slider, all_players_components + player_chatbots)
+
+                human_input_textbox = gr.Textbox(show_label=True, label="Human Input", lines=1, visible=True,
+                                                 interactive=True, placeholder="Enter your input here")
+                with gr.Row():
+                    btn_step = gr.Button("Start")
+                    btn_restart = gr.Button("Clear")
+
+                all_components += [human_input_textbox, btn_step, btn_restart]
+
+
+    def _convert_to_chatbot_output(all_messages, display_recv=False):
+        chatbot_output = []
+        for i, message in enumerate(all_messages):
+            agent_name, msg, recv = message.agent_name, message.content, str(message.visible_to)
+            new_msg = re.sub(r'\n+', '<br>', msg.strip())  # Preprocess message for chatbot output
+            if display_recv:
+                new_msg = f"**{agent_name} (-> {recv})**: {new_msg}"  # Add role to the message
+            else:
+                new_msg = f"**{agent_name}**: {new_msg}"
+
+            if agent_name == "Moderator":
+                chatbot_output.append((new_msg, None))
+            else:
+                chatbot_output.append((None, new_msg))
+        return chatbot_output
+
+
+    def _create_arena_config_from_components(all_comps: dict) -> ArenaConfig:
+        env_desc = all_comps[env_desc_textbox]
+
+        # Initialize the players
+        num_players = all_comps[num_player_slider]
+        player_configs = []
+        for i in range(num_players):
+            player_name = f"Player {i + 1}"
+            role_desc, backend_type, temperature, max_tokens = [
+                all_comps[c] for c in players_idx2comp[i] if not isinstance(c, (gr.Accordion, gr.Tab))]
+            player_config = {
+                "name": player_name,
+                "role_desc": role_desc,
+                "env_desc": env_desc,
+                "backend": {
+                    "backend_type": backend_type,
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                }
+            }
+            player_configs.append(player_config)
+
+        # Initialize the environment
+        env_type = all_comps[env_selector]
+        # Get moderator config
+        mod_role_desc, mod_terminal_condition, moderator_backend_type, mod_temp, mod_max_tokens = [
+            all_comps[c] for c in moderator_components if not isinstance(c, (gr.Accordion, gr.Tab))]
+        moderator_config = {
+            "role_desc": mod_role_desc,
+            "env_desc": env_desc,
+            "terminal_condition": mod_terminal_condition,
+            "backend": {
+                "backend_type": moderator_backend_type,
+                "temperature": mod_temp,
+                "max_tokens": mod_max_tokens
+            }
+        }
+        env_config = {
+            "env_type": env_type,
+            "env_desc": env_desc,
+            "parallel": all_comps[parallel_checkbox],
+            "moderator": moderator_config,
+            "moderator_visibility": "all",
+            "moderator_period": "turn"
+        }
+
+        # arena_config = {"players": player_configs, "environment": env_config}
+        arena_config = ArenaConfig(players=player_configs, environment=env_config)
+        return arena_config
+
+
+    def step_game(all_comps: dict):
+        yield {btn_step: gr.update(value="Running...", interactive=False),
+               btn_restart: gr.update(interactive=False)}
+
+        cur_state = all_comps[state]
+
+        # If arena is not yet created, create it
+        if cur_state["arena"] is None:
+            # Create the Arena
+            arena_config = _create_arena_config_from_components(all_comps)
+            arena = Arena.from_config(arena_config)
+            log_arena(arena, database=DB)
+            cur_state["arena"] = arena
+        else:
+            arena = cur_state["arena"]
+
+        try:
+            timestep = arena.step()
+        except HumanBackendError as e:
+            # Handle human input and recover with the game update
+            human_input = all_comps[human_input_textbox]
+            if human_input == "":
+                timestep = None  # Failed to get human input
+            else:
+                timestep = arena.environment.step(e.agent_name, human_input)
+
+        if timestep is None:
+            yield {human_input_textbox: gr.update(value="", placeholder="Please enter a valid input"),
+                   btn_step: gr.update(value="Next Step", interactive=True),
+                   btn_restart: gr.update(interactive=True)}
+        else:
+            all_messages = timestep.observation  # user sees what the moderator sees
+            log_messages(arena, all_messages, database=DB)
+
+            chatbot_output = _convert_to_chatbot_output(all_messages, display_recv=True)
+            update_dict = {human_input_textbox: gr.Textbox.update(value=""),
+                           chatbot: chatbot_output,
+                           btn_step: gr.update(value="Next Step", interactive=not timestep.terminal),
+                           btn_restart: gr.update(interactive=True), state: cur_state}
+            # Get the visible messages for each player
+            for i, player in enumerate(arena.players):
+                player_messages = arena.environment.get_observation(player.name)
+                player_output = _convert_to_chatbot_output(player_messages)
+                # Update the player's chatbot output
+                update_dict[player_chatbots[i]] = player_output
+
+            if DEBUG:
+                arena.environment.print()
+
+            yield update_dict
+
+
+    def restart_game(all_comps: dict):
+        cur_state = all_comps[state]
+        cur_state["arena"] = None
+        yield {chatbot: [], btn_restart: gr.update(interactive=False),
+               btn_step: gr.update(interactive=False), state: cur_state}
+
+        arena_config = _create_arena_config_from_components(all_comps)
+        arena = Arena.from_config(arena_config)
+        log_arena(arena, database=DB)
+        cur_state["arena"] = arena
+
+        yield {btn_step: gr.update(value="Start", interactive=True),
+               btn_restart: gr.update(interactive=True), state: cur_state}
+
+
+    # Remove Accordion and Tab from the list of components
+    all_components = [comp for comp in all_components if not isinstance(comp, (gr.Accordion, gr.Tab))]
+
+    # If any of the Textbox, Slider, Checkbox, Dropdown, RadioButtons is changed, the Step button is disabled
+    for comp in all_components:
+        def _disable_step_button(state):
+            if state["arena"] is not None:
+                return gr.update(interactive=False)
+            else:
+                return gr.update()
+
+
+        if isinstance(comp,
+                      (gr.Textbox, gr.Slider, gr.Checkbox, gr.Dropdown, gr.Radio)) and comp is not human_input_textbox:
+            comp.change(_disable_step_button, state, btn_step)
+
+    btn_step.click(step_game, set(all_components + [state]),
+                   [chatbot, *player_chatbots, btn_step, btn_restart, state, human_input_textbox])
+    btn_restart.click(restart_game, set(all_components + [state]),
+                      [chatbot, *player_chatbots, btn_step, btn_restart, state, human_input_textbox])
+
+
+    # If an example is selected, update the components
+    def update_components_from_example(all_comps: dict):
+        example_name = all_comps[example_selector]
+        example_config = EXAMPLE_REGISTRY[example_name]
+        update_dict = {}
+
+        # Update the environment components
+        env_config = example_config['environment']
+        update_dict[env_desc_textbox] = gr.update(value=example_config['global_prompt'])
+        update_dict[env_selector] = gr.update(value=env_config['env_type'])
+        update_dict[parallel_checkbox] = gr.update(value=env_config['parallel'])
+
+        # Update the moderator components
+        if "moderator" in env_config:
+            mod_role_desc, mod_terminal_condition, moderator_backend_type, mod_temp, mod_max_tokens = [
+                c for c in moderator_components if not isinstance(c, (gr.Accordion, gr.Tab))
+            ]
+            update_dict[mod_role_desc] = gr.update(value=env_config['moderator']['role_desc'])
+            update_dict[mod_terminal_condition] = gr.update(value=env_config['moderator']['terminal_condition'])
+            update_dict[moderator_backend_type] = gr.update(value=env_config['moderator']['backend']['backend_type'])
+            update_dict[mod_temp] = gr.update(value=env_config['moderator']['backend']['temperature'])
+            update_dict[mod_max_tokens] = gr.update(value=env_config['moderator']['backend']['max_tokens'])
+
+        # Update the player components
+        update_dict[num_player_slider] = gr.update(value=len(example_config['players']))
+        for i, player_config in enumerate(example_config['players']):
+            role_desc, backend_type, temperature, max_tokens = [
+                c for c in players_idx2comp[i] if not isinstance(c, (gr.Accordion, gr.Tab))
+            ]
+            update_dict[role_desc] = gr.update(value=player_config['role_desc'])
+            update_dict[backend_type] = gr.update(value=player_config['backend']['backend_type'])
+            update_dict[temperature] = gr.update(value=player_config['backend']['temperature'])
+            update_dict[max_tokens] = gr.update(value=player_config['backend']['max_tokens'])
+
+        return update_dict
+
+
+    example_selector.change(update_components_from_example, set(all_components + [state]), all_components + [state])
+
+demo.queue()
+demo.launch(debug=DEBUG)

examples/chameleon.json

@@ -0,0 +1,37 @@
+{
+  "name": "Chameleon",
+  "global_prompt": "You are playing a game of the Chameleon. Here are the game rules:\n\n## Information and roles\nThere are two roles in the game, chameleon and non-chameleon.\nThe topic of the secret word will be first revealed to all the players.\nThen the secret word will be revealed to non-chameleons.\nThe chameleon does not know the secret word.\n\n## Objectives\nYour objective in the game depends on you role:\n- If you are not a chameleon, your goal is to reveal the chameleon without exposing the secret word.\n- If you are a chameleon, your aim is to blend in with other players, avoid being caught, and figure out the secret word.\n\n## Stages\nThere are three stages in the game:\n1. The giving clues stage: each player will describe the clues about the secret word.\n2. The accusation stage: In this stage, each player will vote for another player who is most likely the chameleon. The chameleon should vote for other players.\n3. The guess stage: If the accusation is correct, the chameleon should guess the secret word given the clues revealed by other players.",
+  "environment": {
+    "env_type": "chameleon",
+    "parallel": false
+  },
+  "players": [
+    {
+      "name": "Player 1",
+      "role_desc": "You are Player 1.\nThe Moderator will tell you whether you are the chameleon.\nYou're playing with two other players.\nDo not pretend you are other players or the moderator.\nYou cannot vote for yourself.\nYou don't need to prepend your player name to your response, despite others may do it.\nAlways end your response with <EOS>.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 50
+      }
+    },
+    {
+      "name": "Player 2",
+      "role_desc": "You are Player 2.\nThe Moderator will tell you whether you are the chameleon.\nYou're playing with two other players.\nDo not pretend you are other players or the moderator.\nYou cannot vote for yourself.\nYou don't need to prepend your player name to your response, despite others may do it.\nAlways end your response with <EOS>.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 50
+      }
+    },
+    {
+      "name": "Player 3",
+      "role_desc": "You are Player 3.\nThe Moderator will tell you whether you are the chameleon.\nYou're playing with two other players.\nDo not pretend you are other players or the moderator.\nYou cannot vote for yourself.\nYou don't need to prepend your player name to your response, despite others may do it.\nAlways end your response with <EOS>.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 50
+      }
+    }
+  ]
+}

examples/chess.json

@@ -0,0 +1,28 @@
+{
+  "name": "chess",
+  "global_prompt": "",
+  "environment": {
+    "env_type": "pettingzoo:chess",
+    "parallel": false
+  },
+  "players": [
+    {
+      "name": "Player 1",
+      "role_desc": "You are playing chess, you are playing white. Only output the starting and ending position of the chess piece.\nThe format is \"Move (x1, y1) to (x2, y2)\". The bottom left corner piece has a position (0, 0)\n\nFor example:\n\n```\nMove (4, 1) to (4, 3) <EOS>\n\n```",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 50
+      }
+    },
+    {
+      "name": "Player 2",
+      "role_desc": "You are playing chess. You are playing black pieces. Only output the starting and ending position of the chess piece.\nThe format is \"Move (x1, y1) to (x2, y2)\". The bottom left corner piece has a position (0, 0)\n\nFor example:\n\n```\nMove (4, 6) to (4, 4) <EOS>\n```",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 50
+      }
+    }
+  ]
+}

examples/nlp-classroom-3players.json

@@ -0,0 +1,37 @@
+{
+  "name": "NLP Classroom 3 Players",
+  "global_prompt": "You are in a university classroom and it is Natural Language Processing module. You start by introducing themselves. Your answer will end with <EOS>.",
+  "environment": {
+    "env_type": "conversation",
+    "parallel": false
+  },
+  "players": [
+    {
+      "name": "Professor",
+      "role_desc": "You are Prof. Alpha, a knowledgeable professor in NLP. Your answer will concise and accurate. The answers should be less than 100 words.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 250
+      }
+    },
+    {
+      "name": "Student",
+      "role_desc": "You are Beta, a student curious about Natural Language Processing and you want to learn some basic concepts of NLP. You know nothing about the area so you will ask lots of questions.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 100
+      }
+    },
+    {
+      "name": "Teaching Assistant",
+      "role_desc": "You are Gamma, a teaching assistant of the Natural Language Processing module. You mostly help with logistics and marking, but occasionally handles questions. Your answer should be less than 100 words.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 250
+      }
+    }
+  ]
+}

examples/nlp-classroom.json

@@ -0,0 +1,28 @@
+{
+  "name": "NLP Classroom",
+  "global_prompt": "You are in a university classroom and it is Natural Language Processing module. You start by introducing themselves. Your answer will end with <EOS>.",
+  "environment": {
+    "env_type": "conversation",
+    "parallel": false
+  },
+  "players": [
+    {
+      "name": "Professor",
+      "role_desc": "You are Prof. Alice, a knowledgeable professor in NLP. Your answer will concise and accurate. The answers should be less than 100 words.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 250
+      }
+    },
+    {
+      "name": "Student",
+      "role_desc": "You are Bob, a student curious about Natural Language Processing and you want to learn some basic concepts of NLP. You know nothing about the area so you will ask lots of questions.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 100
+      }
+    }
+  ]
+}

examples/rock-paper-scissors.json

@@ -0,0 +1,39 @@
+{
+  "name": "Rock-Paper-Scissors",
+  "global_prompt": "Rock Paper Scissors is a two-player hand game where players use hand signals to represent three possible outcomes: rock, paper, or scissors. \n\nThe rules of the game are simple:\n\n1. Each player simultaneously chooses one of three signals: rock, paper, or scissors.\n\n2. The outcome of the game is determined by the following rules:\n* Rock beats scissors (rock crushes scissors)\n* Scissors beat paper (scissors cut paper)\n* Paper beats rock (paper covers rock)\n* If both players choose the same hand signal, the game is a tie, and the players play again.\n\n3. The winner of each round is determined by comparing the chosen signals. The first player to win 2 rounds wins the game.",
+  "environment": {
+    "env_type": "moderated_conversation",
+    "parallel": true,
+    "moderator": {
+      "role_desc": "You are the system of the game.\nYou should count the number of win rounds of each paper. The player who first wins 2 rounds wins the game.\nYou should also end the game if the players say anything else besides \"rock\",  \"paper\" or \"scissors\", especially if they say long sentences.\n\n## Example\nWhen you see:\n```\n[Player 1]: rock\n[Player 2]: rock\n```\nyou should output the following:\n```\nTie.\nPlayer 1 wins: 0/2\nPlayer 2 wins: 0/2\n```\n\nIn the next round, when you see:\n```\n[Player 1]: rock\n[Player 2]: paper\n```\nyou should output the following:\n```\nPlayer 2 wins this round.\nPlayer 1 wins: 0/2\nPlayer 2 wins: 1/2\n```\n\nIn the next round, when you see:\n```\n[Player 1]: paper\n[Player 2]: scissors\n```\nyou should output the following:\n```\nPlayer 2 wins this round.\nPlayer 1 wins: 0/2\nPlayer 2 wins: 2/2\n\nPlayer 2 wins the game!\n```\n\n## Other instructions\nDon't instruct the player to do anything.\nDon't pretend you are a player.\nDon't repeat the players' outputs.",
+      "terminal_condition": "The game is over when one player wins 2 rounds. Did someone win 2 rounds?",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.0,
+        "max_tokens": 50
+      }
+    },
+    "moderator_visibility": "all",
+    "moderator_period": "round"
+  },
+  "players": [
+    {
+      "name": "Player 1",
+      "role_desc": "Randomly output one of the following texts: \"rock\", \"paper\" or \"scissors\"\nYour choice should be random, don't follow the order of the sequence I gave you.\n\n## Example\nYou should output\n```\npaper<EOS>\n```\nor \n```\nrock<EOS>\n```\nor\n```\nscissors<EOS>\n```\n\n## Other instructions\nDon't output anything besides one of the three strings.\nDon't output the results in the last turn like \"tie\".\nDon't pretend as if you are a human player.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 10
+      }
+    },
+    {
+      "name": "Player 2",
+      "role_desc": "Randomly output one of the following texts: \"rock\", \"paper\" or \"scissors\"\nYour choice should be random, don't follow the order of the sequence I gave you.\n\n## Example\nYou should output\n```\npaper<EOS>\n```\nor \n```\nrock<EOS>\n```\nor\n```\nscissors<EOS>\n```\n\n## Other instructions\nDon't output anything besides one of the three strings.\nDon't output the results in the last turn like \"tie\".\nDon't pretend as if you are a human player.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 10
+      }
+    }
+  ]
+}

examples/tic-tac-toe.json

@@ -0,0 +1,40 @@
+{
+  "name": "Tic-Tac-Toe",
+  "global_prompt": "",
+  "global_prompt_backup": "Two players are playing tic-tac-toe. \nTic-tac-toe is played on a three-by-three grid by two players, who alternately place the marks X and O in one of the nine spaces in the grid. \nThe player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row is the winner.\n\nIn the following example, the first player (X) wins the game in seven steps:\n1. [Player 1]: X: (1, 3)\n| _ |_| X |\n| _ | _ |_|\n| _ | _ |_|\n      \n2. [Player 2]: O: (1, 1)\n| O | _ | X |\n| _ | _ |_|\n| _ |_| _ |\n\n3. [Player 1]: X: (3, 1)\n| O | _ | X |\n| _ |_| _ |\n| X | _ |_|\n\n4.  [Player 2]: O: (2, 2)\n| O | _ | X |\n| _ | O | _ |\n| X | _ |_|\n\n5. [Player 1]: X: (3, 3)\n| O | _ | X |\n| _ | O | _ |\n| X | _ | X |\n\n6. [Player 2]: O: (2, 3)\n| O | _ | X |\n| _ | O |O|\n| X | _ | X |\n\n7. [Player 1]: X: (3, 2)\n| O | _ | X |\n| _ | O |O|\n| X |X| X |\n\n\nX plays first. Players will specify the position of the stone and the moderator will plot the board status.\nIf a position has been marked, future marks cannot be put in the same position.\nOnly the moderator can decide who wins. Players shouldn't declare they win.\nThe players interact with the game by specifying the position of the stones (x, y), where x indicates the row and y indicates the column, so (1, 1) is the top left corner and (3, 3) is the bottom right corner.",
+  "environment": {
+    "env_type": "moderated_conversation",
+    "parallel": false,
+    "moderator": {
+      "role_desc": "You are the system of the game.\nYou should first recall the latest move and then display the board status.\n\nFor example, when the last player says: \"X: (1, 2)\"\nIt means the X mark is put in the first row and the second column.\nYou'll output:\n```\nBoard:\n| _ | X | _ |\n| _ |_| _ |\n| _ |_| _ |\n```\n\nIn the next step, another player says: \"O: (3, 1)\"\nIt means the O mark is put in the third row and the first column.\nYou'll output:\n```\nBoard:\n| _ |_| X |\n| _ |_| _ |\n| O | _ |_|\n```\n\n## Termination condition\nIf a player succeeds in placing three of their marks in a horizontal, vertical, or diagonal line, it wins. \nThe horizontal line means there are three same marks in the same row (n, 1) (n, 2) (n, 3), where n can be from 1 to 3.\nThe vertical line means there are three same marks in the same column (1, m) (2, m) (3, m), where m can be from 1 to 3.\nThe diagonal line means three same marks occupy one of the following position combinations: (1, 1) (2, 2) (3, 3) or (1, 3) (2, 2) (3, 1)\n\nYou should declare the winner after displaying the board status if a player wins the game in the last move.\nFor example, you should output the following:\n```\nBoard\n| O | _ | X |\n| _ | X | O |\n| X |X| O |\n\nPlayer 1 (X) wins!\n```\nbecause X marks form a diagonal line on the board, so the player who plays X is the winner. The game ends.\n\n\n\n## Other instructions\nDon't write code.\nDon't instruct the player to do anything.\nDon't output \"Moderator\".",
+      "terminal_condition": "If a player wins, the game ends immediately. Is the game ended? Answer yes or no?",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.0,
+        "max_tokens": 50
+      }
+    },
+    "moderator_visibility": "all",
+    "moderator_period": "turn"
+  },
+  "players": [
+    {
+      "name": "Player 1",
+      "role_desc": "You play X.\nYou should only output X and the position of the move, for example: \"X: (1, 3)<EOS>\"\nThe position you put the mark on must be empty.\n\nYou shouldn't act as a moderator.\nDo not output \"Moderator\" and the board status.\nDon't say anything besides mark position.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 15
+      }
+    },
+    {
+      "name": "Player 2",
+      "role_desc": "You play O.\nYou should only output O and the position of the move, for example: \"O: (2, 3)<EOS>\"\nThe position you put the mark on must be empty.\n\nYou shouldn't act as a moderator.\nDo not output \"Moderator\" and the board status.\nDon't say anything besides mark position.",
+      "backend": {
+        "backend_type": "openai-chat",
+        "temperature": 0.7,
+        "max_tokens": 15
+      }
+    }
+  ]
+}

requirements.txt

@@ -0,0 +1,9 @@
+cohere>=4.1.0
+openai>=0.27.2
+gradio>=3.20.0
+transformers>=4.0
+tenacity==8.2.2
+rich>=13.3.1
+prompt_toolkit>=3.0
+pettingzoo==1.22.3
+chess