TEST ROUTES

FIX_404_SUMMARY.md

@@ -0,0 +1,170 @@
+# Fix for 404 Error on `/generate_patient_summary` Endpoint
+
+## Problem
+The `/generate_patient_summary` endpoint was returning a 404 Not Found error when accessed on Hugging Face Spaces at:
+```
+https://salvinjose-hntai.hf.space/generate_patient_summary?stream=true
+```
+
+## Root Cause
+1. **Route Registration Issue**: The `/generate_patient_summary` endpoint was defined INSIDE the `register_routes()` function, which meant it was being added to the router AFTER the router was already included in the app. While this should work in FastAPI, it's not best practice and can cause timing issues.
+
+2. **Double Initialization**: The app was being initialized twice:
+   - Once in `create_app()` (which calls `initialize_agents` by default)
+   - Once again in the root `app.py` file
+   
+   This double initialization could cause routes to be registered incorrectly or timing issues.
+
+## Changes Made
+
+### 1. Fixed Route Registration (`services/ai-service/src/ai_med_extract/api/routes_fastapi.py`)
+
+**Before:**
+```python
+def register_routes(app, agents):
+    app.include_router(router)
+    
+    # Routes defined INSIDE the function
+    @router.post("/generate_patient_summary")
+    async def generate_patient_summary(...):
+        ...
+```
+
+**After:**
+```python
+# Define routes at MODULE LEVEL (outside register_routes)
+@router.post("/generate_patient_summary")
+async def generate_patient_summary(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    stream: bool = False
+):
+    """Generate patient summary with optional streaming support."""
+    ...
+
+def register_routes(app, agents):
+    # Just include the router with already-defined routes
+    app.include_router(router)
+    ...
+```
+
+### 2. Fixed Double Initialization (`app.py`)
+
+**Before:**
+```python
+app = create_app()  # This calls initialize_agents internally
+initialize_agents(app, preload_small_models=False)  # Called again!
+```
+
+**After:**
+```python
+app = create_app(initialize=False)  # Don't initialize yet
+initialize_agents(app, preload_small_models=False)  # Initialize once
+```
+
+### 3. Added Comprehensive Logging
+
+Added logging to show all registered routes on startup in both:
+- `services/ai-service/src/ai_med_extract/app.py` (lines 781-786)
+- `app.py` (lines 95-103)
+
+This will help debug any remaining routing issues on HF Spaces.
+
+### 4. Added Diagnostic Endpoint
+
+Added a new `/api/info` endpoint that returns:
+```json
+{
+  "status": "ok",
+  "message": "Medical AI Service API",
+  "version": "1.0.0",
+  "endpoints": {
+    "generate_patient_summary": "/generate_patient_summary (POST)",
+    "upload": "/upload (POST)",
+    "transcribe": "/transcribe (POST)",
+    "health": "/health/* (GET)"
+  }
+}
+```
+
+## Testing
+
+### 1. Verify Routes are Registered
+After deploying to HF Spaces, check the logs for:
+```
+============================================================
+REGISTERED ROUTES:
+  ['POST'] /generate_patient_summary
+  ...
+Total routes registered: X
+============================================================
+```
+
+### 2. Test the Diagnostic Endpoint
+Access: `https://salvinjose-hntai.hf.space/api/info`
+
+Should return:
+```json
+{
+  "status": "ok",
+  "message": "Medical AI Service API",
+  ...
+}
+```
+
+### 3. Test the Debug Endpoint
+Access: `https://salvinjose-hntai.hf.space/debug/routes`
+
+Should return a list of all registered routes:
+```json
+{
+  "routes": [
+    {"path": "/generate_patient_summary", "methods": ["POST"], "name": "generate_patient_summary"},
+    ...
+  ],
+  "total": X
+}
+```
+
+### 4. Test the Target Endpoint
+```bash
+curl -X POST "https://salvinjose-hntai.hf.space/generate_patient_summary?stream=true" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "patientid": "your-patient-id",
+    "token": "your-auth-token",
+    "key": "your-api-key"
+  }'
+```
+
+## Expected Outcome
+
+The `/generate_patient_summary` endpoint should now:
+1. Return a proper response instead of 404
+2. Support both streaming (`stream=true`) and non-streaming modes
+3. Be visible in the route listing at `/debug/routes`
+
+## If Issues Persist
+
+If the 404 error persists after these changes:
+
+1. **Check the logs** - Look for the "REGISTERED ROUTES" section to verify the endpoint is registered
+2. **Test the diagnostic endpoint** - Access `/api/info` to verify the API is accessible
+3. **Check the debug endpoint** - Access `/debug/routes` to see all registered routes
+4. **Verify the URL** - Ensure you're using the correct URL without double slashes
+5. **Check for errors** - Look for any exceptions during route registration in the logs
+
+## Next Steps
+
+1. Commit these changes
+2. Push to HF Spaces
+3. Check the logs for route registration
+4. Test the endpoints as described above
+5. If issues persist, share the logs from HF Spaces
+
+## Files Modified
+
+- `app.py` (root level)
+- `services/ai-service/src/ai_med_extract/app.py`
+- `services/ai-service/src/ai_med_extract/api/routes_fastapi.py`
+

app.py

@@ -63,10 +63,10 @@ try:
     from ai_med_extract.app import create_app, initialize_agents  # type: ignore
     logging.info("Successfully imported create_app and initialize_agents")
     
-    # Create the app instance
+    # Create the app instance WITHOUT initializing agents yet
     try:
-        app = create_app()
-        logging.info("App instance created successfully")
+        app = create_app(initialize=False)
+        logging.info("App instance created successfully (without agents)")
         logging.info(f"App title: {app.title}")
         logging.info(f"App version: {getattr(app, 'version', 'unknown')}")
     except Exception as e:
@@ -87,13 +87,27 @@ try:
     
     # Initialize agents with minimal preloading for Hugging Face Spaces
     try:
+        logging.info("Initializing agents with preload_small_models=False...")
         initialize_agents(app, preload_small_models=False)
         logging.info("Agents initialized successfully")
+        
+        # Log all registered routes after initialization
+        logging.info("=" * 60)
+        logging.info("FINAL REGISTERED ROUTES ON HF SPACES:")
+        route_count = 0
+        for route in app.routes:
+            if hasattr(route, "methods") and hasattr(route, "path"):
+                logging.info(f"  {list(route.methods)} {route.path}")
+                route_count += 1
+        logging.info(f"Total routes registered: {route_count}")
+        logging.info("=" * 60)
     except Exception as e:
-        logging.warning(f"Agent initialization failed: {e}")
-        logging.info("App will start with basic functionality")
+        logging.error(f"Agent initialization failed: {e}")
+        import traceback
+        logging.error(f"Agent initialization traceback: {traceback.format_exc()}")
+        logging.warning("App will start with basic functionality")
         # Add a basic health endpoint if agents fail
-        @app.get("/health")
+        @app.get("/health/status")
         async def basic_health():
             return {"status": "degraded", "message": "Agents not initialized", "error": str(e)}
         

services/ai-service/src/ai_med_extract/api/routes_fastapi.py

@@ -947,9 +947,122 @@ async def process_patient_summary_sync(data):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Summary generation failed: {str(e)}")
 
+# ========== MODULE-LEVEL ROUTE DEFINITIONS ==========
+# Define routes at module level so they're available immediately when router is included
+
+# Health check routes
+@router.get("/live")
+async def live():
+    return {"status": "ok"}
+
+@router.get("/ready")
+async def ready():
+    try:
+        from config_settings import get_settings
+        settings = get_settings()
+        loaded = {}
+        try:
+            from ..utils.model_manager import model_manager
+            loaded = model_manager.list_loaded_models()
+        except Exception:
+            pass
+        return {
+            "app": settings.APP_NAME,
+            "version": settings.APP_VERSION,
+            "loaded_models": loaded,
+        }
+    except Exception:
+        return {"error": "Failed to get readiness status"}
+
+@router.get("/metrics")
+async def metrics():
+    return {"performance": PERFORMANCE_METRICS, "loaded_models": {}}
+
+# Home route
+@router.get("/")
+async def home():
+    return "Medical Data Extraction API is running!"
+
+# Simple diagnostic endpoint
+@router.get("/api/info")
+async def api_info():
+    """Simple diagnostic endpoint to verify API is accessible"""
+    return JSONResponse(content={
+        "status": "ok",
+        "message": "Medical AI Service API",
+        "version": "1.0.0",
+        "endpoints": {
+            "generate_patient_summary": "/generate_patient_summary (POST)",
+            "upload": "/upload (POST)",
+            "transcribe": "/transcribe (POST)",
+            "health": "/health/* (GET)"
+        }
+    })
+
+# Performance metrics route
+@router.get("/api/performance_metrics")
+async def get_performance_metrics():
+    return JSONResponse(content={
+        "metrics": PERFORMANCE_METRICS,
+        "timestamp": time.time()
+    })
+
+# Generate patient summary endpoint (migrated from Flask)
+@router.post("/generate_patient_summary")
+async def generate_patient_summary(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    stream: bool = False
+):
+    """
+    Generate patient summary with optional streaming support.
+    Migrated from Flask implementation with background processing.
+    """
+    try:
+        data = await request.json()
+        patientid = data.get("patientid")
+        token = data.get("token")
+        key = data.get("key")
+
+        if not patientid or not token or not key:
+            raise HTTPException(status_code=400, detail="Missing required fields: patientid, token, or key")
+
+        if stream:
+            # Return streaming response for long-running tasks
+            job_id = str(uuid.uuid4())
+            update_job(job_id, 'queued', progress=0, data={'job_id': job_id, 'message': 'Job queued ...'})
+
+            # Start background task
+            threading.Thread(target=process_patient_summary_background, args=(data, job_id), daemon=True).start()
+
+            return StreamingResponse(
+                sse_generator(job_id),
+                media_type="text/event-stream",
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'X-Accel-Buffering': 'no'
+                }
+            )
+        else:
+            # Prefer deterministic rule-based mode on Spaces unless explicitly overridden
+            try:
+                is_spaces = os.environ.get('HF_SPACES', 'false').lower() == 'true'
+            except Exception:
+                is_spaces = False
+            if is_spaces and not data.get('generation_mode'):
+                data['generation_mode'] = 'rule'
+            # Synchronous processing (for compatibility)
+            return await process_patient_summary_sync(data)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to start summary generation: {str(e)}")
+
 def register_routes(app, agents):
     # Register the router with the FastAPI app
     app.include_router(router)
+    logging.info("Main router registered with app")
+    
     # Ensure module-level agents reference is wired for route handlers
     try:
         globals()['agents'] = agents
@@ -959,105 +1072,32 @@ def register_routes(app, agents):
     # Include additional API endpoints
     from ..api_endpoints import router as api_router
     app.include_router(api_router)
+    logging.info("API router registered with app")
+    
     # Include model management FastAPI routes (non-breaking addition)
     try:
         from .model_management_fastapi import router as model_mgmt_router
         app.include_router(model_mgmt_router)
+        logging.info("Model management router registered with app")
     except Exception as _e:
         # Keep running even if this optional router fails
         logging.warning(f"Model management router not loaded: {_e}")
-
-    # Health check routes
-    @router.get("/live")
-    async def live():
-        return {"status": "ok"}
-
-    @router.get("/ready")
-    async def ready():
-        try:
-            from config_settings import get_settings
-            settings = get_settings()
-            loaded = {}
-            try:
-                from ..utils.model_manager import model_manager
-                loaded = model_manager.list_loaded_models()
-            except Exception:
-                pass
-            return {
-                "app": settings.APP_NAME,
-                "version": settings.APP_VERSION,
-                "loaded_models": loaded,
-            }
-        except Exception:
-            return {"error": "Failed to get readiness status"}
-
-    @router.get("/metrics")
-    async def metrics():
-        return {"performance": PERFORMANCE_METRICS, "loaded_models": {}}
-
-    # Home route
-    @router.get("/")
-    async def home():
-        return "Medical Data Extraction API is running!"
-
-    # Performance metrics route
-    @router.get("/api/performance_metrics")
-    async def get_performance_metrics():
-        return JSONResponse(content={
-            "metrics": PERFORMANCE_METRICS,
-            "timestamp": time.time()
-        })
-
-    # Generate patient summary endpoint (migrated from Flask)
-    @router.post("/generate_patient_summary")
-    async def generate_patient_summary(
-        request: Request,
-        background_tasks: BackgroundTasks,
-        stream: bool = False
-    ):
-        """
-        Generate patient summary with optional streaming support.
-        Migrated from Flask implementation with background processing.
-        """
-        try:
-            data = await request.json()
-            patientid = data.get("patientid")
-            token = data.get("token")
-            key = data.get("key")
-
-            if not patientid or not token or not key:
-                raise HTTPException(status_code=400, detail="Missing required fields: patientid, token, or key")
-
-            if stream:
-                # Return streaming response for long-running tasks
-                job_id = str(uuid.uuid4())
-                update_job(job_id, 'queued', progress=0, data={'job_id': job_id, 'message': 'Job queued ...'})
-
-                # Start background task
-                threading.Thread(target=process_patient_summary_background, args=(data, job_id), daemon=True).start()
-
-                return StreamingResponse(
-                    sse_generator(job_id),
-                    media_type="text/event-stream",
-                    headers={
-                        'Cache-Control': 'no-cache',
-                        'Connection': 'keep-alive',
-                        'X-Accel-Buffering': 'no'
-                    }
-                )
-            else:
-                # Prefer deterministic rule-based mode on Spaces unless explicitly overridden
-                try:
-                    is_spaces = os.environ.get('HF_SPACES', 'false').lower() == 'true'
-                except Exception:
-                    is_spaces = False
-                if is_spaces and not data.get('generation_mode'):
-                    data['generation_mode'] = 'rule'
-                # Synchronous processing (for compatibility)
-                return await process_patient_summary_sync(data)
-
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Failed to start summary generation: {str(e)}")
+    
+    # Debug route to list all available routes (needs app reference)
+    @app.get("/debug/routes")
+    async def list_routes():
+        """List all registered routes for debugging"""
+        routes = []
+        for route in app.routes:
+            if hasattr(route, "methods"):
+                routes.append({
+                    "path": route.path,
+                    "methods": list(route.methods),
+                    "name": route.name
+                })
+        return {"routes": routes, "total": len(routes)}
+    
+    logging.info("All routes registered successfully")
 
     # Upload file endpoint (migrated from Flask)
     @router.post("/upload")

services/ai-service/src/ai_med_extract/app.py

@@ -776,7 +776,14 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
         register_routes(app, agents)
         app.include_router(health_router, prefix="/health")
 
+        # Log all registered routes for debugging
         logging.info("Agents initialized and routes registered")
+        logging.info("=" * 60)
+        logging.info("REGISTERED ROUTES:")
+        for route in app.routes:
+            if hasattr(route, "methods") and hasattr(route, "path"):
+                logging.info(f"  {list(route.methods)} {route.path}")
+        logging.info("=" * 60)
     except Exception as e:
         logging.error(f"Failed to register routes: {e}")
         import traceback
@@ -820,9 +827,5 @@ def run_dev(host: str = "0.0.0.0", port: int = 7860, debug: bool = False):
 if __name__ == "__main__":
     run_dev()
 
-# Expose a module-level app instance for Hugging Face Spaces autodiscovery
-try:
-    app = create_app()
-except Exception:
-    # Defer errors to runtime logs rather than import-time crash on Spaces
-    app = FastAPI(title="Medical AI Service (degraded)")
+# Module-level app instance is now created in root app.py to avoid multiple initializations
+# Do NOT create app here as it causes duplicate initialization

test_routes_local.py

@@ -0,0 +1,109 @@
+"""
+Local test script to verify routes are properly registered.
+Run this before deploying to HF Spaces.
+
+Usage:
+    python test_routes_local.py
+"""
+
+import sys
+import os
+
+# Add the source directory to the path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+src_dir = os.path.join(current_dir, "services", "ai-service", "src")
+sys.path.insert(0, src_dir)
+
+# Set environment variables for testing
+os.environ["HF_SPACES"] = "true"
+os.environ["FAST_MODE"] = "true"
+
+print("=" * 60)
+print("Testing Route Registration")
+print("=" * 60)
+
+try:
+    from ai_med_extract.app import create_app, initialize_agents
+    print("✓ Successfully imported create_app and initialize_agents")
+    
+    # Create app without initialization
+    print("\nCreating app...")
+    app = create_app(initialize=False)
+    print(f"✓ App created: {app.title}")
+    
+    # Initialize agents
+    print("\nInitializing agents...")
+    initialize_agents(app, preload_small_models=False)
+    print("✓ Agents initialized")
+    
+    # List all routes
+    print("\n" + "=" * 60)
+    print("REGISTERED ROUTES:")
+    print("=" * 60)
+    
+    routes_found = []
+    generate_patient_summary_found = False
+    
+    for route in app.routes:
+        if hasattr(route, "methods") and hasattr(route, "path"):
+            methods = list(route.methods)
+            path = route.path
+            routes_found.append((methods, path))
+            print(f"  {methods} {path}")
+            
+            # Check for the specific endpoint we're looking for
+            if path == "/generate_patient_summary" and "POST" in methods:
+                generate_patient_summary_found = True
+    
+    print("=" * 60)
+    print(f"Total routes: {len(routes_found)}")
+    print("=" * 60)
+    
+    # Verify critical endpoints
+    print("\n" + "=" * 60)
+    print("ENDPOINT VERIFICATION:")
+    print("=" * 60)
+    
+    critical_endpoints = {
+        "/generate_patient_summary": False,
+        "/api/info": False,
+        "/debug/routes": False,
+        "/": False,
+    }
+    
+    for methods, path in routes_found:
+        if path in critical_endpoints:
+            critical_endpoints[path] = True
+    
+    all_found = True
+    for endpoint, found in critical_endpoints.items():
+        status = "✓" if found else "✗"
+        print(f"  {status} {endpoint}")
+        if not found:
+            all_found = False
+    
+    print("=" * 60)
+    
+    if generate_patient_summary_found:
+        print("\n✓✓✓ SUCCESS! /generate_patient_summary endpoint is registered ✓✓✓")
+    else:
+        print("\n✗✗✗ ERROR! /generate_patient_summary endpoint NOT found ✗✗✗")
+        sys.exit(1)
+    
+    if all_found:
+        print("✓ All critical endpoints are registered")
+        print("\nReady for deployment to HF Spaces!")
+    else:
+        print("\n⚠ Some endpoints are missing (see above)")
+    
+    print("\n" + "=" * 60)
+    print("Test completed successfully!")
+    print("=" * 60)
+
+except Exception as e:
+    print(f"\n✗✗✗ ERROR: {str(e)}")
+    import traceback
+    print("\nTraceback:")
+    print(traceback.format_exc())
+    sys.exit(1)
+