some files added

gemini_helper.py

@@ -0,0 +1,428 @@
+# Groq AI Helper for Natural Language Understanding with Structured Output
+
+from groq import Groq
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+import re
+import json
+from voice_config import GROQ_API_KEY, USE_GROQ_AI
+
+
+# Pydantic Models for Structured Output
+class RequestTypeResponse(BaseModel):
+    intent: Literal["exchange", "return"] = Field(description="Whether customer wants exchange or return")
+    confidence: Literal["high", "medium", "low"] = Field(description="Confidence level")
+    reasoning: str = Field(description="Brief explanation")
+
+
+class OrderIdResponse(BaseModel):
+    order_id: Optional[str] = Field(description="Order ID extracted, null if not found")
+    found: bool = Field(description="Whether order ID was found")
+    interpretation: str = Field(description="How it was interpreted")
+
+
+class ReasonResponse(BaseModel):
+    reason: str = Field(description="Professional reason in 2nd person (You...), max 10 words")
+    category: Literal["size", "defect", "wrong_item", "preference", "delivery", "other"] = Field(description="Issue category")
+
+
+class PreferenceResponse(BaseModel):
+    preference: str = Field(description="Product description, max 15 words")
+    type: Literal["size", "color", "model", "feature", "other"] = Field(description="Preference type")
+
+
+class ConfirmationResponse(BaseModel):
+    confirmed: bool = Field(description="True if confirming, False if declining")
+    confidence: Literal["high", "medium", "low"] = Field(description="Confidence level")
+
+
+class CorrectionField(BaseModel):
+    field: Literal["request_type", "order_id", "reason", "exchange_preference", "everything"] = Field(description="Which field the customer wants to correct")
+    reasoning: str = Field(description="Why this field needs correction")
+
+
+class GroqAI:
+    def __init__(self):
+        print(f"\n{'='*60}")
+        print("🔧 INITIALIZING GROQ AI")
+        print(f"USE_GROQ_AI = {USE_GROQ_AI}")
+        print(f"GROQ_API_KEY = {'SET ('+str(len(GROQ_API_KEY))+' chars)' if GROQ_API_KEY else 'NOT SET'}")
+        print(f"{'='*60}\n")
+        
+        self.enabled = USE_GROQ_AI and GROQ_API_KEY
+        if self.enabled:
+            try:
+                self.client = Groq(api_key=GROQ_API_KEY)
+                self.model_name = "llama-3.3-70b-versatile"  # Fast and powerful model
+                print("✅ Groq AI initialized successfully")
+            except Exception as e:
+                print(f"⚠️ Groq AI initialization failed: {e}")
+                self.enabled = False
+        else:
+            print("⚠️ Groq AI is DISABLED - will use basic pattern matching")
+            if not USE_GROQ_AI:
+                print("   Reason: USE_GROQ_AI is False")
+            if not GROQ_API_KEY:
+                print("   Reason: GROQ_API_KEY is not set")
+    
+    def extract_request_type(self, user_text, question_asked="Would you like exchange or return?"):
+        print(f"\n{'='*60}")
+        print(f"🎯 EXTRACT_REQUEST_TYPE")
+        print(f"📝 User Input (raw): '{user_text}'")
+        print(f"📝 User Input (repr): {repr(user_text)}")
+        print(f"📝 Input length: {len(user_text)} chars")
+        print(f"❓ Question: {question_asked}")
+        print(f"🔌 Groq Enabled: {self.enabled}")
+        print(f"{'='*60}")
+        
+        # Clean input
+        user_text_clean = user_text.strip().lower()
+
+        # Fast path: deterministic keyword detection to avoid model mistakes
+        strong_return_keywords = [
+            'return', 'refund', 'money back', 'send back', 'want to return',
+            'need to return', 'request a return', 'two kind of return'
+        ]
+        strong_exchange_keywords = [
+            'exchange', 'swap', 'replace', 'replacement', 'change it', 'different product'
+        ]
+
+        if any(keyword in user_text_clean for keyword in strong_return_keywords):
+            print("   ✅ FAST PATH: RETURN detected via keyword match")
+            return 'return'
+        if any(keyword in user_text_clean for keyword in strong_exchange_keywords):
+            print("   ✅ FAST PATH: EXCHANGE detected via keyword match")
+            return 'exchange'
+        
+        # Try Groq AI first if enabled
+        if self.enabled:
+            try:
+                prompt = (
+                    f"You are analyzing customer service dialogue.\n\n"
+                    f"QUESTION: {question_asked}\n"
+                    f"CUSTOMER SAYS: {user_text}\n\n"
+                    f"TASK: Determine what the customer wants.\n\n"
+                    f"YOU MUST CHOOSE EXACTLY ONE:\n"
+                    f"A) 'exchange' - if they want to swap/replace/exchange the product\n"
+                    f"B) 'return' - if they want to send back/refund/return the product\n\n"
+                    f"EXAMPLES:\n"
+                    f"'exchange' → exchange\n"
+                    f"'return' → return\n"
+                    f"'I want to exchange this' → exchange\n"
+                    f"'can I get a refund' → return\n"
+                    f"'I would like you to process an exchange' → exchange\n"
+                    f"'swap it for another one' → exchange\n\n"
+                    f"Look for these keywords:\n"
+                    f"- exchange, swap, replace, change, different = EXCHANGE\n"
+                    f"- return, refund, send back, money back = RETURN\n\n"
+                    f"RESPOND WITH JSON ONLY:\n"
+                    f'{{"intent": "exchange", "confidence": "high", "reasoning": "..."}}\n'
+                    f'OR\n'
+                    f'{{"intent": "return", "confidence": "high", "reasoning": "..."}}\n\n'
+                    f"The 'intent' MUST be EXACTLY either 'exchange' or 'return' (lowercase).\n"
+                    f"Choose the BEST match even if you're uncertain. NEVER return anything other than 'exchange' or 'return'."
+                )
+                
+                response = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[{"role": "user", "content": prompt}],
+                    response_format={"type": "json_object"},
+                    temperature=0.0,  # More deterministic
+                )
+                
+                json_text = response.choices[0].message.content
+                print(f"[LLM_OUTPUT request_type] {json_text}")
+                result = RequestTypeResponse.model_validate_json(json_text)
+                print(f"✅ Groq Result: {result.intent} ({result.confidence}) - {result.reasoning}")
+                
+                # Validate result is one of the two options
+                if result.intent in ['exchange', 'return']:
+                    return result.intent
+                else:
+                    print(f"⚠️ Invalid intent from Groq: {result.intent}, falling back")
+                    
+            except Exception as e:
+                print(f"❌ Groq Error: {e}")
+                print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+                # ensure downstream always gets a value
+                return 'exchange'
+        
+        # Fallback: Basic keyword matching (ALWAYS returns a result)
+        print(f"\n🔍 BASIC KEYWORD MATCHING")
+        print(f"   Cleaned input: '{user_text_clean}'")
+        
+        # Check for return keywords first
+        return_keywords = ['return', 'refund', 'money back', 'send back', 'don\'t want', 'cancel']
+        for keyword in return_keywords:
+            if keyword in user_text_clean:
+                print(f"   ✅ RETURN detected (keyword: '{keyword}')")
+                return 'return'
+        
+        # Check for exchange keywords
+        exchange_keywords = ['exchange', 'swap', 'replace', 'change', 'different']
+        for keyword in exchange_keywords:
+            if keyword in user_text_clean:
+                print(f"   ✅ EXCHANGE detected (keyword: '{keyword}')")
+                return 'exchange'
+        
+        # If no keywords found, make best guess based on partial matches
+        print(f"   ⚠️ No exact keywords found, checking partial matches...")
+        
+        if any(word in user_text_clean for word in ['exch', 'swp', 'replac']):
+            print(f"   ✅ EXCHANGE detected (partial match)")
+            return 'exchange'
+        
+        if any(word in user_text_clean for word in ['retur', 'refun', 'back']):
+            print(f"   ✅ RETURN detected (partial match)")
+            return 'return'
+        
+        # Absolute last resort: default to exchange
+        print(f"   ⚠️ No matches found, defaulting to EXCHANGE")
+        return 'exchange'
+    
+    def extract_order_id(self, user_text, question_asked="Please provide your order ID"):
+        print(f"\n🎯 EXTRACT_ORDER_ID: {user_text}")
+        
+        if not self.enabled:
+            return self._basic_extract_order_id(user_text)
+        
+        try:
+            prompt = (
+                f"Question: {question_asked}\n"
+                f"Response: {user_text}\n\n"
+                "Extract any order number/ID from the customer's response.\n"
+                "Numbers can be spoken as words (e.g., 'one two three' = 123).\n"
+                "Look for patterns like: 'order 123', 'order number ABC', 'ORD-456', etc.\n\n"
+                "You MUST respond with valid JSON in this exact format:\n"
+                '{"order_id": "12345", "found": true, "interpretation": "Extracted from order 12345"}\n'
+                'OR if no order ID found:\n'
+                '{"order_id": null, "found": false, "interpretation": "No order ID mentioned"}'
+            )
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                response_format={"type": "json_object"},
+                temperature=0.1,
+            )
+            
+            json_text = response.choices[0].message.content
+            print(f"🔍 Groq JSON Response: {json_text}")
+            result = OrderIdResponse.model_validate_json(json_text)
+            
+            if result.found and result.order_id:
+                order_id = re.sub(r'\D', '', result.order_id)
+                if order_id:
+                    print(f"✅ Order ID: {order_id}")
+                    return order_id
+            
+            return self._basic_extract_order_id(user_text)
+                
+        except Exception as e:
+            print(f"❌ Groq Error: {e}")
+            print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+            return self._basic_extract_order_id(user_text)
+    
+    def extract_reason(self, user_text, request_type, question_asked=None):
+        if not self.enabled:
+            return user_text
+        
+        if not question_asked:
+            question_asked = f"Why do you want to {request_type}?"
+        
+        try:
+            prompt = (
+                f"Question: {question_asked}\n"
+                f"Response: {user_text}\n\n"
+                "Convert their reason to professional format (max 10 words).\n\n"
+                "CRITICAL: Convert 1st person to 2nd person:\n"
+                "- 'I don't like' → 'You didn't like'\n"
+                "- 'I changed my mind' → 'You changed your mind'\n"
+                "- 'It's too small' → 'It's too small' (already neutral)\n"
+                "- 'I ordered wrong size' → 'You ordered wrong size'\n\n"
+                "Categorize as: size, defect, wrong_item, preference, delivery, other\n\n"
+                "You MUST respond with valid JSON in this exact format:\n"
+                '{"reason": "You didn\'t like the product", "category": "preference"}\n'
+                'OR\n'
+                '{"reason": "Wrong size ordered", "category": "size"}\n\n'
+                "The 'category' MUST be one of: size, defect, wrong_item, preference, delivery, other"
+            )
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                response_format={"type": "json_object"},
+                temperature=0.1,
+            )
+            
+            json_text = response.choices[0].message.content
+            print(f"🔍 Groq JSON Response: {json_text}")
+            result = ReasonResponse.model_validate_json(json_text)
+            print(f"✅ Reason: {result.reason} ({result.category})")
+            return result.reason
+                
+        except Exception as e:
+            print(f"❌ Groq Error: {e}")
+            print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+            return user_text
+    
+    def extract_exchange_preference(self, user_text, question_asked="What would you prefer instead?"):
+        if not self.enabled:
+            return user_text
+        
+        try:
+            prompt = (
+                f"Question: {question_asked}\n"
+                f"Response: {user_text}\n\n"
+                "Extract what product they want (max 15 words).\n"
+                "Categorize type as: size, color, model, feature, other\n\n"
+                "You MUST respond with valid JSON in this exact format:\n"
+                '{"preference": "Size large in black", "type": "size"}\n'
+                'OR\n'
+                '{"preference": "Different color - blue", "type": "color"}\n\n'
+                "The 'type' MUST be one of: size, color, model, feature, other"
+            )
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                response_format={"type": "json_object"},
+                temperature=0.1,
+            )
+            
+            json_text = response.choices[0].message.content
+            print(f"🔍 Groq JSON Response: {json_text}")
+            result = PreferenceResponse.model_validate_json(json_text)
+            print(f"✅ Preference: {result.preference} ({result.type})")
+            return result.preference
+                
+        except Exception as e:
+            print(f"❌ Groq Error: {e}")
+            print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+            return user_text
+    
+    def is_confirmation(self, user_text, question_asked="Is this correct?"):
+        if not self.enabled:
+            return self._basic_is_confirmation(user_text)
+        
+        try:
+            prompt = (
+                f"Question: {question_asked}\n"
+                f"Response: {user_text}\n\n"
+                "Is the customer confirming (yes) or declining (no)?\n\n"
+                "AFFIRMATIVE (confirming): yes, yeah, yep, sure, ok, okay, correct, right, go ahead, proceed, confirm\n"
+                "NEGATIVE (declining): no, nope, nah, wrong, incorrect, cancel, stop, wait\n\n"
+                "You MUST respond with valid JSON in this exact format:\n"
+                '{"confirmed": true, "confidence": "high"}\n'
+                'OR\n'
+                '{"confirmed": false, "confidence": "high"}\n\n'
+                "The 'confirmed' field MUST be boolean (true or false).\n"
+                "The 'confidence' MUST be 'high', 'medium', or 'low'."
+            )
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                response_format={"type": "json_object"},
+                temperature=0.1,
+            )
+            
+            json_text = response.choices[0].message.content
+            print(f"🔍 Groq JSON Response: {json_text}")
+            result = ConfirmationResponse.model_validate_json(json_text)
+            print(f"✅ Confirmed: {result.confirmed} ({result.confidence})")
+            return result.confirmed
+                
+        except Exception as e:
+            print(f"❌ Groq Error: {e}")
+            print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+            return self._basic_is_confirmation(user_text)
+    
+    def _basic_extract_request_type(self, text):
+        """Legacy method - not used anymore, kept for compatibility"""
+        text_lower = text.lower().strip()
+        
+        return_keywords = ['return', 'refund', 'money back', 'send back']
+        for keyword in return_keywords:
+            if keyword in text_lower:
+                return 'return'
+        
+        exchange_keywords = ['exchange', 'swap', 'replace', 'change', 'different']
+        for keyword in exchange_keywords:
+            if keyword in text_lower:
+                return 'exchange'
+        
+        # Default to exchange if nothing found
+        return 'exchange'
+    
+    def _basic_extract_order_id(self, text):
+        print(f"🔍 Basic order ID extraction: {text}")
+        match = re.search(r'order[\s#]*(\d+)|(\d+)', text.lower())
+        if match:
+            order_id = match.group(1) or match.group(2)
+            print(f"✅ Found: {order_id}")
+            return order_id
+        print("❌ No order ID found")
+        return None
+    
+    def _basic_is_confirmation(self, text):
+        confirmations = ['yes', 'yeah', 'yep', 'correct', 'right', 'sure', 'ok', 'okay']
+        return any(word in text.lower() for word in confirmations)
+
+
+    def identify_correction_field(self, user_text, current_data):
+        """When user says no to confirmation, identify which field they want to correct"""
+        if not self.enabled:
+            return "everything"
+        
+        try:
+            confirmation_summary = (
+                f"Request type: {current_data.get('request_type', 'N/A')}\n"
+                f"Order ID: {current_data.get('order_id', 'N/A')}\n"
+                f"Reason: {current_data.get('reason', 'N/A')}\n"
+            )
+            if current_data.get('request_type') == 'exchange':
+                confirmation_summary += f"Exchange preference: {current_data.get('exchange_preference', 'N/A')}\n"
+            
+            prompt = (
+                f"The customer declined the confirmation. Here's what we have:\n"
+                f"{confirmation_summary}\n"
+                f"Customer said: {user_text}\n\n"
+                "Which field do they want to correct?\n\n"
+                "Options: request_type, order_id, reason, exchange_preference, everything\n\n"
+                "Examples:\n"
+                "- 'wrong order number' = order_id\n"
+                "- 'I want exchange not return' = request_type\n"
+                "- 'reason is wrong' = reason\n"
+                "- 'start over' = everything\n\n"
+                "You MUST respond with valid JSON in this exact format:\n"
+                '{\"field\": \"order_id\", \"reasoning\": \"Customer mentioned wrong order number\"}\n'
+                'OR\n'
+                '{\"field\": \"everything\", \"reasoning\": \"Customer wants to start over\"}\n\n'
+                "The 'field' MUST be one of: request_type, order_id, reason, exchange_preference, everything"
+            )
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                response_format={"type": "json_object"},
+                temperature=0.1,
+            )
+            
+            json_text = response.choices[0].message.content
+            print(f"🔍 Groq JSON Response: {json_text}")
+            result = CorrectionField.model_validate_json(json_text)
+            print(f"✅ Correction needed for: {result.field} - {result.reasoning}")
+            return result.field
+                
+        except Exception as e:
+            print(f"❌ Groq Error: {e}")
+            print(f"❌ Raw response: {json_text if 'json_text' in locals() else 'No response'}")
+            return "everything"
+
+
+# Global instance
+groq_ai = GroqAI()
+
+# Backwards compatibility alias
+gemini_ai = groq_ai

voice_config.py

@@ -0,0 +1,45 @@
+# Voice Bot Configuration with Groq TTS
+
+# Groq AI Configuration (for NLU + TTS)
+GROQ_API_KEY = "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"  # Get free at: https://console.groq.com/keys
+USE_GROQ_AI = True  # Set to False to use basic pattern matching
+
+# Groq TTS Configuration (Orpheus by Canopy Labs)
+GROQ_TTS_MODEL = "canopylabs/orpheus-v1-english"  # Orpheus English TTS
+GROQ_TTS_VOICE = "autumn"  # Default voice (female, natural)
+
+# Available Groq Orpheus English voices:
+# Female: autumn, diana, hannah
+# Male:   austin, daniel, troy
+#
+# Vocal directions (English only): wrap in brackets, e.g. [cheerful], [whisper]
+# Note: Input limit is 200 characters per API call (auto-chunked)
+
+# Conversation Flow Configuration
+CONVERSATION_TEMPLATES = {
+    'greeting': "Hello! I'm your return and exchange assistant. Would you like to process an exchange or a return?",
+    'ask_exchange_or_return': "Please say 'exchange' if you want to exchange a product, or 'return' if you want to return it.",
+    'ask_order_id': "Please provide your order ID. You can say something like 'order 123'.",
+    'ask_reason': "Please tell me the reason for the {request_type}.",
+    'ask_exchange_preference': "What product would you prefer instead? Please describe what you'd like to exchange it for.",
+    'confirm_details': "Let me confirm: You want to {request_type} order {order_id} because {reason}. {extra_info}Is this correct?",
+    'ask_what_wrong': "What did we get wrong?",
+    'processing': "Perfect! I'm processing your {request_type} request now.",
+    'exchange_pickup_scheduled': "Your exchange pickup has been scheduled for {pickup_date}.",
+    'exchange_delivery_scheduled': "Your new product will be delivered by {delivery_date}.",
+    'return_scheduled': "Your return pickup has been scheduled for {pickup_date}.",
+    'success': "Your {request_type} request has been successfully processed! Tracking number: {tracking_number}",
+    'error': "I'm sorry, I didn't understand that. Could you please repeat?",
+    'goodbye': "Thank you for using our service. Have a great day!"
+}
+
+# Database Configuration
+DATABASE_INTEGRATION = True  # Set to False to disable database updates
+
+# API Endpoints
+DELHIVERY_API_KEY = "your_delhivery_api_key"  # For production
+OPENLEAF_API_KEY = "your_openleaf_api_key"  # For production
+
+# Return/Exchange Settings
+DEFAULT_RETURN_DAYS = 7
+EXCHANGE_DELIVERY_DAYS = 5

voice_service.py

@@ -0,0 +1,581 @@
+# Voice Bot Service – TTS handled by browser speechSynthesis
+
+import requests
+import re
+from datetime import datetime, timedelta
+from django.apps import apps
+from django.http import JsonResponse, HttpResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_http_methods
+from django.utils import timezone
+import json
+from voice_config import *
+from gemini_helper import gemini_ai
+
+
+def _get_voice_models():
+    """Lazy import of VoiceSession / VoiceMessage to avoid AppRegistryNotReady."""
+    VoiceSession = apps.get_model('store', 'VoiceSession')
+    VoiceMessage = apps.get_model('store', 'VoiceMessage')
+    return VoiceSession, VoiceMessage
+
+
+class GroqTTS:
+    """Text-to-Speech using Groq Orpheus TTS API"""
+
+    MAX_INPUT_LEN = 200  # Groq Orpheus hard limit per request
+
+    def __init__(self):
+        self.api_key = GROQ_API_KEY
+        self.model = GROQ_TTS_MODEL
+        self.voice = GROQ_TTS_VOICE
+        self.base_url = "https://api.groq.com/openai/v1"
+
+    # ── internal: single chunk (≤200 chars) ────────────────────────
+    def _tts_chunk(self, text):
+        """Send a single ≤200-char chunk to Groq and return WAV bytes."""
+        url = f"{self.base_url}/audio/speech"
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key.strip()}",
+            "Content-Type": "application/json",
+        }
+
+        data = {
+            "model": self.model,
+            "input": text,
+            "voice": self.voice,
+            "response_format": "wav",
+        }
+
+        response = requests.post(url, json=data, headers=headers)
+        response.raise_for_status()
+        return response.content
+
+    # ── split long text into ≤200-char pieces at sentence boundaries ──
+    @staticmethod
+    def _split_text(text, limit=200):
+        """Break *text* into chunks of at most *limit* characters,
+        splitting on sentence-ending punctuation when possible."""
+        chunks = []
+        while text:
+            if len(text) <= limit:
+                chunks.append(text)
+                break
+            # Try to split at the last sentence-end within the limit
+            segment = text[:limit]
+            split_pos = -1
+            for sep in ['. ', '! ', '? ', '.\'', '!\"', '?\"']:
+                idx = segment.rfind(sep)
+                if idx > split_pos:
+                    split_pos = idx + len(sep)
+            if split_pos <= 0:
+                # Fall back to last space
+                split_pos = segment.rfind(' ')
+            if split_pos <= 0:
+                split_pos = limit  # hard cut
+            chunks.append(text[:split_pos].strip())
+            text = text[split_pos:].strip()
+        return [c for c in chunks if c]
+
+    # ── public API (handles any length) ────────────────────────────
+    def text_to_speech(self, text):
+        """
+        Convert text to speech using Groq Orpheus TTS.
+        Automatically chunks text >200 chars and concatenates WAV output.
+        Returns audio data in WAV format.
+        """
+        import struct, io
+        chunks = self._split_text(text, self.MAX_INPUT_LEN)
+        if not chunks:
+            return None
+
+        try:
+            if len(chunks) == 1:
+                return self._tts_chunk(chunks[0])
+
+            # Multiple chunks: concatenate raw PCM from each WAV
+            pcm_parts = []
+            wav_params = None  # (channels, sample_width, sample_rate)
+            for chunk in chunks:
+                wav_bytes = self._tts_chunk(chunk)
+                buf = io.BytesIO(wav_bytes)
+                # Parse minimal WAV header (44 bytes canonical)
+                buf.read(4)   # RIFF
+                buf.read(4)   # file size
+                buf.read(4)   # WAVE
+                buf.read(4)   # fmt 
+                fmt_size = struct.unpack('<I', buf.read(4))[0]
+                fmt_data = buf.read(fmt_size)
+                channels = struct.unpack('<H', fmt_data[2:4])[0]
+                sample_rate = struct.unpack('<I', fmt_data[4:8])[0]
+                bits = struct.unpack('<H', fmt_data[14:16])[0]
+                if wav_params is None:
+                    wav_params = (channels, bits // 8, sample_rate)
+                # Skip to data chunk
+                while True:
+                    chunk_id = buf.read(4)
+                    if not chunk_id:
+                        break
+                    chunk_size = struct.unpack('<I', buf.read(4))[0]
+                    if chunk_id == b'data':
+                        pcm_parts.append(buf.read(chunk_size))
+                        break
+                    else:
+                        buf.read(chunk_size)
+
+            # Rebuild single WAV
+            pcm = b''.join(pcm_parts)
+            ch, sw, sr = wav_params
+            data_size = len(pcm)
+            header = struct.pack(
+                '<4sI4s4sIHHIIHH4sI',
+                b'RIFF', 36 + data_size, b'WAVE',
+                b'fmt ', 16, 1, ch, sr, sr * ch * sw, ch * sw, sw * 8,
+                b'data', data_size,
+            )
+            return header + pcm
+
+        except requests.exceptions.RequestException as e:
+            print(f"Groq TTS API Error: {e}")
+            return None
+        except Exception as e:
+            print(f"Groq TTS processing error: {e}")
+            return None
+
+
+# Backward-compatible alias so existing references keep working
+ElevenLabsTTS = GroqTTS
+
+
+class ConversationFlow:
+    """Manages the conversation flow for returns and exchanges"""
+    
+    def __init__(self):
+        self.tts = ElevenLabsTTS()
+        self.state = {}
+    
+    def process_user_input(self, session_id, user_text, current_step):
+        """Process user input and generate appropriate response"""
+        
+        # Initialize session state
+        if session_id not in self.state:
+            self.state[session_id] = {
+                'step': 'greeting',
+                'data': {}
+            }
+        
+        session = self.state[session_id]
+        
+        # Process based on current step
+        if current_step == 'greeting':
+            # Only short-circuit when the user clearly says exchange/return.
+            # Without a keyword match we ask explicitly — this prevents
+            # inputs like "I would be 23" from being misclassified.
+            user_lower = user_text.strip().lower()
+            intent_keywords = [
+                'return', 'refund', 'money back', 'send back',
+                'exchange', 'swap', 'replace', 'replacement', 'different product',
+            ]
+            has_intent = any(kw in user_lower for kw in intent_keywords)
+
+            if has_intent:
+                question_asked = CONVERSATION_TEMPLATES['ask_exchange_or_return']
+                request_type = self._extract_request_type(user_text, question_asked)
+                print(f"[flow] greeting -> keyword found -> classified: {request_type}")
+                session['data']['request_type'] = request_type
+                response_text = CONVERSATION_TEMPLATES['ask_order_id']
+                next_step = 'ask_order_id'
+            else:
+                print(f"[flow] greeting -> no intent keyword in '{user_text}', asking explicitly")
+                response_text = CONVERSATION_TEMPLATES['ask_exchange_or_return']
+                next_step = 'ask_exchange_or_return'
+        
+        elif current_step == 'ask_exchange_or_return':
+            question_asked = CONVERSATION_TEMPLATES['ask_exchange_or_return']
+            print(f"\n{'='*70}")
+            print(f"🎤 PROCESSING STEP: ask_exchange_or_return")
+            print(f"📝 User input: '{user_text}'")
+            print(f"❓ Question asked: '{question_asked}'")
+            print(f"{'='*70}")
+            
+            request_type = self._extract_request_type(user_text, question_asked)
+            
+            print(f"\n{'='*70}")
+            print(f"🔍 EXTRACTION RESULT: '{request_type}'")
+            print(f"🔍 Result type: {type(request_type)}")
+            print(f"🔍 Result is truthy: {bool(request_type)}")
+            print(f"{'='*70}\n")
+            
+            # request_type should NEVER be None now, but just in case
+            if request_type and request_type in ['exchange', 'return']:
+                session['data']['request_type'] = request_type
+                print(f"✅ SUCCESS: Request type set to: {request_type}")
+                response_text = CONVERSATION_TEMPLATES['ask_order_id']
+                next_step = 'ask_order_id'
+            else:
+                print(f"❌ UNEXPECTED: Got invalid request_type: {request_type}")
+                print(f"⚠️ This should not happen - defaulting to exchange")
+                session['data']['request_type'] = 'exchange'
+                response_text = CONVERSATION_TEMPLATES['ask_order_id']
+                next_step = 'ask_order_id'
+        
+        elif current_step == 'ask_order_id':
+            question_asked = CONVERSATION_TEMPLATES['ask_order_id']
+            print(f"\n🎤 PROCESSING STEP: ask_order_id")
+            print(f"📝 User input: '{user_text}'")
+            
+            order_id = self._extract_order_id(user_text, question_asked)
+            
+            print(f"🔍 Extraction result: {order_id}")
+            
+            if order_id:
+                session['data']['order_id'] = order_id
+                print(f"✅ Order ID set to: {order_id}")
+                request_type = session['data']['request_type']
+                response_text = CONVERSATION_TEMPLATES['ask_reason'].format(request_type=request_type)
+                next_step = 'ask_reason'
+            else:
+                print(f"⚠️ Could not extract order ID from: '{user_text}'")
+                response_text = "I couldn't find an order number. Please say something like 'order 123' or 'my order number is 456'."
+                next_step = 'ask_order_id'
+        
+        elif current_step == 'ask_reason':
+            # Clean up and standardize the reason using Gemini
+            request_type = session['data']['request_type']
+            question_asked = CONVERSATION_TEMPLATES['ask_reason'].format(request_type=request_type)
+            cleaned_reason = gemini_ai.extract_reason(user_text, request_type, question_asked)
+            session['data']['reason'] = cleaned_reason
+            print(f"🤖 Gemini cleaned reason: '{user_text}' -> '{cleaned_reason}'")
+            
+            if request_type == 'exchange':
+                response_text = CONVERSATION_TEMPLATES['ask_exchange_preference']
+                next_step = 'ask_exchange_preference'
+            else:
+                response_text = self._generate_confirmation(session['data'])
+                next_step = 'confirm_details'
+        
+        elif current_step == 'ask_exchange_preference':
+            question_asked = CONVERSATION_TEMPLATES['ask_exchange_preference']
+            session['data']['exchange_preference'] = gemini_ai.extract_exchange_preference(user_text, question_asked)
+            print(f"🤖 Gemini cleaned preference: '{user_text}' -> '{session['data']['exchange_preference']}'")
+            response_text = self._generate_confirmation(session['data'])
+            next_step = 'confirm_details'
+        
+        elif current_step == 'confirm_details':
+            confirmation_question = self._generate_confirmation(session['data'])
+            if self._is_confirmation(user_text, confirmation_question):
+                result = self._process_request(session['data'])
+                response_text = result['message']
+                next_step = 'completed'
+                
+                # Save to database
+                if DATABASE_INTEGRATION:
+                    self._save_to_database(session['data'], result)
+            else:
+                # BUG FIX 2: User said no - ask what was wrong
+                response_text = CONVERSATION_TEMPLATES['ask_what_wrong']
+                next_step = 'identify_correction'
+        
+        elif current_step == 'identify_correction':
+            # User specified what they want to correct
+            field_to_correct = gemini_ai.identify_correction_field(user_text, session['data'])
+            print(f"🔧 User wants to correct: {field_to_correct}")
+            
+            # Redirect to the appropriate question to get NEW answer
+            if field_to_correct == 'request_type':
+                response_text = CONVERSATION_TEMPLATES['ask_exchange_or_return']
+                next_step = 'ask_exchange_or_return'
+            elif field_to_correct == 'order_id':
+                response_text = CONVERSATION_TEMPLATES['ask_order_id']
+                next_step = 'ask_order_id'
+            elif field_to_correct == 'reason':
+                request_type = session['data']['request_type']
+                response_text = CONVERSATION_TEMPLATES['ask_reason'].format(request_type=request_type)
+                next_step = 'ask_reason'
+            elif field_to_correct == 'exchange_preference':
+                response_text = CONVERSATION_TEMPLATES['ask_exchange_preference']
+                next_step = 'ask_exchange_preference'
+            else:  # everything or unrecognized
+                # Start over
+                session['data'] = {}
+                response_text = CONVERSATION_TEMPLATES['ask_exchange_or_return']
+                next_step = 'ask_exchange_or_return'
+        
+        else:
+            response_text = CONVERSATION_TEMPLATES['greeting']
+            next_step = 'greeting'
+        
+        # Update session
+        session['step'] = next_step
+        
+        return {
+            'text': response_text,
+            'next_step': next_step,
+            'session_data': session['data'],
+            'valid_answers': self._get_valid_answers(next_step),
+        }
+    
+    def _extract_request_type(self, text, question_asked):
+        """Extract whether user wants exchange or return using Gemini AI with question context"""
+        result = gemini_ai.extract_request_type(text, question_asked)
+        if result:
+            print(f"🤖 Gemini understood '{text}' as: {result}")
+        return result
+    
+    def _extract_order_id(self, text, question_asked):
+        """Extract order ID from user input using Gemini AI with question context"""
+        result = gemini_ai.extract_order_id(text, question_asked)
+        if result:
+            print(f"🤖 Gemini extracted order ID from '{text}': {result}")
+        return result
+    
+    def _is_confirmation(self, text, question_asked):
+        """Check if user is confirming using Gemini AI with question context"""
+        result = gemini_ai.is_confirmation(text, question_asked)
+        print(f"🤖 Gemini understood '{text}' as confirmation: {result}")
+        return result
+
+    def _get_valid_answers(self, step):
+        """Return the set of valid / example answers for a given step.
+        For ask_order_id we pull real order IDs from the database."""
+        if step == 'greeting' or step == 'ask_exchange_or_return':
+            return ['exchange', 'return', 'I want to exchange', 'I want to return']
+        elif step == 'ask_order_id':
+            try:
+                Order = apps.get_model('store', 'Order')
+                order_ids = list(
+                    Order.objects.order_by('-id').values_list('id', flat=True)[:20]
+                )
+                return [str(oid) for oid in order_ids] if order_ids else ['No orders found']
+            except Exception as e:
+                print(f'[valid_answers] DB error: {e}')
+                return ['order 123', '12345']
+        elif step == 'ask_reason':
+            return ['wrong size', 'defective product', "I don't like it", 'color mismatch', 'poor quality']
+        elif step == 'ask_exchange_preference':
+            return ['size large', 'different color - blue', 'size medium', 'black color']
+        elif step == 'confirm_details':
+            return ['yes', "yes that's correct", 'no', 'change the order number', 'wrong reason']
+        return []
+    def _generate_confirmation(self, data):
+        """Generate confirmation message"""
+        request_type = data['request_type']
+        order_id = data['order_id']
+        reason = data['reason']
+        
+        extra_info = ""
+        if request_type == 'exchange':
+            extra_info = f"You want {data.get('exchange_preference', 'a different product')} instead. "
+        
+        return CONVERSATION_TEMPLATES['confirm_details'].format(
+            request_type=request_type,
+            order_id=order_id,
+            reason=reason,
+            extra_info=extra_info
+        )
+    
+    def _process_request(self, data):
+        """Process the return/exchange request"""
+        request_type = data['request_type']
+        
+        if request_type == 'exchange':
+            return self._process_exchange(data)
+        else:
+            return self._process_return(data)
+    
+    def _process_exchange(self, data):
+        """Process exchange request"""
+        tracking_number = f"EXG-{data['order_id']}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        pickup_date = (datetime.now() + timedelta(days=2)).strftime('%B %d, %Y')
+        delivery_date = (datetime.now() + timedelta(days=EXCHANGE_DELIVERY_DAYS)).strftime('%B %d, %Y')
+        
+        message = CONVERSATION_TEMPLATES['processing'].format(request_type='exchange')
+        message += " " + CONVERSATION_TEMPLATES['exchange_pickup_scheduled'].format(pickup_date=pickup_date)
+        message += " " + CONVERSATION_TEMPLATES['exchange_delivery_scheduled'].format(delivery_date=delivery_date)
+        message += " " + CONVERSATION_TEMPLATES['success'].format(
+            request_type='exchange',
+            tracking_number=tracking_number
+        )
+        
+        return {
+            'message': message,
+            'tracking_number': tracking_number,
+            'pickup_date': pickup_date,
+            'delivery_date': delivery_date
+        }
+    
+    def _process_return(self, data):
+        """Process return request"""
+        tracking_number = f"RET-{data['order_id']}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        pickup_date = (datetime.now() + timedelta(days=2)).strftime('%B %d, %Y')
+        
+        message = CONVERSATION_TEMPLATES['processing'].format(request_type='return')
+        message += " " + CONVERSATION_TEMPLATES['return_scheduled'].format(pickup_date=pickup_date)
+        message += " " + CONVERSATION_TEMPLATES['success'].format(
+            request_type='return',
+            tracking_number=tracking_number
+        )
+        
+        return {
+            'message': message,
+            'tracking_number': tracking_number,
+            'pickup_date': pickup_date
+        }
+    
+    def _save_to_database(self, data, result):
+        """Save exchange/return data to database"""
+        try:
+            # Import your models dynamically
+            Order = apps.get_model('shop', 'Order')
+            OrderDetail = apps.get_model('shop', 'OrderDetail')
+            
+            order_id = data.get('order_id')
+            
+            # Find the order
+            try:
+                order = Order.objects.get(id=order_id)
+                order_details = OrderDetail.objects.filter(order=order)
+                
+                # Update all order details
+                for detail in order_details:
+                    detail.return_reason = data.get('reason', '')
+                    detail.return_status = 'Returned'
+                    detail.return_date = datetime.now()
+                    detail.days_to_return = DEFAULT_RETURN_DAYS
+                    
+                    if data['request_type'] == 'exchange':
+                        detail.is_exchanged = True
+                        detail.exchange_order = data.get('exchange_preference', '')
+                    
+                    detail.save()
+                
+                print(f"✅ Database updated for Order {order_id}")
+                print(f"   Reason: {data.get('reason')}")
+                print(f"   Type: {data['request_type']}")
+                print(f"   Tracking: {result.get('tracking_number')}")
+                
+            except Order.DoesNotExist:
+                print(f"❌ Order {order_id} not found in database")
+                
+        except Exception as e:
+            print(f"❌ Database error: {e}")
+
+
+# Global conversation flow instance
+conversation_flow = ConversationFlow()
+
+
+# Django Views
+@csrf_exempt
+@require_http_methods(["POST"])
+def start_conversation(request):
+    """Start a new conversation session"""
+    import uuid
+    session_id = str(uuid.uuid4())
+    
+    # Generate greeting audio
+    tts = ElevenLabsTTS()
+    greeting_text = CONVERSATION_TEMPLATES['greeting']
+
+    # Create DB session record
+    try:
+        VoiceSession, _ = _get_voice_models()
+        VoiceSession.objects.create(session_id=session_id)
+    except Exception as e:
+        print(f'[voice] DB session create error: {e}')
+
+    return JsonResponse({
+        'session_id': session_id,
+        'message': greeting_text,
+        'next_step': 'greeting',
+        'gemini_enabled': gemini_ai.enabled,
+        'valid_answers': ['exchange', 'return', 'I want to exchange', 'I want to return'],
+    })
+
+
+@csrf_exempt
+@require_http_methods(["POST"])
+def process_voice(request):
+    """Process user voice input and return audio response"""
+    try:
+        data = json.loads(request.body)
+        session_id = data.get('session_id')
+        user_text = data.get('text')
+        current_step = data.get('current_step')
+        
+        # Process input
+        # Log what goes into the LLM (and the current state)
+        print(f"[voice] LLM_INPUT step={current_step} user='{user_text}'")
+
+        result = conversation_flow.process_user_input(session_id, user_text, current_step)
+        print(
+            f"[voice] session={session_id} step={current_step} -> next={result['next_step']} "
+            f"user='{user_text}' response='{result['text'][:200]}'"
+        )
+        # Log LLM outputs / parsed session data for debugging intent extraction
+        try:
+            print(f"[voice] LLM_OUTPUT data={json.dumps(result.get('session_data', {}))}")
+        except Exception:
+            print(f"[voice] LLM_OUTPUT data={result.get('session_data')}")
+
+        # ── Persist turn to database ──────────────────────────────────
+        try:
+            VoiceSession, VoiceMessage = _get_voice_models()
+            vs = VoiceSession.objects.filter(session_id=session_id).first()
+            if vs:
+                turn_num = vs.messages.count() + 1
+                VoiceMessage.objects.create(
+                    session=vs,
+                    turn_number=turn_num,
+                    step=current_step,
+                    next_step=result['next_step'],
+                    user_text=user_text,
+                    bot_text=result['text'],
+                    extracted_value=str(result.get('session_data', {}).get(
+                        {'greeting': 'request_type',
+                         'ask_exchange_or_return': 'request_type',
+                         'ask_order_id': 'order_id',
+                         'ask_reason': 'reason',
+                         'ask_exchange_preference': 'exchange_preference',
+                         'confirm_details': 'confirmed',
+                        }.get(current_step, ''), '')),
+                    session_data_snapshot=result.get('session_data', {}),
+                )
+                # Update session-level fields from collected data
+                sd = result.get('session_data', {})
+                vs.request_type = sd.get('request_type', vs.request_type)
+                vs.order_id = sd.get('order_id', vs.order_id)
+                vs.reason = sd.get('reason', vs.reason)
+                vs.exchange_preference = sd.get('exchange_preference', vs.exchange_preference)
+                vs.session_data_json = sd
+                if result['next_step'] == 'completed':
+                    vs.status = 'completed'
+                    vs.ended_at = timezone.now()
+                    vs.tracking_number = sd.get('tracking_number', '')
+                vs.save()
+        except Exception as e:
+            print(f'[voice] DB log error: {e}')
+        # ──────────────────────────────────────────────────────────────
+        # Return JSON – TTS is handled in the browser via speechSynthesis
+        return JsonResponse({
+            'text': result['text'],
+            'next_step': result['next_step'],
+            'session_data': result['session_data'],
+            'valid_answers': result.get('valid_answers', []),
+        })
+            
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)
+
+
+@csrf_exempt
+@require_http_methods(["POST"])
+def get_speech(request):
+    """Return the text as JSON – browser handles TTS via speechSynthesis"""
+    try:
+        data = json.loads(request.body)
+        text = data.get('text', '')
+        return JsonResponse({'text': text})
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)

voice_urls.py

@@ -0,0 +1,9 @@
+# URL Configuration for Voice Bot
+from django.urls import path
+from voice_service import start_conversation, process_voice, get_speech
+
+urlpatterns = [
+    path('start/', start_conversation, name='start_conversation'),
+    path('process/', process_voice, name='process_voice'),
+    path('speak/', get_speech, name='get_speech'),
+]