fixed llm issues with response

api/models/requests.py

@@ -1,6 +1,6 @@
 # api/models/requests.py
 from pydantic import BaseModel
-from typing import List
+from typing import List,Dict, Optional
 
 class BaseRequest(BaseModel):
     pass
@@ -13,8 +13,9 @@ class ChatMessage(BaseModel):
 class ChatRequest(BaseModel):
     query: str
     history: List[ChatMessage] = []
+    customer_metadata: Dict = None  # Customer info: name, email, phone, user_id
 
 
-
+class SurveyRequest(BaseModel):
-
+    booking_form_input: Dict
 

api/models/responses.py

@@ -1,8 +1,10 @@
 # api/models/responses.py
 from pydantic import BaseModel
-
+from typing import Dict
-
 class ChatResponse(BaseModel):
     status: str
-    message: str
+    message: Dict
    
+class SurveyAgentResponse(BaseModel):
+    status: str
+    result: Dict

api/routes/chat.py

@@ -1,35 +1,80 @@
 # api/routes/chat_ai.py
 
 from fastapi import APIRouter, Depends, HTTPException
-from api.models.requests import ChatRequest, ChatMessage
+from api.models.requests import ChatRequest, ChatMessage,SurveyRequest
-from api.models.responses import ChatResponse
+from api.models.responses import ChatResponse,SurveyAgentResponse
 from api.dependencies.auth import get_api_key
 from src.llm.orchestrator import DroneBot, Message  # Adjust import as needed
-
+from src.llm.agent.flight_assesment import DroneAssessmentAgent
+import json
+from logger import logger
 router = APIRouter(
-    prefix="/chat-ai",
+    prefix="/chat",
     tags=["chat"]
 )
 
-@router.post("", response_model=ChatResponse)
+@router.post("/booking-assistant", response_model=ChatResponse)
 async def chat_ai(
     request: ChatRequest,
     _: str = Depends(get_api_key)
 ):
     """Chat with DroneBot using query and history."""
     try:
+        logger.info(f"Starting chat request with query: {request.query}")
+        logger.info(f"History length: {len(request.history)}")
+        
+        # Extract customer metadata if provided
+        customer_metadata = request.customer_metadata
+        if customer_metadata:
+            logger.info(f"Customer metadata provided: {list(customer_metadata.keys())}")
+        else:
+            logger.info("No customer metadata provided")
+        
         # Convert to internal Message format
         history = [Message(role=msg.role, content=msg.content) for msg in request.history]
+        logger.info(f"Converted history to internal format: {len(history)} messages")
         
-        # Initialize DroneBot with history
+        # Initialize DroneBot with history and customer metadata
-        bot = DroneBot(history=history, use_openai_as_fallback=True)
+        logger.info("Initializing DroneBot...")
+        logger.info(f"History: {history}")
+        bot = DroneBot(history=history, use_openai_as_fallback=True, customer_metadata=customer_metadata)
+        logger.info("DroneBot initialized successfully")
+        
+        # Get response from DroneBot
+        logger.info("Calling DroneBot.chat()...")
+        result = await bot.chat(request.query)
+        logger.info(f"DroneBot response received: {result}")
         
-        # Get response
-        result = bot.chat(request.query)
         
         return ChatResponse(
             status="success",
-            message=result["final_message"]
+            message=result              
+        )
+    except HTTPException:
+        logger.error("Re-raising HTTPException")
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error in chat_ai: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )
+
+
+@router.post("/analyse-survey", response_model=SurveyAgentResponse)
+async def run_survey_agent(
+    request: SurveyRequest,
+    _: str = Depends(get_api_key)
+):
+    """Chat with DroneBot using query and history."""
+    try:
+        booking_form_input = request.booking_form_input
+        #from test2 import booking_form_input
+        agent = DroneAssessmentAgent()
+        result = await agent.run(booking_form_input)
+        return SurveyAgentResponse(
+            status="success",
+            result=result
         )
     except Exception as e:
         raise HTTPException(

config.py

@@ -12,4 +12,5 @@ load_dotenv(override=True)
 class Config:
     OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
     API_KEY = os.getenv("API_KEY")
-    
+    OPENWEATHERMAP_API_KEY = os.getenv("OPENWEATHERMAP_API_KEY")
+    BACKEND_BASE_URL = os.getenv("BACKEND_BASE_URL", "https://baas.mytechpassport.com")

logger.py

@@ -0,0 +1,55 @@
+import logging
+from logging.handlers import RotatingFileHandler
+import os
+
+def setup_logger(
+    name: str = "dronebot_logger",
+    log_file: str = "logs/app.log",
+    level: int = logging.DEBUG,
+    max_bytes: int = 5 * 1024 * 1024,  # 5 MB
+    backup_count: int = 3
+) -> logging.Logger:
+    """
+    Set up a logger that logs to both console and file.
+
+    Args:
+        name (str): Logger name
+        log_file (str): Path to log file
+        level (int): Logging level (e.g., logging.INFO, logging.DEBUG)
+        max_bytes (int): Max size of each log file before rotation
+        backup_count (int): Number of rotated logs to keep
+
+    Returns:
+        logging.Logger: Configured logger instance
+    """
+
+    # Ensure log directory exists
+    os.makedirs(os.path.dirname(log_file), exist_ok=True)
+
+    # Create logger
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    logger.propagate = False  # Avoid double logging
+
+    if not logger.handlers:
+        # Formatter
+        formatter = logging.Formatter(
+            "[%(asctime)s] %(levelname)s — %(name)s — %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+
+        # Console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        # Rotating file handler
+        file_handler = RotatingFileHandler(
+            log_file, maxBytes=max_bytes, backupCount=backup_count
+        )
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+logger = setup_logger()

main.py

@@ -37,4 +37,4 @@ async def root():
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=5120) 
+    uvicorn.run(app, host="0.0.0.0", port=5340) 

src/components/data_extraction/weather_data.py

@@ -0,0 +1,245 @@
+import asyncio
+import aiohttp
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Tuple
+import re
+from logger import logger  #
+
+
+class DroneWeatherDataExtractor:
+    """
+    Extract location data from drone booking forms and fetch structured 
+    weather information for later use in analysis systems.
+    """
+
+    def __init__(self):
+        self.base_url = "https://api.open-meteo.com/v1/forecast"
+
+    def extract_coordinates(self, booking_data: Dict) -> Tuple[float, float]:
+        """Extract latitude and longitude from booking form data."""
+        try:
+            gps_coords = booking_data.get("site_information", {}).get("gps_coordinates", {})
+            if isinstance(gps_coords, dict):
+                lat_str = gps_coords.get("latitude", "")
+                lng_str = gps_coords.get("longitude", "")
+
+                lat_match = re.search(r'([\d.]+)', lat_str)
+                lng_match = re.search(r'([\d.]+)', lng_str)
+
+                if lat_match and lng_match:
+                    latitude = float(lat_match.group(1))
+                    longitude = float(lng_match.group(1))
+
+                    if 'S' in lat_str.upper():
+                        latitude = -latitude
+                    if 'W' in lng_str.upper():
+                        longitude = -longitude
+
+                    logger.info(f"Extracted coordinates from GPS: ({latitude}, {longitude})")
+                    return latitude, longitude
+
+            site_location = booking_data.get("form", {}).get("site_location", "")
+            coord_pattern = r'GPS: ([\d.]+)° ([NS]), ([\d.]+)° ([EW])'
+            match = re.search(coord_pattern, site_location)
+
+            if match:
+                lat, lat_dir, lng, lng_dir = match.groups()
+                latitude = float(lat) if lat_dir == 'N' else -float(lat)
+                longitude = float(lng) if lng_dir == 'E' else -float(lng)
+                logger.info(f"Extracted coordinates from fallback: ({latitude}, {longitude})")
+                return latitude, longitude
+
+        except (ValueError, KeyError) as e:
+            logger.error(f"Error extracting coordinates: {e}")
+
+        raise ValueError("Could not extract valid coordinates from booking data")
+
+    def extract_booking_info(self, booking_data: Dict) -> Dict:
+        """Extract relevant booking information in structured format."""
+        try:
+            job_overview = booking_data.get("job_overview", {})
+            timing = booking_data.get("timing", {})
+            site_info = booking_data.get("site_information", {})
+            form_info = booking_data.get("form", {})
+
+            info = {
+                "job_id": booking_data.get("job_id"),
+                "job_number": job_overview.get("job_number"),
+                "site_name": site_info.get("site_name"),
+                "region": site_info.get("region"),
+                "full_address": site_info.get("full_address"),
+                "asset_type": form_info.get("asset_type"),
+                "system_size": form_info.get("system_size"),
+                "survey_purpose": form_info.get("survey_purpose"),
+                "assigned_engineer": form_info.get("assigned_engineer"),
+                "contact_person": form_info.get("contact_person"),
+                "contact_phone": form_info.get("contact_phone"),
+                "dates": {
+                    "assigned_date": job_overview.get("assigned_date"),
+                    "preferred_dates": form_info.get("preferred_dates"),
+                    "selected_slot": form_info.get("selected_slot")
+                },
+                "timing": {
+                    "start_time": timing.get("start_time"),
+                    "end_time": timing.get("end_time"),
+                    "duration": timing.get("survey_duration"),
+                    "buffer_time": timing.get("buffer_time")
+                },
+                "access_details": {
+                    "access_type": form_info.get("access_type"),
+                    "vehicle_access": form_info.get("vehicle_access"),
+                    "access_details": form_info.get("access_details")
+                },
+                "safety_requirements": form_info.get("special_safety_requirements"),
+                "additional_requirements": form_info.get("additional_requirements"),
+                "booking_timestamp": form_info.get("booking_timestamp"),
+                "booking_id": form_info.get("booking_id")
+            }
+            logger.debug(f"Extracted booking info: {info}")
+            return info
+        except Exception as e:
+            logger.error(f"Error extracting booking info: {e}")
+            return {}
+
+    def parse_target_date(self, booking_data: Dict) -> datetime:
+        """Extract and parse the target date from booking data."""
+        try:
+            date_fields = [
+                booking_data.get("job_overview", {}).get("assigned_date"),
+                booking_data.get("form", {}).get("preferred_dates"),
+                booking_data.get("form", {}).get("selected_slot")
+            ]
+
+            for date_field in date_fields:
+                if not date_field:
+                    continue
+                if "January 23" in date_field:
+                    return datetime(2025, 1, 23)
+                elif "January 24" in date_field:
+                    return datetime(2025, 1, 24)
+
+            logger.warning("Using fallback date")
+            return datetime.now() + timedelta(days=1)
+        except Exception as e:
+            logger.error(f"Error parsing date: {e}")
+            return datetime.now() + timedelta(days=1)
+
+    async def fetch_weather_data(self, latitude: float, longitude: float,
+                                 target_date: datetime, days_range: int = 3) -> Dict:
+        """Fetch structured weather data for specific coordinates and date range."""
+        start_date = target_date - timedelta(days=days_range // 2)
+        end_date = target_date + timedelta(days=days_range // 2)
+
+        params = {
+            "latitude": latitude,
+            "longitude": longitude,
+            "current": "temperature_2m,relative_humidity_2m,wind_speed_10m",
+            "hourly": "temperature_2m,relative_humidity_2m"
+        }
+
+        logger.info(f"Requesting weather data for {latitude}, {longitude} from {start_date.date()} to {end_date.date()}")
+        async with aiohttp.ClientSession() as session:
+            async with session.get(self.base_url, params=params) as response:
+                if response.status == 200:
+                    logger.info("Weather data fetched successfully.")
+                    return await response.json()
+                else:
+                    error_msg = f"Weather API request failed: {response.status}"
+                    logger.error(error_msg)
+                    raise Exception(error_msg)
+
+    def structure_weather_data(self, raw_weather: Dict, target_date: datetime) -> Dict:
+        """Structure raw weather data into organized format."""
+        try:
+            structured_data = {
+                "location": {
+                    "latitude": raw_weather.get("latitude"),
+                    "longitude": raw_weather.get("longitude"),
+                    "elevation": raw_weather.get("elevation"),
+                    "timezone": raw_weather.get("timezone")
+                },
+                "current_conditions": raw_weather.get("current", {}),
+                "hourly_forecast": raw_weather.get("hourly", {}),
+                "daily_forecast": raw_weather.get("daily", {}),
+                "target_date": target_date.strftime("%Y-%m-%d"),
+                "data_retrieved_at": datetime.now().isoformat()
+            }
+            logger.debug("Structured weather data successfully.")
+            return structured_data
+        except Exception as e:
+            logger.error(f"Error structuring weather data: {e}")
+            return {"error": f"Error structuring weather data: {e}"}
+
+    async def extract_booking_weather_data(self, booking_data: Dict) -> Dict:
+        """Main extraction function - returns structured data for external use."""
+        try:
+            logger.info(f"Starting extraction for job_id={booking_data.get('job_id')}")
+            booking_info = self.extract_booking_info(booking_data)
+            latitude, longitude = self.extract_coordinates(booking_data)
+            target_date = self.parse_target_date(booking_data)
+            raw_weather = await self.fetch_weather_data(latitude, longitude, target_date)
+            structured_weather = self.structure_weather_data(raw_weather, target_date)
+
+            logger.info(f"Completed extraction for job_id={booking_data.get('job_id')}")
+            return {
+                "weather_data": structured_weather,
+                "extraction_metadata": {
+                    "processed_at": datetime.now().isoformat(),
+                    "api_endpoint": self.base_url,
+                    "data_source": "open-meteo"
+                }
+            }
+        except Exception as e:
+            logger.exception(f"Data extraction failed for job_id={booking_data.get('job_id', 'unknown')}")
+            return {
+                "error": f"Data extraction failed: {e}",
+                "job_id": booking_data.get("job_id", "unknown"),
+                "processed_at": datetime.now().isoformat()
+            }
+
+
+# Example usage
+async def main():
+    logger.info("Demo started.")
+    booking_form_input = {
+        "job_id": "1043",
+        "job_overview": {
+            "job_number": "Job #1043",
+            "site_name": "Hightower Solar Farm",
+            "assigned_date": "January 23, 2025",
+            "status": "Scheduled"
+        },
+        "site_information": {
+            "site_name": "Hightower Solar Farm",
+            "region": "North England",
+            "full_address": "Grange Lane, Manchester M34 7TF",
+            "gps_coordinates": {
+                "latitude": "13.41° N",
+                "longitude": "52.52 W"
+            }
+        },
+        "timing": {
+            "start_time": "09:00 AM",
+            "end_time": "10:30 AM",
+            "survey_duration": "30–45 mins",
+            "buffer_time": "45 mins"
+        },
+        "form": {
+            "asset_type": "Solar Farm",
+            "system_size": "5.2 MW capacity, approximately 16,000 panels across 12 hectares",
+            "survey_purpose": "Insurance assessment",
+            "assigned_engineer": "David Wilson - 0161-555-0876",
+            "contact_person": "Sarah Thompson",
+            "contact_phone": "0161-555-0234"
+        }
+    }
+
+    extractor = DroneWeatherDataExtractor()
+    result = await extractor.extract_booking_weather_data(booking_form_input)
+    logger.info("Extraction result:")
+    logger.info(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/config/llm_config.py

@@ -3,6 +3,7 @@ class LlmConfig:
         class models:
             gpt_4o = "gpt-4o"
             gpt_4_1 = "gpt-4.1"
+            gpt_5_mini = "gpt-5-mini"
 
         temperatures = {
             "default": 0.7,

src/llm/agent/flight_assesment.py

@@ -0,0 +1,90 @@
+import os
+import json
+import asyncio
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+from src.prompts.templates.flght_prompt import flight_prompt
+from src.config.llm_config import LlmConfig
+from config import Config
+from src.components.data_extraction.weather_data import DroneWeatherDataExtractor
+from logger import logger 
+
+
+class DroneAssessmentAgent:
+    def __init__(self):
+        self.llm = ChatOpenAI(
+            api_key=Config.OPENAI_API_KEY,
+            model=LlmConfig.openai.models.gpt_4o,
+            temperature=0.3
+        )
+        self.weather_extractor = DroneWeatherDataExtractor()
+
+    async def run(self, booking_form: str) -> dict:
+        """
+        Run the drone environmental & safety assessment agent.
+
+        Args:
+            booking_form (str): Structured booking form input
+
+        Returns:
+            dict: AI-generated structured output
+        """
+        logger.info("Starting DroneAssessmentAgent run...")
+
+        try:
+            # Step 1: Fetch weather data
+            weather_data = await self.weather_extractor.extract_booking_weather_data(booking_form)
+            booking_form_text = json.dumps(booking_form)
+
+            # Step 2: Generate prompt
+            prompt = flight_prompt(booking_form_text, weather_data)
+            messages = [
+                SystemMessage(content=prompt),
+                HumanMessage(content=booking_form_text)
+            ]
+
+            # Step 3: Invoke LLM
+            logger.debug("Sending prompt to LLM...")
+            response = self.llm.invoke(messages)
+
+            if hasattr(response, "content"):
+                response_text = response.content.strip()
+                logger.info("Received LLM response.")
+                logger.debug(f"LLM Raw Output (first 300 chars):\n{response_text[:300]}")
+
+                # Extract JSON block
+                start_idx = response_text.find('{')
+                end_idx = response_text.rfind('}') + 1
+
+                if start_idx == -1 or end_idx == -1:
+                    raise ValueError("No JSON object found in output")
+
+                json_str = response_text[start_idx:end_idx]
+                return json.loads(json_str)
+
+            else:
+                raise ValueError("LLM returned no usable content")
+
+        except Exception as e:
+            logger.exception("Error in DroneAssessmentAgent")
+            return {
+                "error": str(e),
+                "raw_response": response.content if 'response' in locals() and hasattr(response, "content") else None
+            }
+
+
+async def main():
+    """Async main function to test the drone assessment agent."""
+    from test2 import booking_form_input
+
+    logger.info("Launching DroneAssessmentAgent from main()...")
+    agent = DroneAssessmentAgent()
+    result = await agent.run(booking_form_input)
+
+    logger.info("Drone assessment completed.")
+    logger.debug("Final structured output:")
+    logger.debug(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/llm/agent/structured_output.py

@@ -0,0 +1,110 @@
+import os
+import json
+import asyncio
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+from typing import List, Optional, Dict, Any
+from typing_extensions import TypedDict, Annotated
+from src.config.llm_config import LlmConfig
+from config import Config
+from logger import logger 
+
+
+class DroneAssessmentResponse(TypedDict):
+    """Structured response for drone assessment that matches the chat template format"""
+    message: Annotated[str, "The main response message about the drone assessment from ai"]
+    options: Annotated[Optional[List[str]], None, "List of options for user selection from ai"]
+    requires_selection: Annotated[bool, False, "Whether the user needs to make a selection from ai"]
+    end: Annotated[str, "in_progress", "The current state: 'in_progress', 'complete', 'cancelled', or other status"]
+    form: Annotated[Dict[str, str], {}, "Form data with assessment results as string key-value pairs"]
+
+
+class structureOuputTool:
+    def __init__(self):
+        self.llm = ChatOpenAI(
+            api_key=Config.OPENAI_API_KEY,
+            model=LlmConfig.openai.models.gpt_4o,
+            temperature=0.3
+        )
+        # Create structured output LLM
+        self.structured_llm = self.llm.with_structured_output(DroneAssessmentResponse)
+
+    def create_assessment_prompt(self, response: dict) -> str:
+        """Create a prompt to convert AI response to structured output"""
+        prompt = f"""
+Your task is to analyze the response from AI and return the structured output in the format provided.
+
+RESPONSE FROM AI:
+{response}
+
+IMPORTANT: Copy the exact values from the response. Do not fabricate or add anything.
+- If message is empty, return empty string
+- If options is empty, return empty list []
+- If form is empty, return empty dict {{}}
+- If requires_selection is empty, return False
+- If end is empty, return "in_progress"
+
+Just convert to structured format - no additional content.
+"""
+        return prompt
+
+    def run(self, booking_form: dict) -> dict:
+        """
+        Convert booking form data to structured assessment response.
+
+        Args:
+            booking_form (dict): Structured booking form input
+
+        Returns:
+            dict: AI-generated structured output
+        """
+        logger.info("Starting DroneAssessmentAgent run...")
+
+        try:
+            # Generate assessment prompt
+            prompt = self.create_assessment_prompt(booking_form)
+            messages = [
+                SystemMessage(content=prompt),
+                HumanMessage(content="Please convert this booking form data into a structured assessment response.")
+            ]
+
+            # Invoke structured LLM
+            logger.debug("Sending prompt to structured LLM...")
+            response = self.structured_llm.invoke(messages)
+
+            # TypedDict response is already a dict, no need to convert
+            result = response
+            logger.info("Received structured LLM response")
+            logger.debug(f"Structured output: {json.dumps(result, indent=2)}")
+
+            return result
+
+        except Exception as e:
+            logger.exception("Error in DroneAssessmentAgent")
+            return {
+                "message": "Error occurred during assessment",
+                "options": ["Try again", "Contact support"],
+                "requires_selection": True,
+                "end": "error",
+                "form": {
+                    "error": str(e),
+                    "assessment_status": "failed"
+                }
+            }
+
+
+async def main():
+    """Async main function to test the drone assessment agent."""
+    from test2 import booking_form_input
+
+    logger.info("Launching DroneAssessmentAgent from main()...")
+    agent = DroneAssessmentAgent()
+    result = await agent.run(booking_form_input)
+
+    logger.info("Drone assessment completed")
+    logger.debug("Final structured output:")
+    logger.debug(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/llm/orchestrator.py

@@ -16,7 +16,7 @@ from src.prompts.setup_prompt import setup_prompt_manager
 from src.config.llm_config import LlmConfig
 from src.llm.tools import AgenTools
 from config import Config
-
+from src.llm.agent.structured_output import structureOuputTool
 prompt_manager = setup_prompt_manager()
 
 
@@ -43,12 +43,12 @@ class ModelRotationManager:
         # Add OpenAI models if enabled
         if use_openai_as_fallback:
             openai_models = [
-                {
+                # {
-                    "name": LlmConfig.openai.models.gpt_4o,
+                #     "name": LlmConfig.openai.models.gpt_5_mini,
-                    "provider": "openai",
+                #     "provider": "openai",
-                    "api_key": Config.OPENAI_API_KEY,
+                #     "api_key": Config.OPENAI_API_KEY,
-                    "temperature": LlmConfig.openai.temperatures.get("drone_bot")
+                #     "temperature": LlmConfig.openai.temperatures.get("drone_bot")
-                },
+                # },
                 {
                     "name": LlmConfig.openai.models.gpt_4_1,
                     "provider": "openai",
@@ -133,16 +133,18 @@ class State(TypedDict):
 
 
 class DroneBot:
-    def __init__(self, history: Optional[List[Message]] = None, use_openai_as_fallback: bool = True):
+    def __init__(self, history: Optional[List[Message]] = None, use_openai_as_fallback: bool = True, customer_metadata: Optional[Dict] = None):
         """
         Initialize DroneBot - a simplified plotting agent
         
         Args:
             history: Optional conversation history
             use_openai_as_fallback: Whether to include OpenAI models as fallback
+            customer_metadata: Optional customer information (name, email, phone, user_id)
         """
         self.history = history if history is not None else []
         self.use_openai_as_fallback = use_openai_as_fallback
+        self.customer_metadata = customer_metadata
         
         # Initialize model rotation manager
         self.model_manager = ModelRotationManager(use_openai_as_fallback=use_openai_as_fallback)
@@ -150,12 +152,21 @@ class DroneBot:
         # Initialize output variables
         self.final_message = ""
         self.final_model_used = ""
+        self.structured_result = None
         
         # Create tools
         self.tools = self._create_tools()
         
+        # Initialize prompt manager with customer metadata
+        self.prompt_manager = setup_prompt_manager(customer_metadata)
+        self.structure_agent = structureOuputTool()
+        
         print(f"DroneBot initialized")
         print(f"OpenAI fallback: {'Enabled' if use_openai_as_fallback else 'Disabled'}")
+        if customer_metadata:
+            print(f"Customer metadata provided: {list(customer_metadata.keys())}")
+        else:
+            print("No customer metadata provided")
 
     def _create_tools(self):
         """define tools for agent"""
@@ -169,17 +180,35 @@ class DroneBot:
         try:
             # Case 1: Response has direct string content
             if hasattr(response, 'content') and isinstance(response.content, str) and response.content.strip():
-                return response.content.strip()
+                content = response.content.strip()
+                
+                # Check if the content is valid JSON
+                try:
+                    json_content = json.loads(content)
+                    # If it's valid JSON, return the message field or the entire JSON
+                    if isinstance(json_content, dict) and "message" in json_content:
+                        return content  # Return the full JSON string
+                    else:
+                        return content  # Return the JSON string even if no message field
+                except json.JSONDecodeError:
+                    # Not JSON, return as plain text
+                    return content
             
             # Case 2: Response has list content (complex format)
             elif hasattr(response, 'content') and isinstance(response.content, list):
                 for item in response.content:
                     if isinstance(item, dict) and item.get('type') == 'text' and item.get('text'):
-                        return item['text'].strip()
+                        text_content = item['text'].strip()
+                        # Check if it's JSON
+                        try:
+                            json.loads(text_content)
+                            return text_content  # Return JSON string
+                        except json.JSONDecodeError:
+                            return text_content  # Return plain text
             
             # Case 3: Response only has tool calls, no text content
             elif hasattr(response, 'tool_calls') and response.tool_calls:
-                return "Generating your visualization..."
+                return "Calling tool..."
             
             # Case 4: Empty or None content
             else:
@@ -219,7 +248,7 @@ class DroneBot:
                     
                     # Add system message if not present
                     if not messages or not isinstance(messages[0], SystemMessage):
-                        system_prompt = prompt_manager.get_prompt("booking")
+                        system_prompt = self.prompt_manager.get_prompt("booking")
                         messages = [SystemMessage(content=system_prompt)] + messages
                     
                     print(f"DroneBot input messages: {len(messages)}")
@@ -228,13 +257,35 @@ class DroneBot:
                     response = llm_with_tools.invoke(messages)
                     
                     print(f"DroneBot response: {type(response).__name__}")
+                    print(f"Response content type: {type(response.content)}")
+                    print(f"Response content: {response.content}")
                     if hasattr(response, 'tool_calls'):
                         print(f"  Tool calls: {len(response.tool_calls) if response.tool_calls else 0}")
                     
                     # Extract and store the final message content
                     final_message_content = self._extract_final_message_content(response)
+                    print(f"Extracted final message: {final_message_content}")
                     self.final_message = final_message_content
                     
+                    # Try to parse as JSON first, if it fails, use structured agent
+                    try:
+                        json.loads(final_message_content)
+                        print("Final message is valid JSON, no need for structured agent")
+                    except json.JSONDecodeError:
+                        print("Final message is not valid JSON, calling structured agent")
+                        # Since we can't await here, we'll store the raw message
+                        # The structured processing can happen later if needed
+                        try:
+                            # Try to run synchronously first
+                            structured_result = self.structure_agent.run(self.final_message)
+                            print(f"Structured agent result: {structured_result}")
+                            # Store the structured result separately, keep final_message as string
+                            self.structured_result = structured_result
+                        except Exception as e:
+                            print(f"Error in structured agent (sync): {str(e)}")
+                            # Keep the original message if structured agent fails
+                            pass
+                    
                     # Update state
                     updated_state = {"messages": state["messages"] + [response]}
                     updated_state["current_model"] = current_model_config["name"]
@@ -362,7 +413,7 @@ class DroneBot:
                 langchain_messages.append(AIMessage(content=msg.content))
         return langchain_messages
 
-    def chat(self, user_query: str) -> Dict[str, Any]:
+    async def chat(self, user_query: str) -> Dict[str, Any]:
         """Main method to interact with DroneBot"""
         print(f"DroneBot processing query: {user_query}")
         
@@ -401,29 +452,55 @@ class DroneBot:
                         break
                 
                 if not self.final_message:
-                    self.final_message = "I've processed your visualization request."
+                    self.final_message = "...."
 
-            final_response = {
+            # Check if we already have a structured result from the workflow
-                "messages": output.get("messages", []),
+            if self.structured_result is not None:
-                "final_message": self.final_message,
+                print("Using pre-computed structured result from workflow")
-                "final_model_used": self.final_model_used or output.get("current_model", "unknown"),
+                structured_message = self.structured_result
-                "user_question": user_query
+            else:
+                # Try to parse final_message as JSON, if it fails, use structured agent
+                try:
+                    structured_message = json.loads(self.final_message)
+                    print("Final message is valid JSON, no structured agent needed")
+                except json.JSONDecodeError:
+                    print("Final message is not valid JSON, calling structured agent")
+                    try:
+                        # Now we can properly await the async function
+                        structured_result = await self.structure_agent.run(self.final_message)
+                        print(f"Structured agent result: {structured_result}")
+                        # Assign the structured result to structured_message
+                        structured_message = structured_result
+                    except Exception as e:
+                        print(f"Error in structured agent: {str(e)}")
+                        structured_message = {
+                            "message": "Sorry i encountered an error while processing your request. Please try again.",
+                            "options": [],
+                            "requires_selection": False,
+                            "end": "error",
+                            "form": {}
                         }
 
-            print(f"Final message: {self.final_message[:100]}...")
+            # final_response = {
-            return final_response
+            #     "messages": output.get("messages", []),
+            #     "final_message": structured_message,
+            #     "final_model_used": self.final_model_used or output.get("current_model", "unknown"),
+            #     "user_question": user_query
+            # }
+
+            #print(f"Final message: {self.final_message[:100]}...")
+            return structured_message
             
         except Exception as e:
             print(f"Error in DroneBot workflow execution: {str(e)}")
             return {
-                "messages": [],
+            "message": "Sorry i encountered an error while processing your request. Please try again.",
-                "final_message": "Sorry, I encountered an error while processing your visualization request. Please try again.",
+            "options": [],
-                "final_model_used": "error",
+            "requires_selection": False,
-                "user_question": user_query,
+            "end": "error",
-                "error": str(e)
+            "form": {}
         }
 
-
 # Example usage
 if __name__ == "__main__":
     # Example conversation history
@@ -434,13 +511,21 @@ if __name__ == "__main__":
     
     history = [Message(role=msg["role"], content=msg["content"]) for msg in history_list]
 
+    # Example customer metadata
+    customer_metadata = {
+        "customer_name": "John Doe",
+        "customer_email": "john.doe@example.com",
+        "customer_phone": "+1-555-0123",
+        "user_id": "12345"
+    }
     
-    # Initialize DroneBot
+    # Initialize DroneBot with customer metadata
-    bot = DroneBot(history=history, use_openai_as_fallback=True)
+    bot = DroneBot(history=history, use_openai_as_fallback=True, customer_metadata=customer_metadata)
     
     query = "Can we start"
     # Chat with DroneBot
-    response = bot.chat(query)
+    import asyncio
+    response = asyncio.run(bot.chat(query))
     
     print("Response:", response["final_message"])
     

src/llm/tools/__init__.py

@@ -1,5 +1,5 @@
 from .booking_calendar import get_booking_calendar
-
+from .book_survey import book_survey_for_customer_after_confirmation
 
 class AgenTools:
-    tools = [get_booking_calendar]
+    tools = [get_booking_calendar, book_survey_for_customer_after_confirmation]

src/llm/tools/book_survey.py

@@ -0,0 +1,136 @@
+from typing import Dict, Any
+from langchain_core.tools import tool
+from datetime import datetime
+import requests
+from config import Config
+from logger import logger
+
+
+@tool
+def book_survey_for_customer_after_confirmation(
+    user_id: int,
+    customer_email: str,
+    customer_name: str,
+    customer_phone: str,
+    site_name: str,
+    location: str,
+    region: str,
+    latitude: str,
+    longitude: str,
+    asset_type: str,
+    system_size: str,
+    preferred_date: str,
+    preferred_time: str,
+    duration_minutes: int,
+    is_flexible: bool,
+    contact_name: str,
+    contact_phone: str,
+    access_instructions: str,
+    survey_purpose: str,
+    additional_notes: str = ""
+) -> Dict[str, Any]:
+    """
+    Book a survey appointment for a customer after confirmation.
+    
+    This tool sends a POST request to the Rowan Energy survey booking endpoint
+    to schedule a site survey appointment. It requires all customer details,
+    site information, and survey preferences.
+    
+    Args:
+        user_id: Unique identifier for the user
+        customer_email: Customer's email address
+        customer_name: Customer's full name
+        customer_phone: Customer's phone number
+        site_name: Name or identifier of the site
+        location: Physical address of the site
+        region: Geographic region/state of the site (e.g., Texas)
+        latitude: Latitude coordinate of the site
+        longitude: Longitude coordinate of the site
+        asset_type: Type of asset (e.g., Solar Panel, Wind Turbine)
+        system_size: Size of the system (e.g., 10kW)
+        preferred_date: Preferred survey date (YYYY-MM-DD format)
+        preferred_time: Preferred survey time (HH:MM format)
+        duration_minutes: Expected duration of the survey in minutes
+        is_flexible: Whether the customer is flexible with timing
+        contact_name: Name of the contact person on site
+        contact_phone: Phone number of the contact person
+        access_instructions: Instructions for accessing the site
+        survey_purpose: Purpose of the survey (e.g., Pre-installation assessment)
+        additional_notes: Any additional notes or requirements
+    
+    Returns:
+        Dict containing the booking status and response data
+    """
+    try:
+        # Log the incoming parameters for debugging
+        logger.info(f"Attempting to book survey for customer: {customer_name} ({customer_email})")
+        logger.info(f"Survey details: {asset_type} system, {system_size}, on {preferred_date} at {preferred_time}")
+        logger.info(f"Location: {location}, Region: {region}, Coordinates: {latitude}, {longitude}")
+        
+        # Prepare the payload
+        payload = {
+            "user_id": user_id,
+            "customer_email": customer_email,
+            "customer_name": customer_name,
+            "customer_phone": customer_phone,
+            "site_name": site_name,
+            "location": location,
+            "region": region,
+            "latitude": latitude,
+            "longitude": longitude,
+            "asset_type": asset_type,
+            "system_size": system_size,
+            "preferred_date": preferred_date,
+            "preferred_time": preferred_time,
+            "duration_minutes": duration_minutes,
+            "is_flexible": is_flexible,
+            "contact_name": contact_name,
+            "contact_phone": contact_phone,
+            "access_instructions": access_instructions,
+            "survey_purpose": survey_purpose,
+            "additional_notes": additional_notes
+        }
+        
+        # Log the payload being sent
+        logger.info(f"Sending survey booking request with payload: {payload}")
+        
+        # API endpoint for survey booking
+        api_url = f"{Config.BACKEND_BASE_URL}/v1/api/rowanenergy/public/webhook/job-survey"
+        
+        # Make HTTP POST request to book the survey
+        response = requests.post(api_url, json=payload)
+        response.raise_for_status()  # Raise exception for bad status codes
+        
+        # Parse the response
+        response_data = response.json()
+        
+        # Log successful response
+        logger.info(f"Survey booking successful for {customer_name}. Response: {response_data}")
+        
+        # Return the response data
+        return {
+            "status": "success",
+            "message": "Survey booking completed successfully",
+            "data": response_data,
+            "job_id": response_data.get("job_id"),
+            "generated_at": datetime.utcnow().isoformat() + "Z"
+        }
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request Exception during survey booking: {e}")
+        return {
+            "status": "error",
+            "error": f"Failed to book survey: {str(e)}",
+            "customer_name": customer_name if 'customer_name' in locals() else "Unknown",
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    except Exception as e:
+        logger.error(f"General Exception during survey booking: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "customer_name": customer_name if 'customer_name' in locals() else "Unknown",
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    
+

src/llm/tools/booking_calendar.py

@@ -1,32 +1,51 @@
 from typing import Dict
 from langchain_core.tools import tool
 from datetime import datetime
+import requests
+from config import Config
+from logger import logger
 
 
 @tool
 def get_booking_calendar() -> Dict:
     """
-    Retrieve the current booking calendar data. This could be integrated with a real calendar API.
+    Retrieve the current booking calendar data from Rowan Energy availability API.
     """
     try:
-        # Simulated booking calendar data
+        # API endpoint for Rowan Energy availability
+        api_url = f"{Config.BACKEND_BASE_URL}/v1/api/rowanenergy/public/availability"
+        
+        # Make HTTP request to get availability data
+        response = requests.get(api_url)
+        response.raise_for_status()  # Raise exception for bad status codes
+        
+        # Parse the response
+        availability_data = response.json()
+        
+        # Transform the data to match expected format
         calendar_data = {
             "status": "success",
             "data": {
-                "available_slots": [
+                "availability": availability_data.get("availability", []),
-                    {"date": "2025-07-24", "time": "10:00 AM"},
+                "total_slots": availability_data.get("total_slots", 0),
-                    {"date": "2025-07-24", "time": "2:00 PM"},
-                    {"date": "2025-07-25", "time": "9:30 AM"}
-                ],
-                "timezone": "UTC+1",
                 "generated_at": datetime.utcnow().isoformat() + "Z"
             }
         }
+        
+        logger.info(f"Calendar data retrieved successfully: {calendar_data}")
         return calendar_data
 
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request Exception: {e}")
+        return {
+            "status": "error",
+            "error": f"Failed to fetch availability data: {str(e)}",
+        }
     except Exception as e:
-        print(f"General Exception: {e}")
+        logger.error(f"General Exception: {e}")
         return {
             "status": "error",
             "error": str(e),
         }
+    
+

src/prompts/setup_prompt.py

@@ -2,7 +2,7 @@
 from .manager import PromptManager
 from src.prompts.templates.chat_templates import get_booking_prompt
 
-def setup_prompt_manager():
+def setup_prompt_manager(customer_metadata: dict = None):
     pm = PromptManager()
-    pm.register_prompt("booking", get_booking_prompt)
+    pm.register_prompt("booking", lambda: get_booking_prompt(customer_metadata))
     return pm

src/prompts/templates/chat_templates.py

@@ -1,6 +1,185 @@
-def get_booking_prompt():
+def get_booking_prompt(customer_metadata: dict = None):
 
-    return """
+    # Prepare customer metadata section if provided
+    customer_info_section = ""
+    if customer_metadata:
+        # Build dynamic customer info list from any keys provided
+        customer_info_items = []
+        for key, value in customer_metadata.items():
+            if value:  # Only show non-empty values
+                customer_info_items.append(f"- **{key.replace('_', ' ').title()}**: {value}")
+        
+        if customer_info_items:
+            customer_info_section = f"""
+## CUSTOMER METADATA (PRE-FILLED INFORMATION)
+
+**The following customer information has been provided and should be used when available:**
+{chr(10).join(customer_info_items)}
+
+**IMPORTANT RULES FOR CUSTOMER METADATA:**
+- Use this information when the user doesn't explicitly provide it
+- If user provides different information, use the user's input instead
+- Never assume or guess customer details - only use what's explicitly provided
+- If metadata is missing, ask the user for the information
+- Always verify critical information with the user before proceeding
+
+"""
+
+    return f"""
+
+## CRITICAL INSTRUCTION - YOU MUST FOLLOW THIS EXACTLY
+
+**YOU MUST ALWAYS RESPOND WITH VALID JSON ONLY. NO OTHER TEXT, NO EXPLANATIONS, NO MARKDOWN FORMATTING.**
+
+**EVERY SINGLE RESPONSE MUST BE A VALID JSON OBJECT WITH THIS EXACT STRUCTURE:**
+
+{{
+    "message": "Your conversational response to the user",
+    "options": ["Option 1", "Option 2", "Option 3"] or null,
+    "requires_selection": true/false,
+    "end": "complete" | "in_progress" | "cancelled",
+    "form": {{}}
+}}
+
+**DO NOT ADD ANYTHING BEFORE OR AFTER THE JSON. NO ```json, NO ```, NO EXPLANATIONS.**
+
+{customer_info_section}
+
+## CRITICAL GUARDRAILS & SAFETY MEASURES
+
+**YOU MUST STRICTLY ADHERE TO THESE RULES - NO EXCEPTIONS:**
+
+### 1. PRIMARY PURPOSE STRICT ADHERENCE
+- **ONLY** assist with drone survey booking for renewable energy assets
+- **NEVER** deviate from your core function as a booking assistant
+- **NEVER** provide advice on technical engineering, legal matters, financial advice, or any other topics
+- **NEVER** attempt to diagnose technical problems or provide maintenance advice
+- **NEVER** make recommendations about equipment, suppliers, or technical specifications
+
+### 2. FACTUAL INFORMATION ONLY - NO ASSUMPTIONS
+- **ONLY** work with information explicitly provided by the user
+- **NEVER** make assumptions about user requirements, site conditions, or technical specifications
+- **NEVER** fill in missing information with guesses or default values
+- **NEVER** assume user preferences, timelines, or constraints
+- **ALWAYS** ask for clarification when information is unclear or incomplete
+- **NEVER** proceed with incomplete information - insist on getting complete details
+- **NEVER** ask for information that was already provided earlier in the conversation
+- **ALWAYS** reference and use information already collected from the user
+
+### 3. STRICT BOUNDARIES - WHAT YOU CANNOT DO
+- **NEVER** provide medical, legal, or financial advice
+- **NEVER** make promises about survey outcomes or results
+- **NEVER** guarantee specific dates or engineer availability without checking
+- **NEVER** provide technical specifications or engineering advice
+- **NEVER** make claims about company policies not explicitly stated
+- **NEVER** provide contact information for other departments or services
+- **NEVER** attempt to troubleshoot technical issues or problems
+
+### 4. INFORMATION VALIDATION REQUIREMENTS
+- **ALWAYS** verify critical information before proceeding
+- **ALWAYS** ask for confirmation of important details
+- **NEVER** accept vague or ambiguous responses
+- **ALWAYS** request specific, concrete information
+- **NEVER** proceed with "maybe" or "probably" responses
+- **ALWAYS** collect GPS coordinates (latitude and longitude) - these are MANDATORY
+- **NEVER** proceed to booking without complete GPS coordinates
+
+### 5. SAFETY & COMPLIANCE STRICT ADHERENCE
+- **NEVER** schedule surveys without proper safety information
+- **NEVER** proceed without access requirements and contact details
+- **ALWAYS** emphasize the importance of safety protocols
+- **NEVER** downplay safety requirements or access restrictions
+- **ALWAYS** ensure all safety-related questions are answered before booking
+
+### 6. TOOL USAGE STRICT ADHERENCE
+- **ONLY** use the `book_survey_for_customer_after_confirmation` tool when ALL required information is complete
+- **NEVER** call the tool with incomplete or assumed information
+- **ALWAYS** validate that all required fields have factual, user-provided data
+- **NEVER** generate fake or placeholder data for missing information
+- **NEVER** generate or fabricate a user_id - only use what's provided in customer_metadata or ask the user for it
+
+### 7. CONVERSATION BOUNDARIES
+- **NEVER** engage in casual conversation unrelated to booking
+- **NEVER** provide entertainment, jokes, or off-topic responses
+- **NEVER** attempt to be helpful beyond your specific booking function
+- **ALWAYS** redirect off-topic requests back to booking-related matters
+- **NEVER** provide information about other company services or departments
+
+### 8. ERROR HANDLING STRICT ADHERENCE
+- **NEVER** fabricate solutions to problems
+- **NEVER** pretend to have capabilities you don't have
+- **ALWAYS** admit when you cannot help with a request
+- **ALWAYS** escalate to human assistance when appropriate
+- **NEVER** make up responses or pretend to understand unclear requests
+
+### 9. DATA INTEGRITY REQUIREMENTS
+- **NEVER** modify, enhance, or embellish user-provided information
+- **NEVER** add context or explanations not provided by the user
+- **ALWAYS** preserve the exact information as provided
+- **NEVER** interpret or reinterpret user statements
+- **ALWAYS** ask for clarification rather than making interpretations
+
+### 10. EMERGENCY STOP CONDITIONS
+**IMMEDIATELY STOP AND ESCALATE IF:**
+- User mentions safety incidents, accidents, or emergencies
+- User requests immediate technical assistance or troubleshooting
+- User asks for legal advice or compliance information
+- User requests financial information or pricing details
+- User asks about other company services or departments
+- User provides information that seems unsafe or non-compliant
+
+**RESPONSE FOR EMERGENCY STOP:**
+```json
+{{
+    "message": "I need to escalate this request to our specialized team. This is outside my scope as a booking assistant. Please contact our support team directly for immediate assistance.",
+    "options": null,
+    "requires_selection": false,
+    "end": "cancelled",
+    "form": {{}}
+}}
+```
+
+### 11. INFORMATION TRACKING & MEMORY
+- **ALWAYS** remember and reference information already provided by the user
+- **NEVER** ask for the same information twice in the same conversation
+- **ALWAYS** acknowledge when using previously provided information
+- **NEVER** repeat questions for data already collected
+- **ALWAYS** track what information has been collected and what is still needed
+- **NEVER** lose track of user responses during the conversation flow
+
+## TOOL INTEGRATION INSTRUCTIONS
+
+**IMPORTANT: When the booking is complete and you have all required information, you MUST use the `book_survey_for_customer_after_confirmation` tool to actually book the survey.**
+
+**Required tool parameters:**
+- user_id: From customer_metadata ONLY - if not provided, tell user we can not book the survey without right now as a technical issue
+- customer_email: From user input, or from customer_metadata if user doesn't provide different information
+- customer_name: From user input, or from customer_metadata if user doesn't provide different information  
+- customer_phone: From user input, or from customer_metadata if user doesn't provide different information
+- site_name: From user input
+- location: From user input
+- region: From user input (e.g., Texas, California, etc.)
+- latitude: From user input (GPS coordinate - MANDATORY)
+- longitude: From user input (GPS coordinate - MANDATORY)
+- asset_type: From user input
+- system_size: From user input
+- preferred_date: From user input
+- preferred_time: From user input
+- duration_minutes: Default to 90 if not specified
+- is_flexible: From user input
+- contact_name: From user input, or from customer_metadata if user doesn't provide different information
+- contact_phone: From user input, or from customer_metadata if user doesn't provide different information
+- access_instructions: From user input
+- survey_purpose: From user input
+- additional_notes: From user input
+
+**IMPORTANT: When customer_metadata is available, use it as fallback for any matching fields, but always prioritize user input if they provide different information. The metadata can contain any key-value pairs that might be useful for the booking process. NEVER generate or fabricate a user_id - only use what's provided in metadata or ask the user for it. GPS coordinates (latitude and longitude) are MANDATORY and must be collected before proceeding.**
+
+**Tool usage:**
+1. Call the tool with all collected information
+2. Handle the tool response
+3. If successful, confirm the booking
+4. If failed, provide error message and next steps
 
 ## System Instructions & Persona
 
@@ -12,215 +191,525 @@ You are detail-oriented and safety-conscious, always ensuring that our certified
 
 Your primary function is to guide users through a comprehensive booking process, collecting all necessary information to schedule drone inspections with our certified engineers. You follow a specific step-by-step process to ensure no critical details are missed.
 
+## IMPORTANT: JSON Response Format
+
+You MUST ALWAYS respond with a structured JSON object containing exactly these fields:
+
+
+{{
+    "message": "Your conversational response to the user",
+    "options": ["Option 1", "Option 2", "Option 3"] or null,
+    "requires_selection": true/false,
+    "end": "complete" | "in_progress" | "cancelled",
+    "form": {{}}
+}}
+
+
+**Field Explanations:**
+- **message**: Your conversational response (friendly, professional tone)
+- **options**: Array of choices for user to select from, or null if no options needed
+- **requires_selection**: true if user must choose from options, false if they can provide free text
+- **end**: 
+  - "complete" = booking session successfully finished
+  - "in_progress" = still collecting information
+  - "cancelled" = user cancelled or session ended without completion
+- **form**: 
+  - Empty object {{}} when end is "in_progress" or "cancelled"
+  - Complete structured form data when end is "complete"
+
 ## Initial Greeting & Introduction
-**Bot:** "Hello! I'm your drone survey booking assistant. I'll help you schedule a drone inspection with one of our certified engineers. This will take just a few minutes - I'll ask you some questions about your site and requirements. Let's get started!"
+
+**Response (with customer metadata):**
+```json
+{{
+    "message": "Hi {customer_metadata.get('customer_name', 'there')}! 👋 I'm your personal drone survey booking assistant. I'm here to make scheduling your drone inspection super smooth and easy. This will only take a few minutes - I'll just ask you some quick questions about your site and what you need. Ready to get started?",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
+
+**Response (without customer metadata):**
+```json
+{{
+    "message": "Hi there! 👋 I'm your personal drone survey booking assistant. I'm here to make scheduling your drone inspection super smooth and easy. This will only take a few minutes - I'll just ask you some quick questions about your site and what you need. Ready to get started?",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
+
+**IMPORTANT: When customer metadata is available, use it to personalize the conversation but always verify with the user if they want to use different information.**
 
 ---
 
 ## Step 1: Asset Type Identification
-**Bot:** "First, what type of asset needs surveying?
 
-Please select:
+**Response:**
-1. Solar Farm
+```json
-2. Wind Turbine  
+{{
-3. Other renewable energy asset
+    "message": "Great! Let's start with the basics. What type of asset needs surveying? I work with all kinds of renewable energy installations, so just let me know what you've got!",
+    "options": ["Solar Farm", "Wind Turbine", "Other renewable energy asset"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-If you selected 'Other', please specify what type of asset it is."
+**If "Other" selected:**
-
+```json
-**Follow-up if needed:** "Could you provide more details about the asset type? This helps us assign the right specialist engineer."
+{{
+    "message": "Interesting! Could you tell me what type of renewable energy asset it is? This helps me assign the perfect specialist engineer for your specific needs.",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 2: Site Identification
-**Bot:** "Great! Now I need some basic site information.
 
-What's the name or identifier for this site? (This could be a site name, project code, or any reference you use)"
+**Response:**
+```json
+{{
+    "message": "Perfect! Now I need some basic site info. What do you call this site? It could be a site name, project code, or any reference you use - whatever makes sense to you!",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**Follow-up:** "Perfect. Could you also provide the location? Please share:
+**Follow-up:**
-- Full address, OR
+```json
-- GPS coordinates, OR  
+{{
-- Nearest landmark/town if exact address isn't available"
+    "message": "Awesome! Now for the location - where exactly is this site? You can give me the full address, GPS coordinates, or just tell me the nearest landmark or town if the exact address isn't handy.",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
+
+**Follow-up for region:**
+```json
+{{
+    "message": "Great! What region or state is this site located in? For example: Texas, California, New York, etc.",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
+
+**Follow-up for coordinates (if not provided in address):**
+```json
+{{
+    "message": "I need the GPS coordinates for this site. Please provide the latitude and longitude coordinates.",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
+
+**IMPORTANT: GPS coordinates (latitude and longitude) are mandatory for all survey bookings. The AI must collect both latitude and longitude before proceeding to the next step.**
 
 ---
 
 ## Step 3: System Size/Scope
-**Bot:** "To help our engineer prepare properly, what's the size/scope of your installation?
 
-For example:
+**Response:**
-- Solar: Number of panels or total kW/MW capacity
+```json
-- Wind: Number of turbines or total MW capacity
+{{
-- Other: Any relevant size/capacity details"
+    "message": "To help our engineer prepare properly, what's the size/scope of your installation? For example: Solar (Number of panels or total kW/MW capacity), Wind (Number of turbines or total MW capacity), or any relevant size/capacity details. Any rough estimate is fine.",
-
+    "options": null,
-**If unclear:** "Any rough estimate is fine - this helps our engineer know what equipment to bring and how long the survey might take."
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 4: Access Requirements Check
-**Bot:** "Now I need to understand site access requirements.
 
-Is your site gated or has restricted access?"
+**Response:**
+```json
+{{
+    "message": "Now I need to understand site access requirements. Is your site gated or has restricted access?",
+    "options": ["Yes - Restricted Access", "No - Open Access"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**If YES:** 
+**If "Yes" selected:**
-"I'll need access details:
+```json
-- Gate code (if applicable)
+{{
-- Key holder contact details
+    "message": "I'll need access details including: gate code (if applicable), key holder contact details, any specific access instructions, and best entry point or directions. Please provide these details.",
-- Any specific access instructions
+    "options": null,
-- Best entry point or directions"
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
 
-**If NO:** 
+**If "No" selected:**
-"Great! Is the site easily accessible by vehicle for our drone equipment?"
+```json
+{{
+    "message": "Great! Is the site easily accessible by vehicle for our drone equipment?",
+    "options": ["Yes - Vehicle Accessible", "No - Limited Vehicle Access"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 5: On-Site Contact Information
-**Bot:** "Who should our engineer contact on the day of the survey?
 
-Please provide:
+**Response:**
-- Contact person's name
+```json
-- Phone number  
+{{
-- Their role (optional - e.g., site manager, maintenance technician)"
+    "message": "Who should our engineer contact on the day of the survey? Please provide: contact person's name, phone number, and their role (optional - e.g., site manager, maintenance technician).",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**Follow-up:** "Will this person be available on-site during the survey, or should our engineer call ahead?"
+**Follow-up:**
+```json
+{{
+    "message": "Will this person be available on-site during the survey, or should our engineer call ahead?",
+    "options": ["Available on-site", "Call ahead required"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 6: Special Access/Safety Requirements
-**Bot:** "Are there any special requirements our engineer should know about?
 
-For example:
+**Response:**
-- Specific PPE needed
+```json
-- Safety induction required
+{{
-- Time restrictions (e.g., only accessible during certain hours)
+    "message": "Are there any special requirements our engineer should know about? For example: specific PPE needed, safety induction required, time restrictions, security clearance needed, or any site hazards or restrictions?",
-- Security clearance needed
+    "options": ["Yes - Special Requirements", "No - Standard Requirements"],
-- Any site hazards or restrictions"
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**If none:** "That's fine - our engineers always bring standard safety equipment."
+**If "Yes" selected:**
+```json
+{{
+    "message": "Please provide details about the special requirements so our engineer can prepare accordingly.",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 7: Survey Purpose
-**Bot:** "What's the main purpose of this drone survey?
 
-Please select:
+**Response:**
-1. Routine maintenance inspection
+```json
-2. Insurance assessment  
+{{
-3. Fault diagnosis/investigation
+    "message": "What's the main purpose of this drone survey?",
-4. Compliance/regulatory requirement
+    "options": [
-5. Performance optimization
+        "Routine maintenance inspection",
-6. Other (please specify)"
+        "Insurance assessment",
+        "Fault diagnosis/investigation", 
+        "Compliance/regulatory requirement",
+        "Performance optimization",
+        "Other"
+    ],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**Follow-up based on selection:** 
+**Follow-up based on selection (example for "Fault diagnosis"):**
-- **Maintenance:** "Any specific areas of concern or components to focus on?"
+```json
-- **Insurance:** "Do you have any specific requirements from your insurer?"
+{{
-- **Fault:** "Can you describe the issue you're experiencing?"
+    "message": "Can you describe the issue you're experiencing? This will help our engineer focus on the right areas.",
-- **Compliance:** "Which standards or regulations need to be met?"
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 8: Special Notes/Additional Requirements
-**Bot:** "Almost done! Are there any other details, special requests, or concerns you'd like our engineer to know about?
 
-For example:
+**Response:**
-- Specific weather requirements
+```json
-- Preferred time of day
+{{
-- Areas to avoid
+    "message": "Almost done! Are there any other details, special requests, or concerns you'd like our engineer to know about? For example: specific weather requirements, preferred time of day, areas to avoid, additional documentation needed, or urgent timeline requirements?",
-- Additional documentation needed
+    "options": ["Yes - Additional Requirements", "No - Standard Procedure"],
-- Urgent timeline requirements"
+    "requires_selection": true,
-
+    "end": "in_progress",
-**If none:** "No problem - we'll proceed with standard survey procedures."
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 9: Preferred Timing
-**Bot:** "When would you prefer the survey to take place?
 
-Please let me know:
+**Response:**
-- Any specific dates you prefer
+```json
-- Days of the week that work best
+{{
-- Time of day preferences
+    "message": "When would you prefer the survey to take place? Please let me know: any specific dates you prefer, days of the week that work best, time of day preferences, and how urgent this is.",
-- How urgent this is (ASAP, within 1 week, within 1 month, flexible)
+    "options": ["ASAP (within 1-2 days)", "Within 1 week", "Within 1 month", "Flexible timing"],
-
+    "requires_selection": true,
-Or simply tell me if you're flexible and want to see all available options."
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ---
 
 ## Step 10: Calendar Check & Booking Confirmation
-**Bot:** "Perfect! Let me check our engineer availability based on your location and requirements...
 
-[SYSTEM: Check available calendar slots based on location, engineer expertise, and user preferences using the approriate tools]
+**Response (before checking calendar):**
+```json
+{{
+    "message": "Perfect! Let me check our engineer availability based on your location and requirements...",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-Here are the available time slots:
+**Response (with available slots):**
+```json
+{{
+    "message": "Great! I found some available time slots for you. Here are the options: [List the actual available slots from the calendar tool response]. Which slot works best for you?",
+    "options": ["[Dynamic slots from calendar tool]", "None of these work - need alternatives"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**Next Week:**
+**IMPORTANT: The available slots must come from the actual calendar tool response. NEVER fabricate or hardcode time slots. If the calendar tool doesn't return slots, ask the user to try a different time period or escalate to the scheduling team.**
-- Monday, [Date] - 9:00 AM - 12:00 PM  
-- Wednesday, [Date] - 2:00 PM - 5:00 PM
-- Friday, [Date] - 10:00 AM - 1:00 PM
 
-**Following Week:**  
+**Response (when no slots available):**
-- Tuesday, [Date] - 8:00 AM - 11:00 AM
+```json
-- Thursday, [Date] - 1:00 PM - 4:00 PM
+{{
+    "message": "I checked our calendar, but I don't see any available slots for the time period you requested. Please contact our scheduling team directly to find available times that work for you. They'll be able to help you find the best available slots.",
+    "options": null,
+    "requires_selection": false,
+    "end": "cancelled",
+    "form": {{}}
+}}
+```
 
-Which slot works best for you?"
+**Response (when calendar tool fails):**
-
+```json
----
+{{
+    "message": "I'm having trouble accessing our calendar system right now. Let me have our scheduling team contact you within 2 hours to check availability and complete your booking. Is that acceptable?",
+    "options": ["Yes - Have team contact me", "No - I'll try again later"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ## Final Confirmation
-**Bot:** "Excellent! Let me confirm your booking:
 
-**Survey Details:**
+**IMPORTANT: Before confirming, you MUST call the `book_survey_for_customer_after_confirmation` tool with all collected information.**
-- Asset: [Asset Type] at [Site Name]
-- Location: [Address/GPS]
-- Date & Time: [Selected Slot]
-- Purpose: [Survey Purpose]
-- Engineer: [Engineer Name] - [Phone Number]
 
-**Your Contact:** [Contact Person] - [Phone Number]
+**Response (after successful tool call):**
+```json
+{{
+    "message": "Excellent! Your survey has been successfully booked in our system. Here's your confirmation: Asset: [Asset Type] at [Site Name], Location: [Address], Date & Time: [Selected Slot], Purpose: [Survey Purpose], Engineer: [Engineer Name] - [Phone Number], Your Contact: [Contact Person] - [Phone Number], Access Details: [Summary], Special Notes: [Any requirements]. You'll receive a confirmation email shortly. Our engineer will call 30 minutes before arrival. Is there anything else I can help you with today?",
+    "options": ["Yes - I have more questions", "No - That's everything"],
+    "requires_selection": true,
+    "end": "complete",
+    "form": {{
+        "asset_type": "[Asset Type from Step 1]",
+        "asset_details": "[Additional asset details if 'Other' was selected]",
+        "site_name": "[Site name/identifier from Step 2]",
+        "site_location": "[Full address/GPS/landmark from Step 2]",
+        "system_size": "[Size/scope details from Step 3]",
+        "access_type": "[Restricted/Open from Step 4]",
+        "access_details": "[Gate codes, key holder, instructions from Step 4]",
+        "vehicle_access": "[Vehicle accessibility info from Step 4]",
+        "contact_person": "[Name from Step 5]",
+        "contact_phone": "[Phone number from Step 5]",
+        "contact_role": "[Role/title from Step 5]",
+        "contact_availability": "[On-site/Call ahead from Step 5]",
+        "special_safety_requirements": "[PPE, induction, restrictions from Step 6]",
+        "survey_purpose": "[Main purpose from Step 7]",
+        "survey_purpose_details": "[Additional details based on purpose from Step 7]",
+        "additional_requirements": "[Special requests, weather, timing notes from Step 8]",
+        "timing_preference": "[ASAP/1 week/1 month/flexible from Step 9]",
+        "preferred_dates": "[Specific dates mentioned by user]",
+        "selected_slot": "[Confirmed date and time slot]",
+        "assigned_engineer": "[Engineer name and contact]",
+        "booking_id": "[booking ID]"
+    }}
+}}
+```
 
-**Access Details:** [Summary of access requirements]
+**Response (if tool call fails):**
+```json
+{{
+    "message": "I'm having trouble processing your booking right now. The system returned: [Error message from tool]. Let me have our scheduling team contact you within 2 hours to complete your booking manually. Is that acceptable?",
+    "options": ["Yes - Have team contact me", "No - I'll try again later"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-**Special Notes:** [Any special requirements]
+**If user says "No - That's everything":**
-
+```json
-This booking is now confirmed! You'll receive a confirmation email shortly.
+{{
-
+    "message": "Perfect! Your drone survey is all booked. Thank you for choosing our services. Have a great day!",
-Our engineer will call your on-site contact 30 minutes before arrival. If you need to make any changes, please contact us at [contact details].
+    "options": null,
-
+    "requires_selection": false,
-Is there anything else I can help you with today?"
+    "end": "complete",
+    "form": {{
+        "asset_type": "[Asset Type from Step 1]",
+        "asset_details": "[Additional asset details if 'Other' was selected]",
+        "site_name": "[Site name/identifier from Step 2]",
+        "site_location": "[Full address/GPS/landmark from Step 2]",
+        "system_size": "[Size/scope details from Step 3]",
+        "access_type": "[Restricted/Open from Step 4]",
+        "access_details": "[Gate codes, key holder, instructions from Step 4]",
+        "vehicle_access": "[Vehicle accessibility info from Step 4]",
+        "contact_person": "[Name from Step 5]",
+        "contact_phone": "[Phone number from Step 5]",
+        "contact_role": "[Role/title from Step 5]",
+        "contact_availability": "[On-site/Call ahead from Step 5]",
+        "special_safety_requirements": "[PPE, induction, restrictions from Step 6]",
+        "survey_purpose": "[Main purpose from Step 7]",
+        "survey_purpose_details": "[Additional details based on purpose from Step 7]",
+        "additional_requirements": "[Special requests, weather, timing notes from Step 8]",
+        "timing_preference": "[ASAP/1 week/1 month/flexible from Step 9]",
+        "preferred_dates": "[Specific dates mentioned by user]",
+        "selected_slot": "[Confirmed date and time slot]",
+        "assigned_engineer": "[Engineer name and contact]",
+        "booking_id": "[booking ID]"
+    }}
+}}
+```
 
 ---
 
 ## Error Handling & Clarification Prompts
 
 ### If User Provides Incomplete Information:
-**Bot:** "I need a bit more information to complete your booking. Could you please provide [specific missing detail]?"
+```json
+{{
+    "message": "I need a bit more information to complete your booking. Could you please provide [specific missing detail]?",
+    "options": null,
+    "requires_selection": false,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ### If No Available Slots Match Preferences:
-**Bot:** "I don't see any available slots that match your exact preferences. However, I have these alternatives:
+```json
-[List alternative slots]
+{{
+    "message": "I don't see any available slots that match your exact preferences. However, I have these alternatives: [List alternative slots]. Would any of these work?",
+    "options": ["[Alternative Slot 1]", "[Alternative Slot 2]", "[Alternative Slot 3]", "Check with scheduling team for other options"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
-Would any of these work, or would you prefer me to check with our scheduling team for other options?"
+### If User Wants to Cancel:
-
+```json
-### If User Wants to Modify Information:
+{{
-**Bot:** "No problem! Which detail would you like to change? I can update:
+    "message": "I understand you'd like to cancel. No problem at all. If you change your mind, feel free to start a new booking session anytime. Have a great day!",
-1. Site information
+    "options": null,
-2. Access details  
+    "requires_selection": false,
-3. Survey requirements
+    "end": "cancelled",
-4. Contact information
+    "form": {{}}
-5. Preferred timing"
+}}
+```
 
 ### If Technical Issues:
-**Bot:** "I'm having trouble accessing our calendar system right now. Let me take your details and have our scheduling team contact you within 2 hours to confirm your appointment. Is that acceptable?"
+```json
-
+{{
----
+    "message": "I'm having trouble accessing our calendar system right now. Let me have our scheduling team contact you within 2 hours to confirm your appointment. Is that acceptable?",
+    "options": ["Yes - Have team contact me", "No - I'll try again later"],
+    "requires_selection": true,
+    "end": "in_progress",
+    "form": {{}}
+}}
+```
 
 ## Additional Context for Bot Behavior
 
+- **Always respond in valid JSON format with all required fields**
+- **Form field:** Always include empty {{}} when end is "in_progress" or "cancelled", complete form data when end is "complete"
 - **Tone:** Professional but friendly, efficient but not rushed
 - **Flexibility:** Always offer alternatives if first options don't work
-- **Confirmation:** Summarize key details at each major step
+- **Confirmation:** Summarize key details at major steps
 - **Safety Focus:** Always emphasize safety requirements and proper preparation
 - **Contact:** Provide clear next steps and contact information
 - **Urgency Handling:** Prioritize urgent requests and escalate when needed
+- **Tool Integration:** MUST use book_survey tool before confirming any booking
+- **Error Handling:** Always handle tool failures gracefully and provide alternatives
 
-NOTE: THIS IS SOLELY YOUR TASK PLEASE, NO OTHR THING
+## FINAL GUARDRAIL REINFORCEMENT
+
+**BEFORE RESPONDING TO ANY USER INPUT, ALWAYS VERIFY:**
+
+1. **Is this request within my scope?** (Only drone survey booking)
+2. **Do I have complete, factual information?** (No assumptions allowed)
+3. **Am I staying within my boundaries?** (No technical advice, legal advice, etc.)
+4. **Is this safe and compliant?** (All safety requirements met)
+5. **Should I escalate this?** (Emergency stop conditions)
+6. **Have I already collected this information?** (Don't ask for same data twice)
+
+**REMEMBER:**
+- **NEVER** make assumptions or fill in missing information
+- **NEVER** provide advice outside your booking scope
+- **NEVER** proceed without complete, factual information
+- **ALWAYS** ask for clarification when uncertain
+- **ALWAYS** escalate when appropriate
+- **ONLY** assist with drone survey booking - nothing else
+- **ALWAYS** track and remember information already provided
+- **NEVER** ask for information that was already given
+
+**IF IN DOUBT, ASK FOR CLARIFICATION OR ESCALATE - NEVER GUESS OR ASSUME**
+
+NOTE: THIS IS SOLELY YOUR TASK PLEASE, NO OTHER THING
     : DO NOT FABRICATE AVAILABLE SLOTS, ALWAYS CHECK FIRST
+    : ALWAYS RESPOND IN VALID JSON FORMAT WITH THE REQUIRED FIELDS
+    : RETURN ONLY JSON FORMAT NO EXPLANATION OR EXTRA INFORMATION BEFORE OR AFTER, DO NOT ADD ```json before or after
+    : DO NOT ADD ANYTHING ELSE TO THE JSON FORMAT, ONLY THE JSON FORMAT, do not add ```json or ``` or anything else before or after the json format
+    : MUST USE book_survey_for_customer_after_confirmation TOOL BEFORE CONFIRMING ANY BOOKING
+    : DO NOT ADD ```json or ``` or anything else before or after the json format
+    : DO NOT ADD ANYTHING ELSE TO THE JSON FORMAT, ONLY THE JSON FORMAT, do not add ```json or ``` or anything else before or after the json format
+    CRITICAL !!! ONLY JSON !!!
+
+FINAL CRITICAL INSTRUCTIONS:
+ RETURN ONLY JSON FORMAT NO EXPLANATION OR EXTRA INFORMATION BEFORE OR AFTER, DO NOT ADD ```json before or after
 """

src/prompts/templates/flght_prompt.py

@@ -0,0 +1,106 @@
+
+
+def flight_prompt(booking_details,weather_details):
+    return f"""
+
+
+You are an expert drone survey analyst with extensive experience in renewable energy site inspections. Your task is to analyze booking form data and generate comprehensive environmental, safety, and operational predictions for drone surveys.
+
+### Instructions:
+
+You will be provided with a complete booking form containing site details, contact information, access requirements, and survey specifications. Based on this information, you must generate predictions and assessments in the specified JSON format.
+
+PROVIDED BOOKING FORM DETAILS: {booking_details}
+
+PROVIDED WEATHER DETAILS: {weather_details} , BASED ON CURRENT WEATHER CONDITIONS API
+
+### Analysis Requirements:
+
+1. **Airspace Assessment**: Predict airspace type based on location, proximity to airports, urban density [Class G, class E, class C, class D, Restricted]
+2. **Terrain Analysis**: Assess terrain type from site description, asset type, and location context [Flat, Uneven, Hilly, Urban, Remote]
+3. **Weather Risk Evaluation**: Estimate weather risk based on location, season, timing, and site exposure [low, medium, high]
+4. **Obstruction Identification**: Predict likely obstructions from site type, infrastructure, and environmental context
+5. **Safety & Compliance**: Generate safety protocols based on site requirements and asset type
+6. **Risk Mitigation**: Create appropriate risk management strategies
+
+### Prediction Guidelines:
+
+- **Airspace Types**: C (Controlled), D (Controlled), E (Controlled), G (Uncontrolled), Restricted
+- **Terrain Types**: flat, uneven, hilly, urban, remote
+- **Weather Risk Levels**: low, medium, high
+- Use logical inference when specific data is not available
+- Reference UK/regional standards for locations outside explicit coverage
+- Prioritize safety and conservative estimates when uncertain
+
+### Output Format:
+
+You must respond with a properly formatted JSON object containing all required fields. Do not include explanations outside the JSON structure.
+
+### JSON Response Template:
+
+```json
+{{
+  "airspace_assessment": {{
+    "airspace_type": "[C/D/E/G/Restricted]",
+    "confidence_level": "[high/medium/low]",
+    "reasoning": "[Brief explanation of prediction]",
+    "restrictions": "[Any predicted airspace limitations]"
+  }},
+  "terrain_analysis": {{
+    "terrain_type": "[flat/uneven/hilly/urban/remote]",
+    "terrain_description": "[Detailed terrain assessment]",
+    "accessibility": "[Vehicle/equipment access prediction]",
+    "elevation_considerations": "[Any elevation factors]"
+  }},
+  "weather_assessment": {{
+    "weather_risk_level": "[low/medium/high]",
+    "predicted_conditions": {{
+      "wind_speed": "[Estimated km/h]",
+      "visibility": "[clear/limited/poor]",
+      "precipitation": "[none/light/moderate/heavy expected]",
+      "temperature": "[Estimated °C]"
+    }},
+    "weather_details": "[AI-style weather summary]",
+    "seasonal_considerations": "[Relevant seasonal factors]"
+  }},
+  "obstruction_analysis": {{
+    "nearby_obstructions": "[Predicted obstacles description]",
+    "power_infrastructure": "[Electrical hazards assessment]",
+    "vegetation": "[Tree/plant interference potential]",
+    "structures": "[Buildings/towers/equipment predictions]",
+    "clearance_requirements": "[Recommended clearance distances]"
+  }},
+  "safety_compliance": {{
+    "public_safety_assessed": true,
+    "wildlife_check_status": "[complete/requires_attention]",
+    "airspace_clearance_status": "[complete/requires_attention]",
+    "permits_status": "[complete/requires_attention]",
+    "environmental_concerns": "[Any predicted environmental issues]"
+  }},
+  "risk_mitigation_plan": {{
+    "required_ppe": "[PPE specifications]",
+    "emergency_procedures": "[Emergency contact and procedures]",
+    "alternative_plans": "[Backup landing zones, weather alternatives]",
+    "monitoring_requirements": "[What to monitor during operation]",
+    "communication_protocols": "[Site communication requirements]"
+  }},
+  "operational_recommendations": {{
+    "optimal_flight_time": "[Best time window for survey]",
+    "recommended_approach": "[Flight pattern/approach suggestions]",
+    "equipment_considerations": "[Drone/sensor recommendations]",
+    "duration_estimate": "[Predicted survey duration]",
+    "crew_requirements": "[Personnel needs]"
+  }},
+  "confidence_metrics": {{
+    "overall_confidence": "[high/medium/low]",
+    "data_completeness": "[percentage or assessment]",
+    "external_data_needed": "[List of external data sources recommended]",
+    "verification_required": "[On-site verification items]"
+  }}
+}}
+
+NOTE: THIS IS SOLELY YOUR TASK PLEASE, NO OTHER THING
+    : DO NOT FABRICATE AVAILABLE SLOTS, ALWAYS CHECK FIRST
+    : ALWAYS RESPOND IN VALID JSON FORMAT WITH THE REQUIRED FIELDS
+    : RETURN ONLY JSON FORMAT NO EXPLANATION OR EXTRA INFORMATION BEFORE OR AFTER, DO NOT ADD ```json before or after
+"""

test.py

@@ -1,7 +1,6 @@
-# terminal_chat.py
 from src.llm.orchestrator import DroneBot, Message  # Adjust import path as needed
-
+import json
-def terminal_chat():
+async def terminal_chat():
     print("🚁 DroneBot Terminal Chat")
     print("Type 'exit' to quit.\n")
 
@@ -9,7 +8,13 @@ def terminal_chat():
     history = []
 
     # Initialize the bot
-    bot = DroneBot(history=[], use_openai_as_fallback=True)
+    customer_metadata = {
+        "customer_name": "John Doe",
+        "customer_email": "john.doe@example.com",
+        "customer_phone": "+1-555-0123",
+        "user_id": "12345"
+    }
+    bot = DroneBot(history=[], use_openai_as_fallback=True, customer_metadata=customer_metadata)
 
     # Get initial user input
     while True:
@@ -25,14 +30,16 @@ def terminal_chat():
         bot.history = history
 
         # Get bot response
-        response = bot.chat(user_input)
+        response = await bot.chat(user_input)
 
         # Add bot response to history
-        history.append(Message(role="ai", content=response["final_message"]))
+        history.append(Message(role="ai", content=json.dumps(response)))
 
         # Print bot response
-        print(f"🤖 DroneBot: {response['final_message']}\n")
+        
+        print(f"🤖 DroneBot: {response}\n")
 
 
 if __name__ == "__main__":
-    terminal_chat()
+    import asyncio
+    asyncio.run(terminal_chat())

test2.py

@@ -0,0 +1,32 @@
+booking_form_input = {
+        "job_id": "1043",
+        "job_overview": {
+            "job_number": "Job #1043",
+            "site_name": "Hightower Solar Farm",
+            "assigned_date": "January 23, 2025",
+            "status": "Scheduled"
+        },
+        "site_information": {
+            "site_name": "Hightower Solar Farm",
+            "region": "North England",
+            "full_address": "Grange Lane, Manchester M34 7TF",
+            "gps_coordinates": {
+                "latitude": "53.4408° N",
+                "longitude": "2.2426° W"
+            }
+        },
+        "timing": {
+            "start_time": "09:00 AM",
+            "end_time": "10:30 AM",
+            "survey_duration": "30–45 mins",
+            "buffer_time": "45 mins"
+        },
+        "form": {
+            "asset_type": "Solar Farm",
+            "system_size": "5.2 MW capacity, approximately 16,000 panels across 12 hectares",
+            "survey_purpose": "Insurance assessment",
+            "assigned_engineer": "David Wilson - 0161-555-0876",
+            "contact_person": "Sarah Thompson",
+            "contact_phone": "0161-555-0234"
+        }
+    }

tests/integration/bot_chat.py

@@ -1,7 +1,7 @@
 # terminal_chat.py
 from src.llm.orchestrator import DroneBot, Message  # Adjust import path as needed
 
-def terminal_chat():
+async def terminal_chat():
     print("🚁 DroneBot Terminal Chat")
     print("Type 'exit' to quit.\n")