more troubleshooting

app/main.py

@@ -1,15 +1,21 @@
+"""
+Complete ChatFed Orchestrator with flexible input handling for ChatUI compatibility
+"""
 from fastapi import FastAPI, Request
 from langserve import add_routes
 from langchain_core.runnables import RunnableLambda
 from pydantic import BaseModel
 from typing import List, Literal, Optional, Dict, Any
+import gradio as gr
+from datetime import datetime
 import logging
 
 # Set up logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ─────────────────────────────────────────
-# Keep existing schemas for backwards compatibility
+# Schemas - Both Legacy and Flexible
 # ─────────────────────────────────────────
 
 class ChatMessage(BaseModel):
@@ -19,8 +25,9 @@ class ChatMessage(BaseModel):
 class ChatUIInput(BaseModel):
     messages: List[ChatMessage]
 
+# Legacy schema for backwards compatibility
 class ChatFedInput(BaseModel):
-    query: str  # Keep original strict validation
+    query: str
     reports_filter: Optional[str] = ""
     sources_filter: Optional[str] = ""
     subtype_filter: Optional[str] = ""
@@ -28,20 +35,20 @@ class ChatFedInput(BaseModel):
     session_id: Optional[str] = None
     user_id: Optional[str] = None
 
-# ─────────────────────────────────────────
-# Add new flexible schema for ChatUI compatibility
-# ─────────────────────────────────────────
-
+# New flexible schema for ChatUI compatibility
 class FlexibleChatInput(BaseModel):
-    """Flexible input that accepts multiple field names"""
+    """Flexible input that accepts multiple field names for the query"""
+    # Accept any of these fields for the main query
     query: Optional[str] = None
     text: Optional[str] = None
     input: Optional[str] = None
     prompt: Optional[str] = None
     content: Optional[str] = None
+    
+    # ChatUI messages format
     messages: Optional[List[Dict[str, Any]]] = None
     
-    # Keep RAG filters
+    # RAG filters (optional)
     reports_filter: Optional[str] = ""
     sources_filter: Optional[str] = ""
     subtype_filter: Optional[str] = ""
@@ -50,13 +57,13 @@ class FlexibleChatInput(BaseModel):
     user_id: Optional[str] = None
     
     def extract_query(self) -> str:
-        """Extract query from any available field"""
-        # Try direct fields
+        """Extract query text from any of the available fields"""
+        # Try direct text fields first
         for field in [self.query, self.text, self.input, self.prompt, self.content]:
             if field and field.strip():
                 return field.strip()
         
-        # Try messages
+        # Try messages format
         if self.messages:
             for msg in reversed(self.messages):
                 if isinstance(msg, dict) and msg.get('role') == 'user':
@@ -71,7 +78,7 @@ class ChatFedOutput(BaseModel):
     metadata: Dict[str, Any]
 
 # ─────────────────────────────────────────
-# Updated handlers
+# Core Logic
 # ─────────────────────────────────────────
 
 def process_chatfed_query_core(query: str) -> ChatFedOutput:
@@ -83,60 +90,226 @@ def process_chatfed_query_core(query: str) -> ChatFedOutput:
         }
     )
 
+def extract_user_query_fallback(data: Any) -> str:
+    """Fallback function to extract user query from any input format"""
+    try:
+        if not data:
+            return ""
+        
+        # Handle Pydantic models
+        if hasattr(data, '__dict__'):
+            data_dict = data.__dict__
+        elif isinstance(data, dict):
+            data_dict = data
+        else:
+            return str(data)
+        
+        # Method 1: Direct query fields
+        for field in ["query", "text", "input", "prompt", "content", "question"]:
+            if field in data_dict and data_dict[field]:
+                return str(data_dict[field])
+        
+        # Method 2: Messages format
+        if "messages" in data_dict:
+            messages = data_dict["messages"]
+            if isinstance(messages, list):
+                for msg in reversed(messages):
+                    if isinstance(msg, dict) and msg.get("role") == "user":
+                        content = msg.get("content") or msg.get("text")
+                        if content:
+                            return str(content)
+        
+        # Method 3: If the whole thing looks like a message
+        if isinstance(data_dict, dict) and "role" in data_dict and data_dict.get("role") == "user":
+            return str(data_dict.get("content", data_dict.get("text", "")))
+        
+        return ""
+        
+    except Exception as e:
+        logger.error(f"Error extracting query from {data}: {e}")
+        return ""
+
+# ─────────────────────────────────────────
+# Handlers - Multiple for Different Use Cases
+# ─────────────────────────────────────────
+
 def flexible_handler(data: FlexibleChatInput) -> ChatFedOutput:
-    """Handler for flexible input that accepts multiple formats"""
+    """Primary handler for flexible input that accepts multiple formats"""
     try:
+        logger.info(f"flexible_handler received: {data}")
+        
         query = data.extract_query()
         
         if not query:
             return ChatFedOutput(
                 result="No query found. Please provide text in one of these fields: query, text, prompt, content, or messages array.",
-                metadata={"error": True, "source": "flexible", "provided_fields": list(data.__dict__.keys())}
+                metadata={
+                    "error": True, 
+                    "source": "flexible", 
+                    "provided_fields": [k for k, v in data.__dict__.items() if v],
+                    "help": "Supported formats: {'query': 'text'}, {'text': 'text'}, {'messages': [{'role': 'user', 'content': 'text'}]}"
+                }
             )
             
         result = process_chatfed_query_core(query)
         result.metadata.update({
             "source": "flexible",
             "extracted_query": query,
-            "input_method": "flexible_handler"
+            "input_method": "flexible_handler",
+            "extracted_from": next((k for k, v in data.__dict__.items() if v and k in ['query', 'text', 'input', 'prompt', 'content']), "messages")
         })
         return result
         
     except Exception as e:
         logger.error(f"Error in flexible_handler: {str(e)}")
         return ChatFedOutput(
-            result=f"Error: {str(e)}",
-            metadata={"error": True, "source": "flexible"}
+            result=f"Error processing request: {str(e)}",
+            metadata={"error": True, "source": "flexible", "exception": str(e)}
         )
 
 def legacy_langserve_handler(data: ChatFedInput) -> ChatFedOutput:
-    """Original handler for backwards compatibility"""
+    """Legacy handler for backwards compatibility - strict validation"""
     try:
+        logger.info(f"legacy_langserve_handler received: {data}")
+        
         result = process_chatfed_query_core(data.query)
-        result.metadata["source"] = "legacy_langserve"
+        result.metadata.update({
+            "source": "legacy_langserve",
+            "input_method": "legacy_handler"
+        })
         return result
+        
     except Exception as e:
+        logger.error(f"Error in legacy_langserve_handler: {str(e)}")
         return ChatFedOutput(
-            result=f"Error: {str(e)}",
-            metadata={"error": True, "source": "legacy_langserve"}
+            result=f"Error processing request: {str(e)}",
+            metadata={"error": True, "source": "legacy_langserve", "exception": str(e)}
+        )
+
+def chatui_handler(data) -> ChatFedOutput:
+    """Handler for chat UI input - accepts raw dict and returns ChatFedOutput"""
+    try:
+        logger.info(f"chatui_handler received: {data}")
+        
+        # Handle both dict and Pydantic model input
+        if isinstance(data, dict):
+            messages = data.get("messages", [])
+            
+            # Handle case where ChatUI sends 'text' instead of 'messages'
+            if not messages and "text" in data:
+                # Convert text to messages format
+                messages = [{"role": "user", "content": data["text"]}]
+            
+        else:
+            messages = data.messages if hasattr(data, 'messages') else []
+        
+        # Find the last user message
+        last_user_msg = ""
+        for msg in reversed(messages):
+            if isinstance(msg, dict):
+                if msg.get("role") == "user":
+                    last_user_msg = msg.get("content", "")
+                    break
+            else:
+                if hasattr(msg, 'role') and msg.role == "user":
+                    last_user_msg = msg.content
+                    break
+        
+        # Fallback to extract from any format
+        if not last_user_msg:
+            last_user_msg = extract_user_query_fallback(data)
+        
+        if not last_user_msg.strip():
+            return ChatFedOutput(
+                result="No user message found in chat UI input",
+                metadata={"error": True, "source": "chatui", "raw_input": str(data)}
+            )
+        
+        result = process_chatfed_query_core(last_user_msg.strip())
+        result.metadata.update({
+            "source": "chatui",
+            "extracted_query": last_user_msg.strip(),
+            "input_method": "chatui_handler"
+        })
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error in chatui_handler: {str(e)}")
+        return ChatFedOutput(
+            result=f"Error processing chat UI request: {str(e)}",
+            metadata={"error": True, "source": "chatui", "exception": str(e)}
         )
 
 # ─────────────────────────────────────────
-# App setup with multiple endpoints
+# Gradio Interface
 # ─────────────────────────────────────────
 
-app = FastAPI(title="ChatFed API", version="1.0.0")
+def create_gradio_interface():
+    with gr.Blocks(title="ChatFed UI") as demo:
+        gr.Markdown("## ChatFed Dev UI")
+        
+        with gr.Row():
+            with gr.Column(scale=4):
+                query = gr.Textbox(label="Query", placeholder="Enter your query here...")
+            with gr.Column(scale=1):
+                btn = gr.Button("Send", variant="primary")
+        
+        out = gr.Textbox(label="Response", lines=10)
 
-# Legacy endpoint (strict validation)
-add_routes(
-    app,
-    RunnableLambda(legacy_langserve_handler),
-    path="/chatfed-strict",
-    input_type=ChatFedInput,
-    output_type=ChatFedOutput
+        def process_query(q: str) -> str:
+            if not q.strip():
+                return "Please enter a query."
+            try:
+                result = process_chatfed_query_core(q)
+                return result.result
+            except Exception as e:
+                return f"Error processing query: {str(e)}"
+
+        btn.click(fn=process_query, inputs=query, outputs=out)
+        query.submit(fn=process_query, inputs=query, outputs=out)  # Allow Enter key
+    
+    return demo
+
+# ─────────────────────────────────────────
+# App Startup
+# ─────────────────────────────────────────
+
+app = FastAPI(
+    title="ChatFed API",
+    description="API for ChatFed query processing with flexible input handling",
+    version="1.0.0"
 )
 
-# New flexible endpoint for ChatUI (THIS IS WHAT YOU SHOULD USE)
+# Add request logging middleware for debugging
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    """Log incoming requests for debugging"""
+    if request.url.path.startswith("/chatfed") or request.url.path.startswith("/debug"):
+        try:
+            body = await request.body()
+            logger.info(f"=== REQUEST DEBUG ===")
+            logger.info(f"Path: {request.url.path}")
+            logger.info(f"Method: {request.method}")
+            logger.info(f"Headers: {dict(request.headers)}")
+            logger.info(f"Body: {body.decode('utf-8') if body else 'Empty'}")
+            
+            # Recreate request for next handler
+            async def receive():
+                return {"type": "http.request", "body": body}
+            
+            request._receive = receive
+            
+        except Exception as e:
+            logger.error(f"Error logging request: {e}")
+    
+    response = await call_next(request)
+    return response
+
+# ─────────────────────────────────────────
+# LangServe Routes
+# ─────────────────────────────────────────
+
+# Primary flexible endpoint for ChatUI (THIS IS THE MAIN ONE)
 add_routes(
     app,
     RunnableLambda(flexible_handler),
@@ -145,27 +318,59 @@ add_routes(
     output_type=ChatFedOutput
 )
 
-# Add health check endpoint
+# ChatUI specific endpoint with flexible handling
+add_routes(
+    app,
+    RunnableLambda(chatui_handler),
+    path="/chatfed-chatui",
+    input_type=ChatUIInput,
+    output_type=ChatFedOutput
+)
+
+# Legacy endpoint for backwards compatibility (strict validation)
+add_routes(
+    app,
+    RunnableLambda(legacy_langserve_handler),
+    path="/chatfed-strict",
+    input_type=ChatFedInput,
+    output_type=ChatFedOutput
+)
+
+# ─────────────────────────────────────────
+# Additional Endpoints
+# ─────────────────────────────────────────
+
+# Health check endpoint
 @app.get("/health")
 async def health_check():
     return {"status": "healthy", "timestamp": datetime.now().isoformat()}
 
-# Add a simple root endpoint
+# Root endpoint
 @app.get("/")
 async def root():
     return {
         "message": "ChatFed API is running",
+        "status": "healthy",
         "endpoints": {
-            "chatfed": "/chatfed",
-            "chatfed_chatui": "/chatfed-chatui", 
+            "primary": "/chatfed (flexible input - use this for ChatUI)",
+            "chatui": "/chatfed-chatui",
+            "legacy": "/chatfed-strict (requires 'query' field)",
+            "openai": "/v1/chat/completions",
+            "simple": "/simple-chat",
             "gradio_ui": "/ui",
             "docs": "/docs",
-            "health": "/health"
+            "health": "/health",
+            "debug": "/debug-input"
+        },
+        "supported_input_formats": {
+            "query_field": '{"query": "your text"}',
+            "text_field": '{"text": "your text"}',
+            "messages": '{"messages": [{"role": "user", "content": "your text"}]}',
+            "other_fields": "prompt, input, content are also supported"
         }
     }
 
-# Add this to your FastAPI app after the existing routes
-
+# OpenAI-compatible endpoint
 @app.post("/v1/chat/completions")
 async def openai_compatible_endpoint(request: Request):
     """OpenAI-compatible endpoint that ChatUI might prefer"""
@@ -204,7 +409,7 @@ async def openai_compatible_endpoint(request: Request):
         logger.error(f"Error in OpenAI endpoint: {str(e)}")
         return {"error": str(e)}
 
-# Also add a simple text endpoint
+# Simple chat endpoint
 @app.post("/simple-chat")
 async def simple_chat_endpoint(request: Request):
     """Simple endpoint that accepts any text input"""
@@ -230,7 +435,51 @@ async def simple_chat_endpoint(request: Request):
         logger.error(f"Error in simple chat: {str(e)}")
         return {"error": str(e)}
 
-# Mount Gradio at a specific path instead of root to avoid conflicts
+# Debug endpoint for testing
+@app.post("/debug-input")
+async def debug_input_endpoint(request: Request):
+    """Debug endpoint to see exactly what's being sent and how it's processed"""
+    try:
+        # Get raw body
+        raw_body = await request.body()
+        
+        # Parse JSON
+        data = await request.json()
+        
+        # Create FlexibleChatInput to test extraction
+        try:
+            flexible_input = FlexibleChatInput(**data)
+            extracted_query = flexible_input.extract_query()
+        except Exception as e:
+            flexible_input = None
+            extracted_query = f"Error creating FlexibleChatInput: {str(e)}"
+        
+        # Try fallback extraction
+        fallback_query = extract_user_query_fallback(data)
+        
+        return {
+            "debug_info": {
+                "raw_body": raw_body.decode('utf-8'),
+                "parsed_data": data,
+                "data_keys": list(data.keys()) if isinstance(data, dict) else "not_dict",
+                "data_type": str(type(data)),
+                "flexible_input_created": flexible_input is not None,
+                "extracted_query_flexible": extracted_query,
+                "extracted_query_fallback": fallback_query,
+            },
+            "test_results": {
+                "would_process": extracted_query or fallback_query,
+                "final_query": extracted_query or fallback_query or "NO_QUERY_FOUND"
+            }
+        }
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "raw_body": raw_body.decode('utf-8') if 'raw_body' in locals() else "failed_to_read"
+        }
+
+# Mount Gradio at a specific path
 demo = create_gradio_interface()
 app.mount("/ui", demo)