Add main application logic, memory management, and configuration for 12 Angry Agents

app.py

@@ -0,0 +1,453 @@
+"""12 Angry Agents - Main Gradio Application.
+
+AI-powered jury deliberation simulation where 11 AI agents + 1 human player
+debate criminal cases. A Judge narrator orchestrates the experience.
+"""
+
+import asyncio
+import os
+import random
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Add project root to path for imports
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+
+from core.game_state import GameState, GamePhase, DeliberationTurn
+from core.models import JurorConfig
+from core.conviction import calculate_conviction_change
+from case_db import CaseLoader, CriminalCase
+from agents import load_juror_configs, JurorAgent
+from ui.components import render_jury_box, render_vote_tally
+
+
+# Custom CSS for dark jury room theme
+CUSTOM_CSS = """
+.gradio-container {
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%) !important;
+}
+.jury-title {
+    text-align: center;
+    color: #e94560 !important;
+    font-family: 'Georgia', serif;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
+}
+.phase-indicator {
+    background: #0f3460;
+    padding: 10px;
+    border-radius: 8px;
+    text-align: center;
+    color: #4ecdc4;
+    margin-bottom: 10px;
+}
+"""
+
+
+class JuryDeliberation:
+    """Main game orchestrator."""
+
+    def __init__(self):
+        self.case_loader = CaseLoader()
+        self.juror_configs = load_juror_configs()
+        self.juror_agents: dict[str, JurorAgent] = {}
+        self.game_state: GameState | None = None
+        self.current_case: CriminalCase | None = None
+
+    def initialize_game(self, case_id: str | None = None) -> tuple[str, str, str, list]:
+        """Initialize a new game.
+
+        Returns:
+            Tuple of (case_summary, evidence_html, jury_box_html, chat_history)
+        """
+        # Load case
+        if case_id:
+            self.current_case = self.case_loader.get_case(case_id)
+        else:
+            self.current_case = self.case_loader.get_random_case()
+
+        if not self.current_case:
+            # Use a default case if none found
+            return (
+                "No cases available. Please add case files to case_db/cases/",
+                "",
+                render_jury_box(self.juror_configs),
+                []
+            )
+
+        # Initialize game state
+        self.game_state = GameState(
+            case_id=self.current_case.case_id,
+            phase=GamePhase.PRESENTATION,
+        )
+
+        # Initialize juror agents (skip player seat 7)
+        self.juror_agents = {}
+        for config in self.juror_configs:
+            if config.archetype != "player":
+                try:
+                    agent = JurorAgent(config)
+                    # Set initial conviction
+                    conviction = agent.set_initial_conviction(self.current_case)
+                    # Set initial vote
+                    self.game_state.votes[config.juror_id] = agent.get_vote()
+                    self.game_state.conviction_scores[config.juror_id] = conviction
+                    self.juror_agents[config.juror_id] = agent
+                except Exception as e:
+                    print(f"Warning: Failed to initialize {config.name}: {e}")
+
+        # Format case info
+        case_summary = f"""## {self.current_case.title}
+
+**Year:** {self.current_case.year} | **Jurisdiction:** {self.current_case.jurisdiction}
+
+**Charges:** {self.current_case.get_charges_text()}
+
+---
+
+{self.current_case.summary}
+"""
+
+        # Format evidence
+        evidence_html = f"""### Evidence
+
+{self.current_case.get_evidence_summary()}
+
+### Witnesses
+
+{self.current_case.get_witness_summary()}
+"""
+
+        # Render jury box
+        jury_html = render_jury_box(self.juror_configs, self.game_state)
+
+        # Initial chat with judge introduction
+        chat_history = [
+            (None, f"**\u2696\uFE0F Judge:** Members of the jury, you are here today to determine the fate of the defendant in the case of {self.current_case.title}. Please review the evidence carefully and deliberate with your fellow jurors. The burden of proof lies with the prosecution.")
+        ]
+
+        return case_summary, evidence_html, jury_html, chat_history
+
+    def select_player_side(self, side: str) -> tuple[str, str, list]:
+        """Player selects prosecution or defense side.
+
+        Returns:
+            Tuple of (vote_tally_html, jury_html, chat_history_update)
+        """
+        if not self.game_state:
+            return "", "", []
+
+        self.game_state.player_side = side
+        self.game_state.phase = GamePhase.DELIBERATION
+
+        # Set player's vote based on side
+        player_vote = "guilty" if side == "prosecute" else "not_guilty"
+        self.game_state.votes["juror_7"] = player_vote
+        self.game_state.conviction_scores["juror_7"] = 0.8 if side == "prosecute" else 0.2
+
+        vote_html = render_vote_tally(self.game_state)
+        jury_html = render_jury_box(self.juror_configs, self.game_state)
+
+        side_text = "PROSECUTION (Guilty)" if side == "prosecute" else "DEFENSE (Not Guilty)"
+        chat_update = [(f"*You have chosen to argue for the {side_text}*", None)]
+
+        return vote_html, jury_html, chat_update
+
+    async def run_deliberation_round(self) -> tuple[str, str, list[tuple]]:
+        """Run a single round of AI juror deliberation.
+
+        Returns:
+            Tuple of (vote_html, jury_html, new_chat_messages)
+        """
+        if not self.game_state or not self.current_case:
+            return "", "", []
+
+        self.game_state.round_number += 1
+        new_messages = []
+
+        # Select 1-3 random speakers (excluding player)
+        available_jurors = [
+            jid for jid in self.juror_agents.keys()
+            if jid != "juror_7"
+        ]
+        num_speakers = random.randint(1, min(3, len(available_jurors)))
+        speakers = random.sample(available_jurors, num_speakers)
+
+        # Each speaker makes an argument
+        for speaker_id in speakers:
+            agent = self.juror_agents[speaker_id]
+            config = next(c for c in self.juror_configs if c.juror_id == speaker_id)
+
+            try:
+                # Generate argument
+                turn = await agent.generate_argument(self.current_case, self.game_state)
+
+                # Add to chat
+                new_messages.append((
+                    None,
+                    f"**{config.emoji} {config.name}:** {turn.content}"
+                ))
+
+                # Other jurors react
+                for other_id, other_agent in self.juror_agents.items():
+                    if other_id != speaker_id:
+                        # Calculate impact based on archetype compatibility
+                        base_impact = random.uniform(-0.15, 0.15)
+                        impact = calculate_conviction_change(
+                            other_agent.config,
+                            other_agent.memory,
+                            turn,
+                            base_impact=base_impact
+                        )
+                        other_agent.receive_argument(turn, impact)
+
+                        # Update vote if conviction changed significantly
+                        new_vote = other_agent.get_vote()
+                        if self.game_state.votes.get(other_id) != new_vote:
+                            self.game_state.votes[other_id] = new_vote
+                            vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
+                            other_config = next(c for c in self.juror_configs if c.juror_id == other_id)
+                            new_messages.append((
+                                None,
+                                f"*{other_config.emoji} {other_config.name} changes their vote to {vote_text}*"
+                            ))
+
+                # Log turn
+                self.game_state.deliberation_log.append(turn)
+
+            except Exception as e:
+                print(f"Error in deliberation for {speaker_id}: {e}")
+
+        # Update displays
+        vote_html = render_vote_tally(self.game_state)
+        jury_html = render_jury_box(self.juror_configs, self.game_state)
+
+        return vote_html, jury_html, new_messages
+
+    def make_player_argument(
+        self,
+        strategy: str,
+        custom_text: str | None = None
+    ) -> tuple[str, str, list[tuple]]:
+        """Process player's argument.
+
+        Returns:
+            Tuple of (vote_html, jury_html, new_chat_messages)
+        """
+        if not self.game_state or not self.current_case:
+            return "", "", []
+
+        # Get player config
+        player_config = next(c for c in self.juror_configs if c.archetype == "player")
+
+        # Create argument content
+        if custom_text:
+            content = custom_text
+        else:
+            # Generate content based on strategy
+            strategy_templates = {
+                "Challenge Evidence": "I'd like to point out some issues with the evidence presented...",
+                "Question Witness Credibility": "Can we really trust the witness testimony here?",
+                "Appeal to Reasonable Doubt": "Remember, we need proof beyond reasonable doubt. Do we have that?",
+                "Present Alternative Theory": "What if there's another explanation for what happened?",
+                "Call for Vote": "I think we should take a vote and see where everyone stands.",
+            }
+            content = strategy_templates.get(strategy, "I have some concerns about this case...")
+
+        # Create turn
+        turn = DeliberationTurn(
+            round_number=self.game_state.round_number,
+            speaker_id="juror_7",
+            speaker_name="You",
+            argument_type=strategy.lower().replace(" ", "_"),
+            content=content,
+        )
+
+        new_messages = [(f"**{player_config.emoji} You:** {content}", None)]
+
+        # AI jurors react
+        for juror_id, agent in self.juror_agents.items():
+            base_impact = random.uniform(-0.1, 0.1)
+            # Player arguments have moderate base influence
+            base_impact *= 1.2
+            impact = calculate_conviction_change(
+                agent.config,
+                agent.memory,
+                turn,
+                base_impact=base_impact
+            )
+            agent.receive_argument(turn, impact)
+
+            # Check for vote changes
+            new_vote = agent.get_vote()
+            if self.game_state.votes.get(juror_id) != new_vote:
+                self.game_state.votes[juror_id] = new_vote
+                config = next(c for c in self.juror_configs if c.juror_id == juror_id)
+                vote_text = "GUILTY" if new_vote == "guilty" else "NOT GUILTY"
+                new_messages.append((
+                    None,
+                    f"*{config.emoji} {config.name} changes their vote to {vote_text}*"
+                ))
+
+        self.game_state.deliberation_log.append(turn)
+
+        vote_html = render_vote_tally(self.game_state)
+        jury_html = render_jury_box(self.juror_configs, self.game_state)
+
+        return vote_html, jury_html, new_messages
+
+
+# Create global game instance
+game = JuryDeliberation()
+
+
+def create_ui():
+    """Create the Gradio UI."""
+
+    with gr.Blocks(css=CUSTOM_CSS, title="12 Angry Agents", theme=gr.themes.Base()) as demo:
+
+        # State
+        chat_history = gr.State([])
+
+        # Header
+        gr.HTML("<h1 class='jury-title'>12 ANGRY AGENTS</h1>")
+        gr.HTML("<p style='text-align: center; color: #888;'>AI-Powered Jury Deliberation</p>")
+
+        with gr.Row():
+            # Left Column: Jury Box
+            with gr.Column(scale=1):
+                gr.Markdown("### The Jury")
+                jury_box = gr.HTML(render_jury_box(game.juror_configs))
+                vote_tally = gr.HTML("")
+
+                gr.Markdown("### Your Side")
+                with gr.Row():
+                    defend_btn = gr.Button("DEFEND\n(Not Guilty)", variant="secondary")
+                    prosecute_btn = gr.Button("PROSECUTE\n(Guilty)", variant="primary")
+
+            # Center Column: Deliberation
+            with gr.Column(scale=2):
+                gr.Markdown("### Deliberation Room")
+                deliberation_chat = gr.Chatbot(
+                    label="Deliberation",
+                    height=400,
+                    show_label=False,
+                )
+
+                # Player input
+                with gr.Row():
+                    strategy_select = gr.Dropdown(
+                        choices=[
+                            "Challenge Evidence",
+                            "Question Witness Credibility",
+                            "Appeal to Reasonable Doubt",
+                            "Present Alternative Theory",
+                            "Call for Vote",
+                        ],
+                        label="Your Strategy",
+                        value="Challenge Evidence",
+                    )
+                    speak_btn = gr.Button("Speak", variant="primary")
+
+                custom_text = gr.Textbox(
+                    label="Custom argument (optional)",
+                    placeholder="Type your own argument here...",
+                    max_lines=2,
+                )
+
+                with gr.Row():
+                    pass_btn = gr.Button("Pass Turn")
+                    next_round_btn = gr.Button("Next Round (AI Speaks)", variant="secondary")
+
+            # Right Column: Case File
+            with gr.Column(scale=1):
+                gr.Markdown("### Case File")
+                case_summary = gr.Markdown("*Click 'Start New Case' to begin*")
+
+                with gr.Accordion("Evidence & Witnesses", open=False):
+                    evidence_display = gr.Markdown("")
+
+        # Start Game Button
+        start_btn = gr.Button("Start New Case", variant="primary", size="lg")
+
+        # Event handlers
+        def start_game():
+            case_md, evidence_md, jury_html, chat = game.initialize_game()
+            return case_md, evidence_md, jury_html, chat, render_vote_tally(game.game_state)
+
+        start_btn.click(
+            fn=start_game,
+            inputs=[],
+            outputs=[case_summary, evidence_display, jury_box, deliberation_chat, vote_tally]
+        )
+
+        def select_defend(chat):
+            vote_html, jury_html, new_msgs = game.select_player_side("defend")
+            return vote_html, jury_html, chat + new_msgs
+
+        def select_prosecute(chat):
+            vote_html, jury_html, new_msgs = game.select_player_side("prosecute")
+            return vote_html, jury_html, chat + new_msgs
+
+        defend_btn.click(
+            fn=select_defend,
+            inputs=[deliberation_chat],
+            outputs=[vote_tally, jury_box, deliberation_chat]
+        )
+
+        prosecute_btn.click(
+            fn=select_prosecute,
+            inputs=[deliberation_chat],
+            outputs=[vote_tally, jury_box, deliberation_chat]
+        )
+
+        async def run_ai_round(chat):
+            vote_html, jury_html, new_msgs = await game.run_deliberation_round()
+            return vote_html, jury_html, chat + new_msgs
+
+        next_round_btn.click(
+            fn=run_ai_round,
+            inputs=[deliberation_chat],
+            outputs=[vote_tally, jury_box, deliberation_chat]
+        )
+
+        def player_speak(strategy, custom, chat):
+            text = custom if custom else None
+            vote_html, jury_html, new_msgs = game.make_player_argument(strategy, text)
+            return vote_html, jury_html, chat + new_msgs, ""
+
+        speak_btn.click(
+            fn=player_speak,
+            inputs=[strategy_select, custom_text, deliberation_chat],
+            outputs=[vote_tally, jury_box, deliberation_chat, custom_text]
+        )
+
+        def pass_turn(chat):
+            chat.append(("*You pass your turn*", None))
+            return chat
+
+        pass_btn.click(
+            fn=pass_turn,
+            inputs=[deliberation_chat],
+            outputs=[deliberation_chat]
+        )
+
+        # Enable MCP server
+        return demo
+
+
+# Main entry point
+if __name__ == "__main__":
+    demo = create_ui()
+    demo.launch(
+        mcp_server=True,
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+    )

config/models.yaml

@@ -0,0 +1,27 @@
+# Model configuration for 12 Angry Agents
+
+default_model:
+  provider: "gemini"
+  model_id: "gemini-2.5-flash"
+  temperature: 0.7
+  max_tokens: 1024
+
+# Optional per-agent overrides
+model_overrides:
+  # Judge narration
+  judge:
+    provider: "gemini"
+    model_id: "gemini-2.5-flash"
+    temperature: 0.5
+
+  # Batch conviction updates
+  batch_updater:
+    provider: "gemini"
+    model_id: "gemini-2.5-flash"
+    temperature: 0.3
+
+  # Example: Give the contrarian philosopher a different model
+  # juror_5:
+  #   provider: "anthropic"
+  #   model_id: "claude-sonnet-4-20250514"
+  #   temperature: 0.9

mcp/__init__.py

@@ -0,0 +1,6 @@
+"""MCP server tools for 12 Angry Agents."""
+
+# MCP tools will be defined in app.py via Gradio's mcp_server=True
+# This module is reserved for future tool definitions
+
+__all__ = []

memory/__init__.py

@@ -0,0 +1,5 @@
+"""Memory management for juror agents."""
+
+from .summarizer import MemorySummarizer
+
+__all__ = ["MemorySummarizer"]

memory/summarizer.py

@@ -0,0 +1,68 @@
+"""Memory summarization for context window management."""
+
+from core.models import JurorMemory, ArgumentMemory
+
+
+class MemorySummarizer:
+    """Compresses old deliberation history to manage context window."""
+
+    SUMMARY_INTERVAL = 5  # Summarize every 5 rounds
+    KEEP_RECENT = 3  # Keep last 3 turns in full detail
+
+    def should_summarize(self, round_num: int) -> bool:
+        """Check if we should summarize at this round."""
+        return round_num > 0 and round_num % self.SUMMARY_INTERVAL == 0
+
+    def summarize(self, memory: JurorMemory) -> None:
+        """Compress old turns in memory if needed.
+
+        Args:
+            memory: Juror memory to summarize.
+        """
+        if len(memory.arguments_heard) <= self.KEEP_RECENT:
+            return
+
+        # Split: recent (keep full) vs old (summarize)
+        old_turns = memory.arguments_heard[:-self.KEEP_RECENT]
+        recent_turns = memory.arguments_heard[-self.KEEP_RECENT:]
+
+        if not old_turns:
+            return
+
+        # Create simple text summary
+        summary_parts = []
+        for arg in old_turns:
+            summary_parts.append(
+                f"- {arg.speaker_id} made a {arg.argument_type} argument"
+            )
+
+        # Append to existing summary
+        if memory.deliberation_summary:
+            memory.deliberation_summary += "\n" + "\n".join(summary_parts)
+        else:
+            memory.deliberation_summary = "\n".join(summary_parts)
+
+        # Keep only recent turns
+        memory.arguments_heard = recent_turns
+
+    def get_memory_context(self, memory: JurorMemory) -> str:
+        """Get formatted memory context for prompts.
+
+        Args:
+            memory: Juror memory.
+
+        Returns:
+            Formatted string of memory context.
+        """
+        parts = []
+
+        if memory.deliberation_summary:
+            parts.append("## Earlier Discussion Summary")
+            parts.append(memory.deliberation_summary)
+
+        if memory.arguments_heard:
+            parts.append("## Recent Arguments")
+            for arg in memory.arguments_heard:
+                parts.append(f"- {arg.speaker_id} [{arg.argument_type}]: {arg.content_summary}")
+
+        return "\n".join(parts) if parts else "No deliberation history yet."

requirements.txt

@@ -1,5 +1,6 @@
 # Core
-gradio==6.0.1
+gradio[mcp]==6.0.1
+pyyaml>=6.0.0
 pydantic>=2.0.0
 pydantic-settings>=2.0.0