multiple prompting

agent.py

@@ -127,6 +127,32 @@ TOOL: play_action
 ARGS: {"action": "look"}
 """
 
+SUMMARIZING_SYSTEM_PROMPT = """
+You are the Chronicler of a text-adventure game. Your goal is to summarize the 
+current game state. 
+
+YOUR INPUT :
+SUMMARY : <a short summary of the story so far>.
+OBSERVATIONS : <the last 5 actions and resulting observations, with the format [action1 -> 
+observation1, action2 -> observation2...]>
+
+YOUR TASK : 
+Update the summary of the game with the last 5 observations. Focus on the 
+important details : unsolved puzzles, immediate goal of the agent, important pieces of the
+inventory, failed attempts... Try to orient the agent towards the next logical step in 
+the story. 
+
+YOUR OUTPUT : 
+The updated summary only (no comments). The new summary should be less than 300 tokens !
+"""
+
+
+INTERFACE_SYSTEM_PROMPT = """
+You are helping an AI agent interact with a text-adventure game. You receive the raw
+observation resulting from the agent playing an action, and your task is to extract all 
+the useful metadata about this observation.
+"""
+
 
 # =============================================================================
 # Student Agent - IMPLEMENT THIS CLASS
@@ -148,7 +174,11 @@ class StudentAgent:
         """Initialize your agent here."""
         # TODO: Initialize any state tracking you need
         # self.history = []
-        # self.visited_locations = set()
+        self.visited_locations = set()
+        self.history: list[dict] = []
+        self.recent_actions: list[str] = []
+        self.score: int = 0
+
         pass
     
     async def run(
@@ -204,6 +234,95 @@ class StudentAgent:
         
         # TODO: Your implementation here
         # ...
+
+        # Get list of available tools
+        tools = await client.list_tools()
+        tool_names = [t.name for t in tools]
+        
+        # Get initial observation
+        result = await client.call_tool("play_action", {"action": "look"})
+        observation = self._extract_result(result)
+        
+        # Track initial location
+        location = observation.split("\n")[0] if observation else "Unknown"
+        locations_visited.add(location)
+        
+        if verbose:
+            print(f"\n{observation}")
+        
+        # Main ReAct loop
+        for step in range(1, max_steps + 1):
+            # Build prompt with context
+            prompt = self._build_prompt(observation)
+            
+            # Call LLM for reasoning (use step-based seed for variety)
+            response = call_llm(prompt, SYSTEM_PROMPT, seed + step)
+            
+            # Parse the response
+            thought, tool_name, tool_args = self._parse_response(response, tool_names)
+            
+            if verbose:
+                print(f"\n--- Step {step} ---")
+                print(f"[THOUGHT] {thought}")
+                print(f"[TOOL] {tool_name}({tool_args})")
+            
+            # Validate and fix common issues
+            tool_name, tool_args = self._validate_tool_call(tool_name, tool_args, tool_names)
+            
+            # Loop detection
+            if tool_name == "play_action":
+                action = tool_args.get("action", "look")
+                self.recent_actions.append(action)
+                if len(self.recent_actions) > 5:
+                    self.recent_actions = self.recent_actions[-5:]
+                
+                # Detect loops - if same action 3 times, force "look"
+                if len(self.recent_actions) >= 3 and len(set(self.recent_actions[-3:])) == 1:
+                    if verbose:
+                        print(f"[WARNING] Loop detected - forcing 'look'")
+                    tool_args = {"action": "look"}
+                    self.recent_actions.append("look")
+                
+                moves += 1
+            
+            # Execute the tool
+            try:
+                result = await client.call_tool(tool_name, tool_args)
+                observation = self._extract_result(result)
+                
+                if verbose:
+                    print(f"[RESULT] {observation[:200]}...")
+            except Exception as e:
+                observation = f"Error: {e}"
+                if verbose:
+                    print(f"[ERROR] {e}")
+            
+            # Track location
+            location = observation.split("\n")[0] if observation else "Unknown"
+            locations_visited.add(location)
+            
+            # Update history
+            self.history.append({
+                "step": step,
+                "thought": thought,
+                "tool": tool_name,
+                "args": tool_args,
+                "result": observation[:200]
+            })
+            if len(self.history) > 10:
+                self.history = self.history[-10:]
+            
+            # Track score from observation
+            self._update_score(observation)
+            
+            # Record in result history
+            history.append((thought, f"{tool_name}({tool_args})", observation[:100]))
+            
+            # Check for game over
+            if self._is_game_over(observation):
+                if verbose:
+                    print("\n*** GAME OVER ***")
+                break
         
         return RunResult(
             final_score=final_score,

mcp_server.py

@@ -63,6 +63,10 @@ class GameManager:
         # self.history: list[tuple[str, str]] = []
         # self.explored_locations: dict[str, set[str]] = {}
         # self.current_location: str = ""
+
+        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."""
@@ -82,8 +86,27 @@ class GameManager:
         # TODO: Update your state tracking here
         # self.history.append((action, self.state.observation))
         # Update location tracking, etc.
+
+        result = self.state.observation
+
+        self.history.append((action, result))
+        if len(self.history) > 50:
+            self.history = self.history[-50:]
+
+        # Update map
+        new_location = self._extract_location(result)
+        if action in ["north", "south", "east", "west", "up", "down", 
+                      "enter", "exit", "n", "s", "e", "w", "u", "d"]:
+            if self.current_location not in self.explored_locations:
+                self.explored_locations[self.current_location] = set()
+            if new_location != self.current_location:
+                self.explored_locations[self.current_location].add(f"{action} -> {new_location}")
+        self.current_location = new_location
         
-        return self.state.observation
+        return result
+    
+    def get_memory(self) -> str:
+        """Get a summary of current game state."""
     
     def get_score(self) -> int:
         """Get current score."""