Refactor app.py: enhance BotConfig and BotClient classes, streamline environment variable validation, and improve message handling for better clarity and functionality.

app.py

@@ -7,424 +7,348 @@ import re
 import json
 import time
 import random
+from concurrent.futures import ThreadPoolExecutor
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import PlainTextResponse, JSONResponse
 from FLUX import generate_image
 from VoiceReply import generate_voice_reply
 from polLLM import generate_llm
 
-# Configure logging
-logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s")
+# --- Configuration and Client Classes ---
+
+class BotConfig:
+    GREEN_API_URL         = os.getenv("GREEN_API_URL")
+    GREEN_API_MEDIA_URL   = os.getenv("GREEN_API_MEDIA_URL", "https://api.green-api.com")
+    GREEN_API_TOKEN       = os.getenv("GREEN_API_TOKEN")
+    GREEN_API_ID_INSTANCE = os.getenv("GREEN_API_ID_INSTANCE")
+    WEBHOOK_AUTH_TOKEN    = os.getenv("WEBHOOK_AUTH_TOKEN")
+    BOT_GROUP_CHAT        = "[email protected]"
+    IMAGE_DIR             = "/tmp/images"
+    AUDIO_DIR             = "/tmp/audio"
+
+    @classmethod
+    def validate(cls):
+        if not all([cls.GREEN_API_URL, cls.GREEN_API_TOKEN, cls.GREEN_API_ID_INSTANCE, cls.WEBHOOK_AUTH_TOKEN]):
+            raise ValueError("Environment variables are not set properly")
+
+class BotClient:
+    def __init__(self, cfg: BotConfig):
+        self.cfg = cfg
+        self.session = requests.Session()
+        logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s")
+
+    def send(self, endpoint: str, payload: dict, files=None, retries=3):
+        url = f"{self.cfg.GREEN_API_URL}/waInstance{self.cfg.GREEN_API_ID_INSTANCE}/{endpoint}/{self.cfg.GREEN_API_TOKEN}"
+        for attempt in range(1, retries + 1):
+            try:
+                resp = self.session.post(url, json=payload if files is None else None, data=None if files is None else payload, files=files)
+                resp.raise_for_status()
+                return resp.json()
+            except requests.RequestException as e:
+                logging.warning(f"Attempt {attempt}/{retries} failed for {endpoint}: {e}")
+                if attempt == retries:
+                    logging.error(f"{endpoint} ultimately failed: {e}")
+                    return {"error": str(e)}
+
+    def send_message(self, message_id: str, chat_id: str, text: str):
+        payload = {"chatId": chat_id, "message": text, "quotedMessageId": message_id}
+        return self.send(f"sendMessage", payload)
+
+    def send_message_to(self, chat_id: str, text: str):
+        payload = {"chatId": chat_id, "message": text}
+        return self.send(f"sendMessage", payload)
+
+    def send_media(self, message_id: str, chat_id: str, file_path: str, caption: str, media_type: str):
+        endpoint = "sendFileByUpload"
+        payload = {"chatId": chat_id, "caption": caption, "quotedMessageId": message_id}
+        with open(file_path, "rb") as f:
+            mime = "image/jpeg" if media_type == "image" else "audio/mpeg"
+            files = [("file", (os.path.basename(file_path), f, mime))]
+            return self.send(endpoint, payload, files=files)
+
+# Validate env
+BotConfig.validate()
+client = BotClient(BotConfig)
+
+# --- Queues, stores, and threading ---
 
-# Env vars
-GREEN_API_URL         = os.getenv("GREEN_API_URL")
-GREEN_API_MEDIA_URL   = os.getenv("GREEN_API_MEDIA_URL", "https://api.green-api.com")
-GREEN_API_TOKEN       = os.getenv("GREEN_API_TOKEN")
-GREEN_API_ID_INSTANCE = os.getenv("GREEN_API_ID_INSTANCE")
-WEBHOOK_AUTH_TOKEN    = os.getenv("WEBHOOK_AUTH_TOKEN")
-BOT_GROUP_CHAT       = "[email protected]"  # Chat ID for system messages
-image_dir             = "/tmp/images"
-audio_dir             = "/tmp/audio"
-
-if not all([GREEN_API_URL, GREEN_API_TOKEN, GREEN_API_ID_INSTANCE, WEBHOOK_AUTH_TOKEN]):
-    raise ValueError("Environment variables are not set properly")
-
-# Queues & in‑memory stores
 task_queue   = queue.Queue()
-trivia_store = {}   # chat_id → {"question":…, "answer":…}
-polls        = {}   # chat_id → {"question":…, "options": […], "votes": {1: 0, ...}, "voters": {jid: opt}}
+trivia_store = {}
+polls        = {}
 
-app = FastAPI()
-
-# Global inactivity tracker
 last_message_time = time.time()
 
-# --- Inactivity Monitor ---
+# Inactivity monitor
 def inactivity_monitor():
     global last_message_time
     while True:
-        time.sleep(60)  # check every minute
-        if time.time() - last_message_time >= 300:  # 5 minutes inactivity
-            if BOT_GROUP_CHAT:
-                reminder = "⏰ I haven't heard from you in a while! I'm still here if you need anything."
-                send_message("inactivity", BOT_GROUP_CHAT, reminder)
+        time.sleep(60)
+        if time.time() - last_message_time >= 300:
+            client.send_message_to(BotConfig.BOT_GROUP_CHAT,
+                                   "⏰ I haven't heard from you in a while! I'm still here if you need anything.")
             last_message_time = time.time()
 
 threading.Thread(target=inactivity_monitor, daemon=True).start()
 
-# --- Background Worker ---
+# Worker pool
+executor = ThreadPoolExecutor(max_workers=4)
+
 def worker():
     while True:
         task = task_queue.get()
         try:
-            typ = task["type"]
-            mid = task["message_id"]
-            cid = task["chat_id"]
-            if typ == "image":
-                handle_image_generation(mid, cid, task["prompt"])
-            elif typ == "audio":
-                response_audio(mid, cid, task["prompt"])
+            if task["type"] == "image":
+                handle_image_generation(task["message_id"], task["chat_id"], task["prompt"])
+            elif task["type"] == "audio":
+                response_audio(task["message_id"], task["chat_id"], task["prompt"])
         except Exception as e:
-            logging.error(f"Error processing {task}: {e}")
+            logging.error(f"Error in worker for task {task}: {e}")
         finally:
             task_queue.task_done()
 
-threading.Thread(target=worker, daemon=True).start()
+for _ in range(4):
+    threading.Thread(target=worker, daemon=True).start()
 
-# --- send helpers ---
-def send_message_to_chat(to_number, message, retries=3):
-    chat_id = to_number if to_number.endswith("@g.us") else to_number
-    url = f"{GREEN_API_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendMessage/{GREEN_API_TOKEN}"
-    payload = {"chatId": chat_id, "message": message}
-    for i in range(retries):
-        try:
-            r = requests.post(url, json=payload)
-            r.raise_for_status()
-            return r.json()
-        except requests.RequestException as e:
-            if i == retries - 1:
-                logging.error("send_message_to_chat failed: %s", str(e))
-                return {"error": str(e)}
-
-def send_message(message_id, to_number, message, retries=3):
-    chat_id = to_number if to_number.endswith("@g.us") else to_number
-    url = f"{GREEN_API_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendMessage/{GREEN_API_TOKEN}"
-    payload = {"chatId": chat_id, "message": message, "quotedMessageId": message_id}
-    for i in range(retries):
-        try:
-            r = requests.post(url, json=payload)
-            r.raise_for_status()
-            return r.json()
-        except requests.RequestException as e:
-            if i == retries - 1:
-                return {"error": str(e)}
-
-def send_image(message_id, to_number, image_path, caption="Here you go!", retries=3):
-    chat_id = to_number if to_number.endswith("@g.us") else to_number
-    url = f"{GREEN_API_MEDIA_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendFileByUpload/{GREEN_API_TOKEN}"
-    payload = {"chatId": chat_id, "caption": caption, "quotedMessageId": message_id}
-    files = [("file", ("image.jpg", open(image_path, "rb"), "image/jpeg"))]
-    for i in range(retries):
-        try:
-            r = requests.post(url, data=payload, files=files)
-            r.raise_for_status()
-            return r.json()
-        except requests.RequestException as e:
-            if i == retries - 1:
-                return {"error": str(e)}
-
-def send_audio(message_id, to_number, audio_path, retries=3):
-    logging.debug("send_audio")
-    chat_id = to_number if to_number.endswith("@g.us") else to_number
-    if not os.path.exists(audio_path):
-        logging.debug(f"Missing audio: {audio_path}")
-    url = f"{GREEN_API_MEDIA_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendFileByUpload/{GREEN_API_TOKEN}"
-    payload = {"chatId": chat_id, "caption": "Here is your voice reply!", "quotedMessageId": message_id}
-    try:
-        with open(audio_path, "rb") as f:
-            files = [("file", ("audio.mp3", f, "audio/mpeg"))]
-            for i in range(retries):
-                try:
-                    r = requests.post(url, data=payload, files=files)
-                    r.raise_for_status()
-                    return r.json()
-                except requests.RequestException as e:
-                    if i == retries - 1:
-                        return {"error": str(e)}
-    except Exception as e:
-        return {"error": str(e)}
+# --- Core response functions ---
 
-# --- core response functions ---
 def response_text(message_id, chat_id, prompt):
     try:
         msg = generate_llm(prompt)
-        send_message(message_id, chat_id, msg)
-    except Exception:
-        send_message(message_id, chat_id, "Error processing your request.")
+        client.send_message(message_id, chat_id, msg)
+    except Exception as e:
+        logging.error(f"LLM error: {e}")
+        client.send_message(message_id, chat_id, "Error processing your request.")
 
 def response_audio(message_id, chat_id, prompt):
-    logging.debug("response_audio prompt=%s", prompt)
     try:
-        result = generate_voice_reply(prompt, model="openai-audio", voice="coral", audio_dir=audio_dir)
+        result = generate_voice_reply(prompt, model="openai-audio", voice="coral", audio_dir=BotConfig.AUDIO_DIR)
         if result and result[0]:
             audio_path, _ = result
-            send_audio(message_id, chat_id, audio_path)
-            if os.path.exists(audio_path):
-                os.remove(audio_path)
+            client.send_media(message_id, chat_id, audio_path, "", media_type="audio")
+            os.remove(audio_path)
         else:
             response_text(message_id, chat_id, prompt)
     except Exception as e:
-        logging.debug("audio error: %s", e)
-        send_message(message_id, chat_id, "Error generating audio. Try again later.")
+        logging.error(f"Audio error: {e}")
+        client.send_message(message_id, chat_id, "Error generating audio. Try again later.")
 
 def handle_image_generation(message_id, chat_id, prompt):
-    for i in range(4):
+    attempts = 4
+    for attempt in range(1, attempts + 1):
         try:
-            img, path, ret_prompt, url = generate_image(prompt, message_id, message_id, image_dir)
+            img, path, ret_prompt, url = generate_image(prompt, message_id, message_id, BotConfig.IMAGE_DIR)
             if img:
-                formatted_ret_prompt = "\n\n".join(
-                    f"_{paragraph.strip()}_" for paragraph in ret_prompt.split("\n\n") if paragraph.strip()
-                )
-                send_image(
-                    message_id,
-                    chat_id,
-                    path,
-                    caption=f"✨ Image ready: {url}\n>{chr(8203)} {formatted_ret_prompt}"
-                )
+                formatted = "\n\n".join(f"_{p.strip()}_" for p in ret_prompt.split("\n\n") if p.strip())
+                caption = f"✨ Image ready: {url}\n>{chr(8203)} {formatted}"
+                client.send_media(message_id, chat_id, path, caption, media_type="image")
+                return
             else:
-                send_message(message_id, chat_id, "Image generation failed.")
+                raise RuntimeError("generate_image returned no image")
         except Exception as e:
-            logging.error("Error in handle_image_generation: %s", e)
-            send_message(message_id, chat_id, "Error generating image.")
+            logging.warning(f"Image gen attempt {attempt}/{attempts} failed: {e}")
+            if attempt < attempts:
+                time.sleep(5)
+            else:
+                client.send_message(message_id, chat_id, "😢 Image generation failed after several attempts.")
+
+# --- Startup ---
 
-# --- Startup Message ---
 def send_startup_message():
-    if BOT_GROUP_CHAT:
-        startup_msg = "🌟 Hi! I'm Eve, your friendly AI assistant. I'm now live and ready to help with images, voice replies, and more!"
-        resp = send_message_to_chat(BOT_GROUP_CHAT, startup_msg)
-        if "error" in resp:
-            logging.error("Startup message failed: %s", resp["error"])
-    else:
-        logging.warning("BOT_GROUP_CHAT is not set; startup message not sent.")
+    client.send_message_to(BotConfig.BOT_GROUP_CHAT,
+                           "🌟 Hi! I'm Eve, your friendly AI assistant. I'm now live and ready to help!")
+
+send_startup_message()
+
+# --- FastAPI App & Webhook ---
+
+app = FastAPI()
 
 help_text = (
-            "🤖 *Hi there, I'm Eve!* Here are the commands you can use:\n\n"
-            "• */help* – _Show this help message._\n"
-            "• */summarize <text>* – _Get a quick summary of your text._\n"
-            "• */translate <language>|<text>* – _Translate text to your chosen language._\n"
-            "• */joke* – _Enjoy a random, funny joke._\n"
-            "• */weather <location>* – _Get the current weather for a location._\n"
-            "• */inspire* – _Receive a short inspirational quote._\n"
-            "• */trivia* – _Start a new trivia question._\n"
-            "• */answer [your answer]* – _Reveal the trivia answer or check your answer if provided._\n"
-            "• */meme <text>* – _Generate a fun meme image._\n"
-            "• */poll <Question>|<Option1>|<Option2>|…* – _Create a poll._\n"
-            "• */results* – _See current poll results._\n"
-            "• */endpoll* – _End the poll and show final results._\n"
-            "• */gen <prompt>* – _Generate an image from your prompt._\n\n"
-            "Send any other text and I'll reply with a voice message. I'm here to help, so don't hesitate to ask!"
-        )
+    "🤖 *Hi there, I'm Eve!* Here are the commands you can use:\n\n"
+    "• */help* – _Show this help message._\n"
+    "• */summarize <text>* – _Get a quick summary._\n"
+    "• */translate <language>|<text>* – _Translate text._\n"
+    "• */joke* – _Get a joke._\n"
+    "• */weather <location>* – _Get weather._\n"
+    "• */inspire* – _Get an inspirational quote._\n"
+    "• */trivia* – _Start trivia._\n"
+    "• */answer* – _Answer trivia._\n"
+    "• */meme <text>* – _Generate a meme._\n"
+    "• */poll Q|A|B…* – _Create a poll._\n"
+    "• */results* – _Show poll results._\n"
+    "• */endpoll* – _End the poll._\n"
+    "• */gen <prompt>* – _Generate an image._\n\n"
+    "Any other text → I'll send you a voice reply!"
+)
 
-# --- Webhook ---
 @app.post("/whatsapp")
 async def whatsapp_webhook(request: Request):
     global last_message_time
     last_message_time = time.time()
 
-    auth = request.headers.get("Authorization", "").strip()
-    if auth != f"Bearer {WEBHOOK_AUTH_TOKEN}":
+    # Auth
+    auth = request.headers.get("Authorization", "")
+    if auth != f"Bearer {BotConfig.WEBHOOK_AUTH_TOKEN}":
         raise HTTPException(403, "Unauthorized")
-    try:
-        data = await request.json()
-        chat_id = data["senderData"]["chatId"]
-        print(f"New message from chat ID: {chat_id}")
-    except:
-        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
-    if data.get("typeWebhook") != "incomingMessageReceived":
+
+    data = await request.json()
+    chat_id = data.get("senderData", {}).get("chatId")
+    # Only respond in the group chat
+    if chat_id != BotConfig.BOT_GROUP_CHAT:
         return {"success": True}
 
-    logging.debug("recv: %s", data)
-    sd = data["senderData"]
-    chat = sd["chatId"]
-    mid = data["idMessage"]
-    sender_jid = sd.get("sender")
+    if data.get("typeWebhook") != "incomingMessageReceived":
+        return {"success": True}
 
     md = data.get("messageData", {})
-    if md.get("typeMessage") == "quotedMessage" or "quotedMessage" in md:
-        logging.debug("skip native quotedMessage")
-        return {"success": True}
+    mid = data["idMessage"]
 
+    # Extract text
     if "textMessageData" in md:
-        body = md["textMessageData"].get("textMessage", "").strip()
-        ctx = md["textMessageData"].get("contextInfo", {})
+        body = md["textMessageData"]["textMessage"].strip()
     elif "extendedTextMessageData" in md:
-        body = md["extendedTextMessageData"].get("text", "").strip()
-        ctx = md["extendedTextMessageData"].get("contextInfo", {})
+        body = md["extendedTextMessageData"]["text"].strip()
     else:
         return {"success": True}
 
-    if ctx.get("mentionedJid") or ctx.get("mentionedJidList"):
-        return {"success": True}
-    if chat.endswith("@g.us") and re.search(r"@\d+", body):
-        return {"success": True}
-
     low = body.lower()
 
-    # --- New Commands ---
+    # Commands
     if low == "/help":
-        send_message(mid, chat, help_text)
+        client.send_message(mid, chat_id, help_text)
         return {"success": True}
 
     if low.startswith("/summarize "):
         txt = body[len("/summarize "):].strip()
         summary = generate_llm(f"Summarize this text in one short paragraph:\n\n{txt}")
-        send_message(mid, chat, summary)
+        client.send_message(mid, chat_id, summary)
         return {"success": True}
 
     if low.startswith("/translate "):
         part = body[len("/translate "):]
         if "|" not in part:
-            send_message(mid, chat, "Please use `/translate <language>|<text>`")
+            client.send_message(mid, chat_id, "Please use `/translate <language>|<text>`")
         else:
             lang, txt = part.split("|", 1)
             resp = generate_llm(f"Translate the following into {lang.strip()}:\n\n{txt.strip()}")
-            send_message(mid, chat, resp)
+            client.send_message(mid, chat_id, resp)
         return {"success": True}
 
     if low == "/joke":
         try:
             joke = requests.get("https://official-joke-api.appspot.com/random_joke", timeout=5).json()
-            send_message(mid, chat, f"{joke['setup']}\n\n{joke['punchline']}")
+            client.send_message(mid, chat_id, f"{joke['setup']}\n\n{joke['punchline']}")
         except:
-            send_message(mid, chat, generate_llm("Tell me a short, funny joke."))
+            client.send_message(mid, chat_id, generate_llm("Tell me a short, funny joke."))
         return {"success": True}
 
     if low.startswith("/weather "):
         loc = body[len("/weather "):].strip().replace(" ", "+")
         try:
             w = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-            send_message(mid, chat, w)
+            client.send_message(mid, chat_id, w)
         except:
-            send_message(mid, chat, "Could not fetch weather.")
+            client.send_message(mid, chat_id, "Could not fetch weather.")
         return {"success": True}
 
     if low == "/inspire":
         quote = generate_llm("Give me a short inspirational quote.")
-        send_message(mid, chat, f"✨ {quote}")
+        client.send_message(mid, chat_id, f"✨ {quote}")
         return {"success": True}
 
-    # TRIVIA
+    # Trivia
     if low == "/trivia":
-        randomSeed = random.randint(0, 9999999)
+        seed = random.randint(0, 1_000_000)
         raw = generate_llm(
-            (f"Generate a unique and random trivia question and answer based on this random seed {randomSeed} to make it unique in JSON format. "
-             "The output should strictly follow this example format without extra text:\n\n"
-             "{\"question\": \"What is the capital of France?\", \"answer\": \"Paris\"}")
+            f"Generate a unique trivia Q&A in JSON based on seed {seed}:\n"
+            '{"question":"...","answer":"..."}'
         )
-        def extract_json(text):
-            import re
-            match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
-            if match:
-                return match.group(1)
-            return text
         try:
-            json_text = extract_json(raw)
-            obj = json.loads(json_text)
-            if "question" in obj and "answer" in obj:
-                trivia_store[chat] = obj
-                send_message(mid, chat, f"❓ {obj['question']}\nReply with `/answer` followed by your answer (if you want to check it) or just `/answer` to reveal the correct answer.")
-            else:
-                raise ValueError("Missing expected keys.")
-        except Exception as e:
-            logging.error("Trivia JSON parse error: %s, raw response: %s", e, raw)
-            send_message(mid, chat, "Failed to generate trivia. Please try again.")
+            obj = json.loads(raw.strip().strip("```json").strip("```"))
+            trivia_store[chat_id] = obj
+            client.send_message(mid, chat_id,
+                f"❓ {obj['question']}\nReply `/answer` or `/answer your guess`.")
+        except:
+            client.send_message(mid, chat_id, "Failed to generate trivia.")
         return {"success": True}
 
-    # ANSWER: Accept any message starting with /answer. If additional text is provided, check it.
     if low.startswith("/answer"):
-        # Remove command and any extra spaces
-        user_response = body[len("/answer"):].strip()
-        if chat in trivia_store:
-            correct_answer = trivia_store[chat]["answer"]
-            question = trivia_store[chat]["question"]
-            # If user provided an answer, evaluate it via LLM; otherwise, just reveal the answer.
-            if user_response:
-                eval_prompt = (
-                    f"Question: {question}\n"
-                    f"Correct Answer: {correct_answer}\n"
-                    f"User Answer: {user_response}\n"
-                    "Is the user's answer correct? Respond with 'Correct' if yes, or 'Incorrect' if not, and explain briefly."
+        resp = body[len("/answer"):].strip()
+        if chat_id in trivia_store:
+            qa = trivia_store.pop(chat_id)
+            if resp:
+                verdict = generate_llm(
+                    f"Q: {qa['question']}\nCorrect: {qa['answer']}\nUser: {resp}\nCorrect?"
                 )
-                verdict = generate_llm(eval_prompt)
-                send_message(mid, chat, f"💡 {verdict}")
+                client.send_message(mid, chat_id, verdict)
             else:
-                send_message(mid, chat, f"💡 Answer: {correct_answer}")
-            trivia_store.pop(chat, None)
+                client.send_message(mid, chat_id, f"💡 Answer: {qa['answer']}")
         else:
-            send_message(mid, chat, "No active trivia. Send `/trivia` to start one.")
+            client.send_message(mid, chat_id, "No active trivia. `/trivia` to start.")
         return {"success": True}
 
+    # Meme
     if low.startswith("/meme "):
         txt = body[len("/meme "):].strip()
-        send_message(mid, chat, "🎨 Generating your meme...")
-        task_queue.put({
-            "type": "image",
-            "message_id": mid,
-            "chat_id": chat,
-            "prompt": f"meme template with text: {txt}"
-        })
+        client.send_message(mid, chat_id, "🎨 Generating your meme...")
+        task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,"prompt":f"meme: {txt}"})
         return {"success": True}
 
+    # Polls
     if low.startswith("/poll "):
         parts = body[len("/poll "):].split("|")
         if len(parts) < 3:
-            send_message(mid, chat, "Please use `/poll Question|Option1|Option2|...`")
+            client.send_message(mid, chat_id, "Use `/poll Q|A|B`")
         else:
-            q = parts[0].strip()
-            opts = [p.strip() for p in parts[1:]]
-            votes = {i+1: 0 for i in range(len(opts))}
-            polls[chat] = {"question": q, "options": opts, "votes": votes, "voters": {}}
-            txt = f"📊 *Poll:* {q}\n" + "\n".join(
-                f"{i+1}. {opt}" for i, opt in enumerate(opts)
-            ) + "\n\nReply with the *option number* to vote."
-            send_message(mid, chat, txt)
+            q, *opts = [p.strip() for p in parts]
+            votes = {i+1:0 for i in range(len(opts))}
+            polls[chat_id] = {"question":q,"options":opts,"votes":votes,"voters":{}}
+            text = f"📊 *Poll:* {q}\n" + "\n".join(f"{i+1}. {o}" for i,o in enumerate(opts))
+            client.send_message(mid, chat_id, text)
         return {"success": True}
 
-    if chat in polls and body.isdigit():
-        n = int(body)
-        p = polls[chat]
-        if 1 <= n <= len(p["options"]):
-            prev = p["voters"].get(sender_jid)
+    if chat_id in polls and low.isdigit():
+        n = int(low)
+        poll = polls[chat_id]
+        if 1 <= n <= len(poll["options"]):
+            prev = poll["voters"].get(data["senderData"].get("sender"))
             if prev:
-                p["votes"][prev] -= 1
-            p["votes"][n] += 1
-            p["voters"][sender_jid] = n
-            send_message(mid, chat, f"✅ Vote recorded: {p['options'][n-1]}")
+                poll["votes"][prev] -= 1
+            poll["votes"][n] += 1
+            poll["voters"][data["senderData"].get("sender")] = n
+            client.send_message(mid, chat_id, f"✅ Voted for {poll['options'][n-1]}")
         return {"success": True}
 
     if low == "/results":
-        if chat in polls:
-            p = polls[chat]
-            txt = f"📊 *Results:* {p['question']}\n" + "\n".join(
-                f"{i}. {opt}: {p['votes'][i]}" for i, opt in enumerate([""] + p["options"]) if i > 0
-            )
-            send_message(mid, chat, txt)
+        if chat_id in polls:
+            p = polls[chat_id]
+            text = f"📊 *Results:* {p['question']}\n" + "\n".join(f"{i}. {o}: {p['votes'][i]}" for i,o in enumerate(p["options"],1))
+            client.send_message(mid, chat_id, text)
         else:
-            send_message(mid, chat, "No active poll.")
+            client.send_message(mid, chat_id, "No active poll.")
         return {"success": True}
 
     if low == "/endpoll":
-        if chat in polls:
-            p = polls.pop(chat)
-            txt = f"📊 *Final Results:* {p['question']}\n" + "\n".join(
-                f"{i}. {opt}: {p['votes'][i]}" for i, opt in enumerate([""] + p["options"]) if i > 0
-            )
-            send_message(mid, chat, txt)
+        if chat_id in polls:
+            p = polls.pop(chat_id)
+            text = f"📊 *Final Results:* {p['question']}\n" + "\n".join(f"{i}. {o}: {p['votes'][i]}" for i,o in enumerate(p["options"],1))
+            client.send_message(mid, chat_id, text)
         else:
-            send_message(mid, chat, "No active poll.")
+            client.send_message(mid, chat_id, "No active poll.")
         return {"success": True}
 
+    # Image gen
     if low.startswith("/gen"):
         prompt = body[len("/gen"):].strip()
         if not prompt:
-            send_message(mid, chat, "Please use `/gen <prompt>` to generate an image.")
+            client.send_message(mid, chat_id, "Use `/gen <prompt>`")
         else:
-            send_message(mid, chat, "✨ Your image is being generated. Please wait...")
-            task_queue.put({
-                "type": "image",
-                "message_id": mid,
-                "chat_id": chat,
-                "prompt": prompt
-            })
+            client.send_message(mid, chat_id, "✨ Generating image...")
+            task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,"prompt":prompt})
         return {"success": True}
 
-    # Fallback: voice reply for any other text
-    task_queue.put({
-        "type": "audio",
-        "message_id": mid,
-        "chat_id": chat,
-        "prompt": body
-    })
+    # Fallback: voice reply
+    task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":body})
     return {"success": True}
 
 @app.get("/", response_class=PlainTextResponse)
@@ -432,13 +356,5 @@ def index():
     return "Server is running!"
 
 if __name__ == "__main__":
-    # Send startup message on launch
-    def send_startup_message():
-        if BOT_GROUP_CHAT:
-            startup_msg = "🌟 Hi! I'm Eve, your friendly AI assistant. I'm now live and ready to help with images, voice replies, and more!"
-            send_message_to_chat(BOT_GROUP_CHAT, startup_msg)
-        else:
-            logging.warning("BOT_GROUP_CHAT is not set; startup message not sent.")
-    send_startup_message()
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)