Update app.py

app.py

@@ -2,27 +2,34 @@ import os
 import requests
 import gradio as gr
 
-# Set this environment variable before running:
-# export OPENROUTER_API_KEY="your_openrouter_api_key_here"
-API_KEY = os.getenv("Open_Router")
+# -------------------------
+# Configuration (edit here)
+# -------------------------
+# Option A (recommended): set an environment variable named OPENROUTER_API_KEY
+# Option B: paste your key directly (not recommended for production)
+API_KEY = os.getenv("Open_Router") or ""  # read from env
+# If you prefer to paste manually, replace the line above with e.g.
+# API_KEY = "sk-or-v1-your-openrouter-key-here"
+
 if not API_KEY:
-    raise ValueError("OPENROUTER_API_KEY not found. Please set it in your environment variables.")
+    raise ValueError(
+        "OPENROUTER_API_KEY not found. "
+        "Set it in your shell, or paste the key directly in the script (not recommended)."
+    )
 
-# OpenRouter API endpoint
 MODEL_URL = "https://openrouter.ai/api/v1/chat/completions"
-
 HEADERS = {
     "Authorization": f"Bearer {API_KEY}",
     "Content-Type": "application/json",
-    # Optional headers:
-    # "HTTP-Referer": "https://your-app-url.com",
-    # "X-Title": "LocoBot"
 }
 
-def query_gpt35(messages, max_tokens=500, temperature=0.7):
+# -------------------------
+# Helper: call OpenRouter
+# -------------------------
+def query_gpt35(messages, max_tokens=500, temperature=0.7, timeout=30):
     """
-    Send a list of messages (OpenAI-style) to OpenRouter and return assistant text.
-    messages: [{"role":"system"/"user"/"assistant", "content": "..."} , ...]
+    Send OpenAI-style messages to OpenRouter and return assistant text.
+    messages: list of {"role": "...", "content": "..."}
     """
     payload = {
         "model": "openai/gpt-3.5-turbo",
@@ -32,50 +39,67 @@ def query_gpt35(messages, max_tokens=500, temperature=0.7):
     }
 
     try:
-        resp = requests.post(MODEL_URL, headers=HEADERS, json=payload, timeout=30)
+        resp = requests.post(MODEL_URL, headers=HEADERS, json=payload, timeout=timeout)
         resp.raise_for_status()
         data = resp.json()
-        # OpenRouter's response format mirrors OpenAI ChatCompletion:
-        return data["choices"][0]["message"]["content"].strip()
+        # Support both typical "choices[0].message.content" and possible alternative formats
+        if "choices" in data and len(data["choices"]) > 0:
+            choice = data["choices"][0]
+            # Typical OpenAI-style response:
+            msg = choice.get("message", {}).get("content")
+            if msg:
+                return msg.strip()
+            # Fall back to 'text' or other fields if present
+            if "text" in choice:
+                return choice["text"].strip()
+        # fallback: try to find a top-level text
+        if isinstance(data, dict) and "text" in data:
+            return data["text"].strip()
+        return "Error: Unexpected response format from API"
     except requests.exceptions.RequestException as e:
         return f"Error: Could not connect to the API - {e}"
-    except (KeyError, IndexError):
-        return "Error: Unexpected response format from API"
+    except ValueError:
+        return "Error: Could not decode JSON response from API"
 
+# -------------------------
+# Gradio response function
+# -------------------------
 def respond(user_message, chat_history):
     """
-    Gradio will pass chat_history as a list of (user, bot) tuples.
-    We convert that to a messages list, append the new user message, query the model,
-    then append the assistant reply and return updated history.
+    Gradio passes chat_history as a list of (user, bot) tuples, or None.
+    Return updated history and an empty string to clear the input box.
     """
-    # Start with a system prompt to constrain behavior
+    if chat_history is None:
+        chat_history = []
+
+    # Build messages for the model
     messages = [
         {"role": "system", "content": "You are LocoBot, a helpful assistant. Answer concisely and politely."}
     ]
 
-    # Recreate prior conversation
-    if chat_history:
-        for user, bot in chat_history:
-            messages.append({"role": "user", "content": user})
-            messages.append({"role": "assistant", "content": bot})
+    # Re-add previous messages so model has context
+    for user, bot in chat_history:
+        messages.append({"role": "user", "content": user})
+        messages.append({"role": "assistant", "content": bot})
 
     # Add current user message
     messages.append({"role": "user", "content": user_message})
 
     assistant_reply = query_gpt35(messages)
 
-    # Update history for Gradio (list of tuples)
+    # Append to history and return (and clear the input textbox)
     new_history = chat_history + [(user_message, assistant_reply)]
     return new_history, ""
 
-# Build Gradio UI
+# -------------------------
+# Build and launch UI
+# -------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("## LocoBot — Your AI Companion (via OpenRouter GPT-3.5)")
+    gr.Markdown("## LocoBot — Your AI Companion (OpenRouter)")
     chatbot = gr.Chatbot()
-    message = gr.Textbox(placeholder="Type your message and press Enter")
+    message = gr.Textbox(placeholder="Type your message and press Enter", lines=2)
     send = gr.Button("Send")
 
-    # Hook up interactions
     send.click(fn=respond, inputs=[message, chatbot], outputs=[chatbot, message])
     message.submit(fn=respond, inputs=[message, chatbot], outputs=[chatbot, message])