Refactor app.py to improve function signatures and enhance intent routing; update requirements.txt to ensure pydantic is included.

app.py

@@ -4,11 +4,14 @@ import requests
 import logging
 import queue
 import json
-import random
+from typing import List, Optional, Union, Literal
 from collections import defaultdict, deque
 from concurrent.futures import ThreadPoolExecutor
+
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel, Field, ValidationError
+
 from FLUX import generate_image
 from VoiceReply import generate_voice_reply
 from polLLM import generate_llm
@@ -39,7 +42,7 @@ _thread_ctx = threading.local()
 def set_thread_context(chat_id, sender, message_id):
     _thread_ctx.chat_id     = chat_id
     _thread_ctx.sender      = sender
-    _thread_ctx.message_id = message_id
+    _thread_ctx.message_id  = message_id
 
 def get_thread_context():
     return (
@@ -50,7 +53,6 @@ def get_thread_context():
 
 # --- Conversation History -------------------------------------------------
 
-# keep last 20 messages per (chat_id, sender)
 history = defaultdict(lambda: deque(maxlen=20))
 
 def record_user_message(chat_id, sender, message):
@@ -135,7 +137,6 @@ class BotClient:
             files = [("file",(os.path.basename(file_path),f,mime))]
             return self.send(endpoint, payload, files=files)
 
-# Validate env & init client
 BotConfig.validate()
 client = BotClient(BotConfig)
 
@@ -150,21 +151,9 @@ def worker():
         task = task_queue.get()
         try:
             if task["type"] == "image":
-                _fn_generate_images(
-                    task["message_id"],
-                    task["chat_id"],
-                    task["prompt"],
-                    task.get("num_images", 1),
-                    task.get("width"),
-                    task.get("height")
-                )
-
+                _fn_generate_images(**task)
             elif task["type"] == "audio":
-                _fn_voice_reply(
-                    task["message_id"],
-                    task["chat_id"],
-                    task["prompt"]
-                )
+                _fn_voice_reply(**task)
         except Exception as e:
             logger.error(f"Worker error {task}: {e}")
         finally:
@@ -176,7 +165,6 @@ for _ in range(4):
 # --- Basic Tool Functions -------------------------------------------------
 
 def _fn_send_text(mid, cid, message):
-    """Send text + record + queue voice."""
     client.send_message(mid, cid, message)
     chat_id, sender, _ = get_thread_context()
     if chat_id and sender:
@@ -189,7 +177,6 @@ def _fn_send_text(mid, cid, message):
     })
 
 def _fn_send_accept(mid, cid, message):
-    """Send text + record, but no voice."""
     client.send_message(mid, cid, message)
     chat_id, sender, _ = get_thread_context()
     if chat_id and sender:
@@ -269,23 +256,24 @@ def _fn_poll_end(mid, cid):
     )
     _fn_send_text(mid, cid, txt)
 
-def _fn_generate_images(mid, cid, prompt, count=1, width=None, height=None):
+def _fn_generate_images(message_id: str, chat_id: str, prompt: str,
+                        count: int = 1, width: Optional[int] = None,
+                        height: Optional[int] = None, **_):
     for i in range(1, count+1):
         try:
             img, path, ret_p, url = generate_image(
-                prompt, mid, mid, BotConfig.IMAGE_DIR,
+                prompt, message_id, message_id, BotConfig.IMAGE_DIR,
                 width=width, height=height
             )
             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")
+            client.send_media(message_id, chat_id, path, cap, media_type="image")
             os.remove(path)
         except Exception as e:
             logger.warning(f"Img {i}/{count} failed: {e}")
-            _fn_send_text(mid, cid, f"😢 Failed to generate image {i}/{count}.")
-
+            _fn_send_text(message_id, chat_id, f"😢 Failed to generate image {i}/{count}.")
 
-def _fn_voice_reply(mid, cid, prompt):
+def _fn_voice_reply(message_id: str, chat_id: str, prompt: str, **_):
     proc = (
         f"Just say this exactly as written in a flirty, friendly, playful, "
         f"happy and helpful but a little bit clumsy-cute way: {prompt}"
@@ -293,144 +281,158 @@ def _fn_voice_reply(mid, cid, prompt):
     res = generate_voice_reply(proc, 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")
+        client.send_media(message_id, chat_id, path, "", media_type="audio")
         os.remove(path)
     else:
-        _fn_send_text(mid, cid, prompt)
-
-# --- Intent Dispatcher ----------------------------------------------------
-
-FUNCTION_SCHEMA = {
-    "summarize":      {"description":"Summarize text",     "params":["text"]},
-    "translate":      {"description":"Translate text",     "params":["lang","text"]},
-    "joke":           {"description":"Tell a joke",        "params":[]},
-    "weather":        {"description":"Weather report",     "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","width","height"]
-   },
-    "send_text":      {"description":"Send plain text",    "params":["message"]}}
-
-class IntentDispatcher:
-    def __init__(self):
-        self.handlers = {}
-
-    def register(self, action):
-        def decorator(fn):
-            self.handlers[action] = fn
-            return fn
-        return decorator
-
-    def dispatch(self, action, mid, cid, intent):
-        fn = self.handlers.get(action)
-        if not fn:
-            return False
-        fn(mid, cid, intent)
-        return True
-
-dispatcher = IntentDispatcher()
-
-def validate_intent(action, intent):
-    schema = FUNCTION_SCHEMA.get(action)
-    if not schema:
-        return False
-    for p in schema["params"]:
-        if p not in intent:
-            logger.warning(f"Missing param '{p}' for action '{action}'")
-            return False
-    return True
-
-@dispatcher.register("summarize")
-def _h_summarize(mid, cid, intent):
-    _fn_summarize(mid, cid, intent["text"])
-
-@dispatcher.register("translate")
-def _h_translate(mid, cid, intent):
-    _fn_translate(mid, cid, intent["lang"], intent["text"])
-
-@dispatcher.register("joke")
-def _h_joke(mid, cid, intent):
-    _fn_joke(mid, cid)
-
-@dispatcher.register("weather")
-def _h_weather(mid, cid, intent):
-    _fn_weather(mid, cid, intent["location"])
-
-@dispatcher.register("inspire")
-def _h_inspire(mid, cid, intent):
-    _fn_inspire(mid, cid)
-
-@dispatcher.register("meme")
-def _h_meme(mid, cid, intent):
-    _fn_meme(mid, cid, intent["text"])
-
-@dispatcher.register("poll_create")
-def _h_poll_create(mid, cid, intent):
-    _fn_poll_create(mid, cid, intent["question"], intent["options"])
-
-@dispatcher.register("poll_vote")
-def _h_poll_vote(mid, cid, intent):
-    _fn_poll_vote(mid, cid, intent["voter"], intent["choice"])
-
-@dispatcher.register("poll_results")
-def _h_poll_results(mid, cid, intent):
-    _fn_poll_results(mid, cid)
-
-@dispatcher.register("poll_end")
-def _h_poll_end(mid, cid, intent):
-    _fn_poll_end(mid, cid)
-
-@dispatcher.register("generate_image")
-def _h_generate_image(mid, cid, intent):
-    prompt = intent["prompt"]
-    count  = intent.get("count", 1)
-    width  = intent.get("width")
-    height = intent.get("height")
-    _fn_send_accept(mid, cid, f"✨ Generating {count} image(s)…")
-    task_queue.put({
-        "type":       "image",
-        "message_id": mid,
-        "chat_id":    cid,
-        "prompt":     prompt,
-        "num_images": count,
-        "width":      width,
-        "height":     height
-    })
-
-
-@dispatcher.register("send_text")
-def _h_send_text(mid, cid, intent):
-    _fn_send_text(mid, cid, intent["message"])
-
-# --- Intent Routing --------------------------------------------------------
-
-def route_intent(user_input, chat_id, sender):
+        _fn_send_text(message_id, chat_id, prompt)
+
+# --- Pydantic Models for Function Calling --------------------------------
+
+class BaseIntent(BaseModel):
+    action: str
+
+class SummarizeIntent(BaseIntent):
+    action: Literal["summarize"]
+    text: str
+
+class TranslateIntent(BaseIntent):
+    action: Literal["translate"]
+    lang: str
+    text: str
+
+class JokeIntent(BaseIntent):
+    action: Literal["joke"]
+
+class WeatherIntent(BaseIntent):
+    action: Literal["weather"]
+    location: str
+
+class InspireIntent(BaseIntent):
+    action: Literal["inspire"]
+
+class MemeIntent(BaseIntent):
+    action: Literal["meme"]
+    text: str
+
+class PollCreateIntent(BaseIntent):
+    action: Literal["poll_create"]
+    question: str
+    options: List[str]
+
+class PollVoteIntent(BaseIntent):
+    action: Literal["poll_vote"]
+    voter: str
+    choice: int
+
+class PollResultsIntent(BaseIntent):
+    action: Literal["poll_results"]
+
+class PollEndIntent(BaseIntent):
+    action: Literal["poll_end"]
+
+class GenerateImageIntent(BaseIntent):
+    action: Literal["generate_image"]
+    prompt: str
+    count: int = Field(default=1, ge=1)
+    width: Optional[int]
+    height: Optional[int]
+
+class SendTextIntent(BaseIntent):
+    action: Literal["send_text"]
+    message: str
+
+IntentUnion = Union[
+    SummarizeIntent, TranslateIntent, JokeIntent, WeatherIntent,
+    InspireIntent, MemeIntent, PollCreateIntent, PollVoteIntent,
+    PollResultsIntent, PollEndIntent, GenerateImageIntent, SendTextIntent
+]
+
+ACTION_HANDLERS = {
+    "summarize":      lambda mid,cid,**i: _fn_summarize(mid,cid,i["text"]),
+    "translate":      lambda mid,cid,**i: _fn_translate(mid,cid,i["lang"],i["text"]),
+    "joke":           lambda mid,cid,**i: _fn_joke(mid,cid),
+    "weather":        lambda mid,cid,**i: _fn_weather(mid,cid,i["location"]),
+    "inspire":        lambda mid,cid,**i: _fn_inspire(mid,cid),
+    "meme":           lambda mid,cid,**i: _fn_meme(mid,cid,i["text"]),
+    "poll_create":    lambda mid,cid,**i: _fn_poll_create(mid,cid,i["question"],i["options"]),
+    "poll_vote":      lambda mid,cid,**i: _fn_poll_vote(mid,cid,i["voter"],i["choice"]),
+    "poll_results":   lambda mid,cid,**i: _fn_poll_results(mid,cid),
+    "poll_end":       lambda mid,cid,**i: _fn_poll_end(mid,cid),
+    "generate_image": _fn_generate_images,
+    "send_text":      lambda mid,cid,**i: _fn_send_text(mid,cid,i["message"]),
+}
+
+# --- Intent Routing with Fallback ------------------------------------------
+
+def route_intent(user_input: str, chat_id: str, sender: str) -> IntentUnion:
     history_text = get_history_text(chat_id, sender)
     sys_prompt = (
         "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"
-        + "Here’s an example for generating images:\n"
-        + "  {\"action\":\"generate_image\",\"prompt\":\"a red fox\",\"count\":3,\"width\":512,\"height\":512}\n"
-        + "Otherwise return JSON with \"action\":\"send_text\",\"message\":\"...\".\n"
-        "Return only raw JSON."
+        "- summarize(text)\n"
+        "- translate(lang, text)\n"
+        "- joke()\n"
+        "- weather(location)\n"
+        "- inspire()\n"
+        "- meme(text)\n"
+        "- poll_create(question, options)\n"
+        "- poll_vote(voter, choice)\n"
+        "- poll_results()\n"
+        "- poll_end()\n"
+        "- generate_image(prompt, count, width, height)\n"
+        "- send_text(message)\n\n"
+        "Return only raw JSON matching one of these shapes. For example:\n"
+        "  {\"action\":\"generate_image\",\"prompt\":\"a red fox\",\"count\":3,\"width\":512,\"height\":512}\n"
+        "Otherwise, use send_text to reply with plain chat.\n"
     )
     prompt = (
-        f"{sys_prompt}\n\n"
+        f"{sys_prompt}\n"
         f"Conversation so far:\n{history_text}\n\n"
         f"User: {user_input}"
     )
     raw = generate_llm(prompt)
+
+    # 1) Try strict Pydantic parse
     try:
-        return json.loads(raw)
-    except:
-        return {"action":"send_text","message":raw}
+        parsed = json.loads(raw)
+        intent = IntentUnion.parse_obj(parsed)
+        return intent
+    except (json.JSONDecodeError, ValidationError) as e:
+        logger.warning(f"Strict parse failed: {e}. Falling back to lenient.")
+
+    # 2) Lenient: basic JSON get + defaults
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return SendTextIntent(action="send_text", message=raw)
+
+    action = data.get("action")
+    if action in ACTION_HANDLERS:
+        kwargs = {}
+        if action == "generate_image":
+            kwargs["prompt"] = data.get("prompt", "")
+            kwargs["count"] = int(data.get("count", BotConfig.DEFAULT_IMAGE_COUNT))
+            kwargs["width"] = data.get("width")
+            kwargs["height"] = data.get("height")
+        elif action == "send_text":
+            kwargs["message"] = data.get("message", "")
+        elif action == "translate":
+            kwargs["lang"] = data.get("lang", "")
+            kwargs["text"] = data.get("text", "")
+        elif action == "summarize":
+            kwargs["text"] = data.get("text", "")
+        elif action == "weather":
+            kwargs["location"] = data.get("location", "")
+        elif action == "meme":
+            kwargs["text"] = data.get("text", "")
+        elif action == "poll_create":
+            kwargs["question"] = data.get("question", "")
+            kwargs["options"] = data.get("options", [])
+        elif action == "poll_vote":
+            kwargs["voter"] = sender
+            kwargs["choice"] = int(data.get("choice", 0))
+        return IntentUnion.parse_obj({"action": action, **kwargs})
+
+    return SendTextIntent(action="send_text", message=raw)
 
 # --- FastAPI & Webhook ----------------------------------------------------
 
@@ -470,12 +472,8 @@ async def whatsapp_webhook(request: Request):
         return {"success": True}
 
     body = (tmd.get("textMessage") or tmd.get("text","")).strip()
-    ctx  = tmd.get("contextInfo", {})
-
-    # record user message
     record_user_message(chat_id, sender, body)
 
-    # Slash commands
     low = body.lower()
     if low == "/help":
         _fn_send_text(mid, chat_id, help_text)
@@ -524,45 +522,24 @@ async def whatsapp_webhook(request: Request):
             "message_id": mid,
             "chat_id":    chat_id,
             "prompt":     pr,
-            "num_images": ct,
+            "count":      ct,
             "width":      width,
             "height":     height
         })
         return {"success": True}
 
-
-    # Skip mentions
-    if ctx.get("mentionedJidList"):
+    if tmd.get("contextInfo", {}).get("mentionedJidList"):
         return {"success": True}
 
-    # Build effective text (handle quoted replies to the 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','')}\n"
-                f"User:   {ext.get('text','')}"
-            )
-        else:
-            effective = body
-    else:
-        effective = body
+    # Handle quoted replies if needed...
+    effective = body
 
-    # Route intent & dispatch
     intent = route_intent(effective, chat_id, sender)
-    action = intent.get("action")
-
-    if action in FUNCTION_SCHEMA:
-        if not validate_intent(action, intent):
-            _fn_send_text(mid, chat_id, f"❗ Missing parameter(s) for `{action}`.")
-        else:
-            dispatched = dispatcher.dispatch(action, mid, chat_id, intent)
-            if not dispatched:
-                _fn_send_text(mid, chat_id, intent.get("message","Sorry, I couldn't handle that."))
+    handler = ACTION_HANDLERS.get(intent.action)
+    if handler:
+        handler(mid, chat_id, **intent.dict(exclude={"action"}))
     else:
-        # fallback chat
-        _fn_send_text(mid, chat_id, intent.get("message","Sorry, I didn't get that."))
+        _fn_send_text(mid, chat_id, "Sorry, I didn't understand that.")
 
     return {"success": True}
 

requirements.txt

@@ -3,4 +3,5 @@ uvicorn[standard]
 openai
 pillow
 requests
-supabase
+supabase
+pydantic