fixes

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

dexcom_real_auth_system.py

@@ -1,147 +1,74 @@
 #!/usr/bin/env python3
 """
-Dexcom Real Authentication System
-Uses your actual CLIENT_ID and CLIENT_SECRET from developer.dexcom.com
+MIXED ENDPOINTS FIX for Dexcom OAuth
+Login endpoint: developer.dexcom.com/sandbox-login (WORKING - you got the code!)
+Token endpoint: sandbox-api.dexcom.com/v2/oauth2/token (FROM OFFICIAL DOCS)
 """
 
+import os
 import requests
+import urllib.parse
 import json
-import base64
 import secrets
-import hashlib
-import urllib.parse
 import webbrowser
-import threading
-import time
 from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Tuple
-from http.server import HTTPServer, BaseHTTPRequestHandler
+from typing import Dict, List, Optional
 import logging
 
-# Set up logging
+# Setup logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# 🔑 YOUR REAL DEXCOM CREDENTIALS (replace with your actual values)
-CLIENT_ID = "YOUR_REAL_CLIENT_ID_HERE"  # Replace with your actual client ID
-CLIENT_SECRET = "YOUR_REAL_CLIENT_SECRET_HERE"  # Replace with your actual client secret
-REDIRECT_URI = "http://localhost:8080/callback"
+# Credentials
+CLIENT_ID = os.getenv("DEXCOM_CLIENT_ID", "mLElKHKRwRDVUrAOPBzktFGY7qkTc7Zm")
+CLIENT_SECRET = os.getenv("DEXCOM_CLIENT_SECRET", "HmFpgyVweuwKrQpf")
+REDIRECT_URI = "http://localhost:7860/callback"
 
-# Dexcom API URLs
-SANDBOX_BASE_URL = "https://sandbox-api.dexcom.com"
-PRODUCTION_BASE_URL = "https://api.dexcom.com"
-
-class OAuth2CallbackHandler(BaseHTTPRequestHandler):
-    """HTTP handler for OAuth2 callback"""
-    
-    def do_GET(self):
-        """Handle GET request for OAuth callback"""
-        if self.path.startswith('/callback'):
-            # Parse the authorization code from the URL
-            parsed_url = urllib.parse.urlparse(self.path)
-            query_params = urllib.parse.parse_qs(parsed_url.query)
-            
-            if 'code' in query_params:
-                # Store the authorization code in the server
-                self.server.auth_code = query_params['code'][0]
-                self.server.auth_error = None
-                
-                # Send success response
-                self.send_response(200)
-                self.send_header('Content-type', 'text/html')
-                self.end_headers()
-                
-                success_html = """
-                <html>
-                <head><title>Dexcom Authorization Successful</title></head>
-                <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                    <h2 style="color: green;">✅ Authorization Successful!</h2>
-                    <p>You have successfully authorized the application to access your Dexcom data.</p>
-                    <p>You can close this window and return to the application.</p>
-                    <script>
-                        setTimeout(function(){
-                            window.close();
-                        }, 3000);
-                    </script>
-                </body>
-                </html>
-                """
-                self.wfile.write(success_html.encode())
-                
-            elif 'error' in query_params:
-                # Handle authorization error
-                error = query_params.get('error', ['Unknown error'])[0]
-                error_description = query_params.get('error_description', [''])[0]
-                
-                self.server.auth_code = None
-                self.server.auth_error = f"{error}: {error_description}"
-                
-                self.send_response(400)
-                self.send_header('Content-type', 'text/html')
-                self.end_headers()
-                
-                error_html = f"""
-                <html>
-                <head><title>Dexcom Authorization Failed</title></head>
-                <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                    <h2 style="color: red;">❌ Authorization Failed</h2>
-                    <p><strong>Error:</strong> {error}</p>
-                    <p><strong>Description:</strong> {error_description}</p>
-                    <p>Please try again or contact support if the problem persists.</p>
-                </body>
-                </html>
-                """
-                self.wfile.write(error_html.encode())
-            else:
-                # Unexpected callback
-                self.send_response(400)
-                self.send_header('Content-type', 'text/html')
-                self.end_headers()
-                self.wfile.write(b"<html><body><h2>Invalid callback</h2></body></html>")
-        else:
-            # 404 for other paths
-            self.send_response(404)
-            self.end_headers()
-    
-    def log_message(self, format, *args):
-        """Suppress default logging"""
-        pass
+# MIXED ENDPOINTS CONFIGURATION
+# Login: Use what worked for you
+# Token: Use official documentation
+SANDBOX_LOGIN_BASE = "https://developer.dexcom.com"        # ✅ WORKED for login
+SANDBOX_TOKEN_BASE = "https://sandbox-api.dexcom.com"      # ✅ OFFICIAL for token
+PRODUCTION_BASE = "https://api.dexcom.com"                 # ✅ OFFICIAL for production
 
 class DexcomRealAPI:
-    """Real Dexcom API client using your actual credentials"""
+    """
+    MIXED ENDPOINTS Dexcom API
     
-    def __init__(self, client_id: str = CLIENT_ID, client_secret: str = CLIENT_SECRET, 
-                 environment: str = "sandbox"):
-        """
-        Initialize Dexcom API client
-        
-        Args:
-            client_id: Your real Dexcom client ID
-            client_secret: Your real Dexcom client secret  
-            environment: "sandbox" or "production"
-        """
-        self.client_id = client_id
-        self.client_secret = client_secret
+    SOLUTION:
+    ✅ Login: developer.dexcom.com/sandbox-login (YOU CONFIRMED THIS WORKS)
+    ✅ Token: sandbox-api.dexcom.com/v2/oauth2/token (OFFICIAL DOCS)
+    ✅ API:   sandbox-api.dexcom.com/v2/... (OFFICIAL DOCS)
+    """
+    
+    def __init__(self, client_id: str = None, client_secret: str = None, environment: str = "sandbox"):
+        self.client_id = client_id or CLIENT_ID
+        self.client_secret = client_secret or CLIENT_SECRET
         self.redirect_uri = REDIRECT_URI
+        self.environment = environment
         
+        # MIXED ENDPOINT CONFIGURATION
         if environment == "sandbox":
-            self.base_url = SANDBOX_BASE_URL
+            self.login_base = SANDBOX_LOGIN_BASE    # https://developer.dexcom.com
+            self.token_base = SANDBOX_TOKEN_BASE    # https://sandbox-api.dexcom.com
+            self.api_base = SANDBOX_TOKEN_BASE      # https://sandbox-api.dexcom.com
         else:
-            self.base_url = PRODUCTION_BASE_URL
+            self.login_base = PRODUCTION_BASE       # https://api.dexcom.com
+            self.token_base = PRODUCTION_BASE       # https://api.dexcom.com
+            self.api_base = PRODUCTION_BASE         # https://api.dexcom.com
             
-        self.environment = environment
         self.access_token = None
         self.refresh_token = None
         self.token_expires_at = None
         
-        # Validate credentials
-        if not client_id or client_id == "YOUR_REAL_CLIENT_ID_HERE":
-            raise ValueError("Please set your real CLIENT_ID")
-        if not client_secret or client_secret == "YOUR_REAL_CLIENT_SECRET_HERE":
-            raise ValueError("Please set your real CLIENT_SECRET")
+        logger.info(f"✅ MIXED ENDPOINTS Dexcom API initialized")
+        logger.info(f"   Environment: {environment}")
+        logger.info(f"   Login base: {self.login_base}")
+        logger.info(f"   Token base: {self.token_base}")
+        logger.info(f"   API base: {self.api_base}")
     
     def generate_auth_url(self, state: str = None) -> str:
-        """Generate OAuth authorization URL"""
+        """Generate OAuth URL using the login endpoint that WORKED for you"""
         if not state:
             state = secrets.token_urlsafe(32)
         
@@ -154,91 +81,91 @@ class DexcomRealAPI:
         }
         
         query_string = urllib.parse.urlencode(params)
-        auth_url = f"{self.base_url}/v2/oauth2/login?{query_string}"
         
-        logger.info(f"Generated authorization URL for {self.environment} environment")
+        # Use the login endpoint that worked for you
+        if self.environment == "sandbox":
+            auth_url = f"{self.login_base}/sandbox-login?{query_string}"
+        else:
+            auth_url = f"{self.login_base}/v2/oauth2/login?{query_string}"
+        
+        logger.info(f"✅ Auth URL (proven working): {auth_url}")
         return auth_url
     
     def start_oauth_flow(self) -> bool:
-        """Start the complete OAuth flow with browser"""
-        print(f"\n🔐 Starting Dexcom OAuth Authentication")
-        print(f"🌐 Environment: {self.environment}")
-        print(f"🔑 Client ID: {self.client_id[:8]}...")
+        """Start OAuth with proven working login endpoint"""
+        print(f"\n🔐 MIXED ENDPOINTS DEXCOM OAUTH")
+        print("=" * 60)
+        print(f"Environment: {self.environment}")
+        print(f"Login endpoint: {self.login_base} ← PROVEN TO WORK FOR YOU")
+        print(f"Token endpoint: {self.token_base} ← FROM OFFICIAL DOCS")
         
         try:
-            # Generate authorization URL
-            state = secrets.token_urlsafe(32)
-            auth_url = self.generate_auth_url(state)
+            auth_url = self.generate_auth_url()
             
-            # Start local callback server
-            server = HTTPServer(('localhost', 8080), OAuth2CallbackHandler)
-            server.timeout = 120  # 2 minute timeout
-            server.auth_code = None
-            server.auth_error = None
+            print(f"\n📋 OAUTH INSTRUCTIONS:")
+            print(f"1. 🌐 Opening: {auth_url}")
+            print(f"2. 📝 Log in (this endpoint worked before!)")
+            if self.environment == "sandbox":
+                print(f"   Sandbox: sandboxuser1@dexcom.com / Dexcom123!")
+            print(f"3. ✅ Authorize application")
+            print(f"4. 📋 Copy authorization code from callback")
+            print(f"5. ⚡ Token exchange with CORRECTED endpoint")
             
-            print(f"🌐 Opening browser for authorization...")
-            print(f"📋 URL: {auth_url}")
-            print(f"⏳ Waiting for authorization (timeout: 2 minutes)...")
-            
-            # Open browser
             webbrowser.open(auth_url)
+            print(f"\n✅ Browser opened to WORKING login endpoint")
+            return True
             
-            # Wait for callback
-            start_time = time.time()
-            while time.time() - start_time < 120:  # 2 minute timeout
-                server.handle_request()
-                if server.auth_code or server.auth_error:
-                    break
-            
-            if server.auth_error:
-                print(f"❌ Authorization failed: {server.auth_error}")
-                return False
-            
-            if not server.auth_code:
-                print(f"❌ Authorization timeout - no response received")
-                return False
-            
-            print(f"✅ Authorization code received!")
-            
-            # Exchange code for tokens
-            success = self.exchange_code_for_tokens(server.auth_code)
-            
-            if success:
-                print(f"🎉 Authentication successful!")
-                print(f"📊 Access token obtained")
-                print(f"⏰ Token expires: {self.token_expires_at}")
-                return True
-            else:
-                print(f"❌ Token exchange failed")
-                return False
-                
         except Exception as e:
-            logger.error(f"OAuth flow error: {e}")
-            print(f"❌ OAuth flow error: {e}")
+            logger.error(f"OAuth start error: {e}")
             return False
     
     def exchange_code_for_tokens(self, authorization_code: str) -> bool:
-        """Exchange authorization code for access and refresh tokens"""
-        url = f"{self.base_url}/v2/oauth2/token"
+        """
+        Exchange code for tokens using CORRECTED token endpoint
+        
+        KEY FIX: Use sandbox-api.dexcom.com for token exchange
+        NOT developer.dexcom.com
+        """
+        
+        # Clean authorization code
+        auth_code = self._extract_auth_code(authorization_code.strip())
+        
+        if not auth_code:
+            logger.error("No valid authorization code provided")
+            return False
+        
+        # CORRECTED TOKEN ENDPOINT (from official docs)
+        token_url = f"{self.token_base}/v2/oauth2/token"
         
+        logger.info(f"🔄 TOKEN EXCHANGE WITH CORRECTED ENDPOINT")
+        logger.info(f"   Login was: {self.login_base} (worked!)")
+        logger.info(f"   Token is: {token_url} ← CORRECTED!")
+        logger.info(f"   Auth code: {auth_code[:15]}...{auth_code[-8:]}")
+        
+        # Request data
         data = {
             'client_id': self.client_id,
             'client_secret': self.client_secret,
-            'code': authorization_code,
+            'code': auth_code,
             'grant_type': 'authorization_code',
             'redirect_uri': self.redirect_uri
         }
         
+        # Headers
         headers = {
             'Content-Type': 'application/x-www-form-urlencoded',
-            'Accept': 'application/json'
+            'Accept': 'application/json',
+            'User-Agent': 'GlycoAI/1.0'
         }
         
         try:
-            logger.info("Exchanging authorization code for tokens...")
-            response = requests.post(url, data=data, headers=headers)
+            print(f"\n📡 Making token request to CORRECTED endpoint...")
+            print(f"   URL: {token_url}")
+            print(f"   Data: client_id, client_secret, code, grant_type, redirect_uri")
             
-            logger.info(f"Token exchange response: {response.status_code}")
+            response = requests.post(token_url, data=data, headers=headers, timeout=30)
+            
+            print(f"📨 Response status: {response.status_code}")
             
             if response.status_code == 200:
                 token_data = response.json()
@@ -246,26 +173,89 @@ class DexcomRealAPI:
                 self.access_token = token_data.get('access_token')
                 self.refresh_token = token_data.get('refresh_token')
                 
-                expires_in = token_data.get('expires_in', 3600)
+                expires_in = token_data.get('expires_in', 7200)
                 self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
                 
-                logger.info("Successfully obtained access and refresh tokens")
+                print(f"✅ TOKEN EXCHANGE SUCCESSFUL!")
+                print(f"   Access token: {self.access_token[:25]}...")
+                print(f"   Refresh token: {self.refresh_token[:25] if self.refresh_token else 'None'}...")
+                print(f"   Expires in: {expires_in} seconds ({expires_in/3600:.1f} hours)")
+                print(f"   Token type: {token_data.get('token_type', 'Bearer')}")
+                
+                logger.info("✅ TOKEN EXCHANGE SUCCESS WITH MIXED ENDPOINTS!")
                 return True
             else:
-                logger.error(f"Token exchange failed: {response.status_code} - {response.text}")
+                print(f"❌ Token exchange failed: {response.status_code}")
+                
+                try:
+                    error_data = response.json()
+                    print(f"📋 Error details:")
+                    for key, value in error_data.items():
+                        print(f"   {key}: {value}")
+                    
+                    # Specific guidance
+                    if response.status_code == 400:
+                        error_type = error_data.get('error', 'unknown')
+                        if error_type == 'invalid_grant':
+                            print(f"\n💡 SOLUTION: Authorization code expired or invalid")
+                            print(f"   → Get a fresh code (expires in 1 minute!)")
+                        elif error_type == 'invalid_client':
+                            print(f"\n💡 SOLUTION: Check credentials")
+                            print(f"   → Verify CLIENT_ID and CLIENT_SECRET")
+                        elif error_type == 'invalid_request':
+                            print(f"\n💡 SOLUTION: Check redirect URI")
+                            print(f"   → Must match: {self.redirect_uri}")
+                    
+                except:
+                    print(f"📋 Raw error response: {response.text}")
+                
                 return False
                 
         except requests.exceptions.RequestException as e:
+            print(f"❌ Network error: {e}")
             logger.error(f"Network error during token exchange: {e}")
             return False
+        except Exception as e:
+            print(f"❌ Unexpected error: {e}")
+            logger.error(f"Unexpected error during token exchange: {e}")
+            return False
+    
+    def _extract_auth_code(self, input_text: str) -> str:
+        """Extract authorization code from various formats"""
+        try:
+            if input_text.startswith('http'):
+                # Full callback URL
+                parsed_url = urllib.parse.urlparse(input_text)
+                query_params = urllib.parse.parse_qs(parsed_url.query)
+                
+                if 'code' in query_params:
+                    code = query_params['code'][0]
+                    logger.info(f"Extracted code from URL: {code[:15]}...")
+                    return code
+                else:
+                    logger.error("No 'code' parameter in callback URL")
+                    return ""
+            else:
+                # Direct code input
+                if input_text.startswith('code='):
+                    code = input_text[5:]
+                else:
+                    code = input_text.strip()
+                
+                logger.info(f"Using direct code input: {code[:15]}...")
+                return code
+                    
+        except Exception as e:
+            logger.error(f"Error extracting auth code: {e}")
+            return ""
     
     def refresh_access_token(self) -> bool:
-        """Refresh the access token using refresh token"""
+        """Refresh token using corrected endpoint"""
         if not self.refresh_token:
             logger.error("No refresh token available")
             return False
         
-        url = f"{self.base_url}/v2/oauth2/token"
+        token_url = f"{self.token_base}/v2/oauth2/token"
         
         data = {
             'client_id': self.client_id,
@@ -280,82 +270,72 @@ class DexcomRealAPI:
         }
         
         try:
-            response = requests.post(url, data=data, headers=headers)
+            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')
-                # Note: Some OAuth providers issue new refresh tokens
-                if 'refresh_token' in token_data:
-                    self.refresh_token = token_data.get('refresh_token')
+                new_refresh_token = token_data.get('refresh_token')
+                if new_refresh_token:
+                    self.refresh_token = new_refresh_token
                 
-                expires_in = token_data.get('expires_in', 3600)
+                expires_in = token_data.get('expires_in', 7200)
                 self.token_expires_at = datetime.now() + timedelta(seconds=expires_in)
                 
-                logger.info("Access token refreshed successfully")
+                logger.info("✅ Token refreshed successfully")
                 return True
             else:
                 logger.error(f"Token refresh failed: {response.status_code} - {response.text}")
                 return False
                 
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Network error during token refresh: {e}")
+        except Exception as e:
+            logger.error(f"Error refreshing token: {e}")
             return False
     
-    def is_token_valid(self) -> bool:
-        """Check if current access token is valid and not expired"""
+    def _ensure_valid_token(self):
+        """Ensure valid access token"""
         if not self.access_token:
-            return False
+            raise Exception("No access token. Please authenticate first.")
         
-        if not self.token_expires_at:
-            return True  # Assume valid if no expiry set
-        
-        # Consider token expired if it expires within next 5 minutes
-        return datetime.now() < (self.token_expires_at - timedelta(minutes=5))
-    
-    def ensure_valid_token(self) -> bool:
-        """Ensure we have a valid access token, refresh if needed"""
-        if not self.is_token_valid():
-            logger.info("Token expired or invalid, attempting refresh...")
-            if self.refresh_token:
-                return self.refresh_access_token()
-            else:
-                logger.error("No refresh token available, re-authentication required")
-                return False
-        return True
+        if self.token_expires_at and datetime.now() >= self.token_expires_at - timedelta(minutes=5):
+            logger.info("Token expiring soon, refreshing...")
+            if not self.refresh_access_token():
+                raise Exception("Token expired and refresh failed. Please re-authenticate.")
     
     def get_auth_headers(self) -> Dict[str, str]:
-        """Get headers with valid authorization token"""
-        if not self.ensure_valid_token():
-            raise Exception("No valid access token available. Please authenticate first.")
+        """Get authorization headers"""
+        self._ensure_valid_token()
         
         return {
             'Authorization': f'Bearer {self.access_token}',
-            'Accept': 'application/json'
+            'Accept': 'application/json',
+            'User-Agent': 'GlycoAI/1.0'
         }
     
     def get_data_range(self) -> Dict:
-        """Get available data range for authenticated user"""
-        url = f"{self.base_url}/v2/users/self/dataRange"
+        """Get data range using corrected API endpoint"""
+        url = f"{self.api_base}/v2/users/self/dataRange"
         headers = self.get_auth_headers()
         
         try:
             response = requests.get(url, headers=headers)
             
             if response.status_code == 200:
-                return response.json()
+                data = response.json()
+                logger.info(f"✅ Data range retrieved: {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 requests.exceptions.RequestException as e:
             logger.error(f"Network error getting data range: {e}")
-            raise Exception(f"Network error getting data range: {e}")
+            raise Exception(f"Network error: {e}")
     
     def get_egv_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
-        """Get Estimated Glucose Values (EGV) data"""
-        url = f"{self.base_url}/v2/users/self/egvs"
+        """Get EGV data using corrected API endpoint"""
+        url = f"{self.api_base}/v2/users/self/egvs"
         headers = self.get_auth_headers()
         
         params = {}
@@ -369,133 +349,60 @@ class DexcomRealAPI:
             
             if response.status_code == 200:
                 data = response.json()
-                return data.get('egvs', [])
+                egvs = data.get('egvs', [])
+                logger.info(f"✅ Retrieved {len(egvs)} EGV readings")
+                return egvs
             else:
                 logger.error(f"EGV API error: {response.status_code} - {response.text}")
                 raise Exception(f"EGV API error: {response.status_code}")
                 
         except requests.exceptions.RequestException as e:
             logger.error(f"Network error getting EGV data: {e}")
-            raise Exception(f"Network error getting EGV data: {e}")
-    
-    def get_events_data(self, start_date: str = None, end_date: str = None) -> List[Dict]:
-        """Get events data (meals, insulin, etc.)"""
-        url = f"{self.base_url}/v2/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)
-            
-            if response.status_code == 200:
-                data = response.json()
-                return data.get('events', [])
-            else:
-                logger.error(f"Events API error: {response.status_code} - {response.text}")
-                raise Exception(f"Events API error: {response.status_code}")
-                
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Network error getting events data: {e}")
-            raise Exception(f"Network error getting events data: {e}")
+            raise Exception(f"Network error: {e}")
 
-def test_real_dexcom_api():
-    """Test the real Dexcom API with your credentials"""
-    print("🧪 Testing Real Dexcom API Integration")
+# Quick test function
+def test_mixed_endpoints():
+    """Test the mixed endpoint configuration"""
+    print("🧪 TESTING MIXED ENDPOINTS CONFIGURATION")
     print("=" * 60)
     
-    try:
-        # Initialize API with your real credentials
-        api = DexcomRealAPI(environment="sandbox")
-        
-        # Start OAuth authentication
-        print("\n🔐 Step 1: Authentication")
-        auth_success = api.start_oauth_flow()
-        
-        if not auth_success:
-            print("❌ Authentication failed - cannot proceed")
-            return False
-        
-        # Test data range
-        print("\n📅 Step 2: Getting Data Range")
+    api = DexcomRealAPI(environment="sandbox")
+    
+    print(f"✅ Login base: {api.login_base}")
+    print(f"   → This worked for you before!")
+    print(f"✅ Token base: {api.token_base}")
+    print(f"   → From official documentation")
+    print(f"✅ API base: {api.api_base}")
+    print(f"   → From official documentation")
+    
+    auth_url = api.generate_auth_url()
+    print(f"\n✅ Auth URL: {auth_url}")
+    print(f"   → Should work (you got code before)")
+    
+    print(f"\n🎯 READY TO TEST TOKEN EXCHANGE!")
+    print(f"1. Run: api.start_oauth_flow()")
+    print(f"2. Get fresh authorization code")
+    print(f"3. Run: api.exchange_code_for_tokens('fresh_code')")
+    print(f"4. Should get 200 OK with corrected token endpoint!")
+    
+    return api
+
+def quick_token_test(auth_code: str):
+    """Quick test of token exchange with mixed endpoints"""
+    api = DexcomRealAPI(environment="sandbox")
+    success = api.exchange_code_for_tokens(auth_code)
+    
+    if success:
+        print(f"\n🎉 SUCCESS! Mixed endpoints work!")
         try:
             data_range = api.get_data_range()
-            print(f"✅ Data range retrieved:")
-            print(f"   EGV: {data_range.get('egvStart', 'N/A')} to {data_range.get('egvEnd', 'N/A')}")
-            print(f"   Events: {data_range.get('eventStart', 'N/A')} to {data_range.get('eventEnd', 'N/A')}")
+            print(f"✅ API test successful: {data_range}")
         except Exception as e:
-            print(f"❌ Data range error: {e}")
-        
-        # Test glucose data
-        print("\n📊 Step 3: Getting Glucose Data")
-        try:
-            # Get last 24 hours
-            end_time = datetime.now()
-            start_time = end_time - timedelta(hours=24)
-            
-            egv_data = api.get_egv_data(
-                start_date=start_time.isoformat(),
-                end_date=end_time.isoformat()
-            )
-            
-            print(f"✅ Retrieved {len(egv_data)} glucose readings")
-            
-            if egv_data:
-                latest = egv_data[-1]
-                print(f"   Latest: {latest['value']} mg/dL at {latest['displayTime']}")
-                print(f"   Trend: {latest.get('trend', 'N/A')}")
-        except Exception as e:
-            print(f"❌ Glucose data error: {e}")
-        
-        # Test events data
-        print("\n🍽️ Step 4: Getting Events Data")
-        try:
-            events_data = api.get_events_data(
-                start_date=start_time.isoformat(),
-                end_date=end_time.isoformat()
-            )
-            
-            print(f"✅ Retrieved {len(events_data)} events")
-            
-            if events_data:
-                carb_events = [e for e in events_data if e.get('eventType') == 'carbs']
-                insulin_events = [e for e in events_data if e.get('eventType') == 'insulin']
-                print(f"   Carb events: {len(carb_events)}")
-                print(f"   Insulin events: {len(insulin_events)}")
-        except Exception as e:
-            print(f"❌ Events data error: {e}")
-        
-        print(f"\n🎉 Real Dexcom API integration completed!")
-        return True
-        
-    except ValueError as e:
-        print(f"❌ Configuration error: {e}")
-        print(f"💡 Please update CLIENT_ID and CLIENT_SECRET with your real credentials")
-        return False
-    except Exception as e:
-        print(f"❌ Unexpected error: {e}")
-        return False
+            print(f"⚠️ Token works but API call failed: {e}")
+    else:
+        print(f"\n❌ Still failed. Let's debug further...")
+    
+    return api
 
 if __name__ == "__main__":
-    print("🔑 Dexcom Real API Authentication System")
-    print("📋 Make sure to update CLIENT_ID and CLIENT_SECRET with your real values!")
-    print()
-    
-    # Run the test
-    test_real_dexcom_api()
-    
-    print(f"\n💡 Usage Example:")
-    print(f"   api = DexcomRealAPI(environment='sandbox')")
-    print(f"   api.start_oauth_flow()  # Opens browser for auth")
-    print(f"   glucose_data = api.get_egv_data()")
-    print(f"   events_data = api.get_events_data()")
-    
-    print(f"\n⚠️  Important Notes:")
-    print(f"   • This uses the real Dexcom sandbox environment")
-    print(f"   • You'll need to authenticate through the browser")
-    print(f"   • Sandbox users are provided by Dexcom (like SandboxUser7)")
-    print(f"   • Update environment='production' for real user data")
+    test_mixed_endpoints()

hybrid_auth.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """
-Hybrid Dexcom Integration
-Combines demo users with optional real Dexcom authentication
+Enhanced Hybrid Dexcom Integration
+Combines demo users with working real Dexcom authentication
+Updated to work with the fixed OAuth system
 """
 
 import os
@@ -129,18 +130,17 @@ class HybridDexcomManager:
     
     def _check_real_auth_available(self) -> bool:
         """Check if real authentication is properly configured"""
-        client_id = os.getenv("DEXCOM_CLIENT_ID")
-        client_secret = os.getenv("DEXCOM_CLIENT_SECRET")
-        
-        # Also check for hardcoded values in the real auth system
         try:
-            from dexcom_real_auth_system import CLIENT_ID, CLIENT_SECRET
-            if CLIENT_ID and CLIENT_ID != "YOUR_REAL_CLIENT_ID_HERE":
-                return True
+            from dexcom_real_auth_system import DexcomRealAPI
+            # Try to create an instance
+            test_api = DexcomRealAPI()
+            return True
         except ImportError:
-            pass
-        
-        return bool(client_id and client_secret)
+            logger.warning("dexcom_real_auth_system module not found")
+            return False
+        except Exception as e:
+            logger.warning(f"Real auth check failed: {e}")
+            return False
     
     def get_user_options(self) -> Dict[str, str]:
         """Get available user options for the UI"""
@@ -155,7 +155,7 @@ class HybridDexcomManager:
         if self.real_auth_enabled:
             options["real_user"] = "🔐 Real Dexcom User (OAuth)"
         else:
-            options["real_user_disabled"] = "🔒 Real Dexcom User (Configure to Enable)"
+            options["real_user_disabled"] = "🔒 Real Dexcom User (Not Available)"
         
         return options
     
@@ -194,30 +194,55 @@ class HybridDexcomManager:
         if not self.real_auth_enabled:
             return {
                 "success": False, 
-                "message": "Real authentication not configured. Check DEXCOM_CLIENT_ID/SECRET"
+                "message": "Real authentication not available. Check dexcom_real_auth_system.py"
             }
         
         try:
-            # Start OAuth flow
+            # Start OAuth flow (this will open browser and expect manual callback)
             auth_success = self.real_api.start_oauth_flow()
             
             if auth_success:
-                # Get real data
+                return {
+                    "success": True,
+                    "message": "✅ OAuth flow started - follow browser instructions",
+                    "user": self._create_real_user_profile(),
+                    "data": None,  # Will be loaded after OAuth completion
+                    "auth_type": "real",
+                    "oauth_pending": True
+                }
+            else:
+                return {"success": False, "message": "OAuth flow failed to start"}
+                
+        except Exception as e:
+            logger.error(f"Real authentication error: {e}")
+            return {"success": False, "message": f"Real authentication failed: {e}"}
+    
+    def complete_real_oauth(self, callback_url: str) -> Dict[str, Any]:
+        """Complete real OAuth with callback URL"""
+        if not self.real_auth_enabled:
+            return {"success": False, "message": "Real auth not available"}
+        
+        try:
+            # Process callback URL
+            success = self.real_api.process_callback_url(callback_url)
+            
+            if success:
+                # Fetch real data
                 real_data = self._fetch_real_data()
                 
                 return {
                     "success": True,
-                    "message": "✅ Real Dexcom user authenticated",
+                    "message": "✅ Real Dexcom authentication completed",
                     "user": self._create_real_user_profile(),
                     "data": real_data,
                     "auth_type": "real"
                 }
             else:
-                return {"success": False, "message": "OAuth authentication failed"}
+                return {"success": False, "message": "Callback URL processing failed"}
                 
         except Exception as e:
-            logger.error(f"Real authentication error: {e}")
-            return {"success": False, "message": f"Real authentication failed: {e}"}
+            logger.error(f"OAuth completion error: {e}")
+            return {"success": False, "message": f"OAuth completion failed: {e}"}
     
     def _fetch_real_data(self) -> Dict[str, Any]:
         """Fetch real data from Dexcom API"""
@@ -240,6 +265,8 @@ class HybridDexcomManager:
                 end_date=end_time.isoformat()
             )
             
+            logger.info(f"Fetched real data: {len(egv_data)} glucose readings")
+            
             return {
                 "data_range": data_range,
                 "egv_data": egv_data,
@@ -259,7 +286,7 @@ class HybridDexcomManager:
             device_type="Real Dexcom Device",
             username="authenticated_real_user",
             password="oauth_token",
-            description="Authenticated real Dexcom user",
+            description="Authenticated real Dexcom user with live data",
             diabetes_type="From Real Data",
             years_with_diabetes=0,
             typical_glucose_pattern="real_data",
@@ -442,7 +469,7 @@ def create_hybrid_ui_components():
                         )
                         demo_buttons.append((key, btn))
             
-            # Real auth button
+            # Real auth section
             with gr.Row():
                 if hybrid_manager.real_auth_enabled:
                     real_auth_btn = gr.Button(
@@ -450,13 +477,35 @@ def create_hybrid_ui_components():
                         variant="primary",
                         size="lg"
                     )
+                    
+                    # OAuth completion components
+                    oauth_instructions = gr.Markdown(
+                        "Click above to start real Dexcom authentication",
+                        visible=True
+                    )
+                    
+                    callback_url_input = gr.Textbox(
+                        label="Callback URL (Paste from browser after 404 error)",
+                        placeholder="http://localhost:7860/callback?code=AUTHORIZATION_CODE&state=...",
+                        lines=2,
+                        visible=False
+                    )
+                    
+                    complete_oauth_btn = gr.Button(
+                        "✅ Complete OAuth",
+                        variant="primary",
+                        visible=False
+                    )
                 else:
                     real_auth_btn = gr.Button(
-                        "🔒 Real Dexcom (Not Configured)\nSet DEXCOM_CLIENT_ID/SECRET",
+                        "🔒 Real Dexcom (Not Available)\nCheck dexcom_real_auth_system.py",
                         variant="secondary",
                         size="lg",
                         interactive=False
                     )
+                    oauth_instructions = gr.Markdown("Real OAuth not available")
+                    callback_url_input = gr.Textbox(visible=False)
+                    complete_oauth_btn = gr.Button(visible=False)
     
     # Status displays
     with gr.Row():
@@ -472,7 +521,7 @@ def create_hybrid_ui_components():
             <h4>🔧 Configuration Status</h4>
             <p>
                 <strong>Demo Mode:</strong> {'✅ Available' if hybrid_manager.demo_enabled else '❌ Disabled'}<br>
-                <strong>Real Auth:</strong> {'✅ Configured' if hybrid_manager.real_auth_enabled else '❌ Not Configured'}<br>
+                <strong>Real Auth:</strong> {'✅ Available' if hybrid_manager.real_auth_enabled else '❌ Not Available'}<br>
                 <strong>Total Users:</strong> {len([u for u in ENHANCED_DEMO_USERS.values() if u.auth_type == 'demo'])} Demo + {'1 Real' if hybrid_manager.real_auth_enabled else '0 Real'}
             </p>
         </div>
@@ -482,6 +531,9 @@ def create_hybrid_ui_components():
         "hybrid_manager": hybrid_manager,
         "demo_buttons": demo_buttons,
         "real_auth_btn": real_auth_btn,
+        "oauth_instructions": oauth_instructions,
+        "callback_url_input": callback_url_input,
+        "complete_oauth_btn": complete_oauth_btn,
         "auth_status": auth_status
     }
 
@@ -506,119 +558,65 @@ def setup_authentication_handlers(components):
             )
     
     def handle_real_auth():
-        """Handle real Dexcom authentication"""
+        """Handle real Dexcom authentication start"""
         result = components["hybrid_manager"].authenticate_user("real_user")
         
         if result["success"]:
+            instructions = f"""
+🚀 **Real Dexcom OAuth Started**
+
+{result['message']}
+
+**Next Steps:**
+1. ✅ Browser should have opened to Dexcom login
+2. 📝 Log in with your real Dexcom credentials
+3. ✅ Authorize the application
+4. ❌ You'll get a 404 error - **THIS IS EXPECTED!**
+5. 📋 Copy the entire URL from your browser
+6. ⬇️ Paste it below and click "Complete OAuth"
+
+**Expected URL format:**
+`http://localhost:7860/callback?code=AUTHORIZATION_CODE&state=...`
+            """
+            
             return (
-                f"✅ {result['message']} - Browser will open for OAuth",
-                gr.update(visible=True),
-                []
+                instructions,
+                gr.update(visible=True),  # Show callback input
+                gr.update(visible=True),  # Show complete button
+                gr.update(visible=False)  # Hide main interface for now
             )
         else:
             return (
                 f"❌ {result['message']}",
                 gr.update(visible=False),
-                []
+                gr.update(visible=False),
+                gr.update(visible=False)
             )
     
-    return handle_demo_auth, handle_real_auth
-
-# Integration with your existing main.py
-def integrate_with_existing_app():
-    """Integration guide for your existing application"""
-    
-    integration_code = '''
-# Add this to your main.py imports
-from hybrid_dexcom_integration import HybridDexcomManager, ENHANCED_DEMO_USERS
-
-class GlucoBuddyApp:
-    def __init__(self):
-        # Replace your existing initialization
-        self.hybrid_manager = HybridDexcomManager()
-        self.data_manager = UnifiedDataManager()
-        self.mistral_chat = GlucoBuddyMistralChat()
+    def handle_oauth_completion(callback_url):
+        """Handle OAuth completion"""
+        if not callback_url or not callback_url.strip():
+            return "❌ Please paste the callback URL", gr.update(visible=False), []
         
-        # UI state
-        self.chat_history = []
-    
-    def select_user(self, user_key: str) -> Tuple[str, str]:
-        """Enhanced user selection with hybrid auth"""
-        try:
-            # Use hybrid authentication
-            auth_result = self.hybrid_manager.authenticate_user(user_key)
-            
-            if not auth_result['success']:
-                return f"❌ {auth_result['message']}", gr.update(visible=False)
-            
-            # Load data based on auth type
-            if auth_result['auth_type'] == 'demo':
-                # Use mock data
-                user = auth_result['user']
-                data = auth_result['data']
-                
-                # Convert to format expected by UnifiedDataManager
-                load_result = self.data_manager.load_mock_data(user, data)
-            else:
-                # Use real data
-                user = auth_result['user']
-                data = auth_result['data']
-                
-                # Convert to format expected by UnifiedDataManager
-                load_result = self.data_manager.load_real_data(user, data)
-            
-            if load_result['success']:
-                self._sync_chat_with_data_manager()
-                self.chat_history = []
-                self.mistral_chat.clear_conversation()
-                
-                return (
-                    f"Connected: {user.name} ({auth_result['auth_type'].upper()}) - Click 'Load Data' to begin",
-                    gr.update(visible=True)
-                )
-            else:
-                return f"❌ Data loading failed: {load_result['message']}", gr.update(visible=False)
-                
-        except Exception as e:
-            logger.error(f"User selection failed: {e}")
-            return f"❌ Selection failed: {e}", gr.update(visible=False)
-
-# Update your user buttons in create_interface()
-def create_enhanced_interface():
-    # Replace the user selection section with:
-    
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 👥 Select User")
-            gr.Markdown("Choose demo users (instant) or real Dexcom authentication")
-            
-            # Demo users
-            with gr.Row():
-                sarah_btn = gr.Button("🎭 Sarah (Demo)\\nG7 Mobile", variant="secondary")
-                marcus_btn = gr.Button("🎭 Marcus (Demo)\\nONE+ Mobile", variant="secondary") 
-                jennifer_btn = gr.Button("🎭 Jennifer (Demo)\\nG6 Mobile", variant="secondary")
-                robert_btn = gr.Button("🎭 Robert (Demo)\\nG6 Receiver", variant="secondary")
-            
-            # Real auth
-            with gr.Row():
-                real_auth_btn = gr.Button(
-                    "🔐 REAL DEXCOM USER\\n(OAuth Authentication)",
-                    variant="primary",
-                    size="lg"
-                )
-    
-    # Connect handlers:
-    sarah_btn.click(lambda: app.select_user("sarah_demo"), outputs=[connection_status, main_interface, chatbot])
-    marcus_btn.click(lambda: app.select_user("marcus_demo"), outputs=[connection_status, main_interface, chatbot])
-    jennifer_btn.click(lambda: app.select_user("jennifer_demo"), outputs=[connection_status, main_interface, chatbot])
-    robert_btn.click(lambda: app.select_user("robert_demo"), outputs=[connection_status, main_interface, chatbot])
-    real_auth_btn.click(lambda: app.select_user("real_user"), outputs=[connection_status, main_interface, chatbot])
-    '''
+        result = components["hybrid_manager"].complete_real_oauth(callback_url)
+        
+        if result["success"]:
+            return (
+                f"✅ {result['message']} - Real data loaded!",
+                gr.update(visible=True),  # Show main interface
+                []  # Clear chat history
+            )
+        else:
+            return (
+                f"❌ {result['message']}",
+                gr.update(visible=False),
+                []
+            )
     
-    return integration_code
+    return handle_demo_auth, handle_real_auth, handle_oauth_completion
 
 if __name__ == "__main__":
-    print("🔧 Hybrid Dexcom Integration - Demo + Real Authentication")
+    print("🔧 Enhanced Hybrid Dexcom Integration")
     print("=" * 60)
     
     # Test the hybrid manager
@@ -634,15 +632,21 @@ if __name__ == "__main__":
         available = "✅" if user.auth_type == "demo" or manager.real_auth_enabled else "❌"
         print(f"  {available} {auth_icon} {user.name}")
     
-    print(f"\n💡 Integration Guide:")
-    print("  1. Import: from hybrid_dexcom_integration import HybridDexcomManager")
-    print("  2. Replace user selection in your main.py")
-    print("  3. Update button handlers to use hybrid authentication")
-    print("  4. Your existing UnifiedDataManager works with both data types!")
+    if manager.real_auth_enabled:
+        print(f"\n🧪 Testing real OAuth availability...")
+        try:
+            from dexcom_real_auth_system import DexcomRealAPI
+            test_api = DexcomRealAPI()
+            print(f"  ✅ DexcomRealAPI can be imported and initialized")
+            print(f"  🔑 Client ID: {test_api.client_id[:8]}...")
+            print(f"  🔄 Redirect URI: {test_api.redirect_uri}")
+        except Exception as e:
+            print(f"  ❌ Error testing real auth: {e}")
     
-    print(f"\n🚀 Benefits:")
+    print(f"\n🚀 Integration Benefits:")
     print("  ✅ Keep all 4 demo users for easy demos")
     print("  ✅ Add real authentication when needed")
     print("  ✅ Seamless switching between demo and real")
+    print("  ✅ Manual OAuth process handles port 7860 correctly")
     print("  ✅ No changes needed to existing chat/UI logic")
-    print("  ✅ Progressive enhancement - works with/without real auth")
+    print("  ✅ Works with/without real auth configuration")

main.py

@@ -1,6 +1,6 @@
 """
 GlycoAI - AI-Powered Glucose Insights
-Main Gradio application with prominent, centralized load data button
+Main Gradio application with both demo users AND real Dexcom OAuth
 """
 
 import gradio as gr
@@ -11,6 +11,8 @@ import pandas as pd
 from typing import Optional, Tuple, List
 import logging
 import os
+import webbrowser
+import urllib.parse
 
 # Load environment variables from .env file
 from dotenv import load_dotenv
@@ -32,8 +34,17 @@ from apifunctions import (
     format_glucose_data_for_display
 )
 
+# Import real Dexcom OAuth (now working!)
+try:
+    from dexcom_real_auth_system import DexcomRealAPI
+    REAL_OAUTH_AVAILABLE = True
+    logger.info("✅ Real Dexcom OAuth available")
+except ImportError as e:
+    REAL_OAUTH_AVAILABLE = False
+    logger.warning(f"⚠️ Real Dexcom OAuth not available: {e}")
+
 class GlucoBuddyApp:
-    """Main application class for GlucoBuddy with unified data management"""
+    """Main application class for GlucoBuddy with demo users AND real OAuth"""
 
     def __init__(self):
         # Validate environment before initializing
@@ -46,8 +57,12 @@ class GlucoBuddyApp:
         # Chat interface (will use data manager's context)
         self.mistral_chat = GlucoBuddyMistralChat()
         
+        # Real OAuth API (if available)
+        self.real_api = DexcomRealAPI(environment="sandbox") if REAL_OAUTH_AVAILABLE else None
+        
         # UI state
         self.chat_history = []
+        self.current_user_type = None  # "demo" or "real"
 
     def select_demo_user(self, user_key: str) -> Tuple[str, str]:
         """Handle demo user selection and load data consistently"""
@@ -62,6 +77,7 @@ class GlucoBuddyApp:
                 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()
@@ -71,28 +87,239 @@ class GlucoBuddyApp:
             self.mistral_chat.clear_conversation()
 
             return (
-                f"Connected: {user.name} ({user.device_type}) - Click 'Load Data' to begin", 
+                f"Connected: {user.name} ({user.device_type}) - DEMO DATA - Click 'Load Data' to begin", 
                 gr.update(visible=True)
             )
 
         except Exception as e:
-            logger.error(f"User selection failed: {str(e)}")
+            logger.error(f"Demo user selection failed: {str(e)}")
             return f"❌ Connection failed: {str(e)}", gr.update(visible=False)
 
+    def start_real_oauth(self) -> str:
+        """Start real Dexcom OAuth process"""
+        if not REAL_OAUTH_AVAILABLE:
+            return """
+❌ **Real Dexcom OAuth Not Available**
+
+The real authentication module is not properly configured.
+Please ensure:
+1. dexcom_real_auth_system.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
+            success = self.real_api.start_oauth_flow()
+            
+            if success:
+                return f"""
+🚀 **Real Dexcom OAuth Started**
+
+**SIMPLIFIED PROCESS FOR PORT 7860:**
+
+1. ✅ Browser should have opened to Dexcom login page
+2. 📝 Log in with your **real Dexcom account credentials**
+   - For sandbox testing: `sandboxuser1@dexcom.com` / `Dexcom123!`
+3. ✅ Authorize GlycoAI to access your data  
+4. ❌ **You will get a 404 error - THIS IS EXPECTED!**
+5. 📋 **Copy ONLY the authorization code** from the URL
+
+**Example callback URL:**
+`http://localhost:7860/callback?code=ABC123XYZ&state=...`
+
+**Copy just this part:** `ABC123XYZ`
+
+**Why simpler?** Your token generator script works perfectly with just the code, so we're using the same approach!
+                """
+            else:
+                return "❌ Failed to start OAuth process. Check console for details."
+                
+        except Exception as e:
+            logger.error(f"OAuth start error: {e}")
+            return f"❌ OAuth error: {str(e)}"
+
+    def complete_real_oauth(self, auth_code_input: str) -> Tuple[str, str]:
+        """Complete real OAuth with authorization code (like the working script)"""
+        if not REAL_OAUTH_AVAILABLE:
+            return "❌ Real OAuth not available", gr.update(visible=False)
+        
+        if not auth_code_input or not auth_code_input.strip():
+            return "❌ Please paste the authorization code", gr.update(visible=False)
+        
+        try:
+            # Clean up the input - handle both full URLs and just codes
+            auth_code = self._extract_auth_code(auth_code_input.strip())
+            
+            if not auth_code:
+                return "❌ No authorization code found in input", gr.update(visible=False)
+            
+            logger.info(f"Processing authorization code: {auth_code[:20]}...")
+            
+            # Use the same method as the working script - direct token exchange
+            success = self.real_api.exchange_code_for_tokens(auth_code)
+            
+            if success:
+                logger.info("✅ Token exchange successful")
+                
+                # Load real data into data manager
+                real_data_result = self._load_real_dexcom_data()
+                
+                if real_data_result['success']:
+                    self.current_user_type = "real"
+                    
+                    # 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: Real Dexcom User - LIVE DATA - Click 'Load Data' to begin",
+                        gr.update(visible=True)
+                    )
+                else:
+                    return f"❌ Data loading failed: {real_data_result['message']}", gr.update(visible=False)
+            else:
+                return "❌ Token exchange failed - check the authorization code", gr.update(visible=False)
+                
+        except Exception as e:
+            logger.error(f"OAuth completion error: {e}")
+            return f"❌ OAuth completion failed: {str(e)}", gr.update(visible=False)
+    
+    def _extract_auth_code(self, input_text: str) -> str:
+        """Extract authorization code from various input formats"""
+        try:
+            # If it's a full URL, parse it
+            if input_text.startswith('http'):
+                parsed_url = urllib.parse.urlparse(input_text)
+                query_params = urllib.parse.parse_qs(parsed_url.query)
+                
+                if 'code' in query_params:
+                    return query_params['code'][0]
+                else:
+                    logger.warning(f"No 'code' parameter found in URL: {input_text}")
+                    return ""
+            else:
+                # Assume it's just the authorization code
+                # Remove any "code=" prefix if present
+                if input_text.startswith('code='):
+                    return input_text[5:]
+                else:
+                    return input_text
+                    
+        except Exception as e:
+            logger.error(f"Error extracting auth code: {e}")
+            return ""
+
+    def _load_real_dexcom_data(self) -> dict:
+        """Load real Dexcom data through the unified data manager"""
+        try:
+            # Get data range
+            data_range = self.real_api.get_data_range()
+            
+            # Get glucose data (last 14 days)
+            end_time = datetime.now()
+            start_time = end_time - timedelta(days=14)
+            
+            egv_data = self.real_api.get_egv_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            # Get events data
+            events_data = self.real_api.get_events_data(
+                start_date=start_time.isoformat(),
+                end_date=end_time.isoformat()
+            )
+            
+            # Create a real user profile
+            from dataclasses import dataclass
+            
+            @dataclass
+            class RealDexcomUser:
+                name: str = "Real Dexcom User"
+                age: int = 0
+                device_type: str = "Real Dexcom Device"
+                username: str = "authenticated_user"
+                password: str = "oauth_token"
+                description: str = "Authenticated real Dexcom user with live data"
+                diabetes_type: str = "Real Patient"
+                years_with_diabetes: int = 0
+                typical_glucose_pattern: str = "real_data"
+            
+            real_user = RealDexcomUser()
+            
+            # Process the real data through unified data manager
+            # Convert to format expected by data manager
+            formatted_data = {
+                "data_range": data_range,
+                "egv_data": egv_data,
+                "events_data": events_data,
+                "source": "real_dexcom_api"
+            }
+            
+            # Load into data manager
+            self.data_manager.current_user = real_user
+            self.data_manager.processed_glucose_data = pd.DataFrame(egv_data) if egv_data else pd.DataFrame()
+            
+            if not self.data_manager.processed_glucose_data.empty:
+                # Process timestamps
+                self.data_manager.processed_glucose_data['systemTime'] = pd.to_datetime(
+                    self.data_manager.processed_glucose_data['systemTime']
+                )
+                self.data_manager.processed_glucose_data['displayTime'] = pd.to_datetime(
+                    self.data_manager.processed_glucose_data['displayTime']
+                )
+                self.data_manager.processed_glucose_data['value'] = pd.to_numeric(
+                    self.data_manager.processed_glucose_data['value'], errors='coerce'
+                )
+                
+                # Calculate stats
+                from apifunctions import GlucoseAnalyzer
+                self.data_manager.calculated_stats = GlucoseAnalyzer.calculate_basic_stats(
+                    self.data_manager.processed_glucose_data
+                )
+                self.data_manager.identified_patterns = GlucoseAnalyzer.identify_patterns(
+                    self.data_manager.processed_glucose_data
+                )
+            
+            logger.info(f"Loaded real Dexcom data: {len(egv_data)} glucose readings")
+            
+            return {
+                'success': True,
+                'message': f'Loaded {len(egv_data)} real glucose readings'
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to load real Dexcom data: {e}")
+            return {
+                'success': False,
+                'message': f'Failed to load real data: {str(e)}'
+            }
+
     def load_glucose_data(self) -> Tuple[str, go.Figure]:
         """Load and display glucose data using unified manager"""
         if not self.data_manager.current_user:
-            return "Please select a demo user first", None
+            return "Please select a user first (demo or real Dexcom)", None
 
         try:
-            # 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
+            # For real users, we already loaded the data during OAuth
+            if self.current_user_type == "real":
+                if self.data_manager.processed_glucose_data.empty:
+                    return "No real glucose data available", None
+            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
             stats = self.data_manager.get_stats_for_ui()
@@ -122,11 +349,15 @@ class GlucoBuddyApp:
             # Calculate date range
             end_date = datetime.now()
             start_date = end_date - timedelta(days=14)
-
+            
+            # Determine data source
+            data_source = "REAL DEXCOM DATA" if self.current_user_type == "real" else "DEMO DATA"
+            
             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}
@@ -160,6 +391,10 @@ class GlucoBuddyApp:
 • **Improved Trend Analysis:** Identifies consistent patterns vs. one-time events
 • **Better Clinical Insights:** More reliable data for healthcare decisions
 • **AI Consistency:** Same data used for chat analysis and UI display
+
+### Authentication Status
+• **User Type:** {self.current_user_type.upper() if self.current_user_type else 'Unknown'}
+• **OAuth Status:** {'✅ Authenticated with real Dexcom account' if self.current_user_type == 'real' else '🎭 Using demo data for testing'}
             """
 
             chart = self.create_glucose_chart()
@@ -223,6 +458,12 @@ class GlucoBuddyApp:
         else:
             templates.append("What are the best practices for preventing hypoglycemia in my situation?")
 
+        # Add data source specific template
+        if self.current_user_type == "real":
+            templates.append("This is my real Dexcom data. What insights can you provide about my actual 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]:
@@ -231,7 +472,7 @@ class GlucoBuddyApp:
             return "", history
 
         if not self.data_manager.current_user:
-            response = "Please select a demo user first to get personalized insights about glucose data."
+            response = "Please select a user first (demo or real Dexcom) to get personalized insights about glucose data."
             history.append([message, response])
             return "", history
 
@@ -252,9 +493,16 @@ class GlucoBuddyApp:
                     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
+                data_type = "real Dexcom data" if self.current_user_type == "real" else "demo data"
+                if self.current_user_type == "real":
+                    response += f"\n\n🔐 *This analysis is based on your real Dexcom data from your authenticated account.*"
+                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 += "\n\n💡 *For more personalized advice, make sure your glucose data is loaded.*"
+                    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."
 
@@ -329,10 +577,11 @@ class GlucoBuddyApp:
         # Get current stats for title
         stats = self.data_manager.get_stats_for_ui()
         tir = stats.get('time_in_range_70_180', 0)
+        data_type = "REAL" if self.current_user_type == "real" else "DEMO"
         
         fig.update_layout(
             title={
-                'text': f"14-Day Glucose Trends - {self.data_manager.current_user.name} (TIR: {tir:.1f}%)",
+                'text': f"14-Day Glucose Trends - {self.data_manager.current_user.name} ({data_type} DATA - TIR: {tir:.1f}%)",
                 'x': 0.5,
                 'xanchor': 'center'
             },
@@ -354,7 +603,7 @@ class GlucoBuddyApp:
 
 
 def create_interface():
-    """Create the Gradio interface with prominent, centralized load data button"""
+    """Create the Gradio interface with demo users AND real OAuth"""
     app = GlucoBuddyApp()
 
     custom_css = """
@@ -392,47 +641,11 @@ def create_interface():
         transform: translateY(-2px) !important;
         box-shadow: 0 12px 40px rgba(102, 126, 234, 0.6) !important;
     }
-    .data-status-card {
-        background: #f8f9fa;
-        border: 2px solid #e9ecef;
-        border-radius: 10px;
-        padding: 1rem;
-        margin: 0.5rem 0;
-        text-align: center;
-        font-weight: 500;
-    }
-    .data-status-success {
-        border-color: #28a745;
-        background: #d4edda;
-        color: #155724;
-    }
-    .data-status-error {
-        border-color: #dc3545;
-        background: #f8d7da;
-        color: #721c24;
-    }
-    .user-card {
-        background: #f8f9fa;
-        border: 1px solid #dee2e6;
-        border-radius: 8px;
-        padding: 1rem;
-        margin: 0.5rem;
-    }
-    .template-button {
-        margin: 0.25rem;
-        padding: 0.5rem;
-        font-size: 0.9rem;
-    }
-    .chat-container {
-        background: #f8f9fa;
-        border-radius: 10px;
-        padding: 1rem;
-    }
-    .section-divider {
-        height: 2px;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        border-radius: 1px;
-        margin: 2rem 0;
+    .real-oauth-button {
+        background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%) !important;
+        color: white !important;
+        border: none !important;
+        font-weight: bold !important;
     }
     """
 
@@ -457,7 +670,7 @@ def create_interface():
                         </div>
                     </div>
                     <p style="margin-top: 1rem; font-size: 1rem; color: white; opacity: 0.8;">
-                        Connect your Dexcom CGM data and chat with AI for personalized glucose insights
+                        Connect your Dexcom CGM data OR try demo users and chat with AI for personalized glucose insights
                     </p>
                 </div>
                 """)
@@ -465,30 +678,83 @@ def create_interface():
         # User Selection Section
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### 👥 Select Demo User")
-                gr.Markdown("Choose from our demo users to explore GlycoAI's chat capabilities")
+                gr.Markdown("### 👥 Choose Your Data Source")
+                gr.Markdown("Select demo users for instant testing OR authenticate with your real Dexcom account")
+
+                # Demo Users Section
+                with gr.Group():
+                    gr.Markdown("#### 🎭 Demo Users (Instant Access)")
+                    gr.Markdown("*Realistic demo data for testing GlycoAI's capabilities*")
+
+                    with gr.Row():
+                        sarah_btn = gr.Button(
+                            "Sarah Thompson\n(G7 Mobile - Stable Control)",
+                            variant="secondary",
+                            size="lg"
+                        )
+                        marcus_btn = gr.Button(
+                            "Marcus Rodriguez\n(ONE+ Mobile - Type 2)",
+                            variant="secondary",
+                            size="lg"
+                        )
+                        jennifer_btn = gr.Button(
+                            "Jennifer Chen\n(G6 Mobile - Athletic)",
+                            variant="secondary",
+                            size="lg"
+                        )
+                        robert_btn = gr.Button(
+                            "Robert Williams\n(G6 Receiver - Experienced)",
+                            variant="secondary",
+                            size="lg"
+                        )
 
-                with gr.Row():
-                    sarah_btn = gr.Button(
-                        "Sarah Thompson\n(G7 Mobile)",
-                        variant="secondary",
-                        size="lg"
-                    )
-                    marcus_btn = gr.Button(
-                        "Marcus Rodriguez\n(ONE+ Mobile)",
-                        variant="secondary",
-                        size="lg"
-                    )
-                    jennifer_btn = gr.Button(
-                        "Jennifer Chen\n(G6 Mobile)",
-                        variant="secondary",
-                        size="lg"
-                    )
-                    robert_btn = gr.Button(
-                        "Robert Williams\n(G6 Receiver)",
-                        variant="secondary",
-                        size="lg"
-                    )
+                # Real OAuth Section (if available)
+                if REAL_OAUTH_AVAILABLE:
+                    with gr.Group():
+                        gr.Markdown("#### 🔐 Real Dexcom Authentication")
+                        gr.Markdown("*Connect your actual Dexcom account for live glucose data analysis*")
+                        
+                        with gr.Row():
+                            real_oauth_btn = gr.Button(
+                                "🚀 Connect Real Dexcom Account\n(OAuth Authentication)",
+                                variant="primary",
+                                size="lg",
+                                elem_classes=["real-oauth-button"]
+                            )
+                        
+                        oauth_instructions = gr.Markdown(
+                            "Click above to start real Dexcom authentication",
+                            visible=True
+                        )
+                        
+                        with gr.Row():
+                            auth_code_input = gr.Textbox(
+                                label="Authorization Code (from callback URL after 404 error)",
+                                placeholder="ABC123XYZ... (just the code part, not the full URL)",
+                                lines=2,
+                                visible=False
+                            )
+                            complete_oauth_btn = gr.Button(
+                                "✅ Complete OAuth",
+                                variant="primary",
+                                visible=False
+                            )
+                else:
+                    with gr.Group():
+                        gr.Markdown("#### 🔒 Real Dexcom Authentication (Unavailable)")
+                        gr.Markdown("*Real OAuth is not configured. Please check your setup.*")
+                        
+                        gr.Button(
+                            "🔒 Real OAuth Not Available\n(Check Configuration)",
+                            variant="secondary",
+                            size="lg",
+                            interactive=False
+                        )
+                        
+                        # Create dummy variables for consistency
+                        oauth_instructions = gr.Markdown("Real OAuth not available")
+                        auth_code_input = gr.Textbox(visible=False)
+                        complete_oauth_btn = gr.Button(visible=False)
 
         # Connection Status
         with gr.Row():
@@ -500,7 +766,7 @@ def create_interface():
             )
 
         # Section Divider
-        gr.HTML('<div class="section-divider"></div>')
+        gr.HTML('<div style="height: 2px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 1px; margin: 2rem 0;"></div>')
 
         # PROMINENT CENTRALIZED DATA LOADING SECTION
         with gr.Group(visible=False) as main_interface:
@@ -518,7 +784,7 @@ def create_interface():
                     pass  # Right spacer
 
             # Section Divider
-            gr.HTML('<div class="section-divider"></div>')
+            gr.HTML('<div style="height: 2px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 1px; margin: 2rem 0;"></div>')
 
             # Main Content Tabs
             with gr.Tabs():
@@ -536,7 +802,7 @@ def create_interface():
 
                 # Chat Tab
                 with gr.TabItem("💬 Chat with AI"):
-                    with gr.Column(elem_classes=["chat-container"]):
+                    with gr.Column():
                         gr.Markdown("### 🤖 Chat with GlycoAI about your glucose data")
                         gr.Markdown("*📊 Load your data using the button above to enable personalized AI insights*")
                         
@@ -548,25 +814,22 @@ def create_interface():
                                     template1_btn = gr.Button(
                                         "🎯 Analyze My 14-Day Patterns",
                                         variant="secondary",
-                                        size="sm",
-                                        elem_classes=["template-button"]
+                                        size="sm"
                                     )
                                     template2_btn = gr.Button(
                                         "⚡ Improve My Control",
                                         variant="secondary",
-                                        size="sm",
-                                        elem_classes=["template-button"]
+                                        size="sm"
                                     )
                                     template3_btn = gr.Button(
                                         "🍽️ Meal Management Tips",
                                         variant="secondary",
-                                        size="sm",
-                                        elem_classes=["template-button"]
+                                        size="sm"
                                     )
 
                         # Chat Interface
                         chatbot = gr.Chatbot(
-                            label="💬 Chat with GlycoAI (Unified Data)",
+                            label="💬 Chat with GlycoAI (Demo + Real Data)",
                             height=500,
                             show_label=True,
                             container=True,
@@ -606,7 +869,7 @@ def create_interface():
                         data_display = gr.Markdown("Click 'Load 14-Day Glucose Data' above to see your comprehensive analysis", container=True)
 
         # Event Handlers
-        def handle_user_selection(user_key):
+        def handle_demo_user_selection(user_key):
             status, interface_visibility = app.select_demo_user(user_key)
             return status, interface_visibility, []
 
@@ -631,29 +894,46 @@ def create_interface():
                 return app.chat_with_mistral(message, history)
             return "", history
 
-        # Connect Event Handlers
-        user_selection_outputs = [connection_status, main_interface, chatbot]
-
+        # Connect Event Handlers for Demo Users
         sarah_btn.click(
-            lambda: handle_user_selection("sarah_g7"),
+            lambda: handle_demo_user_selection("sarah_g7"),
             outputs=[connection_status, main_interface, chatbot]
         )
 
         marcus_btn.click(
-            lambda: handle_user_selection("marcus_one"),
+            lambda: handle_demo_user_selection("marcus_one"),
             outputs=[connection_status, main_interface, chatbot]
         )
 
         jennifer_btn.click(
-            lambda: handle_user_selection("jennifer_g6"),
+            lambda: handle_demo_user_selection("jennifer_g6"),
             outputs=[connection_status, main_interface, chatbot]
         )
 
         robert_btn.click(
-            lambda: handle_user_selection("robert_receiver"),
+            lambda: handle_demo_user_selection("robert_receiver"),
             outputs=[connection_status, main_interface, chatbot]
         )
 
+        # Connect Event Handlers for Real OAuth (if available)
+        if REAL_OAUTH_AVAILABLE:
+            real_oauth_btn.click(
+                app.start_real_oauth,
+                outputs=[oauth_instructions]
+            ).then(
+                lambda: (gr.update(visible=True), gr.update(visible=True)),
+                outputs=[auth_code_input, complete_oauth_btn]
+            )
+
+            complete_oauth_btn.click(
+                app.complete_real_oauth,
+                inputs=[auth_code_input],
+                outputs=[connection_status, main_interface]
+            ).then(
+                lambda: [],  # Clear chatbot
+                outputs=[chatbot]
+            )
+
         # PROMINENT DATA LOADING - Single button updates all views
         load_data_btn.click(
             handle_load_data,
@@ -697,14 +977,15 @@ def create_interface():
 
         # Footer
         with gr.Row():
-            gr.HTML("""
+            gr.HTML(f"""
             <div style="text-align: center; padding: 2rem; margin-top: 2rem; border-top: 1px solid #dee2e6; color: #6c757d;">
                 <p><strong>⚠️ Important Medical Disclaimer</strong></p>
                 <p>GlycoAI is for informational and educational purposes only. Always consult your healthcare provider 
                 before making any changes to your diabetes management plan. This tool does not replace professional medical advice.</p>
                 <p style="margin-top: 1rem; font-size: 0.9rem;">
                     🔒 Your data is processed securely and not stored permanently. 
-                    💡 Powered by Dexcom API integration and Mistral AI.
+                    💡 Powered by Dexcom API integration and Mistral AI.<br>
+                    {"🎭 Demo data available instantly • 🔐 Real OAuth: " + ("Available" if REAL_OAUTH_AVAILABLE else "Not configured")}
                 </p>
             </div>
             """)
@@ -714,7 +995,11 @@ def create_interface():
 
 def main():
     """Main function to launch the application"""
-    print("🚀 Starting GlycoAI - AI-Powered Glucose Insights (Enhanced UI)...")
+    print("🚀 Starting GlycoAI - AI-Powered Glucose Insights (Demo + Real OAuth)...")
+    
+    # Check OAuth availability
+    oauth_status = "✅ Available" if REAL_OAUTH_AVAILABLE else "❌ Not configured"
+    print(f"🔐 Real Dexcom OAuth: {oauth_status}")
     
     # Validate environment before starting
     print("🔍 Validating environment configuration...")
@@ -729,13 +1014,18 @@ def main():
         # Create and launch the interface
         demo = create_interface()
         
-        print("🎯 GlycoAI is starting with enhanced UI design...")
-        print("📊 Features: Prominent load button, unified data management, consistent metrics")
+        print("🎯 GlycoAI is starting with enhanced features...")
+        print("📊 Features: Demo users + Real OAuth, unified data management, consistent metrics")
+        print("🎭 Demo users: 4 realistic profiles for instant testing")
+        if REAL_OAUTH_AVAILABLE:
+            print("🔐 Real OAuth: Available - connect your actual Dexcom account")
+        else:
+            print("🔒 Real OAuth: Not configured - demo users only")
         
         # Launch with custom settings
         demo.launch(
             server_name="0.0.0.0",  # Allow external access
-            server_port=7860,       # Default Gradio port
+            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

mistral_chat.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
 """
-GlucoBuddy Mistral Chat Integration - Compatible with Unified Data Manager
-Clean, standard dotenv approach with unified data consistency
+Enhanced GlucoBuddy Mistral Chat Integration
+Improved rate limit handling and fallback strategies
 """
 
 import os
 import json
 import logging
 import sys
+import time
 from typing import Any, Dict, List, Optional, Union
 from datetime import datetime, timedelta
 import pandas as pd
@@ -169,8 +170,8 @@ class GlucoseDataGenerator:
         else:
             return 'flat'
 
-class MistralAPIClient:
-    """Simple Mistral API client"""
+class EnhancedMistralAPIClient:
+    """Enhanced Mistral API client with better rate limit handling"""
     
     def __init__(self, api_key: str = None, agent_id: str = None):
         self.api_key = api_key or MISTRAL_API_KEY
@@ -186,15 +187,27 @@ class MistralAPIClient:
             "Content-Type": "application/json"
         })
         
-        logger.info("MistralAPIClient initialized successfully")
+        # Rate limit handling
+        self.last_request_time = 0
+        self.min_request_interval = 1.0  # Minimum seconds between requests
+        
+        # Model fallback chain
+        self.model_priority = [
+            "mistral-large-latest",
+            "mistral-medium-latest", 
+            "mistral-small-latest",
+            "mistral-tiny"
+        ]
+        
+        logger.info("Enhanced MistralAPIClient initialized with rate limit handling")
     
     def test_connection(self) -> Dict[str, Any]:
-        """Test API connection"""
+        """Test API connection with lightweight request"""
         try:
             response = self.session.post(
                 f"{self.base_url}/chat/completions",
                 json={
-                    "model": "mistral-tiny",
+                    "model": "mistral-tiny",  # Use smallest model for testing
                     "messages": [{"role": "user", "content": "Hello"}],
                     "max_tokens": 5
                 },
@@ -206,7 +219,7 @@ class MistralAPIClient:
             elif response.status_code == 401:
                 return {"success": False, "message": "Invalid API key"}
             elif response.status_code == 429:
-                return {"success": False, "message": "Rate limit exceeded"}
+                return {"success": False, "message": "Rate limit exceeded - API is accessible but busy"}
             else:
                 return {"success": False, "message": f"API error: {response.status_code}"}
                 
@@ -217,76 +230,154 @@ class MistralAPIClient:
         except Exception as e:
             return {"success": False, "message": f"Unexpected error: {str(e)}"}
     
-    def chat_completion(self, messages: List[Dict], model: str = "mistral-large-latest") -> Dict[str, Any]:
-        """Send chat completion request"""
-        try:
-            payload = {
-                "model": model,
-                "messages": messages,
-                "max_tokens": 800,
-                "temperature": 0.7
-            }
-            
-            response = self.session.post(
-                f"{self.base_url}/chat/completions",
-                json=payload,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                return {
-                    "success": True,
-                    "response": result["choices"][0]["message"]["content"],
-                    "usage": result.get("usage", {})
-                }
-            else:
-                error_detail = self._extract_error_message(response)
-                return {
-                    "success": False,
-                    "error": f"API error {response.status_code}: {error_detail}"
-                }
+    def _wait_for_rate_limit(self):
+        """Ensure minimum time between requests"""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+        
+        if time_since_last < self.min_request_interval:
+            sleep_time = self.min_request_interval - time_since_last
+            logger.debug(f"Rate limiting: waiting {sleep_time:.2f}s")
+            time.sleep(sleep_time)
+        
+        self.last_request_time = time.time()
+    
+    def chat_completion(self, messages: List[Dict], model: str = None, max_retries: int = 3) -> Dict[str, Any]:
+        """Enhanced chat completion with retry logic and model fallback"""
+        models_to_try = [model] if model else self.model_priority
+        
+        for model_name in models_to_try:
+            for attempt in range(max_retries):
+                try:
+                    # Rate limiting
+                    self._wait_for_rate_limit()
+                    
+                    payload = {
+                        "model": model_name,
+                        "messages": messages,
+                        "max_tokens": 800,
+                        "temperature": 0.7
+                    }
+                    
+                    logger.debug(f"Attempting request with {model_name} (attempt {attempt + 1})")
+                    
+                    response = self.session.post(
+                        f"{self.base_url}/chat/completions",
+                        json=payload,
+                        timeout=30
+                    )
+                    
+                    if response.status_code == 200:
+                        result = response.json()
+                        logger.info(f"✅ Success with {model_name}")
+                        return {
+                            "success": True,
+                            "response": result["choices"][0]["message"]["content"],
+                            "usage": result.get("usage", {}),
+                            "model_used": model_name,
+                            "attempt": attempt + 1
+                        }
+                    
+                    elif response.status_code == 429:
+                        # Rate limit exceeded
+                        retry_after = int(response.headers.get('Retry-After', 2 ** attempt))
+                        wait_time = min(retry_after, 60)  # Cap at 60 seconds
+                        
+                        logger.warning(f"Rate limit hit with {model_name}, waiting {wait_time}s (attempt {attempt + 1})")
+                        
+                        if attempt < max_retries - 1:
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            # Try next model if available
+                            break
+                    
+                    elif response.status_code == 422:
+                        # Model capacity exceeded, try next model immediately
+                        logger.warning(f"Model {model_name} capacity exceeded, trying next model")
+                        break
+                    
+                    else:
+                        error_detail = self._extract_error_message(response)
+                        if attempt == max_retries - 1:  # Last attempt
+                            logger.error(f"API error {response.status_code} with {model_name}: {error_detail}")
+                            break
+                        else:
+                            logger.warning(f"API error {response.status_code} with {model_name}, retrying...")
+                            time.sleep(2 ** attempt)  # Exponential backoff
                 
-        except requests.exceptions.Timeout:
-            return {"success": False, "error": "Request timed out"}
-        except requests.exceptions.RequestException as e:
-            return {"success": False, "error": f"Network error: {str(e)}"}
-        except Exception as e:
-            return {"success": False, "error": f"Unexpected error: {str(e)}"}
+                except requests.exceptions.Timeout:
+                    if attempt == max_retries - 1:
+                        logger.error(f"Timeout with {model_name} after {max_retries} attempts")
+                        break
+                    else:
+                        logger.warning(f"Timeout with {model_name}, retrying...")
+                        time.sleep(2 ** attempt)
+                
+                except requests.exceptions.RequestException as e:
+                    if attempt == max_retries - 1:
+                        logger.error(f"Network error with {model_name}: {str(e)}")
+                        break
+                    else:
+                        logger.warning(f"Network error with {model_name}, retrying...")
+                        time.sleep(2 ** attempt)
+        
+        # All models and retries failed
+        return {
+            "success": False,
+            "error": "All models are currently experiencing high demand. Please try again in a few minutes.",
+            "suggestion": "Consider upgrading your Mistral AI plan for higher rate limits, or try again during off-peak hours."
+        }
     
     def agent_completion(self, messages: List[Dict]) -> Dict[str, Any]:
-        """Send request to Mistral agent (if agent_id is available)"""
+        """Enhanced agent completion with retry logic"""
         if not self.agent_id:
             return {"success": False, "error": "No agent ID configured"}
         
-        try:
-            payload = {
-                "agent_id": self.agent_id,
-                "messages": messages,
-                "max_tokens": 800
-            }
-            
-            response = self.session.post(
-                f"{self.base_url}/agents/completions",
-                json=payload,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                return {
-                    "success": True,
-                    "response": result["choices"][0]["message"]["content"]
-                }
-            else:
-                error_detail = self._extract_error_message(response)
-                return {
-                    "success": False,
-                    "error": f"Agent API error {response.status_code}: {error_detail}"
+        max_retries = 2  # Fewer retries for agent calls
+        
+        for attempt in range(max_retries):
+            try:
+                self._wait_for_rate_limit()
+                
+                payload = {
+                    "agent_id": self.agent_id,
+                    "messages": messages,
+                    "max_tokens": 800
                 }
                 
-        except Exception as e:
-            return {"success": False, "error": f"Agent request failed: {str(e)}"}
+                response = self.session.post(
+                    f"{self.base_url}/agents/completions",
+                    json=payload,
+                    timeout=30
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    return {
+                        "success": True,
+                        "response": result["choices"][0]["message"]["content"]
+                    }
+                elif response.status_code == 429:
+                    retry_after = int(response.headers.get('Retry-After', 5))
+                    if attempt < max_retries - 1:
+                        logger.warning(f"Agent rate limit, waiting {retry_after}s")
+                        time.sleep(retry_after)
+                        continue
+                else:
+                    error_detail = self._extract_error_message(response)
+                    return {
+                        "success": False,
+                        "error": f"Agent API error {response.status_code}: {error_detail}"
+                    }
+                    
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    return {"success": False, "error": f"Agent request failed: {str(e)}"}
+                else:
+                    time.sleep(2)
+        
+        return {"success": False, "error": "Agent request failed after retries"}
     
     def _extract_error_message(self, response) -> str:
         """Extract error message from API response"""
@@ -298,12 +389,11 @@ class MistralAPIClient:
 
 class GlucoBuddyMistralChat:
     """
-    Main chat interface for glucose data analysis with Mistral AI
-    Compatible with unified data manager for consistent metrics
+    Enhanced chat interface with better error handling and user feedback
     """
     
     def __init__(self, mistral_api_key: str = None, mistral_agent_id: str = None):
-        self.mistral_client = MistralAPIClient(mistral_api_key, mistral_agent_id)
+        self.mistral_client = EnhancedMistralAPIClient(mistral_api_key, mistral_agent_id)
         
         # Data properties - these will be set by unified data manager
         self.current_user: Optional[DemoUser] = None
@@ -315,6 +405,10 @@ class GlucoBuddyMistralChat:
         self.conversation_history = []
         self.max_history = 10
         
+        # Error tracking
+        self.consecutive_errors = 0
+        self.last_successful_model = None
+        
         self.logger = logging.getLogger(self.__class__.__name__)
     
     def test_connection(self) -> Dict[str, Any]:
@@ -395,7 +489,7 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
         return base_prompt + context_addition
     
     def chat_with_mistral(self, user_message: str, prefer_agent: bool = False) -> Dict[str, Any]:
-        """Main chat function using externally managed data"""
+        """Enhanced chat function with better error handling"""
         if not user_message.strip():
             return {"success": False, "error": "Please enter a message"}
         
@@ -417,6 +511,7 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
                 agent_result = self.mistral_client.agent_completion(messages)
                 if agent_result["success"]:
                     self._update_conversation_history(user_message, agent_result["response"])
+                    self.consecutive_errors = 0  # Reset error counter
                     return {
                         "success": True,
                         "response": agent_result["response"],
@@ -424,33 +519,69 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
                         "context_included": not context.get("error")
                     }
                 else:
-                    self.logger.warning(f"Agent failed, trying chat completion: {agent_result['error']}")
+                    self.logger.warning(f"Agent failed: {agent_result['error']}")
             
-            # Use chat completion API
+            # Use enhanced chat completion API
             chat_result = self.mistral_client.chat_completion(messages)
             
             if chat_result["success"]:
                 self._update_conversation_history(user_message, chat_result["response"])
+                self.consecutive_errors = 0  # Reset error counter
+                self.last_successful_model = chat_result.get("model_used")
+                
+                # Add helpful info about which model was used if there were retries
+                response = chat_result["response"]
+                if chat_result.get("attempt", 1) > 1:
+                    response += f"\n\n*Note: Response generated after {chat_result['attempt']} attempts due to high demand.*"
+                
                 return {
                     "success": True,
-                    "response": chat_result["response"],
+                    "response": response,
                     "method": "chat_completion",
                     "context_included": not context.get("error"),
-                    "usage": chat_result.get("usage", {})
+                    "usage": chat_result.get("usage", {}),
+                    "model_used": chat_result.get("model_used")
                 }
             else:
+                self.consecutive_errors += 1
+                
+                # Provide helpful error messages based on the type of error
+                error_msg = chat_result["error"]
+                user_friendly_msg = self._get_user_friendly_error(error_msg)
+                
                 return {
                     "success": False,
-                    "error": chat_result["error"]
+                    "error": user_friendly_msg,
+                    "suggestion": chat_result.get("suggestion", ""),
+                    "consecutive_errors": self.consecutive_errors
                 }
             
         except Exception as e:
             self.logger.error(f"Chat error: {e}")
+            self.consecutive_errors += 1
             return {
                 "success": False,
-                "error": f"Unexpected chat error: {str(e)}"
+                "error": f"I'm experiencing technical difficulties. Please try again in a moment.",
+                "consecutive_errors": self.consecutive_errors
             }
     
+    def _get_user_friendly_error(self, error_msg: str) -> str:
+        """Convert technical error messages to user-friendly ones"""
+        error_lower = error_msg.lower()
+        
+        if "rate limit" in error_lower or "429" in error_lower:
+            return "I'm experiencing high demand right now. Please wait a moment and try again."
+        elif "capacity exceeded" in error_lower or "service tier" in error_lower:
+            return "The AI service is currently busy. Please try again in a few minutes."
+        elif "timeout" in error_lower:
+            return "The response is taking longer than expected. Please try again."
+        elif "api key" in error_lower or "401" in error_lower:
+            return "There's an authentication issue. Please contact support."
+        elif "network" in error_lower:
+            return "I'm having trouble connecting. Please check your internet connection and try again."
+        else:
+            return "I'm experiencing technical difficulties. Please try again or rephrase your question."
+    
     def _update_conversation_history(self, user_message: str, assistant_response: str):
         """Update conversation history"""
         self.conversation_history.extend([
@@ -462,12 +593,13 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
             self.conversation_history = self.conversation_history[-self.max_history * 2:]
     
     def clear_conversation(self):
-        """Clear conversation history"""
+        """Clear conversation history and reset error counters"""
         self.conversation_history = []
+        self.consecutive_errors = 0
         self.logger.info("Conversation history cleared")
     
     def get_status(self) -> Dict[str, Any]:
-        """Get current system status"""
+        """Get current system status with enhanced information"""
         api_status = self.test_connection()
         
         return {
@@ -479,7 +611,9 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
             "current_user": self.current_user.name if self.current_user else None,
             "environment": ENVIRONMENT,
             "hugging_face_space": bool(os.getenv("SPACE_ID")),
-            "agent_available": bool(MISTRAL_AGENT_ID)
+            "agent_available": bool(MISTRAL_AGENT_ID),
+            "consecutive_errors": self.consecutive_errors,
+            "last_successful_model": self.last_successful_model
         }
     
     def _safe_convert_to_json(self, obj):
@@ -547,20 +681,37 @@ CRITICAL: Use these EXACT values in your responses. Do not recalculate or estima
             self.logger.error(f"Error extracting recent readings: {e}")
             return []
 
-# Legacy compatibility methods (for standalone use)
+# Update the main.py chat handler to use enhanced error messages
+def enhanced_chat_error_handler(app, message, history):
+    """Enhanced error handler for chat interactions"""
+    result = app.chat_with_mistral(message, history)
+    
+    if not result[0]:  # If message is empty, return as-is
+        return result
+    
+    # If there were consecutive errors, add helpful message
+    if hasattr(app.mistral_chat, 'consecutive_errors') and app.mistral_chat.consecutive_errors > 2:
+        error_help = "\n\n💡 *Multiple errors detected. This usually indicates high API demand. Consider trying again later or during off-peak hours.*"
+        if result[1] and len(result[1]) > 0:
+            last_response = result[1][-1][1] if len(result[1][-1]) > 1 else ""
+            if "technical difficulties" in last_response or "try again" in last_response:
+                result[1][-1][1] += error_help
+    
+    return result
+
+# Legacy compatibility
 def create_enhanced_cli():
-    """Enhanced command-line interface"""
-    print("🩺 GlucoBuddy Chat Interface")
+    """Enhanced CLI with better error handling"""
+    print("🩺 GlucoBuddy Chat Interface (Enhanced)")
     print("=" * 50)
     
-    # Validate environment
     if not validate_environment():
         print("❌ Environment validation failed. Please check your configuration.")
         return
     
     try:
         chat = GlucoBuddyMistralChat()
-        print("✅ Chat system initialized successfully!")
+        print("✅ Enhanced chat system initialized!")
     except Exception as e:
         print(f"❌ Failed to initialize chat system: {e}")
         return
@@ -572,19 +723,17 @@ def create_enhanced_cli():
     if connection_test["success"]:
         print(f"✅ {connection_test['message']}")
     else:
-        print(f"❌ {connection_test['message']}")
-        if input("Continue anyway? (y/n): ").lower() != 'y':
-            return
-    
-    print("\n📋 Available commands:")
-    print("  /status          - Show system status")
-    print("  /clear           - Clear conversation history")
-    print("  /test            - Test API connection")
-    print("  /help            - Show this help")
-    print("  /quit            - Exit")
-    print("\n💬 Or just type your glucose-related questions!")
-    print("⚠️  Note: For full functionality, use the Gradio interface with unified data management")
-    print("\n" + "=" * 50)
+        print(f"⚠️ {connection_test['message']}")
+        print("💡 The chat will still work but may experience rate limits.")
+    
+    print("\n📋 Enhanced features:")
+    print("  • Automatic retry on rate limits")
+    print("  • Model fallback (large → medium → small → tiny)")
+    print("  • Better error messages")
+    print("  • Smart rate limiting")
+    
+    print("\n💬 Start chatting! (Type /quit to exit)")
+    print("=" * 50)
     
     while True:
         try:
@@ -593,135 +742,42 @@ def create_enhanced_cli():
             if not user_input:
                 continue
             
-            # Handle commands
-            if user_input.startswith('/'):
-                command_parts = user_input[1:].split()
-                command = command_parts[0].lower()
-                
-                if command == 'quit':
-                    print("\n👋 Thanks for using GlucoBuddy! Stay healthy! 🌟")
-                    break
-                
-                elif command == 'help':
-                    print("\n📋 Commands:")
-                    print("  /status       - System status")
-                    print("  /clear        - Clear chat history")
-                    print("  /test         - Test API")
-                    print("  /quit         - Exit")
-                    continue
-                
-                elif command == 'clear':
-                    chat.clear_conversation()
-                    print("🧹 Conversation cleared!")
-                    continue
-                
-                elif command == 'status':
-                    status = chat.get_status()
-                    print(f"\n📊 System Status:")
-                    print(f"  🌐 API Connected: {'✅' if status['api_connected'] else '❌'} {status['api_message']}")
-                    print(f"  👤 User Loaded: {'✅' if status['user_loaded'] else '❌'} {status.get('current_user', 'None')}")
-                    print(f"  📊 Data Available: {'✅' if status['data_available'] else '❌'}")
-                    print(f"  💬 Messages in Chat: {status['conversation_messages']}")
-                    print(f"  🏠 Environment: {status['environment']}")
-                    print(f"  🤗 Hugging Face Space: {'✅' if status['hugging_face_space'] else '❌'}")
-                    print(f"  🤖 Agent Available: {'✅' if status['agent_available'] else '❌'}")
-                    continue
-                
-                elif command == 'test':
-                    print("🔍 Testing connection...")
-                    test_result = chat.test_connection()
-                    print(f"{'✅' if test_result['success'] else '❌'} {test_result['message']}")
-                    continue
-                
-                else:
-                    print(f"❌ Unknown command: /{command}")
-                    print("💡 Use /help to see available commands")
-                    continue
-            
-            # Regular chat message
-            print("🤔 Processing your question...")
-            print("⚠️  Note: No user data loaded. Responses will be general diabetes advice.")
+            if user_input == '/quit':
+                print("\n👋 Thanks for using GlucoBuddy Enhanced! 🌟")
+                break
             
-            # Send to Mistral
-            result = chat.chat_with_mistral(user_input, prefer_agent=True)
+            print("🤔 Processing...")
+            result = chat.chat_with_mistral(user_input)
             
             if result['success']:
-                method_info = f" [{result.get('method', 'unknown')}]"
-                print(f"\n🤖 GlucoBuddy{method_info}: {result['response']}")
-                
-                # Show usage info if available
-                usage = result.get('usage', {})
-                if usage:
-                    tokens = usage.get('total_tokens', 0)
-                    if tokens > 0:
-                        print(f"\n📊 Tokens used: {tokens}")
+                model_info = f" [{result.get('model_used', 'unknown')}]" if result.get('model_used') else ""
+                print(f"\n🤖 GlucoBuddy{model_info}: {result['response']}")
             else:
-                print(f"\n❌ Error: {result['error']}")
-                
-                # Provide helpful suggestions based on error type
-                error_msg = result['error'].lower()
-                if 'api key' in error_msg or '401' in error_msg:
-                    print("💡 Check your Mistral API key configuration")
-                elif 'rate limit' in error_msg or '429' in error_msg:
-                    print("💡 Rate limit reached - please wait a moment before trying again")
-                elif 'timeout' in error_msg:
-                    print("💡 Request timed out - please try again")
-                else:
-                    print("💡 Use /test to check your connection")
+                print(f"\n❌ {result['error']}")
+                if result.get('suggestion'):
+                    print(f"💡 {result['suggestion']}")
         
         except KeyboardInterrupt:
-            print("\n\n👋 Thanks for using GlucoBuddy! Take care! 🌟")
+            print("\n👋 Goodbye!")
             break
         except Exception as e:
             print(f"\n❌ Unexpected error: {e}")
-            print("💡 Try /status to check system state")
 
 def main():
-    """Main function with menu system"""
-    print("🩺 GlucoBuddy - AI-Powered Glucose Chat Assistant")
+    """Enhanced main function"""
+    print("🩺 GlucoBuddy Enhanced - Better Rate Limit Handling")
     print("=" * 60)
     
-    # Validate configuration first
-    print("🔍 Validating configuration...")
     if not validate_environment():
-        print("\n❌ Configuration validation failed!")
-        print("Please set up your environment variables before continuing.")
         return
     
-    print("✅ Configuration validation passed!")
+    print("🚀 Enhanced features:")
+    print("  ✅ Automatic retry with exponential backoff")
+    print("  ✅ Model fallback chain (large → small)")
+    print("  ✅ Smart rate limiting")
+    print("  ✅ User-friendly error messages")
     
-    print("\n🎯 Choose an option:")
-    print("1. 💬 Start standalone chat (limited functionality)")
-    print("2. 🚀 Run quick demo")
-    print("3. 🔧 Show configuration")
-    print("4. ❌ Exit")
-    print("\n💡 For full functionality with glucose data, use: python main.py")
-    
-    while True:
-        try:
-            choice = input("\nEnter your choice (1-4): ").strip()
-            
-            if choice == '1':
-                create_enhanced_cli()
-                break
-            elif choice == '2':
-                print("🚀 Quick demo requires the unified data manager.")
-                print("💡 Please run: python main.py")
-                break
-            elif choice == '3':
-                validate_environment()
-                break
-            elif choice == '4':
-                print("👋 Goodbye!")
-                break
-            else:
-                print("❌ Invalid choice. Please enter 1, 2, 3, or 4.")
-        
-        except KeyboardInterrupt:
-            print("\n👋 Goodbye!")
-            break
-        except Exception as e:
-            print(f"❌ Error: {e}")
+    create_enhanced_cli()
 
 if __name__ == "__main__":
     main()