Update app.py

app.py

@@ -1,58 +1,126 @@
 # app.py
 import os
+import sys
 import asyncio
+import subprocess
+import shutil
 from dotenv import load_dotenv
+
+# third-party imports (must be in requirements.txt)
 import chainlit as cl
 import google.generativeai as genai
 
-# Load environment variables from .env
+# Load environment variables from .env if present
 load_dotenv()
-API_KEY = os.getenv("GOOGLE_API_KEY")
-MODEL_NAME = os.getenv("MODEL_NAME", "gemini-2.0-flash")
 
+# Required env var: GOOGLE_API_KEY
+API_KEY = os.getenv("GOOGLE_API_KEY")
 if not API_KEY:
-    raise RuntimeError("GOOGLE_API_KEY not set in environment or .env")
+    raise RuntimeError("GOOGLE_API_KEY is not set. Add it to the environment or .env file.")
 
-# Configure Google Generative AI
+# Optional: choose model via env, default to gemini-2.0-flash
+MODEL_NAME = os.getenv("MODEL_NAME", "gemini-2.0-flash")
+PORT = int(os.getenv("PORT", 8000))
+
+# Configure the Google Generative client
 genai.configure(api_key=API_KEY)
 
-# Create model once at import time
-model = genai.GenerativeModel(MODEL_NAME)
+# Instantiate model at import time (so handlers can reference it)
+try:
+    model = genai.GenerativeModel(MODEL_NAME)
+except Exception as e:
+    # If model initialization fails at import, keep model None but register handlers
+    model = None
+    print(f"[Warning] Failed to initialize GenerativeModel('{MODEL_NAME}') at import time: {e}", file=sys.stderr)
+
+# Simple system prompt used for per-session history (optional)
+SYSTEM_PROMPT = "You are a helpful, friendly AI assistant. Provide clear and concise answers."
 
-# Optional system prompt
-SYSTEM_PROMPT = "You are a helpful, friendly AI assistant. Provide clear and concise responses."
+# Helper to run blocking model.generate_content in a background thread
+async def _generate_content_in_thread(prompt_text: str):
+    if model is None:
+        raise RuntimeError("Generative model not initialized.")
+    # run blocking call in thread
+    return await asyncio.to_thread(model.generate_content, prompt_text)
 
+# Register a welcome message per new chat session
 @cl.on_chat_start
-async def start():
-    # Initialize per-session message history if you want
+async def on_chat_start():
+    # initialize message history for this user session (optional bookkeeping)
     cl.user_session.set("message_history", [{"role": "system", "content": SYSTEM_PROMPT}])
-    await cl.Message(content="Hello! I'm your Gemini-powered assistant. Ask me anything!").send()
+    await cl.Message(content="Hello! I'm your Gemini-powered assistant. Ask me anything.").send()
 
+# Main message handler
 @cl.on_message
 async def handle_message(message: cl.Message):
-    text = (message.content or "").strip()
-    if not text:
-        await cl.Message(content="Please type something to ask.").send()
+    user_text = (message.content or "").strip()
+    if not user_text:
+        await cl.Message(content="Please type a question or prompt.").send()
         return
 
-    # Get session history (optional: used only for bookkeeping)
-    message_history = cl.user_session.get("message_history", [])
-    message_history.append({"role": "user", "content": text})
-    cl.user_session.set("message_history", message_history)
+    # Optionally keep a local session history (not sent to model in this simple generate_content flow,
+    # but useful for UI/logging)
+    history = cl.user_session.get("message_history", [])
+    history.append({"role": "user", "content": user_text})
+    cl.user_session.set("message_history", history)
+
+    # Prepare an empty message so we can update progressively if desired.
+    progress_msg = cl.Message(content="(Thinking...)")
+    await progress_msg.send()
 
-    # Use generate_content (simple single-response call).
-    # Run the blocking call in a thread to avoid blocking Chainlit's event loop.
     try:
-        resp = await asyncio.to_thread(model.generate_content, text)
-        reply = getattr(resp, "text", None) or str(resp)
+        # Call the blocking generation in a background thread to avoid blocking the event loop.
+        resp = await _generate_content_in_thread(user_text)
+
+        # defensive: many responses expose .text
+        reply_text = getattr(resp, "text", None) or str(resp)
+
     except Exception as e:
-        reply = f"[Error calling Gemini API] {e}"
+        reply_text = f"[Error calling Gemini API] {e}"
+
+    # Send final reply (update the progress message)
+    try:
+        progress_msg.content = reply_text
+        await progress_msg.update()
+    except Exception:
+        # If update fails, send a new message
+        await cl.Message(content=reply_text).send()
 
-    # send reply and add to history
-    await cl.Message(content=reply).send()
-    message_history.append({"role": "assistant", "content": reply})
-    cl.user_session.set("message_history", message_history)
+    # Save assistant reply to session history
+    history.append({"role": "assistant", "content": reply_text})
+    cl.user_session.set("message_history", history)
 
-# NOTE: Do not call cl.run() if you will use the CLI `chainlit run app.py`.
+
+# When launched directly (python app.py), start the Chainlit CLI as a subprocess.
+# This avoids calling cl.run() directly and is compatible with hosting environments
+# (like Hugging Face Spaces) that run the script.
 if __name__ == "__main__":
-    cl.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8000)))
+    # Prefer using the same Python interpreter to run python -m chainlit so module paths match.
+    # First check if 'chainlit' CLI is available
+    cli_path = shutil.which("chainlit")
+
+    # Build the CLI command: prefer "python -m chainlit run app.py" for environment consistency
+    if cli_path is None:
+        # fallback to python -m chainlit
+        cmd = [sys.executable, "-m", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", str(PORT)]
+    else:
+        # If chainlit CLI is on PATH, call it directly
+        cmd = [cli_path, "run", "app.py", "--host", "0.0.0.0", "--port", str(PORT)]
+
+    print("Starting Chainlit via CLI command:", " ".join(cmd), file=sys.stderr)
+
+    # Launch the CLI as a subprocess. This blocks until process exits.
+    # On hosted platforms the parent process will be monitored/killed by the host as usual.
+    try:
+        # Use exec-like run so SIGINT/G signals behave reasonably
+        return_code = subprocess.call(cmd)
+        if return_code != 0:
+            print(f"[chainlit exit] process returned code: {return_code}", file=sys.stderr)
+            sys.exit(return_code)
+    except FileNotFoundError as fnf:
+        print("[Error] chainlit CLI not found and python -m chainlit failed.", file=sys.stderr)
+        print("Ensure chainlit is installed in the environment (pip install chainlit).", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"[Error] Failed to launch Chainlit CLI: {e}", file=sys.stderr)
+        sys.exit(1)