refactor(cleanup): Remove Anthropic + Modal partial wiring (P3 Tech Debt) (#130)

## P3 Tech Debt Cleanup Complete

### Anthropic Removal
- Removed partial wiring that never worked end-to-end
- Cleaned config, factory, app, agent_factory

### Modal Removal
- Deleted code_execution, statistical_analyzer, analysis agents
- Net reduction: ~1400 lines of dead code

### CodeRabbit Fixes
- Removed duplicate chromadb/sentence-transformers from extras
- Kept them in core deps (needed for evidence deduplication)
- Pinned requires-python to >=3.11,<4.0
- Removed Modal deps from requirements.txt

✅ 302 tests pass

AGENTS.md

@@ -60,13 +60,11 @@ Research Report with Citations
 - `src/tools/pubmed.py` - PubMed E-utilities search
 - `src/tools/clinicaltrials.py` - ClinicalTrials.gov API
 - `src/tools/europepmc.py` - Europe PMC search
-- `src/tools/code_execution.py` - Modal sandbox execution
 - `src/tools/search_handler.py` - Scatter-gather orchestration
 - `src/services/embeddings.py` - Local embeddings (sentence-transformers, in-memory)
 - `src/services/llamaindex_rag.py` - Premium embeddings (OpenAI, persistent ChromaDB)
 - `src/services/embedding_protocol.py` - Protocol interface for embedding services
 - `src/services/research_memory.py` - Shared memory layer for research state
-- `src/services/statistical_analyzer.py` - Statistical analysis via Modal
 - `src/utils/service_loader.py` - Tiered service selection (free vs premium)
 - `src/agent_factory/judges.py` - LLM-based evidence assessment
 - `src/agents/` - Magentic multi-agent mode (SearchAgent, JudgeAgent, etc.)
@@ -82,10 +80,9 @@ Research Report with Citations
 
 Settings via pydantic-settings from `.env`:
 
-- `LLM_PROVIDER`: "openai" or "anthropic"
-- `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`: LLM keys
+- `LLM_PROVIDER`: "openai" or "huggingface"
+- `OPENAI_API_KEY`: LLM keys
 - `NCBI_API_KEY`: Optional, for higher PubMed rate limits
-- `MODAL_TOKEN_ID` / `MODAL_TOKEN_SECRET`: For Modal sandbox (optional)
 - `MAX_ITERATIONS`: 1-50, default 10
 - `LOG_LEVEL`: DEBUG, INFO, WARNING, ERROR
 
@@ -107,8 +104,6 @@ Default models in `src/utils/config.py`:
 - **OpenAI:** `gpt-5` - Flagship model
 - **HuggingFace (Free Tier):** `Qwen/Qwen2.5-7B-Instruct` - See critical note below
 
-**NOTE:** Anthropic is NOT supported (no embeddings API). See `P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md`.
-
 ---
 
 ## ⚠️ OpenAI API Keys

CLAUDE.md

@@ -60,13 +60,11 @@ Research Report with Citations
 - `src/tools/pubmed.py` - PubMed E-utilities search
 - `src/tools/clinicaltrials.py` - ClinicalTrials.gov API
 - `src/tools/europepmc.py` - Europe PMC search
-- `src/tools/code_execution.py` - Modal sandbox execution
 - `src/tools/search_handler.py` - Scatter-gather orchestration
 - `src/services/embeddings.py` - Local embeddings (sentence-transformers, in-memory)
 - `src/services/llamaindex_rag.py` - Premium embeddings (OpenAI, persistent ChromaDB)
 - `src/services/embedding_protocol.py` - Protocol interface for embedding services
 - `src/services/research_memory.py` - Shared memory layer for research state
-- `src/services/statistical_analyzer.py` - Statistical analysis via Modal
 - `src/utils/service_loader.py` - Tiered service selection (free vs premium)
 - `src/agent_factory/judges.py` - LLM-based evidence assessment
 - `src/agents/` - Magentic multi-agent mode (SearchAgent, JudgeAgent, etc.)
@@ -82,10 +80,9 @@ Research Report with Citations
 
 Settings via pydantic-settings from `.env`:
 
-- `LLM_PROVIDER`: "openai" or "anthropic"
-- `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`: LLM keys
+- `LLM_PROVIDER`: "openai" or "huggingface"
+- `OPENAI_API_KEY`: LLM keys
 - `NCBI_API_KEY`: Optional, for higher PubMed rate limits
-- `MODAL_TOKEN_ID` / `MODAL_TOKEN_SECRET`: For Modal sandbox (optional)
 - `MAX_ITERATIONS`: 1-50, default 10
 - `LOG_LEVEL`: DEBUG, INFO, WARNING, ERROR
 
@@ -114,8 +111,6 @@ Default models in `src/utils/config.py`:
 - **OpenAI:** `gpt-5` - Flagship model
 - **HuggingFace (Free Tier):** `Qwen/Qwen2.5-7B-Instruct` - See critical note below
 
-**NOTE:** Anthropic is NOT supported (no embeddings API). See `P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md`.
-
 ---
 
 ## ⚠️ OpenAI API Keys

GEMINI.md

@@ -16,7 +16,6 @@ The project follows a **Vertical Slice Architecture** (Search -> Judge -> Orches
 - **Package Manager:** `uv` (Rust-based, extremely fast)
 - **Frameworks:** `pydantic`, `pydantic-ai`, `httpx`, `gradio[mcp]`
 - **Vector DB:** `chromadb` with `sentence-transformers` for semantic search
-- **Code Execution:** `modal` for secure sandboxed Python execution
 - **Testing:** `pytest`, `pytest-asyncio`, `respx` (for mocking)
 - **Quality:** `ruff` (linting/formatting), `mypy` (strict type checking), `pre-commit`
 
@@ -60,13 +59,11 @@ The project follows a **Vertical Slice Architecture** (Search -> Judge -> Orches
 - `src/tools/pubmed.py` - PubMed E-utilities search
 - `src/tools/clinicaltrials.py` - ClinicalTrials.gov API
 - `src/tools/europepmc.py` - Europe PMC search
-- `src/tools/code_execution.py` - Modal sandbox execution
 - `src/tools/search_handler.py` - Scatter-gather orchestration
 - `src/services/embeddings.py` - Local embeddings (sentence-transformers, in-memory)
 - `src/services/llamaindex_rag.py` - Premium embeddings (OpenAI, persistent ChromaDB)
 - `src/services/embedding_protocol.py` - Protocol interface for embedding services
 - `src/services/research_memory.py` - Shared memory layer for research state
-- `src/services/statistical_analyzer.py` - Statistical analysis via Modal
 - `src/utils/service_loader.py` - Tiered service selection (free vs premium)
 - `src/mcp_tools.py` - MCP tool wrappers
 - `src/app.py` - Gradio UI (HuggingFace Spaces) with MCP server
@@ -75,10 +72,9 @@ The project follows a **Vertical Slice Architecture** (Search -> Judge -> Orches
 
 Settings via pydantic-settings from `.env`:
 
-- `LLM_PROVIDER`: "openai" or "anthropic"
-- `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`: LLM keys
+- `LLM_PROVIDER`: "openai" or "huggingface"
+- `OPENAI_API_KEY`: LLM keys
 - `NCBI_API_KEY`: Optional, for higher PubMed rate limits
-- `MODAL_TOKEN_ID` / `MODAL_TOKEN_SECRET`: For Modal sandbox (optional)
 - `MAX_ITERATIONS`: 1-50, default 10
 - `LOG_LEVEL`: DEBUG, INFO, WARNING, ERROR
 
@@ -89,8 +85,6 @@ Default models in `src/utils/config.py`:
 - **OpenAI:** `gpt-5` - Flagship model
 - **HuggingFace (Free Tier):** `Qwen/Qwen2.5-7B-Instruct` - See critical note below
 
-**NOTE:** Anthropic is NOT supported (no embeddings API). See `P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md`.
-
 ---
 
 ## ⚠️ OpenAI API Keys

docs/future-roadmap/P3_MODAL_INTEGRATION_REMOVAL.md

@@ -1,7 +1,7 @@
 # P3 Tech Debt: Modal Integration Removal
 
 **Date**: 2025-12-04
-**Status**: OPEN - Tech Debt (Future Roadmap)
+**Status**: DONE
 **Severity**: P3 (Tech Debt - Not blocking functionality)
 **Component**: Multiple files
 

docs/future-roadmap/P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md

@@ -1,7 +1,7 @@
 # P3 Tech Debt: Remove Anthropic Partial Wiring
 
 **Date**: 2025-12-03
-**Status**: OPEN
+**Status**: DONE
 **Severity**: P3 (Tech Debt / Simplification)
 **Component**: Architecture / Provider Integration
 

examples/modal_demo/run_analysis.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-"""Demo: Modal-powered statistical analysis.
-
-This script uses StatisticalAnalyzer directly (NO agent_framework dependency).
-
-# Usage:
-#   source .env
-#   uv run python examples/modal_demo/run_analysis.py "testosterone libido"
-"""
-
-import argparse
-import asyncio
-import os
-import sys
-
-from src.services.statistical_analyzer import get_statistical_analyzer
-from src.tools.pubmed import PubMedTool
-from src.utils.config import settings
-
-
-async def main() -> None:
-    """Run the Modal analysis demo."""
-    parser = argparse.ArgumentParser(description="Modal Analysis Demo")
-    parser.add_argument("query", help="Research query")
-    args = parser.parse_args()
-
-    if not settings.modal_available:
-        print("Error: Modal credentials not configured.")
-        sys.exit(1)
-
-    if not (os.getenv("OPENAI_API_KEY") or os.getenv("ANTHROPIC_API_KEY")):
-        print("Error: No LLM API key found.")
-        sys.exit(1)
-
-    print(f"\n{'=' * 60}")
-    print("DeepBoner Modal Analysis Demo")
-    print(f"Query: {args.query}")
-    print(f"{'=' * 60}\n")
-
-    # Step 1: Gather Evidence
-    print("Step 1: Gathering evidence from PubMed...")
-    pubmed = PubMedTool()
-    evidence = await pubmed.search(args.query, max_results=5)
-    print(f"  Found {len(evidence)} papers\n")
-
-    # Step 2: Run Modal Analysis
-    print("Step 2: Running statistical analysis in Modal sandbox...")
-    analyzer = get_statistical_analyzer()
-    result = await analyzer.analyze(query=args.query, evidence=evidence)
-
-    # Step 3: Display Results
-    print("\n" + "=" * 60)
-    print("ANALYSIS RESULTS")
-    print("=" * 60)
-    print(f"\nVerdict: {result.verdict}")
-    print(f"Confidence: {result.confidence:.0%}")
-    print("\nKey Findings:")
-    for finding in result.key_findings:
-        print(f"  - {finding}")
-
-    print("\n[Demo Complete - Code executed in Modal, not locally]")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

examples/modal_demo/test_code_execution.py

@@ -1,169 +0,0 @@
-"""Demo script to test Modal code execution integration.
-
-Run with: uv run python examples/modal_demo/test_code_execution.py
-"""
-
-import sys
-from pathlib import Path
-
-# Add src to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from src.tools.code_execution import CodeExecutionError, get_code_executor
-
-
-def test_basic_execution():
-    """Test basic code execution."""
-    print("\n=== Test 1: Basic Execution ===")
-    executor = get_code_executor()
-
-    code = """
-print("Hello from Modal sandbox!")
-result = 2 + 2
-print(f"2 + 2 = {result}")
-"""
-
-    result = executor.execute(code)
-    print(f"Success: {result['success']}")
-    print(f"Stdout:\n{result['stdout']}")
-    if result["stderr"]:
-        print(f"Stderr:\n{result['stderr']}")
-
-
-def test_scientific_computing():
-    """Test scientific computing libraries."""
-    print("\n=== Test 2: Scientific Computing ===")
-    executor = get_code_executor()
-
-    code = """
-import pandas as pd
-import numpy as np
-
-# Create sample data
-data = {
-    'drug': ['DrugA', 'DrugB', 'DrugC'],
-    'efficacy': [0.75, 0.82, 0.68],
-    'sample_size': [100, 150, 120]
-}
-
-df = pd.DataFrame(data)
-
-# Calculate weighted average
-weighted_avg = np.average(df['efficacy'], weights=df['sample_size'])
-
-print(f"Drugs tested: {len(df)}")
-print(f"Weighted average efficacy: {weighted_avg:.3f}")
-print("\\nDataFrame:")
-print(df.to_string())
-"""
-
-    result = executor.execute(code)
-    print(f"Success: {result['success']}")
-    print(f"Output:\n{result['stdout']}")
-
-
-def test_statistical_analysis():
-    """Test statistical analysis."""
-    print("\n=== Test 3: Statistical Analysis ===")
-    executor = get_code_executor()
-
-    code = """
-import numpy as np
-from scipy import stats
-
-# Simulate two treatment groups
-np.random.seed(42)
-control_group = np.random.normal(100, 15, 50)
-treatment_group = np.random.normal(110, 15, 50)
-
-# Perform t-test
-t_stat, p_value = stats.ttest_ind(treatment_group, control_group)
-
-print(f"Control mean: {np.mean(control_group):.2f}")
-print(f"Treatment mean: {np.mean(treatment_group):.2f}")
-print(f"T-statistic: {t_stat:.3f}")
-print(f"P-value: {p_value:.4f}")
-
-if p_value < 0.05:
-    print("Result: Statistically significant difference")
-else:
-    print("Result: No significant difference")
-"""
-
-    result = executor.execute(code)
-    print(f"Success: {result['success']}")
-    print(f"Output:\n{result['stdout']}")
-
-
-def test_with_return_value():
-    """Test execute_with_return method."""
-    print("\n=== Test 4: Return Value ===")
-    executor = get_code_executor()
-
-    code = """
-import numpy as np
-
-# Calculate something
-data = np.array([1, 2, 3, 4, 5])
-result = {
-    'mean': float(np.mean(data)),
-    'std': float(np.std(data)),
-    'sum': int(np.sum(data))
-}
-"""
-
-    try:
-        result = executor.execute_with_return(code)
-        print(f"Returned result: {result}")
-        print(f"Mean: {result['mean']}")
-        print(f"Std: {result['std']}")
-        print(f"Sum: {result['sum']}")
-    except CodeExecutionError as e:
-        print(f"Error: {e}")
-
-
-def test_error_handling():
-    """Test error handling."""
-    print("\n=== Test 5: Error Handling ===")
-    executor = get_code_executor()
-
-    code = """
-# This will fail
-x = 1 / 0
-"""
-
-    result = executor.execute(code)
-    print(f"Success: {result['success']}")
-    print(f"Error: {result['error']}")
-
-
-def main():
-    """Run all tests."""
-    print("=" * 60)
-    print("Modal Code Execution Demo")
-    print("=" * 60)
-
-    tests = [
-        test_basic_execution,
-        test_scientific_computing,
-        test_statistical_analysis,
-        test_with_return_value,
-        test_error_handling,
-    ]
-
-    for test in tests:
-        try:
-            test()
-        except Exception as e:
-            print(f"\n❌ Test failed: {e}")
-            import traceback
-
-            traceback.print_exc()
-
-    print("\n" + "=" * 60)
-    print("Demo completed!")
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    main()

examples/modal_demo/verify_sandbox.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""Verify that Modal sandbox is properly isolated.
-
-This script proves to judges that code runs in Modal, not locally.
-NO agent_framework dependency - uses only src.tools.code_execution.
-
-Usage:
-    uv run python examples/modal_demo/verify_sandbox.py
-"""
-
-import asyncio
-from functools import partial
-
-from src.tools.code_execution import CodeExecutionError, get_code_executor
-from src.utils.config import settings
-
-
-def print_result(result: dict) -> None:
-    """Print execution result, surfacing errors when they occur."""
-    if result.get("success"):
-        print(f"  {result['stdout'].strip()}\n")
-    else:
-        error = result.get("error") or result.get("stderr", "").strip() or "Unknown error"
-        print(f"  ERROR: {error}\n")
-
-
-async def main() -> None:
-    """Verify Modal sandbox isolation."""
-    if not settings.modal_available:
-        print("Error: Modal credentials not configured.")
-        print("Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET in .env")
-        return
-
-    try:
-        executor = get_code_executor()
-        loop = asyncio.get_running_loop()
-
-        print("=" * 60)
-        print("Modal Sandbox Isolation Verification")
-        print("=" * 60 + "\n")
-
-        # Test 1: Hostname
-        print("Test 1: Check hostname (should NOT be your machine)")
-        code1 = "import socket; print(f'Hostname: {socket.gethostname()}')"
-        result1 = await loop.run_in_executor(None, partial(executor.execute, code1))
-        print_result(result1)
-
-        # Test 2: Scientific libraries
-        print("Test 2: Verify scientific libraries")
-        code2 = """
-import pandas as pd
-import numpy as np
-import scipy
-print(f"pandas: {pd.__version__}")
-print(f"numpy: {np.__version__}")
-print(f"scipy: {scipy.__version__}")
-"""
-        result2 = await loop.run_in_executor(None, partial(executor.execute, code2))
-        print_result(result2)
-
-        # Test 3: Network blocked
-        print("Test 3: Verify network isolation")
-        code3 = """
-import urllib.request
-try:
-    urllib.request.urlopen("https://google.com", timeout=2)
-    print("Network: ALLOWED (unexpected!)")
-except Exception:
-    print("Network: BLOCKED (as expected)")
-"""
-        result3 = await loop.run_in_executor(None, partial(executor.execute, code3))
-        print_result(result3)
-
-        # Test 4: Real statistics
-        print("Test 4: Execute statistical analysis")
-        code4 = """
-import pandas as pd
-import scipy.stats as stats
-
-data = pd.DataFrame({'effect': [0.42, 0.38, 0.51]})
-mean = data['effect'].mean()
-t_stat, p_val = stats.ttest_1samp(data['effect'], 0)
-
-print(f"Mean Effect: {mean:.3f}")
-print(f"P-value: {p_val:.4f}")
-print(f"Verdict: {'SUPPORTED' if p_val < 0.05 else 'INCONCLUSIVE'}")
-"""
-        result4 = await loop.run_in_executor(None, partial(executor.execute, code4))
-        print_result(result4)
-
-        print("=" * 60)
-        print("All tests complete - Modal sandbox verified!")
-        print("=" * 60)
-
-    except CodeExecutionError as e:
-        print(f"Error: Modal code execution failed: {e}")
-        print("Hint: Ensure Modal SDK is installed and credentials are valid.")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "AI-Native Sexual Health Research Agent"
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<4.0"
 dependencies = [
     # Core
     "pydantic>=2.7",
@@ -12,7 +12,8 @@ dependencies = [
     "pydantic-ai>=0.0.16", # Agent framework
     # AI Providers
     "openai>=1.0.0",
-    "anthropic>=0.18.0",
+        "chromadb>=0.4.22",
+        "sentence-transformers>=2.2.2",
     # HTTP & Parsing
     "httpx>=0.27", # Async HTTP client (PubMed)
     "beautifulsoup4>=4.12", # HTML parsing
@@ -62,18 +63,12 @@ dev = [
 magentic = [
     "agent-framework-core>=1.0.0b251120,<2.0.0",  # Microsoft Agent Framework (PyPI)
 ]
-embeddings = [
-    "chromadb>=0.4.0",
-    "sentence-transformers>=2.2.0",
-]
-modal = [
-    # Mario's Modal code execution + LlamaIndex RAG
-    "modal>=0.63.0",
+rag = [
+    # LlamaIndex RAG support (chromadb already in core deps)
     "llama-index>=0.11.0",
     "llama-index-llms-openai",
     "llama-index-embeddings-openai",
     "llama-index-vector-stores-chroma",
-    "chromadb>=0.4.0",
 ]
 
 [build-system]

requirements.txt

@@ -5,7 +5,8 @@ pydantic-ai>=0.0.16
 
 # AI Providers
 openai>=1.0.0
-anthropic>=0.18.0
+chromadb>=0.4.22
+sentence-transformers>=2.2.2
 huggingface-hub>=0.20.0
 
 # Multi-agent orchestration (Advanced mode)
@@ -37,9 +38,8 @@ requests>=2.32.5
 limits>=3.0
 urllib3>=2.5.0  # Security fix for GHSA-48p4-8xcf-vxj5
 
-# Optional: Modal for code execution
-modal>=0.63.0
-
-# Optional: Embeddings & Vector Store
-chromadb>=0.4.0
-sentence-transformers>=2.2.0
+# Optional: LlamaIndex RAG (chromadb/sentence-transformers already in core above)
+llama-index>=0.11.0
+llama-index-llms-openai
+llama-index-embeddings-openai
+llama-index-vector-stores-chroma

src/agent_factory/judges.py

@@ -63,24 +63,11 @@ def get_model(api_key: str | None = None) -> Any:
 
     Args:
         api_key: Optional BYOK key. Auto-detects provider from prefix:
-                 - "sk-ant-..." → Anthropic (NOT SUPPORTED - raises error)
                  - "sk-..." → OpenAI
                  - Other → Falls through to env vars
-
-    Raises:
-        NotImplementedError: If Anthropic key detected (no embeddings support).
-
-    Note: Anthropic is NOT supported because it lacks embeddings API.
-    See P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md.
     """
     # Priority 1: BYOK - Auto-detect provider from key prefix
     if api_key:
-        if api_key.startswith("sk-ant-"):
-            # Anthropic not supported - no embeddings API
-            raise NotImplementedError(
-                "Anthropic is not supported (no embeddings API). "
-                "Use OpenAI key (sk-...) or leave empty for free HuggingFace tier."
-            )
         if api_key.startswith("sk-"):
             # OpenAI BYOK
             openai_provider = OpenAIProvider(api_key=api_key)

src/agents/analysis_agent.py

@@ -1,145 +0,0 @@
-"""Analysis agent for statistical analysis using Modal code execution.
-
-This agent wraps StatisticalAnalyzer for use in magentic multi-agent mode.
-The core logic is in src/services/statistical_analyzer.py to avoid
-coupling agent_framework to the simple orchestrator.
-"""
-
-from collections.abc import AsyncIterable
-from typing import TYPE_CHECKING, Any
-
-from agent_framework import (
-    AgentRunResponse,
-    AgentRunResponseUpdate,
-    AgentThread,
-    BaseAgent,
-    ChatMessage,
-    Role,
-)
-
-from src.services.statistical_analyzer import (
-    AnalysisResult,
-    get_statistical_analyzer,
-)
-
-if TYPE_CHECKING:
-    from src.services.embeddings import EmbeddingService
-
-
-class AnalysisAgent(BaseAgent):  # type: ignore[misc]
-    """Wraps StatisticalAnalyzer for magentic multi-agent mode."""
-
-    def __init__(
-        self,
-        evidence_store: dict[str, Any],
-        embedding_service: "EmbeddingService | None" = None,
-    ) -> None:
-        super().__init__(
-            name="AnalysisAgent",
-            description="Performs statistical analysis using Modal sandbox",
-        )
-        self._evidence_store = evidence_store
-        self._embeddings = embedding_service
-        self._analyzer = get_statistical_analyzer()
-
-    async def run(
-        self,
-        messages: str | ChatMessage | list[str] | list[ChatMessage] | None = None,
-        *,
-        thread: AgentThread | None = None,
-        **kwargs: Any,
-    ) -> AgentRunResponse:
-        """Analyze evidence and return verdict."""
-        query = self._extract_query(messages)
-        hypotheses = self._evidence_store.get("hypotheses", [])
-        evidence = self._evidence_store.get("current", [])
-
-        if not evidence:
-            return self._error_response("No evidence available.")
-
-        # Get primary hypothesis if available
-        hypothesis_dict = None
-        if hypotheses:
-            h = hypotheses[0]
-            hypothesis_dict = {
-                "drug": getattr(h, "drug", "Unknown"),
-                "target": getattr(h, "target", "?"),
-                "pathway": getattr(h, "pathway", "?"),
-                "effect": getattr(h, "effect", "?"),
-                "confidence": getattr(h, "confidence", 0.5),
-            }
-
-        # Delegate to StatisticalAnalyzer
-        result = await self._analyzer.analyze(
-            query=query,
-            evidence=evidence,
-            hypothesis=hypothesis_dict,
-        )
-
-        # Store in shared context
-        self._evidence_store["analysis"] = result.model_dump()
-
-        # Format response
-        response_text = self._format_response(result)
-
-        return AgentRunResponse(
-            messages=[ChatMessage(role=Role.ASSISTANT, text=response_text)],
-            response_id=f"analysis-{result.verdict.lower()}",
-            additional_properties={"analysis": result.model_dump()},
-        )
-
-    def _format_response(self, result: AnalysisResult) -> str:
-        """Format analysis result as markdown."""
-        lines = [
-            "## Statistical Analysis Complete\n",
-            f"### Verdict: **{result.verdict}**",
-            f"**Confidence**: {result.confidence:.0%}\n",
-            "### Key Findings",
-        ]
-        for finding in result.key_findings:
-            lines.append(f"- {finding}")
-
-        lines.extend(
-            [
-                "\n### Statistical Evidence",
-                "```",
-                result.statistical_evidence,
-                "```",
-            ]
-        )
-        return "\n".join(lines)
-
-    def _error_response(self, message: str) -> AgentRunResponse:
-        """Create error response."""
-        return AgentRunResponse(
-            messages=[ChatMessage(role=Role.ASSISTANT, text=f"**Error**: {message}")],
-            response_id="analysis-error",
-        )
-
-    def _extract_query(
-        self,
-        messages: str | ChatMessage | list[str] | list[ChatMessage] | None,
-    ) -> str:
-        """Extract query from messages."""
-        if isinstance(messages, str):
-            return messages
-        elif isinstance(messages, ChatMessage):
-            return messages.text or ""
-        elif isinstance(messages, list):
-            for msg in reversed(messages):
-                if isinstance(msg, ChatMessage) and msg.role == Role.USER:
-                    return msg.text or ""
-                elif isinstance(msg, str):
-                    return msg
-        return ""
-
-    async def run_stream(
-        self,
-        messages: str | ChatMessage | list[str] | list[ChatMessage] | None = None,
-        *,
-        thread: AgentThread | None = None,
-        **kwargs: Any,
-    ) -> AsyncIterable[AgentRunResponseUpdate]:
-        """Streaming wrapper."""
-        result = await self.run(messages, thread=thread, **kwargs)
-        yield AgentRunResponseUpdate(messages=result.messages, response_id=result.response_id)

src/agents/code_executor_agent.py

@@ -1,66 +0,0 @@
-"""Code execution agent using Modal."""
-
-import asyncio
-
-import structlog
-from agent_framework import ChatAgent, ai_function
-
-from src.clients.base import BaseChatClient
-from src.clients.factory import get_chat_client
-from src.tools.code_execution import get_code_executor
-
-logger = structlog.get_logger()
-
-
-@ai_function  # type: ignore[arg-type, misc]
-async def execute_python_code(code: str) -> str:
-    """Execute Python code in a secure sandbox.
-
-    Args:
-        code: The Python code to execute.
-
-    Returns:
-        The standard output and standard error of the execution.
-    """
-    logger.info("Code execution starting", code_length=len(code))
-    executor = get_code_executor()
-    loop = asyncio.get_running_loop()
-
-    # Run in executor to avoid blocking
-    try:
-        result = await loop.run_in_executor(None, lambda: executor.execute(code))
-        if result["success"]:
-            logger.info("Code execution succeeded")
-            return f"Stdout:\n{result['stdout']}"
-        else:
-            logger.warning("Code execution failed", error=result.get("error"))
-            return f"Error:\n{result['error']}\nStderr:\n{result['stderr']}"
-    except Exception as e:
-        logger.error("Code execution exception", error=str(e))
-        return f"Execution failed: {e}"
-
-
-def create_code_executor_agent(chat_client: BaseChatClient | None = None) -> ChatAgent:
-    """Create a code executor agent.
-
-    Args:
-        chat_client: Optional custom chat client.
-
-    Returns:
-        ChatAgent configured for code execution.
-    """
-    client = chat_client or get_chat_client()
-
-    return ChatAgent(
-        name="CodeExecutorAgent",
-        description="Executes Python code for data analysis, calculation, and simulation.",
-        instructions="""You are a code execution expert.
-When asked to analyze data or perform calculations, write Python code and execute it.
-Use libraries like pandas, numpy, scipy, matplotlib.
-
-Always output the code you want to execute using the `execute_python_code` tool.
-Check the output and interpret the results.""",
-        chat_client=client,
-        tools=[execute_python_code],
-        temperature=0.0,  # Strict code generation
-    )

src/app.py

@@ -161,7 +161,7 @@ async def research_agent(
     if not has_paid_key:
         yield (
             "🤗 **Free Tier**: Using HuggingFace Inference (Llama 3.1 / Mistral) for AI analysis.\n"
-            "For premium models, enter an OpenAI or Anthropic API key below.\n\n"
+            "For premium models, enter an OpenAI API key below.\n\n"
         )
 
     # Run the agent and stream events

src/mcp_tools.py

@@ -161,72 +161,3 @@ async def search_all_sources(
         formatted.append(f"## Europe PMC\n*Error: {europepmc_results}*\n")
 
     return "\n---\n".join(formatted)
-
-
-async def analyze_hypothesis(
-    drug: str,
-    condition: str,
-    evidence_summary: str,
-) -> str:
-    """Perform statistical analysis of research hypothesis using Modal.
-
-    Executes AI-generated Python code in a secure Modal sandbox to analyze
-    the statistical evidence for a research hypothesis.
-
-    Args:
-        drug: The drug being evaluated (e.g., "sildenafil")
-        condition: The target condition (e.g., "erectile dysfunction")
-        evidence_summary: Summary of evidence to analyze
-
-    Returns:
-        Analysis result with verdict (SUPPORTED/REFUTED/INCONCLUSIVE) and statistics
-    """
-    from src.services.statistical_analyzer import get_statistical_analyzer
-    from src.utils.config import settings
-    from src.utils.models import Citation, Evidence
-
-    if not settings.modal_available:
-        return "Error: Modal credentials not configured. Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET."
-
-    # Create evidence from summary
-    evidence = [
-        Evidence(
-            content=evidence_summary,
-            citation=Citation(
-                source="pubmed",
-                title=f"Evidence for {drug} in {condition}",
-                url="https://example.com",
-                date="2024-01-01",
-                authors=["User Provided"],
-            ),
-            relevance=0.9,
-        )
-    ]
-
-    analyzer = get_statistical_analyzer()
-    result = await analyzer.analyze(
-        query=f"Can {drug} treat {condition}?",
-        evidence=evidence,
-        hypothesis={"drug": drug, "target": "unknown", "pathway": "unknown", "effect": condition},
-    )
-
-    return f"""## Statistical Analysis: {drug} for {condition}
-
-### Verdict: **{result.verdict}**
-**Confidence**: {result.confidence:.0%}
-
-### Key Findings
-{chr(10).join(f"- {f}" for f in result.key_findings) or "- No specific findings extracted"}
-
-### Execution Output
-```
-{result.execution_output}
-```
-
-### Generated Code
-```python
-{result.code_generated}
-```
-
-**Executed in Modal Sandbox** - Isolated, secure, reproducible.
-"""

src/services/llamaindex_rag.py

@@ -1,6 +1,6 @@
 """LlamaIndex RAG service for evidence retrieval and indexing.
 
-Requires optional dependencies: uv sync --extra modal
+Requires optional dependencies: uv sync --extra rag
 
 Migration Note (v1.0 rebrand):
     Default collection_name changed from "deepcritical_evidence" to "deepboner_evidence".
@@ -64,7 +64,7 @@ class LlamaIndexRAGService:
             from llama_index.vector_stores.chroma import ChromaVectorStore
         except ImportError as e:
             raise ImportError(
-                "LlamaIndex dependencies not installed. Run: uv sync --extra modal"
+                "LlamaIndex dependencies not installed. Run: uv sync --extra rag"
             ) from e
 
         # Store references for use in other methods
@@ -91,12 +91,6 @@ class LlamaIndexRAGService:
             raise ConfigurationError("OPENAI_API_KEY required for LlamaIndex RAG service")
 
         # Defense-in-depth: Validate key prefix to prevent cryptic auth errors
-        # Note: Anthropic keys start with sk-ant-, which would pass startswith("sk-")
-        if self.api_key.startswith("sk-ant-"):
-            raise ConfigurationError(
-                "Anthropic keys (sk-ant-...) are not supported for embeddings. "
-                "LlamaIndex RAG requires an OpenAI API key (sk-...)."
-            )
         if not self.api_key.startswith("sk-"):
             raise ConfigurationError(
                 f"Invalid API key format. Expected OpenAI key starting with 'sk-', "

src/services/statistical_analyzer.py

@@ -1,259 +0,0 @@
-"""Statistical analysis service using Modal code execution.
-
-This module provides Modal-based statistical analysis WITHOUT depending on
-agent_framework. This allows it to be used in the simple orchestrator mode
-without requiring the magentic optional dependency.
-
-The AnalysisAgent (in src/agents/) wraps this service for magentic mode.
-"""
-
-import asyncio
-import re
-from functools import lru_cache, partial
-from typing import Any, Literal
-
-import structlog
-
-# Type alias for verdict values
-VerdictType = Literal["SUPPORTED", "REFUTED", "INCONCLUSIVE"]
-
-from pydantic import BaseModel, Field
-from pydantic_ai import Agent
-
-from src.agent_factory.judges import get_model
-from src.tools.code_execution import (
-    CodeExecutionError,
-    get_code_executor,
-    get_sandbox_library_prompt,
-)
-from src.utils.models import Evidence
-
-logger = structlog.get_logger()
-
-
-class AnalysisResult(BaseModel):
-    """Result of statistical analysis."""
-
-    verdict: VerdictType = Field(
-        description="SUPPORTED, REFUTED, or INCONCLUSIVE",
-    )
-    confidence: float = Field(ge=0.0, le=1.0, description="Confidence in verdict (0-1)")
-    statistical_evidence: str = Field(
-        description="Summary of statistical findings from code execution"
-    )
-    code_generated: str = Field(description="Python code that was executed")
-    execution_output: str = Field(description="Output from code execution")
-    key_findings: list[str] = Field(default_factory=list, description="Key takeaways")
-    limitations: list[str] = Field(default_factory=list, description="Limitations")
-
-
-class StatisticalAnalyzer:
-    """Performs statistical analysis using Modal code execution.
-
-    This service:
-    1. Generates Python code for statistical analysis using LLM
-    2. Executes code in Modal sandbox
-    3. Interprets results
-    4. Returns verdict (SUPPORTED/REFUTED/INCONCLUSIVE)
-
-    Note: This class has NO agent_framework dependency, making it safe
-    to use in the simple orchestrator without the magentic extra.
-    """
-
-    def __init__(self) -> None:
-        """Initialize the analyzer."""
-        self._code_executor: Any = None
-        self._agent: Agent[None, str] | None = None
-
-    def _get_code_executor(self) -> Any:
-        """Lazy initialization of code executor."""
-        if self._code_executor is None:
-            self._code_executor = get_code_executor()
-        return self._code_executor
-
-    def _get_agent(self) -> Agent[None, str]:
-        """Lazy initialization of LLM agent for code generation."""
-        if self._agent is None:
-            library_versions = get_sandbox_library_prompt()
-            self._agent = Agent(
-                model=get_model(),
-                output_type=str,
-                system_prompt=f"""You are a biomedical data scientist.
-
-Generate Python code to analyze research evidence and test hypotheses.
-
-Guidelines:
-1. Use pandas, numpy, scipy.stats for analysis
-2. Print clear, interpretable results
-3. Include statistical tests (t-tests, chi-square, etc.)
-4. Calculate effect sizes and confidence intervals
-5. Keep code concise (<50 lines)
-6. Set 'result' variable to SUPPORTED, REFUTED, or INCONCLUSIVE
-
-Available libraries:
-{library_versions}
-
-Output format: Return ONLY executable Python code, no explanations.""",
-            )
-        return self._agent
-
-    async def analyze(
-        self,
-        query: str,
-        evidence: list[Evidence],
-        hypothesis: dict[str, Any] | None = None,
-    ) -> AnalysisResult:
-        """Run statistical analysis on evidence.
-
-        Args:
-            query: The research question
-            evidence: List of Evidence objects to analyze
-            hypothesis: Optional hypothesis dict with drug, target, pathway, effect
-
-        Returns:
-            AnalysisResult with verdict and statistics
-        """
-        # Build analysis prompt (method handles slicing internally)
-        evidence_summary = self._summarize_evidence(evidence)
-        hypothesis_text = ""
-        if hypothesis:
-            hypothesis_text = (
-                f"\nHypothesis: {hypothesis.get('drug', 'Unknown')} → "
-                f"{hypothesis.get('target', '?')} → "
-                f"{hypothesis.get('pathway', '?')} → "
-                f"{hypothesis.get('effect', '?')}\n"
-                f"Confidence: {hypothesis.get('confidence', 0.5):.0%}\n"
-            )
-
-        prompt = f"""Generate Python code to statistically analyze:
-
-**Research Question**: {query}
-{hypothesis_text}
-
-**Evidence Summary**:
-{evidence_summary}
-
-Generate executable Python code to analyze this evidence."""
-
-        try:
-            # Generate code
-            agent = self._get_agent()
-            code_result = await agent.run(prompt)
-            generated_code = code_result.output
-
-            # Execute in Modal sandbox
-            loop = asyncio.get_running_loop()
-            executor = self._get_code_executor()
-            execution = await loop.run_in_executor(
-                None, partial(executor.execute, generated_code, timeout=120)
-            )
-
-            if not execution["success"]:
-                return AnalysisResult(
-                    verdict="INCONCLUSIVE",
-                    confidence=0.0,
-                    statistical_evidence=(
-                        f"Execution failed: {execution.get('error', 'Unknown error')}"
-                    ),
-                    code_generated=generated_code,
-                    execution_output=execution.get("stderr", ""),
-                    key_findings=[],
-                    limitations=["Code execution failed"],
-                )
-
-            # Interpret results
-            return self._interpret_results(generated_code, execution)
-
-        except CodeExecutionError as e:
-            return AnalysisResult(
-                verdict="INCONCLUSIVE",
-                confidence=0.0,
-                statistical_evidence=str(e),
-                code_generated="",
-                execution_output="",
-                key_findings=[],
-                limitations=[f"Analysis error: {e}"],
-            )
-
-    def _summarize_evidence(self, evidence: list[Evidence]) -> str:
-        """Summarize evidence for code generation prompt."""
-        if not evidence:
-            return "No evidence available."
-
-        lines = []
-        for i, ev in enumerate(evidence[:5], 1):
-            content = ev.content
-            truncated = content[:200] + ("..." if len(content) > 200 else "")
-            lines.append(f"{i}. {truncated}")
-            lines.append(f"   Source: {ev.citation.title}")
-            lines.append(f"   Relevance: {ev.relevance:.0%}\n")
-
-        return "\n".join(lines)
-
-    def _interpret_results(
-        self,
-        code: str,
-        execution: dict[str, Any],
-    ) -> AnalysisResult:
-        """Interpret code execution results."""
-        stdout = execution["stdout"]
-        stdout_upper = stdout.upper()
-
-        # Extract verdict with robust word-boundary matching
-        verdict: VerdictType = "INCONCLUSIVE"
-        if re.search(r"\bSUPPORTED\b", stdout_upper) and not re.search(
-            r"\b(?:NOT|UN)SUPPORTED\b", stdout_upper
-        ):
-            verdict = "SUPPORTED"
-        elif re.search(r"\bREFUTED\b", stdout_upper):
-            verdict = "REFUTED"
-
-        # Extract key findings
-        key_findings = []
-        for line in stdout.split("\n"):
-            line_lower = line.lower()
-            if any(kw in line_lower for kw in ["p-value", "significant", "effect", "mean"]):
-                key_findings.append(line.strip())
-
-        # Calculate confidence from p-values
-        confidence = self._calculate_confidence(stdout)
-
-        return AnalysisResult(
-            verdict=verdict,
-            confidence=confidence,
-            statistical_evidence=stdout.strip(),
-            code_generated=code,
-            execution_output=stdout,
-            key_findings=key_findings[:5],
-            limitations=[
-                "Analysis based on summary data only",
-                "Limited to available evidence",
-                "Statistical tests assume data independence",
-            ],
-        )
-
-    def _calculate_confidence(self, output: str) -> float:
-        """Calculate confidence based on statistical results."""
-        p_values = re.findall(r"p[-\s]?value[:\s]+(\d+\.?\d*)", output.lower())
-
-        if p_values:
-            try:
-                min_p = min(float(p) for p in p_values)
-                if min_p < 0.001:
-                    return 0.95
-                elif min_p < 0.01:
-                    return 0.90
-                elif min_p < 0.05:
-                    return 0.80
-                else:
-                    return 0.60
-            except ValueError:
-                logger.debug("Failed to parse p-values", p_values=p_values)
-
-        return 0.70  # Default
-
-
-@lru_cache(maxsize=1)
-def get_statistical_analyzer() -> StatisticalAnalyzer:
-    """Get or create singleton StatisticalAnalyzer instance (thread-safe via lru_cache)."""
-    return StatisticalAnalyzer()

src/tools/code_execution.py

@@ -1,260 +0,0 @@
-"""Modal-based secure code execution tool for statistical analysis.
-
-This module provides sandboxed Python code execution using Modal's serverless infrastructure.
-It's designed for running LLM-generated statistical analysis code safely.
-"""
-
-from functools import lru_cache
-from typing import Any
-
-import structlog
-
-from src.utils.config import settings
-
-logger = structlog.get_logger(__name__)
-
-# Shared library versions for Modal sandbox - used by both executor and LLM prompts
-# Keep these in sync to avoid version mismatch between generated code and execution
-SANDBOX_LIBRARIES: dict[str, str] = {
-    "pandas": "2.2.0",
-    "numpy": "1.26.4",
-    "scipy": "1.11.4",
-    "matplotlib": "3.8.2",
-    "scikit-learn": "1.4.0",
-    "statsmodels": "0.14.1",
-}
-
-
-def get_sandbox_library_list() -> list[str]:
-    """Get list of library==version strings for Modal image."""
-    return [f"{lib}=={ver}" for lib, ver in SANDBOX_LIBRARIES.items()]
-
-
-def get_sandbox_library_prompt() -> str:
-    """Get formatted library versions for LLM prompts."""
-    return "\n".join(f"- {lib}=={ver}" for lib, ver in SANDBOX_LIBRARIES.items())
-
-
-class CodeExecutionError(Exception):
-    """Raised when code execution fails."""
-
-    pass
-
-
-class ModalCodeExecutor:
-    """Execute Python code securely using Modal sandboxes.
-
-    This class provides a safe environment for executing LLM-generated code,
-    particularly for scientific computing and statistical analysis tasks.
-
-    Features:
-    - Sandboxed execution (isolated from host system)
-    - Pre-installed scientific libraries (numpy, scipy, pandas, matplotlib)
-    - Network isolation for security
-    - Timeout protection
-    - Stdout/stderr capture
-
-    Example:
-        >>> executor = ModalCodeExecutor()
-        >>> result = executor.execute('''
-        ... import pandas as pd
-        ... df = pd.DataFrame({'a': [1, 2, 3]})
-        ... result = df['a'].sum()
-        ... ''')
-        >>> print(result['stdout'])
-        6
-    """
-
-    def __init__(self) -> None:
-        """Initialize Modal code executor.
-
-        Note:
-            Logs a warning if Modal credentials are not configured.
-            Execution will fail at runtime without valid credentials.
-        """
-        # Check for Modal credentials
-        self.modal_token_id = settings.modal_token_id
-        self.modal_token_secret = settings.modal_token_secret
-
-        if not self.modal_token_id or not self.modal_token_secret:
-            logger.warning(
-                "Modal credentials not found. Code execution will fail unless modal setup is run."
-            )
-
-    def execute(self, code: str, timeout: int = 60, allow_network: bool = False) -> dict[str, Any]:
-        """Execute Python code in a Modal sandbox.
-
-        Args:
-            code: Python code to execute
-            timeout: Maximum execution time in seconds (default: 60)
-            allow_network: Whether to allow network access (default: False for security)
-
-        Returns:
-            Dictionary containing:
-                - stdout: Standard output from code execution
-                - stderr: Standard error from code execution
-                - success: Boolean indicating if execution succeeded
-                - error: Error message if execution failed
-
-        Raises:
-            CodeExecutionError: If execution fails or times out
-        """
-        try:
-            import modal
-        except ImportError as e:
-            raise CodeExecutionError(
-                "Modal SDK not installed. Run: uv sync or pip install modal>=0.63.0"
-            ) from e
-
-        logger.info("executing_code", code_length=len(code), timeout=timeout)
-
-        try:
-            # Create or lookup Modal app
-            app = modal.App.lookup("deepboner-code-execution", create_if_missing=True)
-
-            # Define scientific computing image with common libraries
-            scientific_image = modal.Image.debian_slim(python_version="3.11").pip_install(
-                *get_sandbox_library_list()
-            )
-
-            # Create sandbox with security restrictions
-            sandbox = modal.Sandbox.create(
-                app=app,
-                image=scientific_image,
-                timeout=timeout,
-                block_network=not allow_network,  # Wire the network control
-            )
-
-            try:
-                # Execute the code
-                # Wrap code to capture result
-                wrapped_code = f"""
-import sys
-import io
-from contextlib import redirect_stdout, redirect_stderr
-
-stdout_io = io.StringIO()
-stderr_io = io.StringIO()
-
-try:
-    with redirect_stdout(stdout_io), redirect_stderr(stderr_io):
-        {self._indent_code(code, 8)}
-    print("__EXECUTION_SUCCESS__")
-except Exception as e:
-    print(f"__EXECUTION_ERROR__: {{type(e).__name__}}: {{e}}", file=sys.stderr)
-
-print("__STDOUT_START__")
-print(stdout_io.getvalue())
-print("__STDOUT_END__")
-print("__STDERR_START__")
-print(stderr_io.getvalue(), file=sys.stderr)
-print("__STDERR_END__", file=sys.stderr)
-"""
-
-                # Run the wrapped code
-                process = sandbox.exec("python", "-c", wrapped_code, timeout=timeout)
-
-                # Read output
-                stdout_raw = process.stdout.read()
-                stderr_raw = process.stderr.read()
-            finally:
-                # Always clean up sandbox to prevent resource leaks
-                sandbox.terminate()
-
-            # Parse output
-            success = "__EXECUTION_SUCCESS__" in stdout_raw
-
-            # Extract actual stdout/stderr
-            stdout = self._extract_output(stdout_raw, "__STDOUT_START__", "__STDOUT_END__")
-            stderr = self._extract_output(stderr_raw, "__STDERR_START__", "__STDERR_END__")
-
-            result = {
-                "stdout": stdout,
-                "stderr": stderr,
-                "success": success,
-                "error": stderr if not success else None,
-            }
-
-            logger.info(
-                "code_execution_completed",
-                success=success,
-                stdout_length=len(stdout),
-                stderr_length=len(stderr),
-            )
-
-            return result
-
-        except Exception as e:
-            logger.error("code_execution_failed", error=str(e), error_type=type(e).__name__)
-            raise CodeExecutionError(f"Code execution failed: {e}") from e
-
-    def execute_with_return(self, code: str, timeout: int = 60) -> Any:
-        """Execute code and return the value of the 'result' variable.
-
-        Convenience method that executes code and extracts a return value.
-        The code should assign its final result to a variable named 'result'.
-
-        Args:
-            code: Python code to execute (must set 'result' variable)
-            timeout: Maximum execution time in seconds
-
-        Returns:
-            The value of the 'result' variable from the executed code
-
-        Example:
-            >>> executor.execute_with_return("result = 2 + 2")
-            4
-        """
-        # Modify code to print result as JSON
-        wrapped = f"""
-import json
-{code}
-print(json.dumps({{"__RESULT__": result}}))
-"""
-
-        execution_result = self.execute(wrapped, timeout=timeout)
-
-        if not execution_result["success"]:
-            raise CodeExecutionError(f"Execution failed: {execution_result['error']}")
-
-        # Parse result from stdout
-        import json
-
-        try:
-            output = execution_result["stdout"].strip()
-            if "__RESULT__" in output:
-                # Extract JSON line
-                for line in output.split("\n"):
-                    if "__RESULT__" in line:
-                        data = json.loads(line)
-                        return data["__RESULT__"]
-            raise ValueError("Result not found in output")
-        except (json.JSONDecodeError, ValueError) as e:
-            logger.warning(
-                "failed_to_parse_result", error=str(e), stdout=execution_result["stdout"]
-            )
-            return execution_result["stdout"]
-
-    def _indent_code(self, code: str, spaces: int) -> str:
-        """Indent code by specified number of spaces."""
-        indent = " " * spaces
-        return "\n".join(indent + line if line.strip() else line for line in code.split("\n"))
-
-    def _extract_output(self, text: str, start_marker: str, end_marker: str) -> str:
-        """Extract content between markers."""
-        start_idx = text.find(start_marker)
-        if start_idx == -1:
-            return text.strip()
-        start_idx += len(start_marker)
-
-        end_idx = text.find(end_marker, start_idx)
-        if end_idx == -1:
-            return text.strip()
-
-        return text[start_idx:end_idx].strip()
-
-
-@lru_cache(maxsize=1)
-def get_code_executor() -> ModalCodeExecutor:
-    """Get or create singleton code executor instance (thread-safe via lru_cache)."""
-    return ModalCodeExecutor()

src/utils/config.py

@@ -42,7 +42,7 @@ class Settings(BaseSettings):
     )
 
     # Embedding Configuration
-    # Note: OpenAI embeddings require OPENAI_API_KEY (Anthropic has no embeddings API)
+    # Note: OpenAI embeddings require OPENAI_API_KEY
     openai_embedding_model: str = Field(
         default="text-embedding-3-small",
         description="OpenAI embedding model (used by LlamaIndex RAG)",
@@ -77,15 +77,8 @@ class Settings(BaseSettings):
     log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
 
     # External Services
-    modal_token_id: str | None = Field(default=None, description="Modal token ID")
-    modal_token_secret: str | None = Field(default=None, description="Modal token secret")
     chroma_db_path: str = Field(default="./chroma_db", description="ChromaDB storage path")
 
-    @property
-    def modal_available(self) -> bool:
-        """Check if Modal credentials are configured."""
-        return bool(self.modal_token_id and self.modal_token_secret)
-
     def get_api_key(self) -> str:
         """Get the API key for the configured provider."""
         # Normalize provider for case-insensitive matching

src/utils/exceptions.py

@@ -49,12 +49,6 @@ class QuotaExceededError(LLMError):
     pass
 
 
-class ModalError(DeepBonerError):
-    """Raised when Modal sandbox operations fail."""
-
-    pass
-
-
 class SynthesisError(DeepBonerError):
     """Raised when report synthesis fails after trying all available models.
 

src/utils/llm_factory.py

@@ -1,64 +0,0 @@
-"""Centralized LLM client factory.
-
-This module provides factory functions for creating LLM clients.
-DEPRECATED: Prefer src.clients.factory.get_chat_client() directly.
-"""
-
-from typing import Any
-
-from src.clients.base import BaseChatClient
-from src.clients.factory import get_chat_client
-from src.utils.config import settings
-from src.utils.exceptions import ConfigurationError
-
-
-def get_magentic_client() -> BaseChatClient:
-    """
-    Get the chat client for Magentic agents.
-
-    Now unified to support OpenAI, Gemini, and HuggingFace.
-    """
-    return get_chat_client()
-
-
-def get_pydantic_ai_model() -> Any:
-    """
-    Get the appropriate model for pydantic-ai based on configuration.
-    Used by legacy Simple Mode components.
-    """
-    from pydantic_ai.models.openai import OpenAIChatModel
-    from pydantic_ai.providers.openai import OpenAIProvider
-
-    # Normalize provider for case-insensitive matching
-    provider_lower = settings.llm_provider.lower() if settings.llm_provider else ""
-
-    if provider_lower == "openai":
-        if not settings.openai_api_key:
-            raise ConfigurationError("OPENAI_API_KEY not set for pydantic-ai")
-        provider = OpenAIProvider(api_key=settings.openai_api_key)
-        return OpenAIChatModel(settings.openai_model, provider=provider)
-
-    if provider_lower == "anthropic":
-        raise ConfigurationError("Anthropic is not supported (no embeddings API). See P3 doc.")
-
-    raise ConfigurationError(f"Unknown LLM provider for simple mode: {settings.llm_provider}")
-
-
-def check_magentic_requirements() -> None:
-    """
-    Check if Magentic mode requirements are met.
-    Now supports multiple providers via ChatClientFactory.
-    """
-    # Advanced/Magentic mode now works with ANY provider (including free HF)
-    pass
-
-
-def check_simple_mode_requirements() -> None:
-    """
-    Check if simple mode requirements are met.
-    """
-    if not settings.has_any_llm_key:
-        # Simple mode still requires explicit keys?
-        # Actually, simple mode also had HF support but it was brittle.
-        # We are deleting simple mode later, so let's leave this as is for now.
-        pass

src/utils/service_loader.py

@@ -18,7 +18,6 @@ from src.utils.config import settings
 
 if TYPE_CHECKING:
     from src.services.embedding_protocol import EmbeddingServiceProtocol
-    from src.services.statistical_analyzer import StatisticalAnalyzer
 
 logger = structlog.get_logger()
 
@@ -66,13 +65,9 @@ def get_embedding_service(api_key: str | None = None) -> "EmbeddingServiceProtoc
         ImportError: If no embedding service dependencies are available
     """
     # Determine if we have a valid OpenAI key (BYOK or Env)
-    # Note: Must check sk-ant- BEFORE sk- since Anthropic keys start with sk-ant-
     has_openai = False
     if api_key:
-        if api_key.startswith("sk-ant-"):
-            # Anthropic key - not supported for embeddings
-            logger.warning("Anthropic keys don't support embeddings, falling back to free tier")
-        elif api_key.startswith("sk-"):
+        if api_key.startswith("sk-"):
             # OpenAI BYOK
             has_openai = True
     elif settings.has_openai_key:
@@ -125,7 +120,7 @@ def get_embedding_service(api_key: str | None = None) -> "EmbeddingServiceProtoc
         raise ImportError(
             "No embedding service available. Install either:\n"
             "  - uv sync --extra embeddings (for local embeddings)\n"
-            "  - uv sync --extra modal (for LlamaIndex with OpenAI)"
+            "  - uv sync --extra rag (for LlamaIndex with OpenAI)"
         ) from e
 
 
@@ -157,29 +152,3 @@ def get_embedding_service_if_available(
             error_type=type(e).__name__,
         )
     return None
-
-
-def get_analyzer_if_available() -> "StatisticalAnalyzer | None":
-    """Safely attempt to load and initialize the StatisticalAnalyzer.
-
-    Returns:
-        StatisticalAnalyzer instance if Modal is available, else None.
-    """
-    try:
-        from src.services.statistical_analyzer import get_statistical_analyzer
-
-        analyzer = get_statistical_analyzer()
-        logger.info("StatisticalAnalyzer initialized successfully")
-        return analyzer
-    except ImportError as e:
-        logger.info(
-            "StatisticalAnalyzer not available (Modal dependencies missing)",
-            missing_dependency=str(e),
-        )
-    except Exception as e:
-        logger.warning(
-            "StatisticalAnalyzer initialization failed unexpectedly",
-            error=str(e),
-            error_type=type(e).__name__,
-        )
-    return None

tests/integration/test_modal.py

@@ -1,67 +0,0 @@
-"""Integration tests for Modal (requires credentials and modal package)."""
-
-import pytest
-
-from src.utils.config import settings
-
-# Check if any LLM API key is available
-_llm_available = bool(settings.openai_api_key or settings.anthropic_api_key)
-
-# Check if modal package is installed
-try:
-    import modal  # noqa: F401
-
-    _modal_installed = True
-except ImportError:
-    _modal_installed = False
-
-
-@pytest.mark.integration
-@pytest.mark.skipif(not _modal_installed, reason="Modal package not installed")
-@pytest.mark.skipif(not settings.modal_available, reason="Modal credentials not configured")
-class TestModalIntegration:
-    """Integration tests requiring Modal credentials."""
-
-    @pytest.mark.asyncio
-    async def test_sandbox_executes_code(self) -> None:
-        """Modal sandbox should execute Python code."""
-        import asyncio
-        from functools import partial
-
-        from src.tools.code_execution import get_code_executor
-
-        executor = get_code_executor()
-        code = "import pandas as pd; print(pd.DataFrame({'a': [1,2,3]})['a'].sum())"
-
-        loop = asyncio.get_running_loop()
-        result = await loop.run_in_executor(None, partial(executor.execute, code, timeout=30))
-
-        assert result["success"]
-        assert "6" in result["stdout"]
-
-    @pytest.mark.asyncio
-    @pytest.mark.skipif(not _llm_available, reason="LLM API key not configured")
-    async def test_statistical_analyzer_works(self) -> None:
-        """StatisticalAnalyzer should work end-to-end (requires Modal + LLM)."""
-        from src.services.statistical_analyzer import get_statistical_analyzer
-        from src.utils.models import Citation, Evidence
-
-        evidence = [
-            Evidence(
-                content="Drug shows 40% improvement in trial.",
-                citation=Citation(
-                    source="pubmed",
-                    title="Test",
-                    url="https://test.com",
-                    date="2024-01-01",
-                    authors=["Test"],
-                ),
-                relevance=0.9,
-            )
-        ]
-
-        analyzer = get_statistical_analyzer()
-        result = await analyzer.analyze("test drug efficacy", evidence)
-
-        assert result.verdict in ["SUPPORTED", "REFUTED", "INCONCLUSIVE"]
-        assert 0.0 <= result.confidence <= 1.0

tests/unit/agent_factory/test_get_model_auto_detect.py

@@ -7,11 +7,7 @@ from src.utils.config import settings
 
 
 class TestGetModelAutoDetect:
-    """Test that get_model() auto-detects available providers.
-
-    NOTE: Anthropic is NOT supported (no embeddings API).
-    See P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md.
-    """
+    """Test that get_model() auto-detects available providers."""
 
     def test_returns_openai_when_key_present(self, monkeypatch):
         """OpenAI key present → OpenAI model."""
@@ -30,16 +26,6 @@ class TestGetModelAutoDetect:
         model = get_model(api_key="sk-byok-test-key")
         assert isinstance(model, OpenAIChatModel)
 
-    def test_byok_anthropic_key_raises_not_implemented(self, monkeypatch):
-        """BYOK: api_key='sk-ant-...' → NotImplementedError (Anthropic not supported)."""
-        monkeypatch.setattr(settings, "openai_api_key", None)
-        monkeypatch.setattr(settings, "hf_token", None)
-
-        with pytest.raises(NotImplementedError) as exc_info:
-            get_model(api_key="sk-ant-test-key")
-
-        assert "Anthropic is not supported" in str(exc_info.value)
-
     def test_returns_huggingface_when_hf_token_present(self, monkeypatch):
         """HF_TOKEN present (no paid keys) → HuggingFace model."""
         monkeypatch.setattr(settings, "openai_api_key", None)
@@ -57,7 +43,6 @@ class TestGetModelAutoDetect:
         monkeypatch.delenv("HF_TOKEN", raising=False)
 
         # Should raise clear error when no tokens available
-        import pytest
 
         with pytest.raises(RuntimeError) as exc_info:
             get_model()

tests/unit/agent_factory/test_judges_factory.py

@@ -1,8 +1,4 @@
-"""Unit tests for Judge Factory and Model Selection.
-
-NOTE: Anthropic is NOT supported (no embeddings API).
-See P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md.
-"""
+"""Unit tests for Judge Factory and Model Selection."""
 
 from unittest.mock import patch
 
@@ -42,16 +38,6 @@ def test_get_model_byok_openai(mock_settings):
     assert isinstance(model, OpenAIChatModel)
 
 
-def test_get_model_byok_anthropic_raises(mock_settings):
-    """Test that BYOK Anthropic key raises NotImplementedError."""
-    mock_settings.has_openai_key = False
-
-    with pytest.raises(NotImplementedError) as exc_info:
-        get_model(api_key="sk-ant-test")
-
-    assert "Anthropic is not supported" in str(exc_info.value)
-
-
 def test_get_model_huggingface(mock_settings):
     """Test that HuggingFace model is returned when no paid keys."""
     mock_settings.has_openai_key = False

tests/unit/orchestrators/test_advanced_p2_dead_zones.py

@@ -14,7 +14,6 @@ async def test_advanced_initialization_events():
         patch("src.orchestrators.advanced.AdvancedOrchestrator._init_embedding_service"),
         patch("src.orchestrators.advanced.init_magentic_state"),
         patch("src.orchestrators.advanced.AdvancedOrchestrator._build_workflow") as mock_build,
-        patch("src.utils.llm_factory.check_magentic_requirements"),
     ):  # Bypass check
         # Setup mocks
         mock_workflow = MagicMock()

tests/unit/services/test_statistical_analyzer.py

@@ -1,104 +0,0 @@
-"Unit tests for StatisticalAnalyzer service."
-
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from src.services.statistical_analyzer import (
-    AnalysisResult,
-    StatisticalAnalyzer,
-    get_statistical_analyzer,
-)
-from src.utils.models import Citation, Evidence
-
-
-@pytest.fixture
-def sample_evidence() -> list[Evidence]:
-    """Sample evidence for testing."""
-    return [
-        Evidence(
-            content="Testosterone therapy shows effect size of 0.45.",
-            citation=Citation(
-                source="pubmed",
-                title="Testosterone HSDD Study",
-                url="https://pubmed.ncbi.nlm.nih.gov/12345/",
-                date="2024-01-15",
-                authors=["Smith J"],
-            ),
-            relevance=0.9,
-        )
-    ]
-
-
-class TestStatisticalAnalyzer:
-    """Tests for StatisticalAnalyzer (no agent_framework dependency)."""
-
-    def test_no_agent_framework_import(self) -> None:
-        """StatisticalAnalyzer must NOT import agent_framework."""
-        import src.services.statistical_analyzer as module
-
-        # Check module doesn't import agent_framework
-        with open(module.__file__) as f:
-            source = f.read()
-        assert "from agent_framework" not in source
-        assert "import agent_framework" not in source
-        assert "BaseAgent" not in source
-
-    @pytest.mark.asyncio
-    async def test_analyze_returns_result(self, sample_evidence: list[Evidence]) -> None:
-        """analyze() should return AnalysisResult."""
-        analyzer = StatisticalAnalyzer()
-
-        with (
-            patch.object(analyzer, "_get_agent") as mock_agent,
-            patch.object(analyzer, "_get_code_executor") as mock_executor,
-        ):
-            # Mock LLM
-            mock_agent.return_value.run = AsyncMock(
-                return_value=MagicMock(output="print('SUPPORTED')")
-            )
-
-            # Mock Modal
-            mock_executor.return_value.execute.return_value = {
-                "stdout": "SUPPORTED\np-value: 0.01",
-                "stderr": "",
-                "success": True,
-            }
-
-            result = await analyzer.analyze("test query", sample_evidence)
-
-            assert isinstance(result, AnalysisResult)
-            assert result.verdict == "SUPPORTED"
-
-    def test_singleton(self) -> None:
-        """get_statistical_analyzer should return singleton."""
-        a1 = get_statistical_analyzer()
-        a2 = get_statistical_analyzer()
-        assert a1 is a2
-
-
-class TestAnalysisResult:
-    """Tests for AnalysisResult model."""
-
-    def test_verdict_values(self) -> None:
-        """Verdict should be one of the expected values."""
-        for verdict in ["SUPPORTED", "REFUTED", "INCONCLUSIVE"]:
-            result = AnalysisResult(
-                verdict=verdict,  # type: ignore
-                confidence=0.8,
-                statistical_evidence="test",
-                code_generated="print('test')",
-                execution_output="test",
-            )
-            assert result.verdict == verdict
-
-    def test_confidence_bounds(self) -> None:
-        """Confidence must be 0.0-1.0."""
-        with pytest.raises(ValueError):
-            AnalysisResult(
-                verdict="SUPPORTED",
-                confidence=1.5,  # Invalid
-                statistical_evidence="test",
-                code_generated="test",
-                execution_output="test",
-            )

tests/unit/test_app_smoke.py

@@ -35,7 +35,6 @@ class TestAppSmoke:
         Ensures the MCP server can expose these tools.
         """
         from src.mcp_tools import (
-            analyze_hypothesis,
             search_all_sources,
             search_clinical_trials,
             search_europepmc,
@@ -47,4 +46,3 @@ class TestAppSmoke:
         assert callable(search_clinical_trials)
         assert callable(search_europepmc)
         assert callable(search_all_sources)
-        assert callable(analyze_hypothesis)

tests/unit/utils/test_service_loader.py

@@ -1,36 +1,37 @@
 from unittest.mock import MagicMock, patch
 
 from src.utils.service_loader import (
-    get_analyzer_if_available,
     get_embedding_service_if_available,
 )
 
 
-def test_get_embedding_service_success():
-    """Test successful loading of embedding service (free tier fallback)."""
-    mock_service = MagicMock()
+class TestGetEmbeddingServiceIfAvailable:
+    """Test get_embedding_service_if_available() safety wrapper."""
 
-    # Patch settings to disable premium tier, then patch the local service
-    with patch("src.utils.service_loader.settings") as mock_settings:
-        mock_settings.has_openai_key = False
+    def test_returns_service_when_available(self):
+        """Test successful loading of embedding service (free tier fallback)."""
+        mock_service = MagicMock()
 
-        with patch("src.services.embeddings.get_embedding_service", return_value=mock_service):
-            service = get_embedding_service_if_available()
-            assert service is mock_service
+        # Patch settings to disable premium tier, then patch the local service
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = False
 
+            with patch("src.services.embeddings.get_embedding_service", return_value=mock_service):
+                service = get_embedding_service_if_available()
+                assert service is mock_service
 
-def test_get_embedding_service_import_error():
-    """Test handling of ImportError when loading embedding service."""
-    # Disable premium tier, then make local service fail
-    with patch("src.utils.service_loader.settings") as mock_settings:
-        mock_settings.has_openai_key = False
+    def test_returns_none_when_no_service_available(self):
+        """Test handling of ImportError when loading embedding service."""
+        # Disable premium tier, then make local service fail
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = False
 
-        with patch(
-            "src.services.embeddings.get_embedding_service",
-            side_effect=ImportError("Missing deps"),
-        ):
-            service = get_embedding_service_if_available()
-            assert service is None
+            with patch(
+                "src.services.embeddings.get_embedding_service",
+                side_effect=ImportError("Missing deps"),
+            ):
+                service = get_embedding_service_if_available()
+                assert service is None
 
 
 def test_get_embedding_service_generic_error():
@@ -47,33 +48,97 @@ def test_get_embedding_service_generic_error():
             assert service is None
 
 
-def test_get_analyzer_success():
-    """Test successful loading of analyzer."""
-    with patch("src.services.statistical_analyzer.get_statistical_analyzer") as mock_get:
-        mock_analyzer = MagicMock()
-        mock_get.return_value = mock_analyzer
-
-        analyzer = get_analyzer_if_available()
-
-        assert analyzer is mock_analyzer
-        mock_get.assert_called_once()
-
-
-def test_get_analyzer_import_error():
-    """Test handling of ImportError when loading analyzer."""
-    with patch(
-        "src.services.statistical_analyzer.get_statistical_analyzer",
-        side_effect=ImportError("No Modal"),
-    ):
-        analyzer = get_analyzer_if_available()
-        assert analyzer is None
-
-
-def test_get_analyzer_generic_error():
-    """Test handling of generic Exception when loading analyzer."""
-    with patch(
-        "src.services.statistical_analyzer.get_statistical_analyzer",
-        side_effect=RuntimeError("Fail"),
-    ):
-        analyzer = get_analyzer_if_available()
-        assert analyzer is None
+class TestGetEmbeddingService:
+    """Test get_embedding_service() logic."""
+
+    def test_uses_llamaindex_when_openai_key_present(self):
+        """OpenAI key (env) → LlamaIndex."""
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = True
+            mock_settings.openai_api_key = "sk-env"
+
+            # Mock LlamaIndex dependencies and factory
+            with patch.dict(
+                "sys.modules",
+                {
+                    "src.services.llamaindex_rag": MagicMock(),
+                    "chromadb": MagicMock(),
+                    "llama_index": MagicMock(),
+                },
+            ):
+                mock_rag_service = MagicMock()
+                with patch(
+                    "src.services.llamaindex_rag.get_rag_service", return_value=mock_rag_service
+                ):
+                    from src.utils.service_loader import get_embedding_service
+
+                    service = get_embedding_service()
+                    assert service is mock_rag_service
+
+    def test_uses_llamaindex_when_byok_key_present(self):
+        """BYOK key → LlamaIndex."""
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = False
+
+            with patch.dict(
+                "sys.modules",
+                {
+                    "src.services.llamaindex_rag": MagicMock(),
+                },
+            ):
+                mock_rag_service = MagicMock()
+                with patch(
+                    "src.services.llamaindex_rag.get_rag_service", return_value=mock_rag_service
+                ):
+                    from src.utils.service_loader import get_embedding_service
+
+                    service = get_embedding_service(api_key="sk-test")
+                    assert service is mock_rag_service
+
+    def test_falls_back_to_local_when_no_openai_key(self):
+        """No OpenAI key → Local embeddings."""
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = False
+
+            mock_local_service = MagicMock()
+            with patch(
+                "src.services.embeddings.get_embedding_service", return_value=mock_local_service
+            ):
+                from src.utils.service_loader import get_embedding_service
+
+                service = get_embedding_service()
+                assert service is mock_local_service
+
+    def test_falls_back_when_llamaindex_import_fails(self):
+        """LlamaIndex fails import → Local embeddings."""
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = True
+
+            # Mock ImportError for LlamaIndex
+            with patch(
+                "src.services.llamaindex_rag.get_rag_service", side_effect=ImportError("No deps")
+            ):
+                mock_local_service = MagicMock()
+                with patch(
+                    "src.services.embeddings.get_embedding_service", return_value=mock_local_service
+                ):
+                    from src.utils.service_loader import get_embedding_service
+
+                    service = get_embedding_service()
+                    assert service is mock_local_service
+
+    def test_raises_when_no_embedding_service_available(self):
+        """All services fail → ImportError."""
+        with patch("src.utils.service_loader.settings") as mock_settings:
+            mock_settings.has_openai_key = False
+
+            with patch(
+                "src.services.embeddings.get_embedding_service", side_effect=ImportError("No deps")
+            ):
+                import pytest
+
+                from src.utils.service_loader import get_embedding_service
+
+                with pytest.raises(ImportError) as exc:
+                    get_embedding_service()
+                assert "No embedding service available" in str(exc.value)

uv.lock

@@ -1,6 +1,6 @@
 version = 1
 revision = 1
-requires-python = ">=3.11"
+requires-python = ">=3.11, <4.0"
 resolution-markers = [
     "python_full_version >= '3.13'",
     "python_full_version == '3.12.*'",
@@ -619,47 +619,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503 },
 ]
 
-[[package]]
-name = "cbor2"
-version = "5.7.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/b8/c0f6a7d46f816cb18b1fda61a2fe648abe16039f1ff93ea720a6e9fb3cee/cbor2-5.7.1.tar.gz", hash = "sha256:7a405a1d7c8230ee9acf240aad48ae947ef584e8af05f169f3c1bde8f01f8b71", size = 102467 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/52/67/319baac9c51de0053f58fa74a9548f93f3629aa3adeebd7d2c99d1379370/cbor2-5.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2b1efbe6e82721be44b9faf47d0fd97b0150213eb6a4ba554f4947442bc4e13f", size = 67894 },
-    { url = "https://files.pythonhosted.org/packages/2c/53/d23d0a234a4a098b019ac1cadd33631c973142fc947a68c4a38ca47aa5dc/cbor2-5.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fb94bab27e00283bdd8f160e125e17dbabec4c9e6ffc8da91c36547ec1eb707f", size = 68444 },
-    { url = "https://files.pythonhosted.org/packages/3a/a2/a6fa59e1c23b0bc77628d64153eb9fc69ac8dde5f8ed41a7d5316fcd0bcd/cbor2-5.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:29f22266b5e08e0e4152e87ba185e04d3a84a4fd545b99ae3ebe42c658c66a53", size = 261600 },
-    { url = "https://files.pythonhosted.org/packages/3d/cb/e0fa066aa7a09b15b8f56bafef6b2be19d9db31310310b0a5601af5c0128/cbor2-5.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25d4c7554d6627da781c9bd1d0dd0709456eecb71f605829f98961bb98487dda", size = 254904 },
-    { url = "https://files.pythonhosted.org/packages/2c/d5/b1fb4a3828c440e100a4b2658dd2e8f422faf08f4fcc8e2c92b240656b44/cbor2-5.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1e15c3a08008cf13ce1dfc64d17c960df5d66d935788d28ec7df54bf0ffb0ef", size = 257388 },
-    { url = "https://files.pythonhosted.org/packages/34/d5/252657bc5af964fc5f19c0e0e82031b4c32eba5d3ed4098e963e0e8c47a6/cbor2-5.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9f6cdf7eb604ea0e7ef34e3f0b5447da0029ecd3ab7b2dc70e43fa5f7bcfca89", size = 251494 },
-    { url = "https://files.pythonhosted.org/packages/8a/3a/503ea4c2977411858ca287808d077fdb4bb1fafdb4b39177b8ce3d5619ac/cbor2-5.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:dd25cbef8e8e6dbf69f0de95311aecaca7217230cda83ae99fdc37cd20d99250", size = 68147 },
-    { url = "https://files.pythonhosted.org/packages/49/9e/fe4c9703fd444da193f892787110c5da2a85c16d26917fcb2584f5d00077/cbor2-5.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:40cc9c67242a7abac5a4e062bc4d1d2376979878c0565a4b2f08fd9ed9212945", size = 64126 },
-    { url = "https://files.pythonhosted.org/packages/56/54/48426472f0c051982c647331441aed09b271a0500356ae0b7054c813d174/cbor2-5.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bd5ca44891c06f6b85d440836c967187dc1d30b15f86f315d55c675d3a841078", size = 69031 },
-    { url = "https://files.pythonhosted.org/packages/d3/68/1dd58c7706e9752188358223db58c83f3c48e07f728aa84221ffd244652f/cbor2-5.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:537d73ef930ccc1a7b6a2e8d2cbf81407d270deb18e40cda5eb511bd70f71078", size = 68825 },
-    { url = "https://files.pythonhosted.org/packages/09/4e/380562fe9f9995a1875fb5ec26fd041e19d61f4630cb690a98c5195945fc/cbor2-5.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:edbf814dd7763b6eda27a5770199f6ccd55bd78be8f4367092460261bfbf19d0", size = 286222 },
-    { url = "https://files.pythonhosted.org/packages/7c/bb/9eccdc1ea3c4d5c7cdb2e49b9de49534039616be5455ce69bd64c0b2efe2/cbor2-5.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fc81da8c0e09beb42923e455e477b36ff14a03b9ca18a8a2e9b462de9a953e8", size = 285688 },
-    { url = "https://files.pythonhosted.org/packages/59/8c/4696d82f5bd04b3d45d9a64ec037fa242630c134e3218d6c252b4f59b909/cbor2-5.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e4a7d660d428911a3aadb7105e94438d7671ab977356fdf647a91aab751033bd", size = 277063 },
-    { url = "https://files.pythonhosted.org/packages/95/50/6538e44ca970caaad2fa376b81701d073d84bf597aac07a59d0a253b1a7f/cbor2-5.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:228e0af9c0a9ddf6375b6ae010eaa1942a1901d403f134ac9ee6a76a322483f9", size = 278334 },
-    { url = "https://files.pythonhosted.org/packages/64/a9/156ccd2207fb26b5b61d23728b4dbdc595d1600125aa79683a4a8ddc9313/cbor2-5.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:2d08a6c0d9ed778448e185508d870f4160ba74f59bb17a966abd0d14d0ff4dd3", size = 68404 },
-    { url = "https://files.pythonhosted.org/packages/4f/49/adc53615e9dd32c4421f6935dfa2235013532c6e6b28ee515bbdd92618be/cbor2-5.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:752506cfe72da0f4014b468b30191470ee8919a64a0772bd3b36a4fccf5fcefc", size = 64047 },
-    { url = "https://files.pythonhosted.org/packages/16/b1/51fb868fe38d893c570bb90b38d365ff0f00421402c1ae8f63b31b25d665/cbor2-5.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:59d5da59fffe89692d5bd1530eef4d26e4eb7aa794aaa1f4e192614786409009", size = 69068 },
-    { url = "https://files.pythonhosted.org/packages/b9/db/5abc62ec456f552f617aac3359a5d7114b23be9c4d886169592cd5f074b9/cbor2-5.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:533117918d518e01348f8cd0331271c207e7224b9a1ed492a0ff00847f28edc8", size = 68927 },
-    { url = "https://files.pythonhosted.org/packages/9a/c2/58d787395c99874d2a2395b3a22c9d48a3cfc5a7dcd5817bf74764998b75/cbor2-5.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d6d9436ff3c3323ea5863ecf7ae1139590991685b44b9eb6b7bb1734a594af6", size = 285185 },
-    { url = "https://files.pythonhosted.org/packages/d0/9c/b680b264a8f4b9aa59c95e166c816275a13138cbee92dd2917f58bca47b9/cbor2-5.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:661b871ca754a619fcd98c13a38b4696b2b57dab8b24235c00b0ba322c040d24", size = 284440 },
-    { url = "https://files.pythonhosted.org/packages/1f/59/68183c655d6226d0eee10027f52516882837802a8d5746317a88362ed686/cbor2-5.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d8065aa90d715fd9bb28727b2d774ee16e695a0e1627ae76e54bf19f9d99d63f", size = 276876 },
-    { url = "https://files.pythonhosted.org/packages/ee/a2/1964e0a569d2b81e8f4862753fee7701ae5773c22e45492a26f92f62e75a/cbor2-5.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cb1b7047d73590cfe8e373e2c804fa99be47e55b1b6186602d0f86f384cecec1", size = 278216 },
-    { url = "https://files.pythonhosted.org/packages/00/78/9b566d68cb88bb1ecebe354765625161c9d6060a16e55008006d6359f776/cbor2-5.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:31d511df7ebd6624fdb4cecdafb4ffb9a205f9ff8c8d98edd1bef0d27f944d74", size = 68451 },
-    { url = "https://files.pythonhosted.org/packages/db/85/7a6a922d147d027fd5d8fd5224b39e8eaf152a42e8cf16351458096d3d62/cbor2-5.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:f5d37f7b0f84394d2995bd8722cb01c86a885c4821a864a34b7b4d9950c5e26e", size = 64111 },
-    { url = "https://files.pythonhosted.org/packages/5f/f0/f220222a57371e33434ba7bdc25de31d611cbc0ade2a868e03c3553305e7/cbor2-5.7.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e5826e4fa4c33661960073f99cf67c82783895524fb66f3ebdd635c19b5a7d68", size = 69002 },
-    { url = "https://files.pythonhosted.org/packages/c7/3c/34b62ba5173541659f248f005d13373530f02fb997b78fde00bf01ede4f4/cbor2-5.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f19a00d6ac9a77cb611073250b06bf4494b41ba78a1716704f7008e0927d9366", size = 69177 },
-    { url = "https://files.pythonhosted.org/packages/77/fd/2400d820d9733df00a5c18aa74201e51d710fb91588687eb594f4a7688ea/cbor2-5.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2113aea044cd172f199da3520bc4401af69eae96c5180ca7eb660941928cb89", size = 284259 },
-    { url = "https://files.pythonhosted.org/packages/42/65/280488ef196c1d71ba123cd406ea47727bb3a0e057767a733d9793fcc428/cbor2-5.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f17eacea2d28fecf28ac413c1d7927cde0a11957487d2630655d6b5c9c46a0b", size = 281958 },
-    { url = "https://files.pythonhosted.org/packages/42/82/bcdd3fdc73bd5f4194fdb08c808112010add9530bae1dcfdb1e2b2ceae19/cbor2-5.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d65deea39cae533a629561e7da672402c46731122b6129ed7c8eaa1efe04efce", size = 276025 },
-    { url = "https://files.pythonhosted.org/packages/ae/a8/a6065dd6a157b877d7d8f3fe96f410fb191a2db1e6588f4d20b5f9a507c2/cbor2-5.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:57d8cc29ec1fd20500748e0e767ff88c13afcee839081ba4478c41fcda6ee18b", size = 275978 },
-    { url = "https://files.pythonhosted.org/packages/62/f4/37934045174af9e4253a340b43f07197af54002070cb80fae82d878f1f14/cbor2-5.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:94fb939d0946f80c49ba45105ca3a3e13e598fc9abd63efc6661b02d4b4d2c50", size = 70269 },
-    { url = "https://files.pythonhosted.org/packages/0b/fd/933416643e7f5540ae818691fb23fa4189010c6efa39a12c4f59d825da28/cbor2-5.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4fd7225ac820bbb9f03bd16bc1a7efb6c4d1c451f22c0a153ff4ec46495c59c5", size = 66182 },
-    { url = "https://files.pythonhosted.org/packages/d5/7d/383bafeabb54c17fe5b6d5aca4e863e6b7df10bcc833b34aa169e9dfce1a/cbor2-5.7.1-py3-none-any.whl", hash = "sha256:68834e4eff2f56629ce6422b0634bc3f74c5a4269de5363f5265fe452c706ba7", size = 23829 },
-]
-
 [[package]]
 name = "certifi"
 version = "2025.11.12"
@@ -1118,8 +1077,8 @@ name = "deepboner"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
-    { name = "anthropic" },
     { name = "beautifulsoup4" },
+    { name = "chromadb" },
     { name = "duckduckgo-search" },
     { name = "gradio", extra = ["mcp"] },
     { name = "httpx" },
@@ -1137,6 +1096,7 @@ dependencies = [
     { name = "pydantic-settings" },
     { name = "python-dotenv" },
     { name = "requests" },
+    { name = "sentence-transformers" },
     { name = "structlog" },
     { name = "tenacity" },
     { name = "urllib3" },
@@ -1158,30 +1118,22 @@ dev = [
     { name = "ruff" },
     { name = "typer" },
 ]
-embeddings = [
-    { name = "chromadb" },
-    { name = "sentence-transformers" },
-]
 magentic = [
     { name = "agent-framework-core" },
 ]
-modal = [
-    { name = "chromadb" },
+rag = [
     { name = "llama-index" },
     { name = "llama-index-embeddings-openai" },
     { name = "llama-index-llms-openai" },
     { name = "llama-index-vector-stores-chroma" },
-    { name = "modal" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "agent-framework-core", marker = "extra == 'magentic'", specifier = ">=1.0.0b251120,<2.0.0" },
-    { name = "anthropic", specifier = ">=0.18.0" },
     { name = "bandit", marker = "extra == 'dev'", specifier = ">=1.7.0" },
     { name = "beautifulsoup4", specifier = ">=4.12" },
-    { name = "chromadb", marker = "extra == 'embeddings'", specifier = ">=0.4.0" },
-    { name = "chromadb", marker = "extra == 'modal'", specifier = ">=0.4.0" },
+    { name = "chromadb", specifier = ">=0.4.22" },
     { name = "duckduckgo-search", specifier = ">=5.0" },
     { name = "gradio", extras = ["mcp"], specifier = ">=6.0.0" },
     { name = "httpx", specifier = ">=0.27" },
@@ -1192,12 +1144,11 @@ requires-dist = [
     { name = "langgraph", specifier = ">=0.2.50,<1.0" },
     { name = "langgraph-checkpoint-sqlite", specifier = ">=3.0.0,<4.0" },
     { name = "limits", specifier = ">=3.0" },
-    { name = "llama-index", marker = "extra == 'modal'", specifier = ">=0.11.0" },
-    { name = "llama-index-embeddings-openai", marker = "extra == 'modal'" },
-    { name = "llama-index-llms-openai", marker = "extra == 'modal'" },
-    { name = "llama-index-vector-stores-chroma", marker = "extra == 'modal'" },
+    { name = "llama-index", marker = "extra == 'rag'", specifier = ">=0.11.0" },
+    { name = "llama-index-embeddings-openai", marker = "extra == 'rag'" },
+    { name = "llama-index-llms-openai", marker = "extra == 'rag'" },
+    { name = "llama-index-vector-stores-chroma", marker = "extra == 'rag'" },
     { name = "mcp", specifier = ">=1.23.0" },
-    { name = "modal", marker = "extra == 'modal'", specifier = ">=0.63.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.10" },
     { name = "openai", specifier = ">=1.0.0" },
     { name = "pip-audit", marker = "extra == 'dev'", specifier = ">=2.7.0" },
@@ -1214,14 +1165,14 @@ requires-dist = [
     { name = "requests", specifier = ">=2.32.5" },
     { name = "respx", marker = "extra == 'dev'", specifier = ">=0.21" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.4.0" },
-    { name = "sentence-transformers", marker = "extra == 'embeddings'", specifier = ">=2.2.0" },
+    { name = "sentence-transformers", specifier = ">=2.2.2" },
     { name = "structlog", specifier = ">=24.1" },
     { name = "tenacity", specifier = ">=8.2" },
     { name = "typer", marker = "extra == 'dev'", specifier = ">=0.9.0" },
     { name = "urllib3", specifier = ">=2.5.0" },
     { name = "xmltodict", specifier = ">=0.13" },
 ]
-provides-extras = ["dev", "magentic", "embeddings", "modal"]
+provides-extras = ["dev", "magentic", "rag"]
 
 [[package]]
 name = "defusedxml"
@@ -1863,19 +1814,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/19/41/0b430b01a2eb38ee887f88c1f07644a1df8e289353b78e82b37ef988fb64/grpcio-1.76.0-cp314-cp314-win_amd64.whl", hash = "sha256:922fa70ba549fce362d2e2871ab542082d66e2aaf0c19480ea453905b01f384e", size = 4834462 },
 ]
 
-[[package]]
-name = "grpclib"
-version = "0.4.8"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "h2" },
-    { name = "multidict" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/19/75/0f0d3524b38b35e5cd07334b754aa9bd0570140ad982131b04ebfa3b0374/grpclib-0.4.8.tar.gz", hash = "sha256:d8823763780ef94fed8b2c562f7485cf0bbee15fc7d065a640673667f7719c9a", size = 62793 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/8b/ad381ec1b8195fa4a9a693cb8087e031b99530c0d6b8ad036dcb99e144c4/grpclib-0.4.8-py3-none-any.whl", hash = "sha256:a5047733a7acc1c1cee6abf3c841c7c6fab67d2844a45a853b113fa2e6cd2654", size = 76311 },
-]
-
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -1885,19 +1823,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
 ]
 
-[[package]]
-name = "h2"
-version = "4.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "hpack" },
-    { name = "hyperframe" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779 },
-]
-
 [[package]]
 name = "hf-xet"
 version = "1.2.0"
@@ -1927,15 +1852,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735 },
 ]
 
-[[package]]
-name = "hpack"
-version = "4.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357 },
-]
-
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -2045,15 +1961,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f0/0f/310fb31e39e2d734ccaa2c0fb981ee41f7bd5056ce9bc29b2248bd569169/humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477", size = 86794 },
 ]
 
-[[package]]
-name = "hyperframe"
-version = "6.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007 },
-]
-
 [[package]]
 name = "identify"
 version = "2.6.15"
@@ -3160,31 +3067,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/fc/0e61d9a4e29c8679356795a40e48f647b4aad58d71bfc969f0f8f56fb912/mmh3-5.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:e7884931fe5e788163e7b3c511614130c2c59feffdc21112290a194487efb2e9", size = 40455 },
 ]
 
-[[package]]
-name = "modal"
-version = "1.2.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiohttp" },
-    { name = "cbor2" },
-    { name = "certifi" },
-    { name = "click" },
-    { name = "grpclib" },
-    { name = "protobuf" },
-    { name = "rich" },
-    { name = "synchronicity" },
-    { name = "toml" },
-    { name = "typer" },
-    { name = "types-certifi" },
-    { name = "types-toml" },
-    { name = "typing-extensions" },
-    { name = "watchfiles" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/91/b1/7bd589a3e1cc1ffc3fc2c05d1fab4b02459552d1ed416e00f19969e54f32/modal-1.2.4.tar.gz", hash = "sha256:5acb4a57a4bc857944579a3cf36e93f38d39499837628e9acf591d45d0c88c89", size = 645018 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ad/5a/a6bb9d01111109398bad8405587dde4f65088604b958c4f5e8cc5b212460/modal-1.2.4-py3-none-any.whl", hash = "sha256:cf4f01081bd9e5e1ec844d87a2c6a5805fd7c8f4deff5671c20d3b1505899aa8", size = 742291 },
-]
-
 [[package]]
 name = "more-itertools"
 version = "10.8.0"
@@ -5919,18 +5801,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353 },
 ]
 
-[[package]]
-name = "synchronicity"
-version = "0.10.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/92/2abaf9f4d846c2b7c240e9ce3c9198abf6660265bc1031640cbca5365351/synchronicity-0.10.4.tar.gz", hash = "sha256:3a9ac19f9a58cad64fcb3729812b828b77e54e0a90ced4439e09d3d9c19a90f0", size = 66903 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/c6/a3631d119c9979816c0ed0354aa9fb829a14f53a43337f263dc3329b3a6e/synchronicity-0.10.4-py3-none-any.whl", hash = "sha256:0e3f00b2123cf2a77a8bb3b65fbeccad04adea682bfbd50c01637b75a168c73b", size = 39652 },
-]
-
 [[package]]
 name = "temporalio"
 version = "1.19.0"
@@ -6239,15 +6109,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/64/7713ffe4b5983314e9d436a90d5bd4f63b6054e2aca783a3cfc44cb95bbf/typer-0.20.0-py3-none-any.whl", hash = "sha256:5b463df6793ec1dca6213a3cf4c0f03bc6e322ac5e16e13ddd622a889489784a", size = 47028 },
 ]
 
-[[package]]
-name = "types-certifi"
-version = "2021.10.8.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/52/68/943c3aeaf14624712a0357c4a67814dba5cea36d194f5c764dad7959a00c/types-certifi-2021.10.8.3.tar.gz", hash = "sha256:72cf7798d165bc0b76e1c10dd1ea3097c7063c42c21d664523b928e88b554a4f", size = 2095 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/63/2463d89481e811f007b0e1cd0a91e52e141b47f9de724d20db7b861dcfec/types_certifi-2021.10.8.3-py3-none-any.whl", hash = "sha256:b2d1e325e69f71f7c78e5943d410e650b4707bb0ef32e4ddf3da37f54176e88a", size = 2136 },
-]
-
 [[package]]
 name = "types-protobuf"
 version = "6.32.1.20251105"
@@ -6269,15 +6130,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/20/9a227ea57c1285986c4cf78400d0a91615d25b24e257fd9e2969606bdfae/types_requests-2.32.4.20250913-py3-none-any.whl", hash = "sha256:78c9c1fffebbe0fa487a418e0fa5252017e9c60d1a2da394077f1780f655d7e1", size = 20658 },
 ]
 
-[[package]]
-name = "types-toml"
-version = "0.10.8.20240310"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/86/47/3e4c75042792bff8e90d7991aa5c51812cc668828cc6cce711e97f63a607/types-toml-0.10.8.20240310.tar.gz", hash = "sha256:3d41501302972436a6b8b239c850b26689657e25281b48ff0ec06345b8830331", size = 4392 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/a2/d32ab58c0b216912638b140ab2170ee4b8644067c293b170e19fba340ccc/types_toml-0.10.8.20240310-py3-none-any.whl", hash = "sha256:627b47775d25fa29977d9c70dc0cbab3f314f32c8d8d0c012f2ef5de7aaec05d", size = 4777 },
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"