Enhance configuration to support function calling for image generation and text replies; improve help text for user commands.

app.py

@@ -22,7 +22,7 @@ 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")    # your bot's own WhatsApp JID
     IMAGE_DIR             = "/tmp/images"
     AUDIO_DIR             = "/tmp/audio"
     DEFAULT_IMAGE_COUNT   = 4
@@ -39,16 +39,19 @@ class BotConfig:
             ) if not getattr(cls, name)
         ]
         if missing:
-            raise ValueError(f"Environment variables not set: {', '.join(missing)}")
+            raise ValueError(f"Missing env vars: {', '.join(missing)}")
 
 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")
+        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}"
+        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):
             try:
                 resp = self.session.post(
@@ -66,16 +69,26 @@ class BotClient:
                     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("sendMessage", payload)
+        return self.send("sendMessage", {
+            "chatId": chat_id,
+            "message": text,
+            "quotedMessageId": message_id
+        })
 
     def send_message_to(self, chat_id: str, text: str):
-        payload = {"chatId": chat_id, "message": text}
-        return self.send("sendMessage", payload)
+        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: str, chat_id: str, file_path: str,
+                   caption: str, media_type: str):
         endpoint = "sendFileByUpload"
-        payload = {"chatId": chat_id, "caption": caption, "quotedMessageId": message_id}
+        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))]
@@ -85,7 +98,7 @@ class BotClient:
 BotConfig.validate()
 client = BotClient(BotConfig)
 
-# --- Queues, stores, threading ---
+# --- Threading, Queues, Stores ---
 
 task_queue   = queue.Queue()
 trivia_store = {}
@@ -111,90 +124,222 @@ def worker():
         task = task_queue.get()
         try:
             if task["type"] == "image":
-                handle_image_generation(task)
+                _fn_generate_images(task["message_id"],
+                                    task["chat_id"],
+                                    task["prompt"],
+                                    task.get("num_images", 1))
             elif task["type"] == "audio":
-                response_audio(task["message_id"], task["chat_id"], task["prompt"])
+                _fn_voice_reply(task["message_id"],
+                                task["chat_id"],
+                                task["prompt"])
         except Exception as e:
-            logging.error(f"Error in worker for task {task}: {e}")
+            logging.error(f"Worker error {task}: {e}")
         finally:
             task_queue.task_done()
 
 for _ in range(4):
     threading.Thread(target=worker, daemon=True).start()
 
-# --- Core responders ---
+# --- Primitive “tool” functions ---
 
-def response_text(message_id, chat_id, prompt):
-    try:
-        msg = generate_llm(prompt)
-        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 _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_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 response_audio(message_id, chat_id, prompt):
+def _fn_joke(message_id, chat_id):
+    try:
+        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)
+
+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_weather_poem(message_id, chat_id, loc):
+    raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
+    poem = generate_llm(
+        f"Write a short, poetic weather summary in Celsius based on:\n\n{raw}"
+    )
+    client.send_message(message_id, chat_id, poem)
+    task_queue.put({
+        "type":"audio","message_id":message_id,"chat_id":chat_id,
+        "prompt":f"Speak only this poetic weather summary: {poem}"
+    })
+
+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_trivia(message_id, chat_id):
+    raw = generate_llm(
+        f"Generate a unique trivia Q&A in JSON: {{\"question\":\"...\",\"answer\":\"...\"}}"
+    )
     try:
-        result = generate_voice_reply(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)
-        else:
-            response_text(message_id, chat_id, prompt)
-    except Exception as e:
-        logging.error(f"Audio error: {e}")
-        client.send_message(message_id, chat_id, "Error generating audio. Try again later.")
-
-def handle_image_generation(task):
-    message_id = task["message_id"]
-    chat_id    = task["chat_id"]
-    prompt     = task["prompt"]
-    count      = task.get("num_images", BotConfig.DEFAULT_IMAGE_COUNT)
-
-    for i in range(1, count + 1):
+        obj = json.loads(raw.strip().strip("```json").strip("```"))
+        trivia_store[chat_id] = obj
+        client.send_message(
+            message_id, chat_id,
+            f"❓ {obj['question']}\nReply `/answer` or `/answer your guess`."
+        )
+    except:
+        client.send_message(message_id, chat_id, "Failed to generate trivia.")
+
+def _fn_answer(message_id, chat_id, guess):
+    if chat_id not in trivia_store:
+        client.send_message(message_id, chat_id, "No active trivia. `/trivia` to start.")
+        return
+    qa = trivia_store.pop(chat_id)
+    if guess:
+        verdict = generate_llm(
+            f"Q: {qa['question']}\nCorrect: {qa['answer']}\nUser: {guess}\nCorrect?"
+        )
+        client.send_message(message_id, chat_id, verdict)
+    else:
+        client.send_message(message_id, chat_id, f"💡 Answer: {qa['answer']}")
+
+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):
+    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)
+
+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
+    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 not poll:
+        client.send_message(message_id, chat_id, "No active poll.")
+        return
+    text = 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)
+
+def _fn_poll_end(message_id, chat_id):
+    poll = polls.pop(chat_id, None)
+    if not poll:
+        client.send_message(message_id, chat_id, "No active poll.")
+        return
+    text = 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)
+
+def _fn_generate_images(message_id, chat_id, 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
             )
-            if not img:
-                raise RuntimeError("generate_image returned no image")
-            formatted = "\n\n".join(f"_{p.strip()}_" for p in ret_prompt.split("\n\n") if p.strip())
+            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")
             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}.")
-
-# --- Startup ---
-
-def send_startup_message():
-    client.send_message_to(
-        BotConfig.BOT_GROUP_CHAT,
-        "🌟 Hi! I'm Eve, your friendly AI assistant. I'm now live and ready to help!"
+            client.send_message(message_id, chat_id,
+                                f"😢 Failed to generate image {i}/{count}.")
+
+def _fn_voice_reply(message_id, chat_id, prompt):
+    result = generate_voice_reply(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)
+    else:
+        # fallback to text
+        response = generate_llm(prompt)
+        client.send_message(message_id, chat_id, response)
+
+# --- Intent router for fallback ---
+
+FUNCTION_SCHEMA = {
+    "generate_image": {
+        "description": "Generate one or more images",
+        "params": ["prompt","count"]
+    },
+    "send_text": {
+        "description": "Send a plain text response",
+        "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"
+        "Otherwise return JSON with \"action\":\"send_text\",\"message\":\"...\".\n"
+        "Do NOT wrap your response in any extra text—only raw JSON."
     )
-
-send_startup_message()
+    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 ---
 
 app = FastAPI()
-
 help_text = (
-    "🤖 *Hi there, I'm Eve!* Here are the commands you can use:\n\n"
-    "• */help* – list commands\n"
-    "• */gen <prompt>|<count>* – generate images (default 4)\n"
-    "• */summarize <text>*\n"
-    "• */translate <lang>|<text>*\n"
-    "• */joke*\n"
-    "• */weather <location>*\n"
-    "• */weatherpoem <location>*\n"
-    "• */inspire*\n"
-    "• */trivia* / *answer*\n"
-    "• */meme <text>*\n"
-    "• */poll <Q>|<opt1>|… / /results / /endpoll*\n\n"
-    "Reply to one of my messages → I'll LLM‑answer it.\n"
-    "Any other text → voice reply."
+    "🤖 *Hi, I'm 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"
+    "• /gen <prompt>|<count>\n"
+    "Otherwise I’ll chat or generate images for you!"
 )
 
 @app.post("/whatsapp")
@@ -207,205 +352,102 @@ async def whatsapp_webhook(request: Request):
         raise HTTPException(403, "Unauthorized")
 
     data    = await request.json()
-    logging.debug(f"Received data: {data}")
     chat_id = data.get("senderData", {}).get("chatId")
     if chat_id != BotConfig.BOT_GROUP_CHAT or data.get("typeWebhook") != "incomingMessageReceived":
         return {"success": True}
 
-    md = data.get("messageData", {})
-    mid = data["idMessage"]
+    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", {})
 
-    # --- Quoted‑reply handling ---
+    # 1) Quoted‑reply to bot
     if md.get("typeMessage") == "quotedMessage":
-        ext = md.get("extendedTextMessageData", {})
-        quoted = md.get("quotedMessage", {})
-        quoted_participant = ext.get("participant")
-        # only if the quoted message was from the bot
-        if quoted_participant == BotConfig.BOT_JID:
+        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, concise follow‑up."
+                "Provide a helpful follow‑up."
             )
-            reply = generate_llm(prompt)
-            client.send_message(mid, chat_id, reply)
-            voice_prompt = f"Speak only this dialog: {reply}"
-            task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":voice_prompt})
+            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}
 
-    # --- Extract normal text + skip mentions ---
-    text_data = md.get("textMessageData") or md.get("extendedTextMessageData")
-    if not text_data:
-        return {"success": True}
-    body = text_data.get("textMessage", text_data.get("text", "")).strip()
-    ctx  = text_data.get("contextInfo", {})
+    # 2) Mentions skip
     if ctx.get("mentionedJidList"):
         return {"success": True}
 
     low = body.lower()
 
-    # --- COMMANDS ---
+    # 3) Slash‑commands
     if low == "/help":
-        client.send_message(mid, chat_id, help_text)
-        return {"success": True}
-
+        client.send_message(mid, chat_id, help_text); return {"success": True}
     if low.startswith("/summarize "):
-        summary = generate_llm(f"Summarize this text in one short paragraph:\n\n{body[11:].strip()}")
-        client.send_message(mid, chat_id, summary)
-        return {"success": True}
-
+        _fn_summarize(mid, chat_id, body[11:].strip()); return {"success": True}
     if low.startswith("/translate "):
-        part = body[11:]
-        if "|" not in part:
-            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()}")
-            client.send_message(mid, chat_id, resp)
-        return {"success": True}
-
+        lang, txt = body[11:].split("|",1)
+        _fn_translate(mid, chat_id, lang.strip(), txt.strip()); return {"success": True}
     if low == "/joke":
-        try:
-            joke = requests.get("https://official-joke-api.appspot.com/random_joke", timeout=5).json()
-            client.send_message(mid, chat_id, f"{joke['setup']}\n\n{joke['punchline']}")
-        except:
-            client.send_message(mid, chat_id, generate_llm("Tell me a short, funny joke."))
-        return {"success": True}
-
+        _fn_joke(mid, chat_id); return {"success": True}
     if low.startswith("/weather "):
-        loc = body[9:].strip().replace(" ", "+")
-        try:
-            raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-            prompt = (
-                f"Convert this weather report into Celsius and craft a short, creative, "
-                f"beautiful weather report with emojis:\n\n{raw}"
-            )
-            report = generate_llm(prompt)
-            client.send_message(mid, chat_id, report)
-            voice_prompt = f"Provide only the following weather report as speech: {report}"
-            task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":voice_prompt})
-        except:
-            client.send_message(mid, chat_id, "Could not fetch weather.")
-        return {"success": True}
-
+        _fn_weather(mid, chat_id, body[9:].strip().replace(" ","+")); return {"success": True}
     if low.startswith("/weatherpoem "):
-        loc = body[13:].strip().replace(" ", "+")
-        try:
-            raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-            poem = generate_llm(f"Write a short, poetic weather summary in Celsius based on this:\n\n{raw}")
-            client.send_message(mid, chat_id, poem)
-            voice_prompt = f"Speak only this poetic weather summary: {poem}"
-            task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":voice_prompt})
-        except:
-            client.send_message(mid, chat_id, "Could not fetch weather.")
-        return {"success": True}
-
+        _fn_weather_poem(mid, chat_id, body[13:].strip().replace(" ","+")); return {"success": True}
     if low == "/inspire":
-        quote = generate_llm(f"Give me a short inspirational unique quote with seed {random.randint(0,1e6)}.")
-        client.send_message(mid, chat_id, f"✨ {quote}")
-        return {"success": True}
-
+        _fn_inspire(mid, chat_id); return {"success": True}
     if low == "/trivia":
-        raw = generate_llm(
-            f"Generate a unique trivia Q&A in JSON:\n"
-            '{"question":"...","answer":"..."}'
-        )
-        try:
-            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}
-
+        _fn_trivia(mid, chat_id); return {"success": True}
     if low.startswith("/answer"):
-        resp = body[7:].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?"
-                )
-                client.send_message(mid, chat_id, verdict)
-            else:
-                client.send_message(mid, chat_id, f"💡 Answer: {qa['answer']}")
-        else:
-            client.send_message(mid, chat_id, "No active trivia. `/trivia` to start.")
-        return {"success": True}
-
+        _fn_answer(mid, chat_id, body[7:].strip()); return {"success": True}
     if low.startswith("/meme "):
-        client.send_message(mid, chat_id, "🎨 Generating your meme...")
-        task_queue.put({"type":"image","message_id":mid,"chat_id":chat_id,"prompt":f"meme: {body[6:].strip()}"})
-        return {"success": True}
-
+        _fn_meme(mid, chat_id, body[6:].strip()); return {"success": True}
     if low.startswith("/poll "):
-        parts = body[6:].split("|")
-        if len(parts) < 3:
-            client.send_message(mid, chat_id, "Use `/poll Q|A|B`")
-        else:
-            q, *opts = [p.strip() for p in parts]
-            polls[chat_id] = {"question":q,"options":opts,"votes":{i+1:0 for i in range(len(opts))},"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}
-
+        parts = [p.strip() for p in body[6:].split("|")]
+        _fn_poll(mid, chat_id, parts[0], parts[1:]); return {"success": True}
     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:
-                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}
-
+        _fn_poll_vote(mid, chat_id,
+                      data["senderData"]["sender"],
+                      int(low)); return {"success": True}
     if low == "/results":
-        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:
-            client.send_message(mid, chat_id, "No active poll.")
-        return {"success": True}
-
+        _fn_poll_results(mid, chat_id); return {"success": True}
     if low == "/endpoll":
-        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:
-            client.send_message(mid, chat_id, "No active poll.")
-        return {"success": True}
-
+        _fn_poll_end(mid, chat_id); return {"success": True}
     if low.startswith("/gen"):
-        parts = body[4:].split("|", 1)
+        parts = body[4:].split("|",1)
         prompt = parts[0].strip()
-        count = BotConfig.DEFAULT_IMAGE_COUNT
-        if len(parts) > 1 and parts[1].strip().isdigit():
-            count = int(parts[1].strip())
-        if not prompt:
-            client.send_message(mid, chat_id, "Use `/gen <prompt>|<count>`")
-        else:
-            client.send_message(mid, chat_id, f"✨ Generating {count} image(s)...")
-            task_queue.put({
-                "type":"image","message_id":mid,"chat_id":chat_id,
-                "prompt":prompt,"num_images":count
-            })
+        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}
 
-    # Fallback → voice reply
-    reply = generate_llm(body)
-    client.send_message(mid, chat_id, reply)
-    voice_prompt = f"Speak only this dialog: {reply}"
-    task_queue.put({"type":"audio","message_id":mid,"chat_id":chat_id,"prompt":voice_prompt})
+    # 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})
+    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})
+
     return {"success": True}
 
 @app.get("/", response_class=PlainTextResponse)

config.yaml

@@ -19,9 +19,57 @@ config:
         • /results — show poll results
         • /endpoll — end the poll
       Use a concise, friendly tone. If a command is malformed, gently ask the user to correct it.
-      For any other message, respond via voice or text.
+      For any other message, you can either chat normally or invoke one of your tools.
     char: Eve
 
+    # Tell your LLM client to expose these functions
+    function_calling: auto
+
+    functions:
+      - name: generate_image
+        description: Generate one or more images from a prompt.
+        parameters:
+          type: object
+          properties:
+            prompt:
+              type: string
+              description: The text prompt to generate an image for
+            count:
+              type: integer
+              description: Number of images to generate
+          required:
+            - prompt
+
+      - name: send_text
+        description: Send a plain text reply back to the user.
+        parameters:
+          type: object
+          properties:
+            message:
+              type: string
+              description: The text content to send
+          required:
+            - message
+
+  bot:
+    default_image_count: 4
+    skip:
+      mentions: true
+      quotes:   true
+
+  image:
+    model: flux
+    width: 1920
+    height: 1080
+    enhance: true
+    safe: false
+    nologo: true
+
+  voice:
+    model: openai-audio
+    voice: coral
+
+
   SD:
     steps: 30
     negative_prompt: low quality, lowres, low details, oversaturated, undersaturated, underexposed,blurry, grainy, morbid, ugly, asymmetrical, mutated malformed, mutilated, poorly lit, bad shadow, draft, cropped, out of frame, cut off, jpeg artifacts, out of focus, glitch, duplicate,bad body parts, bad anatomy, bad hands, bad face, bad eyes, bad mouth, bad ears, bad legs, ugly face, ugly eyes, watermark, text, error, missing fingers