feat: Introduce smolagents tools for juror agents

- Added EvidenceLookupTool for semantic search of case evidence.
- Implemented CaseQueryTool for querying various aspects of the case.
- Created a new CaseIndex for efficient semantic search using LlamaIndex.
- Updated JuryDeliberation to utilize new tools and integrate case indexing.
- Refactored OrchestratorAgent to support reasoning steps and tool calls.
- Enhanced requirements for LlamaIndex and related dependencies.

.env.example

@@ -10,3 +10,7 @@ OPENAI_DEFAULT_MODEL=gpt-4o
 # ElevenLabs Voice IDs
 VALOR_VOICE_ID=your_valor_voice_id
 GLOOM_VOICE_ID=your_gloom_voice_id
+
+LAMAINDEX_API_KEY=llx-xxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+NEBIUS_API_KEY=

agents/__init__.py

@@ -1,9 +1,18 @@
-"""Agent implementations for 12 Angry Agents."""
+"""Agent implementations for 12 Angry Agents.
+
+Uses smolagents CodeAgent with LlamaIndex-powered tools for autonomous reasoning.
+"""
 
-from .base_juror import JurorAgent
 from .config_loader import load_juror_configs
+from .smolagent_juror import (
+    SmolagentJuror,
+    ReasoningStep,
+    AgentResult,
+)
 
 __all__ = [
-    "JurorAgent",
+    "SmolagentJuror",
+    "ReasoningStep",
+    "AgentResult",
     "load_juror_configs",
 ]

agents/{base_juror.py → smolagent_juror.py}

@@ -1,46 +1,133 @@
-"""Base juror agent implementation using Gemini."""
+"""smolagents-based juror agent with CodeAgent and tool use.
+
+Uses:
+- smolagents CodeAgent for multi-step reasoning
+- LiteLLMModel for multi-provider LLM support
+- LlamaIndex-powered tools for evidence/case queries
+- Visible reasoning steps for UI display
+"""
 
 import asyncio
-import json
-import os
 import random
-from typing import Any
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-from google import genai
-from google.genai import types
+from smolagents import CodeAgent, LiteLLMModel
 
 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
+from agents.tools import EvidenceLookupTool, CaseQueryTool
+
+if TYPE_CHECKING:
+    from case_db.models import CriminalCase
+    from case_db.index import CaseIndex
+
+
+@dataclass
+class ReasoningStep:
+    """A single step in the agent's reasoning process."""
+    step_number: int
+    action: str  # "thinking", "tool_call", "observation", "final_answer"
+    content: str
+    tool_name: str | None = None
+    tool_input: str | None = None
+    tool_output: str | None = None
+
 
+@dataclass
+class AgentResult:
+    """Result from running the smolagent."""
+    final_answer: str
+    reasoning_steps: list[ReasoningStep] = field(default_factory=list)
+    tool_calls_made: list[str] = field(default_factory=list)
+    total_steps: int = 0
 
-class JurorAgent:
-    """AI-powered juror agent using Gemini for reasoning."""
 
-    def __init__(self, config: JurorConfig, api_key: str | None = None):
-        """Initialize juror agent.
+class SmolagentJuror:
+    """Autonomous juror agent with tool access and visible reasoning.
+
+    Uses smolagents CodeAgent for multi-step reasoning with tools.
+    Agents can autonomously query evidence and case details during deliberation.
+    Reasoning steps are captured for UI display.
+    """
+
+    DEFAULT_MODEL_ID = "gemini/gemini-2.0-flash"
+    MAX_STEPS = 3  # Limit reasoning steps for performance
+
+    def __init__(
+        self,
+        config: JurorConfig,
+        case_index: "CaseIndex | None" = None,
+        case: "CriminalCase | None" = None,
+    ):
+        """Initialize the smolagent juror.
 
         Args:
-            config: Juror configuration.
-            api_key: Gemini API key. Defaults to GEMINI_API_KEY env var.
+            config: Juror configuration
+            case_index: LlamaIndex CaseIndex for semantic search
+            case: CriminalCase for tools if no index provided
         """
         self.config = config
         self.memory = JurorMemory(juror_id=config.juror_id)
+        self.case_index = case_index
+        self.case = case
+
+        # Build model ID from config
+        model_id = f"{config.model_provider}/{config.model_id}"
+        if config.model_provider == "gemini":
+            model_id = f"gemini/{config.model_id}"
+
+        # Initialize LiteLLM model
+        self.model = LiteLLMModel(
+            model_id=model_id,
+            temperature=config.temperature,
+        )
+
+        # Initialize tools
+        self.tools = self._create_tools()
 
-        # 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)
+        # Create CodeAgent
+        self.agent = CodeAgent(
+            tools=self.tools,
+            model=self.model,
+            max_steps=self.MAX_STEPS,
+            verbosity_level=1,
+        )
+
+        # Store last reasoning for UI
+        self.last_reasoning_steps: list[ReasoningStep] = []
+        self.last_tool_calls: list[str] = []
+
+    def _create_tools(self) -> list:
+        """Create tools for the agent."""
+        tools = []
 
-    def _build_system_prompt(self, case: CriminalCase, game_state: GameState) -> str:
-        """Build the system prompt for the juror."""
+        if self.case_index is not None:
+            # Full LlamaIndex-powered tools
+            tools.append(EvidenceLookupTool(self.case_index))
+            tools.append(CaseQueryTool(self.case_index))
+        elif self.case is not None:
+            # Mock tools when no index
+            from agents.tools.evidence_tool import EvidenceLookupToolMock
+            from agents.tools.case_query_tool import CaseQueryToolMock
+            tools.append(EvidenceLookupToolMock(self.case))
+            tools.append(CaseQueryToolMock(self.case))
+
+        return tools
+
+    def _build_prompt(
+        self,
+        case: "CriminalCase",
+        game_state: GameState,
+        task: str = "speak"
+    ) -> str:
+        """Build the prompt for the agent."""
         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}"
@@ -55,19 +142,16 @@ class JurorAgent:
         # Format reasoning chain
         reasoning_text = " ".join(self.memory.reasoning_chain[-3:]) if self.memory.reasoning_chain else "Still forming opinion."
 
-        return f"""# JUROR IDENTITY
+        base_prompt = 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 reasoning so far: {reasoning_text}
 - Your doubts: {doubts_text}
 
 # RECENT DELIBERATION
@@ -75,95 +159,142 @@ You are {self.config.name}, Juror #{self.config.seat_number}.
 
 # 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
+        if task == "speak":
+            task_prompt = f"""
+# YOUR TASK
+Make an argument in the deliberation. You have access to tools to look up evidence
+and query the case if needed. Use them if you need to verify facts or find specific
+evidence to support your argument.
+
+Stay in character as {self.config.name} ({self.config.archetype}).
+- Be authentic to your personality and background
+- Keep your argument focused (2-4 sentences)
+- You may address other jurors or speak to the room
+- Base your argument on evidence when possible
+
+Provide your argument as a single statement that your character would say out loud
+in the jury room. Do not include internal thoughts - just what you would say.
 """
+        else:  # react
+            task_prompt = """
+# YOUR TASK
+React to the latest argument. You may use tools to verify claims made.
+Return a brief internal reaction (not spoken aloud).
+"""
+
+        return base_prompt + task_prompt
 
     async def generate_argument(
         self,
-        case: CriminalCase,
+        case: "CriminalCase",
         game_state: GameState,
-    ) -> DeliberationTurn:
-        """Generate an argument for this juror's turn.
-
-        Args:
-            case: The criminal case.
-            game_state: Current game state.
+    ) -> tuple[DeliberationTurn, list[ReasoningStep]]:
+        """Generate an argument using the CodeAgent.
 
         Returns:
-            DeliberationTurn with the generated argument.
+            Tuple of (DeliberationTurn, list of ReasoningSteps for UI)
         """
-        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)
+        prompt = self._build_prompt(case, game_state, task="speak")
 
-        user_prompt = f"""Make an argument in the deliberation. Your argument style should lean toward: {selected_type}
+        try:
+            # Run the agent
+            result = await asyncio.to_thread(self.agent.run, prompt)
 
-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"
-}}
+            # Extract reasoning steps from agent logs
+            self.last_reasoning_steps = self._extract_reasoning_steps()
+            self.last_tool_calls = self._extract_tool_calls()
 
-Remember to stay in character as {self.config.name}!"""
+            # Parse the result
+            content = str(result).strip()
 
-        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",
-                ),
-            )
+            # Clean up the content
+            content = self._clean_content(content)
 
-            # Parse response
-            response_text = response.text.strip()
-            result = json.loads(response_text)
+            # Determine argument type based on archetype
+            argument_types = self._get_preferred_argument_types()
+            selected_type = random.choice(argument_types)
 
-            # Create turn
+            # Create the 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"),
+                argument_type=selected_type,
+                content=content,
             )
 
             # Update own memory
-            self.memory.arguments_made.append(turn.content)
-            if result.get("internal_reasoning"):
-                self.memory.reasoning_chain.append(result["internal_reasoning"])
+            self.memory.arguments_made.append(content)
 
-            return turn
+            return turn, self.last_reasoning_steps
 
         except Exception as e:
-            # Fallback response on error
-            print(f"Error generating argument for {self.config.name}: {e}")
-            return DeliberationTurn(
+            print(f"Error in SmolagentJuror.generate_argument for {self.config.name}: {e}")
+            # Fallback response
+            turn = 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...",
             )
+            return turn, []
+
+    def _extract_reasoning_steps(self) -> list[ReasoningStep]:
+        """Extract reasoning steps from agent logs."""
+        steps = []
+
+        try:
+            if hasattr(self.agent, 'logs') and self.agent.logs:
+                for i, log in enumerate(self.agent.logs):
+                    step = ReasoningStep(
+                        step_number=i + 1,
+                        action=log.get('type', 'thinking'),
+                        content=log.get('content', str(log)),
+                        tool_name=log.get('tool_name'),
+                        tool_input=log.get('tool_input'),
+                        tool_output=log.get('tool_output'),
+                    )
+                    steps.append(step)
+        except Exception:
+            pass
+
+        # If no logs available, create a simple step
+        if not steps:
+            steps.append(ReasoningStep(
+                step_number=1,
+                action="thinking",
+                content="Analyzed case and formed argument based on personality and evidence."
+            ))
+
+        return steps
+
+    def _extract_tool_calls(self) -> list[str]:
+        """Extract tool calls from reasoning steps."""
+        calls = []
+        for step in self.last_reasoning_steps:
+            if step.tool_name:
+                calls.append(f"{step.tool_name}({step.tool_input})")
+        return calls
+
+    def _clean_content(self, content: str) -> str:
+        """Clean up agent output for display."""
+        # Remove code blocks
+        content = re.sub(r'```[\s\S]*?```', '', content)
+        # Remove markdown formatting
+        content = re.sub(r'\*\*([^*]+)\*\*', r'\1', content)
+        # Remove quotes that might wrap the whole response
+        content = content.strip('"\'')
+        # Clean up whitespace
+        content = ' '.join(content.split())
+
+        # Ensure it's not empty
+        if not content:
+            content = "I need more time to consider the evidence."
+
+        return content
 
     def _get_preferred_argument_types(self) -> list[str]:
         """Get argument types this archetype prefers."""
@@ -183,34 +314,22 @@ Remember to stay in character as {self.config.name}!"""
         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
+        """Process an argument from another juror."""
         arg_memory = ArgumentMemory(
             speaker_id=argument.speaker_id,
-            content_summary=argument.content[:200],  # Truncate for memory
+            content_summary=argument.content[:200],
             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.
+    def set_initial_conviction(self, case: "CriminalCase") -> float:
+        """Set initial conviction based on case and archetype."""
+        # Store case reference for tools
+        self.case = case
 
-        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
@@ -225,9 +344,6 @@ Remember to stay in character as {self.config.name}!"""
             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)
 
@@ -243,3 +359,18 @@ Remember to stay in character as {self.config.name}!"""
     def get_vote(self) -> str:
         """Get current vote based on conviction."""
         return self.memory.get_current_vote()
+
+    def get_reasoning_for_ui(self) -> list[str]:
+        """Get formatted reasoning steps for UI display."""
+        formatted = []
+        for step in self.last_reasoning_steps:
+            if step.tool_name:
+                formatted.append(
+                    f"Step {step.step_number}: Tool call - {step.tool_name}(\"{step.tool_input}\")"
+                )
+                if step.tool_output:
+                    formatted.append(f"  Result: {step.tool_output[:100]}...")
+            else:
+                formatted.append(f"Step {step.step_number}: {step.action} - {step.content[:100]}")
+
+        return formatted

agents/tools/__init__.py

@@ -0,0 +1,13 @@
+"""smolagents tools for juror agents.
+
+Tools allow agents to autonomously query case evidence and details
+during deliberation, enabling true agentic behavior.
+"""
+
+from .evidence_tool import EvidenceLookupTool
+from .case_query_tool import CaseQueryTool
+
+__all__ = [
+    "EvidenceLookupTool",
+    "CaseQueryTool",
+]

agents/tools/case_query_tool.py

@@ -0,0 +1,144 @@
+"""Case query tool for smolagents.
+
+Allows juror agents to query any aspect of the case.
+"""
+
+from typing import TYPE_CHECKING
+
+from smolagents import Tool
+
+if TYPE_CHECKING:
+    from case_db.index import CaseIndex
+    from case_db.models import CriminalCase
+
+
+class CaseQueryTool(Tool):
+    """Tool for agents to query any aspect of the case.
+
+    General-purpose tool that allows agents to ask questions about
+    the case - timeline, people, charges, context, connections between facts.
+
+    Examples of queries an agent might make:
+    - "What are the charges against the defendant?"
+    - "Who discovered the body?"
+    - "What is the defendant's background?"
+    - "What time did the incident occur?"
+    - "What is the connection between the witness and defendant?"
+    """
+
+    name = "case_query"
+    description = """Query any aspect of the case. Use this tool to:
+- Understand the timeline of events
+- Learn about people involved (defendant, witnesses, victims)
+- Clarify the charges and legal context
+- Find connections between facts
+- Get background information
+- Understand who said what
+
+This is a general-purpose case query tool. Ask any question about
+the case in natural language, such as "What happened on the night
+of the incident?" or "What is the relationship between the defendant
+and the victim?"."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "Question about the case (natural language)"
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, case_index: "CaseIndex"):
+        """Initialize with a case index.
+
+        Args:
+            case_index: LlamaIndex CaseIndex for semantic search
+        """
+        super().__init__()
+        self.case_index = case_index
+
+    def forward(self, query: str) -> str:
+        """Execute the case query.
+
+        Args:
+            query: Natural language question about the case
+
+        Returns:
+            Answer synthesized from case documents
+        """
+        if self.case_index is None:
+            return "Error: No case index available. Case query disabled."
+
+        try:
+            result = self.case_index.query(query)
+            return result if result else "No information found for this query."
+        except Exception as e:
+            return f"Error querying case: {str(e)}"
+
+
+class CaseQueryToolMock(Tool):
+    """Mock case query tool for testing without LlamaIndex.
+
+    Returns case information based on simple pattern matching.
+    """
+
+    name = "case_query"
+    description = "Query case information (mock version for testing)"
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "Question about the case"
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, case: "CriminalCase"):
+        """Initialize with a case object.
+
+        Args:
+            case: CriminalCase object
+        """
+        super().__init__()
+        self.case = case
+
+    def forward(self, query: str) -> str:
+        """Simple pattern-based case query.
+
+        Args:
+            query: Question about the case
+
+        Returns:
+            Relevant case information
+        """
+        if not self.case:
+            return "No case information available."
+
+        query_lower = query.lower()
+
+        if "charge" in query_lower:
+            return f"Charges: {', '.join(self.case.charges)}"
+
+        if "defendant" in query_lower or "accused" in query_lower:
+            if self.case.defendant:
+                return f"Defendant: {self.case.defendant.name}. {self.case.defendant.background}"
+            return "Defendant information not available."
+
+        if "witness" in query_lower:
+            if self.case.witnesses:
+                summaries = [f"- {w.name} ({w.role}): {w.testimony_summary}"
+                            for w in self.case.witnesses]
+                return "Witnesses:\n" + "\n".join(summaries)
+            return "No witness information available."
+
+        if "evidence" in query_lower:
+            if self.case.evidence:
+                summaries = [f"- [{e.type}] {e.description}"
+                            for e in self.case.evidence]
+                return "Evidence:\n" + "\n".join(summaries)
+            return "No evidence information available."
+
+        if "summary" in query_lower or "what happened" in query_lower:
+            return self.case.summary
+
+        # Default: return case summary
+        return f"Case: {self.case.title}\n\n{self.case.summary}"

agents/tools/evidence_tool.py

@@ -0,0 +1,123 @@
+"""Evidence lookup tool for smolagents.
+
+Allows juror agents to semantically search case evidence.
+"""
+
+from typing import TYPE_CHECKING
+
+from smolagents import Tool
+
+if TYPE_CHECKING:
+    from case_db.index import CaseIndex
+    from case_db.models import CriminalCase
+
+
+class EvidenceLookupTool(Tool):
+    """Tool for agents to search case evidence semantically.
+
+    Enables juror agents to autonomously query evidence during deliberation.
+    Uses LlamaIndex for semantic search.
+
+    Examples of queries an agent might make:
+    - "fingerprints found at the scene"
+    - "timeline of events"
+    - "weapon used in the crime"
+    - "DNA evidence"
+    - "alibi documentation"
+    """
+
+    name = "evidence_lookup"
+    description = """Search case evidence semantically. Use this tool to find:
+- Physical evidence (weapons, fingerprints, DNA, items found at scene)
+- Documentary evidence (receipts, records, contracts, photos)
+- Forensic evidence (lab results, medical reports, autopsy)
+- Timeline evidence (timestamps, alibis, movement records)
+
+Ask about specific items or search for evidence types. The search is semantic,
+so you can ask natural questions like "what physical evidence links the defendant
+to the crime scene?" or "evidence about the timeline of events"."""
+
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "What evidence to search for (natural language query)"
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, case_index: "CaseIndex"):
+        """Initialize with a case index.
+
+        Args:
+            case_index: LlamaIndex CaseIndex for semantic search
+        """
+        super().__init__()
+        self.case_index = case_index
+
+    def forward(self, query: str) -> str:
+        """Execute the evidence search.
+
+        Args:
+            query: Natural language query about evidence
+
+        Returns:
+            Relevant evidence information from the case
+        """
+        if self.case_index is None:
+            return "Error: No case index available. Evidence lookup disabled."
+
+        try:
+            result = self.case_index.query_evidence(query)
+            return result if result else "No relevant evidence found for this query."
+        except Exception as e:
+            return f"Error searching evidence: {str(e)}"
+
+
+class EvidenceLookupToolMock(Tool):
+    """Mock evidence lookup tool for testing without LlamaIndex.
+
+    Uses simple keyword matching instead of semantic search.
+    """
+
+    name = "evidence_lookup"
+    description = "Search case evidence (mock version for testing)"
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "What evidence to search for"
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, case: "CriminalCase"):
+        """Initialize with a case object.
+
+        Args:
+            case: CriminalCase object with evidence list
+        """
+        super().__init__()
+        self.case = case
+
+    def forward(self, query: str) -> str:
+        """Simple keyword-based evidence search.
+
+        Args:
+            query: Keywords to search for
+
+        Returns:
+            Matching evidence descriptions
+        """
+        if not self.case or not self.case.evidence:
+            return "No evidence available."
+
+        query_lower = query.lower()
+        matches = []
+
+        for evidence in self.case.evidence:
+            if (query_lower in evidence.description.lower() or
+                query_lower in evidence.type.lower()):
+                matches.append(f"[{evidence.type}] {evidence.description}")
+
+        if matches:
+            return "\n".join(matches)
+        return f"No evidence found matching '{query}'"

app.py

@@ -1,14 +1,11 @@
 """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.
+debate criminal cases. Uses smolagents CodeAgent with LlamaIndex-powered tools.
 """
 
 import asyncio
-import os
-import random
 from pathlib import Path
-from typing import Any
 
 import gradio as gr
 from dotenv import load_dotenv
@@ -20,12 +17,10 @@ load_dotenv()
 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 core.orchestrator import OrchestratorAgent, TurnManager
-from case_db import CaseLoader, CriminalCase
-from agents import load_juror_configs, JurorAgent
+from core.game_state import GameState, GamePhase
+from core.orchestrator import OrchestratorAgent
+from case_db import CaseLoader, CriminalCase, CaseIndexFactory
+from agents import load_juror_configs, SmolagentJuror
 from ui.components import render_jury_box, render_vote_tally
 
 
@@ -39,7 +34,7 @@ class JuryDeliberation:
     def __init__(self):
         self.case_loader = CaseLoader()
         self.juror_configs = load_juror_configs()
-        self.juror_agents: dict[str, JurorAgent] = {}
+        self.juror_agents: dict[str, SmolagentJuror] = {}
         self.orchestrator: OrchestratorAgent | None = None
         self.current_case: CriminalCase | None = None
 
@@ -68,12 +63,19 @@ class JuryDeliberation:
                 []
             )
 
-        # Initialize juror agents (skip player seat 7)
+        # Create LlamaIndex for this case
+        case_index = CaseIndexFactory.get_index(self.current_case)
+
+        # Initialize juror agents with case index (skip player seat 7)
         self.juror_agents = {}
         for config in self.juror_configs:
             if config.archetype != "player":
                 try:
-                    agent = JurorAgent(config)
+                    agent = SmolagentJuror(
+                        config,
+                        case_index=case_index,
+                        case=self.current_case
+                    )
                     agent.set_initial_conviction(self.current_case)
                     self.juror_agents[config.juror_id] = agent
                 except Exception as e:
@@ -111,7 +113,7 @@ class JuryDeliberation:
         jury_html = render_jury_box(self.juror_configs, self.game_state)
 
         chat_history = [
-            {"role": "assistant", "content": f"**⚖️ 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."}
+            {"role": "assistant", "content": f"**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
@@ -151,6 +153,22 @@ class JuryDeliberation:
                 {"role": "assistant", "content": f"**{config.emoji} {config.name}:** {turn.content}"}
             )
 
+            # Show reasoning steps if available (smolagents feature)
+            if result.reasoning_steps:
+                reasoning_text = "\n".join([f"  {step}" for step in result.reasoning_steps])
+                new_messages.append({
+                    "role": "assistant",
+                    "content": f"*{config.emoji} {config.name}'s reasoning:*\n```\n{reasoning_text}\n```"
+                })
+
+            # Show tool calls if any
+            if result.tool_calls:
+                tools_text = ", ".join(result.tool_calls)
+                new_messages.append({
+                    "role": "assistant",
+                    "content": f"*Tools used: {tools_text}*"
+                })
+
             # Vote changes
             for juror_id, old_vote, new_vote in result.vote_changes:
                 other_config = next(c for c in self.juror_configs if c.juror_id == juror_id)

case_db/__init__.py

@@ -7,6 +7,7 @@ from .models import (
     Defendant,
 )
 from .loader import CaseLoader
+from .index import CaseIndex, CaseIndexFactory
 
 __all__ = [
     "CriminalCase",
@@ -14,4 +15,6 @@ __all__ = [
     "Witness",
     "Defendant",
     "CaseLoader",
+    "CaseIndex",
+    "CaseIndexFactory",
 ]

case_db/index.py

@@ -0,0 +1,223 @@
+"""LlamaIndex case index for semantic search over case documents.
+
+Provides RAG capabilities for smolagents tools to query evidence and case details.
+Uses Nebius embeddings via the decoupled embedding service.
+"""
+
+from typing import TYPE_CHECKING
+
+from llama_index.core import VectorStoreIndex, Document
+
+from services.embeddings import get_embedding_service
+
+if TYPE_CHECKING:
+    from case_db.models import CriminalCase
+
+
+class CaseIndex:
+    """Semantic search over case documents for agent tool use.
+
+    Creates a vector index from case summary, evidence, and witness testimonies.
+    Agents can query this index to find relevant information during deliberation.
+
+    Uses Nebius embeddings (4096-dim) via the centralized embedding service.
+    """
+
+    def __init__(self, case: "CriminalCase"):
+        """Initialize the case index.
+
+        Args:
+            case: The criminal case to index
+        """
+        self.case = case
+
+        # Initialize embedding service (configures LlamaIndex Settings)
+        self._embedding_service = get_embedding_service()
+
+        # Build the index
+        self.index = self._build_index()
+        self.query_engine = self.index.as_query_engine()
+
+    def _build_index(self) -> VectorStoreIndex:
+        """Build vector index from case documents."""
+        documents = []
+
+        # Index case summary
+        documents.append(Document(
+            text=self.case.summary,
+            metadata={
+                "type": "summary",
+                "case_id": self.case.case_id
+            }
+        ))
+
+        # Index charges
+        if self.case.charges:
+            charges_text = f"Charges: {', '.join(self.case.charges)}"
+            documents.append(Document(
+                text=charges_text,
+                metadata={
+                    "type": "charges",
+                    "case_id": self.case.case_id
+                }
+            ))
+
+        # Index each piece of evidence
+        for evidence in self.case.evidence:
+            doc_text = f"Evidence ({evidence.type}): {evidence.description}"
+            if evidence.contestable and evidence.contest_reason:
+                doc_text += f" [Contestable: {evidence.contest_reason}]"
+
+            documents.append(Document(
+                text=doc_text,
+                metadata={
+                    "type": "evidence",
+                    "evidence_type": evidence.type,
+                    "evidence_id": evidence.evidence_id,
+                    "case_id": self.case.case_id,
+                    "strength_prosecution": evidence.strength_prosecution,
+                    "strength_defense": evidence.strength_defense,
+                }
+            ))
+
+        # Index witness testimonies
+        for witness in self.case.witnesses:
+            doc_text = (
+                f"Witness {witness.name} ({witness.role}, {witness.side}): "
+                f"{witness.testimony_summary}"
+            )
+            if witness.credibility_issues:
+                doc_text += f" [Credibility issues: {', '.join(witness.credibility_issues)}]"
+
+            documents.append(Document(
+                text=doc_text,
+                metadata={
+                    "type": "witness",
+                    "witness_id": witness.witness_id,
+                    "witness_name": witness.name,
+                    "witness_role": witness.role,
+                    "witness_side": witness.side,
+                    "case_id": self.case.case_id,
+                }
+            ))
+
+        # Index defendant background if available
+        if self.case.defendant:
+            defendant_text = f"Defendant: {self.case.defendant.name}"
+            if self.case.defendant.age:
+                defendant_text += f", age {self.case.defendant.age}"
+            if self.case.defendant.occupation:
+                defendant_text += f", {self.case.defendant.occupation}"
+            if self.case.defendant.background:
+                defendant_text += f". Background: {self.case.defendant.background}"
+            if self.case.defendant.prior_record:
+                defendant_text += f". Prior record: {', '.join(self.case.defendant.prior_record)}"
+
+            documents.append(Document(
+                text=defendant_text,
+                metadata={
+                    "type": "defendant",
+                    "case_id": self.case.case_id,
+                }
+            ))
+
+        # Index prosecution arguments
+        for i, arg in enumerate(self.case.prosecution_arguments):
+            documents.append(Document(
+                text=f"Prosecution argument: {arg}",
+                metadata={
+                    "type": "prosecution_argument",
+                    "argument_index": i,
+                    "case_id": self.case.case_id,
+                }
+            ))
+
+        # Index defense arguments
+        for i, arg in enumerate(self.case.defense_arguments):
+            documents.append(Document(
+                text=f"Defense argument: {arg}",
+                metadata={
+                    "type": "defense_argument",
+                    "argument_index": i,
+                    "case_id": self.case.case_id,
+                }
+            ))
+
+        return VectorStoreIndex.from_documents(documents)
+
+    def query(self, question: str) -> str:
+        """Query the case index for relevant information.
+
+        Args:
+            question: Natural language question about the case
+
+        Returns:
+            Synthesized answer from relevant case documents
+        """
+        response = self.query_engine.query(question)
+        return str(response)
+
+    def query_evidence(self, query: str) -> str:
+        """Query specifically for evidence-related information.
+
+        Args:
+            query: What evidence to search for
+
+        Returns:
+            Relevant evidence information
+        """
+        full_query = f"Evidence related to: {query}"
+        return self.query(full_query)
+
+    def query_witnesses(self, query: str) -> str:
+        """Query specifically for witness testimony.
+
+        Args:
+            query: What witness information to search for
+
+        Returns:
+            Relevant witness testimony
+        """
+        full_query = f"Witness testimony about: {query}"
+        return self.query(full_query)
+
+    def get_all_evidence_summaries(self) -> list[str]:
+        """Get list of all evidence summaries for quick reference."""
+        return [
+            f"[{e.evidence_id}] {e.type}: {e.description}"
+            for e in self.case.evidence
+        ]
+
+    def get_all_witness_summaries(self) -> list[str]:
+        """Get list of all witness summaries for quick reference."""
+        return [
+            f"[{w.witness_id}] {w.name} ({w.role}): {w.testimony_summary[:100]}..."
+            for w in self.case.witnesses
+        ]
+
+
+class CaseIndexFactory:
+    """Factory for creating and caching case indices."""
+
+    _cache: dict[str, CaseIndex] = {}
+
+    @classmethod
+    def get_index(cls, case: "CriminalCase") -> CaseIndex:
+        """Get or create a case index.
+
+        Caches indices by case_id to avoid rebuilding.
+
+        Args:
+            case: The criminal case to index
+
+        Returns:
+            CaseIndex for the case
+        """
+        if case.case_id not in cls._cache:
+            cls._cache[case.case_id] = CaseIndex(case)
+        return cls._cache[case.case_id]
+
+    @classmethod
+    def clear_cache(cls) -> None:
+        """Clear the index cache."""
+        cls._cache.clear()

core/orchestrator.py

@@ -12,7 +12,7 @@ from core.models import JurorConfig, JurorMemory
 from core.conviction import calculate_conviction_change
 
 if TYPE_CHECKING:
-    from agents.base_juror import JurorAgent
+    from agents.smolagent_juror import SmolagentJuror
     from case_db.models import CriminalCase
 
 
@@ -21,15 +21,17 @@ class SpeakerWeight:
     """Weight information for speaker selection."""
     juror_id: str
     weight: float
-    reason: str  # Why this weight was assigned
+    reason: str
 
 
 @dataclass
 class TurnResult:
     """Result of a single turn in deliberation."""
     turn: DeliberationTurn
-    conviction_changes: dict[str, float]  # juror_id -> delta
-    vote_changes: list[tuple[str, str, str]]  # (juror_id, old_vote, new_vote)
+    conviction_changes: dict[str, float]
+    vote_changes: list[tuple[str, str, str]]
+    reasoning_steps: list[str] = field(default_factory=list)
+    tool_calls: list[str] = field(default_factory=list)
 
 
 class TurnManager:
@@ -42,17 +44,14 @@ class TurnManager:
     4. Some randomness to keep things unpredictable
     """
 
-    # Weights for different factors
-    ON_FENCE_BONUS = 2.0       # Bonus for jurors near 0.5 conviction
-    RECENCY_PENALTY = 0.3     # Multiplier for recent speakers
-    INFLUENCE_WEIGHT = 1.5    # How much influence affects selection
-    RANDOM_FACTOR = 0.3       # Random noise to add variety
-
-    # Track how many rounds before a juror can be "prioritized" again
+    ON_FENCE_BONUS = 2.0
+    RECENCY_PENALTY = 0.3
+    INFLUENCE_WEIGHT = 1.5
+    RANDOM_FACTOR = 0.3
     RECENCY_WINDOW = 2
 
     def __init__(self):
-        self.speaker_history: list[list[str]] = []  # Per-round speaker lists
+        self.speaker_history: list[list[str]] = []
 
     def select_speakers(
         self,
@@ -62,23 +61,10 @@ class TurnManager:
         num_speakers: int = None,
         exclude_player: bool = True
     ) -> list[str]:
-        """Select speakers for the next round using weighted selection.
-
-        Args:
-            game_state: Current game state
-            juror_configs: All juror configurations
-            juror_memories: Memory state for each juror
-            num_speakers: Number of speakers (1-4, random if None)
-            exclude_player: Whether to exclude player from selection
-
-        Returns:
-            List of juror_ids selected to speak
-        """
-        # Determine number of speakers
+        """Select speakers for the next round using weighted selection."""
         if num_speakers is None:
             num_speakers = random.randint(1, 3)
 
-        # Get eligible jurors
         eligible = [
             c for c in juror_configs
             if not (exclude_player and c.is_player())
@@ -87,20 +73,14 @@ class TurnManager:
         if not eligible:
             return []
 
-        # Calculate weights for each juror
         weights = self._calculate_weights(
             eligible,
             juror_memories,
             game_state.round_number
         )
 
-        # Select speakers using weighted random selection
         selected = self._weighted_select(weights, min(num_speakers, len(eligible)))
-
-        # Record this round's speakers
         self.speaker_history.append(selected)
-
-        # Update game state speaking queue
         game_state.speaking_queue = selected
 
         return selected
@@ -118,55 +98,45 @@ class TurnManager:
             jid = config.juror_id
             memory = memories.get(jid)
 
-            # Base weight from influence
             base_weight = 0.5 + (config.influence * self.INFLUENCE_WEIGHT)
 
-            # On-the-fence bonus (conviction between 0.35-0.65)
             if memory:
                 conviction = memory.current_conviction
                 fence_distance = abs(conviction - 0.5)
-                if fence_distance < 0.15:  # Very on the fence
+                if fence_distance < 0.15:
                     fence_bonus = self.ON_FENCE_BONUS * (1 - fence_distance / 0.15)
                 else:
                     fence_bonus = 0.0
             else:
                 fence_bonus = 0.0
 
-            # Recency penalty - spoke recently?
             recency_multiplier = 1.0
             reason_parts = []
 
             for rounds_ago, speakers in enumerate(reversed(self.speaker_history[-self.RECENCY_WINDOW:])):
                 if jid in speakers:
-                    # More recent = bigger penalty
                     penalty = self.RECENCY_PENALTY ** (rounds_ago + 1)
                     recency_multiplier *= penalty
                     reason_parts.append(f"spoke {rounds_ago + 1} rounds ago")
                     break
 
-            # Volatility bonus - volatile jurors speak more
             volatility_bonus = config.volatility * 0.5
-
-            # Calculate final weight
             weight = (base_weight + fence_bonus + volatility_bonus) * recency_multiplier
-
-            # Add some randomness
             weight += random.uniform(0, self.RANDOM_FACTOR)
 
-            # Build reason string
             reasons = []
             if fence_bonus > 0:
                 reasons.append(f"on fence (+{fence_bonus:.2f})")
             if recency_multiplier < 1.0:
                 reasons.append(f"recent speaker (x{recency_multiplier:.2f})")
             if config.influence > 0.6:
-                reasons.append(f"high influence")
+                reasons.append("high influence")
             if config.volatility > 0.6:
-                reasons.append(f"volatile")
+                reasons.append("volatile")
 
             weights.append(SpeakerWeight(
                 juror_id=jid,
-                weight=max(0.1, weight),  # Minimum weight to ensure everyone has a chance
+                weight=max(0.1, weight),
                 reason=", ".join(reasons) if reasons else "baseline"
             ))
 
@@ -185,12 +155,10 @@ class TurnManager:
             if not remaining:
                 break
 
-            # Calculate total weight
             total = sum(w.weight for w in remaining)
             if total <= 0:
                 break
 
-            # Random selection
             r = random.uniform(0, total)
             cumulative = 0
 
@@ -203,15 +171,6 @@ class TurnManager:
 
         return selected
 
-    def get_speaker_weights_debug(
-        self,
-        configs: list[JurorConfig],
-        memories: dict[str, JurorMemory],
-        current_round: int
-    ) -> list[SpeakerWeight]:
-        """Get weights for debugging/display purposes."""
-        return self._calculate_weights(configs, memories, current_round)
-
     def reset(self):
         """Reset speaker history for new game."""
         self.speaker_history = []
@@ -230,7 +189,7 @@ class OrchestratorAgent:
     def __init__(
         self,
         juror_configs: list[JurorConfig],
-        juror_agents: dict[str, "JurorAgent"],
+        juror_agents: dict[str, "SmolagentJuror"],
         case: "CriminalCase"
     ):
         self.juror_configs = juror_configs
@@ -238,10 +197,8 @@ class OrchestratorAgent:
         self.case = case
         self.turn_manager = TurnManager()
 
-        # Initialize game state
         self.state = GameState(case_id=case.case_id)
 
-        # Initialize votes and convictions from agents
         for jid, agent in juror_agents.items():
             self.state.votes[jid] = agent.get_vote()
             self.state.conviction_scores[jid] = agent.memory.current_conviction
@@ -259,21 +216,12 @@ class OrchestratorAgent:
         self,
         num_speakers: int = None
     ) -> list[TurnResult]:
-        """Run a single round of deliberation.
-
-        Args:
-            num_speakers: Number of AI speakers this round (random 1-3 if None)
-
-        Returns:
-            List of TurnResult for each speaker
-        """
+        """Run a single round of deliberation."""
         self.state.round_number += 1
         results = []
 
-        # Record vote snapshot at start of round
         votes_at_start = dict(self.state.votes)
 
-        # Select speakers using fair queue
         speakers = self.turn_manager.select_speakers(
             self.state,
             self.juror_configs,
@@ -282,13 +230,11 @@ class OrchestratorAgent:
             exclude_player=True
         )
 
-        # Process each speaker
         for speaker_id in speakers:
             result = await self._process_speaker_turn(speaker_id)
             if result:
                 results.append(result)
 
-        # Check for vote stability
         if self.state.votes == votes_at_start:
             self.state.rounds_without_change += 1
         else:
@@ -297,21 +243,29 @@ class OrchestratorAgent:
         return results
 
     async def _process_speaker_turn(self, speaker_id: str) -> TurnResult | None:
-        """Process a single speaker's turn.
-
-        Args:
-            speaker_id: ID of the speaking juror
-
-        Returns:
-            TurnResult with argument and impacts, or None on error
-        """
+        """Process a single speaker's turn."""
         agent = self.juror_agents.get(speaker_id)
         if not agent:
             return None
 
         try:
-            # Generate argument
-            turn = await agent.generate_argument(self.case, self.state)
+            # Generate argument - SmolagentJuror always returns (turn, reasoning_steps)
+            turn, reasoning_data = await agent.generate_argument(self.case, self.state)
+
+            # Extract reasoning steps for UI
+            reasoning_steps = []
+            if reasoning_data:
+                reasoning_steps = [
+                    f"Step {s.step_number}: {s.action} - {s.content[:100]}"
+                    if hasattr(s, 'step_number') else str(s)
+                    for s in reasoning_data
+                ]
+
+            # Extract tool calls
+            tool_calls = agent.last_tool_calls if hasattr(agent, 'last_tool_calls') else []
+
+            # Select active listeners for full processing
+            active_listeners = self._select_active_listeners(turn)
 
             # Process reactions from other jurors
             conviction_changes = {}
@@ -321,14 +275,12 @@ class OrchestratorAgent:
                 if other_id == speaker_id:
                     continue
 
-                # Calculate conviction change
                 old_vote = self.state.votes.get(other_id)
-                old_conviction = other_agent.memory.current_conviction
-
-                # Base impact with some randomness
                 base_impact = random.uniform(-0.15, 0.15)
 
-                # Calculate actual impact
+                if other_id in active_listeners:
+                    base_impact *= 1.2
+
                 delta = calculate_conviction_change(
                     other_agent.config,
                     other_agent.memory,
@@ -336,52 +288,69 @@ class OrchestratorAgent:
                     base_impact=base_impact
                 )
 
-                # Apply to agent
                 other_agent.receive_argument(turn, delta)
                 conviction_changes[other_id] = delta
-
-                # Record in turn impact
                 turn.impact[other_id] = delta
 
-                # Check for vote change
                 new_vote = other_agent.get_vote()
                 if old_vote != new_vote:
                     self.state.votes[other_id] = new_vote
                     vote_changes.append((other_id, old_vote, new_vote))
 
-                # Update conviction in game state
                 self.state.conviction_scores[other_id] = other_agent.memory.current_conviction
 
-            # Log the turn
             self.state.deliberation_log.append(turn)
 
             return TurnResult(
                 turn=turn,
                 conviction_changes=conviction_changes,
-                vote_changes=vote_changes
+                vote_changes=vote_changes,
+                reasoning_steps=reasoning_steps,
+                tool_calls=tool_calls,
             )
 
         except Exception as e:
             print(f"Error processing turn for {speaker_id}: {e}")
             return None
 
+    def _select_active_listeners(
+        self,
+        turn: DeliberationTurn,
+        max_active: int = 3
+    ) -> list[str]:
+        """Select jurors for full agent processing (active listeners)."""
+        active = []
+
+        for jid, agent in self.juror_agents.items():
+            if jid == turn.speaker_id:
+                continue
+
+            if 0.35 < agent.memory.current_conviction < 0.65:
+                active.append((jid, 3))
+            elif agent.config.influence > 0.7:
+                active.append((jid, 2))
+            elif turn.target_id == jid:
+                active.append((jid, 3))
+            elif len(agent.memory.conviction_history) > 1:
+                recent_change = abs(
+                    agent.memory.conviction_history[-1] -
+                    agent.memory.conviction_history[-2]
+                ) if len(agent.memory.conviction_history) >= 2 else 0
+                if recent_change > 0.1:
+                    active.append((jid, 2))
+            else:
+                active.append((jid, 1))
+
+        active.sort(key=lambda x: x[1], reverse=True)
+        return [jid for jid, _ in active[:max_active]]
+
     def process_player_argument(
         self,
         content: str,
         argument_type: str,
         target_id: str | None = None
     ) -> TurnResult:
-        """Process an argument from the human player.
-
-        Args:
-            content: The argument text
-            argument_type: Type of argument (e.g., "challenge_evidence")
-            target_id: Optional specific juror being addressed
-
-        Returns:
-            TurnResult with impacts
-        """
-        # Create turn
+        """Process an argument from the human player."""
         turn = DeliberationTurn(
             round_number=self.state.round_number,
             speaker_id="juror_7",
@@ -391,17 +360,13 @@ class OrchestratorAgent:
             target_id=target_id
         )
 
-        # Process reactions
         conviction_changes = {}
         vote_changes = []
 
         for juror_id, agent in self.juror_agents.items():
             old_vote = self.state.votes.get(juror_id)
-
-            # Player arguments have slightly higher base impact
             base_impact = random.uniform(-0.1, 0.1) * 1.2
 
-            # Bonus if targeting this specific juror
             if target_id == juror_id:
                 base_impact *= 1.5
 
@@ -416,7 +381,6 @@ class OrchestratorAgent:
             conviction_changes[juror_id] = delta
             turn.impact[juror_id] = delta
 
-            # Check vote change
             new_vote = agent.get_vote()
             if old_vote != new_vote:
                 self.state.votes[juror_id] = new_vote
@@ -433,15 +397,10 @@ class OrchestratorAgent:
         )
 
     def set_player_side(self, side: str) -> None:
-        """Set the player's chosen side.
-
-        Args:
-            side: "prosecute" or "defend"
-        """
+        """Set the player's chosen side."""
         self.state.player_side = side
         self.state.phase = GamePhase.DELIBERATION
 
-        # Set player vote
         player_vote = "guilty" if side == "prosecute" else "not_guilty"
         self.state.votes["juror_7"] = player_vote
         self.state.conviction_scores["juror_7"] = 0.8 if side == "prosecute" else 0.2

requirements.txt

@@ -13,6 +13,11 @@ elevenlabs>=1.0.0
 
 # Agents
 smolagents>=1.0.0
+litellm>=1.30.0
+
+# LlamaIndex RAG with Nebius embeddings
+llama-index-core>=0.10.0
+llama-index-embeddings-nebius>=0.1.0
 
 # Utilities
 httpx>=0.27.0