Update app.py

app.py

@@ -9,8 +9,8 @@ import faiss
 import numpy as np
 from twilio.rest import Client
 from groq import Groq
-import re # Import re module
- 
+import re
+
 # --- Page Configuration ---
 st.set_page_config(page_title="RAG Customer Support Chatbot", layout="wide")
 
@@ -42,142 +42,142 @@ APP_TWILIO_BOT_WHATSAPP_IDENTITY_SECRET = st.secrets.get("TWILIO_BOT_WHATSAPP_ID
 
 # --- RAG Processing Utilities ---
 def load_json_data(file_path):
-    """Loads data from a JSON file."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-        return data
-    except FileNotFoundError:
-        st.error(f"Error: JSON file not found at {file_path}")
-        return None
-    except json.JSONDecodeError:
-        st.error(f"Error: Could not decode JSON from {file_path}")
-        return None
-    except Exception as e:
-        st.error(f"An unexpected error occurred while loading {file_path}: {e}")
-        return None
+    """Loads data from a JSON file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return data
+    except FileNotFoundError:
+        st.error(f"Error: JSON file not found at {file_path}")
+        return None
+    except json.JSONDecodeError:
+        st.error(f"Error: Could not decode JSON from {file_path}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred while loading {file_path}: {e}")
+        return None
 
 def load_pdf_data(file_path):
-    """Extracts text from a PDF file, page by page."""
-    try:
-        with open(file_path, 'rb') as f:
-            reader = PyPDF2.PdfReader(f)
-            text_pages = []
-            for page_num in range(len(reader.pages)):
-                page = reader.pages[page_num]
-                text_pages.append(page.extract_text() or "")
-        return text_pages
-    except FileNotFoundError:
-        st.error(f"Error: PDF file not found at {file_path}")
-        return []
-    except Exception as e:
-        st.error(f"An error occurred while processing PDF {file_path}: {e}")
-        return []
+    """Extracts text from a PDF file, page by page."""
+    try:
+        with open(file_path, 'rb') as f:
+            reader = PyPDF2.PdfReader(f)
+            text_pages = []
+            for page_num in range(len(reader.pages)):
+                page = reader.pages[page_num]
+                text_pages.append(page.extract_text() or "")
+        return text_pages
+    except FileNotFoundError:
+        st.error(f"Error: PDF file not found at {file_path}")
+        return []
+    except Exception as e:
+        st.error(f"An error occurred while processing PDF {file_path}: {e}")
+        return []
 
 def chunk_text(text_pages, chunk_size=1000, chunk_overlap=200):
-    """Chunks text from PDF pages into smaller, overlapping pieces."""
-    full_text = "\n".join(text_pages)
-    if not full_text.strip():
-        return []
-    chunks = []
-    start = 0
-    while start < len(full_text):
-        end = start + chunk_size
-        chunks.append(full_text[start:end])
-        if end >= len(full_text):
-            break
-        start += (chunk_size - chunk_overlap)
-        if start >= len(full_text):
-            break
-    return [chunk for chunk in chunks if chunk.strip()]
+    """Chunks text from PDF pages into smaller, overlapping pieces."""
+    full_text = "\n".join(text_pages)
+    if not full_text.strip():
+        return []
+    chunks = []
+    start = 0
+    while start < len(full_text):
+        end = start + chunk_size
+        chunks.append(full_text[start:end])
+        if end >= len(full_text):
+            break
+        start += (chunk_size - chunk_overlap)
+        if start >= len(full_text):
+            break
+    return [chunk for chunk in chunks if chunk.strip()]
 
 @st.cache_resource(show_spinner="Initializing embedding model...")
 def initialize_embedding_model(model_name=DEFAULT_EMBEDDING_MODEL_NAME):
-    """Initializes and returns a SentenceTransformer model."""
-    try:
-        model = SentenceTransformer(model_name)
-        return model
-    except Exception as e:
-        st.error(f"Error initializing embedding model '{model_name}': {e}")
-        return None
+    """Initializes and returns a SentenceTransformer model."""
+    try:
+        model = SentenceTransformer(model_name)
+        return model
+    except Exception as e:
+        st.error(f"Error initializing embedding model '{model_name}': {e}")
+        return None
 
 @st.cache_resource(show_spinner="Building FAISS index for PDF documents...")
 def create_faiss_index(_text_chunks, _embedding_model):
-    """Creates a FAISS index from text chunks and an embedding model."""
-    if not _text_chunks or _embedding_model is None:
-        st.warning("Cannot create FAISS index: No text chunks or embedding model available.")
-        return None, []
-    try:
-        valid_chunks = [str(chunk) for chunk in _text_chunks if chunk and isinstance(chunk, str) and chunk.strip()]
-        if not valid_chunks:
-            st.warning("No valid text chunks to embed for FAISS index.")
-            return None, []
-        embeddings = _embedding_model.encode(valid_chunks, convert_to_tensor=False)
-        if embeddings.ndim == 1:
-            embeddings = embeddings.reshape(1, -1)
-        if embeddings.shape[0] == 0:
-             st.warning("No embeddings were generated for FAISS index.")
-             return None, []
-        dimension = embeddings.shape[1]
-        index = faiss.IndexFlatL2(dimension)
-        index.add(np.array(embeddings, dtype=np.float32))
-        return index, valid_chunks
-    except Exception as e:
-        st.error(f"Error creating FAISS index: {e}")
-        return None, []
+    """Creates a FAISS index from text chunks and an embedding model."""
+    if not _text_chunks or _embedding_model is None:
+        st.warning("Cannot create FAISS index: No text chunks or embedding model available.")
+        return None, []
+    try:
+        valid_chunks = [str(chunk) for chunk in _text_chunks if chunk and isinstance(chunk, str) and chunk.strip()]
+        if not valid_chunks:
+            st.warning("No valid text chunks to embed for FAISS index.")
+            return None, []
+        embeddings = _embedding_model.encode(valid_chunks, convert_to_tensor=False)
+        if embeddings.ndim == 1:
+            embeddings = embeddings.reshape(1, -1)
+        if embeddings.shape[0] == 0:
+             st.warning("No embeddings were generated for FAISS index.")
+             return None, []
+        dimension = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dimension)
+        index.add(np.array(embeddings, dtype=np.float32))
+        return index, valid_chunks
+    except Exception as e:
+        st.error(f"Error creating FAISS index: {e}")
+        return None, []
 
 def search_faiss_index(index, query_text, embedding_model, indexed_chunks, k=3):
-    """Searches the FAISS index and returns top_k relevant chunk texts."""
-    if index is None or embedding_model is None or not query_text:
-        return []
-    try:
-        query_embedding = embedding_model.encode([query_text], convert_to_tensor=False)
-        if query_embedding.ndim == 1:
-            query_embedding = query_embedding.reshape(1, -1)
-        distances, indices = index.search(np.array(query_embedding, dtype=np.float32), k)
-        results = []
-        for i in range(len(indices[0])):
-            idx = indices[0][i]
-            if 0 <= idx < len(indexed_chunks):
-                results.append(indexed_chunks[idx])
-        return results
-    except Exception as e:
-        st.error(f"Error searching FAISS index: {e}")
-        return []
+    """Searches the FAISS index and returns top_k relevant chunk texts."""
+    if index is None or embedding_model is None or not query_text:
+        return []
+    try:
+        query_embedding = embedding_model.encode([query_text], convert_to_tensor=False)
+        if query_embedding.ndim == 1:
+            query_embedding = query_embedding.reshape(1, -1)
+        distances, indices = index.search(np.array(query_embedding, dtype=np.float32), k)
+        results = []
+        for i in range(len(indices[0])):
+            idx = indices[0][i]
+            if 0 <= idx < len(indexed_chunks):
+                results.append(indexed_chunks[idx])
+        return results
+    except Exception as e:
+        st.error(f"Error searching FAISS index: {e}")
+        return []
 
 def get_order_details(order_id, customer_orders_data):
-    """Retrieves order details for a given order_id."""
-    if not customer_orders_data:
-        return "Customer order data is not loaded."
-    for order in customer_orders_data:
-        if order.get("order_id") == order_id:
-            return json.dumps(order, indent=2)
-    return f"No order found with ID: {order_id}."
+    """Retrieves order details for a given order_id."""
+    if not customer_orders_data:
+        return "Customer order data is not loaded."
+    for order in customer_orders_data:
+        if order.get("order_id") == order_id:
+            return json.dumps(order, indent=2)
+    return f"No order found with ID: {order_id}."
 
 def get_product_info(query, products_data):
-    """Retrieves product information based on a query."""
-    if not products_data:
-        return "Product data is not loaded."
-    query_lower = query.lower()
-    found_products = []
-    for product in products_data:
-        if query_lower in (product.get("name", "").lower()) or \
-           query_lower in (product.get("description", "").lower()) or \
-           query_lower == (product.get("product_id", "").lower()):
-            found_products.append(product)
-    if found_products:
-        return json.dumps(found_products, indent=2)
-    return f"No product information found matching your query: '{query}'."
+    """Retrieves product information based on a query."""
+    if not products_data:
+        return "Product data is not loaded."
+    query_lower = query.lower()
+    found_products = []
+    for product in products_data:
+        if query_lower in (product.get("name", "").lower()) or \
+           query_lower in (product.get("description", "").lower()) or \
+           query_lower == (product.get("product_id", "").lower()):
+            found_products.append(product)
+    if found_products:
+        return json.dumps(found_products, indent=2)
+    return f"No product information found matching your query: '{query}'."
 
 # --- LLM Operations ---
 @st.cache_data(show_spinner="Generating response with LLaMA3...")
 def generate_response_groq(_groq_client, query, context, model="llama3-8b-8192"):
-    """Generates a response using GROQ LLaMA3 API."""
-    if not _groq_client:
-        return "GROQ client not initialized. Please check API key."
-    if not query:
-        return "Query is empty."
-    prompt = f"""You are a helpful customer support assistant.
+    """Generates a response using GROQ LLaMA3 API."""
+    if not _groq_client:
+        return "GROQ client not initialized. Please check API key."
+    if not query:
+        return "Query is empty."
+    prompt = f"""You are a helpful customer support assistant.
 Use the following context to answer the user's question.
 If the context doesn't contain the answer, state that you don't have enough information.
 Do not make up information. Be concise and polite.
@@ -189,107 +189,107 @@ User Question: {query}
 
 Assistant Answer:
 """
-    try:
-        chat_completion = _groq_client.chat.completions.create(
-            messages=[
-                {"role": "system", "content": "You are a helpful customer support assistant."},
-                {"role": "user", "content": prompt}
-            ],
-            model=model, temperature=0.7, max_tokens=1024, top_p=1
-        )
-        response = chat_completion.choices[0].message.content
-        return response
-    except Exception as e:
-        st.error(f"Error calling GROQ API: {e}")
-        return "Sorry, I encountered an error while trying to generate a response."
+    try:
+        chat_completion = _groq_client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a helpful customer support assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            model=model, temperature=0.7, max_tokens=1024, top_p=1
+        )
+        response = chat_completion.choices[0].message.content
+        return response
+    except Exception as e:
+        st.error(f"Error calling GROQ API: {e}")
+        return "Sorry, I encountered an error while trying to generate a response."
 
 def initialize_groq_client(api_key_val):
-    """Initializes the GROQ client."""
-    if not api_key_val: # Changed parameter name to avoid conflict
-        st.warning("GROQ API Key is missing.")
-        return None
-    try:
-        client = Groq(api_key=api_key_val)
-        return client
-    except Exception as e:
-        st.error(f"Failed to initialize GROQ client: {e}")
-        return None
+    """Initializes the GROQ client."""
+    if not api_key_val: # Changed parameter name to avoid conflict
+        st.warning("GROQ API Key is missing.")
+        return None
+    try:
+        client = Groq(api_key=api_key_val)
+        return client
+    except Exception as e:
+        st.error(f"Failed to initialize GROQ client: {e}")
+        return None
 
 # --- Twilio Operations ---
 def initialize_twilio_client(acc_sid, auth_tkn): # Changed parameter names
-    """Initializes the Twilio client."""
-    if not acc_sid or not auth_tkn:
-        st.warning("Twilio Account SID or Auth Token is missing.")
-        return None
-    try:
-        client = Client(acc_sid, auth_tkn)
-        return client
-    except Exception as e:
-        st.error(f"Failed to initialize Twilio client: {e}")
-        return None
+    """Initializes the Twilio client."""
+    if not acc_sid or not auth_tkn:
+        st.warning("Twilio Account SID or Auth Token is missing.")
+        return None
+    try:
+        client = Client(acc_sid, auth_tkn)
+        return client
+    except Exception as e:
+        st.error(f"Failed to initialize Twilio client: {e}")
+        return None
 
 def get_new_whatsapp_messages(twilio_client, conversation_service_sid_val, bot_start_time_utc, # Renamed
-                              processed_message_sids, bot_whatsapp_identity_val): # Renamed
-    """Fetches new, unanswered WhatsApp messages from Twilio Conversations."""
-    if not twilio_client:
-        st.warning("Twilio client not initialized.")
-        return []
-    if not conversation_service_sid_val:
-        st.warning("Twilio Conversation Service SID not provided.")
-        return []
-
-    new_messages_to_process = []
-    try:
-        conversations = twilio_client.conversations.v1 \
-            .services(conversation_service_sid_val) \
-            .conversations \
-            .list(limit=50)
-
-        for conv in conversations:
-            if conv.date_updated and conv.date_updated > bot_start_time_utc:
-                messages = twilio_client.conversations.v1 \
-                    .services(conversation_service_sid_val) \
-                    .conversations(conv.sid) \
-                    .messages \
-                    .list(order='desc', limit=10)
-
-                for msg in messages:
-                    if msg.sid in processed_message_sids:
-                        continue
-                    if msg.author and msg.author.lower() != bot_whatsapp_identity_val.lower() and \
-                       msg.date_created and msg.date_created > bot_start_time_utc:
-                        new_messages_to_process.append({
-                            "conversation_sid": conv.sid, "message_sid": msg.sid,
-                            "author_identity": msg.author, "message_body": msg.body,
-                            "timestamp_utc": msg.date_created 
-                        })
-                        break 
-    except Exception as e:
-        st.error(f"Error fetching Twilio messages: {e}")
-    return sorted(new_messages_to_process, key=lambda m: m['timestamp_utc'])
+                              processed_message_sids, bot_whatsapp_identity_val): # Renamed
+    """Fetches new, unanswered WhatsApp messages from Twilio Conversations."""
+    if not twilio_client:
+        st.warning("Twilio client not initialized.")
+        return []
+    if not conversation_service_sid_val:
+        st.warning("Twilio Conversation Service SID not provided.")
+        return []
+
+    new_messages_to_process = []
+    try:
+        conversations = twilio_client.conversations.v1 \
+            .services(conversation_service_sid_val) \
+            .conversations \
+            .list(limit=50)
+
+        for conv in conversations:
+            if conv.date_updated and conv.date_updated > bot_start_time_utc:
+                messages = twilio_client.conversations.v1 \
+                    .services(conversation_service_sid_val) \
+                    .conversations(conv.sid) \
+                    .messages \
+                    .list(order='desc', limit=10)
+
+                for msg in messages:
+                    if msg.sid in processed_message_sids:
+                        continue
+                    if msg.author and msg.author.lower() != bot_whatsapp_identity_val.lower() and \
+                       msg.date_created and msg.date_created > bot_start_time_utc:
+                        new_messages_to_process.append({
+                            "conversation_sid": conv.sid, "message_sid": msg.sid,
+                            "author_identity": msg.author, "message_body": msg.body,
+                            "timestamp_utc": msg.date_created
+                        })
+                        break
+    except Exception as e:
+        st.error(f"Error fetching Twilio messages: {e}")
+    return sorted(new_messages_to_process, key=lambda m: m['timestamp_utc'])
 
 def send_whatsapp_message(twilio_client, conversation_service_sid_val, conversation_sid, message_body, bot_identity_val): # Renamed
-    """Sends a message to a Twilio Conversation from the bot's identity."""
-    if not twilio_client:
-        st.error("Twilio client not initialized for sending message.")
-        return False
-    if not conversation_service_sid_val:
-        st.error("Twilio Conversation Service SID not provided for sending message.")
-        return False
-    if not bot_identity_val:
-        st.error("Bot identity not provided for sending message.")
-        return False
-    try:
-        twilio_client.conversations.v1 \
-            .services(conversation_service_sid_val) \
-            .conversations(conversation_sid) \
-            .messages \
-            .create(author=bot_identity_val, body=message_body)
-        st.success(f"Sent reply to conversation {conversation_sid}")
-        return True
-    except Exception as e:
-        st.error(f"Error sending Twilio message to {conversation_sid}: {e}")
-        return False
+    """Sends a message to a Twilio Conversation from the bot's identity."""
+    if not twilio_client:
+        st.error("Twilio client not initialized for sending message.")
+        return False
+    if not conversation_service_sid_val:
+        st.error("Twilio Conversation Service SID not provided for sending message.")
+        return False
+    if not bot_identity_val:
+        st.error("Bot identity not provided for sending message.")
+        return False
+    try:
+        twilio_client.conversations.v1 \
+            .services(conversation_service_sid_val) \
+            .conversations(conversation_sid) \
+            .messages \
+            .create(author=bot_identity_val, body=message_body)
+        st.success(f"Sent reply to conversation {conversation_sid}")
+        return True
+    except Exception as e:
+        st.error(f"Error sending Twilio message to {conversation_sid}: {e}")
+        return False
 
 # --- Main Application Logic & UI ---
 st.title("🤖 RAG-Based Customer Support Chatbot")
@@ -300,47 +300,47 @@ st.sidebar.title("⚙️ Configurations")
 
 # Use APP_ prefixed variables for values from secrets, then allow manual input if not found
 if APP_TWILIO_ACCOUNT_SID:
-    st.sidebar.text_input("Twilio Account SID (from Secrets)", value="********" + APP_TWILIO_ACCOUNT_SID[-4:] if len(APP_TWILIO_ACCOUNT_SID) > 4 else "********", disabled=True)
-    twilio_account_sid_to_use = APP_TWILIO_ACCOUNT_SID
+    st.sidebar.text_input("Twilio Account SID (from Secrets)", value="********" + APP_TWILIO_ACCOUNT_SID[-4:] if len(APP_TWILIO_ACCOUNT_SID) > 4 else "********", disabled=True)
+    twilio_account_sid_to_use = APP_TWILIO_ACCOUNT_SID
 else:
-    st.sidebar.warning("Secret 'TWILIO_SID' not found.")
-    twilio_account_sid_to_use = st.sidebar.text_input("Twilio Account SID (Enter Manually)", value=DEFAULT_TWILIO_ACCOUNT_SID_FALLBACK, type="password")
+    st.sidebar.warning("Secret 'TWILIO_SID' not found.")
+    twilio_account_sid_to_use = st.sidebar.text_input("Twilio Account SID (Enter Manually)", value=DEFAULT_TWILIO_ACCOUNT_SID_FALLBACK, type="password")
 
 if APP_TWILIO_AUTH_TOKEN:
-    st.sidebar.text_input("Twilio Auth Token (from Secrets)", value="********", disabled=True)
-    twilio_auth_token_to_use = APP_TWILIO_AUTH_TOKEN
+    st.sidebar.text_input("Twilio Auth Token (from Secrets)", value="********", disabled=True)
+    twilio_auth_token_to_use = APP_TWILIO_AUTH_TOKEN
 else:
-    st.sidebar.warning("Secret 'TWILIO_TOKEN' not found.")
-    twilio_auth_token_to_use = st.sidebar.text_input("Twilio Auth Token (Enter Manually)", value=DEFAULT_TWILIO_AUTH_TOKEN_FALLBACK, type="password")
+    st.sidebar.warning("Secret 'TWILIO_TOKEN' not found.")
+    twilio_auth_token_to_use = st.sidebar.text_input("Twilio Auth Token (Enter Manually)", value=DEFAULT_TWILIO_AUTH_TOKEN_FALLBACK, type="password")
 
 if APP_GROQ_API_KEY:
-    st.sidebar.text_input("GROQ API Key (from Secrets)", value="gsk_********" + APP_GROQ_API_KEY[-4:] if len(APP_GROQ_API_KEY) > 8 else "********", disabled=True)
-    groq_api_key_to_use = APP_GROQ_API_KEY
+    st.sidebar.text_input("GROQ API Key (from Secrets)", value="gsk_********" + APP_GROQ_API_KEY[-4:] if len(APP_GROQ_API_KEY) > 8 else "********", disabled=True)
+    groq_api_key_to_use = APP_GROQ_API_KEY
 else:
-    st.sidebar.warning("Secret 'GROQ_API_KEY' not found.")
-    groq_api_key_to_use = st.sidebar.text_input("GROQ API Key (Enter Manually)", value=DEFAULT_GROQ_API_KEY_FALLBACK, type="password")
+    st.sidebar.warning("Secret 'GROQ_API_KEY' not found.")
+    groq_api_key_to_use = st.sidebar.text_input("GROQ API Key (Enter Manually)", value=DEFAULT_GROQ_API_KEY_FALLBACK, type="password")
 
 # For other configurations that can be overridden if secrets not found or for user preference
 twilio_conversation_service_sid_to_use = st.sidebar.text_input(
-    "Twilio Conversation Service SID (IS...)", 
-    value=APP_TWILIO_CONVERSATION_SERVICE_SID_SECRET or DEFAULT_TWILIO_CONVERSATION_SERVICE_SID, 
-    type="password", 
-    help="The SID of your Twilio Conversations Service. Can be set by 'TWILIO_CONVERSATION_SERVICE_SID' secret."
+    "Twilio Conversation Service SID (IS...)",
+    value=APP_TWILIO_CONVERSATION_SERVICE_SID_SECRET or DEFAULT_TWILIO_CONVERSATION_SERVICE_SID,
+    type="password",
+    help="The SID of your Twilio Conversations Service. Can be set by 'TWILIO_CONVERSATION_SERVICE_SID' secret."
 )
 twilio_bot_whatsapp_identity_to_use = st.sidebar.text_input(
-    "Twilio Bot WhatsApp Identity", 
-    value=APP_TWILIO_BOT_WHATSAPP_IDENTITY_SECRET or DEFAULT_TWILIO_BOT_WHATSAPP_IDENTITY,
-    help="e.g., 'whatsapp:+1234567890'. Can be set by 'TWILIO_BOT_WHATSAPP_IDENTITY' secret."
+    "Twilio Bot WhatsApp Identity",
+    value=APP_TWILIO_BOT_WHATSAPP_IDENTITY_SECRET or DEFAULT_TWILIO_BOT_WHATSAPP_IDENTITY,
+    help="e.g., 'whatsapp:+1234567890'. Can be set by 'TWILIO_BOT_WHATSAPP_IDENTITY' secret."
 )
 embedding_model_name_to_use = st.sidebar.text_input( # Renamed
-    "Embedding Model Name", 
-    value=DEFAULT_EMBEDDING_MODEL_NAME
+    "Embedding Model Name",
+    value=DEFAULT_EMBEDDING_MODEL_NAME
 )
 polling_interval_to_use = st.sidebar.number_input( # Renamed
-    "Twilio Polling Interval (seconds)", 
-    min_value=10, max_value=300, 
-    value=DEFAULT_POLLING_INTERVAL_S, 
-    step=5
+    "Twilio Polling Interval (seconds)",
+    min_value=10, max_value=300,
+    value=DEFAULT_POLLING_INTERVAL_S,
+    step=5
 )
 
 # --- Initialize Session State ---
@@ -354,197 +354,197 @@ if "manual_chat_history" not in st.session_state: st.session_state.manual_chat_h
 
 # --- Helper: Simple Intent Classifier ---
 def simple_intent_classifier(query):
-    query_lower = query.lower()
-    if any(k in query_lower for k in ["order", "status", "track", "delivery"]):
-        # More specific regex to find 'ORD' followed by digits (assuming order IDs are like ORD1001)
-        match = re.search(r'\b(ord\d{3,})\b', query_lower) # Matches 'ord' followed by at least 3 digits, as a whole word
-        if match:
-            return "ORDER_STATUS", match.group(1).upper() # Return intent and extracted ID
-        # Fallback if specific order ID not found but still an order-related query
-        return "ORDER_STATUS", None # Indicate order status intent but no specific ID found yet
-
-    if any(k in query_lower for k in ["product", "item", "buy", "price", "feature", "stock"]): return "PRODUCT_INFO", None
-    if any(k in query_lower for k in ["return", "policy", "refund", "exchange", "faq", "question", "how to", "support"]): return "GENERAL_POLICY_FAQ", None
-    return "UNKNOWN", None # Return intent and None for ID if unknown
+    query_lower = query.lower()
+    if any(k in query_lower for k in ["order", "status", "track", "delivery"]):
+        # More specific regex to find 'ORD' followed by digits (assuming order IDs are like ORD1001)
+        match = re.search(r'\b(ord\d{3,})\b', query_lower) # Matches 'ord' followed by at least 3 digits, as a whole word
+        if match:
+            return "ORDER_STATUS", match.group(1).upper() # Return intent and extracted ID
+        # Fallback if specific order ID not found but still an order-related query
+        return "ORDER_STATUS", None # Indicate order status intent but no specific ID found yet
+
+    if any(k in query_lower for k in ["product", "item", "buy", "price", "feature", "stock"]): return "PRODUCT_INFO", None
+    if any(k in query_lower for k in ["return", "policy", "refund", "exchange", "faq", "question", "how to", "support"]): return "GENERAL_POLICY_FAQ", None
+    return "UNKNOWN", None # Return intent and None for ID if unknown
 
 # --- Main Application Controls ---
 col1, col2, col3, col4 = st.columns(4)
 with col1:
-    if st.button("🚀 Start App", disabled=st.session_state.app_started, use_container_width=True):
-        if not groq_api_key_to_use: # Use the correct variable
-            st.error("GROQ API Key is required.")
-        else:
-            with st.spinner("Initializing RAG pipeline..."):
-                st.session_state.embedding_model = initialize_embedding_model(embedding_model_name_to_use) # Use correct var
-                st.session_state.customer_orders_data = load_json_data(CUSTOMER_ORDERS_FILE)
-                st.session_state.products_data = load_json_data(PRODUCTS_FILE)
-                policy_pdf_pages = load_pdf_data(POLICY_PDF_FILE)
-                faq_pdf_pages = load_pdf_data(FAQ_PDF_FILE)
-                all_pdf_text_pages = policy_pdf_pages + faq_pdf_pages
-                st.session_state.pdf_text_chunks_raw = chunk_text(all_pdf_text_pages)
-
-                if st.session_state.embedding_model and st.session_state.pdf_text_chunks_raw:
-                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = \
-                        create_faiss_index(st.session_state.pdf_text_chunks_raw, st.session_state.embedding_model)
-                else:
-                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = None, []
-                    st.warning("FAISS index for PDFs could not be created.")
-                
-                st.session_state.groq_client = initialize_groq_client(groq_api_key_to_use) # Use correct var
-
-                if st.session_state.embedding_model and st.session_state.groq_client and \
-                   st.session_state.customer_orders_data and st.session_state.products_data:
-                    st.session_state.rag_pipeline_ready = True
-                    st.session_state.app_started = True
-                    st.success("RAG Application Started!")
-                    st.rerun()
-                else:
-                    st.error("Failed to initialize RAG pipeline. Check configurations and ensure all data files are present in 'docs/'.")
-                    st.session_state.app_started = False
+    if st.button("🚀 Start App", disabled=st.session_state.app_started, use_container_width=True):
+        if not groq_api_key_to_use: # Use the correct variable
+            st.error("GROQ API Key is required.")
+        else:
+            with st.spinner("Initializing RAG pipeline..."):
+                st.session_state.embedding_model = initialize_embedding_model(embedding_model_name_to_use) # Use correct var
+                st.session_state.customer_orders_data = load_json_data(CUSTOMER_ORDERS_FILE)
+                st.session_state.products_data = load_json_data(PRODUCTS_FILE)
+                policy_pdf_pages = load_pdf_data(POLICY_PDF_FILE)
+                faq_pdf_pages = load_pdf_data(FAQ_PDF_FILE)
+                all_pdf_text_pages = policy_pdf_pages + faq_pdf_pages
+                st.session_state.pdf_text_chunks_raw = chunk_text(all_pdf_text_pages)
+
+                if st.session_state.embedding_model and st.session_state.pdf_text_chunks_raw:
+                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = \
+                        create_faiss_index(st.session_state.pdf_text_chunks_raw, st.session_state.embedding_model)
+                else:
+                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = None, []
+                    st.warning("FAISS index for PDFs could not be created.")
+                
+                st.session_state.groq_client = initialize_groq_client(groq_api_key_to_use) # Use correct var
+
+                if st.session_state.embedding_model and st.session_state.groq_client and \
+                   st.session_state.customer_orders_data and st.session_state.products_data:
+                    st.session_state.rag_pipeline_ready = True
+                    st.session_state.app_started = True
+                    st.success("RAG Application Started!")
+                    st.rerun()
+                else:
+                    st.error("Failed to initialize RAG pipeline. Check configurations and ensure all data files are present in 'docs/'.")
+                    st.session_state.app_started = False
 with col2:
-    if st.button("🛑 Stop App", disabled=not st.session_state.app_started, use_container_width=True):
-        keys_to_reset = ["app_started", "bot_started", "rag_pipeline_ready", "embedding_model", 
-                         "customer_orders_data", "products_data", "pdf_text_chunks_raw", 
-                         "faiss_index_pdfs", "indexed_pdf_chunks", "groq_client", "twilio_client", 
-                         "bot_start_time_utc", "processed_message_sids", "manual_chat_history"]
-        for key in keys_to_reset:
-            if key in st.session_state: del st.session_state[key]
-        st.session_state.app_started = False
-        st.session_state.bot_started = False
-        st.session_state.rag_pipeline_ready = False
-        st.session_state.processed_message_sids = set()
-        st.session_state.manual_chat_history = []
-        st.success("Application Stopped.")
-        st.rerun()
+    if st.button("🛑 Stop App", disabled=not st.session_state.app_started, use_container_width=True):
+        keys_to_reset = ["app_started", "bot_started", "rag_pipeline_ready", "embedding_model",
+                         "customer_orders_data", "products_data", "pdf_text_chunks_raw",
+                         "faiss_index_pdfs", "indexed_pdf_chunks", "groq_client", "twilio_client",
+                         "bot_start_time_utc", "processed_message_sids", "manual_chat_history"]
+        for key in keys_to_reset:
+            if key in st.session_state: del st.session_state[key]
+        st.session_state.app_started = False
+        st.session_state.bot_started = False
+        st.session_state.rag_pipeline_ready = False
+        st.session_state.processed_message_sids = set()
+        st.session_state.manual_chat_history = []
+        st.success("Application Stopped.")
+        st.rerun()
 with col3:
-    if st.button("💬 Start WhatsApp Bot", disabled=not st.session_state.app_started or st.session_state.bot_started, use_container_width=True):
-        if not all([twilio_account_sid_to_use, twilio_auth_token_to_use, twilio_conversation_service_sid_to_use, twilio_bot_whatsapp_identity_to_use]): # Use correct vars
-            st.error("Twilio credentials, Service SID, and Bot Identity are required.")
-        else:
-            st.session_state.twilio_client = initialize_twilio_client(twilio_account_sid_to_use, twilio_auth_token_to_use) # Use correct vars
-            if st.session_state.twilio_client:
-                st.session_state.bot_started = True
-                st.session_state.bot_start_time_utc = datetime.now(timezone.utc)
-                st.session_state.processed_message_sids = set()
-                st.session_state.last_twilio_poll_time = time.time() - polling_interval_to_use -1 # Use correct var
-                st.success("WhatsApp Bot Started!")
-                st.rerun()
-            else:
-                st.error("Failed to initialize Twilio client.")
+    if st.button("💬 Start WhatsApp Bot", disabled=not st.session_state.app_started or st.session_state.bot_started, use_container_width=True):
+        if not all([twilio_account_sid_to_use, twilio_auth_token_to_use, twilio_conversation_service_sid_to_use, twilio_bot_whatsapp_identity_to_use]): # Use correct vars
+            st.error("Twilio credentials, Service SID, and Bot Identity are required.")
+        else:
+            st.session_state.twilio_client = initialize_twilio_client(twilio_account_sid_to_use, twilio_auth_token_to_use) # Use correct vars
+            if st.session_state.twilio_client:
+                st.session_state.bot_started = True
+                st.session_state.bot_start_time_utc = datetime.now(timezone.utc)
+                st.session_state.processed_message_sids = set()
+                st.session_state.last_twilio_poll_time = time.time() - polling_interval_to_use -1 # Use correct var
+                st.success("WhatsApp Bot Started!")
+                st.rerun()
+            else:
+                st.error("Failed to initialize Twilio client.")
 with col4:
-    if st.button("🔕 Stop WhatsApp Bot", disabled=not st.session_state.bot_started, use_container_width=True):
-        st.session_state.bot_started = False
-        st.info("WhatsApp Bot Stopped.")
-        st.rerun()
+    if st.button("🔕 Stop WhatsApp Bot", disabled=not st.session_state.bot_started, use_container_width=True):
+        st.session_state.bot_started = False
+        st.info("WhatsApp Bot Stopped.")
+        st.rerun()
 st.divider()
 
 # --- Manual Query Interface ---
 if st.session_state.get("app_started") and st.session_state.get("rag_pipeline_ready"):
-    st.subheader("💬 Manual Query")
-    for chat_entry in st.session_state.manual_chat_history:
-        with st.chat_message(chat_entry["role"]):
-            st.markdown(chat_entry["content"])
-            if "context" in chat_entry and chat_entry["context"]:
-                with st.expander("Retrieved Context"):
-                    try:
-                        # Attempt to parse as JSON only if it looks like a JSON string
-                        if isinstance(chat_entry["context"], str) and (chat_entry["context"].strip().startswith('{') or chat_entry["context"].strip().startswith('[')):
-                            st.json(json.loads(chat_entry["context"]))
-                        else:
-                            # Otherwise, display as plain text
-                            st.text(str(chat_entry["context"]))
-                    except (json.JSONDecodeError, TypeError):
-                        # Fallback for any other parsing errors
-                        st.text(str(chat_entry["context"]))
-
-    user_query_manual = st.chat_input("Ask a question:")
-    if user_query_manual:
-        st.session_state.manual_chat_history.append({"role": "user", "content": user_query_manual})
-        with st.chat_message("user"): st.markdown(user_query_manual)
-
-        with st.spinner("Thinking..."):
-            intent_result = simple_intent_classifier(user_query_manual) # Get both intent and potential_id
-            intent = intent_result[0]
-            potential_oid_from_intent = intent_result[1] # This is the extracted ID if any
-
-            context_for_llm, raw_context_data = "No specific context.", None
-
-            if intent == "ORDER_STATUS":
-                order_id_to_check = None
-                if potential_oid_from_intent:
-                    order_id_to_check = potential_oid_from_intent
-                else:
-                    # Fallback for edge cases, though the regex should catch most
-                    words = user_query_manual.upper().split()
-                    # This regex specifically looks for 'ORD' followed by digits
-                    possible_match = next((w for w in words if re.match(r'ORD\d+', w)), None)
-                    if possible_match:
-                        order_id_to_check = possible_match
-
-
-                if order_id_to_check:
-                    raw_context_data = get_order_details(order_id_to_check.upper(), st.session_state.customer_orders_data)
-                    context_for_llm = f"Order Details: {raw_context_data}"
-                else:
-                    context_for_llm = "Please provide a valid Order ID (e.g., ORD1234)."
-                    raw_context_data = {"message": "Order ID needed."}
-            elif intent == "PRODUCT_INFO":
-                raw_context_data = get_product_info(user_query_manual, st.session_state.products_data)
-                context_for_llm = f"Product Information: {raw_context_data}"
-            elif intent == "GENERAL_POLICY_FAQ" or intent == "UNKNOWN":
-                # ... (rest of your existing logic for these intents) ...
-                if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
-                    k_val = 2 if intent == "GENERAL_POLICY_FAQ" else 1
-                    retrieved_chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_manual,
-                                                          st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
-                    if retrieved_chunks:
-                        context_for_llm = "\n\n".join(retrieved_chunks)
-                        raw_context_data = retrieved_chunks
-                    else:
-                        context_for_llm = "No specific policy/FAQ info found." if intent == "GENERAL_POLICY_FAQ" else "Could not find relevant info."
-                        raw_context_data = {"message": "No relevant PDF chunks found."}
-                else:
-                    context_for_llm = "Policy/FAQ documents unavailable."
-                    raw_context_data = {"message": "PDF index not ready."}
-
-            llm_response = generate_response_groq(st.session_state.groq_client, user_query_manual, context_for_llm)
-            with st.chat_message("assistant"):
-                st.markdown(llm_response)
-                if raw_context_data:
-                    with st.expander("Retrieved Context"):
-                        try:
-                            if isinstance(raw_context_data, str) and (raw_context_data.strip().startswith('{') or raw_context_data.strip().startswith('[')):
-                                st.json(json.loads(raw_context_data))
-                            else:
-                                st.text(str(raw_context_data))
-                        except (json.JSONDecodeError, TypeError):
-                            st.text(str(raw_context_data))
-            st.session_state.manual_chat_history.append({"role": "assistant", "content": llm_response, "context": raw_context_data})
+    st.subheader("💬 Manual Query")
+    for chat_entry in st.session_state.manual_chat_history:
+        with st.chat_message(chat_entry["role"]):
+            st.markdown(chat_entry["content"])
+            if "context" in chat_entry and chat_entry["context"]:
+                with st.expander("Retrieved Context"):
+                    try:
+                        # Attempt to parse as JSON only if it looks like a JSON string
+                        if isinstance(chat_entry["context"], str) and (chat_entry["context"].strip().startswith('{') or chat_entry["context"].strip().startswith('[')):
+                            st.json(json.loads(chat_entry["context"]))
+                        else:
+                            # Otherwise, display as plain text
+                            st.text(str(chat_entry["context"]))
+                    except (json.JSONDecodeError, TypeError):
+                        # Fallback for any other parsing errors
+                        st.text(str(chat_entry["context"]))
+
+    user_query_manual = st.chat_input("Ask a question:")
+    if user_query_manual:
+        st.session_state.manual_chat_history.append({"role": "user", "content": user_query_manual})
+        with st.chat_message("user"): st.markdown(user_query_manual)
+
+        with st.spinner("Thinking..."):
+            intent_result = simple_intent_classifier(user_query_manual) # Get both intent and potential_id
+            intent = intent_result[0]
+            potential_oid_from_intent = intent_result[1] # This is the extracted ID if any
+
+            context_for_llm, raw_context_data = "No specific context.", None
+
+            if intent == "ORDER_STATUS":
+                order_id_to_check = None
+                if potential_oid_from_intent:
+                    order_id_to_check = potential_oid_from_intent
+                else:
+                    # Fallback for edge cases, though the regex should catch most
+                    words = user_query_manual.upper().split()
+                    # This regex specifically looks for 'ORD' followed by digits
+                    possible_match = next((w for w in words if re.match(r'ORD\d+', w)), None)
+                    if possible_match:
+                        order_id_to_check = possible_match
+
+
+                if order_id_to_check:
+                    raw_context_data = get_order_details(order_id_to_check.upper(), st.session_state.customer_orders_data)
+                    context_for_llm = f"Order Details: {raw_context_data}"
+                else:
+                    context_for_llm = "Please provide a valid Order ID (e.g., ORD1234)."
+                    raw_context_data = {"message": "Order ID needed."}
+            elif intent == "PRODUCT_INFO":
+                raw_context_data = get_product_info(user_query_manual, st.session_state.products_data)
+                context_for_llm = f"Product Information: {raw_context_data}"
+            elif intent == "GENERAL_POLICY_FAQ" or intent == "UNKNOWN":
+                # ... (rest of your existing logic for these intents) ...
+                if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
+                    k_val = 2 if intent == "GENERAL_POLICY_FAQ" else 1
+                    retrieved_chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_manual,
+                                                          st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
+                    if retrieved_chunks:
+                        context_for_llm = "\n\n".join(retrieved_chunks)
+                        raw_context_data = retrieved_chunks
+                    else:
+                        context_for_llm = "No specific policy/FAQ info found." if intent == "GENERAL_POLICY_FAQ" else "Could not find relevant info."
+                        raw_context_data = {"message": "No relevant PDF chunks found."}
+                else:
+                    context_for_llm = "Policy/FAQ documents unavailable."
+                    raw_context_data = {"message": "PDF index not ready."}
+
+            llm_response = generate_response_groq(st.session_state.groq_client, user_query_manual, context_for_llm)
+            with st.chat_message("assistant"):
+                st.markdown(llm_response)
+                if raw_context_data:
+                    with st.expander("Retrieved Context"):
+                        try:
+                            if isinstance(raw_context_data, str) and (raw_context_data.strip().startswith('{') or raw_context_data.strip().startswith('[')):
+                                st.json(json.loads(raw_context_data))
+                            else:
+                                st.text(str(raw_context_data))
+                        except (json.JSONDecodeError, TypeError):
+                            st.text(str(raw_context_data))
+            st.session_state.manual_chat_history.append({"role": "assistant", "content": llm_response, "context": raw_context_data})
 
 # --- Twilio Bot Polling Logic ---
 if st.session_state.get("bot_started") and st.session_state.get("rag_pipeline_ready"):
-    current_time = time.time()
-    if (current_time - st.session_state.get("last_twilio_poll_time", 0)) > polling_interval_to_use: # Use correct var
-        st.session_state.last_twilio_poll_time = current_time
-        with st.spinner("Checking WhatsApp messages..."):
-            if not st.session_state.get("twilio_client") or not twilio_conversation_service_sid_to_use or not twilio_bot_whatsapp_identity_to_use: # Use correct vars
-                st.warning("Twilio client/config missing for polling.")
-            else:
-                new_messages = get_new_whatsapp_messages(st.session_state.twilio_client, twilio_conversation_service_sid_to_use, 
-                                                         st.session_state.bot_start_time_utc, st.session_state.processed_message_sids,
-                                                         twilio_bot_whatsapp_identity_to_use) # Use correct vars
-                if new_messages:
-                    st.info(f"Found {len(new_messages)} new WhatsApp message(s).")
-                    for msg_data in new_messages:
-                        user_query_whatsapp, conv_sid, msg_sid, author_id = msg_data["message_body"], msg_data["conversation_sid"], msg_data["message_sid"], msg_data["author_identity"]
-                        st.write(f"Processing from {author_id} in {conv_sid}: '{user_query_whatsapp}'")
-
-                        intent_result_whatsapp = simple_intent_classifier(user_query_whatsapp) # Use the updated classifier
-                        intent_whatsapp = intent_result_whatsapp[0]
-                        potential_oid_whatsapp = intent_result_whatsapp[1] # Extracted ID from intent classifier
-
-                        context_whatsapp = "No specific context."
-                        if intent_whatsapp == "ORDER_STATUS":
+    current_time = time.time()
+    if (current_time - st.session_state.get("last_twilio_poll_time", 0)) > polling_interval_to_use: # Use correct var
+        st.session_state.last_twilio_poll_time = current_time
+        with st.spinner("Checking WhatsApp messages..."):
+            if not st.session_state.get("twilio_client") or not twilio_conversation_service_sid_to_use or not twilio_bot_whatsapp_identity_to_use: # Use correct vars
+                st.warning("Twilio client/config missing for polling.")
+            else:
+                new_messages = get_new_whatsapp_messages(st.session_state.twilio_client, twilio_conversation_service_sid_to_use,
+                                                         st.session_state.bot_start_time_utc, st.session_state.processed_message_sids,
+                                                         twilio_bot_whatsapp_identity_to_use) # Use correct vars
+                if new_messages:
+                    st.info(f"Found {len(new_messages)} new WhatsApp message(s).")
+                    for msg_data in new_messages:
+                        user_query_whatsapp, conv_sid, msg_sid, author_id = msg_data["message_body"], msg_data["conversation_sid"], msg_data["message_sid"], msg_data["author_identity"]
+                        st.write(f"Processing from {author_id} in {conv_sid}: '{user_query_whatsapp}'")
+
+                        intent_result_whatsapp = simple_intent_classifier(user_query_whatsapp) # Use the updated classifier
+                        intent_whatsapp = intent_result_whatsapp[0]
+                        potential_oid_whatsapp = intent_result_whatsapp[1] # Extracted ID from intent classifier
+
+                        context_whatsapp = "No specific context."
+                        if intent_whatsapp == "ORDER_STATUS":
                             order_id_to_check_whatsapp = None
                             if potential_oid_whatsapp:
                                 order_id_to_check_whatsapp = potential_oid_whatsapp
@@ -555,29 +555,29 @@ if st.session_state.get("bot_started") and st.session_state.get("rag_pipeline_re
                                     order_id_to_check_whatsapp = possible_match_whatsapp
 
                             if order_id_to_check_whatsapp:
-                                context_whatsapp = f"Order Details: {get_order_details(order_id_to_check_whatsapp.upper(), st.session_state.customer_orders_data)}"
+                                context_whatsapp = f"Order Details: {get_order_details(order_id_to_check_whatsapp.upper(), st.session_state.customer_orders_data)}"
                             else:
                                 context_whatsapp = "Please provide a valid Order ID."
-                        elif intent_whatsapp == "PRODUCT_INFO":
-                            context_whatsapp = f"Product Info: {get_product_info(user_query_whatsapp, st.session_state.products_data)}"
-                        elif intent_whatsapp == "GENERAL_POLICY_FAQ" or intent_whatsapp == "UNKNOWN":
-                            if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
-                                k_val = 2 if intent_whatsapp == "GENERAL_POLICY_FAQ" else 1
-                                chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_whatsapp, st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
-                                context_whatsapp = "\n\n".join(chunks) if chunks else ("No policy/FAQ info." if intent_whatsapp == "GENERAL_POLICY_FAQ" else "No relevant info.")
-                            else: context_whatsapp = "Policy/FAQ docs unavailable."
-                        
-                        response_whatsapp = generate_response_groq(st.session_state.groq_client, user_query_whatsapp, context_whatsapp)
-                        if send_whatsapp_message(st.session_state.twilio_client, twilio_conversation_service_sid_to_use, conv_sid, response_whatsapp, twilio_bot_whatsapp_identity_to_use): # Use correct vars
-                            st.session_state.processed_message_sids.add(msg_sid)
-                            st.success(f"Responded to {msg_sid} from {author_id}")
-                        else: st.error(f"Failed to send response for {msg_sid}")
-                    st.experimental_rerun()
+                        elif intent_whatsapp == "PRODUCT_INFO":
+                            context_whatsapp = f"Product Info: {get_product_info(user_query_whatsapp, st.session_state.products_data)}"
+                        elif intent_whatsapp == "GENERAL_POLICY_FAQ" or intent_whatsapp == "UNKNOWN":
+                            if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
+                                k_val = 2 if intent_whatsapp == "GENERAL_POLICY_FAQ" else 1
+                                chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_whatsapp, st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
+                                context_whatsapp = "\n\n".join(chunks) if chunks else ("No policy/FAQ info." if intent_whatsapp == "GENERAL_POLICY_FAQ" else "No relevant info.")
+                            else: context_whatsapp = "Policy/FAQ docs unavailable."
+                        
+                        response_whatsapp = generate_response_groq(st.session_state.groq_client, user_query_whatsapp, context_whatsapp)
+                        if send_whatsapp_message(st.session_state.twilio_client, twilio_conversation_service_sid_to_use, conv_sid, response_whatsapp, twilio_bot_whatsapp_identity_to_use): # Use correct vars
+                            st.session_state.processed_message_sids.add(msg_sid)
+                            st.success(f"Responded to {msg_sid} from {author_id}")
+                        else: st.error(f"Failed to send response for {msg_sid}")
+                    st.experimental_rerun()
 
 # --- Footer & Status ---
 st.sidebar.markdown("---")
 st.sidebar.info("Ensure all keys and SIDs are correctly configured. Primary API keys (Twilio SID/Token, GROQ Key) are loaded from secrets if available.")
 if st.session_state.get("app_started"):
-    st.sidebar.success(f"App RUNNING. WhatsApp Bot {'RUNNING' if st.session_state.get('bot_started') else 'STOPPED'}.")
+    st.sidebar.success(f"App RUNNING. WhatsApp Bot {'RUNNING' if st.session_state.get('bot_started') else 'STOPPED'}.")
 else:
-    st.sidebar.warning("App is STOPPED.")
+    st.sidebar.warning("App is STOPPED.")