Update app.py

app.py

@@ -2995,6 +2995,317 @@ async def handle_veterinary_product_followup(selection: str, from_number: str) -
             current_menu_options=list(MENU_CONFIG['main_menu']['option_descriptions'].values())
         )
 
+# Add or update the following functions in app.py:
+
+# --- Restore handle_voice_message_complete ---
+async def handle_voice_message_complete(from_number: str, msg: dict):
+    """Complete voice message processing with OpenAI transcription - treats voice exactly like text"""
+    try:
+        logger.info(f"[Voice] Processing voice message from {from_number}")
+        logger.info(f"[Voice] Message structure: {msg}")
+        
+        # Check if OpenAI is available
+        if not OPENAI_API_KEY:
+            send_whatsjet_message(from_number, 
+                "🎤 Voice messages require OpenAI API. Please send a text message or type 'main' to see the menu.")
+            return
+        
+        # Extract media URL from different possible locations
+        media_url = None
+        logger.info(f"[Voice] Checking media URL locations...")
+        
+        if msg.get('media', {}).get('link'):
+            media_url = msg.get('media', {}).get('link')
+            logger.info(f"[Voice] Found media URL in media.link: {media_url}")
+        elif msg.get('media', {}).get('url'):
+            media_url = msg.get('media', {}).get('url')
+            logger.info(f"[Voice] Found media URL in media.url: {media_url}")
+        elif msg.get('url'):
+            media_url = msg.get('url')
+            logger.info(f"[Voice] Found media URL in url: {media_url}")
+        elif msg.get('audio', {}).get('url'):
+            media_url = msg.get('audio', {}).get('url')
+            logger.info(f"[Voice] Found media URL in audio.url: {media_url}")
+        else:
+            logger.error(f"[Voice] No media URL found in message structure")
+            logger.error(f"[Voice] Available fields: {list(msg.keys())}")
+            if 'media' in msg:
+                logger.error(f"[Voice] Media fields: {list(msg['media'].keys())}")
+        
+        logger.info(f"[Voice] Final extracted media URL: {media_url}")
+        
+        if not media_url:
+            send_whatsjet_message(from_number, "❌ Could not process voice message. Please try again.")
+            return
+        
+        # Generate unique filename
+        filename = f"voice_{from_number}_{int(time.time())}.ogg"
+        
+        # Download voice file
+        file_path = await download_voice_file(media_url, filename)
+        if not file_path:
+            send_whatsjet_message(from_number, "❌ Failed to download voice message. Please try again.")
+            return
+        
+        # Transcribe with OpenAI
+        transcribed_text = await transcribe_voice_with_openai(file_path)
+        
+        # Clean up voice file immediately
+        try:
+            os.remove(file_path)
+        except:
+            pass
+        
+        # Handle empty or failed transcription
+        if not transcribed_text or transcribed_text.strip() == "":
+            logger.warning(f"[Voice] Empty transcription for {from_number}")
+            send_whatsjet_message(from_number, 
+                "🎤 *Voice Message Issue*\n\n"
+                "I couldn't hear anything in your voice message. This can happen due to:\n"
+                "• Very short voice note\n"
+                "• Background noise\n"
+                "• Microphone too far away\n"
+                "• Audio quality issues\n\n"
+                "💡 *Tips for better voice notes:*\n"
+                "• Speak clearly and slowly\n"
+                "• Keep phone close to mouth\n"
+                "• Record in quiet environment\n"
+                "• Make voice note at least 2-3 seconds\n\n"
+                "💬 *You can also:*\n"
+                "• Send a text message\n"
+                "• Type 'main' to see menu options\n"
+                "• Try voice note again")
+            return
+        
+        # Process transcribed text with full intelligence
+        logger.info(f"[Voice] Transcribed: {transcribed_text}")
+        
+        # Apply transcription error corrections
+        corrected_text = process_voice_input(transcribed_text)
+        if corrected_text != transcribed_text:
+            logger.info(f"[Voice] Applied corrections: '{transcribed_text}' -> '{corrected_text}'")
+            transcribed_text = corrected_text
+        
+        # Detect language of transcribed text
+        detected_lang = 'en'  # Default to English
+        try:
+            detected_lang = detect(transcribed_text)
+            logger.info(f"[Voice] Detected language: {detected_lang}")
+            
+            # Map language codes to supported languages
+            lang_mapping = {
+                'ur': 'ur',  # Urdu
+                'ar': 'ur',  # Arabic (treat as Urdu for Islamic greetings)
+                'en': 'en',  # English
+                'hi': 'ur',  # Hindi (treat as Urdu)
+                'bn': 'ur',  # Bengali (treat as Urdu)
+                'pa': 'ur',  # Punjabi (treat as Urdu)
+                'id': 'ur',  # Indonesian (often misdetected for Urdu/Arabic)
+                'ms': 'ur',  # Malay (often misdetected for Urdu/Arabic)
+                'tr': 'ur',  # Turkish (often misdetected for Urdu/Arabic)
+            }
+            
+            # Check if text contains Urdu/Arabic characters or Islamic greetings
+            urdu_arabic_pattern = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+            islamic_greetings = ['assalamu', 'assalam', 'salam', 'salaam', 'adaab', 'namaste', 'khuda', 'allah']
+            
+            has_urdu_chars = bool(urdu_arabic_pattern.search(transcribed_text))
+            has_islamic_greeting = any(greeting in transcribed_text.lower() for greeting in islamic_greetings)
+            
+            if has_urdu_chars or has_islamic_greeting:
+                detected_lang = 'ur'
+                logger.info(f"[Voice] Overriding language detection to Urdu due to Arabic/Urdu characters or Islamic greeting")
+            
+            reply_language = lang_mapping.get(detected_lang, 'en')
+            logger.info(f"[Voice] Language '{detected_lang}' mapped to: {reply_language}")
+            
+        except Exception as e:
+            logger.warning(f"[Voice] Language detection failed: {e}")
+            reply_language = 'en'
+        
+        if reply_language not in ['en', 'ur']:
+            logger.info(f"[Voice] Language '{reply_language}' not supported, defaulting to English")
+            reply_language = 'en'
+        
+        # For Urdu voice notes, translate to English for processing
+        processing_text = transcribed_text
+        if reply_language == 'ur' and detected_lang == 'ur':
+            try:
+                logger.info(f"[Voice] Translating Urdu voice note to English for processing")
+                translated_text = GoogleTranslator(source='ur', target='en').translate(transcribed_text)
+                processing_text = translated_text
+                logger.info(f"[Voice] Translated to English: {translated_text}")
+            except Exception as e:
+                logger.error(f"[Voice] Translation failed: {e}")
+                # If translation fails, use original text
+                processing_text = transcribed_text
+        
+        # Determine reply language - always respond in English or Urdu
+        if detected_lang == 'ur':
+            reply_language = 'ur'  # Urdu voice notes get Urdu replies
+        else:
+            reply_language = 'en'  # All other languages get English replies
+        
+        logger.info(f"[Voice] Processing text: {processing_text}")
+        logger.info(f"[Voice] Reply language set to: {reply_language}")
+        
+        # Check if this is a greeting in voice note (check both original and translated)
+        if is_greeting(transcribed_text) or is_greeting(processing_text):
+            logger.info(f"[Voice] Greeting detected in voice note: {transcribed_text}")
+            
+            # Check if user is currently in AI chat mode - if so, don't trigger menu mode
+            user_context = context_manager.get_context(from_number)
+            current_state = user_context.get('current_state', 'main_menu')
+            
+            if current_state == 'ai_chat_mode':
+                logger.info(f"[Voice] User is in AI chat mode, treating greeting as AI query instead of menu trigger")
+                # Treat greeting as a general query in AI chat mode
+                await handle_general_query_with_ai(from_number, processing_text, user_context, reply_language)
+                return
+            else:
+                # Only trigger menu mode if not in AI chat mode
+                welcome_msg = generate_veterinary_welcome_message(from_number, user_context)
+                send_whatsjet_message(from_number, welcome_msg)
+                context_manager.update_context(from_number, current_state='main_menu', current_menu='main_menu', current_menu_options=list(MENU_CONFIG['main_menu']['option_descriptions'].values()))
+                return
+        
+        # Process the translated text using the same strict state-based logic as text messages
+        # This ensures voice messages follow the same menu and state rules as text messages
+        await process_incoming_message(from_number, {
+            'body': processing_text,  # Use translated text for processing
+            'type': 'text',
+            'reply_language': reply_language,
+            'original_transcription': transcribed_text  # Keep original for context
+        })
+        
+    except Exception as e:
+        logger.error(f"[Voice] Error processing voice message: {e}")
+        logger.error(f"[Voice] Full error details: {str(e)}")
+        import traceback
+        logger.error(f"[Voice] Traceback: {traceback.format_exc()}")
+        send_whatsjet_message(from_number, 
+            "❌ Error processing voice message. Please try a text message.")
+
+# --- Update send_product_image_with_caption to latest version ---
+async def send_product_image_with_caption(from_number: str, product: Dict[str, Any], user_context: Dict[str, Any]):
+    """
+    Send product image (if available) with product details as caption in a single WhatsApp message.
+    If image is not available, send only the product details as text.
+    Now supports 'Images' column in CSV (Google Drive or direct links).
+    """
+    ensure_images_dir()
+    product_name = product.get('Product Name', 'Unknown Product')
+    details = generate_veterinary_product_response(product, user_context)
+    image_url = product.get('Images', '').strip() if 'Images' in product else ''
+    
+    # Force image URL for Respira Aid Plus (use cPanel public URL)
+    if product_name.lower().strip() == "respira aid plus":
+        image_url = "https://amgocus.com/uploads/images/Respira%20Aid%20Plus.jpg"
+    
+    logger.info(f"[Product] Processing image for product: {product_name}")
+    logger.info(f"[Product] Image URL from CSV: {image_url}")
+    try:
+        # First, check if we have an image URL from CSV
+        if image_url:
+            # Convert Google Drive link to direct download if needed
+            if 'drive.google.com' in image_url:
+                logger.info(f"[Product] Converting Google Drive link: {image_url}")
+                if '/d/' in image_url:
+                    file_id = image_url.split('/d/')[1].split('/')[0]
+                elif 'id=' in image_url:
+                    file_id = image_url.split('id=')[1].split('&')[0]
+                else:
+                    file_id = ''
+                if file_id:
+                    image_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+                    logger.info(f"[Product] Converted to direct download URL: {image_url}")
+            # Use the public URL directly for WhatsApp API
+            media_type = 'image/jpeg'
+            filename = f"{product_name.replace(' ', '_')}.jpg"
+            # Test the image URL first
+            try:
+                logger.info(f"[Product] Testing image URL accessibility: {image_url}")
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    'Accept': 'image/webp,image/apng,image/*,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.9',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                    'Connection': 'keep-alive',
+                    'Upgrade-Insecure-Requests': '1'
+                }
+                test_response = requests.head(image_url, headers=headers, timeout=10, allow_redirects=True)
+                if test_response.status_code != 200:
+                    logger.warning(f"[Product] Image URL not accessible (status {test_response.status_code}): {image_url}")
+                    raise Exception(f"Image URL not accessible: {test_response.status_code}")
+                logger.info(f"[Product] Image URL is accessible")
+            except Exception as e:
+                logger.warning(f"[Product] Failed to test image URL {image_url}: {e}")
+                image_url = None
+            # Send using public URL (not local file)
+            if image_url:
+                logger.info(f"[Product] Attempting to send image from CSV URL for: {product_name}")
+                success = send_whatsjet_message(
+                    from_number,
+                    details,
+                    media_type=media_type,
+                    media_path=image_url,  # Use public URL directly
+                    filename=filename
+                )
+                if success:
+                    logger.info(f"[Product] Successfully sent image from CSV link with caption for product: {product_name}")
+                    return
+                else:
+                    logger.warning(f"[Product] Failed to send image from CSV link, trying fallback: {product_name}")
+        # Fallback 1: Try with a known public test image
+        logger.info(f"[Product] Trying public test image for: {product_name}")
+        test_image_url = "https://www.w3schools.com/w3images/lights.jpg"
+        media_type = 'image/jpeg'
+        filename = f"{product_name.replace(' ', '_')}.jpg"
+        success = send_whatsjet_message(
+            from_number,
+            details,
+            media_type=media_type,
+            media_path=test_image_url,
+            filename=filename
+        )
+        if success:
+            logger.info(f"[Product] Successfully sent test image with caption for product: {product_name}")
+            return
+        # Fallback 2: Try local uploads directory (public URL)
+        logger.info(f"[Product] Trying local uploads directory for: {product_name}")
+        image_path = get_product_image_path(product_name)
+        if image_path and (image_path.startswith('http') or os.path.exists(image_path)):
+            media_type = get_product_image_media_type(image_path)
+            filename = f"{product_name.replace(' ', '_')}.jpg"
+            # If it's already a public URL, use it directly
+            if image_path.startswith('http'):
+                media_path = image_path
+                logger.info(f"[Product] Using existing public URL: {media_path}")
+            else:
+                # Convert local path to public URL
+                media_path = f"https://dreamstream-1-chatbot.hf.space/uploads/{os.path.basename(image_path).replace(' ', '%20')}"
+                logger.info(f"[Product] Converted local path to public URL: {media_path}")
+            success = send_whatsjet_message(
+                from_number,
+                details,
+                media_type=media_type,
+                media_path=media_path,  # Use public URL
+                filename=filename
+            )
+            if success:
+                logger.info(f"[Product] Successfully sent image with caption for product: {product_name}")
+            else:
+                logger.warning(f"[Product] Failed to send image, sending text only: {product_name}")
+                send_whatsjet_message(from_number, details)
+        else:
+            # No image available, send text only
+            logger.info(f"[Product] No image available, sending text only for: {product_name}")
+            send_whatsjet_message(from_number, details)
+    except Exception as e:
+        logger.error(f"[Product] Error sending product image with caption: {e}")
+        logger.info(f"[Product] Falling back to text-only message for: {product_name}")
+        send_whatsjet_message(from_number, details)
+
 if __name__ == "__main__":
     # Launch FastAPI app
     import uvicorn