Increase max_tokens for LLM generation to 8000; update example usage comment

app.py

@@ -22,22 +22,17 @@ class BotConfig:
     GREEN_API_ID_INSTANCE = os.getenv("GREEN_API_ID_INSTANCE")
     WEBHOOK_AUTH_TOKEN    = os.getenv("WEBHOOK_AUTH_TOKEN")
     BOT_GROUP_CHAT        = "[email protected]"
-    BOT_JID               = os.getenv("BOT_JID")    # your bot's own WhatsApp JID
+    BOT_JID               = os.getenv("BOT_JID")
     IMAGE_DIR             = "/tmp/images"
     AUDIO_DIR             = "/tmp/audio"
     DEFAULT_IMAGE_COUNT   = 4
 
     @classmethod
     def validate(cls):
-        missing = [
-            name for name in (
-                "GREEN_API_URL",
-                "GREEN_API_TOKEN",
-                "GREEN_API_ID_INSTANCE",
-                "WEBHOOK_AUTH_TOKEN",
-                "BOT_JID",
-            ) if not getattr(cls, name)
-        ]
+        missing = [n for n in (
+            "GREEN_API_URL","GREEN_API_TOKEN",
+            "GREEN_API_ID_INSTANCE","WEBHOOK_AUTH_TOKEN","BOT_JID"
+        ) if not getattr(cls, n)]
         if missing:
             raise ValueError(f"Missing env vars: {', '.join(missing)}")
 
@@ -48,11 +43,11 @@ class BotClient:
         logging.basicConfig(level=logging.DEBUG,
                             format="%(asctime)s [%(levelname)s] %(message)s")
 
-    def send(self, endpoint: str, payload: dict, files=None, retries=3):
+    def send(self, endpoint, payload, files=None, retries=3):
         url = (f"{self.cfg.GREEN_API_URL}/waInstance"
                f"{self.cfg.GREEN_API_ID_INSTANCE}/{endpoint}/"
                f"{self.cfg.GREEN_API_TOKEN}")
-        for attempt in range(1, retries + 1):
+        for i in range(1, retries+1):
             try:
                 resp = self.session.post(
                     url,
@@ -63,355 +58,304 @@ class BotClient:
                 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)}
+                logging.warning(f"{endpoint} attempt {i}/{retries} failed: {e}")
+        return {"error":"failed"}
 
-    def send_message(self, message_id: str, chat_id: str, text: str):
+    def send_message(self, message_id, chat_id, text):
         return self.send("sendMessage", {
             "chatId": chat_id,
             "message": text,
             "quotedMessageId": message_id
         })
 
-    def send_message_to(self, chat_id: str, text: str):
+    def send_message_to(self, chat_id, text):
         return self.send("sendMessage", {
             "chatId": chat_id,
             "message": text
         })
 
-    def send_media(self, message_id: str, chat_id: str, file_path: str,
-                   caption: str, media_type: str):
+    def send_media(self, message_id, chat_id, file_path, caption, media_type):
         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)
+        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)
 
-# --- Threading, Queues, Stores ---
+# --- Threading & Queues ---
 
-task_queue   = queue.Queue()
-polls        = {}
-last_message_time = time.time()
+task_queue = queue.Queue()
+polls      = {}
+executor   = ThreadPoolExecutor(max_workers=4)
 
-def inactivity_monitor():
-    global last_message_time
-    while True:
-        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()
-
-executor = ThreadPoolExecutor(max_workers=4)
 def worker():
     while True:
-        task = task_queue.get()
+        t = task_queue.get()
         try:
-            if task["type"] == "image":
-                _fn_generate_images(task["message_id"],
-                                    task["chat_id"],
-                                    task["prompt"],
-                                    task.get("num_images", 1))
-            elif task["type"] == "audio":
-                _fn_voice_reply(task["message_id"],
-                                task["chat_id"],
-                                task['prompt'])
+            if t["type"]=="image":
+                _fn_generate_images(t["message_id"],t["chat_id"],t["prompt"],t.get("num_images",1))
+            elif t["type"]=="audio":
+                _fn_voice_reply(t["message_id"],t["chat_id"],t["prompt"])
         except Exception as e:
-            logging.error(f"Worker error {task}: {e}")
+            logging.error(f"Worker error {t}: {e}")
         finally:
             task_queue.task_done()
 
 for _ in range(4):
-    threading.Thread(target=worker, daemon=True).start()
+    threading.Thread(target=worker,daemon=True).start()
 
-# --- Primitive “tool” functions ---
+# --- Tool Functions ---
 
-def _fn_summarize(message_id, chat_id, text):
-    summary = generate_llm(f"Summarize this text in one short paragraph:\n\n{text}")
-    client.send_message(message_id, chat_id, summary)
+def _fn_summarize(mid, cid, text):
+    s = generate_llm(f"Summarize:\n\n{text}")
+    client.send_message(mid,cid,s)
 
-def _fn_translate(message_id, chat_id, lang, text):
-    resp = generate_llm(f"Translate the following into {lang}:\n\n{text}")
-    client.send_message(message_id, chat_id, resp)
+def _fn_translate(mid, cid, lang, text):
+    r = generate_llm(f"Translate to {lang}:\n\n{text}")
+    client.send_message(mid,cid,r)
 
-def _fn_joke(message_id, chat_id):
+def _fn_joke(mid, cid):
     try:
-        j = requests.get("https://official-joke-api.appspot.com/random_joke", timeout=5).json()
+        j = requests.get("https://official-joke-api.appspot.com/random_joke",timeout=5).json()
         joke = f"{j['setup']}\n\n{j['punchline']}"
     except:
-        joke = generate_llm("Tell me a short, funny joke.")
-    client.send_message(message_id, chat_id, joke)
+        joke = generate_llm("Tell me a short joke.")
+    client.send_message(mid,cid,joke)
 
-def _fn_weather(message_id, chat_id, loc):
-    raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-    report = generate_llm(
-        f"Convert this weather report into Celsius and craft a short, creative report:\n\n{raw}"
-    )
-    client.send_message(message_id, chat_id, report)
-    task_queue.put({
-        "type":"audio","message_id":message_id,"chat_id":chat_id,
-        "prompt":f"Speak only this weather report: {report}"
-    })
-
-def _fn_inspire(message_id, chat_id):
-    quote = generate_llm(f"Give me a short inspirational unique quote.")
-    client.send_message(message_id, chat_id, f"✨ {quote}")
-
-def _fn_meme(message_id, chat_id, txt):
-    client.send_message(message_id, chat_id, "🎨 Generating your meme...")
-    task_queue.put({"type":"image","message_id":message_id,
-                    "chat_id":chat_id,"prompt":f"meme: {txt}"})
-
-def _fn_poll(message_id, chat_id, question, options):
+def _fn_weather(mid,cid,loc):
+    raw = requests.get(f"http://sl.wttr.in/{loc}?format=4",timeout=5).text
+    r = generate_llm(f"Convert to °C & creative:\n\n{raw}")
+    client.send_message(mid,cid,r)
+    task_queue.put({"type":"audio","message_id":mid,"chat_id":cid,"prompt":r})
+
+def _fn_inspire(mid,cid):
+    q = generate_llm("Give me a short inspirational quote.")
+    client.send_message(mid,cid,f"✨ {q}")
+
+def _fn_meme(mid,cid,txt):
+    client.send_message(mid,cid,"🎨 Generating meme…")
+    task_queue.put({"type":"image","message_id":mid,"chat_id":cid,"prompt":f"meme: {txt}"})
+
+def _fn_poll_create(mid,cid,question,options):
     votes = {i+1:0 for i in range(len(options))}
-    polls[chat_id] = {"question":question,"options":options,"votes":votes,"voters":{}}
-    text = f"📊 *Poll:* {question}\n" + "\n".join(
-        f"{i+1}. {o}" for i,o in enumerate(options)
-    )
-    client.send_message(message_id, chat_id, text)
+    polls[cid] = {"question":question,"options":options,"votes":votes,"voters":{}}
+    text = f"📊 *Poll:* {question}\n" + "\n".join(f"{i+1}. {o}" for i,o in enumerate(options))
+    client.send_message(mid,cid,text)
 
-def _fn_poll_vote(message_id, chat_id, voter, choice):
-    poll = polls.get(chat_id)
-    if not poll or choice < 1 or choice > len(poll["options"]):
-        return
+def _fn_poll_vote(mid,cid,voter,choice):
+    poll = polls.get(cid)
+    if not poll or choice<1 or choice>len(poll["options"]): return
     prev = poll["voters"].get(voter)
-    if prev:
-        poll["votes"][prev] -= 1
-    poll["votes"][choice] += 1
-    poll["voters"][voter] = choice
-    client.send_message(message_id, chat_id,
-                        f"✅ Voted for {poll['options'][choice-1]}")
-
-def _fn_poll_results(message_id, chat_id):
-    poll = polls.get(chat_id)
+    if prev: poll["votes"][prev]-=1
+    poll["votes"][choice]+=1
+    poll["voters"][voter]=choice
+    client.send_message(mid,cid,f"✅ Voted for {poll['options'][choice-1]}")
+
+def _fn_poll_results(mid,cid):
+    poll = polls.get(cid)
     if not poll:
-        client.send_message(message_id, chat_id, "No active poll.")
+        client.send_message(mid,cid,"No active poll.")
         return
-    text = f"📊 *Results:* {poll['question']}\n" + "\n".join(
+    txt = f"📊 *Results:* {poll['question']}\n" + "\n".join(
         f"{i}. {o}: {poll['votes'][i]}" for i,o in enumerate(poll["options"],1)
     )
-    client.send_message(message_id, chat_id, text)
+    client.send_message(mid,cid,txt)
 
-def _fn_poll_end(message_id, chat_id):
-    poll = polls.pop(chat_id, None)
+def _fn_poll_end(mid,cid):
+    poll = polls.pop(cid,None)
     if not poll:
-        client.send_message(message_id, chat_id, "No active poll.")
+        client.send_message(mid,cid,"No active poll.")
         return
-    text = f"📊 *Final Results:* {poll['question']}\n" + "\n".join(
+    txt = f"📊 *Final Results:* {poll['question']}\n" + "\n".join(
         f"{i}. {o}: {poll['votes'][i]}" for i,o in enumerate(poll["options"],1)
     )
-    client.send_message(message_id, chat_id, text)
+    client.send_message(mid,cid,txt)
 
-def _fn_generate_images(message_id, chat_id, prompt, count=1):
-    for i in range(1, count+1):
+def _fn_generate_images(mid,cid,prompt,count=1):
+    for i in range(1,count+1):
         try:
-            img, path, ret_prompt, url = generate_image(
-                prompt, message_id, message_id, BotConfig.IMAGE_DIR
-            )
-            formatted = "\n\n".join(f"_{p.strip()}_"
-                                    for p in ret_prompt.split("\n\n") if p.strip())
-            caption = f"✨ Image {i}/{count}: {url}\n>{chr(8203)} {formatted}"
-            client.send_media(message_id, chat_id, path, caption, media_type="image")
+            img,path,ret_p,url = generate_image(prompt,mid,mid,BotConfig.IMAGE_DIR)
+            formatted = "\n\n".join(f"_{p.strip()}_" for p in ret_p.split("\n\n") if p.strip())
+            cap = f"✨ Image {i}/{count}: {url}\n>{chr(8203)} {formatted}"
+            client.send_media(mid,cid,path,cap,media_type="image")
             os.remove(path)
         except Exception as e:
-            logging.warning(f"Image {i}/{count} failed: {e}")
-            client.send_message(message_id, chat_id,
-                                f"😢 Failed to generate image {i}/{count}.")
-
-def _fn_voice_reply(message_id, chat_id, prompt):
-    processed_prompt = f"Say this dialog in a friendly tone:\n\n{prompt}"
-    result = generate_voice_reply(processed_prompt,
-                                  model="openai-audio",
-                                  voice="coral",
-                                  audio_dir=BotConfig.AUDIO_DIR)
-    if result and result[0]:
-        audio_path, _ = result
-        client.send_media(message_id, chat_id, audio_path, "", media_type="audio")
-        os.remove(audio_path)
+            logging.warning(f"Img {i}/{count} failed: {e}")
+            client.send_message(mid,cid,f"😢 Failed to gen image {i}/{count}.")
+
+def _fn_send_text(mid,cid,message):
+    client.send_message(mid,cid,message)
+
+def _fn_voice_reply(mid,cid,prompt):
+    res = generate_voice_reply(prompt,model="openai-audio",voice="coral",audio_dir=BotConfig.AUDIO_DIR)
+    if res and res[0]:
+        path,_ = res
+        client.send_media(mid,cid,path,"",media_type="audio")
+        os.remove(path)
     else:
-        # fallback to text
-        response = generate_llm(prompt)
-        client.send_message(message_id, chat_id, response)
+        txt = generate_llm(prompt)
+        client.send_message(mid,cid,txt)
 
-# --- Intent router for fallback ---
+# --- Function schema & router ---
 
 FUNCTION_SCHEMA = {
-    "generate_image": {
-        "description": "Generate one or more images",
-        "params": ["prompt","count"]
-    },
-    "send_text": {
-        "description": "Send a plain text response",
-        "params": ["message"]
-    }
+    "summarize":     {"description":"Summarize text","params":["text"]},
+    "translate":     {"description":"Translate text","params":["lang","text"]},
+    "joke":          {"description":"Tell a joke","params":[]},
+    "weather":       {"description":"Creative weather","params":["location"]},
+    "weather_poem":  {"description":"Poetic weather","params":["location"]},
+    "inspire":       {"description":"Inspirational quote","params":[]},
+    "meme":          {"description":"Generate meme","params":["text"]},
+    "poll_create":   {"description":"Create poll","params":["question","options"]},
+    "poll_vote":     {"description":"Vote poll","params":["choice"]},
+    "poll_results":  {"description":"Show poll results","params":[]},
+    "poll_end":      {"description":"End poll","params":[]},
+    "generate_image":{"description":"Generate images","params":["prompt","count"]},
+    "send_text":     {"description":"Send plain text","params":["message"]}
 }
 
 def route_intent(user_input: str):
-    """
-    Ask the LLM whether to call a function or just chat.
-    Expects a JSON response like:
-      {"action":"generate_image","prompt":"a sunset","count":2}
-      or
-      {"action":"send_text","message":"Here's my reply..."}
-    """
     sys_prompt = (
-        "You are Eve. You can either chat normally or call one of these functions:\n"
-        + "\n".join(f"- {name}: {info['description']}"
-                    for name,info in FUNCTION_SCHEMA.items())
-        + "\n\nIf the user wants an image generated, return JSON with "
-          "\"action\":\"generate_image\",\"prompt\":\"...\",\"count\":<int>.\n"
+        "You are Eve. You can either chat or call one of these functions:\n"
+        + "\n".join(f"- {n}: {f['description']}" for n,f in FUNCTION_SCHEMA.items())
+        + "\n\nTo call a function, return JSON with \"action\":\"<name>\", plus its parameters.\n"
         "Otherwise return JSON with \"action\":\"send_text\",\"message\":\"...\".\n"
-        "Do NOT wrap your response in any extra text—only raw JSON."
+        "Return only raw JSON."
     )
     raw = generate_llm(f"{sys_prompt}\nUser: {user_input}")
     try:
         return json.loads(raw)
     except:
-        # fallback: treat entire raw as chat
         return {"action":"send_text","message":raw}
 
-# --- FastAPI App & Webhook ---
+# --- FastAPI & Webhook ---
 
 app = FastAPI()
 help_text = (
-    "🤖 *Hi, I'm Eve!* Commands:\n"
+    "🤖 *Eve* commands:\n"
     "• /help\n"
     "• /summarize <text>\n"
     "• /translate <lang>|<text>\n"
     "• /joke\n"
     "• /weather <loc>\n"
+    "• /weatherpoem <loc>\n"
     "• /inspire\n"
+    "• /trivia / /answer\n"
     "• /meme <text>\n"
-    "• /poll <Q>|<opt1>|… / /results / /endpoll\n"
+    "• /poll <Q>|… / /results / /endpoll\n"
     "• /gen <prompt>|<count>\n"
-    "Otherwise I’ll chat or generate images for you!"
+    "Otherwise chat freely or reply to one of my messages to invoke tools."
 )
 
 @app.post("/whatsapp")
 async def whatsapp_webhook(request: Request):
-    global last_message_time
-    last_message_time = time.time()
-
-    # Auth
+    data = await request.json()
     if request.headers.get("Authorization") != f"Bearer {BotConfig.WEBHOOK_AUTH_TOKEN}":
-        raise HTTPException(403, "Unauthorized")
+        raise HTTPException(403,"Unauthorized")
 
-    data    = await request.json()
-    chat_id = data.get("senderData", {}).get("chatId")
-    if chat_id != BotConfig.BOT_GROUP_CHAT or data.get("typeWebhook") != "incomingMessageReceived":
-        return {"success": True}
+    chat_id = data["senderData"]["chatId"]
+    if chat_id != BotConfig.BOT_GROUP_CHAT or data["typeWebhook"]!="incomingMessageReceived":
+        return {"success":True}
 
     md   = data["messageData"]
     mid  = data["idMessage"]
     tmd  = md.get("textMessageData") or md.get("extendedTextMessageData")
     if not tmd:
-        return {"success": True}
-    body = tmd.get("textMessage", tmd.get("text", "")).strip()
-    ctx  = tmd.get("contextInfo", {})
-
-    # 1) Quoted‑reply to bot
-    if md.get("typeMessage") == "quotedMessage":
-        ext = md["extendedTextMessageData"]
-        quoted = md["quotedMessage"]
-        if ext.get("participant") == BotConfig.BOT_JID:
-            user_reply  = ext.get("text", "")
-            quoted_text = quoted.get("textMessage", "")
-            prompt = (
-                f"You asked: {quoted_text}\n"
-                f"User replied: {user_reply}\n"
-                "Provide a helpful follow‑up."
-            )
-            ans = generate_llm(prompt)
-            client.send_message(mid, chat_id, ans)
-            task_queue.put({
-                "type":"audio","message_id":mid,
-                "chat_id":chat_id,"prompt":ans
-            })
-        return {"success": True}
-
-    # 2) Mentions skip
-    if ctx.get("mentionedJidList"):
-        return {"success": True}
+        return {"success":True}
+    body = (tmd.get("textMessage") or tmd.get("text","")).strip()
+    ctx  = tmd.get("contextInfo",{})
 
+    # Slash commands
     low = body.lower()
-
-    # 3) Slash‑commands
-    if low == "/help":
-        client.send_message(mid, chat_id, help_text); return {"success": True}
+    if low=="/help":
+        client.send_message(mid,chat_id,help_text); return {"success":True}
     if low.startswith("/summarize "):
-        _fn_summarize(mid, chat_id, body[11:].strip()); return {"success": True}
+        _fn_summarize(mid,chat_id,body[11:].strip()); return {"success":True}
     if low.startswith("/translate "):
-        lang, txt = body[11:].split("|",1)
-        _fn_translate(mid, chat_id, lang.strip(), txt.strip()); return {"success": True}
-    if low == "/joke":
-        _fn_joke(mid, chat_id); return {"success": True}
+        lang,txt = body[11:].split("|",1)
+        _fn_translate(mid,chat_id,lang.strip(),txt.strip()); return {"success":True}
+    if low=="/joke":
+        _fn_joke(mid,chat_id); return {"success":True}
     if low.startswith("/weather "):
-        _fn_weather(mid, chat_id, body[9:].strip().replace(" ","+")); return {"success": True}
-    if low == "/inspire":
-        _fn_inspire(mid, chat_id); return {"success": True}
+        _fn_weather(mid,chat_id,body[9:].strip().replace(" ","+")); return {"success":True}
+    if low=="/inspire":
+        _fn_inspire(mid,chat_id); return {"success":True}
     if low.startswith("/meme "):
-        _fn_meme(mid, chat_id, body[6:].strip()); return {"success": True}
+        _fn_meme(mid,chat_id,body[6:].strip()); return {"success":True}
     if low.startswith("/poll "):
-        parts = [p.strip() for p in body[6:].split("|")]
-        _fn_poll(mid, chat_id, parts[0], parts[1:]); return {"success": True}
+        parts=[p.strip() for p in body[6:].split("|")]
+        _fn_poll_create(mid,chat_id,parts[0],parts[1:]); return {"success":True}
     if chat_id in polls and low.isdigit():
-        _fn_poll_vote(mid, chat_id,
-                      data["senderData"]["sender"],
-                      int(low)); return {"success": True}
-    if low == "/results":
-        _fn_poll_results(mid, chat_id); return {"success": True}
-    if low == "/endpoll":
-        _fn_poll_end(mid, chat_id); return {"success": True}
+        _fn_poll_vote(mid,chat_id,data["senderData"]["sender"],int(low)); return {"success":True}
+    if low=="/results":
+        _fn_poll_results(mid,chat_id); return {"success":True}
+    if low=="/endpoll":
+        _fn_poll_end(mid,chat_id); return {"success":True}
     if low.startswith("/gen"):
-        parts = body[4:].split("|",1)
-        prompt = parts[0].strip()
-        cnt    = int(parts[1]) if len(parts)>1 and parts[1].isdigit() else BotConfig.DEFAULT_IMAGE_COUNT
-        client.send_message(mid, chat_id, f"✨ Generating {cnt} image(s)…")
-        task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,
-                        "prompt":prompt,"num_images":cnt})
-        return {"success": True}
-
-    # 4) Fallback → function calling router
-    intent = route_intent(body)
-    act    = intent.get("action")
-    if act == "generate_image":
-        pr = intent.get("prompt","")
-        ct = intent.get("count",1)
-        client.send_message(mid, chat_id, f"👍 Generating {ct} images for “{pr}”…")
-        task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,
-                        "prompt":pr,"num_images":ct})
+        parts=body[4:].split("|",1)
+        pr=parts[0].strip()
+        ct=int(parts[1]) if len(parts)>1 and parts[1].isdigit() else BotConfig.DEFAULT_IMAGE_COUNT
+        client.send_message(mid,chat_id,f"✨ Generating {ct} images…")
+        task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,"prompt":pr,"num_images":ct})
+        return {"success":True}
+
+    # Skip mentions
+    if ctx.get("mentionedJidList"):
+        return {"success":True}
+
+    # Build effective_text (include quoted if replying to bot)
+    if md.get("typeMessage")=="quotedMessage":
+        ext=md["extendedTextMessageData"]
+        quoted=md["quotedMessage"]
+        if ext.get("participant")==BotConfig.BOT_JID:
+            effective = f"Quoted: {quoted.get('textMessage','')}\nUser: {ext.get('text','')}"
+        else:
+            effective = body
     else:
-        # send_text or any unknown
-        msg = intent.get("message", "Sorry, I didn't understand.")
-        client.send_message(mid, chat_id, msg)
-        task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,
-                        "prompt":msg})
+        effective = body
+
+    # Route intent across all tools
+    intent = route_intent(effective)
+    action = intent.get("action")
+
+    dispatch = {
+        "summarize":     lambda: _fn_summarize(mid,chat_id,intent["text"]),
+        "translate":     lambda: _fn_translate(mid,chat_id,intent["lang"],intent["text"]),
+        "joke":          lambda: _fn_joke(mid,chat_id),
+        "weather":       lambda: _fn_weather(mid,chat_id,intent["location"]),
+        "inspire":       lambda: _fn_inspire(mid,chat_id),
+        "meme":          lambda: _fn_meme(mid,chat_id,intent["text"]),
+        "poll_create":   lambda: _fn_poll_create(mid,chat_id,intent["question"],intent["options"]),
+        "poll_vote":     lambda: _fn_poll_vote(mid,chat_id,data["senderData"]["sender"],intent["choice"]),
+        "poll_results":  lambda: _fn_poll_results(mid,chat_id),
+        "poll_end":      lambda: _fn_poll_end(mid,chat_id),
+        "generate_image":lambda: _fn_generate_images(mid,chat_id,intent["prompt"],intent.get("count",1)),
+        "send_text":     lambda: _fn_send_text(mid,chat_id,intent["message"]),
+    }
+
+    if action in dispatch:
+        dispatch[action]()
+    else:
+        # fallback chat
+        txt = intent.get("message","Sorry, I didn't get that.")
+        _fn_send_text(mid,chat_id,txt)
+        task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":txt})
 
-    return {"success": True}
+    return {"success":True}
 
-@app.get("/", response_class=PlainTextResponse)
+@app.get("/",response_class=PlainTextResponse)
 def index():
     return "Server is running!"
 
-if __name__ == "__main__":
-    client.send_message_to(
-        BotConfig.BOT_GROUP_CHAT,
-        "🤖 *Eve is online!* Commands:\n" + help_text
-    )
+if __name__=="__main__":
+    client.send_message_to(BotConfig.BOT_GROUP_CHAT,
+        "🌟 Eve is online! Type /help to see commands.")
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app,host="0.0.0.0",port=7860)

polLLM.py

@@ -18,7 +18,7 @@ def pre_process():
     char = config['llm']['char']
     return system_prompt.replace("{char}", char)
 
-def generate_llm(prompt, model="openai-large", max_tokens=100):
+def generate_llm(prompt, model="openai-large", max_tokens=8000):
     system_prompt = pre_process()
     
     try:
@@ -40,5 +40,6 @@ def generate_llm(prompt, model="openai-large", max_tokens=100):
 
 # Example usage (can be removed or commented out in production):
 if __name__ == "__main__":
-    sample_prompt = f"Generate a unique trivia Q&A in JSON: {{\"question\":\"...\",\"answer\":\"...\"}}"
+    #sample_prompt = f"Generate a unique trivia Q&A in JSON: {{\"question\":\"...\",\"answer\":\"...\"}}"
+    sample_prompt = "search for free image generation api"
     print("Response:", generate_llm(sample_prompt))