How AI Voice Agents Book Appointments in Google Calendar and Send SMS Confirmations Live on Call (2026)

The Complete Live Booking and SMS Delivery Timeline:

[Caller Speaks on Phone]: "Do you have any openings this Friday around 3:00 PM?"
                                   │
                                   ▼ (Elapsed Time: 0ms)
┌────────────────────────────────────────────────────────────────────────┐
│ 1. Neural LLM Emits Tool Call & Acoustic Filler (<40ms)                │
│    - Dispatches async webhook: check_calendar(date="2026-09-08", time="15:00")
│    - Agent speaks natural filler: "Let me check our Friday schedule..."│
└────────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼ (Elapsed Time: 45ms)
┌────────────────────────────────────────────────────────────────────────┐
│ 2. Asynchronous API Webhook Resolves Slot Availability                 │
│    - Google Calendar API returns: Status=Available, Resource=Dr. Miller │
└────────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼ (Elapsed Time: 80ms)
┌────────────────────────────────────────────────────────────────────────┐
│ 3. AI Confirms Slot and Requests Confirmation                          │
│    - AI speaks: "Yes, Friday at 3:00 PM is wide open! Shall I lock that in?"
└────────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
[Caller Confirms]: "Yes, please book it."
                                   │
                                   ▼ (Elapsed Time: 120ms)
┌────────────────────────────────────────────────────────────────────────┐
│ 4. Concurrent Slot Creation & Live SMS Gateway Dispatch                │
│    - Google Calendar event created with Google Meet link               │
│    - SMS dispatched to caller mobile: "Your booking for Friday is set!"│
└────────────────────────────────────────────────────────────────────────┘

Atomic Slot Reservation Logic:

Caller A and Caller B Inquire Simultaneously for Friday 3:00 PM
                       │
                       ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 1. Distributed Redis Lock (Atomic SETNX with 60-Second TTL)            │
│    - Caller A acquires lock: lock:calendar:slot:20260908_1500          │
└────────────────────────────────────────────────────────────────────────┘
                       │
         ┌─────────────┴─────────────┐
         ▼                           ▼
Caller A (Lock Granted)     Caller B (Lock Contended)
"Friday 3:00 PM is open!    "Friday 3:00 PM was just reserved.
Shall I confirm it?"        I have 3:30 PM or 4:00 PM open.
                            Which works better?"

import asyncio
import json
from datetime import datetime, timedelta

class LiveAppointmentBookingEngine:
    """
    Handles streaming tool execution for calendar scheduling and instant
    SMS confirmation dispatch during an active telephone call.
    """
    def __init__(self, calendar_api_token: str, sms_gateway_token: str):
        self.calendar_token = calendar_api_token
        self.sms_token = sms_gateway_token

    async def check_slot_availability(self, target_date: str, target_time: str) -> dict:
        """Simulates checking calendar resource in <35ms."""
        await asyncio.sleep(0.035) # Simulates low-latency Google Calendar API call
        print(f"[Calendar API]: Verified {target_date} at {target_time} is AVAILABLE.")
        return {"status": "available", "date": target_date, "time": target_time}

    async def book_appointment_slot(self, patient_name: str, patient_phone: str, slot_time: str) -> dict:
        """Creates calendar event and triggers live SMS dispatch concurrently."""
        print(f"[Booking]: Creating Google Calendar event for {patient_name}...")
        await asyncio.sleep(0.045) # Simulates calendar event insertion

        event_details = {
            "summary": f"Consultation - {patient_name}",
            "start": slot_time,
            "attendees": [patient_phone]
        }

        # Dispatch instant SMS confirmation in background
        asyncio.create_task(self.dispatch_live_sms(
            phone_number=patient_phone,
            message=f"Hi {patient_name}, your appointment is confirmed for {slot_time}! Add to calendar: https://cal.com/e/8812"
        ))

        return {"status": "confirmed", "event": event_details}

    async def dispatch_live_sms(self, phone_number: str, message: str):
        """Sends SMS via carrier API while caller is still on the line."""
        await asyncio.sleep(0.040) # Simulates carrier SMS dispatch
        print(f"[SMS Gateway]: Instant text sent to {phone_number}: '{message}'")

# Example execution flow
if __name__ == "__main__":
    engine = LiveAppointmentBookingEngine("google_cal_token_2026", "twilio_sms_token")

    async def simulate_call_turn():
        # Step 1: Check availability
        availability = await engine.check_slot_availability("2026-09-08", "15:00")

        # Step 2: Book slot & trigger SMS
        if availability["status"] == "available":
            result = await engine.book_appointment_slot(
                patient_name="Sarah Jenkins",
                patient_phone="+15550192831",
                slot_time="Friday, Sept 8 at 3:00 PM"
            )
            print(f"[Call Result]: {result['status'].upper()} - Ready for caller goodbye.")

    asyncio.run(simulate_call_turn())

Advanced Scheduling Edge Cases:

1. Timezone Normalization:
   - Caller says: "I want 10:00 AM Central Time."
   - AI converts: 10:00 AM CST ──► 11:00 AM EST (Clinic primary calendar timezone).
   - Confirms back: "Got it! That is 10:00 AM your time, which is 11:00 AM our time."

2. Rescheduling Existing Bookings:
   - AI queries by caller phone number (Caller ID).
   - Locates existing booking on Wednesday at 2:00 PM.
   - Deletes prior booking and issues new confirmation in under 80ms.

3. Multi-Attendee Calendar Invites:
   - Collects secondary emails (*"Can you invite my spouse at sarah@acme.com?"*)
   - Dispatches Google Calendar invites to all participants simultaneously.