Repackaged arena from original repo for Spaces deployment

app.py

@@ -1,11 +1,7 @@
-import gradio as gr
+from arena.c4 import make_display
 
 
-def greet(name):
-    return f"Hello, {name}!"
-
-
-app = gr.Interface(fn=greet, inputs="text", outputs="text")
+app = make_display()
 
 if __name__ == "__main__":
     app.launch()

arena/board.py

@@ -0,0 +1,117 @@
+from arena.board_view import to_svg
+
+RED = 1
+YELLOW = -1
+EMPTY = 0
+show = {EMPTY: "⚪️", RED: "🔴", YELLOW: "🟡"}
+pieces = {EMPTY: "", RED: "red", YELLOW: "yellow"}
+simple = {EMPTY: ".", RED: "R", YELLOW: "Y"}
+cols = "ABCDEFG"
+
+
+class Board:
+
+    def __init__(self):
+        self.cells = [[0 for _ in range(7)] for _ in range(6)]
+        self.player = RED
+        self.winner = EMPTY
+        self.draw = False
+        self.forfeit = False
+        self.latest_x, self.latest_y = -1, -1
+
+    def __repr__(self):
+        result = ""
+        for y in range(6):
+            for x in range(7):
+                result += show[self.cells[5 - y][x]]
+            result += "\n"
+        result += "\n" + self.message()
+        return result
+
+    def message(self):
+        if self.winner and self.forfeit:
+            return f"{show[self.winner]} wins after an illegal move by {show[-1*self.winner]}\n"
+        elif self.winner:
+            return f"{show[self.winner]} wins\n"
+        elif self.draw:
+            return "The game is a draw\n"
+        else:
+            return f"{show[self.player]} to play\n"
+
+    def html(self):
+        result = '<div style="text-align: center;font-size:24px">'
+        result += self.__repr__().replace("\n", "<br/>")
+        result += "</div>"
+        return result
+
+    def svg(self):
+        """Convert the board state to an SVG representation"""
+        return to_svg(self)
+
+    def json(self):
+        result = "{\n"
+        result += '    "Column names": ["A", "B", "C", "D", "E", "F", "G"],\n'
+        for y in range(6):
+            result += f'    "Row {6-y}": ['
+            for x in range(7):
+                result += f'"{pieces[self.cells[5-y][x]]}", '
+            result = result[:-2] + "],\n"
+        result = result[:-2] + "\n}"
+        return result
+
+    def alternative(self):
+        result = "ABCDEFG\n"
+        for y in range(6):
+            for x in range(7):
+                result += simple[self.cells[5 - y][x]]
+            result += "\n"
+        return result
+
+    def height(self, x):
+        height = 0
+        while height < 6 and self.cells[height][x] != EMPTY:
+            height += 1
+        return height
+
+    def legal_moves(self):
+        return [cols[x] for x in range(7) if self.height(x) < 6]
+
+    def illegal_moves(self):
+        return [cols[x] for x in range(7) if self.height(x) == 6]
+
+    def winning_line(self, x, y, dx, dy):
+        color = self.cells[y][x]
+        for pointer in range(1, 4):
+            xp = x + dx * pointer
+            yp = y + dy * pointer
+            if not (0 <= xp <= 6 and 0 <= yp <= 5) or self.cells[yp][xp] != color:
+                return EMPTY
+        return color
+
+    def winning_cell(self, x, y):
+        for dx, dy in ((0, 1), (1, 1), (1, 0), (1, -1)):
+            if winner := self.winning_line(x, y, dx, dy):
+                return winner
+        return EMPTY
+
+    def wins(self):
+        for y in range(6):
+            for x in range(7):
+                if winner := self.winning_cell(x, y):
+                    return winner
+        return EMPTY
+
+    def move(self, x):
+        y = self.height(x)
+        self.cells[y][x] = self.player
+        self.latest_x, self.latest_y = x, y
+        if winner := self.wins():
+            self.winner = winner
+        elif not self.legal_moves:
+            self.draw = True
+        else:
+            self.player = -1 * self.player
+        return self
+
+    def is_active(self):
+        return not self.winner and not self.draw

arena/board_view.py

@@ -0,0 +1,132 @@
+RED = 1
+YELLOW = -1
+EMPTY = 0
+
+def to_svg(board):
+    """Convert the board state to an SVG representation"""
+    svg = '''
+    <div style="display: flex; justify-content: center;">
+    <svg width="450" height="420" viewBox="0 0 450 420">
+        <!-- Definitions for gradients and clips -->
+        <defs>
+            <radialGradient id="redGradient" cx="0.5" cy="0.3" r="0.7">
+                <stop offset="0%" stop-color="#ff6666"/>
+                <stop offset="100%" stop-color="#cc0000"/>
+            </radialGradient>
+            <radialGradient id="yellowGradient" cx="0.5" cy="0.3" r="0.7">
+                <stop offset="0%" stop-color="#ffff88"/>
+                <stop offset="100%" stop-color="#cccc00"/>
+            </radialGradient>
+            <linearGradient id="emptyGradient" x1="0" y1="0" x2="0" y2="1">
+                <stop offset="0%" stop-color="#ffffff"/>
+                <stop offset="100%" stop-color="#e0e0e0"/>
+            </linearGradient>
+
+            <!-- Define the mask for the holes -->
+            <mask id="holes">
+                <rect x="25" y="25" width="400" height="320" fill="white"/>
+                '''
+    # Add the holes to the mask
+    svg += ''.join(f'''
+                <circle 
+                    cx="{(x * 50) + 75}" 
+                    cy="{(y * 50) + 60}" 
+                    r="20" 
+                    fill="black"
+                />
+                '''
+                for y in range(6)
+                for x, cell in enumerate(board.cells[5-y])
+            )
+    
+    svg += '''
+            </mask>
+        </defs>
+
+        <!-- Stand -->
+        <path d="M0 360 L25 300 H425 L450 360 L425 385 H25 Z" fill="#004fa3"/>
+        
+        <!-- Game pieces (will show through the holes) -->
+        '''
+    
+    # Add pieces
+    svg += ''.join(f'''
+            <circle 
+                class="{f'new-piece' if x == board.latest_x and y == (5-board.latest_y) else ''}"
+                cx="{(x * 50) + 75}"
+                cy="{(y * 50) + 60}"
+                r="20" 
+                fill="{
+                    'url(#redGradient)' if (cell == RED) else 
+                    'url(#yellowGradient)' if (cell == YELLOW) else 
+                    'none'
+                }"
+                stroke="{
+                    '#cc0000' if (cell == RED) else
+                    '#cccc00' if (cell == YELLOW) else
+                    'none'
+                }"
+                stroke-width="1"
+            />
+            <circle 
+                class="{f'new-piece-highlight' if x == board.latest_x and y == (5-board.latest_y) else ''}"
+                cx="{(x * 50) + 75 - 5}"
+                cy="{(y * 50) + 60 - 5}"
+                r="8" 
+                fill="{
+                    '#ff8888' if (cell == RED) else
+                    '#ffff99' if (cell == YELLOW) else
+                    'none'
+                }"
+                opacity="0.3"
+            />
+            '''
+            for y in range(6)
+            for x, cell in enumerate(board.cells[5-y])
+            if cell != EMPTY
+        )
+
+    svg += '''
+
+        <!-- Board overlay with holes -->
+        <rect x="25" y="25" width="400" height="320" fill="#0066cc" rx="10" mask="url(#holes)"/>
+        
+        <!-- Hole borders (on top of everything for better 3D effect) -->
+        '''
+    
+    # Add hole borders on top
+    svg += ''.join(f'''
+            <circle 
+                cx="{(x * 50) + 75}" 
+                cy="{(y * 50) + 60}" 
+                r="20" 
+                fill="none"
+                stroke="#005ab3"
+                stroke-width="2"
+            />
+            '''
+            for y in range(6)
+            for x, cell in enumerate(board.cells[5-y])
+        )
+    
+    svg += '''
+    </svg>
+</div>
+<style>
+    .new-piece {
+        animation: dropPiece 0.5s cubic-bezier(0.95, 0.05, 1, 0.5);
+    }
+    .new-piece-highlight {
+        animation: dropPiece 0.5s cubic-bezier(0.95, 0.05, 1, 0.5);
+    }
+    @keyframes dropPiece {
+        from {
+            transform: translateY(-300px);
+        }
+        to {
+            transform: translateY(0);
+        }
+    }
+</style>
+'''
+    return svg

arena/c4.py

@@ -0,0 +1,198 @@
+from arena.game import Game
+from arena.board import RED, YELLOW
+from arena.llm import LLM
+import gradio as gr
+
+all_model_names = LLM.all_model_names()
+
+css = "footer{display:none !important}"
+
+js = """
+function refresh() {
+    const url = new URL(window.location);
+
+    if (url.searchParams.get('__theme') !== 'dark') {
+        url.searchParams.set('__theme', 'dark');
+        window.location.href = url.href;
+    }
+}
+"""
+
+
+def message_html(game):
+    return (
+        f'<div style="text-align: center;font-size:18px">{game.board.message()}</div>'
+    )
+
+
+def load_callback(red_llm, yellow_llm):
+    game = Game(red_llm, yellow_llm)
+    enabled = gr.Button(interactive=True)
+    message = message_html(game)
+    return game, game.board.svg(), message, "", "", enabled, enabled, enabled
+
+
+def move_callback(game):
+    game.move()
+    message = message_html(game)
+    if_active = gr.Button(interactive=game.board.is_active())
+    return (
+        game,
+        game.board.svg(),
+        message,
+        game.thoughts(RED),
+        game.thoughts(YELLOW),
+        if_active,
+        if_active,
+    )
+
+
+def run_callback(game):
+    enabled = gr.Button(interactive=True)
+    disabled = gr.Button(interactive=False)
+    message = message_html(game)
+    yield game, game.board.svg(), message, game.thoughts(RED), game.thoughts(
+        YELLOW
+    ), disabled, disabled, disabled
+    while game.board.is_active():
+        game.move()
+        message = message_html(game)
+        yield game, game.board.svg(), message, game.thoughts(RED), game.thoughts(
+            YELLOW
+        ), disabled, disabled, disabled
+    yield game, game.board.svg(), message, game.thoughts(RED), game.thoughts(
+        YELLOW
+    ), disabled, disabled, enabled
+
+
+def model_callback(player_name, game, new_model_name):
+    player = game.players[player_name]
+    player.switch_model(new_model_name)
+    return game
+
+
+def red_model_callback(game, new_model_name):
+    return model_callback(RED, game, new_model_name)
+
+
+def yellow_model_callback(game, new_model_name):
+    return model_callback(YELLOW, game, new_model_name)
+
+
+def player_section(name, default):
+    with gr.Row():
+        gr.Markdown(
+            f'<div style="text-align: center;font-size:18px">{name} Player</div>'
+        )
+    with gr.Row():
+        dropdown = gr.Dropdown(
+            all_model_names, value=default, label="LLM", interactive=True
+        )
+    with gr.Row():
+        gr.Markdown(
+            f'<div style="text-align: center;font-size:16px">Inner thoughts</div>'
+        )
+    with gr.Row():
+        thoughts = gr.Markdown(label="Thoughts")
+    return thoughts, dropdown
+
+
+def make_display():
+    with gr.Blocks(
+        title="C4 Battle",
+        css=css,
+        js=js,
+        theme=gr.themes.Default(primary_hue="sky"),
+    ) as blocks:
+
+        game = gr.State()
+
+        with gr.Row():
+            gr.Markdown(
+                '<div style="text-align: center;font-size:24px">Four-in-a-row LLM Showdown</div>'
+            )
+        with gr.Row():
+            with gr.Column(scale=1):
+                red_thoughts, red_dropdown = player_section("Red", "gpt-4o")
+            with gr.Column(scale=2):
+                with gr.Row():
+                    message = gr.Markdown(
+                        '<div style="text-align: center;font-size:18px">The Board</div>'
+                    )
+                with gr.Row():
+                    board_display = gr.HTML()
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        move_button = gr.Button("Next move")
+                    with gr.Column(scale=1):
+                        run_button = gr.Button("Run game", variant="primary")
+                    with gr.Column(scale=1):
+                        reset_button = gr.Button("Start Over", variant="stop")
+            with gr.Column(scale=1):
+                yellow_thoughts, yellow_dropdown = player_section(
+                    "Yellow", "claude-3-5-sonnet-latest"
+                )
+
+        blocks.load(
+            load_callback,
+            inputs=[red_dropdown, yellow_dropdown],
+            outputs=[
+                game,
+                board_display,
+                message,
+                red_thoughts,
+                yellow_thoughts,
+                move_button,
+                run_button,
+                reset_button,
+            ],
+        )
+        move_button.click(
+            move_callback,
+            inputs=[game],
+            outputs=[
+                game,
+                board_display,
+                message,
+                red_thoughts,
+                yellow_thoughts,
+                move_button,
+                run_button,
+            ],
+        )
+        red_dropdown.change(
+            red_model_callback, inputs=[game, red_dropdown], outputs=[game]
+        )
+        yellow_dropdown.change(
+            yellow_model_callback, inputs=[game, yellow_dropdown], outputs=[game]
+        )
+        run_button.click(
+            run_callback,
+            inputs=[game],
+            outputs=[
+                game,
+                board_display,
+                message,
+                red_thoughts,
+                yellow_thoughts,
+                move_button,
+                run_button,
+                reset_button,
+            ],
+        )
+        reset_button.click(
+            load_callback,
+            inputs=[red_dropdown, yellow_dropdown],
+            outputs=[
+                game,
+                board_display,
+                message,
+                red_thoughts,
+                yellow_thoughts,
+                move_button,
+                run_button,
+                reset_button,
+            ],
+        )
+
+    return blocks

arena/game.py

@@ -0,0 +1,28 @@
+from arena.board import Board, RED, YELLOW, EMPTY, pieces
+from arena.player import Player
+from dotenv import load_dotenv
+
+
+class Game:
+
+    def __init__(self, model_red, model_yellow):
+        load_dotenv(override=True)
+        self.board = Board()
+        self.players = {
+            RED: Player(model_red, RED),
+            YELLOW: Player(model_yellow, YELLOW),
+        }
+
+    def move(self):
+        self.players[self.board.player].move(self.board)
+
+    def is_active(self):
+        return self.board.is_active()
+
+    def thoughts(self, player):
+        return self.players[player].thoughts()
+
+    def run(self):
+        while self.is_active():
+            self.move()
+            print(self.board)

arena/llm.py

@@ -0,0 +1,383 @@
+from abc import ABC
+from anthropic import Anthropic
+from openai import OpenAI
+from groq import Groq
+import logging
+from typing import Dict, Type, Self, List
+import os
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class LLMException(Exception):
+    pass
+
+
+class LLM(ABC):
+    """
+    An abstract superclass for interacting with LLMs - subclass for Claude and GPT
+    """
+
+    model_names = []
+
+    def __init__(self, model_name: str, temperature: float):
+        self.model_name = model_name
+        self.client = None
+        self.temperature = temperature
+
+    def send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        print("_____")
+        print(f"Calling {self.model_name}")
+        print("System prompt:\n" + system)
+        print("User prompt:\n" + user)
+        result = self.protected_send(system, user, max_tokens)
+        print("Response:\n" + result)
+        print("_____")
+        left = result.find("{")
+        right = result.rfind("}")
+        if left > -1 and right > -1:
+            result = result[left : right + 1]
+        return result
+
+    def protected_send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        retries = 5
+        done = False
+        while retries:
+            retries -= 1
+            try:
+                return self._send(system, user, max_tokens)
+            except Exception as e:
+                print(f"Exception on calling LLM of {e}")
+                if retries:
+                    print("Waiting 2s and retrying")
+                    time.sleep(2)
+        return "{}"
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        pass
+
+    @classmethod
+    def model_map(cls) -> Dict[str, Type[Self]]:
+        """
+        Generate a mapping of Model Names to LLM classes, by looking at all subclasses of this one
+        :return: a mapping dictionary from model name to LLM subclass
+        """
+        mapping = {}
+        for llm in cls.__subclasses__():
+            for model_name in llm.model_names:
+                mapping[model_name] = llm
+        return mapping
+
+    @classmethod
+    def all_model_names(cls) -> List[str]:
+        return cls.model_map().keys()
+
+    @classmethod
+    def create(cls, model_name: str, temperature: float = 0.5) -> Self:
+        """
+        Return an instance of a subclass that corresponds to this model_name
+        :param model_name: a string to describe this model
+        :param temperature: the creativity setting
+        :return: a new instance of a subclass of LLM
+        """
+        subclass = cls.model_map().get(model_name)
+        if not subclass:
+            raise LLMException(f"Unrecognized LLM model name specified: {model_name}")
+        return subclass(model_name, temperature)
+
+
+class Claude(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case Claude
+    """
+
+    model_names = ["claude-3-5-sonnet-latest"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the Anthropic client
+        """
+        super().__init__(model_name, temperature)
+        self.client = Anthropic()
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to Claude
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        response = self.client.messages.create(
+            model=self.model_name,
+            max_tokens=max_tokens,
+            temperature=self.temperature,
+            system=system,
+            messages=[
+                {"role": "user", "content": user},
+            ],
+        )
+        return response.content[0].text
+
+
+class GPT(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case GPT
+    """
+
+    model_names = ["gpt-4o-mini", "gpt-4o"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name, temperature)
+        self.client = OpenAI()
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to GPT
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            response_format={"type": "json_object"},
+        )
+        return response.choices[0].message.content
+
+
+class O1(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case GPT
+    """
+
+    model_names = ["o1-mini"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name, temperature)
+        self.client = OpenAI()
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to GPT
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        message = system + "\n\n" + user
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "user", "content": message},
+            ],
+        )
+        return response.choices[0].message.content
+
+
+class O3(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case GPT
+    """
+
+    model_names = ["o3-mini"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name, temperature)
+        override = os.getenv("OPENAI_API_KEY_O3")
+        if override:
+            print("Using special key with o3 access")
+            self.client = OpenAI(api_key=override)
+        else:
+            self.client = OpenAI()
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to GPT
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        message = system + "\n\n" + user
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "user", "content": message},
+            ],
+        )
+        return response.choices[0].message.content
+
+
+class Ollama(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case Ollama via the OpenAI client
+    """
+
+    model_names = ["llama3.2 local", "gemma2 local", "qwen2.5 local", "phi4 local"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name.replace(" local", ""), temperature)
+        self.client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to Ollama
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            response_format={"type": "json_object"},
+        )
+        reply = response.choices[0].message.content
+        if "</think>" in reply:
+            print("Thoughts:\n" + reply.split("</think>")[0].replace("<think>", ""))
+            reply = reply.split("</think>")[1]
+        return reply
+
+
+class DeepSeekAPI(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case DeepSeek via the OpenAI client
+    """
+
+    model_names = ["deepseek-V3", "deepseek-r1"]
+
+    model_map = {"deepseek-V3": "deepseek-chat", "deepseek-r1": "deepseek-reasoner"}
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(self.model_map[model_name], temperature)
+        deepseek_api_key = os.getenv("DEEPSEEK_API_KEY")
+        self.client = OpenAI(
+            api_key=deepseek_api_key, base_url="https://api.deepseek.com"
+        )
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to DeepSeek
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            # response_format={"type": "json_object"},
+        )
+        reply = response.choices[0].message.content
+        return reply
+
+
+class DeepSeekLocal(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case Ollama via the OpenAI client
+    """
+
+    model_names = ["deepseek-r1:14b local"]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name.replace(" local", ""), temperature)
+        self.client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to Ollama
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        system += "\nImportant: avoid overthinking. Think briefly and decisively. The final response must follow the given json format or you forfeit the game. Do not overthink. Respond with json."
+        user += "\nImportant: avoid overthinking. Think briefly and decisively. The final response must follow the given json format or you forfeit the game. Do not overthink. Respond with json."
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+        )
+        reply = response.choices[0].message.content
+        if "</think>" in reply:
+            print("Thoughts:\n" + reply.split("</think>")[0].replace("<think>", ""))
+            reply = reply.split("</think>")[1]
+        return reply
+
+
+class GroqAPI(LLM):
+    """
+    A class to act as an interface to the remote AI, in this case Groq
+    """
+
+    model_names = [
+        "deepseek-r1-distill-llama-70b via Groq",
+        "llama-3.3-70b-versatile via Groq",
+        "mixtral-8x7b-32768 via Groq",
+    ]
+
+    def __init__(self, model_name: str, temperature: float):
+        """
+        Create a new instance of the OpenAI client
+        """
+        super().__init__(model_name[:-9], temperature)
+        self.client = Groq()
+
+    def _send(self, system: str, user: str, max_tokens: int = 3000) -> str:
+        """
+        Send a message to GPT
+        :param system: the context in which this message is to be taken
+        :param user: the prompt
+        :param max_tokens: max number of tokens to generate
+        :return: the response from the AI
+        """
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            response_format={"type": "json_object"},
+        )
+        return response.choices[0].message.content

arena/player.py

@@ -0,0 +1,126 @@
+from arena.llm import LLM
+from arena.board import pieces, cols
+import json
+import random
+
+
+class Player:
+
+    def __init__(self, model, color):
+        self.color = color
+        self.model = model
+        self.llm = LLM.create(self.model)
+        self.evaluation = ""
+        self.threats = ""
+        self.opportunities = ""
+        self.strategy = ""
+
+    def system(self, board, legal_moves, illegal_moves):
+        return f"""You are playing the board game Connect 4.
+Players take turns to drop counters into one of 7 columns A, B, C, D, E, F, G.
+The winner is the first player to get 4 counters in a row in any direction.
+You are {pieces[self.color]} and your opponent is {pieces[self.color * -1]}.
+You must pick a column for your move. You must pick one of the following legal moves: {legal_moves}.
+You should respond in JSON according to this spec:
+
+{{
+    "evaluation": "my assessment of the board",
+    "threats": "any threats from my opponent that I should block",
+    "opportunities": "my best chances to win",
+    "strategy": "my thought process",
+    "move_column": "one letter from this list of legal moves: {legal_moves}"
+}}
+
+You must pick one of these letters for your move_column: {legal_moves}{illegal_moves}"""
+
+    def user(self, board, legal_moves, illegal_moves):
+        return f"""It is your turn to make a move as {pieces[self.color]}.
+Here is the current board, with row 1 at the bottom of the board:
+
+{board.json()}
+
+Here's another way of looking at the board visually, where R represents a red counter and Y for a yellow counter.
+
+{board.alternative()}
+
+Your final response should be only in JSON strictly according to this spec:
+
+{{
+    "evaluation": "my assessment of the board",
+    "threats": "any threats from my opponent that I should block",
+    "opportunities": "my best chances to win",
+    "strategy": "my thought process",
+    "move_column": "one of {legal_moves} which are the legal moves"
+}}
+
+For example, the following could be a response:
+
+{{
+    "evaluation": "the board is equally balanced but I have a slight advantage",
+    "threats": "my opponent has a threat but I can block it",
+    "opportunities": "I've developed several promising 3 in a row opportunities",
+    "strategy": "I must first block my opponent, then I can continue to develop",
+    "move_column": "{random.choice(board.legal_moves())}"
+}}
+
+And this is another example of a well formed response:
+
+{{
+    "evaluation": "although my opponent has more threats, I can win immediately",
+    "threats": "my opponent has several threats",
+    "opportunities": "I can immediately win the game by making a diagonal 4",
+    "strategy": "I will take the winning move",
+    "move_column": "{random.choice(board.legal_moves())}"
+}}
+
+
+Now make your decision.
+You must pick one of these letters for your move_column: {legal_moves}{illegal_moves}
+"""
+
+    def process_move(self, reply, board):
+        print(reply)
+        try:
+            if len(reply) == 3 and reply[0] == "{" and reply[2] == "}":
+                reply = f'{{"move_column": "{reply[1]}"}}'
+            result = json.loads(reply)
+            move = result.get("move_column") or "missing"
+            move = move.upper()
+            col = cols.find(move)
+            if not (0 <= col <= 6) or board.height(col) == 6:
+                raise ValueError("Illegal move")
+            board.move(col)
+            self.evaluation = result.get("evaluation") or ""
+            self.threats = result.get("threats") or ""
+            self.opportunities = result.get("opportunities") or ""
+            self.strategy = result.get("strategy") or ""
+        except Exception as e:
+            print(f"Exception {e}")
+            board.forfeit = True
+            board.winner = -1 * board.player
+
+    def move(self, board):
+        legal_moves = ", ".join(board.legal_moves())
+        if illegal := board.illegal_moves():
+            illegal_moves = (
+                "\nYou must NOT make any of these moves which are ILLEGAL: "
+                + ", ".join(illegal)
+            )
+        else:
+            illegal_moves = ""
+        system = self.system(board, legal_moves, illegal_moves)
+        user = self.user(board, legal_moves, illegal_moves)
+        reply = self.llm.send(system, user)
+        self.process_move(reply, board)
+
+    def thoughts(self):
+        result = '<div style="text-align: left;font-size:14px"><br/>'
+        result += f"<b>Evaluation:</b><br/>{self.evaluation}<br/><br/>"
+        result += f"<b>Threats:</b><br/>{self.threats}<br/><br/>"
+        result += f"<b>Opportunities:</b><br/>{self.opportunities}<br/><br/>"
+        result += f"<b>Strategy:</b><br/>{self.strategy}"
+        result += "</div>"
+        return result
+
+    def switch_model(self, new_model_name):
+        self.llm = LLM.create(new_model_name)