Upload app.py

app.py

@@ -6,7 +6,7 @@ from fastapi import FastAPI, Request, HTTPException, Depends, status
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from fastapi.security import APIKeyHeader
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 from datetime import datetime
 
 # LangGraph and Model Imports
@@ -22,6 +22,24 @@ from models import (
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# --- Global Debug Store ---
+# This will store the last 50 requests and responses in memory for easy debugging
+DEBUG_LOGS: List[Dict[str, Any]] = []
+MAX_DEBUG_LOGS = 50
+
+def add_debug_log(direction: str, path: str, method: str, headers: Dict[str, str], body: Any):
+    log_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "direction": direction,
+        "path": path,
+        "method": method,
+        "headers": {k: v for k, v in headers.items() if k.lower() != "x-api-key"}, # Hide key for safety
+        "body": body
+    }
+    DEBUG_LOGS.insert(0, log_entry)
+    if len(DEBUG_LOGS) > MAX_DEBUG_LOGS:
+        DEBUG_LOGS.pop()
+
 # --- Configuration ---
 API_KEY_NAME = "x-api-key"
 API_KEY = os.environ.get("HONEYPOT_API_KEY", "sk_test_123456789")
@@ -29,40 +47,64 @@ api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
 
 # --- Initialization ---
 app = FastAPI(
-    title="Agentic Honey-Pot API",
-    description="REST API for Scam Detection and Intelligence Extraction (Problem Statement 2).",
-    version="1.2.0"
+    title="Agentic Honey-Pot API - Super Debug Mode",
+    description="REST API for Scam Detection with enhanced logging.",
+    version="1.3.0"
 )
 
 # Initialize LangGraph Checkpointer
 checkpointer: BaseCheckpointSaver = MemorySaver()
 honeypot_app = create_honeypot_graph(checkpointer)
 
+# --- Middleware for Global Logging ---
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    path = request.url.path
+    method = request.method
+    headers = dict(request.headers)
+    
+    # Capture request body
+    body = None
+    if method == "POST":
+        try:
+            raw_body = await request.body()
+            body = json.loads(raw_body)
+        except:
+            body = "Could not parse body as JSON"
+            
+    add_debug_log("INCOMING", path, method, headers, body)
+    logger.info(f"INCOMING {method} {path} | Body: {body}")
+
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = time.time() - start_time
+
+    # Capture response body (this is a bit tricky in FastAPI middleware)
+    # For simplicity, we'll log the status code here and log the actual body in the endpoint
+    logger.info(f"OUTGOING {method} {path} | Status: {response.status_code} | Time: {process_time:.4f}s")
+    
+    return response
+
 # --- Exception Handler for Diagnostic Logging ---
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    """
-    Captures and logs the exact payload that caused a 422 Unprocessable Entity error.
-    This is crucial for diagnosing why the tester is failing.
-    """
     body = await request.body()
     try:
         payload = json.loads(body)
     except:
         payload = body.decode()
     
-    logger.error(f"422 Unprocessable Entity Error!")
-    logger.error(f"Payload received: {payload}")
-    logger.error(f"Validation errors: {exc.errors()}")
+    error_detail = exc.errors()
+    logger.error(f"422 Unprocessable Entity Error! Payload: {payload} | Errors: {error_detail}")
     
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        content={
-            "detail": exc.errors(),
-            "body": payload,
-            "message": "The request body does not match the Problem Statement 2 schema. Check logs for details."
-        }
-    )
+    response_body = {
+        "detail": error_detail,
+        "received_body": payload,
+        "message": "Validation failed. Check /debug/logs for details."
+    }
+    add_debug_log("OUTGOING_ERROR", request.url.path, request.method, {}, response_body)
+    
+    return JSONResponse(status_code=422, content=response_body)
 
 # --- Dependency for API Key Validation ---
 async def get_api_key(api_key_header: str = Depends(api_key_header)):
@@ -75,15 +117,19 @@ async def get_api_key(api_key_header: str = Depends(api_key_header)):
 
 # --- API Endpoints ---
 
+@app.get("/debug/logs")
+async def get_debug_logs():
+    """Endpoint to view the last 50 requests and responses."""
+    return {
+        "count": len(DEBUG_LOGS),
+        "logs": DEBUG_LOGS
+    }
+
 @app.post("/api/honeypot-detection", response_model=HoneypotResponse)
 async def honeypot_detection(
     request_data: HoneypotRequest,
     api_key: str = Depends(get_api_key)
 ) -> Dict[str, Any]:
-    """
-    Accepts an incoming message event, runs the LangGraph agent, and returns the response.
-    Strictly follows Problem Statement 2 schema.
-    """
     session_id = request_data.sessionId
     config = {"configurable": {"thread_id": session_id}}
     
@@ -104,7 +150,6 @@ async def honeypot_detection(
         current_state["totalMessagesExchanged"] += 1
         input_state = current_state
     else:
-        # New session
         initial_history = request_data.conversationHistory + [request_data.message]
         input_state = AgentState(
             sessionId=session_id,
@@ -121,11 +166,9 @@ async def honeypot_detection(
     try:
         final_state_dict = honeypot_app.invoke(input_state, config=config)
         final_state = AgentState(**final_state_dict)
-        
         engagement_duration = int(time.time() - start_time)
         
-        # Prepare response strictly matching PDF
-        return {
+        response_content = {
             "status": "success",
             "scamDetected": final_state["scamDetected"],
             "engagementMetrics": {
@@ -135,14 +178,24 @@ async def honeypot_detection(
             "extractedIntelligence": final_state["extractedIntelligence"].model_dump(),
             "agentNotes": final_state["agentNotes"]
         }
+        
+        # Log the successful response body
+        add_debug_log("OUTGOING_SUCCESS", "/api/honeypot-detection", "POST", {}, response_content)
+        
+        return response_content
 
     except Exception as e:
-        logger.error(f"Internal Error: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Internal server error: {str(e)}",
-        )
+        error_msg = f"Internal Error: {str(e)}"
+        logger.error(error_msg)
+        add_debug_log("OUTGOING_ERROR", "/api/honeypot-detection", "POST", {}, {"error": error_msg})
+        raise HTTPException(status_code=500, detail=error_msg)
 
 @app.get("/")
 async def root():
-    return {"message": "Agentic Honey-Pot API is running. Use /api/honeypot-detection."}
+    return {
+        "message": "Agentic Honey-Pot API is running.",
+        "endpoints": {
+            "detection": "/api/honeypot-detection",
+            "debug_logs": "/debug/logs"
+        }
+    }