Add agent implementation and configuration loader for jurors

agents/__init__.py

@@ -0,0 +1,9 @@
+"""Agent implementations for 12 Angry Agents."""
+
+from .base_juror import JurorAgent
+from .config_loader import load_juror_configs
+
+__all__ = [
+    "JurorAgent",
+    "load_juror_configs",
+]

agents/base_juror.py

@@ -0,0 +1,245 @@
+"""Base juror agent implementation using Gemini."""
+
+import asyncio
+import json
+import os
+import random
+from typing import Any
+
+from google import genai
+from google.genai import types
+
+from core.models import JurorConfig, JurorMemory, ArgumentMemory
+from core.game_state import GameState, DeliberationTurn
+from core.conviction import conviction_to_text
+from case_db.models import CriminalCase
+
+
+class JurorAgent:
+    """AI-powered juror agent using Gemini for reasoning."""
+
+    def __init__(self, config: JurorConfig, api_key: str | None = None):
+        """Initialize juror agent.
+
+        Args:
+            config: Juror configuration.
+            api_key: Gemini API key. Defaults to GEMINI_API_KEY env var.
+        """
+        self.config = config
+        self.memory = JurorMemory(juror_id=config.juror_id)
+
+        # Initialize Gemini client
+        api_key = api_key or os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY not set")
+        self.client = genai.Client(api_key=api_key)
+
+    def _build_system_prompt(self, case: CriminalCase, game_state: GameState) -> str:
+        """Build the system prompt for the juror."""
+        guilty, not_guilty = game_state.get_vote_tally()
+
+        # Get recent arguments
+        recent_args = self.memory.get_recent_arguments(5)
+        recent_args_text = ""
+        if recent_args:
+            recent_args_text = "\n".join(
+                f"- {arg.speaker_id}: [{arg.argument_type}] {arg.content_summary}"
+                for arg in recent_args
+            )
+        else:
+            recent_args_text = "No arguments have been made yet."
+
+        # Format doubts
+        doubts_text = ", ".join(self.memory.doubts[:3]) if self.memory.doubts else "None currently"
+
+        # Format reasoning chain
+        reasoning_text = " ".join(self.memory.reasoning_chain[-3:]) if self.memory.reasoning_chain else "Still forming opinion."
+
+        return f"""# JUROR IDENTITY
+You are {self.config.name}, Juror #{self.config.seat_number}.
+{self.config.personality_prompt}
+
+# THE CASE: {case.title}
+{case.summary}
+
+# KEY EVIDENCE
+{case.get_evidence_summary()}
+
+# YOUR CURRENT POSITION
+- Conviction Level: {conviction_to_text(self.memory.current_conviction)}
+- Your reasoning: {reasoning_text}
+- Your doubts: {doubts_text}
+
+# RECENT DELIBERATION
+{recent_args_text}
+
+# CURRENT VOTE TALLY
+Guilty: {guilty} | Not Guilty: {not_guilty}
+
+# INSTRUCTIONS
+You must respond IN CHARACTER as {self.config.name}. Stay true to your personality:
+- Archetype: {self.config.archetype}
+- Be authentic to your background and perspective
+- Keep your argument focused and natural (2-4 sentences typically)
+- You may address other jurors directly or speak to the room
+- Consider but don't simply repeat previous arguments
+"""
+
+    async def generate_argument(
+        self,
+        case: CriminalCase,
+        game_state: GameState,
+    ) -> DeliberationTurn:
+        """Generate an argument for this juror's turn.
+
+        Args:
+            case: The criminal case.
+            game_state: Current game state.
+
+        Returns:
+            DeliberationTurn with the generated argument.
+        """
+        system_prompt = self._build_system_prompt(case, game_state)
+
+        # Determine argument type based on archetype tendencies
+        argument_types = self._get_preferred_argument_types()
+        selected_type = random.choice(argument_types)
+
+        user_prompt = f"""Make an argument in the deliberation. Your argument style should lean toward: {selected_type}
+
+Respond with a JSON object in this exact format:
+{{
+    "argument_type": "{selected_type}",
+    "content": "Your argument here - speak naturally as your character would",
+    "target_juror": null or "juror_X" if addressing someone specific,
+    "internal_reasoning": "Brief note about why you're making this argument"
+}}
+
+Remember to stay in character as {self.config.name}!"""
+
+        try:
+            response = await asyncio.to_thread(
+                self.client.models.generate_content,
+                model=self.config.model_id,
+                contents=[
+                    types.Content(
+                        role="user",
+                        parts=[types.Part(text=system_prompt + "\n\n" + user_prompt)]
+                    )
+                ],
+                config=types.GenerateContentConfig(
+                    temperature=self.config.temperature,
+                    response_mime_type="application/json",
+                ),
+            )
+
+            # Parse response
+            response_text = response.text.strip()
+            result = json.loads(response_text)
+
+            # Create turn
+            turn = DeliberationTurn(
+                round_number=game_state.round_number,
+                speaker_id=self.config.juror_id,
+                speaker_name=self.config.name,
+                argument_type=result.get("argument_type", selected_type),
+                content=result.get("content", "I need more time to think about this."),
+                target_id=result.get("target_juror"),
+            )
+
+            # Update own memory
+            self.memory.arguments_made.append(turn.content)
+            if result.get("internal_reasoning"):
+                self.memory.reasoning_chain.append(result["internal_reasoning"])
+
+            return turn
+
+        except Exception as e:
+            # Fallback response on error
+            print(f"Error generating argument for {self.config.name}: {e}")
+            return DeliberationTurn(
+                round_number=game_state.round_number,
+                speaker_id=self.config.juror_id,
+                speaker_name=self.config.name,
+                argument_type="observation",
+                content=f"*{self.config.name} pauses thoughtfully* I'm still considering the evidence...",
+            )
+
+    def _get_preferred_argument_types(self) -> list[str]:
+        """Get argument types this archetype prefers."""
+        archetype_preferences = {
+            "rationalist": ["logical", "evidence", "question"],
+            "empath": ["emotional", "moral", "narrative"],
+            "cynic": ["evidence", "logical", "observation"],
+            "conformist": ["observation", "question", "emotional"],
+            "contrarian": ["question", "logical", "challenge"],
+            "impatient": ["observation", "logical", "evidence"],
+            "detail_obsessed": ["evidence", "question", "logical"],
+            "moralist": ["moral", "emotional", "narrative"],
+            "pragmatist": ["logical", "evidence", "observation"],
+            "storyteller": ["narrative", "question", "emotional"],
+            "wildcard": ["observation", "question", "emotional", "narrative"],
+        }
+        return archetype_preferences.get(self.config.archetype, ["observation", "logical"])
+
+    def receive_argument(self, argument: DeliberationTurn, impact: float = 0.0) -> None:
+        """Process an argument from another juror.
+
+        Args:
+            argument: The argument that was made.
+            impact: Pre-calculated conviction change.
+        """
+        # Create memory of argument
+        arg_memory = ArgumentMemory(
+            speaker_id=argument.speaker_id,
+            content_summary=argument.content[:200],  # Truncate for memory
+            argument_type=argument.argument_type,
+            persuasiveness=abs(impact),
+            round_heard=argument.round_number,
+        )
+        self.memory.add_argument(arg_memory)
+
+        # Update conviction
+        self.memory.update_conviction(impact)
+
+    def set_initial_conviction(self, case: CriminalCase) -> float:
+        """Set initial conviction based on case and archetype.
+
+        Args:
+            case: The case being deliberated.
+
+        Returns:
+            Initial conviction score (0.0 to 1.0).
+        """
+        # Base conviction by case difficulty
+        if case.difficulty == "clear_guilty":
+            base = 0.7
+        elif case.difficulty == "clear_innocent":
+            base = 0.3
+        else:
+            base = 0.5
+
+        # Adjust by initial lean
+        lean = self.config.initial_lean
+        if lean == "prosecution":
+            base += 0.15
+        elif lean == "defense":
+            base -= 0.15
+        elif lean == "minority":
+            # Will be set based on majority later
+            pass
+        elif lean == "random":
+            base += random.uniform(-0.2, 0.2)
+
+        # Add some individual variance
+        base += random.gauss(0, 0.1 * self.config.volatility)
+
+        # Clamp to valid range
+        self.memory.current_conviction = max(0.0, min(1.0, base))
+        self.memory.conviction_history.append(self.memory.current_conviction)
+
+        return self.memory.current_conviction
+
+    def get_vote(self) -> str:
+        """Get current vote based on conviction."""
+        return self.memory.get_current_vote()

agents/config_loader.py

@@ -0,0 +1,67 @@
+"""Load juror configurations from YAML."""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from core.models import JurorConfig
+
+
+def load_juror_configs(config_path: str | Path | None = None) -> list[JurorConfig]:
+    """Load all juror configurations from YAML file.
+
+    Args:
+        config_path: Path to jurors.yaml. Defaults to agents/configs/jurors.yaml.
+
+    Returns:
+        List of JurorConfig objects.
+    """
+    if config_path is None:
+        config_path = Path(__file__).parent / "configs" / "jurors.yaml"
+
+    config_path = Path(config_path)
+    if not config_path.exists():
+        raise FileNotFoundError(f"Juror config file not found: {config_path}")
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    configs = []
+    for juror_data in data.get("jurors", []):
+        config = JurorConfig(
+            juror_id=juror_data["juror_id"],
+            seat_number=juror_data["seat_number"],
+            name=juror_data["name"],
+            emoji=juror_data["emoji"],
+            archetype=juror_data["archetype"],
+            personality_prompt=juror_data["personality_prompt"],
+            stubbornness=juror_data["stubbornness"],
+            volatility=juror_data["volatility"],
+            influence=juror_data["influence"],
+            verbosity=juror_data.get("verbosity", 0.5),
+            initial_lean=juror_data.get("initial_lean", "neutral"),
+        )
+        configs.append(config)
+
+    return configs
+
+
+def get_juror_config(juror_id: str, configs: list[JurorConfig] | None = None) -> JurorConfig | None:
+    """Get a specific juror config by ID.
+
+    Args:
+        juror_id: The juror ID to find.
+        configs: Optional list of configs. If None, loads from default path.
+
+    Returns:
+        JurorConfig if found, None otherwise.
+    """
+    if configs is None:
+        configs = load_juror_configs()
+
+    for config in configs:
+        if config.juror_id == juror_id:
+            return config
+
+    return None