edit image

app.py

@@ -1,555 +1,534 @@
+"""
+Professional WhatsApp Bot using Green-API
+Author: Assistant
+Description: A comprehensive WhatsApp bot with a professional, class-based structure.
+             Features include image generation, image editing, voice replies,
+             and various utility functions, all handled by an asynchronous task queue.
+"""
+
 import os
 import threading
 import requests
 import logging
 import queue
 import json
-from typing import List, Optional, Union, Literal
+import base64
+from typing import List, Optional, Union, Literal, Dict, Any, Tuple
 from collections import defaultdict, deque
 from concurrent.futures import ThreadPoolExecutor
 
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import JSONResponse, PlainTextResponse
 from pydantic import BaseModel, Field, ValidationError
+import uvicorn
 
+# Assume these are your custom libraries for AI functionalities
 from FLUX import generate_image
 from VoiceReply import generate_voice_reply
-from polLLM import generate_llm, LLMBadRequestError  # assume this exception is raised on 400
-
-# --- Logging Setup ---------------------------------------------------------
+from polLLM import generate_llm, LLMBadRequestError
+import flux_kontext_lib
 
-LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
-logger = logging.getLogger("eve_bot")
-logger.setLevel(LOG_LEVEL)
-
-handler = logging.StreamHandler()
-formatter = logging.Formatter(
-    "%(asctime)s [%(levelname)s] [%(message_id)s/%(sender)s] %(message)s"
-)
-handler.setFormatter(formatter)
-
-class ContextFilter(logging.Filter):
-    def filter(self, record):
-        record.message_id = getattr(record, "message_id", "-")
-        record.sender     = getattr(record, "sender", "-")
-        return True
-
-handler.addFilter(ContextFilter())
-logger.handlers = [handler]
-
-# Thread‐local to carry context through helpers
-_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
-
-def get_thread_context():
-    return (
-        getattr(_thread_ctx, "chat_id", None),
-        getattr(_thread_ctx, "sender", None),
-        getattr(_thread_ctx, "message_id", None),
-    )
+# --- Configuration ---------------------------------------------------------
 
-# --- Conversation History -------------------------------------------------
+class BotConfig:
+    """Manages all bot configuration from environment variables."""
+    GREEN_API_URL: str
+    GREEN_API_TOKEN: str
+    GREEN_API_ID_INSTANCE: str
+    WEBHOOK_AUTH_TOKEN: str
+    
+    IMAGE_DIR: str = "/tmp/whatsapp_images"
+    AUDIO_DIR: str = "/tmp/whatsapp_audio"
+    TEMP_DIR: str = "/tmp/whatsapp_edit"
+    DEFAULT_IMAGE_COUNT: int = 4
+    MAX_HISTORY_SIZE: int = 20
+    WORKER_THREADS: int = 4
+    LOG_LEVEL: str = "INFO"
+
+    def __init__(self):
+        self.GREEN_API_URL = os.getenv("GREEN_API_URL")
+        self.GREEN_API_TOKEN = os.getenv("GREEN_API_TOKEN")
+        self.GREEN_API_ID_INSTANCE = os.getenv("GREEN_API_ID_INSTANCE")
+        self.WEBHOOK_AUTH_TOKEN = os.getenv("WEBHOOK_AUTH_TOKEN")
+        self.LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+        self._validate()
+
+    def _validate(self):
+        """Ensures all required environment variables are set."""
+        missing = [
+            var for var in ("GREEN_API_URL", "GREEN_API_TOKEN", 
+                           "GREEN_API_ID_INSTANCE", "WEBHOOK_AUTH_TOKEN")
+            if not getattr(self, var)
+        ]
+        if missing:
+            raise ValueError(f"Missing required environment variables: {', '.join(missing)}")
 
-history = defaultdict(lambda: deque(maxlen=20))
+# --- Logging Setup ---------------------------------------------------------
 
-def record_user_message(chat_id, sender, message):
-    history[(chat_id, sender)].append(f"User: {message}")
+class LoggerSetup:
+    """Sets up and manages structured logging for the application."""
+    @staticmethod
+    def setup(level: str) -> logging.Logger:
+        logger = logging.getLogger("whatsapp_bot")
+        logger.setLevel(level)
+        logger.handlers.clear()
+
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s [%(levelname)s] [%(chat_id)s] %(funcName)s:%(lineno)d - %(message)s"
+        )
+        handler.setFormatter(formatter)
 
-def record_bot_message(chat_id, sender, message):
-    history[(chat_id, sender)].append(f"Assistant: {message}")
+        class ContextFilter(logging.Filter):
+            def filter(self, record):
+                record.chat_id = ThreadContext.get_context().get("chat_id", "-")
+                return True
 
-def get_history_text(chat_id, sender):
-    return "\n".join(history[(chat_id, sender)])
+        handler.addFilter(ContextFilter())
+        logger.addHandler(handler)
+        return logger
 
-def clear_history(chat_id, sender):
-    history[(chat_id, sender)].clear()
+# --- Thread Context Management ---------------------------------------------
 
-# --- Bot Config & Client --------------------------------------------------
+class ThreadContext:
+    """Manages thread-local context for chat and message IDs."""
+    _context = threading.local()
 
-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]"
-    BOT_JID               = os.getenv("BOT_JID")
-    IMAGE_DIR             = "/tmp/images"
-    AUDIO_DIR             = "/tmp/audio"
-    DEFAULT_IMAGE_COUNT   = 4
+    @classmethod
+    def set_context(cls, chat_id: str, message_id: str):
+        cls._context.chat_id = chat_id
+        cls._context.message_id = message_id
 
     @classmethod
-    def validate(cls):
-        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)}")
+    def get_context(cls) -> Dict[str, Optional[str]]:
+        return {
+            "chat_id": getattr(cls._context, "chat_id", None),
+            "message_id": getattr(cls._context, "message_id", None),
+        }
 
-class BotClient:
-    def __init__(self, cfg: BotConfig):
-        self.cfg = cfg
-        self.session = requests.Session()
+# --- Conversation History -------------------------------------------------
 
-    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 i 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:
-                logger.warning(f"{endpoint} attempt {i}/{retries} failed: {e}")
-        return {"error":"failed"}
-
-    def send_message(self, message_id, chat_id, text):
-        return self.send("sendMessage", {
-            "chatId": chat_id,
-            "message": text,
-            "quotedMessageId": message_id
-        })
+class ConversationManager:
+    """Manages conversation history for each chat."""
+    def __init__(self, max_size: int):
+        self.history = defaultdict(lambda: deque(maxlen=max_size))
 
-    def send_message_to(self, chat_id, text):
-        return self.send("sendMessage", {
-            "chatId": chat_id,
-            "message": text
-        })
+    def add_user_message(self, chat_id: str, message: str):
+        self.history[chat_id].append(f"User: {message}")
 
-    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)
+    def add_bot_message(self, chat_id: str, message: str):
+        self.history[chat_id].append(f"Assistant: {message}")
 
-BotConfig.validate()
-client = BotClient(BotConfig)
+    def get_history_text(self, chat_id: str) -> str:
+        return "\n".join(self.history[chat_id])
 
-# --- Threading & Queues ---------------------------------------------------
+    def clear_history(self, chat_id: str):
+        self.history[chat_id].clear()
 
-task_queue = queue.Queue()
-executor   = ThreadPoolExecutor(max_workers=4)
+# --- Green-API Client -----------------------------------------------------
 
-def worker():
-    while True:
-        task = task_queue.get()
-        try:
-            if task["type"] == "image":
-                _fn_generate_images(**task)
-            elif task["type"] == "audio":
-                _fn_voice_reply(**task)
-        except Exception as e:
-            logger.error(f"Worker error {task}: {e}")
-        finally:
-            task_queue.task_done()
-
-for _ in range(4):
-    threading.Thread(target=worker, daemon=True).start()
-
-# --- Basic Tool Functions -------------------------------------------------
-
-def _fn_send_text(mid, cid, message):
-    client.send_message(mid, cid, message)
-    chat_id, sender, _ = get_thread_context()
-    if chat_id and sender:
-        record_bot_message(chat_id, sender, message)
-    task_queue.put({
-        "type":       "audio",
-        "message_id": mid,
-        "chat_id":    cid,
-        "prompt":     message
-    })
-
-def _fn_send_accept(mid, cid, message):
-    client.send_message(mid, cid, message)
-    chat_id, sender, _ = get_thread_context()
-    if chat_id and sender:
-        record_bot_message(chat_id, sender, message)
-
-def _fn_summarize(mid, cid, text):
-    summary = generate_llm(f"Summarize:\n\n{text}")
-    _fn_send_text(mid, cid, summary)
-
-def _fn_translate(mid, cid, lang, text):
-    resp = generate_llm(f"Translate to {lang}:\n\n{text}")
-    _fn_send_text(mid, cid, resp)
-
-def _fn_joke(mid, cid):
-    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 joke.")
-    _fn_send_text(mid, cid, joke)
-
-def _fn_weather(mid, cid, loc):
-    raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-    report = generate_llm(f"Give a weather report in °C:\n\n{raw}")
-    _fn_send_text(mid, cid, report)
-
-def _fn_inspire(mid, cid):
-    quote = generate_llm("Give me a unique, random short inspirational quote.")
-    _fn_send_text(mid, cid, f"✨ {quote}")
-
-def _fn_meme(mid, cid, txt):
-    _fn_send_accept(mid, cid, "🎨 Generating meme…")
-    task_queue.put({
-        "type":       "image",
-        "message_id": mid,
-        "chat_id":    cid,
-        "prompt":     f"meme: {txt}"
-    })
-
-def _fn_generate_images(
-    message_id: str,
-    chat_id: str,
-    prompt: str,
-    count: int = 1,
-    width: Optional[int] = None,
-    height: Optional[int] = None,
-    **_
-):
-    _fn_send_accept(message_id, chat_id, f"✨ Generating {count if count != 1 else 'a'} image{'s' if count != 1 else ''}...")
-    for i in range(1, count+1):
-        try:
-            img, path, ret_p, url = generate_image(
-                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(message_id, chat_id, path, cap, media_type="image")
-            os.remove(path)
-        except Exception as e:
-            if "Timed out" in str(e):
-                logger.warning("Image generation timed out.")
-            else:
-                logger.warning(f"Img {i}/{count} failed: {e}")
-                _fn_send_text(message_id, chat_id, f"😢 Failed to generate image {i}/{count}.")
-
-def _fn_voice_reply(
-    message_id: str,
-    chat_id: str,
-    prompt: str,
-    **_
-):
-    """
-    Try to generate an audio reply once. If it fails (e.g. a 400),
-    send the text fallback directly (no further retry).
-    """
-    proc = (
-        f"Just say this exactly as written in a friendly, playful, "
-        f"happy and helpful but a little bit clumsy-cute way: {prompt}"
-    )
-    try:
-        res = generate_voice_reply(proc, model="openai-audio", voice="coral", audio_dir=BotConfig.AUDIO_DIR)
-    except Exception as e:
-        logger.warning(f"Audio generation failed ({e}); sending text only.")
-        return
+class GreenApiClient:
+    """A client for interacting with the Green-API for WhatsApp."""
+    def __init__(self, config: BotConfig, logger: logging.Logger):
+        self.config = config
+        self.logger = logger
+        self.session = requests.Session()
+        self.base_url = (
+            f"{self.config.GREEN_API_URL}/waInstance"
+            f"{self.config.GREEN_API_ID_INSTANCE}"
+        )
 
-    if res and res[0]:
-        path, _ = res
-        client.send_media(message_id, chat_id, path, "", media_type="audio")
-        os.remove(path)
-    else:
-        logger.warning("Audio reply failed")
+    def _request(self, method: str, endpoint: str, **kwargs) -> Optional[Dict[str, Any]]:
+        """Makes a request to the Green-API with retries."""
+        url = f"{self.base_url}/{endpoint}/{self.config.GREEN_API_TOKEN}"
+        for attempt in range(3):
+            try:
+                response = self.session.request(method, url, timeout=20, **kwargs)
+                response.raise_for_status()
+                return response.json()
+            except requests.RequestException as e:
+                self.logger.warning(
+                    f"API request to {endpoint} failed (attempt {attempt + 1}): {e}"
+                )
+        self.logger.error(f"API request to {endpoint} failed after all retries.")
+        return None
+
+    def send_message(self, chat_id: str, text: str, quoted_message_id: str = None):
+        payload = {"chatId": chat_id, "message": text}
+        if quoted_message_id:
+            payload["quotedMessageId"] = quoted_message_id
+        return self._request("POST", "sendMessage", json=payload)
+
+    def send_file(self, chat_id: str, file_path: str, caption: str = "", quoted_message_id: str = None):
+        """Uploads and sends a file (image or audio)."""
+        filename = os.path.basename(file_path)
+        payload = {"chatId": chat_id, "caption": caption}
+        if quoted_message_id:
+            payload["quotedMessageId"] = quoted_message_id
+
+        with open(file_path, "rb") as f:
+            files = {"file": (filename, f)}
+            return self._request("POST", "sendFileByUpload", data=payload, files=files)
+
+    def download_file(self, url: str) -> Optional[bytes]:
+        """Downloads a file from a given URL."""
+        try:
+            response = self.session.get(url, timeout=30)
+            response.raise_for_status()
+            return response.content
+        except requests.RequestException as e:
+            self.logger.error(f"Failed to download file from {url}: {e}")
+            return None
 
-# --- Pydantic Models for Function Calling --------------------------------
+# --- Pydantic Models for Intent Recognition --------------------------------
 
 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 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 EditImageIntent(BaseIntent): action: Literal["edit_image"]; prompt: str
 
 class GenerateImageIntent(BaseModel):
     action: Literal["generate_image"]
     prompt: str
-    count: int = Field(default=1, ge=1)
-    width: Optional[int]
-    height: Optional[int]
+    count: int = Field(default=1, ge=1, le=10)
+    width: Optional[int] = Field(default=None, ge=512, le=2048)
+    height: Optional[int] = Field(default=None, ge=512, le=2048)
 
-class SendTextIntent(BaseModel):
+class SendTextIntent(BaseIntent):
     action: Literal["send_text"]
     message: str
 
-# list of all intent models
-INTENT_MODELS = [
-    SummarizeIntent, TranslateIntent, JokeIntent, WeatherIntent,
-    InspireIntent, MemeIntent, 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"]),
-    "generate_image": _fn_generate_images,
-    "send_text":      lambda mid,cid,**i: _fn_send_text(mid,cid,i["message"]),
-}
-
-# --- Intent Routing with Fallback & History‐Reset on 400 -------------------
-
-def route_intent(user_input: str, chat_id: str, sender: str):
-    history_text = get_history_text(chat_id, sender)
-    sys_prompt = (
-        "You never perform work yourself—you only invoke one of the available functions."
-        "When the user asks for something that matches a function signature, you must return exactly one JSON object matching that function’s parameters—and nothing else. "
-        "Do not wrap it in markdown, do not add extra text, and do not show the JSON to the user. "
-        "If the user’s request does not match any function, reply in plain text, and never mention JSON or internal logic.\n\n"
-        "- summarize(text)\n"
-        "- translate(lang, text)\n"
-        "- joke()\n"
-        "- weather(location)\n"
-        "- inspire()\n"
-        "- meme(text)\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\":4,\"width\":1920,\"height\":1080}\n"
-        "Another Example:\n"
-        "   {\"action\":\"send_text\",\"message\":\"Hello!\"}\n\n"
-        "Otherwise, use send_text to reply with plain chat and you should only return one json for the current message not for previous conversations.\n"
-        f"Conversation so far:\n{history_text}\n\n current message: User: {user_input}"
-    )
+# --- Intent Router --------------------------------------------------------
 
-    try:
-        raw = generate_llm(sys_prompt)
-    except LLMBadRequestError:
-        clear_history(chat_id, sender)
-        return SendTextIntent(action="send_text", message="Oops, I lost my train of thought—let’s start fresh!")
+class IntentRouter:
+    """Recognizes user intent using an LLM and routes to appropriate actions."""
+    INTENT_MODELS = [
+        SummarizeIntent, TranslateIntent, JokeIntent, WeatherIntent,
+        InspireIntent, MemeIntent, GenerateImageIntent, EditImageIntent, SendTextIntent
+    ]
 
-    logger.debug(f"LLM raw response: {raw}")
+    def __init__(self, conv_manager: ConversationManager, logger: logging.Logger):
+        self.conv_manager = conv_manager
+        self.logger = logger
 
-    try:
-        parsed = json.loads(raw)
-        logger.debug(f"Parsed JSON: {parsed}")
-    except json.JSONDecodeError:
-        return SendTextIntent(action="send_text", message=raw)
+    def get_intent(self, user_input: str, chat_id: str) -> BaseIntent:
+        history_text = self.conv_manager.get_history_text(chat_id)
+        system_prompt = self._build_system_prompt(history_text, user_input)
 
-    for M in INTENT_MODELS:
-        try:
-            intent = M.model_validate(parsed)
-            logger.debug(f"Matched intent model: {M.__name__} with data {parsed}")
-            return intent
-        except ValidationError:
-            continue
-
-    logger.warning("Strict parse failed for all models, falling back to lenient")
-
-    action = parsed.get("action")
-    if action in ACTION_HANDLERS:
-        data = parsed
-        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","")
         try:
-            model = next(
-                m for m in INTENT_MODELS
-                if getattr(m, "__fields__", {}).get("action").default == action
-            )
-            intent = model.model_validate({"action":action, **kwargs})
-            logger.debug(f"Leniently matched intent model: {model.__name__} with kwargs {kwargs}")
-            return intent
-        except Exception as e:
-            logger.error(f"Lenient parsing into Pydantic failed: {e}")
-            return SendTextIntent(action="send_text", message=raw)
-
-    return SendTextIntent(action="send_text", message=raw)
-
-# --- FastAPI & Webhook ----------------------------------------------------
-
-app = FastAPI()
-help_text = (
-    "*🤖 Eve's Command Center:*\n\n"
-    "🔹 `/help` - Show this help message\n"
-    "🔹 `/summarize <text>` - Get a quick summary of the text\n"
-    "🔹 `/translate <lang>|<text>` - Convert your text to the specified language\n"
-    "🔹 `/joke` - Enjoy a light-hearted joke\n"
-    "🔹 `/weather <location>` - Check the current weather for your location\n"
-    "🔹 `/inspire` - Receive an uplifting inspirational quote\n"
-    "🔹 `/meme <text>` - Generate a meme based on your text\n"
-    "🔹 `/gen <prompt>|<count>|<width>|<height>` - Generate creative images\n\n"
-    "Just type your message or command to start interacting with Eve!"
-)
-
-@app.post("/whatsapp")
-async def whatsapp_webhook(request: Request):
-    data = await request.json()
-    logger.debug(f"Incoming webhook payload: {json.dumps(data)}")
-
-    if request.headers.get("Authorization") != f"Bearer {BotConfig.WEBHOOK_AUTH_TOKEN}":
-        raise HTTPException(403, "Unauthorized")
+            raw_response = generate_llm(system_prompt)
+        except LLMBadRequestError:
+            self.conv_manager.clear_history(chat_id)
+            return SendTextIntent(action="send_text", message="Oops! Let's start fresh! 🌟")
+
+        return self._parse_response(raw_response)
+
+    def _build_system_prompt(self, history: str, user_input: str) -> str:
+        return (
+            "You are a function dispatcher. You only invoke functions by returning a single JSON object.\n"
+            "Available functions:\n"
+            "- summarize(text): Summarize given text\n"
+            "- translate(lang, text): Translate text to a language\n"
+            "- joke(): Tell a random joke\n"
+            "- weather(location): Get weather for a location\n"
+            "- inspire(): Get an inspirational quote\n"
+            "- meme(text): Generate a meme from text\n"
+            "- generate_image(prompt, count, width, height): Generate images\n"
+            "- edit_image(prompt): Edit an image (requires replying to an image)\n"
+            "- send_text(message): Send a plain text response\n\n"
+            "Return only raw JSON. Examples:\n"
+            '{"action":"generate_image","prompt":"a red fox","count":2}\n'
+            '{"action":"edit_image","prompt":"make the sky purple"}\n'
+            '{"action":"send_text","message":"Hello there!"}\n\n'
+            f"Conversation history:\n{history}\n\n"
+            f"Current message: User: {user_input}"
+        )
 
-    try:
-        chat_id = data["senderData"]["chatId"]
-        sender  = data["senderData"]["sender"]
-        mid     = data["idMessage"]
-    except KeyError:
+    def _parse_response(self, raw_response: str) -> BaseIntent:
         try:
-            chat_id = data["chatId"]
-            sender  = data["sender"]
-            mid     = data["messageId"]
-        except KeyError:
-            logger.error("Cannot find chat_id/sender/message_id in payload")
-            return {"success": False, "error": "bad payload"}
-
-    set_thread_context(chat_id, sender, mid)
-    logger.debug(f"Received webhook for message {mid} from {sender}")
-
-    if chat_id != BotConfig.BOT_GROUP_CHAT or data.get("typeWebhook") != "incomingMessageReceived":
-        return {"success": True}
-
-    md  = data.get("messageData", {})
-    tmd = md.get("textMessageData") or md.get("extendedTextMessageData")
-    if not tmd:
-        return {"success": True}
-
-    body = (tmd.get("textMessage") or tmd.get("text","")).strip()
-    record_user_message(chat_id, sender, body)
-    logger.debug(f"User message: {body}")
-
-    low = body.lower()
-    if low == "/help":
-        _fn_send_text(mid, chat_id, help_text)
-        return {"success": True}
-    if low.startswith("/summarize "):
-        _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}
-    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}
-    if low.startswith("/meme "):
-        _fn_meme(mid, chat_id, body[6:].strip())
-        return {"success": True}
-    if low.startswith("/gen"):
-        parts = body[4:].split("|")
-        pr = parts[0].strip()
-        count = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else BotConfig.DEFAULT_IMAGE_COUNT
-        width = int(parts[2]) if len(parts) > 2 and parts[2].isdigit() else None
-        height = int(parts[3]) if len(parts) > 3 and parts[3].isdigit() else None
-        _fn_send_accept(mid, chat_id, f"✨ Generating {count if count != 1 else 'a'} image{'s' if count != 1 else ''}...")
-        task_queue.put({
-            "type":       "image",
-            "message_id": mid,
-            "chat_id":    chat_id,
-            "prompt":     pr,
-            "count":      count,
-            "width":      width,
-            "height":     height
-        })
-        return {"success": True}
-
-    if tmd.get("contextInfo", {}).get("mentionedJidList"):
-        return {"success": True}
-
-    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','')}"
+            parsed = json.loads(raw_response)
+            for model in self.INTENT_MODELS:
+                try:
+                    return model.model_validate(parsed)
+                except ValidationError:
+                    continue
+        except json.JSONDecodeError:
+            pass
+        
+        # Fallback for non-JSON or unparsable responses
+        return SendTextIntent(action="send_text", message=raw_response)
+
+# --- Main Application Class ------------------------------------------------
+
+class WhatsAppBot:
+    def __init__(self, config: BotConfig):
+        self.config = config
+        self.logger = LoggerSetup.setup(config.LOG_LEVEL)
+        self.api_client = GreenApiClient(config, self.logger)
+        self.conv_manager = ConversationManager(config.MAX_HISTORY_SIZE)
+        self.intent_router = IntentRouter(self.conv_manager, self.logger)
+        self.task_queue = queue.Queue()
+        self.fastapi_app = FastAPI(title="WhatsApp Eve Bot", version="2.0.0")
+        self._setup_routes()
+        self._start_workers()
+
+    def _setup_routes(self):
+        @self.fastapi_app.post("/whatsapp")
+        async def webhook(request: Request):
+            if request.headers.get("Authorization") != f"Bearer {self.config.WEBHOOK_AUTH_TOKEN}":
+                raise HTTPException(403, "Unauthorized")
+            
+            payload = await request.json()
+            self.logger.debug(f"Incoming webhook: {json.dumps(payload)}")
+
+            # Process valid incoming messages in the background
+            if payload.get("typeWebhook") == "incomingMessageReceived":
+                executor.submit(self._process_incoming_message, payload)
+
+            return JSONResponse(content={"status": "received"})
+
+        @self.fastapi_app.api_route("/health", methods=["GET", "HEAD"])
+        def health_check():
+            return JSONResponse(content={"status": "healthy"})
+
+    def _start_workers(self):
+        for i in range(self.config.WORKER_THREADS):
+            threading.Thread(target=self._worker, name=f"Worker-{i}", daemon=True).start()
+        self.logger.info(f"Started {self.config.WORKER_THREADS} worker threads.")
+    
+    def _worker(self):
+        """Worker thread to process tasks from the queue."""
+        while True:
+            task = self.task_queue.get()
+            try:
+                handler = getattr(self, f"_task_{task['type']}", None)
+                if handler:
+                    handler(task)
+                else:
+                    self.logger.warning(f"Unknown task type: {task['type']}")
+            except Exception as e:
+                self.logger.error(f"Error processing task {task['type']}: {e}", exc_info=True)
+            finally:
+                self.task_queue.task_done()
+
+    def _process_incoming_message(self, payload: Dict[str, Any]):
+        """Main logic for handling an incoming message payload."""
+        try:
+            chat_id = payload["senderData"]["chatId"]
+            message_id = payload["idMessage"]
+            ThreadContext.set_context(chat_id, message_id)
+
+            message_data = payload.get("messageData", {})
+            type_message = message_data.get("typeMessage")
+            
+            text = ""
+            if type_message == "textMessage":
+                text = message_data["textMessageData"]["textMessage"]
+            elif type_message == "extendedTextMessage":
+                text = message_data["extendedTextMessageData"]["text"]
+
+            text = text.strip()
+            if not text:
+                return
+            
+            self.conv_manager.add_user_message(chat_id, text)
+
+            # Handle direct commands
+            if text.startswith('/'):
+                self._handle_command(chat_id, message_id, text, payload)
+            else:
+                # Handle natural language and replies
+                self._handle_natural_language(chat_id, message_id, text, payload)
+        
+        except Exception as e:
+            self.logger.error(f"Failed to process message payload: {e}", exc_info=True)
+
+    def _handle_command(self, chat_id, message_id, text, payload):
+        """Processes direct slash commands."""
+        parts = text.lower().split()
+        command = parts[0]
+        args = text.split(maxsplit=1)[1] if len(parts) > 1 else ""
+
+        if command == "/help":
+            help_text = (
+                "*🤖 Eve's Command Center:*\n\n"
+                "🔹 `/help` - Show this help message\n"
+                "🔹 `/gen <prompt>` - Generate an image\n"
+                "🔹 `/edit <prompt>` - Reply to an image to edit it\n"
+                "🔹 `/joke` - Get a random joke\n"
+                "🔹 `/inspire` - Receive an inspirational quote\n"
+                "🔹 `/weather <location>` - Check the weather\n\n"
+                "You can also just chat with me naturally!"
             )
+            self.api_client.send_message(chat_id, help_text, message_id)
+        elif command == "/gen":
+            self.task_queue.put({"type": "generate_image", "chat_id": chat_id, "message_id": message_id, "prompt": args})
+        elif command == "/edit":
+            self._dispatch_edit_image(chat_id, message_id, args, payload)
+        elif command == "/joke":
+            self._task_joke({"chat_id": chat_id, "message_id": message_id})
+        elif command == "/inspire":
+            self._task_inspire({"chat_id": chat_id, "message_id": message_id})
+        elif command == "/weather":
+            self._task_weather({"chat_id": chat_id, "message_id": message_id, "location": args})
         else:
-            effective = body
-    else:
-        effective = body
-
-    intent = route_intent(effective, chat_id, sender)
-    logger.debug(f"Final intent: {intent}")
-    handler = ACTION_HANDLERS.get(intent.action)
-    if handler:
-        kwargs = intent.model_dump(exclude={"action"})
-        logger.debug(f"Dispatching action '{intent.action}' with args {kwargs}")
-        handler(mid, chat_id, **kwargs)
-    else:
-        logger.warning(f"No handler for action '{intent.action}'")
-        _fn_send_text(mid, chat_id, "Sorry, I didn't understand that.")
+            self.api_client.send_message(chat_id, "Unknown command. Type /help for options.", message_id)
+            
+    def _handle_natural_language(self, chat_id, message_id, text, payload):
+        """Processes natural language using the intent router."""
+        intent = self.intent_router.get_intent(text, chat_id)
+        
+        task_data = {
+            "chat_id": chat_id, 
+            "message_id": message_id, 
+            **intent.model_dump()
+        }
+        
+        if intent.action == "edit_image":
+            # This action needs the original payload to find the replied-to image
+            self._dispatch_edit_image(chat_id, message_id, intent.prompt, payload)
+        elif hasattr(self, f"_task_{intent.action}"):
+            self.task_queue.put({"type": intent.action, **task_data})
+        else:
+            self.logger.warning(f"No handler found for intent action: {intent.action}")
+            self.api_client.send_message(chat_id, "Sorry, I'm not sure how to handle that.", message_id)
+            
+    def _dispatch_edit_image(self, chat_id, message_id, prompt, payload):
+        """Checks for a replied-to image and dispatches the edit task."""
+        quoted_message = payload.get("messageData", {}).get("quotedMessage")
+        if not quoted_message or quoted_message.get("typeMessage") != "imageMessage":
+            self.api_client.send_message(chat_id, "To edit an image, please reply to it with your instructions.", message_id)
+            return
+            
+        download_url = quoted_message["imageMessage"]["downloadUrl"]
+        self.task_queue.put({
+            "type": "edit_image",
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "prompt": prompt,
+            "download_url": download_url
+        })
+        
+    # --- Task Handler Methods ---
+
+    def _task_send_text(self, task: Dict[str, Any]):
+        chat_id, message_id, message = task["chat_id"], task["message_id"], task["message"]
+        self.api_client.send_message(chat_id, message, message_id)
+        self.conv_manager.add_bot_message(chat_id, message)
+        self.task_queue.put({"type": "voice_reply", "chat_id": chat_id, "message_id": message_id, "text": message})
+
+    def _task_generate_image(self, task: Dict[str, Any]):
+        chat_id, mid, prompt, count = task["chat_id"], task["message_id"], task["prompt"], task.get("count", 1)
+        self.api_client.send_message(chat_id, f"🎨 Generating {count} image(s) for: \"{prompt}\"...", mid)
+        
+        for i in range(count):
+            try:
+                _, path, _, url = generate_image(prompt, mid, str(i), self.config.IMAGE_DIR, width=task.get("width"), height=task.get("height"))
+                caption = f"✨ Image {i+1}/{count}: {prompt}"
+                self.api_client.send_file(chat_id, path, caption, mid)
+                os.remove(path)
+            except Exception as e:
+                self.logger.error(f"Image generation {i+1} failed: {e}")
+                self.api_client.send_message(chat_id, f"😢 Failed to generate image {i+1}.", mid)
+    
+    def _task_edit_image(self, task: Dict[str, Any]):
+        chat_id, mid, prompt, url = task["chat_id"], task["message_id"], task["prompt"], task["download_url"]
+        self.api_client.send_message(chat_id, f"🎨 Editing image with prompt: \"{prompt}\"...", mid)
+
+        input_path, output_path = None, None
+        try:
+            image_data = self.api_client.download_file(url)
+            if not image_data:
+                raise ValueError("Failed to download image.")
+
+            input_path = os.path.join(self.config.TEMP_DIR, f"input_{mid}.jpg")
+            output_path = os.path.join(self.config.TEMP_DIR, f"output_{mid}.jpg")
+            
+            with open(input_path, 'wb') as f:
+                f.write(image_data)
+            
+            flux_kontext_lib.generate_image(prompt, input_path, download_path=output_path)
+            
+            if os.path.exists(output_path):
+                caption = f"✨ Edited: {prompt}"
+                self.api_client.send_file(chat_id, output_path, caption, mid)
+            else:
+                raise ValueError("Edited image file not found.")
 
-    return {"success": True}
+        except Exception as e:
+            self.logger.error(f"Image editing task failed: {e}")
+            self.api_client.send_message(chat_id, "😢 Sorry, I failed to edit the image.", mid)
+        finally:
+            for path in [input_path, output_path]:
+                if path and os.path.exists(path):
+                    os.remove(path)
+    
+    def _task_voice_reply(self, task: Dict[str, Any]):
+        text = task["text"]
+        prompt = f"Say this in a friendly, playful, and slightly clumsy-cute way: {text}"
+        try:
+            result = generate_voice_reply(prompt, model="openai-audio", voice="coral", audio_dir=self.config.AUDIO_DIR)
+            if result and result[0]:
+                path, _ = result
+                self.api_client.send_file(task["chat_id"], path, quoted_message_id=task["message_id"])
+                os.remove(path)
+        except Exception as e:
+            self.logger.warning(f"Voice reply generation failed: {e}")
 
-@app.get("/", response_class=PlainTextResponse)
-def index():
-    return "Server is running!"
+    def _task_joke(self, task: Dict[str, Any]):
+        try:
+            j = requests.get("https://official-joke-api.appspot.com/random_joke", timeout=5).json()
+            joke = f"{j['setup']}\n\n{j['punchline']}"
+        except Exception:
+            joke = generate_llm("Tell me a short, clean joke.")
+        self._task_send_text({"type": "send_text", **task, "message": f"😄 {joke}"})
+
+    def _task_inspire(self, task: Dict[str, Any]):
+        quote = generate_llm("Give me a unique, short, uplifting inspirational quote with attribution.")
+        self._task_send_text({"type": "send_text", **task, "message": f"✨ {quote}"})
+        
+    def _task_weather(self, task: Dict[str, Any]):
+        location = task.get("location", "New York")
+        try:
+            raw = requests.get(f"http://wttr.in/{location.replace(' ', '+')}?format=4", timeout=10).text
+            report = generate_llm(f"Create a friendly weather report in Celsius from this data:\n\n{raw}")
+            self._task_send_text({"type": "send_text", **task, "message": f"🌤️ Weather for {location}:\n{report}"})
+        except Exception as e:
+            self.logger.error(f"Weather task failed: {e}")
+            self.api_client.send_message(task["chat_id"], "Sorry, I couldn't get the weather.", task["message_id"])
+
+    def run(self):
+        """Starts the bot and FastAPI server."""
+        self.logger.info("Starting Eve WhatsApp Bot...")
+        for d in [self.config.IMAGE_DIR, self.config.AUDIO_DIR, self.config.TEMP_DIR]:
+            os.makedirs(d, exist_ok=True)
+            self.logger.info(f"Ensured directory exists: {d}")
+        
+        self.api_client.send_message(
+           "[email protected]",
+           "🌟 Eve is online and ready to help! Type /help to see commands."
+        )
 
-@app.api_route("/health", methods=["GET", "HEAD"])
-def health():
-    # HEAD requests ignore the body by HTTP spec, so FastAPI handles that automatically
-    return JSONResponse(content={"status": "ok"})
+        uvicorn.run(self.fastapi_app, host="0.0.0.0", port=7860)
 
 
 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)
+    try:
+        config = BotConfig()
+        executor = ThreadPoolExecutor(max_workers=config.WORKER_THREADS * 2)
+        bot = WhatsAppBot(config)
+        bot.run()
+    except ValueError as e:
+        # Catch config validation errors
+        print(f"❌ CONFIGURATION ERROR: {e}")
+    except KeyboardInterrupt:
+        print("\n🛑 Bot stopped by user.")
+    except Exception as e:
+        print(f"❌ A fatal error occurred: {e}")
+

flux_kontext_lib/README.md

@@ -0,0 +1,42 @@
+# Flux Kontext Image Generator Library
+
+A Python library for interacting with the Kontext Chat image generation API.
+
+## Installation
+```bash
+pip install requests
+```
+
+## Usage
+```python
+from flux_kontext_lib import generate_image
+
+# Using file path
+result = generate_image("close her eyes", "path/to/image.jpg")
+
+# Using image bytes
+with open("path/to/image.jpg", "rb") as f:
+    image_bytes = f.read()
+result = generate_image("add sunglasses", image_bytes)
+
+# Custom headers
+custom_headers = {"Authorization": "Bearer YOUR_TOKEN"}
+result = generate_image("make it sunny", "path/to/image.jpg", headers=custom_headers)
+```
+
+## Parameters
+- `prompt_text` (str): Text prompt for image modification
+- `image_input` (str or bytes): Image file path or bytes content
+- `headers` (dict, optional): Custom request headers
+
+## Returns
+- dict: API response on success
+- None: On request failure
+
+## Error Handling
+Raises:
+- `FileNotFoundError`: If image file doesn't exist
+- `ValueError`: For unsupported input types
+
+## Example
+See [example_usage.py](example_usage.py) for a complete usage example.

flux_kontext_lib/__init__.py

@@ -0,0 +1,3 @@
+from .image_generator import generate_image
+
+__all__ = ['generate_image']

flux_kontext_lib/example_usage.py

@@ -0,0 +1,19 @@
+from flux_kontext_lib import generate_image
+
+# Example usage
+if __name__ == '__main__':
+    try:
+        # Replace with your actual image path
+        image_path = "./image.jpg"
+        prompt = "close his eyes"
+        
+        # Call the library function
+        result = generate_image(prompt, image_path)
+        
+        if result:
+            print("API Response:")
+            print(result)
+        else:
+            print("Request failed. Check error messages for details.")
+    except Exception as e:
+        print(f"Error: {e}")

flux_kontext_lib/image_generator.py

@@ -0,0 +1,119 @@
+import requests
+import base64
+import json
+from io import BytesIO
+from typing import Optional, Dict
+
+# Pillow is required for image format conversion and normalization.
+# Please install it using: pip install Pillow
+try:
+    from PIL import Image
+except ImportError:
+    print("Pillow library not found. Please install it using: pip install Pillow")
+    exit()
+
+def _download_image_from_url(image_url: str, save_path: str) -> bool:
+    """
+    Downloads an image from a URL and saves it to a local path.
+
+    Args:
+        image_url: The URL of the image to download.
+        save_path: The local path to save the downloaded image.
+
+    Returns:
+        True if the download was successful, False otherwise.
+    """
+    print(f"Downloading generated image from: {image_url}")
+    try:
+        image_response = requests.get(image_url, stream=True)
+        # Check if the download request was successful.
+        if image_response.status_code == 200:
+            content_type = image_response.headers.get('Content-Type', '')
+            if 'image' in content_type:
+                with open(save_path, 'wb') as f:
+                    for chunk in image_response.iter_content(1024):
+                        f.write(chunk)
+                print(f"Image successfully saved to {save_path}")
+                return True
+            else:
+                print(f"Error: Content at URL is not an image. Content-Type: {content_type}")
+                return False
+        else:
+            print(f"Error: Failed to download image. Status code: {image_response.status_code}")
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred during image download: {e}")
+        return False
+
+def generate_image(
+    prompt_text: str,
+    image_path: str,
+    download_path: Optional[str] = None
+) -> Optional[Dict]:
+    """
+    Sends a request to the image generation API and optionally downloads the result.
+
+    Args:
+        prompt_text: The instructional text for image modification.
+        image_path: The file path to the input image (any common format).
+        download_path: If provided, the path to save the generated image.
+
+    Returns:
+        A dictionary of the JSON response from the API, or None on error.
+    """
+    url = "https://kontext-chat.replicate.dev/generate-image"
+
+    try:
+        # --- Image Normalization Step ---
+        with Image.open(image_path) as img:
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+            with BytesIO() as output_buffer:
+                img.save(
+                    output_buffer,
+                    format="JPEG",
+                    quality=95,
+                    subsampling=0,
+                    progressive=False
+                )
+                image_bytes = output_buffer.getvalue()
+    except FileNotFoundError:
+        print(f"Error: Image file not found at {image_path}")
+        return None
+    except Exception as e:
+        print(f"Error processing image file. Ensure it's a valid image. Details: {e}")
+        return None
+
+    encoded_string = base64.b64encode(image_bytes).decode('utf-8')
+    input_image_data_uri = f"data:image/jpeg;base64,{encoded_string}"
+
+    payload = {
+        "prompt": prompt_text,
+        "input_image": input_image_data_uri
+    }
+
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:139.0) Gecko/20100101 Firefox/139.0",
+        "Accept": "*/*",
+        "Content-Type": "application/json",
+        "Referer": "https://kontext-chat.replicate.dev/",
+        "Origin": "https://kontext-chat.replicate.dev",
+    }
+
+    try:
+        response = requests.post(url, headers=headers, data=json.dumps(payload))
+        response.raise_for_status()
+        api_response_data = response.json()
+
+        # --- Optional Download Logic ---
+        if download_path and isinstance(api_response_data, dict):
+            image_url = api_response_data.get("imageUrl")
+            if image_url:
+                _download_image_from_url(image_url, download_path)
+            else:
+                print("Warning: 'imageUrl' not found in response, could not download image.")
+
+        return api_response_data
+    except requests.exceptions.RequestException as e:
+        print(f"API request failed: {e}")
+        return None