Before chat history

app/handlers/media_handler.py

@@ -0,0 +1,15 @@
+# media_handler.py
+from abc import ABC, abstractmethod
+import logging
+from app.services.download_media import download_whatsapp_media
+
+logger = logging.getLogger(__name__)
+
+class MediaHandler(ABC):
+    @abstractmethod
+    async def download(self, media_id: str, access_token: str, file_path: str) -> str:
+        pass
+
+class WhatsAppMediaHandler(MediaHandler):
+    async def download(self, media_id: str, access_token: str, file_path: str) -> str:
+        return await download_whatsapp_media(media_id, access_token, file_path)

app/handlers/message_handler.py

@@ -0,0 +1,89 @@
+from typing import Dict, List, Optional
+
+from app.services.cache import MessageCache
+from app.services.chat_manager import ChatManager
+from app.handlers.media_handler import MediaHandler
+from app.services.message_parser import MessageParser
+from app.services.download_media import download_whatsapp_media
+from app.services.message import process_message_with_llm
+from app.models.message_types import Message, MediaType, MediaContent
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class MessageHandler:
+    def __init__(
+        self,
+        message_cache: MessageCache,
+        chat_manager: ChatManager,
+        media_handler: MediaHandler,
+        logger: logging.Logger
+    ):
+        self.message_cache = message_cache
+        self.chat_manager = chat_manager
+        self.media_handler = media_handler
+        self.logger = logger
+
+    async def handle(self, raw_message: dict, access_token: str) -> dict:
+        try:
+            # Parse message
+            message = MessageParser.parse(raw_message)
+            
+            if self.message_cache.exists(message.id):
+                self.logger.info(f"Duplicate message detected and skipped: {message.id}")
+                return {"status": "duplicate", "message_id": message.id}
+
+            # Download media
+            media_paths = await self._process_media(message, access_token)
+            
+            self.chat_manager.initialize_chat(message.sender_id)
+
+
+            # Process message with LLM
+            result = await process_message_with_llm(
+                message.sender_id,
+                message.content,
+                self.chat_manager.get_chat_history(message.sender_id),
+                **media_paths
+            )
+
+            # Append message to chat to keep track of conversation
+            self.chat_manager.append_message(message.sender_id, "user", message.content)
+            self.chat_manager.append_message(message.sender_id, "model", result)
+            
+            self.message_cache.add(message.id)
+            
+            return {"status": "success", "message_id": message.id, "result": result}
+            
+        except Exception as e:
+            return {"status": "error", "message_id": raw_message.get("id"), "error": str(e)}
+
+    async def _process_media(self, message: Message, access_token: str) -> Dict[str, Optional[str]]:
+        media_paths = {
+            "image_file_path": None,
+            "doc_path": None,
+            "video_file_path": None
+        }
+        
+        if not message.media:
+            return media_paths
+
+        for media_type, content in message.media.items():
+            self.logger.info(f"Processing {media_type.value}: {content.file_path}")
+            file_path = await self.media_handler.download(
+                content.id,
+                access_token,
+                content.file_path
+            )
+            self.logger.info(f"{media_type.value} file_path: {file_path}")
+            
+            if media_type == MediaType.IMAGE:
+                media_paths["image_file_path"] = file_path
+            elif media_type == MediaType.DOCUMENT:
+                media_paths["doc_path"] = file_path
+            elif media_type == MediaType.VIDEO:
+                media_paths["video_file_path"] = file_path
+
+        return media_paths

app/handlers/webhook_handler.py

@@ -0,0 +1,52 @@
+# webhook_handler.py
+from dataclasses import dataclass
+from typing import List, Dict
+import time
+import logging
+from fastapi import Request, status
+from fastapi.responses import JSONResponse
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class WebhookResponse:
+    request_id: str
+    results: List[Dict]
+
+class WebhookHandler:
+    def __init__(self, message_handler):
+        self.message_handler = message_handler
+        self.logger = logging.getLogger(__name__)
+
+    async def process_webhook(self, payload: dict, access_token: str) -> WebhookResponse:
+        request_id = f"req_{int(time.time()*1000)}"
+        results = []
+
+        self.logger.info(f"Processing webhook request {payload}")
+
+        try:
+            entries = payload.get("entry", [])
+            for entry in entries:
+                entry_id = entry.get("id")
+                self.logger.info(f"Processing entry_id: {entry_id}")
+
+                changes = entry.get("changes", [])
+                for change in changes:
+                    messages = change.get("value", {}).get("messages", [])
+                    for message in messages:
+                        self.logger.info(f"Processing message: {message}")
+                        response = await self.message_handler.handle(
+                            raw_message=message,
+                            access_token=access_token
+                        )
+                        results.append(response)
+
+        except Exception as e:
+            self.logger.error(f"Error processing webhook: {str(e)}")
+            return WebhookResponse(
+                request_id=request_id,
+                results=[{"status": "error", "error": str(e)}]
+            )
+
+        self.logger.info(f"Webhook processing completed - Results: {len(results)}")
+        return WebhookResponse(request_id=request_id, results=results)

app/main.py

@@ -2,15 +2,27 @@ from fastapi import FastAPI, Request, status
 from fastapi.responses import JSONResponse
 from fastapi.responses import Response
 from fastapi.exceptions import HTTPException
-from typing import Dict
-from app.services.message import generate_reply, send_reply, process_message_with_retry
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+from slowapi.util import get_remote_address
+from typing import Dict, List
+from prometheus_client import Counter, Histogram, start_http_server
+from pydantic import BaseModel, ValidationError
+from app.services.message import generate_reply, send_reply
 import logging
 from datetime import datetime
 import time
 from contextlib import asynccontextmanager
 from app.db.database import create_indexes, init_db
 from app.endpoints.v1 import users
-from app.services.webhook_handler import webhook, verify_webhook
+from app.services.webhook_handler import verify_webhook
+from app.handlers.message_handler import MessageHandler
+from app.handlers.webhook_handler import WebhookHandler
+from app.handlers.media_handler import WhatsAppMediaHandler
+from app.services.cache import MessageCache
+from app.services.chat_manager import ChatManager
+
+from app.utils.load_env import ACCESS_TOKEN
 
 # Configure logging
 logging.basicConfig(
@@ -19,6 +31,24 @@ logging.basicConfig(
 )
 
 logger = logging.getLogger(__name__)
+
+# Initialize handlers at startup
+message_handler = None
+webhook_handler = None
+
+
+async def setup_message_handler():
+    logger = logging.getLogger(__name__)
+    message_cache = MessageCache()
+    chat_manager = ChatManager()
+    media_handler = WhatsAppMediaHandler()
+    
+    return MessageHandler(
+        message_cache=message_cache,
+        chat_manager=chat_manager,
+        media_handler=media_handler,
+        logger=logger
+    )
 # Initialize FastAPI app
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -26,21 +56,84 @@ async def lifespan(app: FastAPI):
     
     try:
         await init_db()
+
         logger.info("Connected to the MongoDB database!")
+
+
+        global message_handler, webhook_handler
+        message_handler = await setup_message_handler()
+        webhook_handler = WebhookHandler(message_handler)
         # collections = app.database.list_collection_names()
         # print(f"Collections in {db_name}: {collections}")
         yield
     except Exception as e:
         logger.error(e)
-        
+
+# Initialize Limiter and Prometheus Metrics
+limiter = Limiter(key_func=get_remote_address)
 app = FastAPI(lifespan=lifespan)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
 
 
 app.include_router(users.router, prefix="/users", tags=["Users"])
 
+
+# Prometheus metrics
+webhook_requests = Counter('webhook_requests_total', 'Total webhook requests')
+webhook_processing_time = Histogram('webhook_processing_seconds', 'Time spent processing webhook')
+
+# Start Prometheus metrics server on port 8002
+# start_http_server(8002)
 # Register webhook routes
-app.post("/webhook")(webhook)
+# app.post("/webhook")(webhook)
+# Define Pydantic schema for request validation
+class WebhookPayload(BaseModel):
+    entry: List[Dict]
+
+@app.post("/webhook")
+@limiter.limit("100/minute")
+async def webhook(request: Request):
+    try:
+        payload = await request.json()
+
+        # validated_payload = WebhookPayload(**payload)  # Validate payload
+        # logger.info(f"Validated Payload: {validated_payload}")
+            
+            # Process the webhook payload here
+            # For example:
+        # results = process_webhook_entries(validated_payload.entry)
+        response = await webhook_handler.process_webhook(
+            payload=payload,
+            access_token=ACCESS_TOKEN
+        )
+        
+        return JSONResponse(
+            content=response.__dict__,
+            status_code=status.HTTP_200_OK
+        )
+        
+    except ValidationError as ve:
+            logger.error(f"Validation error: {ve}")
+            return JSONResponse(
+                content={"status": "error", "detail": ve.errors()},
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY
+            )
+    except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            return JSONResponse(
+                content={"status": "error", "detail": str(e)},
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+    
 app.get("/webhook")(verify_webhook)
+
+# Add a route for Prometheus metrics (optional, if not using a separate Prometheus server)
+@app.get("/metrics")
+async def metrics():
+    from prometheus_client import generate_latest
+    return Response(content=generate_latest(), media_type="text/plain")
 # In-memory cache with timestamp cleanup
 # class MessageCache:
 #     def __init__(self, max_age_hours: int = 24):

app/models/message_types.py

@@ -0,0 +1,23 @@
+# message_types.py
+from dataclasses import dataclass
+from typing import Optional, Dict, List
+from enum import Enum
+
+class MediaType(Enum):
+    IMAGE = "image"
+    DOCUMENT = "document"
+    VIDEO = "video"
+
+@dataclass
+class MediaContent:
+    id: str
+    file_path: str
+    mime_type: Optional[str] = None
+    filename: Optional[str] = None
+
+@dataclass
+class Message:
+    id: str
+    sender_id: str
+    content: Optional[str]
+    media: Optional[Dict[MediaType, MediaContent]] = None

app/services/chat_manager.py

@@ -0,0 +1,19 @@
+from typing import Dict, List
+
+# chat_manager.py
+class ChatManager:
+    def __init__(self):
+        self.user_chats: Dict[str, List[Dict]] = {}
+
+    def initialize_chat(self, sender_id: str) -> None:
+        if sender_id not in self.user_chats:
+            self.user_chats[sender_id] = [
+                {"role": "user", "parts": "This is the chat history so far"}
+            ]
+
+    def append_message(self, sender_id: str, role: str, content: str) -> None:
+        if content:
+            self.user_chats[sender_id].append({"role": role, "parts": content})
+
+    def get_chat_history(self, sender_id: str) -> List[Dict]:
+        return self.user_chats.get(sender_id, [])

app/services/message.py

@@ -18,8 +18,6 @@ load_dotenv()
 
 genai.configure(api_key=GEMNI_API)
 client = AsyncOpenAI(api_key = OPENAI_API)
-# ACCESS_TOKEN = "EAAQNYsHYo2cBO30HZCtSkpRppS8ZA6Du2MV9PPFFepInIb2og5cjP1ZAZBJrJhHTlkmcrcN0BS6NZAqMltXhOZBzAyGdNaZCL6XtC6ZCdcug5JR5fZCdXVMzOBbuwPKPBwZABhFsWDIAORYaCI97ajvUxrZCSALNZAIH1E5hs2ZApETvWoVMiZCnoT5MqpyAZBoFFJ84K6vFgZDZD"
-
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
@@ -27,11 +25,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Define the WhatsApp API URL and Access Token
-# WHATSAPP_API_URL = os.environ.get("WHATSAPP_API_URL")
-# WHATSAPP_API_URL = "https://graph.facebook.com/v21.0/360447720489034/messages"
-# ACCESS_TOKEN = os.environ.get("ACCESS_TOKEN")
-
 # Validate environment variables
 if not WHATSAPP_API_URL or not ACCESS_TOKEN:
     logger.warning("Environment variables for WHATSAPP_API_URL or ACCESS_TOKEN are not set!")
@@ -77,88 +70,166 @@ async def generate_reply(sender: str, content: str, timestamp: int) -> str:
         logger.error(f"Error generating reply: {str(e)}", exc_info=True)
         return f"Sorry {sender}, I couldn't process your message. Please try again."
 
-# Process message with retry logic
-async def process_message_with_retry(
+async def process_message_with_llm(
     sender_id: str,
     content: str,
-    history: List[str],
-    timestamp: Optional[int] = None,
-    media: Optional[Dict[str, Any]] = None,
+    history: List[Dict[str, str]],
     image_file_path: Optional[str] = None,
     doc_path: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Process message with retry logic"""
-    retries = 1
-    delay = 0.1  # Initial delay in seconds
-
-    # for attempt in range(retries):
+    video_file_path: Optional[str] = None,
+) -> str:
+    """Process message with retry logic."""
     try:
-        logger.info(f"Sending message to the Gemini model...")
-        generated_reply = await generate_response_from_gemini(sender = sender_id, content=content, history = history, timestamp = timestamp, image_file_path = image_file_path, media=media, doc_path = doc_path)   
-        logger.info(f"Reply generated: {generated_reply}")
+        logger.info(f"Processing message for sender: {sender_id}")
+        generated_reply = await generate_response_from_gemini(
+            sender=sender_id,
+            content=content,
+            history=history,
+            image_file_path=image_file_path,
+            doc_path=doc_path,
+            video_file_path=video_file_path
+        )
+        logger.info(f"Generated reply: {generated_reply}")
+
         response = await send_reply(sender_id, generated_reply)
+#         return generated_reply
         return generated_reply
-        return {"status": "success", "reply": generated_reply, "response": response}
     except Exception as e:
-        logger.error(f"Error generating reply: {str(e)}", exc_info=True)
-        return {"status": "error", "reply": "Sorry, I couldn't generate a response at this time."}
-        # logger.error(f"Attempt {attempt + 1} failed: {str(e)}", exc_info=True)
-        # if attempt < retries - 1:
-        #     await asyncio.sleep(delay)
-        #     delay *= 2  # Exponential backoff
-        # else:
-        #     raise Exception(f"All {retries} attempts failed.") from e
-
-# Example usage
-# asyncio.run(process_message_with_retry("1234567890", "hello", 1700424056000))
-
-
-async def generate_response_from_gemini(sender: str, content: str, timestamp: str, history: List[Dict[str, str]], media: Optional[Dict[str, Any]] = None, image_file_path: Optional[str] = None, doc_path: Optional[str] = None) -> str:
+        logger.error(f"Error in process_message_with_retry: {str(e)}", exc_info=True)
+        return "Sorry, I couldn't generate a response at this time."
+    
+async def generate_response_from_gemini(
+    sender: str,
+    content: str,
+    history: List[Dict[str, str]],
+    image_file_path: Optional[str] = None,
+    doc_path: Optional[str] = None,
+    video_file_path: Optional[str] = None,
+) -> str:
     try:
-        print(f"Sender: {sender}")
-        print(f"Content: {content}")
-        print(f"Timestamp: {timestamp}")
-        print(f"History: {history}")
-        print(f"Media: {media}")
+        logger.info(f"Generating response for sender: {sender}")
 
         # Initialize the model
         model = genai.GenerativeModel("gemini-1.5-pro-002")
 
-        # Define the chat history
-        chat = model.start_chat(
-            history=history
-        )
-        logger.info(f"file_path: {image_file_path}")
-        if image_file_path: # Should be bytes or a file-like object
-    
+        # Start chat with history
+        chat = model.start_chat(history=history)
 
-            prompt = "Describe the following image:"
+        # Process image
+        if image_file_path:
+            logger.info(f"Processing image at {image_file_path}")
             image_data = PIL.Image.open(image_file_path)
-
-            print("Sending image to the Gemini model...")
             response = await chat.send_message_async(image_data)
-            print(f"Model response: {response.text}")
             return response.text
-        
+
+        # Process document
         if doc_path:
+            logger.info(f"Processing document at {doc_path}")
             doc_data = genai.upload_file(doc_path)
-            print("Sending document to the Gemini model...")
             response = await chat.send_message_async(doc_data)
-            print(f"Model response: {response.text}")
             return response.text
 
+        # Process video (if supported)
+        if video_file_path:
+            logger.info(f"Processing video at {video_file_path}")
+            video_data = genai.upload_file(video_file_path)
+            response = await chat.send_message_async(video_data)
+            return response.text
+            # Implement video processing logic here
+            pass  # Placeholder for video processing logic
+
         # Send the user's message
-        print("Sending message to the Gemini model...")
         response = await chat.send_message_async(content)
-        print(f"Model response: {response.text}")
-
         return response.text
 
     except Exception as e:
-        print("Error generating reply from Gemini:", e)
+        logger.error("Error in generate_response_from_gemini:", exc_info=True)
         return "Sorry, I couldn't generate a response at this time."
 
 
+
+# Process message with retry logic
+# async def process_message_with_retry(
+#     sender_id: str,
+#     content: str,
+#     history: List[str],
+#     timestamp: Optional[int] = None,
+#     media: Optional[Dict[str, Any]] = None,
+#     image_file_path: Optional[str] = None,
+#     doc_path: Optional[str] = None,
+# ) -> Dict[str, Any]:
+#     """Process message with retry logic"""
+#     retries = 1
+#     delay = 0.1  # Initial delay in seconds
+
+#     # for attempt in range(retries):
+#     try:
+#         logger.info(f"Sending message to the Gemini model...")
+#         generated_reply = await generate_response_from_gemini(sender = sender_id, content=content, history = history, timestamp = timestamp, image_file_path = image_file_path, media=media, doc_path = doc_path)   
+#         logger.info(f"Reply generated: {generated_reply}")
+#         response = await send_reply(sender_id, generated_reply)
+#         return generated_reply
+#         return {"status": "success", "reply": generated_reply, "response": response}
+#     except Exception as e:
+#         logger.error(f"Error generating reply: {str(e)}", exc_info=True)
+#         return {"status": "error", "reply": "Sorry, I couldn't generate a response at this time."}
+        # logger.error(f"Attempt {attempt + 1} failed: {str(e)}", exc_info=True)
+        # if attempt < retries - 1:
+        #     await asyncio.sleep(delay)
+        #     delay *= 2  # Exponential backoff
+        # else:
+        #     raise Exception(f"All {retries} attempts failed.") from e
+
+# Example usage
+# asyncio.run(process_message_with_retry("1234567890", "hello", 1700424056000))
+
+
+# async def generate_response_from_gemini(sender: str, content: str, timestamp: str, history: List[Dict[str, str]], media: Optional[Dict[str, Any]] = None, image_file_path: Optional[str] = None, doc_path: Optional[str] = None) -> str:
+#     try:
+#         print(f"Sender: {sender}")
+#         print(f"Content: {content}")
+#         print(f"Timestamp: {timestamp}")
+#         print(f"History: {history}")
+#         print(f"Media: {media}")
+
+#         # Initialize the model
+#         model = genai.GenerativeModel("gemini-1.5-pro-002")
+
+#         # Define the chat history
+#         chat = model.start_chat(
+#             history=history
+#         )
+#         logger.info(f"file_path: {image_file_path}")
+#         if image_file_path: # Should be bytes or a file-like object
+    
+
+#             prompt = "Describe the following image:"
+#             image_data = PIL.Image.open(image_file_path)
+
+#             print("Sending image to the Gemini model...")
+#             response = await chat.send_message_async(image_data)
+#             print(f"Model response: {response.text}")
+#             return response.text
+        
+#         if doc_path:
+#             doc_data = genai.upload_file(doc_path)
+#             print("Sending document to the Gemini model...")
+#             response = await chat.send_message_async(doc_data)
+#             print(f"Model response: {response.text}")
+#             return response.text
+
+#         # Send the user's message
+#         print("Sending message to the Gemini model...")
+#         response = await chat.send_message_async(content)
+#         print(f"Model response: {response.text}")
+
+#         return response.text
+
+#     except Exception as e:
+#         print("Error generating reply from Gemini:", e)
+#         return "Sorry, I couldn't generate a response at this time."
+
+
 async def generate_response_from_chatgpt(sender: str, content: str, timestamp: str, history: str) -> str:
     """
     Generate a reply using OpenAI's ChatGPT API.

app/services/message_parser.py

@@ -0,0 +1,36 @@
+# message_parser.py
+
+from app.models.message_types import Message, MediaContent, MediaType
+
+class MessageParser:
+    @staticmethod
+    def parse(raw_message: dict) -> Message:
+        media = {}
+        
+        if image := raw_message.get("image"):
+            media[MediaType.IMAGE] = MediaContent(
+                id=image["id"],
+                file_path=f"{image['id']}.jpg"
+            )
+            
+        if document := raw_message.get("document"):
+            media[MediaType.DOCUMENT] = MediaContent(
+                id=document["id"],
+                file_path=document.get("filename"),
+                filename=document.get("filename")
+            )
+            
+        if video := raw_message.get("video"):
+            mime_type = video.get("mime_type")
+            media[MediaType.VIDEO] = MediaContent(
+                id=video["id"],
+                file_path=f"{video['id']}.{mime_type.split('/')[-1]}",
+                mime_type=mime_type
+            )
+
+        return Message(
+            id=raw_message["id"],
+            sender_id=raw_message["from"],
+            content=raw_message.get("text", {}).get("body"),
+            media=media if media else None
+        )

app/services/webhook_handler.py

@@ -3,7 +3,7 @@ from fastapi import Request, status
 from fastapi.responses import JSONResponse, Response
 from fastapi.exceptions import HTTPException
 from app.services.cache import MessageCache
-from app.services.message import process_message_with_retry
+
 from app.services.download_media import download_whatsapp_media
 from app.utils.handle_message import handle_message
 from app.utils.load_env import ACCESS_TOKEN
@@ -13,39 +13,40 @@ logger = logging.getLogger(__name__)
 message_cache = MessageCache()
 user_chats = {}
 
-async def webhook(request: Request):
-    request_id = f"req_{int(time.time()*1000)}"
-
-    payload = await request.json()
-    logger.info(f"Processing webhook request {payload}")
-    processed_count = 0
-    error_count = 0
-    results = []
-
-    entries = payload.get("entry", [])
-    for entry in entries:
-        entry_id = entry.get("id")
-        logger.info(f"Processing entry_id: {entry_id}")
-
-        changes = entry.get("changes", [])
-        for change in changes:
-            messages = change.get("value", {}).get("messages", [])
-            media = {}
-            for message in messages:
-                logger.info(f"Processing message: {message}")
-                response = await handle_message(message=message, user_chats = user_chats, message_cache = message_cache, access_token = ACCESS_TOKEN)
-
-                results.append(response)
-
-    response_data = {
-        "request_id": request_id,
-        # "processed": processed_count,
-        # "errors": error_count,
-        "results": results,
-    }
-
-    logger.info(f"Webhook processing completed - Processed: {processed_count}, Errors: {error_count}")
-    return JSONResponse(content=response_data, status_code=status.HTTP_200_OK)
+
+# async def webhook(request: Request):
+#     request_id = f"req_{int(time.time()*1000)}"
+
+#     payload = await request.json()
+#     logger.info(f"Processing webhook request {payload}")
+#     processed_count = 0
+#     error_count = 0
+#     results = []
+
+#     entries = payload.get("entry", [])
+#     for entry in entries:
+#         entry_id = entry.get("id")
+#         logger.info(f"Processing entry_id: {entry_id}")
+
+#         changes = entry.get("changes", [])
+#         for change in changes:
+#             messages = change.get("value", {}).get("messages", [])
+#             media = {}
+#             for message in messages:
+#                 logger.info(f"Processing message: {message}")
+#                 response = await handle_message(message=message, user_chats = user_chats, message_cache = message_cache, access_token = ACCESS_TOKEN)
+
+#                 results.append(response)
+
+#     response_data = {
+#         "request_id": request_id,
+#         # "processed": processed_count,
+#         # "errors": error_count,
+#         "results": results,
+#     }
+
+#     logger.info(f"Webhook processing completed - Processed: {processed_count}, Errors: {error_count}")
+#     return JSONResponse(content=response_data, status_code=status.HTTP_200_OK)
 
 async def verify_webhook(request: Request):
     mode = request.query_params.get('hub.mode')

app/utils/handle_message.py

@@ -1,5 +1,5 @@
 from app.services.download_media import download_whatsapp_media
-from app.services.message import process_message_with_retry
+from app.services.message import process_message_with_llm
 from app.services.cache import MessageCache
 import logging
 
@@ -61,7 +61,7 @@ async def handle_message(message, user_chats, message_cache, access_token):
     
     
         # Process the message
-        result = await process_message_with_retry(sender_id, content, user_chats[sender_id], image_file_path = image_file_path, doc_path = document_file_path)
+        result = await process_message_with_llm(sender_id, content, user_chats[sender_id], image_file_path = image_file_path, doc_path = document_file_path)
         
         if content != None:
             user_chats[sender_id].append({"role": "user", "parts": content})

testcode.py

@@ -0,0 +1,4 @@
+import PIL.Image
+
+organ = PIL.Image.open("organ.jpg")
+print(organ)