Add OpenRouter support for Claude Opus 4.5

agent/src/openrouter_client.py

@@ -0,0 +1,312 @@
+"""
+OpenRouter Client for TSA Agent
+
+Provides Claude access via OpenRouter API when direct Anthropic API is not available.
+Supports Claude Opus 4.5 and other models through OpenRouter's unified API.
+"""
+
+import asyncio
+import json
+import os
+from typing import AsyncIterator, Optional
+import httpx
+
+# OpenRouter model mappings
+OPENROUTER_MODELS = {
+    "claude-opus-4.5": "anthropic/claude-opus-4",
+    "claude-opus-4": "anthropic/claude-opus-4",
+    "claude-sonnet-4": "anthropic/claude-sonnet-4",
+    "claude-3.5-sonnet": "anthropic/claude-3.5-sonnet",
+    "claude-3-opus": "anthropic/claude-3-opus",
+    "claude-3-sonnet": "anthropic/claude-3-sonnet",
+    "claude-3-haiku": "anthropic/claude-3-haiku",
+}
+
+
+class OpenRouterClient:
+    """
+    OpenRouter API client for accessing Claude models.
+
+    This client provides a compatible interface for the TSA Agent
+    when using OpenRouter instead of direct Anthropic API access.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "claude-opus-4.5",
+        base_url: str = "https://openrouter.ai/api/v1",
+    ):
+        """
+        Initialize the OpenRouter client.
+
+        Args:
+            api_key: OpenRouter API key (or set OPENROUTER_API_KEY env var)
+            model: Model to use (will be mapped to OpenRouter format)
+            base_url: OpenRouter API base URL
+        """
+        self.api_key = api_key or os.environ.get("OPENROUTER_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenRouter API key required. Set OPENROUTER_API_KEY or pass api_key.")
+
+        # Map model name to OpenRouter format
+        self.model = OPENROUTER_MODELS.get(model, f"anthropic/{model}")
+        self.base_url = base_url
+        self.conversation_history: list[dict] = []
+        self.system_prompt: Optional[str] = None
+
+    def set_system_prompt(self, prompt: str) -> None:
+        """Set the system prompt for conversations."""
+        self.system_prompt = prompt
+
+    def clear_history(self) -> None:
+        """Clear conversation history."""
+        self.conversation_history = []
+
+    async def chat(
+        self,
+        message: str,
+        max_tokens: int = 4096,
+        temperature: float = 0.7,
+    ) -> str:
+        """
+        Send a message and get a response.
+
+        Args:
+            message: User message
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+
+        Returns:
+            Assistant's response text
+        """
+        # Add user message to history
+        self.conversation_history.append({
+            "role": "user",
+            "content": message
+        })
+
+        # Build messages array
+        messages = []
+        if self.system_prompt:
+            messages.append({
+                "role": "system",
+                "content": self.system_prompt
+            })
+        messages.extend(self.conversation_history)
+
+        # Make API request
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                    "HTTP-Referer": "https://tsa-shiny-agent.app",
+                    "X-Title": "TSA Shiny Agent",
+                },
+                json={
+                    "model": self.model,
+                    "messages": messages,
+                    "max_tokens": max_tokens,
+                    "temperature": temperature,
+                }
+            )
+
+            if response.status_code != 200:
+                error_text = response.text
+                raise Exception(f"OpenRouter API error {response.status_code}: {error_text}")
+
+            result = response.json()
+
+        # Extract assistant message
+        assistant_message = result["choices"][0]["message"]["content"]
+
+        # Add to history
+        self.conversation_history.append({
+            "role": "assistant",
+            "content": assistant_message
+        })
+
+        return assistant_message
+
+    async def chat_stream(
+        self,
+        message: str,
+        max_tokens: int = 4096,
+        temperature: float = 0.7,
+    ) -> AsyncIterator[str]:
+        """
+        Send a message and stream the response.
+
+        Args:
+            message: User message
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+
+        Yields:
+            Response text chunks
+        """
+        # Add user message to history
+        self.conversation_history.append({
+            "role": "user",
+            "content": message
+        })
+
+        # Build messages array
+        messages = []
+        if self.system_prompt:
+            messages.append({
+                "role": "system",
+                "content": self.system_prompt
+            })
+        messages.extend(self.conversation_history)
+
+        full_response = []
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            async with client.stream(
+                "POST",
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                    "HTTP-Referer": "https://tsa-shiny-agent.app",
+                    "X-Title": "TSA Shiny Agent",
+                },
+                json={
+                    "model": self.model,
+                    "messages": messages,
+                    "max_tokens": max_tokens,
+                    "temperature": temperature,
+                    "stream": True,
+                }
+            ) as response:
+                if response.status_code != 200:
+                    error_text = await response.aread()
+                    raise Exception(f"OpenRouter API error {response.status_code}: {error_text}")
+
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data = line[6:]
+                        if data == "[DONE]":
+                            break
+                        try:
+                            chunk = json.loads(data)
+                            if "choices" in chunk and len(chunk["choices"]) > 0:
+                                delta = chunk["choices"][0].get("delta", {})
+                                content = delta.get("content", "")
+                                if content:
+                                    full_response.append(content)
+                                    yield content
+                        except json.JSONDecodeError:
+                            continue
+
+        # Add complete response to history
+        self.conversation_history.append({
+            "role": "assistant",
+            "content": "".join(full_response)
+        })
+
+
+# TSA-specific system prompt
+TSA_OPENROUTER_SYSTEM_PROMPT = """You are an expert Trial Sequential Analysis (TSA) assistant specializing in cumulative meta-analysis with sequential monitoring boundaries.
+
+## Your Expertise
+
+You have deep knowledge of:
+
+### Meta-Analysis Fundamentals
+- **Effect Models**: Fixed effect assumes one true effect; Random Effects (DerSimonian-Laird, Sidik-Jonkman) accounts for heterogeneity
+- **Effect Measures**: Odds Ratio (OR), Relative Risk (RR), Risk Difference (RD), Mean Difference (MD)
+- **Heterogeneity**: Q-statistic, I² (low <25%, moderate 25-75%, high >75%), τ² (tau-squared)
+
+### Trial Sequential Analysis
+- **Optimal Information Size (OIS)**: The meta-analysis equivalent of sample size calculation
+- **Alpha Spending Functions**:
+  - O'Brien-Fleming: Conservative early, preserves power for final analysis
+  - Pocock: Uniform spending, allows earlier stopping
+- **Z-curve Interpretation**: Crossing boundaries indicates sufficient evidence
+
+### Result Interpretation
+- Confidence intervals and their clinical significance
+- Publication bias assessment using funnel plots
+- Cumulative meta-analysis trends
+
+## Communication Style
+
+- Use clear, accessible language
+- Provide context for statistical concepts
+- Give actionable recommendations
+- Format results with markdown for readability
+- When explaining statistics, use analogies when helpful
+
+## Important Notes
+
+- Always validate input data before calculations
+- Warn users about limitations (e.g., small sample sizes, high heterogeneity)
+- Recommend appropriate analysis settings based on data characteristics
+- If uncertain, suggest consulting a biostatistician
+"""
+
+
+class TSAOpenRouterAgent:
+    """
+    TSA Agent using OpenRouter for Claude access.
+
+    This is an alternative to the main TSAAgent when using OpenRouter
+    instead of direct Anthropic API access.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "claude-opus-4.5",
+        tsa_api_url: str = "http://localhost:8000",
+    ):
+        """
+        Initialize the TSA OpenRouter Agent.
+
+        Args:
+            api_key: OpenRouter API key
+            model: Claude model to use
+            tsa_api_url: URL of the TSA Plumber API
+        """
+        self.client = OpenRouterClient(api_key=api_key, model=model)
+        self.client.set_system_prompt(TSA_OPENROUTER_SYSTEM_PROMPT)
+        self.tsa_api_url = tsa_api_url
+        self.http_client = httpx.AsyncClient(base_url=tsa_api_url, timeout=30.0)
+
+    async def chat(self, message: str) -> str:
+        """
+        Send a message and get a response.
+
+        The agent will use the TSA Plumber API for calculations
+        and Claude via OpenRouter for natural language understanding.
+        """
+        # For now, just use the OpenRouter client directly
+        # In a full implementation, we'd parse the message,
+        # determine if TSA API calls are needed, make them,
+        # and incorporate results into the response
+        return await self.client.chat(message)
+
+    def new_session(self) -> None:
+        """Start a new conversation session."""
+        self.client.clear_history()
+
+    async def close(self) -> None:
+        """Close the agent and release resources."""
+        await self.http_client.aclose()
+
+
+async def test_openrouter():
+    """Test the OpenRouter client."""
+    client = OpenRouterClient(model="claude-opus-4.5")
+    client.set_system_prompt("You are a helpful assistant. Be concise.")
+
+    response = await client.chat("What is 2+2? Reply in one word.")
+    print(f"Response: {response}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_openrouter())

agent/src/tsa_agent.py

@@ -8,22 +8,40 @@ This agent specializes in:
 - Interpreting results and providing guidance
 
 The agent communicates with the R Plumber API which bridges to the Java TSA.jar
+
+Supports both:
+- Direct Anthropic API (ANTHROPIC_API_KEY)
+- OpenRouter API (OPENROUTER_API_KEY) for Claude access
 """
 
 import asyncio
 import os
 from pathlib import Path
-from typing import Any
-
-from claude_agent_sdk import (
-    ClaudeSDKClient,
-    ClaudeAgentOptions,
-    tool,
-    create_sdk_mcp_server,
-    AssistantMessage,
-    TextBlock,
-    ResultMessage,
-)
+from typing import Any, Optional
+
+# Check which API is available
+USE_OPENROUTER = bool(os.environ.get("OPENROUTER_API_KEY")) and not bool(os.environ.get("ANTHROPIC_API_KEY"))
+
+if not USE_OPENROUTER:
+    try:
+        from claude_agent_sdk import (
+            ClaudeSDKClient,
+            ClaudeAgentOptions,
+            tool,
+            create_sdk_mcp_server,
+            AssistantMessage,
+            TextBlock,
+            ResultMessage,
+        )
+        SDK_AVAILABLE = True
+    except ImportError:
+        SDK_AVAILABLE = False
+        USE_OPENROUTER = True  # Fall back to OpenRouter if SDK not available
+else:
+    SDK_AVAILABLE = False
+
+# Import OpenRouter client
+from openrouter_client import OpenRouterClient, TSAOpenRouterAgent, TSA_OPENROUTER_SYSTEM_PROMPT
 
 # Import our custom tools
 from tools.meta_analysis_tool import (
@@ -262,7 +280,15 @@ class TSAAgent:
 
 async def interactive_mode():
     """Run the agent in interactive mode."""
-    agent = TSAAgent()
+    # Choose agent based on available API
+    if USE_OPENROUTER:
+        print("\n🔄 Using OpenRouter API (Claude Opus 4.5)")
+        agent = TSAOpenRouterAgent(model="claude-opus-4.5")
+        is_openrouter = True
+    else:
+        print("\n🔄 Using Anthropic API")
+        agent = TSAAgent()
+        is_openrouter = False
 
     print("\n" + "="*60)
     print("   TSA AI Assistant - Trial Sequential Analysis Expert")
@@ -276,7 +302,8 @@ async def interactive_mode():
     print("Type 'new' to start a fresh session.")
     print("="*60 + "\n")
 
-    await agent.start_session()
+    if not is_openrouter:
+        await agent.start_session()
 
     try:
         while True:
@@ -289,8 +316,11 @@ async def interactive_mode():
                 break
 
             if user_input.lower() == 'new':
-                await agent.end_session()
-                await agent.start_session()
+                if is_openrouter:
+                    agent.new_session()
+                else:
+                    await agent.end_session()
+                    await agent.start_session()
                 print("\n🔄 Started new session.")
                 continue
 
@@ -299,7 +329,10 @@ async def interactive_mode():
             print(response)
 
     finally:
-        await agent.end_session()
+        if is_openrouter:
+            await agent.close()
+        else:
+            await agent.end_session()
 
     print("\nGoodbye! 👋")
 
@@ -342,8 +375,16 @@ async def server_mode(host: str = "127.0.0.1", port: int = 8080):
     from aiohttp import web
     import json
 
-    agent = TSAAgent()
-    await agent.start_session()
+    # Choose agent based on available API
+    if USE_OPENROUTER:
+        print("🔄 Using OpenRouter API (Claude Opus 4.5)")
+        agent = TSAOpenRouterAgent(model="claude-opus-4.5")
+        is_openrouter = True
+    else:
+        print("🔄 Using Anthropic API")
+        agent = TSAAgent()
+        is_openrouter = False
+        await agent.start_session()
 
     async def handle_chat(request: web.Request) -> web.Response:
         """Handle chat messages."""
@@ -370,14 +411,18 @@ async def server_mode(host: str = "127.0.0.1", port: int = 8080):
         """Health check endpoint."""
         return web.json_response({
             "status": "healthy",
-            "session_active": agent.session_active,
+            "backend": "openrouter" if is_openrouter else "anthropic",
+            "session_active": True if is_openrouter else agent.session_active,
         })
 
     async def handle_new_session(request: web.Request) -> web.Response:
         """Start a new session."""
         try:
-            await agent.end_session()
-            await agent.start_session()
+            if is_openrouter:
+                agent.new_session()
+            else:
+                await agent.end_session()
+                await agent.start_session()
             return web.json_response({"status": "new session started"})
         except Exception as e:
             return web.json_response(
@@ -431,7 +476,10 @@ async def server_mode(host: str = "127.0.0.1", port: int = 8080):
     except asyncio.CancelledError:
         pass
     finally:
-        await agent.end_session()
+        if is_openrouter:
+            await agent.close()
+        else:
+            await agent.end_session()
         await runner.cleanup()