update debugs

app.py

@@ -4,6 +4,7 @@ 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.
+             Includes request logging and chat ID filtering.
 """
 
 import os
@@ -13,12 +14,12 @@ import logging
 import queue
 import json
 import base64
-from typing import List, Optional, Union, Literal, Dict, Any, Tuple
+from typing import List, Optional, Union, Literal, Dict, Any, Tuple, Set
 from collections import defaultdict, deque
 from concurrent.futures import ThreadPoolExecutor
 
 from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse, PlainTextResponse
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field, ValidationError
 import uvicorn
 
@@ -43,14 +44,20 @@ class BotConfig:
     DEFAULT_IMAGE_COUNT: int = 4
     MAX_HISTORY_SIZE: int = 20
     WORKER_THREADS: int = 4
-    LOG_LEVEL: str = "DEBUG"
+    # Set log level to DEBUG to capture all incoming requests
+    LOG_LEVEL: str = "DEBUG" 
+    
+    # Whitelisted chat IDs. The bot will only respond to these chats.
+    ALLOWED_CHATS: Set[str] = {"[email protected]", "[email protected]"}
 
     def __init__(self):
+        """Initializes configuration from environment variables."""
         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()
+        # Allow overriding log level from environment
+        self.LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG").upper()
         self._validate()
 
     def _validate(self):
@@ -69,19 +76,31 @@ class LoggerSetup:
     """Sets up and manages structured logging for the application."""
     @staticmethod
     def setup(level: str) -> logging.Logger:
+        """
+        Configures the root logger for the application.
+        Args:
+            level: The logging level (e.g., "DEBUG", "INFO").
+        Returns:
+            A configured logger instance.
+        """
         logger = logging.getLogger("whatsapp_bot")
         logger.setLevel(level)
-        logger.handlers.clear()
+        
+        # Avoid adding duplicate handlers
+        if logger.hasHandlers():
+            logger.handlers.clear()
 
         handler = logging.StreamHandler()
+        # Added a more detailed formatter
         formatter = logging.Formatter(
-            "%(asctime)s [%(levelname)s] [%(chat_id)s] %(funcName)s:%(lineno)d - %(message)s"
+            "%(asctime)s - %(name)s - [%(levelname)s] - [%(chat_id)s] - %(funcName)s:%(lineno)d - %(message)s"
         )
         handler.setFormatter(formatter)
 
         class ContextFilter(logging.Filter):
+            """Injects contextual information into log records."""
             def filter(self, record):
-                record.chat_id = ThreadContext.get_context().get("chat_id", "-")
+                record.chat_id = ThreadContext.get_context().get("chat_id", "NO_CONTEXT")
                 return True
 
         handler.addFilter(ContextFilter())
@@ -96,11 +115,13 @@ class ThreadContext:
 
     @classmethod
     def set_context(cls, chat_id: str, message_id: str):
+        """Sets the context for the current thread."""
         cls._context.chat_id = chat_id
         cls._context.message_id = message_id
 
     @classmethod
     def get_context(cls) -> Dict[str, Optional[str]]:
+        """Retrieves the context for the current thread."""
         return {
             "chat_id": getattr(cls._context, "chat_id", None),
             "message_id": getattr(cls._context, "message_id", None),
@@ -143,6 +164,7 @@ class GreenApiClient:
         url = f"{self.base_url}/{endpoint}/{self.config.GREEN_API_TOKEN}"
         for attempt in range(3):
             try:
+                self.logger.debug(f"Sending API request to {url} with payload: {kwargs.get('json', kwargs.get('data'))}")
                 response = self.session.request(method, url, timeout=20, **kwargs)
                 response.raise_for_status()
                 return response.json()
@@ -224,6 +246,7 @@ class IntentRouter:
         try:
             raw_response = generate_llm(system_prompt)
         except LLMBadRequestError:
+            self.logger.warning(f"LLM request failed due to bad request for chat {chat_id}. Clearing history.")
             self.conv_manager.clear_history(chat_id)
             return SendTextIntent(action="send_text", message="Oops! Let's start fresh! 🌟")
 
@@ -252,14 +275,16 @@ class IntentRouter:
 
     def _parse_response(self, raw_response: str) -> BaseIntent:
         try:
-            parsed = json.loads(raw_response)
+            # Clean the response to ensure it's valid JSON
+            cleaned_response = raw_response.strip().replace("`json", "").replace("`", "")
+            parsed = json.loads(cleaned_response)
             for model in self.INTENT_MODELS:
                 try:
                     return model.model_validate(parsed)
                 except ValidationError:
                     continue
         except json.JSONDecodeError:
-            pass
+            self.logger.warning(f"Could not decode LLM response to JSON: {raw_response}")
         
         # Fallback for non-JSON or unparsable responses
         return SendTextIntent(action="send_text", message=raw_response)
@@ -282,14 +307,22 @@ class WhatsAppBot:
         @self.fastapi_app.post("/whatsapp")
         async def webhook(request: Request):
             if request.headers.get("Authorization") != f"Bearer {self.config.WEBHOOK_AUTH_TOKEN}":
+                self.logger.warning("Unauthorized webhook access attempt.")
                 raise HTTPException(403, "Unauthorized")
             
-            payload = await request.json()
-            self.logger.debug(f"Incoming webhook: {json.dumps(payload)}")
+            try:
+                payload = await request.json()
+                # Log the entire incoming request payload for debugging
+                self.logger.debug(f"Incoming webhook payload: {json.dumps(payload, indent=2)}")
 
-            # Process valid incoming messages in the background
-            if payload.get("typeWebhook") == "incomingMessageReceived":
-                executor.submit(self._process_incoming_message, payload)
+                # Process valid incoming messages in the background
+                if payload.get("typeWebhook") == "incomingMessageReceived":
+                    executor.submit(self._process_incoming_message, payload)
+                else:
+                    self.logger.info(f"Received non-message webhook type: {payload.get('typeWebhook')}")
+            except json.JSONDecodeError:
+                self.logger.error("Failed to decode JSON from webhook request.")
+                raise HTTPException(400, "Invalid JSON payload.")
 
             return JSONResponse(content={"status": "received"})
 
@@ -307,13 +340,16 @@ class WhatsAppBot:
         while True:
             task = self.task_queue.get()
             try:
+                # Set context for the worker thread
+                ThreadContext.set_context(task["chat_id"], task["message_id"])
                 handler = getattr(self, f"_task_{task['type']}", None)
                 if handler:
+                    self.logger.debug(f"Processing task: {task['type']} for chat {task['chat_id']}")
                     handler(task)
                 else:
-                    self.logger.warning(f"Unknown task type: {task['type']}")
+                    self.logger.warning(f"Unknown task type received: {task['type']}")
             except Exception as e:
-                self.logger.error(f"Error processing task {task['type']}: {e}", exc_info=True)
+                self.logger.error(f"Error processing task {task.get('type', 'N/A')}: {e}", exc_info=True)
             finally:
                 self.task_queue.task_done()
 
@@ -322,6 +358,14 @@ class WhatsAppBot:
         try:
             chat_id = payload["senderData"]["chatId"]
             message_id = payload["idMessage"]
+            
+            # ** CHAT RESTRICTION LOGIC **
+            # Check if the sender is in the allowed list
+            if chat_id not in self.config.ALLOWED_CHATS:
+                self.logger.warning(f"Ignoring message from unauthorized chat ID: {chat_id}")
+                return  # Stop processing immediately
+
+            # Set thread context for logging
             ThreadContext.set_context(chat_id, message_id)
 
             message_data = payload.get("messageData", {})
@@ -335,8 +379,10 @@ class WhatsAppBot:
 
             text = text.strip()
             if not text:
+                self.logger.debug(f"Received empty message from {chat_id}. Ignoring.")
                 return
             
+            self.logger.info(f"Processing message from {chat_id}: '{text}'")
             self.conv_manager.add_user_message(chat_id, text)
 
             # Handle direct commands
@@ -346,6 +392,8 @@ class WhatsAppBot:
                 # Handle natural language and replies
                 self._handle_natural_language(chat_id, message_id, text, payload)
         
+        except KeyError as e:
+            self.logger.error(f"Missing expected key in message payload: {e}. Payload: {payload}")
         except Exception as e:
             self.logger.error(f"Failed to process message payload: {e}", exc_info=True)
 
@@ -372,11 +420,11 @@ class WhatsAppBot:
         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})
+            self.task_queue.put({"type": "joke", "chat_id": chat_id, "message_id": message_id})
         elif command == "/inspire":
-            self._task_inspire({"chat_id": chat_id, "message_id": message_id})
+            self.task_queue.put({"type": "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})
+            self.task_queue.put({"type": "weather", "chat_id": chat_id, "message_id": message_id, "location": args})
         else:
             self.api_client.send_message(chat_id, "Unknown command. Type /help for options.", message_id)
             
@@ -394,6 +442,7 @@ class WhatsAppBot:
             # 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}"):
+            # Enqueue the task with its type and all necessary data
             self.task_queue.put({"type": intent.action, **task_data})
         else:
             self.logger.warning(f"No handler found for intent action: {intent.action}")
@@ -401,7 +450,7 @@ class WhatsAppBot:
             
     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")
+        quoted_message = payload.get("messageData", {}).get("extendedTextMessageData", {}).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
@@ -421,6 +470,7 @@ class WhatsAppBot:
         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)
+        # Asynchronously generate a voice reply for the sent text
         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]):
@@ -434,7 +484,7 @@ class WhatsAppBot:
                 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.logger.error(f"Image generation {i+1} failed: {e}", exc_info=True)
                 self.api_client.send_message(chat_id, f"😢 Failed to generate image {i+1}.", mid)
     
     def _task_edit_image(self, task: Dict[str, Any]):
@@ -447,6 +497,7 @@ class WhatsAppBot:
             if not image_data:
                 raise ValueError("Failed to download image.")
 
+            os.makedirs(self.config.TEMP_DIR, exist_ok=True)
             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")
             
@@ -462,7 +513,7 @@ class WhatsAppBot:
                 raise ValueError("Edited image file not found.")
 
         except Exception as e:
-            self.logger.error(f"Image editing task failed: {e}")
+            self.logger.error(f"Image editing task failed: {e}", exc_info=True)
             self.api_client.send_message(chat_id, "😢 Sorry, I failed to edit the image.", mid)
         finally:
             for path in [input_path, output_path]:
@@ -479,13 +530,14 @@ class WhatsAppBot:
                 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}")
+            self.logger.warning(f"Voice reply generation failed: {e}", exc_info=True)
 
     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:
+            self.logger.warning("Joke API failed, falling back to LLM.")
             joke = generate_llm("Tell me a short, clean joke.")
         self._task_send_text({"type": "send_text", **task, "message": f"😄 {joke}"})
 
@@ -494,13 +546,16 @@ class WhatsAppBot:
         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")
+        location = task.get("location")
+        if not location:
+             self.api_client.send_message(task["chat_id"], "Please provide a location for the weather.", task["message_id"])
+             return
         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.logger.error(f"Weather task failed: {e}", exc_info=True)
             self.api_client.send_message(task["chat_id"], "Sorry, I couldn't get the weather.", task["message_id"])
 
     def run(self):
@@ -508,27 +563,29 @@ class WhatsAppBot:
         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.logger.debug(f"Ensured directory exists: {d}")
         
+        # Send a startup message to one of the allowed chats to confirm it's online
         self.api_client.send_message(
            "[email protected]",
            "🌟 Eve is online and ready to help! Type /help to see commands."
         )
 
-        uvicorn.run(self.fastapi_app, host="0.0.0.0", port=7860)
+        uvicorn.run(self.fastapi_app, host="0.0.0.0", port=7860, log_config=None)
 
 
 if __name__ == "__main__":
     try:
-        config = BotConfig()
-        executor = ThreadPoolExecutor(max_workers=config.WORKER_THREADS * 2)
-        bot = WhatsAppBot(config)
+        bot_config = BotConfig()
+        executor = ThreadPoolExecutor(max_workers=bot_config.WORKER_THREADS * 2)
+        bot = WhatsAppBot(bot_config)
         bot.run()
     except ValueError as e:
         # Catch config validation errors
-        print(f"❌ CONFIGURATION ERROR: {e}")
+        logging.basicConfig()
+        logging.getLogger().critical(f"❌ CONFIGURATION ERROR: {e}")
     except KeyboardInterrupt:
         print("\n🛑 Bot stopped by user.")
     except Exception as e:
-        print(f"❌ A fatal error occurred: {e}")
-
+        logging.basicConfig()
+        logging.getLogger().critical(f"❌ A fatal error occurred: {e}", exc_info=True)

polLLM.py

@@ -11,7 +11,7 @@ load_dotenv()
 _config = read_config()["llm"]
 
 # --- Logging setup ---
-LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG").upper()
 logger = logging.getLogger("polLLM")
 logger.setLevel(LOG_LEVEL)
 handler = logging.StreamHandler()