Upload 14 files

.env

@@ -0,0 +1,4 @@
+CAL_API_KEY=cal_live_c51069c635cb79e8ddb92bd38c85887c
+CAL_USERNAME=fiwyve-cliplat
+OPENAI_API_KEY=sk-vIC99U09XnsUcghERnIdhdTtznAGLcldxZzR2SjqAUT3BlbkFJ_DAvTZPRBjLBKbjhZm79nH8xliS0PYjic-mTx1BNwA
+GOOGLE_API_KEY=AIzaSyCO3jJkzNlgkcc_egBIKlelgberVozSON0

c_booking_controller.py

@@ -0,0 +1,106 @@
+"""Streamlit interface for the barber booking system."""
+
+import streamlit as st
+from c_langgraph_flow_new import run_booking_flow, SERVICE_MAPPING
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def initialize_session():
+    """Initialize the session state with default values."""
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+        # Add initial greeting
+        st.session_state.messages.append({
+            "role": "assistant",
+            "content": "Hello! Welcome to our barber shop. I'll help you book an appointment. Could you please tell me your name?"
+        })
+    
+    if "booking_info" not in st.session_state:
+        st.session_state.booking_info = {
+            "current_node": "Greeting",
+            "booking_info": {},
+            "response": "",
+            "messages": []
+        }
+
+def main():
+    st.set_page_config(page_title="AI Barber Booking", page_icon="💇‍♂️")
+    st.title("💇‍♂️ AI Barber Booking Assistant")
+    
+    # Initialize session
+    initialize_session()
+    
+    # Display current state (for debugging)
+    with st.sidebar:
+        st.subheader("Debug Information")
+        st.write("Current State:", st.session_state.booking_info.get("current_node", "Unknown"))
+        st.write("\nBooking Info:", st.session_state.booking_info.get("booking_info", {}))
+        if st.checkbox("Show Full Debug Info"):
+            st.json(st.session_state.booking_info)
+    
+    # Display service cards
+    st.markdown("### Our Services")
+    cols = st.columns(len(SERVICE_MAPPING))
+    for col, (service_name, details) in zip(cols, SERVICE_MAPPING.items()):
+        with col:
+            st.markdown(
+                f"""
+                <div style="padding: 10px; border-radius: 10px; border: 1px solid #ddd; text-align: center;">
+                    <h4>{service_name.title()}</h4>
+                    <p>${details['price']}<br>{details['duration']} min</p>
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+    
+    # Chat interface
+    st.markdown("### Chat with our Booking Assistant")
+    
+    # Display chat history
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+    
+    # Get user input
+    if prompt := st.chat_input("Type your message here..."):
+        if prompt.strip() == "":
+            st.warning("Please enter a valid message.")
+            return
+        
+        # Add user message to chat history
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        try:
+            # Update booking_info messages
+            st.session_state.booking_info["messages"] = st.session_state.messages.copy()
+            
+            # Process user input through LangGraph flow
+            with st.spinner("Processing your request..."):
+                new_state = run_booking_flow(prompt, st.session_state.booking_info)
+                
+                # Update session state
+                st.session_state.booking_info = new_state
+                
+                # Add assistant response to chat history
+                if new_state.get("response"):
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": new_state["response"]
+                    })
+                    with st.chat_message("assistant"):
+                        st.markdown(new_state["response"])
+            
+            # Force streamlit to rerun
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+            print(f"Error in main loop: {str(e)}")
+
+if __name__ == "__main__":
+    main()

c_langgraph_flow_new.py

@@ -0,0 +1,330 @@
+"""Main flow controller for the barber booking system."""
+
+import json
+from typing import Dict, Any, Union, TypedDict
+from langchain.schema import HumanMessage, SystemMessage
+from langchain_core.messages import AIMessage
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+from config.services import SERVICE_MAPPING
+from config.prompts import BOOKING_FLOW
+from config.validation import (
+    validate_email, validate_phone, validate_name, format_phone,
+    validate_booking_info, get_closest_service
+)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Gemini
+def get_llm():
+    api_key = os.getenv("GOOGLE_API_KEY")
+    if not api_key:
+        raise ValueError("GOOGLE_API_KEY environment variable is not set")
+    
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-pro')
+        return model
+    except Exception as e:
+        print(f"Error initializing Gemini: {str(e)}")
+        raise
+
+try:
+    llm = get_llm()
+except Exception as e:
+    print(f"Error initializing LLM: {str(e)}")
+    raise
+
+# Type definition for booking state
+class BookingState(TypedDict):
+    current_node: str
+    booking_info: Dict[str, Any]
+    response: str
+    messages: list
+
+def handle_greeting(message: str, booking_info: Dict) -> Dict:
+    """Handle the greeting state."""
+    if validate_name(message):
+        name = message.strip().title()
+        return {
+            "current_node": "ServiceSelection",
+            "booking_info": {"name": name},
+            "response": f"Hi {name}, welcome to our barbershop! Here are our services:"
+        }
+    return {
+        "current_node": "Greeting",
+        "booking_info": booking_info,
+        "response": "Could you please tell me your name?"
+    }
+
+def handle_service_selection(message: str, booking_info: Dict) -> Dict:
+    """Handle the service selection state."""
+    message = message.lower().strip()
+    
+    # Check for cancellation
+    if message in ["no", "cancel", "actually no", "nevermind"]:
+        return {
+            "current_node": "ServiceSelection",
+            "booking_info": booking_info,
+            "response": "No problem. Which service would you like to book? We offer haircut, beard trim, and full service."
+        }
+    
+    # Check for multiple services
+    if "and" in message or "," in message:
+        return {
+            "current_node": "ServiceSelection",
+            "booking_info": booking_info,
+            "response": "I see you're interested in multiple services. I recommend booking our full service which includes both haircut and beard trim. Would you like that?"
+        }
+    
+    # Check for completion keywords
+    if message in ["no", "nothing", "nothing else", "that's all"]:
+        if "service" in booking_info:
+            return {
+                "current_node": "ShowTopSlots",
+                "booking_info": booking_info,
+                "response": "Great! Let me show you our available time slots."
+            }
+    
+    # Try to match service
+    service = get_closest_service(message)
+    if service:
+        booking_info["service"] = service
+        return {
+            "current_node": "ShowTopSlots",
+            "booking_info": booking_info,
+            "response": f"Perfect! Let me show you our available time slots for your {service}."
+        }
+    
+    return {
+        "current_node": "ServiceSelection",
+        "booking_info": booking_info,
+        "response": "Which service would you like to book? We offer haircut, beard trim, and full service."
+    }
+
+def handle_time_selection(message: str, booking_info: Dict) -> Dict:
+    """Handle the time selection state."""
+    time_slots = ["9:00 AM", "10:00 AM", "11:00 AM", "2:00 PM", "3:00 PM"]
+    message = message.upper().strip()
+    
+    # Check for cancellation or change
+    if message.lower() in ["cancel", "change", "different time", "other time"]:
+        slots_text = "\n".join([f"- {slot}" for slot in time_slots])
+        return {
+            "current_node": "TimeSelection",
+            "booking_info": booking_info,
+            "response": f"Here are all our available times:\n{slots_text}\nWhich time works best for you?"
+        }
+    
+    # Handle relative time references
+    relative_times = {
+        "MORNING": ["9:00 AM", "10:00 AM", "11:00 AM"],
+        "AFTERNOON": ["2:00 PM", "3:00 PM"],
+        "EARLY": ["9:00 AM", "10:00 AM"],
+        "LATE": ["2:00 PM", "3:00 PM"],
+        "FIRST": ["9:00 AM"],
+        "LAST": ["3:00 PM"]
+    }
+    
+    for keyword, options in relative_times.items():
+        if keyword in message:
+            slots_text = "\n".join([f"- {slot}" for slot in options])
+            return {
+                "current_node": "TimeSelection",
+                "booking_info": booking_info,
+                "response": f"Here are the {keyword.lower()} slots:\n{slots_text}\nWhich specific time would you prefer?"
+            }
+    
+    # Normalize input
+    message = message.replace(":", "").replace(" ", "")
+    
+    # Map variations to standard format
+    time_map = {
+        "9": "9:00 AM", "9AM": "9:00 AM", "900": "9:00 AM", "900AM": "9:00 AM", "NINE": "9:00 AM",
+        "10": "10:00 AM", "10AM": "10:00 AM", "1000": "10:00 AM", "1000AM": "10:00 AM", "TEN": "10:00 AM",
+        "11": "11:00 AM", "11AM": "11:00 AM", "1100": "11:00 AM", "1100AM": "11:00 AM", "ELEVEN": "11:00 AM",
+        "2": "2:00 PM", "2PM": "2:00 PM", "200": "2:00 PM", "200PM": "2:00 PM", "TWO": "2:00 PM",
+        "3": "3:00 PM", "3PM": "3:00 PM", "300": "3:00 PM", "300PM": "3:00 PM", "THREE": "3:00 PM"
+    }
+    
+    selected_time = time_map.get(message)
+    if selected_time and selected_time in time_slots:
+        booking_info["time_slot"] = selected_time
+        return {
+            "current_node": "CustomerInfo",
+            "booking_info": booking_info,
+            "response": f"Perfect! I'll book you for {selected_time}. What's your email address?"
+        }
+    
+    # If time not found, show all slots
+    slots_text = "\n".join([f"- {slot}" for slot in time_slots])
+    return {
+        "current_node": "TimeSelection",
+        "booking_info": booking_info,
+        "response": f"I couldn't understand that time. Please select from these available times:\n{slots_text}"
+    }
+
+def handle_customer_info(message: str, booking_info: Dict) -> Dict:
+    """Handle the customer information state."""
+    if "email" not in booking_info:
+        if validate_email(message):
+            booking_info["email"] = message
+            return {
+                "current_node": "CustomerInfo",
+                "booking_info": booking_info,
+                "response": "Great! Now, what's your phone number for appointment reminders?"
+            }
+        return {
+            "current_node": "CustomerInfo",
+            "booking_info": booking_info,
+            "response": "Please provide a valid email address (e.g., name@example.com)."
+        }
+    
+    if "phone" not in booking_info:
+        if validate_phone(message):
+            booking_info["phone"] = format_phone(message)
+            return {
+                "current_node": "Confirmation",
+                "booking_info": booking_info,
+                "response": "Perfect! Let me confirm your booking details..."
+            }
+        return {
+            "current_node": "CustomerInfo",
+            "booking_info": booking_info,
+            "response": "Please provide a valid phone number (e.g., 1234567890)."
+        }
+    
+    return {
+        "current_node": "CustomerInfo",
+        "booking_info": booking_info,
+        "response": "I need your contact information. What's your email address?"
+    }
+
+def handle_confirmation(message: str, booking_info: Dict) -> Dict:
+    """Handle the confirmation state."""
+    message = message.lower().strip()
+    
+    # Format booking summary
+    service = booking_info.get("service", "")
+    price = SERVICE_MAPPING[service]["price"] if service else 0
+    duration = SERVICE_MAPPING[service]["duration"] if service else 0
+    
+    summary = f"""Here's your booking summary:
+- Name: {booking_info.get('name', '')}
+- Service: {service.title()} (${price}, {duration} min)
+- Time: {booking_info.get('time_slot', '')}
+- Email: {booking_info.get('email', '')}
+- Phone: {booking_info.get('phone', '')}
+
+Is this correct? Please confirm (yes/no)."""
+    
+    if message in ["yes", "correct", "confirm", "y"]:
+        return {
+            "current_node": "BookingComplete",
+            "booking_info": {**booking_info, "confirmation": True},
+            "response": "Great! Your appointment has been confirmed. We'll send you a confirmation email shortly."
+        }
+    
+    if message in ["no", "wrong", "incorrect", "n"]:
+        return {
+            "current_node": "ServiceSelection",
+            "booking_info": {"name": booking_info.get("name", "")},
+            "response": "I understand. Let's start over with the service selection."
+        }
+    
+    return {
+        "current_node": "Confirmation",
+        "booking_info": booking_info,
+        "response": summary
+    }
+
+def process_node(state: Dict) -> Dict:
+    """Process the current node in the booking flow."""
+    try:
+        current_node = state["current_node"]
+        booking_info = state.get("booking_info", {})
+        messages = state.get("messages", [])
+        
+        # Get the last user message
+        last_message = ""
+        if messages:
+            last_msg = messages[-1]
+            if isinstance(last_msg, dict):
+                last_message = last_msg.get("content", "")
+            elif isinstance(last_msg, (HumanMessage, AIMessage, SystemMessage)):
+                last_message = last_msg.content
+            else:
+                last_message = str(last_msg)
+        
+        # Handle each state
+        if current_node == "Greeting":
+            new_state = handle_greeting(last_message, booking_info)
+        elif current_node == "ServiceSelection":
+            new_state = handle_service_selection(last_message, booking_info)
+        elif current_node == "ShowTopSlots":
+            time_slots = ["9:00 AM", "10:00 AM", "11:00 AM", "2:00 PM", "3:00 PM"]
+            slots_text = "\n".join([f"- {slot}" for slot in time_slots])
+            new_state = {
+                "current_node": "TimeSelection",
+                "booking_info": booking_info,
+                "response": f"Here are our available time slots:\n{slots_text}\n\nWhich time works best for you?"
+            }
+        elif current_node == "TimeSelection":
+            new_state = handle_time_selection(last_message, booking_info)
+        elif current_node == "CustomerInfo":
+            new_state = handle_customer_info(last_message, booking_info)
+        elif current_node == "Confirmation":
+            new_state = handle_confirmation(last_message, booking_info)
+        elif current_node == "BookingComplete":
+            new_state = {
+                "current_node": "Farewell",
+                "booking_info": booking_info,
+                "response": "Thank you for booking with us! We look forward to seeing you soon."
+            }
+        else:
+            new_state = {
+                "current_node": "Greeting",
+                "booking_info": {},
+                "response": "Hello! Welcome to our barber shop. Could you please tell me your name?"
+            }
+        
+        return {**new_state, "messages": messages}
+    
+    except Exception as e:
+        print(f"Error in process_node: {str(e)}")
+        return {
+            "current_node": state.get("current_node", "Greeting"),
+            "booking_info": state.get("booking_info", {}),
+            "response": "I encountered an error. Could you please rephrase that?",
+            "messages": messages
+        }
+
+def run_booking_flow(user_input: str, state: Dict[str, Any] = None) -> Dict[str, Any]:
+    """Run the booking workflow."""
+    if state is None:
+        state = {
+            "current_node": "Greeting",
+            "booking_info": {},
+            "response": "",
+            "messages": []
+        }
+    
+    try:
+        # Process the current node
+        new_state = process_node(state)
+        return new_state
+    
+    except Exception as e:
+        print(f"Error in run_booking_flow: {str(e)}")
+        return {
+            "current_node": "Greeting",
+            "booking_info": {},
+            "response": "I encountered an error. Let's start over.",
+            "messages": []
+        }
+
+# Export necessary components
+__all__ = ['run_booking_flow', 'SERVICE_MAPPING']

config/prompts.py

@@ -0,0 +1,198 @@
+"""Prompts and flow configuration for the barber booking system."""
+
+BOOKING_FLOW = {
+    "Greeting": {
+        "prompt": """You are a friendly barber shop assistant. Your task is to get the customer's name.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. Accept any greeting or name input
+2. If input length >= 2, treat it as a name
+3. Store name in title case
+4. After getting name, show services list
+
+Available services:
+{services_list}
+
+Output format (JSON):
+{{
+    "next_node": "ServiceSelection",
+    "booking_info": {{"name": "User Name"}},
+    "response": "Your response message"
+}}""",
+        "next_states": ["ServiceSelection"],
+        "required_info": ["name"]
+    },
+    "ServiceSelection": {
+        "prompt": """You are helping select a service.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+Previous messages: {messages}
+
+Available services:
+{services_list}
+
+Rules:
+1. Direct matches: "haircut", "beard trim", "full service"
+2. Partial matches: 
+   - haircut: "hair", "cut"
+   - beard trim: "beard", "trim"
+   - full service: "full", "complete", "both"
+3. Once service is selected, move to ShowTopSlots
+4. If user says "no" or "nothing else", assume they're done selecting and move to ShowTopSlots
+
+Output format (JSON):
+{{
+    "next_node": "ShowTopSlots",
+    "booking_info": {{"service": "selected_service"}},
+    "response": "Great! Let me show you our available time slots for your [service]."
+}}""",
+        "next_states": ["ShowTopSlots"],
+        "required_info": ["service"]
+    },
+    "ShowTopSlots": {
+        "prompt": """You are showing available time slots.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. Show these time slots:
+   - 9:00 AM
+   - 10:00 AM
+   - 11:00 AM
+   - 2:00 PM
+   - 3:00 PM
+2. Ask user to select a preferred time
+3. Include service duration and price
+
+Output format (JSON):
+{{
+    "next_node": "TimeSelection",
+    "booking_info": {booking_info},
+    "response": "Here are our available time slots for your {booking_info[service]}:\\n- 9:00 AM\\n- 10:00 AM\\n- 11:00 AM\\n- 2:00 PM\\n- 3:00 PM\\n\\nWhich time works best for you?"
+}}""",
+        "next_states": ["TimeSelection"],
+        "required_info": []
+    },
+    "TimeSelection": {
+        "prompt": """You are helping select a time slot.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Available slots:
+- 9:00 AM
+- 10:00 AM
+- 11:00 AM
+- 2:00 PM
+- 3:00 PM
+
+Rules:
+1. Match user's input to available slots
+2. Accept variations (e.g., "9", "9am", "9:00", "9 am")
+3. If valid slot selected, move to CustomerInfo
+4. If invalid, stay in TimeSelection and show slots again
+
+Output format (JSON):
+{{
+    "next_node": "CustomerInfo" if valid_slot else "TimeSelection",
+    "booking_info": {{"time_slot": "selected_time"}} if valid_slot,
+    "response": "Perfect! I'll book you for [time]. What's your email address?" if valid_slot else "Please select from these times:\\n- 9:00 AM\\n- 10:00 AM\\n- 11:00 AM\\n- 2:00 PM\\n- 3:00 PM"
+}}""",
+        "next_states": ["CustomerInfo"],
+        "required_info": ["time_slot"]
+    },
+    "CustomerInfo": {
+        "prompt": """You are collecting customer contact information.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. First collect email
+2. Then collect phone
+3. Validate format of each
+4. Move to Confirmation when both collected
+
+Output format (JSON):
+{{
+    "next_node": "Confirmation" if have_all_info else "CustomerInfo",
+    "booking_info": {{
+        "email": "user@email.com" if valid_email,
+        "phone": "+1234567890" if valid_phone
+    }},
+    "response": "Your response asking for missing info or confirming"
+}}""",
+        "next_states": ["Confirmation"],
+        "required_info": ["email", "phone"]
+    },
+    "Confirmation": {
+        "prompt": """You are confirming the booking details.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. Show full booking summary:
+   - Name
+   - Service
+   - Time
+   - Email
+   - Phone
+2. Ask for confirmation
+3. Accept yes/no response
+
+Output format (JSON):
+{{
+    "next_node": "BookingComplete" if confirmed else "ServiceSelection",
+    "booking_info": {{"confirmation": true/false}},
+    "response": "Your confirmation message or start over message"
+}}""",
+        "next_states": ["BookingComplete", "ServiceSelection"],
+        "required_info": ["confirmation"]
+    },
+    "BookingComplete": {
+        "prompt": """You are completing the booking.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. Confirm booking details
+2. Provide booking reference
+3. Thank the customer
+
+Output format (JSON):
+{{
+    "next_node": "Farewell",
+    "booking_info": {booking_info},
+    "response": "Your thank you message with booking details"
+}}""",
+        "next_states": ["Farewell"],
+        "required_info": []
+    },
+    "Farewell": {
+        "prompt": """You are saying goodbye.
+
+Current message: "{user_input}"
+Current booking info: {booking_info}
+
+Rules:
+1. Thank the customer
+2. Provide contact info if needed
+3. Say goodbye
+
+Output format (JSON):
+{{
+    "next_node": "Farewell",
+    "booking_info": {booking_info},
+    "response": "Your goodbye message"
+}}""",
+        "next_states": [],
+        "required_info": []
+    }
+}

config/services.py

@@ -0,0 +1,19 @@
+"""Service configuration for the barber booking system."""
+
+SERVICE_MAPPING = {
+    "haircut": {
+        "price": 25,
+        "duration": 35,
+        "description": "Classic haircut service including wash and style"
+    },
+    "beard trim": {
+        "price": 15,
+        "duration": 25,
+        "description": "Professional beard trimming and shaping"
+    },
+    "full service": {
+        "price": 35,
+        "duration": 60,
+        "description": "Complete package including haircut, beard trim, and styling"
+    }
+}

config/validation.py

@@ -0,0 +1,55 @@
+"""Validation utilities for the barber booking system."""
+
+import re
+from typing import Tuple, Dict, Optional
+
+def validate_email(email: str) -> bool:
+    """Validate email format."""
+    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    return bool(re.match(pattern, email))
+
+def validate_phone(phone: str) -> bool:
+    """Validate phone number format."""
+    pattern = r'^\+?[1-9]\d{1,14}$'
+    return bool(re.match(pattern, phone))
+
+def validate_name(name: str) -> bool:
+    """Validate customer name."""
+    words = name.strip().split()
+    return len(words) >= 1 and all(len(word) >= 2 for word in words)
+
+def format_phone(phone: str) -> str:
+    """Format phone number to international format."""
+    if not phone.startswith('+'):
+        return f"+{phone.lstrip('0')}"
+    return phone
+
+def validate_booking_info(current_node: str, booking_info: Dict) -> Tuple[bool, str]:
+    """Validate required booking information for the current node."""
+    if current_node == "ShowTopSlots" and not booking_info.get("name"):
+        return False, "I need your name first. What's your name?"
+    elif current_node == "CollectEmail" and not booking_info.get("service"):
+        return False, "Please select a service first."
+    elif current_node == "CollectPhone" and not booking_info.get("email"):
+        return False, "I need your email for the confirmation. What's your email address?"
+    elif current_node == "Confirmation" and not booking_info.get("phone"):
+        return False, "What's your phone number for appointment reminders?"
+    return True, ""
+
+def get_closest_service(query: str) -> Optional[str]:
+    """Find the closest matching service based on the user's input."""
+    query = query.lower().strip()
+    
+    # Direct matches
+    if query in ["haircut", "beard trim", "full service"]:
+        return query
+        
+    # Handle variations and partial matches
+    if any(word in query for word in ["hair", "cut", "haircut"]):
+        return "haircut"
+    elif any(word in query for word in ["beard", "trim", "beardtrim"]):
+        return "beard trim"
+    elif any(word in query for word in ["full", "complete", "both", "all"]):
+        return "full service"
+            
+    return None

improved_cal_booking.py

@@ -0,0 +1,209 @@
+import os
+from datetime import datetime, timedelta
+import requests
+import json
+from typing import Dict, List, Optional, Union
+from dotenv import load_dotenv
+
+class ImprovedCalBookingSystem:
+    def __init__(self, api_key: Optional[str] = None, username: Optional[str] = None):
+        """Initialize the booking system with API credentials"""
+        # Load from environment if not provided
+        if api_key is None:
+            load_dotenv()
+            api_key = os.getenv('CAL_API_KEY')
+        if username is None:
+            load_dotenv()
+            username = os.getenv('CAL_USERNAME')
+            
+        if not api_key or not username:
+            raise ValueError("CAL_API_KEY and CAL_USERNAME are required")
+            
+        self.api_key = api_key
+        self.username = username
+        self.base_url = "https://api.cal.com/v1"
+        self.headers = {"Content-Type": "application/json"}
+        self.params = {"apiKey": self.api_key}
+
+    def get_event_types(self) -> List[Dict]:
+        """Get all available event types"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/event-types",
+                headers=self.headers,
+                params=self.params
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            print(f"Error fetching event types: {e}")
+            if hasattr(e.response, 'text'):
+                print(f"Response: {e.response.text}")
+            return []
+
+    def get_available_slots(
+        self, 
+        event_type_id: int, 
+        date: Optional[datetime] = None,
+        days_ahead: int = 7
+    ) -> List[str]:
+        """Get available time slots for a specific event type"""
+        if date is None:
+            # Start from tomorrow to avoid "booking in the past" errors
+            date = datetime.now() + timedelta(days=1)
+            date = date.replace(hour=0, minute=0, second=0, microsecond=0)
+        
+        try:
+            availability_params = {
+                **self.params,
+                "username": self.username,
+                "eventTypeId": event_type_id,
+                "dateFrom": date.strftime("%Y-%m-%d"),
+                "dateTo": (date + timedelta(days=days_ahead)).strftime("%Y-%m-%d"),
+                "duration": 30
+            }
+            
+            response = requests.get(
+                f"{self.base_url}/availability",
+                headers=self.headers,
+                params=availability_params
+            )
+            response.raise_for_status()
+            availability_data = response.json()
+            
+            # Generate available slots based on working hours
+            available_slots = []
+            date_ranges = availability_data.get("dateRanges", [])
+            busy_times = availability_data.get("busy", [])
+            
+            # Convert busy times to datetime objects
+            busy_periods = []
+            for busy in busy_times:
+                start = datetime.fromisoformat(busy["start"].replace("Z", "+00:00"))
+                end = datetime.fromisoformat(busy["end"].replace("Z", "+00:00"))
+                busy_periods.append((start, end))
+            
+            # Generate slots for each date range
+            for date_range in date_ranges:
+                range_start = datetime.fromisoformat(date_range["start"].replace("Z", "+00:00"))
+                range_end = datetime.fromisoformat(date_range["end"].replace("Z", "+00:00"))
+                
+                current_slot = range_start
+                while current_slot + timedelta(minutes=30) <= range_end:
+                    slot_end = current_slot + timedelta(minutes=30)
+                    
+                    # Check if slot is available
+                    is_available = True
+                    for busy_start, busy_end in busy_periods:
+                        if (current_slot >= busy_start and current_slot < busy_end) or \
+                           (slot_end > busy_start and slot_end <= busy_end):
+                            is_available = False
+                            break
+                    
+                    if is_available:
+                        available_slots.append(current_slot.isoformat())
+                    
+                    current_slot = slot_end
+            
+            return available_slots
+            
+        except requests.RequestException as e:
+            print(f"Error fetching available slots: {e}")
+            if hasattr(e.response, 'text'):
+                print(f"Response: {e.response.text}")
+            return []
+
+    def book_appointment(
+        self,
+        event_type_id: int,
+        customer: Dict[str, str],
+        start_time: str,
+        notes: str = "",
+        location: str = ""
+    ) -> Dict[str, Union[bool, Dict]]:
+        """Book an appointment with the provided details"""
+        try:
+            # Format the booking data according to Cal.com's API requirements
+            booking_data = {
+                "eventTypeId": event_type_id,
+                "start": start_time,
+                "email": customer["email"],
+                "name": customer["name"],
+                "timeZone": "UTC",
+                "language": "en",
+                "guests": [],
+                "notes": notes,
+                "location": location,
+                "smsReminderNumber": customer.get("phone", ""),
+                "rescheduleReason": "",
+                "customInputs": [],
+                "metadata": {}  # Required field
+            }
+
+            response = requests.post(
+                f"{self.base_url}/bookings",
+                headers=self.headers,
+                params=self.params,
+                json=booking_data
+            )
+            response.raise_for_status()
+            return {"success": True, "booking": response.json()}
+            
+        except requests.RequestException as e:
+            print(f"Error creating booking: {e}")
+            if hasattr(e.response, 'text'):
+                print(f"Response: {e.response.text}")
+            return {"success": False, "message": str(e)}
+
+    def get_booking_details(self, booking_id: str) -> Optional[Dict]:
+        """Get details of a specific booking"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/bookings/{booking_id}",
+                headers=self.headers,
+                params=self.params
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            print(f"Error fetching booking details: {e}")
+            return None
+
+    def cancel_booking(self, booking_id: str, reason: str = "") -> bool:
+        """Cancel a booking"""
+        try:
+            response = requests.delete(
+                f"{self.base_url}/bookings/{booking_id}",
+                headers=self.headers,
+                params={**self.params, "reason": reason}
+            )
+            response.raise_for_status()
+            return True
+        except requests.RequestException as e:
+            print(f"Error canceling booking: {e}")
+            return False
+
+    def reschedule_booking(
+        self,
+        booking_id: str,
+        new_start_time: str,
+        reason: str = ""
+    ) -> Dict[str, Union[bool, Dict]]:
+        """Reschedule a booking to a new time"""
+        try:
+            reschedule_data = {
+                "start": new_start_time,
+                "reason": reason
+            }
+            
+            response = requests.patch(
+                f"{self.base_url}/bookings/{booking_id}",
+                headers=self.headers,
+                params=self.params,
+                json=reschedule_data
+            )
+            response.raise_for_status()
+            return {"success": True, "booking": response.json()}
+        except requests.RequestException as e:
+            print(f"Error rescheduling booking: {e}")
+            return {"success": False, "message": str(e)}