Webhook should not have a upddate before instancing the bot

pxy_bots/views.py

@@ -16,23 +16,41 @@ logger = logging.getLogger(__name__)
 @csrf_exempt
 async def telegram_webhook(request, bot_name):
     """
-    Webhook view that handles Telegram updates asynchronously and only uses LangChain.
+    Webhook view that handles Telegram updates asynchronously and logs messages.
     """
     try:
         logger.info(f"Webhook called for bot: {bot_name}")
 
-        # Step 1: Fetch the bot instance asynchronously
+        # 1) Fetch the bot instance
         try:
-            bot_instance = await sync_to_async(TelegramBot.objects.get)(name=bot_name, is_active=True)
+            bot_instance = await sync_to_async(TelegramBot.objects.get)(
-            # Step 1.5: get_or_create de la conversación
+                name=bot_name, is_active=True
+            )
+            logger.info(f"Loaded bot configuration: {bot_instance}")
+        except TelegramBot.DoesNotExist:
+            logger.error(f"Bot '{bot_name}' not found or inactive.")
+            return JsonResponse({"error": f"Bot '{bot_name}' not found."}, status=400)
+
+        if request.method != "POST":
+            logger.warning("Received non-POST request")
+            return JsonResponse({"error": "Invalid request method"}, status=405)
+
+        # 2) Parse the incoming update
+        try:
+            payload = json.loads(request.body.decode("utf-8"))
+            update = Update.de_json(payload, Bot(token=bot_instance.token))
+            logger.info(f"Update received: {update}")
+        except Exception as e:
+            logger.error(f"Failed to parse update: {e}")
+            return JsonResponse({"error": "Invalid JSON payload"}, status=400)
+
+        # 3) Log conversation & inbound message
         user_id = str(update.effective_user.id)
         conv, _ = await sync_to_async(TelegramConversation.objects.get_or_create)(
             bot=bot_instance,
             user_id=user_id,
             defaults={'started_at': timezone.now()}
         )
-
-            # Step 1.6: guardar mensaje entrante
         incoming_text = update.message.text or ""
         await sync_to_async(TelegramMessage.objects.create)(
             conversation=conv,
@@ -40,28 +58,9 @@ async def telegram_webhook(request, bot_name):
             content=incoming_text
         )
 
-            logger.info(f"Loaded bot configuration: {bot_instance}")
+        # 4) Route commands or AI
-        except TelegramBot.DoesNotExist:
-            logger.error(f"Bot '{bot_name}' not found or inactive.")
-            return JsonResponse({"error": f"Bot '{bot_name}' not found."}, status=400)
-
-        # Step 2: Ensure the bot has a LangChain assistant
-        if not bot_instance.assistant:
-            logger.error(f"No assistant configured for bot '{bot_name}'.")
-            return JsonResponse({"error": "Assistant not configured."}, status=400)
-
-        # Step 3: Process POST request from Telegram
-        if request.method == "POST":
-            try:
-                request_body = json.loads(request.body.decode("utf-8"))
-                update = Update.de_json(request_body, Bot(token=bot_instance.token))
-                logger.info(f"Update received: {update}")
-            except json.JSONDecodeError as e:
-                logger.error(f"Failed to decode JSON: {e}")
-                return JsonResponse({"error": "Invalid JSON payload"}, status=400)
-
-            # Step 4: Route commands to the appropriate handlers
         if update.message:
+            # built-in commands
             if update.message.text == "/start":
                 await start(update)
             elif update.message.text == "/help":
@@ -71,18 +70,29 @@ async def telegram_webhook(request, bot_name):
             elif update.message.location:
                 await handle_location(update)
             else:
-                    # Step 5: Process AI-generated response using LangChain
+                # AI fallback
-                    assistant_instance = await sync_to_async(LangchainAIService)(bot_instance.assistant)
+                assistant_instance = await sync_to_async(LangchainAIService)(
-                    bot_response = await sync_to_async(assistant_instance.generate_response)(update.message.text)
+                    bot_instance.assistant
+                )
+                start_time = timezone.now()
+                bot_response = await sync_to_async(
+                    assistant_instance.generate_response
+                )(update.message.text)
+                response_time = int((timezone.now() - start_time).total_seconds() * 1000)
 
-                    # Step 6: Send the response back to Telegram
+                # Send reply
                 await update.message.reply_text(bot_response)
 
+                # 5) Log outbound message
+                await sync_to_async(TelegramMessage.objects.create)(
+                    conversation=conv,
+                    direction=TelegramMessage.OUT,
+                    content=bot_response,
+                    response_time_ms=response_time
+                )
+
         return JsonResponse({"status": "ok"})
 
-        logger.warning("Received non-POST request")
-        return JsonResponse({"error": "Invalid request method"}, status=400)
-
     except Exception as e:
-        logger.error(f"Error in webhook: {e}")
+        logger.error(f"Error in telegram_webhook: {e}")
-        return JsonResponse({"error": f"Unexpected error: {str(e)}"}, status=500)
+        return JsonResponse({"error": f"Unexpected error: {e}"}, status=500)