synth-ai 0.2.14__py3-none-any.whl → 0.4.1__py3-none-any.whl

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/utils/anticheat.py

@@ -1,372 +0,0 @@
-import hashlib
-import json
-import time
-import logging
-import numpy as np
-from collections import deque
-
-# Set up logging
-logger = logging.getLogger(__name__)
-
-# Milestone tracking for progression verification - exact milestones for submission.log
-MILESTONES = [
-    # Phase 1: Game Initialization
-    'GAME_RUNNING', 'PLAYER_NAME_SET', 'INTRO_CUTSCENE_COMPLETE',
-    
-    # Phase 2: Tutorial & Starting Town
-    'LITTLEROOT_TOWN', 'PLAYER_HOUSE_ENTERED', 'PLAYER_BEDROOM', 
-    'RIVAL_HOUSE', 'RIVAL_BEDROOM',
-    
-    # Phase 3: Professor Birch & Starter
-    'ROUTE_101', 'STARTER_CHOSEN', 'BIRCH_LAB_VISITED',
-    
-    # Phase 4: Rival
-    'OLDALE_TOWN', 'ROUTE_103', 'RECEIVED_POKEDEX',
-    
-    # Phase 5: Route 102 & Petalburg
-    'ROUTE_102', 'PETALBURG_CITY', 'DAD_FIRST_MEETING', 'GYM_EXPLANATION',
-    
-    # Phase 6: Road to Rustboro City
-    'ROUTE_104_SOUTH', 'PETALBURG_WOODS', 'TEAM_AQUA_GRUNT_DEFEATED',
-    'ROUTE_104_NORTH', 'RUSTBORO_CITY',
-    
-    # Phase 7: First Gym Challenge
-    'RUSTBORO_GYM_ENTERED', 'ROXANNE_DEFEATED', 'FIRST_GYM_COMPLETE'
-]
-
-class AntiCheatTracker:
-    """
-    Tracks anti-cheat metrics and behavioral patterns for Pokemon Emerald AI agent.
-    """
-    
-    def __init__(self):
-        self.latest_milestone = None
-        self.previous_position = None
-        self.decision_times = deque(maxlen=100)  # Track last 100 decision times
-        self.invalid_actions = 0
-        self.total_actions = 0
-        self.exploration_moves = 0  # Moves that deviate from direct paths
-        self.backtrack_moves = 0    # Moves that return to previous positions
-        self.position_history = deque(maxlen=20)  # Track recent positions
-        self.start_time = None  # Will be set when logging is initialized
-        
-        # Set up submission logging (avoid duplicate handlers)
-        self.submission_logger = logging.getLogger('submission')
-        self.submission_logger.setLevel(logging.INFO)
-        
-        # Only add handler if none exists
-        if not self.submission_logger.handlers:
-            submission_handler = logging.FileHandler('submission.log', mode='a')
-            submission_handler.setLevel(logging.INFO)  # Explicitly set handler level
-            submission_formatter = logging.Formatter('%(message)s')
-            submission_handler.setFormatter(submission_formatter)
-            self.submission_logger.addHandler(submission_handler)
-            self.submission_logger.propagate = False
-    
-    def create_state_hash(self, state_data):
-        """
-        Create a hash of critical game state elements for integrity verification.
-        """
-        # Extract key elements that shouldn't change unexpectedly
-        hash_elements = {
-            'player_name': state_data.get('player', {}).get('name', ''),
-            'money': state_data.get('player', {}).get('money') or state_data.get('game', {}).get('money', 0),
-            'location': state_data.get('player', {}).get('location', ''),
-            'coordinates': state_data.get('player', {}).get('coordinates', {}),
-            'in_battle': state_data.get('game', {}).get('in_battle', False),
-            'step_number': state_data.get('step_number', 0)
-        }
-        
-        # Add party pokemon data
-        party_data = state_data.get('player', {}).get('party') or state_data.get('game', {}).get('party')
-        party_hash_data = []
-        if party_data:
-            pokemon_list = []
-            if isinstance(party_data, dict) and party_data.get('pokemon'):
-                pokemon_list = party_data.get('pokemon', [])
-            elif isinstance(party_data, list):
-                pokemon_list = party_data
-            
-            for pokemon in pokemon_list[:6]:
-                if pokemon:
-                    party_hash_data.append({
-                        'species': pokemon.get('species', ''),
-                        'level': pokemon.get('level', 0),
-                        'max_hp': pokemon.get('max_hp', 0)
-                    })
-        
-        hash_elements['party'] = party_hash_data
-        
-        # Create deterministic hash
-        hash_string = json.dumps(hash_elements, sort_keys=True)
-        return hashlib.md5(hash_string.encode()).hexdigest()[:8]
-    
-    def analyze_movement_behavior(self, current_pos, previous_pos, action_taken):
-        """
-        Analyze movement patterns for behavioral fingerprinting.
-        """
-        if not current_pos or not previous_pos:
-            return
-        
-        current_x = current_pos.get('x')
-        current_y = current_pos.get('y')
-        prev_x = previous_pos.get('x')
-        prev_y = previous_pos.get('y')
-        
-        if None in [current_x, current_y, prev_x, prev_y]:
-            return
-        
-        # Calculate movement delta
-        dx = current_x - prev_x
-        dy = current_y - prev_y
-        
-        # Check if movement matches action
-        action_str = str(action_taken).upper()
-        expected_movement = False
-        
-        if 'UP' in action_str and dy == -1 and dx == 0:
-            expected_movement = True
-        elif 'DOWN' in action_str and dy == 1 and dx == 0:
-            expected_movement = True
-        elif 'LEFT' in action_str and dx == -1 and dy == 0:
-            expected_movement = True
-        elif 'RIGHT' in action_str and dx == 1 and dy == 0:
-            expected_movement = True
-        elif action_str in ['A', 'B', 'START', 'SELECT'] and dx == 0 and dy == 0:
-            expected_movement = True  # Non-movement actions
-        
-        if not expected_movement and (dx != 0 or dy != 0):
-            self.invalid_actions += 1
-        
-        # Check for backtracking (returning to a recent position)
-        current_pos_tuple = (current_x, current_y)
-        if current_pos_tuple in list(self.position_history)[-10:]:  # Last 10 positions
-            self.backtrack_moves += 1
-        
-        # Add to position history
-        self.position_history.append(current_pos_tuple)
-        
-        # Simple exploration detection (movement without clear direction)
-        if abs(dx) + abs(dy) > 1:  # Diagonal or multi-tile movement (unusual)
-            self.exploration_moves += 1
-    
-    def calculate_behavioral_metrics(self):
-        """
-        Calculate behavioral fingerprinting metrics.
-        """
-        avg_decision_time = sum(self.decision_times) / len(self.decision_times) if self.decision_times else 0
-        error_rate = self.invalid_actions / max(self.total_actions, 1)
-        exploration_ratio = self.exploration_moves / max(self.total_actions, 1)
-        backtrack_ratio = self.backtrack_moves / max(self.total_actions, 1)
-        
-        return {
-            'avg_decision_time': round(avg_decision_time, 3),
-            'error_rate': round(error_rate, 3),
-            'exploration_ratio': round(exploration_ratio, 3),
-            'backtrack_ratio': round(backtrack_ratio, 3),
-            'decision_variance': round(np.var(list(self.decision_times)), 3) if len(self.decision_times) > 1 else 0
-        }
-    
-    def detect_milestone(self, location_name):
-        """
-        Detect if the current location corresponds to a milestone.
-        Maps actual game location names to milestone identifiers.
-        """
-        if not location_name or location_name == 'Unknown':
-            return None
-        
-        # Normalize location name (remove spaces, convert to uppercase)
-        normalized = location_name.replace(' ', '_').upper()
-        
-        # Direct mapping for locations that match exactly
-        if normalized in MILESTONES:
-            return normalized
-        
-        # Special mappings for locations that might have different names
-        location_mappings = {
-            # Phase 1: Game Initialization
-            'MOVING_VAN': 'INTRO_CUTSCENE_COMPLETE',
-            
-            # Phase 2: Tutorial & Starting Town
-            'LITTLEROOT': 'LITTLEROOT_TOWN',
-            'BRENDANS_HOUSE_1F': 'PLAYER_HOUSE_ENTERED',
-            'BRENDANS_HOUSE_2F': 'PLAYER_BEDROOM',
-            'MAYS_HOUSE_1F': 'RIVAL_HOUSE',
-            'MAYS_HOUSE_2F': 'RIVAL_BEDROOM',
-            
-            # Phase 3: Professor Birch & Starter
-            'ROUTE_101': 'ROUTE_101',
-            'ROUTE101': 'ROUTE_101',
-            'BIRCHS_LAB': 'BIRCH_LAB_VISITED',
-            'PROFESSOR_BIRCHS_LAB': 'BIRCH_LAB_VISITED',
-            
-            # Phase 4: Rival
-            'OLDALE': 'OLDALE_TOWN',
-            'ROUTE_103': 'ROUTE_103',
-            'ROUTE103': 'ROUTE_103',
-            
-            # Phase 5: Route 102 & Petalburg
-            'ROUTE_102': 'ROUTE_102',
-            'ROUTE102': 'ROUTE_102',
-            'PETALBURG': 'PETALBURG_CITY',
-            'PETALBURG_CITY_GYM': 'DAD_FIRST_MEETING',
-            'PETALBURG_GYM': 'DAD_FIRST_MEETING',
-            
-            # Phase 6: Road to Rustboro City
-            'ROUTE_104': 'ROUTE_104_SOUTH',
-            'ROUTE104': 'ROUTE_104_SOUTH',
-            'PETALBURG_WOODS': 'PETALBURG_WOODS',
-            
-            # Phase 7: First Gym Challenge
-            'RUSTBORO': 'RUSTBORO_CITY',
-            'RUSTBORO_GYM': 'RUSTBORO_GYM_ENTERED',
-            'RUSTBORO_CITY_GYM': 'RUSTBORO_GYM_ENTERED'
-        }
-        
-        # Check for partial matches
-        for key, milestone in location_mappings.items():
-            if key in normalized:
-                return milestone
-        
-        return None
-    
-    def update_milestone(self, current_location):
-        """Update the latest milestone based on current location"""
-        detected_milestone = self.detect_milestone(current_location)
-        if detected_milestone:
-            # Check if this is a new milestone (further in progression)
-            if self.latest_milestone is None:
-                self.latest_milestone = detected_milestone
-                logger.info(f"[MILESTONE] First milestone detected: {self.latest_milestone}")
-            else:
-                try:
-                    current_index = MILESTONES.index(self.latest_milestone)
-                    new_index = MILESTONES.index(detected_milestone)
-                    
-                    # Only update if we've progressed further
-                    if new_index > current_index:
-                        self.latest_milestone = detected_milestone
-                        logger.info(f"[MILESTONE] New milestone reached: {self.latest_milestone}")
-                except ValueError:
-                    # If milestone not found in list, just log it
-                    logger.warning(f"[MILESTONE] Unknown milestone detected: {detected_milestone}")
-        
-        return self.latest_milestone
-    
-    def log_submission_data(self, step, state_data, action_taken, decision_time, state_hash, manual_mode=False, milestone_override=None):
-        """Log structured data for anticheat verification"""
-        # Extract key information
-        player_data = state_data.get('player', {})
-        game_data = state_data.get('game', {})
-        map_info = state_data.get('map', {})
-        
-        # Position - use the same logic as state formatter
-        position = None
-        if 'coordinates' in player_data:
-            position = player_data['coordinates']
-        elif 'position' in player_data and player_data['position']:
-            position = player_data['position']
-        
-        if position and isinstance(position, dict):
-            x_val = position.get('x', '?')
-            y_val = position.get('y', '?')
-            pos_str = f"({x_val},{y_val})"
-        else:
-            pos_str = "(?,?)"
-        
-        # Battle state
-        battle_state = "BATTLE" if game_data.get('in_battle', False) else "OVERWORLD"
-        
-        # Party summary - use similar logic to state formatter
-        party_data = player_data.get('party') or game_data.get('party')
-        party_summary = []
-        if party_data:
-            pokemon_list = []
-            if isinstance(party_data, dict) and party_data.get('pokemon'):
-                pokemon_list = party_data.get('pokemon', [])
-            elif isinstance(party_data, list):
-                pokemon_list = party_data
-            
-            for pokemon in pokemon_list[:6]:  # Max 6 pokemon
-                if pokemon:
-                    # Use same field names as get_comprehensive_state for consistency
-                    species = pokemon.get('species_name', pokemon.get('species', 'Unknown'))
-                    level = pokemon.get('level', '?')
-                    hp = pokemon.get('current_hp', '?')
-                    max_hp = pokemon.get('max_hp', '?')
-                    status = pokemon.get('status', 'OK')
-                    party_summary.append(f"{species}(Lv{level},HP:{hp}/{max_hp},{status})")
-        
-        party_str = "[" + ",".join(party_summary) + "]" if party_summary else "[]"
-        
-        # Action taken
-        action_str = str(action_taken) if action_taken else "None"
-        
-        # Current map - correctly extract from player.location
-        current_map = player_data.get('location', 'Unknown')
-        
-        # Use provided milestone or update and get latest milestone
-        if milestone_override:
-            milestone_str = milestone_override
-        else:
-            milestone = self.update_milestone(current_map)
-            milestone_str = milestone if milestone else "NONE"
-        
-        # Money
-        money = player_data.get('money')
-        if money is None:
-            money = game_data.get('money', 0)
-        
-        # Analyze movement behavior
-        if position and isinstance(position, dict):
-            self.analyze_movement_behavior(position, self.previous_position, action_taken)
-            self.previous_position = position.copy()
-        
-        self.total_actions += 1
-        self.decision_times.append(decision_time)
-        
-        # Get behavioral metrics
-        behavioral_metrics = self.calculate_behavioral_metrics()
-        
-        # Calculate current runtime
-        current_runtime = 0.0
-        runtime_str = "00:00:00"
-        if self.start_time is not None:
-            current_runtime = time.time() - self.start_time
-            hours = int(current_runtime // 3600)
-            minutes = int((current_runtime % 3600) // 60)
-            seconds = int(current_runtime % 60)
-            runtime_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        
-        # Determine mode string
-        mode_str = "MANUAL" if manual_mode else "AGENT"
-        
-        # Log structured entry with enhanced anti-cheat data including runtime and mode
-        log_entry = (f"STEP={step} | POS={pos_str} | MAP={current_map} | MILESTONE={milestone_str} | "
-                    f"STATE={battle_state} | MONEY=${money} | PARTY={party_str} | ACTION={action_str} | "
-                    f"MODE={mode_str} | DECISION_TIME={decision_time:.3f}s | RUNTIME={runtime_str} | "
-                    f"STATE_HASH={state_hash} | "
-                    f"AVG_TIME={behavioral_metrics['avg_decision_time']}s | "
-                    f"ERROR_RATE={behavioral_metrics['error_rate']} | "
-                    f"EXPLORE_RATIO={behavioral_metrics['exploration_ratio']} | "
-                    f"BACKTRACK_RATIO={behavioral_metrics['backtrack_ratio']} | "
-                    f"TIME_VAR={behavioral_metrics['decision_variance']}")
-        
-        self.submission_logger.info(log_entry)
-        
-        # Force flush to ensure immediate write
-        for handler in self.submission_logger.handlers:
-            handler.flush()
-    
-    def initialize_submission_log(self, model_name):
-        """Initialize submission log with header information"""
-        self.start_time = time.time()  # Store start time for total runtime calculation
-        
-        # Clear the file first by writing directly
-        with open('submission.log', 'w') as f:
-            f.write("")
-        
-        self.submission_logger.info("=== POKEMON EMERALD AGENT SUBMISSION LOG ===")
-        self.submission_logger.info(f"Model: {model_name} | Start Time: {time.strftime('%Y-%m-%d %H:%M:%S')}")
-        self.submission_logger.info("Format: STEP | POS | MAP | MILESTONE | STATE | MONEY | PARTY | ACTION | MODE | DECISION_TIME | RUNTIME | STATE_HASH | AVG_TIME | ERROR_RATE | EXPLORE_RATIO | BACKTRACK_RATIO | TIME_VAR")
-        self.submission_logger.info("=" * 120) 

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/utils/checkpoint.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-"""
-Checkpoint management utilities for saving and loading game states,
-agent states, and LLM history.
-"""
-
-import os
-import json
-import traceback
-from collections import deque
-from datetime import datetime
-
-
-def save_checkpoint(emulator, llm_logger=None, agent_step_count=0):
-    """
-    Save a complete checkpoint including game state, milestones, and LLM history.
-    
-    Args:
-        emulator: The game emulator instance
-        llm_logger: Optional LLM logger for saving conversation history
-        agent_step_count: Current agent step count
-    
-    Returns:
-        bool: True if checkpoint saved successfully, False otherwise
-    """
-    try:
-        # Save emulator state
-        print("💾 Saving checkpoint...")
-        os.makedirs(".pokeagent_cache", exist_ok=True)
-        emulator.save_state(".pokeagent_cache/checkpoint.state")
-        print(f"   ✅ Saved emulator state to .pokeagent_cache/checkpoint.state")
-        
-        # Save milestones
-        milestone_data = {
-            "milestones": emulator.memory_reader.milestones if emulator.memory_reader else {},
-            "step_count": agent_step_count,
-            "timestamp": datetime.now().isoformat()
-        }
-        os.makedirs(".pokeagent_cache", exist_ok=True)
-        with open(".pokeagent_cache/checkpoint_milestones.json", "w") as f:
-            json.dump(milestone_data, f, indent=2)
-        print(f"   ✅ Saved milestones to .pokeagent_cache/checkpoint_milestones.json")
-        
-        # Save location maps
-        try:
-            from utils.state_formatter import save_persistent_world_map
-            os.makedirs(".pokeagent_cache", exist_ok=True)
-            save_persistent_world_map(".pokeagent_cache/checkpoint_maps.json")
-            print(f"   ✅ Saved location maps to .pokeagent_cache/checkpoint_maps.json")
-        except Exception as e:
-            print(f"   ⚠️ Failed to save location maps: {e}")
-        
-        # Save LLM history if logger available
-        if llm_logger:
-            # Get conversation history from logger
-            history = llm_logger.get_conversation_history()
-            
-            # Also get metrics if available
-            try:
-                metrics = llm_logger.get_interaction_metrics()
-                checkpoint_data = {
-                    "history": history,
-                    "metrics": metrics,
-                    "step_counter": agent_step_count,
-                    "timestamp": datetime.now().isoformat()
-                }
-            except:
-                checkpoint_data = {
-                    "history": history,
-                    "step_counter": agent_step_count,
-                    "timestamp": datetime.now().isoformat()
-                }
-            
-            # Save to cache folder
-            cache_dir = ".pokeagent_cache"
-            os.makedirs(cache_dir, exist_ok=True)
-            checkpoint_file = os.path.join(cache_dir, "checkpoint_llm.txt")
-            with open(checkpoint_file, "w") as f:
-                json.dump(checkpoint_data, f, indent=2)
-            print(f"   ✅ Saved LLM history to {checkpoint_file}")
-        
-        print(f"✅ Checkpoint saved at step {agent_step_count}")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Failed to save checkpoint: {e}")
-        traceback.print_exc()
-        return False
-
-
-def load_checkpoint(emulator, llm_logger=None):
-    """
-    Load a checkpoint including game state, milestones, and LLM history.
-    
-    Args:
-        emulator: The game emulator instance
-        llm_logger: Optional LLM logger for loading conversation history
-    
-    Returns:
-        dict: Checkpoint data including step_count, or None if failed
-    """
-    try:
-        checkpoint_data = {}
-        
-        # Load emulator state
-        if os.path.exists(".pokeagent_cache/checkpoint.state"):
-            print("🔄 Loading checkpoint...")
-            emulator.load_state(".pokeagent_cache/checkpoint.state")
-            print(f"   ✅ Loaded emulator state from .pokeagent_cache/checkpoint.state")
-        else:
-            print("   ⚠️ No .pokeagent_cache/checkpoint.state found")
-            return None
-        
-        # Load milestones
-        if os.path.exists(".pokeagent_cache/checkpoint_milestones.json"):
-            with open(".pokeagent_cache/checkpoint_milestones.json", "r") as f:
-                milestone_data = json.load(f)
-            if emulator.memory_reader:
-                emulator.memory_reader.milestones = milestone_data.get("milestones", {})
-            checkpoint_data['step_count'] = milestone_data.get("step_count", 0)
-            print(f"   ✅ Loaded milestones from .pokeagent_cache/checkpoint_milestones.json")
-        
-        # Load location maps
-        try:
-            from utils.state_formatter import load_persistent_world_map
-            if os.path.exists(".pokeagent_cache/checkpoint_maps.json"):
-                load_persistent_world_map(".pokeagent_cache/checkpoint_maps.json")
-                print(f"   ✅ Loaded location maps from .pokeagent_cache/checkpoint_maps.json")
-            else:
-                print(f"   ⚠️ No .pokeagent_cache/checkpoint_maps.json found")
-        except Exception as e:
-            print(f"   ⚠️ Failed to load location maps: {e}")
-        
-        # Load LLM history if logger available
-        cache_dir = ".pokeagent_cache"
-        checkpoint_file = os.path.join(cache_dir, "checkpoint_llm.txt") if os.path.exists(cache_dir) else "checkpoint_llm.txt"
-        if not os.path.exists(checkpoint_file) and os.path.exists("checkpoint_llm.txt"):
-            checkpoint_file = "checkpoint_llm.txt"
-        
-        if llm_logger and os.path.exists(checkpoint_file):
-            with open(checkpoint_file, "r") as f:
-                llm_data = json.load(f)
-            
-            # Restore conversation history
-            if 'history' in llm_data:
-                llm_logger.set_conversation_history(llm_data['history'])
-            
-            checkpoint_data['llm_step_count'] = llm_data.get('step_counter', 0)
-            print(f"   ✅ Loaded LLM history from checkpoint_llm.txt")
-        
-        print(f"✅ Checkpoint loaded successfully")
-        return checkpoint_data
-        
-    except Exception as e:
-        print(f"❌ Failed to load checkpoint: {e}")
-        traceback.print_exc()
-        return None
-
-
-def save_simple_agent_state(simple_agent, filename="agent_state.json"):
-    """
-    Save SimpleAgent state to JSON file.
-    
-    Args:
-        simple_agent: The SimpleAgent instance
-        filename: Output filename
-    
-    Returns:
-        bool: True if saved successfully
-    """
-    try:
-        # Convert SimpleAgent state to serializable format
-        state_data = {
-            "step_counter": simple_agent.state.step_counter,
-            "stuck_detection": simple_agent.state.stuck_detection,
-            "objectives_updated": simple_agent.state.objectives_updated,
-            "history": [],
-            "objectives": []
-        }
-        
-        # Convert history entries
-        for entry in simple_agent.state.history:
-            state_data["history"].append({
-                "timestamp": entry.timestamp.isoformat() if hasattr(entry.timestamp, 'isoformat') else str(entry.timestamp),
-                "screenshot": None,  # Don't save screenshots
-                "game_state": entry.game_state,
-                "llm_output": entry.llm_output
-            })
-        
-        # Convert objectives
-        for obj in simple_agent.state.objectives:
-            state_data["objectives"].append({
-                "description": obj.description,
-                "completed": obj.completed
-            })
-        
-        # Save to file
-        with open(filename, 'w') as f:
-            json.dump(state_data, f, indent=2)
-        
-        print(f"✅ Saved SimpleAgent state to {filename}")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Failed to save SimpleAgent state: {e}")
-        traceback.print_exc()
-        return False
-
-
-def load_simple_agent_state(simple_agent, filename="agent_state.json"):
-    """
-    Load SimpleAgent state from JSON file.
-    
-    Args:
-        simple_agent: The SimpleAgent instance to load state into
-        filename: Input filename
-    
-    Returns:
-        bool: True if loaded successfully
-    """
-    try:
-        from agent.simple import HistoryEntry, Objective
-        
-        with open(filename, 'r') as f:
-            state_data = json.load(f)
-        
-        # Restore basic counters
-        simple_agent.state.step_counter = state_data.get("step_counter", 0)
-        simple_agent.state.stuck_detection = state_data.get("stuck_detection", {})
-        simple_agent.state.objectives_updated = state_data.get("objectives_updated", False)
-        
-        # Restore history
-        simple_agent.state.history = deque(maxlen=10)
-        for entry_data in state_data.get("history", []):
-            # Parse timestamp
-            timestamp_str = entry_data.get("timestamp", "")
-            try:
-                timestamp = datetime.fromisoformat(timestamp_str)
-            except:
-                timestamp = datetime.now()
-            
-            entry = HistoryEntry(
-                timestamp=timestamp,
-                screenshot=None,  # Don't restore screenshots
-                game_state=entry_data.get("game_state", {}),
-                llm_output=entry_data.get("llm_output", {})
-            )
-            simple_agent.state.history.append(entry)
-        
-        # Restore objectives
-        simple_agent.state.objectives = []
-        for obj_data in state_data.get("objectives", []):
-            obj = Objective(
-                description=obj_data.get("description", ""),
-                completed=obj_data.get("completed", False)
-            )
-            simple_agent.state.objectives.append(obj)
-        
-        print(f"✅ Loaded SimpleAgent state from {filename}")
-        print(f"   - Step counter: {simple_agent.state.step_counter}")
-        print(f"   - History entries: {len(simple_agent.state.history)}")
-        print(f"   - Objectives: {len(simple_agent.state.objectives)}")
-        
-        return True
-        
-    except FileNotFoundError:
-        print(f"⚠️ No saved state found at {filename}")
-        return False
-    except Exception as e:
-        print(f"❌ Failed to load SimpleAgent state: {e}")
-        traceback.print_exc()
-        return False
-
-
-def load_llm_checkpoint(filename="checkpoint_llm.txt"):
-    """
-    Load LLM checkpoint data from file.
-    
-    Args:
-        filename: Input filename
-    
-    Returns:
-        dict: Checkpoint data or None if failed
-    """
-    try:
-        if not os.path.exists(filename):
-            return None
-        
-        with open(filename, 'r') as f:
-            data = json.load(f)
-        
-        return data
-        
-    except Exception as e:
-        print(f"❌ Failed to load LLM checkpoint: {e}")
-        return None