quasi final version

agent.py

@@ -104,27 +104,55 @@ class RunResult:
 
 SYSTEM_PROMPT = """You are playing a classic text adventure game.
 
-GOAL: Explore the world, solve puzzles, and maximize your score.
+GOAL:
+Explore the world, discover new locations, collect useful items, solve puzzles, and maximize your score while avoiding useless or dangerous actions.
 
 AVAILABLE TOOLS (use via MCP):
-- play_action: Execute a game command (north, take lamp, open mailbox, etc.)
-- memory: Get current game state and history (if implemented)
-- inventory: Check what you're carrying (if implemented)
+- play_action: Execute ONE game command (movement or interaction)
+- memory: Get a summary of the current game state and recent actions
+- inventory: Check what you are carrying
+- get_map: Get a map of explored locations and known connections
+- get_valid_actions: Get a list of actions that are likely to work in the current location
 
 VALID GAME COMMANDS for play_action:
 - Movement: north, south, east, west, up, down, enter, exit
-- Objects: take <item>, drop <item>, open <thing>, close <thing>, examine <thing>
-- Other: look, inventory, read <thing>, turn on lamp
+- Shortcuts: n, s, e, w, u, d
+- Objects: take <item>, drop <item>, open <object>, close <object>, examine <object>
+- Other: look, inventory, read <object>, turn on lamp, turn off lamp
 
-RESPOND IN THIS EXACT FORMAT (no markdown):
-THOUGHT: <your reasoning about what to do next>
-TOOL: <tool_name>
-ARGS: <JSON arguments, e.g., {"action": "look"}>
+RESPOND IN THIS EXACT FORMAT (DO NOT DEVIATE):
+THOUGHT: <brief reasoning about what to do next>
+TOOL: <tool name>
+ARGS: <JSON arguments>
 
-Example:
-THOUGHT: I should look around to see where I am.
+EXAMPLES:
+
+THOUGHT: I am in a dark room and see a lamp on the ground.
+TOOL: play_action
+ARGS: {"action": "take lamp"}
+
+THOUGHT: I can now see exits and should explore further.
 TOOL: play_action
-ARGS: {"action": "look"}
+ARGS: {"action": "north"}
+
+STRATEGY:
+1. Use get_valid_actions frequently to know which actions are possible.
+2. Prefer actions that:
+   - reveal new locations
+   - interact with visible objects
+   - unlock new paths
+   - increase the score
+3. Avoid repeating actions that had no effect.
+4. Do not repeat the same action twice in a row.
+5. Use inventory awareness before dropping or interacting with items.
+6. Use look, inventory, memory, or get_map when unsure.
+7. Explore methodically rather than randomly.
+
+IMPORTANT RULES:
+- Execute EXACTLY ONE action per turn.
+- Never invent commands or arguments.
+- Avoid risky actions (jump, attack, wait).
+- Progress and exploration matter more than speed.
 """
 
 
@@ -135,21 +163,28 @@ ARGS: {"action": "look"}
 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
+        
+        self.history = []
+        self.score:int = 0
+        self.map:Optional[str] = None  
+        self.recent_actions: list[str] = []
+        self.failure: dict[str, int] = {}  
+        self.valid_actions: list[str] = []  
+        self.important_objects = {
+    "lamp", "lantern", "key", "keys", "door",
+    "mailbox", "box", "chest", "sword", "treasure"
+}
+        self.object_goals: dict[str, dict] = {}
+        self.tried_edges: dict[tuple[str, str], str] = {}
+        self.edge_candidates: list[str] = []
+        self.last_action = None
+        self.current_inventory: list[str] = []  
+        self.visited_locations = set()
+
     
     async def run(
         self,
@@ -162,81 +197,242 @@ class StudentAgent:
         """
         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
         """
-        # TODO: Implement your ReAct loop here
-        #
-        # Basic structure:
-        # 1. Get initial observation (call play_action with "look")
-        # 2. Loop for max_steps:
-        #    a. Build prompt with current observation and history
-        #    b. Call LLM to get thought and action
-        #    c. Parse the response to extract tool and args
-        #    d. Call the tool via client.call_tool(tool_name, args)
-        #    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
-        # ...
+        self.last_action = None
+
+        tools = await client.list_tools()
+        tool_names = [t.name for t in tools]
+
+        inventory_result = await client.call_tool("inventory", {})
+        inventory_text = self.extract_result(inventory_result)
+        self.current_inventory = self.parse_inventory(inventory_text)
+
+        init_result = await client.call_tool("play_action", {"action": "look"})
+        obs = self.extract_result(init_result)
+        self.update_score(obs)
+
+        location = self.extract_location(obs) or "Unknown"
+        locations_visited.add(location)
+        self.visited_locations.add(location)
+
+        for obs in obs:
+            for obj in self.extract_objects(obs):
+                if obj not in self.object_goals:
+                    self.object_goals[obj] = {
+                        "seen_at": location,
+                        "obtained": False
+                    }
+        for obj in self.extract_objects(obs):
+            if obj not in self.object_goals:
+                self.object_goals[obj] = {"seen_at": location, "obtained": False}
         
+        for step in range(1, max_steps + 1):
+            map_result = await client.call_tool("get_map", {})
+            self.map = self.extract_result(map_result)
+
+
+            try:
+                result = await client.call_tool("get_valid_actions", {})
+                valid_text = self.extract_result(result)
+                if "Valid actions:" in valid_text:
+                    actions_str = valid_text.split("Valid actions:")[1].strip()
+                    self.valid_actions = [a.strip() for a in actions_str.split(",")]
+            except Exception:
+                self.valid_actions = []
+
+            self.edge_candidates = [
+                a for a in self.valid_actions
+                if (location, a) not in self.tried_edges
+            ]
+
+            print(f"Edge candidates: {self.edge_candidates[:5]}")
+
+
+            prompt = self._build_prompt(obs)
+
+            response = call_llm(prompt, SYSTEM_PROMPT, seed + step)
+            thought, tool_name, tool_args = self._parse_response(response, tool_names)
+
+
+            tool_name, tool_args = self.format_llm_response(
+                tool_name, tool_args, tool_names
+            )
+
+
+            if tool_name == "play_action":
+                action = tool_args.get("action", "")
+                inverse_pairs = {
+                    ("take", "put"),
+                    ("put", "take"),
+                    ("open", "close"),
+                    ("close", "open"),
+                }
+                if self.last_action:
+                    prev = self.last_action.split()[0]
+                    curr = action.split()[0]
+                    if (prev, curr) in inverse_pairs:
+                        if verbose:
+                            print("Reversible action blocked")
+                        tool_args = {"action": "look"}
+                        action = "look"
+
+                self.recent_actions.append(action)
+                if len(self.recent_actions) > 5:
+                    self.recent_actions = self.recent_actions[-5:]
+
+                moves += 1
+                
+
+
+            try:
+                result = await client.call_tool(tool_name, tool_args)
+                observation = self.extract_result(result)
+
+            
+                if tool_name == "inventory":
+                    self.current_inventory = self.parse_inventory(observation)
+                    inv_text = " ".join(self.current_inventory).lower()
+                    for obj in self.object_goals:
+                        if obj in inv_text:
+                            self.object_goals[obj]["obtained"] = True
+
+            except Exception as e:
+                observation = f"Error: {e}"
+                print(f"Error {e}")
+
+            new_location = self.extract_location(observation, location)
+
+            if tool_name == "play_action":
+                action = tool_args.get("action", "")
+                self.tried_edges[(location, action)] = new_location
+                self.last_action = action
+
+            old_score = self.score
+            self.update_score(observation)
+
+            if tool_name == "play_action":
+                if new_location == location and self.score == old_score:
+                    self.failure[action] = self.failure.get(action, 0) + 1
+
+            if new_location != location:
+                location = new_location
+                locations_visited.add(location)
+                self.visited_locations.add(location)
+
+            self.history.append({
+                "step": step,
+                "thought": thought,
+                "tool": tool_name,
+                "args": tool_args,
+                "result": observation[:200],
+                "location": location,
+                "score": self.score
+            })
+            if len(self.history) > 10:
+                self.history = self.history[-10:]
+
+            history.append((thought, f"{tool_name}({tool_args})", observation[:100]))
+            print(f"Location : {location} | Score: {self.score} | Moves: {moves}")
+
+            if self.is_game_over(observation):
+                print("\n*** GAME OVER ***")
+                break
+
+
         return RunResult(
-            final_score=final_score,
+            final_score=self.score,
             max_score=350,  # Zork1 max score, adjust if needed
             moves=moves,
-            locations_visited=locations_visited,
+            locations_visited=self.visited_locations,
             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 _build_prompt(self, observation: str) -> str:
+
+        lines = []
+        lines.append("RULES YOU MUST RESPECT:")
+        lines.append("- Do not repeat actions that recently failed.")
+        lines.append("- Do not loop on the same action.")
+        lines.append("- Prefer actions that reveal new information or areas.")
+
+        lines.append("\nCURRENT FACTS:")
+        lines.append(f"- Score: {self.score}")
+        lines.append(f"- Known locations: {len(self.visited_locations)}")
+
+        if self.history:
+            last = self.history[-1]
+            last_action = last.get("args", {}).get("action") or last.get("tool", "?")
+            last_result = last.get("result", "")
+            lines.append("\nLAST MOVE:")
+            lines.append(f"- Action: {last_action}")
+            lines.append(f"- Outcome: {last_result[:120]}")
+
+        blocked = [
+            name for name, count in self.failure.items() if count >= 2
+        ]
+        if blocked:
+            lines.append("\nDO NOT TRY AGAIN:")
+            for b in blocked:
+                lines.append(f"- {b}")
+
+        if self.valid_actions:
+            lines.append("\nACTIONS CURRENTLY POSSIBLE:")
+            for a in self.valid_actions[:10]:
+                lines.append(f"- {a}")
+
+        if self.edge_candidates:
+            lines.append("\nUNEXPLORED ACTIONS FROM THIS LOCATION:")
+            for a in self.edge_candidates[:5]:
+                lines.append(f"- {a}")
+
+
+        lines.append("\nRAW OBSERVATION FROM THE WORLD:")
+        lines.append(observation.strip())
+
+        unobtained = [
+            obj for obj, info in self.object_goals.items()
+            if not info["obtained"]
+        ]
+
+        if unobtained:
+            lines.append("\nOBJECT-DRIVEN GOALS:")
+            for obj in unobtained[:3]:
+                loc = self.object_goals[obj]["seen_at"]
+                lines.append(f"- {obj} (seen at: {loc})")
+
+            lines.append(
+                "\nPRIORITY RULE:\n"
+                "Prefer actions that help obtain or interact with these objects "
+                "over random exploration."
+            )
+
+
+        lines.append(
+            "\nDECISION REQUIRED:\n"
+            "Choose ONE action that is different from your recent behavior "
+            "and maximizes the chance of discovering something new."
+        )
+
+        return "\n".join(lines)
     
-    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)
-        """
-        # TODO: Parse the response format:
-        # THOUGHT: ...
-        # TOOL: ...
-        # ARGS: {...}
-        pass
+    
+    
+    def _parse_response(self, response: str, valid_tools: list[str]) -> tuple[str, str, dict]:
+
+        fields = self._index_response(response)
+
+        thought = self.extract_thought(fields)
+        tool = self.extract_tool(fields, valid_tools)
+        args = self.extract_args(fields)
+
+        return thought, tool, args
     
     def _call_llm(self, prompt: str, system_prompt: str, seed: int) -> str:
         """
@@ -245,6 +441,245 @@ class StudentAgent:
         This is a convenience wrapper - you can also use call_llm() directly.
         """
         return call_llm(prompt, system_prompt, seed)
+    
+
+    def _index_response(self, text: str) -> dict:
+        indexed = {}
+
+        for line in text.splitlines():
+            if ":" not in line:
+                continue
+            key, value = line.split(":", 1)
+            indexed[key.strip().lower()] = value.strip()
+
+        return indexed
+
+    # =============================================================================
+    # Extract information from game observations
+    # =============================================================================
+
+    def extract_objects(self, text: str) -> list[str]:
+        found = set()
+        text = text.lower()
+        for obj in self.important_objects:
+            if obj in text:
+                found.add(obj)
+        return list(found)
+    
+    def extract_thought(self, fields: dict) -> str:
+        return fields.get("thought", "No reasoning provided")
+    
+    def extract_tool(self, fields: dict, valid_tools: list[str]) -> str:
+        raw = fields.get("tool", "play_action").lower()
+        raw = raw.translate(str.maketrans("", "", "*`"))
+
+        candidate = raw.split()[0] if raw else "play_action"
+        return candidate
+    
+    def extract_args(self, fields: dict) -> dict:
+        payload = fields.get("args")
+        if not payload:
+            return {"action": "look"}
+
+        payload = payload.replace("'", '"')
+
+        try:
+            return json.loads(payload)
+        except json.JSONDecodeError:
+            match = re.search(r'"action"\s*:\s*"([^"]+)"', payload)
+            if match:
+                return {"action": match.group(1)}
+
+        return {"action": "look"}
+    
+
+
+    def extract_result(self, result) -> str:
+        if hasattr(result, 'content') and result.content:
+            return result.content[0].text
+        if isinstance(result, list) and result:
+            return result[0].text if hasattr(result[0], 'text') else str(result[0])
+        return str(result)
+    
+    def extract_location(self, observation: str, previous_location: str | None = None) -> str:
+        if not observation:
+            return previous_location or "Unknown"
+
+        line = observation.strip().splitlines()[0].strip()
+        lower = line.lower()
+
+        if any(k in lower for k in ("copyright", "infocom", "all rights reserved")):
+            return previous_location or "Unknown"
+        if lower.startswith(("you ", "opening", "opened", "taken", "done", "with great effort", "the ")):
+            return previous_location or "Unknown"
+        if line.endswith((".", "!", "?")) or len(line.split()) > 6:
+            return previous_location or "Unknown"
+
+        return line
+    
+    # =============================================================================
+    # Function to parse inventory
+    # =============================================================================
+    def parse_inventory(self, blob: str) -> list[str]:
+        if not blob:
+            return []
+
+        low = blob.lower()
+
+        if any(x in low for x in ("empty-handed", "nothing")):
+            return []
+
+        core = blob.split(":", 1)[-1]
+
+        tokens = [
+            t.strip().lower()
+            for t in core.replace("\n", ",").split(",")
+            if t.strip()
+            and not any(w in t.lower() for w in ("you", "carrying", "parent"))
+        ]
+
+        return sorted(set(tokens))
+    
+
+    
+    # =============================================================================
+    # Function to update score
+    # =============================================================================
+
+    def update_score(self, text: str) -> None:
+        if not text:
+            return
+
+        t = text.replace("[", "").replace("]", "").lower()
+
+        if "score" not in t:
+            return
+
+        parts = t.split("score")
+        values = []
+
+        for p in parts[1:]:
+            digits = ""
+            for ch in p:
+                if ch.isdigit():
+                    digits += ch
+                elif digits:
+                    break
+            if digits:
+                values.append(int(digits))
+
+        if values:
+            best = max(values)
+            if best > self.score:
+                self.score = best
+
+
+    # =============================================================================
+    # Function to reformat LLM response
+    # =============================================================================
+
+    def format_llm_response(
+    self,
+    tool_name: str,
+    tool_args: dict,
+    valid_tools: list[str]
+) -> tuple[str, dict]:
+
+        tool_aliases = {
+            "action": "play_action",
+            "do": "play_action",
+            "command": "play_action",
+            "map": "get_map",
+            "location": "get_map",
+            "mem": "memory",
+            "state": "memory",
+            "status": "memory",
+            "inv": "inventory",
+            "items": "inventory",
+        }
+
+        tool_name = tool_name.lower().strip()
+        tool_name = tool_aliases.get(tool_name, tool_name)
+
+        if tool_name not in valid_tools:
+            tool_name = "play_action"
+
+        if tool_name == "play_action":
+            raw_action = tool_args.get("action", "")
+
+            if not isinstance(raw_action, str) or not raw_action.strip():
+                return "play_action", {"action": "look"}
+
+            action = raw_action.lower()
+
+            for ch in ["*", "`", "\"", "'"]:
+                action = action.replace(ch, "")
+
+            action = " ".join(action.split())
+
+            verb_aliases = {
+                "check": "examine",
+                "inspect": "examine",
+                "use": "examine",
+                "investigate": "examine",
+                "grab": "take",
+                "pick": "take",
+                "pickup": "take",
+                "search": "look",
+            }
+
+            words = action.split()
+            if words and words[0] in verb_aliases:
+                words[0] = verb_aliases[words[0]]
+                action = " ".join(words)
+
+            forbidden_prefixes = {
+                "help",
+                "quit",
+                "save",
+                "load",
+            }
+
+            dangerous_verbs = {
+                "jump",
+                "dive",
+                "leap",
+            }
+
+            verb = action.split()[0]
+
+            if verb in forbidden_prefixes:
+                return "play_action", {"action": "look"}
+
+            if verb in dangerous_verbs:
+                return "play_action", {"action": "look"}
+
+            if not action:
+                action = "look"
+
+            return "play_action", {"action": action}
+
+        return tool_name, {}
+
+
+    def is_game_over(self, text: str) -> bool:
+        if not text:
+            return False
+
+        text = text.lower()
+
+        deaths = (
+            "game over",
+            "you have died",
+            "you are dead",
+            "*** you have died ***",
+            "you die",
+            "you have been killed",
+            "your score was",
+        )
+
+        return any(p in text for p in deaths)
+
 
 
 # =============================================================================

mcp_server.py

@@ -48,43 +48,270 @@ mcp = FastMCP("Student Text Adventure Server")
 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
-        self.game_name: str = ""
-        # TODO: Add more state tracking
-        # 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
+    def __init__(self, game: str = "zork1"):
         self.env = TextAdventureEnv(game)
+        self.game_name = game
         self.state = self.env.reset()
-        # TODO: Reset your state tracking here
-        return self.state.observation
+        self.state = self.env.step("look")
+
+        self.history = []
+        self.explored_locations = {}
+        self.current_location = self.extract_location(self.state.observation)
+        self.object_goals: dict[str, dict] = {}
+
+
     
-    def step(self, action: str) -> str:
-        """Execute an action and return the result."""
-        if self.env is None:
-            self.initialize()
-        
+    def update_map(self, prev_location: str, action: str, new_location: str):
+        if prev_location not in self.explored_locations:
+            self.explored_locations[prev_location] = set()
+
+        if new_location != prev_location:
+            self.explored_locations[prev_location].add(
+                f"{action} -> {new_location}"
+            )
+    
+    
+    def choose_an_action(self, action: str) -> str:
+        prev_observation = self.state.observation
+        prev_location = self.current_location
+        prev_score = self.state.score
+
         self.state = self.env.step(action)
+        observation = self.state.observation
+
+        new_location = self.extract_location(observation)
+        self.current_location = new_location
+
+        no_op = (
+            observation.strip() == prev_observation.strip()
+            and new_location == prev_location
+            and self.state.score == prev_score
+        )
+
+        self.history.append({
+            "action": action,
+            "observation": observation,
+            "location": new_location,
+            "no_op": no_op,
+        })
+        self.history = self.history[-35:]
+
+        return observation
+    
+
+          
+    def extract_location(self, observation: str) -> str:
+        if not observation:
+            return self.current_location or "Unknown"
+
+        line = observation.strip().splitlines()[0].strip()
+        lower = line.lower()
+
+        if any(k in lower for k in ("copyright", "infocom", "all rights reserved")):
+            return self.current_location or "Unknown"
+        if lower.startswith(("you ", "opening", "opened", "taken", "done", "with great effort", "the ")):
+            return self.current_location or "Unknown"
+        if line.endswith((".", "!", "?")) or len(line.split()) > 6:
+            return self.current_location or "Unknown"
+
+        return line
+    
+
+    def is_valid_location(self, candidate: str) -> bool:
+        if not candidate:
+            return False
+
+        candidate = candidate.strip()
+
+        if candidate.endswith("."):
+            return False
+
+        if len(candidate.split()) > 5:
+            return False
+
+        lowered = candidate.lower()
+        banned_prefixes = (
+            "taken",
+            "done",
+            "opening",
+            "you",
+            "there is",
+            "with great effort",
+            "it is",
+        )
+        if lowered.startswith(banned_prefixes):
+            return False
+
+        return True
+    
+
+    def get_memory(self) -> str:
+   
+        recent = self.history[-6:] if self.history else []
+
+        recent_actions = []
+        no_op_count = 0
+
+        for h in recent:
+            if isinstance(h, dict):
+                action = h.get("action", "?")
+                loc = h.get("location", "?")
+                no_op = h.get("no_op", False)
+                recent_actions.append(f"- {action} @ {loc}")
+                if no_op:
+                    no_op_count += 1
+
+        recent_block = (
+            "\n".join(recent_actions)
+            if recent_actions else
+            "- none"
+        )
+
+        progress_signals = []
+
+        if len(self.explored_locations) > 1:
+            progress_signals.append("new locations visited")
+
+        if self.state.score > 0:
+            progress_signals.append(f"score = {self.state.score}")
+
+        obtained = [
+            obj for obj, info in self.object_goals.items()
+            if info.get("obtained")
+        ]
+        if obtained:
+            progress_signals.append(f"objects obtained: {', '.join(obtained[:3])}")
+
+        if not progress_signals:
+            progress_signals.append("no clear progress")
+
+        stagnation = ""
+        if no_op_count >= 3:
+            stagnation = "repeated ineffective actions detected"
+
+        return f"""STATE SNAPSHOT
+            Location: {self.current_location}
+            Score: {self.state.score}
+            Moves: {self.state.moves}
+            Game: {self.game_name}
+
+            RECENT ACTIONS
+            {recent_block}
+
+            PROGRESS
+            - {'; '.join(progress_signals)}
+
+            STAGNATION
+            - {stagnation if stagnation else "none"}
+
+            LAST OBSERVATION (verbatim)
+            {self.state.observation}
+            """
         
-        # TODO: Update your state tracking here
-        # self.history.append((action, self.state.observation))
-        # Update location tracking, etc.
-        
-        return self.state.observation
+
+
+    def get_map(self) -> str:
+
+        if not self.explored_locations:
+            return "MAP SNAPSHOT\n- No locations visited yet."
+
+        output = []
+        output.append("MAP SNAPSHOT")
+        output.append(f"Current location: {self.current_location}")
+
+        exploration_frontier = []
+        exhausted_nodes = []
+
+        for node, transitions in self.explored_locations.items():
+            degree = len(transitions)
+
+            if degree == 0:
+                exhausted_nodes.append(node)
+            elif degree <= 2:
+                exploration_frontier.append(node)
+
+        output.append("\nKNOWN CONNECTIONS")
+        for node, transitions in sorted(self.explored_locations.items()):
+            if not transitions:
+                output.append(f"- {node}: no confirmed exits")
+            else:
+                compressed = ", ".join(sorted(transitions))
+                output.append(f"- {node} → {compressed}")
+
+        if exploration_frontier:
+            output.append("\nEXPLORATION FRONTIER")
+            for node in exploration_frontier[:5]:
+                output.append(f"- {node} (few exits explored)")
+
+        if exhausted_nodes:
+            output.append("\nLOW VALUE AREAS")
+            for node in exhausted_nodes[:5]:
+                output.append(f"- {node} (dead end or fully explored)")
+
+        cyclic_nodes = []
+        for node, transitions in self.explored_locations.items():
+            for t in transitions:
+                if f"{node}" in t and "->" in t:
+                    cyclic_nodes.append(node)
+                    break
+
+        if cyclic_nodes:
+            output.append("\nPOTENTIAL LOOPS DETECTED")
+            for node in cyclic_nodes[:3]:
+                output.append(f"- {node}")
+
+        if exploration_frontier:
+            output.append(
+                "\nNAVIGATION HINT\n"
+                f"- Prefer exploring from: {exploration_frontier[0]}"
+            )
+
+        return "\n".join(output)
     
+
+    def get_inventory(self) -> str:
+        items = (
+            self.state.inventory
+            if hasattr(self.state, "inventory") and self.state.inventory
+            else []
+        )
+
+        if not items:
+            return "Inventory: empty (hands free)."
+
+        parsed_items = []
+
+        for item in items:
+            item_str = str(item)
+
+            if ":" in item_str:
+                item_str = item_str.split(":", 1)[1]
+            if "parent" in item_str.lower():
+                item_str = item_str.lower().split("parent")[0]
+
+            name = item_str.strip().lower()
+
+            tag = None
+            if any(k in name for k in ["lamp", "torch", "lantern"]):
+                tag = "light"
+            elif any(k in name for k in ["sword", "knife", "weapon"]):
+                tag = "weapon"
+            elif any(k in name for k in ["key"]):
+                tag = "key item"
+            elif any(k in name for k in ["treasure", "jewel", "egg", "canary"]):
+                tag = "valuable"
+
+            if tag:
+                parsed_items.append(f"{name} ({tag})")
+            else:
+                parsed_items.append(name)
+
+        count = len(parsed_items)
+        return f"Inventory ({count} item{'s' if count > 1 else ''}): " + ", ".join(parsed_items)
+
+
     def get_score(self) -> int:
         """Get current score."""
         return self.state.score if self.state else 0
@@ -95,18 +322,16 @@ class GameManager:
 
 
 # Global game manager
-_game = GameManager()
+g = GameManager()
 
 
-def get_game() -> GameManager:
-    """Get or initialize the game manager."""
-    global _game
-    if _game.env is None:
-        # Get game from environment variable (set by evaluator)
-        game = os.environ.get("GAME", "zork1")
-        _game.initialize(game)
-    return _game
 
+def get_game(reseed: bool = False) -> GameManager:
+    global g
+
+    if g is None or reseed:
+        g = GameManager()
+    return g
 
 # =============================================================================
 # MCP Tools - IMPLEMENT THESE
@@ -114,90 +339,74 @@ def get_game() -> GameManager:
 
 @mcp.tool()
 def play_action(action: str) -> str:
+    game = get_game()
+
+    origin = game.current_location
+    before_score = game.state.score
+
+    result = game.choose_an_action(action)
+    destination = game.current_location
+
+    if origin and destination and origin != destination:
+        game.update_map(origin, action, destination)
+
+    footer = f"\n[Score: {game.state.score}"
+    footer+= f"\nMoves: {game.state.moves}]"
+
+    return result + footer
+
+
+# TODO: Implement additional tools to help your agent
+
+@mcp.tool()
+def memory() -> str:
     """
-    Execute a game command and return the result.
-    
-    This is the main tool for interacting with the game.
+    Get the current game state summary.
     
-    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
+        A summary including current location, score, moves, and recent history
     """
     game = get_game()
+    return game.get_memory()
+
+
+@mcp.tool()
+def inventory() -> str:
+    """
+    Check what the player is carrying.
     
-    # 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
+    Returns:
+        List of items in the player's inventory
+    """
+    return get_game().get_inventory()
 
 
-# TODO: Implement additional tools to help your agent
+@mcp.tool()
+def get_map() -> str:
+    """
+    Get a map of explored locations.
+    
+    Returns:
+        A text representation of explored locations and connections
+    """
+    game = get_game()
+    return game.get_map()
+
 
-# @mcp.tool()
-# def memory() -> str:
-#     """
-#     Get the current game state summary.
-#     
-#     Returns:
-#         A summary including current location, score, moves, and recent history
-#     """
-#     game = get_game()
-#     # TODO: Return useful state information
-#     pass
-
-
-# @mcp.tool()
-# def inventory() -> str:
-#     """
-#     Check what the player is carrying.
-#     
-#     Returns:
-#         List of items in the player's inventory
-#     """
-#     game = get_game()
-#     result = game.step("inventory")
-#     return result
-
-
-# @mcp.tool()
-# def get_map() -> str:
-#     """
-#     Get a map of explored locations.
-#     
-#     Returns:
-#         A text representation of explored locations and connections
-#     """
-#     game = get_game()
-#     # TODO: Return map of explored locations
-#     pass
-
-
-# @mcp.tool()
-# def get_valid_actions() -> str:
-#     """
-#     Get a list of likely valid actions from the current location.
-#     
-#     Returns:
-#         List of actions that might work here
-#     """
-#     # This is a hint: Jericho provides get_valid_actions()
-#     game = get_game()
-#     if game.env and game.env.env:
-#         valid = game.env.env.get_valid_actions()
-#         return "Valid actions: " + ", ".join(valid[:20])
-#     return "Could not determine valid actions"
+@mcp.tool()
+def get_valid_actions() -> str:
+    """
+    Get a list of likely valid actions from the current location.
+    
+    Returns:
+        List of actions that might work here
+    """
+    # This is a hint: Jericho provides get_valid_actions()
+    game = get_game()
+    if game.env and game.env.env:
+        valid = game.env.env.get_valid_actions()
+        return "Valid actions: " + ", ".join(valid[:20])
+    return "Could not determine valid actions"
 
 
 # =============================================================================
@@ -205,5 +414,4 @@ def play_action(action: str) -> str:
 # =============================================================================
 
 if __name__ == "__main__":
-    # This runs the server with stdio transport (for MCP clients)
     mcp.run()