feat(mcp): integrate local FastMCP client with logging and improve service management and add display cache

README.md

@@ -27,10 +27,11 @@ tags:
 
 ### Key Highlights
 
-- **Multi-stage advisor (Assess → Plan → Execute → Cycle Summary → After-Action)** powered by `openai/gpt-oss-120b` via HuggingFace Inference.
+- **Multi-stage advisor (Assess → Plan → Execute → Cycle Summary → After-Action)**
 - **10 FastMCP tools** cover scenario control, deployment, repositioning, removal, and analytics (idle units, coverage, building threats).
 - **Real-time Gradio 6 UI**: 10×10 emoji grid, animated status HUD, AI chat timeline, event logs, and clickable placement controls.
 - **Auto-execute toggle** lets players hand full control to the AI or approve every deployment manually—including adding new fires for stress tests.
+- **Advisor model switcher** directly in the control panel lets you hop between GPT-OSS 120B/20B, Llama-3.1 8B, and OpenAI GPT-5.1 backends.
 - **AI Battle Report Overlay**: After each victory/defeat the agent compiles charts, highlights, risks, and next actions before you rerun.
 - **Submission-ready metadata**: README + prompts + PRD/dev plan + Space tags prepared for the hackathon checklist.
 
@@ -132,7 +133,7 @@ Prompts for every stage live in `prompts.yaml`, making it easy to retune instruc
 
 - **`app.py`** – Gradio 6 Blocks UI, CSS-heavy HUD, timers, and event handlers for start/pause/reset, auto-execute toggles, and grid interactions.
 - **`service.py`** – Threaded simulation service with 1s ticks, 10-tick advisor cadence, change-tracked UI diffing, player action tracking, and after-action orchestration.
-- **`agent.py`** – Multi-stage LLM pipeline using HuggingFace’s OpenAI-compatible endpoint (`openai/gpt-oss-120b`) plus JSON-repair helpers and retry/backoff logic.
+- **`agent.py`** – Multi-stage LLM pipeline that bridges HuggingFace’s OpenAI-compatible endpoint and native OpenAI APIs, alongside JSON-repair helpers and retry/backoff logic.
 - **`simulation.py`** – 10×10 grid-based simulation (fire spread, win/lose rules, unit power/range, building cluster generator, seedable randomness).
 - **`models.py`** – Dataclasses for world/units/fires/events and serialization helpers used by both Gradio and MCP servers.
 - **`prompts.yaml`** – Configuration for every stage (Assess/Plan/Execute/Summary/After-Action) and model defaults (`max_completion_tokens=10000`).
@@ -181,12 +182,15 @@ pip install -e .
 
 ```bash
 export HF_TOKEN=your-huggingface-token-here
+# Optional: enable OpenAI GPT-5 models via the new dropdown
+export OPENAI_API_KEY=your-openai-key-here
 ```
 
 Or create `.env` next to `agent.py`:
 
 ```
 HF_TOKEN=hf_xxx
+OPENAI_API_KEY=sk-...
 ```
 
 ### Launch the Gradio app
@@ -241,8 +245,8 @@ fire-rescue-mcp/
 |------------|---------|
 | **Gradio 6** | Responsive Blocks UI, timers, and theming |
 | **FastMCP** | Lightweight MCP server for exposing tools |
-| **HuggingFace Inference (OpenAI-compatible)** | Runs `openai/gpt-oss-120b` without vendor lock-in |
-| **OpenAI Python SDK** | Client for HF’s router (JSON mode + retries) |
+| **HuggingFace Inference (OpenAI-compatible)** | Runs the GPT-OSS 120B/20B and Llama-3.1 8B lineup without vendor lock-in |
+| **OpenAI Python SDK** | Native client for the GPT-5.1 advisor option plus JSON-mode retries |
 | **UV** | Dependency + virtualenv manager |
 | **Python 3.10+ / dataclasses** | Core simulation + service logic |
 

agent.py

@@ -37,6 +37,11 @@ except ImportError:
 HF_INFERENCE_BASE_URL = "https://router.huggingface.co/v1"
 HF_DEFAULT_MODEL = "openai/gpt-oss-120b"
 
+# OpenAI native configuration
+OPENAI_DEFAULT_MODEL = "gpt-5-mini"
+OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+OPENAI_API_ENV_VAR = "OPENAI_API_KEY"
+
 def get_hf_token() -> str | None:
     """
     Get HuggingFace token from environment variable.
@@ -47,6 +52,16 @@ def get_hf_token() -> str | None:
     return os.getenv("HF_TOKEN")
 
 
+def get_openai_api_key() -> str | None:
+    """
+    Get OpenAI API key from environment variable.
+    
+    Returns:
+        OPENAI_API_KEY if available, None otherwise
+    """
+    return os.getenv(OPENAI_API_ENV_VAR)
+
+
 # =============================================================================
 # Stage 3 action cap + Prompt loading
 # =============================================================================
@@ -250,38 +265,52 @@ class AdvisorAgent:
         self,
         api_key: Optional[str] = None,
         model: Optional[str] = None,
+        provider: str = "hf",
+        base_url: Optional[str] = None,
     ):
         """
         Initialize the advisor agent.
         
         Args:
-            api_key: HuggingFace token (defaults to HF_TOKEN env var)
-            model: Model to use for inference (defaults to openai/gpt-oss-120b)
+            api_key: Optional override for provider API key
+            model: Model to use for inference (defaults depend on provider)
+            provider: "hf" for HuggingFace Router or "openai" for native OpenAI
+            base_url: Optional override for API base URL
         """
-        # Get HuggingFace token
-        self.api_key = api_key or get_hf_token()
-        self.base_url = HF_INFERENCE_BASE_URL
+        self.provider = (provider or "hf").lower()
+        if self.provider not in {"hf", "openai"}:
+            self.provider = "hf"
+        
+        if self.provider == "openai":
+            self.api_key = api_key or get_openai_api_key()
+            self.base_url = base_url or OPENAI_BASE_URL
+        else:
+            self.api_key = api_key or get_hf_token()
+            self.base_url = base_url or HF_INFERENCE_BASE_URL
         
         # Load model config from prompts.yaml
         model_config = PROMPTS_CONFIG.get("model", {})
         
         # Model priority: explicit param > prompts.yaml > default
-        yaml_model = model_config.get("default")
-        self.model = model or yaml_model or HF_DEFAULT_MODEL
+        yaml_model = model_config.get("default") if self.provider == "hf" else None
+        provider_default_model = OPENAI_DEFAULT_MODEL if self.provider == "openai" else HF_DEFAULT_MODEL
+        self.model = model or yaml_model or provider_default_model
         
         self.temperature = model_config.get("temperature")  # None if not set
         self.max_completion_tokens = model_config.get("max_completion_tokens", 2000)
         
         # Initialize client
         if self.api_key:
-            print(f"🤖 AI Advisor initialized with HuggingFace Inference API, model: {self.model}")
+            provider_label = "OpenAI" if self.provider == "openai" else "HuggingFace Inference"
+            print(f"🤖 AI Advisor initialized with {provider_label} API, model: {self.model}")
             self.client = OpenAI(
                 api_key=self.api_key,
                 base_url=self.base_url
             )
         else:
             self.client = None
-            print("⚠️ Warning: No HF_TOKEN found. AI analysis will not work.")
+            missing_env = OPENAI_API_ENV_VAR if self.provider == "openai" else "HF_TOKEN"
+            print(f"⚠️ Warning: Missing {missing_env}. AI analysis will not work.")
     
     # =========================================================================
     # JSON Repair Helper
@@ -348,7 +377,8 @@ class AdvisorAgent:
             Parsed JSON dict, or None if failed
         """
         if not self.client:
-            print("Error: No API client available (HF_TOKEN not set)")
+            missing_env = OPENAI_API_ENV_VAR if self.provider == "openai" else "HF_TOKEN"
+            print(f"Error: No API client available ({missing_env} not set)")
             return None
         
         # Retry logic for rate limiting (429 errors)
@@ -357,16 +387,17 @@ class AdvisorAgent:
         
         for attempt in range(max_retries):
             try:
-                # Build API call parameters for HuggingFace Inference Provider
+                # Build API call parameters for current provider
+                token_param = "max_completion_tokens" if self.provider == "openai" else "max_tokens"
                 api_params = {
                     "model": self.model,
                     "messages": [
                         {"role": "system", "content": system_prompt},
                         {"role": "user", "content": user_message}
                     ],
-                    "max_tokens": self.max_completion_tokens,
                     "response_format": {"type": "json_object"}
                 }
+                api_params[token_param] = self.max_completion_tokens
                 
                 # Only add temperature if explicitly set
                 if self.temperature is not None:

app.py

@@ -11,16 +11,53 @@ import uuid
 import gradio as gr
 from typing import Optional
 
-from service import get_service, SimulationService
+from service import (
+    ADVISOR_MODEL_CHOICES,
+    DEFAULT_ADVISOR_MODEL_CHOICE,
+    SimulationService,
+)
 
 AUTO_EXECUTE_DEFAULT = True  # Keep UI + backend aligned on initial load
+ADVISOR_MODEL_LABELS = list(ADVISOR_MODEL_CHOICES.keys())
 
 
-def _reset_auto_execute_to_default() -> bool:
+def get_or_create_service(service: Optional[SimulationService]) -> SimulationService:
+    """Return existing SimulationService or create a new one for the session."""
+    if service is None:
+        return SimulationService()
+    return service
+
+
+def _create_display_cache() -> dict:
+    """Create a per-session cache for advisor/history/status renders."""
+    return {
+        "last_status_html": None,
+        "last_advisor_signature": (),
+        "history_messages_cache": [],
+        "current_cycle_messages_cache": [],
+        "result_freeze_state": "",
+    }
+
+
+def _reset_advisor_display_cache(cache: Optional[dict] = None) -> dict:
+    """Clear cached advisor/chatbot renders (prevents stale history after reset)."""
+    if cache is None:
+        cache = _create_display_cache()
+    cache["last_status_html"] = None
+    cache["last_advisor_signature"] = ()
+    cache["history_messages_cache"] = []
+    cache["current_cycle_messages_cache"] = []
+    cache["result_freeze_state"] = ""
+    return cache
+
+
+def _reset_auto_execute_to_default(
+    service: Optional[SimulationService] = None,
+) -> tuple[bool, SimulationService]:
     """Restore auto-execute to the configured default and sync the checkbox."""
-    service = get_service()
+    service = get_or_create_service(service)
     service.set_auto_execute(AUTO_EXECUTE_DEFAULT)
-    return AUTO_EXECUTE_DEFAULT
+    return AUTO_EXECUTE_DEFAULT, service
 
 
 def _generate_session_token() -> str:
@@ -34,14 +71,43 @@ def _generate_session_token() -> str:
     return f"{timestamp_ms}_{unique_id}"
 
 
-def _initialize_session_defaults() -> tuple[bool, bool, str]:
+def _initialize_session_defaults(
+    service: Optional[SimulationService] = None,
+    display_cache: Optional[dict] = None,
+):
     """
     Reset auto-execute back to default and mark the new Gradio session
     as fresh so the next Start press always creates a brand-new run.
     Also issues a unique session token to bind backend ownership.
+    Returns initial values for all UI components to ensure clean state.
     """
-    auto_value = _reset_auto_execute_to_default()
-    return auto_value, False, _generate_session_token()
+    auto_value, service = _reset_auto_execute_to_default(service)
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
+    display_cache = _reset_advisor_display_cache(display_cache)
+    default_model_choice = service.reset_advisor_model_choice()
+    advisor_messages = [
+        {
+            "role": "assistant",
+            "content": "No AI analysis yet. Press **Start** to begin the advisor cycle.",
+        }
+    ]
+    event_log = "No events yet..."
+    status_html = render_status_html({"status": "idle"})
+    grid_updates = [gr.update(value="🌲") for _ in range(100)]
+    return (
+        auto_value,
+        False,
+        _generate_session_token(),
+        default_model_choice,
+        service,
+        display_cache,
+        advisor_messages,
+        event_log,
+        status_html,
+        *grid_updates,
+    )
 
 
 # =============================================================================
@@ -552,7 +618,7 @@ def render_game_result(status: str, report_payload: Optional[dict] = None) -> st
             <div class="result-title" style="color: {outcome_config['color']};">{outcome_config['title']}</div>
             <div class="result-subtitle">{outcome_config['subtitle']}</div>
             {report_section}
-            <button class="result-ok-btn" onclick="document.getElementById('result-overlay').style.display='none'">OK</button>
+            <button class="result-ok-btn" onclick="const overlay=document.getElementById('result-overlay');if(overlay){{overlay.style.display='none';}}">OK</button>
         </div>
     </div>
     """
@@ -582,9 +648,13 @@ def start_or_resume_simulation(
     seed: Optional[int],
     should_resume: bool,
     session_token: Optional[str],
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
 ):
     """Handle Start/Resume button click."""
-    service = get_service()
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
     token = (session_token or "").strip()
     
     resume_requested = bool(should_resume) and service.can_resume_session(token)
@@ -598,7 +668,7 @@ def start_or_resume_simulation(
     else:
         # Start new simulation - ALWAYS generate fresh token to ensure uniqueness
         # This prevents any possibility of matching old paused sessions
-        _reset_advisor_display_cache()
+        display_cache = _reset_advisor_display_cache(display_cache)
         new_token = _generate_session_token()
         actual_seed = int(seed) if seed and seed > 0 else None
         state = service.start(
@@ -626,12 +696,17 @@ def start_or_resume_simulation(
         gr.update(interactive=False),  # start btn
         gr.update(interactive=True),   # pause btn
         render_status_html(state, is_thinking, thinking_stage),
-    ] + updates + [False, new_token]
+    ] + updates + [False, new_token, service, display_cache]
 
 
-def pause_simulation():
+def pause_simulation(
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
+):
     """Handle Pause button click."""
-    service = get_service()
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
     state = service.pause()
     
     updates = get_all_button_updates(state)
@@ -645,13 +720,24 @@ def pause_simulation():
         gr.update(interactive=True),   # start btn (can resume)
         gr.update(interactive=False),  # pause btn
         render_status_html(state),
-    ] + updates + [True]
+    ] + updates + [True, service, display_cache]
 
 
-def reset_simulation(fire_count: int, fire_intensity: float, building_count: int, max_units: int, seed: Optional[int], session_token: Optional[str]):
+def reset_simulation(
+    fire_count: int,
+    fire_intensity: float,
+    building_count: int,
+    max_units: int,
+    seed: Optional[int],
+    session_token: Optional[str],
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
+):
     """Handle Reset button click."""
-    service = get_service()
-    _reset_advisor_display_cache()
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
+    display_cache = _reset_advisor_display_cache(display_cache)
     # Always generate fresh token on reset to ensure clean state
     new_token = _generate_session_token()
     actual_seed = int(seed) if seed and seed > 0 else None
@@ -675,12 +761,30 @@ def reset_simulation(fire_count: int, fire_intensity: float, building_count: int
         gr.update(interactive=True),
         gr.update(interactive=False),
         render_status_html(state),
-    ] + updates + [False, new_token]
+    ] + updates + [False, new_token, service, display_cache]
 
 
-def deploy_at_cell(x: int, y: int, selection: str):
+def prepare_reset(
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
+):
+    """Clean up the current service instance before reloading."""
+    if service:
+        service.shutdown()
+    return None, None
+
+
+def deploy_at_cell(
+    x: int,
+    y: int,
+    selection: str,
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
+):
     """Deploy unit or fire at specific cell, or remove if unit already exists there."""
-    service = get_service()
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
     
     # Get thinking state
     is_thinking = service.is_thinking()
@@ -730,12 +834,12 @@ def deploy_at_cell(x: int, y: int, selection: str):
         _get_combined_advisor_messages(service),
         service.get_event_log_text(),
         render_status_html(state, is_thinking, thinking_stage),
-    ] + updates
+    ] + updates + [service, display_cache]
 
 
-def poll_after_action_report():
+def poll_after_action_report(service: Optional[SimulationService]):
     """Poll after-action report status independently of the main simulation timer."""
-    service = get_service()
+    service = get_or_create_service(service)
     state = service.get_state()
     status = state.get("status", "idle")
     report_payload = state.get("after_action_report")
@@ -748,6 +852,7 @@ def poll_after_action_report():
     return [
         report_timer_update,
         render_game_result(status, report_payload),
+        service,
     ]
 
 
@@ -761,30 +866,17 @@ def get_all_button_updates(state: dict) -> list:
     return updates
 
 
-# Cache for preventing unnecessary UI updates (flicker prevention)
-_last_status_html = None
-_last_advisor_signature = ()
-_history_messages_cache: list[dict] = []
-_current_cycle_messages_cache: list[dict] = []
-_result_freeze_state = ""
-
-
-def _reset_advisor_display_cache():
-    """Clear cached advisor/chatbot renders (prevents stale history after reset)."""
-    global _last_advisor_signature, _history_messages_cache, _current_cycle_messages_cache, _last_status_html, _result_freeze_state
-    _last_advisor_signature = ()
-    _history_messages_cache = []
-    _current_cycle_messages_cache = []
-    _last_status_html = None
-    _result_freeze_state = ""
-
-
-def refresh_display():
+def refresh_display(
+    service: Optional[SimulationService],
+    display_cache: Optional[dict],
+):
     """
     Single timer refresh (every 1 second).
     Uses unified change tracking to update only changed components.
     """
-    service = get_service()
+    service = get_or_create_service(service)
+    if display_cache is None:
+        display_cache = _create_display_cache()
     
     # Get all changes in one call
     changes = service.get_changed_components()
@@ -798,17 +890,13 @@ def refresh_display():
     thinking_stage = service.get_thinking_stage()
     
     # Freeze background UI once a win/lose overlay has already been shown
-    global _result_freeze_state
-    overlay_outcome = status if status in ["success", "fail"] else ""
-    freeze_background = False
-    if overlay_outcome:
-        if _result_freeze_state == overlay_outcome:
-            freeze_background = True
-        else:
-            _result_freeze_state = overlay_outcome
-    else:
-        if _result_freeze_state:
-            _result_freeze_state = ""
+    overlay_state = changes.get("result_state", "")
+    freeze_background = bool(overlay_state)
+    if freeze_background:
+        if display_cache["result_freeze_state"] != overlay_state:
+            display_cache["result_freeze_state"] = overlay_state
+    elif display_cache["result_freeze_state"]:
+        display_cache["result_freeze_state"] = ""
     
     # Timer control - stop when game ends
     timer_update = gr.update()
@@ -832,19 +920,20 @@ def refresh_display():
         advisor_display = gr.skip()
     else:
         # Advisor display (chatbot) showing combined history + current cycle
-        global _last_advisor_signature, _history_messages_cache, _current_cycle_messages_cache
         if changes["history_changed"]:
             history_messages = changes.get("advisor_history")
             if history_messages is not None:
-                _history_messages_cache = history_messages
+                display_cache["history_messages_cache"] = history_messages
         current_cycle_messages = changes.get("advisor_messages")
         if current_cycle_messages is not None:
-            _current_cycle_messages_cache = current_cycle_messages
-        combined_messages = (_history_messages_cache or []) + (_current_cycle_messages_cache or [])
+            display_cache["current_cycle_messages_cache"] = current_cycle_messages
+        combined_messages = (display_cache["history_messages_cache"] or []) + (
+            display_cache["current_cycle_messages_cache"] or []
+        )
         if combined_messages:
             signature = _chat_signature(combined_messages)
-            if signature != _last_advisor_signature:
-                _last_advisor_signature = signature
+            if signature != display_cache["last_advisor_signature"]:
+                display_cache["last_advisor_signature"] = signature
                 advisor_display = gr.update(value=combined_messages)
             else:
                 advisor_display = gr.skip()
@@ -856,11 +945,12 @@ def refresh_display():
         event_log = gr.update()
     else:
         event_log = changes["event_log"] if changes["event_log_changed"] else gr.update()
+
     
     # Buttons - only when state changes
     if freeze_background:
-        start_btn_update = gr.update()
-        pause_btn_update = gr.update()
+        start_btn_update = gr.update(interactive=True)
+        pause_btn_update = gr.update(interactive=False)
     else:
         if changes["buttons_changed"]:
             start_enabled, pause_enabled = changes["button_states"]
@@ -871,15 +961,14 @@ def refresh_display():
             pause_btn_update = gr.update()
     
     # Status bar - use cache to prevent flicker (only update when content changes)
-    global _last_status_html
     if freeze_background:
         status_html_update = gr.skip()
     else:
         new_status_html = render_status_html(state, is_thinking, thinking_stage)
-        if new_status_html == _last_status_html:
+        if new_status_html == display_cache["last_status_html"]:
             status_html_update = gr.skip()
         else:
-            _last_status_html = new_status_html
+            display_cache["last_status_html"] = new_status_html
             status_html_update = new_status_html
     
     # Grid buttons - only update if changed
@@ -900,7 +989,7 @@ def refresh_display():
         start_btn_update,
         pause_btn_update,
         status_html_update,
-    ] + updates
+    ] + updates + [service, display_cache]
 
 
 # =============================================================================
@@ -1738,6 +1827,8 @@ def create_app() -> gr.Blocks:
         gr.HTML(f"<style>{CUSTOM_CSS}</style>")
         session_resume_state = gr.State(False)
         session_token_state = gr.State("")
+        service_state = gr.State(None)
+        display_cache_state = gr.State(None)
         
         # Header with title and instructions
         gr.Markdown("# 🔥 Fire Rescue Simulator Game")
@@ -1803,18 +1894,28 @@ def create_app() -> gr.Blocks:
         with gr.Row(elem_classes=["section-gap"]):
             # Left column: AI Advisor - THE STAR OF THE SHOW
             with gr.Column(scale=2, min_width=300):
-                service = get_service()
-                advisor_interval_ticks = getattr(service, "advisor_interval", 10)
+                advisor_interval_ticks = 10
                 gr.Markdown(
                     f"## 🤖 AI Tactical Advisor · (refreshes every {advisor_interval_ticks} ticks)"
                 )
+                model_selector = gr.Dropdown(
+                    label="🧠 Advisor Model Source",
+                    choices=ADVISOR_MODEL_LABELS,
+                    value=DEFAULT_ADVISOR_MODEL_CHOICE,
+                    interactive=True,
+                )
                 auto_execute_toggle = gr.Checkbox(
                     label="🎮 Auto-Execute",
                     value=AUTO_EXECUTE_DEFAULT,
                     info="Automatically execute AI recommendations",
                 )
                 
-                advisor_initial_messages = _get_combined_advisor_messages(service)
+                advisor_initial_messages = [
+                    {
+                        "role": "assistant",
+                        "content": "No AI analysis yet. Press **Start** to begin the advisor cycle.",
+                    }
+                ]
                 
                 with gr.Accordion("📜 AI Analysis History", open=True):
                     gr.Markdown(
@@ -1908,75 +2009,117 @@ def create_app() -> gr.Blocks:
         # Event handlers for simulation controls
         start_btn.click(
             fn=start_or_resume_simulation,
-            inputs=[fire_count, fire_intensity, building_count, max_units, seed_input, session_resume_state, session_token_state],
-            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display] + all_buttons + [session_resume_state, session_token_state]
+            inputs=[
+                fire_count,
+                fire_intensity,
+                building_count,
+                max_units,
+                seed_input,
+                session_resume_state,
+                session_token_state,
+                service_state,
+                display_cache_state,
+            ],
+            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display]
+            + all_buttons
+            + [session_resume_state, session_token_state, service_state, display_cache_state],
         )
         
         pause_btn.click(
             fn=pause_simulation,
-            inputs=[],
-            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display] + all_buttons + [session_resume_state]
+            inputs=[service_state, display_cache_state],
+            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display]
+            + all_buttons
+            + [session_resume_state, service_state, display_cache_state],
         )
         
         reset_btn.click(
-            fn=reset_simulation,
-            inputs=[fire_count, fire_intensity, building_count, max_units, seed_input, session_token_state],
-            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display] + all_buttons + [session_resume_state, session_token_state]
+            fn=prepare_reset,
+            inputs=[service_state, display_cache_state],
+            outputs=[service_state, display_cache_state],
+            queue=False,
+            js="() => { window.location.reload(); return []; }",
         )
         
         # Event handlers for grid buttons (click to place)
         for x, y, btn in grid_buttons:
             btn.click(
-                fn=lambda sel, _x=x, _y=y: deploy_at_cell(_x, _y, sel),
-                inputs=[place_selector],
-                outputs=[result_popup, advisor_display, event_log_display, status_display] + all_buttons
+                fn=lambda sel, _x=x, _y=y, svc=None, cache=None: deploy_at_cell(_x, _y, sel, svc, cache),
+                inputs=[place_selector, service_state, display_cache_state],
+                outputs=[result_popup, advisor_display, event_log_display, status_display] + all_buttons + [service_state, display_cache_state],
             )
         
         # Timer tick handler - updates all components with change tracking
         timer.tick(
             fn=refresh_display,
-            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display] + all_buttons
+            inputs=[service_state, display_cache_state],
+            outputs=[timer, report_timer, result_popup, advisor_display, event_log_display, start_btn, pause_btn, status_display]
+            + all_buttons
+            + [service_state, display_cache_state],
         )
         
         report_timer.tick(
             fn=poll_after_action_report,
-            outputs=[report_timer, result_popup]
+            inputs=[service_state],
+            outputs=[report_timer, result_popup, service_state],
         )
         
         # Auto-execute toggle handler
-        def on_auto_execute_toggle(enabled: bool):
-            service = get_service()
+        def on_auto_execute_toggle(enabled: bool, service: Optional[SimulationService]):
+            service = get_or_create_service(service)
             service.set_auto_execute(enabled)
-            # No return value needed since outputs=[]
+            return service
+        
+        def on_model_choice_change(selection: str, service: Optional[SimulationService]):
+            service = get_or_create_service(service)
+            result = service.set_advisor_model_choice(selection)
+            if result.get("status") != "ok":
+                raise gr.Error(result.get("message", "Failed to switch advisor model"))
+            return service
         
         auto_execute_toggle.change(
             fn=on_auto_execute_toggle,
-            inputs=[auto_execute_toggle],
-            outputs=[]
+            inputs=[auto_execute_toggle, service_state],
+            outputs=[service_state],
         )
         
+        model_selector.change(
+            fn=on_model_choice_change,
+            inputs=[model_selector, service_state],
+            outputs=[service_state],
+        )
         app.load(
             fn=_initialize_session_defaults,
-            inputs=None,
-            outputs=[auto_execute_toggle, session_resume_state, session_token_state],
+            inputs=[service_state, display_cache_state],
+            outputs=[
+                auto_execute_toggle,
+                session_resume_state,
+                session_token_state,
+                model_selector,
+                service_state,
+                display_cache_state,
+                advisor_display,
+                event_log_display,
+                status_display,
+            ]
+            + all_buttons,
         )
     
     return app
 
 
+demo = create_app()
+
+
 def launch_simple():
     """Launch simple Gradio app (for HF Spaces / local development)."""
-    gradio_app = create_app()
-    gradio_app.launch(
+    demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        ssr_mode=False,  # Disable SSR for better compatibility
+        ssr_mode=False,  # Disable SSR for better compatibility,
+        mcp_server=True,
         footer_links=["gradio", "settings"],  # Hide API docs button
     )
 
-
-# For Hugging Face Spaces - must be named 'demo' for HF Spaces auto-detection
-demo = create_app()
-
 if __name__ == "__main__":
     launch_simple()

fire_rescue_mcp/mcp_client.py

@@ -0,0 +1,114 @@
+"""
+Local FastMCP client used by the Gradio simulator service.
+
+This module provides a lightweight in-process client that routes every request
+through the registered FastMCP server instance so the application can rely on
+actual MCP tool invocations (and capture request/response telemetry) instead
+of calling helper functions directly.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+from copy import deepcopy
+from datetime import datetime
+from typing import Any, Callable, Sequence
+
+import anyio
+
+from mcp.types import ContentBlock
+
+
+class LocalFastMCPClient:
+    """Synchronous helper that forwards calls to a FastMCP server instance."""
+
+    def __init__(self, server, log_callback: Callable[[dict[str, Any]], None] | None = None):
+        self._server = server
+        self._log_callback = log_callback
+        self._lock = threading.Lock()
+
+    def list_tools(self) -> Any:
+        """Expose server tool metadata (used for debugging/tests)."""
+
+        async def _list_tools():
+            return await self._server.list_tools()
+
+        with self._lock:
+            return anyio.run(_list_tools)
+
+    def call_tool(self, name: str, **arguments: Any) -> dict[str, Any]:
+        """Invoke an MCP tool and return a normalized dict response."""
+        clean_args = {k: v for k, v in arguments.items() if v is not None}
+        start = time.perf_counter()
+
+        async def _call():
+            return await self._server.call_tool(name, clean_args)
+
+        with self._lock:
+            raw_result = anyio.run(_call)
+
+        normalized = self._normalize_result(raw_result)
+        self._log(name, clean_args, normalized, start)
+        return normalized
+
+    # --------------------------------------------------------------------- #
+    # Internal utilities
+    # --------------------------------------------------------------------- #
+    def _normalize_result(self, result: Any) -> dict[str, Any]:
+        """Convert FastMCP responses into standard dicts for easier handling."""
+        if isinstance(result, dict):
+            return result
+        if isinstance(result, Sequence):
+            parsed = self._maybe_parse_json_from_blocks(result)
+            if parsed is not None:
+                return parsed
+            blocks: list[dict[str, Any]] = []
+            for block in result:
+                if isinstance(block, ContentBlock):
+                    blocks.append(block.model_dump(mode="json"))
+                elif hasattr(block, "model_dump"):
+                    blocks.append(block.model_dump(mode="json"))
+                else:
+                    blocks.append({"type": "text", "text": str(block)})
+            return {"status": "ok", "content": blocks}
+        return {"status": "ok", "data": deepcopy(result)}
+
+    def _maybe_parse_json_from_blocks(self, blocks: Sequence[Any]) -> dict[str, Any] | None:
+        """If the MCP server returned a single text block containing JSON, parse it."""
+        if not blocks:
+            return None
+        first = blocks[0]
+        text = None
+        if isinstance(first, ContentBlock) and getattr(first, "type", None) == "text":
+            text = first.model_dump().get("text")
+        elif hasattr(first, "text"):
+            text = getattr(first, "text")
+        elif isinstance(first, dict) and first.get("type") == "text":
+            text = first.get("text")
+        if text is None:
+            return None
+        stripped = text.strip()
+        if not stripped or stripped[0] not in "{[":
+            return None
+        try:
+            return json.loads(stripped)
+        except json.JSONDecodeError:
+            return None
+
+    def _log(self, name: str, arguments: dict[str, Any], result: dict[str, Any], start: float) -> None:
+        """Send invocation metadata to the optional callback."""
+        if not self._log_callback:
+            return
+        duration_ms = round((time.perf_counter() - start) * 1000, 1)
+        entry = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "tool": name,
+            "arguments": deepcopy(arguments),
+            "result": deepcopy(result),
+            "duration_ms": duration_ms,
+        }
+        self._log_callback(entry)
+
+

fire_rescue_mcp/mcp_server.py

@@ -19,6 +19,7 @@ Data Query Tools:
 """
 
 import sys
+import threading
 from pathlib import Path
 from typing import Optional
 
@@ -33,20 +34,40 @@ from simulation import SimulationEngine, SimulationConfig
 # Create FastMCP server instance
 mcp = FastMCP("Fire-Rescue Simulation")
 
-# Shared simulation engine instance
-_engine: Optional[SimulationEngine] = None
+# Shared simulation engines keyed by session_id
+_engines: dict[str, SimulationEngine] = {}
+_engine_lock = threading.RLock()
+
+
+def attach_engine(engine: SimulationEngine, session_id: str) -> None:
+    """Allow external callers to reuse their engine inside the MCP server."""
+    if not session_id:
+        raise ValueError("session_id is required to attach engine")
+    with _engine_lock:
+        _engines[session_id] = engine
 
 # Unit effective ranges (matching SimulationConfig, Chebyshev/square distance)
 FIRE_TRUCK_RANGE = 1  # Square coverage radius (includes 8 neighbors)
 HELICOPTER_RANGE = 2  # Square coverage radius (extends two cells in all directions)
 
 
-def get_engine() -> SimulationEngine:
-    """Get or create the simulation engine singleton."""
-    global _engine
-    if _engine is None:
-        _engine = SimulationEngine()
-    return _engine
+def detach_engine(session_id: str) -> None:
+    """Remove engine mapping for a session (best-effort)."""
+    if not session_id:
+        return
+    with _engine_lock:
+        _engines.pop(session_id, None)
+
+
+def get_engine(session_id: Optional[str]) -> SimulationEngine:
+    """Get the simulation engine for a specific session."""
+    if not session_id:
+        raise ValueError("session_id is required")
+    with _engine_lock:
+        engine = _engines.get(session_id)
+    if engine is None:
+        raise ValueError(f"No simulation engine attached for session '{session_id}'")
+    return engine
 
 
 def _get_unit_effective_range(unit_type: str) -> int:
@@ -137,13 +158,22 @@ def generate_emoji_map(engine: SimulationEngine) -> str:
     return "\n".join(lines)
 
 
+def _resolve_engine(session_id: Optional[str]):
+    """Return (engine, error_dict) tuple for tool handlers."""
+    try:
+        return get_engine(session_id), None
+    except ValueError as exc:
+        return None, {"status": "error", "message": str(exc)}
+
+
 @mcp.tool()
 def reset_scenario(
     seed: Optional[int] = None,
     fire_count: int = 10,
     fire_intensity: float = 0.5,
     building_count: int = 20,
-    max_units: int = 10
+    max_units: int = 10,
+    session_id: Optional[str] = None,
 ) -> dict:
     """
     Reset and initialize a new fire rescue simulation scenario.
@@ -158,7 +188,9 @@ def reset_scenario(
     Returns:
         Status, summary, and emoji map of the initial state
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     world = engine.reset(
         seed=seed, 
@@ -182,7 +214,7 @@ def reset_scenario(
 
 
 @mcp.tool()
-def get_world_state() -> dict:
+def get_world_state(session_id: Optional[str] = None) -> dict:
     """
     Get the current world state snapshot with emoji map visualization.
     
@@ -198,7 +230,9 @@ def get_world_state() -> dict:
     🌲 Forest | 🏢 Building | 🔥 Fire (>=10%) | 💨 Smoke (<10%)
     🚒 Fire Truck | 🚁 Helicopter
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -217,7 +251,8 @@ def deploy_unit(
     unit_type: str,
     x: int,
     y: int,
-    source: str = "player"
+    source: str = "player",
+    session_id: Optional[str] = None,
 ) -> dict:
     """
     Deploy a firefighting unit at the specified position.
@@ -231,12 +266,14 @@ def deploy_unit(
     Returns:
         Status and details of the deployed unit
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     return engine.deploy_unit(unit_type, x, y, source)
 
 
 @mcp.tool()
-def step_simulation(ticks: int = 1) -> dict:
+def step_simulation(ticks: int = 1, session_id: Optional[str] = None) -> dict:
     """
     Advance the simulation by the specified number of ticks.
     
@@ -246,7 +283,9 @@ def step_simulation(ticks: int = 1) -> dict:
     Returns:
         Current world state with emoji map after advancing
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -268,7 +307,8 @@ def move_unit(
     source_x: int,
     source_y: int,
     target_x: int,
-    target_y: int
+    target_y: int,
+    session_id: Optional[str] = None,
 ) -> dict:
     """
     Move an existing unit from source position to target position.
@@ -283,7 +323,9 @@ def move_unit(
     Returns:
         Status and details of the move operation
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -336,7 +378,8 @@ def move_unit(
 @mcp.tool()
 def remove_unit(
     x: int,
-    y: int
+    y: int,
+    session_id: Optional[str] = None,
 ) -> dict:
     """
     Remove an existing unit at the specified position.
@@ -354,7 +397,9 @@ def remove_unit(
     - Free up deployment slot when unit is no longer needed
     - Reposition unit: remove_unit + deploy_unit at new location
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -394,7 +439,7 @@ def remove_unit(
 
 
 @mcp.tool()
-def find_idle_units() -> dict:
+def find_idle_units(session_id: Optional[str] = None) -> dict:
     """
     Find units that are not covering any fires (idle/ineffective units).
     
@@ -405,7 +450,9 @@ def find_idle_units() -> dict:
     Returns:
         List of idle units and effective units with their positions
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -453,7 +500,7 @@ def find_idle_units() -> dict:
 
 
 @mcp.tool()
-def find_uncovered_fires() -> dict:
+def find_uncovered_fires(session_id: Optional[str] = None) -> dict:
     """
     Find fires that have NO unit coverage.
     
@@ -464,7 +511,9 @@ def find_uncovered_fires() -> dict:
     Returns:
         List of uncovered fires with their positions, intensity, and building threat status
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -521,14 +570,16 @@ def find_uncovered_fires() -> dict:
 
 
 @mcp.tool()
-def find_building_threats() -> dict:
+def find_building_threats(session_id: Optional[str] = None) -> dict:
     """
     Find fires that are threatening buildings (within 2 cells of any building).
     
     Returns:
         List of building-threatening fires with their positions, threatened buildings, and coverage status
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {
@@ -583,7 +634,7 @@ def find_building_threats() -> dict:
 
 
 @mcp.tool()
-def analyze_coverage() -> dict:
+def analyze_coverage(session_id: Optional[str] = None) -> dict:
     """
     Get comprehensive coverage analysis data.
     
@@ -596,7 +647,9 @@ def analyze_coverage() -> dict:
     Returns:
         Comprehensive data about fires, units, and coverage status
     """
-    engine = get_engine()
+    engine, error = _resolve_engine(session_id)
+    if error:
+        return error
     
     if engine.world is None:
         return {

service.py

@@ -9,11 +9,12 @@ import asyncio
 import concurrent.futures
 import html
 import json
+import os
 import threading
 import time
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
 from agent import (
     AdvisorAgent,
@@ -23,10 +24,38 @@ from agent import (
     PlanResult,
     CycleSummary,
 )
+from fire_rescue_mcp.mcp_client import LocalFastMCPClient
+from fire_rescue_mcp.mcp_server import attach_engine, detach_engine, mcp as fastmcp_server
 from models import SimulationStatus, CellType
 from simulation import SimulationEngine
 
 
+ADVISOR_MODEL_CHOICES = {
+    "GPT-OSS · HuggingFace (openai/gpt-oss-120b)": {
+        "provider": "hf",
+        "model": "openai/gpt-oss-120b",
+        "description": "Default OSS advisor routed through HuggingFace Inference",
+    },
+    "GPT-OSS-20B · HuggingFace (openai/gpt-oss-20b)": {
+        "provider": "hf",
+        "model": "openai/gpt-oss-20b",
+        "description": "OpenAI GPT-OSS 20B model via HuggingFace Inference",
+    },
+    "Llama-3.1 · HuggingFace (meta-llama/Llama-3.1-8B-Instruct)": {
+        "provider": "hf",
+        "model": "meta-llama/Llama-3.1-8B-Instruct",
+        "description": "Meta Llama-3.1 8B Instruct model via HuggingFace Inference",
+    },
+    "OpenAI · gpt-5.1": {
+        "provider": "openai",
+        "model": "gpt-5.1",
+        "description": "Flagship GPT-5.1 via native OpenAI API",
+    },
+}
+
+DEFAULT_ADVISOR_MODEL_CHOICE = "GPT-OSS · HuggingFace (openai/gpt-oss-120b)"
+
+
 def generate_emoji_map(engine: SimulationEngine) -> str:
     """
     Generate an emoji-based visualization of the current world state.
@@ -124,7 +153,7 @@ class SimulationService:
     # Runtime state
     _running: bool = False
     _thread: Optional[threading.Thread] = None
-    _lock: threading.Lock = field(default_factory=threading.Lock)
+    _lock: threading.RLock = field(default_factory=threading.RLock)
     
     # Logs and recommendations
     _logs: list[LogEntry] = field(default_factory=list)
@@ -144,6 +173,12 @@ class SimulationService:
     _threat_history: list[dict] = field(default_factory=list)
     _action_history: list[dict] = field(default_factory=list)
     _player_actions: list[dict] = field(default_factory=list)
+
+    # MCP integration
+    _mcp_client: LocalFastMCPClient | None = None
+    _mcp_call_log: list[dict] = field(default_factory=list)
+    _mcp_log_dirty: bool = False
+    _last_mcp_log: str = ""
     
     # Advisor call control
     _advisor_running: bool = False  # Prevent concurrent advisor calls
@@ -163,6 +198,8 @@ class SimulationService:
     _auto_execute: bool = True      # Whether to automatically execute AI recommendations
     _executed_recommendations: set = field(default_factory=set)  # Track executed recommendations
     _session_owner_id: str = ""
+    _attached_session_id: str = ""
+    _model_choice: str = DEFAULT_ADVISOR_MODEL_CHOICE
     
     # Simulation loop state (preserved across pause/resume)
     _tick_count: int = 0            # Current tick count in simulation loop
@@ -177,7 +214,7 @@ class SimulationService:
     _last_result_state: str = ""        # Last result popup state ("", "success", "fail")
     
     def __post_init__(self):
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
         self._logs = []
         self._result_shown = False
         self._result_dismissed = False
@@ -204,6 +241,10 @@ class SimulationService:
         self._last_event_log = ""
         self._last_button_states = (True, False)
         self._last_result_state = ""
+        self._mcp_client = LocalFastMCPClient(fastmcp_server, self._record_mcp_call)
+        self._mcp_call_log = []
+        self._mcp_log_dirty = False
+        self._last_mcp_log = ""
     
     def start(
         self, 
@@ -591,6 +632,32 @@ class SimulationService:
             "markdown": markdown,
         }
 
+    def _record_mcp_call(self, entry: dict[str, Any]) -> None:
+        """Capture MCP tool invocations for UI display."""
+        with self._lock:
+            cloned = dict(entry)
+            cloned.setdefault("local_timestamp", datetime.now().strftime("%H:%M:%S"))
+            self._mcp_call_log.append(cloned)
+            if len(self._mcp_call_log) > 80:
+                self._mcp_call_log = self._mcp_call_log[-80:]
+            self._mcp_log_dirty = True
+
+    def _get_mcp_log_text_locked(self, limit: int = 20) -> str:
+        """Format MCP tool logs for UI display."""
+        if not self._mcp_call_log:
+            return "No MCP tool calls yet..."
+        lines = []
+        for entry in self._mcp_call_log[-limit:]:
+            ts = entry.get("local_timestamp", entry.get("timestamp", ""))
+            tool = entry.get("tool", "unknown")
+            args = entry.get("arguments", {})
+            args_preview = ", ".join(f"{k}={v}" for k, v in list(args.items())[:3])
+            result = entry.get("result", {})
+            status = result.get("status", "ok") if isinstance(result, dict) else "ok"
+            duration = entry.get("duration_ms", 0)
+            lines.append(f"[{ts}] {tool}({args_preview}) → {status} ({duration} ms)")
+        return "\n".join(lines)
+
     def _get_after_action_report_payload_locked(self) -> dict:
         """Serialize after-action report state for UI consumption."""
         payload: dict = {"status": self._result_report_status}
@@ -599,6 +666,58 @@ class SimulationService:
         elif self._result_report_status == "error":
             payload["error"] = self._result_report_error or "Unknown error"
         return payload
+
+    def _call_mcp_tool(self, name: str, **kwargs: Any) -> dict[str, Any]:
+        """Invoke a tool through the shared FastMCP client."""
+        session_id = self._session_owner_id or "default"
+        if not self._mcp_client:
+            self._mcp_client = LocalFastMCPClient(fastmcp_server, self._record_mcp_call)
+        if self._attached_session_id and self._attached_session_id != session_id:
+            detach_engine(self._attached_session_id)
+            self._attached_session_id = ""
+        if self._attached_session_id != session_id:
+            attach_engine(self.engine, session_id)
+            self._attached_session_id = session_id
+        try:
+            call_kwargs = dict(kwargs)
+            call_kwargs["session_id"] = session_id
+            return self._mcp_client.call_tool(name, **call_kwargs)
+        except Exception as exc:  # pragma: no cover
+            self._add_log("error", f"MCP tool {name} failed: {exc}")
+            return {"status": "error", "message": str(exc)}
+
+    def shutdown(self) -> None:
+        """Stop background threads and detach from MCP server."""
+        thread = None
+        with self._lock:
+            if self._running:
+                self._running = False
+                thread = self._thread
+                self._thread = None
+        if thread and thread.is_alive():
+            thread.join(timeout=2.0)
+        with self._lock:
+            if self._attached_session_id:
+                detach_engine(self._attached_session_id)
+                self._attached_session_id = ""
+            self._session_owner_id = ""
+            self._on_update = None
+
+    def _get_mcp_world_state(self) -> dict:
+        """Fetch world state via the MCP tools with local fallback."""
+        state = self._call_mcp_tool("get_world_state")
+        if not isinstance(state, dict) or state.get("status") == "error":
+            state = self.engine.get_state()
+
+        def _maybe(name: str) -> dict[str, Any]:
+            data = self._call_mcp_tool(name)
+            return data if isinstance(data, dict) else {}
+
+        state["mcp_idle_units"] = _maybe("find_idle_units")
+        state["mcp_uncovered_fires"] = _maybe("find_uncovered_fires")
+        state["mcp_building_threats"] = _maybe("find_building_threats")
+        state["mcp_coverage"] = _maybe("analyze_coverage")
+        return state
     
     def should_show_result(self) -> tuple[bool, bool]:
         """
@@ -782,6 +901,11 @@ class SimulationService:
                 else:
                     lines.append(f"[Tick {log.tick}] {log.message}")
             return "\n".join(lines)
+
+    def get_mcp_log_text(self, limit: int = 20) -> str:
+        """Expose MCP call history."""
+        with self._lock:
+            return self._get_mcp_log_text_locked(limit)
     
     def get_advisor_text(self, limit: int = 5) -> str:
         """Get AI advisor display with rich reasoning (legacy text format)."""
@@ -1120,6 +1244,17 @@ class SimulationService:
             result["event_log"] = event_log if result["event_log_changed"] else None
             if result["event_log_changed"]:
                 self._last_event_log = event_log
+
+            # 3b. MCP tool log
+            if self._mcp_log_dirty:
+                mcp_log = self._get_mcp_log_text_locked()
+                result["mcp_log_changed"] = True
+                result["mcp_log"] = mcp_log
+                self._last_mcp_log = mcp_log
+                self._mcp_log_dirty = False
+            else:
+                result["mcp_log_changed"] = False
+                result["mcp_log"] = None
             
             # 4. Button states
             status = state.get("status", "idle")
@@ -1181,6 +1316,8 @@ class SimulationService:
             "advisor_history": ui["advisor_history"],
             "event_log_changed": ui["event_log_changed"],
             "event_log": ui["event_log"],
+            "mcp_log_changed": ui["mcp_log_changed"],
+            "mcp_log": ui["mcp_log"],
             "buttons_changed": ui["buttons_changed"],
             "button_states": ui["button_states"],
             "result_changed": ui["result_changed"],
@@ -1266,7 +1403,7 @@ class SimulationService:
     def deploy_unit(self, unit_type: str, x: int, y: int, source: str = "player") -> dict:
         """Deploy a unit (thread-safe)."""
         with self._lock:
-            result = self.engine.deploy_unit(unit_type, x, y, source)
+            result = self._call_mcp_tool("deploy_unit", unit_type=unit_type, x=x, y=y, source=source)
             
             if result.get("status") == "ok":
                 self._add_log(
@@ -1292,7 +1429,7 @@ class SimulationService:
     def remove_unit(self, x: int, y: int) -> dict:
         """Remove a unit at position (thread-safe)."""
         with self._lock:
-            result = self.engine.remove_unit_at(x, y)
+            result = self._call_mcp_tool("remove_unit", x=x, y=y)
             
             if result.get("status") == "ok":
                 self._add_log(
@@ -1300,8 +1437,11 @@ class SimulationService:
                     f"Removed unit at ({x}, {y})",
                     {"unit": result.get("unit")}
                 )
-                removed_unit = result.get("unit") or {}
-                unit_type = removed_unit.get("type", "")
+                removed_unit = result.get("unit") or {
+                    "type": result.get("removed_unit_type"),
+                    **(result.get("position") or {"x": x, "y": y}),
+                }
+                unit_type = removed_unit.get("type") or result.get("removed_unit_type", "")
                 unit_label = (
                     "fire truck"
                     if unit_type == "fire_truck"
@@ -1385,6 +1525,50 @@ class SimulationService:
         """Check if auto-execute is enabled."""
         return self._auto_execute
     
+    def get_advisor_model_choice(self) -> str:
+        """Return the currently selected advisor model label."""
+        with self._lock:
+            return self._model_choice
+    
+    def set_advisor_model_choice(self, choice: str) -> dict:
+        """
+        Switch the advisor backend/model based on UI selection.
+        Returns status dict usable by the UI for feedback.
+        """
+        preset = ADVISOR_MODEL_CHOICES.get(choice)
+        if not preset:
+            return {"status": "error", "message": "Unknown model selection."}
+        
+        if preset["provider"] == "openai" and not os.getenv("OPENAI_API_KEY"):
+            return {
+                "status": "error",
+                "message": "Please set OPENAI_API_KEY before selecting an OpenAI model.",
+            }
+        
+        with self._lock:
+            self.advisor = AdvisorAgent(
+                provider=preset["provider"],
+                model=preset["model"],
+            )
+            self._model_choice = choice
+            self._add_log("status", f"Advisor model switched to {choice}")
+        
+        return {"status": "ok", "selection": choice}
+    
+    def reset_advisor_model_choice(self) -> str:
+        """Reset advisor selection back to the default preset."""
+        default_choice = DEFAULT_ADVISOR_MODEL_CHOICE
+        preset = ADVISOR_MODEL_CHOICES[default_choice]
+        with self._lock:
+            self.advisor = AdvisorAgent(
+                provider=preset["provider"],
+                model=preset["model"],
+            )
+            self._model_choice = default_choice
+            self._advisor_first_run = True
+            self._add_log("status", f"Advisor model reset to {default_choice}")
+        return default_choice
+    
     def is_thinking(self) -> bool:
         """Check if AI advisor is currently thinking."""
         return self._is_thinking
@@ -1408,8 +1592,7 @@ class SimulationService:
                     # Run advisor immediately on first tick (only once per simulation)
                     if self._advisor_first_run:
                         self._advisor_first_run = False
-                        state = self.engine.get_state()
-                        self._run_advisor(state)
+                        self._run_advisor(self._get_mcp_world_state())
                     
                     # Advance simulation
                     self.engine.step()
@@ -1431,7 +1614,7 @@ class SimulationService:
                     else:
                         # Periodic advisor evaluation (every advisor_interval ticks)
                         if self._tick_count % self.advisor_interval == 0:
-                            self._run_advisor(state)
+                            self._run_advisor(self._get_mcp_world_state())
                         
                         # Notify UI
                         if self._on_update:
@@ -1902,87 +2085,81 @@ mcp.deploy_unit(
         """Execute AI recommendations (must be called with lock held)."""
         executed_count = 0
         for rec in response.recommendations:
-            # Create unique key for this recommendation
-            action = getattr(rec, 'action', 'deploy')
+            action = getattr(rec, "action", "deploy")
             rec_key = f"{tick}_{action}_{rec.suggested_unit_type}_{rec.target_x}_{rec.target_y}"
-            
-            # Skip if already executed
+
             if rec_key in self._executed_recommendations:
                 continue
-            
+
             if action == "move":
-                # Move action: remove from source, deploy at target
-                source_x = getattr(rec, 'source_x', -1)
-                source_y = getattr(rec, 'source_y', -1)
-                
-                if source_x >= 0 and source_y >= 0:
-                    # First remove the unit from source
-                    remove_result = self.engine.remove_unit_at(source_x, source_y)
-                    
-                    if remove_result.get("status") == "ok":
-                        # Then deploy at target
-                        deploy_result = self.engine.deploy_unit(rec.suggested_unit_type, rec.target_x, rec.target_y, "ai")
-                        
-                        if deploy_result.get("status") == "ok":
-                            executed_count += 1
-                            unit_name = "Fire Truck" if rec.suggested_unit_type == "fire_truck" else "Helicopter"
-                            self._add_log(
-                                "deploy",
-                                f"🤖 AI moved {unit_name}: ({source_x},{source_y}) → ({rec.target_x},{rec.target_y})",
-                                {"unit": deploy_result.get("unit"), "source": "ai", "reason": rec.reason, "action": "move"}
-                            )
-                            self._executed_recommendations.add(rec_key)
-                        else:
-                            # Deploy failed, try to restore the removed unit
-                            self.engine.deploy_unit(rec.suggested_unit_type, source_x, source_y, "ai")
-                            self._add_log(
-                                "error",
-                                f"🤖 AI move failed: {deploy_result.get('message')} - restored unit at ({source_x},{source_y})"
-                            )
-                    else:
-                        self._add_log(
-                            "error",
-                            f"🤖 AI move failed: No unit at source ({source_x},{source_y})"
-                        )
+                source_x = getattr(rec, "source_x", -1)
+                source_y = getattr(rec, "source_y", -1)
+                if source_x < 0 or source_y < 0:
+                    self._add_log("error", f"🤖 AI move failed: missing source ({source_x},{source_y})")
+                    continue
+                result = self._call_mcp_tool(
+                    "move_unit",
+                    source_x=source_x,
+                    source_y=source_y,
+                    target_x=rec.target_x,
+                    target_y=rec.target_y,
+                )
+                if result.get("status") == "ok":
+                    executed_count += 1
+                    unit_name = "Fire Truck" if rec.suggested_unit_type == "fire_truck" else "Helicopter"
+                    self._add_log(
+                        "deploy",
+                        f"🤖 AI moved {unit_name}: ({source_x},{source_y}) → ({rec.target_x},{rec.target_y})",
+                        {"source": "ai", "reason": rec.reason, "action": "move"},
+                    )
+                    self._executed_recommendations.add(rec_key)
+                else:
+                    self._add_log(
+                        "error",
+                        f"🤖 AI move failed: {result.get('message', 'unknown error')} "
+                        f"(source=({source_x},{source_y}) target=({rec.target_x},{rec.target_y}))",
+                    )
             elif action == "remove":
-                # Remove action: remove unit at position (frees slot for redeployment elsewhere)
-                remove_result = self.engine.remove_unit_at(rec.target_x, rec.target_y)
-                
-                if remove_result.get("status") == "ok":
+                result = self._call_mcp_tool("remove_unit", x=rec.target_x, y=rec.target_y)
+                if result.get("status") == "ok":
                     executed_count += 1
                     unit_name = "Fire Truck" if rec.suggested_unit_type == "fire_truck" else "Helicopter"
                     self._add_log(
                         "deploy",
                         f"🤖 AI removed {unit_name} at ({rec.target_x},{rec.target_y}) - ready to redeploy",
-                        {"source": "ai", "reason": rec.reason, "action": "remove"}
+                        {"source": "ai", "reason": rec.reason, "action": "remove"},
                     )
                     self._executed_recommendations.add(rec_key)
                 else:
                     self._add_log(
                         "error",
-                        f"🤖 AI remove failed: {remove_result.get('message')} at ({rec.target_x},{rec.target_y})"
+                        f"🤖 AI remove failed: {result.get('message', 'unknown error')} at "
+                        f"({rec.target_x},{rec.target_y})",
                     )
             else:
-                # Deploy action
-                result = self.engine.deploy_unit(rec.suggested_unit_type, rec.target_x, rec.target_y, "ai")
-                
+                result = self._call_mcp_tool(
+                    "deploy_unit",
+                    unit_type=rec.suggested_unit_type,
+                    x=rec.target_x,
+                    y=rec.target_y,
+                    source="ai",
+                )
                 if result.get("status") == "ok":
                     executed_count += 1
                     unit_name = "Fire Truck" if rec.suggested_unit_type == "fire_truck" else "Helicopter"
                     self._add_log(
                         "deploy",
                         f"🤖 AI deployed {unit_name} at ({rec.target_x}, {rec.target_y})",
-                        {"unit": result.get("unit"), "source": "ai", "reason": rec.reason, "action": "deploy"}
+                        {"source": "ai", "reason": rec.reason, "action": "deploy"},
                     )
                     self._executed_recommendations.add(rec_key)
                 else:
-                    # Log failure but don't stop
                     self._add_log(
                         "error",
-                        f"🤖 AI deploy failed: {result.get('message')} at ({rec.target_x}, {rec.target_y})"
+                        f"🤖 AI deploy failed: {result.get('message', 'unknown error')} "
+                        f"at ({rec.target_x}, {rec.target_y})",
                     )
-        
-        # Keep executed recommendations bounded
+
         if len(self._executed_recommendations) > 100:
             self._executed_recommendations = set(list(self._executed_recommendations)[-50:])