Enhance logging and error handling across modules; refactor image generation and upload processes; update configuration for image generation parameters.

FLUX.py

@@ -1,147 +1,143 @@
-import requests
-import time
-import io
 import os
-import re
-import json
+import io
+import time
 import random
+import logging
+import requests
 from PIL import Image, UnidentifiedImageError
 
-# Load the ImgBB API key from the environment variables.
+# --- Logging setup ---
+logger = logging.getLogger("flux")
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+logger.setLevel(LOG_LEVEL)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+logger.addHandler(handler)
+
+# --- Configuration ---
 IMGBB_API_KEY = os.getenv("IMGBB_API_KEY")
+DEFAULT_MODEL = "flux"
+DEFAULT_WIDTH = 1920
+DEFAULT_HEIGHT = 1080
+MAX_RETRIES   = 3
+BACKOFF_BASE  = 2  # exponential backoff
 
-def upload_to_imgbb(image_path, file_name):
+def upload_to_imgbb(image_path: str, file_name: str) -> str | None:
     """
-    Uploads the image located at image_path to ImgBB.
-    Returns:
-        str: URL of the uploaded image on ImgBB or None if failed.
+    Uploads the image at image_path to ImgBB.
+    Returns the public URL or None on failure.
     """
+    if not IMGBB_API_KEY:
+        logger.warning("IMGBB_API_KEY not set, skipping upload")
+        return None
+
     try:
         with open(image_path, 'rb') as f:
-            image_data = f.read()
-        response = requests.post(
+            files = {"image": (file_name, f.read())}
+        resp = requests.post(
             "https://api.imgbb.com/1/upload",
             params={"key": IMGBB_API_KEY},
-            files={"image": (file_name, image_data)}
+            files=files,
+            timeout=15
         )
-        response.raise_for_status()
-        result = response.json()
-        if result.get("data") and "url" in result["data"]:
-            return result["data"]["url"]
+        resp.raise_for_status()
+        data = resp.json().get("data", {})
+        url  = data.get("url")
+        if url:
+            logger.debug(f"Uploaded to ImgBB: {url}")
+            return url
         else:
-            print("Failed to upload image to ImgBB.")
+            logger.error("ImgBB response missing URL")
             return None
-    except requests.RequestException as e:
-        print(f"Error uploading image to ImgBB: {e}")
-        return None
     except Exception as e:
-        print(f"Unexpected error uploading image to ImgBB: {e}")
+        logger.error(f"ImgBB upload failed: {e}")
         return None
 
-def generate_image(prompt, request_id, current_request_id, image_dir, attempt=0):
+def generate_image(
+    prompt: str,
+    request_id: str,
+    current_request_id: str,
+    image_dir: str,
+    model: str = None,
+    width: int = None,
+    height: int = None
+) -> tuple[Image.Image, str, str, str] | None:
     """
-    Generate an image using the Pollinations API.
-    
-    Parameters:
-        prompt (str): The prompt for image generation.
-        width (int): Desired image width.
-        height (int): Desired image height.
-        request_id (int): The request id for the current operation.
-        current_request_id (int): The current active request id.
-        image_dir (str): Directory where image will be saved.
-        attempt (int): Current attempt count (zero-indexed).
-    
+    Generate an image via Pollinations API, save locally, upload to ImgBB.
+
     Returns:
-        tuple: (PIL.Image object, image_path (str), returned_prompt (str), image_url (str))
-        or None if image fetch fails or request id mismatches.
+      (PIL.Image, local_path, returned_prompt, image_url) or None on failure.
     """
-    model = "flux"
-    width = 1920
-    height = 1080
-    randomSeed = random.randint(0, 9999999)
-    url = f"https://image.pollinations.ai/prompt/{prompt}?nologo=true&safe=false&private=true&model={model}&enhance=true&width={width}&height={height}&seed={randomSeed}"
-    print(f"Attempt {attempt + 1}: Fetching image with URL: {url}")
-    
-    try:
-        response = requests.get(url, timeout=45)
-    except Exception as e:
-        print(f"Error fetching image: {e}")
-        return None
+    model  = model or DEFAULT_MODEL
+    width  = width or DEFAULT_WIDTH
+    height = height or DEFAULT_HEIGHT
 
-    if response.status_code != 200:
-        print(f"Failed to fetch image. Status code: {response.status_code}")
+    # if the request has been superseded, bail early
+    if request_id != current_request_id:
+        logger.info("Request ID mismatch; cancelling generation")
         return None
 
+    seed = random.randint(0, 2**31 - 1)
+    url  = (
+        f"https://image.pollinations.ai/prompt/{requests.utils.quote(prompt)}"
+        f"?nologo=true&safe=false&private=true&model={model}"
+        f"&enhance=true&width={width}&height={height}&seed={seed}"
+    )
+    logger.debug(f"Fetching image (seed={seed}): {url}")
+
+    backoff = 1
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            resp = requests.get(url, timeout=45)
+            if resp.status_code != 200:
+                raise RuntimeError(f"Status {resp.status_code}")
+            break
+        except Exception as e:
+            logger.warning(f"Attempt {attempt}/{MAX_RETRIES} failed: {e}")
+            if attempt == MAX_RETRIES:
+                logger.error("Max retries reached, aborting image fetch")
+                return None
+            time.sleep(backoff)
+            backoff *= BACKOFF_BASE
+
+    # verify still the active request
     if request_id != current_request_id:
-        print("Request ID mismatch. Operation cancelled.")
+        logger.info("Request ID mismatch after fetch; discarding result")
         return None
 
-    print("Image fetched successfully.")
-    image_data = response.content
-
+    # load image
     try:
-        image = Image.open(io.BytesIO(image_data))
-        actual_width, actual_height = image.size
-        print(f"Actual image dimensions: {actual_width}x{actual_height}")
-        
-        # Extract metadata from EXIF if available
-        exif_data = image.info.get('exif', b'')
-        returned_prompt = prompt
-        if exif_data:
-            json_match = re.search(b'{"prompt":.*}', exif_data)
-            if json_match:
-                json_str = json_match.group(0).decode('utf-8')
-                try:
-                    metadata_dict = json.loads(json_str)
-                    returned_prompt = metadata_dict.get('prompt', prompt)
-                except json.JSONDecodeError as e:
-                    print(f"Failed to parse JSON in metadata: {e}")
-            else:
-                print("No JSON data found in EXIF")
-        
-        if (actual_width, actual_height) != (width, height):
-            print(f"Warning: Received image dimensions ({actual_width}x{actual_height}) do not match requested dimensions ({width}x{height})")
-    except UnidentifiedImageError:
-        print("Error: Received data is not a valid image.")
-        raise
+        image = Image.open(io.BytesIO(resp.content))
+        logger.debug(f"Image loaded: {image.size[0]}×{image.size[1]}")
+    except UnidentifiedImageError as e:
+        logger.error(f"Invalid image data: {e}")
+        return None
+
+    # try to extract prompt metadata from EXIF
+    returned_prompt = prompt
+    exif = image.info.get("exif", b"")
+    if exif:
+        try:
+            import re, json as _json
+            m = re.search(b'{"prompt":.*}', exif)
+            if m:
+                meta = _json.loads(m.group(0).decode())
+                returned_prompt = meta.get("prompt", prompt)
+        except Exception as e:
+            logger.debug(f"EXIF parse failed: {e}")
 
-    timestamp = int(time.time())
-    image_filename = f"flux_{timestamp}.png"
-    image_path = os.path.join(image_dir, image_filename)
-    
-    # Ensure the image directory exists
+    # ensure output directory
     os.makedirs(image_dir, exist_ok=True)
-    
+    filename = f"flux_{int(time.time())}.png"
+    path     = os.path.join(image_dir, filename)
+
     try:
-        image.save(image_path, 'PNG')
-        print(f"Image saved to {image_path}")
-        # Upload image to ImgBB
-        image_url = upload_to_imgbb(image_path, image_filename)
-        if image_url:
-            print(f"Image uploaded to ImgBB: {image_url}")
-        else:
-            print("Failed to upload image to ImgBB.")
+        image.save(path, format="PNG")
+        logger.info(f"Image saved to {path}")
     except Exception as e:
-        print(f"Error saving image: {e}")
+        logger.error(f"Failed to save image: {e}")
         return None
 
-    return image, image_path, returned_prompt, image_url
-
-# if __name__ == "__main__":
-#     from dotenv import load_dotenv
-
-#     load_dotenv()
-#     # Example usage
-#     prompt = "Beach party, anime style, vibrant colors"
-#     request_id = 1
-#     current_request_id = 1
-#     image_dir = "./images"
-    
-#     image, image_path, returned_prompt, image_url = generate_image(prompt, request_id, current_request_id, image_dir)
-    
-#     if image:
-#         print(f"Image generated and saved at {image_path}")
-#         print(f"Returned prompt: {returned_prompt}")
-#         print(f"Image URL: {image_url}")
-#     else:
-#         print("Failed to generate image.")
+    # upload
+    image_url = upload_to_imgbb(path, filename) or ""
+    return image, path, returned_prompt, image_url

app.py

@@ -4,8 +4,8 @@ import requests
 import logging
 import queue
 import json
-import time
 import random
+from collections import defaultdict, deque
 from concurrent.futures import ThreadPoolExecutor
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import PlainTextResponse
@@ -13,7 +13,56 @@ from FLUX import generate_image
 from VoiceReply import generate_voice_reply
 from polLLM import generate_llm
 
-# --- Configuration and Client Classes ---
+# --- Logging Setup ---------------------------------------------------------
+
+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),
+    )
+
+# --- Conversation History -------------------------------------------------
+
+# keep last 20 messages per (chat_id, sender)
+history = defaultdict(lambda: deque(maxlen=20))
+
+def record_user_message(chat_id, sender, message):
+    history[(chat_id, sender)].append(f"User: {message}")
+
+def record_bot_message(chat_id, sender, message):
+    history[(chat_id, sender)].append(f"Assistant: {message}")
+
+def get_history_text(chat_id, sender):
+    return "\n".join(history[(chat_id, sender)])
+
+# --- Bot Config & Client --------------------------------------------------
 
 class BotConfig:
     GREEN_API_URL         = os.getenv("GREEN_API_URL")
@@ -40,13 +89,13 @@ class BotClient:
     def __init__(self, cfg: BotConfig):
         self.cfg = cfg
         self.session = requests.Session()
-        logging.basicConfig(level=logging.DEBUG,
-                            format="%(asctime)s [%(levelname)s] %(message)s")
 
     def send(self, endpoint, 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}")
+        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(
@@ -58,7 +107,7 @@ class BotClient:
                 resp.raise_for_status()
                 return resp.json()
             except requests.RequestException as e:
-                logging.warning(f"{endpoint} attempt {i}/{retries} failed: {e}")
+                logger.warning(f"{endpoint} attempt {i}/{retries} failed: {e}")
         return {"error":"failed"}
 
     def send_message(self, message_id, chat_id, text):
@@ -84,13 +133,13 @@ class BotClient:
         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)
+            return self.send(endpoint, payload, files=files)
 
-# Validate env
+# Validate env & init client
 BotConfig.validate()
 client = BotClient(BotConfig)
 
-# --- Threading & Queues ---
+# --- Threading & Queues ---------------------------------------------------
 
 task_queue = queue.Queue()
 polls      = {}
@@ -98,38 +147,68 @@ executor   = ThreadPoolExecutor(max_workers=4)
 
 def worker():
     while True:
-        t = task_queue.get()
+        task = task_queue.get()
         try:
-            if t["type"] == "image":
+            if task["type"] == "image":
                 _fn_generate_images(
-                    t["message_id"],
-                    t["chat_id"],
-                    t["prompt"],
-                    t.get("num_images", 1)
+                    task["message_id"],
+                    task["chat_id"],
+                    task["prompt"],
+                    task.get("num_images", 1),
+                    task.get("width"),
+                    task.get("height")
+                )
+
+            elif task["type"] == "audio":
+                _fn_voice_reply(
+                    task["message_id"],
+                    task["chat_id"],
+                    task["prompt"]
                 )
-            elif t["type"] == "audio":
-                _fn_voice_reply(t["message_id"], t["chat_id"], t["prompt"])
         except Exception as e:
-            logging.error(f"Worker error {t}: {e}")
+            logger.error(f"Worker error {task}: {e}")
         finally:
             task_queue.task_done()
 
 for _ in range(4):
     threading.Thread(target=worker, daemon=True).start()
 
-# --- Tool Functions ---
+# --- 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:
+        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):
+    """Send text + record, but no voice."""
+    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):
-    s = generate_llm(f"Summarize:\n\n{text}")
-    _fn_send_text(mid, cid, s)
+    summary = generate_llm(f"Summarize:\n\n{text}")
+    _fn_send_text(mid, cid, summary)
 
 def _fn_translate(mid, cid, lang, text):
-    r = generate_llm(f"Translate to {lang}:\n\n{text}")
-    _fn_send_text(mid, cid, r)
+    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()
+        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.")
@@ -137,20 +216,20 @@ def _fn_joke(mid, cid):
 
 def _fn_weather(mid, cid, loc):
     raw = requests.get(f"http://sl.wttr.in/{loc}?format=4", timeout=5).text
-    r = generate_llm(f"Give a weather report in °C:\n\n{raw}")
-    _fn_send_text(mid, cid, r)
+    report = generate_llm(f"Give a weather report in °C:\n\n{raw}")
+    _fn_send_text(mid, cid, report)
 
 def _fn_inspire(mid, cid):
-    q = generate_llm("Give me a unique, random short inspirational quote.")
-    _fn_send_text(mid, cid, f"✨ {q}")
+    quote = generate_llm("Give me a unique, random short inspirational quote.")
+    _fn_send_text(mid, cid, f"✨ {quote}")
 
 def _fn_meme(mid, cid, txt):
-    client.send_message(mid, cid, "🎨 Generating meme…")
+    _fn_send_accept(mid, cid, "🎨 Generating meme…")
     task_queue.put({
-        "type": "image",
+        "type":       "image",
         "message_id": mid,
-        "chat_id": cid,
-        "prompt": f"meme: {txt}"
+        "chat_id":    cid,
+        "prompt":     f"meme: {txt}"
     })
 
 def _fn_poll_create(mid, cid, question, options):
@@ -161,7 +240,7 @@ def _fn_poll_create(mid, cid, question, options):
 
 def _fn_poll_vote(mid, cid, voter, choice):
     poll = polls.get(cid)
-    if not poll or choice < 1 or choice > len(poll["options"]):
+    if not poll or choice<1 or choice>len(poll["options"]):
         return
     prev = poll["voters"].get(voter)
     if prev:
@@ -190,66 +269,147 @@ def _fn_poll_end(mid, cid):
     )
     _fn_send_text(mid, cid, txt)
 
-def _fn_generate_images(mid, cid, prompt, count=1):
+def _fn_generate_images(mid, cid, prompt, count=1, width=None, height=None):
     for i in range(1, count+1):
         try:
-            img, path, ret_p, url = generate_image(prompt, mid, mid, BotConfig.IMAGE_DIR)
+            img, path, ret_p, url = generate_image(
+                prompt, mid, mid, 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")
             os.remove(path)
         except Exception as e:
-            logging.warning(f"Img {i}/{count} failed: {e}")
+            logger.warning(f"Img {i}/{count} failed: {e}")
             _fn_send_text(mid, cid, f"😢 Failed to generate image {i}/{count}.")
 
-def _fn_send_text(mid, cid, message):
-    # send text...
-    client.send_message(mid, cid, message)
-    # ...and queue voice with the same content
-    task_queue.put({
-        "type": "audio",
-        "message_id": mid,
-        "chat_id": cid,
-        "prompt": message
-    })
 
 def _fn_voice_reply(mid, cid, prompt):
-    processed = (
+    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}"
     )
-    res = generate_voice_reply(
-        processed,
-        model="openai-audio",
-        voice="coral",
-        audio_dir=BotConfig.AUDIO_DIR
-    )
+    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")
         os.remove(path)
     else:
-        # fallback to text+voice
         _fn_send_text(mid, cid, prompt)
 
-# --- Function schema & router ---
+# --- 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"]},
+    "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"]},
-    "send_text":      {"description":"Send plain text","params":["message"]}
+    "meme":           {"description":"Generate meme",      "params":["text"]},
+    "poll_create":    {"description":"Create poll",        "params":["question","options"]},
+    "poll_vote":      {"description":"Vote poll",          "params":["choice"]},
+    "poll_results":   {"description":"Show poll results",  "params":[]},
+    "poll_end":       {"description":"End poll",           "params":[]},
+    "generate_image": {"description":"Generate images",    "params":["prompt","count"]},
+    "send_text":      {"description":"Send plain text",    "params":["message"]},
 }
 
-def route_intent(user_input: str):
+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):
+    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())
@@ -257,13 +417,18 @@ def route_intent(user_input: str):
         "Otherwise return JSON with \"action\":\"send_text\",\"message\":\"...\".\n"
         "Return only raw JSON."
     )
-    raw = generate_llm(f"{sys_prompt}\nUser: {user_input}")
+    prompt = (
+        f"{sys_prompt}\n\n"
+        f"Conversation so far:\n{history_text}\n\n"
+        f"User: {user_input}"
+    )
+    raw = generate_llm(prompt)
     try:
         return json.loads(raw)
     except:
         return {"action":"send_text","message":raw}
 
-# --- FastAPI & Webhook ---
+# --- FastAPI & Webhook ----------------------------------------------------
 
 app = FastAPI()
 help_text = (
@@ -276,7 +441,7 @@ help_text = (
     "• /inspire\n"
     "• /meme <text>\n"
     "• /poll <Q>|… / /results / /endpoll\n"
-    "• /gen <prompt>|<count>\n"
+    "• /gen <prompt>|<count>|<width>|<height>\n"
     "Otherwise chat or reply to my message to invoke tools."
 )
 
@@ -287,18 +452,25 @@ async def whatsapp_webhook(request: Request):
         raise HTTPException(403, "Unauthorized")
 
     chat_id = data["senderData"]["chatId"]
+    sender  = data["senderData"]["sender"]
+    mid     = data["idMessage"]
+    set_thread_context(chat_id, sender, mid)
+    logger.debug("Received webhook")
+
     if chat_id != BotConfig.BOT_GROUP_CHAT or data["typeWebhook"] != "incomingMessageReceived":
         return {"success": True}
 
     md  = data["messageData"]
-    mid = data["idMessage"]
     tmd = md.get("textMessageData") or md.get("extendedTextMessageData")
     if not tmd:
         return {"success": True}
 
-    body = (tmd.get("textMessage") or tmd.get("text", "")).strip()
+    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":
@@ -315,7 +487,7 @@ async def whatsapp_webhook(request: Request):
         _fn_joke(mid, chat_id)
         return {"success": True}
     if low.startswith("/weather "):
-        _fn_weather(mid, chat_id, body[9:].strip().replace(" ", "+"))
+        _fn_weather(mid, chat_id, body[9:].strip().replace(" ","+"))
         return {"success": True}
     if low == "/inspire":
         _fn_inspire(mid, chat_id)
@@ -328,7 +500,7 @@ async def whatsapp_webhook(request: Request):
         _fn_poll_create(mid, chat_id, parts[0], parts[1:])
         return {"success": True}
     if chat_id in polls and low.isdigit():
-        _fn_poll_vote(mid, chat_id, data["senderData"]["sender"], int(low))
+        _fn_poll_vote(mid, chat_id, sender, int(low))
         return {"success": True}
     if low == "/results":
         _fn_poll_results(mid, chat_id)
@@ -337,24 +509,29 @@ async def whatsapp_webhook(request: Request):
         _fn_poll_end(mid, chat_id)
         return {"success": True}
     if low.startswith("/gen"):
-        parts = body[4:].split("|", 1)
-        pr    = parts[0].strip()
-        ct    = int(parts[1]) if len(parts)>1 and parts[1].isdigit() else BotConfig.DEFAULT_IMAGE_COUNT
-        client.send_message(mid, chat_id, f"✨ Generating {ct} images…")
+        parts = body[4:].split("|")
+        pr = parts[0].strip()
+        ct = 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 {ct} image(s)…")
         task_queue.put({
-            "type": "image",
+            "type":       "image",
             "message_id": mid,
-            "chat_id": chat_id,
-            "prompt": pr,
-            "num_images": ct
+            "chat_id":    chat_id,
+            "prompt":     pr,
+            "num_images": ct,
+            "width":      width,
+            "height":     height
         })
         return {"success": True}
 
+
     # Skip mentions
     if ctx.get("mentionedJidList"):
         return {"success": True}
 
-    # Build effective_text (include quoted if replying to bot)
+    # Build effective text (handle quoted replies to the bot)
     if md.get("typeMessage") == "quotedMessage":
         ext    = md["extendedTextMessageData"]
         quoted = md["quotedMessage"]
@@ -368,42 +545,20 @@ async def whatsapp_webhook(request: Request):
     else:
         effective = body
 
-    # Route intent across all tools
-    intent = route_intent(effective)
+    # Route intent & dispatch
+    intent = route_intent(effective, chat_id, sender)
     action = intent.get("action")
 
-    # helper to confirm+enqueue image generation
-    def _dispatch_generate_image():
-        prompt = intent["prompt"]
-        count  = intent.get("count", 1)
-        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
-        })
-
-    dispatch = {
-        "summarize":      lambda: _fn_summarize(mid, chat_id, intent["text"]),
-        "translate":      lambda: _fn_translate(mid, chat_id, intent["lang"], intent["text"]),
-        "joke":           lambda: _fn_joke(mid, chat_id),
-        "weather":        lambda: _fn_weather(mid, chat_id, intent["location"]),
-        "inspire":        lambda: _fn_inspire(mid, chat_id),
-        "meme":           lambda: _fn_meme(mid, chat_id, intent["text"]),
-        "poll_create":    lambda: _fn_poll_create(mid, chat_id, intent["question"], intent["options"]),
-        "poll_vote":      lambda: _fn_poll_vote(mid, chat_id, data["senderData"]["sender"], intent["choice"]),
-        "poll_results":   lambda: _fn_poll_results(mid, chat_id),
-        "poll_end":       lambda: _fn_poll_end(mid, chat_id),
-        "generate_image": _dispatch_generate_image,
-        "send_text":      lambda: _fn_send_text(mid, chat_id, intent["message"]),
-    }
-
-    if action in dispatch:
-        dispatch[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."))
     else:
-        _fn_send_text(mid, chat_id, intent.get("message", "Sorry, I didn't get that."))
+        # fallback chat
+        _fn_send_text(mid, chat_id, intent.get("message","Sorry, I didn't get that."))
 
     return {"success": True}
 

config.yaml

@@ -5,7 +5,7 @@ config:
       You are {char}, a sweet and helpful AI assistant in Telegram and WhatsApp.
       You generate images, voice and text replies, and support these commands:
         • /help — list all commands
-        • /gen <prompt>|<count> — generate <count> images (default 4)
+        • /gen <prompt>|<count>|<width>|<height> — generate <count> images (default 4) 
         • /summarize <text> — get a concise summary
         • /translate <lang>|<text> — translate text
         • /joke — tell a short joke
@@ -17,67 +17,4 @@ config:
         • /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, 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
-    width: 1024
-    height: 1024
-    sampler_name: DPM++ 2M
-    cfg_scale: 7.0
-    imgbb_upload: false
-
-  app:
-    whatsapp_bot_enabled: true
-    telegram_bot_enabled: true
-    version: "0.6 Beta"
-    debug: true
+    char: Eve

polLLM.py

@@ -1,47 +1,86 @@
 import os
+import time
+import random
+import logging
 from openai import OpenAI
 from dotenv import load_dotenv
 from utils import read_config
-import random
-import time  # Import time for retry delay
 
+# --- Load environment & config ---
 load_dotenv()
+_config = read_config()["llm"]
+
+# --- Logging setup ---
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+logger = logging.getLogger("polLLM")
+logger.setLevel(LOG_LEVEL)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+logger.addHandler(handler)
+
+# --- LLM settings from config.yaml ---
+_DEFAULT_MODEL     = _config.get("model", "openai-large")
+_SYSTEM_TEMPLATE   = _config.get("system_prompt", "")
+_CHAR              = _config.get("char", "Eve")
+_DEFAULT_MAX_TOKENS = _config.get("max_tokens", 8000)
 
+# --- OpenAI client init ---
 client = OpenAI(
-    base_url="https://text.pollinations.ai/openai",
-    api_key="YOUR_API_KEY"  # Add if needed
+    base_url    = os.getenv("OPENAI_BASE_URL", "https://text.pollinations.ai/openai"),
+    api_key     = os.getenv("OPENAI_API_KEY", "")
 )
 
-def pre_process():
-    # Read the configuration and substitute the character placeholder
-    config = read_config()
-    system_prompt = config['llm']['system_prompt']
-    char = config['llm']['char']
-    return system_prompt.replace("{char}", char)
-
-def generate_llm(prompt, model="openai-large", max_tokens=8000):
-    system_prompt = pre_process()
-    
-    while True:  # Keep retrying indefinitely
+def _build_system_prompt() -> str:
+    """
+    Substitute {char} into the system prompt template.
+    """
+    return _SYSTEM_TEMPLATE.replace("{char}", _CHAR)
+
+def generate_llm(
+    prompt: str,
+    model: str = None,
+    max_tokens: int = None,
+    temperature: float = None,
+) -> str:
+    """
+    Send a chat-completion request to the LLM, with retries and backoff.
+    Reads defaults from config.yaml, but can be overridden per-call.
+    """
+    model       = model or _DEFAULT_MODEL
+    max_tokens  = max_tokens or _DEFAULT_MAX_TOKENS
+    temperature = temperature if temperature is not None else _DEFAULT_TEMPERATURE
+
+    system_prompt = _build_system_prompt()
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user",   "content": prompt},
+    ]
+
+    backoff = 1
+    for attempt in range(1, 6):
         try:
-            # Use OpenAI's ChatCompletion API
-            randomSeed = random.randint(0, 9999999)
-            response = client.chat.completions.create(
-                model=model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=max_tokens,
-                seed=randomSeed
+            seed = random.randint(0, 2**31 - 1)
+            logger.debug(f"LLM call attempt={attempt}, model={model}, seed={seed}")
+            resp = client.chat.completions.create(
+                model       = model,
+                messages    = messages,
+                max_tokens  = max_tokens,
+                temperature = temperature,
+                seed        = seed,
             )
-            # Return the generated text
-            return response.choices[0].message.content.strip()
+            text = resp.choices[0].message.content.strip()
+            logger.debug("LLM response received")
+            return text
         except Exception as e:
-            print(f"Error occurred: {str(e)}. Retrying in 5 seconds...")
-            time.sleep(5)  # Wait before retrying
+            logger.error(f"LLM error on attempt {attempt}: {e}")
+            if attempt < 5:
+                time.sleep(backoff)
+                backoff *= 2
+            else:
+                logger.critical("LLM failed after 5 attempts, raising")
+                raise
 
-# Example usage (can be removed or commented out in production):
+# Example local test
 if __name__ == "__main__":
-    sample_prompt = "search for free image generation api"
-    print("Response:", generate_llm(sample_prompt))
+    logger.info("Testing generate_llm() with a sample prompt")
+    print(generate_llm("Say hello in a poetic style."))