pm_watcher_single.py

#!/usr/bin/env python3
"""
Prediction Market Watcher - Single File FastAPI Microservice
Exposes endpoints for evidence filtering, thesis generation, and decision making.
"""

import os
import sys
import json
import asyncio
import argparse
from typing import List, Dict, Any, Optional
from datetime import datetime
from dataclasses import dataclass, asdict
from enum import Enum

import uvicorn
from fastapi import FastAPI, HTTPException, Depends, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel, Field
from dotenv import load_dotenv

# LLM Providers
from openai import AsyncOpenAI
import google.generativeai as genai

# Kalshi imports
try:
    from kalshi_python import Configuration, ApiClient
    from kalshi_python.api import ExchangeApi, MarketsApi, PortfolioApi
    KALSHI_AVAILABLE = True
except ImportError:
    KALSHI_AVAILABLE = False
    print("Warning: kalshi-python not available. Kalshi integration disabled.")

# Polymarket imports
try:
    from py_clob_client.client import ClobClient
    from py_clob_client.clob_types import OrderArgs, MarketOrderArgs, OrderType
    from py_clob_client.order_builder.constants import BUY, SELL
    POLYMARKET_AVAILABLE = True
except ImportError:
    POLYMARKET_AVAILABLE = False
    print("Warning: py-clob-client not available. Polymarket integration disabled.")


# =============================================================================
# Data Models
# =============================================================================

class EvidenceItem(BaseModel):
    """Evidence item from web search or other sources"""
    url: str = Field(..., description="Source URL")
    title: str = Field(..., description="Title of the source")
    summary: str = Field(..., description="Summary of the content")
    timestamp: Optional[str] = Field(None, description="When this evidence was collected")
    relevance_score: Optional[float] = Field(None, description="Relevance score 0-1")

class Market(BaseModel):
    """Prediction market definition"""
    id: str = Field(..., description="Market identifier")
    question: str = Field(..., description="Market question")
    description: Optional[str] = Field(None, description="Detailed market description")
    end_date: Optional[str] = Field(None, description="Market resolution date")
    current_price: Optional[float] = Field(None, description="Current market price")
    platform: Optional[str] = Field("polymarket", description="Market platform")

class Thesis(BaseModel):
    """Analysis thesis for a market"""
    p_star: float = Field(..., description="Predicted probability", ge=0, le=1)
    confidence: float = Field(..., description="Confidence in prediction", ge=0, le=1)
    rationale: str = Field(..., description="Reasoning behind the prediction")
    supporting_sources: List[str] = Field(..., description="URLs of supporting evidence")
    risk_factors: Optional[List[str]] = Field(None, description="Identified risk factors")

class Decision(BaseModel):
    """Trading decision output"""
    action: str = Field(..., description="Recommended action: buy, sell, hold")
    size: float = Field(..., description="Position size (0-1)")
    confidence: float = Field(..., description="Decision confidence", ge=0, le=1)
    rationale: str = Field(..., description="Decision rationale")
    max_loss: Optional[float] = Field(None, description="Maximum acceptable loss")
    execution_disabled: bool = Field(True, description="Whether execution is disabled")

# Request/Response Models
class FilterEvidenceRequest(BaseModel):
    items: List[EvidenceItem]
    market: Market

class FilterEvidenceResponse(BaseModel):
    evidence: List[EvidenceItem]

class ThesisRequest(BaseModel):
    market: Market
    evidence: List[EvidenceItem]

class ThesisResponse(BaseModel):
    p_star: float
    confidence: float
    rationale: str
    supporting_sources: List[str]
    risk_factors: Optional[List[str]] = None
    thesis: Optional[Thesis] = None

class DecideRequest(BaseModel):
    market: Market
    thesis: Thesis

class DecideResponse(BaseModel):
    action: str
    size: float
    confidence: float
    rationale: str
    max_loss: Optional[float] = None
    execution_disabled: bool = True


# =============================================================================
# Configuration
# =============================================================================

class Config:
    """Application configuration"""
    
    def __init__(self):
        env_path = os.path.join(os.getcwd(), ".env")
        print(f"Loading env from: {env_path}")
        load_dotenv(env_path)
        
        self.llm_backend = os.getenv("LLM_BACKEND", "mock")
        self.openai_api_key = os.getenv("OPENAI_API_KEY")
        self.openai_base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
        self.openai_model = os.getenv("OPENAI_MODEL", "gpt-4")
        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
        self.openrouter_base_url = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
        self.openrouter_model = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.1-8b-instruct:free")
        self.polymarket_enabled = os.getenv("POLYMARKET_ENABLED", "false").lower() == "true"
        self.polymarket_api_key = os.getenv("POLYMARKET_API_KEY")
        self.polymarket_private_key = os.getenv("POLYMARKET_PRIVATE_KEY")
        self.polymarket_funder_address = os.getenv("POLYMARKET_FUNDER_ADDRESS")
        self.kalshi_enabled = os.getenv("KALSHI_ENABLED", "false").lower() == "true"
        self.kalshi_api_key = os.getenv("KALSHI_API_KEY")
        self.kalshi_private_key = os.getenv("KALSHI_PRIVATE_KEY")
        self.execution_enabled = os.getenv("EXECUTION_ENABLED", "false").lower() == "true"
        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
        self.port = int(os.getenv("PORT", "8787"))
        
        # Risk Management Configuration
        self.max_position_size_usd = float(os.getenv("MAX_POSITION_SIZE_USD", "50.0"))
        self.max_daily_loss_usd = float(os.getenv("MAX_DAILY_LOSS_USD", "100.0"))
        
    def validate_production_config(self):
        """Validate that production configuration is complete"""
        if self.llm_backend == "openai" and not self.openai_api_key:
            raise ValueError("OPENAI_API_KEY is required when LLM_BACKEND=openai")
        if self.llm_backend == "openrouter" and not self.openrouter_api_key:
            raise ValueError("OPENROUTER_API_KEY is required when LLM_BACKEND=openrouter")
        if self.llm_backend == "gemini" and not self.gemini_api_key:
            raise ValueError("GEMINI_API_KEY is required when LLM_BACKEND=gemini")
            raise ValueError("OPENROUTER_API_KEY is required when LLM_BACKEND=openrouter")


# =============================================================================
# Risk Management
# =============================================================================

class RiskManager:
    """
    Enforces safety limits on trading decisions.
    Acts as a circuit breaker and position sizer.
    """
    
    def __init__(self, config: Config):
        self.config = config
        self.daily_loss = 0.0  # In a real app, this should be persisted (DB/Redis)
        self.last_reset = datetime.utcnow().date()
    
    def _reset_daily_stats_if_needed(self):
        """Reset daily stats if the day has changed"""
        current_date = datetime.utcnow().date()
        if current_date > self.last_reset:
            self.daily_loss = 0.0
            self.last_reset = current_date
            
    def validate_decision(self, decision: DecideResponse, market: Market) -> DecideResponse:
        """
        Validate and potentially modify a trading decision based on risk rules.
        """
        self._reset_daily_stats_if_needed()
        
        # Rule 1: If execution is disabled globally, ensure it's disabled in decision
        if not self.config.execution_enabled:
            decision.execution_disabled = True
            return decision

        # If action is HOLD, no risk check needed
        if decision.action.lower() not in ["buy", "sell"]:
            return decision
            
        # Rule 2: Check Daily Loss Limit
        # Note: This is a simple check. In production, we'd need to track realized PnL.
        # Here we just stop trading if we've hit the limit.
        if self.daily_loss >= self.config.max_daily_loss_usd:
            print(f"Risk Alert: Daily loss limit reached (${self.daily_loss} >= ${self.config.max_daily_loss_usd})")
            decision.action = "hold"
            decision.rationale += " [RISK OVERRIDE: Daily loss limit reached]"
            decision.execution_disabled = True
            return decision
            
        # Rule 3: Max Position Size
        # We assume 'size' in decision is 0-1 (percentage of max size) or absolute amount?
        # The prompt implies 0-1. Let's interpret it as percentage of MAX_POSITION_SIZE_USD for safety.
        # Or if it's raw amount, we cap it.
        # Let's assume the LLM returns a confidence-weighted size (0-1).
        
        target_size_usd = decision.size * self.config.max_position_size_usd
        
        # Cap at max position size
        if target_size_usd > self.config.max_position_size_usd:
            target_size_usd = self.config.max_position_size_usd
            decision.rationale += f" [RISK: Capped at max size ${self.config.max_position_size_usd}]"
            
        # Update the decision size to be the USD amount (or keep as ratio if downstream expects ratio)
        # The PlaceOrderRequest expects 'amount'. Let's standardize on 'amount' being USD/Contracts.
        # For now, we'll update the rationale to reflect the approved size.
        
        decision.rationale += f" [RISK APPROVED: Size ${target_size_usd:.2f}]"
        
        return decision

# Global Risk Manager
risk_manager = None

def get_risk_manager() -> RiskManager:
    global risk_manager
    if risk_manager is None:
        risk_manager = RiskManager(config)
    return risk_manager


# =============================================================================
# LLM Integration
# =============================================================================

class LLMProvider:
    """Abstract LLM provider interface"""
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        raise NotImplementedError
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        raise NotImplementedError


class OpenRouterProvider(LLMProvider):
    """OpenRouter provider for production use with various models"""
    
    def __init__(self, config: Config):
        self.config = config
        # Import OpenAI only when needed (OpenRouter uses OpenAI-compatible API)
        try:
            import openai
            self.client = openai.AsyncOpenAI(
                api_key=config.openrouter_api_key,
                base_url=config.openrouter_base_url
            )
        except ImportError:
            raise ImportError("openai package required for OpenRouter provider. Install with: pip install openai")
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        """Generate thesis using OpenRouter"""
        evidence_text = "\n".join([
            f"- {item.title}: {item.summary} ({item.url})"
            for item in evidence
        ])
        
        prompt = f"""
        Analyze the following prediction market and evidence to generate a thesis:
        
        Market: {market.question}
        Description: {market.description or "N/A"}
        Current Price: {market.current_price or "Unknown"}
        
        Evidence:
        {evidence_text}
        
        Provide a JSON response with exactly this structure:
        {{
            "p_star": 0.75,
            "confidence": 0.8,
            "rationale": "detailed reasoning here",
            "supporting_sources": ["url1", "url2"],
            "risk_factors": ["risk1", "risk2"]
        }}
        
        Important: 
        - p_star and confidence must be numbers between 0 and 1
        - supporting_sources must be a list of strings (URLs)
        - risk_factors must be a list of strings (not a single string)
        - Be objective and base your analysis on the evidence provided
        """
        
        try:
            response = await self.client.chat.completions.create(
                model=self.config.openrouter_model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.1
            )
            
            result = json.loads(response.choices[0].message.content)
            
            # Ensure risk_factors is a list if provided
            if "risk_factors" in result and isinstance(result["risk_factors"], str):
                result["risk_factors"] = [result["risk_factors"]]
            
            return ThesisResponse(**result)
            
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"LLM analysis failed: {str(e)}")
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        """Make trading decision using OpenRouter"""
        prompt = f"""
        Based on the following market analysis, make a trading decision:
        
        Market: {market.question}
        Current Price: {market.current_price or "Unknown"}
        
        Thesis:
        - Predicted Probability: {thesis.p_star}
        - Confidence: {thesis.confidence}
        - Rationale: {thesis.rationale}
        
        Provide a JSON response with:
        - action: "buy", "sell", or "hold"
        - size: position size (0-1, where 1 is maximum position)
        - confidence: decision confidence (0-1)
        - rationale: decision reasoning
        - max_loss: maximum acceptable loss (optional)
        
        Consider risk management and position sizing carefully.
        """
        
        try:
            response = await self.client.chat.completions.create(
                model=self.config.openrouter_model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.1
            )
            
            result = json.loads(response.choices[0].message.content)
            result["execution_disabled"] = not self.config.execution_enabled
            return DecideResponse(**result)
            
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"Decision making failed: {str(e)}")


class OpenAIProvider(LLMProvider):
    """OpenAI GPT provider for production use"""
    
    def __init__(self, config: Config):
        self.config = config
        # Import OpenAI only when needed
        try:
            import openai
            self.client = openai.AsyncOpenAI(
                api_key=config.openai_api_key,
                base_url=config.openai_base_url
            )
        except ImportError:
            raise ImportError("openai package required for OpenAI provider. Install with: pip install openai")
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        """Generate thesis using OpenAI"""
        evidence_text = "\n".join([
            f"- {item.title}: {item.summary} ({item.url})"
            for item in evidence
        ])
        
        prompt = f"""
        Analyze the following prediction market and evidence to generate a thesis:
        
        Market: {market.question}
        Description: {market.description or "N/A"}
        Current Price: {market.current_price or "Unknown"}
        
        Evidence:
        {evidence_text}
        
        Provide a JSON response with:
        - p_star: probability estimate (0-1)
        - confidence: confidence in estimate (0-1)
        - rationale: detailed reasoning
        - supporting_sources: list of relevant URLs
        - risk_factors: potential risks (optional)
        
        Be objective and base your analysis on the evidence provided.
        """
        
        try:
            response = await self.client.chat.completions.create(
                model=self.config.openai_model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.1
            )
            
            result = json.loads(response.choices[0].message.content)
            return ThesisResponse(**result)
            
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"LLM analysis failed: {str(e)}")
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        """Make trading decision using OpenAI"""
        prompt = f"""
        Based on the following market analysis, make a trading decision:
        
        Market: {market.question}
        Current Price: {market.current_price or "Unknown"}
        
        Thesis:
        - Predicted Probability: {thesis.p_star}
        - Confidence: {thesis.confidence}
        - Rationale: {thesis.rationale}
        
        Provide a JSON response with:
        - action: "buy", "sell", or "hold"
        - size: position size (0-1, where 1 is maximum position)
        - confidence: decision confidence (0-1)
        - rationale: decision reasoning
        - max_loss: maximum acceptable loss (optional)
        
        Consider risk management and position sizing carefully.
        """
        
        try:
            response = await self.client.chat.completions.create(
                model=self.config.openai_model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.1
            )
            
            result = json.loads(response.choices[0].message.content)
            result["execution_disabled"] = not self.config.execution_enabled
            return DecideResponse(**result)
            
        except Exception as e:
            raise HTTPException(status_code=500, detail=f"Decision making failed: {str(e)}")


class MockProvider(LLMProvider):
    """Mock provider for testing only - should never be used in production"""
    
    def __init__(self, config: Config):
        self.config = config
        if config.llm_backend == "openai":
            raise ValueError("Mock provider should not be used when LLM_BACKEND=openai")
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        """Mock thesis generation - TEST ONLY"""
        if self.config.llm_backend == "openai":
            raise ValueError("Mock provider called in production mode")
            
        return ThesisResponse(
            p_star=0.65,
            confidence=0.7,
            rationale="Mock analysis - this should only appear in test mode",
            supporting_sources=[item.url for item in evidence[:3]],
            risk_factors=["This is mock data", "Not for production use"]
        )
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        """Mock decision making - TEST ONLY"""
        if self.config.llm_backend == "openai":
            raise ValueError("Mock provider called in production mode")
            
        return DecideResponse(
            action="hold",
            size=0.0,
            confidence=0.5,
            rationale="Mock decision - this should only appear in test mode",
            execution_disabled=True
        )


# =============================================================================
# FastAPI Application
# =============================================================================

# Global configuration
config = Config()

# Initialize FastAPI app
app = FastAPI(
    title="Prediction Market Watcher",
    description="Microservice for prediction market analysis and decision making",
    version="1.0.0"
)

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize LLM provider
def get_llm_provider() -> LLMProvider:
    """Get the appropriate LLM provider based on configuration"""
    if config.llm_backend == "openai":
        return OpenAIProvider(config)
    elif config.llm_backend == "openrouter":
        return OpenRouterProvider(config)
    elif config.llm_backend == "polymarket":
        if not POLYMARKET_AVAILABLE:
            raise HTTPException(status_code=500, detail="Polymarket integration not available")
        return PolymarketProvider(config)
    elif config.llm_backend == "kalshi":
        if not KALSHI_AVAILABLE:
            raise HTTPException(status_code=500, detail="Kalshi integration not available")
        return KalshiProvider(config)
    elif config.llm_backend == "mock":
        return MockProvider(config)
    else:
        raise HTTPException(status_code=500, detail=f"Unknown LLM backend: {config.llm_backend}")


# =============================================================================
# API Endpoints
# =============================================================================

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {
        "ok": True,
        "timestamp": datetime.utcnow().isoformat(),
        "llm_backend": config.llm_backend,
        "execution_enabled": config.execution_enabled,
        "risk_config": {
            "max_position_size": config.max_position_size_usd,
            "max_daily_loss": config.max_daily_loss_usd
        }
    }


@app.post("/filter_evidence", response_model=FilterEvidenceResponse)
async def filter_evidence(request: FilterEvidenceRequest):
    """Filter and rank evidence items by relevance"""
    try:
        # Simple filtering logic - in production this could be more sophisticated
        filtered_evidence = []
        
        for item in request.items:
            # Basic filtering criteria
            if len(item.summary) < 10:  # Too short
                continue
            if "404" in item.title.lower() or "not found" in item.title.lower():
                continue
            if not item.url.startswith(("http://", "https://")):
                continue
                
            # Add relevance score if not present
            if item.relevance_score is None:
                # Simple scoring based on summary length and title keywords
                score = min(len(item.summary) / 500.0, 1.0)
                item.relevance_score = score
            
            filtered_evidence.append(item)
        
        # Sort by relevance score (descending)
        filtered_evidence.sort(key=lambda x: x.relevance_score or 0, reverse=True)
        
        # Limit to top 10 items
        filtered_evidence = filtered_evidence[:10]
        
        return FilterEvidenceResponse(evidence=filtered_evidence)
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Evidence filtering failed: {str(e)}")


@app.post("/thesis", response_model=ThesisResponse)
async def generate_thesis(request: ThesisRequest, llm: LLMProvider = Depends(get_llm_provider)):
    """Generate analysis thesis for a market based on evidence"""
    try:
        if not request.evidence:
            raise HTTPException(status_code=400, detail="No evidence provided")
        
        thesis = await llm.analyze_evidence(request.market, request.evidence)
        return thesis
        
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Thesis generation failed: {str(e)}")


@app.post("/decide", response_model=DecideResponse)
async def make_decision(request: DecideRequest, llm: LLMProvider = Depends(get_llm_provider)):
    """Make trading decision based on market and thesis"""
    try:
        decision = await llm.make_decision(request.market, request.thesis)
        
        # Risk Management Check
        rm = get_risk_manager()
        decision = rm.validate_decision(decision, request.market)
        
        # Ensure execution is disabled by default if config says so (double check)
        if not config.execution_enabled:
            decision.execution_disabled = True
        
        return decision
        
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Decision making failed: {str(e)}")


# =============================================================================
# Market Data and Trading Endpoints
# =============================================================================

class MarketDataRequest(BaseModel):
    market_id: str = Field(..., description="Market identifier")
    platform: str = Field(..., description="Platform (polymarket or kalshi)")

class MarketDataResponse(BaseModel):
    market_id: str
    platform: str
    data: Dict[str, Any]

class PlaceOrderRequest(BaseModel):
    market_id: str = Field(..., description="Market identifier")
    platform: str = Field(..., description="Platform (polymarket or kalshi)")
    side: str = Field(..., description="Order side (buy or sell)")
    amount: float = Field(..., description="Order amount")
    price: Optional[float] = Field(None, description="Order price (for limit orders)")

class PlaceOrderResponse(BaseModel):
    success: bool
    order_id: Optional[str] = None
    message: str
    details: Dict[str, Any] = {}

@app.get("/market/{platform}/{market_id}")
async def get_market_data(platform: str, market_id: str):
    """Get market data from specified platform"""
    try:
        if platform.lower() == "polymarket":
            if not POLYMARKET_AVAILABLE:
                raise HTTPException(status_code=400, detail="Polymarket integration not available")
            
            provider = PolymarketProvider(config)
            data = await provider.get_market_data(market_id)
            return MarketDataResponse(
                market_id=market_id,
                platform="polymarket",
                data=data
            )
            
        elif platform.lower() == "kalshi":
            if not KALSHI_AVAILABLE:
                raise HTTPException(status_code=400, detail="Kalshi integration not available")
            
            provider = KalshiProvider(config)
            data = await provider.get_market_data(market_id)
            return MarketDataResponse(
                market_id=market_id,
                platform="kalshi",
                data=data
            )
            
        else:
            raise HTTPException(status_code=400, detail=f"Unsupported platform: {platform}")
            
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to get market data: {str(e)}")

@app.post("/trade", response_model=PlaceOrderResponse)
async def place_order(request: PlaceOrderRequest):
    """Place an order on the specified platform"""
    try:
        if not config.execution_enabled:
            return PlaceOrderResponse(
                success=False,
                message="Trading execution is disabled",
                details={"execution_enabled": False}
            )
        
        if request.platform.lower() == "polymarket":
            if not POLYMARKET_AVAILABLE:
                raise HTTPException(status_code=400, detail="Polymarket integration not available")
            
            provider = PolymarketProvider(config)
            result = await provider.place_order(
                request.market_id, 
                request.side, 
                request.amount, 
                request.price
            )
            
            return PlaceOrderResponse(
                success=result.get("success", False),
                order_id=result.get("order_id"),
                message=result.get("message", "Order placed"),
                details=result
            )
            
        elif request.platform.lower() == "kalshi":
            if not KALSHI_AVAILABLE:
                raise HTTPException(status_code=400, detail="Kalshi integration not available")
            
            provider = KalshiProvider(config)
            # Convert amount to int for Kalshi (cents)
            kalshi_amount = int(request.amount * 100) if request.amount else 0
            kalshi_price = int(request.price * 100) if request.price else None
            
            result = await provider.place_order(
                request.market_id, 
                request.side, 
                kalshi_amount, 
                kalshi_price
            )
            
            return PlaceOrderResponse(
                success=result.get("success", False),
                order_id=result.get("order_id"),
                message=result.get("message", "Order placed"),
                details=result
            )
            
        else:
            raise HTTPException(status_code=400, detail=f"Unsupported platform: {request.platform}")
            
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Failed to place order: {str(e)}")


# =============================================================================
# CLI Interface
# =============================================================================

class PolymarketProvider(LLMProvider):
    """Polymarket integration provider for real market data and trading"""
    
    def __init__(self, config: Config):
        self.config = config
        self.client = None
        if POLYMARKET_AVAILABLE and config.polymarket_private_key:
            try:
                self.client = ClobClient(
                    host="https://clob.polymarket.com",
                    key=config.polymarket_private_key,
                    chain_id=137,  # Polygon mainnet
                    signature_type=0,  # EOA signature
                    funder=config.polymarket_funder_address
                )
                if self.client:
                    self.client.set_api_creds(self.client.create_or_derive_api_creds())
                    print("Polymarket client initialized successfully")
            except Exception as e:
                print(f"Failed to initialize Polymarket client: {e}")
                self.client = None
        else:
            print("Polymarket not available or credentials missing")
    
    async def get_market_data(self, market_id: str) -> Dict[str, Any]:
        """Get real market data from Polymarket"""
        if not self.client:
            raise HTTPException(status_code=503, detail="Polymarket client not available")
        
        try:
            # Get market price and orderbook data
            midpoint = self.client.get_midpoint(market_id)
            buy_price = self.client.get_price(market_id, side="BUY")
            sell_price = self.client.get_price(market_id, side="SELL")
            orderbook = self.client.get_order_book(market_id)
            
            return {
                "market_id": market_id,
                "midpoint": midpoint,
                "buy_price": buy_price,
                "sell_price": sell_price,
                "orderbook": orderbook,
                "timestamp": datetime.utcnow().isoformat()
            }
        except Exception as e:
            print(f"Error fetching Polymarket data: {e}")
            raise HTTPException(status_code=500, detail=f"Failed to fetch market data: {str(e)}")
    
    async def place_order(self, market_id: str, side: str, amount: float, price: float = None) -> Dict[str, Any]:
        """Place an order on Polymarket"""
        if not self.client:
            raise HTTPException(status_code=503, detail="Polymarket client not available")
        
        if not self.config.execution_enabled:
            return {
                "status": "simulation",
                "message": "Order placement disabled - simulation mode",
                "market_id": market_id,
                "side": side,
                "amount": amount,
                "price": price
            }
        
        try:
            if price is None:
                # Market order
                order_side = BUY if side.lower() == "buy" else SELL
                mo = MarketOrderArgs(
                    token_id=market_id,
                    amount=amount,
                    side=order_side,
                    order_type=OrderType.FOK
                )
                signed_order = self.client.create_market_order(mo)
                response = self.client.post_order(signed_order, OrderType.FOK)
            else:
                # Limit order
                order_side = BUY if side.lower() == "buy" else SELL
                order_args = OrderArgs(
                    token_id=market_id,
                    price=price,
                    size=amount,
                    side=order_side
                )
                signed_order = self.client.create_order(order_args)
                response = self.client.post_order(signed_order, OrderType.GTC)
            
            return {
                "status": "success",
                "order_response": response,
                "market_id": market_id,
                "side": side,
                "amount": amount,
                "price": price,
                "timestamp": datetime.utcnow().isoformat()
            }
        except Exception as e:
            print(f"Error placing Polymarket order: {e}")
            raise HTTPException(status_code=500, detail=f"Failed to place order: {str(e)}")
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        """Analyze evidence using real market data from Polymarket"""
        try:
            # Get real market data if market ID is provided
            market_data = None
            if hasattr(market, 'id') and market.id and self.client:
                try:
                    market_data = await self.get_market_data(market.id)
                except Exception as e:
                    print(f"Could not fetch market data: {e}")
            
            # Use OpenRouter for LLM analysis with real market context
            openrouter_provider = OpenRouterProvider(self.config)
            
            # Enhance the market context with real data
            enhanced_market = market
            if market_data:
                enhanced_market.current_price = market_data.get("midpoint", market.current_price)
                enhanced_market.description = f"{market.description or ''}\n\nReal-time market data:\n- Current price: {market_data.get('midpoint', 'N/A')}\n- Buy price: {market_data.get('buy_price', 'N/A')}\n- Sell price: {market_data.get('sell_price', 'N/A')}"
            
            return await openrouter_provider.analyze_evidence(enhanced_market, evidence)
            
        except Exception as e:
            print(f"Error in Polymarket analysis: {e}")
            raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        """Make trading decision with real Polymarket integration"""
        try:
            # Get real market data for decision making
            market_data = None
            if hasattr(market, 'id') and market.id and self.client:
                try:
                    market_data = await self.get_market_data(market.id)
                except Exception as e:
                    print(f"Could not fetch market data for decision: {e}")
            
            # Use OpenRouter for decision logic with real market context
            openrouter_provider = OpenRouterProvider(self.config)
            
            # Enhance the market context with real data
            enhanced_market = market
            if market_data:
                enhanced_market.current_price = market_data.get("midpoint", market.current_price)
            
            decision = await openrouter_provider.make_decision(enhanced_market, thesis)
            
            # If execution is enabled and we have a buy/sell decision, place the order
            if (self.config.execution_enabled and 
                decision.action.lower() in ["buy", "sell"] and 
                hasattr(market, 'id') and market.id and 
                self.client):
                
                try:
                    # Calculate order amount based on decision size
                    order_amount = decision.size * 100  # Convert to dollar amount
                    
                    # Place the order
                    order_result = await self.place_order(
                        market_id=market.id,
                        side=decision.action,
                        amount=order_amount
                    )
                    
                    # Update decision with execution details
                    decision.execution_disabled = False
                    decision.rationale += f"\n\nOrder executed: {order_result.get('status', 'unknown')}"
                    
                except Exception as e:
                    print(f"Order execution failed: {e}")
                    decision.rationale += f"\n\nOrder execution failed: {str(e)}"
            
            return decision
            
        except Exception as e:
            print(f"Error in Polymarket decision: {e}")
            raise HTTPException(status_code=500, detail=f"Decision failed: {str(e)}")


class KalshiProvider(LLMProvider):
    """Kalshi integration provider for real market data and trading"""
    
    def __init__(self, config: Config):
        self.config = config
        self.client = None
        self.market_api = None
        self.exchange_api = None
        self.portfolio_api = None
        
        if KALSHI_AVAILABLE and config.kalshi_api_key:
            try:
                configuration = Configuration(
                    host="https://api.elections.kalshi.com/trade-api/v2",
                    api_key={'KEY': config.kalshi_api_key}
                )
                
                api_client = ApiClient(configuration)
                
                # Set up authentication if private key is available
                if config.kalshi_private_key and os.path.exists(config.kalshi_private_key):
                    api_client.set_kalshi_auth(config.kalshi_api_key, config.kalshi_private_key)
                    print(f"Kalshi authentication configured with key: {config.kalshi_private_key}")
                else:
                    print("Warning: Kalshi private key not found, authentication will fail for trading")
                
                self.exchange_api = ExchangeApi(api_client)
                self.market_api = MarketsApi(api_client)
                self.portfolio_api = PortfolioApi(api_client)
                print("Kalshi client initialized successfully")
            except Exception as e:
                print(f"Failed to initialize Kalshi client: {e}")
                self.client = None
        else:
            print("Kalshi not available or credentials missing")
    
    async def get_market_data(self, market_id: str) -> Dict[str, Any]:
        """Get real market data from Kalshi"""
        if not self.market_api:
            raise HTTPException(status_code=503, detail="Kalshi client not available")
        
        try:
            # Get market information
            market_response = self.market_api.get_market(market_id)
            market = market_response.market
            
            # Get orderbook data
            orderbook_response = self.market_api.get_market_orderbook(market_id)
            orderbook = orderbook_response.orderbook
            
            return {
                "market_id": market_id,
                "title": market.title,
                "subtitle": market.subtitle,
                "yes_price": market.yes_bid if hasattr(market, 'yes_bid') else None,
                "no_price": market.no_bid if hasattr(market, 'no_bid') else None,
                "volume": market.volume,
                "open_interest": market.open_interest,
                "orderbook": {
                    "yes": orderbook.yes if orderbook else [],
                    "no": orderbook.no if orderbook else []
                },
                "timestamp": datetime.utcnow().isoformat()
            }
        except Exception as e:
            print(f"Error fetching Kalshi data: {e}")
            raise HTTPException(status_code=500, detail=f"Failed to fetch market data: {str(e)}")
    
    async def place_order(self, market_id: str, side: str, amount: int, price: int = None) -> Dict[str, Any]:
        """Place an order on Kalshi"""
        if not self.market_api:
            raise HTTPException(status_code=503, detail="Kalshi client not available")
        
        if not self.config.execution_enabled:
            return {
                "status": "simulation",
                "message": "Order placement disabled - simulation mode",
                "market_id": market_id,
                "side": side,
                "amount": amount,
                "price": price
            }
        
        try:
            # Create order request
            order_request = {
                "ticker": market_id,
                "client_order_id": f"order_{datetime.utcnow().timestamp()}",
                "side": side.lower(),  # "yes" or "no"
                "action": "buy",  # Kalshi uses "buy" for both yes/no positions
                "count": amount,
                "type": "market" if price is None else "limit"
            }
            
            if price is not None:
                order_request["yes_price"] = price if side.lower() == "yes" else None
                order_request["no_price"] = price if side.lower() == "no" else None
            
            # Submit order
            response = self.market_api.create_order(**order_request)
            
            return {
                "status": "success",
                "order_response": response,
                "market_id": market_id,
                "side": side,
                "amount": amount,
                "price": price,
                "timestamp": datetime.utcnow().isoformat()
            }
        except Exception as e:
            print(f"Error placing Kalshi order: {e}")
            raise HTTPException(status_code=500, detail=f"Failed to place order: {str(e)}")
    
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        """Analyze evidence using real market data from Kalshi"""
        try:
            # Get real market data if market ID is provided
            market_data = None
            if hasattr(market, 'id') and market.id and self.market_api:
                try:
                    market_data = await self.get_market_data(market.id)
                except Exception as e:
                    print(f"Could not fetch Kalshi market data: {e}")
            
            # Use OpenRouter for LLM analysis with real market context
            openrouter_provider = OpenRouterProvider(self.config)
            
            # Enhance the market context with real data
            enhanced_market = market
            if market_data:
                enhanced_market.current_price = market_data.get("yes_price", market.current_price)
                enhanced_market.description = f"{market.description or ''}\n\nReal-time Kalshi data:\n- Title: {market_data.get('title', 'N/A')}\n- Yes price: {market_data.get('yes_price', 'N/A')}\n- No price: {market_data.get('no_price', 'N/A')}\n- Volume: {market_data.get('volume', 'N/A')}\n- Open Interest: {market_data.get('open_interest', 'N/A')}"
            
            return await openrouter_provider.analyze_evidence(enhanced_market, evidence)
            
        except Exception as e:
            print(f"Error in Kalshi analysis: {e}")
            raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
    
    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        """Make trading decision with real Kalshi integration"""
        try:
            # Get real market data for decision making
            market_data = None
            if hasattr(market, 'id') and market.id and self.market_api:
                try:
                    market_data = await self.get_market_data(market.id)
                except Exception as e:
                    print(f"Could not fetch Kalshi market data for decision: {e}")
            
            # Use OpenRouter for decision logic with real market context
            openrouter_provider = OpenRouterProvider(self.config)
            
            # Enhance the market context with real data
            enhanced_market = market
            if market_data:
                enhanced_market.current_price = market_data.get("yes_price", market.current_price)
            
            decision = await openrouter_provider.make_decision(enhanced_market, thesis)
            
            # If execution is enabled and we have a buy/sell decision, place the order
            if (self.config.execution_enabled and 
                decision.action.lower() in ["buy", "sell"] and 
                hasattr(market, 'id') and market.id and 
                self.market_api):
                
                try:
                    # Convert decision to Kalshi format
                    side = "yes" if decision.action.lower() == "buy" else "no"
                    order_count = int(decision.size * 100)  # Convert to contract count
                    
                    # Place the order
                    order_result = await self.place_order(
                        market_id=market.id,
                        side=side,
                        amount=order_count
                    )
                    
                    # Update decision with execution details
                    decision.execution_disabled = False
                    decision.rationale += f"\n\nKalshi order executed: {order_result.get('status', 'unknown')}"
                    
                except Exception as e:
                    print(f"Kalshi order execution failed: {e}")
                    decision.rationale += f"\n\nKalshi order execution failed: {str(e)}"
            
            return decision
            
        except Exception as e:
            print(f"Error in Kalshi decision: {e}")
            raise HTTPException(status_code=500, detail=f"Decision failed: {str(e)}")


def run_api(host: str = "127.0.0.1", port: int = 8787):
    """Run the FastAPI server"""
    try:
        config.validate_production_config()
    except ValueError as e:
        print(f"Configuration error: {e}")
        sys.exit(1)
    
    print(f"Starting Prediction Market Watcher API on {host}:{port}")
    print(f"LLM Backend: {config.llm_backend}")
    print(f"Execution Enabled: {config.execution_enabled}")
    
    uvicorn.run(
        "pm_watcher_single:app",
        host=host,
        port=port,
        reload=False,
        access_log=True
    )


import google.generativeai as genai


class GeminiProvider(LLMProvider):
    """Gemini integration provider"""
    
    def __init__(self, config: Config):
        self.config = config
        if config.gemini_api_key:
            genai.configure(api_key=config.gemini_api_key)
            self.model = genai.GenerativeModel('gemini-2.5-flash')
        else:
            print("Gemini API key missing")
            
    async def analyze_evidence(self, market: Market, evidence: List[EvidenceItem]) -> ThesisResponse:
        prompt = f"""
        Analyze the following prediction market:
        Question: {market.question}
        Description: {market.description}
        Current Price: {market.current_price}
        
        Evidence:
        {json.dumps([e.dict() for e in evidence], indent=2)}
        
        Provide a probability estimate (p_star), confidence level (0-1), rationale, and risk factors.
        Return ONLY valid JSON in the following format:
        {{
            "p_star": 0.75,
            "confidence": 0.8,
            "rationale": "...",
            "supporting_sources": ["..."],
            "risk_factors": ["..."]
        }}
        """
        try:
            response = self.model.generate_content(prompt)
            # Clean up response to ensure valid JSON
            text = response.text.replace("```json", "").replace("```", "").strip()
            data = json.loads(text)
            # Return ThesisResponse with nested Thesis
            return ThesisResponse(
                p_star=data["p_star"],
                confidence=data["confidence"],
                rationale=data["rationale"],
                supporting_sources=data["supporting_sources"],
                thesis=Thesis(**data)
            )
        except Exception as e:
            print(f"Gemini analysis failed: {e}")
            raise HTTPException(status_code=500, detail=f"Gemini analysis failed: {str(e)}")

    async def make_decision(self, market: Market, thesis: Thesis) -> DecideResponse:
        prompt = f"""
        Make a trading decision based on this thesis:
        Market: {market.question} (Price: {market.current_price})
        Thesis: P(True)={thesis.p_star}, Confidence={thesis.confidence}
        Rationale: {thesis.rationale}
        
        Risk Limits: Max Size ${self.config.max_position_size_usd}
        
        Return ONLY valid JSON with these fields:
        {{
            "action": "buy" | "sell" | "hold",
            "size": 0.5,
            "confidence": 0.8,
            "rationale": "..."
        }}
        """
        try:
            response = self.model.generate_content(prompt)
            text = response.text.replace("```json", "").replace("```", "").strip()
            data = json.loads(text)
            return DecideResponse(**data)
        except Exception as e:
            print(f"Gemini decision failed: {e}")
            raise HTTPException(status_code=500, detail=f"Gemini decision failed: {str(e)}")

# ... (GeminiProvider implementation)

def get_config():
    return config

def get_llm_provider(config: Config = Depends(get_config)) -> LLMProvider:
    if config.llm_backend == "openai":
        return OpenAIProvider(config)
    elif config.llm_backend == "openrouter":
        return OpenRouterProvider(config)
    elif config.llm_backend == "gemini":
        return GeminiProvider(config)

async def scan_markets(limit: int = 10):
    """Scan active Kalshi markets and generate detailed investment recommendations"""
    print(f"Scanning top {limit} active Kalshi markets for profitable opportunities...")
    
    config = Config()
    kalshi = KalshiProvider(config)
    gemini = GeminiProvider(config)
    
    if not kalshi.market_api:
        print("Kalshi client not available. Check credentials.")
        return

    try:
        # Fetch markets (fetch more to find liquid ones)
        print("Fetching top 100 active markets (no status filter) to debug...")
        markets_response = kalshi.market_api.get_markets(limit=100)
        all_markets = markets_response.markets
        
        if all_markets:
            print(f"DEBUG: First market raw data: {all_markets[0]}")
        
        # Filter and Sort
        active_markets = []
        for m in all_markets:
            # Price Discovery: Prefer last_price, then mid-market, then bid
            current_price = m.last_price
            if not current_price:
                if m.yes_bid and m.yes_ask:
                    current_price = (m.yes_bid + m.yes_ask) / 2
                elif m.yes_bid:
                    current_price = m.yes_bid
                else:
                    # current_price = 0.5 # DANGEROUS: Do not guess price
                    continue
            
            # Skip if price is effectively 0 or 1 (likely dead market)
            if current_price <= 0.01 or current_price >= 0.99:
                continue
                
            active_markets.append((m, current_price))
            
        # Sort by 24h volume descending, then total volume
        active_markets.sort(key=lambda x: ((x[0].volume_24h or 0), (x[0].volume or 0)), reverse=True)
        
        print(f"Found {len(active_markets)} potentially active markets. Analyzing top {limit}...\n")
        
        opportunities = []
        for m, current_price in active_markets[:limit]:
            vol_str = f"Vol24h: {m.volume_24h}, Total: {m.volume}"
            print(f"📊 Analyzing: {m.title[:60]} (Price: {current_price*100:.1f}%, {vol_str})")
            
            # Construct Market object
            market_obj = Market(
                id=m.ticker,
                question=m.title,
                description=m.subtitle,
                current_price=current_price
            )
            
            try:
                # Enhanced analysis prompt
                enhanced_prompt = f"""
                Analyze this prediction market for investment potential:
                
                Question: {market_obj.question}
                Description: {market_obj.description}
                Current Price: {market_obj.current_price} (implies {market_obj.current_price*100:.1f}% probability)
                
                Provide a comprehensive analysis including:
                1. Your probability estimate (p_star)
                2. Confidence level (0-1)
                3. Expected value calculation
                4. Timing considerations (urgency: low/medium/high)
                5. Risk factors
                6. Recommended position size as % of max capital
                
                Return ONLY valid JSON:
                {{
                    "p_star": 0.XX,
                    "confidence": 0.XX,
                    "rationale": "Detailed analysis including WHY this is mispriced and profit potential...",
                    "supporting_sources": ["reasoning points"],
                    "risk_factors": ["key risks"],
                    "urgency": "low|medium|high",
                    "recommended_size_pct": 0.XX
                }}
                """
                
                # Get enhanced analysis
                response = gemini.model.generate_content(enhanced_prompt)
                text = response.text.replace("```json", "").replace("```", "").strip()
                analysis = json.loads(text)
                
                # Calculate expected value and profit metrics
                p_star = analysis["p_star"]
                market_price = max(market_obj.current_price, 0.01)  # Avoid division by zero
                edge = p_star - market_price
                
                # Expected value per $1 bet (handle edge cases)
                if market_price > 0.01:
                    ev_per_dollar = (p_star * (1/market_price - 1)) - ((1-p_star) * 1)
                else:
                    ev_per_dollar = 0
                
                # Position sizing (Kelly Criterion simplified)
                if market_price > 0.01 and edge > 0:
                    kelly_fraction = edge / (1/market_price - 1)
                    kelly_fraction = max(0, min(kelly_fraction, 0.25))  # Cap at 25%
                else:
                    kelly_fraction = 0.05  # Default 5% if can't calculate
                
                # Recommended investment
                recommended_size = analysis.get("recommended_size_pct", kelly_fraction)
                recommended_usd = recommended_size * config.max_position_size_usd
                
                # Potential profit - Track ALL opportunities with positive edge
                if edge > 0.01:  # Only track opportunities with >1% edge
                    potential_profit = recommended_usd * ev_per_dollar
                    
                    action = "BUY YES" if p_star > market_price else "SELL/SHORT" if p_star < market_price else "PASS"
                    
                    opportunities.append({
                        "ticker": m.ticker,
                        "question": m.title,
                        "market_price": market_price,
                        "fair_value": p_star,
                        "edge": edge,
                        "ev_per_dollar": ev_per_dollar,
                        "confidence": analysis["confidence"],
                        "action": action,
                        "recommended_usd": recommended_usd,
                        "potential_profit": potential_profit,
                        "urgency": analysis.get("urgency", "medium"),
                        "rationale": analysis["rationale"],
                        "risks": analysis.get("risk_factors", [])
                    })
            except Exception as e:
                print(f"  ⚠️  Skipping {m.ticker}: {e}")
        
        # Sort by potential profit (descending)
        opportunities.sort(key=lambda x: x["potential_profit"], reverse=True)
        
        # Print detailed report
        print("\n" + "="*120)
        print("🎯 TOP INVESTMENT OPPORTUNITIES (Ranked by Potential Profit)")
        print("="*120)
        
        for i, opp in enumerate(opportunities[:10], 1):  # Top 10
            print(f"\n#{i} | {opp['action']} | Urgency: {opp['urgency'].upper()}")
            print(f"{'─'*120}")
            print(f"📌 Market: {opp['question'][:100]}")
            print(f"💰 Investment: ${opp['recommended_usd']:.2f} (at {opp['market_price']*100:.1f}% price)")
            print(f"📈 Fair Value: {opp['fair_value']*100:.1f}% | Edge: {opp['edge']*100:+.1f}%")
            print(f"💵 Expected Profit: ${opp['potential_profit']:.2f} (EV per $1: ${opp['ev_per_dollar']:.2f})")
            print(f"🎲 Confidence: {opp['confidence']*100:.0f}%")
            print(f"\n📝 Analysis: {opp['rationale'][:200]}...")
            print(f"⚠️  Risks: {', '.join(opp['risks'][:3])}")
            
        print("\n" + "="*120)
        print(f"💡 Total Opportunities Found: {len(opportunities)}")
        print(f"💰 Total Recommended Investment: ${sum(o['recommended_usd'] for o in opportunities[:10]):.2f}")
        print(f"📊 Total Expected Profit: ${sum(o['potential_profit'] for o in opportunities[:10]):.2f}")
        print("="*120 + "\n")
            
    except Exception as e:
        print(f"Scan failed: {e}")

def main():
    """Main CLI entry point"""
    parser = argparse.ArgumentParser(description="Prediction Market Watcher")
    subparsers = parser.add_subparsers(dest="command", help="Available commands")
    
    # API server command
    api_parser = subparsers.add_parser("api", help="Run API server")
    api_parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
    api_parser.add_argument("--port", type=int, default=8787, help="Port to bind to")
    
    scan_parser = subparsers.add_parser("scan", help="Scan markets for opportunities")
    scan_parser.add_argument("--limit", type=int, default=10, help="Number of markets to scan")
    
    args = parser.parse_args()
    
    if args.command == "api":
        run_api(host=args.host, port=args.port)
    elif args.command == "scan":
        import asyncio
        asyncio.run(scan_markets(args.limit))
    else:
        parser.print_help()


if __name__ == "__main__":
    main()