audit logs and mongo util

ai/extract.py

@@ -0,0 +1,123 @@
+import re
+from langdetect import detect
+import openai
+import os
+from dotenv import load_dotenv
+from utils.db import MongoDBUtil
+from bson import ObjectId
+# Load environment variables
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+mongo_util = MongoDBUtil()
+
+# Function to use GPT for extracting details
+def gpt_extract_trip_details(sentence):
+    """
+    Use OpenAI GPT to extract destination and number of days.
+    """
+    prompt = (
+        f"Extract the following details from this sentence:\n"
+        f"Sentence: '{sentence}'\n\n"
+        f"Details to extract:\n"
+        f"1. Destination: (The place the user wants to travel to, None if not mentioned)\n"
+        f"2. Number of Days: (The number of days the user plans to stay, None if not explicitly mentioned)\n\n"
+        f"Format the response as:\n"
+        f"Destination: [destination]\n"
+        f"Number of Days: [days]\n"
+    )
+    try:
+        client = openai.OpenAI() 
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are an assistant that extracts structured details from sentences."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=150,
+            temperature=0.5
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"OpenAI API Error: {e}")
+        return None
+
+# Function to parse GPT response
+def parse_gpt_response(response):
+    """
+    Parse GPT response into a structured dictionary and handle missing values.
+    """
+    try:
+        result = {"destination": None, "num_days": None}
+
+        if not response:
+            return result
+
+        lines = response.split("\n")
+
+        for line in lines:
+            if ": " in line:
+                key, value = line.split(": ", 1)
+                key = key.lower().strip()
+                value = value.strip()
+
+                if key == "destination":
+                    result["destination"] = value if value and value.lower() != "none" else None
+                elif key == "number of days":
+                    result["num_days"] = int(value) if value.isdigit() else None
+
+        return result
+    except Exception as e:
+        print(f"Error parsing GPT response: {e}")
+        return {"destination": None, "num_days": None}
+
+# Regex-based extraction
+def extract_trip_details(sentence):
+    """
+    Extract destination and number of days using regex.
+    """
+    destination_pattern = r'(?:to|for)\s+(\w+(?:\s+\w+)*)'
+    days_pattern = r'(\d+)\s+(?:days|day)'
+
+    destination_match = re.search(destination_pattern, sentence, re.IGNORECASE)
+    destination = destination_match.group(1).strip() if destination_match else None
+
+    days_match = re.search(days_pattern, sentence, re.IGNORECASE)
+    num_days = int(days_match.group(1)) if days_match else None
+
+    # If "from" is present, it indicates origin, not destination
+    if "from" in sentence.lower():
+        destination = None
+
+    return {"destination": destination, "num_days": num_days}
+
+# Main processing function
+def extract_sentence(sentence, user):
+    """
+    Complete pipeline for extracting travel details with fallback to regex if GPT fails.
+    """
+    try:
+        if detect(sentence) != "en":
+            return {"destination": None, "num_days": None}
+    except Exception as e:
+        print(f"Error in language detection: {e}")
+        return {"destination": None, "num_days": None}
+
+    print("Using GPT to extract travel details...")
+    gpt_response = gpt_extract_trip_details(sentence)
+    if gpt_response:
+        mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
+        gpt_details = parse_gpt_response(gpt_response)
+        if gpt_details["destination"] is None and "from" in sentence.lower():
+            gpt_details["destination"] = None
+        return gpt_details
+
+    print("GPT extraction failed or returned no details. Falling back to regex extraction...")
+    return extract_trip_details(sentence)
+
+# Main entry point
+if __name__ == "__main__":
+    sentence = input("Enter a trip-related sentence: ")
+    result = extract_sentence(sentence)
+    print("Extracted Travel Details:")
+    print(result)

ai/iata.py

@@ -36,9 +36,9 @@ def get_country_code(access_key=None, query=None):
         print(f"Error: {e}")
         return {"error": str(e)}
 
-# if __name__ == "__main__":
-#     country_name = input("Enter the country name or skyId to search for airports: ")
-#     response = get_country_code(query=country_name)
-#     print("Formatted Response:")
-#     for airport in response:
-#         print(f"skyId: {airport['skyId']}, entityId: {airport['entityId']}")
+if __name__ == "__main__":
+    country_name = input("Enter the country name or skyId to search for airports: ")
+    response = get_country_code(query=country_name)
+    print("Formatted Response:")
+    for airport in response:
+        print(f"skyId: {airport['skyId']}, entityId: {airport['entityId']}")

ai/prompt.py

@@ -0,0 +1,159 @@
+import re
+from datetime import datetime
+from langdetect import detect
+import openai
+import os
+from dotenv import load_dotenv
+from utils.db import MongoDBUtil
+from bson import ObjectId
+
+# Load environment variables
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+mongo_util = MongoDBUtil()
+
+# Function to use GPT for extracting details
+def gpt_extract_flight_details(sentence):
+    """
+    Use OpenAI GPT to extract origin, destination, date, and number of people.
+    """
+    prompt = (
+        f"Extract the following details from this sentence:\n"
+        f"Sentence: '{sentence}'\n\n"
+        f"Details to extract:\n"
+        f"1. Origin: (The place the user is traveling from. Set to None if not mentioned)\n"
+        f"2. Destination: (The place the user is traveling to. Set to None if not mentioned)\n"
+        f"3. Date: (The travel date in YYYY-MM-DD format. Set to None if not mentioned)\n"
+        f"4. Number of People: (Set to None if not explicitly mentioned)\n\n"
+        f"Format the response as:\n"
+        f"Origin: [origin]\n"
+        f"Destination: [destination]\n"
+        f"Date: [date]\n"
+        f"Number of People: [number]\n"
+    )
+    try:
+        client = openai.OpenAI() 
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are an assistant that extracts structured details from sentences."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=150,
+            temperature=0.5
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"OpenAI API Error: {e}")
+        return None
+
+# Function to parse GPT response
+def parse_gpt_response(response):
+    """
+    Parse GPT response into a structured dictionary and return None for missing or invalid fields.
+    """
+    result = {"origin": None, "destination": None, "date": None, "num_people": None}
+
+    if not response:
+        return result
+
+    lines = response.split("\n")
+
+    for line in lines:
+        if ": " in line:
+            key, value = line.split(": ", 1)
+            key = key.lower().strip()
+            value = value.strip()
+
+            if key == "origin":
+                result["origin"] = value if value.lower() != "none" and value.lower() != "not mentioned" else None
+            elif key == "destination":
+                result["destination"] = value if value.lower() != "none" and value.lower() != "not mentioned" else None
+            elif key == "date":
+                result["date"] = parse_date(value) if value.lower() != "none" and value.lower() != "not mentioned" else None
+            elif key == "number of people":
+                result["num_people"] = int(value) if value.isdigit() else None
+
+    return result
+
+# Function to parse and normalize dates
+def parse_date(date_text):
+    """
+    Convert extracted date into YYYY-MM-DD format.
+    """
+    try:
+        date_formats = [
+            "%d %B %Y", "%B %d %Y", "%Y-%m-%d", "%d-%m-%Y", "%m-%d-%Y",
+            "%d/%m/%Y", "%m/%d/%Y", "%d %b %Y", "%b %d %Y"
+        ]
+        for fmt in date_formats:
+            try:
+                parsed_date = datetime.strptime(date_text, fmt)
+                return parsed_date.strftime("%Y-%m-%d")
+            except ValueError:
+                continue
+        return None
+    except Exception as e:
+        print(f"Error parsing date: {e}")
+        return None
+
+# Function to check if a sentence is in English
+def check_if_english(sentence):
+    """
+    Check if the sentence is in English using langdetect.
+    """
+    try:
+        language = detect(sentence)
+        return language == "en"
+    except Exception as e:
+        print(f"Error in language detection: {e}")
+        return False
+
+# Regex-based extraction
+def extract_flight_details(sentence):
+    """
+    Extract origin, destination, date, and number of people using regex.
+    """
+    origin_dest_pattern = r'from\s+(.*?)\s+to\s+(.*?)(?:\s+on|\s+with|\s+for|\.|$)'
+    date_pattern = r'\b(?:\d{1,2}[-/\s]?[A-Za-z]+[-/\s]?\d{2,4}|\d{4}-\d{2}-\d{2})\b'
+    people_pattern = r'(\d+)\s+(?:people|adults)'
+
+    match = re.search(origin_dest_pattern, sentence, re.IGNORECASE)
+    origin = match.group(1).strip() if match else None
+    destination = match.group(2).strip() if match else None
+
+    date_match = re.search(date_pattern, sentence)
+    date = parse_date(date_match.group(0).strip()) if date_match else None
+
+    people_match = re.search(people_pattern, sentence, re.IGNORECASE)
+    num_people = int(people_match.group(1)) if people_match else None
+
+    return {"origin": origin, "destination": destination, "date": date, "num_people": num_people}
+
+# Main processing function
+def process_sentence(sentence, user):
+    """
+    Complete pipeline for extracting flight details with fallback to regex if GPT fails.
+    """
+    if not check_if_english(sentence):
+        return {"error": "The sentence is not in English."}
+
+    gpt_response = gpt_extract_flight_details(sentence)
+    if gpt_response:
+        mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
+        gpt_details = parse_gpt_response(gpt_response)
+        return gpt_details
+
+    regex_details = extract_flight_details(sentence)
+    return {
+        "origin": regex_details.get("origin", None),
+        "destination": regex_details.get("destination", None),
+        "date": regex_details.get("date", None),
+        "num_people": regex_details.get("num_people", None),
+    }
+
+if __name__ == "__main__":
+    sentence = input("Enter a sentence: ")
+    result = process_sentence(sentence)
+    print("Extracted Flight Details:")
+    print(result)

ai/travel.py

@@ -1,47 +1,3 @@
-# code1: 
-
-# import requests
-# import os
-# import pandas as pd
-
-# from dotenv import load_dotenv
-# load_dotenv()
-
-# def get_travel_listing (origin_iata, destination_iata, depart_date, return_date ):
-#      try:
-#         api_token = os.environ["TRAVEL_PAYOUT_API_TOKEN"]
-#         api_url = f"https://api.travelpayouts.com/v1/prices/cheap?origin={origin_iata}&destination={destination_iata}&depart_date={depart_date}&return_date={return_date or ''}&token={api_token}&currency=usd"
-#       # FOR CALENDAR
-#       #   api_url = f"https://api.travelpayouts.com/v1/prices/calendar?origin={origin_iata}&destination={destination_iata}&depart_date={depart_date}&return_date={return_date or ''}&token={api_token}&currency=usd"
-#         print(api_url)
-#         response = requests.get(api_url)
-#         data = response.json()
-#         print(data)
-        
-#         airlines_data = []
-#         airlines = pd.read_json('data/airlines.json')
-        
-#         for k in data['data'].keys():
-#             # find PK in airlines[]{code = PK}
-#             # FOR CALENDER
-#             # data['data'][k]['airline_name'] = airlines[airlines['code'] == data['data'][k]['airline']]['name'].values[0]
-            
-#             # FOR CHEAP FLIGHTS
-#             airline = {}
-#             airline_complete = airlines[airlines['code'] == data['data'][k][list(data['data'][k].keys())[0]]['airline']]['name'].values[0]
-            
-#             airline = data['data'][k][list(data['data'][k].keys())[0]]
-#             airline['airline_name'] = airline_complete
-
-#             airlines_data.append(airline)
-
-#         return airlines_data
-
-#      except Exception as e:
-#         print(e)
-#         print("ERR")
-#         return False
-
 import requests
 import os
 from dotenv import load_dotenv
@@ -51,79 +7,101 @@ load_dotenv()
 
 def get_travel_listing(originSkyId, destinationSkyId, originEntityId, destinationEntityId, date, adults, access_key=None):
     try:
-        access_key = access_key or os.environ["FLIGHTLABS_API_TOKEN"]
+        # Use API token from environment or passed as an argument
+        access_key = access_key or os.environ.get("FLIGHTLABS_API_TOKEN")
         if not access_key:
             raise ValueError("Access key is required.")
+        
         if not originSkyId or not destinationSkyId or not originEntityId or not destinationEntityId:
             raise ValueError("All IDs (Sky and Entity) are required.")
 
         # Construct API URL
         api_url = f"https://app.goflightlabs.com/retrieveFlights?access_key={access_key}&originSkyId={originSkyId}&destinationSkyId={destinationSkyId}&originEntityId={originEntityId}&destinationEntityId={destinationEntityId}&date={date}&adults={adults}"
-
-        print(f"Requesting API URL: {api_url}")
         response = requests.get(api_url)
-       
         response.raise_for_status()
+
+        # Parse response JSON
         data = response.json()
-        
+
         if 'error' in data:
             raise ValueError(f"API Error: {data['error']}")
 
+        # Process the response data
         extracted_data = []
-        seen_flights = set()  # To prevent duplicate outputs
+        seen_flights = set()
 
         for itinerary in data.get("itineraries", []):
             for leg in itinerary.get("legs", []):
-                # Unique flight key to ensure no duplicates
-                unique_key = (leg["origin"]["displayCode"], leg["destination"]["displayCode"], leg["departure"])
+                # Safely access nested keys
+                origin = leg.get("origin", {}).get("name", "N/A")
+                destination = leg.get("destination", {}).get("name", "N/A")
+                duration_in_minutes = leg.get("durationInMinutes", 0)
+                carriers = leg.get("carriers", {}).get("marketing", [{}])
+
+                unique_key = (
+                    leg.get("origin", {}).get("displayCode", "N/A"),
+                    leg.get("destination", {}).get("displayCode", "N/A"),
+                    leg.get("departure", "N/A")
+                )
                 if unique_key in seen_flights:
                     continue
                 seen_flights.add(unique_key)
 
-                # Convert duration from minutes to hours and minutes
-                duration_in_minutes = leg['durationInMinutes']
+                # Format duration safely
                 hours = duration_in_minutes // 60
                 minutes = duration_in_minutes % 60
-                duration_formatted = f"{hours} hours and {minutes} minutes"
+                duration_formatted = f"{hours} hours and {minutes} minutes" if duration_in_minutes else "N/A"
+
+                # Safely get airline details
+                airline_code = carriers[0].get("alternateId", "N/A")
+                airline_name = carriers[0].get("name", "N/A")
 
                 # Build stops information
-                stop_locations = [leg["origin"]["displayCode"]] 
+                stop_locations = [leg.get("origin", {}).get("displayCode", "N/A")]
                 stop_details = []
                 segments = leg.get("segments", [])
                 for i, segment in enumerate(segments[:-1]):
-                    stop_code = segment["destination"]["displayCode"]
-                    stop_arrival = datetime.datetime.fromisoformat(segment["arrival"])
-                    next_departure = datetime.datetime.fromisoformat(segments[i + 1]["departure"])
-                    stop_duration_minutes = int((next_departure - stop_arrival).total_seconds() / 60)
-                    stop_hours = stop_duration_minutes // 60
-                    stop_minutes = stop_duration_minutes % 60
-                    stop_time_formatted = (
-                        f"{stop_hours} hour{'s' if stop_hours > 1 else ''}" if stop_minutes == 0 else
-                        f"{stop_hours} hour{'s' if stop_hours > 1 else ''} and {stop_minutes} minutes" if stop_hours > 0 else
-                        f"{stop_minutes} minutes"
-                    )
-                    stop_details.append(f"{stop_code} ({stop_time_formatted})")
-                    stop_locations.append(stop_code)  # Add to the route
-
-                stop_locations.append(leg["destination"]["displayCode"])  # Add the final destination
+                    stop_code = segment.get("destination", {}).get("displayCode", "N/A")
+                    stop_arrival = segment.get("arrival", None)
+                    next_departure = segments[i + 1].get("departure", None)
+                    if stop_arrival and next_departure:
+                        stop_duration_minutes = int(
+                            (datetime.datetime.fromisoformat(next_departure) -
+                             datetime.datetime.fromisoformat(stop_arrival)).total_seconds() / 60
+                        )
+                        stop_hours = stop_duration_minutes // 60
+                        stop_minutes = stop_duration_minutes % 60
+                        stop_time_formatted = (
+                            f"{stop_hours} hours" if stop_minutes == 0 else
+                            f"{stop_hours} hours and {stop_minutes} minutes" if stop_hours > 0 else
+                            f"{stop_minutes} minutes"
+                        )
+                        stop_details.append(f"{stop_code} ({stop_time_formatted})")
+                    stop_locations.append(stop_code)
+
+                stop_locations.append(leg.get("destination", {}).get("displayCode", "N/A"))
                 stops_route = " --> ".join(stop_locations)
 
+                # Safely extract flight price
+                price = itinerary.get("price", {}).get("formatted", "N/A")
+
+                # Add extracted data to the list
                 extracted_data.append({
-                    "origin": leg["origin"]["name"],
-                    "destination": leg["destination"]["name"],
-                    "airline_code": leg["carriers"]["marketing"][0]["alternateId"] if leg["carriers"]["marketing"] else "N/A",
-                    "airline_name": leg["carriers"]["marketing"][0]["name"] if leg["carriers"]["marketing"] else "N/A",
+                    "origin": origin,
+                    "destination": destination,
+                    "airline_code": airline_code,
+                    "airline_name": airline_name,
                     "duration": duration_formatted,
-                    "price": itinerary["price"]["formatted"],
-                    "departure": leg["departure"],
-                    "arrival": leg["arrival"],
-                    "flight_number": ", ".join(segment["flightNumber"] for segment in segments),
+                    "price": price,
+                    "departure": leg.get("departure", "N/A"),
+                    "arrival": leg.get("arrival", "N/A"),
+                    "flight_number": ", ".join(segment.get("flightNumber", "N/A") for segment in segments),
                     "stop_count": leg.get("stopCount", 0),
                     "stops_route": stops_route,
                     "stops_details": stop_details
                 })
 
-        # Print and return the extracted data
+        # Display the extracted flight data in a structured format
         for flight in extracted_data:
             print("\nFlight Details:")
             print(f"Origin: {flight['origin']}")
@@ -141,56 +119,100 @@ def get_travel_listing(originSkyId, destinationSkyId, originEntityId, destinatio
                 print(f"Stop Details: {', '.join(flight['stops_details'])}")
             else:
                 print("Stop Details: No stops on the trip")
-        
+
         return extracted_data
 
     except Exception as e:
         print(f"Error occurred: {e}")
         return False
 
-# if __name__ == "__main__":
-#     try:
-#         # Gather user inputs
-#         originSkyId = input("Enter the origin SkyId: ").strip()
-#         if not originSkyId:
-#             raise ValueError("Origin SkyId is required.")
+if __name__ == "__main__":
+    try:
+        # Gather user inputs
+        originSkyId = input("Enter the origin SkyId: ").strip()
+        if not originSkyId:
+            raise ValueError("Origin SkyId is required.")
         
-#         destinationSkyId = input("Enter the destination SkyId: ").strip()
-#         if not destinationSkyId:
-#             raise ValueError("Destination SkyId is required.")
+        destinationSkyId = input("Enter the destination SkyId: ").strip()
+        if not destinationSkyId:
+            raise ValueError("Destination SkyId is required.")
         
-#         originEntityId = input("Enter the origin EntityId: ").strip()
-#         if not originEntityId:
-#             raise ValueError("Origin EntityId is required.")
+        originEntityId = input("Enter the origin EntityId: ").strip()
+        if not originEntityId:
+            raise ValueError("Origin EntityId is required.")
         
-#         destinationEntityId = input("Enter the destination EntityId: ").strip()
-#         if not destinationEntityId:
-#             raise ValueError("Destination EntityId is required.")
+        destinationEntityId = input("Enter the destination EntityId: ").strip()
+        if not destinationEntityId:
+            raise ValueError("Destination EntityId is required.")
+        
+        date_input = input("Enter the travel date (YYYY-MM-DD): ").strip()
+        if not date_input:
+            raise ValueError("Travel date is required.")
+        
+        adults = input("Enter the number of adults (optional): ").strip()
+
+        # Validate the date input
+        try:
+            date = datetime.datetime.strptime(date_input, "%Y-%m-%d").date()
+        except ValueError:
+            raise ValueError("Invalid date format. Please use YYYY-MM-DD.")
+
+        # Call the get_travel_listing function
+        print("\nFetching travel listings...")
+        travel_listings = get_travel_listing(
+            originSkyId=originSkyId,
+            destinationSkyId=destinationSkyId,
+            originEntityId=originEntityId,
+            destinationEntityId=destinationEntityId,
+            date=str(date),
+            adults=adults or 1  
+        )
+
+        if not travel_listings:
+            print("No travel listings found or an error occurred.")
+    except Exception as e:
+        print(f"Error occurred: {e}")
+
+# code1: 
+
+# import requests
+# import os
+# import pandas as pd
+
+# from dotenv import load_dotenv
+# load_dotenv()
+
+# def get_travel_listing (origin_iata, destination_iata, depart_date, return_date ):
+#      try:
+#         api_token = os.environ["TRAVEL_PAYOUT_API_TOKEN"]
+#         api_url = f"https://api.travelpayouts.com/v1/prices/cheap?origin={origin_iata}&destination={destination_iata}&depart_date={depart_date}&return_date={return_date or ''}&token={api_token}&currency=usd"
+#       # FOR CALENDAR
+#       #   api_url = f"https://api.travelpayouts.com/v1/prices/calendar?origin={origin_iata}&destination={destination_iata}&depart_date={depart_date}&return_date={return_date or ''}&token={api_token}&currency=usd"
+#         print(api_url)
+#         response = requests.get(api_url)
+#         data = response.json()
+#         print(data)
         
-#         date_input = input("Enter the travel date (YYYY-MM-DD): ").strip()
-#         if not date_input:
-#             raise ValueError("Travel date is required.")
+#         airlines_data = []
+#         airlines = pd.read_json('data/airlines.json')
         
-#         adults = input("Enter the number of adults (optional): ").strip()
-
-#         # Validate the date input
-#         try:
-#             date = datetime.datetime.strptime(date_input, "%Y-%m-%d").date()
-#         except ValueError:
-#             raise ValueError("Invalid date format. Please use YYYY-MM-DD.")
-
-#         # Call the get_travel_listing function
-#         print("\nFetching travel listings...")
-#         travel_listings = get_travel_listing(
-#             originSkyId=originSkyId,
-#             destinationSkyId=destinationSkyId,
-#             originEntityId=originEntityId,
-#             destinationEntityId=destinationEntityId,
-#             date=str(date),
-#             adults=adults or 1  
-#         )
-
-#         if not travel_listings:
-#             print("No travel listings found or an error occurred.")
-#     except Exception as e:
-#         print(f"Error occurred: {e}")
+#         for k in data['data'].keys():
+#             # find PK in airlines[]{code = PK}
+#             # FOR CALENDER
+#             # data['data'][k]['airline_name'] = airlines[airlines['code'] == data['data'][k]['airline']]['name'].values[0]
+            
+#             # FOR CHEAP FLIGHTS
+#             airline = {}
+#             airline_complete = airlines[airlines['code'] == data['data'][k][list(data['data'][k].keys())[0]]['airline']]['name'].values[0]
+            
+#             airline = data['data'][k][list(data['data'][k].keys())[0]]
+#             airline['airline_name'] = airline_complete
+
+#             airlines_data.append(airline)
+
+#         return airlines_data
+
+#      except Exception as e:
+#         print(e)
+#         print("ERR")
+#         return False

ai/trip.py

@@ -19,149 +19,61 @@ def get_trip_planner(days, destination):
 
         # Construct API URL
         api_url = f"https://zylalabs.com/api/2242/trip+planner+api/2103/get+planning?days={days}&destination={destination}"
-        print(f"Requesting API URL: {api_url}")
-
+        
         # Make the API request
         response = requests.get(api_url, headers={"Authorization": f"Bearer {api_token}"})
         response.raise_for_status()
-
+        
         # Parse the response
         data = response.json()
+        
         if 'error' in data:
             raise ValueError(f"API Error: {data['error']}")
 
-        # Extract trip plans
-        trip_plans = data.get("plans", [])
-        if not trip_plans:
-            print("No trip plans found.")
+        trip_plan = data.get("plan", [])
+        if not trip_plan:
+            print("No trip plan found.")
             return []
 
-        # Format the trip plans
-        extracted_data = [
-            {
-                "day": plan.get("day", "Unknown Day"),
-                "activities": [activity.get("description", "No Description") for activity in plan.get("activities", [])]
-            }
-            for plan in trip_plans
-        ]
-
-        # Print the trip plans
-        for plan in extracted_data:
-            print(f"\nDay: {plan['day']}")
-            print("Activities:")
-            for activity in plan["activities"]:
-                print(f" - {activity}")
-
-        return extracted_data
+        formatted_plan = {
+            "_id": data.get("_id", "Unknown ID"),
+            "plan": [
+                {
+                    "day": day_plan.get("day"),
+                    "activities": [
+                        {
+                            "time": activity.get("time"),
+                            "description": activity.get("description")
+                        }
+                        for activity in day_plan.get("activities", [])
+                    ]
+                }
+                for day_plan in trip_plan
+            ],
+            "key": data.get("key", "Unknown Key")
+        }
+
+        # Print the formatted output
+        print("\nFormatted Trip Plan:")
+        print(formatted_plan)
+        
+        return formatted_plan
 
     except Exception as e:
         print(f"Error occurred: {e}")
-        return False
+        return None
 
 if __name__ == "__main__":
     try:
         # Gather user inputs
         days = int(input("Enter the number of days for the trip: ").strip())
         destination = input("Enter the destination: ").strip()
-        if not days or not destination:
-            raise ValueError("Both days and destination are required.")
 
         # Fetch trip plans
         print("\nFetching trip plans...")
-        trip_plans = get_trip_planner(days, destination)
+        trip_plan = get_trip_planner(days, destination)
 
-        if not trip_plans:
+        if not trip_plan:
             print("No trip plans found or an error occurred.")
     except Exception as e:
         print(f"Error occurred: {e}")
-
-
-
-# import requests
-# import os
-# from dotenv import load_dotenv
-
-# load_dotenv()
-
-# def get_trip_planner(days, destination):
-#     try:
-#         # Fetch the API token from environment variables
-#         api_token = os.environ.get("ZYLA_API_TOKEN")
-#         if not api_token:
-#             raise ValueError("API token is required. Set ZYLA_API_TOKEN in environment variables.")
-
-#         # Validate inputs
-#         if not isinstance(days, int) or days <= 0:
-#             raise ValueError("Days must be a positive integer.")
-#         if not destination.strip():
-#             raise ValueError("Destination cannot be empty.")
-
-#         # Construct API URL
-#         api_url = f"https://zylalabs.com/api/2242/trip+planner+api/2103/get+planning?days={days}&destination={destination}"
-#         print(f"Requesting API URL: {api_url}")
-
-#         # Make the API request
-#         response = requests.get(api_url, headers={"Authorization": f"Bearer {api_token}"})
-#         response.raise_for_status()
-
-#         # Parse the response
-#         data = response.json()
-#         if 'error' in data:
-#             raise ValueError(f"API Error: {data['error']}")
-
-#         # Extract trip plans
-#         trip_plans = data.get("plans", [])
-#         if not trip_plans:
-#             print("No trip plans found.")
-#             return {}
-
-#         # Format the trip plans
-#         formatted_plans = {
-#             "plan": [
-#                 {
-#                     "day": plan.get("day", "Unknown Day"),
-#                     "activities": [
-#                         {
-#                             "time": activity.get("time", "Unknown Time"),
-#                             "description": activity.get("description", "No Description")
-#                         }
-#                         for activity in plan.get("activities", [])
-#                     ]
-#                 }
-#                 for plan in trip_plans
-#             ],
-#             "key": f"{days}-{destination.lower().replace(' ', '')}",
-#             "_id": data.get("_id", "Unknown ID")
-#         }
-
-#         # Print the formatted plans
-#         for day_plan in formatted_plans["plan"]:
-#             print(f"\nDay {day_plan['day']}:")
-#             for activity in day_plan["activities"]:
-#                 print(f"{activity['time']} - {activity['description']}")
-
-#         return formatted_plans
-
-#     except Exception as e:
-#         print(f"Error occurred: {e}")
-#         return {}
-
-# if __name__ == "__main__":
-#     try:
-#         # Gather user inputs
-#         days = int(input("Enter the number of days for the trip: ").strip())
-#         destination = input("Enter the destination: ").strip()
-#         if not days or not destination:
-#             raise ValueError("Both days and destination are required.")
-
-#         # Fetch trip plans
-#         print("\nFetching trip plans...")
-#         trip_plans = get_trip_planner(days, destination)
-
-#         if not trip_plans:
-#             print("No trip plans found or an error occurred.")
-#         else:
-#             print("\nFinal Trip Plans:")
-#             print(trip_plans)
-#     except Exception as e:
-#         print(f"Error occurred: {e}")

ai/tti.py

@@ -35,24 +35,24 @@ def texttoimage(prompt):
         s3_path = f'images/{now}.png'
         path = f'tmp/{now}.png'
 
-        # Assuming you want to save the response (audio content) to a file
-        with open(path, 'wb') as file:
-            file.write(requests.get(image_url).content)
-
-        s3.Bucket(os.environ["S3_BUCKET_NAME"]).upload_file(path, s3_path)
-        url = s3.meta.client.generate_presigned_url(
-            ClientMethod='get_object',
-            Params={
-                'Bucket': os.environ["S3_BUCKET_NAME"],
-                'Key': s3_path
-            }
-        )
-        os.remove(path)
+        # # Assuming you want to save the response (audio content) to a file
+        # with open(path, 'wb') as file:
+        #     file.write(requests.get(image_url).content)
+
+        # s3.Bucket(os.environ["S3_BUCKET_NAME"]).upload_file(path, s3_path)
+        # url = s3.meta.client.generate_presigned_url(
+        #     ClientMethod='get_object',
+        #     Params={
+        #         'Bucket': os.environ["S3_BUCKET_NAME"],
+        #         'Key': s3_path
+        #     }
+        # )
+        # os.remove(path)
 
 
-        print(url)
+        print(image_url)
 
-        return url
+        return image_url
 
     except Exception as e:
         print('error occurred!', str(e))

main.py

@@ -7,22 +7,30 @@ from mutagen.wave import WAVE
 import json
 import random
 from fastapi import Request, HTTPException
+from dotenv import load_dotenv
+import re
+
 
 from models.messages import Messages
 from models.translation import Translation
 from models.tts import TTS
 from models.commands import Command
-
-
-from ai.autosuggest import auto_suggest_ask_llama2, auto_suggest_normalize_llama2,auto_suggest_ask_gpt
-from ai.translator import auto_translate
-from ai.audiotranscribe import audio_transcribe
 from ai.tts import texttospeech, texttospeech2
+
 from ai.travel import get_travel_listing
 from ai.iata import get_country_code
 from ai.tti import texttoimage
 from ai.trip import get_trip_planner
 from ai.job import get_job_listings
+from ai.prompt import process_sentence
+from ai.prompt import parse_date
+from ai.extract import extract_sentence
+
+
+from ai.autosuggest import auto_suggest_ask_llama2, auto_suggest_normalize_llama2,auto_suggest_ask_gpt
+from ai.translator import auto_translate
+from ai.audiotranscribe import audio_transcribe
+
 
 from utils.helpers import parse_json_garbage, parse_number, word_to_number
 from datetime import datetime
@@ -37,7 +45,7 @@ from utils.authenticator import check_session
 # Fetch a collection
 mongo_util = MongoDBUtil()
 
-
+load_dotenv()
 app = FastAPI()
 
 # Add the authentication middleware
@@ -48,27 +56,50 @@ app.add_middleware(AuditLogMiddleware)
 questions = {
     "travel": {
         "origin": [
-            "Can you tell me where are you traveling from?",
-            "Thank you for using Next Chat. Where are you traveling from?",
-            "Certainly, can you tell me where are you traveling from?",
-            "Great! What is your origin?"
+            "Can you tell me which city are you traveling from?",
+            "Thank you for using Next Chat. Which city are you traveling from?",
+            "Greetings, can you tell me which city are you traveling from?",
+            "Hello User! Can you tell me What is your origin city?",
+            "Sure! From which city will you begin your journey?",
+            "Please provide me the city where you are departing from.",
+            "Let me know the city or location where you will start your travel.",
+            "To assist you better, could you tell me your starting point?"
         ],
         "destination": [
-            "Got it, can you tell me where are you traveling to?",
-            "Great, and what is your destination?"
+            "Got it, can you tell me which city are you traveling to?",
+            "Great, and what is your destination city?",
+            "Perfect, which city you like to travel to?",
+            "Please tell me the city you are headed to.",
+            "Where is your final city for this trip?",
+            "Could you let me know which city are flying to?",
+            "What is the place or city you want to visit?",
+            "Let me know the destination city you're traveling to."
         ],
-        "start_date": [
-            "OK, when are you traveling?"
+        "date": [
+            "OK, when are you traveling?",
+            "Affirmative, and on which date are you planning to fly?",
+            "Please let me know the date of your journey.",
+            "When do you plan to start your travel?",
+            "Which date would you like to book your flight for?",
+            "What is the travel date for your trip?",
+            "On which day do you wish to travel?",
+            "Could you specify the date of your departure?"
         ],
         "people": [
             "Awesome, how many people will be traveling including yourself?",
-            "Noted, and how many people are you going with including yourself?"
+            "Noted, and how many people are you going with including yourself?",
+            "How many passengers will be traveling in total?",
+            "Including yourself, how many people are joining this trip?",
+            "What is the total number of travelers?",
+            "Could you let me know how many people will accompany you?",
+            "How many tickets should I consider for this trip?",
+            "Please specify the number of travelers, including you."
         ]
-    },
+},
     "trip": {
         "destination": [
             "Where would you like to go?",
-            "Great! Can you tell me your destination?",
+            "Hello! Can you tell me your destination?",
             "Where are you planning to travel to?",
             "What is the name of the place you want to visit?"
         ],
@@ -78,7 +109,7 @@ questions = {
             "Please let me know the number of days for your trip.",
             "How many days are you planning for your journey?"
         ]
-    },
+},
     "job": {
         "job_title": [
             "What job title are you looking for?",
@@ -92,7 +123,7 @@ questions = {
             "Can you specify the location for the job search?",
             "Which city or area do you prefer for this job?"
         ]
-    }
+}
 }
 
 @app.get("/")
@@ -209,183 +240,293 @@ async def audiotranscribe(
 #     return {"success": True, "url": url, "text": text, "translated_text": translated_text}
     
 @app.post("/api/commands/query")
-async def query(body: Command, request: Request):
-    user = request.state.user
-    print(user)
-    
+async def query(request: Request, body:Command):
     try:
-        if body.command == "/travel":
-            body.data = body.data or {}
-            print(f"Initial body.data: {body.data}")
-
-            if body.follow_question == "":
-
-                # decrement a token from "ai_whisper" attribute of user document
-                mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
-
-                return {
-                    "success": True,
-                    "follow_question": "origin",
-                    "data": body.data,
-                    "question": random.choice(questions["travel"]["origin"]),
-                }
-
-            elif body.follow_question == "origin":
-                origin_response = get_country_code(query=body.query)
-                print("Origin Response:", origin_response)
+        user = request.state.user
+        print("Debug: Received request body:", body)
 
-                if not origin_response or not isinstance(origin_response, list) or len(origin_response) == 0:
-                    return {"success": False, "message": "Unable to retrieve origin information."}
+        if len(body.query.strip()) > 100:
+            print("Debug: Query length exceeds 100 characters.")
+            return {
+                "success": False,
+                "message": "Please enter all the details in a short sentence of 100 characters or less.",
+            }
 
-                body.data["origin_skyid"] = origin_response[0]["skyId"]
-                body.data["origin_entityid"] = origin_response[0]["entityId"]
-                print(f"Updated body.data after origin: {body.data}")
-
-                # decrement a token from "ai_gpt" attribute of user document
-                mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
+                    
+        if body.command == "/travel":
+            body.data = body.data or {}
+            body.data["adults"] = body.data.get("adults")  # Allow adults to remain missing for sequential questions
 
-                return {
-                    "success": True,
-                    "follow_question": "destination",
-                    "data": body.data,
-                    "question": random.choice(questions["travel"]["destination"]),
-                }
+            print(f"Debug: Initial body.data: {body.data}")
 
-            elif body.follow_question == "destination":
-                destination_response = get_country_code(query=body.query)
-                print("Destination Response:", destination_response)
+            required_fields = ["origin_skyid", "destination_skyid", "date", "adults"]
 
-                if not destination_response or not isinstance(destination_response, list) or len(destination_response) == 0:
-                    return {"success": False, "message": "Unable to retrieve destination information."}
+            # Function to check for missing fields
+            def get_missing_fields(data):
+                return [field for field in required_fields if field not in data or not data.get(field)]
 
-                body.data["destination_skyid"] = destination_response[0]["skyId"]
-                body.data["destination_entityid"] = destination_response[0]["entityId"]
-                print(f"Updated body.data after destination: {body.data}")
+            # Map field names to question keys
+            field_to_question_key = {
+                "origin_skyid": "origin",
+                "destination_skyid": "destination",
+                "date": "date",
+                "adults": "people",
+            }
 
-                # decrement a token from "ai_gpt" attribute of user document
-                mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
+            # Case 1: Process the first query
+            if body.follow_question == "":
+                print("Debug: Processing first query with process_sentence.")
+                result = process_sentence(body.query, user)
+
+                # Ensure result is a valid dictionary
+                if not isinstance(result, dict):
+                    print("Error: process_sentence returned an invalid result.")
+                    return {"success": False, "message": "Internal error occurred during processing."}
+
+                print("Debug: Process Sentence Result:", result)
+                num_people = result.get("num_people")
+                if not isinstance(num_people, int) or num_people < 1 or num_people > 8:
+                    return {
+                        "success": False,
+                        "message": "Please enter the details of your travel with a valid number of people between 1 and 8."
+        }
+
+                # Store extracted fields into body.data
+                if result.get("origin"):
+                    origin_response = get_country_code(query=result["origin"])
+                    if origin_response:
+                        body.data["origin_skyid"] = str(origin_response[0]["skyId"])
+                        body.data["origin_entityid"] = str(origin_response[0]["entityId"])
+                    else:
+                        return {"success": False, "message": "Unable to retrieve origin information."}
 
+                if result.get("destination"):
+                    destination_response = get_country_code(query=result["destination"])
+                    if destination_response:
+                        body.data["destination_skyid"] = str(destination_response[0]["skyId"])
+                        body.data["destination_entityid"] = str(destination_response[0]["entityId"])
+                    else:
+                        return {"success": False, "message": "Unable to retrieve destination information."}
+
+                if result.get("date"):
+                    body.data["date"] = str(result["date"])
+
+                if result.get("num_people"):
+                    body.data["adults"] = str(result["num_people"])
+
+                print(f"Debug: Updated body.data after setting extracted fields: {body.data}")
+
+                # Check for missing fields
+                missing_fields = get_missing_fields(body.data)
+                print(f"Debug: Missing fields: {missing_fields}")
+                if not missing_fields:
+                    # All fields are present; fetch travel listings
+                    travel_listings = get_travel_listing(
+                        originSkyId=body.data["origin_skyid"],
+                        destinationSkyId=body.data["destination_skyid"],
+                        originEntityId=body.data.get("origin_entityid"),
+                        destinationEntityId=body.data.get("destination_entityid"),
+                        date=body.data["date"],
+                        adults=body.data["adults"],
+                    )
+                    print("Debug: Travel Listings Response:", travel_listings)
+                    if not travel_listings or "error" in travel_listings:
+                        return {"success": False, "message": "Unable to fetch travel listings."}
+                    return {"success": True, "suggestions": travel_listings}
+
+                # If fields are still missing, ask for the next missing field
+                next_field = missing_fields[0]
+                question_key = field_to_question_key[next_field]  # Map the field to the question key
+                print(f"Debug: Missing field detected, asking for '{question_key}'.")
                 return {
                     "success": True,
-                    "follow_question": "start_date",
+                    "follow_question": question_key,
                     "data": body.data,
-                    "question": random.choice(questions["travel"]["start_date"]),
+                    "question": random.choice(questions["travel"][question_key]),
                 }
 
-            elif body.follow_question == "start_date":
-                body.data["date"] = body.query
-                print(f"Updated body.data after start_date: {body.data}")
+            # Case 2: Sequentially ask for missing fields
+            else:
+                print(f"Debug: Processing follow-up question for '{body.follow_question}'.")
+                if body.follow_question == "origin":
+                    origin_response = get_country_code(query=body.query)
+                    if origin_response:
+                        body.data["origin_skyid"] = origin_response[0]["skyId"]
+                        body.data["origin_entityid"] = origin_response[0]["entityId"]
+                    else:
+                        return {"success": False, "message": "Unable to retrieve origin information."}
 
-                # decrement a token from "ai_gpt" attribute of user document
-                mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
+                elif body.follow_question == "destination":
+                    destination_response = get_country_code(query=body.query)
+                    if destination_response:
+                        body.data["destination_skyid"] = destination_response[0]["skyId"]
+                        body.data["destination_entityid"] = destination_response[0]["entityId"]
+                    else:
+                        return {"success": False, "message": "Unable to retrieve destination information."}
 
+                elif body.follow_question == "date":
+                    date_response = parse_date(body.query)
+                    if date_response:
+                        body.data["date"] = date_response
+                    else:
+                        return {"success": False, "message": "Invalid date format. Please provide a valid date."}
+
+                elif body.follow_question == "people":
+                    try:
+                        # Handle cases where the query explicitly indicates a single person
+                        if body.query.strip().lower() in {"just me", "only me", "me only", "myself", "only I", "simply me", "it's me alone", "none but me", "me and no one else", "me exclusively", "solely me", "just myself", "no one but me", "only myself", "exclusively me", "me alone", "it's just me", "i am by myself", "I am alone", "by myself", "on my own", "all by myself"}:
+                            body.data["adults"] = 1
+                        else:
+                            # Extract the number of people using regex
+                            people_pattern = r"(\d+)\s*(?:people|adult|adults|passengers|travelers|travellers|companions)?"
+                            people_match = re.search(people_pattern, body.query.strip(), re.IGNORECASE)
+
+                            if people_match:
+                                body.data["adults"] = int(people_match.group(1))
+                            else:
+                                return {"success": False, "message": "Please provide a valid number of people."}
+
+                        # Validate the number of people
+                        if body.data["adults"] <= 0 or body.data["adults"] > 8:
+                            return {"success": False, "message": "Please provide a valid number of people (1-8)."}
+                    except ValueError:
+                        return {"success": False, "message": "Invalid input for the number of people."}
+
+
+                print(f"Debug: Updated body.data after processing follow-up question: {body.data}")
+
+                # Check if all fields are now filled
+                missing_fields = get_missing_fields(body.data)
+                print(f"Debug: Missing fields: {missing_fields}")
+                if not missing_fields:
+                    # All fields are present; fetch travel listings
+                    travel_listings = get_travel_listing(
+                        originSkyId=body.data["origin_skyid"],
+                        destinationSkyId=body.data["destination_skyid"],
+                        originEntityId=body.data.get("origin_entityid"),
+                        destinationEntityId=body.data.get("destination_entityid"),
+                        date=body.data["date"],
+                        adults=body.data["adults"],
+                    )
+                    print("Debug: Travel Listings Response:", travel_listings)
+                    if not travel_listings or "error" in travel_listings:
+                        return {"success": False, "message": "Unable to fetch travel listings."}
+                    return {"success": True, "suggestions": travel_listings}
+
+                # Ask for the next missing field
+                next_field = missing_fields[0]
+                question_key = field_to_question_key[next_field]
+                print(f"Debug: Missing field detected, asking for '{question_key}'.")
                 return {
                     "success": True,
-                    "follow_question": "people",
+                    "follow_question": question_key,
                     "data": body.data,
-                    "question": random.choice(questions["travel"]["people"]),
+                    "question": random.choice(questions["travel"][question_key]),
                 }
 
-            elif body.follow_question == "people":
-                try:
-                    if not body.query:
-                        body.data["adults"] = 1
-                    else:
-                        body.data["adults"] = int(body.query)
-                        if body.data["adults"] <= 0:
-                            return {"success": False, "message": "Please provide a valid number of adults greater than 0."}
-                        if body.data["adults"] > 8:
-                            return {"success": False, "message": "Please provide a count of people less than or equal to 8."}
-                except ValueError:
-                    return {"success": False, "message": "Please provide a valid number of adults."}
-
-                print(f"Updated body.data after people: {body.data}")
-
-                missing_keys = [
-                    key for key in ["origin_skyid", "destination_skyid", "origin_entityid", "destination_entityid", "date"]
-                    if not body.data.get(key)
-                ]
-                if missing_keys:
-                    return {"success": False, "message": f"Missing required data: {', '.join(missing_keys)}"}
-
-                travel_listings = get_travel_listing(
-                    originSkyId=body.data["origin_skyid"],
-                    destinationSkyId=body.data["destination_skyid"],
-                    originEntityId=body.data["origin_entityid"],
-                    destinationEntityId=body.data["destination_entityid"],
-                    date=body.data["date"],
-                    adults=body.data["adults"],
-                )
-
-                if not travel_listings or "error" in travel_listings:
-                    return {"success": False, "message": "Unable to fetch travel listings."}
-                
-                # decrement a token from "ai_gpt" attribute of user document
-                mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_gpt": -1}})
-
-                return {"success": True, "suggestions": travel_listings}
-
         elif body.command == "/image":
-            user = request.state.user
             prompt = body.query.strip()
-            # url = texttoimage(prompt)
-            # if not url:
-            #     return {"success": False, "message": "Unable to generate an image. Please try again."}
-            
-            # decrement a token from "ai_image" attribute of user document
+            url = texttoimage(prompt)
+            if not url:
+                return {"success": False, "message": "Unable to generate an image. Please try again."}
             mongo_util.get_collection("users").update_one({"_id": ObjectId(user["_id"])},{"$inc": {"ai_image": -1}})
-            # return {"success": True, "url": url}
-            return {"success": True}
+            return {"success": True, "url": url}
 
         elif body.command == "/trip":
             body.data = body.data or {}
-            print(f"Initial body.data: {body.data}")
+            print(f"Debug: Initial body.data: {body.data}")
+
+            required_fields = ["destination", "days"]
 
+            def get_missing_fields(data):
+                return [field for field in required_fields if not data.get(field)]
+
+            # Case 1: Process the first query
             if body.follow_question == "":
-                return {
-                    "success": True,
-                    "follow_question": "destination",
-                    "data": body.data,
-                    "question": random.choice(questions["trip"]["destination"]),
-                }
+                print("Debug: Processing first query with extract_sentence.")
+                result = extract_sentence(body.query, user)
 
-            elif body.follow_question == "destination":
-                body.data["destination"] = body.query.strip()
-                if not body.data["destination"]:
-                    return {"success": False, "message": "Please provide a valid destination."}
+                if not isinstance(result, dict):
+                    print("Error: extract_sentence returned an invalid result.")
+                    return {"success": False, "message": "Internal error occurred during processing."}
 
-                print(f"Updated body.data after destination: {body.data}")
+                print("Debug: Extract Sentence Result:", result)
 
-                return {
-                    "success": True,
-                    "follow_question": "days",
-                    "data": body.data,
-                    "question": random.choice(questions["trip"]["days"]),
-                }   
+                if result.get("destination"):
+                    body.data["destination"] = result["destination"]
 
-            elif body.follow_question == "days":
-                try:
-                    days = int(body.query.strip())
-                    if days <= 0:
-                        return {"success": False, "message": "Please provide a positive number of days for the trip."}
+                if result.get("num_days"):
+                    body.data["days"] = result["num_days"]
 
-                    body.data["days"] = days
-                except ValueError:
-                    return {"success": False, "message": "Please provide a valid number of days."}
+                print(f"Debug: Updated body.data after setting extracted fields: {body.data}")
 
-                print(f"Updated body.data after days: {body.data}")
-                trip_plans = get_trip_planner(days=body.data["days"], destination=body.data["destination"])
+                missing_fields = get_missing_fields(body.data)
+                if not missing_fields:
+                    trip_plans = get_trip_planner(
+                        days=body.data["days"],
+                        destination=body.data["destination"]
+                    )
+                    print("Debug: Trip Plans Response:", trip_plans)
+                    if not trip_plans:
+                        return {"success": False, "message": "Unable to fetch trip plans."}
+                    return {"success": True, "trip_plans": trip_plans, "message": "Here are your trip plans!"}
 
-                if not trip_plans:
-                    return {"success": False, "message": "Unable to fetch trip plans. Please try again later."}
+                next_field = missing_fields[0]
+                print(f"Debug: Missing field detected, asking for '{next_field}'.")
+                return {
+                    "success": True,
+                    "follow_question": next_field,
+                    "data": body.data,
+                    "question": random.choice(questions["trip"][next_field]),
+                }
 
+            # Case 2: Sequentially ask for missing fields
+            else:
+                print(f"Debug: Processing follow-up question for '{body.follow_question}'.")
+                if body.follow_question == "destination":
+                    body.data["destination"] = body.query.strip()
+                    if not body.data["destination"]:
+                        return {"success": False, "message": "Please provide a valid destination."}
+
+                elif body.follow_question == "days":
+                    try:
+                        # Extract the number of days using regex
+                        days_pattern = r"(\d+)(?:\s+(?:days|day))?"
+                        days_match = re.search(days_pattern, body.query.strip(), re.IGNORECASE)
+
+                        if days_match:
+                            body.data["days"] = int(days_match.group(1))
+                        else:
+                            return {"success": False, "message": "Please provide a valid number of days."}
+
+                        if body.data["days"] <= 0:
+                            return {"success": False, "message": "Please provide a positive number of days for the trip."}
+                    except ValueError:
+                        return {"success": False, "message": "Please provide a valid number of days."}
+
+                print(f"Debug: Updated body.data after processing follow-up question: {body.data}")
+
+                missing_fields = get_missing_fields(body.data)
+                if not missing_fields:
+                    trip_plans = get_trip_planner(
+                        days=body.data["days"],
+                        destination=body.data["destination"]
+                    )
+                    print("Debug: Trip Plans Response:", trip_plans)
+                    if not trip_plans:
+                        return {"success": False, "message": "Unable to fetch trip plans."}
+                    return {"success": True, "trip_plans": trip_plans, "message": "Here are your trip plans!"}
+
+                next_field = missing_fields[0]
+                print(f"Debug: Missing field detected, asking for '{next_field}'.")
                 return {
                     "success": True,
-                    "trip_plans": trip_plans,
-                    "message": "Here are your trip plans!"
+                    "follow_question": next_field,
+                    "data": body.data,
+                    "question": random.choice(questions["trip"][next_field]),
                 }
             
-        if body.command == "/job":
+        elif body.command == "/job":
             body.data = body.data or {}
             print(f"Initial body.data: {body.data}")
 
@@ -437,7 +578,6 @@ async def query(body: Command, request: Request):
         return {"success": False, "error": str(e)}
 
 
-
 # @app.post("/api/commands/query")
 # async def query(body: Command):