chore: format code

agent.py

@@ -23,9 +23,7 @@ Tips:
 - The seed parameter should be used to set your LLM's seed for reproducibility
 """
 
-import json
 import os
-import re
 from dataclasses import dataclass, field
 from typing import Optional
 
@@ -70,16 +68,16 @@ else:
 def call_llm(prompt: str, system_prompt: str, seed: int, max_tokens: int = 300) -> str:
     """
     Call the LLM with the given prompt. Use this function in your agent.
-    
+
     Args:
         prompt: The user prompt (current game state, history, etc.)
         system_prompt: The system prompt (instructions for the agent)
         seed: Random seed for reproducibility
         max_tokens: Maximum tokens in response (default: 300)
-        
+
     Returns:
         The LLM's response text
-        
+
     Example:
         response = call_llm(
             prompt="You are in a forest. What do you do?",
@@ -115,6 +113,7 @@ def call_llm(prompt: str, system_prompt: str, seed: int, max_tokens: int = 300)
 @dataclass
 class RunResult:
     """Result of running the agent. Do not modify this class."""
+
     final_score: int
     max_score: int
     moves: int
@@ -158,25 +157,26 @@ ARGS: {"action": "look"}
 # Student Agent - IMPLEMENT THIS CLASS
 # =============================================================================
 
+
 class StudentAgent:
     """
     Your ReAct agent implementation.
-    
+
     TODO:
     1. Implement the run() method with the ReAct loop
     2. Parse LLM responses to extract tool calls
     3. Track state and avoid loops
-    
+
     Use the provided call_llm() function to interact with the LLM.
     """
-    
+
     def __init__(self):
         """Initialize your agent here."""
         # TODO: Initialize any state tracking you need
         # self.history = []
         # self.visited_locations = set()
         pass
-    
+
     async def run(
         self,
         client,  # FastMCP Client connected to your MCP server
@@ -187,14 +187,14 @@ class StudentAgent:
     ) -> RunResult:
         """
         Run the agent for a game session.
-        
+
         Args:
             client: FastMCP Client connected to your MCP server
             game: Name of the game being played (e.g., "zork1")
             max_steps: Maximum number of steps to take
             seed: Random seed for reproducibility (use for LLM calls)
             verbose: Whether to print detailed output
-            
+
         Returns:
             RunResult with final score and statistics
         """
@@ -210,27 +210,27 @@ class StudentAgent:
         #    e. Update history and state
         #    f. Check for game over
         # 3. Return RunResult with final statistics
-        
+
         # Example of calling a tool:
         # result = await client.call_tool("play_action", {"action": "look"})
         # observation = result[0].text if result else "No response"
-        
+
         # Example of calling the LLM:
         # response = call_llm(
         #     prompt="Current observation: " + observation,
         #     system_prompt=SYSTEM_PROMPT,
         #     seed=seed,
         # )
-        
+
         # Placeholder implementation - replace with your code
         locations_visited = set()
         history = []
         final_score = 0
         moves = 0
-        
+
         # TODO: Your implementation here
         # ...
-        
+
         return RunResult(
             final_score=final_score,
             max_score=350,  # Zork1 max score, adjust if needed
@@ -239,22 +239,22 @@ class StudentAgent:
             game_completed=False,
             history=history,
         )
-    
+
     def _build_prompt(self, observation: str, history: list) -> str:
         """
         Build the prompt for the LLM.
-        
+
         TODO: Implement this to create effective prompts
         """
         # TODO: Combine system prompt, history, and current observation
         pass
-    
+
     def _parse_response(self, response: str) -> tuple[str, str, dict]:
         """
         Parse LLM response to extract thought, tool name, and arguments.
-        
+
         TODO: Implement robust parsing
-        
+
         Returns:
             Tuple of (thought, tool_name, args_dict)
         """
@@ -263,11 +263,11 @@ class StudentAgent:
         # TOOL: ...
         # ARGS: {...}
         pass
-    
+
     def _call_llm(self, prompt: str, system_prompt: str, seed: int) -> str:
         """
         Call the LLM with the given prompt.
-        
+
         This is a convenience wrapper - you can also use call_llm() directly.
         """
         return call_llm(prompt, system_prompt, seed)
@@ -277,15 +277,16 @@ class StudentAgent:
 # For local testing
 # =============================================================================
 
+
 async def test_agent():
     """Test the agent locally."""
     from fastmcp import Client
-    
+
     # Path to your MCP server
     server_path = "mcp_server.py"
-    
+
     agent = StudentAgent()
-    
+
     async with Client(server_path) as client:
         result = await agent.run(
             client=client,
@@ -294,7 +295,7 @@ async def test_agent():
             seed=42,
             verbose=True,
         )
-        
+
         print(f"\nFinal Score: {result.final_score}")
         print(f"Moves: {result.moves}")
         print(f"Locations: {result.locations_visited}")
@@ -302,4 +303,5 @@ async def test_agent():
 
 if __name__ == "__main__":
     import asyncio
+
     asyncio.run(test_agent())

app.py

@@ -15,7 +15,6 @@ To test locally:
 """
 
 import gradio as gr
-from pathlib import Path
 
 # Create the Gradio interface
 with gr.Blocks(title="Text Adventure Agent Submission") as demo:
@@ -23,7 +22,7 @@ with gr.Blocks(title="Text Adventure Agent Submission") as demo:
     gr.Markdown(
         "This Space contains a template submission for the Text Adventure Agent assignment. "
     )
-        
+
     gr.Markdown(
         "---\n"
         "**Note:** This is a code submission Space. "

mcp_server.py

@@ -11,10 +11,10 @@ Required tool:
 Recommended tools:
     memory() -> str
         Return current game state, score, and recent history.
-    
-    inventory() -> str  
+
+    inventory() -> str
         Return the player's current inventory.
-    
+
     get_map() -> str
         Return a map of explored locations.
 
@@ -45,16 +45,17 @@ mcp = FastMCP("Student Text Adventure Server")
 # Game State Management
 # =============================================================================
 
+
 class GameManager:
     """
     Manages the text adventure game state.
-    
+
     TODO: Extend this class to track:
     - Action history (for memory tool)
     - Explored locations (for mapping)
     - Current score and moves
     """
-    
+
     def __init__(self):
         self.env: TextAdventureEnv = None
         self.state = None
@@ -63,7 +64,7 @@ class GameManager:
         # self.history: list[tuple[str, str]] = []
         # self.explored_locations: dict[str, set[str]] = {}
         # self.current_location: str = ""
-    
+
     def initialize(self, game: str = "zork1"):
         """Initialize or reset the game."""
         self.game_name = game
@@ -71,24 +72,24 @@ class GameManager:
         self.state = self.env.reset()
         # TODO: Reset your state tracking here
         return self.state.observation
-    
+
     def step(self, action: str) -> str:
         """Execute an action and return the result."""
         if self.env is None:
             self.initialize()
-        
+
         self.state = self.env.step(action)
-        
+
         # TODO: Update your state tracking here
         # self.history.append((action, self.state.observation))
         # Update location tracking, etc.
-        
+
         return self.state.observation
-    
+
     def get_score(self) -> int:
         """Get current score."""
         return self.state.score if self.state else 0
-    
+
     def get_moves(self) -> int:
         """Get number of moves taken."""
         return self.state.moves if self.state else 0
@@ -112,34 +113,35 @@ def get_game() -> GameManager:
 # MCP Tools - IMPLEMENT THESE
 # =============================================================================
 
+
 @mcp.tool()
 def play_action(action: str) -> str:
     """
     Execute a game command and return the result.
-    
+
     This is the main tool for interacting with the game.
-    
+
     Args:
         action: The command to execute (e.g., "north", "take lamp", "open mailbox")
-        
+
     Returns:
         The game's response to the action
-        
+
     Valid commands include:
         - Movement: north, south, east, west, up, down, enter, exit
         - Objects: take <item>, drop <item>, open <thing>, examine <thing>
         - Other: look, inventory, read <thing>, turn on lamp
     """
     game = get_game()
-    
+
     # TODO: You might want to add action validation here
     # TODO: You might want to include score changes in the response
-    
+
     result = game.step(action)
-    
+
     # Optional: Append score info
     # result += f"\n[Score: {game.get_score()} | Moves: {game.get_moves()}]"
-    
+
     return result
 
 
@@ -149,7 +151,7 @@ def play_action(action: str) -> str:
 # def memory() -> str:
 #     """
 #     Get the current game state summary.
-#     
+#
 #     Returns:
 #         A summary including current location, score, moves, and recent history
 #     """
@@ -162,7 +164,7 @@ def play_action(action: str) -> str:
 # def inventory() -> str:
 #     """
 #     Check what the player is carrying.
-#     
+#
 #     Returns:
 #         List of items in the player's inventory
 #     """
@@ -175,7 +177,7 @@ def play_action(action: str) -> str:
 # def get_map() -> str:
 #     """
 #     Get a map of explored locations.
-#     
+#
 #     Returns:
 #         A text representation of explored locations and connections
 #     """
@@ -188,7 +190,7 @@ def play_action(action: str) -> str:
 # def get_valid_actions() -> str:
 #     """
 #     Get a list of likely valid actions from the current location.
-#     
+#
 #     Returns:
 #         List of actions that might work here
 #     """