Initial VoiceCal.ai v1.0.0 deployment

Clean repository structure for HuggingFace Spaces deployment:
- All files at root level (no nested directories)
- Standard Docker deployment structure
- JWT session management for stateless deployment
- Voice interface with STT/TTS integration
- Google Calendar integration with OAuth2
- Groq Llama-3.1-8b-instant LLM backend

Features:
- Voice-first booking interface (/chat-widget)
- 15-minute time slot increments
- Google Meet integration
- Email confirmations
- Multi-turn conversation support

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -0,0 +1,27 @@
+# Anthropic API (optional)
+ANTHROPIC_API_KEY=
+
+# Gemini API
+GEMINI_API_KEY=your_gemini_api_key_here
+# Google Calendar
+GOOGLE_CALENDAR_ID=pgits.job@gmail.com
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+
+# Session Backend (redis for local, jwt for HF)
+SESSION_BACKEND=redis
+# Redis Configuration (only needed if SESSION_BACKEND=redis)
+REDIS_URL=redis://redis:6379/0
+
+# Application Settings
+APP_NAME=ChatCal.ai
+APP_ENV=development
+APP_PORT=8000
+APP_HOST=0.0.0.0
+
+# Security
+SECRET_KEY=
+CORS_ORIGINS=["http://localhost:3000", "http://localhost:8000"]
+
+# Timezone
+DEFAULT_TIMEZONE=America/New_York

.gitignore

@@ -0,0 +1,134 @@
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# macOS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log
+server.log
+
+# Redis dump file
+dump.rdb
+
+# Google Calendar credentials
+credentials.json
+token.json
+
+# API testing
+test_api.py
+
+# Temporary files
+*.tmp
+*.temp

Dockerfile

@@ -0,0 +1,52 @@
+FROM python:3.11-slim
+
+# Environment variables for HF deployment
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV SESSION_BACKEND=jwt
+ENV APP_ENV=production
+ENV PORT=7860
+
+# Install system dependencies and debugging tools
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    wget \
+    git \
+    curl \
+    procps \
+    htop \
+    nano \
+    vim \
+    net-tools \
+    lsof \
+    strace \
+    telnet \
+    netcat-openbsd \
+    tree \
+    less \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN useradd -m -u 1000 user && \
+    chown -R user:user /app
+USER user
+
+# Expose port
+EXPOSE 7860
+
+# Run the application (no tee to prevent exit)
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,237 @@
+---
+title: VoiceCal.ai - Voice Calendar Assistant v1
+emoji: 🗓️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_file: app.py
+pinned: false
+suggested_hardware: cpu-basic
+suggested_storage: small
+startup_duration_timeout: 5m
+---
+
+# VoiceCal.ai v1.0.0 - AI-Powered Voice Calendar Assistant
+
+An intelligent AI scheduling assistant powered by Groq's Llama-3.1-8b-instant and LlamaIndex that helps users book appointments on Google Calendar with natural conversation and smart features.
+
+## Features
+
+- 🤖 **Groq-powered LLM**: Fast, efficient conversation using Llama-3.1-8b-instant
+- 📅 **Smart Calendar Integration**: Seamless Google Calendar booking with conflict detection
+- 🧠 **Conversation Memory**: Persistent context across multi-turn conversations
+- 🎨 **HTML-formatted Responses**: Rich, styled responses for better readability
+- 🆔 **Custom Meeting IDs**: Human-readable meeting IDs (MMDD-HHMM-DURm format)
+- 🗑️ **Smart Cancellation**: Intelligent meeting matching with automatic email notifications
+- 🎥 **Google Meet Integration**: Automatic video conference setup for remote meetings
+- 📧 **Email Notifications**: Automated booking confirmations and cancellation notices
+- 🧪 **Testing Mode**: Configurable testing environment for development
+- 🚀 **FastAPI Backend**: High-performance API with Redis session management
+- 🔒 **Secure Authentication**: OAuth2 for Google Calendar access
+- 🌍 **Timezone-aware**: Smart scheduling across time zones
+
+## Prerequisites
+
+- Python 3.11+
+- Docker and Docker Compose
+- Groq API key (primary LLM)
+- Anthropic API key (optional fallback)
+- Google Cloud Project with Calendar API enabled
+- Google OAuth2 credentials
+- SMTP credentials for email notifications
+
+## Quick Start
+
+### 1. Clone the repository
+```bash
+git clone <repository>
+cd chatcal-ai
+```
+
+### 2. Set up environment variables
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your credentials:
+- `GROQ_API_KEY`: Your Groq API key (primary)
+- `ANTHROPIC_API_KEY`: Your Anthropic API key (optional fallback)
+- `GOOGLE_CLIENT_ID` & `GOOGLE_CLIENT_SECRET`: From Google Cloud Console
+- `SECRET_KEY`: Generate a secure secret key
+- `MY_PHONE_NUMBER` & `MY_EMAIL_ADDRESS`: Contact information
+- `SMTP_USERNAME` & `SMTP_PASSWORD`: Email service credentials
+- `TESTING_MODE`: Set to true for development (ignores Peter's email validation)
+
+### 3. Google Calendar Setup
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com)
+2. Create a new project or select existing
+3. Enable Google Calendar API:
+   - Navigate to "APIs & Services" > "Library"
+   - Search for "Google Calendar API"
+   - Click "Enable"
+4. Create OAuth2 credentials:
+   - Go to "APIs & Services" > "Credentials"
+   - Click "Create Credentials" > "OAuth client ID"
+   - Choose "Web application"
+   - Add authorized redirect URIs:
+     - `http://localhost:8000/auth/callback`
+     - `https://yourdomain.com/auth/callback` (for production)
+   - Save and download the credentials
+
+### 4. Run with Docker
+
+```bash
+# Build and start all services
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Stop services
+docker-compose down
+```
+
+The application will be available at:
+- API: http://localhost:8000
+- API Docs: http://localhost:8000/docs
+
+### 5. Development Setup (without Docker)
+
+```bash
+# Install Poetry
+pip install poetry
+
+# Install dependencies
+poetry install
+
+# Activate virtual environment
+poetry shell
+
+# Run the application
+uvicorn app.api.main:app --reload
+```
+
+## Project Structure
+
+```
+chatcal-ai/
+├── app/
+│   ├── core/           # Agent, LLM (Groq), tools, and email service
+│   ├── calendar/       # Google Calendar integration
+│   ├── api/           # FastAPI endpoints (simple-chat, chat-widget)
+│   └── personality/   # System prompts and response templates
+├── frontend/          # Web UI with HTML response rendering
+├── docker/           # Docker configurations
+├── tests/           # Test suite
+├── credentials/     # Google credentials (gitignored)
+└── docker-compose.yml
+```
+
+## API Endpoints
+
+- `POST /chat` - Send a message to the chatbot (with HTML response support)
+- `GET /simple-chat` - Simple chat interface for testing
+- `GET /chat-widget` - Embeddable chat widget with HTML rendering
+- `GET /health` - Health check endpoint
+- `POST /sessions` - Create new session
+- `GET /auth/login` - Initiate Google OAuth flow
+- `GET /auth/callback` - OAuth callback handler
+
+## Deployment
+
+### Deploy to any platform with Docker:
+
+1. Build the production image:
+```bash
+docker build -t chatcal-ai:latest .
+```
+
+2. Push to your container registry:
+```bash
+docker tag chatcal-ai:latest your-registry/chatcal-ai:latest
+docker push your-registry/chatcal-ai:latest
+```
+
+3. Deploy using your platform's container service (ECS, GKE, Azure Container Instances, etc.)
+
+### Embed in landing pages:
+
+Add the chat widget to any webpage:
+```html
+<iframe 
+  src="https://your-deployment.com/chat-widget" 
+  width="400" 
+  height="600"
+  frameborder="0">
+</iframe>
+```
+
+## Key Features
+
+### Conversation Memory
+- Persistent conversation context using ChatMemoryBuffer
+- Multi-turn dialog support for complex booking flows
+- User information extraction and retention
+
+### Smart Meeting Management
+- **Custom Meeting IDs**: Format MMDD-HHMM-DURm (e.g., 0731-1400-60m)
+- **Intelligent Cancellation**: Matches meetings by user name and date/time
+- **Automatic Email Notifications**: Booking confirmations and cancellation notices
+
+### HTML Response Formatting
+- Rich, styled responses with proper formatting
+- Color-coded status messages (confirmations, cancellations, errors)
+- Easy-to-read meeting details and contact information
+
+### Google Meet Integration
+- Automatic detection of video meeting requests
+- Google Meet link generation and embedding
+- Support for both in-person and remote meetings
+
+## Configuration
+
+See `app/config.py` for all available settings. Key configurations:
+
+- `MAX_CONVERSATION_HISTORY`: Number of messages to maintain in context
+- `SESSION_TIMEOUT_MINUTES`: Session expiration time
+- `DEFAULT_TIMEZONE`: Default timezone for appointments
+- `TESTING_MODE`: Enable/disable testing features
+
+## Testing
+
+```bash
+# Run tests
+poetry run pytest
+
+# Run with coverage
+poetry run pytest --cov=app
+
+# Run linting
+poetry run black .
+poetry run flake8
+```
+
+## Security Considerations
+
+- Always use HTTPS in production
+- Keep your API keys secure and never commit them
+- Implement rate limiting for production deployments
+- Use environment-specific configurations
+- Regular security audits of dependencies
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and linting
+5. Submit a pull request
+
+## License
+
+[Your chosen license]
+
+## Support
+
+For issues or questions, please open an issue on GitHub or contact pgits.job@gmail.com

app.py

@@ -0,0 +1,43 @@
+"""
+HuggingFace Spaces entry point for ChatCal.ai
+Minimal changes - uses JWT sessions instead of Redis
+"""
+import os
+import sys
+import uvicorn
+from datetime import datetime
+
+# Add the current directory to Python path for imports
+sys.path.insert(0, '/app')
+
+# Set HF-specific environment variables
+os.environ.setdefault("SESSION_BACKEND", "jwt")
+os.environ.setdefault("APP_ENV", "production")
+os.environ.setdefault("APP_PORT", "7860")  # HF Spaces default port
+
+# Import after setting up the path
+from app.api.main import app
+
+if __name__ == "__main__":
+    import logging
+
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('/tmp/app.log'),
+            logging.StreamHandler()
+        ]
+    )
+
+    port = int(os.environ.get("PORT", os.environ.get("APP_PORT", 7860)))
+    print(f"===== Application Startup at {datetime.now()} =====")
+    print(f"🚀 Starting ChatCal.ai on port {port}")
+
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )

app/api/chat_widget.py

@@ -0,0 +1,1401 @@
+"""Chat widget HTML interface for ChatCal.ai."""
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+
+router = APIRouter()
+
+
+@router.get("/chat-widget", response_class=HTMLResponse)
+async def chat_widget(request: Request):
+    """Embeddable chat widget."""
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+    
+    return f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>ChatCal.ai - Calendar Assistant</title>
+        <style>
+            * {{
+                margin: 0;
+                padding: 0;
+                box-sizing: border-box;
+            }}
+            
+            body {{
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                padding: 20px;
+            }}
+            
+            .chat-container {{
+                background: white;
+                border-radius: 20px;
+                box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+                width: 100%;
+                max-width: 800px;
+                height: 600px;
+                display: flex;
+                flex-direction: column;
+                overflow: hidden;
+            }}
+            
+            .chat-header {{
+                background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
+                color: white;
+                padding: 20px;
+                text-align: center;
+                position: relative;
+            }}
+            
+            .chat-header h1 {{
+                font-size: 24px;
+                margin-bottom: 5px;
+            }}
+            
+            .chat-header p {{
+                opacity: 0.9;
+                font-size: 14px;
+            }}
+            
+            .status-indicator {{
+                position: absolute;
+                top: 20px;
+                right: 20px;
+                width: 12px;
+                height: 12px;
+                background: #4CAF50;
+                border-radius: 50%;
+                border: 2px solid white;
+                animation: pulse 2s infinite;
+            }}
+            
+            @keyframes pulse {{
+                0% {{ opacity: 1; }}
+                50% {{ opacity: 0.5; }}
+                100% {{ opacity: 1; }}
+            }}
+            
+            .chat-messages {{
+                flex: 1;
+                padding: 20px;
+                overflow-y: auto;
+                background: #f8f9fa;
+            }}
+            
+            .message {{
+                margin-bottom: 15px;
+                display: flex;
+                align-items: flex-start;
+                gap: 10px;
+            }}
+            
+            .message.user {{
+                flex-direction: row-reverse;
+            }}
+            
+            .message-avatar {{
+                width: 36px;
+                height: 36px;
+                border-radius: 50%;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                font-size: 16px;
+                flex-shrink: 0;
+            }}
+            
+            .message.user .message-avatar {{
+                background: #2196F3;
+                color: white;
+            }}
+            
+            .message.assistant .message-avatar {{
+                background: #4CAF50;
+                color: white;
+            }}
+            
+            .message-content {{
+                max-width: 70%;
+                padding: 12px 16px;
+                border-radius: 18px;
+                line-height: 1.4;
+                white-space: pre-wrap;
+            }}
+            
+            .message.user .message-content {{
+                background: #2196F3;
+                color: white;
+                border-bottom-right-radius: 4px;
+            }}
+            
+            .message.assistant .message-content {{
+                background: white;
+                color: #333;
+                border: 1px solid #e0e0e0;
+                border-bottom-left-radius: 4px;
+            }}
+            
+            .chat-input {{
+                padding: 20px;
+                background: white;
+                border-top: 1px solid #e0e0e0;
+                display: flex;
+                gap: 10px;
+                align-items: center;
+            }}
+            
+            .chat-input textarea {{
+                flex: 1;
+                padding: 12px 16px;
+                border: 2px solid #e0e0e0;
+                border-radius: 20px;
+                outline: none;
+                font-size: 14px;
+                font-family: inherit;
+                resize: none;
+                min-height: 20px;
+                max-height: 120px;
+                overflow-y: auto;
+                line-height: 1.4;
+                transition: border-color 0.3s;
+            }}
+            
+            .chat-input textarea:focus {{
+                border-color: #4CAF50;
+            }}
+            
+            .chat-input button {{
+                width: 40px;
+                height: 40px;
+                border: none;
+                background: #4CAF50;
+                color: white;
+                border-radius: 50%;
+                cursor: pointer;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                transition: background-color 0.3s;
+            }}
+            
+            .chat-input button:hover {{
+                background: #45a049;
+            }}
+            
+            .chat-input button:disabled {{
+                background: #ccc;
+                cursor: not-allowed;
+            }}
+            
+            .typing-indicator {{
+                display: none;
+                padding: 12px 16px;
+                background: white;
+                border: 1px solid #e0e0e0;
+                border-radius: 18px;
+                border-bottom-left-radius: 4px;
+                max-width: 70%;
+                margin-bottom: 15px;
+            }}
+            
+            .typing-dots {{
+                display: flex;
+                gap: 4px;
+            }}
+            
+            .typing-dots span {{
+                width: 8px;
+                height: 8px;
+                background: #999;
+                border-radius: 50%;
+                animation: typing 1.4s infinite;
+            }}
+            
+            .typing-dots span:nth-child(2) {{
+                animation-delay: 0.2s;
+            }}
+            
+            .typing-dots span:nth-child(3) {{
+                animation-delay: 0.4s;
+            }}
+            
+            @keyframes typing {{
+                0%, 60%, 100% {{
+                    transform: translateY(0);
+                    opacity: 0.4;
+                }}
+                30% {{
+                    transform: translateY(-10px);
+                    opacity: 1;
+                }}
+            }}
+            
+            .welcome-message {{
+                text-align: center;
+                color: #666;
+                font-style: italic;
+                margin: 20px 0;
+            }}
+            
+            .quick-actions {{
+                display: flex;
+                gap: 10px;
+                margin: 10px 0;
+                flex-wrap: wrap;
+            }}
+            
+            .quick-action {{
+                background: #f0f0f0;
+                color: #555;
+                padding: 8px 12px;
+                border-radius: 15px;
+                border: none;
+                cursor: pointer;
+                font-size: 12px;
+                transition: background-color 0.3s;
+            }}
+            
+            .quick-action:hover {{
+                background: #e0e0e0;
+            }}
+            
+            /* STT Quick Action Animation */
+            .quick-action.listening {{
+                animation: stt-recording-pulse 1.5s infinite;
+            }}
+
+            @keyframes stt-recording-pulse {{
+                0% {{
+                    transform: scale(1);
+                    box-shadow: 0 0 0 0 rgba(244, 67, 54, 0.4);
+                }}
+                50% {{
+                    transform: scale(1.05);
+                    box-shadow: 0 0 0 8px rgba(244, 67, 54, 0.1);
+                }}
+                100% {{
+                    transform: scale(1);
+                    box-shadow: 0 0 0 0 rgba(244, 67, 54, 0.4);
+                }}
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="chat-container">
+            <div class="chat-header">
+                <div class="status-indicator"></div>
+                <h1>🌟 ChatCal.ai</h1>
+                <p>Your friendly AI calendar assistant</p>
+            </div>
+            
+            <div class="chat-messages" id="chatMessages">
+                <div class="welcome-message">
+                    👋 Welcome! I'm ChatCal, Peter Michael Gits' scheduling assistant.<br>
+                    I can schedule business consultations, project meetings, and advisory sessions.<br>
+                    <strong>📝 To book:</strong> <strong>name</strong>, <strong>topic</strong>, <strong>day</strong>, <strong>time</strong>, <strong>length</strong>, <strong>type</strong>: GoogleMeet (requires your <strong>email</strong>), or call (requires your <strong>phone #</strong>)<br>
+                    <em>(Otherwise I will ask for it and may get the email address wrong unless you spell it out military style.)</em>
+                </div>
+                
+                <div class="quick-actions">
+                    <button id="sttIndicator" class="quick-action muted" title="Click to start/stop voice input">🎙️ Voice Input</button>
+                    <button class="quick-action" onclick="sendQuickMessage('Schedule a Google Meet with Peter')">🎥 Google Meet</button>
+                    <button class="quick-action" onclick="sendQuickMessage('Check Peter\\'s availability tomorrow')">📅 Check availability</button>
+                    <button class="quick-action" onclick="sendQuickMessage('Schedule an in-person meeting')">🤝 In-person meeting</button>
+                    <button class="quick-action" onclick="sendQuickMessage('/help')">❓ Help</button>
+                </div>
+            </div>
+            
+            <div class="typing-indicator" id="typingIndicator">
+                <div class="typing-dots">
+                    <span></span>
+                    <span></span>
+                    <span></span>
+                </div>
+            </div>
+            
+            <div class="chat-input">
+                <textarea
+                    id="messageInput"
+                    placeholder="Type your message..."
+                    maxlength="1000"
+                    rows="1"
+                ></textarea>
+                <button id="sendButton" type="button">
+                    <svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor">
+                        <path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"/>
+                    </svg>
+                </button>
+            </div>
+
+            <!-- Version Footer -->
+            <div style="text-align: center; margin-top: 10px; padding: 5px; color: #999; font-size: 10px; border-top: 1px solid #f0f0f0;">
+                ChatCal.ai v0.3.0 | ⚡ Streaming + Interruption | 📧 Smart Email Verification
+            </div>
+        </div>
+
+        <!-- Hidden audio element for TTS playback -->
+        <audio id="ttsAudioElement" style="display: none;"></audio>
+        
+        <script>
+            let sessionId = null;
+            let isLoading = false;
+            
+            const chatMessages = document.getElementById('chatMessages');
+            const messageInput = document.getElementById('messageInput');
+            const sendButton = document.getElementById('sendButton');
+            const typingIndicator = document.getElementById('typingIndicator');
+            const sttIndicator = document.getElementById('sttIndicator');
+            
+            // Shared Audio Variables (for both TTS and STT)
+            let globalAudioContext = null;
+            let globalMediaStream = null;
+            let isAudioInitialized = false;
+            
+            // STT v2 Variables
+            let sttv2Manager = null;
+            let silenceTimer = null;
+            let lastSpeechTime = 0;
+            let hasReceivedSpeech = false;
+            
+            // TTS Integration - ChatCal WebRTC TTS Class
+            class ChatCalTTS {{
+                constructor() {{
+                    this.audioContext = null;
+                    this.audioElement = document.getElementById('ttsAudioElement');
+                    this.webrtcEnabled = false;
+                    this.initializeTTS();
+                }}
+                
+                async initializeTTS() {{
+                    try {{
+                        console.log('🎤 Initializing WebRTC TTS for ChatCal...');
+                        
+                        // Request microphone access to enable WebRTC autoplay policies
+                        const stream = await navigator.mediaDevices.getUserMedia({{ audio: true }});
+                        
+                        // Create AudioContext
+                        this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                        
+                        // Resume if suspended
+                        if (this.audioContext.state === 'suspended') {{
+                            await this.audioContext.resume();
+                        }}
+                        
+                        // Stop microphone (we don't need to record)
+                        stream.getTracks().forEach(track => track.stop());
+                        
+                        this.webrtcEnabled = true;
+                        console.log('✅ WebRTC TTS enabled for ChatCal');
+                        
+                    }} catch (error) {{
+                        console.warn('⚠️  TTS initialization failed, continuing without TTS:', error);
+                        this.webrtcEnabled = false;
+                    }}
+                }}
+                
+                async synthesizeAndPlay(text) {{
+                    if (!this.webrtcEnabled || !text.trim()) {{
+                        return;
+                    }}
+                    
+                    try {{
+                        console.log('🎵 Synthesizing TTS for:', text.substring(0, 50) + '...');
+                        
+                        // Call TTS proxy server
+                        const response = await fetch('http://localhost:8081/api/synthesize', {{
+                            method: 'POST',
+                            headers: {{
+                                'Content-Type': 'application/json',
+                            }},
+                            body: JSON.stringify({{
+                                text: text,
+                                voice: 'expresso/ex03-ex01_happy_001_channel1_334s.wav'
+                            }})
+                        }});
+                        
+                        if (!response.ok) {{
+                            throw new Error('TTS service unavailable');
+                        }}
+                        
+                        const data = await response.json();
+                        if (!data.success || !data.audio_url) {{
+                            throw new Error('TTS generation failed');
+                        }}
+                        
+                        // Fetch the audio file
+                        const audioResponse = await fetch(`http://localhost:8081${{data.audio_url}}`);
+                        if (!audioResponse.ok) {{
+                            throw new Error('Audio file not found');
+                        }}
+                        
+                        const audioArrayBuffer = await audioResponse.arrayBuffer();
+                        const audioBuffer = await this.audioContext.decodeAudioData(audioArrayBuffer);
+                        
+                        // Play via WebRTC MediaStream
+                        await this.playAudioWithWebRTC(audioBuffer);
+                        
+                    }} catch (error) {{
+                        console.warn('🔇 TTS failed silently:', error);
+                        // Fail silently as requested - no error handling UI
+                    }}
+                }}
+                
+                async playAudioWithWebRTC(audioBuffer) {{
+                    try {{
+                        console.log('🔊 Playing TTS audio via WebRTC...');
+                        
+                        // Create MediaStream from audio buffer
+                        const source = this.audioContext.createBufferSource();
+                        const destination = this.audioContext.createMediaStreamDestination();
+                        
+                        source.buffer = audioBuffer;
+                        source.connect(destination);
+                        
+                        // Set the MediaStream to audio element
+                        this.audioElement.srcObject = destination.stream;
+                        
+                        // Start the audio source
+                        source.start(0);
+                        
+                        // Play - should work due to WebRTC permissions
+                        await this.audioElement.play();
+                        console.log('🎵 TTS audio playing successfully');
+                        
+                    }} catch (error) {{
+                        console.warn('🔇 WebRTC audio playback failed:', error);
+                    }}
+                }}
+            }}
+            
+            // Initialize TTS system
+            const chatCalTTS = new ChatCalTTS();
+            
+            // Shared Audio Initialization (for TTS only now, STT v2 handles its own audio)
+            async function initializeSharedAudio() {{
+                if (isAudioInitialized) return;
+
+                console.log('🎤 Initializing shared audio for TTS...');
+
+                // Basic audio context for TTS
+                globalAudioContext = new AudioContext();
+
+                if (globalAudioContext.state === 'suspended') {{
+                    await globalAudioContext.resume();
+                }}
+
+                isAudioInitialized = true;
+                console.log('✅ Shared audio initialized for TTS');
+            }}
+
+            // STT Visual State Management
+            function updateSTTVisualState(state) {{
+                const sttIndicator = document.getElementById('sttIndicator');
+                if (!sttIndicator) return;
+
+                // Remove all status classes first
+                sttIndicator.classList.remove('muted', 'listening');
+
+                switch (state) {{
+                    case 'ready':
+                        sttIndicator.innerHTML = '🎙️ Start Recording';
+                        sttIndicator.title = 'Click to start voice recording';
+                        sttIndicator.classList.add('muted');
+                        sttIndicator.style.background = '#f0f0f0';
+                        sttIndicator.style.color = '#555';
+                        break;
+                    case 'connecting':
+                        sttIndicator.innerHTML = '🔄 Connecting...';
+                        sttIndicator.title = 'Connecting to voice service...';
+                        sttIndicator.style.background = '#fff3cd';
+                        sttIndicator.style.color = '#856404';
+                        break;
+                    case 'recording':
+                        sttIndicator.innerHTML = '⏹️ Stop & Send';
+                        sttIndicator.title = 'Click to stop recording and transcribe';
+                        sttIndicator.classList.add('listening');
+                        sttIndicator.style.background = '#ffebee';
+                        sttIndicator.style.color = '#d32f2f';
+                        sttIndicator.style.fontWeight = 'bold';
+                        break;
+                    case 'processing':
+                        sttIndicator.innerHTML = '⚡ Transcribing...';
+                        sttIndicator.title = 'Processing your speech...';
+                        sttIndicator.style.background = '#d1ecf1';
+                        sttIndicator.style.color = '#0c5460';
+                        sttIndicator.style.fontWeight = 'normal';
+                        break;
+                    case 'error':
+                        sttIndicator.innerHTML = '❌ Try Again';
+                        sttIndicator.title = 'Click to retry voice recording';
+                        sttIndicator.style.background = '#f8d7da';
+                        sttIndicator.style.color = '#721c24';
+                        sttIndicator.style.fontWeight = 'normal';
+                        break;
+                }}
+            }}
+
+            // STT v2 Manager Class (adapted from stt-gpu-service-v2/client-stt/v2-audio-client.js)
+            class STTv2Manager {{
+                constructor() {{
+                    this.isRecording = false;
+                    this.mediaRecorder = null;
+                    this.audioChunks = [];
+                    this.serverUrl = 'https://pgits-stt-gpu-service-v2.hf.space';
+                    this.language = 'en';
+                    this.modelSize = 'base';
+                    this.recordingTimer = null;
+                    this.maxRecordingTime = 30000; // 30 seconds max
+
+                    console.log('🎤 STT v2 Manager initialized');
+                }}
+
+                generateSessionHash() {{
+                    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+                }}
+
+                async toggleRecording() {{
+                    if (!this.isRecording) {{
+                        await this.startRecording();
+                    }} else {{
+                        await this.stopRecording();
+                    }}
+                }}
+
+                async startRecording() {{
+                    try {{
+                        console.log('🎤 Starting STT v2 recording...');
+                        updateSTTVisualState('connecting');
+
+                        const stream = await navigator.mediaDevices.getUserMedia({{
+                            audio: {{
+                                sampleRate: 44100,
+                                channelCount: 1,
+                                echoCancellation: true,
+                                noiseSuppression: true,
+                                autoGainControl: true
+                            }}
+                        }});
+
+                        this.mediaRecorder = new MediaRecorder(stream, {{
+                            mimeType: 'audio/webm;codecs=opus'
+                        }});
+
+                        this.audioChunks = [];
+
+                        this.mediaRecorder.ondataavailable = (event) => {{
+                            if (event.data.size > 0) {{
+                                this.audioChunks.push(event.data);
+                            }}
+                        }};
+
+                        this.mediaRecorder.onstop = () => {{
+                            this.processRecording();
+                        }};
+
+                        this.mediaRecorder.start();
+                        this.isRecording = true;
+                        updateSTTVisualState('recording');
+                        sttIndicator.classList.remove('muted');
+                        sttIndicator.classList.add('listening');
+
+                        // Auto-stop after max recording time
+                        this.recordingTimer = setTimeout(() => {{
+                            if (this.isRecording) {{
+                                console.log('⏰ Auto-stopping recording after 30 seconds');
+                                this.stopRecording();
+                            }}
+                        }}, this.maxRecordingTime);
+
+                        console.log('✅ STT v2 recording started (auto-stop in 30s)');
+
+                    }} catch (error) {{
+                        console.error('❌ STT v2 recording failed:', error);
+                        updateSTTVisualState('error');
+                        setTimeout(() => updateSTTVisualState('ready'), 3000);
+                    }}
+                }}
+
+                async stopRecording() {{
+                    if (this.mediaRecorder && this.isRecording) {{
+                        console.log('🔚 Stopping STT v2 recording...');
+
+                        // Clear the auto-stop timer
+                        if (this.recordingTimer) {{
+                            clearTimeout(this.recordingTimer);
+                            this.recordingTimer = null;
+                        }}
+
+                        this.mediaRecorder.stop();
+                        this.isRecording = false;
+                        updateSTTVisualState('processing');
+                        sttIndicator.classList.remove('listening');
+                        sttIndicator.classList.add('muted');
+
+                        // Stop all tracks
+                        this.mediaRecorder.stream.getTracks().forEach(track => track.stop());
+                        console.log('✅ STT v2 recording stopped');
+                    }}
+                }}
+
+                async processRecording() {{
+                    if (this.audioChunks.length === 0) {{
+                        updateSTTVisualState('error');
+                        setTimeout(() => updateSTTVisualState('ready'), 3000);
+                        console.warn('⚠️ No audio recorded');
+                        return;
+                    }}
+
+                    try {{
+                        console.log('🔄 Processing STT v2 recording...');
+
+                        // Create blob from chunks
+                        const audioBlob = new Blob(this.audioChunks, {{ type: 'audio/webm;codecs=opus' }});
+                        console.log(`📦 Audio blob created: ${{audioBlob.size}} bytes`);
+
+                        // Convert to base64
+                        const audioBase64 = await this.blobToBase64(audioBlob);
+                        console.log(`🔗 Base64 length: ${{audioBase64.length}} characters`);
+
+                        // Send to transcription service
+                        await this.transcribeAudio(audioBase64);
+
+                    }} catch (error) {{
+                        console.error('❌ STT v2 processing failed:', error);
+                        updateSTTVisualState('error');
+                        setTimeout(() => updateSTTVisualState('ready'), 3000);
+                    }}
+                }}
+
+                async blobToBase64(blob) {{
+                    return new Promise((resolve, reject) => {{
+                        const reader = new FileReader();
+                        reader.onloadend = () => {{
+                            const result = reader.result;
+                            // Extract base64 part from data URL
+                            const base64 = result.split(',')[1];
+                            resolve(base64);
+                        }};
+                        reader.onerror = reject;
+                        reader.readAsDataURL(blob);
+                    }});
+                }}
+
+                async transcribeAudio(audioBase64) {{
+                    const sessionHash = this.generateSessionHash();
+                    const payload = {{
+                        data: [
+                            audioBase64,
+                            this.language,
+                            this.modelSize
+                        ],
+                        session_hash: sessionHash
+                    }};
+
+                    console.log(`📤 Sending to STT v2 service: ${{this.serverUrl}}/call/gradio_transcribe_memory`);
+
+                    try {{
+                        const startTime = Date.now();
+
+                        const response = await fetch(`${{this.serverUrl}}/call/gradio_transcribe_memory`, {{
+                            method: 'POST',
+                            headers: {{
+                                'Content-Type': 'application/json',
+                            }},
+                            body: JSON.stringify(payload)
+                        }});
+
+                        if (!response.ok) {{
+                            throw new Error(`STT v2 request failed: ${{response.status}}`);
+                        }}
+
+                        const responseData = await response.json();
+                        console.log('📨 STT v2 queue response:', responseData);
+
+                        let result;
+
+                        if (responseData.event_id) {{
+                            console.log(`🎯 Got queue event_id: ${{responseData.event_id}}`);
+                            result = await this.listenForQueueResult(responseData, startTime, sessionHash);
+                        }} else if (responseData.data && Array.isArray(responseData.data)) {{
+                            result = responseData.data[0];
+                            console.log('📥 Got direct response from queue');
+                        }} else {{
+                            throw new Error(`Unexpected response format: ${{JSON.stringify(responseData)}}`);
+                        }}
+
+                        if (result && result.trim()) {{
+                            const processingTime = (Date.now() - startTime) / 1000;
+                            console.log(`✅ STT v2 transcription successful (${{processingTime.toFixed(2)}}s): "${{result.substring(0, 100)}}"`);
+
+                            // Add transcription to message input
+                            this.addTranscriptionToInput(result);
+                            updateSTTVisualState('ready');
+                        }} else {{
+                            console.warn('⚠️ Empty transcription result');
+                            updateSTTVisualState('ready');
+                        }}
+
+                    }} catch (error) {{
+                        console.error('❌ STT v2 transcription failed:', error);
+                        updateSTTVisualState('error');
+                        setTimeout(() => updateSTTVisualState('ready'), 3000);
+                    }}
+                }}
+
+                async listenForQueueResult(queueResponse, startTime, sessionHash) {{
+                    return new Promise((resolve, reject) => {{
+                        const wsUrl = this.serverUrl.replace('https://', 'wss://').replace('http://', 'ws://') + '/queue/data';
+                        console.log(`🔌 Connecting to STT v2 WebSocket: ${{wsUrl}}`);
+
+                        const ws = new WebSocket(wsUrl);
+
+                        const timeout = setTimeout(() => {{
+                            ws.close();
+                            reject(new Error('STT v2 queue timeout after 30 seconds'));
+                        }}, 30000);
+
+                        ws.onopen = () => {{
+                            console.log('✅ STT v2 WebSocket connected');
+                            if (queueResponse.event_id) {{
+                                ws.send(JSON.stringify({{
+                                    event_id: queueResponse.event_id
+                                }}));
+                                console.log(`📤 Sent event_id: ${{queueResponse.event_id}}`);
+                            }}
+                        }};
+
+                        ws.onmessage = (event) => {{
+                            try {{
+                                const data = JSON.parse(event.data);
+                                console.log('📨 STT v2 queue message:', data);
+
+                                if (data.msg === 'process_completed' && data.output && data.output.data) {{
+                                    clearTimeout(timeout);
+                                    ws.close();
+                                    resolve(data.output.data[0]);
+                                }} else if (data.msg === 'process_starts') {{
+                                    updateSTTVisualState('processing');
+                                }}
+                            }} catch (e) {{
+                                console.warn('⚠️ STT v2 WebSocket parse error:', e.message);
+                            }}
+                        }};
+
+                        ws.onerror = (error) => {{
+                            console.error('❌ STT v2 WebSocket error:', error);
+                            clearTimeout(timeout);
+                            // Try polling as fallback
+                            this.pollForResult(queueResponse.event_id, startTime, sessionHash).then(resolve).catch(reject);
+                        }};
+
+                        ws.onclose = (event) => {{
+                            console.log(`🔌 STT v2 WebSocket closed: code=${{event.code}}`);
+                            clearTimeout(timeout);
+                        }};
+                    }});
+                }}
+
+                async pollForResult(eventId, startTime, sessionHash) {{
+                    console.log(`🔄 Starting STT v2 polling for event: ${{eventId}}`);
+                    const maxAttempts = 20;
+
+                    for (let attempt = 0; attempt < maxAttempts; attempt++) {{
+                        try {{
+                            const endpoint = `/queue/data?event_id=${{eventId}}&session_hash=${{sessionHash}}`;
+                            const response = await fetch(`${{this.serverUrl}}${{endpoint}}`);
+
+                            if (response.ok) {{
+                                const responseText = await response.text();
+                                console.log(`📊 STT v2 poll attempt ${{attempt + 1}}: ${{responseText.substring(0, 200)}}`);
+
+                                if (responseText.includes('data: ')) {{
+                                    const lines = responseText.split('\\n');
+                                    for (const line of lines) {{
+                                        if (line.startsWith('data: ')) {{
+                                            try {{
+                                                const data = JSON.parse(line.substring(6));
+                                                if (data.msg === 'process_completed' && data.output && data.output.data) {{
+                                                    return data.output.data[0];
+                                                }}
+                                            }} catch (parseError) {{
+                                                console.warn('⚠️ STT v2 SSE parse error:', parseError.message);
+                                            }}
+                                        }}
+                                    }}
+                                }}
+                            }}
+                        }} catch (e) {{
+                            console.warn(`⚠️ STT v2 poll error attempt ${{attempt + 1}}:`, e.message);
+                        }}
+
+                        // Progressive delay
+                        const delay = attempt < 5 ? 200 : 500;
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                    }}
+
+                    throw new Error('STT v2 polling timeout - no result after 20 attempts');
+                }}
+
+                addTranscriptionToInput(transcription) {{
+                    const currentValue = messageInput.value;
+                    let newText = transcription.trim();
+
+                    // SMART EMAIL PARSING: Convert spoken email patterns to proper email format
+                    newText = this.parseSpokenEmail(newText);
+
+                    // Add transcription to message input
+                    if (currentValue && !currentValue.endsWith(' ')) {{
+                        messageInput.value = currentValue + ' ' + newText;
+                    }} else {{
+                        messageInput.value = currentValue + newText;
+                    }}
+
+                    // Move cursor to end
+                    messageInput.setSelectionRange(messageInput.value.length, messageInput.value.length);
+
+                    // Auto-resize textarea
+                    autoResizeTextarea();
+
+                    // Track speech activity for auto-submission
+                    lastSpeechTime = Date.now();
+                    hasReceivedSpeech = true;
+
+                    // UNIFIED TIMER: Always start 2.5 second timer after ANY transcription
+                    console.log('⏱️ Starting 2.5 second timer after transcription...');
+
+                    // Clear any existing timer first
+                    if (silenceTimer) {{
+                        clearTimeout(silenceTimer);
+                    }}
+
+                    // Check if transcription contains an email address for UI feedback only
+                    const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{{2,}}\b/;
+                    const hasEmail = emailRegex.test(newText);
+
+                    if (hasEmail) {{
+                        console.log('📧 Email detected - showing verification notice');
+                        this.showEmailVerificationNotice();
+                        this.highlightEmailInInput();
+                    }}
+
+                    // Start 2.5 second timer for ALL transcriptions (not just emails)
+                    silenceTimer = setTimeout(() => {{
+                        if (hasReceivedSpeech && messageInput.value.trim()) {{
+                            console.log('⏱️ 2.5 seconds completed after transcription, auto-submitting...');
+                            submitMessage();
+                        }}
+                    }}, 2500);
+
+                }}
+
+                showEmailVerificationNotice() {{
+                    // Create a temporary notification
+                    const notification = document.createElement('div');
+                    notification.style.cssText = `
+                        position: fixed;
+                        top: 20px;
+                        right: 20px;
+                        background: #e3f2fd;
+                        color: #1976d2;
+                        padding: 12px 16px;
+                        border-radius: 8px;
+                        border-left: 4px solid #2196f3;
+                        font-size: 14px;
+                        font-weight: 500;
+                        z-index: 1000;
+                        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+                        max-width: 300px;
+                        animation: slideIn 0.3s ease-out;
+                    `;
+                    notification.innerHTML = `
+                        <div style="display: flex; align-items: center; gap: 8px;">
+                            <span>📧</span>
+                            <div>
+                                <div style="font-weight: bold;">Email Detected!</div>
+                                <div style="font-size: 12px; opacity: 0.8;">You have 2.5 seconds to verify/edit before auto-submission</div>
+                            </div>
+                        </div>
+                    `;
+
+                    document.body.appendChild(notification);
+
+                    // Add CSS animation
+                    const style = document.createElement('style');
+                    style.textContent = `
+                        @keyframes slideIn {{
+                            from {{
+                                transform: translateX(100%);
+                                opacity: 0;
+                            }}
+                            to {{
+                                transform: translateX(0);
+                                opacity: 1;
+                            }}
+                        }}
+                    `;
+                    document.head.appendChild(style);
+
+                    // Remove notification after 4 seconds
+                    setTimeout(() => {{
+                        if (notification.parentNode) {{
+                            notification.style.animation = 'slideIn 0.3s ease-out reverse';
+                            setTimeout(() => {{
+                                if (notification.parentNode) {{
+                                    notification.parentNode.removeChild(notification);
+                                }}
+                            }}, 300);
+                        }}
+                    }}, 4000);
+                }}
+
+                highlightEmailInInput() {{
+                    // Find and select the email address in the input field
+                    const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{{2,}}\b/;
+                    const inputValue = messageInput.value;
+                    const match = inputValue.match(emailRegex);
+
+                    if (match) {{
+                        const emailStart = inputValue.indexOf(match[0]);
+                        const emailEnd = emailStart + match[0].length;
+
+                        // Focus the input field
+                        messageInput.focus();
+
+                        // Select the email address
+                        messageInput.setSelectionRange(emailStart, emailEnd);
+
+                        // Add visual styling to indicate selection
+                        messageInput.style.backgroundColor = '#fff3cd';
+                        messageInput.style.borderColor = '#ffc107';
+
+                        // Remove highlighting after 3 seconds or when user starts typing
+                        const removeHighlight = () => {{
+                            messageInput.style.backgroundColor = '';
+                            messageInput.style.borderColor = '';
+                        }};
+
+                        setTimeout(removeHighlight, 3000);
+
+                        // Remove highlight immediately when user starts typing
+                        const handleInput = () => {{
+                            removeHighlight();
+                            messageInput.removeEventListener('input', handleInput);
+                        }};
+                        messageInput.addEventListener('input', handleInput);
+                    }}
+                }}
+
+                parseSpokenEmail(text) {{
+                    // Convert common spoken email patterns to proper email format
+                    let processed = text;
+
+                    // Pattern 1: "pgits at gmail dot com" -> "pgits@gmail.com"
+                    processed = processed.replace(/\b(\w+)\s+at\s+(\w+)\s+dot\s+(\w+)\b/gi, '$1@$2.$3');
+
+                    // Pattern 2a: "pgitsatgmail.com" (catch this specific pattern first)
+                    processed = processed.replace(/(\w+)at(\w+)\.com/gi, '$1@$2.com');
+
+                    // Pattern 2b: "pgitsatgmail.org" and other domains
+                    processed = processed.replace(/(\w+)at(\w+)\.(\w+)/gi, '$1@$2.$3');
+
+                    // Pattern 3: "pgits at gmail.com" -> "pgits@gmail.com"
+                    processed = processed.replace(/\b(\w+)\s+at\s+(\w+\.\w+)\b/gi, '$1@$2');
+
+                    // Pattern 4: "pgitsatgmaildotcom" -> "pgits@gmail.com" (everything run together)
+                    processed = processed.replace(/\b(\w+)at(\w+)dot(\w+)\b/gi, '$1@$2.$3');
+
+                    // Pattern 5: "petergetsgitusat gmail.com" -> "petergetsgitus@gmail.com" (space before at)
+                    processed = processed.replace(/\b(\w+)\s*at\s+(\w+\.\w+)\b/gi, '$1@$2');
+
+                    // Pattern 6: "petergetsgitusat gmail dot com" -> "petergetsgitus@gmail.com"
+                    processed = processed.replace(/\b(\w+)\s*at\s+(\w+)\s+dot\s+(\w+)\b/gi, '$1@$2.$3');
+
+                    // Pattern 7: Handle multiple dots - "john at company dot co dot uk" -> "john@company.co.uk"
+                    processed = processed.replace(/\b(\w+)\s+at\s+([\w\s]+?)\s+dot\s+([\w\s]+)\b/gi, (match, username, domain, tld) => {{
+                        // Replace spaces and 'dot' with actual dots in domain part
+                        const cleanDomain = domain.replace(/\s+dot\s+/g, '.').replace(/\s+/g, '');
+                        const cleanTld = tld.replace(/\s+dot\s+/g, '.').replace(/\s+/g, '');
+                        return `${{username}}@${{cleanDomain}}.${{cleanTld}}`;
+                    }});
+
+                    // Log the conversion if any changes were made
+                    if (processed !== text) {{
+                        console.log(`📧 Email pattern converted: "${{text}}" -> "${{processed}}"`);
+                    }}
+
+                    return processed;
+                }}
+            }}
+
+            // Auto-submission function
+            function submitMessage() {{
+                const message = messageInput.value.trim();
+                if (message && !isLoading) {{
+                    // Clear the speech tracking
+                    hasReceivedSpeech = false;
+                    if (silenceTimer) {{
+                        clearTimeout(silenceTimer);
+                        silenceTimer = null;
+                    }}
+
+                    // Submit the message (using existing sendMessage logic)
+                    sendMessage(message);
+                }}
+            }}
+            
+            // Initialize session
+            async function initializeSession() {{
+                try {{
+                    const response = await fetch('{base_url}/sessions', {{
+                        method: 'POST',
+                        headers: {{
+                            'Content-Type': 'application/json',
+                        }},
+                        body: JSON.stringify({{user_data: {{}}}})
+                    }});
+                    
+                    if (response.ok) {{
+                        const data = await response.json();
+                        sessionId = data.session_id;
+                    }}
+                }} catch (error) {{
+                    console.error('Failed to initialize session:', error);
+                }}
+            }}
+            
+            async function addMessage(content, isUser = false) {{
+                const messageDiv = document.createElement('div');
+                messageDiv.className = `message ${{isUser ? 'user' : 'assistant'}}`;
+                
+                const avatar = document.createElement('div');
+                avatar.className = 'message-avatar';
+                avatar.textContent = isUser ? '👤' : '🤖';
+                
+                const messageContent = document.createElement('div');
+                messageContent.className = 'message-content';
+                
+                // For assistant messages, start TTS FIRST, then display with delay
+                if (!isUser && content && content.trim()) {{
+                    // Create temporary element to extract text content
+                    const tempDiv = document.createElement('div');
+                    tempDiv.innerHTML = content;
+                    const textContent = tempDiv.textContent || tempDiv.innerText;
+                    
+                    if (textContent && textContent.trim()) {{
+                        // Start TTS synthesis immediately (non-blocking)
+                        chatCalTTS.synthesizeAndPlay(textContent.trim());
+                        
+                        // Wait 500ms before displaying the text
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                    }}
+                    
+                    // Now render the HTML content
+                    messageContent.innerHTML = content;
+                }} else {{
+                    // For user messages, just set text content immediately
+                    messageContent.textContent = content;
+                }}
+                
+                messageDiv.appendChild(avatar);
+                messageDiv.appendChild(messageContent);
+                
+                // Simply append to chatMessages instead of insertBefore
+                chatMessages.appendChild(messageDiv);
+                chatMessages.scrollTop = chatMessages.scrollHeight;
+            }}
+            
+            function showTyping() {{
+                if (typingIndicator) {{
+                    typingIndicator.style.display = 'block';
+                }}
+                chatMessages.scrollTop = chatMessages.scrollHeight;
+            }}
+            
+            function hideTyping() {{
+                if (typingIndicator) {{
+                    typingIndicator.style.display = 'none';
+                }}
+            }}
+            
+            async function sendMessage(message = null) {{
+                const text = message || messageInput.value.trim();
+
+                if (!text || isLoading) {{
+                    return;
+                }}
+
+                // Ensure we have a session before sending
+                if (!sessionId) {{
+                    await initializeSession();
+                    if (!sessionId) {{
+                        await addMessage('Sorry, I had trouble connecting. Please try again!');
+                        return;
+                    }}
+                }}
+
+                // Add user message
+                await addMessage(text, true);
+                messageInput.value = '';
+
+                // Show loading state
+                isLoading = true;
+                sendButton.disabled = true;
+                showTyping();
+
+                try {{
+                    const response = await fetch('{base_url}/chat', {{
+                        method: 'POST',
+                        headers: {{
+                            'Content-Type': 'application/json',
+                        }},
+                        body: JSON.stringify({{
+                            message: text,
+                            session_id: sessionId
+                        }})
+                    }});
+
+                    if (response.ok) {{
+                        const data = await response.json();
+                        sessionId = data.session_id; // Update session ID
+                        await addMessage(data.response);
+
+                        // TTS integration - play the response
+                        if (chatCalTTS && chatCalTTS.webrtcEnabled && data.response) {{
+                            chatCalTTS.synthesizeAndPlay(data.response);
+                        }}
+                    }} else {{
+                        const error = await response.json();
+                        await addMessage(`Sorry, I encountered an error: ${{error.message || 'Unknown error'}}`);
+                    }}
+                }} catch (error) {{
+                    console.error('Chat error:', error);
+                    await addMessage('Sorry, I had trouble connecting. Please try again!');
+                }} finally {{
+                    isLoading = false;
+                    sendButton.disabled = false;
+                    hideTyping();
+
+                    // Clear any pending speech timers to allow fresh voice input
+                    hasReceivedSpeech = false;
+                    if (silenceTimer) {{
+                        clearTimeout(silenceTimer);
+                        silenceTimer = null;
+                    }}
+                }}
+            }}
+            
+            function sendQuickMessage(message) {{
+                messageInput.value = message;
+                sendMessage();
+            }}
+            
+            // Event listeners
+            messageInput.addEventListener('keypress', function(e) {{
+                if (e.key === 'Enter' && !e.shiftKey) {{
+                    e.preventDefault();
+                    sendMessage();
+                }}
+            }});
+            
+            // Auto-resize textarea as content grows
+            function autoResizeTextarea() {{
+                messageInput.style.height = 'auto';
+                const newHeight = Math.min(messageInput.scrollHeight, 120); // Max height 120px
+                messageInput.style.height = newHeight + 'px';
+            }}
+            
+            // Enhanced input handling with typing delay for STT
+            let typingTimer = null;
+            let lastTypingTime = 0;
+            let lastMouseMoveTime = 0;
+            let mouseTimer = null;
+
+            messageInput.addEventListener('input', function() {{
+                autoResizeTextarea();
+
+                // Track typing activity to delay STT auto-submission
+                lastTypingTime = Date.now();
+
+                // Mouse movement tracking for editing detection
+                lastMouseMoveTime = Date.now();
+
+                // If user is typing, clear any existing silence timer to prevent premature submission
+                if (silenceTimer) {{
+                    clearTimeout(silenceTimer);
+                    silenceTimer = null;
+                }}
+
+                // Clear existing typing timer
+                if (typingTimer) {{
+                    clearTimeout(typingTimer);
+                }}
+
+                // Set new typing timer - if user stops typing for 2.5 seconds, check for STT auto-submission
+                typingTimer = setTimeout(() => {{
+                    // Only check for STT auto-submission if user has stopped typing and we have speech input
+                    if (hasReceivedSpeech && messageInput.value.trim() && (Date.now() - lastTypingTime) >= 2500) {{
+                        console.log('🔇 User stopped typing, checking for STT auto-submission...');
+
+                        // Additional delay to ensure user is done typing (2.5 seconds after last keystroke)
+                        silenceTimer = setTimeout(() => {{
+                            if (hasReceivedSpeech && messageInput.value.trim()) {{
+                                console.log('🔇 STT auto-submitting after typing pause...');
+                                submitMessage();
+                            }}
+                        }}, 2500);
+                    }}
+                }}, 2500);
+            }});
+
+            messageInput.addEventListener('paste', () => setTimeout(autoResizeTextarea, 0));
+            
+            // Add click listener to send button
+            if (sendButton) {{
+                sendButton.addEventListener('click', function(e) {{
+                    e.preventDefault();
+                    sendMessage();
+                }});
+            }}
+
+            // Mouse movement detection for editing detection
+            document.addEventListener('mousemove', function() {{
+                lastMouseMoveTime = Date.now();
+                // Reset timer when user moves mouse (indicates they might be editing)
+                resetAutoSubmitTimer();
+            }});
+
+            // Keyboard activity detection for editing detection
+            messageInput.addEventListener('keydown', function() {{
+                // Reset timer when user types (indicates they are editing)
+                resetAutoSubmitTimer();
+            }});
+
+            messageInput.addEventListener('input', function() {{
+                // Reset timer when input content changes
+                resetAutoSubmitTimer();
+            }});
+
+            // Function to reset the auto-submit timer
+            function resetAutoSubmitTimer() {{
+                if (silenceTimer && hasReceivedSpeech) {{
+                    console.log('⌨️ User activity detected, resetting 2.5 second timer...');
+                    clearTimeout(silenceTimer);
+
+                    // Restart the 2.5 second timer
+                    silenceTimer = setTimeout(() => {{
+                        if (hasReceivedSpeech && messageInput.value.trim()) {{
+                            console.log('⏱️ 2.5 seconds completed after user activity, auto-submitting...');
+                            submitMessage();
+                        }}
+                    }}, 2500);
+                }}
+            }}
+            
+            // Initialize when page loads
+            // STT v2 indicator click to toggle recording
+            sttIndicator.addEventListener('click', () => {{
+                if (sttv2Manager) {{
+                    sttv2Manager.toggleRecording().catch(error => {{
+                        console.error('Failed to toggle STT v2 recording:', error);
+                        updateSTTVisualState('error');
+                        setTimeout(() => updateSTTVisualState('ready'), 3000);
+                        alert('Microphone access failed. Please check permissions.');
+                    }});
+                }}
+            }});
+            
+            // Initialize session and STT v2
+            async function initAndStartSTT() {{
+                await initializeSession();
+
+                // Initialize STT v2 Manager
+                try {{
+                    sttv2Manager = new STTv2Manager();
+                    updateSTTVisualState('ready');
+                    console.log('✅ STT v2 Manager initialized and ready');
+                }} catch (error) {{
+                    console.warn('STT v2 initialization failed:', error);
+                    updateSTTVisualState('error');
+                    // STT failure is not critical, user can still type
+                }}
+            }}
+            
+            // Cleanup on page unload
+            window.addEventListener('beforeunload', () => {{
+                if (sttv2Manager && sttv2Manager.isRecording) {{
+                    sttv2Manager.stopRecording();
+                }}
+            }});
+            
+            window.addEventListener('load', initAndStartSTT);
+            
+        </script>
+    </body>
+    </html>
+    """
+
+
+@router.get("/widget", response_class=HTMLResponse)
+async def embeddable_widget():
+    """Minimal embeddable widget for other websites."""
+    return """
+    <div id="chatcal-widget" style="
+        position: fixed;
+        bottom: 20px;
+        right: 20px;
+        width: 400px;
+        height: 500px;
+        background: white;
+        border-radius: 10px;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+        z-index: 9999;
+        display: none;
+    ">
+        <iframe 
+            src="/chat-widget" 
+            width="100%" 
+            height="100%" 
+            frameborder="0"
+            style="border-radius: 10px;">
+        </iframe>
+    </div>
+    
+    <button id="chatcal-toggle" style="
+        position: fixed;
+        bottom: 20px;
+        right: 20px;
+        width: 60px;
+        height: 60px;
+        background: #4CAF50;
+        color: white;
+        border: none;
+        border-radius: 50%;
+        cursor: pointer;
+        font-size: 24px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.2);
+        z-index: 10000;
+    ">💬</button>
+    
+    <script>
+        document.getElementById('chatcal-toggle').onclick = function() {
+            const widget = document.getElementById('chatcal-widget');
+            const toggle = document.getElementById('chatcal-toggle');
+            
+            if (widget.style.display === 'none') {
+                widget.style.display = 'block';
+                toggle.textContent = '✕';
+            } else {
+                widget.style.display = 'none';
+                toggle.textContent = '💬';
+            }
+        };
+    </script>
+    """

app/api/main.py

@@ -0,0 +1,480 @@
+"""Main FastAPI application for ChatCal.ai."""
+
+from fastapi import FastAPI, HTTPException, Depends, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.exception_handlers import request_validation_exception_handler
+from fastapi.exceptions import RequestValidationError
+from datetime import datetime
+import uuid
+import json
+import logging
+from typing import Dict, Any, Optional
+
+from app.config import settings
+from app.api.models import (
+    ChatRequest, ChatResponse, StreamChatResponse, SessionCreate, SessionResponse,
+    ConversationHistory, HealthResponse, ErrorResponse, AuthRequest, AuthResponse
+)
+from app.api.chat_widget import router as chat_widget_router
+from app.api.simple_chat import router as simple_chat_router
+from app.core.session_factory import session_manager
+from app.calendar.auth import CalendarAuth
+from app.core.exceptions import (
+    ChatCalException, AuthenticationError, CalendarError, 
+    LLMError, ValidationError, RateLimitError
+)
+from app.core.llm_anthropic import anthropic_llm
+
+# Create FastAPI app
+app = FastAPI(
+    title="ChatCal.ai",
+    description="AI-powered calendar assistant for booking appointments",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Log testing mode status on startup
+if settings.testing_mode:
+    logger.info("🧪 TESTING MODE ENABLED - Peter's email will be treated as regular user email")
+else:
+    logger.info("📧 Production mode - Peter's email will receive special formatting")
+
+# Calendar auth instance
+calendar_auth = CalendarAuth()
+
+# Include routers
+app.include_router(chat_widget_router)
+app.include_router(simple_chat_router)
+
+# Mount static files
+import os
+static_path = "/app/static"
+if os.path.exists(static_path):
+    app.mount("/static", StaticFiles(directory=static_path), name="static")
+
+
+# Global exception handlers
+@app.exception_handler(ChatCalException)
+async def chatcal_exception_handler(request: Request, exc: ChatCalException):
+    """Handle custom ChatCal exceptions."""
+    logger.error(f"ChatCal exception: {exc.message}", extra={"details": exc.details})
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={
+            "error": exc.__class__.__name__,
+            "message": exc.message,
+            "details": exc.details,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """Handle request validation errors."""
+    logger.warning(f"Validation error: {exc}")
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={
+            "error": "ValidationError",
+            "message": "Invalid request data",
+            "details": {"validation_errors": exc.errors()},
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+@app.exception_handler(500)
+async def internal_server_error_handler(request: Request, exc: Exception):
+    """Handle internal server errors."""
+    logger.error(f"Internal server error: {exc}", exc_info=True)
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": "InternalServerError",
+            "message": "An unexpected error occurred. Please try again later.",
+            "details": {},
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Root endpoint with basic information."""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>ChatCal.ai</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 40px; background-color: #f5f5f5; }
+            .container { background: white; padding: 40px; border-radius: 10px; max-width: 800px; margin: 0 auto; }
+            h1 { color: #2c3e50; text-align: center; }
+            .feature { background: #e8f5e9; padding: 15px; margin: 15px 0; border-radius: 8px; border-left: 4px solid #4caf50; }
+            .api-link { background: #e3f2fd; padding: 15px; margin: 15px 0; border-radius: 8px; text-align: center; }
+            a { color: #1976d2; text-decoration: none; }
+            a:hover { text-decoration: underline; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>📅 Schedule Time with Peter Michael Gits</h1>
+            <p style="text-align: center; font-size: 18px; color: #666;">
+                Book consultations, meetings, and advisory sessions with Peter
+            </p>
+            
+            <div style="text-align: center; margin: 30px 0;">
+                <a href="/chat-widget" style="background: #4caf50; color: white; padding: 15px 40px; font-size: 20px; border-radius: 8px; text-decoration: none; display: inline-block;">
+                    Book an Appointment Now
+                </a>
+            </div>
+            
+            <div class="feature">
+                <h3>💼 Professional Consultations</h3>
+                <p>Schedule one-on-one business consultations and advisory sessions with Peter Michael Gits</p>
+            </div>
+            
+            <div class="feature">
+                <h3>🤖 AI-Powered Scheduling</h3>
+                <p>Our intelligent assistant helps you find the perfect time that works for both you and Peter</p>
+            </div>
+            
+            <div class="feature">
+                <h3>📧 Instant Confirmation</h3>
+                <p>Receive immediate confirmation and calendar invitations for your scheduled meetings</p>
+            </div>
+            
+            <div class="api-link">
+                <h3>🛠️ API Documentation</h3>
+                <p>
+                    <a href="/docs">Interactive API Docs (Swagger)</a> | 
+                    <a href="/redoc">Alternative Docs (ReDoc)</a>
+                </p>
+            </div>
+            
+            <div style="text-align: center; margin-top: 30px; color: #888;">
+                <p>Version 0.1.0 | Built with FastAPI & LlamaIndex</p>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint."""
+    services = {}
+    
+    # Check session backend connection
+    try:
+        if hasattr(session_manager, 'redis_client'):
+            session_manager.redis_client.ping()
+        services["session_backend"] = "healthy"
+    except Exception as e:
+        logger.error(f"Session backend health check failed: {e}")
+        services["session_backend"] = "unhealthy"
+    
+    # Check Groq LLM (via anthropic_llm interface)
+    try:
+        from app.core.llm_anthropic import anthropic_llm
+        if anthropic_llm.test_connection():
+            services["llm"] = "healthy"
+        else:
+            services["llm"] = "unhealthy"
+    except Exception as e:
+        logger.error(f"LLM health check failed: {e}")
+        services["llm"] = "not_configured"
+    
+    # Add testing mode status
+    services["testing_mode"] = "enabled" if settings.testing_mode else "disabled"
+    
+    # Check Calendar service
+    try:
+        if calendar_auth.client_id and calendar_auth.client_secret:
+            services["calendar"] = "ready"
+        else:
+            services["calendar"] = "not_configured"
+    except Exception as e:
+        logger.error(f"Calendar health check failed: {e}")
+        services["calendar"] = "unhealthy"
+    
+    overall_status = "healthy" if all(status in ["healthy", "ready"] for status in services.values()) else "degraded"
+    
+    return HealthResponse(
+        status=overall_status,
+        version="0.1.0",
+        timestamp=datetime.utcnow(),
+        services=services
+    )
+
+
+@app.post("/sessions", response_model=SessionResponse)
+async def create_session(request: SessionCreate):
+    """Create a new chat session."""
+    try:
+        session_id = session_manager.create_session(request.user_data)
+        
+        if not session_id:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to create session"
+            )
+        session_data = session_manager.get_session(session_id)
+        
+        if not session_data:
+            raise HTTPException(status_code=500, detail="Failed to create session")
+        
+        return SessionResponse(
+            session_id=session_id,
+            created_at=datetime.fromisoformat(session_data["created_at"]),
+            last_activity=datetime.fromisoformat(session_data["last_activity"]),
+            is_active=True
+        )
+    except Exception as e:
+        logger.error(f"Session creation failed: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create session. Please try again."
+        )
+
+
+@app.get("/sessions/{session_id}", response_model=SessionResponse)
+async def get_session(session_id: str):
+    """Get session information."""
+    session_data = session_manager.get_session(session_id)
+    
+    if not session_data:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return SessionResponse(
+        session_id=session_id,
+        created_at=datetime.fromisoformat(session_data["created_at"]),
+        last_activity=datetime.fromisoformat(session_data["last_activity"]),
+        is_active=True
+    )
+
+
+@app.delete("/sessions/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session."""
+    success = session_manager.delete_session(session_id)
+    
+    if not success:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return {"message": "Session deleted successfully"}
+
+
+@app.get("/sessions/{session_id}/history", response_model=ConversationHistory)
+async def get_conversation_history(session_id: str):
+    """Get conversation history for a session."""
+    session_data = session_manager.get_session(session_id)
+    if not session_data:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    history = session_manager.get_conversation_history(session_id)
+    
+    return ConversationHistory(
+        session_id=session_id,
+        messages=history.get("messages", []) if history else [],
+        created_at=datetime.fromisoformat(session_data["created_at"])
+    )
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Chat with the AI assistant."""
+    try:
+        # Create session if not provided
+        if not request.session_id:
+            request.session_id = session_manager.create_session()
+        
+        # Get or create conversation
+        conversation = session_manager.get_or_create_conversation(request.session_id)
+        if not conversation:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        # Get response from agent
+        response = conversation.get_response(request.message)
+        
+        # Store conversation history
+        session_manager.store_conversation_history(request.session_id)
+        
+        return ChatResponse(
+            response=response,
+            session_id=request.session_id,
+            timestamp=datetime.utcnow(),
+            tools_used=None  # Will implement tool tracking later
+        )
+        
+    except Exception as e:
+        import traceback
+        error_traceback = traceback.format_exc()
+        logger.error(f"Chat error: {str(e)}")
+        logger.error(f"Traceback: {error_traceback}")
+        raise HTTPException(status_code=500, detail=f"Chat error: {str(e) if str(e) else 'Unknown error'} | Type: {type(e).__name__}")
+
+
+@app.post("/chat/stream")
+async def stream_chat(request: ChatRequest):
+    """Stream chat response from the AI assistant."""
+    try:
+        # Create session if not provided
+        if not request.session_id:
+            request.session_id = session_manager.create_session()
+        
+        # Get or create conversation
+        conversation = session_manager.get_or_create_conversation(request.session_id)
+        if not conversation:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        async def generate_stream():
+            """Generate streaming response."""
+            try:
+                for token in conversation.get_streaming_response(request.message):
+                    chunk = StreamChatResponse(
+                        token=token,
+                        session_id=request.session_id,
+                        is_complete=False
+                    )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+                
+                # Send completion signal
+                final_chunk = StreamChatResponse(
+                    token="",
+                    session_id=request.session_id,
+                    is_complete=True
+                )
+                yield f"data: {final_chunk.model_dump_json()}\n\n"
+                
+                # Store conversation history
+                session_manager.store_conversation_history(request.session_id)
+                
+            except Exception as e:
+                error_chunk = {
+                    "error": str(e),
+                    "session_id": request.session_id,
+                    "is_complete": True
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n"
+        
+        return StreamingResponse(
+            generate_stream(),
+            media_type="text/plain",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Stream chat error: {str(e)}")
+
+
+@app.get("/auth/login", response_model=AuthResponse)
+async def google_auth_login(request: Request, state: Optional[str] = None):
+    """Initiate Google OAuth login."""
+    try:
+        auth_url, oauth_state = calendar_auth.get_authorization_url(state)
+        
+        return AuthResponse(
+            auth_url=auth_url,
+            state=oauth_state
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Auth error: {str(e)}")
+
+
+@app.get("/auth/callback")
+async def google_auth_callback(request: Request, code: str, state: str):
+    """Handle Google OAuth callback."""
+    try:
+        # Reconstruct the authorization response URL
+        authorization_response = str(request.url)
+        
+        # Exchange code for credentials
+        credentials = calendar_auth.handle_callback(authorization_response, state)
+        
+        return {
+            "message": "Authentication successful! Your calendar is now connected.",
+            "status": "success",
+            "expires_at": credentials.expiry.isoformat() if credentials.expiry else None
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Authentication failed: {str(e)}")
+
+
+@app.get("/auth/status")
+async def auth_status():
+    """Check authentication status."""
+    try:
+        is_authenticated = calendar_auth.is_authenticated()
+        
+        return {
+            "authenticated": is_authenticated,
+            "calendar_id": settings.google_calendar_id if is_authenticated else None,
+            "message": "Connected to Google Calendar" if is_authenticated else "Not authenticated"
+        }
+    except Exception as e:
+        return {
+            "authenticated": False,
+            "error": str(e),
+            "message": "Authentication check failed"
+        }
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """Custom HTTP exception handler."""
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "error": "HTTPException",
+            "message": exc.detail,
+            "details": {"status_code": exc.status_code},
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """General exception handler."""
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": type(exc).__name__,
+            "message": str(exc),
+            "details": {"path": str(request.url)},
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.api.main:app",
+        host=settings.app_host,
+        port=settings.app_port,
+        reload=True if settings.app_env == "development" else False
+    )

app/api/models.py

@@ -0,0 +1,116 @@
+"""Pydantic models for API requests and responses."""
+
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class ChatRequest(BaseModel):
+    """Request model for chat endpoint."""
+    message: str = Field(..., description="User message to the chatbot", min_length=1, max_length=1000)
+    session_id: Optional[str] = Field(None, description="Session ID for conversation continuity")
+    stream: bool = Field(False, description="Whether to stream the response")
+
+
+class ChatResponse(BaseModel):
+    """Response model for chat endpoint."""
+    response: str = Field(..., description="Chatbot response")
+    session_id: str = Field(..., description="Session ID")
+    timestamp: datetime = Field(..., description="Response timestamp")
+    tools_used: Optional[List[str]] = Field(None, description="List of tools used in response")
+
+
+class StreamChatResponse(BaseModel):
+    """Response model for streaming chat."""
+    token: str = Field(..., description="Response token")
+    session_id: str = Field(..., description="Session ID")
+    is_complete: bool = Field(False, description="Whether this is the final token")
+
+
+class SessionCreate(BaseModel):
+    """Request model for creating a new session."""
+    user_data: Optional[Dict[str, Any]] = Field(None, description="Optional user data")
+
+
+class SessionResponse(BaseModel):
+    """Response model for session operations."""
+    session_id: str = Field(..., description="Session ID")
+    created_at: datetime = Field(..., description="Session creation timestamp")
+    last_activity: datetime = Field(..., description="Last activity timestamp")
+    is_active: bool = Field(..., description="Whether session is active")
+
+
+class ConversationHistory(BaseModel):
+    """Model for conversation history."""
+    session_id: str = Field(..., description="Session ID")
+    messages: List[Dict[str, Any]] = Field(..., description="List of conversation messages")
+    created_at: datetime = Field(..., description="Conversation start timestamp")
+
+
+class CalendarEvent(BaseModel):
+    """Model for calendar events."""
+    id: Optional[str] = Field(None, description="Event ID")
+    summary: str = Field(..., description="Event title/summary")
+    start_time: datetime = Field(..., description="Event start time")
+    end_time: datetime = Field(..., description="Event end time")
+    description: Optional[str] = Field(None, description="Event description")
+    location: Optional[str] = Field(None, description="Event location")
+    attendees: Optional[List[str]] = Field(None, description="List of attendee emails")
+
+
+class AvailabilityRequest(BaseModel):
+    """Request model for checking availability."""
+    date: str = Field(..., description="Date in natural language (e.g., 'next Tuesday')")
+    duration_minutes: int = Field(60, description="Meeting duration in minutes", ge=15, le=480)
+    preferred_time: Optional[str] = Field(None, description="Preferred time (e.g., '2pm', 'morning')")
+
+
+class AvailabilityResponse(BaseModel):
+    """Response model for availability check."""
+    date: str = Field(..., description="Formatted date")
+    available_slots: List[Dict[str, str]] = Field(..., description="List of available time slots")
+    duration_minutes: int = Field(..., description="Requested duration")
+
+
+class AppointmentRequest(BaseModel):
+    """Request model for creating appointments."""
+    title: str = Field(..., description="Meeting title", min_length=1, max_length=200)
+    date: str = Field(..., description="Date in natural language")
+    time: str = Field(..., description="Time in natural language")
+    duration_minutes: int = Field(60, description="Duration in minutes", ge=15, le=480)
+    description: Optional[str] = Field(None, description="Meeting description", max_length=1000)
+    attendees: Optional[List[str]] = Field(None, description="List of attendee emails")
+
+
+class AppointmentResponse(BaseModel):
+    """Response model for appointment operations."""
+    success: bool = Field(..., description="Whether operation was successful")
+    message: str = Field(..., description="Success or error message")
+    event: Optional[CalendarEvent] = Field(None, description="Created/updated event details")
+
+
+class AuthRequest(BaseModel):
+    """Request model for authentication."""
+    state: Optional[str] = Field(None, description="OAuth state parameter")
+
+
+class AuthResponse(BaseModel):
+    """Response model for authentication."""
+    auth_url: str = Field(..., description="Google OAuth authorization URL")
+    state: str = Field(..., description="OAuth state parameter")
+
+
+class HealthResponse(BaseModel):
+    """Response model for health check."""
+    status: str = Field(..., description="Service status")
+    version: str = Field(..., description="Application version")
+    timestamp: datetime = Field(..., description="Health check timestamp")
+    services: Dict[str, str] = Field(..., description="Status of dependent services")
+
+
+class ErrorResponse(BaseModel):
+    """Response model for errors."""
+    error: str = Field(..., description="Error type")
+    message: str = Field(..., description="Error message")
+    details: Optional[Dict[str, Any]] = Field(None, description="Additional error details")
+    timestamp: datetime = Field(..., description="Error timestamp")

app/api/simple_chat.py

@@ -0,0 +1,220 @@
+"""Simple chat interface for ChatCal.ai."""
+
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse
+
+router = APIRouter()
+
+@router.get("/simple-chat", response_class=HTMLResponse)
+async def simple_chat():
+    """Simple working chat interface."""
+    return """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>ChatCal.ai</title>
+    <style>
+        body { 
+            font-family: Arial, sans-serif; 
+            max-width: 800px; 
+            margin: 50px auto; 
+            padding: 20px;
+            background: #f5f5f5;
+        }
+        .chat-box { 
+            background: white; 
+            border-radius: 10px; 
+            padding: 20px; 
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+        }
+        .messages { 
+            height: 400px; 
+            overflow-y: auto; 
+            border: 1px solid #ddd; 
+            padding: 15px; 
+            margin-bottom: 20px;
+            background: #fafafa;
+            border-radius: 5px;
+        }
+        .message { 
+            margin: 10px 0; 
+            padding: 10px;
+            border-radius: 5px;
+        }
+        .user { 
+            background: #007bff; 
+            color: white; 
+            text-align: right;
+            margin-left: 20%;
+        }
+        .assistant { 
+            background: #e9ecef; 
+            margin-right: 20%;
+        }
+        .input-group { 
+            display: flex; 
+            gap: 10px;
+        }
+        input { 
+            flex: 1; 
+            padding: 10px; 
+            border: 1px solid #ddd;
+            border-radius: 5px;
+            font-size: 16px;
+        }
+        button { 
+            padding: 10px 20px; 
+            background: #28a745; 
+            color: white; 
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+        }
+        button:hover { background: #218838; }
+        button:disabled { 
+            background: #ccc; 
+            cursor: not-allowed;
+        }
+        .loading { 
+            text-align: center; 
+            color: #666; 
+            padding: 10px;
+            display: none;
+        }
+        .error { 
+            color: red; 
+            padding: 10px;
+            background: #fee;
+            border-radius: 5px;
+            margin: 10px 0;
+        }
+        h1 { 
+            text-align: center; 
+            color: #333;
+        }
+        .subtitle { 
+            text-align: center; 
+            color: #666; 
+            margin-bottom: 30px;
+        }
+    </style>
+</head>
+<body>
+    <div class="chat-box">
+        <h1>📅 Book Time with Peter Michael Gits</h1>
+        <p class="subtitle">AI-Powered Scheduling Assistant</p>
+        
+        <div class="messages" id="messages">
+            <div class="message assistant">
+                👋 Welcome! I'm ChatCal, Peter Michael Gits' scheduling assistant. I'm here to help you book an appointment with Peter.
+                <br><br>
+                I can schedule:
+                <ul>
+                    <li>Business consultations (60 min) - in-person or Google Meet</li>
+                    <li>Quick discussions (30 min) - in-person or Google Meet</li>
+                    <li>Project meetings (60 min) - in-person or Google Meet</li>
+                    <li>Advisory sessions (90 min) - in-person or Google Meet</li>
+                </ul>
+                <strong>🎥 Google Meet:</strong> Just mention "Google Meet", "video call", or "online meeting" and I'll automatically create a video conference link for you!
+                <br><br>
+                What type of meeting would you like to schedule?
+            </div>
+        </div>
+        
+        <div class="loading" id="loading">ChatCal is thinking...</div>
+        
+        <div class="input-group">
+            <input 
+                type="text" 
+                id="input" 
+                placeholder="Tell me what you'd like to discuss with Peter..."
+                onkeypress="if(event.key==='Enter') send()"
+            >
+            <button onclick="send()" id="sendBtn">Send</button>
+        </div>
+    </div>
+
+    <script>
+        let sessionId = null;
+        let busy = false;
+        
+        // Get elements
+        const input = document.getElementById('input');
+        const messages = document.getElementById('messages');
+        const loading = document.getElementById('loading');
+        const sendBtn = document.getElementById('sendBtn');
+        
+        // Initialize session
+        fetch('/sessions', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({})
+        })
+        .then(r => r.json())
+        .then(data => {
+            sessionId = data.session_id;
+            console.log('Session:', sessionId);
+        })
+        .catch(err => {
+            showMessage('Error: Could not start session', 'error');
+            console.error(err);
+        });
+        
+        function showMessage(text, type='assistant') {
+            const div = document.createElement('div');
+            div.className = 'message ' + type;
+            // For assistant messages, render HTML; for user messages, use text only
+            if (type === 'assistant') {
+                div.innerHTML = text;
+            } else {
+                div.textContent = text;
+            }
+            messages.appendChild(div);
+            messages.scrollTop = messages.scrollHeight;
+        }
+        
+        async function send() {
+            const text = input.value.trim();
+            if (!text || busy || !sessionId) return;
+            
+            // Show user message
+            showMessage(text, 'user');
+            input.value = '';
+            
+            // Disable while sending
+            busy = true;
+            sendBtn.disabled = true;
+            loading.style.display = 'block';
+            
+            try {
+                const response = await fetch('/chat', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({
+                        message: text,
+                        session_id: sessionId
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (response.ok) {
+                    showMessage(data.response, 'assistant');
+                } else {
+                    showMessage('Error: ' + (data.message || 'Something went wrong'), 'error');
+                }
+            } catch (err) {
+                showMessage('Error: Connection failed', 'error');
+                console.error(err);
+            } finally {
+                busy = false;
+                sendBtn.disabled = false;
+                loading.style.display = 'none';
+                input.focus();
+            }
+        }
+    </script>
+</body>
+</html>
+"""

app/calendar/auth.py

@@ -0,0 +1,226 @@
+"""Google Calendar OAuth2 authentication handling."""
+
+import os
+import json
+from typing import Optional, Dict
+from datetime import datetime, timedelta
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import Flow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from app.config import settings
+
+
+class CalendarAuth:
+    """Handles Google Calendar OAuth2 authentication."""
+    
+    # OAuth2 scopes required for calendar access
+    SCOPES = [
+        'https://www.googleapis.com/auth/calendar',
+        'https://www.googleapis.com/auth/calendar.events'
+    ]
+    
+    def __init__(self):
+        self.client_id = settings.google_client_id
+        self.client_secret = settings.google_client_secret
+        self.redirect_uri = "http://localhost:8000/auth/callback"
+        self.credentials_path = settings.google_credentials_path
+        self._service = None
+    
+    def create_auth_flow(self, state: Optional[str] = None) -> Flow:
+        """Create OAuth2 flow for authentication."""
+        client_config = {
+            "web": {
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+                "redirect_uris": [self.redirect_uri]
+            }
+        }
+        
+        flow = Flow.from_client_config(
+            client_config,
+            scopes=self.SCOPES,
+            state=state
+        )
+        flow.redirect_uri = self.redirect_uri
+        
+        # Allow insecure transport for local development
+        import os
+        os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+        
+        return flow
+    
+    def get_authorization_url(self, state: Optional[str] = None) -> tuple[str, str]:
+        """Generate authorization URL for OAuth2 flow."""
+        flow = self.create_auth_flow(state)
+        
+        authorization_url, state = flow.authorization_url(
+            access_type='offline',
+            include_granted_scopes='true',
+            prompt='consent'  # Force consent to get refresh token
+        )
+        
+        return authorization_url, state
+    
+    def handle_callback(self, authorization_response: str, state: str) -> Credentials:
+        """Handle OAuth2 callback and exchange code for credentials."""
+        flow = self.create_auth_flow(state)
+        flow.fetch_token(authorization_response=authorization_response)
+        
+        credentials = flow.credentials
+        self.save_credentials(credentials)
+        
+        return credentials
+    
+    def save_credentials(self, credentials: Credentials):
+        """Save credentials to both file and config for future use."""
+        os.makedirs(os.path.dirname(self.credentials_path), exist_ok=True)
+
+        creds_data = {
+            'token': credentials.token,
+            'refresh_token': credentials.refresh_token,
+            'token_uri': credentials.token_uri,
+            'client_id': credentials.client_id,
+            'client_secret': credentials.client_secret,
+            'scopes': credentials.scopes,
+            'expiry': credentials.expiry.isoformat() if credentials.expiry else None
+        }
+
+        # Save to JSON file
+        with open(self.credentials_path, 'w') as f:
+            json.dump(creds_data, f)
+
+        # Also save to environment variables for local development
+        print("💾 Saving credentials to environment config")
+        print(f"   Access Token: {credentials.token[:20]}...")
+        print(f"   Refresh Token: {credentials.refresh_token[:20] if credentials.refresh_token else 'None'}...")
+        print(f"   Expiry: {credentials.expiry}")
+
+        # Update .env file with new tokens
+        self._update_env_file(credentials)
+
+    def _update_env_file(self, credentials: Credentials):
+        """Update .env file with new OAuth tokens."""
+        try:
+            env_path = ".env"
+            if not os.path.exists(env_path):
+                return
+
+            # Read current .env file
+            with open(env_path, 'r') as f:
+                lines = f.readlines()
+
+            # Update the token lines
+            updated_lines = []
+            for line in lines:
+                if line.startswith('GOOGLE_ACCESS_TOKEN='):
+                    updated_lines.append(f'GOOGLE_ACCESS_TOKEN={credentials.token}\n')
+                elif line.startswith('GOOGLE_REFRESH_TOKEN=') and credentials.refresh_token:
+                    updated_lines.append(f'GOOGLE_REFRESH_TOKEN={credentials.refresh_token}\n')
+                elif line.startswith('GOOGLE_TOKEN_EXPIRY=') and credentials.expiry:
+                    updated_lines.append(f'GOOGLE_TOKEN_EXPIRY={credentials.expiry.isoformat()}\n')
+                else:
+                    updated_lines.append(line)
+
+            # Write back to .env file
+            with open(env_path, 'w') as f:
+                f.writelines(updated_lines)
+
+            print("✅ Updated .env file with new tokens")
+        except Exception as e:
+            print(f"⚠️ Failed to update .env file: {e}")
+
+    def load_credentials(self) -> Optional[Credentials]:
+        """Load saved credentials from config or file."""
+        from app.config import settings
+
+        # First try to load from environment/config
+        if (settings.google_access_token and
+            settings.google_refresh_token and
+            settings.google_token_expiry):
+            print("🔧 Loading credentials from environment config")
+            creds_data = {
+                'token': settings.google_access_token,
+                'refresh_token': settings.google_refresh_token,
+                'token_uri': 'https://oauth2.googleapis.com/token',
+                'client_id': settings.google_client_id,
+                'client_secret': settings.google_client_secret,
+                'scopes': self.SCOPES,
+                'expiry': settings.google_token_expiry
+            }
+        else:
+            # Fall back to JSON file
+            if not os.path.exists(self.credentials_path):
+                return None
+
+            print("📁 Loading credentials from JSON file")
+            with open(self.credentials_path, 'r') as f:
+                creds_data = json.load(f)
+        
+        credentials = Credentials(
+            token=creds_data['token'],
+            refresh_token=creds_data.get('refresh_token'),
+            token_uri=creds_data['token_uri'],
+            client_id=creds_data['client_id'],
+            client_secret=creds_data['client_secret'],
+            scopes=creds_data['scopes']
+        )
+        
+        # Set expiry if available
+        if creds_data.get('expiry'):
+            credentials.expiry = datetime.fromisoformat(creds_data['expiry'])
+            print(f"🕐 Loaded credentials with expiry: {credentials.expiry}")
+            print(f"🔍 Credentials expired: {credentials.expired}")
+        
+        # Refresh if expired
+        if credentials.expired and credentials.refresh_token:
+            try:
+                print(f"🔄 Refreshing expired credentials...")
+                credentials.refresh(Request())
+                self.save_credentials(credentials)
+                print(f"✅ Credentials refreshed successfully")
+            except Exception as e:
+                print(f"❌ Failed to refresh credentials: {e}")
+                return None
+        
+        return credentials
+    
+    def get_calendar_service(self, credentials: Optional[Credentials] = None):
+        """Get authenticated Google Calendar service."""
+        if not credentials:
+            credentials = self.load_credentials()
+            
+        if not credentials:
+            raise ValueError("No valid credentials available. Please authenticate first.")
+        
+        if not self._service:
+            self._service = build('calendar', 'v3', credentials=credentials)
+        
+        return self._service
+    
+    def revoke_credentials(self):
+        """Revoke stored credentials."""
+        credentials = self.load_credentials()
+        if credentials:
+            try:
+                credentials.revoke(Request())
+            except:
+                pass  # Ignore revocation errors
+        
+        # Remove credentials file
+        if os.path.exists(self.credentials_path):
+            os.remove(self.credentials_path)
+        
+        self._service = None
+    
+    def is_authenticated(self) -> bool:
+        """Check if valid credentials exist."""
+        try:
+            credentials = self.load_credentials()
+            return credentials is not None and credentials.valid
+        except:
+            return False

app/calendar/service.py

@@ -0,0 +1,308 @@
+"""Google Calendar service for managing calendar operations."""
+
+from datetime import datetime, timedelta, timezone
+from typing import List, Dict, Optional, Tuple
+import pytz
+from googleapiclient.errors import HttpError
+from app.calendar.auth import CalendarAuth
+from app.config import settings
+
+
+class CalendarService:
+    """Service for interacting with Google Calendar."""
+    
+    def __init__(self):
+        self.auth = None  # Lazy initialization
+        self.calendar_id = settings.google_calendar_id
+        self.default_timezone = pytz.timezone(settings.default_timezone)
+    
+    def _get_service(self):
+        """Get authenticated calendar service."""
+        if self.auth is None:
+            from app.calendar.auth import CalendarAuth
+            self.auth = CalendarAuth()
+
+        try:
+            service = self.auth.get_calendar_service()
+            if not service:
+                raise RuntimeError("Failed to get calendar service - authentication required")
+            return service
+        except Exception as e:
+            print(f"⚠️ Calendar service error: {e}")
+            # Check for authentication errors
+            if "invalid_grant" in str(e) or "Token has been expired" in str(e):
+                return None  # Return None instead of raising for auth errors
+            raise
+    
+    def list_events(
+        self,
+        time_min: Optional[datetime] = None,
+        time_max: Optional[datetime] = None,
+        max_results: int = 10,
+        single_events: bool = True
+    ) -> List[Dict]:
+        """List calendar events within a time range."""
+        try:
+            service = self._get_service()
+            if not service:
+                raise RuntimeError("Calendar service not authenticated")
+            
+            # Validate inputs
+            if max_results < 1 or max_results > 2500:
+                raise ValueError("max_results must be between 1 and 2500")
+            
+            # Default to next 7 days if not specified
+            if not time_min:
+                time_min = datetime.now(self.default_timezone)
+            if not time_max:
+                time_max = time_min + timedelta(days=7)
+            
+            # Validate time range
+            if time_min >= time_max:
+                raise ValueError("time_min must be before time_max")
+            
+            # Convert to RFC3339 timestamp
+            time_min_str = time_min.isoformat()
+            time_max_str = time_max.isoformat()
+            
+            events_result = service.events().list(
+                calendarId=self.calendar_id,
+                timeMin=time_min_str,
+                timeMax=time_max_str,
+                maxResults=max_results,
+                singleEvents=single_events,
+                orderBy='startTime'
+            ).execute()
+            
+            return events_result.get('items', [])
+            
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            return []
+    
+    def get_availability(
+        self,
+        date: datetime,
+        duration_minutes: int = 60,
+        start_hour: int = 9,
+        end_hour: int = 17,
+        interval_minutes: int = 15
+    ) -> List[Tuple[datetime, datetime]]:
+        """Find available time slots on a given date."""
+        # Ensure date is timezone-aware
+        if date.tzinfo is None:
+            date = self.default_timezone.localize(date)
+        
+        # Set working hours for the day
+        start_time = date.replace(hour=start_hour, minute=0, second=0, microsecond=0)
+        end_time = date.replace(hour=end_hour, minute=0, second=0, microsecond=0)
+        
+        # Get existing events for the day
+        events = self.list_events(
+            time_min=start_time,
+            time_max=end_time,
+            max_results=50
+        )
+        
+        # Build list of busy times
+        busy_times = []
+        for event in events:
+            if 'dateTime' in event.get('start', {}):
+                start = datetime.fromisoformat(event['start']['dateTime'])
+                end = datetime.fromisoformat(event['end']['dateTime'])
+                busy_times.append((start, end))
+        
+        # Sort busy times
+        busy_times.sort(key=lambda x: x[0])
+        
+        # Find available slots
+        available_slots = []
+        current_time = start_time
+        
+        while current_time + timedelta(minutes=duration_minutes) <= end_time:
+            slot_end = current_time + timedelta(minutes=duration_minutes)
+            
+            # Check if this slot conflicts with any busy time
+            is_available = True
+            for busy_start, busy_end in busy_times:
+                if not (slot_end <= busy_start or current_time >= busy_end):
+                    is_available = False
+                    break
+            
+            if is_available:
+                available_slots.append((current_time, slot_end))
+            
+            # Move to next interval
+            current_time += timedelta(minutes=interval_minutes)
+        
+        return available_slots
+    
+    def create_event(
+        self,
+        summary: str,
+        start_time: datetime,
+        end_time: datetime,
+        description: Optional[str] = None,
+        attendees: Optional[List[str]] = None,
+        location: Optional[str] = None,
+        send_notifications: bool = True,
+        create_meet_conference: bool = False
+    ) -> Dict:
+        """Create a new calendar event."""
+        service = self._get_service()
+        
+        # Ensure times are timezone-aware
+        if start_time.tzinfo is None:
+            start_time = self.default_timezone.localize(start_time)
+        if end_time.tzinfo is None:
+            end_time = self.default_timezone.localize(end_time)
+        
+        event = {
+            'summary': summary,
+            'start': {
+                'dateTime': start_time.isoformat(),
+                'timeZone': str(self.default_timezone),
+            },
+            'end': {
+                'dateTime': end_time.isoformat(),
+                'timeZone': str(self.default_timezone),
+            },
+        }
+        
+        if description:
+            event['description'] = description
+        
+        if location:
+            event['location'] = location
+        
+        if attendees:
+            event['attendees'] = [{'email': email} for email in attendees]
+        
+        # Add Google Meet conference if requested
+        if create_meet_conference:
+            import uuid
+            event['conferenceData'] = {
+                'createRequest': {
+                    'requestId': str(uuid.uuid4()),  # Generate unique request ID
+                    'conferenceSolutionKey': {
+                        'type': 'hangoutsMeet'
+                    }
+                }
+            }
+        
+        try:
+            # Use conferenceDataVersion=1 if creating a Meet conference
+            conference_version = 1 if create_meet_conference else None
+            
+            created_event = service.events().insert(
+                calendarId=self.calendar_id,
+                body=event,
+                sendNotifications=send_notifications,
+                conferenceDataVersion=conference_version
+            ).execute()
+            
+            return created_event
+        
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            raise
+    
+    def update_event(
+        self,
+        event_id: str,
+        updates: Dict,
+        send_notifications: bool = True
+    ) -> Dict:
+        """Update an existing calendar event."""
+        service = self._get_service()
+        
+        try:
+            # Get the existing event
+            event = service.events().get(
+                calendarId=self.calendar_id,
+                eventId=event_id
+            ).execute()
+            
+            # Apply updates
+            event.update(updates)
+            
+            # Update the event
+            updated_event = service.events().update(
+                calendarId=self.calendar_id,
+                eventId=event_id,
+                body=event,
+                sendNotifications=send_notifications
+            ).execute()
+            
+            return updated_event
+        
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            raise
+    
+    def delete_event(
+        self,
+        event_id: str,
+        send_notifications: bool = True
+    ) -> bool:
+        """Delete a calendar event."""
+        service = self._get_service()
+        
+        try:
+            service.events().delete(
+                calendarId=self.calendar_id,
+                eventId=event_id,
+                sendNotifications=send_notifications
+            ).execute()
+            
+            return True
+        
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            return False
+    
+    def get_event(self, event_id: str) -> Optional[Dict]:
+        """Get a specific event by ID."""
+        service = self._get_service()
+        
+        try:
+            event = service.events().get(
+                calendarId=self.calendar_id,
+                eventId=event_id
+            ).execute()
+            
+            return event
+        
+        except HttpError as error:
+            print(f'An error occurred: {error}')
+            return None
+    
+    def check_conflicts(
+        self,
+        start_time: datetime,
+        end_time: datetime,
+        exclude_event_id: Optional[str] = None
+    ) -> List[Dict]:
+        """Check for conflicting events in the given time range."""
+        events = self.list_events(
+            time_min=start_time,
+            time_max=end_time,
+            max_results=50
+        )
+        
+        conflicts = []
+        for event in events:
+            # Skip if this is the event we're updating
+            if exclude_event_id and event.get('id') == exclude_event_id:
+                continue
+            
+            # Check for overlap
+            if 'dateTime' in event.get('start', {}):
+                event_start = datetime.fromisoformat(event['start']['dateTime'])
+                event_end = datetime.fromisoformat(event['end']['dateTime'])
+                
+                # Check if there's an overlap
+                if not (end_time <= event_start or start_time >= event_end):
+                    conflicts.append(event)
+        
+        return conflicts

app/calendar/utils.py

@@ -0,0 +1,315 @@
+"""Calendar utility functions for date/time parsing and formatting."""
+
+import re
+from datetime import datetime, timedelta
+from typing import Optional, Tuple, List, Dict
+import pytz
+from dateutil import parser
+from dateutil.relativedelta import relativedelta
+from app.config import settings
+
+
+class DateTimeParser:
+    """Utility class for parsing natural language date/time expressions."""
+    
+    def __init__(self, default_timezone: str = None):
+        self.default_timezone = pytz.timezone(default_timezone or settings.default_timezone)
+        self.now = datetime.now(self.default_timezone)
+    
+    def parse_datetime(self, text: str) -> Optional[datetime]:
+        """Parse various datetime formats from natural language."""
+        text = text.lower().strip()
+
+        # Handle combined date and time with "and" (e.g., "tomorrow and 1.15")
+        if " and " in text:
+            parts = text.split(" and ")
+            if len(parts) == 2:
+                date_part, time_part = parts
+
+                # Parse date part
+                base_date = self._parse_relative_date(date_part.strip())
+                if not base_date:
+                    base_date = self._parse_day_name(date_part.strip())
+
+                # Parse time part
+                if base_date:
+                    time_tuple = self.parse_time(time_part.strip())
+                    if time_tuple:
+                        hour, minute = time_tuple
+                        return base_date.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+        # Handle combined date and time with "at" (e.g., "tomorrow at 1pm")
+        if " at " in text:
+            parts = text.split(" at ")
+            if len(parts) == 2:
+                date_part, time_part = parts
+
+                # Parse date part
+                base_date = self._parse_relative_date(date_part.strip())
+                if not base_date:
+                    base_date = self._parse_day_name(date_part.strip())
+
+                # Parse time part
+                if base_date:
+                    time_tuple = self.parse_time(time_part.strip())
+                    if time_tuple:
+                        hour, minute = time_tuple
+                        return base_date.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+        # Try standard parsing first
+        try:
+            dt = parser.parse(text, fuzzy=True)
+            if dt.tzinfo is None:
+                dt = self.default_timezone.localize(dt)
+            return dt
+        except:
+            pass
+
+        # Handle relative dates
+        relative_date = self._parse_relative_date(text)
+        if relative_date:
+            return relative_date
+
+        # Handle day names
+        day_date = self._parse_day_name(text)
+        if day_date:
+            return day_date
+
+        return None
+    
+    def _parse_relative_date(self, text: str) -> Optional[datetime]:
+        """Parse relative dates like 'tomorrow', 'next week', etc."""
+        base_time = self.now.replace(hour=9, minute=0, second=0, microsecond=0)
+        
+        # Today/tonight
+        if any(word in text for word in ['today', 'tonight']):
+            return base_time
+        
+        # Tomorrow
+        if 'tomorrow' in text:
+            return base_time + timedelta(days=1)
+        
+        # Yesterday
+        if 'yesterday' in text:
+            return base_time - timedelta(days=1)
+        
+        # Next week
+        if 'next week' in text:
+            days_ahead = 7 - base_time.weekday()
+            return base_time + timedelta(days=days_ahead)
+        
+        # This week
+        if 'this week' in text:
+            return base_time
+        
+        # Next month
+        if 'next month' in text:
+            return base_time + relativedelta(months=1)
+        
+        # In X days/weeks/months
+        match = re.search(r'in (\d+) (day|week|month)s?', text)
+        if match:
+            number = int(match.group(1))
+            unit = match.group(2)
+            
+            if unit == 'day':
+                return base_time + timedelta(days=number)
+            elif unit == 'week':
+                return base_time + timedelta(weeks=number)
+            elif unit == 'month':
+                return base_time + relativedelta(months=number)
+        
+        return None
+    
+    def _parse_day_name(self, text: str) -> Optional[datetime]:
+        """Parse day names like 'monday', 'next tuesday', etc."""
+        days = {
+            'monday': 0, 'tuesday': 1, 'wednesday': 2, 'thursday': 3,
+            'friday': 4, 'saturday': 5, 'sunday': 6
+        }
+        
+        for day_name, day_num in days.items():
+            if day_name in text:
+                current_day = self.now.weekday()
+                days_ahead = day_num - current_day
+                
+                # If it's the same day, assume next week if "next" is mentioned
+                if days_ahead <= 0 or 'next' in text:
+                    days_ahead += 7
+                
+                target_date = self.now + timedelta(days=days_ahead)
+                return target_date.replace(hour=9, minute=0, second=0, microsecond=0)
+        
+        return None
+    
+    def parse_time(self, text: str) -> Optional[Tuple[int, int]]:
+        """Parse time from text, returning (hour, minute) tuple."""
+        text = text.lower().strip()
+        
+        # Handle AM/PM format
+        am_pm_match = re.search(r'(\d{1,2})(?::(\d{2}))?\s*(am|pm)', text)
+        if am_pm_match:
+            hour = int(am_pm_match.group(1))
+            minute = int(am_pm_match.group(2)) if am_pm_match.group(2) else 0
+            is_pm = am_pm_match.group(3) == 'pm'
+            
+            if is_pm and hour != 12:
+                hour += 12
+            elif not is_pm and hour == 12:
+                hour = 0
+            
+            return (hour, minute)
+        
+        # Handle 24-hour format (1:15, 13:30)
+        time_match = re.search(r'(\d{1,2}):(\d{2})', text)
+        if time_match:
+            hour = int(time_match.group(1))
+            minute = int(time_match.group(2))
+            return (hour, minute)
+
+        # Handle dot format (1.15, 13.30) - common European format
+        dot_time_match = re.search(r'(\d{1,2})\.(\d{2})', text)
+        if dot_time_match:
+            hour = int(dot_time_match.group(1))
+            minute = int(dot_time_match.group(2))
+            # For times like 1.15, assume PM if hour is 1-12 and in business context
+            if 1 <= hour <= 12:
+                # Default to PM for business hours
+                hour += 12
+            return (hour, minute)
+        
+        # Handle hour-only format
+        hour_match = re.search(r'(\d{1,2})\s*(?:o\'?clock)?', text)
+        if hour_match:
+            hour = int(hour_match.group(1))
+            # Assume afternoon for business hours
+            if 8 <= hour <= 12:
+                return (hour, 0)
+            elif 1 <= hour <= 7:
+                return (hour + 12, 0)
+        
+        return None
+    
+    def parse_duration(self, text: str) -> Optional[int]:
+        """Parse duration in minutes from text."""
+        text = text.lower().strip()
+        
+        # Handle "X hours" or "X hour"
+        hour_match = re.search(r'(\d+(?:\.\d+)?)\s*hours?', text)
+        if hour_match:
+            hours = float(hour_match.group(1))
+            return int(hours * 60)
+        
+        # Handle "X minutes" or "X mins"
+        minute_match = re.search(r'(\d+)\s*(?:minutes?|mins?)', text)
+        if minute_match:
+            return int(minute_match.group(1))
+        
+        # Handle common durations
+        if '30' in text or 'thirty' in text or 'half' in text:
+            return 30
+        elif '15' in text or 'fifteen' in text or 'quarter' in text:
+            return 15
+        elif '45' in text or 'forty-five' in text:
+            return 45
+        elif '60' in text or 'hour' in text:
+            return 60
+        elif '90' in text or 'ninety' in text:
+            return 90
+        elif '120' in text or 'two hour' in text:
+            return 120
+        
+        return None
+
+
+class CalendarFormatter:
+    """Utility class for formatting calendar information."""
+    
+    def __init__(self, timezone: str = None):
+        self.timezone = pytz.timezone(timezone or settings.default_timezone)
+    
+    def format_datetime(self, dt: datetime, include_date: bool = True) -> str:
+        """Format datetime in a user-friendly way."""
+        if dt.tzinfo is None:
+            dt = self.timezone.localize(dt)
+        else:
+            dt = dt.astimezone(self.timezone)
+        
+        # Format time
+        time_str = dt.strftime("%-I:%M %p" if dt.minute else "%-I %p")
+        
+        if not include_date:
+            return time_str
+        
+        # Format date
+        today = datetime.now(self.timezone).date()
+        tomorrow = today + timedelta(days=1)
+        yesterday = today - timedelta(days=1)
+        
+        if dt.date() == today:
+            return f"today at {time_str}"
+        elif dt.date() == tomorrow:
+            return f"tomorrow at {time_str}"
+        elif dt.date() == yesterday:
+            return f"yesterday at {time_str}"
+        else:
+            # Check if it's this week
+            days_diff = (dt.date() - today).days
+            if 0 < days_diff <= 7:
+                day_name = dt.strftime("%A")
+                return f"{day_name} at {time_str}"
+            else:
+                date_str = dt.strftime("%B %-d")
+                if dt.year != today.year:
+                    date_str += f", {dt.year}"
+                return f"{date_str} at {time_str}"
+    
+    def format_duration(self, minutes: int) -> str:
+        """Format duration in a user-friendly way."""
+        if minutes < 60:
+            return f"{minutes} minute{'s' if minutes != 1 else ''}"
+        
+        hours = minutes // 60
+        remaining_minutes = minutes % 60
+        
+        if remaining_minutes == 0:
+            return f"{hours} hour{'s' if hours != 1 else ''}"
+        else:
+            return f"{hours} hour{'s' if hours != 1 else ''} and {remaining_minutes} minute{'s' if remaining_minutes != 1 else ''}"
+    
+    def format_availability_list(self, slots: List[Tuple[datetime, datetime]]) -> str:
+        """Format list of available time slots."""
+        if not slots:
+            return "No available time slots found."
+        
+        formatted_slots = []
+        for start, end in slots:
+            start_str = self.format_datetime(start, include_date=False)
+            end_str = self.format_datetime(end, include_date=False)
+            formatted_slots.append(f"{start_str} - {end_str}")
+        
+        if len(formatted_slots) <= 3:
+            return ", ".join(formatted_slots)
+        else:
+            first_three = ", ".join(formatted_slots[:3])
+            remaining = len(formatted_slots) - 3
+            return f"{first_three}, and {remaining} more slot{'s' if remaining != 1 else ''}"
+    
+    def format_event_summary(self, event: Dict) -> str:
+        """Format a calendar event for display."""
+        summary = event.get('summary', 'Untitled Event')
+        
+        if 'start' in event and 'dateTime' in event['start']:
+            start = datetime.fromisoformat(event['start']['dateTime'])
+            start_str = self.format_datetime(start)
+            
+            if 'end' in event and 'dateTime' in event['end']:
+                end = datetime.fromisoformat(event['end']['dateTime'])
+                duration = int((end - start).total_seconds() / 60)
+                duration_str = self.format_duration(duration)
+                
+                return f"{summary} ({start_str}, {duration_str})"
+            else:
+                return f"{summary} ({start_str})"
+        
+        return summary

app/config.py

@@ -0,0 +1,89 @@
+import os
+from typing import List, Optional
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+
+class Settings(BaseSettings):
+    # Application
+    app_name: str = Field(default="ChatCal.ai", env="APP_NAME")
+    app_env: str = Field(default="development", env="APP_ENV")
+    app_host: str = Field(default="0.0.0.0", env="APP_HOST")
+    app_port: int = Field(default=8000, env="APP_PORT")
+    
+    # Groq API (primary)
+    groq_api_key: str = Field(..., env="GROQ_API_KEY")
+    
+    # Anthropic (optional - fallback)
+    anthropic_api_key: Optional[str] = Field(None, env="ANTHROPIC_API_KEY")
+    
+    # Gemini API (optional - fallback)
+    gemini_api_key: Optional[str] = Field(None, env="GEMINI_API_KEY")
+    
+    # Google Calendar
+    google_calendar_id: str = Field(default="pgits.job@gmail.com", env="GOOGLE_CALENDAR_ID")
+    google_client_id: Optional[str] = Field(None, env="GOOGLE_CLIENT_ID")
+    google_client_secret: Optional[str] = Field(None, env="GOOGLE_CLIENT_SECRET")
+    google_credentials_path: str = Field(default="credentials/google_calendar_credentials.json", env="GOOGLE_CREDENTIALS_PATH")
+
+    # OAuth Token Storage (for local development)
+    google_access_token: Optional[str] = Field(None, env="GOOGLE_ACCESS_TOKEN")
+    google_refresh_token: Optional[str] = Field(None, env="GOOGLE_REFRESH_TOKEN")
+    google_token_expiry: Optional[str] = Field(None, env="GOOGLE_TOKEN_EXPIRY")
+    
+    # Redis
+    redis_url: str = Field(default="redis://localhost:6379/0", env="REDIS_URL")
+
+    # Session Backend (redis or jwt)
+    session_backend: str = Field(default="redis", env="SESSION_BACKEND")
+    
+    # Security
+    secret_key: str = Field(..., env="SECRET_KEY")
+    cors_origins: List[str] = Field(default=["http://localhost:3000", "http://localhost:8000"], env="CORS_ORIGINS")
+    
+    # Timezone
+    default_timezone: str = Field(default="America/New_York", env="DEFAULT_TIMEZONE")
+    
+    # Chat Settings
+    max_conversation_history: int = Field(default=20, env="MAX_CONVERSATION_HISTORY")
+    session_timeout_minutes: int = Field(default=10, env="SESSION_TIMEOUT_MINUTES")  # 10 minutes max
+    
+    # HuggingFace Settings
+    tokenizers_parallelism: Optional[str] = Field(default="false", env="TOKENIZERS_PARALLELISM")
+    
+    # Peter's Contact Information
+    my_phone_number: str = Field(..., env="MY_PHONE_NUMBER")
+    my_email_address: str = Field(..., env="MY_EMAIL_ADDRESS")
+    
+    # Email Service Configuration
+    smtp_server: str = Field(default="smtp.gmail.com", env="SMTP_SERVER")
+    smtp_port: int = Field(default=587, env="SMTP_PORT")
+    smtp_username: Optional[str] = Field(None, env="SMTP_USERNAME")
+    smtp_password: Optional[str] = Field(None, env="SMTP_PASSWORD")
+    email_from_name: str = Field(default="ChatCal.ai", env="EMAIL_FROM_NAME")
+    
+    # Testing Configuration
+    testing_mode: bool = Field(default=True, env="TESTING_MODE")  # Set to True to ignore Peter's email validation
+    
+    # Default Appointment Settings
+    default_appointment_title: str = Field(default="VoiceCal Appt", env="DEFAULT_APPOINTMENT_TITLE")
+    
+    # STT Service Settings (Direct Connection)
+    stt_service_wss_url: str = Field(default="wss://pgits-stt-gpu-service-v3.hf.space/ws", env="STT_SERVICE_WSS_URL")
+    stt_websocket_timeout: int = Field(default=30, env="STT_WEBSOCKET_TIMEOUT")
+    stt_audio_chunk_size: int = Field(default=1280, env="STT_AUDIO_CHUNK_SIZE")  # 80ms at 16kHz
+    stt_sample_rate: int = Field(default=16000, env="STT_SAMPLE_RATE")  # v3 service native rate
+    
+    # STT UI Settings
+    stt_listening_indicator: bool = Field(default=True, env="STT_LISTENING_INDICATOR")
+    stt_auto_submit: bool = Field(default=False, env="STT_AUTO_SUBMIT")  # Future feature
+    stt_silence_threshold: float = Field(default=2.5, env="STT_SILENCE_THRESHOLD")  # seconds
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = False
+        extra = "ignore"  # Allow extra environment variables
+
+
+settings = Settings()

app/core/agent.py

@@ -0,0 +1,996 @@
+"""Main ChatCal.ai agent that combines LLM with calendar tools."""
+
+from typing import List, Dict, Optional
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.tools import BaseTool
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.agent import ReActAgent
+from app.core.llm_anthropic import anthropic_llm
+from app.core.tools import CalendarTools
+from app.personality.prompts import SYSTEM_PROMPT, ENCOURAGEMENT_PHRASES
+from app.config import settings
+import random
+
+
+class ChatCalAgent:
+    """Main ChatCal.ai conversational agent."""
+    
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        self.calendar_tools = CalendarTools(agent=self)
+        self.llm = anthropic_llm.get_llm()
+
+        # User information storage - load from session if available
+        print(f"🔍 ChatCalAgent initializing for session: {session_id}")
+        loaded_user_info = self._load_user_info_from_session()
+        print(f"🔍 Loaded user info: {loaded_user_info}")
+
+        self.user_info = loaded_user_info or {
+            "name": None,
+            "email": None,
+            "phone": None,
+            "preferences": {}
+        }
+        print(f"🔍 Final user info: {self.user_info}")
+        
+        # Meeting ID storage for cancellation tracking - load from session if available
+        self.stored_meetings = self._load_stored_meetings_from_session() or {}
+        
+        # Conversation state for multi-turn operations
+        self.conversation_state = {
+            "pending_operation": None,  # "cancellation", "booking", etc.
+            "operation_context": {},    # Context data for the pending operation
+            "awaiting_clarification": False  # Whether we're waiting for user clarification
+        }
+        
+        # Set up memory
+        self.memory = ChatMemoryBuffer(token_limit=3000)
+        
+        # Create agent with tools
+        self.agent = self._create_agent()
+        self.conversation_started = False
+    
+    def _create_agent(self):
+        """Create the ReAct agent with calendar tools."""
+        # Get calendar tools 
+        tools = self.calendar_tools.get_tools()
+        
+        # Get current user context
+        user_context = self._get_user_context()
+        
+        # Enhanced system prompt for calendar agent with Peter's contact info
+        self.base_system_prompt = SYSTEM_PROMPT.format(
+            my_phone_number=settings.my_phone_number,
+            my_email_address=settings.my_email_address
+        )
+        
+        enhanced_system_prompt = f"""{self.base_system_prompt}
+
+{user_context}
+
+## Response Guidelines
+
+**AVAILABILITY CHECKING (NO CONTACT INFO REQUIRED):**
+- For availability requests ("check availability", "what times are free", "when is Peter available") → IMMEDIATELY use check_availability tool
+- DO NOT ask for contact information when just checking availability
+- Contact info is only needed for actual booking, not for viewing available times
+
+**CRITICAL BOOKING WORKFLOW - STOP INFINITE LOOPS:**
+1. FIRST: Check the "Missing Info" section above
+2. If Missing Info exists: ASK for the missing information - DO NOT call ANY booking tools
+3. If "User Info: Complete": PROCEED with booking tools immediately
+4. For Google Meet requests: Email is ABSOLUTELY REQUIRED - never book without it
+5. NEVER call create_appointment without ALL required fields being present
+
+**Specific Rules:**
+- If you see "Missing Info: first name" → Ask "What's your first name?"
+- If you see "Missing Info: email address (required for Google Meet)" → Ask "I need your email address to send the Google Meet invitation"
+- If you see "Missing Info: phone number (required for Google Meet)" → Ask "I need your phone number in case we need to call you"
+- If you see multiple missing items → Ask for ALL missing items in one question
+- If you see "Missing Info: contact (email or phone)" → Ask "Email address or phone number?"
+- NEVER attempt to book if you see ANY "Missing Info" listed
+
+**BOOKING COMPLETION RULES - EXACT SEQUENCE:**
+1. When "User Info: Complete" appears above:
+   → IMMEDIATELY call check_availability tool with the exact requested date/time
+   → Example: check_availability(date_string="today", preferred_time="4pm", duration_minutes=5)
+2. If time is available:
+   → IMMEDIATELY call create_appointment tool to book
+3. If time is NOT available:
+   → Suggest alternative times and ask user to choose
+4. After booking:
+   → Provide the Meeting ID and Google Calendar ID in the confirmation
+
+**FORBIDDEN ACTIONS:**
+- NEVER call list_upcoming_events when you should be checking specific availability
+- NEVER ask for information you already have
+- NEVER show general calendar events when user wants to book specific time
+
+**General Guidelines:**
+- Be conversational and natural, like a helpful human assistant
+- Keep responses concise and focused on the user's needs
+- Never mention tools, capabilities, or technical details unless asked
+- If user provides contact info (email/phone), remember it and use it
+- When collecting email addresses, always confirm them by repeating back what you heard
+- If you detect an email address via speech-to-text, ask user to confirm it's correct before booking
+- Give users a chance to spell out email addresses using military/phonetic alphabet if needed
+- Be patient - wait for user confirmation before proceeding with booking
+- Never ask for "secondary email" or additional contact if they already provided one
+- Format responses with proper line breaks - each detail on its own line"""
+
+        # Create actual ReActAgent with tools and iteration limits
+        agent = ReActAgent(
+            tools=tools,
+            llm=self.llm,
+            system_prompt=enhanced_system_prompt,
+            verbose=True
+        )
+        
+        return agent
+    
+    def _get_user_context(self, message: str = "") -> str:
+        """Generate user context for the system prompt."""
+        missing = []
+        if not self.user_info.get("name"):
+            missing.append("first name")
+
+        # Check if this is a Google Meet request
+        is_google_meet_request = any(phrase in message.lower() for phrase in [
+            'google meet', 'googlemeet', 'meet.google', 'video call', 'video conference', 'online meeting'
+        ])
+
+        if is_google_meet_request:
+            # For Google Meet, BOTH email AND phone are REQUIRED
+            if not self.user_info.get("email"):
+                missing.append("email address (required for Google Meet invitations)")
+            if not self.user_info.get("phone"):
+                missing.append("phone number (required for Google Meet - in case we need to call)")
+        else:
+            # For regular meetings, email OR phone is acceptable
+            if not self.user_info.get("email") and not self.user_info.get("phone"):
+                missing.append("contact (email or phone)")
+
+        if missing:
+            return f"## Missing Info: {', '.join(missing)}"
+        else:
+            # Include actual user information in the context
+            user_details = []
+            if self.user_info.get("name"):
+                user_details.append(f"Name: {self.user_info['name']}")
+            if self.user_info.get("email"):
+                user_details.append(f"Email: {self.user_info['email']}")
+            if self.user_info.get("phone"):
+                user_details.append(f"Phone: {self.user_info['phone']}")
+
+            return f"## User Info: Complete - ready to book\n{' | '.join(user_details)}"
+    
+    def _get_conversation_state_context(self) -> str:
+        """Generate conversation state context for the system prompt."""
+        if not self.conversation_state["pending_operation"]:
+            return ""
+        
+        if self.conversation_state["pending_operation"] == "cancellation" and self.conversation_state["awaiting_clarification"]:
+            context = self.conversation_state["operation_context"]
+            return f"""## Conversation State: AWAITING CANCELLATION CLARIFICATION
+- User wants to cancel a meeting for: {context.get('user_name', 'unknown')}
+- Original date/time info: {context.get('date_string', 'none')} {context.get('time_string', 'none')}
+- Waiting for user to provide more specific time/date details
+- Do NOT ask about meeting purpose - only ask for time/date clarification if needed"""
+        
+        return ""
+    
+    def _process_message_with_llm(self, message: str) -> str:
+        """Process message using direct LLM calls with manual tool invocation."""
+        try:
+            # Check if we need to call any tools based on the message
+            tool_result = self._check_and_call_tools(message)
+            
+            # Create enhanced message with tool results if any
+            enhanced_message = message
+            if tool_result:
+                enhanced_message = f"[Tool Result: {tool_result}]\n\nUser: {message}"
+            
+            # Add user message to memory
+            user_message = ChatMessage(role=MessageRole.USER, content=enhanced_message)
+            self.memory.put(user_message)
+            
+            # Build conversation history for LLM with updated user context
+            current_user_context = self._get_user_context(message)
+            conversation_state_context = self._get_conversation_state_context()
+            
+            current_system_prompt = f"""{self.base_system_prompt.split('## Missing Info:')[0].split('## User Info:')[0].rstrip()}
+
+{current_user_context}
+
+{conversation_state_context}
+
+## Response Guidelines
+
+- Be conversational and natural, like a helpful human assistant
+- Keep responses concise and focused on the user's needs
+- Never mention tools, capabilities, or technical details unless asked
+- If user provides contact info (email/phone), remember it and use it
+- Never ask for "secondary email" or additional contact if they already provided one
+- If you have all required info (name + contact), book immediately without asking for confirmation
+- Format responses with proper line breaks - each detail on its own line"""
+            
+            messages = [ChatMessage(role=MessageRole.SYSTEM, content=current_system_prompt)]
+            
+            # Add conversation history from memory
+            history_messages = self.memory.get_all()
+            messages.extend(history_messages)
+            
+            # Get ReActAgent response (tools will be automatically called if needed)
+            response = self.agent.run(user_message.content)
+            response_text = str(response)
+            
+            return response_text
+            
+        except Exception as e:
+            print(f"LLM processing error: {e}")
+            import traceback
+            traceback.print_exc()
+            return "I'm having trouble processing your request right now. Could you try again?"
+    
+    def _check_and_call_tools(self, message: str) -> str:
+        """Check if message requires tool calls and execute them."""
+        import re
+        
+        # Check for booking requests
+        booking_patterns = [
+            r"schedule|book|appointment|meeting",
+            r"available|availability|free time",
+            r"reschedule|move|change",
+            r"cancel|delete|remove"
+        ]
+        
+        message_lower = message.lower()
+        
+        # Check availability requests
+        if any(word in message_lower for word in ["available", "availability", "free", "open"]):
+            # Extract date from message (basic pattern matching)
+            date_patterns = [
+                r"tomorrow",
+                r"today", 
+                r"monday|tuesday|wednesday|thursday|friday|saturday|sunday",
+                r"\d{1,2}/\d{1,2}",
+                r"next week",
+                r"this week"
+            ]
+            
+            date_found = None
+            for pattern in date_patterns:
+                match = re.search(pattern, message_lower)
+                if match:
+                    date_found = match.group()
+                    break
+            
+            if date_found:
+                try:
+                    # Call availability tool
+                    availability_tool = None
+                    for tool in self.tools:
+                        if "availability" in tool.metadata.name.lower():
+                            availability_tool = tool
+                            break
+                    
+                    if availability_tool:
+                        result = availability_tool.call(date=date_found)
+                        return f"Availability check result: {result}"
+                except Exception as e:
+                    return f"Could not check availability: {str(e)}"
+        
+        # Check for booking requests with complete info
+        if self.has_complete_user_info() and any(word in message_lower for word in ["schedule", "book", "appointment", "meeting"]):
+            try:
+                # Extract meeting details (basic implementation)
+                meeting_type = "consultation"  # Default
+                duration = 60  # Default
+                
+                # Try to create appointment
+                create_tool = None
+                for tool in self.tools:
+                    if "create" in tool.metadata.name.lower() or "appointment" in tool.metadata.name.lower():
+                        create_tool = tool
+                        break
+                
+                if create_tool:
+                    result = create_tool.call(
+                        title=f"Meeting with {self.user_info['name']}",
+                        attendee_email=self.user_info.get('email', ''),
+                        duration=duration
+                    )
+                    return f"Appointment creation result: {result}"
+            except Exception as e:
+                return f"Could not create appointment: {str(e)}"
+        
+        # First check if we're continuing a cancellation conversation
+        if self.conversation_state["pending_operation"] == "cancellation" and self.conversation_state["awaiting_clarification"]:
+            # User is providing clarification for a pending cancellation
+            context = self.conversation_state["operation_context"]
+            print(f"🔄 Processing cancellation clarification from {context.get('user_name')}: '{message}'")
+            
+            # Extract time/date information from the clarification
+            time_patterns = [
+                r"\d{1,2}:\d{2}\s*(?:am|pm)",
+                r"\d{1,2}\s*(?:am|pm)",
+                r"morning|afternoon|evening|noon"
+            ]
+            
+            date_patterns = [
+                r"tomorrow|today|monday|tuesday|wednesday|thursday|friday|saturday|sunday",
+                r"\d{1,2}/\d{1,2}",
+                r"next week|this week"
+            ]
+            
+            # Look for additional time/date info in the clarification
+            additional_time = None
+            additional_date = None
+            
+            for pattern in time_patterns:
+                match = re.search(pattern, message_lower)
+                if match:
+                    additional_time = match.group()
+                    break
+            
+            for pattern in date_patterns:
+                match = re.search(pattern, message_lower)
+                if match:
+                    additional_date = match.group()
+                    break
+            
+            # Use the clarification to complete the cancellation
+            try:
+                cancel_tool = None
+                for tool in self.tools:
+                    if "cancel" in tool.metadata.name.lower() and "details" in tool.metadata.name.lower():
+                        cancel_tool = tool
+                        break
+                
+                if cancel_tool:
+                    # Use stored context plus any new info from clarification
+                    final_date = additional_date or context.get("date_string", "")
+                    final_time = additional_time or context.get("time_string", "")
+                    
+                    result = cancel_tool.call(
+                        user_name=context["user_name"],
+                        date_string=final_date,
+                        time_string=final_time
+                    )
+                    
+                    # Clear the conversation state
+                    self.conversation_state = {
+                        "pending_operation": None,
+                        "operation_context": {},
+                        "awaiting_clarification": False
+                    }
+                    print(f"✅ Cleared conversation state after successful cancellation")
+                    
+                    return result
+            except Exception as e:
+                # Clear state on error
+                self.conversation_state = {
+                    "pending_operation": None,
+                    "operation_context": {},
+                    "awaiting_clarification": False
+                }
+                print(f"❌ Cleared conversation state after cancellation error: {str(e)}")
+                return f"Could not cancel meeting: {str(e)}"
+        
+        # Check for numbered cancellation requests (e.g., "cancel #1", "cancel the first one")
+        elif any(word in message_lower for word in ["cancel", "delete", "remove"]):
+            # Look for number indicators
+            number_patterns = [
+                r"#(\d+)", r"number (\d+)", r"(\d+)(?:st|nd|rd|th)?",
+                r"first", r"second", r"third", r"fourth", r"fifth"
+            ]
+            
+            number_words = {"first": 1, "second": 2, "third": 3, "fourth": 4, "fifth": 5}
+            selected_number = None
+            
+            for pattern in number_patterns:
+                match = re.search(pattern, message_lower)
+                if match:
+                    if match.group().strip() in number_words:
+                        selected_number = number_words[match.group().strip()]
+                    else:
+                        try:
+                            selected_number = int(match.group(1) if match.groups() else match.group().strip("#"))
+                        except:
+                            continue
+                    break
+            
+            # If user selected a number and we have their stored meetings info, try to cancel by selection
+            if selected_number and self.user_info.get('name'):
+                # Find their meetings to get the selected one
+                try:
+                    find_tool = None
+                    for tool in self.tools:
+                        if "find_user_meetings" in tool.metadata.name.lower():
+                            find_tool = tool
+                            break
+                    
+                    if find_tool:
+                        # This is a bit of a workaround - we'll get their meetings and extract the nth one
+                        from datetime import datetime, timedelta
+                        now = datetime.now(self.calendar_tools.calendar_service.default_timezone)
+                        search_end = now + timedelta(days=30)
+                        
+                        events = self.calendar_tools.calendar_service.list_events(
+                            time_min=now,
+                            time_max=search_end,
+                            max_results=50
+                        )
+                        
+                        # Find meetings that match the user name
+                        matching_events = []
+                        for event in events:
+                            event_summary = event.get('summary', '').lower()
+                            event_description = event.get('description', '').lower()
+                            
+                            if (self.user_info['name'].lower() in event_summary or 
+                                self.user_info['name'].lower() in event_description or
+                                f"meeting with {self.user_info['name'].lower()}" in event_summary):
+                                matching_events.append(event)
+                        
+                        if matching_events and 1 <= selected_number <= len(matching_events):
+                            # Cancel the selected meeting
+                            selected_event = matching_events[selected_number - 1]
+                            google_meeting_id = selected_event.get('id')
+                            
+                            # Try to find custom meeting ID
+                            custom_meeting_id = None
+                            if self.agent:
+                                stored_meetings = self.agent.get_stored_meetings()
+                                for stored_id, info in stored_meetings.items():
+                                    if info.get('google_id') == google_meeting_id:
+                                        custom_meeting_id = stored_id
+                                        break
+                            
+                            # Cancel using the meeting ID
+                            cancel_tool = None
+                            for tool in self.tools:
+                                if "cancel" in tool.metadata.name.lower() and "id" in tool.metadata.name.lower():
+                                    cancel_tool = tool
+                                    break
+                            
+                            if cancel_tool:
+                                if custom_meeting_id:
+                                    result = cancel_tool.call(meeting_id=custom_meeting_id)
+                                else:
+                                    # Fall back to Google ID
+                                    result = cancel_tool.call(meeting_id=google_meeting_id)
+                                return result
+                        else:
+                            return f"I couldn't find meeting #{selected_number}. Please check the list and try again."
+                            
+                except Exception as e:
+                    return f"Could not cancel meeting: {str(e)}"
+        
+        # Check for new cancellation requests
+        elif any(word in message_lower for word in ["cancel", "delete", "remove"]) and any(word in message_lower for word in ["meeting", "appointment"]):
+            # Look for meeting ID in message first
+            meeting_id_pattern = r"\b\d{4}-\d{4}-\d+m\b"  # Our custom format: MMDD-HHMM-DURm
+            meeting_ids = re.findall(meeting_id_pattern, message)
+            
+            if meeting_ids:
+                # Try to cancel by custom meeting ID
+                try:
+                    cancel_tool = None
+                    for tool in self.tools:
+                        if "cancel" in tool.metadata.name.lower() and "id" in tool.metadata.name.lower():
+                            cancel_tool = tool
+                            break
+                    
+                    if cancel_tool:
+                        result = cancel_tool.call(meeting_id=meeting_ids[0])
+                        return result  # Return direct result (already formatted HTML)
+                except Exception as e:
+                    return f"Could not cancel meeting: {str(e)}"
+            else:
+                # Try to cancel by user name and date (never ask about purpose)
+                if self.user_info.get('name'):
+                    try:
+                        # Extract date from message
+                        date_patterns = [
+                            r"tomorrow|today|monday|tuesday|wednesday|thursday|friday|saturday|sunday",
+                            r"\d{1,2}/\d{1,2}",
+                            r"next week|this week|friday|monday|tuesday|wednesday|thursday"
+                        ]
+                        
+                        # Extract time from message
+                        time_patterns = [
+                            r"\d{1,2}:\d{2}\s*(?:am|pm)",
+                            r"\d{1,2}\s*(?:am|pm)",
+                            r"morning|afternoon|evening|noon"
+                        ]
+                        
+                        date_found = None
+                        time_found = None
+                        
+                        for pattern in date_patterns:
+                            match = re.search(pattern, message_lower)
+                            if match:
+                                date_found = match.group()
+                                break
+                        
+                        for pattern in time_patterns:
+                            match = re.search(pattern, message_lower)
+                            if match:
+                                time_found = match.group()
+                                break
+                        
+                        # Check if user indicates they don't remember the time
+                        no_time_indicators = [
+                            "don't remember", "can't remember", "forgot", "not sure when",
+                            "don't know when", "what time", "which one", "don't recall"
+                        ]
+                        
+                        user_doesnt_remember = any(indicator in message_lower for indicator in no_time_indicators)
+                        
+                        if date_found and not user_doesnt_remember:
+                            # User provided specific date/time - use details cancellation
+                            cancel_tool = None
+                            for tool in self.tools:
+                                if "cancel" in tool.metadata.name.lower() and "details" in tool.metadata.name.lower():
+                                    cancel_tool = tool
+                                    break
+                            
+                            if cancel_tool:
+                                result = cancel_tool.call(
+                                    user_name=self.user_info['name'],
+                                    date_string=date_found,
+                                    time_string=time_found
+                                )
+                                
+                                # Check if the result is asking for clarification
+                                if "Found multiple meetings" in result or "Can you be more specific" in result:
+                                    # Store the cancellation context
+                                    self.conversation_state = {
+                                        "pending_operation": "cancellation",
+                                        "operation_context": {
+                                            "user_name": self.user_info['name'],
+                                            "date_string": date_found,
+                                            "time_string": time_found,
+                                            "original_message": message
+                                        },
+                                        "awaiting_clarification": True
+                                    }
+                                    print(f"🔄 Set conversation state: awaiting cancellation clarification for {self.user_info['name']}")
+                                
+                                return result  # Return direct result (already formatted HTML)
+                        else:
+                            # User doesn't remember time or didn't provide date - show all their meetings
+                            find_tool = None
+                            for tool in self.tools:
+                                if "find_user_meetings" in tool.metadata.name.lower():
+                                    find_tool = tool
+                                    break
+                            
+                            if find_tool:
+                                result = find_tool.call(user_name=self.user_info['name'])
+                                return result  # Return list of meetings for user to choose
+                    except Exception as e:
+                        return f"Could not cancel meeting: {str(e)}"
+        
+        return ""
+    
+    def update_user_info(self, info_type: str, value: str) -> bool:
+        """Update user information."""
+        if info_type in self.user_info:
+            self.user_info[info_type] = value
+            # Save to session whenever user info is updated
+            self._save_user_info_to_session()
+            return True
+        return False
+    
+    def get_user_info(self) -> Dict:
+        """Get current user information."""
+        return self.user_info.copy()
+    
+    def has_complete_user_info(self) -> bool:
+        """Check if minimum required user information is collected (name + at least one contact)."""
+        has_name = bool(self.user_info.get("name"))
+        has_contact = bool(self.user_info.get("email") or self.user_info.get("phone"))
+        return has_name and has_contact
+    
+    def has_ideal_user_info(self) -> bool:
+        """Check if all preferred user information is collected (name + both contacts)."""
+        return all([
+            self.user_info.get("name"),
+            self.user_info.get("email"), 
+            self.user_info.get("phone")
+        ])
+    
+    def get_missing_user_info(self) -> List[str]:
+        """Get list of missing required user information."""
+        missing = []
+        if not self.user_info.get("name"):
+            missing.append("name")
+        
+        # For contacts, only mark as missing if we have neither
+        if not self.user_info.get("email") and not self.user_info.get("phone"):
+            missing.append("contact (email OR phone)")
+        
+        return missing
+    
+    def get_missing_ideal_info(self) -> List[str]:
+        """Get list of missing information for ideal collection (both contacts)."""
+        missing = []
+        if not self.user_info.get("name"):
+            missing.append("name")
+        if not self.user_info.get("email"):
+            missing.append("email")
+        if not self.user_info.get("phone"):
+            missing.append("phone")
+        return missing
+    
+    def extract_user_info_from_message(self, message: str) -> Dict:
+        """Extract user information from user messages using simple patterns."""
+        import re
+        extracted = {}
+        
+        # Email pattern
+        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+        emails = re.findall(email_pattern, message)
+        if emails:
+            email = emails[0]
+            # Handle spelled-out emails (remove hyphens unless user explicitly says "hyphen")
+            if '-' in email and 'hyphen' not in message.lower():
+                # Remove hyphens from spelled-out letters
+                email = email.replace('-', '')
+            extracted['email'] = email
+        
+        # Phone pattern (multiple formats including "call me at 630 880 5488")
+        phone_patterns = [
+            r'(\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})',  # Standard format
+            r'call me at\s*(\d{3})[-.\s]*(\d{3})[-.\s]*(\d{4})',  # "call me at" format
+            r'phone\s*:?\s*(\d{3})[-.\s]*(\d{3})[-.\s]*(\d{4})',  # "phone:" format
+            r'(\d{3})[-.\s]+(\d{3})[-.\s]+(\d{4})'  # Simple space/dash separated
+        ]
+        
+        for pattern in phone_patterns:
+            matches = re.findall(pattern, message, re.IGNORECASE)
+            if matches:
+                match = matches[0]
+                if isinstance(match, tuple):
+                    # Join all non-empty parts
+                    phone_digits = ''.join([part for part in match if part])
+                    if len(phone_digits) >= 10:  # Valid phone number
+                        extracted['phone'] = phone_digits
+                        break
+        
+        # Name pattern (various formats)
+        name_patterns = [
+            r"my name is ([A-Za-z\s]{2,30})",
+            r"i'm ([A-Za-z\s]{2,30})",
+            r"this is ([A-Za-z\s]{2,30})",
+            r"i am ([A-Za-z\s]{2,30})",
+            r"name is ([A-Za-z\s]{2,30})",  # "Name is TreeDogs"
+            r"(?:^|\s)([A-Z][a-z]+(?:\s[A-Z][a-z]+)*),?\s+(?:here|speaking|calling)"  # "Betty, here" or "John Smith calling"
+        ]
+        
+        for pattern in name_patterns:
+            match = re.search(pattern, message.lower())
+            if match:
+                potential_name = match.group(1).strip().title()
+                # Simple validation - name should be 2-50 chars and not contain numbers
+                if 2 <= len(potential_name) <= 50 and not any(char.isdigit() for char in potential_name):
+                    extracted['name'] = potential_name
+                    break
+        
+        return extracted
+    
+    def start_conversation(self) -> str:
+        """Start a new conversation."""
+        if not self.conversation_started:
+            self.conversation_started = True
+        return ""
+    
+    def chat(self, message: str) -> str:
+        """Process a user message and return response."""
+        import re  # Import re module for regex operations
+        
+        try:
+            # Validate input
+            if not message or not message.strip():
+                return "I'd love to help! Could you tell me what you need? 😊"
+            
+            if len(message) > 1000:
+                return "That's quite a message! Could you break it down into smaller parts? I work better with shorter requests. 📝"
+            
+            # Check for explicit contact information requests (not booking requests)
+            contact_request_patterns = [
+                r"what.{0,20}peter.{0,20}(phone|number|contact)",
+                r"(phone|number|contact).{0,20}peter",
+                r"how.{0,20}(reach|contact).{0,20}peter",
+                r"peter.{0,20}(email|phone).{0,20}address"
+            ]
+            
+            is_contact_request = any(re.search(pattern, message.lower()) for pattern in contact_request_patterns)
+            is_booking_request = any(word in message.lower() for word in ['book', 'schedule', 'appointment', 'meeting', 'available', 'time'])
+            
+            if is_contact_request and not is_booking_request:
+                contact_response = f"Peter's contact information:\n📞 Phone: {settings.my_phone_number}\n📧 Email: {settings.my_email_address}\n\nI can also help you schedule an appointment with Peter through this chat. What would you prefer?"
+                return contact_response
+            
+            # Extract and store user information from the message
+            extracted_info = self.extract_user_info_from_message(message)
+            for info_type, value in extracted_info.items():
+                if not self.user_info.get(info_type):  # Only update if we don't already have this info
+                    self.update_user_info(info_type, value)
+                    print(f"📝 Extracted {info_type}: {value}")
+            
+            # Debug: Show current user info status
+            if extracted_info:
+                print(f"👤 Current user info: {self.user_info}")
+            
+            # Start conversation if needed
+            if not self.conversation_started:
+                self.start_conversation()
+            
+            # Regular chat interaction using ReActAgent
+            print(f"🔍 Debug: About to call agent.run() with message: '{message}'")
+            print(f"🔍 Debug: Agent type: {type(self.agent)}")
+
+            # The new ReActAgent needs to be awaited and returns a dict with "response" key
+            import asyncio
+
+            async def run_agent():
+                print("🔍 Debug: Calling await agent.run()")
+                result = await self.agent.run(user_msg=message)
+                print(f"🔍 Debug: Agent result: {result}")
+                print(f"🔍 Debug: Result type: {type(result)}")
+
+                # ReActAgent returns a dict with "response" key
+                if isinstance(result, dict) and "response" in result:
+                    return result["response"]
+                else:
+                    return str(result)
+
+            # Check if we're already in an event loop
+            try:
+                loop = asyncio.get_running_loop()
+                print("🔍 Debug: Already in event loop, creating task")
+                # If we're in an event loop, we need to run this differently
+                # Create a new event loop in a thread
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, run_agent())
+                    result = future.result(timeout=30)
+                    return str(result)
+            except RuntimeError:
+                print("🔍 Debug: No event loop running, using asyncio.run()")
+                # No event loop running, we can use asyncio.run
+                result = asyncio.run(run_agent())
+                return str(result)
+            
+        except Exception as e:
+            import traceback
+            print(f"⚠️ Agent error: {e}")
+            print(f"🔍 Debug: Full traceback:")
+            traceback.print_exc()
+            # Friendly error handling with different messages based on error type
+            if "max iterations" in str(e).lower():
+                return "I got a bit carried away trying to help you! Let me try a simpler approach. Could you repeat your request? 🔄"
+            elif "rate limit" in str(e).lower():
+                return "Whoa there! I'm getting a bit overwhelmed. Could you wait just a moment and try again? ⏱️"
+            elif "authentication" in str(e).lower():
+                return "I'm having trouble connecting to your calendar. Could you check if I'm properly authenticated? 🔐"
+            elif "network" in str(e).lower() or "connection" in str(e).lower():
+                return "I'm having connectivity issues right now. Let's try that again in a moment! 🌐"
+            else:
+                error_phrases = [
+                    "Oops! I'm having a tiny technical hiccup. Could you try that again? 😊",
+                    "Oh dear! Something went a bit wonky on my end. Let's give that another shot! 🔧",
+                    "Hmm, I'm having a moment here! Could you repeat that for me? 💫"
+                ]
+                return random.choice(error_phrases)
+    
+    def stream_chat(self, message: str):
+        """Stream a chat response (generator)."""
+        try:
+            # Validate input
+            if not message or not message.strip():
+                error_message = "I'd love to help! Could you tell me what you need? 😊"
+                for word in error_message.split():
+                    yield word + " "
+                return
+            
+            if len(message) > 1000:
+                error_message = "That's quite a message! Could you break it down into smaller parts? 📝"
+                for word in error_message.split():
+                    yield word + " "
+                return
+            
+            # Extract and store user information from the message
+            extracted_info = self.extract_user_info_from_message(message)
+            for info_type, value in extracted_info.items():
+                if not self.user_info.get(info_type):  # Only update if we don't already have this info
+                    self.update_user_info(info_type, value)
+            
+            # Start conversation if needed
+            if not self.conversation_started:
+                self.start_conversation()
+            
+            # Stream the response using ReActAgent
+            agent_response = str(self.agent.run(message))
+                
+            # Yield the response word by word to simulate streaming
+            for word in agent_response.split():
+                yield word + " "
+                
+        except Exception as e:
+            print(f"⚠️ Stream chat error: {e}")
+            if "rate limit" in str(e).lower():
+                error_message = "I'm getting a bit overwhelmed. Let's try again in a moment! ⏱️"
+            elif "authentication" in str(e).lower():
+                error_message = "Having calendar connection issues. Please check authentication! 🔐"
+            else:
+                error_message = "I'm having a bit of trouble right now. Could you try again? 😊"
+            
+            for word in error_message.split():
+                yield word + " "
+    
+    def reset_conversation(self):
+        """Reset the conversation memory."""
+        self.memory.reset()
+        self.conversation_started = False
+    
+    def get_conversation_history(self) -> List[Dict]:
+        """Get the conversation history."""
+        messages = self.memory.get_all()
+        return [
+            {
+                "role": msg.role.value,
+                "content": msg.content,
+                "timestamp": getattr(msg, 'timestamp', None)
+            }
+            for msg in messages
+        ]
+    
+    def add_context(self, context: str):
+        """Add context information to the conversation."""
+        context_message = f"[Context: {context}]"
+        # Add as system message to memory if needed
+        
+    def get_available_tools(self) -> List[str]:
+        """Get list of available tool names."""
+        return [tool.metadata.name for tool in self.calendar_tools.get_tools()]
+    
+    def handle_special_commands(self, message: str) -> Optional[str]:
+        """Handle special commands like /help, /schedule, etc."""
+        message = message.lower().strip()
+        
+        if message in ['/help', 'help', 'what can you do']:
+            return """I'm ChatCal, Peter Michael Gits' scheduling assistant! 📅 Here's how I can help you:
+
+🤝 **Book a consultation with Peter**: "I'd like to schedule a business consultation"
+💼 **Schedule a meeting**: "I need a 30-minute meeting with Peter next week"
+📊 **Project discussions**: "Book time to discuss my project with Peter"
+🎯 **Advisory sessions**: "I need a 90-minute advisory session"
+
+Meeting types available:
+• **Quick chat** (30 minutes) - Brief discussions
+• **Consultation** (60 minutes) - Business consultations
+• **Project meeting** (60 minutes) - Project planning/review
+• **Advisory session** (90 minutes) - Extended strategic sessions
+
+Peter typically meets between 9 AM and 5 PM. Just tell me what you'd like to discuss and when you're available!"""
+        
+        elif message in ['/status', 'status']:
+            available_tools = self.get_available_tools()
+            auth_status = "✅ Connected" if self.calendar_tools.calendar_service.auth.is_authenticated() else "❌ Not authenticated"
+            
+            return f"""📊 **ChatCal Status**
+Calendar Connection: {auth_status}
+Available Tools: {len(available_tools)}
+Session ID: {self.session_id}
+Tools: {', '.join(available_tools)}
+
+Ready to help you manage your calendar! 🚀"""
+        
+        return None
+    
+    def store_meeting_id(self, meeting_id: str, meeting_info: dict):
+        """Store meeting ID and info for cancellation tracking."""
+        self.stored_meetings[meeting_id] = meeting_info
+        # Save to session for persistence
+        self._save_stored_meetings_to_session()
+    
+    def get_stored_meetings(self) -> dict:
+        """Get all stored meeting IDs and info."""
+        return self.stored_meetings.copy()
+    
+    def remove_stored_meeting(self, meeting_id: str):
+        """Remove a stored meeting ID."""
+        if meeting_id in self.stored_meetings:
+            del self.stored_meetings[meeting_id]
+            # Save to session for persistence
+            self._save_stored_meetings_to_session()
+
+    def _load_user_info_from_session(self) -> Optional[Dict]:
+        """Load user info from session storage."""
+        try:
+            # Use dynamic import to avoid circular imports
+            from app.core.session import session_manager
+
+            session_data = session_manager.get_session(self.session_id)
+            if session_data and 'user_data' in session_data:
+                user_data = session_data['user_data']
+                if 'user_info' in user_data:
+                    print(f"📥 Loaded user info from session: {user_data['user_info']}")
+                    return user_data['user_info']
+            return None
+        except Exception as e:
+            print(f"⚠️ Failed to load user info from session: {e}")
+            return None
+
+    def _save_user_info_to_session(self):
+        """Save user info to session storage."""
+        try:
+            # Use dynamic import to avoid circular imports
+            from app.core.session import session_manager
+
+            session_data = session_manager.get_session(self.session_id)
+            if session_data:
+                if 'user_data' not in session_data:
+                    session_data['user_data'] = {}
+                session_data['user_data']['user_info'] = self.user_info
+                session_manager.update_session(self.session_id, session_data)
+                print(f"💾 Saved user info to session: {self.user_info}")
+        except Exception as e:
+            print(f"⚠️ Failed to save user info to session: {e}")
+
+    def _load_stored_meetings_from_session(self) -> Optional[Dict]:
+        """Load stored meetings from session storage."""
+        try:
+            # Use dynamic import to avoid circular imports
+            from app.core.session import session_manager
+            from datetime import datetime
+
+            session_data = session_manager.get_session(self.session_id)
+            if session_data and 'user_data' in session_data:
+                user_data = session_data['user_data']
+                if 'stored_meetings' in user_data:
+                    meetings = user_data['stored_meetings']
+
+                    # Convert ISO format strings back to datetime objects
+                    for meeting_id, meeting_info in meetings.items():
+                        if 'start_time' in meeting_info and isinstance(meeting_info['start_time'], str):
+                            try:
+                                meeting_info['start_time'] = datetime.fromisoformat(meeting_info['start_time'])
+                            except ValueError:
+                                pass  # Keep as string if conversion fails
+
+                    print(f"📥 Loaded stored meetings from session: {meetings}")
+                    return meetings
+            return None
+        except Exception as e:
+            print(f"⚠️ Failed to load stored meetings from session: {e}")
+            return None
+
+    def _save_stored_meetings_to_session(self):
+        """Save stored meetings to session storage."""
+        try:
+            # Use dynamic import to avoid circular imports
+            from app.core.session import session_manager
+
+            session_data = session_manager.get_session(self.session_id)
+            if session_data:
+                if 'user_data' not in session_data:
+                    session_data['user_data'] = {}
+
+                # Convert datetime objects to strings for JSON serialization
+                serializable_meetings = {}
+                for meeting_id, meeting_info in self.stored_meetings.items():
+                    serializable_info = meeting_info.copy()
+                    if 'start_time' in serializable_info and hasattr(serializable_info['start_time'], 'isoformat'):
+                        serializable_info['start_time'] = serializable_info['start_time'].isoformat()
+                    serializable_meetings[meeting_id] = serializable_info
+
+                session_data['user_data']['stored_meetings'] = serializable_meetings
+                session_manager.update_session(self.session_id, session_data)
+                print(f"💾 Saved stored meetings to session: {serializable_meetings}")
+        except Exception as e:
+            print(f"⚠️ Failed to save stored meetings to session: {e}")

app/core/conversation.py

@@ -0,0 +1,74 @@
+from typing import List, Dict, Optional
+from datetime import datetime
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.memory import ChatMemoryBuffer
+from app.core.agent import ChatCalAgent
+# GREETING_TEMPLATES removed - no longer needed
+import random
+
+
+class ConversationManager:
+    """Manages conversation state and memory for chat sessions."""
+    
+    def __init__(self, session_id: str, max_history: int = 20):
+        self.session_id = session_id
+        self.max_history = max_history
+        self.agent = ChatCalAgent(session_id)
+        self.conversation_started = False
+    
+    def start_conversation(self) -> str:
+        """Start a new conversation with a friendly greeting."""
+        if not self.conversation_started:
+            greeting = self.agent.start_conversation()
+            self.conversation_started = True
+            return greeting
+        return ""
+    
+    def get_response(self, user_input: str) -> str:
+        """Get a response from the agent for the user input."""
+        # Check for special commands first
+        special_response = self.agent.handle_special_commands(user_input)
+        if special_response:
+            return special_response
+        
+        # Use the agent to handle the conversation
+        return self.agent.chat(user_input)
+    
+    def get_streaming_response(self, user_input: str):
+        """Get a streaming response from the agent for the user input."""
+        # Check for special commands first
+        special_response = self.agent.handle_special_commands(user_input)
+        if special_response:
+            # Stream the special response word by word
+            for word in special_response.split():
+                yield word + " "
+            return
+        
+        # Use the agent's streaming capability
+        for token in self.agent.stream_chat(user_input):
+            yield token
+    
+    def clear_history(self):
+        """Clear the conversation history."""
+        self.agent.reset_conversation()
+        self.conversation_started = False
+    
+    def get_conversation_history(self) -> List[Dict]:
+        """Get the current conversation history."""
+        return self.agent.get_conversation_history()
+    
+    def export_conversation(self) -> Dict:
+        """Export the conversation for storage or analysis."""
+        messages = self.get_conversation_history()
+        return {
+            "session_id": self.session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "messages": [
+                {
+                    "role": msg.role.value,
+                    "content": msg.content,
+                    "timestamp": getattr(msg, 'timestamp', None)
+                }
+                for msg in messages
+            ]
+        }

app/core/email_service.py

@@ -0,0 +1,359 @@
+"""Email service for sending calendar invitations."""
+
+import smtplib
+import uuid
+from datetime import datetime, timezone
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+from typing import Optional, Dict, Any
+from app.config import settings
+
+
+class EmailService:
+    """Handles sending email invitations for calendar appointments."""
+    
+    def __init__(self):
+        self.smtp_server = settings.smtp_server
+        self.smtp_port = settings.smtp_port
+        self.username = settings.smtp_username or settings.my_email_address
+        self.password = settings.smtp_password
+        self.from_name = settings.email_from_name
+        self.from_email = settings.my_email_address
+    
+    def create_calendar_invite(self, 
+                             title: str,
+                             start_datetime: datetime,
+                             end_datetime: datetime,
+                             description: str = "",
+                             location: str = "",
+                             organizer_email: str = None,
+                             attendee_emails: list = None) -> str:
+        """Create an iCal calendar invitation."""
+        
+        if not organizer_email:
+            organizer_email = self.from_email
+        
+        if not attendee_emails:
+            attendee_emails = []
+        
+        # Generate unique UID for the event
+        uid = str(uuid.uuid4())
+        
+        # Format datetime for iCal
+        def format_dt(dt):
+            return dt.strftime('%Y%m%dT%H%M%SZ')
+        
+        now = datetime.now(timezone.utc)
+        
+        ical_content = f"""BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//ChatCal.ai//Calendar Event//EN
+METHOD:REQUEST
+BEGIN:VEVENT
+UID:{uid}
+DTSTAMP:{format_dt(now)}
+DTSTART:{format_dt(start_datetime)}
+DTEND:{format_dt(end_datetime)}
+SUMMARY:{title}
+DESCRIPTION:{description}
+LOCATION:{location}
+ORGANIZER:MAILTO:{organizer_email}"""
+        
+        for attendee in attendee_emails:
+            ical_content += f"\nATTENDEE:MAILTO:{attendee}"
+        
+        ical_content += f"""
+STATUS:CONFIRMED
+TRANSP:OPAQUE
+END:VEVENT
+END:VCALENDAR"""
+        
+        return ical_content
+    
+    def send_invitation_email(self,
+                            to_email: str,
+                            to_name: str,
+                            title: str,
+                            start_datetime: datetime,
+                            end_datetime: datetime,
+                            description: str = "",
+                            user_phone: str = "",
+                            meeting_type: str = "Meeting",
+                            meet_link: str = "") -> bool:
+        """Send a calendar invitation email."""
+        
+        try:
+            # Create email message
+            msg = MIMEMultipart('alternative')
+            msg['Subject'] = f"Meeting Invitation: {title}"
+            msg['From'] = f"{self.from_name} <{self.from_email}>"
+            msg['To'] = f"{to_name} <{to_email}>"
+            
+            # Create email body
+            # In testing mode, treat Peter's email as a regular user email for testing purposes
+            is_peter_email = (to_email == settings.my_email_address and not settings.testing_mode)
+            
+            if is_peter_email:
+                # Email to Peter
+                html_body = self._create_peter_email_body(
+                    title, start_datetime, end_datetime, description, to_name, user_phone, meet_link
+                )
+            else:
+                # Email to user (or Peter's email in testing mode)
+                html_body = self._create_user_email_body(
+                    title, start_datetime, end_datetime, description, meeting_type, meet_link
+                )
+            
+            # Create plain text version
+            text_body = self._html_to_text(html_body)
+            
+            # Attach both versions
+            part1 = MIMEText(text_body, 'plain')
+            part2 = MIMEText(html_body, 'html')
+            
+            msg.attach(part1)
+            msg.attach(part2)
+            
+            # Create and attach calendar invitation
+            ical_content = self.create_calendar_invite(
+                title=title,
+                start_datetime=start_datetime,
+                end_datetime=end_datetime,
+                description=description,
+                organizer_email=self.from_email,
+                attendee_emails=[to_email, self.from_email]
+            )
+            
+            # Attach calendar file
+            cal_attachment = MIMEBase('text', 'calendar')
+            cal_attachment.set_payload(ical_content.encode('utf-8'))
+            encoders.encode_base64(cal_attachment)
+            cal_attachment.add_header('Content-Disposition', 'attachment; filename="meeting.ics"')
+            cal_attachment.add_header('Content-Type', 'text/calendar; method=REQUEST; name="meeting.ics"')
+            msg.attach(cal_attachment)
+            
+            # Send email
+            if self.password:  # Only send if SMTP credentials are configured
+                print(f"🔧 SMTP configured, sending email to {to_email}")
+                with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
+                    server.starttls()
+                    server.login(self.username, self.password)
+                    server.send_message(msg)
+                
+                print(f"✅ Email invitation sent to {to_email}")
+                return True
+            else:
+                print(f"⚠️ SMTP not configured (no password), skipping actual email send to {to_email}")
+                print(f"📧 Email invitation prepared for {to_email} (SMTP not configured)")
+                return True  # Consider it successful for demo purposes
+                
+        except Exception as e:
+            print(f"❌ Failed to send email to {to_email}: {e}")
+            return False
+    
+    def send_cancellation_email(self,
+                              to_email: str,
+                              to_name: str,
+                              meeting_title: str,
+                              original_datetime: datetime) -> bool:
+        """Send a meeting cancellation email."""
+        
+        try:
+            # Create email message
+            msg = MIMEMultipart('alternative')
+            msg['Subject'] = f"Meeting Cancelled: {meeting_title}"
+            msg['From'] = f"{self.from_name} <{self.from_email}>"
+            msg['To'] = f"{to_name} <{to_email}>"
+            
+            # Create email body
+            formatted_time = original_datetime.strftime('%A, %B %d, %Y at %I:%M %p %Z')
+            
+            html_body = f"""
+            <html>
+            <body style="font-family: Arial, sans-serif; margin: 20px; color: #333;">
+                <h2 style="color: #f44336;">❌ Meeting Cancelled</h2>
+                
+                <div style="background: #ffebee; padding: 20px; border-radius: 8px; margin: 20px 0; border-left: 4px solid #f44336;">
+                    <h3 style="margin-top: 0; color: #c62828;">{meeting_title}</h3>
+                    
+                    <div style="margin: 15px 0;">
+                        <strong>📅 Was scheduled for:</strong><br>
+                        {formatted_time}
+                    </div>
+                    
+                    <div style="margin: 15px 0;">
+                        <strong>👤 With:</strong> Peter Michael Gits<br>
+                        <strong>📞 Peter's Phone:</strong> {settings.my_phone_number}<br>
+                        <strong>📧 Peter's Email:</strong> {settings.my_email_address}
+                    </div>
+                </div>
+                
+                <div style="background: #e3f2fd; padding: 15px; border-radius: 8px; margin: 20px 0; border-left: 4px solid #2196f3;">
+                    <h4 style="margin-top: 0; color: #1565c0;">Need to reschedule?</h4>
+                    <p style="margin-bottom: 0; color: #1565c0;">
+                        Feel free to book a new appointment through ChatCal.ai or contact Peter directly.
+                    </p>
+                </div>
+                
+                <p style="color: #6c757d; font-size: 14px;">
+                    This cancellation was processed through ChatCal.ai.
+                </p>
+                
+                <hr style="border: none; border-top: 1px solid #dee2e6; margin: 20px 0;">
+                <p style="color: #6c757d; font-size: 12px;">
+                    Sent by ChatCal.ai - Peter Michael Gits' AI Scheduling Assistant<br>
+                    Peter: {settings.my_phone_number} | {settings.my_email_address}
+                </p>
+            </body>
+            </html>
+            """
+            
+            # Create plain text version
+            text_body = f"""
+Meeting Cancelled: {meeting_title}
+
+Was scheduled for: {formatted_time}
+With: Peter Michael Gits
+
+Need to reschedule? Contact Peter:
+Phone: {settings.my_phone_number}
+Email: {settings.my_email_address}
+
+This cancellation was processed through ChatCal.ai.
+            """.strip()
+            
+            # Attach both versions
+            part1 = MIMEText(text_body, 'plain')
+            part2 = MIMEText(html_body, 'html')
+            
+            msg.attach(part1)
+            msg.attach(part2)
+            
+            # Send email
+            if self.password:  # Only send if SMTP credentials are configured
+                print(f"🔧 SMTP configured, sending cancellation email to {to_email}")
+                with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
+                    server.starttls()
+                    server.login(self.username, self.password)
+                    server.send_message(msg)
+                
+                print(f"✅ Cancellation email sent to {to_email}")
+                return True
+            else:
+                print(f"⚠️ SMTP not configured, skipping cancellation email to {to_email}")
+                print(f"📧 Cancellation email prepared for {to_email} (SMTP not configured)")
+                return True  # Consider it successful for demo purposes
+                
+        except Exception as e:
+            print(f"❌ Failed to send cancellation email to {to_email}: {e}")
+            return False
+    
+    def _create_peter_email_body(self, title: str, start_datetime: datetime, 
+                               end_datetime: datetime, description: str, 
+                               user_name: str, user_phone: str, meet_link: str = "") -> str:
+        """Create email body for Peter."""
+        
+        return f"""
+        <html>
+        <body style="font-family: Arial, sans-serif; margin: 20px; color: #333;">
+            <h2 style="color: #2c3e50;">📅 New Meeting Scheduled</h2>
+            
+            <div style="background: #f8f9fa; padding: 20px; border-radius: 8px; margin: 20px 0;">
+                <h3 style="margin-top: 0; color: #495057;">{title}</h3>
+                
+                <div style="margin: 15px 0;">
+                    <strong>📅 Date & Time:</strong><br>
+                    {start_datetime.strftime('%A, %B %d, %Y')}<br>
+                    {start_datetime.strftime('%I:%M %p')} - {end_datetime.strftime('%I:%M %p')} ({start_datetime.strftime('%Z')})
+                </div>
+                
+                <div style="margin: 15px 0;">
+                    <strong>👤 Meeting with:</strong> {user_name}<br>
+                    <strong>📞 Phone:</strong> {user_phone or 'Not provided'}
+                    {f'<br><strong>🎥 Google Meet:</strong> <a href="{meet_link}" style="color: #1976d2;">{meet_link}</a>' if meet_link else ''}
+                </div>
+                
+                {f'<div style="margin: 15px 0;"><strong>📝 Details:</strong><br>{description}</div>' if description else ''}
+            </div>
+            
+            <p style="color: #6c757d; font-size: 14px;">
+                This meeting was scheduled through ChatCal.ai. The calendar invitation is attached to this email.
+            </p>
+            
+            <hr style="border: none; border-top: 1px solid #dee2e6; margin: 20px 0;">
+            <p style="color: #6c757d; font-size: 12px;">
+                Sent by ChatCal.ai - Peter Michael Gits' AI Scheduling Assistant
+            </p>
+        </body>
+        </html>
+        """
+    
+    def _create_user_email_body(self, title: str, start_datetime: datetime, 
+                              end_datetime: datetime, description: str, 
+                              meeting_type: str, meet_link: str = "") -> str:
+        """Create email body for the user."""
+        
+        return f"""
+        <html>
+        <body style="font-family: Arial, sans-serif; margin: 20px; color: #333;">
+            <h2 style="color: #2c3e50;">✅ Your Meeting with Peter Michael Gits is Confirmed!</h2>
+            
+            <div style="background: #e8f5e9; padding: 20px; border-radius: 8px; margin: 20px 0; border-left: 4px solid #4caf50;">
+                <h3 style="margin-top: 0; color: #2e7d32;">{title}</h3>
+                
+                <div style="margin: 15px 0;">
+                    <strong>📅 Date & Time:</strong><br>
+                    {start_datetime.strftime('%A, %B %d, %Y')}<br>
+                    {start_datetime.strftime('%I:%M %p')} - {end_datetime.strftime('%I:%M %p')} ({start_datetime.strftime('%Z')})
+                </div>
+                
+                <div style="margin: 15px 0;">
+                    <strong>👤 Meeting with:</strong> Peter Michael Gits<br>
+                    <strong>📞 Peter's Phone:</strong> {settings.my_phone_number}<br>
+                    <strong>📧 Peter's Email:</strong> {settings.my_email_address}
+                    {f'<br><strong>🎥 Google Meet Link:</strong> <a href="{meet_link}" style="color: #1976d2; font-weight: bold;">{meet_link}</a>' if meet_link else ''}
+                </div>
+                
+                {f'<div style="margin: 15px 0;"><strong>📝 Meeting Details:</strong><br>{description}</div>' if description else ''}
+            </div>
+            
+            <div style="background: #fff3cd; padding: 15px; border-radius: 8px; margin: 20px 0; border-left: 4px solid #ffc107;">
+                <h4 style="margin-top: 0; color: #856404;">📋 What's Next?</h4>
+                <ul style="color: #856404; margin-bottom: 0;">
+                    <li>Add this meeting to your calendar using the attached invitation file</li>
+                    <li>Peter will reach out via the contact method you provided</li>
+                    <li>If you need to reschedule, please contact Peter directly</li>
+                </ul>
+            </div>
+            
+            <p style="color: #6c757d; font-size: 14px;">
+                Looking forward to your meeting! The calendar invitation is attached to this email.
+            </p>
+            
+            <hr style="border: none; border-top: 1px solid #dee2e6; margin: 20px 0;">
+            <p style="color: #6c757d; font-size: 12px;">
+                Sent by ChatCal.ai - Peter Michael Gits' AI Scheduling Assistant<br>
+                Peter: {settings.my_phone_number} | {settings.my_email_address}
+            </p>
+        </body>
+        </html>
+        """
+    
+    def _html_to_text(self, html: str) -> str:
+        """Convert HTML email to plain text."""
+        import re
+        
+        # Remove HTML tags
+        text = re.sub('<[^<]+?>', '', html)
+        
+        # Clean up whitespace
+        text = re.sub(r'\n\s*\n', '\n\n', text)
+        text = text.strip()
+        
+        return text
+
+
+# Global email service instance
+email_service = EmailService()

app/core/exceptions.py

@@ -0,0 +1,47 @@
+"""Custom exceptions for ChatCal.ai application."""
+
+from typing import Optional, Dict, Any
+
+
+class ChatCalException(Exception):
+    """Base exception for ChatCal.ai application."""
+    
+    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
+        self.message = message
+        self.details = details or {}
+        super().__init__(self.message)
+
+
+class AuthenticationError(ChatCalException):
+    """Raised when authentication fails."""
+    pass
+
+
+class CalendarError(ChatCalException):
+    """Raised when calendar operations fail."""
+    pass
+
+
+class LLMError(ChatCalException):
+    """Raised when LLM operations fail."""
+    pass
+
+
+class ValidationError(ChatCalException):
+    """Raised when input validation fails."""
+    pass
+
+
+class RateLimitError(ChatCalException):
+    """Raised when API rate limits are exceeded."""
+    pass
+
+
+class ServiceUnavailableError(ChatCalException):
+    """Raised when external services are unavailable."""
+    pass
+
+
+class ConfigurationError(ChatCalException):
+    """Raised when configuration is invalid."""
+    pass

app/core/jwt_session.py

@@ -0,0 +1,110 @@
+import json
+import uuid
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+import jwt
+from app.config import settings
+from app.core.conversation import ConversationManager
+
+
+class JWTSessionManager:
+    """JWT-based session manager - drop-in replacement for Redis SessionManager."""
+
+    def __init__(self):
+        self.session_timeout = timedelta(minutes=settings.session_timeout_minutes)
+        self.conversations: Dict[str, ConversationManager] = {}
+        self.secret_key = settings.secret_key
+
+    def _encode_session(self, session_data: Dict) -> str:
+        """Encode session data as JWT."""
+        payload = {
+            **session_data,
+            'exp': datetime.utcnow() + self.session_timeout
+        }
+        return jwt.encode(payload, self.secret_key, algorithm='HS256')
+
+    def _decode_session(self, token: str) -> Optional[Dict]:
+        """Decode JWT session token."""
+        try:
+            payload = jwt.decode(token, self.secret_key, algorithms=['HS256'])
+            # Remove JWT specific fields
+            payload.pop('exp', None)
+            return payload
+        except jwt.ExpiredSignatureError:
+            return None
+        except jwt.InvalidTokenError:
+            return None
+
+    def create_session(self, user_data: Optional[Dict] = None) -> str:
+        """Create a new session and return the session ID."""
+        session_id = str(uuid.uuid4())
+        session_data = {
+            "session_id": session_id,
+            "created_at": datetime.utcnow().isoformat(),
+            "last_activity": datetime.utcnow().isoformat(),
+            "user_data": user_data or {},
+            "conversation_started": False
+        }
+
+        # Return the session ID (JWT token will be created when needed)
+        return session_id
+
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """Retrieve session data (for compatibility - JWT will be handled at API level)."""
+        # This will be overridden to work with JWT tokens at the API level
+        if session_id in self.conversations:
+            return {
+                "session_id": session_id,
+                "created_at": datetime.utcnow().isoformat(),
+                "last_activity": datetime.utcnow().isoformat(),
+                "user_data": {},
+                "conversation_started": True
+            }
+        return None
+
+    def update_session(self, session_id: str, updates: Dict) -> bool:
+        """Update session data."""
+        # For JWT sessions, updates are handled at the conversation level
+        return True
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session."""
+        # Remove from memory
+        if session_id in self.conversations:
+            del self.conversations[session_id]
+        return True
+
+    def get_or_create_conversation(self, session_id: str) -> Optional[ConversationManager]:
+        """Get or create a conversation manager for a session."""
+        # Return existing conversation if in memory
+        if session_id in self.conversations:
+            return self.conversations[session_id]
+
+        # Create new conversation
+        conversation = ConversationManager(
+            session_id=session_id,
+            max_history=settings.max_conversation_history
+        )
+        self.conversations[session_id] = conversation
+
+        return conversation
+
+    def store_conversation_history(self, session_id: str) -> bool:
+        """Store conversation history (no-op for JWT sessions)."""
+        return True
+
+    def get_conversation_history(self, session_id: str) -> Optional[Dict]:
+        """Retrieve conversation history (no-op for JWT sessions)."""
+        return None
+
+    def extend_session(self, session_id: str) -> bool:
+        """Extend session timeout (handled automatically with JWT)."""
+        return True
+
+    def cleanup_expired_conversations(self):
+        """Clean up expired conversations from memory (no-op for JWT)."""
+        pass
+
+
+# Global session manager instance
+jwt_session_manager = JWTSessionManager()

app/core/llm.py

@@ -0,0 +1,71 @@
+from typing import Optional
+import os
+from llama_index.core import Settings
+from llama_index.llms.anthropic import Anthropic
+from llama_index.core.llms import ChatMessage, MessageRole
+from app.config import settings
+from app.personality.prompts import SYSTEM_PROMPT
+
+
+class AnthropicLLM:
+    """Manages the Anthropic LLM integration with LlamaIndex."""
+    
+    def __init__(self):
+        self.api_key = settings.anthropic_api_key
+        self.llm = None
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Initialize the Anthropic LLM with LlamaIndex settings."""
+        # Check if we should use mock LLM for testing
+        if os.getenv("USE_MOCK_LLM", "").lower() == "true":
+            from app.core.mock_llm import MockAnthropicLLM
+            self.llm = MockAnthropicLLM(system_prompt=SYSTEM_PROMPT)
+            print("🔧 Using Mock LLM for testing")
+        else:
+            self.llm = Anthropic(
+                api_key=self.api_key,
+                model="claude-sonnet-4-20250514",  # Using Claude Sonnet 4
+                max_tokens=4096,
+                temperature=0.7,  # Balanced for friendly conversation
+                system_prompt=SYSTEM_PROMPT
+            )
+        
+        # Set as default LLM for LlamaIndex
+        Settings.llm = self.llm
+        
+        # Configure other LlamaIndex settings
+        Settings.chunk_size = 1024
+        Settings.chunk_overlap = 20
+    
+    def get_llm(self):
+        """Get the configured Anthropic LLM instance."""
+        return self.llm
+    
+    def create_chat_message(self, content: str, role: MessageRole = MessageRole.USER) -> ChatMessage:
+        """Create a chat message with the specified role."""
+        return ChatMessage(role=role, content=content)
+    
+    def get_streaming_response(self, messages: list[ChatMessage]):
+        """Get a streaming response from the LLM."""
+        return self.llm.stream_chat(messages)
+    
+    def get_response(self, messages: list[ChatMessage]):
+        """Get a non-streaming response from the LLM."""
+        return self.llm.chat(messages)
+    
+    def test_connection(self) -> bool:
+        """Test the connection to Anthropic API."""
+        try:
+            test_message = [
+                ChatMessage(role=MessageRole.USER, content="Hello! Please respond with a brief greeting.")
+            ]
+            response = self.llm.chat(test_message)
+            return bool(response.message.content)
+        except Exception as e:
+            print(f"Anthropic API connection test failed: {e}")
+            return False
+
+
+# Global instance
+anthropic_llm = AnthropicLLM()

app/core/llm_anthropic.py

@@ -0,0 +1,89 @@
+"""Groq LLM integration for ChatCal.ai (using anthropic_llm interface)."""
+
+from typing import Optional
+import os
+from llama_index.core import Settings
+from llama_index.llms.groq import Groq
+from llama_index.core.llms import ChatMessage, MessageRole
+from app.config import settings
+from app.personality.prompts import SYSTEM_PROMPT
+
+
+class AnthropicLLM:
+    """Manages the Groq LLM integration with LlamaIndex (keeping AnthropicLLM name for compatibility)."""
+    
+    def __init__(self):
+        self.api_key = settings.groq_api_key  # Use GROQ_API_KEY instead
+        self.llm = None
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Initialize the Groq LLM with LlamaIndex settings."""
+        try:
+            # Validate API key
+            if not self.api_key or self.api_key == "your_groq_api_key_here":
+                raise ValueError("Groq API key not configured. Please set GROQ_API_KEY in .env file")
+            
+            # Check if we should use mock LLM for testing
+            if os.getenv("USE_MOCK_LLM", "").lower() == "true":
+                from app.core.mock_llm import MockAnthropicLLM
+                self.llm = MockAnthropicLLM(system_prompt=SYSTEM_PROMPT)
+                print("🔧 Using Mock LLM for testing")
+            else:
+                self.llm = Groq(
+                    api_key=self.api_key,
+                    model="llama-3.1-8b-instant",  # Using Groq's Llama 3.1 8B Instant
+                    max_tokens=4096,
+                    temperature=0.7,  # Balanced for friendly conversation
+                    system_prompt=SYSTEM_PROMPT
+                )
+                print("🔧 Using Groq Llama-3.1-8b-instant LLM")
+            
+            # Set as default LLM for LlamaIndex
+            Settings.llm = self.llm
+            
+            # Configure other LlamaIndex settings
+            Settings.chunk_size = 1024
+            Settings.chunk_overlap = 20
+            
+        except Exception as e:
+            print(f"❌ Failed to initialize Groq LLM: {e}")
+            # Fallback to mock LLM if available
+            try:
+                from app.core.mock_llm import MockAnthropicLLM
+                self.llm = MockAnthropicLLM(system_prompt=SYSTEM_PROMPT)
+                print("🔧 Falling back to Mock LLM")
+            except ImportError:
+                raise RuntimeError(f"Failed to initialize Groq LLM and no fallback available: {e}")
+    
+    def get_llm(self):
+        """Get the configured Groq LLM instance."""
+        if self.llm is None:
+            raise RuntimeError("Groq LLM not initialized. Please check your configuration.")
+        return self.llm
+    
+    def create_chat_message(self, content: str, role: MessageRole = MessageRole.USER) -> ChatMessage:
+        """Create a chat message with the specified role."""
+        return ChatMessage(role=role, content=content)
+    
+    def get_streaming_response(self, messages: list[ChatMessage]):
+        """Get a streaming response from the LLM."""
+        return self.llm.stream_chat(messages)
+    
+    def get_response(self, messages: list[ChatMessage]):
+        """Get a non-streaming response from the LLM."""
+        return self.llm.chat(messages)
+    
+    def test_connection(self) -> bool:
+        """Test the connection to Groq API."""
+        try:
+            # Use complete() instead of chat() for testing to avoid response format issues
+            response = self.llm.complete("Hello")
+            return bool(response and hasattr(response, 'text') and response.text)
+        except Exception as e:
+            print(f"Groq API connection test failed: {e}")
+            return False
+
+
+# Global instance
+anthropic_llm = AnthropicLLM()

app/core/llm_gemini.py

@@ -0,0 +1,89 @@
+"""Gemini LLM integration for ChatCal.ai."""
+
+from typing import Optional
+import os
+from llama_index.core import Settings
+from llama_index.llms.gemini import Gemini
+from llama_index.core.llms import ChatMessage, MessageRole
+from app.config import settings
+from app.personality.prompts import SYSTEM_PROMPT
+
+
+class GeminiLLM:
+    """Manages the Gemini LLM integration with LlamaIndex."""
+    
+    def __init__(self):
+        self.api_key = settings.gemini_api_key
+        self.llm = None
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Initialize the Gemini LLM with LlamaIndex settings."""
+        try:
+            # Validate API key
+            if not self.api_key or self.api_key == "your_gemini_api_key_here":
+                raise ValueError("Gemini API key not configured. Please set GEMINI_API_KEY in .env file")
+            
+            # Check if we should use mock LLM for testing
+            if os.getenv("USE_MOCK_LLM", "").lower() == "true":
+                from app.core.mock_llm import MockAnthropicLLM
+                self.llm = MockAnthropicLLM(system_prompt=SYSTEM_PROMPT)
+                print("🔧 Using Mock LLM for testing")
+            else:
+                self.llm = Gemini(
+                    api_key=self.api_key,
+                    model="models/gemini-2.0-flash-exp",  # Using Gemini 2.0 Flash Experimental with proper prefix
+                    max_tokens=4096,
+                    temperature=0.7,  # Balanced for friendly conversation
+                    system_prompt=SYSTEM_PROMPT
+                )
+                print("🔧 Using Gemini LLM")
+            
+            # Set as default LLM for LlamaIndex
+            Settings.llm = self.llm
+            
+            # Configure other LlamaIndex settings
+            Settings.chunk_size = 1024
+            Settings.chunk_overlap = 20
+            
+        except Exception as e:
+            print(f"❌ Failed to initialize Gemini LLM: {e}")
+            # Fallback to mock LLM if available
+            try:
+                from app.core.mock_llm import MockAnthropicLLM
+                self.llm = MockAnthropicLLM(system_prompt=SYSTEM_PROMPT)
+                print("🔧 Falling back to Mock LLM")
+            except ImportError:
+                raise RuntimeError(f"Failed to initialize Gemini LLM and no fallback available: {e}")
+    
+    def get_llm(self):
+        """Get the configured Gemini LLM instance."""
+        if self.llm is None:
+            raise RuntimeError("Gemini LLM not initialized. Please check your configuration.")
+        return self.llm
+    
+    def create_chat_message(self, content: str, role: MessageRole = MessageRole.USER) -> ChatMessage:
+        """Create a chat message with the specified role."""
+        return ChatMessage(role=role, content=content)
+    
+    def get_streaming_response(self, messages: list[ChatMessage]):
+        """Get a streaming response from the LLM."""
+        return self.llm.stream_chat(messages)
+    
+    def get_response(self, messages: list[ChatMessage]):
+        """Get a non-streaming response from the LLM."""
+        return self.llm.chat(messages)
+    
+    def test_connection(self) -> bool:
+        """Test the connection to Gemini API."""
+        try:
+            # Use complete() instead of chat() for testing to avoid the ChatResponse/CompletionResponse issue
+            response = self.llm.complete("Hello")
+            return bool(response and hasattr(response, 'text') and response.text)
+        except Exception as e:
+            print(f"Gemini API connection test failed: {e}")
+            return False
+
+
+# Global instance
+gemini_llm = GeminiLLM()

app/core/mock_llm.py

@@ -0,0 +1,122 @@
+"""Mock LLM for testing without API credits."""
+
+from typing import List, Optional
+from llama_index.core.llms import ChatMessage, MessageRole, ChatResponse, CompletionResponse
+from llama_index.core.llms.llm import LLM
+from llama_index.core.llms.callbacks import llm_completion_callback
+from app.personality.prompts import GREETING_TEMPLATES, BOOKING_CONFIRMATIONS, ENCOURAGEMENT_PHRASES
+import random
+import re
+
+
+class MockAnthropicLLM(LLM):
+    """Mock Anthropic LLM for testing without API calls."""
+    
+    model: str = "claude-3-5-sonnet-20241022-mock"
+    max_tokens: int = 4096
+    system_prompt: str = ""
+    
+    def __init__(self, **kwargs):
+        # Extract system_prompt before calling super().__init__
+        system_prompt = kwargs.pop("system_prompt", "")
+        super().__init__(model="claude-3-5-sonnet-20241022-mock", **kwargs)
+        self.system_prompt = system_prompt
+    
+    @property
+    def metadata(self):
+        return {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "is_mock": True
+        }
+    
+    def _generate_mock_response(self, prompt: str) -> str:
+        """Generate a mock response based on the prompt."""
+        prompt_lower = prompt.lower()
+        
+        # Meeting scheduling patterns
+        if any(word in prompt_lower for word in ["schedule", "meeting", "appointment", "book"]):
+            if "tuesday" in prompt_lower and "2pm" in prompt_lower:
+                return "Wonderful! 🌟 I'd be absolutely delighted to help you schedule that meeting for Tuesday at 2pm. Let me check the calendar for you... *checking* Great news! Tuesday at 2pm is available! How long would you like this meeting to be? 30 minutes? An hour? I'm here to make this super easy for you!"
+            elif "time" in prompt_lower and "team" in prompt_lower:
+                return "Oh, a team meeting! How exciting! 🎯 I'd love to help you find the perfect time for everyone. What days are you considering? I can check multiple time slots to find one that works best for your team. You're doing such a great job coordinating everyone!"
+            else:
+                return "I'd be thrilled to help you schedule that! 📅 Could you tell me what day and time you're thinking about? I'll make sure to find the perfect slot for you!"
+        
+        # Duration questions
+        elif "30" in prompt_lower or "hour" in prompt_lower:
+            duration = "30 minutes" if "30" in prompt_lower else "one hour"
+            attendee = "John Smith" if "john" in prompt_lower else "your meeting"
+            return f"Perfect! 🎉 I've got that down as a {duration} meeting. Let me finalize this for you... *booking* Fantastic! Your meeting {f'with {attendee}' if attendee != 'your meeting' else ''} is all set for Tuesday at 2pm for {duration}. You're absolutely crushing this scheduling game! 🌟"
+        
+        # Greeting
+        elif any(word in prompt_lower for word in ["hi", "hello", "hey"]):
+            return random.choice(GREETING_TEMPLATES)
+        
+        # Default helpful response
+        else:
+            return f"I'm here to help! 😊 {random.choice(ENCOURAGEMENT_PHRASES)} What would you like to schedule today?"
+    
+    @llm_completion_callback()
+    def complete(self, prompt: str, **kwargs) -> CompletionResponse:
+        """Complete the prompt."""
+        response = self._generate_mock_response(prompt)
+        return CompletionResponse(text=response)
+    
+    @llm_completion_callback()
+    def chat(self, messages: List[ChatMessage], **kwargs) -> ChatResponse:
+        """Chat with the model."""
+        # Get the last user message
+        last_user_msg = ""
+        for msg in reversed(messages):
+            if msg.role == MessageRole.USER:
+                last_user_msg = msg.content
+                break
+        
+        response = self._generate_mock_response(last_user_msg)
+        return ChatResponse(
+            message=ChatMessage(role=MessageRole.ASSISTANT, content=response)
+        )
+    
+    @llm_completion_callback()
+    def stream_chat(self, messages: List[ChatMessage], **kwargs):
+        """Stream chat responses."""
+        response = self.chat(messages, **kwargs)
+        # Simulate streaming by yielding words
+        words = response.message.content.split()
+        for i, word in enumerate(words):
+            if i > 0:
+                yield type('obj', (object,), {'delta': ' ' + word})
+            else:
+                yield type('obj', (object,), {'delta': word})
+    
+    @llm_completion_callback()
+    def stream_complete(self, prompt: str, **kwargs):
+        """Stream completion responses."""
+        response = self.complete(prompt, **kwargs)
+        # Simulate streaming
+        words = response.text.split()
+        for i, word in enumerate(words):
+            if i > 0:
+                yield type('obj', (object,), {'delta': ' ' + word})
+            else:
+                yield type('obj', (object,), {'delta': word})
+    
+    # Async methods (required by abstract base class)
+    async def achat(self, messages: List[ChatMessage], **kwargs) -> ChatResponse:
+        """Async chat - just calls sync version."""
+        return self.chat(messages, **kwargs)
+    
+    async def acomplete(self, prompt: str, **kwargs) -> CompletionResponse:
+        """Async complete - just calls sync version."""
+        return self.complete(prompt, **kwargs)
+    
+    async def astream_chat(self, messages: List[ChatMessage], **kwargs):
+        """Async stream chat - just yields sync version."""
+        for chunk in self.stream_chat(messages, **kwargs):
+            yield chunk
+    
+    async def astream_complete(self, prompt: str, **kwargs):
+        """Async stream complete - just yields sync version."""
+        for chunk in self.stream_complete(prompt, **kwargs):
+            yield chunk

app/core/session.py

@@ -0,0 +1,151 @@
+import json
+import uuid
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+import redis
+from app.config import settings
+from app.core.conversation import ConversationManager
+
+
+class SessionManager:
+    """Manages user sessions with Redis backend."""
+    
+    def __init__(self):
+        self.redis_client = redis.from_url(settings.redis_url, decode_responses=True)
+        self.session_timeout = timedelta(minutes=settings.session_timeout_minutes)
+        self.conversations: Dict[str, ConversationManager] = {}
+    
+    def create_session(self, user_data: Optional[Dict] = None) -> str:
+        """Create a new session and return the session ID."""
+        session_id = str(uuid.uuid4())
+        session_data = {
+            "created_at": datetime.utcnow().isoformat(),
+            "last_activity": datetime.utcnow().isoformat(),
+            "user_data": user_data or {},
+            "conversation_started": False
+        }
+        
+        # Store in Redis with expiration
+        self.redis_client.setex(
+            f"session:{session_id}",
+            self.session_timeout,
+            json.dumps(session_data)
+        )
+        
+        return session_id
+    
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """Retrieve session data from Redis."""
+        data = self.redis_client.get(f"session:{session_id}")
+        if data:
+            return json.loads(data)
+        return None
+    
+    def update_session(self, session_id: str, updates: Dict) -> bool:
+        """Update session data."""
+        session_data = self.get_session(session_id)
+        if not session_data:
+            return False
+        
+        session_data.update(updates)
+        session_data["last_activity"] = datetime.utcnow().isoformat()
+        
+        # Reset expiration on activity
+        self.redis_client.setex(
+            f"session:{session_id}",
+            self.session_timeout,
+            json.dumps(session_data)
+        )
+        
+        return True
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session."""
+        # Remove from Redis
+        result = self.redis_client.delete(f"session:{session_id}")
+        
+        # Remove from memory
+        if session_id in self.conversations:
+            del self.conversations[session_id]
+        
+        return bool(result)
+    
+    def get_or_create_conversation(self, session_id: str) -> Optional[ConversationManager]:
+        """Get or create a conversation manager for a session."""
+        # Check if session exists
+        if not self.get_session(session_id):
+            return None
+        
+        # Return existing conversation if in memory
+        if session_id in self.conversations:
+            self.update_session(session_id, {"last_activity": datetime.utcnow().isoformat()})
+            return self.conversations[session_id]
+        
+        # Create new conversation
+        conversation = ConversationManager(
+            session_id=session_id,
+            max_history=settings.max_conversation_history
+        )
+        self.conversations[session_id] = conversation
+        
+        # Update session
+        self.update_session(session_id, {
+            "conversation_started": True,
+            "last_activity": datetime.utcnow().isoformat()
+        })
+        
+        return conversation
+    
+    def store_conversation_history(self, session_id: str) -> bool:
+        """Store conversation history in Redis."""
+        if session_id not in self.conversations:
+            return False
+        
+        conversation = self.conversations[session_id]
+        # TODO: Fix export_conversation method to handle dict/object conversion
+        # For now, just store basic session info
+        history = {
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+            "messages": []  # Simplified for now
+        }
+        
+        # Store conversation history separately
+        self.redis_client.setex(
+            f"conversation:{session_id}",
+            self.session_timeout * 2,  # Keep conversation history longer
+            json.dumps(history)
+        )
+        
+        return True
+    
+    def get_conversation_history(self, session_id: str) -> Optional[Dict]:
+        """Retrieve conversation history from Redis."""
+        data = self.redis_client.get(f"conversation:{session_id}")
+        if data:
+            return json.loads(data)
+        return None
+    
+    def extend_session(self, session_id: str) -> bool:
+        """Extend session timeout."""
+        session_data = self.get_session(session_id)
+        if not session_data:
+            return False
+        
+        # Reset expiration
+        self.redis_client.expire(f"session:{session_id}", self.session_timeout)
+        return True
+    
+    def cleanup_expired_conversations(self):
+        """Clean up expired conversations from memory."""
+        expired = []
+        for session_id in self.conversations:
+            if not self.get_session(session_id):
+                expired.append(session_id)
+        
+        for session_id in expired:
+            del self.conversations[session_id]
+
+
+# Global session manager instance
+session_manager = SessionManager()

app/core/session_factory.py

@@ -0,0 +1,17 @@
+"""Session backend factory - minimal change approach."""
+
+from app.config import settings
+
+
+def get_session_manager():
+    """Get the appropriate session manager based on configuration."""
+    if settings.session_backend == "jwt":
+        from app.core.jwt_session import jwt_session_manager
+        return jwt_session_manager
+    else:
+        from app.core.session import session_manager
+        return session_manager
+
+
+# Global session manager instance
+session_manager = get_session_manager()

app/core/tools.py

@@ -0,0 +1,981 @@
+"""LlamaIndex tools for calendar operations."""
+
+from typing import List, Optional, Dict
+from datetime import datetime, timedelta
+from llama_index.core.tools import FunctionTool
+from app.calendar.service import CalendarService
+from app.calendar.utils import DateTimeParser, CalendarFormatter
+from app.personality.prompts import BOOKING_CONFIRMATIONS, ERROR_RESPONSES
+from app.core.email_service import email_service
+from app.config import settings
+import random
+
+
+class CalendarTools:
+    """LlamaIndex tools for calendar operations."""
+    
+    def __init__(self, agent=None):
+        self.calendar_service = CalendarService()
+        self.datetime_parser = DateTimeParser()
+        self.formatter = CalendarFormatter()
+        self.agent = agent  # Reference to the ChatCalAgent for user info
+    
+    def _generate_meeting_id(self, start_time: datetime, duration_minutes: int) -> str:
+        """Generate a human-readable meeting ID from date-time-duration."""
+        # Format: MMDD-HHMM-DURm (e.g., 0731-1400-60m for July 31 at 2:00 PM for 60 minutes)
+        date_part = start_time.strftime("%m%d")  # MMDD
+        time_part = start_time.strftime("%H%M")  # HHMM
+        duration_part = f"{duration_minutes}m"   # Duration in minutes
+        
+        return f"{date_part}-{time_part}-{duration_part}"
+    
+    def check_availability(
+        self,
+        date_string: str,
+        duration_minutes: int = 60,
+        preferred_time: Optional[str] = None
+    ) -> str:
+        """
+        Check availability for a given date and return available time slots.
+        
+        Args:
+            date_string: Natural language date (e.g., "next Tuesday", "tomorrow")
+            duration_minutes: Meeting duration in minutes (default: 60)
+            preferred_time: Preferred time if specified (e.g., "2pm", "morning")
+        
+        Returns:
+            Formatted string with available time slots
+        """
+        try:
+            # Parse the date
+            target_date = self.datetime_parser.parse_datetime(date_string)
+            if not target_date:
+                return "I'm having trouble understanding that date. Could you try rephrasing it? For example: 'next Tuesday' or 'tomorrow'"
+            
+            # Get availability
+            try:
+                slots = self.calendar_service.get_availability(
+                    date=target_date,
+                    duration_minutes=duration_minutes
+                )
+            except Exception as e:
+                if "invalid_grant" in str(e) or "Token has been expired" in str(e) or "authentication" in str(e).lower():
+                    return "I need to reconnect to your calendar. Please visit http://localhost:8000/auth/google to re-authenticate, then try again."
+                raise e
+            
+            if not slots:
+                return f"Unfortunately, I don't see any available {self.formatter.format_duration(duration_minutes)} slots on {self.formatter.format_datetime(target_date, include_date=False)}. Would you like to try a different day?"
+            
+            # Filter by preferred time if specified
+            if preferred_time:
+                time_tuple = self.datetime_parser.parse_time(preferred_time)
+                if time_tuple:
+                    preferred_hour, preferred_minute = time_tuple
+                    filtered_slots = []
+                    for start, end in slots:
+                        if abs(start.hour - preferred_hour) <= 2:  # Within 2 hours
+                            filtered_slots.append((start, end))
+                    if filtered_slots:
+                        slots = filtered_slots
+            
+            date_str = self.formatter.format_datetime(target_date, include_date=True).split(" at ")[0]
+            availability_str = self.formatter.format_availability_list(slots)
+            
+            return f"Great news! Here are the available {self.formatter.format_duration(duration_minutes)} slots for {date_str}: {availability_str}. Which time works best for you?"
+            
+        except Exception as e:
+            return f"I'm having a bit of trouble checking your calendar right now. Could you try again? (Error: {str(e)})"
+    
+    def create_appointment(
+        self,
+        title: str,
+        date_string: str,
+        time_string: str,
+        duration_minutes: int = 60,
+        description: Optional[str] = None,
+        attendee_emails: Optional[List[str]] = None,
+        user_name: str = None,
+        user_phone: str = None,
+        user_email: str = None,
+        create_meet_conference: bool = False
+    ) -> str:
+        """
+        Create a new calendar appointment with email invitations.
+        
+        Args:
+            title: Meeting title/summary
+            date_string: Date in natural language
+            time_string: Time in natural language  
+            duration_minutes: Duration in minutes
+            description: Optional meeting description
+            attendee_emails: Optional list of attendee email addresses
+            user_name: User's full name
+            user_phone: User's phone number
+            user_email: User's email address
+            create_meet_conference: Whether to create a Google Meet conference
+        
+        Returns:
+            Confirmation message or error
+        """
+        try:
+            # CRITICAL: Validate Google Meet requires email for invitations
+            if create_meet_conference and not user_email:
+                return "I need your email address to send the Google Meet invitation. Please provide your email and I'll book the meeting for you!"
+
+            # Parse date and time
+            datetime_str = f"{date_string} at {time_string}"
+            start_time = self.datetime_parser.parse_datetime(datetime_str)
+            
+            if not start_time:
+                return "I'm having trouble understanding that date and time. Could you clarify? For example: 'next Tuesday at 2pm'"
+            
+            end_time = start_time + timedelta(minutes=duration_minutes)
+            
+            # Check for conflicts
+            try:
+                conflicts = self.calendar_service.check_conflicts(start_time, end_time)
+                if conflicts:
+                    conflict_summaries = [event.get('summary', 'Untitled') for event in conflicts]
+                    return f"Oops! You already have {', '.join(conflict_summaries)} scheduled at that time. How about we find a different slot?"
+            except Exception as e:
+                if "invalid_grant" in str(e) or "Token has been expired" in str(e) or "authentication" in str(e).lower():
+                    return "I need to reconnect to your calendar. Please visit http://localhost:8000/auth/google to re-authenticate, then try again."
+                # Continue without conflict check if other error
+                print(f"⚠️ Warning: Could not check calendar conflicts: {e}")
+
+            # Create the event
+            try:
+                event = self.calendar_service.create_event(
+                    summary=title,
+                    start_time=start_time,
+                    end_time=end_time,
+                    description=description,
+                    attendees=attendee_emails or [],
+                    create_meet_conference=create_meet_conference
+                )
+            except Exception as e:
+                if "invalid_grant" in str(e) or "Token has been expired" in str(e) or "authentication" in str(e).lower():
+                    return "I need to reconnect to your calendar. Please visit http://localhost:8000/auth/google to re-authenticate, then try again."
+                raise e
+            
+            # Create custom meeting ID based on date-time-duration
+            google_meeting_id = event.get('id', 'unknown')
+            custom_meeting_id = self._generate_meeting_id(start_time, duration_minutes)
+            
+            if self.agent:
+                self.agent.store_meeting_id(custom_meeting_id, {
+                    'title': title,
+                    'start_time': start_time,
+                    'user_name': user_name,
+                    'user_email': user_email,
+                    'user_phone': user_phone,
+                    'google_id': google_meeting_id,
+                    'duration': duration_minutes
+                })
+            
+            # Format confirmation
+            formatted_time = self.formatter.format_datetime(start_time)
+            duration_str = self.formatter.format_duration(duration_minutes)
+            
+            # Extract Google Meet link if conference was created
+            meet_link = ""
+            if create_meet_conference and 'conferenceData' in event and 'entryPoints' in event['conferenceData']:
+                meet_entries = event['conferenceData']['entryPoints']
+                meet_link = next((entry['uri'] for entry in meet_entries if entry['entryPointType'] == 'video'), "")
+            
+            # Send email invitations
+            email_sent_to_user = False
+            email_sent_to_peter = False
+            
+            # Send email to Peter (always)
+            try:
+                print(f"🔄 Attempting to send email to Peter at: {settings.my_email_address}")
+                email_sent_to_peter = email_service.send_invitation_email(
+                    to_email=settings.my_email_address,
+                    to_name="Peter Michael Gits",
+                    title=title,
+                    start_datetime=start_time,
+                    end_datetime=end_time,
+                    description=description or "",
+                    user_phone=user_phone or "",
+                    meeting_type=title,
+                    meet_link=meet_link
+                )
+                print(f"📧 Peter email send result: {email_sent_to_peter}")
+            except Exception as e:
+                print(f"❌ Failed to send email to Peter: {e}")
+                email_sent_to_peter = False
+            
+            # Send email to user if they provided email
+            if user_email:
+                try:
+                    print(f"🔄 Attempting to send email to user at: {user_email}")
+                    email_sent_to_user = email_service.send_invitation_email(
+                        to_email=user_email,
+                        to_name=user_name or "Guest",
+                        title=title,
+                        start_datetime=start_time,
+                        end_datetime=end_time,
+                        description=description or "",
+                        user_phone=user_phone or "",
+                        meeting_type=title,
+                        meet_link=meet_link
+                    )
+                    print(f"📧 User email send result: {email_sent_to_user}")
+                except Exception as e:
+                    print(f"❌ Failed to send email to user: {e}")
+                    email_sent_to_user = False
+            
+            # Use random confirmation message
+            confirmation_template = random.choice(BOOKING_CONFIRMATIONS)
+            confirmation = confirmation_template.format(
+                meeting_type=title,
+                attendee=user_name or "your meeting",
+                date=formatted_time.split(" at ")[0],
+                time=formatted_time.split(" at ")[1]
+            )
+            
+            # Add email status to confirmation
+            email_status = ""
+            if user_email and email_sent_to_user and email_sent_to_peter:
+                email_status = "\n\n📧 Calendar invitations have been sent to both you and Peter via email."
+            elif user_email and email_sent_to_user and not email_sent_to_peter:
+                email_status = "\n\n📧 Email invitation sent to you. There was an issue sending Peter's invitation, but the meeting is confirmed."
+            elif user_email and not email_sent_to_user and email_sent_to_peter:
+                email_status = "\n\n📧 Email invitation sent to Peter. There was an issue sending your invitation, but the meeting is confirmed."
+            elif user_email and not email_sent_to_user and not email_sent_to_peter:
+                email_status = "\n\n📧 There were issues sending email invitations to both you and Peter, but the meeting is confirmed in the calendar."
+            elif not user_email and email_sent_to_peter:
+                email_status = "\n\n📧 Email invitation sent to Peter. If you'd like me to send you a calendar invitation via email, please provide your email address."
+            elif not user_email and not email_sent_to_peter:
+                email_status = "\n\n📧 There was an issue sending Peter's email invitation, but the meeting is confirmed in the calendar. If you'd like me to send you a calendar invitation via email, please provide your email address."
+            else:
+                email_status = "\n\n📧 If you'd like me to send you a calendar invitation via email, please provide your email address."
+            
+            # Add Google Meet information if conference was created
+            meet_info = ""
+            if create_meet_conference:
+                # Extract Meet link from the created event
+                if 'conferenceData' in event and 'entryPoints' in event['conferenceData']:
+                    meet_entries = event['conferenceData']['entryPoints']
+                    meet_link = next((entry['uri'] for entry in meet_entries if entry['entryPointType'] == 'video'), None)
+                    if meet_link:
+                        meet_info = f"\n\n🎥 Google Meet link: {meet_link}"
+                    else:
+                        meet_info = "\n\n🎥 Google Meet conference call has been set up (link will be available in your calendar)."
+                else:
+                    meet_info = "\n\n🎥 Google Meet conference call has been set up (link will be available in your calendar)."
+            
+            # Add meeting ID and Google Calendar ID with HTML formatting
+            details_html = f"""
+            <div style="background: #f5f5f5; padding: 12px; border-radius: 6px; margin: 10px 0; font-size: 14px;">
+                <strong>⏱️ Duration:</strong> {duration_str}<br>
+                <strong>📋 Meeting ID:</strong> <code style="background: #e0e0e0; padding: 2px 6px; border-radius: 3px;">{custom_meeting_id}</code><br>
+                <strong>🗓️ Google Calendar ID:</strong> <code style="background: #e0e0e0; padding: 2px 6px; border-radius: 3px;">{google_meeting_id}</code><br>
+                <em style="color: #666;">(save these IDs to cancel or modify later)</em>
+            </div>"""
+            
+            # Format email status with better HTML
+            email_html = ""
+            if user_email and email_sent_to_user and email_sent_to_peter:
+                email_html = '<div style="color: #4caf50; margin: 8px 0;"><strong>📧 Invites sent to both you and Peter!</strong></div>'
+            elif user_email and email_sent_to_user and not email_sent_to_peter:
+                email_html = '<div style="color: #ff9800; margin: 8px 0;"><strong>📧 Your invite sent.</strong> Issue with Peter\'s email.</div>'
+            elif user_email and not email_sent_to_user and email_sent_to_peter:
+                email_html = '<div style="color: #ff9800; margin: 8px 0;"><strong>📧 Peter\'s invite sent.</strong> Issue with your email.</div>'
+            elif user_email and not email_sent_to_user and not email_sent_to_peter:
+                email_html = '<div style="color: #f44336; margin: 8px 0;"><strong>📧 Email issues</strong> but meeting is confirmed!</div>'
+            elif not user_email and email_sent_to_peter:
+                email_html = '<div style="color: #2196f3; margin: 8px 0;"><strong>📧 Peter notified!</strong> Want a calendar invite? Just share your email.</div>'
+            elif not user_email and not email_sent_to_peter:
+                email_html = '<div style="color: #ff9800; margin: 8px 0;"><strong>📧 Email issue</strong> but meeting is confirmed!</div>'
+            
+            # Format Google Meet info
+            meet_html = ""
+            if create_meet_conference:
+                if 'conferenceData' in event and 'entryPoints' in event['conferenceData']:
+                    meet_entries = event['conferenceData']['entryPoints']
+                    meet_link = next((entry['uri'] for entry in meet_entries if entry['entryPointType'] == 'video'), None)
+                    if meet_link:
+                        meet_html = f'<div style="background: #e8f5e9; padding: 10px; border-radius: 6px; margin: 8px 0;"><strong>🎥 Google Meet:</strong> <a href="{meet_link}" style="color: #1976d2; font-weight: bold;">Join here</a></div>'
+                    else:
+                        meet_html = '<div style="background: #e8f5e9; padding: 10px; border-radius: 6px; margin: 8px 0;"><strong>🎥 Google Meet set up</strong> (link in your calendar)</div>'
+                else:
+                    meet_html = '<div style="background: #e8f5e9; padding: 10px; border-radius: 6px; margin: 8px 0;"><strong>🎥 Google Meet set up</strong> (link in your calendar)</div>'
+            
+            return f"{confirmation}{details_html}{email_html}{meet_html}"
+            
+        except Exception as e:
+            return f"I'm having trouble creating that appointment right now. Could you try again? (Error: {str(e)})"
+    
+    def list_upcoming_events(self, days_ahead: int = 7) -> str:
+        """
+        List upcoming events in the next specified days.
+        
+        Args:
+            days_ahead: Number of days to look ahead (default: 7)
+        
+        Returns:
+            Formatted list of upcoming events
+        """
+        try:
+            now = datetime.now(self.calendar_service.default_timezone)
+            end_time = now + timedelta(days=days_ahead)
+            
+            events = self.calendar_service.list_events(
+                time_min=now,
+                time_max=end_time,
+                max_results=20
+            )
+            
+            if not events:
+                return f"You have a completely clear schedule for the next {days_ahead} day{'s' if days_ahead != 1 else ''}! Perfect time to book some meetings! 📅"
+            
+            formatted_events = []
+            for event in events[:10]:  # Limit to 10 events
+                event_summary = self.formatter.format_event_summary(event)
+                formatted_events.append(f"• {event_summary}")
+            
+            events_list = "\n".join(formatted_events)
+            total_count = len(events)
+            
+            if total_count > 10:
+                events_list += f"\n• ... and {total_count - 10} more events"
+            
+            period = f"next {days_ahead} day{'s' if days_ahead != 1 else ''}"
+            return f"Here's what's coming up in the {period}:\n\n{events_list}"
+            
+        except Exception as e:
+            return f"I'm having trouble accessing your calendar right now. Could you try again? (Error: {str(e)})"
+    
+    def reschedule_appointment(
+        self,
+        original_date_time: str,
+        new_date_string: str,
+        new_time_string: str
+    ) -> str:
+        """
+        Reschedule an existing appointment.
+        
+        Args:
+            original_date_time: Original appointment date/time to find
+            new_date_string: New date in natural language
+            new_time_string: New time in natural language
+        
+        Returns:
+            Confirmation message or error
+        """
+        try:
+            # Parse original date/time to find the event
+            original_dt = self.datetime_parser.parse_datetime(original_date_time)
+            if not original_dt:
+                return "I'm having trouble finding that appointment. Could you be more specific about the original date and time?"
+            
+            # Find events around that time
+            search_start = original_dt - timedelta(hours=1)
+            search_end = original_dt + timedelta(hours=1)
+            
+            events = self.calendar_service.list_events(
+                time_min=search_start,
+                time_max=search_end,
+                max_results=5
+            )
+            
+            if not events:
+                return "I couldn't find any appointments around that time. Could you check your calendar and try again?"
+            
+            # For now, take the first matching event (in a real implementation, 
+            # we might want to present options to the user)
+            event_to_update = events[0]
+            
+            # Parse new date/time
+            new_datetime_str = f"{new_date_string} at {new_time_string}"
+            new_start_time = self.datetime_parser.parse_datetime(new_datetime_str)
+            
+            if not new_start_time:
+                return "I'm having trouble understanding the new date and time. Could you clarify?"
+            
+            # Calculate new end time based on original duration
+            if 'start' in event_to_update and 'end' in event_to_update:
+                original_start = datetime.fromisoformat(event_to_update['start']['dateTime'])
+                original_end = datetime.fromisoformat(event_to_update['end']['dateTime'])
+                duration = original_end - original_start
+                new_end_time = new_start_time + duration
+            else:
+                new_end_time = new_start_time + timedelta(hours=1)  # Default 1 hour
+            
+            # Check for conflicts at new time
+            conflicts = self.calendar_service.check_conflicts(
+                new_start_time, 
+                new_end_time,
+                exclude_event_id=event_to_update.get('id')
+            )
+            
+            if conflicts:
+                return "The new time conflicts with another appointment. Could you suggest a different time?"
+            
+            # Update the event
+            updates = {
+                'start': {
+                    'dateTime': new_start_time.isoformat(),
+                    'timeZone': str(self.calendar_service.default_timezone),
+                },
+                'end': {
+                    'dateTime': new_end_time.isoformat(),
+                    'timeZone': str(self.calendar_service.default_timezone),
+                }
+            }
+            
+            self.calendar_service.update_event(event_to_update['id'], updates)
+            
+            old_time = self.formatter.format_datetime(original_dt)
+            new_time = self.formatter.format_datetime(new_start_time)
+            
+            return f"Perfect! I've rescheduled your appointment from {old_time} to {new_time}. All set! 🎉"
+            
+        except Exception as e:
+            return f"I'm having trouble rescheduling that appointment. Could you try again? (Error: {str(e)})"
+    
+    def cancel_meeting_by_id(self, meeting_id: str) -> str:
+        """
+        Cancel a meeting by its ID (supports both custom and Google IDs).
+        
+        Args:
+            meeting_id: The meeting ID (custom format like 0731-1400-60m or Google ID)
+        
+        Returns:
+            Confirmation message or error
+        """
+        try:
+            google_meeting_id = None
+            meeting_info = None
+            
+            # Check if this is our custom meeting ID format
+            if self.agent:
+                stored_meetings = self.agent.get_stored_meetings()
+                
+                # First try exact match with custom ID
+                if meeting_id in stored_meetings:
+                    meeting_info = stored_meetings[meeting_id]
+                    google_meeting_id = meeting_info.get('google_id')
+                else:
+                    # Try partial match for custom IDs (in case user doesn't type full ID)
+                    for stored_id, info in stored_meetings.items():
+                        if stored_id.startswith(meeting_id):
+                            meeting_info = info
+                            google_meeting_id = info.get('google_id')
+                            meeting_id = stored_id  # Update to full custom ID
+                            break
+            
+            # If not found in custom IDs, treat as Google ID
+            if not google_meeting_id:
+                google_meeting_id = meeting_id
+            
+            # Get meeting details before deletion
+            try:
+                event = self.calendar_service.get_event(google_meeting_id)
+                if not event:
+                    return "Meeting not found. Please check the meeting ID."
+                
+                meeting_title = event.get('summary', 'Meeting')
+                start_time_str = event.get('start', {}).get('dateTime', '')
+                if start_time_str:
+                    start_time = datetime.fromisoformat(start_time_str.replace('Z', '+00:00'))
+                    formatted_time = self.formatter.format_datetime(start_time)
+                else:
+                    formatted_time = "Unknown time"
+                    
+            except Exception:
+                # Fall back to stored info if available
+                if meeting_info:
+                    meeting_title = meeting_info.get('title', 'Meeting')
+                    start_time = meeting_info.get('start_time')
+                    if start_time:
+                        formatted_time = self.formatter.format_datetime(start_time)
+                    else:
+                        formatted_time = "Unknown time"
+                else:
+                    meeting_title = "Meeting"
+                    formatted_time = "Unknown time"
+            
+            # Delete the event using Google ID
+            self.calendar_service.delete_event(google_meeting_id)
+            
+            # Remove from stored meetings using custom ID
+            if self.agent and meeting_id in self.agent.get_stored_meetings():
+                self.agent.remove_stored_meeting(meeting_id)
+            
+            return f"""<div style="background: #ffebee; padding: 15px; border-radius: 8px; border-left: 4px solid #f44336; margin: 10px 0;">
+            <strong>✅ Cancelled!</strong><br>
+            <strong>{meeting_title}</strong><br>
+            <em>was scheduled for {formatted_time}</em>
+            </div>"""
+            
+        except Exception as e:
+            return f"I'm having trouble cancelling that meeting. Could you try again? (Error: {str(e)})"
+    
+    def find_user_meetings(self, user_name: str, days_ahead: int = 30) -> str:
+        """
+        Find all meetings for a specific user within the next specified days.
+        
+        Args:
+            user_name: Name of the person who booked meetings
+            days_ahead: Number of days to look ahead (default: 30)
+        
+        Returns:
+            List of meetings for the user or message if none found
+        """
+        try:
+            # Search for meetings in the next specified days
+            now = datetime.now(self.calendar_service.default_timezone)
+            search_end = now + timedelta(days=days_ahead)
+            
+            events = self.calendar_service.list_events(
+                time_min=now,
+                time_max=search_end,
+                max_results=50
+            )
+            
+            # Find meetings that match the user name
+            matching_events = []
+            for event in events:
+                event_summary = event.get('summary', '').lower()
+                event_description = event.get('description', '').lower()
+                
+                # Check if user name appears in title or description
+                if (user_name.lower() in event_summary or 
+                    user_name.lower() in event_description or
+                    f"meeting with {user_name.lower()}" in event_summary):
+                    matching_events.append(event)
+            
+            if not matching_events:
+                return f"I couldn't find any upcoming meetings for {user_name} in the next {days_ahead} days."
+            
+            # Format the meetings for display
+            meetings_list = []
+            for i, event in enumerate(matching_events[:5], 1):  # Limit to 5 meetings
+                event_time = datetime.fromisoformat(event['start']['dateTime'].replace('Z', '+00:00'))
+                formatted_time = self.formatter.format_datetime(event_time)
+                event_title = event.get('summary', 'Meeting')
+                
+                # Find custom meeting ID if available
+                custom_id = "N/A"
+                if self.agent:
+                    stored_meetings = self.agent.get_stored_meetings()
+                    for stored_id, info in stored_meetings.items():
+                        if info.get('google_id') == event.get('id'):
+                            custom_id = stored_id
+                            break
+                
+                meetings_list.append(f"**{i}. {event_title}**<br>{formatted_time}<br><em>ID: {custom_id}</em>")
+            
+            meetings_text = "<br><br>".join(meetings_list)
+            return f"""<div style="background: #fff3e0; padding: 15px; border-radius: 8px; border-left: 4px solid #ff9800; margin: 10px 0;">
+            <strong>🔍 Found {len(matching_events)} meeting{'s' if len(matching_events) != 1 else ''} for {user_name}:</strong><br><br>
+            {meetings_text}<br><br>
+            Which one would you like to cancel? You can say "cancel #1" or "cancel the first one".
+            </div>"""
+            
+        except Exception as e:
+            return f"I'm having trouble finding meetings for {user_name}. Error: {str(e)}"
+
+    def cancel_meeting_by_details(self, user_name: str, date_string: str, time_string: str = None) -> str:
+        """
+        Cancel a meeting by user name and date/time.
+        
+        Args:
+            user_name: Name of the person who booked the meeting
+            date_string: Date in natural language
+            time_string: Optional time in natural language
+        
+        Returns:
+            Confirmation message or error
+        """
+        try:
+            # Parse the date
+            if time_string:
+                datetime_str = f"{date_string} at {time_string}"
+            else:
+                datetime_str = date_string
+                
+            target_datetime = self.datetime_parser.parse_datetime(datetime_str)
+            if not target_datetime:
+                return "I'm having trouble understanding that date/time. Could you be more specific?"
+            
+            # Search for meetings around that time
+            search_start = target_datetime - timedelta(hours=12)  # Search wider range
+            search_end = target_datetime + timedelta(hours=12)
+            
+            events = self.calendar_service.list_events(
+                time_min=search_start,
+                time_max=search_end,
+                max_results=20
+            )
+            
+            # Find meetings that match the user name
+            matching_events = []
+            for event in events:
+                event_summary = event.get('summary', '').lower()
+                event_description = event.get('description', '').lower()
+                
+                # Check if user name appears in title or description
+                if (user_name.lower() in event_summary or 
+                    user_name.lower() in event_description or
+                    f"meeting with {user_name.lower()}" in event_summary):
+                    matching_events.append(event)
+            
+            if not matching_events:
+                return f"I couldn't find any meetings for {user_name} around {datetime_str}. Please check the details."
+            
+            if len(matching_events) == 1:
+                # Single match - cancel it directly
+                event = matching_events[0]
+                google_meeting_id = event.get('id')
+                
+                # Get meeting details for confirmation
+                meeting_title = event.get('summary', 'Meeting')
+                start_time_str = event.get('start', {}).get('dateTime', '')
+                if start_time_str:
+                    start_time = datetime.fromisoformat(start_time_str.replace('Z', '+00:00'))
+                    formatted_time = self.formatter.format_datetime(start_time)
+                else:
+                    formatted_time = "Unknown time"
+                
+                # Cancel the meeting
+                try:
+                    self.calendar_service.delete_event(google_meeting_id)
+                    
+                    # Remove from stored meetings if exists
+                    if self.agent:
+                        # Find and remove custom meeting ID
+                        stored_meetings = self.agent.get_stored_meetings()
+                        for custom_id, info in stored_meetings.items():
+                            if info.get('google_id') == google_meeting_id:
+                                self.agent.remove_stored_meeting(custom_id)
+                                break
+                    
+                    # Automatically send cancellation email if user has email (no asking)
+                    email_sent = False
+                    if self.agent and self.agent.user_info.get('email'):
+                        user_email = self.agent.user_info.get('email')
+                        user_name_for_email = self.agent.user_info.get('name', user_name)
+                        
+                        try:
+                            from app.core.email_service import email_service
+                            email_sent = email_service.send_cancellation_email(
+                                to_email=user_email,
+                                to_name=user_name_for_email,
+                                meeting_title=meeting_title,
+                                original_datetime=start_time
+                            )
+                        except Exception as e:
+                            print(f"Failed to send cancellation email: {e}")
+                            email_sent = False
+                    
+                    # Only show confirmation after email is processed
+                    if email_sent:
+                        return f"""<div style="background: #ffebee; padding: 15px; border-radius: 8px; border-left: 4px solid #f44336; margin: 10px 0;">
+                        <strong>✅ Cancelled & Confirmed!</strong><br>
+                        <strong>{meeting_title}</strong><br>
+                        <em>was scheduled for {formatted_time}</em><br>
+                        <span style="color: #4caf50;">📧 Cancellation details sent to your email</span>
+                        </div>"""
+                    else:
+                        return f"""<div style="background: #ffebee; padding: 15px; border-radius: 8px; border-left: 4px solid #f44336; margin: 10px 0;">
+                        <strong>✅ Cancelled!</strong><br>
+                        <strong>{meeting_title}</strong><br>
+                        <em>was scheduled for {formatted_time}</em>
+                        </div>"""
+                    
+                except Exception as e:
+                    return f"I had trouble cancelling that meeting. Error: {str(e)}"
+                    
+            elif len(matching_events) > 1:
+                # Multiple matches - check if any match closely on time
+                if time_string:
+                    # Try to narrow down by time matching
+                    target_time = self.datetime_parser.parse_time(time_string)
+                    if target_time:
+                        target_hour, target_minute = target_time
+                        close_matches = []
+                        
+                        for event in matching_events:
+                            event_start = datetime.fromisoformat(event['start']['dateTime'].replace('Z', '+00:00'))
+                            # Match within 1 hour of target time
+                            if abs(event_start.hour - target_hour) <= 1:
+                                close_matches.append(event)
+                        
+                        if len(close_matches) == 1:
+                            # Found one close match - cancel it
+                            return self.cancel_meeting_by_details(user_name, date_string, time_string)
+                
+                # Still multiple matches - only show meeting IDs if needed
+                options = []
+                for i, event in enumerate(matching_events[:3], 1):  # Limit to 3
+                    event_time = datetime.fromisoformat(event['start']['dateTime'].replace('Z', '+00:00'))
+                    formatted_time = self.formatter.format_datetime(event_time)
+                    event_title = event.get('summary', 'Meeting')
+                    
+                    # Find custom meeting ID if available
+                    custom_id = "N/A"
+                    if self.agent:
+                        stored_meetings = self.agent.get_stored_meetings()
+                        for stored_id, info in stored_meetings.items():
+                            if info.get('google_id') == event.get('id'):
+                                custom_id = stored_id
+                                break
+                    
+                    options.append(f"• <strong>{event_title}</strong> - {formatted_time}")
+                
+                options_text = "<br>".join(options)
+                return f"""<div style="background: #fff3e0; padding: 15px; border-radius: 8px; border-left: 4px solid #ff9800; margin: 10px 0;">
+                <strong>🤔 Found multiple meetings for {user_name}:</strong><br><br>
+                {options_text}<br><br>
+                Can you be more specific about the time, or provide the meeting ID?
+                </div>"""
+            
+        except Exception as e:
+            return f"I'm having trouble finding that meeting. Could you try again? (Error: {str(e)})"
+
+    def get_meeting_details(
+        self,
+        meeting_id: Optional[str] = None,
+        user_name: Optional[str] = None,
+        date_string: Optional[str] = None
+    ) -> str:
+        """
+        Get details about a specific meeting including Google Meet link, Meeting ID, and Google Calendar ID.
+
+        Args:
+            meeting_id: Custom meeting ID (e.g., "0918-0754-60m")
+            user_name: User name to find their meetings
+            date_string: Date to search for meetings
+
+        Returns:
+            Meeting details or error message
+        """
+        try:
+            if not self.agent:
+                return "Internal error: No agent reference available."
+
+            # If meeting_id is provided, look up the stored meeting
+            if meeting_id:
+                stored_meetings = self.agent.get_stored_meetings()
+                if meeting_id in stored_meetings:
+                    meeting_info = stored_meetings[meeting_id]
+
+                    # Get additional details from Google Calendar
+                    google_id = meeting_info.get('google_id')
+                    event = None
+                    if google_id:
+                        try:
+                            event = self.calendar_service.get_event(google_id)
+                        except Exception as e:
+                            print(f"Could not fetch Google Calendar event: {e}")
+
+                    # Extract Google Meet link if available
+                    meet_link = "Not available"
+                    if event and 'conferenceData' in event and 'entryPoints' in event['conferenceData']:
+                        meet_entries = event['conferenceData']['entryPoints']
+                        meet_link = next((entry['uri'] for entry in meet_entries if entry['entryPointType'] == 'video'), "Not available")
+
+                    # Format response
+                    start_time = meeting_info.get('start_time', 'Unknown')
+                    duration = meeting_info.get('duration', 60)
+
+                    return f"""<div style="background: #e3f2fd; padding: 15px; border-radius: 8px; border-left: 4px solid #2196f3; margin: 10px 0;">
+                    <strong>📋 Meeting Details:</strong><br><br>
+                    <strong>📅 Title:</strong> {meeting_info.get('title', 'Meeting')}<br>
+                    <strong>⏰ Time:</strong> {start_time}<br>
+                    <strong>⏱️ Duration:</strong> {duration} minutes<br>
+                    <strong>👤 Attendee:</strong> {meeting_info.get('user_name', 'Unknown')}<br>
+                    <strong>📧 Email:</strong> {meeting_info.get('user_email', 'None provided')}<br><br>
+                    <strong>🔖 Meeting ID:</strong> <code style="background: #e0e0e0; padding: 2px 6px; border-radius: 3px;">{meeting_id}</code><br>
+                    <strong>🗓️ Google Calendar ID:</strong> <code style="background: #e0e0e0; padding: 2px 6px; border-radius: 3px;">{google_id or 'Not available'}</code><br>
+                    <strong>🎥 Google Meet Link:</strong> {f'<a href="{meet_link}" style="color: #1976d2;">Join Meeting</a>' if meet_link != "Not available" else "Not available"}
+                    </div>"""
+                else:
+                    return f"I couldn't find a meeting with ID '{meeting_id}'. Please check the ID and try again."
+
+            # If user_name is provided, find their recent meetings
+            elif user_name:
+                stored_meetings = self.agent.get_stored_meetings()
+                user_meetings = {mid: info for mid, info in stored_meetings.items()
+                               if info.get('user_name', '').lower() == user_name.lower()}
+
+                if not user_meetings:
+                    return f"I couldn't find any meetings for {user_name}. Please check the name and try again."
+
+                # Show the most recent meeting
+                latest_meeting_id = max(user_meetings.keys())
+                return self.get_meeting_details(meeting_id=latest_meeting_id)
+
+            else:
+                return "Please provide either a meeting ID or user name to look up meeting details."
+
+        except Exception as e:
+            return f"I'm having trouble retrieving meeting details. Error: {str(e)}"
+
+    def create_appointment_with_user_info(
+        self,
+        title: str,
+        date_string: str,
+        time_string: str,
+        duration_minutes: int = 60,
+        description: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Create appointment using stored user information from agent."""
+        
+        # FORBIDDEN PARAMETER VALIDATION - Detect and reject invalid parameters
+        # Note: organizer_email is NOT forbidden as it should be automatically set to Peter's email
+        forbidden_params = [
+            'email', 'phone', 'user_name', 'attendee_email',
+            'attendee_name', 'organizer_phone', 'user_email', 'user_phone'
+        ]
+        if kwargs:
+            invalid_params = [param for param in kwargs.keys() if param in forbidden_params]
+            if invalid_params:
+                return f"ERROR: Invalid parameters detected: {', '.join(invalid_params)}. This function ONLY accepts: 'title', 'date_string', 'time_string', 'duration_minutes', 'description'. Please use only these 5 parameters."
+        
+        if not self.agent:
+            return "Internal error: No agent reference available."
+        
+        user_info = self.agent.get_user_info()
+        
+        # COMPREHENSIVE VALIDATION - Check ALL required parameters before booking
+        missing_items = []
+        
+        # 1. Validate user information
+        if not self.agent.has_complete_user_info():
+            missing = self.agent.get_missing_user_info()
+            if "contact (email OR phone)" in missing:
+                missing_items.append("your contact information (email or phone number)")
+            if "name" in missing:
+                missing_items.append("your name")
+        
+        # 2. Validate date and time parameters
+        if not date_string or not date_string.strip():
+            missing_items.append("the date for the appointment")
+        
+        if not time_string or not time_string.strip():
+            missing_items.append("the time for the appointment")
+        
+        # 3. Validate that date/time can be parsed (basic check)
+        if date_string and date_string.strip() and time_string and time_string.strip():
+            try:
+                datetime_str = f"{date_string.strip()} at {time_string.strip()}"
+                test_datetime = self.datetime_parser.parse_datetime(datetime_str)
+                if not test_datetime:
+                    missing_items.append("a valid date and time (I'm having trouble understanding the date/time format)")
+            except Exception:
+                missing_items.append("a valid date and time (please clarify the date/time)")
+        
+        # If ANY required information is missing, request it instead of booking
+        if missing_items:
+            if len(missing_items) == 1:
+                if "contact information" in missing_items[0]:
+                    return f"To book your appointment, I still need {missing_items[0]}. Please provide your email address or phone number. If using voice input, please spell out your email address using the military alphabet (Alpha, Bravo, Charlie, etc.) to ensure accuracy."
+                else:
+                    return f"To book your appointment, I still need {missing_items[0]}. Can you provide this information?"
+            elif len(missing_items) == 2:
+                return f"To book your appointment, I still need {missing_items[0]} and {missing_items[1]}. Can you provide this information?"
+            else:
+                missing_list = ", ".join(missing_items[:-1]) + f", and {missing_items[-1]}"
+                return f"To book your appointment, I still need {missing_list}. Can you provide this information?"
+        
+        # Use default title if no title provided or if title is vague/generic
+        if not title or not title.strip() or title.strip().lower() in ['meeting', 'appointment', 'call', 'session', 'consultation']:
+            title = settings.default_appointment_title
+        
+        # Detect if user requests Google Meet conference
+        create_meet = False
+        meet_keywords = ['google meet', 'meet', 'video call', 'video conference', 'online meeting', 'virtual meeting', 'conference call', 'zoom', 'online', 'remote']
+        
+        # Check title and description for meet keywords
+        text_to_check = f"{title} {description or ''}".lower()
+        create_meet = any(keyword in text_to_check for keyword in meet_keywords)
+        
+        # Also check recent conversation history for meet requests
+        if not create_meet and self.agent:
+            try:
+                recent_messages = self.agent.get_conversation_history()
+                if recent_messages:
+                    # Check last few messages for meet-related keywords
+                    recent_text = ' '.join([msg.get('content', '') for msg in recent_messages[-3:] if msg.get('content')])
+                    create_meet = any(keyword in recent_text.lower() for keyword in meet_keywords)
+            except:
+                pass  # If history access fails, continue without it
+
+        # CRITICAL: Validate Google Meet requires BOTH email AND phone
+        if create_meet:
+            missing_for_meet = []
+            if not user_info.get("email"):
+                missing_for_meet.append("email address (for Google Meet invitation)")
+            if not user_info.get("phone"):
+                missing_for_meet.append("phone number (in case we need to call you)")
+
+            if missing_for_meet:
+                if len(missing_for_meet) == 1:
+                    return f"For Google Meet, I need your {missing_for_meet[0]}. Please provide it and I'll book the meeting!"
+                else:
+                    return f"For Google Meet, I need your {' and '.join(missing_for_meet)}. Please provide both and I'll book the meeting!"
+
+        # Create appointment with user information
+        return self.create_appointment(
+            title=title,
+            date_string=date_string,
+            time_string=time_string,
+            duration_minutes=duration_minutes,
+            description=description,
+            attendee_emails=[user_info.get('email')] if user_info.get('email') else None,
+            user_name=user_info.get('name'),
+            user_phone=user_info.get('phone'),
+            user_email=user_info.get('email'),
+            create_meet_conference=create_meet
+        )
+
+    def get_tools(self) -> List[FunctionTool]:
+        """Get list of LlamaIndex FunctionTool objects."""
+        return [
+            FunctionTool.from_defaults(
+                fn=self.check_availability,
+                name="check_availability",
+                description="**AVAILABILITY CHECKER** - Check if specific time slot is free for booking. MANDATORY: Use this tool BEFORE booking to verify time is available. PARAMETERS: date_string (required - e.g. 'today', 'tomorrow'), duration_minutes (optional, default 60), preferred_time (optional - e.g. '4pm'). Use when ready to book meeting and need to check if time is free."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.create_appointment_with_user_info,
+                name="create_appointment",
+                description="**PRIMARY BOOKING TOOL** - Create appointment after checking availability. WORKFLOW: 1) Check availability first with check_availability tool, 2) If time is free, call this tool to book. MAIN PARAMETERS: 'title', 'date_string', 'time_string', 'duration_minutes', 'description'. For Google Meet: requires BOTH email AND phone. User contact info is automatically retrieved from agent context. DO NOT call if information is missing or if you haven't checked availability first."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.list_upcoming_events,
+                name="list_upcoming_events",
+                description="List general upcoming calendar events. ONLY use when user asks 'what's on my calendar' or 'show my events'. DO NOT use when checking if specific time is available for booking - use check_availability instead. PARAMETERS: days_ahead (optional, default 7). DO NOT use user_name parameter."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.reschedule_appointment,
+                name="reschedule_appointment",
+                description="Reschedule an existing appointment. PARAMETERS: original_date_time (required), new_date_string (required), new_time_string (required)."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.find_user_meetings,
+                name="find_user_meetings",
+                description="Find all meetings for a specific user. PARAMETERS: user_name (required), days_ahead (optional, default 30)."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.get_meeting_details,
+                name="get_meeting_details",
+                description="Get details about a specific meeting including Google Meet link, Meeting ID, and Google Calendar ID. Use this when user asks for meeting information, details, IDs, or links. PARAMETERS: meeting_id (optional), user_name (optional), date_string (optional)."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.cancel_meeting_by_id,
+                name="cancel_meeting_by_id",
+                description="CANCELLATION TOOL - Cancel a meeting using its meeting ID. EXTREMELY CRITICAL: ONLY call this when user message contains words 'cancel', 'delete', 'remove', 'unbook' AND 'meeting'/'appointment'. NEVER call for: asking about IDs, meeting details, confirmation, information, 'what is', 'show me', or any questions. If user wants meeting info, use get_meeting_details instead. PARAMETERS: meeting_id (required)."
+            ),
+            FunctionTool.from_defaults(
+                fn=self.cancel_meeting_by_details,
+                name="cancel_meeting_by_details",
+                description="CANCELLATION TOOL - Cancel a meeting by user name and date/time. EXTREMELY CRITICAL: ONLY call this when user message contains words 'cancel', 'delete', 'remove', 'unbook' AND 'meeting'/'appointment'. NEVER call for: asking about IDs, meeting details, confirmation, information, 'what is', 'show me', or any questions. If user wants meeting info, use get_meeting_details instead. PARAMETERS: user_name (required), date_string (required), time_string (optional)."
+            )
+        ]

app/core/validators.py

@@ -0,0 +1,173 @@
+"""Input validation utilities for ChatCal.ai."""
+
+import re
+from datetime import datetime, timedelta
+from typing import Optional, List, Tuple
+from app.core.exceptions import ValidationError
+
+
+class InputValidator:
+    """Validates user inputs for the chat application."""
+    
+    # Email validation regex
+    EMAIL_PATTERN = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
+    
+    # Time patterns for natural language
+    TIME_PATTERNS = [
+        r'\d{1,2}:\d{2}\s*(am|pm|AM|PM)?',
+        r'\d{1,2}\s*(am|pm|AM|PM)',
+        r'(morning|afternoon|evening|noon)',
+        r'(early|late)\s+(morning|afternoon|evening)'
+    ]
+    
+    @staticmethod
+    def validate_message(message: str) -> str:
+        """Validate chat message input."""
+        if not message:
+            raise ValidationError("Message cannot be empty")
+        
+        message = message.strip()
+        if not message:
+            raise ValidationError("Message cannot be empty")
+        
+        if len(message) > 1000:
+            raise ValidationError("Message too long (max 1000 characters)")
+        
+        # Check for potential injection attempts
+        suspicious_patterns = [
+            r'<script.*?>',
+            r'javascript:',
+            r'on\w+\s*=',
+            r'eval\s*\(',
+            r'exec\s*\('
+        ]
+        
+        for pattern in suspicious_patterns:
+            if re.search(pattern, message, re.IGNORECASE):
+                raise ValidationError("Message contains potentially harmful content")
+        
+        return message
+    
+    @staticmethod
+    def validate_email(email: str) -> str:
+        """Validate email address."""
+        if not email:
+            raise ValidationError("Email cannot be empty")
+        
+        email = email.strip().lower()
+        if not InputValidator.EMAIL_PATTERN.match(email):
+            raise ValidationError("Invalid email format")
+        
+        if len(email) > 254:  # RFC 5321 limit
+            raise ValidationError("Email address too long")
+        
+        return email
+    
+    @staticmethod
+    def validate_email_list(emails: List[str]) -> List[str]:
+        """Validate a list of email addresses."""
+        if not emails:
+            return []
+        
+        if len(emails) > 50:  # Reasonable limit
+            raise ValidationError("Too many attendees (max 50)")
+        
+        validated_emails = []
+        for email in emails:
+            validated_emails.append(InputValidator.validate_email(email))
+        
+        return validated_emails
+    
+    @staticmethod
+    def validate_session_id(session_id: str) -> str:
+        """Validate session ID format."""
+        if not session_id:
+            raise ValidationError("Session ID cannot be empty")
+        
+        session_id = session_id.strip()
+        
+        # Check for valid UUID-like format or similar
+        if not re.match(r'^[a-zA-Z0-9\-_]{8,64}$', session_id):
+            raise ValidationError("Invalid session ID format")
+        
+        return session_id
+    
+    @staticmethod
+    def validate_duration(duration_minutes: int) -> int:
+        """Validate meeting duration."""
+        if duration_minutes < 15:
+            raise ValidationError("Meeting duration must be at least 15 minutes")
+        
+        if duration_minutes > 480:  # 8 hours
+            raise ValidationError("Meeting duration cannot exceed 8 hours")
+        
+        # Return as-is for exact durations, round others to nearest 15 minutes
+        if duration_minutes % 15 == 0:
+            return duration_minutes
+        return ((duration_minutes + 7) // 15) * 15
+    
+    @staticmethod
+    def validate_title(title: str) -> str:
+        """Validate meeting title."""
+        if not title:
+            raise ValidationError("Meeting title cannot be empty")
+        
+        title = title.strip()
+        if not title:
+            raise ValidationError("Meeting title cannot be empty")
+        
+        if len(title) > 200:
+            raise ValidationError("Meeting title too long (max 200 characters)")
+        
+        return title
+    
+    @staticmethod
+    def validate_description(description: Optional[str]) -> Optional[str]:
+        """Validate meeting description."""
+        if not description:
+            return None
+        
+        description = description.strip()
+        if not description:
+            return None
+        
+        if len(description) > 1000:
+            raise ValidationError("Meeting description too long (max 1000 characters)")
+        
+        return description
+    
+    @staticmethod
+    def sanitize_user_input(text: str) -> str:
+        """Sanitize user input for safe processing."""
+        if not text:
+            return ""
+        
+        # Remove potentially harmful characters
+        text = re.sub(r'[<>&"\'`]', '', text)
+        
+        # Normalize whitespace
+        text = ' '.join(text.split())
+        
+        return text.strip()
+    
+    @staticmethod
+    def validate_time_range(start_time: datetime, end_time: datetime) -> Tuple[datetime, datetime]:
+        """Validate time range for calendar events."""
+        if start_time >= end_time:
+            raise ValidationError("Start time must be before end time")
+        
+        # Check if event is too far in the future (2 years)
+        max_future = datetime.now() + timedelta(days=730)
+        if start_time > max_future:
+            raise ValidationError("Cannot schedule events more than 2 years in advance")
+        
+        # Check if event is in the past (with 5 minute buffer)
+        min_time = datetime.now() - timedelta(minutes=5)
+        if start_time < min_time:
+            raise ValidationError("Cannot schedule events in the past")
+        
+        # Check maximum event duration (24 hours)
+        if end_time - start_time > timedelta(hours=24):
+            raise ValidationError("Event duration cannot exceed 24 hours")
+        
+        return start_time, end_time

app/personality/prompts.py

@@ -0,0 +1,231 @@
+SYSTEM_PROMPT = """You are ChatCal, a professional and friendly AI assistant for scheduling appointments with Peter Michael Gits. Be concise and helpful.
+
+🎯 **Primary Mission**: Help visitors book consultations, meetings, and appointments with Peter Michael Gits
+💼 **Professional & Warm**: Be welcoming while maintaining a professional demeanor
+📅 **Efficient Scheduler**: Make booking appointments with Peter quick and easy
+🤝 **Clear Communicator**: Ensure all appointment details are crystal clear
+
+**CRITICAL RESPONSE STYLE**:
+- Keep responses brief, conversational, and natural
+- NEVER list available tools or mention tool capabilities unless specifically asked
+- Don't provide excessive detail or explanations
+- Respond like a helpful human assistant, not a technical system
+- **SPEAK DIRECTLY TO THE USER**: Say "I need your name" NOT "I need to ask the user for their name"
+- Always address the person you're talking to directly - you ARE the booking agent talking TO them
+- If user provides email, NEVER ask for a "secondary email" - use what they gave you
+- Format responses in HTML with proper styling for readability
+- Use <strong>, <em>, and line breaks to make information easy to scan
+- When cancelling meetings, NEVER ask about the meeting purpose - only ask for time/date if unclear
+
+## Peter's Contact Information (Always Available):
+📞 **Peter's Phone**: {my_phone_number}
+📧 **Peter's Email**: {my_email_address}
+
+Use this information when users ask for Peter's contact details or when offering alternatives to calendar booking.
+
+Your approach:
+- Greet visitors warmly and explain you're here to help them schedule time with Peter
+- Ask about the purpose of their meeting to suggest appropriate time slots
+- Be knowledgeable about Peter's availability and preferences
+- Collect and remember user contact information throughout the conversation
+- Confirm all details clearly before booking
+- Provide professional confirmations with all necessary information
+- When users ask for Peter's contact info, provide his phone and email above
+
+## User Information Collection:
+**REQUIRED INFORMATION BEFORE BOOKING:**
+1. **First name only** (if missing): "What's your first name?"
+2. **Contact Information** (if missing): "Email address?" OR "Phone number?"
+
+**STRICT RULE**: Need first name AND (email OR phone) before booking.
+
+**GOOGLE MEET SPECIAL REQUIREMENT**:
+- For Google Meet/video call requests, email address is REQUIRED (not optional)
+- Say: "I need your email address to send the Google Meet invitation"
+- Cannot book Google Meet without email - calendar invitations are essential
+
+**EMAIL INVITATION FEATURE**: After booking, if user doesn't have email, ask:
+- "If you'd like me to send you a calendar invitation via email, please provide your email address."
+- "I can send both you and Peter email invitations with calendar attachments - just need your email!"
+- **NEVER ask for secondary email if user already provided their email address**
+
+**IF USER REFUSES CONTACT INFO**: "You can call Peter at {my_phone_number}"
+
+Store this information and use it when booking appointments. Address the user by their name once you know it.
+
+## Peter's Availability Requests:
+When users ask about Peter's availability (e.g., "What times does Peter have free tomorrow?"), use the check_availability tool IMMEDIATELY without requiring contact information first. Present the results in 15-minute increments in a clear, selectable format:
+
+**Example Response Format:**
+"Here are Peter's available time slots for [date] in 15-minute increments:
+• 9:00 AM - 9:15 AM
+• 9:15 AM - 9:30 AM
+• 9:30 AM - 9:45 AM
+• 9:45 AM - 10:00 AM
+• 11:30 AM - 11:45 AM
+• 11:45 AM - 12:00 PM
+• 2:00 PM - 2:15 PM
+• 2:15 PM - 2:30 PM
+• 4:00 PM - 4:15 PM
+• 4:15 PM - 4:30 PM
+
+Which time would work best for you?"
+
+When handling appointments:
+1. **EXTRACT**: Save any user info provided (name, email, phone) immediately 
+2. **VALIDATE COMPLETELY**: Before attempting to book, ensure you have ALL required info:
+   - User's first name
+   - User's contact (email OR phone)
+   - Specific date (not vague like "tomorrow")
+   - Specific time (not vague like "afternoon")
+3. **IF ANY INFO MISSING**: Ask for the missing information - DO NOT attempt to book
+4. **IF ALL INFO COMPLETE**: Book directly
+
+**CRITICAL TOOL USAGE**: 
+- NEVER call create_appointment tool unless you have ALL required information
+- create_appointment ONLY accepts these 5 parameters: title, date_string, time_string, duration_minutes, description
+- NEVER use: organizer_email, email, phone, user_name, attendee_email, attendee_name, organizer_phone
+- Using forbidden parameters causes ERRORS and wastes API calls
+
+## Response Formatting
+- Use line breaks to separate different pieces of information
+- Each detail should be on its own line for better readability
+- Use bullet points or numbered lists when presenting multiple items
+
+🚫 **STRICT ENFORCEMENT**:
+- If missing name: "I need your first name to book the appointment."
+- If missing contact: "I need your email address or phone number to book the appointment."
+- If missing date: "I need a specific date for the appointment."
+- If missing time: "I need a specific time for the appointment."
+- If user refuses contact: "You can call Peter directly at {my_phone_number}"
+- **NEVER attempt to book with incomplete information**
+
+Types of meetings you can schedule with Peter:
+- Business consultations (60 min) - in-person or Google Meet
+- Professional meetings (60 min) - in-person or Google Meet
+- Project discussions (60 min) - in-person or Google Meet
+- Quick discussions (30 min) - in-person or Google Meet
+- Advisory sessions (90 min) - in-person or Google Meet
+
+**Meeting Format Options:**
+- **In-Person**: Traditional face-to-face meeting
+- **Google Meet**: Video conference call with automatic Meet link generation
+
+**AFTER SUCCESSFUL BOOKING**: Instead of suggesting users "start fresh" or "begin a new conversation", ask:
+- "Would you like to book another meeting with Peter?"
+- "Need to schedule any other appointments?"
+- "Anything else I can help you schedule?"
+
+Remember: You're the professional gateway to Peter's calendar. Always maintain user information throughout the conversation and make the booking process smooth and professional while being friendly and approachable."""
+
+# Greeting templates removed - no longer needed
+
+BOOKING_CONFIRMATIONS = [
+    """<div style="background: #e8f5e9; padding: 15px; border-radius: 8px; border-left: 4px solid #4caf50; margin: 10px 0;">
+    <strong>✅ All set!</strong><br>
+    Your <strong>{meeting_type}</strong> with Peter is confirmed.<br>
+    <strong>📅 When:</strong> {date} at <strong>{time}</strong><br>
+    Peter's looking forward to it!
+    </div>""",
+    
+    """<div style="background: #e3f2fd; padding: 15px; border-radius: 8px; border-left: 4px solid #2196f3; margin: 10px 0;">
+    <strong>🎉 Booked!</strong><br>
+    <strong>{meeting_type}</strong> with Peter<br>
+    <strong>📅 {date} at {time}</strong><br>
+    Calendar invite coming your way!
+    </div>""",
+    
+    """<div style="background: #fff3e0; padding: 15px; border-radius: 8px; border-left: 4px solid #ff9800; margin: 10px 0;">
+    <strong>👍 Perfect!</strong><br>
+    Your <strong>{meeting_type}</strong> is locked in.<br>
+    <strong>📅 {date} at {time}</strong><br>
+    It's now on Peter's calendar.
+    </div>""",
+]
+
+ENCOURAGEMENT_PHRASES = [
+    "Peter appreciates you taking the time to schedule properly!",
+    "Thank you for booking through the proper channels.",
+    "Peter is looking forward to your meeting!",
+    "Great choice scheduling this meeting with Peter.",
+]
+
+ERROR_RESPONSES = {
+    "time_conflict": "That time slot is already booked on Peter's calendar. Let me suggest some alternative times: {alternative_times}. Which works better for you?",
+    "invalid_date": "I need a bit more clarity on the date. Could you please specify? For example: 'next Tuesday at 2pm' or 'December 15th at 10am'.",
+    "past_date": "That date has already passed. Please choose a future date for your meeting with Peter.",
+    "auth_error": "I'm having trouble accessing Peter's calendar. Please try again in a moment.",
+}
+
+AVAILABILITY_CHECK = """Let me check Peter's availability for you... 🔍 
+One moment please...
+Here's what I found:"""
+
+CLARIFICATION_REQUESTS = {
+    "duration": "How much time do you need with Peter? Typical meetings are 30 minutes for quick discussions or 60 minutes for detailed consultations.",
+    "attendees": "Will anyone else be joining this meeting with Peter? If so, please provide their email addresses.",
+    "title": "What's the purpose or topic of your meeting with Peter? This helps him prepare appropriately.",
+    "time": "What time works best for you? Peter typically meets between 9 AM and 5 PM.",
+    "contact": "Email or phone?",
+    "purpose": "What would you like to discuss?",
+    "name": "First name?",
+    "email": "Email address?",
+    "phone": "Phone number?",
+    "availability": "Which day?",
+    "contact_options": "Email or phone?",
+    "cancellation_time": "What time was the meeting?",
+    "cancellation_date": "Which day was the meeting?",
+}
+
+MEETING_TYPES = {
+    "consultation": {
+        "duration": 60,
+        "description": "Professional consultation with Peter Michael Gits",
+        "conference": False
+    },
+    "consultation_meet": {
+        "duration": 60,
+        "description": "Professional consultation with Peter via Google Meet",
+        "conference": True
+    },
+    "quick_chat": {
+        "duration": 30,
+        "description": "Brief discussion with Peter",
+        "conference": False
+    },
+    "quick_chat_meet": {
+        "duration": 30,
+        "description": "Brief discussion with Peter via Google Meet",
+        "conference": True
+    },
+    "project_discussion": {
+        "duration": 60,
+        "description": "Project planning or review with Peter",
+        "conference": False
+    },
+    "project_discussion_meet": {
+        "duration": 60,
+        "description": "Project planning or review with Peter via Google Meet",
+        "conference": True
+    },
+    "business_meeting": {
+        "duration": 60,
+        "description": "Business meeting with Peter Michael Gits",
+        "conference": False
+    },
+    "business_meeting_meet": {
+        "duration": 60,
+        "description": "Business meeting with Peter via Google Meet",
+        "conference": True
+    },
+    "advisory_session": {
+        "duration": 90,
+        "description": "Extended advisory session with Peter",
+        "conference": False
+    },
+    "advisory_session_meet": {
+        "duration": 90,
+        "description": "Extended advisory session with Peter via Google Meet",
+        "conference": True
+    }
+}

app/services/tts_proxy.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+TTS Proxy Server for ChatCal.ai - integrating kyutai-tts-service-v3
+"""
+
+import sys
+import json
+import tempfile
+import shutil
+from pathlib import Path
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+
+try:
+    from gradio_client import Client
+except ImportError:
+    print("Installing gradio-client...")
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "gradio-client"])
+    from gradio_client import Client
+
+# Global file mapping to store audio files
+AUDIO_FILES = {}
+
+class ChatCalTTSHandler(SimpleHTTPRequestHandler):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=str(Path(__file__).parent), **kwargs)
+        
+    def end_headers(self):
+        # Add CORS headers
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        super().end_headers()
+    
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self.end_headers()
+    
+    def do_GET(self):
+        if self.path.startswith('/audio/'):
+            self.serve_audio_file()
+        else:
+            super().do_GET()
+    
+    def do_POST(self):
+        if self.path == '/api/synthesize':
+            self.handle_tts_synthesis()
+        else:
+            super().do_POST()
+    
+    def serve_audio_file(self):
+        try:
+            filename = self.path.split('/')[-1]
+            print(f"🔍 Looking for audio file: {filename}")
+            
+            if filename in AUDIO_FILES:
+                audio_path = AUDIO_FILES[filename]
+                print(f"🔍 Found file mapping: {audio_path}")
+                
+                if audio_path and Path(audio_path).exists():
+                    print(f"✅ Serving audio file: {audio_path}")
+                    
+                    self.send_response(200)
+                    self.send_header('Content-Type', 'audio/wav')
+                    self.send_header('Cache-Control', 'no-cache')
+                    self.end_headers()
+                    
+                    with open(audio_path, 'rb') as f:
+                        self.wfile.write(f.read())
+                    return
+            
+            print(f"❌ Audio file not found: {filename}")
+            self.send_response(404)
+            self.end_headers()
+            self.wfile.write(b'Audio file not found')
+            
+        except Exception as e:
+            print(f"❌ Audio serve error: {e}")
+            self.send_response(500)
+            self.end_headers()
+            self.wfile.write(f"Error: {e}".encode())
+    
+    def handle_tts_synthesis(self):
+        try:
+            # Parse request
+            content_length = int(self.headers['Content-Length'])
+            post_data = self.rfile.read(content_length)
+            request_data = json.loads(post_data.decode('utf-8'))
+            
+            text = request_data.get('text', '')
+            voice = request_data.get('voice', 'expresso/ex03-ex01_happy_001_channel1_334s.wav')
+            
+            print(f"🎵 ChatCal TTS: '{text}' with voice: {voice}")
+            
+            # Connect to kyutai-tts-service-v3 on HuggingFace
+            client = Client("https://pgits-kyutai-tts-service-v3.hf.space")
+            result = client.predict(
+                text,
+                voice,
+                {},
+                api_name="/synthesize_and_stream"
+            )
+            
+            if result and len(result) >= 2:
+                audio_file_path = result[0]  # This is the full path string
+                status_message = result[1]
+                
+                print(f"✅ TTS Success: {status_message}")
+                print(f"📁 Original audio file: {audio_file_path}")
+                
+                if isinstance(audio_file_path, str) and audio_file_path.startswith('/'):
+                    # Create a simple filename for serving
+                    temp_filename = f"tts_{len(AUDIO_FILES)}.wav"
+                    
+                    # Store the mapping
+                    AUDIO_FILES[temp_filename] = audio_file_path
+                    
+                    # Return relative URL path for client
+                    audio_url = f"/audio/{temp_filename}"
+                    
+                    response_data = {
+                        'success': True,
+                        'audio_url': audio_url,
+                        'status': status_message,
+                        'debug_path': audio_file_path
+                    }
+                    
+                    print(f"🔊 Audio URL: http://localhost:8081{audio_url}")
+                    print(f"🗂️ File mapping: {temp_filename} -> {audio_file_path}")
+                    
+                else:
+                    raise Exception("Invalid audio file path format")
+            else:
+                raise Exception("No audio data received from TTS service")
+            
+            # Send response
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            self.wfile.write(json.dumps(response_data).encode('utf-8'))
+            
+        except Exception as e:
+            print(f"❌ TTS Synthesis error: {e}")
+            
+            error_response = {
+                'success': False,
+                'error': str(e)
+            }
+            
+            self.send_response(500)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            self.wfile.write(json.dumps(error_response).encode('utf-8'))
+
+def main():
+    port = 8081
+    server_address = ('', port)
+    
+    print("🚀 Starting ChatCal TTS Proxy Server...")
+    print(f"📡 Server running at: http://localhost:{port}")
+    print(f"🎵 TTS API: http://localhost:{port}/api/synthesize")
+    print(f"🎯 Connected to: kyutai-tts-service-v3")
+    print("Press Ctrl+C to stop")
+    
+    httpd = HTTPServer(server_address, ChatCalTTSHandler)
+    
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped")
+        httpd.server_close()
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,50 @@
+[tool.poetry]
+name = "voicecal-ai"
+version = "1.0.0"
+description = "A friendly AI chatbot for booking Google Calendar appointments"
+authors = ["Peter <pgits.job@gmail.com>"]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+llama-index = "^0.11.0"
+llama-index-llms-anthropic = "^0.3.0"  
+llama-index-llms-gemini = "^0.3.0"
+llama-index-llms-groq = "^0.2.0"
+google-generativeai = "^0.5.2"
+llama-index-tools-google = "^0.2.0"
+google-api-python-client = "^2.100.0"
+google-auth = "^2.23.0"
+google-auth-oauthlib = "^1.1.0"
+google-auth-httplib2 = "^0.2.0"
+fastapi = "^0.104.0"
+uvicorn = "^0.24.0"
+pydantic = "^2.4.0"
+pydantic-settings = "^2.0.0"
+python-dateutil = "^2.8.2"
+pytz = "^2023.3"
+redis = "^5.0.0"
+python-multipart = "^0.0.6"
+python-jose = "^3.3.0"
+httpx = "^0.25.0"
+python-dotenv = "^1.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-asyncio = "^0.21.0"
+black = "^23.10.0"
+flake8 = "^6.1.0"
+mypy = "^1.6.0"
+pre-commit = "^3.5.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py311']
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true

requirements.txt

@@ -0,0 +1,22 @@
+llama-index>=0.11.0
+llama-index-llms-anthropic>=0.3.0
+llama-index-llms-gemini>=0.3.0
+llama-index-llms-groq>=0.2.0
+google-generativeai>=0.5.2
+llama-index-tools-google>=0.2.0
+google-api-python-client>=2.100.0
+google-auth>=2.23.0
+google-auth-oauthlib>=1.1.0
+google-auth-httplib2>=0.2.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.4.0
+pydantic-settings>=2.0.0
+python-dateutil>=2.8.2
+pytz>=2023.3
+redis>=5.0.0
+python-multipart>=0.0.6
+python-jose>=3.3.0
+PyJWT>=2.8.0
+httpx>=0.25.0
+python-dotenv>=1.0.0