change

app.py

@@ -2,13 +2,14 @@ import os
 import asyncio
 from dotenv import load_dotenv
 from mcp.server.fastmcp import FastMCP
-from utils.agent_factory import create_agent, get_supported_agent_types, get_default_models
+
 from utils.pokemon_utils import (
-    start_ladder_battle, start_battle_against_agent, start_battle_against_player,
+    start_ladder_battle, start_battle_against_player,
     submit_move_for_battle, get_battle_state, list_active_battles,
     download_battle_replay, cleanup_completed_battles, format_battle_state,
     check_recent_battles, debug_move_attributes, active_battles, player_instances
 )
+from utils.pokemon_utils import player_instances_by_unique
 
 load_dotenv()
 
@@ -25,124 +26,6 @@ current_session = {
     'active_battle_id': None
 }
 
-# --- MCP Tools ---
-
-@mcp.tool()
-def start_ladder_match(username: str = "MCPTrainer") -> dict:
-    """
-    Start a ladder battle on Pokemon Showdown.
-    Args:
-        username (str): Username for the MCP-controlled player
-    Returns:
-        dict: Battle information including battle ID and initial state
-    """
-    global current_session
-    try:
-        # Start ladder search (fire-and-forget)
-        ladder_result = start_ladder_battle(username)
-        
-        current_session['username'] = username
-        # Don't set active_battle_id yet since battle hasn't started
-        
-        return {
-            "status": "ladder_search_queued",
-            "message": f"Ladder search queued for {username}. Waiting for opponent match.",
-            "instructions": "Use find_recent_battles() or get_player_status() in a few seconds to get the battle ID and viewing link once a match is found.",
-            "note": "Check server console for 'Ladder search started' confirmation."
-        }
-    except Exception as e:
-        return {
-            "status": "error",
-            "message": f"Failed to start ladder battle: {str(e)}"
-        }
-
-# @mcp.tool()
-# async def battle_agent(agent_type: str, username: str = "MCPTrainer", api_key: str = None, model: str = None) -> dict:
-#     """
-#     Start a battle against an AI agent.
-#     Args:
-#         agent_type (str): Type of agent ('openai', 'gemini', 'mistral', 'maxdamage', 'random')
-#         username (str): Username for the MCP-controlled player
-#         api_key (str, optional): API key for AI agents (required for openai, gemini, mistral)
-#         model (str, optional): Specific model to use (will use default if not specified)
-#     Returns:
-#         dict: Battle information including battle ID and initial state
-#     """
-#     global current_session
-#     try:
-#         # Validate agent type
-#         if agent_type.lower() not in get_supported_agent_types():
-#             return {
-#                 "status": "error",
-#                 "message": f"Unsupported agent type. Supported types: {get_supported_agent_types()}"
-#             }
-#         
-#         # Create opponent agent
-#         opponent = create_agent(agent_type, api_key=api_key, model=model)
-#         
-#         # Start battle
-#         battle_id = await start_battle_against_agent(username, opponent)
-#         
-#         current_session['username'] = username
-#         current_session['active_battle_id'] = battle_id
-#         
-#         # Get initial battle state
-#         battle_info = get_battle_state(battle_id)
-#         
-#         return {
-#             "status": "success",
-#             "battle_id": battle_id,
-#             "message": f"Battle started against {agent_type} agent",
-#             "opponent": opponent.username,
-#             "battle_url": battle_info.get('battle_url', f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}"),
-#             "battle_state": battle_info['battle_state'],
-#             "waiting_for_move": battle_info['waiting_for_move']
-#         }
-#     except Exception as e:
-#         return {
-#             "status": "error",
-#             "message": f"Failed to start battle against agent: {str(e)}"
-#         }
-
-@mcp.tool()
-def setup_battle() -> dict:
-    """
-    Get setup information for playing Pokemon battles.
-    Provides instructions on how to join and play battles on the platform.
-    Returns:
-        dict: Setup instructions and platform information
-    """
-    return {
-        "status": "success",
-        "message": "Pokemon Battle Setup Information",
-        "instructions": {
-            "how_to_play": [
-                "1. Visit the Pokemon Showdown platform at: https://huggingface.co/spaces/Jofthomas/Pokemon_showdown",
-                "2. Choose a random username for yourself",
-                "3. Use the MCP tools to start battles, make moves, and interact with the game",
-                "4. You can start ladder matches, challenge specific players, or join existing battles"
-            ],
-            "platform_url": "https://huggingface.co/spaces/Jofthomas/Pokemon_showdown",
-            "username_tip": "Choose any random username you like - it will be your identity in the Pokemon battle arena",
-            "available_battle_types": [
-                "Ladder battles (automatic matchmaking)",
-                "Player vs Player challenges",
-                "Spectate ongoing battles"
-            ]
-        },
-        "next_steps": [
-            "Visit the platform and choose your username",
-            "Use start_ladder_match() to find a random opponent",
-            "Use battle_player() to challenge a specific player",
-            "Use get_current_battle_state() to see your battle status"
-        ],
-        "platform_info": {
-            "name": "Pokemon Showdown on Hugging Face",
-            "url": "https://huggingface.co/spaces/Jofthomas/Pokemon_showdown",
-            "type": "Web-based Pokemon battle simulator",
-            "access": "Free and open to all users"
-        }
-    }
 
 @mcp.tool()
 def battle_player(opponent_username: str, username: str = "MCPTrainer") -> dict:
@@ -166,6 +49,8 @@ def battle_player(opponent_username: str, username: str = "MCPTrainer") -> dict:
             "status": "challenge_queued",
             "message": f"Challenge to {opponent_username} queued. Battle will start when accepted.",
             "opponent": opponent_username,
+            "player_base_username": challenge_result.get('player_base_username'),
+            "player_unique_username": challenge_result.get('player_unique_username'),
             "instructions": "Use find_recent_battles() or get_player_status() in a few seconds to get the battle ID and viewing link once the battle starts.",
             "note": "Check server console for 'Challenge sent' confirmation."
         }
@@ -342,25 +227,6 @@ async def download_replay(battle_id: str = None) -> dict:
             "message": f"Failed to download replay: {str(e)}"
         }
 
-@mcp.tool()
-def get_supported_agents() -> dict:
-    """
-    Get information about supported agent types and their default models.
-    Returns:
-        dict: Information about available agents
-    """
-    return {
-        "status": "success",
-        "supported_agents": get_supported_agent_types(),
-        "default_models": get_default_models(),
-        "description": {
-            "openai": "OpenAI GPT models (requires API key) - Deterministic decisions",
-            "gemini": "Google Gemini models (requires API key) - Deterministic decisions",
-            "mistral": "Mistral AI models (requires API key) - Deterministic decisions",
-            "maxdamage": "Simple agent that chooses moves with highest base power - Deterministic decisions"
-        }
-    }
-
 @mcp.tool()
 def get_player_status(username: str = None) -> dict:
     """
@@ -381,34 +247,54 @@ def get_player_status(username: str = None) -> dict:
                 "message": "No username provided and no active session."
             }
         
-        if target_username not in player_instances:
+        players_to_check = []
+        if target_username in player_instances:
+            players_to_check = list(player_instances[target_username].values())
+        elif target_username in player_instances_by_unique:
+            players_to_check = [player_instances_by_unique[target_username]]
+        else:
             return {
                 "status": "no_player",
                 "username": target_username,
                 "message": f"No player instance found for {target_username}"
             }
         
-        player = player_instances[target_username]
-        player_battles = []
-        
-        for battle_id, battle in player.battles.items():
-            battle_info = {
-                'battle_id': battle_id,
-                'battle_url': f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}",
-                'turn': getattr(battle, 'turn', 0),
-                'finished': getattr(battle, 'finished', False),
-                'won': getattr(battle, 'won', None)
-            }
-            player_battles.append(battle_info)
+        all_battles = []
+        total_battles = 0
+        total_won = 0
+        total_finished = 0
+        
+        for p in players_to_check:
+            total_battles += len(p.battles)
+            total_won += getattr(p, 'n_won_battles', 0)
+            total_finished += getattr(p, 'n_finished_battles', 0)
+            for battle_id, battle in p.battles.items():
+                battle_info = {
+                    'battle_id': battle_id,
+                    'battle_url': f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}",
+                    'turn': getattr(battle, 'turn', 0),
+                    'finished': getattr(battle, 'finished', False),
+                    'won': getattr(battle, 'won', None),
+                    'player_unique_username': p.username,
+                    'player_base_username': getattr(p, 'base_username', target_username)
+                }
+                all_battles.append(battle_info)
         
         return {
             "status": "success",
-            "username": target_username,
-            "player_username": player.username,
-            "total_battles": len(player.battles),
-            "battles": player_battles,
-            "n_won_battles": getattr(player, 'n_won_battles', 0),
-            "n_finished_battles": getattr(player, 'n_finished_battles', 0)
+            "query_username": target_username,
+            "resolved_scope": "base" if target_username in player_instances else "unique",
+            "players": [
+                {
+                    'player_unique_username': p.username,
+                    'player_base_username': getattr(p, 'base_username', target_username),
+                    'n_battles': len(p.battles)
+                } for p in players_to_check
+            ],
+            "total_battles": total_battles,
+            "battles": all_battles,
+            "n_won_battles": total_won,
+            "n_finished_battles": total_finished
         }
     except Exception as e:
         return {
@@ -456,75 +342,6 @@ def find_recent_battles(username: str = None) -> dict:
             "status": "error",
             "message": f"Failed to check recent battles: {str(e)}"
         }
-
-@mcp.tool()
-def debug_battle_objects(username: str = None, battle_id: str = None) -> dict:
-    """
-    Debug tool to inspect battle objects and their attributes.
-    Useful for troubleshooting formatting errors.
-    Args:
-        username (str, optional): Username to debug (uses current session if not provided)
-        battle_id (str, optional): Specific battle ID to debug
-    Returns:
-        dict: Debug information about battle objects
-    """
-    global current_session
-    try:
-        # Use provided username or current session username
-        target_username = username or current_session.get('username')
-        target_battle_id = battle_id or current_session.get('active_battle_id')
-        
-        if not target_username:
-            return {
-                "status": "error",
-                "message": "No username provided and no active session."
-            }
-        
-        if target_username not in player_instances:
-            return {
-                "status": "error",
-                "message": f"No player instance found for {target_username}"
-            }
-        
-        player = player_instances[target_username]
-        debug_result = {
-            "status": "success",
-            "username": target_username,
-            "player_username": player.username,
-            "total_battles": len(player.battles),
-            "battles_debug": []
-        }
-        
-        battles_to_debug = []
-        if target_battle_id and target_battle_id in player.battles:
-            battles_to_debug = [(target_battle_id, player.battles[target_battle_id])]
-        else:
-            # Debug all battles (limit to 3 most recent)
-            battles_to_debug = list(player.battles.items())[-3:]
-        
-        for bid, battle in battles_to_debug:
-            try:
-                battle_debug = {
-                    "battle_id": bid,
-                    "battle_type": type(battle).__name__,
-                    "battle_attributes": [attr for attr in dir(battle) if not attr.startswith('_')],
-                    "move_debug": debug_move_attributes(battle)
-                }
-                debug_result["battles_debug"].append(battle_debug)
-            except Exception as e:
-                debug_result["battles_debug"].append({
-                    "battle_id": bid,
-                    "error": f"Error debugging battle: {e}"
-                })
-        
-        return debug_result
-        
-    except Exception as e:
-        return {
-            "status": "error",
-            "message": f"Failed to debug battle objects: {str(e)}"
-        }
-
 @mcp.tool()
 def cleanup_battles() -> dict:
     """

utils/pokemon_utils.py

@@ -18,14 +18,15 @@ custom_config = ServerConfiguration(CUSTOM_SERVER_URL, CUSTOM_ACTION_URL)
 # Global battle state management
 active_battles = {}
 player_instances = {}
+player_instances_by_unique = {}
 
 class MCPPokemonAgent(LLMAgentBase):
     """
     Special Pokemon agent controlled by MCP that allows external move selection.
     """
-    def __init__(self, username: str, *args, **kwargs):
+    def __init__(self, base_username: str, *args, **kwargs):
         # Add random suffix to make username unique
-        unique_username = f"{username}_{random.randint(1000, 9999)}"
+        unique_username = f"{base_username}_{random.randint(1000, 9999)}"
         account_config = AccountConfiguration(unique_username, None)
         super().__init__(
             account_configuration=account_config,
@@ -36,6 +37,8 @@ class MCPPokemonAgent(LLMAgentBase):
             log_level=25,  # Reduce logging verbosity
             *args, **kwargs
         )
+        self.base_username = base_username
+        self.unique_username = unique_username
         self.external_move_queue = asyncio.Queue()
         self.battle_state_callback = None
         self.current_battle_id = None
@@ -102,6 +105,13 @@ class MCPPokemonAgent(LLMAgentBase):
         else:
             raise ValueError("Must specify either move_name or pokemon_name")
 
+# Helper to register instances under base and unique usernames
+def register_player_instance(base_username: str, player: MCPPokemonAgent) -> None:
+    if base_username not in player_instances:
+        player_instances[base_username] = {}
+    player_instances[base_username][player.username] = player
+    player_instances_by_unique[player.username] = player
+
 def normalize_name(name: str) -> str:
     """Lowercase and remove non-alphanumeric characters."""
     return "".join(filter(str.isalnum, name)).lower()
@@ -266,11 +276,9 @@ def start_ladder_battle(username: str) -> Dict[str, str]:
     Returns:
         dict: Status information about the ladder request
     """
-    if username in player_instances:
-        player = player_instances[username]
-    else:
-        player = MCPPokemonAgent(username)
-        player_instances[username] = player
+    # Always create a new unique player instance for this request
+    player = MCPPokemonAgent(username)
+    register_player_instance(username, player)
     
     # Start ladder battle (this will connect to showdown and find a match)
     try:
@@ -280,14 +288,12 @@ def start_ladder_battle(username: str) -> Dict[str, str]:
         # Return immediately
         return {
             'status': 'ladder_search_queued',
-            'player_username': username,
+            'player_base_username': username,
+            'player_unique_username': player.username,
             'message': f'Ladder search queued for {username}. Use find_recent_battles() or get_player_status() to check when match is found.'
         }
             
     except Exception as e:
-        # Clean up player instance on failure
-        if username in player_instances:
-            del player_instances[username]
         raise Exception(f"Failed to queue ladder search: {str(e)}")
 
 async def start_battle_against_agent(username: str, opponent_agent, battle_format: str = "gen9randombattle") -> str:
@@ -302,11 +308,9 @@ async def start_battle_against_agent(username: str, opponent_agent, battle_forma
     Returns:
         str: Battle ID
     """
-    if username in player_instances:
-        player = player_instances[username]
-    else:
-        player = MCPPokemonAgent(username)
-        player_instances[username] = player
+    # Always create a new unique player instance for this request
+    player = MCPPokemonAgent(username)
+    register_player_instance(username, player)
     
     try:
         # Start battle against opponent
@@ -329,7 +333,9 @@ async def start_battle_against_agent(username: str, opponent_agent, battle_forma
                 # Store battle info
                 active_battles[battle_id] = {
                     'type': 'agent',
-                    'player_username': username,
+                    'player_base_username': player.base_username,
+                    'player_unique_username': player.username,
+                    'player_username': player.base_username,
                     'opponent': opponent_agent.username,
                     'battle_state': format_battle_state(battle),
                     'waiting_for_move': False,
@@ -364,11 +370,9 @@ def start_battle_against_player(username: str, opponent_username: str) -> Dict[s
     Returns:
         dict: Status information about the challenge request
     """
-    if username in player_instances:
-        player = player_instances[username]
-    else:
-        player = MCPPokemonAgent(username)
-        player_instances[username] = player
+    # Always create a new unique player instance for this request
+    player = MCPPokemonAgent(username)
+    register_player_instance(username, player)
     
     try:
         # Start challenge in background task (fire-and-forget)
@@ -377,15 +381,13 @@ def start_battle_against_player(username: str, opponent_username: str) -> Dict[s
         # Return immediately
         return {
             'status': 'challenge_queued',
-            'player_username': username,
+            'player_base_username': username,
+            'player_unique_username': player.username,
             'opponent': opponent_username,
             'message': f'Challenge to {opponent_username} queued. Use find_recent_battles() or get_player_status() to check if battle started.'
         }
             
     except Exception as e:
-        # Clean up player instance on failure
-        if username in player_instances:
-            del player_instances[username]
         raise Exception(f"Failed to queue challenge to {opponent_username}: {str(e)}")
 
 async def submit_move_for_battle(battle_id: str, move_name: str = None, pokemon_name: str = None) -> str:
@@ -404,12 +406,12 @@ async def submit_move_for_battle(battle_id: str, move_name: str = None, pokemon_
         raise ValueError(f"Battle {battle_id} not found")
     
     battle_info = active_battles[battle_id]
-    username = battle_info['player_username']
+    unique_username = battle_info.get('player_unique_username') or battle_info.get('player_username')
     
-    if username not in player_instances:
-        raise ValueError(f"Player {username} not found")
+    if unique_username not in player_instances_by_unique:
+        raise ValueError(f"Player {unique_username} not found")
     
-    player = player_instances[username]
+    player = player_instances_by_unique[unique_username]
     
     # Find the battle object
     battle = None
@@ -458,6 +460,8 @@ def list_active_battles() -> List[Dict[str, Any]]:
             'opponent': info['opponent'],
             'waiting_for_move': info['waiting_for_move'],
             'completed': info['completed'],
+            'player_base_username': info.get('player_base_username', info.get('player_username')),
+            'player_unique_username': info.get('player_unique_username'),
             'battle_url': info.get('battle_url', f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}")
         }
         for battle_id, info in active_battles.items()
@@ -468,42 +472,50 @@ def check_recent_battles(username: str) -> List[Dict[str, Any]]:
     Check for recent battles that may have started after a timeout.
     
     Args:
-        username (str): Username to check battles for
+        username (str): Username to check battles for (base or unique)
         
     Returns:
         list: List of recent battle info
     """
-    if username not in player_instances:
+    recent_battles: List[Dict[str, Any]] = []
+    
+    # Determine which player instances to inspect
+    players_to_check: List[MCPPokemonAgent] = []
+    if username in player_instances:
+        players_to_check = list(player_instances[username].values())
+    elif username in player_instances_by_unique:
+        players_to_check = [player_instances_by_unique[username]]
+    else:
         return []
     
-    player = player_instances[username]
-    recent_battles = []
-    
-    for battle_id, battle in player.battles.items():
-        if battle_id not in active_battles:
-            # This is a new battle that wasn't tracked yet
-            battle_url = f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}"
-            battle_info = {
-                'battle_id': battle_id,
-                'battle_url': battle_url,
-                'opponent': getattr(battle, 'opponent_username', 'unknown'),
-                'format': battle.format if hasattr(battle, 'format') else 'unknown',
-                'turn': battle.turn if hasattr(battle, 'turn') else 0,
-                'battle_state': format_battle_state(battle)
-            }
-            
-            # Add to active battles tracking
-            active_battles[battle_id] = {
-                'type': 'recovered',
-                'player_username': username,
-                'opponent': battle_info['opponent'],
-                'battle_state': battle_info['battle_state'],
-                'waiting_for_move': False,
-                'completed': False,
-                'battle_url': battle_url
-            }
-            
-            recent_battles.append(battle_info)
+    for player in players_to_check:
+        for battle_id, battle in player.battles.items():
+            if battle_id not in active_battles:
+                # This is a new battle that wasn't tracked yet
+                battle_url = f"https://jofthomas.com/play.pokemonshowdown.com/testclient.html#battle-{battle_id}"
+                battle_info = {
+                    'battle_id': battle_id,
+                    'battle_url': battle_url,
+                    'opponent': getattr(battle, 'opponent_username', 'unknown'),
+                    'format': battle.format if hasattr(battle, 'format') else 'unknown',
+                    'turn': battle.turn if hasattr(battle, 'turn') else 0,
+                    'battle_state': format_battle_state(battle)
+                }
+                
+                # Add to active battles tracking
+                active_battles[battle_id] = {
+                    'type': 'recovered',
+                    'player_base_username': player.base_username,
+                    'player_unique_username': player.username,
+                    'player_username': player.base_username,
+                    'opponent': battle_info['opponent'],
+                    'battle_state': battle_info['battle_state'],
+                    'waiting_for_move': False,
+                    'completed': False,
+                    'battle_url': battle_url
+                }
+                
+                recent_battles.append(battle_info)
     
     return recent_battles
 
@@ -521,12 +533,12 @@ async def download_battle_replay(battle_id: str) -> str:
         raise ValueError(f"Battle {battle_id} not found")
     
     battle_info = active_battles[battle_id]
-    username = battle_info['player_username']
+    unique_username = battle_info.get('player_unique_username') or battle_info.get('player_username')
     
-    if username not in player_instances:
-        raise ValueError(f"Player {username} not found")
+    if unique_username not in player_instances_by_unique:
+        raise ValueError(f"Player {unique_username} not found")
     
-    player = player_instances[username]
+    player = player_instances_by_unique[unique_username]
     
     # Find the battle object
     battle = None