Fix: Use correct OpenAI-compatible API URL with comprehensive logging

app.py

@@ -2,86 +2,144 @@ import gradio as gr
 import requests
 import logging
 import sys
-import time
 import os
+import json
+import traceback
 
+# --- EXTREME LOGGING SETUP ---
 logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - [%(funcName)s] %(message)s",
     handlers=[logging.StreamHandler(sys.stdout)]
 )
 logger = logging.getLogger("ChatbotBrain")
 
+logger.info("=" * 60)
+logger.info("STARTUP: CPU Chatbot Initializing...")
+logger.info("=" * 60)
 logger.info(f"Gradio Version: {gr.__version__}")
 logger.info(f"Python Version: {sys.version}")
 
+# --- CONFIGURATION ---
 MODEL_NAME = "HuggingFaceH4/zephyr-7b-beta"
 
+# Read HF_TOKEN from environment variable (set in Space Secrets)
 HF_TOKEN = os.environ.get("HF_TOKEN")
+logger.info("Checking for HF_TOKEN in environment...")
 if HF_TOKEN:
-    logger.info("SUCCESS: HF_TOKEN loaded from environment secrets!")
-    logger.info(f"Token starts with: {HF_TOKEN[:10]}...")
+    logger.info(f"SUCCESS: HF_TOKEN found! Length: {len(HF_TOKEN)} chars")
+    logger.info(f"Token preview: {HF_TOKEN[:15]}...{HF_TOKEN[-5:]}")
 else:
-    logger.error("ERROR: HF_TOKEN not found! Add it to Space Secrets.")
+    logger.error("CRITICAL ERROR: HF_TOKEN not found in environment!")
+    logger.error("Please add HF_TOKEN to your Space Secrets")
 
-API_URL = f"https://router.huggingface.co/hf-inference/models/{MODEL_NAME}"
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+# Use the OpenAI-compatible chat completions endpoint
+API_URL = "https://router.huggingface.co/v1/chat/completions"
+HEADERS = {
+    "Authorization": f"Bearer {HF_TOKEN}",
+    "Content-Type": "application/json"
+} if HF_TOKEN else {}
 
-logger.info(f"Using Model: {MODEL_NAME}")
+logger.info(f"Model: {MODEL_NAME}")
 logger.info(f"API URL: {API_URL}")
+logger.info(f"Headers configured: {list(HEADERS.keys())}")
 
-def query_model(payload):
-    logger.info(f"Sending request with payload: {payload}")
+
+def query_model(messages):
+    """Send a request to the HuggingFace Inference API with detailed logging."""
+    logger.info("-" * 40)
+    logger.info("QUERY_MODEL: Starting API call...")
+    
+    payload = {
+        "model": MODEL_NAME,
+        "messages": messages,
+        "max_tokens": 512,
+        "temperature": 0.7
+    }
+    
+    logger.debug(f"Request URL: {API_URL}")
+    logger.debug(f"Request Headers: Authorization=Bearer {HF_TOKEN[:10] if HF_TOKEN else 'MISSING'}...")
+    logger.debug(f"Request Payload: {json.dumps(payload, indent=2)}")
+    
     try:
-        response = requests.post(API_URL, headers=HEADERS, json=payload, timeout=60)
-        logger.info(f"Response Status: {response.status_code}")
+        logger.info("Sending POST request to API...")
+        response = requests.post(API_URL, headers=HEADERS, json=payload, timeout=120)
+        
+        logger.info(f"Response Status Code: {response.status_code}")
+        logger.debug(f"Response Headers: {dict(response.headers)}")
+        
         if response.status_code != 200:
-            logger.error(f"API Error: {response.text}")
-            return {"error": f"API returned {response.status_code}: {response.text}"}
+            logger.error(f"API ERROR: Status {response.status_code}")
+            logger.error(f"Response Body: {response.text}")
+            logger.error(f"URL Used: {API_URL}")
+            logger.error(f"Model Used: {MODEL_NAME}")
+            return {"error": f"API returned {response.status_code}: {response.text[:500]}"}
+        
         result = response.json()
-        logger.info(f"Response Body: {result}")
+        logger.info("SUCCESS: Got valid JSON response")
+        logger.debug(f"Response JSON: {json.dumps(result, indent=2)}")
         return result
+        
+    except requests.exceptions.Timeout:
+        logger.error("TIMEOUT: Request took longer than 120 seconds")
+        return {"error": "Request timed out after 120 seconds"}
+    except requests.exceptions.ConnectionError as e:
+        logger.error(f"CONNECTION ERROR: {e}")
+        return {"error": f"Connection error: {e}"}
     except Exception as e:
-        logger.error(f"Exception: {e}")
+        logger.error(f"UNEXPECTED ERROR: {e}")
+        logger.error(traceback.format_exc())
         return {"error": str(e)}
 
+
 def respond(message, history):
-    logger.info("="*50)
-    logger.info(f"USER MESSAGE: {message}")
-    logger.info(f"History Length: {len(history)}")
+    """Generate a response from the AI model."""
+    logger.info("=" * 60)
+    logger.info("RESPOND: New user message received")
+    logger.info(f"User Message: {message}")
+    logger.info(f"History Length: {len(history)} messages")
+    
+    # Build messages array (OpenAI format)
+    messages = []
+    messages.append({"role": "system", "content": "You are a helpful AI assistant."})
     
-    prompt = ""
     for user_msg, assistant_msg in history:
-        prompt += "User: " + user_msg + "\nAssistant: " + assistant_msg + "\n"
-    prompt += "User: " + message + "\nAssistant:"
+        messages.append({"role": "user", "content": user_msg})
+        if assistant_msg:
+            messages.append({"role": "assistant", "content": assistant_msg})
     
-    logger.info(f"Formatted Prompt: {prompt}")
+    messages.append({"role": "user", "content": message})
     
-    payload = {
-        "inputs": prompt,
-        "parameters": {"max_new_tokens": 512, "temperature": 0.7, "do_sample": True}
-    }
+    logger.info(f"Built {len(messages)} messages for API")
+    logger.debug(f"Messages: {json.dumps(messages, indent=2)}")
     
-    result = query_model(payload)
+    result = query_model(messages)
     
     if "error" in result:
-        return "Error: " + result["error"]
+        error_msg = result["error"]
+        logger.error(f"Returning error to user: {error_msg}")
+        return f"Error: {error_msg}"
     
-    if isinstance(result, list) and len(result) > 0:
-        text = result[0].get("generated_text", "")
-    else:
-        text = str(result)
+    # Extract response from OpenAI-compatible format
+    try:
+        response_text = result["choices"][0]["message"]["content"]
+        logger.info(f"AI Response: {response_text[:200]}...")
+    except (KeyError, IndexError) as e:
+        logger.error(f"Failed to parse response: {e}")
+        logger.error(f"Raw result: {result}")
+        response_text = f"Error parsing response: {result}"
     
-    logger.info(f"RESPONSE: {text}")
-    logger.info("="*50)
-    return text
+    logger.info("=" * 60)
+    return response_text
 
+
+# --- GRADIO UI ---
 logger.info("Building Gradio Interface...")
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# CPU Chatbot")
     gr.Markdown(f"### Powered by {MODEL_NAME}")
-    gr.Markdown("Check Container Logs to see AI thinking!")
+    gr.Markdown("Check Container Logs to see detailed AI processing!")
     
     chatbot = gr.Chatbot(height=500)
     msg = gr.Textbox(placeholder="Ask me anything...", label="Your message")
@@ -105,7 +163,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         bot_respond, chatbot, chatbot
     )
 
+logger.info("Gradio Interface built successfully!")
+
 if __name__ == "__main__":
     logger.info("Launching Gradio App...")
     demo.launch()
-