Update app.py

app.py

@@ -9,7 +9,7 @@ from PIL import Image
 # Get API key from environment variable for security
 OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "")
 
-# Simplified model list
+# Model list
 models = [
     ("Google Gemini Pro 2.0", "google/gemini-2.0-pro-exp-02-05:free"),
     ("Google Gemini 2.5 Pro", "google/gemini-2.5-pro-exp-03-25:free"),
@@ -19,20 +19,20 @@ models = [
     ("Mistral 3.1", "mistralai/mistral-small-3.1-24b-instruct:free")
 ]
 
-def get_response(message, history, model_name, image=None, file=None):
-    """Simple function to get response from API"""
-    # Find model ID from name
+def get_ai_response(message, history, model_name, image=None, file=None):
+    """Get response from AI"""
+    # Find model ID
     model_id = next((mid for name, mid in models if name == model_name), models[0][1])
     
-    # Format messages from history
+    # Prepare messages
     messages = []
     for human, ai in history:
         messages.append({"role": "user", "content": human})
-        if ai:  # Only add if there's a response
+        if ai:
             messages.append({"role": "assistant", "content": ai})
     
-    # Process file if provided
-    if file:
+    # Handle file
+    if file is not None:
         try:
             with open(file.name, 'r', encoding='utf-8') as f:
                 file_content = f.read()
@@ -40,15 +40,13 @@ def get_response(message, history, model_name, image=None, file=None):
         except Exception as e:
             message = f"{message}\n\nError reading file: {str(e)}"
     
-    # Process image if provided
+    # Handle image
     if image is not None:
         try:
-            # Convert image to base64
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             base64_image = base64.b64encode(buffered.getvalue()).decode("utf-8")
             
-            # Create multimodal content
             content = [
                 {"type": "text", "text": message},
                 {
@@ -60,94 +58,104 @@ def get_response(message, history, model_name, image=None, file=None):
             ]
             messages.append({"role": "user", "content": content})
         except Exception as e:
-            messages.append({"role": "user", "content": f"{message}\n\nError processing image: {str(e)}"})
+            messages.append({"role": "user", "content": message})
+            return f"Error processing image: {str(e)}"
     else:
         messages.append({"role": "user", "content": message})
     
-    # Make API call (non-streaming for reliability)
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "HTTP-Referer": "https://huggingface.co/spaces",
-    }
-    
-    data = {
-        "model": model_id,
-        "messages": messages,
-        "temperature": 0.7,
-        "max_tokens": 1000
-    }
-    
+    # API call
     try:
         response = requests.post(
             "https://openrouter.ai/api/v1/chat/completions",
-            headers=headers,
-            json=data,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "HTTP-Referer": "https://huggingface.co/spaces",
+            },
+            json={
+                "model": model_id,
+                "messages": messages,
+                "temperature": 0.7,
+                "max_tokens": 1000
+            },
             timeout=60
         )
         response.raise_for_status()
         
         result = response.json()
-        reply = result.get("choices", [{}])[0].get("message", {}).get("content", "No response")
-        
-        return reply
+        return result.get("choices", [{}])[0].get("message", {}).get("content", "No response")
     except Exception as e:
         return f"Error: {str(e)}"
 
-# Create ultra simple interface
+def clear_inputs():
+    """Clear input fields"""
+    return "", None, None
+
 with gr.Blocks() as demo:
     gr.Markdown("# 🔆 CrispChat")
     
-    chatbot = gr.Chatbot(height=450)
+    chatbot = gr.Chatbot(
+        height=450,
+        type="messages"  # Use the new format as suggested in the warning
+    )
     
-    with gr.Row():
-        with gr.Column(scale=3):
-            msg = gr.Textbox(
-                placeholder="Type your message here...",
-                lines=3,
-                label="Message"
-            )
-        
-        with gr.Column(scale=1):
-            model = gr.Dropdown(
-                choices=[name for name, _ in models],
-                value=models[0][0],
-                label="Model"
-            )
+    model_selector = gr.Dropdown(
+        choices=[name for name, _ in models],
+        value=models[0][0],
+        label="Model"
+    )
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            img = gr.Image(type="pil", label="Image (optional)")
-        
-        with gr.Column(scale=1):
-            file = gr.File(label="Text File (optional)")
+    msg_input = gr.Textbox(
+        placeholder="Type your message here...",
+        lines=3,
+        label="Message"
+    )
+    
+    img_input = gr.Image(
+        type="pil", 
+        label="Image (optional)"
+    )
+    
+    file_input = gr.File(
+        label="Text File (optional)"
+    )
     
     with gr.Row():
-        submit = gr.Button("Send")
-        clear = gr.Button("Clear")
+        submit_btn = gr.Button("Send")
+        clear_btn = gr.Button("Clear Chat")
+    
+    # Define clear function
+    def clear_chat():
+        return []
     
-    # Events
-    submit.click(
-        fn=get_response,
-        inputs=[msg, chatbot, model, img, file],
-        outputs=chatbot
-    ).then(
-        lambda: "", None, None,
-        outputs=[msg, img, file]
+    # Submit function
+    def submit_message(message, chat_history, model, image, file):
+        if not message and not image and not file:
+            return chat_history, "", None, None
+        
+        response = get_ai_response(message, chat_history, model, image, file)
+        chat_history.append((message, response))
+        return chat_history, "", None, None
+    
+    # Set up events
+    submit_btn.click(
+        fn=submit_message,
+        inputs=[msg_input, chatbot, model_selector, img_input, file_input],
+        outputs=[chatbot, msg_input, img_input, file_input]
     )
     
-    msg.submit(
-        fn=get_response,
-        inputs=[msg, chatbot, model, img, file],
-        outputs=chatbot
-    ).then(
-        lambda: "", None, None,
-        outputs=[msg, img, file]
+    msg_input.submit(
+        fn=submit_message,
+        inputs=[msg_input, chatbot, model_selector, img_input, file_input],
+        outputs=[chatbot, msg_input, img_input, file_input]
     )
     
-    clear.click(lambda: [], outputs=chatbot)
+    clear_btn.click(
+        fn=clear_chat,
+        outputs=[chatbot]
+    )
 
-# Define FastAPI endpoint
+# FastAPI endpoint
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -160,56 +168,53 @@ class GenerateRequest(BaseModel):
 
 @app.post("/api/generate")
 async def api_generate(request: GenerateRequest):
-    """Simple API endpoint"""
-    model_id = request.model or models[0][1]
-    
-    messages = []
-    
-    # Process image if provided
-    if request.image_data:
-        try:
-            # Decode base64 image
-            image_bytes = base64.b64decode(request.image_data)
-            image = Image.open(BytesIO(image_bytes))
-            
-            # Re-encode to ensure proper format
-            buffered = BytesIO()
-            image.save(buffered, format="JPEG")
-            base64_image = base64.b64encode(buffered.getvalue()).decode("utf-8")
-            
-            content = [
-                {"type": "text", "text": request.message},
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/jpeg;base64,{base64_image}"
-                    }
-                }
-            ]
-            messages.append({"role": "user", "content": content})
-        except Exception as e:
-            return {"error": f"Image processing error: {str(e)}"}
-    else:
-        messages.append({"role": "user", "content": request.message})
-    
-    # Make API call
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "HTTP-Referer": "https://huggingface.co/spaces",
-    }
-    
-    data = {
-        "model": model_id,
-        "messages": messages,
-        "temperature": 0.7
-    }
-    
+    """API endpoint for text generation"""
     try:
+        model_id = request.model or models[0][1]
+        
+        # Prepare messages
+        messages = []
+        
+        # Handle image
+        if request.image_data:
+            try:
+                # Decode base64 image
+                image_bytes = base64.b64decode(request.image_data)
+                image = Image.open(BytesIO(image_bytes))
+                
+                # Re-encode
+                buffered = BytesIO()
+                image.save(buffered, format="JPEG")
+                base64_image = base64.b64encode(buffered.getvalue()).decode("utf-8")
+                
+                content = [
+                    {"type": "text", "text": request.message},
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_image}"
+                        }
+                    }
+                ]
+                messages.append({"role": "user", "content": content})
+            except Exception as e:
+                return {"error": f"Image processing error: {str(e)}"}
+        else:
+            messages.append({"role": "user", "content": request.message})
+        
+        # API call
         response = requests.post(
             "https://openrouter.ai/api/v1/chat/completions",
-            headers=headers,
-            json=data,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "HTTP-Referer": "https://huggingface.co/spaces",
+            },
+            json={
+                "model": model_id,
+                "messages": messages,
+                "temperature": 0.7
+            },
             timeout=60
         )
         response.raise_for_status()
@@ -224,7 +229,7 @@ async def api_generate(request: GenerateRequest):
 # Mount Gradio app
 app = gr.mount_gradio_app(app, demo, path="/")
 
-# Launch the app
+# Launch
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)