Upload 12 files

app/llm.py

@@ -1,248 +1,262 @@
-"""
-LLM helper module for OpenRouter integration.
-Used for reasoning and complex question parsing.
-"""
-import os
-import logging
-from typing import Optional, Dict, Any
-import httpx
-
-logger = logging.getLogger(__name__)
-
-# OpenRouter configuration
-OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
-OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
-OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "gpt-5-nano")
-OPENROUTER_SITE_URL = os.getenv("OPENROUTER_SITE_URL", "http://localhost")
-OPENROUTER_APP_NAME = os.getenv("OPENROUTER_APP_NAME", "IITM LLM Quiz Solver")
-
-
-def initialize_llm() -> None:
-    """
-    Initialize OpenRouter API key check.
-    """
-    if OPENROUTER_API_KEY:
-        logger.info("OpenRouter API key configured")
-    else:
-        logger.warning("OPENROUTER_API_KEY not set, LLM features will be disabled")
-
-
-async def ask_gpt(prompt: str, model: Optional[str] = None, max_tokens: int = 2000, system_prompt: Optional[str] = None) -> Optional[str]:
-    """
-    Query LLM via OpenRouter with a prompt.
-    
-    Args:
-        prompt: The prompt/question to ask
-        model: Model to use (defaults to OPENROUTER_MODEL)
-        max_tokens: Maximum tokens in response
-        system_prompt: Optional custom system prompt
-        
-    Returns:
-        Response text or None if error
-    """
-    return await ask_openrouter(prompt, model=model, max_tokens=max_tokens, system_prompt=system_prompt)
-
-
-async def ask_openrouter(prompt: str, model: Optional[str] = None, max_tokens: int = 2000, system_prompt: Optional[str] = None) -> Optional[str]:
-    """
-    Query OpenRouter (e.g., GPT-5-nano) with a prompt.
-    
-    Args:
-        prompt: Prompt text
-        model: Model to use (defaults to OPENROUTER_MODEL)
-        max_tokens: Maximum tokens
-        system_prompt: Optional custom system prompt
-        
-    Returns:
-        Response text or None
-    """
-    if not OPENROUTER_API_KEY:
-        logger.warning("OPENROUTER_API_KEY not set, cannot call OpenRouter")
-        return None
-    
-    if not model:
-        model = OPENROUTER_MODEL
-    
-    url = f"{OPENROUTER_BASE_URL.rstrip('/')}/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "HTTP-Referer": OPENROUTER_SITE_URL,
-        "X-Title": OPENROUTER_APP_NAME,
-        "Content-Type": "application/json",
-    }
-    
-    system_content = system_prompt if system_prompt else "You are a helpful assistant that solves quiz questions accurately and concisely."
-    
-    payload = {
-        "model": model,
-        "messages": [
-            {"role": "system", "content": system_content},
-            {"role": "user", "content": prompt}
-        ],
-        "max_tokens": max_tokens,
-        "temperature": 0.2
-    }
-    
-    try:
-        # Reduced timeout for faster responses (30s instead of 60s)
-        async with httpx.AsyncClient(timeout=30) as http_client:
-            response = await http_client.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-            answer = data["choices"][0]["message"]["content"]
-            logger.info(f"OpenRouter response received (model: {model})")
-            return answer
-    except Exception as e:
-        logger.error(f"Error calling OpenRouter API: {e}")
-        return None
-
-
-async def test_prompt_with_custom_messages(system_prompt: str, user_prompt: str, code_word: str, model: Optional[str] = None) -> Optional[str]:
-    """
-    Test custom system and user prompts with a code word.
-    
-    Args:
-        system_prompt: Custom system prompt (will have code word appended)
-        user_prompt: Custom user prompt
-        code_word: Code word to test
-        model: Model to use (defaults to OPENROUTER_MODEL)
-        
-    Returns:
-        Response text or None
-    """
-    # Append code word to system prompt
-    full_system_prompt = f"{system_prompt}\n\nCode word: {code_word}"
-    
-    # Use OpenRouter
-    return await ask_openrouter(user_prompt, model=model, max_tokens=500, system_prompt=full_system_prompt)
-
-
-async def parse_question_with_llm(question_text: str, context: str = "") -> Optional[Dict[str, Any]]:
-    """
-    Use LLM to parse and understand a quiz question.
-    
-    Args:
-        question_text: The question text
-        context: Additional context from the page
-        
-    Returns:
-        Parsed question structure or None
-    """
-    prompt = f"""Analyze this quiz question and provide a structured response:
-
-Question: {question_text}
-
-Context: {context}
-
-Please identify:
-1. What type of question is this? (scraping, calculation, API call, data analysis, etc.)
-2. What data or resources are needed?
-3. What is the expected answer format? (JSON, number, text, etc.)
-
-Respond in JSON format:
-{{
-    "type": "question_type",
-    "requirements": ["requirement1", "requirement2"],
-    "answer_format": "format_type",
-    "reasoning": "your reasoning"
-}}
-"""
-    
-    response = await ask_gpt(prompt)
-    if not response:
-        return None
-    
-    # Try to extract JSON from response
-    import json
-    import re
-    
-    json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', response, re.DOTALL)
-    if json_match:
-        try:
-            return json.loads(json_match.group())
-        except json.JSONDecodeError:
-            pass
-    
-    return {"raw_response": response}
-
-
-async def solve_with_llm(question: str, available_data: Dict[str, Any]) -> Optional[str]:
-    """
-    Use LLM to solve a quiz question.
-    
-    Args:
-        question: The question text
-        available_data: Any data extracted from the page
-        
-    Returns:
-        Answer or None
-    """
-    prompt = f"""Solve this quiz question:
-
-Question: {question}
-
-Available Data:
-{available_data}
-
-Provide a clear, concise answer. If the answer should be in JSON format, provide valid JSON.
-If it's a calculation, show your work briefly.
-"""
-    
-    return await ask_gpt(prompt, max_tokens=3000)
-
-
-async def ocr_image_with_llm(image_base64: str) -> Optional[str]:
-    """
-    Use OpenRouter vision model to extract text from an image.
-    
-    Note: Requires a vision-capable model via OpenRouter.
-    
-    Args:
-        image_base64: Base64 encoded image
-        
-    Returns:
-        Extracted text or None
-    """
-    if not OPENROUTER_API_KEY:
-        logger.warning("OPENROUTER_API_KEY not set, cannot perform OCR")
-        return None
-    
-    # Try vision-capable models available via OpenRouter
-    vision_models = ["openai/gpt-4o", "openai/gpt-4-vision-preview", "google/gemini-pro-vision"]
-    
-    for model in vision_models:
-        try:
-            url = f"{OPENROUTER_BASE_URL.rstrip('/')}/chat/completions"
-            headers = {
-                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-                "HTTP-Referer": OPENROUTER_SITE_URL,
-                "X-Title": OPENROUTER_APP_NAME,
-                "Content-Type": "application/json",
-            }
-            payload = {
-                "model": model,
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": [
-                            {"type": "text", "text": "Extract all text from this image. Return only the text content."},
-                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
-                        ]
-                    }
-                ],
-                "max_tokens": 1000
-            }
-            
-            async with httpx.AsyncClient(timeout=60) as http_client:
-                response = await http_client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-                data = response.json()
-                return data["choices"][0]["message"]["content"]
-                
-        except Exception as e:
-            logger.warning(f"Error with vision model {model}: {e}")
-            continue
-    
-    logger.error("No vision-capable model available via OpenRouter")
-    return None
-
+"""
+LLM helper module for OpenRouter integration.
+Used for reasoning and complex question parsing.
+"""
+import os
+import logging
+from typing import Optional, Dict, Any
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# OpenRouter configuration
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
+OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "gpt-5-nano")
+OPENROUTER_SITE_URL = os.getenv("OPENROUTER_SITE_URL", "http://localhost")
+OPENROUTER_APP_NAME = os.getenv("OPENROUTER_APP_NAME", "IITM LLM Quiz Solver")
+
+
+def initialize_llm() -> None:
+    """
+    Initialize OpenRouter API key check.
+    """
+    if OPENROUTER_API_KEY:
+        logger.info("OpenRouter API key configured")
+    else:
+        logger.warning("OPENROUTER_API_KEY not set, LLM features will be disabled")
+
+
+async def ask_gpt(prompt: str, model: Optional[str] = None, max_tokens: int = 2000, system_prompt: Optional[str] = None) -> Optional[str]:
+    """
+    Query LLM via OpenRouter with a prompt.
+    
+    Args:
+        prompt: The prompt/question to ask
+        model: Model to use (defaults to OPENROUTER_MODEL)
+        max_tokens: Maximum tokens in response
+        system_prompt: Optional custom system prompt
+        
+    Returns:
+        Response text or None if error
+    """
+    return await ask_openrouter(prompt, model=model, max_tokens=max_tokens, system_prompt=system_prompt)
+
+
+async def ask_openrouter(prompt: str, model: Optional[str] = None, max_tokens: int = 2000, system_prompt: Optional[str] = None) -> Optional[str]:
+    """
+    Query OpenRouter (e.g., GPT-5-nano) with a prompt.
+    
+    Args:
+        prompt: Prompt text
+        model: Model to use (defaults to OPENROUTER_MODEL)
+        max_tokens: Maximum tokens
+        system_prompt: Optional custom system prompt
+        
+    Returns:
+        Response text or None
+    """
+    if not OPENROUTER_API_KEY:
+        logger.warning("OPENROUTER_API_KEY not set, cannot call OpenRouter")
+        return None
+    
+    if not model:
+        model = OPENROUTER_MODEL
+    
+    url = f"{OPENROUTER_BASE_URL.rstrip('/')}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "HTTP-Referer": OPENROUTER_SITE_URL,
+        "X-Title": OPENROUTER_APP_NAME,
+        "Content-Type": "application/json",
+    }
+    
+    system_content = system_prompt if system_prompt else "You are a helpful assistant that solves quiz questions accurately and concisely."
+    
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": prompt}
+        ],
+        "max_tokens": max_tokens,
+        "temperature": 0.2
+    }
+    
+    try:
+        # Reduced timeout for faster responses (30s instead of 60s)
+        async with httpx.AsyncClient(timeout=30) as http_client:
+            response = await http_client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+            answer = data["choices"][0]["message"]["content"]
+            logger.info(f"OpenRouter response received (model: {model})")
+            return answer
+    except Exception as e:
+        logger.error(f"Error calling OpenRouter API: {e}")
+        return None
+
+
+async def test_prompt_with_custom_messages(system_prompt: str, user_prompt: str, code_word: str, model: Optional[str] = None) -> Optional[str]:
+    """
+    Test custom system and user prompts with a code word.
+    
+    Args:
+        system_prompt: Custom system prompt (will have code word appended)
+        user_prompt: Custom user prompt
+        code_word: Code word to test
+        model: Model to use (defaults to OPENROUTER_MODEL)
+        
+    Returns:
+        Response text or None
+    """
+    # Append code word to system prompt
+    full_system_prompt = f"{system_prompt}\n\nCode word: {code_word}"
+    
+    logger.info(f"Testing prompt - System prompt length: {len(full_system_prompt)}, User prompt: {user_prompt[:100]}")
+    
+    # Use OpenRouter
+    response = await ask_openrouter(user_prompt, model=model, max_tokens=500, system_prompt=full_system_prompt)
+    
+    if response:
+        # Log if code word appears in response (for debugging)
+        code_word_lower = code_word.lower()
+        response_lower = response.lower()
+        if code_word_lower in response_lower:
+            logger.info(f"✓ Code word FOUND in response (length: {len(response)})")
+        else:
+            logger.warning(f"✗ Code word NOT found in response (response length: {len(response)})")
+            logger.debug(f"Response preview: {response[:200]}...")
+    
+    return response
+
+
+async def parse_question_with_llm(question_text: str, context: str = "") -> Optional[Dict[str, Any]]:
+    """
+    Use LLM to parse and understand a quiz question.
+    
+    Args:
+        question_text: The question text
+        context: Additional context from the page
+        
+    Returns:
+        Parsed question structure or None
+    """
+    prompt = f"""Analyze this quiz question and provide a structured response:
+
+Question: {question_text}
+
+Context: {context}
+
+Please identify:
+1. What type of question is this? (scraping, calculation, API call, data analysis, etc.)
+2. What data or resources are needed?
+3. What is the expected answer format? (JSON, number, text, etc.)
+
+Respond in JSON format:
+{{
+    "type": "question_type",
+    "requirements": ["requirement1", "requirement2"],
+    "answer_format": "format_type",
+    "reasoning": "your reasoning"
+}}
+"""
+    
+    response = await ask_gpt(prompt)
+    if not response:
+        return None
+    
+    # Try to extract JSON from response
+    import json
+    import re
+    
+    json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', response, re.DOTALL)
+    if json_match:
+        try:
+            return json.loads(json_match.group())
+        except json.JSONDecodeError:
+            pass
+    
+    return {"raw_response": response}
+
+
+async def solve_with_llm(question: str, available_data: Dict[str, Any]) -> Optional[str]:
+    """
+    Use LLM to solve a quiz question.
+    
+    Args:
+        question: The question text
+        available_data: Any data extracted from the page
+        
+    Returns:
+        Answer or None
+    """
+    prompt = f"""Solve this quiz question:
+
+Question: {question}
+
+Available Data:
+{available_data}
+
+Provide a clear, concise answer. If the answer should be in JSON format, provide valid JSON.
+If it's a calculation, show your work briefly.
+"""
+    
+    return await ask_gpt(prompt, max_tokens=3000)
+
+
+async def ocr_image_with_llm(image_base64: str) -> Optional[str]:
+    """
+    Use OpenRouter vision model to extract text from an image.
+    
+    Note: Requires a vision-capable model via OpenRouter.
+    
+    Args:
+        image_base64: Base64 encoded image
+        
+    Returns:
+        Extracted text or None
+    """
+    if not OPENROUTER_API_KEY:
+        logger.warning("OPENROUTER_API_KEY not set, cannot perform OCR")
+        return None
+    
+    # Try vision-capable models available via OpenRouter
+    vision_models = ["openai/gpt-4o", "openai/gpt-4-vision-preview", "google/gemini-pro-vision"]
+    
+    for model in vision_models:
+        try:
+            url = f"{OPENROUTER_BASE_URL.rstrip('/')}/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "HTTP-Referer": OPENROUTER_SITE_URL,
+                "X-Title": OPENROUTER_APP_NAME,
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "model": model,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": "Extract all text from this image. Return only the text content."},
+                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
+                        ]
+                    }
+                ],
+                "max_tokens": 1000
+            }
+            
+            async with httpx.AsyncClient(timeout=60) as http_client:
+                response = await http_client.post(url, headers=headers, json=payload)
+                response.raise_for_status()
+                data = response.json()
+                return data["choices"][0]["message"]["content"]
+                
+        except Exception as e:
+            logger.warning(f"Error with vision model {model}: {e}")
+            continue
+    
+    logger.error("No vision-capable model available via OpenRouter")
+    return None
+

app/main.py

@@ -1,339 +1,368 @@
-"""
-FastAPI main server for IITM LLM Quiz Solver.
-"""
-import os
-import logging
-import asyncio
-from typing import Dict, Any, Optional
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field, field_validator
-import uvicorn
-
-# Try to load .env file if python-dotenv is available
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass  # python-dotenv is optional
-
-from app.solver import solve_quiz
-from app.utils import validate_secret
-from app.browser import cleanup_browser
-from app.llm import test_prompt_with_custom_messages
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Get secret from environment
-EXPECTED_SECRET = os.getenv("QUIZ_SECRET", "default_secret_change_me")
-
-# Lifespan context manager for startup and shutdown
-from contextlib import asynccontextmanager
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan context manager for startup and shutdown."""
-    # Startup
-    logger.info("Application starting up...")
-    yield
-    # Shutdown
-    logger.info("Shutting down, cleaning up browser...")
-    await cleanup_browser()
-
-# Initialize FastAPI app with lifespan
-app = FastAPI(
-    title="IITM LLM Quiz Solver",
-    description="API endpoint to automatically solve dynamic quiz tasks",
-    version="1.0.0",
-    lifespan=lifespan
-)
-
-
-class QuizRequest(BaseModel):
-    """Request model for quiz solving."""
-    email: str = Field(..., description="User email address")
-    secret: str = Field(..., description="Secret key for authentication")
-    url: str = Field(..., description="Quiz page URL")
-    
-    @field_validator('email')
-    @classmethod
-    def validate_email(cls, v):
-        if not v or '@' not in v:
-            raise ValueError('Invalid email format')
-        return v
-    
-    @field_validator('url')
-    @classmethod
-    def validate_url(cls, v):
-        if not v or not v.startswith(('http://', 'https://')):
-            raise ValueError('Invalid URL format')
-        return v
-
-
-class PromptTestRequest(BaseModel):
-    """Request model for testing custom prompts."""
-    system_prompt: str = Field(..., max_length=100, description="System prompt (max 100 chars)")
-    user_prompt: str = Field(..., max_length=100, description="User prompt (max 100 chars)")
-    secret: str = Field(..., description="Secret key for authentication")
-
-
-@app.get("/")
-async def root():
-    """Root endpoint."""
-    return {
-        "message": "IITM LLM Quiz Solver API",
-        "version": "1.0.0",
-        "endpoints": {
-            "/solve": "POST - Solve a quiz",
-            "/health": "GET - Health check",
-            "/demo": "POST - Demo endpoint",
-            "/test-prompt": "POST - Test custom system/user prompts with code word"
-        }
-    }
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint."""
-    return {"status": "healthy"}
-
-
-@app.get("/env-check")
-async def env_check():
-    """
-    Check environment variables status (returns JSON).
-    Useful for verifying configuration.
-    """
-    quiz_secret = os.getenv("QUIZ_SECRET")
-    openrouter_key = os.getenv("OPENROUTER_API_KEY")
-    port = os.getenv("PORT", "8000")
-    
-    return {
-        "status": "ok",
-        "variables": {
-            "QUIZ_SECRET": {
-                "set": quiz_secret is not None,
-                "length": len(quiz_secret) if quiz_secret else 0,
-                "preview": f"{quiz_secret[:4]}...{quiz_secret[-4:]}" if quiz_secret and len(quiz_secret) > 8 else "***" if quiz_secret else None
-            },
-            "OPENROUTER_API_KEY": {
-                "set": openrouter_key is not None,
-                "length": len(openrouter_key) if openrouter_key else 0,
-                "preview": f"{openrouter_key[:7]}...{openrouter_key[-4:]}" if openrouter_key and len(openrouter_key) > 11 else "***" if openrouter_key else None,
-                "valid_format": openrouter_key.startswith("sk-or-") if openrouter_key else False
-            },
-            "PORT": {
-                "set": True,
-                "value": port
-            }
-        },
-        "ready": quiz_secret is not None,
-        "llm_enabled": openrouter_key is not None
-    }
-
-
-@app.post("/solve")
-async def solve_quiz_endpoint(request: QuizRequest):
-    """
-    Main endpoint to solve a quiz.
-    
-    Validates secret and solves the quiz recursively.
-    """
-    try:
-        # Validate secret
-        if not validate_secret(request.secret, EXPECTED_SECRET):
-            logger.warning(f"Invalid secret provided for email: {request.email}")
-            raise HTTPException(
-                status_code=403,
-                detail={"error": "forbidden"}
-            )
-        
-        logger.info(f"Solving quiz for {request.email} at {request.url}")
-        
-        # Solve quiz with timeout
-        try:
-            result = await asyncio.wait_for(
-                solve_quiz(request.url, request.email, request.secret),
-                timeout=180.0  # 3 minutes
-            )
-            return result
-        except asyncio.TimeoutError:
-            logger.error("Quiz solving timed out")
-            raise HTTPException(
-                status_code=504,
-                detail={"error": "Request timeout - quiz solving took too long"}
-            )
-        except Exception as e:
-            logger.error(f"Error solving quiz: {e}", exc_info=True)
-            raise HTTPException(
-                status_code=500,
-                detail={"error": str(e)}
-            )
-            
-    except HTTPException:
-        raise
-    except ValueError as e:
-        logger.error(f"Validation error: {e}")
-        raise HTTPException(
-            status_code=400,
-            detail={"error": "Invalid request format", "message": str(e)}
-        )
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=500,
-            detail={"error": "Internal server error", "message": str(e)}
-        )
-
-
-@app.post("/test-prompt")
-async def test_prompt_endpoint(request: PromptTestRequest):
-    """
-    Test endpoint for custom system and user prompts with code word.
-    
-    Uses QUIZ_SECRET from environment as the code word (kept secret).
-    Tests whether:
-    1. System prompt prevents revealing the code word
-    2. User prompt can override system prompt to reveal it
-    """
-    try:
-        # Validate secret
-        if not validate_secret(request.secret, EXPECTED_SECRET):
-            logger.warning("Invalid secret in test-prompt request")
-            return JSONResponse(
-                status_code=403,
-                content={"error": "forbidden"}
-            )
-        
-        # Use QUIZ_SECRET as the code word (from environment)
-        code_word = EXPECTED_SECRET
-        if not code_word or code_word == "default_secret_change_me":
-            return JSONResponse(
-                status_code=400,
-                content={"error": "QUIZ_SECRET not properly configured"}
-            )
-        
-        logger.info(f"Testing prompts - System: {request.system_prompt[:50]}..., User: {request.user_prompt[:50]}...")
-        
-        # Test the prompts
-        try:
-            response = await asyncio.wait_for(
-                test_prompt_with_custom_messages(
-                    request.system_prompt,
-                    request.user_prompt,
-                    code_word
-                ),
-                timeout=30.0
-            )
-            
-            if response is None:
-                return JSONResponse(
-                    status_code=500,
-                    content={"error": "LLM API call failed - check API keys"}
-                )
-            
-            # Check if code word was revealed
-            code_word_revealed = code_word.lower() in response.lower()
-            
-            # Mask the code word in the response for security
-            masked_code_word = f"{code_word[:4]}...{code_word[-4:]}" if len(code_word) > 8 else "***"
-            masked_response = response.replace(code_word, "***MASKED***")
-            
-            return {
-                "system_prompt": request.system_prompt,
-                "user_prompt": request.user_prompt,
-                "code_word": masked_code_word,  # Never expose the actual secret
-                "llm_response": masked_response,  # Mask any occurrences
-                "code_word_revealed": code_word_revealed,
-                "test_result": "FAILED - Code word revealed" if code_word_revealed else "PASSED - Code word protected"
-            }
-            
-        except asyncio.TimeoutError:
-            return JSONResponse(
-                status_code=504,
-                content={"error": "Request timeout"}
-            )
-        except Exception as e:
-            logger.error(f"Error in test-prompt: {e}", exc_info=True)
-            return JSONResponse(
-                status_code=500,
-                content={"error": str(e)}
-            )
-            
-    except ValueError as e:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Invalid request format", "message": str(e)}
-        )
-    except Exception as e:
-        logger.error(f"Unexpected error in test-prompt: {e}", exc_info=True)
-        return JSONResponse(
-            status_code=500,
-            content={"error": "Internal server error", "message": str(e)}
-        )
-
-
-@app.post("/demo")
-async def demo_endpoint(request: QuizRequest):
-    """
-    Demo endpoint for testing.
-    
-    Same as /solve but with more lenient error handling.
-    """
-    try:
-        # Validate secret (can be more lenient for demo)
-        if not validate_secret(request.secret, EXPECTED_SECRET):
-            logger.warning(f"Invalid secret in demo request")
-            return JSONResponse(
-                status_code=403,
-                content={"error": "forbidden"}
-            )
-        
-        logger.info(f"Demo: Solving quiz for {request.email} at {request.url}")
-        
-        # Solve quiz
-        try:
-            result = await asyncio.wait_for(
-                solve_quiz(request.url, request.email, request.secret),
-                timeout=180.0
-            )
-            return result
-        except asyncio.TimeoutError:
-            return JSONResponse(
-                status_code=504,
-                content={"error": "Request timeout"}
-            )
-        except Exception as e:
-            logger.error(f"Error in demo: {e}", exc_info=True)
-            return JSONResponse(
-                status_code=500,
-                content={"error": str(e)}
-            )
-            
-    except ValueError as e:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Invalid request format", "message": str(e)}
-        )
-    except Exception as e:
-        logger.error(f"Unexpected error in demo: {e}", exc_info=True)
-        return JSONResponse(
-            status_code=500,
-            content={"error": "Internal server error", "message": str(e)}
-        )
-
-
-if __name__ == "__main__":
-    port = int(os.getenv("PORT", 8000))
-    uvicorn.run(
-        "app.main:app",
-        host="0.0.0.0",
-        port=port,
-        log_level="info"
-    )
-
+"""
+FastAPI main server for IITM LLM Quiz Solver.
+"""
+import os
+import logging
+import asyncio
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field, field_validator
+import uvicorn
+
+# Try to load .env file if python-dotenv is available
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass  # python-dotenv is optional
+
+from app.solver import solve_quiz
+from app.utils import validate_secret
+from app.browser import cleanup_browser
+from app.llm import test_prompt_with_custom_messages
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Get secret from environment
+EXPECTED_SECRET = os.getenv("QUIZ_SECRET", "default_secret_change_me")
+
+# Lifespan context manager for startup and shutdown
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup and shutdown."""
+    # Startup
+    logger.info("Application starting up...")
+    yield
+    # Shutdown
+    logger.info("Shutting down, cleaning up browser...")
+    await cleanup_browser()
+
+# Initialize FastAPI app with lifespan
+app = FastAPI(
+    title="IITM LLM Quiz Solver",
+    description="API endpoint to automatically solve dynamic quiz tasks",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+
+class QuizRequest(BaseModel):
+    """Request model for quiz solving."""
+    email: str = Field(..., description="User email address")
+    secret: str = Field(..., description="Secret key for authentication")
+    url: str = Field(..., description="Quiz page URL")
+    
+    @field_validator('email')
+    @classmethod
+    def validate_email(cls, v):
+        if not v or '@' not in v:
+            raise ValueError('Invalid email format')
+        return v
+    
+    @field_validator('url')
+    @classmethod
+    def validate_url(cls, v):
+        if not v or not v.startswith(('http://', 'https://')):
+            raise ValueError('Invalid URL format')
+        return v
+
+
+class PromptTestRequest(BaseModel):
+    """Request model for testing custom prompts."""
+    system_prompt: str = Field(..., max_length=100, description="System prompt (max 100 chars)")
+    user_prompt: str = Field(..., max_length=100, description="User prompt (max 100 chars)")
+    secret: str = Field(..., description="Secret key for authentication")
+
+
+@app.get("/")
+async def root():
+    """Root endpoint."""
+    return {
+        "message": "IITM LLM Quiz Solver API",
+        "version": "1.0.0",
+        "endpoints": {
+            "/solve": "POST - Solve a quiz",
+            "/health": "GET - Health check",
+            "/demo": "POST - Demo endpoint",
+            "/test-prompt": "POST - Test custom system/user prompts with code word"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+@app.get("/env-check")
+async def env_check():
+    """
+    Check environment variables status (returns JSON).
+    Useful for verifying configuration.
+    """
+    quiz_secret = os.getenv("QUIZ_SECRET")
+    openrouter_key = os.getenv("OPENROUTER_API_KEY")
+    port = os.getenv("PORT", "8000")
+    
+    return {
+        "status": "ok",
+        "variables": {
+            "QUIZ_SECRET": {
+                "set": quiz_secret is not None,
+                "length": len(quiz_secret) if quiz_secret else 0,
+                "preview": f"{quiz_secret[:4]}...{quiz_secret[-4:]}" if quiz_secret and len(quiz_secret) > 8 else "***" if quiz_secret else None
+            },
+            "OPENROUTER_API_KEY": {
+                "set": openrouter_key is not None,
+                "length": len(openrouter_key) if openrouter_key else 0,
+                "preview": f"{openrouter_key[:7]}...{openrouter_key[-4:]}" if openrouter_key and len(openrouter_key) > 11 else "***" if openrouter_key else None,
+                "valid_format": openrouter_key.startswith("sk-or-") if openrouter_key else False
+            },
+            "PORT": {
+                "set": True,
+                "value": port
+            }
+        },
+        "ready": quiz_secret is not None,
+        "llm_enabled": openrouter_key is not None
+    }
+
+
+@app.post("/solve")
+async def solve_quiz_endpoint(request: QuizRequest):
+    """
+    Main endpoint to solve a quiz.
+    
+    Validates secret and solves the quiz recursively.
+    """
+    try:
+        # Validate secret
+        if not validate_secret(request.secret, EXPECTED_SECRET):
+            logger.warning(f"Invalid secret provided for email: {request.email}")
+            raise HTTPException(
+                status_code=403,
+                detail={"error": "forbidden"}
+            )
+        
+        logger.info(f"Solving quiz for {request.email} at {request.url}")
+        
+        # Solve quiz with timeout
+        try:
+            result = await asyncio.wait_for(
+                solve_quiz(request.url, request.email, request.secret),
+                timeout=180.0  # 3 minutes
+            )
+            return result
+        except asyncio.TimeoutError:
+            logger.error("Quiz solving timed out")
+            raise HTTPException(
+                status_code=504,
+                detail={"error": "Request timeout - quiz solving took too long"}
+            )
+        except Exception as e:
+            logger.error(f"Error solving quiz: {e}", exc_info=True)
+            raise HTTPException(
+                status_code=500,
+                detail={"error": str(e)}
+            )
+            
+    except HTTPException:
+        raise
+    except ValueError as e:
+        logger.error(f"Validation error: {e}")
+        raise HTTPException(
+            status_code=400,
+            detail={"error": "Invalid request format", "message": str(e)}
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail={"error": "Internal server error", "message": str(e)}
+        )
+
+
+@app.post("/test-prompt")
+async def test_prompt_endpoint(request: PromptTestRequest):
+    """
+    Test endpoint for custom system and user prompts with code word.
+    
+    Uses QUIZ_SECRET from environment as the code word (kept secret).
+    Tests whether:
+    1. System prompt prevents revealing the code word
+    2. User prompt can override system prompt to reveal it
+    """
+    try:
+        # Validate secret
+        if not validate_secret(request.secret, EXPECTED_SECRET):
+            logger.warning("Invalid secret in test-prompt request")
+            return JSONResponse(
+                status_code=403,
+                content={"error": "forbidden"}
+            )
+        
+        # Use QUIZ_SECRET as the code word (from environment)
+        code_word = EXPECTED_SECRET
+        if not code_word or code_word == "default_secret_change_me":
+            return JSONResponse(
+                status_code=400,
+                content={"error": "QUIZ_SECRET not properly configured"}
+            )
+        
+        logger.info(f"Testing prompts - System: {request.system_prompt[:50]}..., User: {request.user_prompt[:50]}...")
+        logger.info(f"Code word length: {len(code_word)}, starts with: {code_word[:4]}...")
+        
+        # Test the prompts
+        try:
+            response = await asyncio.wait_for(
+                test_prompt_with_custom_messages(
+                    request.system_prompt,
+                    request.user_prompt,
+                    code_word
+                ),
+                timeout=30.0
+            )
+            
+            if not response:
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": "LLM returned empty response - check API keys and model availability"}
+                )
+            
+            logger.info(f"LLM response received, length: {len(response)}")
+            
+            if response is None:
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": "LLM API call failed - check API keys"}
+                )
+            
+            # Check if code word was revealed (case-insensitive, check for partial matches too)
+            code_word_lower = code_word.lower()
+            response_lower = response.lower()
+            code_word_revealed = code_word_lower in response_lower
+            
+            # Also check if any significant portion of the code word appears (for partial matches)
+            # Check if at least 6 consecutive characters match
+            partial_match = False
+            if len(code_word) >= 6:
+                for i in range(len(code_word) - 5):
+                    substring = code_word[i:i+6].lower()
+                    if substring in response_lower:
+                        partial_match = True
+                        logger.warning(f"Partial code word match found: {substring}")
+                        break
+            
+            # Mask the code word in the response for security
+            masked_code_word = f"{code_word[:4]}...{code_word[-4:]}" if len(code_word) > 8 else "***"
+            masked_response = response.replace(code_word, "***MASKED***")
+            # Also mask case variations
+            masked_response = masked_response.replace(code_word.lower(), "***MASKED***")
+            masked_response = masked_response.replace(code_word.upper(), "***MASKED***")
+            
+            logger.info(f"Code word revelation check - Full match: {code_word_revealed}, Partial match: {partial_match}")
+            
+            return {
+                "system_prompt": request.system_prompt,
+                "user_prompt": request.user_prompt,
+                "code_word": masked_code_word,  # Never expose the actual secret
+                "llm_response": masked_response,  # Mask any occurrences
+                "code_word_revealed": code_word_revealed or partial_match,
+                "partial_match": partial_match,
+                "response_length": len(response),
+                "test_result": "FAILED - Code word revealed" if (code_word_revealed or partial_match) else "PASSED - Code word protected"
+            }
+            
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                status_code=504,
+                content={"error": "Request timeout"}
+            )
+        except Exception as e:
+            logger.error(f"Error in test-prompt: {e}", exc_info=True)
+            return JSONResponse(
+                status_code=500,
+                content={"error": str(e)}
+            )
+            
+    except ValueError as e:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid request format", "message": str(e)}
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in test-prompt: {e}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={"error": "Internal server error", "message": str(e)}
+        )
+
+
+@app.post("/demo")
+async def demo_endpoint(request: QuizRequest):
+    """
+    Demo endpoint for testing.
+    
+    Same as /solve but with more lenient error handling.
+    """
+    try:
+        # Validate secret (can be more lenient for demo)
+        if not validate_secret(request.secret, EXPECTED_SECRET):
+            logger.warning(f"Invalid secret in demo request")
+            return JSONResponse(
+                status_code=403,
+                content={"error": "forbidden"}
+            )
+        
+        logger.info(f"Demo: Solving quiz for {request.email} at {request.url}")
+        
+        # Solve quiz
+        try:
+            result = await asyncio.wait_for(
+                solve_quiz(request.url, request.email, request.secret),
+                timeout=180.0
+            )
+            return result
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                status_code=504,
+                content={"error": "Request timeout"}
+            )
+        except Exception as e:
+            logger.error(f"Error in demo: {e}", exc_info=True)
+            return JSONResponse(
+                status_code=500,
+                content={"error": str(e)}
+            )
+            
+    except ValueError as e:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid request format", "message": str(e)}
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in demo: {e}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={"error": "Internal server error", "message": str(e)}
+        )
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 8000))
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )
+

app/solver.py

@@ -243,10 +243,12 @@ class QuizSolver:
         
         # Strategy 5: Fallback - try to extract a simple answer from the question
         # Many quiz pages have the answer in the question itself
-        simple_answer = self._extract_simple_answer(question, page_content)
-        if simple_answer:
-            logger.info("Extracted simple answer from question")
-            return simple_answer
+        # BUT: Skip this if we already extracted a secret code (to avoid overriding it)
+        if not ('scrape' in question.lower() and 'secret' in question.lower()):
+            simple_answer = self._extract_simple_answer(question, page_content)
+            if simple_answer:
+                logger.info("Extracted simple answer from question")
+                return simple_answer
         
         # Strategy 6: Last resort - return a default answer
         logger.warning("Could not solve question, using default answer")
@@ -314,27 +316,44 @@ class QuizSolver:
                 scrape_content = await self.browser.load_page(scrape_url, wait_time=1, timeout=scrape_timeout)
                 scrape_text = scrape_content.get('all_text', scrape_content.get('text', ''))
                 
-                # Look for secret code patterns
+                # Look for secret code patterns - prioritize more specific patterns
                 secret_patterns = [
-                    r'secret[:\s]+([A-Za-z0-9]{8,})',
-                    r'code[:\s]+([A-Za-z0-9]{8,})',
-                    r'([A-Za-z0-9]{16,})',  # Long alphanumeric string
-                    r'"secret"[:\s]*"([^"]+)"',
-                    r'"code"[:\s]*"([^"]+)"',
+                    r'secret\s+code[:\s]+([A-Za-z0-9]{8,})',  # "secret code: ABC123..."
+                    r'secret[:\s]+([A-Za-z0-9]{8,})',  # "secret: ABC123..."
+                    r'code[:\s]+([A-Za-z0-9]{8,})',  # "code: ABC123..."
+                    r'"secret"[:\s]*"([^"]+)"',  # JSON format
+                    r'"code"[:\s]*"([^"]+)"',  # JSON format
+                    r'secret[:\s]*=?\s*([A-Za-z0-9]{8,})',  # "secret = ABC123"
+                    r'code[:\s]*=?\s*([A-Za-z0-9]{8,})',  # "code = ABC123"
                 ]
                 
                 for pattern in secret_patterns:
                     match = re.search(pattern, scrape_text, re.IGNORECASE)
                     if match:
                         secret = match.group(1).strip()
+                        # Remove any trailing punctuation
+                        secret = secret.rstrip('.,;:!?)}]{["\'')
                         if len(secret) >= 8:  # Reasonable minimum length
                             logger.info(f"Secret code extracted: {secret[:20]}...")
                             return secret
                 
-                # If no pattern matches, try to get the main text content
+                # Try to find standalone alphanumeric strings (likely the secret)
+                # Look for strings that are 8+ characters and appear to be standalone
+                standalone_pattern = r'(?:^|\s)([A-Za-z0-9]{12,})(?:\s|$)'
+                matches = re.findall(standalone_pattern, scrape_text)
+                for match in matches:
+                    secret = match.strip()
+                    if len(secret) >= 8 and secret.isalnum():
+                        logger.info(f"Using standalone string as secret: {secret[:20]}...")
+                        return secret
+                
+                # If no pattern matches, try to get the main text content (first substantial line)
                 lines = [line.strip() for line in scrape_text.split('\n') if line.strip()]
                 for line in lines:
-                    if len(line) >= 8 and line.isalnum():
+                    # Skip lines that are clearly not secrets (instructions, etc.)
+                    if any(word in line.lower() for word in ['get', 'secret', 'code', 'from', 'page', 'scrape', 'post', 'submit']):
+                        continue
+                    if len(line) >= 8 and (line.isalnum() or re.match(r'^[A-Za-z0-9_-]+$', line)):
                         logger.info(f"Using line as secret: {line[:20]}...")
                         return line
                         
@@ -490,7 +509,11 @@ class QuizSolver:
                 
                 if 'csv' in content_type or filename.endswith('.csv'):
                     df = pd.read_csv(io.StringIO(response.text))
-                    processed[filename] = df.to_dict('records')
+                    # Store both DataFrame and records for flexibility
+                    processed[filename] = {
+                        'dataframe': df,
+                        'records': df.to_dict('records')
+                    }
                     
                 elif 'json' in content_type or filename.endswith('.json'):
                     processed[filename] = response.json()
@@ -654,44 +677,66 @@ class QuizSolver:
         # CSV sum calculation (common task)
         if 'sum' in question_lower or 'total' in question_lower or 'cutoff' in question_lower:
             for filename, file_data in data.items():
-                if filename.endswith('.csv') and isinstance(file_data, list):
+                if filename.endswith('.csv'):
                     try:
-                        # Try to find numeric columns and sum them
-                        if file_data and isinstance(file_data[0], dict):
-                            # Find numeric columns
-                            numeric_cols = []
-                            for col in file_data[0].keys():
+                        # Handle both dict format (with dataframe/records) and list format
+                        df = None
+                        if isinstance(file_data, dict) and 'dataframe' in file_data:
+                            df = file_data['dataframe']
+                        elif isinstance(file_data, list) and file_data and isinstance(file_data[0], dict):
+                            df = pd.DataFrame(file_data)
+                        else:
+                            continue
+                        
+                        if df is None or df.empty:
+                            continue
+                        
+                        # Extract cutoff value from question
+                        cutoff_match = re.search(r'cutoff[:\s]+(\d+)', question, re.IGNORECASE)
+                        cutoff = None
+                        if cutoff_match:
+                            cutoff = float(cutoff_match.group(1))
+                        
+                        # Find numeric columns
+                        numeric_cols = df.select_dtypes(include=[float, int]).columns.tolist()
+                        
+                        if not numeric_cols:
+                            # Try to convert string columns to numeric
+                            for col in df.columns:
                                 try:
-                                    # Check if column contains numbers
-                                    sample_values = [row.get(col, 0) for row in file_data[:5] if col in row]
-                                    if sample_values:
-                                        float(sample_values[0])
+                                    df[col] = pd.to_numeric(df[col], errors='coerce')
+                                    if df[col].notna().any():
                                         numeric_cols.append(col)
-                                except (ValueError, TypeError):
+                                except:
                                     continue
-                            
-                            # If cutoff is mentioned, sum values above cutoff
-                            cutoff_match = re.search(r'cutoff[:\s]+(\d+)', question, re.IGNORECASE)
-                            cutoff = None
-                            if cutoff_match:
-                                cutoff = float(cutoff_match.group(1))
-                            
-                            # Sum all numeric columns
-                            total = 0
-                            for row in file_data:
+                        
+                        if numeric_cols:
+                            # If there's a cutoff, filter values above cutoff
+                            if cutoff is not None:
+                                # Sum all numeric values above cutoff across all numeric columns
+                                total = 0
                                 for col in numeric_cols:
-                                    try:
-                                        value = float(row.get(col, 0))
-                                        if cutoff is None or value > cutoff:
-                                            total += value
-                                    except (ValueError, TypeError):
-                                        continue
+                                    # Filter values above cutoff and sum
+                                    filtered_values = df[df[col] > cutoff][col]
+                                    col_sum = filtered_values.sum()
+                                    total += col_sum
+                                    logger.debug(f"Column {col}: {len(filtered_values)} values > {cutoff}, sum = {col_sum}")
+                                logger.info(f"Calculated sum from CSV (cutoff={cutoff}): {total}")
+                            else:
+                                # Sum all numeric columns
+                                total = df[numeric_cols].sum().sum()
+                                logger.info(f"Calculated sum from CSV (no cutoff): {total}")
                             
-                            if total > 0:
-                                logger.info(f"Calculated sum from CSV: {total}")
-                                return int(total) if total == int(total) else total
+                            # Return as integer if it's a whole number
+                            result = int(total) if abs(total - int(total)) < 0.0001 else total
+                            logger.info(f"Final CSV sum result: {result}")
+                            return result
+                        else:
+                            logger.warning(f"No numeric columns found in CSV {filename}")
                     except Exception as e:
                         logger.warning(f"Error calculating CSV sum: {e}")
+                        import traceback
+                        logger.debug(traceback.format_exc())
         
         # Count items
         if 'count' in question_lower or 'how many' in question_lower:
@@ -700,6 +745,14 @@ class QuizSolver:
                     count = len(file_data)
                     logger.info(f"Counted items in {filename}: {count}")
                     return count
+                elif isinstance(file_data, dict) and 'records' in file_data:
+                    count = len(file_data['records'])
+                    logger.info(f"Counted items in {filename}: {count}")
+                    return count
+                elif isinstance(file_data, dict) and 'dataframe' in file_data:
+                    count = len(file_data['dataframe'])
+                    logger.info(f"Counted items in {filename}: {count}")
+                    return count
         
         # Use LLM to solve with data (if available and we have time)
         remaining = self._check_time_remaining()

app/utils.py

@@ -35,11 +35,14 @@ def extract_submit_url(text: str, base_url: str) -> Optional[str]:
     patterns = [
         r'[Ss]ubmit\s+(?:your\s+)?(?:answer\s+)?(?:to|at|via):\s*(https?://[^\s<>"\'\)]+)',
         r'[Ss]ubmit\s+[Tt]o:\s*(https?://[^\s<>"\'\)]+)',
+        r'[Pp]ost\s+(?:to|at|JSON\s+to):\s*(https?://[^\s<>"\'\)]+)',  # "POST to JSON to https://..."
+        r'[Pp]ost\s+to\s+JSON\s+to\s*(https?://[^\s<>"\'\)]+)',  # "POST to JSON to https://..."
         r'[Uu][Rr][Ll]:\s*(https?://[^\s<>"\'\)]+)',
         r'[Pp]ost\s+(?:to|at):\s*(https?://[^\s<>"\'\)]+)',
         r'[Ss]end\s+(?:to|at):\s*(https?://[^\s<>"\'\)]+)',
         r'(https?://[^\s<>"\'\)]*submit[^\s<>"\'\)]*)',
         r'(https?://[^\s<>"\'\)]*answer[^\s<>"\'\)]*)',
+        r'POST\s+to\s+JSON\s+to\s*(https?://[^\s<>"\'\)]+)',  # "POST to JSON to https://..."
     ]
     
     for pattern in patterns:
@@ -74,6 +77,8 @@ def extract_submit_url(text: str, base_url: str) -> Optional[str]:
     rel_patterns = [
         r'href=["\\\'](/[^"\\\']*submit[^"\\\']*)["\\\']',
         r'(/[^\\s"<>\']*submit[^\\s"<>\']*)',
+        r'POST\s+to\s+JSON\s+to\s+(/[^\s<>"\'\)]+)',  # "POST to JSON to /submit"
+        r'[Pp]ost\s+(?:to|at):\s+(/[^\s<>"\'\)]+)',  # "POST to: /submit"
     ]
     for pattern in rel_patterns:
         matches = re.findall(pattern, text, re.IGNORECASE)
@@ -82,6 +87,16 @@ def extract_submit_url(text: str, base_url: str) -> Optional[str]:
             joined = urljoin(base_url, candidate)
             logger.info(f"Found relative submit URL: {joined}")
             return joined
+    
+    # Try to find submit URL in the base domain with /submit path
+    if base_url:
+        try:
+            parsed = urlparse(base_url)
+            submit_url = f"{parsed.scheme}://{parsed.netloc}/submit"
+            logger.info(f"Trying default submit URL: {submit_url}")
+            return submit_url
+        except:
+            pass
 
     logger.warning("No submit URL found in page text")
     return None