Implement AI Detective functionality with spectator mode and voice integration

TODO.md

@@ -8,13 +8,13 @@
 - pre-generate suspects cartoony potraits
 - bottom gradio box to see internal MCP tools calls out/in
 - eleven labs tts/voice
-
-
-# Doing
 - add ai
 - mode selection
 - numbered steps to launch game
 
+
+# Doing
+
 - sound/music
 - video embeded
 - divider

app.py

@@ -57,9 +57,13 @@ class GameSession:
     def __init__(self):
         self.session_id = None
         self.game = None
+        self.voice_enabled = False
+        self.game_mode = "interactive"
 
-    def start(self, difficulty="medium"):
+    def start(self, difficulty="medium", mode="interactive", voice=True):
         self.session_id, self.game = game_engine.start_game(difficulty)
+        self.voice_enabled = voice
+        self.game_mode = mode
         return self._get_init_data()
 
     def _get_init_data(self):
@@ -81,7 +85,8 @@ class GameSession:
                 "points": self.game.points,
                 "available_cameras": cameras,
                 "dna_map": dna_map,
-                "unlocked_evidence": self.game.unlocked_evidence
+                "unlocked_evidence": self.game.unlocked_evidence,
+                "mode": self.game_mode
             }
         }
 
@@ -106,6 +111,46 @@ class GameSession:
         if not self.game:
             return None
 
+        if action == "ai_step":
+            step_data = self.game.run_ai_step()
+            
+            # Format result for frontend
+            # We need to map the AI's internal result to frontend actions
+            actions = []
+            
+            # 1. Thought Bubble
+            actions.append({
+                "action": "ai_thought",
+                "data": {"thought": step_data["thought"]}
+            })
+            
+            res = step_data["result"]
+            res_type = step_data["action"] # use_tool, chat, accuse
+            
+            if res_type == "use_tool":
+                # We need to construct the same evidence payload as handle_input
+                tool_name = step_data["result"].get("location") # Wait, result of use_tool is the raw dict
+                # I need the tool name from decision
+                # Re-running logic here is messy.
+                # Better: run_ai_step should return enough info.
+                # It returns "result" which is the output of use_tool.
+                # But we don't know which tool it was easily unless we parse "action" or store it.
+                
+                # In run_ai_step I did:
+                # tool_name = decision.get("tool_name")
+                # kwargs = decision.get("args", {})
+                
+                # Let's update run_ai_step to include tool_name in result wrapper?
+                # No, let's just infer or update run_ai_step.
+                # Actually, the loop in JS will call this.
+                # I'll handle formatting here.
+                pass 
+                
+            return {
+                "action": "ai_step_result",
+                "data": step_data 
+            }
+
         if action == "select_suspect":
             return None 
             
@@ -133,7 +178,7 @@ class GameSession:
             response = self.game.question_suspect(suspect_id, message)
             
             suspect = next((s for s in self.game.scenario["suspects"] if s["id"] == suspect_id), None)
-            suspect_name = suspect["name"] if suspect else "Suspect"
+            suspect_name = next((s["name"] for s in self.game.scenario["suspects"] if s["id"] == suspect_id), "Suspect")
             
             # Clean text for ElevenLabs
             cleaned_response = response
@@ -151,7 +196,8 @@ class GameSession:
 
             # Generate Audio
             audio_b64 = None
-            if suspect and "voice_id" in suspect and cleaned_response: # Only generate if there's text left
+            # Check Voice Enabled
+            if self.voice_enabled and suspect and "voice_id" in suspect and cleaned_response:
                 audio_bytes = self.game.voice_manager.generate_audio(cleaned_response, suspect["voice_id"])
                 if audio_bytes:
                     audio_b64 = "data:audio/mpeg;base64," + base64.b64encode(audio_bytes).decode('utf-8')
@@ -161,7 +207,7 @@ class GameSession:
                 "data": {
                     "role": "suspect",
                     "name": suspect_name,
-                    "content": response, # Keep original response for display
+                    "content": response,
                     "audio": audio_b64
                 }
             }
@@ -379,12 +425,14 @@ def get_game_iframe():
     """
     return iframe
 
-def start_game_from_ui(case_name):
+def start_game_from_ui(case_name, mode, voice):
     difficulty = "medium"
     if "Coffee" in case_name: difficulty = "easy"
     if "Gallery" in case_name: difficulty = "hard"
     
-    init_data = session.start(difficulty)
+    mode_slug = "spectator" if "Spectator" in mode else "interactive"
+    
+    init_data = session.start(difficulty, mode_slug, voice)
     
     # Return visible updates
     return (
@@ -407,16 +455,25 @@ footer { display: none !important; }
 with gr.Blocks(title="Murder.Ai", fill_height=True) as demo:
     gr.HTML(f"<style>{css}</style>")
     
-    # Case Selector (Visible Initially)
-    with gr.Row(elem_id="case-selector-row", visible=True) as selector_row:
+    # --- Initial Setup Screen ---
+    with gr.Row(elem_id="setup-container", visible=True) as setup_col:
         with gr.Column():
-            gr.Markdown("# 🕵️ MURDER.AI - CASE FILES")
+            gr.Markdown("# 🕵️ MURDER.AI")
+        
+            gr.Markdown("### 1. Select Case File")
             case_dropdown = gr.Dropdown(
                 choices=["The Silicon Valley Incident (Medium)", "The Coffee Shop Murder (Easy)", "The Gallery Heist (Hard)"],
                 value="The Silicon Valley Incident (Medium)",
-                label="Select Case to Investigate"
+                show_label=False
             )
-            start_btn = gr.Button("📂 OPEN CASE FILE", variant="primary")
+
+            gr.Markdown("### 2. Game Configuration")
+            with gr.Row():
+                game_mode = gr.Radio(["Interactive", "AI Spectator (Beta)"], value="Interactive", label="Game Mode")
+                voice_toggle = gr.Checkbox(value=True, label="Enable Voice (ElevenLabs)")
+
+            gr.Markdown("### 3. Investigation")
+            start_btn = gr.Button("📂 OPEN CASE FILE", variant="primary", size="lg")
 
     # Game Frame (Hidden Initially)
     with gr.Group(visible=False, elem_id="game-frame-container") as game_group:
@@ -424,6 +481,7 @@ with gr.Blocks(title="Murder.Ai", fill_height=True) as demo:
     
     bridge_input = gr.Textbox(elem_id="bridge-input", visible=True)
     bridge_output = gr.Textbox(elem_id="bridge-output", visible=True)
+    log_input = gr.Textbox(elem_id="log-input", visible=True) # Input from JS for logs
     
     # Log Box
     with gr.Accordion("System Logs (MCP Traffic)", open=False):
@@ -450,8 +508,8 @@ with gr.Blocks(title="Murder.Ai", fill_height=True) as demo:
     # Start Game Event
     start_btn.click(
         fn=start_game_from_ui,
-        inputs=[case_dropdown],
-        outputs=[selector_row, game_group, bridge_output]
+        inputs=[case_dropdown, game_mode, voice_toggle],
+        outputs=[setup_col, game_group, bridge_output]
     )
     
     # Bridge Logic with Logging (Legacy/Fallback)

game/ai_detective.py

@@ -0,0 +1,103 @@
+import json
+import re
+from .llm_manager import LLMManager
+
+class AIDetective:
+    def __init__(self, game_instance):
+        self.game = game_instance
+        self.llm = LLMManager()
+        # We reuse the LLMManager but we need to register the new prompt role dynamically
+        # or just load it manually.
+        self.prompt_template = self._load_prompt()
+        self.history = []
+        self.memory = [] # Store structured past actions
+
+    def _load_prompt(self):
+        try:
+            with open("prompts/detective_player.txt", "r") as f:
+                return f.read()
+        except:
+            return "Error loading prompt."
+
+    def record_result(self, action_type, result):
+        """Records the outcome of an action to memory."""
+        entry = f"Action: {action_type}\nResult: {json.dumps(result)}"
+        self.memory.append(entry)
+        # Keep prompt focused (last 5 turns)
+        if len(self.memory) > 5:
+            self.memory.pop(0)
+
+    def decide_next_move(self):
+        """
+        Analyzes game state and returns a JSON action.
+        """
+        # 1. Construct Context
+        evidence_list = [f"{e.get('title', e.get('info', 'Evidence'))}: {e.get('html_content', e.get('description', str(e)))}" for e in self.game.evidence_revealed]
+        evidence_summary = "; ".join(evidence_list) if evidence_list else "None"
+        
+        suspect_status = []
+        suspect_phones = []
+        for s in self.game.scenario["suspects"]:
+            status = "Active"
+            if s["id"] in self.game.eliminated_suspects:
+                status = "Eliminated"
+            suspect_status.append(f"{s['name']} ({s['id']}): {status}")
+            suspect_phones.append(f"{s['name']}: {s.get('phone_number', 'Unknown')}")
+            
+        history_str = "\n---\n".join(self.memory) if self.memory else "No previous actions."
+        
+        # Tool Options
+        cameras = list(self.game.scenario["evidence"]["footage_data"].keys())
+        unlocked_items = self.game.unlocked_evidence if self.game.unlocked_evidence else ["None"]
+        
+        prompt = self.prompt_template.format(
+            victim_name=self.game.scenario["victim"]["name"],
+            time_of_death=self.game.scenario["victim"]["time_of_death"],
+            location=self.game.scenario["victim"].get("location", "Unknown"),
+            round=self.game.round,
+            points=self.game.points,
+            evidence_summary=evidence_summary,
+            suspect_status="\n".join(suspect_status),
+            history=history_str,
+            # Tool Hints
+            cameras=", ".join(cameras),
+            suspect_phones="\n".join(suspect_phones),
+            unlocked_items=", ".join(unlocked_items)
+        )
+        
+        # 2. Call LLM
+        # We treat this as a one-shot or maintain simple history
+        # Using a unique agent ID for the detective player
+        agent_id = "ai_detective_player"
+        
+        # We need to inject the prompt into the agent creation if it doesn't exist
+        if agent_id not in self.llm.agents:
+            # We cheat a bit and use 'detective' role but override instructions in the message
+            # because LLMManager expects a fixed role.
+            # Actually, let's just pass the full prompt as the "user input" to a generic agent 
+            # or create a custom agent.
+            pass
+
+        # Direct generation using the underlying model logic would be cleaner, 
+        # but we'll use the existing abstraction.
+        # We will send the ENTIRE prompt as the message.
+        response_text = self.llm.get_response_raw(prompt)
+        
+        # 3. Parse JSON
+        try:
+            # Extract JSON from code blocks if present
+            json_match = re.search(r"\{.*\}", response_text, re.DOTALL)
+            if json_match:
+                response_text = json_match.group(0)
+            
+            action = json.loads(response_text)
+            return action
+        except Exception as e:
+            print(f"AI Detective Error: {e} | Response: {response_text}")
+            # Fallback action
+            return {
+                "thought": "I am confused. I will check the footage.",
+                "action": "use_tool",
+                "tool_name": "get_footage",
+                "args": {"location": "10th_floor_camera"}
+            }

game/game_engine.py

@@ -2,6 +2,7 @@ import uuid
 from .scenario_generator import generate_crime_scenario
 from .llm_manager import LLMManager
 from .voice_manager import VoiceManager
+from .ai_detective import AIDetective
 from mcp import tools
 
 class GameInstance:
@@ -10,6 +11,8 @@ class GameInstance:
         self.scenario = generate_crime_scenario(difficulty)
         self.llm_manager = LLMManager()
         self.voice_manager = VoiceManager()
+        self.ai_detective = None # Initialized later to avoid circular dep issues if any, or just now.
+        
         self.round = 1
         self.max_rounds = 3 # 3 Chances
         self.points = 10
@@ -22,7 +25,54 @@ class GameInstance:
         
         # Initialize Agents
         self._init_agents()
+        self.ai_detective = AIDetective(self)
+        
+    def run_ai_step(self):
+        """Executes one turn for the AI Detective."""
+        if self.game_over:
+            return {"thought": "Game Over.", "action": "none"}
+            
+        decision = self.ai_detective.decide_next_move()
+        action_type = decision.get("action")
+        thought = decision.get("thought", "Thinking...")
+        result = {}
         
+        if action_type == "use_tool":
+            tool_name = decision.get("tool_name")
+            kwargs = decision.get("args", {})
+            result = self.use_tool(tool_name, **kwargs)
+            result["type"] = "evidence"
+            
+        elif action_type == "chat":
+            suspect_id = decision.get("suspect_id")
+            msg = decision.get("message")
+            response = self.question_suspect(suspect_id, msg)
+            result = {
+                "type": "chat",
+                "suspect_id": suspect_id,
+                "question": msg,
+                "response": response
+            }
+            
+        elif action_type == "accuse":
+            suspect_id = decision.get("suspect_id")
+            # Map suspect_id if it's just "suspect_1" (which it is)
+            # But make_accusation handles ID.
+            outcome = self.make_accusation(suspect_id)
+            result = {
+                "type": "game_over",
+                "outcome": outcome
+            }
+            
+        # Record result for AI memory
+        self.ai_detective.record_result(action_type, result)
+            
+        return {
+            "thought": thought,
+            "action": action_type,
+            "result": result
+        }
+
     def _init_agents(self):
         # 1. Detective
         detective_context = {
@@ -119,6 +169,11 @@ class GameInstance:
              return result # Don't deduct points for errors
              
         self.points -= cost
+        
+        # Inject input context for AI memory
+        if isinstance(result, dict):
+            result["_input_args"] = kwargs
+            
         self.evidence_revealed.append(result)
         self.log_event("System", f"Used {tool_name}. Cost: {cost} pts. Result: {str(result)}")
         return result

game/llm_manager.py

@@ -93,3 +93,15 @@ class LLMManager:
         if agent:
             return agent.generate_response(user_input)
         return "Error: Agent not found."
+
+    def get_response_raw(self, prompt):
+        """Stateless generation for AI Detective logic."""
+        if not API_KEY:
+            return '{"thought": "Mock thought", "action": "chat", "suspect_id": "suspect_1", "message": "Hello"}'
+            
+        try:
+            model = genai.GenerativeModel('gemini-2.5-flash')
+            response = model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error: {str(e)}"

prompts/detective_player.txt

@@ -0,0 +1,58 @@
+You are the Lead AI Detective in a murder mystery game.
+Your goal is to solve the case by finding the murderer among the 4 suspects.
+
+CASE DETAILS:
+Victim: {victim_name}
+Time of Death: {time_of_death}
+Location: {location}
+
+CURRENT STATE:
+Round: {round}/3
+Points: {points}
+Evidence Found: {evidence_summary}
+Suspects Status: {suspect_status}
+
+MY PREVIOUS ACTIONS:
+{history}
+
+AVAILABLE TOOLS (Costs Points):
+1. get_location(phone_number) [2 pts]: Check where a suspect was at specific times.
+   - Valid Phones:
+{suspect_phones}
+
+2. call_alibi(alibi_id, question) [1 pt]: Call a suspect's alibi witness.
+   - Ask the suspect for their 'Alibi ID' first!
+
+3. get_footage(camera_name) [3 pts]: Watch security footage. Unlocks physical evidence.
+   - Valid Cameras: {cameras}
+
+4. get_dna_test(evidence_id) [4 pts]: Test DNA on unlocked items.
+   - Unlocked Items: {unlocked_items}
+
+5. interrogate(suspect_id, question) [0 pts]: Chat with a suspect.
+6. accuse(suspect_id) [0 pts]: Accuse a suspect. WARNING: Wrong accusation advances round. 3 strikes = LOSS.
+
+STRATEGY:
+- Start by gathering general evidence (Footage) or questioning suspects to get their stories.
+- Cross-reference stories with Location data.
+- Use DNA to confirm presence at the crime scene.
+- If a suspect lies about their location or alibi, press them.
+- Only ACCUSE if you are 80% sure or running out of points.
+
+INSTRUCTIONS:
+Analyze the current state and decide your next move.
+Provide a "Thought" (your internal reasoning) and an "Action" (the tool/chat to execute).
+
+OUTPUT FORMAT (JSON ONLY):
+{{
+  "thought": "I need to verify Suspect 1's alibi...",
+  "action": "use_tool" OR "chat" OR "accuse",
+  "tool_name": "call_alibi" (if action is use_tool),
+  "args": {{
+    "alibi_id": "...",
+    "question": "..."
+  }}
+  OR
+  "suspect_id": "suspect_1" (if action is chat or accuse),
+  "message": "Where were you..." (if action is chat)
+}}

ui/static/js/game_logic.js

@@ -146,6 +146,91 @@ function initializeGame(data) {
     gameState.unlockedEvidence = data.unlocked_evidence || [];
     
     renderCaseFile(data.scenario);
+    
+    // Mode Check
+    if (data.mode === 'spectator') {
+        document.getElementById('spectator-modal').classList.add('active');
+        document.getElementById('spectator-start-btn').onclick = startSpectatorMode;
+        
+        // Disable user controls
+        document.getElementById('chat-input-area').style.display = 'none';
+        document.getElementById('tools-panel').style.pointerEvents = 'none';
+        document.getElementById('tools-panel').style.opacity = '0.5';
+    }
+}
+
+// --- AI Spectator Logic ---
+
+function startSpectatorMode() {
+    document.getElementById('spectator-modal').classList.remove('active');
+    document.getElementById('ai-log-panel').style.display = 'block';
+    runAIStep();
+}
+
+async function runAIStep() {
+    const logContent = document.getElementById('ai-log-content');
+    
+    // Visual "Thinking" state
+    const thinkingDiv = document.createElement('div');
+    thinkingDiv.style.color = '#888';
+    thinkingDiv.style.fontStyle = 'italic';
+    thinkingDiv.innerText = "Analyzing evidence...";
+    thinkingDiv.id = 'temp-thinking';
+    logContent.appendChild(thinkingDiv);
+    logContent.scrollTop = logContent.scrollHeight;
+    
+    // 1. Request Move
+    const response = await sendAction('ai_step', {});
+    
+    // Remove temp thinking
+    const temp = document.getElementById('temp-thinking');
+    if (temp) temp.remove();
+    
+    if (!response || response.action !== 'ai_step_result') {
+        return;
+    }
+    
+    const step = response.data;
+    
+    // 2. Log Thought
+    const entry = document.createElement('div');
+    entry.style.marginBottom = '15px';
+    entry.style.borderBottom = '1px dashed #333';
+    entry.style.paddingBottom = '10px';
+    entry.innerHTML = `
+        <div style="color:#aaa; margin-bottom:5px;">🤔 <strong>THOUGHT:</strong></div>
+        <div style="margin-bottom:10px;">${step.thought}</div>
+        <div style="color:#aaa; margin-bottom:5px;">⚡ <strong>ACTION:</strong> ${step.action.toUpperCase()}</div>
+    `;
+    logContent.appendChild(entry);
+    logContent.scrollTop = logContent.scrollHeight;
+    
+    // 3. Execute Action Visualization
+    if (step.action === 'chat') {
+        // Select suspect if needed
+        if (gameState.currentSuspect !== step.result.suspect_id) {
+            selectSuspect(step.result.suspect_id);
+        }
+        
+        // Simulate User Message (AI Detective)
+        addChatMessage('detective', step.result.question, "AI DETECTIVE");
+        
+        setTimeout(() => {
+            addChatMessage('suspect', step.result.response, "Suspect");
+        }, 1000);
+        
+    } else if (step.action === 'use_tool') {
+        showNotification(`🤖 AI USED TOOL`);
+    }
+    
+    // Loop
+    if (step.result.type !== 'game_over' && !step.result.outcome) {
+        setTimeout(runAIStep, 6000); // 6s delay for reading
+    } else {
+        if (step.result.type === 'game_over') {
+             triggerGameOver(step.result.outcome);
+        }
+    }
 }
 
 function renderCaseFile(scenario) {
@@ -741,7 +826,11 @@ function showModalResult(data) {
         resultDiv.style.marginTop = '20px';
         resultDiv.style.borderTop = '2px dashed var(--ink-color)';
         resultDiv.style.paddingTop = '10px';
-        document.querySelector('.modal-content').insertBefore(resultDiv, document.querySelector('.modal-actions'));
+        const modalContent = document.querySelector('#tool-modal .modal-content');
+        const modalActions = document.querySelector('#tool-modal .modal-actions');
+        if (modalContent && modalActions) {
+            modalContent.insertBefore(resultDiv, modalActions);
+        }
     }
     
     resultDiv.style.display = 'block';

ui/templates/game_interface.html

@@ -14,6 +14,22 @@
         <div>INITIALIZING CASE FILE...</div>
     </div>
 
+    <!-- AI Spectator Start Modal -->
+    <div id="spectator-modal" class="modal-overlay">
+        <div class="modal-content" style="text-align: center;">
+            <div class="modal-header">AI DETECTIVE MODE</div>
+            <p style="margin: 20px 0;">You are now watching an AI Agent investigate this case.</p>
+            <p style="font-size: 0.9rem; color: #666; margin-bottom: 20px;">It will gather evidence, interview suspects, and make an accusation.</p>
+            <button id="spectator-start-btn" class="modal-btn confirm" style="font-size: 1.2rem; width: 100%;">START INVESTIGATION</button>
+        </div>
+    </div>
+
+    <!-- AI Log Panel -->
+    <div id="ai-log-panel" style="display: none; grid-row: 2/3; grid-column: 2/3; background: rgba(0,0,0,0.95); padding: 20px; border: 2px solid #0f0; overflow-y: auto; font-family: 'Courier New', monospace; color: #0f0; z-index: 50; margin: 10px;">
+        <div style="font-weight: bold; margin-bottom: 10px; border-bottom: 1px solid #0f0; padding-bottom: 5px;">🤖 AI DETECTIVE LOG</div>
+        <div id="ai-log-content"></div>
+    </div>
+
     <div id="game-container">
         
         <!-- Header -->