Update app.py

app.py

@@ -1,76 +1,44 @@
 import os
-import base64
 import gradio as gr
 import requests
 import json
-from io import BytesIO
-from PIL import Image
 
-# Get API key from environment variable for security
+# API key
 OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "")
 
-# 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"),
-    ("Meta Llama 3.2 Vision", "meta-llama/llama-3.2-11b-vision-instruct:free"),
-    ("Qwen 2.5 VL", "qwen/qwen2.5-vl-72b-instruct:free"),
-    ("DeepSeek R1", "deepseek/deepseek-r1:free"),
-    ("Mistral 3.1", "mistralai/mistral-small-3.1-24b-instruct:free")
+# Basic model list
+MODELS = [
+    ("Gemini Pro 2.0", "google/gemini-2.0-pro-exp-02-05:free"),
+    ("Llama 3.2 Vision", "meta-llama/llama-3.2-11b-vision-instruct:free")
 ]
 
-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])
+def ask_ai(message, history, model_choice):
+    """Basic AI query function"""
+    # Get model ID
+    model_id = MODELS[0][1]  # Default
+    for name, model_id_value in MODELS:
+        if name == model_choice:
+            model_id = model_id_value
+            break
     
-    # Prepare messages
+    # Create messages from history
     messages = []
-    for human, ai in history:
-        messages.append({"role": "user", "content": human})
-        if ai:
-            messages.append({"role": "assistant", "content": ai})
+    for human_msg, ai_msg in history:
+        messages.append({"role": "user", "content": human_msg})
+        if ai_msg:
+            messages.append({"role": "assistant", "content": ai_msg})
     
-    # Handle file
-    if file is not None:
-        try:
-            with open(file.name, 'r', encoding='utf-8') as f:
-                file_content = f.read()
-                message = f"{message}\n\nFile content:\n```\n{file_content}\n```"
-        except Exception as e:
-            message = f"{message}\n\nError reading file: {str(e)}"
+    # Add current message
+    messages.append({"role": "user", "content": message})
     
-    # Handle image
-    if image is not None:
-        try:
-            buffered = BytesIO()
-            image.save(buffered, format="JPEG")
-            base64_image = base64.b64encode(buffered.getvalue()).decode("utf-8")
-            
-            content = [
-                {"type": "text", "text": message},
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/jpeg;base64,{base64_image}"
-                    }
-                }
-            ]
-            messages.append({"role": "user", "content": content})
-        except Exception as e:
-            messages.append({"role": "user", "content": message})
-            return f"Error processing image: {str(e)}"
-    else:
-        messages.append({"role": "user", "content": message})
-    
-    # API call
+    # Call API
     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",
+                "HTTP-Referer": "https://huggingface.co/spaces"
             },
             json={
                 "model": model_id,
@@ -80,156 +48,35 @@ def get_ai_response(message, history, model_name, image=None, file=None):
             },
             timeout=60
         )
-        response.raise_for_status()
-        
-        result = response.json()
-        return result.get("choices", [{}])[0].get("message", {}).get("content", "No response")
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def clear_inputs():
-    """Clear input fields"""
-    return "", None, None
-
-with gr.Blocks() as demo:
-    gr.Markdown("# 🔆 CrispChat")
-    
-    chatbot = gr.Chatbot(
-        height=450,
-        type="messages"  # Use the new format as suggested in the warning
-    )
-    
-    model_selector = gr.Dropdown(
-        choices=[name for name, _ in models],
-        value=models[0][0],
-        label="Model"
-    )
-    
-    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_btn = gr.Button("Send")
-        clear_btn = gr.Button("Clear Chat")
-    
-    # Define clear function
-    def clear_chat():
-        return []
-    
-    # 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_input.submit(
-        fn=submit_message,
-        inputs=[msg_input, chatbot, model_selector, img_input, file_input],
-        outputs=[chatbot, msg_input, img_input, file_input]
-    )
-    
-    clear_btn.click(
-        fn=clear_chat,
-        outputs=[chatbot]
-    )
-
-# FastAPI endpoint
-from fastapi import FastAPI
-from pydantic import BaseModel
-
-app = FastAPI()
-
-class GenerateRequest(BaseModel):
-    message: str
-    model: str = None
-    image_data: str = None
-
-@app.post("/api/generate")
-async def api_generate(request: GenerateRequest):
-    """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)}"}
+        if response.status_code == 200:
+            result = response.json()
+            ai_response = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+            history.append((message, ai_response))
         else:
-            messages.append({"role": "user", "content": request.message})
-        
-        # API call
-        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",
-            },
-            json={
-                "model": model_id,
-                "messages": messages,
-                "temperature": 0.7
-            },
-            timeout=60
-        )
-        response.raise_for_status()
-        
-        result = response.json()
-        reply = result.get("choices", [{}])[0].get("message", {}).get("content", "No response")
-        
-        return {"response": reply}
+            history.append((message, f"Error: Status code {response.status_code}"))
     except Exception as e:
-        return {"error": f"Error: {str(e)}"}
+        history.append((message, f"Error: {str(e)}"))
+    
+    return history, ""
 
-# Mount Gradio app
-app = gr.mount_gradio_app(app, demo, path="/")
+# Create minimal interface
+demo = gr.Interface(
+    fn=ask_ai,
+    inputs=[
+        gr.Textbox(placeholder="Type your message here...", label="Message"),
+        gr.State([]),
+        gr.Radio([name for name, _ in MODELS], value=MODELS[0][0], label="Model")
+    ],
+    outputs=[
+        gr.Chatbot(label="Conversation", height=500, type="messages"),
+        gr.Textbox(visible=False)
+    ],
+    title="Simple AI Chat",
+    description="A minimalist chat interface for OpenRouter AI models",
+    allow_flagging="never"
+)
 
-# Launch
+# Launch directly with Gradio's built-in server
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)