Upload 3 files

app.py

@@ -0,0 +1,1306 @@
+#!/usr/bin/env python3
+"""
+GlycoAI - AI-Powered Glucose Insights
+Complete application with Demo Users + Dexcom Sandbox OAuth
+IMPROVED UI VERSION - Clean, readable design with blue theme
+"""
+
+import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta
+import pandas as pd
+from typing import Optional, Tuple, List
+import logging
+import os
+
+# Load environment variables from .env file
+from dotenv import load_dotenv
+load_dotenv()
+
+# Import the Mistral chat class and unified data manager
+from mistral_chat import GlucoBuddyMistralChat, validate_environment
+from unified_data_manager import UnifiedDataManager
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import our custom functions
+from apifunctions import (
+    DexcomAPI,
+    GlucoseAnalyzer,
+    DEMO_USERS,
+    format_glucose_data_for_display
+)
+
+# Import Dexcom Sandbox OAuth
+try:
+    from dexcom_sandbox_oauth import DexcomSandboxIntegration, DexcomSandboxUser
+    DEXCOM_SANDBOX_AVAILABLE = True
+    logger.info("✅ Dexcom Sandbox OAuth available")
+except ImportError as e:
+    DEXCOM_SANDBOX_AVAILABLE = False
+    logger.warning(f"⚠️ Dexcom Sandbox OAuth not available: {e}")
+
+class GlycoAIApp:
+    """Main application class for GlycoAI with demo users AND Dexcom Sandbox OAuth"""
+
+    def __init__(self):
+        # Validate environment before initializing
+        if not validate_environment():
+            raise ValueError("Environment validation failed - check your .env file or environment variables")
+        
+        # Single data manager for consistency
+        self.data_manager = UnifiedDataManager()
+        
+        # Chat interface (will use data manager's context)
+        self.mistral_chat = GlucoBuddyMistralChat()
+        
+        # Dexcom Sandbox OAuth API
+        self.dexcom_sandbox = DexcomSandboxIntegration() if DEXCOM_SANDBOX_AVAILABLE else None
+        
+        # UI state
+        self.chat_history = []
+        self.current_user_type = None  # "demo" or "dexcom_sandbox"
+
+    def select_demo_user(self, user_key: str) -> Tuple[str, str]:
+        """Handle demo user selection and load data consistently"""
+        if user_key not in DEMO_USERS:
+            return "❌ Invalid user selection", gr.update(visible=False)
+
+        try:
+            # Load data through unified manager
+            load_result = self.data_manager.load_user_data(user_key)
+            
+            if not load_result['success']:
+                return f"❌ {load_result['message']}", gr.update(visible=False)
+            
+            user = self.data_manager.current_user
+            self.current_user_type = "demo"
+            
+            # Update Mistral chat with the same context
+            self._sync_chat_with_data_manager()
+            
+            # Clear chat history when switching users
+            self.chat_history = []
+            self.mistral_chat.clear_conversation()
+
+            return (
+                f"✅ Connected: {user.name} ({user.device_type}) - Demo Data", 
+                gr.update(visible=True)
+            )
+
+        except Exception as e:
+            logger.error(f"Demo user selection failed: {str(e)}")
+            return f"❌ Connection failed: {str(e)}", gr.update(visible=False)
+
+    def initialize_chat_with_prompts(self) -> List:
+        """Initialize chat with demo prompts as conversation bubbles"""
+        if not self.data_manager.current_user:
+            return [
+                [None, "👋 Welcome to GlycoAI! Please select a demo user or connect Dexcom Sandbox to get started."],
+                [None, "💡 Once you load your glucose data, I'll provide personalized insights about your patterns and trends."]
+            ]
+        
+        templates = self.get_template_prompts()
+        
+        # Create initial conversation with demo prompts
+        initial_chat = [
+            [None, f"👋 Hi! I'm ready to analyze {self.data_manager.current_user.name}'s glucose data. Here are some quick ways to get started:"],
+            [None, f"🎯 **{templates[0] if templates else 'Analyze my recent glucose patterns and trends'}**"],
+            [None, f"⚡ **{templates[1] if len(templates) > 1 else 'What can I do to improve my glucose control?'}**"],
+            [None, f"🍽️ **What are some meal management strategies for better glucose control?**"],
+            [None, "💬 You can click on any of these questions above, or ask me anything about glucose management!"]
+        ]
+        
+        return initial_chat
+
+    def handle_demo_prompt_click(self, prompt_text: str, history: List) -> Tuple[str, List]:
+        """Handle clicking on demo prompts in chat"""
+        # Remove the emoji and formatting from the prompt
+        clean_prompt = prompt_text.replace("🎯 **", "").replace("⚡ **", "").replace("🍽️ **", "").replace("**", "")
+        
+        # Process the prompt as if user typed it
+        return self.chat_with_mistral(clean_prompt, history)
+
+    def start_dexcom_sandbox_oauth(self) -> str:
+        """Start Dexcom Sandbox OAuth process"""
+        if not DEXCOM_SANDBOX_AVAILABLE:
+            return """
+❌ **Dexcom Sandbox OAuth Not Available**
+
+The Dexcom Sandbox authentication module is not properly configured.
+Please ensure:
+1. dexcom_sandbox_oauth.py exists and imports correctly
+2. You have valid Dexcom developer credentials
+3. All dependencies are installed
+
+For now, please use the demo users above for instant access to realistic glucose data.
+            """
+        
+        try:
+            # Start OAuth flow for Dexcom Sandbox
+            auth_url = self.dexcom_sandbox.oauth.generate_auth_url()
+            
+            # Try to open browser automatically
+            try:
+                import webbrowser
+                webbrowser.open(auth_url)
+                browser_status = "✅ Browser opened automatically"
+            except:
+                browser_status = "⚠️ Please open the URL manually"
+            
+            return f"""
+🚀 **Dexcom Sandbox OAuth Started**
+
+{browser_status}
+
+**🌐 OAuth URL:** {auth_url}
+
+**Step-by-Step Instructions:**
+1. Browser should open automatically (or open URL above)
+2. Select a sandbox user from the dropdown (SandboxUser6 recommended)
+3. Click "Authorize" to grant access
+4. **You will get a 404 error - THIS IS EXPECTED!**
+5. Copy the COMPLETE callback URL from address bar
+
+**Example callback URL:**
+`http://localhost:7860/callback?code=ABC123XYZ&state=sandbox_test`
+
+**Important:** Copy the entire URL (not just the code part)!
+                """
+                
+        except Exception as e:
+            logger.error(f"Dexcom Sandbox OAuth start error: {e}")
+            return f"❌ OAuth error: {str(e)}"
+
+    def complete_dexcom_sandbox_oauth(self, callback_url_input: str) -> Tuple[str, str]:
+        """Complete Dexcom Sandbox OAuth with full callback URL"""
+        if not DEXCOM_SANDBOX_AVAILABLE:
+            return "❌ Dexcom Sandbox OAuth not available", gr.update(visible=False)
+        
+        if not callback_url_input or not callback_url_input.strip():
+            return "❌ Please paste the complete callback URL", gr.update(visible=False)
+        
+        try:
+            callback_url = callback_url_input.strip()
+            
+            logger.info(f"Processing Dexcom Sandbox callback: {callback_url[:50]}...")
+            
+            # Use Dexcom Sandbox OAuth completion
+            status_message, show_interface = self.dexcom_sandbox.complete_oauth(callback_url)
+            
+            if show_interface:
+                logger.info("✅ Dexcom Sandbox OAuth successful")
+                
+                # Load Dexcom Sandbox data into data manager
+                sandbox_data_result = self._load_dexcom_sandbox_data()
+                
+                if sandbox_data_result['success']:
+                    self.current_user_type = "dexcom_sandbox"
+                    
+                    # Update chat context
+                    self._sync_chat_with_data_manager()
+                    
+                    # Clear chat history for new user
+                    self.chat_history = []
+                    self.mistral_chat.clear_conversation()
+                    
+                    return (
+                        f"✅ Connected: Dexcom Sandbox User - OAuth Authenticated",
+                        gr.update(visible=True)
+                    )
+                else:
+                    return f"❌ Dexcom Sandbox data loading failed: {sandbox_data_result['message']}", gr.update(visible=False)
+            else:
+                logger.error(f"Dexcom Sandbox OAuth failed: {status_message}")
+                return f"❌ {status_message}", gr.update(visible=False)
+                
+        except Exception as e:
+            logger.error(f"Dexcom Sandbox OAuth completion error: {e}")
+            return f"❌ OAuth completion failed: {str(e)}", gr.update(visible=False)
+
+    def _load_dexcom_sandbox_data(self) -> dict:
+        """Load Dexcom Sandbox data through the unified data manager"""
+        try:
+            # Get Dexcom Sandbox user profile
+            sandbox_profile = self.dexcom_sandbox.get_user_profile()
+            
+            if not sandbox_profile:
+                return {
+                    'success': False,
+                    'message': 'No Dexcom Sandbox user profile available'
+                }
+            
+            # Set in data manager (compatible with existing structure)
+            self.data_manager.current_user = sandbox_profile
+            self.data_manager.data_source = "dexcom_sandbox_oauth"
+            self.data_manager.data_loaded_at = datetime.now()
+            
+            logger.info("✅ Dexcom Sandbox data integrated with data manager")
+            
+            return {
+                'success': True,
+                'message': 'Dexcom Sandbox user profile loaded successfully'
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to load Dexcom Sandbox data: {e}")
+            return {
+                'success': False,
+                'message': f'Failed to load OAuth data: {str(e)}'
+            }
+
+    def load_glucose_data(self) -> Tuple[str, go.Figure, str]:
+        """Load and display glucose data using unified manager with notifications"""
+        if not self.data_manager.current_user:
+            return "Please select a user first (demo or Dexcom Sandbox)", None, ""
+
+        try:
+            # For Dexcom Sandbox users, load real data via OAuth
+            if self.current_user_type == "dexcom_sandbox":
+                overview, chart = self._load_dexcom_sandbox_glucose_data()
+            else:
+                # For demo users, force reload data to ensure freshness
+                load_result = self.data_manager.load_user_data(
+                    self._get_current_user_key(), 
+                    force_reload=True
+                )
+                
+                if not load_result['success']:
+                    return load_result['message'], None, ""
+                
+                # Get unified stats and build display
+                overview, chart = self._build_glucose_display()
+            
+            # Create notification message based on user and data quality
+            notification = self._create_data_loaded_notification()
+            
+            return overview, chart, notification
+            
+        except Exception as e:
+            logger.error(f"Failed to load glucose data: {str(e)}")
+            return f"Failed to load glucose data: {str(e)}", None, ""
+
+    def _create_data_loaded_notification(self) -> str:
+        """Create appropriate notification based on loaded data"""
+        if not self.data_manager.current_user or not self.data_manager.calculated_stats:
+            return ""
+        
+        user_name = self.data_manager.current_user.name
+        stats = self.data_manager.calculated_stats
+        
+        tir = stats.get('time_in_range_70_180', 0)
+        cv = stats.get('cv', 0)
+        avg_glucose = stats.get('average_glucose', 0)
+        total_readings = stats.get('total_readings', 0)
+        
+        # Special handling for Sarah (unstable patterns)
+        if user_name == "Sarah Thompson":
+            if tir < 50 and cv > 40:
+                notification = f"""
+🚨 **DATA LOADED - CONCERNING PATTERNS DETECTED**
+
+**Patient:** {user_name} ({total_readings:,} readings analyzed)
+
+**⚠️ Critical Findings:**
+• Time in Range: {tir:.1f}% (Target: >70%)
+• High Variability: CV {cv:.1f}% (Target: <36%)
+• Average Glucose: {avg_glucose:.1f} mg/dL
+
+**🔥 Immediate Action Required**
+• Frequent hypoglycemia detected
+• Severe glucose instability
+• Healthcare provider consultation recommended
+
+*AI analysis ready - Click Chat tab for urgent insights*
+                """
+            else:
+                notification = f"""
+✅ **DATA LOADED SUCCESSFULLY**
+
+**Patient:** {user_name} ({total_readings:,} readings analyzed)
+**Time in Range:** {tir:.1f}% | **Average:** {avg_glucose:.1f} mg/dL
+
+*14-day analysis complete - Ready for AI insights*
+                """
+        else:
+            # For other users with better control
+            if tir >= 70:
+                notification = f"""
+✅ **DATA LOADED - EXCELLENT CONTROL**
+
+**Patient:** {user_name} ({total_readings:,} readings analyzed)
+**Time in Range:** {tir:.1f}% ✅ | **CV:** {cv:.1f}%
+
+*Great glucose management - AI ready to help maintain control*
+                """
+            else:
+                notification = f"""
+📊 **DATA LOADED SUCCESSFULLY**
+
+**Patient:** {user_name} ({total_readings:,} readings analyzed)
+**Time in Range:** {tir:.1f}% | **Average:** {avg_glucose:.1f} mg/dL
+
+*Analysis complete - AI ready to provide insights*
+                """
+        
+        return notification
+
+    def _load_dexcom_sandbox_glucose_data(self) -> Tuple[str, go.Figure]:
+        """Load Dexcom Sandbox glucose data via OAuth"""
+        if not self.dexcom_sandbox.authenticated:
+            return "❌ Dexcom Sandbox not authenticated. Please complete OAuth first.", None
+        
+        try:
+            # Load 14 days of data from Dexcom Sandbox
+            data_result = self.dexcom_sandbox.load_glucose_data(days=14)
+            
+            if not data_result['success']:
+                return f"❌ {data_result['error']}", None
+            
+            # Convert Dexcom Sandbox data to data manager format
+            self._convert_dexcom_sandbox_to_dataframe()
+            
+            return self._build_glucose_display()
+            
+        except Exception as e:
+            logger.error(f"Failed to load Dexcom Sandbox data: {e}")
+            return f"❌ Failed to load Dexcom Sandbox data: {str(e)}", None
+
+    def _convert_dexcom_sandbox_to_dataframe(self):
+        """Convert Dexcom Sandbox glucose data to DataFrame format"""
+        try:
+            glucose_data = self.dexcom_sandbox.get_glucose_data_for_ui()
+            
+            if not glucose_data:
+                raise Exception("No glucose data available from Dexcom Sandbox")
+            
+            # Convert to DataFrame
+            df = pd.DataFrame(glucose_data)
+            
+            # Ensure proper datetime conversion
+            df['systemTime'] = pd.to_datetime(df['systemTime'])
+            df['displayTime'] = pd.to_datetime(df['displayTime'])
+            df['value'] = pd.to_numeric(df['value'], errors='coerce')
+            
+            # Sort by time
+            df = df.sort_values('systemTime')
+            
+            # Set in data manager
+            self.data_manager.processed_glucose_data = df
+            
+            # Calculate statistics using existing analyzer
+            self.data_manager.calculated_stats = self.data_manager._calculate_unified_stats()
+            self.data_manager.identified_patterns = GlucoseAnalyzer.identify_patterns(df)
+            
+            logger.info(f"✅ Converted {len(df)} Dexcom Sandbox readings to DataFrame")
+            
+        except Exception as e:
+            logger.error(f"Failed to convert Dexcom Sandbox data: {e}")
+            raise
+
+    def _build_glucose_display(self) -> Tuple[str, go.Figure]:
+        """Build glucose data display (common for demo and Dexcom Sandbox)"""
+        # Get unified stats
+        stats = self.data_manager.get_stats_for_ui()
+        chart_data = self.data_manager.get_chart_data()
+        
+        # Sync chat with fresh data
+        self._sync_chat_with_data_manager()
+        
+        if chart_data is None or chart_data.empty:
+            return "No glucose data available", None
+
+        # Build data summary with CONSISTENT metrics
+        user = self.data_manager.current_user
+        data_points = stats.get('total_readings', 0)
+        avg_glucose = stats.get('average_glucose', 0)
+        std_glucose = stats.get('std_glucose', 0)
+        min_glucose = stats.get('min_glucose', 0)
+        max_glucose = stats.get('max_glucose', 0)
+        
+        time_in_range = stats.get('time_in_range_70_180', 0)
+        time_below_range = stats.get('time_below_70', 0)
+        time_above_range = stats.get('time_above_180', 0)
+        
+        gmi = stats.get('gmi', 0)
+        cv = stats.get('cv', 0)
+        
+        # Calculate date range
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=14)
+        
+        # Determine data source
+        if self.current_user_type == "dexcom_sandbox":
+            data_source = "Dexcom Sandbox OAuth"
+            oauth_status = "✅ Authenticated Dexcom Sandbox with working OAuth"
+        else:
+            data_source = "Demo Data"
+            oauth_status = "🎭 Using demo data for testing"
+        
+        data_summary = f"""
+## 📊 Data Summary for {user.name}
+
+### Basic Information
+• **Data Type:** {data_source}
+• **Analysis Period:** {start_date.strftime('%B %d, %Y')} to {end_date.strftime('%B %d, %Y')} (14 days)
+• **Total Readings:** {data_points:,} glucose measurements
+• **Device:** {user.device_type}
+
+### Glucose Statistics
+• **Average Glucose:** {avg_glucose:.1f} mg/dL
+• **Standard Deviation:** {std_glucose:.1f} mg/dL
+• **Coefficient of Variation:** {cv:.1f}%
+• **Glucose Range:** {min_glucose:.0f} - {max_glucose:.0f} mg/dL
+• **GMI (Glucose Management Indicator):** {gmi:.1f}%
+
+### Time in Range Analysis
+• **Time in Range (70-180 mg/dL):** {time_in_range:.1f}%
+• **Time Below Range (<70 mg/dL):** {time_below_range:.1f}%
+• **Time Above Range (>180 mg/dL):** {time_above_range:.1f}%
+
+### Clinical Targets
+• **Target Time in Range:** >70% (Current: {time_in_range:.1f}%)
+• **Target Time Below Range:** <4% (Current: {time_below_range:.1f}%)
+• **Target CV:** <36% (Current: {cv:.1f}%)
+
+### Authentication Status
+• **User Type:** {self.current_user_type.upper() if self.current_user_type else 'Unknown'}
+• **OAuth Status:** {oauth_status}
+        """
+
+        chart = self.create_glucose_chart()
+        
+        return data_summary, chart
+
+    def _sync_chat_with_data_manager(self):
+        """Ensure chat uses the same data as the UI"""
+        try:
+            # Get context from unified data manager
+            context = self.data_manager.get_context_for_agent()
+            
+            # Update chat's internal data to match
+            if not context.get("error"):
+                self.mistral_chat.current_user = self.data_manager.current_user
+                self.mistral_chat.current_glucose_data = self.data_manager.processed_glucose_data
+                self.mistral_chat.current_stats = self.data_manager.calculated_stats
+                self.mistral_chat.current_patterns = self.data_manager.identified_patterns
+                
+                logger.info(f"Synced chat with data manager - TIR: {self.data_manager.calculated_stats.get('time_in_range_70_180', 0):.1f}%")
+            
+        except Exception as e:
+            logger.error(f"Failed to sync chat with data manager: {e}")
+
+    def _get_current_user_key(self) -> str:
+        """Get the current user key"""
+        if not self.data_manager.current_user:
+            return ""
+        
+        # Find the key for current user
+        for key, user in DEMO_USERS.items():
+            if user == self.data_manager.current_user:
+                return key
+        return ""
+
+    def get_template_prompts(self) -> List[str]:
+        """Get template prompts based on current user data"""
+        if not self.data_manager.current_user or not self.data_manager.calculated_stats:
+            return [
+                "What should I know about managing my diabetes?",
+                "How can I improve my glucose control?"
+            ]
+
+        stats = self.data_manager.calculated_stats
+        time_in_range = stats.get('time_in_range_70_180', 0)
+        time_below_70 = stats.get('time_below_70', 0)
+
+        templates = []
+
+        if time_in_range < 70:
+            templates.append(f"My time in range is {time_in_range:.1f}% which is below the 70% target. What specific strategies can help me improve it?")
+        else:
+            templates.append(f"My time in range is {time_in_range:.1f}% which meets the target. How can I maintain this level of control?")
+
+        if time_below_70 > 4:
+            templates.append(f"I'm experiencing {time_below_70:.1f}% time below 70 mg/dL. What can I do to prevent these low episodes?")
+        else:
+            templates.append("What are the best practices for preventing hypoglycemia in my situation?")
+
+        # Add data source specific template
+        if self.current_user_type == "dexcom_sandbox":
+            templates.append("This is my Dexcom Sandbox OAuth-authenticated data. What insights can you provide about these glucose patterns?")
+        else:
+            templates.append("Based on this demo data, what would you recommend for someone with similar patterns?")
+
+        return templates
+
+    def chat_with_mistral(self, message: str, history: List) -> Tuple[str, List]:
+        """Handle chat interaction with Mistral using unified data"""
+        if not message.strip():
+            return "", history
+
+        if not self.data_manager.current_user:
+            response = "Please select a user first (demo or Dexcom Sandbox) to get personalized insights about glucose data."
+            history.append([message, response])
+            return "", history
+
+        try:
+            # Ensure chat is synced with latest data
+            self._sync_chat_with_data_manager()
+            
+            # Send message to Mistral chat
+            result = self.mistral_chat.chat_with_mistral(message)
+            
+            if result['success']:
+                response = result['response']
+                
+                # Add data consistency note
+                validation = self.data_manager.validate_data_consistency()
+                if validation.get('valid'):
+                    data_age = validation.get('data_age_minutes', 0)
+                    if data_age > 10:  # Warn if data is old
+                        response += f"\n\n📊 *Note: Analysis based on data from {data_age} minutes ago. Reload data for most current insights.*"
+                
+                # Add data source context
+                if self.current_user_type == "dexcom_sandbox":
+                    response += f"\n\n🔐 *This analysis is based on your OAuth-authenticated Dexcom Sandbox data.*"
+                else:
+                    response += f"\n\n🎭 *This analysis is based on demo data for testing purposes.*"
+                
+                # Add context note if no user data was included
+                if not result.get('context_included', True):
+                    response += f"\n\n💡 *For more personalized advice, make sure your glucose data is loaded.*"
+            else:
+                response = f"I apologize, but I encountered an error: {result.get('error', 'Unknown error')}. Please try again or rephrase your question."
+
+            history.append([message, response])
+            return "", history
+
+        except Exception as e:
+            logger.error(f"Chat error: {str(e)}")
+            error_response = f"I apologize, but I encountered an error while processing your question: {str(e)}. Please try rephrasing your question."
+            history.append([message, error_response])
+            return "", history
+
+    def clear_chat_history(self) -> List:
+        """Clear chat history"""
+        self.chat_history = []
+        self.mistral_chat.clear_conversation()
+        return []
+
+    def create_glucose_chart(self) -> Optional[go.Figure]:
+        """Create an interactive glucose chart using unified data"""
+        chart_data = self.data_manager.get_chart_data()
+        
+        if chart_data is None or chart_data.empty:
+            return None
+
+        fig = go.Figure()
+
+        # Color code based on glucose ranges
+        colors = []
+        for value in chart_data['value']:
+            if value < 70:
+                colors.append('#E74C3C')  # Red for low
+            elif value > 180:
+                colors.append('#F39C12')  # Orange for high
+            else:
+                colors.append('#3498DB')  # Blue for in range
+
+        fig.add_trace(go.Scatter(
+            x=chart_data['systemTime'],
+            y=chart_data['value'],
+            mode='lines+markers',
+            name='Glucose',
+            line=dict(color='#2980B9', width=2),
+            marker=dict(size=4, color=colors),
+            hovertemplate='<b>%{y} mg/dL</b><br>%{x}<extra></extra>'
+        ))
+
+        # Add target range shading
+        fig.add_hrect(
+            y0=70, y1=180,
+            fillcolor="rgba(52, 152, 219, 0.1)",
+            layer="below",
+            line_width=0,
+            annotation_text="Target Range",
+            annotation_position="top left"
+        )
+
+        # Add reference lines
+        fig.add_hline(y=70, line_dash="dash", line_color="#E67E22",
+                     annotation_text="Low (70 mg/dL)", annotation_position="right")
+        fig.add_hline(y=180, line_dash="dash", line_color="#E67E22",
+                     annotation_text="High (180 mg/dL)", annotation_position="right")
+        fig.add_hline(y=54, line_dash="dot", line_color="#E74C3C",
+                     annotation_text="Severe Low (54 mg/dL)", annotation_position="right")
+        fig.add_hline(y=250, line_dash="dot", line_color="#E74C3C",
+                     annotation_text="Severe High (250 mg/dL)", annotation_position="right")
+
+        # Get current stats for title
+        stats = self.data_manager.get_stats_for_ui()
+        tir = stats.get('time_in_range_70_180', 0)
+        
+        if self.current_user_type == "dexcom_sandbox":
+            data_type = "Dexcom Sandbox"
+        else:
+            data_type = "Demo Data"
+        
+        fig.update_layout(
+            title={
+                'text': f"14-Day Glucose Trends - {self.data_manager.current_user.name} ({data_type} - TIR: {tir:.1f}%)",
+                'x': 0.5,
+                'xanchor': 'center'
+            },
+            xaxis_title="Time",
+            yaxis_title="Glucose (mg/dL)",
+            hovermode='x unified',
+            height=500,
+            showlegend=False,
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            font=dict(size=12),
+            margin=dict(l=60, r=60, t=80, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)')
+        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)')
+
+        return fig
+
+
+def create_interface():
+    """Create the Gradio interface with improved, cleaner design"""
+    app = GlycoAIApp()
+
+    # Clean blue-themed CSS
+    custom_css = """
+    /* Main header styling */
+    .main-header {
+        text-align: center;
+        background: linear-gradient(135deg, #3498db 0%, #2980b9 100%);
+        color: white;
+        padding: 2rem;
+        border-radius: 12px;
+        margin-bottom: 2rem;
+        box-shadow: 0 4px 20px rgba(52, 152, 219, 0.3);
+    }
+    
+    /* Demo user buttons - consistent size and light blue */
+    .demo-user-btn {
+        background: linear-gradient(135deg, #85c1e9 0%, #5dade2 100%) !important;
+        border: none !important;
+        border-radius: 8px !important;
+        padding: 1rem !important;
+        font-size: 0.95rem !important;
+        font-weight: 600 !important;
+        color: white !important;
+        box-shadow: 0 3px 12px rgba(93, 173, 226, 0.3) !important;
+        transition: all 0.3s ease !important;
+        min-height: 80px !important;
+        text-align: center !important;
+        width: 100% !important;
+    }
+    
+    .demo-user-btn:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 0 6px 20px rgba(93, 173, 226, 0.4) !important;
+        background: linear-gradient(135deg, #7fb3d3 0%, #5499c7 100%) !important;
+    }
+    
+    /* Dexcom OAuth button - smaller and distinct */
+    .dexcom-oauth-btn {
+        background: linear-gradient(135deg, #2980b9 0%, #1f618d 100%) !important;
+        border: none !important;
+        border-radius: 8px !important;
+        padding: 0.8rem 1.5rem !important;
+        font-size: 0.9rem !important;
+        font-weight: 600 !important;
+        color: white !important;
+        box-shadow: 0 3px 12px rgba(41, 128, 185, 0.3) !important;
+        transition: all 0.3s ease !important;
+        text-align: center !important;
+    }
+    
+    .dexcom-oauth-btn:hover {
+        transform: translateY(-1px) !important;
+        box-shadow: 0 5px 16px rgba(41, 128, 185, 0.4) !important;
+    }
+    
+    /* Prominent load data button */
+    .load-data-btn {
+        background: linear-gradient(135deg, #3498db 0%, #2980b9 100%) !important;
+        border: none !important;
+        border-radius: 12px !important;
+        padding: 1.5rem 2rem !important;
+        font-size: 1.1rem !important;
+        font-weight: bold !important;
+        color: white !important;
+        box-shadow: 0 6px 24px rgba(52, 152, 219, 0.4) !important;
+        transition: all 0.3s ease !important;
+        min-height: 80px !important;
+        text-align: center !important;
+    }
+    
+    .load-data-btn:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 0 8px 32px rgba(52, 152, 219, 0.5) !important;
+    }
+    
+    /* Tab styling - more visible */
+    .gradio-tabs .tab-nav {
+        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%) !important;
+        border-radius: 8px !important;
+        padding: 0.5rem !important;
+        margin-bottom: 1rem !important;
+    }
+    
+    .gradio-tabs .tab-nav button {
+        background: white !important;
+        border: 1px solid #90caf9 !important;
+        border-radius: 6px !important;
+        margin: 0 0.25rem !important;
+        padding: 0.75rem 1.5rem !important;
+        font-weight: 600 !important;
+        color: #1565c0 !important;
+        transition: all 0.3s ease !important;
+    }
+    
+    .gradio-tabs .tab-nav button:hover {
+        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%) !important;
+        transform: translateY(-1px) !important;
+    }
+    
+    .gradio-tabs .tab-nav button.selected {
+        background: linear-gradient(135deg, #3498db 0%, #2980b9 100%) !important;
+        color: white !important;
+        border-color: #2980b9 !important;
+        box-shadow: 0 3px 12px rgba(52, 152, 219, 0.3) !important;
+    }
+    
+    /* Chat bubble styling for demo prompts */
+    .demo-prompt-bubble {
+        background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
+        border: 1px solid #90caf9;
+        border-radius: 15px;
+        padding: 0.75rem 1rem;
+        margin: 0.5rem 0;
+        color: #1565c0;
+        font-size: 0.9rem;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        display: inline-block;
+        max-width: 80%;
+    }
+    
+    .demo-prompt-bubble:hover {
+        background: linear-gradient(135deg, #bbdefb 0%, #90caf9 100%);
+        transform: translateY(-1px);
+        box-shadow: 0 3px 8px rgba(52, 152, 219, 0.2);
+    }
+    
+    /* Toggle styling */
+    .oauth-toggle {
+        background: #f8f9fa;
+        border: 1px solid #e3f2fd;
+        border-radius: 6px;
+        padding: 0.5rem;
+    }
+    
+    /* Notification styling */
+    .notification-success {
+        background: white !important;
+        border: 2px solid #27ae60 !important;
+        border-radius: 8px !important;
+        padding: 1rem !important;
+        margin: 1rem 0 !important;
+        box-shadow: 0 4px 12px rgba(39, 174, 96, 0.2) !important;
+        animation: slideIn 0.5s ease-out !important;
+    }
+    
+    .notification-warning {
+        background: white !important;
+        border: 2px solid #f39c12 !important;
+        border-radius: 8px !important;
+        padding: 1rem !important;
+        margin: 1rem 0 !important;
+        box-shadow: 0 4px 12px rgba(243, 156, 18, 0.2) !important;
+        animation: slideIn 0.5s ease-out !important;
+    }
+    
+    .notification-critical {
+        background: white !important;
+        border: 2px solid #e74c3c !important;
+        border-radius: 8px !important;
+        padding: 1rem !important;
+        margin: 1rem 0 !important;
+        box-shadow: 0 4px 12px rgba(231, 76, 60, 0.2) !important;
+        animation: slideIn 0.5s ease-out !important;
+    }
+    
+    @keyframes slideIn {
+        from {
+            opacity: 0;
+            transform: translateY(-20px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    /* Group styling */
+    .user-selection-group {
+        background: #f8f9fa;
+        border: 1px solid #e3f2fd;
+        border-radius: 8px;
+        padding: 1.5rem;
+        margin-bottom: 1rem;
+    }
+    
+    /* Connection status */
+    .connection-status {
+        background: #e3f2fd;
+        border: 1px solid #bbdefb;
+        border-radius: 6px;
+        padding: 1rem;
+        color: #1565c0;
+        font-weight: 500;
+    }
+    """
+
+    with gr.Blocks(
+        title="GlycoAI - AI Glucose Insights",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="blue",
+            neutral_hue="slate"
+        ),
+        css=custom_css
+    ) as interface:
+
+        # Clean Header
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div class="main-header">
+                    <div style="display: flex; align-items: center; justify-content: center; gap: 1rem;">
+                        <div style="width: 50px; height: 50px; background: white; border-radius: 50%; display: flex; align-items: center; justify-content: center;">
+                            <span style="color: #3498db; font-size: 20px; font-weight: bold;">🩺</span>
+                        </div>
+                        <div>
+                            <h1 style="margin: 0; font-size: 2rem; color: white;">GlycoAI</h1>
+                            <p style="margin: 0; font-size: 1rem; color: white; opacity: 0.9;">AI-Powered Glucose Insights</p>
+                        </div>
+                    </div>
+                    <p style="margin-top: 1rem; font-size: 0.9rem; color: white; opacity: 0.8;">
+                        Demo Users + Dexcom Sandbox OAuth • Chat with AI for personalized glucose insights
+                    </p>
+                </div>
+                """)
+
+        # User Selection Section - Cleaner Layout
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 👥 Choose Your Data Source")
+                
+                # Demo Users Section
+                with gr.Group():
+                    gr.Markdown("#### 🎭 Demo Users")
+                    gr.Markdown("*Instant access to realistic glucose data for testing*")
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            sarah_btn = gr.Button(
+                                "Sarah Thompson\nG7 Mobile - ⚠️ Unstable Control",
+                                elem_classes=["demo-user-btn"]
+                            )
+                        with gr.Column(scale=1):
+                            marcus_btn = gr.Button(
+                                "Marcus Rodriguez\nONE+ Mobile - Type 2",
+                                elem_classes=["demo-user-btn"]
+                            )
+                        with gr.Column(scale=1):
+                            jennifer_btn = gr.Button(
+                                "Jennifer Chen\nG6 Mobile - Athletic",
+                                elem_classes=["demo-user-btn"]
+                            )
+                        with gr.Column(scale=1):
+                            robert_btn = gr.Button(
+                                "Robert Williams\nG6 Receiver - Experienced",
+                                elem_classes=["demo-user-btn"]
+                            )
+
+                # Show/Hide OAuth Toggle
+                with gr.Row():
+                    with gr.Column(scale=4):
+                        pass
+                    with gr.Column(scale=2):
+                        show_oauth_toggle = gr.Checkbox(
+                            label="Show Dexcom OAuth Options",
+                            value=False,
+                            container=False,
+                            elem_classes=["oauth-toggle"]
+                        )
+
+                # Dexcom Sandbox OAuth Section (Collapsible)
+                with gr.Group(visible=False) as oauth_section:
+                    if DEXCOM_SANDBOX_AVAILABLE:
+                        gr.Markdown("#### 🔐 Dexcom Sandbox OAuth")
+                        gr.Markdown("*Connect with OAuth-authenticated sandbox data*")
+                        
+                        with gr.Row():
+                            with gr.Column(scale=2):
+                                dexcom_sandbox_btn = gr.Button(
+                                    "🚀 Connect Dexcom Sandbox",
+                                    elem_classes=["dexcom-oauth-btn"]
+                                )
+                            with gr.Column(scale=3):
+                                oauth_instructions = gr.Markdown(
+                                    "Click to start Dexcom Sandbox authentication",
+                                    visible=True
+                                )
+                        
+                        with gr.Row(visible=False) as oauth_completion_row:
+                            with gr.Column():
+                                callback_url_input = gr.Textbox(
+                                    label="Paste Complete Callback URL",
+                                    placeholder="http://localhost:7860/callback?code=ABC123XYZ&state=sandbox_test",
+                                    lines=2
+                                )
+                                complete_oauth_btn = gr.Button(
+                                    "✅ Complete OAuth",
+                                    elem_classes=["dexcom-oauth-btn"]
+                                )
+                    else:
+                        gr.Markdown("#### 🔒 Dexcom Sandbox OAuth")
+                        gr.Markdown("*Not configured - demo users available*")
+                        
+                        gr.Button(
+                            "🔒 Dexcom Sandbox Not Available",
+                            interactive=False,
+                            elem_classes=["dexcom-oauth-btn"]
+                        )
+                        
+                        # Create dummy variables for consistency
+                        oauth_instructions = gr.Markdown("", visible=False)
+                        callback_url_input = gr.Textbox(visible=False)
+                        complete_oauth_btn = gr.Button(visible=False)
+                        oauth_completion_row = gr.Row(visible=False)
+
+        # Connection Status
+        with gr.Row():
+            with gr.Column():
+                connection_status = gr.Textbox(
+                    label="Connection Status",
+                    value="No user selected - Choose a demo user or connect Dexcom Sandbox",
+                    interactive=False,
+                    elem_classes=["connection-status"]
+                )
+
+        # Section Divider
+        gr.HTML('<div class="section-divider"></div>')
+
+        # Update button description for Sarah's unstable patterns
+        with gr.Group(visible=False) as main_interface:
+            # Prominent Load Data Button
+            with gr.Row():
+                with gr.Column(scale=1):
+                    pass  # Left spacer
+                with gr.Column(scale=2):
+                    load_data_btn = gr.Button(
+                        "📊 Load 14-Day Glucose Data\n🚀 Start Analysis & Enable AI Chat",
+                        elem_classes=["load-data-btn"]
+                    )
+                with gr.Column(scale=1):
+                    pass  # Right spacer
+            
+            # Notification area for data loading feedback
+            with gr.Row():
+                notification_area = gr.Markdown(
+                    "",
+                    visible=False,
+                    elem_classes=["notification-success"]
+                )
+
+            # Section Divider
+            gr.HTML('<div class="section-divider"></div>')
+
+            # Main Content Tabs - Reordered with Chat first
+            with gr.Tabs():
+                # Chat Tab - FIRST for priority
+                with gr.TabItem("💬 Chat with AI"):
+                    with gr.Column():
+                        gr.Markdown("### 🤖 Chat with GlycoAI")
+                        
+                        # Chat Interface with integrated demo prompts
+                        chatbot = gr.Chatbot(
+                            label="💬 Chat with GlycoAI",
+                            height=450,
+                            show_label=False,
+                            container=True,
+                            bubble_full_width=False,
+                            avatar_images=(None, "🩺")
+                        )
+
+                        # Chat Input
+                        with gr.Row():
+                            chat_input = gr.Textbox(
+                                placeholder="Ask about your glucose patterns, trends, or management strategies...",
+                                label="Your Question",
+                                lines=2,
+                                scale=4
+                            )
+                            send_btn = gr.Button(
+                                "Send",
+                                variant="primary",
+                                scale=1
+                            )
+
+                        # Chat Controls
+                        with gr.Row():
+                            clear_chat_btn = gr.Button(
+                                "🗑️ Clear Chat",
+                                size="sm"
+                            )
+                            gr.Markdown("*AI responses are for informational purposes only. Always consult your healthcare provider.*")
+
+                # Data Overview Tab - SECOND
+                with gr.TabItem("📋 Data Overview"):
+                    with gr.Column():
+                        gr.Markdown("### 📋 Comprehensive Data Analysis")
+                        
+                        data_display = gr.Markdown(
+                            "Load your glucose data to see detailed statistics and insights",
+                            container=True
+                        )
+
+                # Glucose Chart Tab - THIRD
+                with gr.TabItem("📈 Glucose Chart"):
+                    with gr.Column():
+                        gr.Markdown("### 📊 Interactive 14-Day Glucose Analysis")
+                        
+                        glucose_chart = gr.Plot(
+                            label="Interactive Glucose Trends",
+                            container=True
+                        )
+
+        # Event Handlers
+        def handle_demo_user_selection(user_key):
+            status, interface_visibility = app.select_demo_user(user_key)
+            initial_chat = app.initialize_chat_with_prompts()
+            return status, interface_visibility, initial_chat
+
+        def handle_load_data():
+            overview, chart, notification = app.load_glucose_data()
+            
+            # Determine notification class based on content
+            if "CONCERNING PATTERNS" in notification or "CRITICAL" in notification:
+                notification_class = "notification-critical"
+            elif "EXCELLENT CONTROL" in notification:
+                notification_class = "notification-success"
+            elif notification:
+                notification_class = "notification-warning"
+            else:
+                notification_class = "notification-success"
+            
+            # Show notification with appropriate styling
+            notification_update = gr.update(
+                value=notification,
+                visible=bool(notification),
+                elem_classes=[notification_class]
+            )
+            
+            return overview, chart, notification_update
+
+        def handle_chat_submit(message, history):
+            return app.chat_with_mistral(message, history)
+
+        def handle_enter_key(message, history):
+            if message.strip():
+                return app.chat_with_mistral(message, history)
+            return "", history
+
+        def handle_chatbot_click(history, evt: gr.SelectData):
+            """Handle clicking on chat bubbles (demo prompts)"""
+            if evt.index is not None and len(history) > evt.index[0]:
+                clicked_message = history[evt.index[0]][1]  # Get AI message
+                
+                # Check if it's a demo prompt (contains ** formatting)
+                if "**" in clicked_message and ("🎯" in clicked_message or "⚡" in clicked_message or "🍽️" in clicked_message):
+                    return app.handle_demo_prompt_click(clicked_message, history)
+            
+            return "", history
+
+        # Toggle OAuth section visibility
+        show_oauth_toggle.change(
+            lambda show: gr.update(visible=show),
+            inputs=[show_oauth_toggle],
+            outputs=[oauth_section]
+        )
+
+        # Connect Event Handlers for Demo Users
+        sarah_btn.click(
+            lambda: handle_demo_user_selection("sarah_g7"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        marcus_btn.click(
+            lambda: handle_demo_user_selection("marcus_one"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        jennifer_btn.click(
+            lambda: handle_demo_user_selection("jennifer_g6"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        robert_btn.click(
+            lambda: handle_demo_user_selection("robert_receiver"),
+            outputs=[connection_status, main_interface, chatbot]
+        )
+
+        # Connect Event Handlers for Dexcom Sandbox OAuth
+        if DEXCOM_SANDBOX_AVAILABLE:
+            dexcom_sandbox_btn.click(
+                app.start_dexcom_sandbox_oauth,
+                outputs=[oauth_instructions]
+            ).then(
+                lambda: gr.update(visible=True),
+                outputs=[oauth_completion_row]
+            )
+
+            complete_oauth_btn.click(
+                app.complete_dexcom_sandbox_oauth,
+                inputs=[callback_url_input],
+                outputs=[connection_status, main_interface]
+            ).then(
+                app.initialize_chat_with_prompts,  # Initialize chat with prompts after OAuth
+                outputs=[chatbot]
+            )
+
+        # Data Loading
+        load_data_btn.click(
+            handle_load_data,
+            outputs=[data_display, glucose_chart, notification_area]
+        )
+
+        # Chat Handlers
+        send_btn.click(
+            handle_chat_submit,
+            inputs=[chat_input, chatbot],
+            outputs=[chat_input, chatbot]
+        )
+
+        chat_input.submit(
+            handle_enter_key,
+            inputs=[chat_input, chatbot],
+            outputs=[chat_input, chatbot]
+        )
+
+        # Handle clicking on chat bubbles (demo prompts)
+        chatbot.select(
+            handle_chatbot_click,
+            inputs=[chatbot],
+            outputs=[chat_input, chatbot]
+        )
+
+        # Clear Chat
+        clear_chat_btn.click(
+            app.clear_chat_history,
+            outputs=[chatbot]
+        )
+
+        # Clean Footer
+        with gr.Row():
+            gr.HTML(f"""
+            <div style="text-align: center; padding: 1.5rem; margin-top: 2rem; border-top: 1px solid #e3f2fd; color: #546e7a;">
+                <p><strong>⚠️ Medical Disclaimer</strong></p>
+                <p style="font-size: 0.9rem;">GlycoAI is for informational and educational purposes only. Always consult your healthcare provider 
+                before making any changes to your diabetes management plan.</p>
+                <p style="margin-top: 1rem; font-size: 0.85rem; color: #78909c;">
+                    🔒 Data processed securely • 💡 Powered by Dexcom API & Mistral AI<br>
+                    🎭 Demo: Available • 🔐 Dexcom Sandbox: {"Available" if DEXCOM_SANDBOX_AVAILABLE else "Not configured"}
+                </p>
+            </div>
+            """)
+
+    return interface
+
+
+def main():
+    """Main function to launch the application"""
+    print("🚀 Starting GlycoAI - AI-Powered Glucose Insights...")
+    
+    # Check OAuth availability
+    oauth_status = "✅ Available" if DEXCOM_SANDBOX_AVAILABLE else "❌ Not configured"
+    print(f"🎯 Dexcom Sandbox OAuth: {oauth_status}")
+    
+    # Validate environment before starting
+    print("🔍 Validating environment configuration...")
+    if not validate_environment():
+        print("❌ Environment validation failed!")
+        print("Please check your .env file or environment variables.")
+        return
+    
+    print("✅ Environment validation passed!")
+    
+    try:
+        # Create and launch the interface
+        demo = create_interface()
+        
+        print("🎯 GlycoAI Features:")
+        print("📊 Clean UI with blue theme, consistent button sizes, improved readability")
+        print("🎭 Demo users: 4 realistic profiles for instant testing")
+        if DEXCOM_SANDBOX_AVAILABLE:
+            print("✅ Dexcom Sandbox: Available - OAuth authentication ready")
+        else:
+            print("🔒 Dexcom Sandbox: Not configured - demo users only")
+        
+        # Launch with custom settings
+        demo.launch(
+            server_name="0.0.0.0",  # Allow external access
+            server_port=7860,       # Your port
+            share=True,            # Set to True for public sharing (tunneling)
+            debug=os.getenv("DEBUG", "false").lower() == "true",
+            show_error=True,        # Show errors in the interface
+            auth=None,              # No authentication required
+            favicon_path=None,      # Use default favicon
+            ssl_verify=False        # Disable SSL verification for development
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to launch GlycoAI application: {e}")
+        print(f"❌ Error launching application: {e}")
+        
+        # Provide helpful error information
+        if "environment" in str(e).lower():
+            print("\n💡 Environment troubleshooting:")
+            print("1. Check if .env file exists with MISTRAL_API_KEY")
+            print("2. Verify your API key is valid")
+            print("3. For Hugging Face Spaces, check Repository secrets")
+        else:
+            print("\n💡 Try checking:")
+            print("1. All dependencies are installed: pip install -r requirements.txt")
+            print("2. Port 7860 is available")
+            print("3. Check the logs above for specific error details")
+        
+        raise
+
+
+if __name__ == "__main__":
+    # Setup logging configuration
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    logging.basicConfig(
+        level=getattr(logging, log_level.upper()),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('glycoai.log'),
+            logging.StreamHandler()
+        ]
+    )
+    
+    # Run the main application
+    main()

dexcom_sandbox_oauth.py

@@ -0,0 +1,790 @@
+#!/usr/bin/env python3
+"""
+Dexcom Sandbox OAuth Integration
+Complete implementation for Dexcom Sandbox authentication with user selection
+"""
+
+import os
+import requests
+import urllib.parse
+import json
+import secrets
+import webbrowser
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Dexcom Sandbox Configuration
+CLIENT_ID = os.getenv("DEXCOM_CLIENT_ID", "mLElKHKRwRDVUrAOPBzktFGY7qkTc7Zm")
+CLIENT_SECRET = os.getenv("DEXCOM_CLIENT_SECRET", "HmFpgyVweuwKrQpf")
+REDIRECT_URI = "http://localhost:7860/callback"
+
+# Dexcom Sandbox Users (selection-based, no passwords)
+SANDBOX_USERS = {
+    "user1": "SandboxUser1",
+    "user2": "SandboxUser2", 
+    "user3": "SandboxUser3",
+    "user4": "SandboxUser4",
+    "user5": "SandboxUser5",
+    "user6": "SandboxUser6 (Dexcom G6)",
+    "user7": "SandboxUser7 (Dexcom G7)",
+    "user8": "SandboxUser8"
+}
+
+# Dexcom API Endpoints - Following Official Documentation
+# Based on https://developer.dexcom.com/docs/dexcomv2/endpoint-overview/ and v3
+
+# OAuth endpoints are shared between v2 and v3 (always v2 OAuth)
+OAUTH_ENDPOINTS = {
+    "login": "https://api.dexcom.com/v2/oauth2/login",           # Production OAuth login
+    "token": "https://api.dexcom.com/v2/oauth2/token",           # Production OAuth token
+    "sandbox_login": "https://developer.dexcom.com/sandbox-login" # Special sandbox login
+}
+
+# API Base URLs per official documentation
+API_BASE_URLS = {
+    "production": "https://api.dexcom.com",
+    "sandbox": "https://sandbox-api.dexcom.com"
+}
+
+# Recommended configuration (Sandbox login + Production OAuth + Sandbox API)
+DEFAULT_ENDPOINTS = {
+    "login": "https://developer.dexcom.com/sandbox-login",      # Special sandbox login
+    "token": "https://api.dexcom.com/v2/oauth2/token",          # Production OAuth (works for sandbox too)
+    "api_v2": "https://sandbox-api.dexcom.com/v2",             # Sandbox API v2
+    "api_v3": "https://sandbox-api.dexcom.com/v3"              # Sandbox API v3
+}
+
+# Alternative configurations for troubleshooting
+ENDPOINT_CONFIGURATIONS = [
+    {
+        "name": "Sandbox Login + Production OAuth + Sandbox API (Recommended)",
+        "login": "https://developer.dexcom.com/sandbox-login",
+        "token": "https://api.dexcom.com/v2/oauth2/token",
+        "api_v2": "https://sandbox-api.dexcom.com/v2",
+        "api_v3": "https://sandbox-api.dexcom.com/v3"
+    },
+    {
+        "name": "All Production OAuth + Production API",
+        "login": "https://api.dexcom.com/v2/oauth2/login",
+        "token": "https://api.dexcom.com/v2/oauth2/token",
+        "api_v2": "https://api.dexcom.com/v2",
+        "api_v3": "https://api.dexcom.com/v3"
+    },
+    {
+        "name": "All Sandbox (May not work)",
+        "login": "https://sandbox-api.dexcom.com/v2/oauth2/login",
+        "token": "https://sandbox-api.dexcom.com/v2/oauth2/token",
+        "api_v2": "https://sandbox-api.dexcom.com/v2",
+        "api_v3": "https://sandbox-api.dexcom.com/v3"
+    }
+]
+
+@dataclass
+class DexcomSandboxUser:
+    """Profile for Dexcom Sandbox User"""
+    name: str = "Dexcom Sandbox User"
+    age: int = 35
+    device_type: str = "Dexcom G6 (Sandbox)"
+    username: str = "sandbox_user"
+    password: str = "selection_based"
+    description: str = "Dexcom Sandbox User with OAuth authentication"
+    diabetes_type: str = "Type 1"
+    years_with_diabetes: int = 8
+    typical_glucose_pattern: str = "sandbox_data"
+    auth_type: str = "dexcom_sandbox"
+
+class DexcomSandboxOAuth:
+    """
+    Dexcom Sandbox OAuth implementation with user selection
+    
+    Flow:
+    1. Generate auth URL → developer.dexcom.com/sandbox-login
+    2. User selects sandbox user from dropdown (no password)
+    3. Get authorization code from callback
+    4. Exchange code for token → sandbox-api.dexcom.com/v2/oauth2/token
+    5. Use token for API calls → sandbox-api.dexcom.com/v2/...
+    """
+    
+    def __init__(self, api_version: str = "v3"):
+        self.client_id = CLIENT_ID
+        self.client_secret = CLIENT_SECRET
+        self.redirect_uri = REDIRECT_URI
+        self.api_version = api_version  # "v2" or "v3"
+        
+        # OAuth state
+        self.access_token = None
+        self.refresh_token = None
+        self.token_expires_at = None
+        self.state = None
+        
+        # Use recommended configuration (sandbox login + production OAuth + sandbox API)
+        self.working_endpoints = DEFAULT_ENDPOINTS.copy()
+        
+        logger.info(f"✅ Dexcom Sandbox OAuth initialized (API {api_version})")
+        logger.info(f"   Client ID: {self.client_id[:8]}...")
+        logger.info(f"   Redirect URI: {self.redirect_uri}")
+        
+        if api_version == "v3":
+            logger.info("   Using API v3 for G6, G7, ONE, ONE+ device support")
+        else:
+            logger.info("   Using API v2 for G5, G6 device support")
+    
+    def get_api_base_url(self) -> str:
+        """Get the correct API base URL for the current version"""
+        if self.api_version == "v3":
+            return self.working_endpoints["api_v3"]
+        else:
+            return self.working_endpoints["api_v2"]
+    
+    def generate_auth_url(self) -> str:
+        """Generate OAuth authorization URL for Dexcom Sandbox"""
+        # Generate secure state parameter
+        self.state = secrets.token_urlsafe(32)
+        
+        # OAuth parameters
+        params = {
+            'client_id': self.client_id,
+            'redirect_uri': self.redirect_uri,
+            'response_type': 'code',
+            'scope': 'offline_access',
+            'state': self.state
+        }
+        
+        # Build auth URL using current working endpoints
+        query_string = urllib.parse.urlencode(params)
+        auth_url = f"{self.working_endpoints['login']}?{query_string}"
+        
+        logger.info(f"🔗 Generated auth URL: {auth_url}")
+        return auth_url
+    
+    def start_oauth_flow(self) -> Dict[str, Any]:
+        """Start the Dexcom Sandbox OAuth flow"""
+        try:
+            auth_url = self.generate_auth_url()
+            
+            # Try to open browser automatically
+            try:
+                webbrowser.open(auth_url)
+                browser_opened = True
+                logger.info("✅ Browser opened automatically")
+            except Exception as e:
+                browser_opened = False
+                logger.warning(f"⚠️ Could not open browser: {e}")
+            
+            return {
+                "success": True,
+                "auth_url": auth_url,
+                "browser_opened": browser_opened,
+                "state": self.state,
+                "instructions": self._get_oauth_instructions(auth_url, browser_opened)
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to start OAuth flow: {e}")
+            return {
+                "success": False,
+                "error": f"Failed to start OAuth: {str(e)}"
+            }
+    
+    def _get_oauth_instructions(self, auth_url: str, browser_opened: bool) -> str:
+        """Generate user-friendly OAuth instructions"""
+        browser_status = "✅ Browser opened automatically" if browser_opened else "⚠️ Please open URL manually"
+        
+        return f"""
+🚀 **Dexcom Sandbox OAuth Started**
+
+{browser_status}
+
+**📋 Step-by-Step Instructions:**
+1. 🌐 Browser should open to: {auth_url}
+2. 👥 **Select a Sandbox User** from the dropdown:
+   • **SandboxUser6** - Dexcom G6 device (recommended)
+   • **SandboxUser7** - Dexcom G7 device
+   • **SandboxUser1-8** - Various test scenarios
+3. ✅ Click "Authorize" to grant access
+4. ❌ **You will get a 404 error - THIS IS EXPECTED!**
+5. 📋 **Copy the COMPLETE URL** from your browser's address bar
+6. 📥 Paste the URL below and click "Complete OAuth"
+
+**📱 Example callback URL:**
+`http://localhost:7860/callback?code=ABC123XYZ&state=your_state_here`
+
+**🎯 Important:** 
+- No password needed - just select a user and authorize
+- Copy the **entire URL** (not just the code part)
+- SandboxUser6 = Dexcom G6 device data (most common)
+        """
+    
+    def complete_oauth(self, callback_url: str) -> Dict[str, Any]:
+        """Complete OAuth by processing callback URL and exchanging code for token"""
+        if not callback_url or not callback_url.strip():
+            return {
+                "success": False,
+                "error": "Please provide the callback URL from your browser"
+            }
+        
+        try:
+            # Extract authorization code from callback URL
+            auth_code = self._extract_auth_code(callback_url)
+            
+            if not auth_code:
+                return {
+                    "success": False,
+                    "error": "Could not extract authorization code from URL"
+                }
+            
+            # Validate state parameter
+            callback_state = self._extract_state(callback_url)
+            if callback_state != self.state:
+                logger.warning(f"State mismatch: expected {self.state}, got {callback_state}")
+                # Continue anyway for sandbox testing
+            
+            # Exchange code for tokens
+            token_result = self._exchange_code_for_tokens(auth_code)
+            
+            if token_result["success"]:
+                logger.info("✅ Dexcom Sandbox OAuth completed successfully")
+                return {
+                    "success": True,
+                    "message": "✅ Dexcom Sandbox authentication successful",
+                    "access_token": self.access_token,
+                    "token_expires_at": self.token_expires_at,
+                    "user_profile": DexcomSandboxUser()
+                }
+            else:
+                return token_result
+                
+        except Exception as e:
+            logger.error(f"OAuth completion failed: {e}")
+            return {
+                "success": False,
+                "error": f"OAuth completion failed: {str(e)}"
+            }
+    
+    def _extract_auth_code(self, callback_url: str) -> Optional[str]:
+        """Extract authorization code from callback URL"""
+        try:
+            parsed_url = urllib.parse.urlparse(callback_url)
+            query_params = urllib.parse.parse_qs(parsed_url.query)
+            
+            if 'code' in query_params:
+                code = query_params['code'][0]
+                logger.info(f"✅ Extracted auth code: {code[:15]}...")
+                return code
+            else:
+                logger.error("No 'code' parameter found in callback URL")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error extracting auth code: {e}")
+            return None
+    
+    def _extract_state(self, callback_url: str) -> Optional[str]:
+        """Extract state parameter from callback URL"""
+        try:
+            parsed_url = urllib.parse.urlparse(callback_url)
+            query_params = urllib.parse.parse_qs(parsed_url.query)
+            
+            if 'state' in query_params:
+                return query_params['state'][0]
+            else:
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error extracting state: {e}")
+            return None
+    
+    def _exchange_code_for_tokens(self, auth_code: str) -> Dict[str, Any]:
+        """Exchange authorization code for access token following Dexcom API v3 guidelines"""
+        
+        # Try sandbox configuration first, then alternatives
+        configurations_to_try = [self.working_endpoints] + ENDPOINT_CONFIGURATIONS
+        
+        for i, endpoint_config in enumerate(configurations_to_try):
+            endpoint_name = endpoint_config.get('name', f'Sandbox Config {i+1}')
+            token_url = endpoint_config["token"]
+            
+            logger.info(f"🔄 Attempting token exchange #{i+1}: {endpoint_name}")
+            logger.info(f"   Token URL: {token_url}")
+            
+            # Token exchange data per Dexcom OAuth2 spec
+            data = {
+                'client_id': self.client_id,
+                'client_secret': self.client_secret,
+                'code': auth_code,
+                'grant_type': 'authorization_code',
+                'redirect_uri': self.redirect_uri
+            }
+            
+            # Headers per Dexcom API guidelines
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+                'User-Agent': 'GlycoAI-DexcomSandbox/1.0',
+                'Cache-Control': 'no-cache'
+            }
+            
+            try:
+                logger.info(f"📤 Auth code: {auth_code[:15]}...")
+                
+                response = requests.post(token_url, data=data, headers=headers, timeout=30)
+                
+                logger.info(f"📨 Response status: {response.status_code}")
+                logger.info(f"📨 Response headers: {dict(response.headers)}")
+                
+                if response.status_code == 200:
+                    try:
+                        token_data = response.json()
+                    except json.JSONDecodeError:
+                        logger.error(f"❌ Invalid JSON response: {response.text}")
+                        continue
+                    
+                    # Store tokens
+                    self.access_token = token_data.get('access_token')
+                    self.refresh_token = token_data.get('refresh_token')
+                    
+                    if not self.access_token:
+                        logger.error(f"❌ No access_token in response: {token_data}")
+                        continue
+                    
+                    # Calculate expiration
+                    expires_in = token_data.get('expires_in', 3600)  # Default 1 hour
+                    self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+                    
+                    logger.info(f"✅ Token exchange successful with {endpoint_name}!")
+                    logger.info(f"   Access token: {self.access_token[:25]}...")
+                    logger.info(f"   Token type: {token_data.get('token_type', 'Bearer')}")
+                    logger.info(f"   Expires in: {expires_in} seconds ({expires_in/3600:.1f} hours)")
+                    logger.info(f"   Scope: {token_data.get('scope', 'offline_access')}")
+                    
+                    # Update working endpoints to use the successful configuration
+                    self.working_endpoints = endpoint_config.copy()
+                    
+                    return {
+                        "success": True,
+                        "access_token": self.access_token,
+                        "refresh_token": self.refresh_token,
+                        "expires_in": expires_in,
+                        "working_endpoint": endpoint_config,
+                        "token_type": token_data.get('token_type', 'Bearer'),
+                        "scope": token_data.get('scope', 'offline_access')
+                    }
+                else:
+                    # Log detailed error information
+                    error_text = response.text
+                    try:
+                        error_data = response.json()
+                        error_message = error_data.get('error_description', 
+                                                     error_data.get('error', 'Unknown error'))
+                        error_code = error_data.get('error', 'unknown_error')
+                    except:
+                        error_message = error_text
+                        error_code = f"http_{response.status_code}"
+                    
+                    logger.warning(f"❌ {endpoint_name} failed: {response.status_code} - {error_message}")
+                    
+                    # Specific error handling based on Dexcom API behavior
+                    if response.status_code == 404:
+                        logger.info(f"   → Token endpoint not found, trying next configuration...")
+                        continue
+                    elif response.status_code == 400 and 'invalid_grant' in error_code:
+                        logger.info(f"   → Invalid/expired authorization code, trying next configuration...")
+                        continue
+                    elif response.status_code == 401 and 'invalid_client' in error_code:
+                        logger.info(f"   → Invalid client credentials, trying next configuration...")
+                        continue
+                    else:
+                        logger.info(f"   → HTTP {response.status_code} error, trying next configuration...")
+                        continue
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"⏱️ {endpoint_name} timed out, trying next configuration...")
+                continue
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"🌐 {endpoint_name} network error: {e}, trying next configuration...")
+                continue
+            except Exception as e:
+                logger.warning(f"❓ {endpoint_name} unexpected error: {e}, trying next configuration...")
+                continue
+        
+        # All endpoints failed
+        logger.error("❌ All token endpoint configurations failed")
+        return {
+            "success": False,
+            "error": "All token endpoints failed. This may be due to invalid authorization code, expired code, or Dexcom API issues.",
+            "suggestion": "Please try getting a fresh authorization code (they expire in 60 seconds) or check your Dexcom developer credentials.",
+            "endpoints_tried": configurations_to_try,
+            "troubleshooting": [
+                "1. Make sure you copied the COMPLETE callback URL",
+                "2. Authorization codes expire in 60 seconds - get a fresh one",
+                "3. Verify your CLIENT_ID and CLIENT_SECRET are correct",
+                "4. Check if your app is properly registered in Dexcom developer portal",
+                "5. Ensure redirect URI matches exactly: http://localhost:7860/callback"
+            ]
+        }
+    
+    def _ensure_valid_token(self):
+        """Ensure we have a valid access token"""
+        if not self.access_token:
+            raise Exception("No access token available. Please authenticate first.")
+        
+        if self.token_expires_at and datetime.now() >= self.token_expires_at - timedelta(minutes=5):
+            logger.info("Token expiring soon, need to refresh...")
+            if self.refresh_token:
+                if not self._refresh_token():
+                    raise Exception("Token expired and refresh failed")
+            else:
+                raise Exception("Token expired and no refresh token available")
+    
+    def _refresh_token(self) -> bool:
+        """Refresh the access token using refresh token"""
+        if not self.refresh_token:
+            return False
+        
+        token_url = self.working_endpoints["token"]
+        
+        data = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'refresh_token': self.refresh_token,
+            'grant_type': 'refresh_token'
+        }
+        
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Accept': 'application/json'
+        }
+        
+        try:
+            response = requests.post(token_url, data=data, headers=headers)
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                
+                self.access_token = token_data.get('access_token')
+                if 'refresh_token' in token_data:
+                    self.refresh_token = token_data.get('refresh_token')
+                
+                expires_in = token_data.get('expires_in', 7200)
+                self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
+                
+                logger.info("✅ Token refreshed successfully")
+                return True
+            else:
+                logger.error(f"Token refresh failed: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Token refresh error: {e}")
+            return False
+    
+    def get_auth_headers(self) -> Dict[str, str]:
+        """Get authorization headers for API calls"""
+        self._ensure_valid_token()
+        
+        return {
+            'Authorization': f'Bearer {self.access_token}',
+            'Accept': 'application/json',
+            'User-Agent': 'GlycoAI-DexcomSandbox/1.0'
+        }
+    
+    def get_data_range(self) -> Dict[str, Any]:
+        """Get available data range from Dexcom API"""
+        api_base = self.get_api_base_url()
+        url = f"{api_base}/users/self/dataRange"
+        headers = self.get_auth_headers()
+        
+        try:
+            response = requests.get(url, headers=headers, timeout=30)
+            
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"✅ Data range retrieved from API {self.api_version}: {data}")
+                return data
+            else:
+                logger.error(f"Data range API error: {response.status_code} - {response.text}")
+                raise Exception(f"Data range API error: {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"Error getting data range: {e}")
+            raise
+    
+    def get_glucose_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get glucose (EGV) data from Dexcom API"""
+        api_base = self.get_api_base_url()
+        url = f"{api_base}/users/self/egvs"
+        headers = self.get_auth_headers()
+        
+        # Per Dexcom documentation: all endpoints except dataRange require startDate and endDate
+        params = {}
+        if start_date:
+            params['startDate'] = start_date
+        if end_date:
+            params['endDate'] = end_date
+        
+        # Validate date range (max 90 days per Dexcom spec)
+        if start_date and end_date:
+            from datetime import datetime
+            start_dt = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            end_dt = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+            delta = (end_dt - start_dt).days
+            
+            if delta > 90:
+                logger.warning(f"Date range {delta} days exceeds Dexcom 90-day limit")
+                # Adjust to last 90 days
+                start_dt = end_dt - timedelta(days=90)
+                params['startDate'] = start_dt.isoformat() + 'Z'
+                logger.info(f"Adjusted to 90-day window: {params['startDate']} to {end_date}")
+        
+        try:
+            logger.info(f"🔍 Fetching glucose data from API {self.api_version}")
+            logger.info(f"   URL: {url}")
+            logger.info(f"   Params: {params}")
+            
+            response = requests.get(url, headers=headers, params=params, timeout=30)
+            
+            if response.status_code == 200:
+                data = response.json()
+                egvs = data.get('egvs', [])
+                logger.info(f"✅ Retrieved {len(egvs)} glucose readings from API {self.api_version}")
+                return egvs
+            else:
+                logger.error(f"EGV API error: {response.status_code} - {response.text}")
+                raise Exception(f"EGV API error: {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"Error getting glucose data: {e}")
+            raise
+    
+    def get_events_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
+        """Get events data from Dexcom API"""
+        api_base = self.get_api_base_url()
+        url = f"{api_base}/users/self/events"
+        headers = self.get_auth_headers()
+        
+        params = {}
+        if start_date:
+            params['startDate'] = start_date
+        if end_date:
+            params['endDate'] = end_date
+        
+        try:
+            response = requests.get(url, headers=headers, params=params, timeout=30)
+            
+            if response.status_code == 200:
+                data = response.json()
+                events = data.get('events', [])
+                logger.info(f"✅ Retrieved {len(events)} events from API {self.api_version}")
+                return events
+            else:
+                logger.warning(f"Events API returned {response.status_code}, continuing without events")
+                return []
+                
+        except Exception as e:
+            logger.warning(f"Error getting events data: {e}, continuing without events")
+            return []
+
+class DexcomSandboxIntegration:
+    """Integration wrapper for Gradio app with API version selection"""
+    
+    def __init__(self, api_version: str = "v3"):
+        self.oauth = DexcomSandboxOAuth(api_version=api_version)
+        self.api_version = api_version
+        self.authenticated = False
+        self.user_profile = None
+        self.glucose_data = None
+        self.events_data = None
+        self.data_loaded_at = None
+    
+    def start_oauth(self) -> Tuple[str, bool, bool]:
+        """Start OAuth flow for Gradio interface"""
+        result = self.oauth.start_oauth_flow()
+        
+        if result["success"]:
+            return (
+                result["instructions"],
+                True,  # Show callback input
+                True   # Show complete button
+            )
+        else:
+            return (
+                f"❌ Failed to start OAuth: {result['error']}",
+                False,
+                False
+            )
+    
+    def complete_oauth(self, callback_url: str) -> Tuple[str, bool]:
+        """Complete OAuth flow for Gradio interface"""
+        result = self.oauth.complete_oauth(callback_url)
+        
+        if result["success"]:
+            self.authenticated = True
+            self.user_profile = result["user_profile"]
+            
+            return (
+                f"✅ Dexcom Sandbox authenticated successfully! Click 'Load Data' to begin.",
+                True  # Show main interface
+            )
+        else:
+            return (
+                f"❌ OAuth failed: {result['error']}",
+                False
+            )
+    
+    def load_glucose_data(self, days: int = 14) -> Dict[str, Any]:
+        """Load glucose data for the specified number of days"""
+        if not self.authenticated:
+            return {
+                "success": False,
+                "error": "Not authenticated. Please complete OAuth first."
+            }
+        
+        try:
+            # Calculate date range
+            end_time = datetime.now()
+            start_time = end_time - timedelta(days=days)
+            
+            # Fetch glucose data
+            self.glucose_data = self.oauth.get_glucose_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            # Fetch events data
+            self.events_data = self.oauth.get_events_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            self.data_loaded_at = datetime.now()
+            
+            return {
+                "success": True,
+                "glucose_readings": len(self.glucose_data),
+                "events": len(self.events_data),
+                "date_range": f"{start_time.strftime('%Y-%m-%d')} to {end_time.strftime('%Y-%m-%d')}",
+                "user": self.user_profile.name
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to load glucose data: {e}")
+            return {
+                "success": False,
+                "error": f"Failed to load data: {str(e)}"
+            }
+    
+    def get_user_profile(self) -> Optional[DexcomSandboxUser]:
+        """Get authenticated user profile"""
+        return self.user_profile if self.authenticated else None
+    
+    def get_glucose_data_for_ui(self) -> Optional[List[Dict]]:
+        """Get glucose data formatted for UI display"""
+        return self.glucose_data if self.authenticated else None
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current authentication and data status"""
+        return {
+            "authenticated": self.authenticated,
+            "user": self.user_profile.name if self.user_profile else None,
+            "glucose_readings": len(self.glucose_data) if self.glucose_data else 0,
+            "events": len(self.events_data) if self.events_data else 0,
+            "data_loaded_at": self.data_loaded_at.isoformat() if self.data_loaded_at else None,
+            "token_expires_at": self.oauth.token_expires_at.isoformat() if self.oauth.token_expires_at else None
+        }
+
+def debug_oauth_endpoints():
+    """Debug function to test all OAuth endpoints"""
+    print("🔍 DEBUGGING DEXCOM OAUTH ENDPOINTS")
+    print("=" * 60)
+    
+    # Test all endpoint configurations
+    all_configs = [DEFAULT_ENDPOINTS] + ENDPOINT_CONFIGURATIONS
+    
+    for i, config in enumerate(all_configs):
+        name = config.get('name', f'Configuration {i+1}')
+        print(f"\n🧪 Testing {name}:")
+        print(f"   Login: {config['login']}")
+        print(f"   Token: {config['token']}")
+        print(f"   API v2: {config['api_v2']}")
+        print(f"   API v3: {config['api_v3']}")
+        
+        # Test if endpoints are reachable
+        for endpoint_type, url in config.items():
+            if endpoint_type == 'name':
+                continue
+                
+            try:
+                # Just check if the endpoint exists (don't send real requests)
+                response = requests.head(url, timeout=5)
+                status = "✅ Reachable" if response.status_code != 404 else "❌ 404 Not Found"
+                print(f"   {endpoint_type.upper()}: {status} ({response.status_code})")
+            except requests.exceptions.RequestException as e:
+                print(f"   {endpoint_type.upper()}: ❌ Error - {e}")
+    
+    print(f"\n💡 Key Points from Official Documentation:")
+    print("1. OAuth endpoints are always v2 (even for v3 API calls)")
+    print("2. Sandbox login uses special developer.dexcom.com/sandbox-login")
+    print("3. Token exchange uses production OAuth endpoint for sandbox too")
+    print("4. API v3 supports G6, G7, ONE, ONE+ devices")
+    print("5. API v2 supports G5, G6 devices (legacy)")
+    print("6. Time window max 90 days for all endpoints except dataRange")
+
+def test_dexcom_sandbox():
+    """Test Dexcom Sandbox OAuth implementation with both API versions"""
+    print("🧪 Testing Dexcom Sandbox OAuth Implementation")
+    print("=" * 60)
+    
+    # Run endpoint debug first
+    debug_oauth_endpoints()
+    
+    print(f"\n🚀 OAuth Flow Test:")
+    
+    # Test both API versions
+    for api_version in ["v3", "v2"]:
+        print(f"\n--- Testing API {api_version} ---")
+        
+        # Initialize OAuth
+        oauth = DexcomSandboxOAuth(api_version=api_version)
+        
+        # Test auth URL generation
+        auth_url = oauth.generate_auth_url()
+        print(f"✅ Auth URL generated: {auth_url}")
+        
+        # Test integration wrapper
+        integration = DexcomSandboxIntegration(api_version=api_version)
+        
+        instructions, show_input, show_button = integration.start_oauth()
+        print(f"✅ OAuth flow started for API {api_version}")
+        print(f"   Show callback input: {show_input}")
+        print(f"   Show complete button: {show_button}")
+    
+    print(f"\n📋 Next steps for testing:")
+    print(f"1. Choose API version (v3 recommended for newer devices)")
+    print(f"2. Open auth URL and select sandbox user")
+    print(f"3. SandboxUser6 (G6) works with both v2 and v3")
+    print(f"4. SandboxUser7 (G7) requires API v3")
+    print(f"5. Copy callback URL after 404 error")
+    print(f"6. System will automatically try multiple token endpoints")
+    
+    print(f"\n👥 Available Sandbox Users:")
+    for key, name in SANDBOX_USERS.items():
+        print(f"   • {name}")
+        if "G6" in name:
+            print(f"     ↳ 🎯 Works with both API v2 and v3")
+        elif "G7" in name:
+            print(f"     ↳ 🎯 Requires API v3")
+    
+    return oauth, integration
+
+if __name__ == "__main__":
+    test_dexcom_sandbox()

unified_data_manager.py

@@ -0,0 +1,575 @@
+"""
+Unified Data Manager for GlycoAI - MODIFIED VERSION
+Sarah now has unstable glucose values for demonstration
+"""
+
+import logging
+from typing import Dict, Any, Optional, Tuple
+import pandas as pd
+from datetime import datetime, timedelta
+from dataclasses import asdict
+import numpy as np
+import random
+
+from apifunctions import (
+    DexcomAPI,
+    GlucoseAnalyzer,
+    DEMO_USERS,
+    DemoUser
+)
+
+logger = logging.getLogger(__name__)
+
+class UnifiedDataManager:
+    """
+    MODIFIED: Unified data manager with Sarah having unstable glucose patterns
+    """
+    
+    def __init__(self):
+        self.dexcom_api = DexcomAPI()
+        self.analyzer = GlucoseAnalyzer()
+        
+        logger.info(f"UnifiedDataManager initialized - Sarah will have unstable glucose patterns")
+        
+        # Single source of truth for all data
+        self.current_user: Optional[DemoUser] = None
+        self.raw_glucose_data: Optional[list] = None
+        self.processed_glucose_data: Optional[pd.DataFrame] = None
+        self.calculated_stats: Optional[Dict] = None
+        self.identified_patterns: Optional[Dict] = None
+        
+        # Metadata
+        self.data_loaded_at: Optional[datetime] = None
+        self.data_source: str = "none"  # "dexcom_api", "mock", or "none"
+        
+    def load_user_data(self, user_key: str, force_reload: bool = False) -> Dict[str, Any]:
+        """
+        MODIFIED: Load glucose data with Sarah having unstable patterns
+        """
+        
+        # Check if we already have data for this user and it's recent
+        if (not force_reload and 
+            self.current_user and 
+            self.current_user == DEMO_USERS.get(user_key) and
+            self.data_loaded_at and 
+            (datetime.now() - self.data_loaded_at).seconds < 300):  # 5 minutes cache
+            
+            logger.info(f"Using cached data for {user_key}")
+            return self._build_success_response()
+        
+        try:
+            if user_key not in DEMO_USERS:
+                return {
+                    "success": False,
+                    "message": f"❌ Invalid user key '{user_key}'. Available: {', '.join(DEMO_USERS.keys())}"
+                }
+            
+            logger.info(f"Loading data for user: {user_key}")
+            
+            # Set current user
+            self.current_user = DEMO_USERS[user_key]
+            
+            # Call API EXACTLY as it was working before
+            try:
+                logger.info(f"Attempting Dexcom API authentication for {user_key}")
+                
+                # ORIGINAL WORKING METHOD: Use the simulate_demo_login exactly as before
+                access_token = self.dexcom_api.simulate_demo_login(user_key)
+                logger.info(f"Dexcom authentication result: {bool(access_token)}")
+                
+                if access_token:
+                    # ORIGINAL WORKING METHOD: Get data with 14-day range
+                    end_date = datetime.now()
+                    start_date = end_date - timedelta(days=14)
+                    
+                    # Call get_egv_data EXACTLY as it was working before
+                    self.raw_glucose_data = self.dexcom_api.get_egv_data(
+                        start_date.isoformat(),
+                        end_date.isoformat()
+                    )
+                    
+                    if self.raw_glucose_data and len(self.raw_glucose_data) > 0:
+                        self.data_source = "dexcom_api"
+                        logger.info(f"✅ Successfully loaded {len(self.raw_glucose_data)} readings from Dexcom API")
+                    else:
+                        logger.warning("Dexcom API returned empty data - falling back to mock data")
+                        raise Exception("Empty data from Dexcom API")
+                else:
+                    logger.warning("Failed to get access token - falling back to mock data")
+                    raise Exception("Authentication failed")
+                    
+            except Exception as api_error:
+                logger.warning(f"Dexcom API failed ({str(api_error)}) - using mock data fallback")
+                self.raw_glucose_data = self._generate_realistic_mock_data(user_key)
+                self.data_source = "mock"
+            
+            # Process the raw data (same processing for everyone)
+            self.processed_glucose_data = self.analyzer.process_egv_data(self.raw_glucose_data)
+            
+            if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+                return {
+                    "success": False,
+                    "message": "❌ Failed to process glucose data"
+                }
+            
+            # Calculate statistics (single source of truth)
+            self.calculated_stats = self._calculate_unified_stats()
+            
+            # Identify patterns
+            self.identified_patterns = self.analyzer.identify_patterns(self.processed_glucose_data)
+            
+            # Mark when data was loaded
+            self.data_loaded_at = datetime.now()
+            
+            logger.info(f"Successfully loaded and processed data for {self.current_user.name}")
+            logger.info(f"Data source: {self.data_source}, Readings: {len(self.processed_glucose_data)}")
+            logger.info(f"TIR: {self.calculated_stats.get('time_in_range_70_180', 0):.1f}%")
+            
+            return self._build_success_response()
+            
+        except Exception as e:
+            logger.error(f"Failed to load user data: {e}")
+            return {
+                "success": False,
+                "message": f"❌ Failed to load user data: {str(e)}"
+            }
+    
+    def get_stats_for_ui(self) -> Dict[str, Any]:
+        """Get statistics formatted for the UI display"""
+        if not self.calculated_stats:
+            return {}
+        
+        return {
+            **self.calculated_stats,
+            "data_source": self.data_source,
+            "loaded_at": self.data_loaded_at.isoformat() if self.data_loaded_at else None,
+            "user_name": self.current_user.name if self.current_user else None
+        }
+    
+    def get_context_for_agent(self) -> Dict[str, Any]:
+        """Get context formatted for the AI agent"""
+        if not self.current_user or not self.calculated_stats:
+            return {"error": "No user data loaded"}
+        
+        # Build agent context with the SAME data as UI
+        context = {
+            "user": {
+                "name": self.current_user.name,
+                "age": self.current_user.age,
+                "diabetes_type": self.current_user.diabetes_type,
+                "device_type": self.current_user.device_type,
+                "years_with_diabetes": self.current_user.years_with_diabetes,
+                "typical_pattern": getattr(self.current_user, 'typical_glucose_pattern', 'normal')
+            },
+            "statistics": self._safe_convert_for_json(self.calculated_stats),
+            "patterns": self._safe_convert_for_json(self.identified_patterns),
+            "data_points": len(self.processed_glucose_data) if self.processed_glucose_data is not None else 0,
+            "recent_readings": self._get_recent_readings_for_agent(),
+            "data_metadata": {
+                "source": self.data_source,
+                "loaded_at": self.data_loaded_at.isoformat() if self.data_loaded_at else None,
+                "data_age_minutes": int((datetime.now() - self.data_loaded_at).total_seconds() / 60) if self.data_loaded_at else None
+            }
+        }
+        
+        return context
+    
+    def get_chart_data(self) -> Optional[pd.DataFrame]:
+        """Get processed data for chart display"""
+        return self.processed_glucose_data
+    
+    def _calculate_unified_stats(self) -> Dict[str, Any]:
+        """Calculate statistics using a single, consistent method"""
+        if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+            return {"error": "No data available"}
+        
+        try:
+            # Get glucose values
+            glucose_values = self.processed_glucose_data['value'].dropna()
+            
+            if len(glucose_values) == 0:
+                return {"error": "No valid glucose values"}
+            
+            # Convert to numpy array for consistent calculations
+            import numpy as np
+            values = np.array(glucose_values.tolist(), dtype=float)
+            
+            # Calculate basic statistics
+            avg_glucose = float(np.mean(values))
+            min_glucose = float(np.min(values))
+            max_glucose = float(np.max(values))
+            std_glucose = float(np.std(values))
+            total_readings = int(len(values))
+            
+            # Calculate time in ranges - CONSISTENT METHOD
+            in_range_mask = (values >= 70) & (values <= 180)
+            below_range_mask = values < 70
+            above_range_mask = values > 180
+            
+            in_range_count = int(np.sum(in_range_mask))
+            below_range_count = int(np.sum(below_range_mask))
+            above_range_count = int(np.sum(above_range_mask))
+            
+            # Calculate percentages
+            time_in_range = (in_range_count / total_readings) * 100 if total_readings > 0 else 0
+            time_below_70 = (below_range_count / total_readings) * 100 if total_readings > 0 else 0
+            time_above_180 = (above_range_count / total_readings) * 100 if total_readings > 0 else 0
+            
+            # Calculate additional metrics
+            gmi = 3.31 + (0.02392 * avg_glucose)  # Glucose Management Indicator
+            cv = (std_glucose / avg_glucose) * 100 if avg_glucose > 0 else 0  # Coefficient of Variation
+            
+            stats = {
+                "average_glucose": avg_glucose,
+                "min_glucose": min_glucose,
+                "max_glucose": max_glucose,
+                "std_glucose": std_glucose,
+                "time_in_range_70_180": time_in_range,
+                "time_below_70": time_below_70,
+                "time_above_180": time_above_180,
+                "total_readings": total_readings,
+                "gmi": gmi,
+                "cv": cv,
+                "in_range_count": in_range_count,
+                "below_range_count": below_range_count,
+                "above_range_count": above_range_count
+            }
+            
+            # Log for debugging
+            logger.info(f"Calculated stats - TIR: {time_in_range:.1f}%, Total: {total_readings}, In range: {in_range_count}")
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error calculating unified stats: {e}")
+            return {"error": f"Statistics calculation failed: {str(e)}"}
+    
+    def _generate_realistic_mock_data(self, user_key: str) -> list:
+        """Generate realistic mock data with SARAH having UNSTABLE patterns"""
+        
+        # MODIFIED: Sarah now has unstable glucose patterns
+        pattern_map = {
+            "sarah_g7": "unstable_high_variability",  # CHANGED: Sarah now unstable
+            "marcus_one": "dawn_phenomenon", 
+            "jennifer_g6": "normal",
+            "robert_receiver": "dawn_phenomenon"
+        }
+        
+        user_pattern = pattern_map.get(user_key, "normal")
+        
+        # Generate 14 days of data with specific patterns
+        if user_key == "sarah_g7":
+            # Generate UNSTABLE data for Sarah
+            mock_data = self._generate_unstable_glucose_data()
+            logger.info(f"Generated {len(mock_data)} UNSTABLE mock data points for Sarah")
+        else:
+            # Use normal patterns for other users
+            mock_data = self._create_realistic_pattern(days=14, user_type=user_pattern)
+            logger.info(f"Generated {len(mock_data)} mock data points for {user_key} with pattern {user_pattern}")
+        
+        return mock_data
+    
+    def _generate_unstable_glucose_data(self) -> list:
+        """Generate highly variable, unstable glucose data for Sarah"""
+        readings = []
+        now = datetime.now()
+        
+        # Generate 14 days of unstable data (every 5 minutes)
+        total_minutes = 14 * 24 * 60
+        interval_minutes = 5
+        total_readings = total_minutes // interval_minutes
+        
+        logger.info(f"Generating {total_readings} unstable glucose readings for Sarah")
+        
+        for i in range(total_readings):
+            timestamp = now - timedelta(minutes=total_minutes - (i * interval_minutes))
+            
+            # Create highly variable glucose patterns
+            hour = timestamp.hour
+            day_of_week = timestamp.weekday()
+            
+            # Base glucose with high variability
+            if hour >= 6 and hour <= 8:  # Morning - dawn phenomenon + high variability
+                base_glucose = random.uniform(140, 220)
+                variability = random.uniform(-40, 60)
+            elif hour >= 12 and hour <= 14:  # Lunch - post-meal spikes
+                base_glucose = random.uniform(120, 280)
+                variability = random.uniform(-30, 80)
+            elif hour >= 18 and hour <= 20:  # Dinner - high spikes
+                base_glucose = random.uniform(130, 300)
+                variability = random.uniform(-50, 70)
+            elif hour >= 22 or hour <= 4:  # Night - unpredictable lows and highs
+                base_glucose = random.uniform(60, 200)
+                variability = random.uniform(-30, 50)
+            else:  # Other times - still unstable
+                base_glucose = random.uniform(80, 220)
+                variability = random.uniform(-40, 60)
+            
+            # Add weekend effect (even more unstable)
+            if day_of_week >= 5:  # Weekend
+                base_glucose += random.uniform(-20, 40)
+                variability += random.uniform(-20, 30)
+            
+            # Add random noise for high variability
+            noise = random.uniform(-25, 25)
+            glucose_value = base_glucose + variability + noise
+            
+            # Ensure realistic bounds but allow extreme values
+            glucose_value = max(40, min(400, glucose_value))
+            
+            # Add some random severe lows and highs
+            if random.random() < 0.05:  # 5% chance of severe events
+                if random.random() < 0.5:
+                    glucose_value = random.uniform(45, 65)  # Severe low
+                else:
+                    glucose_value = random.uniform(280, 350)  # Severe high
+            
+            # Determine trend based on glucose change
+            if i > 0:
+                prev_glucose = readings[-1]['value']
+                glucose_change = glucose_value - prev_glucose
+                
+                if glucose_change > 15:
+                    trend = "rising_rapidly"
+                elif glucose_change > 5:
+                    trend = "rising"
+                elif glucose_change < -15:
+                    trend = "falling_rapidly"
+                elif glucose_change < -5:
+                    trend = "falling"
+                else:
+                    trend = "flat"
+            else:
+                trend = "flat"
+            
+            reading = {
+                "systemTime": timestamp.isoformat(),
+                "displayTime": timestamp.isoformat(),
+                "value": round(glucose_value, 1),
+                "trend": trend,
+                "realtimeValue": round(glucose_value, 1),
+                "smoothedValue": round(glucose_value * 0.9 + random.uniform(-5, 5), 1)
+            }
+            
+            readings.append(reading)
+        
+        # Log statistics of generated data
+        values = [r['value'] for r in readings]
+        avg_glucose = np.mean(values)
+        std_glucose = np.std(values)
+        cv = (std_glucose / avg_glucose) * 100
+        
+        in_range = sum(1 for v in values if 70 <= v <= 180)
+        below_range = sum(1 for v in values if v < 70)
+        above_range = sum(1 for v in values if v > 180)
+        
+        tir = (in_range / len(values)) * 100
+        tbr = (below_range / len(values)) * 100
+        tar = (above_range / len(values)) * 100
+        
+        logger.info(f"Sarah's UNSTABLE data generated:")
+        logger.info(f"  Average: {avg_glucose:.1f} mg/dL")
+        logger.info(f"  CV: {cv:.1f}% (VERY HIGH)")
+        logger.info(f"  TIR: {tir:.1f}% (LOW)")
+        logger.info(f"  TBR: {tbr:.1f}% (HIGH)")
+        logger.info(f"  TAR: {tar:.1f}% (HIGH)")
+        
+        return readings
+    
+    def _create_realistic_pattern(self, days: int = 14, user_type: str = "normal") -> list:
+        """Create realistic glucose patterns for non-Sarah users"""
+        readings = []
+        now = datetime.now()
+        
+        # Generate data every 5 minutes
+        total_minutes = days * 24 * 60
+        interval_minutes = 5
+        total_readings = total_minutes // interval_minutes
+        
+        for i in range(total_readings):
+            timestamp = now - timedelta(minutes=total_minutes - (i * interval_minutes))
+            hour = timestamp.hour
+            
+            # Base patterns for different user types
+            if user_type == "dawn_phenomenon":
+                if hour >= 6 and hour <= 8:  # Dawn phenomenon
+                    base_glucose = random.uniform(150, 190)
+                elif hour >= 12 and hour <= 14:  # Post lunch
+                    base_glucose = random.uniform(140, 180)
+                elif hour >= 18 and hour <= 20:  # Post dinner
+                    base_glucose = random.uniform(130, 170)
+                else:
+                    base_glucose = random.uniform(90, 140)
+            else:  # Normal pattern
+                if hour >= 12 and hour <= 14:  # Post lunch
+                    base_glucose = random.uniform(120, 160)
+                elif hour >= 18 and hour <= 20:  # Post dinner
+                    base_glucose = random.uniform(110, 150)
+                else:
+                    base_glucose = random.uniform(80, 120)
+            
+            # Add moderate variability
+            glucose_value = base_glucose + random.uniform(-15, 15)
+            glucose_value = max(70, min(250, glucose_value))
+            
+            reading = {
+                "systemTime": timestamp.isoformat(),
+                "displayTime": timestamp.isoformat(),
+                "value": round(glucose_value, 1),
+                "trend": "flat",
+                "realtimeValue": round(glucose_value, 1),
+                "smoothedValue": round(glucose_value, 1)
+            }
+            
+            readings.append(reading)
+        
+        return readings
+    
+    def _get_recent_readings_for_agent(self, count: int = 5) -> list:
+        """Get recent readings formatted for agent context"""
+        if self.processed_glucose_data is None or self.processed_glucose_data.empty:
+            return []
+        
+        try:
+            recent_df = self.processed_glucose_data.tail(count)
+            readings = []
+            
+            for _, row in recent_df.iterrows():
+                display_time = row.get('displayTime') or row.get('systemTime')
+                glucose_value = row.get('value')
+                trend_value = row.get('trend', 'flat')
+                
+                if pd.notna(display_time):
+                    if isinstance(display_time, str):
+                        time_str = display_time
+                    else:
+                        time_str = pd.to_datetime(display_time).isoformat()
+                else:
+                    time_str = datetime.now().isoformat()
+                
+                if pd.notna(glucose_value):
+                    glucose_clean = self._safe_convert_for_json(glucose_value)
+                else:
+                    glucose_clean = None
+                
+                trend_clean = str(trend_value) if pd.notna(trend_value) else 'flat'
+                
+                readings.append({
+                    "time": time_str,
+                    "glucose": glucose_clean,
+                    "trend": trend_clean
+                })
+            
+            return readings
+            
+        except Exception as e:
+            logger.error(f"Error getting recent readings: {e}")
+            return []
+    
+    def _safe_convert_for_json(self, obj):
+        """Safely convert objects for JSON serialization"""
+        import numpy as np
+        
+        if obj is None:
+            return None
+        elif isinstance(obj, (np.integer, np.int64, np.int32)):
+            return int(obj)
+        elif isinstance(obj, (np.floating, np.float64, np.float32)):
+            if np.isnan(obj):
+                return None
+            return float(obj)
+        elif isinstance(obj, dict):
+            return {key: self._safe_convert_for_json(value) for key, value in obj.items()}
+        elif isinstance(obj, list):
+            return [self._safe_convert_for_json(item) for item in obj]
+        elif isinstance(obj, pd.Timestamp):
+            return obj.isoformat()
+        else:
+            return obj
+    
+    def _build_success_response(self) -> Dict[str, Any]:
+        """Build a consistent success response"""
+        data_points = len(self.processed_glucose_data) if self.processed_glucose_data is not None else 0
+        avg_glucose = self.calculated_stats.get('average_glucose', 0)
+        time_in_range = self.calculated_stats.get('time_in_range_70_180', 0)
+        
+        return {
+            "success": True,
+            "message": f"✅ Successfully loaded data for {self.current_user.name}",
+            "user": asdict(self.current_user),
+            "data_points": data_points,
+            "stats": self.calculated_stats,
+            "data_source": self.data_source,
+            "summary": f"📊 {data_points} readings | Avg: {avg_glucose:.1f} mg/dL | TIR: {time_in_range:.1f}% | Source: {self.data_source}"
+        }
+    
+    def validate_data_consistency(self) -> Dict[str, Any]:
+        """Validate that all components are using consistent data"""
+        if not self.calculated_stats:
+            return {"valid": False, "message": "No data loaded"}
+        
+        validation = {
+            "valid": True,
+            "data_source": self.data_source,
+            "data_age_minutes": int((datetime.now() - self.data_loaded_at).total_seconds() / 60) if self.data_loaded_at else None,
+            "total_readings": self.calculated_stats.get('total_readings', 0),
+            "time_in_range": self.calculated_stats.get('time_in_range_70_180', 0),
+            "average_glucose": self.calculated_stats.get('average_glucose', 0),
+            "user": self.current_user.name if self.current_user else None
+        }
+        
+        logger.info(f"Data consistency check: {validation}")
+        
+        return validation
+
+# ADDITIONAL: Debug function to test the API connection as it was working before
+def test_original_api_method():
+    """Test the API exactly as it was working before unified data manager"""
+    from apifunctions import DexcomAPI, DEMO_USERS
+    
+    print("🔍 Testing API exactly as it was working before...")
+    
+    api = DexcomAPI()
+    
+    # Test with sarah_g7 as it was working before
+    user_key = "sarah_g7"
+    user = DEMO_USERS[user_key]
+    
+    print(f"Testing with {user.name} ({user.username}) - NOW WITH UNSTABLE GLUCOSE")
+    
+    try:
+        # Call simulate_demo_login exactly as before
+        access_token = api.simulate_demo_login(user_key)
+        print(f"✅ Authentication: {bool(access_token)}")
+        
+        if access_token:
+            # Call get_egv_data exactly as before
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=14)
+            
+            egv_data = api.get_egv_data(
+                start_date.isoformat(),
+                end_date.isoformat()
+            )
+            
+            print(f"✅ EGV Data: {len(egv_data)} readings")
+            
+            if egv_data:
+                print(f"✅ SUCCESS! API is working as before (with Sarah's unstable patterns)")
+                sample = egv_data[0] if egv_data else {}
+                print(f"Sample reading: {sample}")
+                return True
+            else:
+                print("⚠️  API authenticated but returned no data")
+                return False
+        else:
+            print("❌ Authentication failed")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    # Test the original API method
+    test_original_api_method()