Update app.py

app.py

@@ -5,6 +5,7 @@ import json
 import base64
 import logging
 import io
+from typing import List, Dict, Any, Union, Tuple, Optional
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -32,7 +33,14 @@ except ImportError:
 # API key
 OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "")
 
-# Complete model list with context sizes - as per requested list
+# Log API key status (masked for security)
+if OPENROUTER_API_KEY:
+    masked_key = OPENROUTER_API_KEY[:4] + "..." + OPENROUTER_API_KEY[-4:] if len(OPENROUTER_API_KEY) > 8 else "***"
+    logger.info(f"Using API key: {masked_key}")
+else:
+    logger.warning("No API key provided!")
+
+# Keep the existing model lists
 MODELS = [
     # 1M+ Context Models
     {"category": "1M+ Context", "models": [
@@ -146,17 +154,62 @@ for category in MODELS:
         if model not in ALL_MODELS:  # Avoid duplicates
             ALL_MODELS.append(model)
 
-def format_to_message_dict(history):
-    """Convert history to proper message format"""
-    messages = []
-    for pair in history:
-        if len(pair) == 2:
-            human, ai = pair
-            if human:
-                messages.append({"role": "user", "content": human})
-            if ai:
-                messages.append({"role": "assistant", "content": ai})
-    return messages
+# Helper functions moved to the top to avoid undefined references
+def filter_models(search_term):
+    """Filter models based on search term"""
+    if not search_term:
+        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
+    
+    filtered_models = [model[0] for model in ALL_MODELS if search_term.lower() in model[0].lower()]
+    
+    if filtered_models:
+        return filtered_models, filtered_models[0]
+    else:
+        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
+
+def update_context_display(model_name):
+    """Update context size display for the selected model"""
+    for model in ALL_MODELS:
+        if model[0] == model_name:
+            _, _, context_size = model
+            context_formatted = f"{context_size:,}"
+            return f"{context_formatted} tokens"
+    return "Unknown"
+
+def update_model_info(model_name):
+    """Generate HTML info display for the selected model"""
+    for model in ALL_MODELS:
+        if model[0] == model_name:
+            name, model_id, context_size = model
+            
+            # Check if this is a vision model
+            is_vision_model = False
+            for cat in MODELS:
+                if cat["category"] == "Vision Models":
+                    if any(m[0] == model_name for m in cat["models"]):
+                        is_vision_model = True
+                        break
+            
+            vision_badge = '<span style="background-color: #4CAF50; color: white; padding: 3px 6px; border-radius: 3px; font-size: 0.8em; margin-left: 5px;">Vision</span>' if is_vision_model else ''
+            
+            return f"""
+            <div class="model-info">
+                <h3>{name} {vision_badge}</h3>
+                <p><strong>Model ID:</strong> {model_id}</p>
+                <p><strong>Context Size:</strong> {context_size:,} tokens</p>
+                <p><strong>Provider:</strong> {model_id.split('/')[0]}</p>
+                {f'<p><strong>Features:</strong> Supports image understanding</p>' if is_vision_model else ''}
+            </div>
+            """
+    return "<p>Model information not available</p>"
+
+def update_category_models(category):
+    """Update model list based on selected category"""
+    for cat in MODELS:
+        if cat["category"] == category:
+            model_names = [model[0] for model in cat["models"]]
+            return model_names, model_names[0]
+    return [], ""
 
 def encode_image_to_base64(image_path):
     """Encode an image file to base64 string"""
@@ -166,7 +219,7 @@ def encode_image_to_base64(image_path):
                 encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
                 file_extension = image_path.split('.')[-1].lower()
                 mime_type = f"image/{file_extension}"
-                if file_extension == "jpg" or file_extension == "jpeg":
+                if file_extension in ["jpg", "jpeg"]:
                     mime_type = "image/jpeg"
                 elif file_extension == "png":
                     mime_type = "image/png"
@@ -204,8 +257,7 @@ def extract_text_from_file(file_path):
         
         elif file_extension == 'md':
             with open(file_path, 'r', encoding='utf-8') as file:
-                md_text = file.read()
-                return md_text
+                return file.read()
         
         elif file_extension == 'txt':
             with open(file_path, 'r', encoding='utf-8') as file:
@@ -252,7 +304,7 @@ def prepare_message_with_media(text, images=None, documents=None):
     content = [{"type": "text", "text": text}]
     
     # Add images if any
-    if images:
+    if images and any(img is not None for img in images):
         for img in images:
             if img is None:
                 continue
@@ -266,6 +318,18 @@ def prepare_message_with_media(text, images=None, documents=None):
     
     return content
 
+def format_to_message_dict(history):
+    """Convert history to proper message format"""
+    messages = []
+    for pair in history:
+        if len(pair) == 2:
+            human, ai = pair
+            if human:
+                messages.append({"role": "user", "content": human})
+            if ai:
+                messages.append({"role": "assistant", "content": ai})
+    return messages
+
 def process_uploaded_images(files):
     """Process uploaded image files - fixed for Gradio 4.44.1"""
     file_paths = []
@@ -274,37 +338,118 @@ def process_uploaded_images(files):
             file_paths.append(file.name)
     return file_paths
 
-def ask_ai(message, chatbot, model_choice, temperature, max_tokens, top_p, 
+def get_model_info(model_choice):
+    """Get model ID and context size from model name"""
+    for name, model_id_value, ctx_size in ALL_MODELS:
+        if name == model_choice:
+            return model_id_value, ctx_size
+    return None, 0
+
+def call_openrouter_api(payload):
+    """Make a call to OpenRouter API with error handling"""
+    try:
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "HTTP-Referer": "https://huggingface.co/spaces/cstr/CrispChat"
+            },
+            json=payload,
+            timeout=180  # Longer timeout for document processing
+        )
+        return response
+    except requests.RequestException as e:
+        logger.error(f"API request error: {str(e)}")
+        raise e
+
+def extract_ai_response(result):
+    """Extract AI response from OpenRouter API result"""
+    try:
+        if "choices" in result and len(result["choices"]) > 0:
+            if "message" in result["choices"][0]:
+                # Handle reasoning field if available
+                message = result["choices"][0]["message"]
+                if message.get("reasoning") and not message.get("content"):
+                    # Extract response from reasoning if there's no content
+                    reasoning = message.get("reasoning")
+                    # If reasoning contains the actual response, find it
+                    lines = reasoning.strip().split('\n')
+                    for line in lines:
+                        if line and not line.startswith('I should') and not line.startswith('Let me'):
+                            return line.strip()
+                    # If no clear response found, return the first non-empty line
+                    for line in lines:
+                        if line.strip():
+                            return line.strip()
+                return message.get("content", "")
+            elif "delta" in result["choices"][0]:
+                return result["choices"][0]["delta"].get("content", "")
+        
+        logger.error(f"Unexpected response structure: {result}")
+        return "Error: Could not extract response from API result"
+    except Exception as e:
+        logger.error(f"Error extracting AI response: {str(e)}")
+        return f"Error: {str(e)}"
+
+def streaming_handler(response, chatbot, message_idx):
+    """Handle streaming response from OpenRouter API"""
+    try:
+        for line in response.iter_lines():
+            if not line:
+                continue
+                
+            line = line.decode('utf-8')
+            if not line.startswith('data: '):
+                continue
+                
+            data = line[6:]
+            if data.strip() == '[DONE]':
+                break
+                
+            try:
+                chunk = json.loads(data)
+                if "choices" in chunk and len(chunk["choices"]) > 0:
+                    delta = chunk["choices"][0].get("delta", {})
+                    if "content" in delta and delta["content"]:
+                        chatbot[message_idx][1] += delta["content"]
+                        yield chatbot
+            except json.JSONDecodeError:
+                logger.error(f"Failed to parse JSON from chunk: {data}")
+    except Exception as e:
+        logger.error(f"Error in streaming handler: {str(e)}")
+        # Add error message to the current response
+        if len(chatbot) > message_idx:
+            chatbot[message_idx][1] += f"\n\nError during streaming: {str(e)}"
+            yield chatbot
+
+def ask_ai(message, history, model_choice, temperature, max_tokens, top_p, 
            frequency_penalty, presence_penalty, repetition_penalty, top_k, 
            min_p, seed, top_a, stream_output, response_format, 
            images, documents, reasoning_effort, system_message, transforms):
-    """Comprehensive AI query function with all parameters"""
+    """Redesigned AI query function with proper error handling for Gradio 4.44.1"""
+    # Validate input
     if not message.strip() and not images and not documents:
-        return chatbot, ""
+        return history
     
-    # Get model ID and context size
-    model_id = None
-    context_size = 0
-    for name, model_id_value, ctx_size in ALL_MODELS:
-        if name == model_choice:
-            model_id = model_id_value
-            context_size = ctx_size
-            break
-    
-    if model_id is None:
+    # Get model information
+    model_id, context_size = get_model_info(model_choice)
+    if not model_id:
         logger.error(f"Model not found: {model_choice}")
-        return chatbot + [[message, "Error: Model not found"]], ""
+        history.append((message, f"Error: Model '{model_choice}' not found"))
+        return history
+    
+    # Copy history to new list to avoid modifying the original
+    chat_history = list(history)
     
-    # Create messages from chatbot history
-    messages = format_to_message_dict(chatbot)
+    # Create messages from chat history
+    messages = format_to_message_dict(chat_history)
     
     # Add system message if provided
     if system_message and system_message.strip():
-        # Insert at the beginning to override any existing system message
-        for i, msg in enumerate(messages):
-            if msg.get("role") == "system":
-                messages.pop(i)
-                break
+        # Remove any existing system message
+        messages = [msg for msg in messages if msg.get("role") != "system"]
+        # Add new system message at the beginning
         messages.insert(0, {"role": "system", "content": system_message.strip()})
     
     # Prepare message with images and documents if any
@@ -313,237 +458,174 @@ def ask_ai(message, chatbot, model_choice, temperature, max_tokens, top_p,
     # Add current message
     messages.append({"role": "user", "content": content})
     
-    # Call API
-    try:
-        logger.info(f"Sending request to model: {model_id}")
-        
-        # Build the comprehensive payload with all parameters
-        payload = {
-            "model": model_id,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-            "top_p": top_p,
-            "frequency_penalty": frequency_penalty,
-            "presence_penalty": presence_penalty,
-            "repetition_penalty": repetition_penalty if repetition_penalty != 1.0 else None,
-            "top_k": top_k,
-            "min_p": min_p if min_p > 0 else None,
-            "seed": seed if seed > 0 else None,
-            "top_a": top_a if top_a > 0 else None,
-            "stream": stream_output
+    # Build the payload with all parameters
+    payload = {
+        "model": model_id,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "top_p": top_p,
+        "frequency_penalty": frequency_penalty,
+        "presence_penalty": presence_penalty,
+        "stream": stream_output
+    }
+    
+    # Add optional parameters if set
+    if repetition_penalty != 1.0:
+        payload["repetition_penalty"] = repetition_penalty
+    
+    if top_k > 0:
+        payload["top_k"] = top_k
+    
+    if min_p > 0:
+        payload["min_p"] = min_p
+    
+    if seed > 0:
+        payload["seed"] = seed
+    
+    if top_a > 0:
+        payload["top_a"] = top_a
+    
+    # Add response format if JSON is requested
+    if response_format == "json_object":
+        payload["response_format"] = {"type": "json_object"}
+    
+    # Add reasoning if selected
+    if reasoning_effort != "none":
+        payload["reasoning"] = {
+            "effort": reasoning_effort
         }
-        
-        # Add response format if not default
-        if response_format == "json_object":
-            payload["response_format"] = {"type": "json_object"}
-        
-        # Add reasoning if selected
-        if reasoning_effort != "none":
-            payload["reasoning"] = {
-                "effort": reasoning_effort
-            }
-        
-        # Add transforms if selected
-        if transforms:
-            payload["transforms"] = transforms
-        
-        # Remove None values
-        payload = {k: v for k, v in payload.items() if v is not None}
-        
-        logger.info(f"Request payload: {json.dumps(payload, default=str)}")
-        
-        response = requests.post(
-            "https://openrouter.ai/api/v1/chat/completions",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-                "HTTP-Referer": "https://huggingface.co/spaces/cstr/CrispStrobe"
-            },
-            json=payload,
-            timeout=180,  # Longer timeout for document processing and streaming
-            stream=stream_output
-        )
-        
+    
+    # Add transforms if selected
+    if transforms:
+        payload["transforms"] = transforms
+    
+    # Log the request
+    logger.info(f"Sending request to model: {model_id}")
+    logger.info(f"Request payload: {json.dumps(payload, default=str)}")
+    
+    try:
+        # Call OpenRouter API
+        response = call_openrouter_api(payload)
         logger.info(f"Response status: {response.status_code}")
         
+        # Handle streaming response
         if stream_output and response.status_code == 200:
-            # Handle streaming response
-            chatbot = chatbot + [[message, ""]]
+            # Add empty response slot to history
+            chat_history.append([message, ""])
+            
+            # Set up generator for streaming updates
+            def streaming_generator():
+                for updated_history in streaming_handler(response, chat_history, len(chat_history) - 1):
+                    yield updated_history
             
-            for line in response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data = line[6:]
-                        if data.strip() == '[DONE]':
-                            break
-                        try:
-                            chunk = json.loads(data)
-                            if "choices" in chunk and len(chunk["choices"]) > 0:
-                                delta = chunk["choices"][0].get("delta", {})
-                                if "content" in delta and delta["content"]:
-                                    chatbot[-1][1] += delta["content"]
-                                    yield chatbot, ""
-                        except json.JSONDecodeError:
-                            continue
-            return chatbot, ""
+            return streaming_generator()
         
+        # Handle normal response
         elif response.status_code == 200:
-            # Handle normal response
-            try:
-                result = response.json()
-                # Add detailed logging to debug what's in the response
-                logger.info(f"Response content: {result}")
-                
-                ai_response = ""
-                if "choices" in result and len(result["choices"]) > 0:
-                    if "message" in result["choices"][0]:
-                        ai_response = result["choices"][0]["message"].get("content", "")
-                    elif "delta" in result["choices"][0]:
-                        ai_response = result["choices"][0]["delta"].get("content", "")
-                    else:
-                        logger.error(f"Unexpected response structure: {result}")
-                        ai_response = "Error: Unexpected response structure from API"
-                else:
-                    logger.error(f"No choices in response: {result}")
-                    ai_response = "Error: No response received from the model"
-                
-                chatbot = chatbot + [[message, ai_response]]
-                
-                # Log token usage if available
-                if "usage" in result:
-                    logger.info(f"Token usage: {result['usage']}")
-            except Exception as e:
-                logger.error(f"Error processing response: {str(e)}")
-                logger.error(f"Response raw text: {response.text}")
-                chatbot = chatbot + [[message, f"Error processing response: {str(e)}"]]
+            result = response.json()
+            logger.info(f"Response content: {result}")
+            
+            # Extract AI response
+            ai_response = extract_ai_response(result)
+            
+            # Log token usage if available
+            if "usage" in result:
+                logger.info(f"Token usage: {result['usage']}")
+            
+            # Add response to history
+            chat_history.append([message, ai_response])
+            return chat_history
+        
+        # Handle error response
         else:
-            response_text = response.text
-            logger.info(f"Error response body: {response_text}")
-            error_message = f"Error: Status code {response.status_code}\n\nResponse: {response_text}"
-            chatbot = chatbot + [[message, error_message]]
+            error_message = f"Error: Status code {response.status_code}"
+            try:
+                response_data = response.json()
+                error_message += f"\n\nDetails: {json.dumps(response_data, indent=2)}"
+            except:
+                error_message += f"\n\nResponse: {response.text}"
+            
+            logger.error(error_message)
+            chat_history.append([message, error_message])
+            return chat_history
+            
     except Exception as e:
-        logger.error(f"Exception during API call: {str(e)}")
-        chatbot = chatbot + [[message, f"Error: {str(e)}"]]
-    
-    return chatbot, ""
+        error_message = f"Error: {str(e)}"
+        logger.error(f"Exception during API call: {error_message}")
+        chat_history.append([message, error_message])
+        return chat_history
 
 def clear_chat():
     """Reset all inputs"""
     return [], "", [], [], 0.7, 1000, 0.8, 0.0, 0.0, 1.0, 40, 0.1, 0, 0.0, False, "default", "none", "", []
 
-# Create requirements.txt content
-requirements = """
-gradio>=4.44.1
-requests>=2.28.1
-Pillow>=9.0.0
-PyPDF2>=3.0.0
-markdown>=3.4.1
-"""
-
-# Helper function to filter models
-def filter_models(search_term):
-    if not search_term:
-        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
-    
-    filtered_models = [model[0] for model in ALL_MODELS if search_term.lower() in model[0].lower()]
-    
-    if filtered_models:
-        return filtered_models, filtered_models[0]
-    else:
-        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
-
-# Helper function for context display
-def update_context_display(model_name):
-    for model in ALL_MODELS:
-        if model[0] == model_name:
-            _, _, context_size = model
-            context_formatted = f"{context_size:,}"
-            return f"{context_formatted} tokens"
-    return "Unknown"
-
-# Helper function for model info display
-# Update the model info display function to indicate vision capability
-def update_model_info(model_name):
-    for model in ALL_MODELS:
-        if model[0] == model_name:
-            name, model_id, context_size = model
-            
-            # Check if this is a vision model
-            is_vision_model = False
-            for cat in MODELS:
-                if cat["category"] == "Vision Models":
-                    if any(m[0] == model_name for m in cat["models"]):
-                        is_vision_model = True
-                        break
-            
-            vision_badge = '<span style="background-color: #4CAF50; color: white; padding: 3px 6px; border-radius: 3px; font-size: 0.8em; margin-left: 5px;">Vision</span>' if is_vision_model else ''
-            
-            return f"""
-            <div class="model-info">
-                <h3>{name} {vision_badge}</h3>
-                <p><strong>Model ID:</strong> {model_id}</p>
-                <p><strong>Context Size:</strong> {context_size:,} tokens</p>
-                <p><strong>Provider:</strong> {model_id.split('/')[0]}</p>
-                {f'<p><strong>Features:</strong> Supports image understanding</p>' if is_vision_model else ''}
-            </div>
-            """
-    return "<p>Model information not available</p>"
-
-# Helper function to update category models
-def update_category_models(category):
-    for cat in MODELS:
-        if cat["category"] == category:
-            model_names = [model[0] for model in cat["models"]]
-            return model_names, model_names[0]
-    return [], ""
-
-# Main application
 def create_app():
-    with gr.Blocks(css="""
-        .context-size { 
-            font-size: 0.9em;
-            color: #666;
-            margin-left: 10px;
-        }
-        footer { display: none !important; }
-        .model-selection-row {
-            display: flex;
-            align-items: center;
-        }
-        .parameter-grid {
-            display: grid;
-            grid-template-columns: 1fr 1fr;
-            gap: 10px;
-        }
-    """) as demo:
+    """Create the Gradio application with improved UI and response handling"""
+    with gr.Blocks(
+        title="CrispChat - AI Assistant",
+        css="""
+            .context-size { 
+                font-size: 0.9em;
+                color: #666;
+                margin-left: 10px;
+            }
+            footer { display: none !important; }
+            .model-selection-row {
+                display: flex;
+                align-items: center;
+            }
+            .parameter-grid {
+                display: grid;
+                grid-template-columns: 1fr 1fr;
+                gap: 10px;
+            }
+            .vision-badge {
+                background-color: #4CAF50;
+                color: white;
+                padding: 3px 6px;
+                border-radius: 3px;
+                font-size: 0.8em;
+                margin-left: 5px;
+            }
+        """
+    ) as demo:
         gr.Markdown("""
-        # Enhanced AI Chat
+        # CrispChat AI Assistant
         
         Chat with various AI models from OpenRouter with support for images and documents.
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
+                # Chatbot interface - properly configured for Gradio 4.44.1
                 chatbot = gr.Chatbot(
                     height=500, 
                     show_copy_button=True, 
                     show_label=False,
-                    # avatar_images=(None, "https://upload.wikimedia.org/wikipedia/commons/0/04/ChatGPT_logo.svg"),
-                    type="messages"  # Fixed: Use messages format instead of tuples
+                    avatar_images=(None, "https://upload.wikimedia.org/wikipedia/commons/0/04/ChatGPT_logo.svg"),
+                    render=True,  # Explicitly enable rendering
+                    elem_id="chat-window"  # Add elem_id for debugging
+                )
+                
+                # Debug output for development
+                debug_output = gr.JSON(
+                    label="Debug Output (Hidden in Production)",
+                    visible=False
                 )
                 
                 with gr.Row():
                     message = gr.Textbox(
                         placeholder="Type your message here...",
                         label="Message",
-                        lines=2
+                        lines=2,
+                        elem_id="message-input",  # Add elem_id for debugging
+                        scale=4
                     )
                 
                 with gr.Row():
                     with gr.Column(scale=3):
-                        submit_btn = gr.Button("Send", variant="primary")
+                        submit_btn = gr.Button("Send", variant="primary", elem_id="send-btn")
                     
                     with gr.Column(scale=1):
                         clear_btn = gr.Button("Clear Chat", variant="secondary")
@@ -588,7 +670,8 @@ def create_app():
                         model_choice = gr.Dropdown(
                             [model[0] for model in ALL_MODELS],
                             value=ALL_MODELS[0][0],
-                            label="Model"
+                            label="Model",
+                            elem_id="model-choice"  # Add elem_id for debugging
                         )
                         context_display = gr.Textbox(
                             value=update_context_display(ALL_MODELS[0][0]),
@@ -740,7 +823,7 @@ def create_app():
                 # Add a model information section
                 with gr.Accordion("About Selected Model", open=False):
                     model_info_display = gr.HTML(
-                        value="<p>Select a model to see details</p>"
+                        value=update_model_info(ALL_MODELS[0][0])
                     )
         
         # Add usage instructions
@@ -770,12 +853,16 @@ def create_app():
         # Add a footer with version info
         footer_md = gr.Markdown("""
         ---
-        ### CrispChat v1.0
-        Built with ❤️ using Gradio and OpenRouter API | Context sizes shown next to model names
+        ### CrispChat v1.1
+        Built with ❤️ using Gradio 4.44.1 and OpenRouter API | Context sizes shown next to model names
         """)
-
         
-
+        # Define a test function for debugging
+        def test_chatbot(test_message):
+            """Simple test function to verify chatbot updates work"""
+            logger.info(f"Test function called with: {test_message}")
+            return [[test_message, "This is a test response to verify the chatbot is working"]]
+        
         # Connect model search to dropdown filter
         model_search.change(
             fn=filter_models,
@@ -827,8 +914,12 @@ def create_app():
                 top_k, min_p, seed, top_a, stream_output, response_format,
                 images, documents, reasoning_effort, system_message, transforms
             ],
-            outputs=[chatbot, message],
-            api_name=False  # ensure direct function calling
+            outputs=chatbot,
+            show_progress="minimal",
+        ).then(
+            fn=lambda: "",  # Clear message box after sending
+            inputs=None,
+            outputs=message
         )
         
         # Set up events for message submission (pressing Enter)
@@ -840,8 +931,12 @@ def create_app():
                 top_k, min_p, seed, top_a, stream_output, response_format,
                 images, documents, reasoning_effort, system_message, transforms
             ],
-            outputs=[chatbot, message],
-            api_name=False  # ensure direct function calling
+            outputs=chatbot,
+            show_progress="minimal",
+        ).then(
+            fn=lambda: "",  # Clear message box after sending
+            inputs=None,
+            outputs=message
         )
         
         # Set up events for the clear button
@@ -856,10 +951,30 @@ def create_app():
             ]
         )
         
+        # Debug button (hidden in production)
+        debug_btn = gr.Button("Debug Chatbot", visible=False)
+        debug_btn.click(
+            fn=test_chatbot,
+            inputs=[message],
+            outputs=[chatbot]
+        )
+        
+        # Enable debugging for key components
+        gr.debug(chatbot)
+        
         return demo
 
-
 # Launch the app
 if __name__ == "__main__":
+    # Check API key before starting
+    if not OPENROUTER_API_KEY:
+        logger.warning("WARNING: OPENROUTER_API_KEY environment variable is not set")
+        print("WARNING: OpenRouter API key not found. Set OPENROUTER_API_KEY environment variable.")
+    
     demo = create_app()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        debug=True,
+        show_error=True
+    )