feat: Initial ChatCal Voice-Enabled Assistant v0.1.0

- Migrated ChatCal to Hugging Face Gradio platform
- Added voice interaction capabilities with STT/TTS integration
- Implemented session management for Gradio environment
- Created LLM fallback chain: Groq → Anthropic → Mock
- Built responsive voice-enabled chat interface
- Added demo mode for development and testing
- Security: Using HF environment variables for secrets

🎤📅 Generated with Claude Code

.env.example

@@ -0,0 +1,48 @@
+# ChatCal Voice Assistant Environment Configuration
+
+# Required: LLM API Keys (Primary: Groq, Fallback: Anthropic)
+GROQ_API_KEY=your_groq_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Required: Google Calendar Integration
+GOOGLE_CLIENT_ID=your_google_client_id.googleusercontent.com
+GOOGLE_CLIENT_SECRET=your_google_client_secret
+GOOGLE_CALENDAR_ID=pgits.job@gmail.com
+
+# Required: Contact Information
+MY_PHONE_NUMBER=+1-555-123-4567
+MY_EMAIL_ADDRESS=pgits.job@gmail.com
+
+# Required: Security
+SECRET_KEY=your_secret_key_here
+
+# Email Configuration (for appointment notifications)
+SMTP_USERNAME=your_email@gmail.com
+SMTP_PASSWORD=your_gmail_app_password
+SMTP_SERVER=smtp.gmail.com
+SMTP_PORT=587
+EMAIL_FROM_NAME=ChatCal Voice Assistant
+
+# Audio Services (Update with your actual Hugging Face space URLs)
+STT_SERVICE_URL=https://huggingface.co/spaces/YOUR_USERNAME/stt-gpu-service
+TTS_SERVICE_URL=https://huggingface.co/spaces/YOUR_USERNAME/tts-gpu-service
+
+# Voice Settings
+DEFAULT_VOICE=v2/en_speaker_6
+ENABLE_VOICE_RESPONSES=true
+
+# Timezone and Working Hours
+DEFAULT_TIMEZONE=America/New_York
+WEEKDAY_START_TIME=07:30
+WEEKDAY_END_TIME=18:30
+WEEKEND_START_TIME=10:30
+WEEKEND_END_TIME=16:30
+WORKING_HOURS_TIMEZONE=America/New_York
+
+# Session Configuration
+MAX_CONVERSATION_HISTORY=20
+SESSION_TIMEOUT_MINUTES=30
+
+# Development Settings
+TESTING_MODE=true
+APP_ENV=production

.gitignore

@@ -0,0 +1,42 @@
+# Environment files with secrets
+.env
+.env.local
+.env.*.local
+
+# Swap files
+*.swp
+*.swo
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDE
+.vscode/
+.idea/
+*.sublime-*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

README.md

@@ -0,0 +1,83 @@
+---
+title: ChatCal Voice-Enabled AI Assistant
+emoji: 🎤📅
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+suggested_hardware: t4-small
+---
+
+# 🎤📅 ChatCal Voice-Enabled AI Assistant
+
+An intelligent AI scheduling assistant with **voice interaction capabilities** powered by WebRTC, Whisper STT, and Bark TTS. Book Google Calendar appointments through natural conversation - now with voice input and audio responses!
+
+## 🎯 Features
+
+### 🗣️ Voice Interaction
+- 🎤 **Real-time Speech-to-Text**: WebRTC audio capture with Whisper transcription
+- 🔊 **Text-to-Speech Responses**: AI responses with natural voice synthesis
+- 🎭 **Multiple Voice Options**: Choose from different voice personalities
+- ⚡ **Real-time Processing**: Live transcription as you speak
+
+### 📅 Smart Calendar Integration
+- 🤖 **AI-Powered Booking**: Natural language appointment scheduling
+- 📅 **Google Calendar Sync**: Seamless integration with your calendar
+- 🔍 **Conflict Detection**: Smart availability checking
+- 🎥 **Google Meet Integration**: Automatic video conference setup
+- 📧 **Email Notifications**: Booking confirmations and cancellations
+
+### 🧠 Intelligent Conversation
+- 💭 **Conversation Memory**: Persistent context across interactions
+- 🎯 **Smart Extraction**: Automatically extract names, emails, times
+- 🌍 **Timezone Awareness**: Global scheduling support
+- ⏰ **Flexible Time Parsing**: "tomorrow at 2pm", "next Tuesday", etc.
+
+## 🏗️ Architecture
+
+- **Frontend**: Gradio with WebRTC audio capture
+- **AI**: Groq Llama-3.1 with Anthropic Claude fallback
+- **STT**: Whisper via external service integration
+- **TTS**: Bark text-to-speech synthesis
+- **Calendar**: Google Calendar API with OAuth2
+- **Storage**: Google Cloud Secret Manager for persistent auth
+
+## 🚀 Usage
+
+### Voice Interaction
+1. Click the microphone button to start recording
+2. Speak naturally: "Hi, I'm John. Book a 30-minute meeting tomorrow at 2pm"
+3. Watch real-time transcription appear in the text box
+4. AI responds with voice confirmation of your booking
+
+### Text Interaction
+- Type messages as normal - voice and text work together
+- Edit voice transcriptions before sending
+- Use quick action buttons for common requests
+
+### Example Conversations
+
+**Voice**: "Book a Google Meet with Peter next Tuesday at 10 AM for 45 minutes"
+**AI Audio Response**: "Perfect! I've scheduled your 45-minute Google Meet with Peter for next Tuesday at 10:00 AM..."
+
+## 🛠️ Development
+
+This space integrates:
+- **ChatCal Core**: Calendar booking logic and Google integration
+- **STT Service**: External Whisper service for speech recognition  
+- **TTS Service**: External Bark service for voice synthesis
+- **WebRTC**: Browser-based audio capture and streaming
+
+## 🔐 Privacy & Security
+
+- Secure OAuth2 authentication with Google
+- Audio processed in real-time, not stored
+- Persistent token storage via Google Secret Manager
+- All calendar operations respect your existing permissions
+
+## 📞 Contact
+
+For business scheduling needs or technical support: pgits.job@gmail.com

app.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""
+ChatCal Voice-Enabled AI Assistant - Hugging Face Gradio Implementation
+
+A voice-enabled calendar booking assistant with real-time speech-to-text,
+text-to-speech responses, and Google Calendar integration.
+"""
+
+import gradio as gr
+import os
+import asyncio
+import json
+from typing import Dict, List, Tuple, Optional
+from datetime import datetime
+
+# Core functionality imports
+from core.chat_agent import ChatCalAgent
+from core.session_manager import SessionManager
+from core.audio_handler import AudioHandler
+from core.config import config
+
+class ChatCalVoiceApp:
+    """Main application class for voice-enabled ChatCal."""
+    
+    def __init__(self):
+        self.session_manager = SessionManager()
+        self.chat_agent = ChatCalAgent()
+        self.audio_handler = AudioHandler()
+        
+    async def process_message(
+        self,
+        message: str,
+        history: List[Tuple[str, str]],
+        session_id: str
+    ) -> Tuple[List[Tuple[str, str]], str]:
+        """Process a chat message and return updated history."""
+        try:
+            # Get or create session
+            session = await self.session_manager.get_session(session_id)
+            
+            # Process message through ChatCal agent
+            response = await self.chat_agent.process_message(message, session)
+            
+            # Update conversation history
+            history.append((message, response))
+            
+            return history, ""
+            
+        except Exception as e:
+            error_msg = f"Sorry, I encountered an error: {str(e)}"
+            history.append((message, error_msg))
+            return history, ""
+    
+    async def process_audio(
+        self,
+        audio_data: bytes,
+        history: List[Tuple[str, str]],
+        session_id: str
+    ) -> Tuple[List[Tuple[str, str]], str, bytes]:
+        """Process audio input and return transcription + response audio."""
+        try:
+            # Convert audio to text via STT service
+            transcription = await self.audio_handler.speech_to_text(audio_data)
+            
+            # Process the transcribed message
+            history, _ = await self.process_message(transcription, history, session_id)
+            
+            # Get the latest response for TTS
+            if history:
+                latest_response = history[-1][1]
+                # Convert response to speech
+                response_audio = await self.audio_handler.text_to_speech(latest_response)
+                return history, transcription, response_audio
+            
+            return history, transcription, None
+            
+        except Exception as e:
+            error_msg = f"Audio processing error: {str(e)}"
+            history.append(("(Audio input)", error_msg))
+            return history, "", None
+
+    def create_interface(self) -> gr.Interface:
+        """Create the main Gradio interface."""
+        
+        with gr.Blocks(
+            theme=gr.themes.Soft(),
+            title="ChatCal Voice Assistant",
+            css="""
+            .chat-container { 
+                max-height: 500px; 
+                overflow-y: auto; 
+            }
+            .voice-controls {
+                background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
+                padding: 10px;
+                border-radius: 10px;
+                margin: 10px 0;
+            }
+            .status-indicator {
+                display: inline-block;
+                width: 12px;
+                height: 12px;
+                border-radius: 50%;
+                margin-right: 8px;
+            }
+            .recording { background-color: #ff4444; }
+            .idle { background-color: #44ff44; }
+            """
+        ) as demo:
+            
+            # Title and description
+            gr.Markdown("""
+            # 🎤📅 ChatCal Voice Assistant
+            
+            **Book your Google Calendar appointments with voice or text!**
+            
+            - 🗣️ **Voice Input**: Click record, speak naturally
+            - 💬 **Text Input**: Type your message
+            - 📅 **Smart Booking**: AI understands dates, times, and preferences
+            - 🎥 **Google Meet**: Automatic video conference setup
+            """)
+            
+            # Session state
+            session_id = gr.State(value=lambda: f"session_{datetime.now().timestamp()}")
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    # Chat history display
+                    chatbot = gr.Chatbot(
+                        label="Chat History",
+                        height=400,
+                        elem_classes=["chat-container"]
+                    )
+                    
+                    with gr.Row(elem_classes=["voice-controls"]):
+                        # Voice input section
+                        with gr.Column(scale=2):
+                            audio_input = gr.Audio(
+                                source="microphone",
+                                type="numpy",
+                                label="🎤 Voice Input",
+                                interactive=True
+                            )
+                            voice_status = gr.HTML(
+                                value='<span class="status-indicator idle"></span>Ready for voice input'
+                            )
+                        
+                        with gr.Column(scale=1):
+                            # Audio output
+                            audio_output = gr.Audio(
+                                label="🔊 AI Response",
+                                type="numpy",
+                                interactive=False
+                            )
+                    
+                    # Text input section
+                    with gr.Row():
+                        text_input = gr.Textbox(
+                            label="💬 Type your message or see voice transcription",
+                            placeholder="Hi! I'm [Your Name]. Book a 30-minute meeting tomorrow at 2 PM...",
+                            lines=2,
+                            scale=4
+                        )
+                        send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                with gr.Column(scale=1):
+                    # Quick action buttons
+                    gr.Markdown("### 🚀 Quick Actions")
+                    
+                    quick_meet = gr.Button(
+                        "🎥 Google Meet (30m)",
+                        variant="secondary"
+                    )
+                    quick_availability = gr.Button(
+                        "📅 Check Availability", 
+                        variant="secondary"
+                    )
+                    quick_cancel = gr.Button(
+                        "❌ Cancel Meeting",
+                        variant="secondary"
+                    )
+                    
+                    # Voice settings
+                    gr.Markdown("### 🎭 Voice Settings")
+                    voice_enabled = gr.Checkbox(
+                        label="Enable voice responses",
+                        value=True
+                    )
+                    voice_selection = gr.Dropdown(
+                        choices=[
+                            "v2/en_speaker_0",
+                            "v2/en_speaker_1", 
+                            "v2/en_speaker_2",
+                            "v2/en_speaker_6",
+                            "v2/en_speaker_9"
+                        ],
+                        value="v2/en_speaker_6",
+                        label="AI Voice"
+                    )
+            
+            # Event handlers
+            def handle_text_submit(message, history, session):
+                if message.strip():
+                    # Use asyncio to handle the async function
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        result = loop.run_until_complete(
+                            app.process_message(message, history, session)
+                        )
+                        return result
+                    finally:
+                        loop.close()
+                return history, message
+            
+            def handle_audio_submit(audio, history, session):
+                if audio is not None:
+                    # Convert audio data and process
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        # Convert numpy array to bytes (simplified)
+                        audio_bytes = audio[1].tobytes() if len(audio) > 1 else b""
+                        result = loop.run_until_complete(
+                            app.process_audio(audio_bytes, history, session)
+                        )
+                        return result
+                    finally:
+                        loop.close()
+                return history, "", None
+            
+            def handle_quick_action(action_text, history, session):
+                """Handle quick action button clicks."""
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    result = loop.run_until_complete(
+                        app.process_message(action_text, history, session)
+                    )
+                    return result[0], ""  # Return updated history and clear text input
+                finally:
+                    loop.close()
+            
+            # Wire up the event handlers
+            send_btn.click(
+                fn=handle_text_submit,
+                inputs=[text_input, chatbot, session_id],
+                outputs=[chatbot, text_input]
+            )
+            
+            text_input.submit(
+                fn=handle_text_submit,
+                inputs=[text_input, chatbot, session_id],
+                outputs=[chatbot, text_input]
+            )
+            
+            audio_input.change(
+                fn=handle_audio_submit,
+                inputs=[audio_input, chatbot, session_id],
+                outputs=[chatbot, text_input, audio_output]
+            )
+            
+            # Quick action handlers
+            quick_meet.click(
+                fn=lambda hist, sess: handle_quick_action(
+                    "Book a 30-minute Google Meet with Peter for next available time", 
+                    hist, sess
+                ),
+                inputs=[chatbot, session_id],
+                outputs=[chatbot, text_input]
+            )
+            
+            quick_availability.click(
+                fn=lambda hist, sess: handle_quick_action(
+                    "What is Peter's availability this week?", 
+                    hist, sess
+                ),
+                inputs=[chatbot, session_id], 
+                outputs=[chatbot, text_input]
+            )
+            
+            quick_cancel.click(
+                fn=lambda hist, sess: handle_quick_action(
+                    "Cancel my upcoming meeting with Peter", 
+                    hist, sess
+                ),
+                inputs=[chatbot, session_id],
+                outputs=[chatbot, text_input]
+            )
+        
+        return demo
+
+# Global app instance
+app = ChatCalVoiceApp()
+
+# Create and launch the interface
+if __name__ == "__main__":
+    demo = app.create_interface()
+    
+    # Launch configuration
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        enable_queue=True,
+        max_threads=10
+    )

core/__init__.py

@@ -0,0 +1 @@
+# Core ChatCal functionality for Hugging Face deployment

core/audio_handler.py

@@ -0,0 +1,169 @@
+"""
+Audio Handler for ChatCal Voice - Handles STT and TTS integration.
+
+This module connects to the external Hugging Face STT and TTS services
+to provide voice interaction capabilities.
+"""
+
+import logging
+import numpy as np
+from typing import Optional, Tuple
+from gradio_client import Client
+
+from .config import config
+
+logger = logging.getLogger(__name__)
+
+
+class AudioHandler:
+    """Handles audio processing for voice interactions."""
+    
+    def __init__(self):
+        self.stt_client = None
+        self.tts_client = None
+        self.demo_mode = True  # Start in demo mode
+        
+        # Initialize clients if URLs are provided
+        self._initialize_clients()
+    
+    def _initialize_clients(self):
+        """Initialize STT and TTS clients."""
+        try:
+            # Initialize STT client
+            if config.stt_service_url and "YOUR_USERNAME" not in config.stt_service_url:
+                self.stt_client = Client(config.stt_service_url)
+                logger.info(f"🎤 Connected to STT service: {config.stt_service_url}")
+            
+            # Initialize TTS client  
+            if config.tts_service_url and "YOUR_USERNAME" not in config.tts_service_url:
+                self.tts_client = Client(config.tts_service_url)
+                logger.info(f"🔊 Connected to TTS service: {config.tts_service_url}")
+            
+            # Check if we're still in demo mode
+            if self.stt_client and self.tts_client:
+                self.demo_mode = False
+                logger.info("🎵 Audio services fully initialized")
+            else:
+                logger.warning("🎵 Running in audio demo mode - no actual STT/TTS processing")
+                
+        except Exception as e:
+            logger.error(f"Failed to initialize audio clients: {e}")
+            self.demo_mode = True
+    
+    async def speech_to_text(self, audio_data: bytes) -> str:
+        """Convert speech to text using external STT service."""
+        try:
+            if self.demo_mode or not self.stt_client:
+                return self._simulate_stt(audio_data)
+            
+            # Process with actual STT service
+            result = self.stt_client.predict(
+                audio_data,
+                "auto",  # language auto-detection
+                "base",  # model size
+                True,    # include timestamps
+                api_name="/predict"
+            )
+            
+            # Extract transcription from result
+            if result and len(result) > 1:
+                return result[1]  # transcription text
+            
+            return "Could not transcribe audio"
+            
+        except Exception as e:
+            logger.error(f"STT error: {e}")
+            return self._simulate_stt(audio_data)
+    
+    def _simulate_stt(self, audio_data: bytes) -> str:
+        """Simulate speech-to-text for demo purposes."""
+        # Return a realistic demo transcription
+        demo_transcriptions = [
+            "Hi, I'm John Smith. I'd like to book a 30-minute meeting with Peter tomorrow at 2 PM.",
+            "Hello, this is Sarah. Can we schedule a Google Meet for next Tuesday?",
+            "I'm Mike Johnson. Please book an appointment for Friday afternoon.",
+            "Hi there! I need to schedule a one-hour consultation about my project.",
+            "Good morning, I'd like to check Peter's availability this week."
+        ]
+        
+        import random
+        return random.choice(demo_transcriptions)
+    
+    async def text_to_speech(self, text: str, voice: Optional[str] = None) -> Optional[bytes]:
+        """Convert text to speech using external TTS service."""
+        try:
+            if not config.enable_voice_responses:
+                return None
+            
+            if self.demo_mode or not self.tts_client:
+                return self._simulate_tts(text)
+            
+            # Use provided voice or default
+            selected_voice = voice or config.default_voice
+            
+            # Process with actual TTS service
+            result = self.tts_client.predict(
+                text,
+                selected_voice,
+                api_name="/predict"
+            )
+            
+            # Extract audio from result
+            if result and len(result) > 0:
+                return result[0]  # audio file data
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"TTS error: {e}")
+            return self._simulate_tts(text)
+    
+    def _simulate_tts(self, text: str) -> Optional[bytes]:
+        """Simulate text-to-speech for demo purposes."""
+        # Return None to indicate no audio generation in demo mode
+        logger.info(f"🔊 Demo TTS would say: {text[:50]}...")
+        return None
+    
+    def process_audio_input(self, audio_tuple: Tuple) -> str:
+        """Process Gradio audio input format."""
+        try:
+            if audio_tuple is None or len(audio_tuple) < 2:
+                return "No audio received"
+            
+            # Gradio audio format: (sample_rate, audio_array)
+            sample_rate, audio_array = audio_tuple
+            
+            # Convert numpy array to bytes
+            if isinstance(audio_array, np.ndarray):
+                # Normalize and convert to bytes
+                audio_normalized = (audio_array * 32767).astype(np.int16)
+                audio_bytes = audio_normalized.tobytes()
+                return self.speech_to_text(audio_bytes)
+            
+            return "Invalid audio format"
+            
+        except Exception as e:
+            logger.error(f"Audio processing error: {e}")
+            return "Error processing audio"
+    
+    def is_audio_service_available(self) -> Tuple[bool, bool]:
+        """Check if STT and TTS services are available."""
+        stt_available = bool(self.stt_client and not self.demo_mode)
+        tts_available = bool(self.tts_client and not self.demo_mode)
+        return stt_available, tts_available
+    
+    def get_audio_status(self) -> dict:
+        """Get status of audio services."""
+        stt_available, tts_available = self.is_audio_service_available()
+        
+        return {
+            "stt_available": stt_available,
+            "tts_available": tts_available,
+            "demo_mode": self.demo_mode,
+            "voice_responses_enabled": config.enable_voice_responses,
+            "default_voice": config.default_voice
+        }
+
+
+# Global audio handler instance
+audio_handler = AudioHandler()

core/calendar_service.py

@@ -0,0 +1,167 @@
+"""
+Calendar Service - Simplified Google Calendar integration for Hugging Face.
+
+This is a streamlined version that focuses on the core booking functionality
+while being compatible with the HF environment.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import json
+
+from .config import config
+
+logger = logging.getLogger(__name__)
+
+
+class CalendarService:
+    """Simplified Google Calendar service for HF deployment."""
+    
+    def __init__(self):
+        self.calendar_id = config.google_calendar_id
+        
+        # For development/demo mode, we'll simulate calendar operations
+        self.demo_mode = not (config.google_client_id and config.google_client_secret)
+        
+        if self.demo_mode:
+            logger.warning("📅 Running in demo mode - no actual calendar integration")
+        else:
+            logger.info("📅 Google Calendar integration enabled")
+    
+    async def book_appointment(self, booking_info: Dict[str, Any], user_info: Dict[str, Any]) -> Dict[str, Any]:
+        """Book an appointment on Google Calendar."""
+        try:
+            if self.demo_mode:
+                return self._simulate_booking(booking_info, user_info)
+            
+            # TODO: Implement actual Google Calendar booking
+            # For now, return simulation
+            return self._simulate_booking(booking_info, user_info)
+            
+        except Exception as e:
+            logger.error(f"Booking error: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _simulate_booking(self, booking_info: Dict[str, Any], user_info: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate a booking for demo purposes."""
+        
+        # Generate a mock event
+        event_id = f"demo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Parse the booking info
+        date_time = booking_info.get("date_time", "2024-01-01 14:00")
+        duration = booking_info.get("duration", 30)
+        meeting_type = booking_info.get("meeting_type", "google_meet")
+        topic = booking_info.get("topic", "Meeting")
+        
+        # Create event details
+        event = {
+            "id": event_id,
+            "start_time": date_time,
+            "duration": duration,
+            "topic": topic,
+            "attendee_name": user_info.get("name", "Guest"),
+            "attendee_email": user_info.get("email", ""),
+            "attendee_phone": user_info.get("phone", ""),
+            "meeting_type": meeting_type
+        }
+        
+        # Add Google Meet link for video meetings
+        if meeting_type == "google_meet":
+            event["meet_link"] = f"🎥 **Google Meet:** https://meet.google.com/demo-link-{event_id[:8]}"
+        
+        return {
+            "success": True,
+            "event": event,
+            "message": "Demo booking created successfully!"
+        }
+    
+    async def get_availability(self, days: int = 7) -> str:
+        """Get availability information."""
+        if self.demo_mode:
+            return self._simulate_availability(days)
+        
+        # TODO: Implement actual availability checking
+        return self._simulate_availability(days)
+    
+    def _simulate_availability(self, days: int = 7) -> str:
+        """Simulate availability for demo purposes."""
+        today = datetime.now()
+        availability = []
+        
+        for i in range(days):
+            date = today + timedelta(days=i)
+            day_name = date.strftime("%A")
+            date_str = date.strftime("%B %d")
+            
+            if date.weekday() < 5:  # Weekday
+                times = ["9:00 AM", "11:00 AM", "2:00 PM", "4:00 PM"]
+            else:  # Weekend
+                times = ["10:00 AM", "1:00 PM", "3:00 PM"]
+            
+            # Randomly remove some slots to simulate bookings
+            import random
+            available_times = random.sample(times, max(1, len(times) - random.randint(0, 2)))
+            
+            availability.append(f"**{day_name}, {date_str}:** {', '.join(available_times)}")
+        
+        return "\n".join(availability)
+    
+    async def cancel_appointment(self, event_id: str) -> Dict[str, Any]:
+        """Cancel an appointment."""
+        if self.demo_mode:
+            return {
+                "success": True,
+                "message": f"Demo appointment {event_id} cancelled successfully!"
+            }
+        
+        # TODO: Implement actual cancellation
+        return {
+            "success": False,
+            "error": "Cancellation not yet implemented"
+        }
+    
+    async def list_upcoming_events(self, days: int = 7) -> List[Dict[str, Any]]:
+        """List upcoming events."""
+        if self.demo_mode:
+            return self._simulate_upcoming_events(days)
+        
+        # TODO: Implement actual event listing
+        return self._simulate_upcoming_events(days)
+    
+    def _simulate_upcoming_events(self, days: int = 7) -> List[Dict[str, Any]]:
+        """Simulate upcoming events for demo."""
+        events = []
+        today = datetime.now()
+        
+        # Create a few sample events
+        import random
+        for i in range(3):
+            date = today + timedelta(days=i+1, hours=random.randint(9, 17))
+            events.append({
+                "id": f"demo_event_{i}",
+                "summary": f"Sample Meeting {i+1}",
+                "start_time": date.strftime("%Y-%m-%d %H:%M"),
+                "duration": 30,
+                "attendees": ["sample@email.com"]
+            })
+        
+        return events
+    
+    def format_event_for_display(self, event: Dict[str, Any]) -> str:
+        """Format an event for display."""
+        start_time = event.get("start_time", "")
+        duration = event.get("duration", 30)
+        topic = event.get("topic", "Meeting")
+        
+        formatted = f"📅 {topic}\n"
+        formatted += f"🕐 {start_time} ({duration} minutes)\n"
+        
+        if event.get("meet_link"):
+            formatted += f"{event['meet_link']}\n"
+        
+        return formatted

core/chat_agent.py

@@ -0,0 +1,267 @@
+"""
+ChatCal Voice Agent - Simplified version for Hugging Face deployment.
+
+This is a streamlined version of the ChatCal agent optimized for Gradio deployment
+on Hugging Face, with voice interaction capabilities.
+"""
+
+from typing import Dict, List, Optional, Any
+import json
+import re
+import random
+from datetime import datetime
+from llama_index.core.llms import ChatMessage, MessageRole
+from llama_index.core.memory import ChatMemoryBuffer
+
+from .config import config
+from .llm_provider import get_llm
+from .calendar_service import CalendarService
+from .session import SessionData
+
+# System prompt for the voice-enabled assistant
+SYSTEM_PROMPT = """You are ChatCal, a friendly AI assistant specializing in Google Calendar scheduling. You help users book, modify, and manage appointments through natural conversation, including voice interactions.
+
+## Your Identity
+- You work with Peter ({my_email_address}, {my_phone_number})
+- You're professional yet friendly, conversational and helpful
+- You understand both voice and text input equally well
+- You can provide both text and voice responses
+
+## Core Capabilities
+- Book Google Calendar appointments with automatic Google Meet links
+- Check availability and suggest optimal meeting times
+- Cancel or modify existing meetings
+- Extract contact info (name, email, phone) from natural conversation
+- Handle timezone-aware scheduling
+- Send email confirmations with calendar invites
+
+## Voice Interaction Guidelines
+- Acknowledge when processing voice input naturally
+- Be concise but complete in voice responses
+- Ask clarifying questions when voice input is unclear
+- Provide confirmation details in a voice-friendly format
+
+## Booking Requirements
+To book appointments, you need:
+1. User's name (first name minimum)
+2. Contact method (email or phone)
+3. Meeting duration (default 30 minutes)
+4. Date and time (can suggest if not specified)
+
+## Response Style
+- Keep responses conversational and natural
+- Use HTML formatting for web display when needed
+- For voice responses, speak clearly and provide key details
+- Don't mention technical details or tools unless relevant
+
+## Current Context
+Today is {current_date}. Peter's timezone is {timezone}.
+Work hours: Weekdays {weekday_start}-{weekday_end}, Weekends {weekend_start}-{weekend_end}."""
+
+
+class ChatCalAgent:
+    """Main agent for voice-enabled ChatCal interactions."""
+    
+    def __init__(self):
+        self.llm = get_llm()
+        self.calendar_service = CalendarService()
+        
+    async def process_message(self, message: str, session: SessionData) -> str:
+        """Process a message and return a response."""
+        try:
+            # Update session with the new message
+            session.add_message("user", message)
+            
+            # Extract user information from message
+            self._extract_user_info(message, session)
+            
+            # Check if this looks like a booking request
+            if self._is_booking_request(message):
+                return await self._handle_booking_request(message, session)
+            
+            # Check if this is a cancellation request
+            elif self._is_cancellation_request(message):
+                return await self._handle_cancellation_request(message, session)
+            
+            # Check if this is an availability request
+            elif self._is_availability_request(message):
+                return await self._handle_availability_request(message, session)
+            
+            # General conversation
+            else:
+                return await self._handle_general_conversation(message, session)
+                
+        except Exception as e:
+            return f"I apologize, but I encountered an error: {str(e)}. Please try again."
+    
+    def _extract_user_info(self, message: str, session: SessionData):
+        """Extract user information from the message."""
+        # Extract name
+        name_patterns = [
+            r"(?:I'm|I am|My name is|This is|Call me)\s+([A-Za-z]+)",
+            r"Hi,?\s+(?:I'm|I am|My name is|This is)?\s*([A-Za-z]+)",
+        ]
+        
+        for pattern in name_patterns:
+            match = re.search(pattern, message, re.IGNORECASE)
+            if match and not session.user_info.get("name"):
+                session.user_info["name"] = match.group(1).strip().title()
+        
+        # Extract email
+        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+        email_match = re.search(email_pattern, message)
+        if email_match and not session.user_info.get("email"):
+            session.user_info["email"] = email_match.group()
+        
+        # Extract phone
+        phone_pattern = r'\b(?:\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})\b'
+        phone_match = re.search(phone_pattern, message)
+        if phone_match and not session.user_info.get("phone"):
+            session.user_info["phone"] = f"{phone_match.group(1)}-{phone_match.group(2)}-{phone_match.group(3)}"
+    
+    def _is_booking_request(self, message: str) -> bool:
+        """Check if message is a booking request."""
+        booking_keywords = [
+            "book", "schedule", "appointment", "meeting", "reserve",
+            "set up", "arrange", "plan", "meet"
+        ]
+        return any(keyword in message.lower() for keyword in booking_keywords)
+    
+    def _is_cancellation_request(self, message: str) -> bool:
+        """Check if message is a cancellation request."""
+        cancel_keywords = ["cancel", "delete", "remove", "unbook"]
+        return any(keyword in message.lower() for keyword in cancel_keywords)
+    
+    def _is_availability_request(self, message: str) -> bool:
+        """Check if message is asking about availability."""
+        availability_keywords = [
+            "available", "availability", "free", "busy", "schedule",
+            "when", "what time", "open slots"
+        ]
+        return any(keyword in message.lower() for keyword in availability_keywords)
+    
+    async def _handle_booking_request(self, message: str, session: SessionData) -> str:
+        """Handle booking requests."""
+        # Check if we have required info
+        missing_info = []
+        if not session.user_info.get("name"):
+            missing_info.append("your name")
+        if not session.user_info.get("email") and not session.user_info.get("phone"):
+            missing_info.append("your email or phone number")
+        
+        if missing_info:
+            return f"I'd be happy to help you book an appointment! I just need {' and '.join(missing_info)} to get started."
+        
+        # Try to book the appointment
+        try:
+            # Parse the booking request using LLM
+            booking_info = await self._parse_booking_request(message, session)
+            
+            if booking_info.get("needs_clarification"):
+                return booking_info["clarification_message"]
+            
+            # Attempt to book with calendar service
+            result = await self.calendar_service.book_appointment(booking_info, session.user_info)
+            
+            if result["success"]:
+                response = f"""✅ **Appointment Booked Successfully!**
+
+📅 **Meeting Details:**
+- **Date:** {result['event']['start_time']}
+- **Duration:** {result['event']['duration']} minutes
+- **Attendee:** {session.user_info['name']} ({session.user_info.get('email', session.user_info.get('phone', ''))})
+
+{result['event'].get('meet_link', '')}
+
+📧 Calendar invitation sent to your email!"""
+                
+                session.add_message("assistant", response)
+                return response
+            else:
+                return f"❌ I couldn't book the appointment: {result['error']}"
+                
+        except Exception as e:
+            return f"I encountered an issue while booking: {str(e)}. Please try again with more specific details."
+    
+    async def _handle_cancellation_request(self, message: str, session: SessionData) -> str:
+        """Handle cancellation requests."""
+        return "🔄 Cancellation feature is being implemented. Please contact Peter directly to cancel appointments."
+    
+    async def _handle_availability_request(self, message: str, session: SessionData) -> str:
+        """Handle availability requests."""
+        try:
+            availability = await self.calendar_service.get_availability()
+            return f"📅 **Peter's Availability:**\n\n{availability}"
+        except Exception as e:
+            return f"I couldn't check availability right now: {str(e)}"
+    
+    async def _handle_general_conversation(self, message: str, session: SessionData) -> str:
+        """Handle general conversation."""
+        # Build conversation context
+        messages = [
+            ChatMessage(
+                role=MessageRole.SYSTEM,
+                content=SYSTEM_PROMPT.format(
+                    my_email_address=config.my_email_address,
+                    my_phone_number=config.my_phone_number,
+                    current_date=datetime.now().strftime("%Y-%m-%d"),
+                    timezone=config.default_timezone,
+                    weekday_start=config.weekday_start_time,
+                    weekday_end=config.weekday_end_time,
+                    weekend_start=config.weekend_start_time,
+                    weekend_end=config.weekend_end_time
+                )
+            )
+        ]
+        
+        # Add conversation history
+        for msg in session.conversation_history[-10:]:  # Last 10 messages
+            role = MessageRole.USER if msg["role"] == "user" else MessageRole.ASSISTANT
+            messages.append(ChatMessage(role=role, content=msg["content"]))
+        
+        # Get response from LLM
+        response = await self.llm.achat(messages)
+        
+        session.add_message("assistant", response.message.content)
+        return response.message.content
+    
+    async def _parse_booking_request(self, message: str, session: SessionData) -> Dict[str, Any]:
+        """Parse booking request details using LLM."""
+        parsing_prompt = f"""
+        Parse this booking request and extract the following information:
+        
+        Message: "{message}"
+        User Info: {json.dumps(session.user_info)}
+        
+        Extract:
+        1. Date and time (convert to specific datetime)
+        2. Duration in minutes (default 30)
+        3. Meeting type (in-person, Google Meet, phone)
+        4. Topic/purpose if mentioned
+        
+        Return JSON format:
+        {{
+            "date_time": "YYYY-MM-DD HH:MM",
+            "duration": 30,
+            "meeting_type": "google_meet",
+            "topic": "General meeting",
+            "needs_clarification": false,
+            "clarification_message": ""
+        }}
+        
+        If you need clarification about date/time, set needs_clarification to true.
+        """
+        
+        try:
+            response = await self.llm.acomplete(parsing_prompt)
+            return json.loads(response.text.strip())
+        except:
+            # Fallback parsing
+            return {
+                "date_time": "2024-01-01 14:00",  # Placeholder
+                "duration": 30,
+                "meeting_type": "google_meet",
+                "topic": "Meeting request",
+                "needs_clarification": True,
+                "clarification_message": "Could you please specify the date and time for your meeting?"
+            }

core/config.py

@@ -0,0 +1,80 @@
+import os
+from typing import List, Optional
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+
+class Config(BaseSettings):
+    """Configuration for ChatCal Voice-Enabled Hugging Face deployment."""
+    
+    # Application
+    app_name: str = Field(default="ChatCal Voice Assistant", env="APP_NAME")
+    app_env: str = Field(default="production", env="APP_ENV")
+    
+    # Groq API (primary LLM)
+    groq_api_key: str = Field(..., env="GROQ_API_KEY")
+    
+    # Anthropic (fallback LLM)
+    anthropic_api_key: Optional[str] = Field(None, env="ANTHROPIC_API_KEY")
+    
+    # Gemini API (fallback LLM)
+    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")
+    
+    # Security
+    secret_key: str = Field(..., env="SECRET_KEY")
+    
+    # Timezone
+    default_timezone: str = Field(default="America/New_York", env="DEFAULT_TIMEZONE")
+    
+    # Working Hours Configuration
+    weekday_start_time: str = Field(default="07:30", env="WEEKDAY_START_TIME")
+    weekday_end_time: str = Field(default="18:30", env="WEEKDAY_END_TIME")
+    weekend_start_time: str = Field(default="10:30", env="WEEKEND_START_TIME")
+    weekend_end_time: str = Field(default="16:30", env="WEEKEND_END_TIME")
+    working_hours_timezone: str = Field(default="America/New_York", env="WORKING_HOURS_TIMEZONE")
+    
+    # Chat Settings
+    max_conversation_history: int = Field(default=20, env="MAX_CONVERSATION_HISTORY")
+    session_timeout_minutes: int = Field(default=30, env="SESSION_TIMEOUT_MINUTES")
+    
+    # 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 Voice Assistant", env="EMAIL_FROM_NAME")
+    
+    # Testing Configuration
+    testing_mode: bool = Field(default=True, env="TESTING_MODE")
+    
+    # Audio Services Configuration (Hugging Face spaces)
+    stt_service_url: str = Field(
+        default="https://huggingface.co/spaces/YOUR_USERNAME/stt-gpu-service", 
+        env="STT_SERVICE_URL"
+    )
+    tts_service_url: str = Field(
+        default="https://huggingface.co/spaces/YOUR_USERNAME/tts-gpu-service",
+        env="TTS_SERVICE_URL"
+    )
+    
+    # Voice Settings
+    default_voice: str = Field(default="v2/en_speaker_6", env="DEFAULT_VOICE")
+    enable_voice_responses: bool = Field(default=True, env="ENABLE_VOICE_RESPONSES")
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = False
+
+
+# Global config instance
+config = Config()

core/llm_provider.py

@@ -0,0 +1,147 @@
+"""
+LLM Provider - Handles different LLM services for ChatCal Voice.
+
+Implements the same fallback chain as the original ChatCal:
+Groq (primary) -> Anthropic (fallback) -> Mock (development)
+"""
+
+import logging
+from typing import Optional
+from llama_index.core.llms import LLM
+from llama_index.llms.groq import Groq
+from llama_index.llms.anthropic import Anthropic
+
+from .config import config
+
+logger = logging.getLogger(__name__)
+
+
+class MockLLM:
+    """Mock LLM for development and testing."""
+    
+    async def achat(self, messages):
+        """Mock async chat method."""
+        last_message = messages[-1].content if messages else "Hello"
+        
+        # Simple rule-based responses for development
+        if any(word in last_message.lower() for word in ["book", "schedule", "appointment"]):
+            response = "I'd be happy to help you book an appointment! Please provide your name, preferred date and time."
+        elif any(word in last_message.lower() for word in ["cancel", "delete"]):
+            response = "I can help you cancel an appointment. Could you tell me which meeting you'd like to cancel?"
+        elif any(word in last_message.lower() for word in ["available", "availability", "free"]):
+            response = "Let me check Peter's availability for you. What dates are you considering?"
+        else:
+            response = "Hello! I'm ChatCal, your voice-enabled scheduling assistant. I can help you book appointments with Peter. What would you like to schedule?"
+        
+        class MockResponse:
+            def __init__(self, content):
+                self.message = self
+                self.content = content
+        
+        return MockResponse(response)
+    
+    async def acomplete(self, prompt):
+        """Mock async completion method."""
+        class MockCompletion:
+            def __init__(self, content):
+                self.text = content
+        
+        # Mock JSON response for booking parsing
+        if "Parse this booking request" in prompt:
+            return MockCompletion('{"date_time": "2024-01-01 14:00", "duration": 30, "meeting_type": "google_meet", "topic": "Meeting", "needs_clarification": true, "clarification_message": "Could you please specify the exact date and time?"}')
+        
+        return MockCompletion("Mock response for development")
+
+
+def get_llm() -> LLM:
+    """
+    Get the appropriate LLM based on available configuration.
+    Implements fallback chain: Groq -> Anthropic -> Mock
+    """
+    
+    # Try Groq first (primary)
+    if config.groq_api_key:
+        try:
+            logger.info("🚀 Using Groq LLM (primary)")
+            return Groq(
+                model="llama-3.1-8b-instant",
+                api_key=config.groq_api_key,
+                temperature=0.1
+            )
+        except Exception as e:
+            logger.warning(f"❌ Groq LLM failed to initialize: {e}")
+    
+    # Fallback to Anthropic
+    if config.anthropic_api_key:
+        try:
+            logger.info("🧠 Using Anthropic Claude (fallback)")
+            return Anthropic(
+                model="claude-3-sonnet-20240229",
+                api_key=config.anthropic_api_key,
+                temperature=0.1
+            )
+        except Exception as e:
+            logger.warning(f"❌ Anthropic LLM failed to initialize: {e}")
+    
+    # Final fallback to Mock LLM
+    logger.warning("⚠️ Using Mock LLM (development/fallback)")
+    return MockLLM()
+
+
+class LLMService:
+    """Service wrapper for LLM operations."""
+    
+    def __init__(self):
+        self.llm = get_llm()
+        self.is_mock = isinstance(self.llm, MockLLM)
+    
+    async def chat(self, messages, temperature: float = 0.1):
+        """Send chat messages to LLM."""
+        if self.is_mock:
+            return await self.llm.achat(messages)
+        
+        # For real LLMs, set temperature if supported
+        try:
+            if hasattr(self.llm, 'temperature'):
+                original_temp = self.llm.temperature
+                self.llm.temperature = temperature
+                result = await self.llm.achat(messages)
+                self.llm.temperature = original_temp
+                return result
+            else:
+                return await self.llm.achat(messages)
+        except Exception as e:
+            logger.error(f"LLM chat error: {e}")
+            # Return a graceful error response
+            class ErrorResponse:
+                def __init__(self, content):
+                    self.message = self
+                    self.content = content
+            
+            return ErrorResponse("I apologize, but I'm having trouble processing your request right now. Please try again.")
+    
+    async def complete(self, prompt: str, temperature: float = 0.1):
+        """Send completion prompt to LLM."""
+        if self.is_mock:
+            return await self.llm.acomplete(prompt)
+        
+        try:
+            if hasattr(self.llm, 'temperature'):
+                original_temp = self.llm.temperature
+                self.llm.temperature = temperature
+                result = await self.llm.acomplete(prompt)
+                self.llm.temperature = original_temp
+                return result
+            else:
+                return await self.llm.acomplete(prompt)
+        except Exception as e:
+            logger.error(f"LLM completion error: {e}")
+            class ErrorCompletion:
+                def __init__(self, content):
+                    self.text = content
+            
+            return ErrorCompletion("Error processing request")
+
+
+# Global LLM service instance
+llm_service = LLMService()

core/session.py

@@ -0,0 +1,135 @@
+"""
+Session Data Model for ChatCal Voice.
+
+Handles conversation state, user information, and session persistence
+in the Hugging Face Gradio environment.
+"""
+
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SessionData:
+    """Data structure for user sessions."""
+    
+    session_id: str
+    created_at: datetime = field(default_factory=datetime.now)
+    last_activity: datetime = field(default_factory=datetime.now)
+    
+    # User information extracted from conversation
+    user_info: Dict[str, Any] = field(default_factory=lambda: {
+        "name": None,
+        "email": None,
+        "phone": None,
+        "preferences": {},
+        "timezone": None
+    })
+    
+    # Conversation history
+    conversation_history: List[Dict[str, str]] = field(default_factory=list)
+    
+    # Session state for multi-turn operations
+    session_state: Dict[str, Any] = field(default_factory=lambda: {
+        "pending_operation": None,  # "booking", "cancellation", "availability"
+        "operation_context": {},    # Context data for operations
+        "awaiting_clarification": False,
+        "last_voice_input": None,
+        "voice_enabled": True
+    })
+    
+    # Booking history for this session
+    booking_history: List[Dict[str, Any]] = field(default_factory=list)
+    
+    def add_message(self, role: str, content: str):
+        """Add a message to conversation history."""
+        self.conversation_history.append({
+            "role": role,  # "user" or "assistant"
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Keep only recent messages to prevent memory issues
+        max_history = 50
+        if len(self.conversation_history) > max_history:
+            self.conversation_history = self.conversation_history[-max_history:]
+        
+        self.last_activity = datetime.now()
+    
+    def get_recent_messages(self, count: int = 10) -> List[Dict[str, str]]:
+        """Get recent conversation messages."""
+        return self.conversation_history[-count:] if self.conversation_history else []
+    
+    def update_user_info(self, **kwargs):
+        """Update user information."""
+        for key, value in kwargs.items():
+            if key in self.user_info and value:
+                self.user_info[key] = value
+        self.last_activity = datetime.now()
+    
+    def has_required_user_info(self) -> bool:
+        """Check if session has minimum required user information."""
+        return (
+            bool(self.user_info.get("name")) and
+            (bool(self.user_info.get("email")) or bool(self.user_info.get("phone")))
+        )
+    
+    def get_user_summary(self) -> str:
+        """Get a summary of user information."""
+        name = self.user_info.get("name", "Unknown")
+        contact = self.user_info.get("email") or self.user_info.get("phone") or "No contact"
+        return f"{name} ({contact})"
+    
+    def set_pending_operation(self, operation: str, context: Dict[str, Any] = None):
+        """Set a pending operation with context."""
+        self.session_state["pending_operation"] = operation
+        self.session_state["operation_context"] = context or {}
+        self.session_state["awaiting_clarification"] = False
+        self.last_activity = datetime.now()
+    
+    def clear_pending_operation(self):
+        """Clear any pending operation."""
+        self.session_state["pending_operation"] = None
+        self.session_state["operation_context"] = {}
+        self.session_state["awaiting_clarification"] = False
+        self.last_activity = datetime.now()
+    
+    def add_booking(self, booking_info: Dict[str, Any]):
+        """Add a booking to the session history."""
+        booking_info["session_id"] = self.session_id
+        booking_info["timestamp"] = datetime.now().isoformat()
+        self.booking_history.append(booking_info)
+        self.last_activity = datetime.now()
+    
+    def get_session_duration_minutes(self) -> int:
+        """Get session duration in minutes."""
+        delta = datetime.now() - self.created_at
+        return int(delta.total_seconds() / 60)
+    
+    def is_expired(self, timeout_minutes: int = 30) -> bool:
+        """Check if session is expired."""
+        delta = datetime.now() - self.last_activity
+        return delta.total_seconds() > (timeout_minutes * 60)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert session to dictionary for serialization."""
+        return {
+            "session_id": self.session_id,
+            "created_at": self.created_at.isoformat(),
+            "last_activity": self.last_activity.isoformat(),
+            "user_info": self.user_info,
+            "conversation_count": len(self.conversation_history),
+            "session_state": self.session_state,
+            "booking_count": len(self.booking_history)
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SessionData':
+        """Create session from dictionary."""
+        session = cls(session_id=data["session_id"])
+        session.created_at = datetime.fromisoformat(data["created_at"])
+        session.last_activity = datetime.fromisoformat(data["last_activity"])
+        session.user_info = data.get("user_info", {})
+        session.session_state = data.get("session_state", {})
+        return session

core/session_manager.py

@@ -0,0 +1,95 @@
+"""
+Session Manager for ChatCal Voice - Handles user sessions in Gradio environment.
+
+Since we're on Hugging Face without persistent storage, we'll use in-memory
+session management with automatic cleanup.
+"""
+
+import time
+import uuid
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+
+from .session import SessionData
+from .config import config
+
+
+class SessionManager:
+    """Manages user sessions for the voice-enabled ChatCal."""
+    
+    def __init__(self):
+        self.sessions: Dict[str, SessionData] = {}
+        self.last_cleanup = time.time()
+        self.cleanup_interval = 300  # 5 minutes
+    
+    async def get_session(self, session_id: Optional[str] = None) -> SessionData:
+        """Get or create a session."""
+        # Auto-cleanup old sessions periodically
+        await self._cleanup_expired_sessions()
+        
+        # Create new session if none provided
+        if not session_id:
+            session_id = self._generate_session_id()
+        
+        # Return existing session or create new one
+        if session_id in self.sessions:
+            session = self.sessions[session_id]
+            session.last_activity = datetime.now()
+            return session
+        
+        # Create new session
+        session = SessionData(session_id=session_id)
+        self.sessions[session_id] = session
+        return session
+    
+    def _generate_session_id(self) -> str:
+        """Generate a unique session ID."""
+        timestamp = int(time.time())
+        unique_id = str(uuid.uuid4())[:8]
+        return f"chatcal_{timestamp}_{unique_id}"
+    
+    async def _cleanup_expired_sessions(self):
+        """Clean up expired sessions."""
+        current_time = time.time()
+        
+        # Only run cleanup periodically
+        if current_time - self.last_cleanup < self.cleanup_interval:
+            return
+        
+        cutoff_time = datetime.now() - timedelta(minutes=config.session_timeout_minutes)
+        expired_sessions = [
+            session_id for session_id, session in self.sessions.items()
+            if session.last_activity < cutoff_time
+        ]
+        
+        for session_id in expired_sessions:
+            del self.sessions[session_id]
+        
+        if expired_sessions:
+            print(f"🧹 Cleaned up {len(expired_sessions)} expired sessions")
+        
+        self.last_cleanup = current_time
+    
+    async def delete_session(self, session_id: str):
+        """Delete a specific session."""
+        if session_id in self.sessions:
+            del self.sessions[session_id]
+    
+    def get_session_count(self) -> int:
+        """Get the number of active sessions."""
+        return len(self.sessions)
+    
+    def get_session_stats(self) -> Dict[str, Any]:
+        """Get session statistics."""
+        return {
+            "active_sessions": len(self.sessions),
+            "total_messages": sum(len(s.conversation_history) for s in self.sessions.values()),
+            "sessions_with_user_info": sum(
+                1 for s in self.sessions.values() 
+                if s.user_info.get("name") or s.user_info.get("email")
+            )
+        }
+
+
+# Global session manager instance
+session_manager = SessionManager()

requirements.txt

@@ -0,0 +1,43 @@
+# Core Gradio and web framework
+gradio==4.44.0
+fastapi==0.104.0
+uvicorn==0.24.0
+httpx==0.25.0
+
+# LLM and AI libraries
+llama-index==0.11.0
+llama-index-llms-groq==0.2.0
+llama-index-llms-anthropic==0.3.0
+llama-index-llms-gemini==0.3.0
+google-generativeai==0.5.2
+llama-index-tools-google==0.2.0
+
+# Google Calendar and Cloud services
+google-api-python-client==2.100.0
+google-auth==2.23.0
+google-auth-oauthlib==1.1.0
+google-auth-httplib2==0.2.0
+google-cloud-secret-manager==2.20.0
+
+# Data validation and parsing
+pydantic==2.4.0
+pydantic-settings==2.0.0
+python-dateutil==2.8.2
+pytz==2023.3
+
+# Audio processing and WebRTC support
+numpy>=1.24.0
+scipy>=1.10.0
+librosa>=0.10.0
+soundfile>=0.12.0
+
+# Gradio client for external service calls
+gradio-client>=0.7.0
+
+# Utilities
+python-dotenv==1.0.0
+python-multipart==0.0.6
+python-jose==3.3.0
+redis==5.0.0
+
+# Email support (smtplib is built-in)

test_basic.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Basic test script to verify ChatCal Voice structure.
+Run this to check if all imports work and basic functionality is available.
+"""
+
+import os
+import sys
+import asyncio
+from datetime import datetime
+
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+def test_imports():
+    """Test that all core modules import correctly."""
+    print("🔍 Testing imports...")
+    
+    try:
+        from core.config import config
+        print("✅ Config imported successfully")
+        
+        from core.session import SessionData
+        print("✅ SessionData imported successfully")
+        
+        from core.session_manager import SessionManager
+        print("✅ SessionManager imported successfully")
+        
+        from core.llm_provider import get_llm
+        print("✅ LLM Provider imported successfully")
+        
+        from core.chat_agent import ChatCalAgent
+        print("✅ ChatCalAgent imported successfully")
+        
+        from core.calendar_service import CalendarService
+        print("✅ CalendarService imported successfully")
+        
+        from core.audio_handler import AudioHandler
+        print("✅ AudioHandler imported successfully")
+        
+        print("🎉 All imports successful!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Import error: {e}")
+        return False
+
+def test_basic_functionality():
+    """Test basic functionality of core components."""
+    print("\n🧪 Testing basic functionality...")
+    
+    try:
+        # Test config
+        from core.config import config
+        print(f"📋 App Name: {config.app_name}")
+        print(f"📋 Default Voice: {config.default_voice}")
+        
+        # Test session creation
+        from core.session import SessionData
+        session = SessionData(session_id="test_session")
+        session.add_message("user", "Hello test")
+        print(f"💬 Session created with {len(session.conversation_history)} messages")
+        
+        # Test LLM provider
+        from core.llm_provider import get_llm
+        llm = get_llm()
+        print(f"🤖 LLM initialized: {type(llm).__name__}")
+        
+        # Test calendar service
+        from core.calendar_service import CalendarService
+        calendar = CalendarService()
+        print(f"📅 Calendar service initialized (demo_mode: {calendar.demo_mode})")
+        
+        # Test audio handler
+        from core.audio_handler import AudioHandler
+        audio = AudioHandler()
+        status = audio.get_audio_status()
+        print(f"🎵 Audio handler initialized (demo_mode: {status['demo_mode']})")
+        
+        print("🎉 Basic functionality tests passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Functionality test error: {e}")
+        return False
+
+async def test_chat_agent():
+    """Test the chat agent with a simple message."""
+    print("\n💬 Testing chat agent...")
+    
+    try:
+        from core.chat_agent import ChatCalAgent
+        from core.session import SessionData
+        
+        agent = ChatCalAgent()
+        session = SessionData(session_id="test_chat")
+        
+        # Test message processing
+        response = await agent.process_message("Hello, I'm John", session)
+        print(f"🤖 Agent response: {response[:100]}...")
+        
+        print(f"👤 User info extracted: {session.user_info}")
+        print("🎉 Chat agent test passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Chat agent test error: {e}")
+        return False
+
+def test_gradio_compatibility():
+    """Test Gradio compatibility."""
+    print("\n🎨 Testing Gradio compatibility...")
+    
+    try:
+        import gradio as gr
+        print(f"✅ Gradio version: {gr.__version__}")
+        
+        # Test basic Gradio components
+        with gr.Blocks() as demo:
+            gr.Markdown("# Test Interface")
+            chatbot = gr.Chatbot()
+            msg = gr.Textbox(label="Message")
+            
+        print("✅ Gradio interface creation successful")
+        print("🎉 Gradio compatibility test passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Gradio compatibility error: {e}")
+        return False
+
+async def main():
+    """Run all tests."""
+    print("🚀 ChatCal Voice - Basic Structure Test")
+    print("=" * 50)
+    
+    # Set minimal environment for testing
+    os.environ.setdefault("GROQ_API_KEY", "test_key")
+    os.environ.setdefault("MY_PHONE_NUMBER", "+1-555-123-4567")
+    os.environ.setdefault("MY_EMAIL_ADDRESS", "test@example.com")
+    os.environ.setdefault("SECRET_KEY", "test_secret")
+    
+    tests = [
+        ("Imports", test_imports),
+        ("Basic Functionality", test_basic_functionality),
+        ("Chat Agent", test_chat_agent),
+        ("Gradio Compatibility", test_gradio_compatibility)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        print(f"\n{'='*20} {test_name} {'='*20}")
+        try:
+            if asyncio.iscoroutinefunction(test_func):
+                result = await test_func()
+            else:
+                result = test_func()
+            
+            if result:
+                passed += 1
+        except Exception as e:
+            print(f"❌ {test_name} failed with exception: {e}")
+    
+    print(f"\n{'='*50}")
+    print(f"🏁 Test Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! ChatCal Voice structure is ready.")
+        print("\n🚀 Next steps:")
+        print("1. Update STT_SERVICE_URL and TTS_SERVICE_URL in .env")
+        print("2. Add your actual API keys")
+        print("3. Deploy to Hugging Face Spaces")
+    else:
+        print("❌ Some tests failed. Check the errors above.")
+        return False
+    
+    return True
+
+if __name__ == "__main__":
+    asyncio.run(main())