Update app.py

app.py

@@ -1,61 +1,39 @@
-# Updated Gemma SaaS Gradio app with Hugging Face OAuth login + key listing
-# Save this as `gemma_saas_gradio_oauth.py`
-
-# IMPORTANT: Before running, set these environment variables (in your Space secrets or .env):
-# SUPABASE_URL, SUPABASE_KEY, HF_OAUTH_CLIENT_ID, HF_OAUTH_CLIENT_SECRET,
-# HF_OAUTH_REDIRECT_URI (e.g. https://<your-space>.hf.space/hf_callback),
-# ADMIN_EMAIL (optional), MODEL_NAME (optional), HF_TOKEN (optional for model preloading)
-
-# NOTE: When deploying to Hugging Face Spaces, register the redirect URI in the
-# Hugging Face OAuth app settings to exactly match HF_OAUTH_REDIRECT_URI.
-
 import os
+import uuid
 import json
 import asyncio
 import logging
+import time
 from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Any, List
 
 import gradio as gr
 import aiohttp
-import secrets
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from dotenv import load_dotenv
 from pydantic import BaseModel, ValidationError
-from fastapi import Request
-from starlette.responses import HTMLResponse
+import secrets
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 
-# Optional transformer/model imports (kept like before)
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+# ----------------- Configuration & Models -----------------
+load_dotenv()
 
-# ----------------- Config -----------------
 @dataclass
 class Config:
-    SUPABASE_URL: str = os.getenv("SUPABASE_URL", "")
-    SUPABASE_KEY: str = os.getenv("SUPABASE_KEY", "")
-    HF_TOKEN: str = os.getenv("HF_TOKEN", "")  # optional; used for loading model directly
-    HF_OAUTH_CLIENT_ID: str = os.getenv("HF_OAUTH_CLIENT_ID", "")
-    HF_OAUTH_CLIENT_SECRET: str = os.getenv("HF_OAUTH_CLIENT_SECRET", "")
-    HF_OAUTH_REDIRECT_URI: str = os.getenv("HF_OAUTH_REDIRECT_URI", "")
-    HF_OAUTH_PORT: int = int(os.getenv("HF_OAUTH_PORT", "8000"))
-    MODEL_NAME: str = os.getenv("MODEL_NAME", "google/gemma-3-270m-it")
-    JWT_SECRET: str = os.getenv("JWT_SECRET", secrets.token_urlsafe(32))
-    RATE_LIMIT_PER_HOUR: int = int(os.getenv("RATE_LIMIT_PER_HOUR", "100"))
-    MAX_TOKENS: int = int(os.getenv("MAX_TOKENS", "500"))
+    HF_TOKEN: str = os.getenv("HF_TOKEN", "")
+    MODEL_NAME: str = os.getenv("MODEL_NAME", "google/gemma-2-9b-it")
+    MAX_TOKENS: int = int(os.getenv("MAX_TOKENS", "1500"))
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
-    ADMIN_EMAIL: str = os.getenv("ADMIN_EMAIL", "")
 
 class GenerationRequest(BaseModel):
     prompt: str
-    max_tokens: int = 200
-    temperature: float = 0.7
+    max_tokens: int = 500
+    temperature: float = 0.75
     top_k: int = 50
     top_p: float = 0.95
-    repetition_penalty: float = 1.0
-
-class UserCreate(BaseModel):
-    name: str
-    email: str
-    plan: str = "free"
+    repetition_penalty: float = 1.1
 
 class APIResponse(BaseModel):
     success: bool
@@ -63,13 +41,13 @@ class APIResponse(BaseModel):
     error: Optional[str] = None
     timestamp: datetime = datetime.now()
 
-# ----------------- Logging -----------------
+# ----------------- Enhanced Logger -----------------
 def setup_logger():
-    cfg = Config()
     logging.basicConfig(
-        level=getattr(logging, cfg.LOG_LEVEL),
+        level=getattr(logging, Config().LOG_LEVEL),
         format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
         handlers=[
+            logging.FileHandler('gemma_saas.log'),
             logging.StreamHandler()
         ]
     )
@@ -77,177 +55,7 @@ def setup_logger():
 
 logger = setup_logger()
 
-# ----------------- Database Manager -----------------
-class DatabaseManager:
-    def __init__(self, config: Config):
-        self.config = config
-        self.headers = {
-            "apikey": config.SUPABASE_KEY,
-            "Authorization": f"Bearer {config.SUPABASE_KEY}",
-            "Content-Type": "application/json"
-        }
-
-    async def create_user(self, user_data: UserCreate, hf_user_id: str = None, hf_token: str = None) -> Tuple[bool, str, str]:
-        try:
-            # Check existing by email
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    f"{self.config.SUPABASE_URL}/rest/v1/users?email=eq.{user_data.email}",
-                    headers=self.headers
-                ) as response:
-                    if response.status == 200:
-                        existing_users = await response.json()
-                        if existing_users:
-                            return False, "❌ User with this email already exists", ""
-
-            api_key = self._generate_api_key()
-            data = {
-                "name": user_data.name.strip(),
-                "email": user_data.email.strip(),
-                "api_key": api_key,
-                "hf_user_id": hf_user_id,
-                "hf_token": hf_token,
-                "requests": 0,
-                "plan": user_data.plan,
-                "created_at": datetime.utcnow().isoformat(),
-                "last_request": None,
-                "requests_this_hour": 0,
-                "rate_limit_reset": (datetime.utcnow() + timedelta(hours=1)).isoformat(),
-                "tokens_used": 0
-            }
-
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
-                    f"{self.config.SUPABASE_URL}/rest/v1/users",
-                    headers=self.headers,
-                    data=json.dumps(data)
-                ) as response:
-                    if response.status in (200, 201):
-                        logger.info(f"User created: {user_data.email}")
-                        return True, f"✅ User created successfully for {user_data.name}", api_key
-                    else:
-                        text = await response.text()
-                        logger.error(f"Error creating user: {text}")
-                        return False, f"❌ Error creating user: {text}", ""
-
-        except Exception as e:
-            logger.error(f"DB create_user error: {e}")
-            return False, f"❌ Database error: {str(e)}", ""
-
-    def _generate_api_key(self) -> str:
-        return f"gsa_{secrets.token_urlsafe(32)}"
-
-    async def get_user_by_email(self, email: str) -> Optional[Dict]:
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    f"{self.config.SUPABASE_URL}/rest/v1/users?email=eq.{email}&select=*",
-                    headers=self.headers
-                ) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return data[0] if data else None
-        except Exception as e:
-            logger.error(f"DB get_user_by_email error: {e}")
-            return None
-
-    async def upsert_hf_token_for_email(self, email: str, hf_token: str, hf_user_id: Optional[str] = None) -> bool:
-        try:
-            user = await self.get_user_by_email(email)
-            payload = {"hf_token": hf_token}
-            if hf_user_id:
-                payload["hf_user_id"] = hf_user_id
-
-            async with aiohttp.ClientSession() as session:
-                if user:
-                    # Patch existing
-                    async with session.patch(
-                        f"{self.config.SUPABASE_URL}/rest/v1/users?email=eq.{email}",
-                        headers=self.headers,
-                        data=json.dumps(payload)
-                    ) as response:
-                        return response.status in (200, 204)
-                else:
-                    # Create new user row with minimal info
-                    new_data = {
-                        "name": email.split('@')[0],
-                        "email": email,
-                        "api_key": self._generate_api_key(),
-                        "hf_token": hf_token,
-                        "hf_user_id": hf_user_id,
-                        "requests": 0,
-                        "plan": "free",
-                        "created_at": datetime.utcnow().isoformat(),
-                        "last_request": None,
-                        "requests_this_hour": 0,
-                        "rate_limit_reset": (datetime.utcnow() + timedelta(hours=1)).isoformat(),
-                        "tokens_used": 0
-                    }
-                    async with session.post(
-                        f"{self.config.SUPABASE_URL}/rest/v1/users",
-                        headers=self.headers,
-                        data=json.dumps(new_data)
-                    ) as response:
-                        return response.status in (200, 201)
-        except Exception as e:
-            logger.error(f"DB upsert_hf_token error: {e}")
-            return False
-
-    async def list_keys_for_email(self, email: str) -> List[Dict]:
-        try:
-            user = await self.get_user_by_email(email)
-            if not user:
-                return []
-            # Return obfuscated tokens/keys
-            api_key = user.get('api_key')
-            hf_token = user.get('hf_token')
-            items = []
-            if api_key:
-                items.append({"type": "api_key", "value": self._obfuscate(api_key)})
-            if hf_token:
-                items.append({"type": "hf_token", "value": self._obfuscate(hf_token)})
-            return items
-        except Exception as e:
-            logger.error(f"DB list_keys error: {e}")
-            return []
-
-    def _obfuscate(self, token: str) -> str:
-        if not token or len(token) < 6:
-            return "****"
-        return '*' * (len(token) - 6) + token[-6:]
-
-    async def get_all_users_stats(self):
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    f"{self.config.SUPABASE_URL}/rest/v1/users?select=*",
-                    headers=self.headers
-                ) as response:
-                    if response.status == 200:
-                        return await response.json()
-                    return []
-        except Exception as e:
-            logger.error(f"DB get_all_users_stats error: {e}")
-            return []
-
-# ----------------- Hugging Face Auth -----------------
-class HuggingFaceAuth:
-    @staticmethod
-    async def validate_token(token: str) -> Tuple[bool, Optional[Dict]]:
-        try:
-            async with aiohttp.ClientSession() as session:
-                headers = {"Authorization": f"Bearer {token}"}
-                async with session.get("https://huggingface.co/api/whoami-v2", headers=headers) as response:
-                    # whoami-v2 returns more structured data; fallback to whoami
-                    if response.status == 200:
-                        return True, await response.json()
-                    else:
-                        return False, None
-        except Exception as e:
-            logger.error(f"HF validate_token error: {e}")
-            return False, None
-
-# ----------------- Model Manager (unchanged mostly) -----------------
+# ----------------- Model Manager -----------------
 class ModelManager:
     def __init__(self, config: Config):
         self.config = config
@@ -257,268 +65,238 @@ class ModelManager:
         self.model_loaded = False
 
     async def initialize(self):
+        """Initialize the model, tokenizer, and pipeline asynchronously."""
         if not self.config.HF_TOKEN:
-            logger.info("No HF_TOKEN provided — skipping model preload. Will lazy-load on first request if needed.")
+            logger.error("Hugging Face token not found. Model loading will fail.")
             self.model_loaded = False
             return
-
         try:
-            logger.info("Loading model...")
+            logger.info(f"Loading model: {self.config.MODEL_NAME}...")
             loop = asyncio.get_event_loop()
-            self.tokenizer = await loop.run_in_executor(
-                None,
-                lambda: AutoTokenizer.from_pretrained(
-                    self.config.MODEL_NAME,
-                    use_auth_token=self.config.HF_TOKEN,
-                    trust_remote_code=True
-                )
-            )
-            self.model = await loop.run_in_executor(
-                None,
-                lambda: AutoModelForCausalLM.from_pretrained(
+
+            def load_components():
+                tokenizer = AutoTokenizer.from_pretrained(self.config.MODEL_NAME, token=self.config.HF_TOKEN)
+                model = AutoModelForCausalLM.from_pretrained(
                     self.config.MODEL_NAME,
-                    use_auth_token=self.config.HF_TOKEN,
+                    token=self.config.HF_TOKEN,
                     device_map="auto",
-                    torch_dtype="auto",
-                    trust_remote_code=True
+                    torch_dtype="auto"
                 )
-            )
-            self.pipeline = await loop.run_in_executor(
-                None,
-                lambda: pipeline(
+                text_pipeline = pipeline(
                     "text-generation",
-                    model=self.model,
-                    tokenizer=self.tokenizer,
-                    pad_token_id=self.tokenizer.eos_token_id
+                    model=model,
+                    tokenizer=tokenizer,
                 )
-            )
+                return tokenizer, model, text_pipeline
+
+            self.tokenizer, self.model, self.pipeline = await loop.run_in_executor(None, load_components)
             self.model_loaded = True
-            logger.info("Model loaded successfully")
+            logger.info("✅ Model loaded successfully!")
         except Exception as e:
-            logger.error(f"Model load error: {e}")
+            logger.error(f"❌ Error loading model: {e}")
             self.model_loaded = False
 
-    async def generate(self, request: GenerationRequest, hf_token: str = None) -> Tuple[bool, str, int]:
+    async def generate(self, request: GenerationRequest) -> Tuple[bool, str, int]:
+        """Generate text based on the provided request."""
         if not self.model_loaded:
-            # try lazy-load with provided token
-            if hf_token:
-                self.config.HF_TOKEN = hf_token
-                await self.initialize()
-            else:
-                return False, "❌ Model not loaded and no HF token provided", 0
-
+            return False, "❌ O modelo não está disponível. Por favor, verifique os logs do servidor.", 0
         try:
-            if len(request.prompt.strip()) == 0:
-                return False, "⚠️ Prompt cannot be empty", 0
+            if not request.prompt.strip():
+                return False, "⚠️ O prompt não pode estar vazio.", 0
+            if len(request.prompt) > 8000:
+                return False, "⚠️ O prompt é muito longo (máximo de 8000 caracteres).", 0
+
             loop = asyncio.get_event_loop()
-            result = await loop.run_in_executor(
-                None,
-                lambda: self.pipeline(
-                    request.prompt.strip(),
+            
+            messages = [
+                {"role": "user", "content": request.prompt.strip()},
+            ]
+
+            def do_generation():
+                prompt = self.pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+                outputs = self.pipeline(
+                    prompt,
                     max_new_tokens=min(request.max_tokens, self.config.MAX_TOKENS),
                     do_sample=True,
                     temperature=request.temperature,
                     top_k=request.top_k,
                     top_p=request.top_p,
-                    repetition_penalty=request.repetition_penalty,
-                    pad_token_id=self.tokenizer.eos_token_id,
-                    return_full_text=False
                 )
-            )
-            generated_text = result[0]["generated_text"]
+                return outputs[0]["generated_text"][len(prompt):]
+
+            generated_text = await loop.run_in_executor(None, do_generation)
             tokens_used = len(self.tokenizer.encode(generated_text))
             return True, generated_text, tokens_used
         except Exception as e:
             logger.error(f"Generation error: {e}")
-            return False, f"❌ Generation failed: {str(e)}", 0
+            return False, f"❌ A geração falhou: {str(e)}", 0
 
-# ----------------- Service -----------------
-class GemmaSaaSService:
+# ----------------- Service Layer -----------------
+class GemmaService:
     def __init__(self):
         self.config = Config()
-        self.db = DatabaseManager(self.config)
         self.model_manager = ModelManager(self.config)
-        self.hf_auth = HuggingFaceAuth()
+        self._validate_config()
 
-        # Validate minimal config (SUPABASE required)
-        if not self.config.SUPABASE_URL or not self.config.SUPABASE_KEY:
-            raise ValueError("Missing SUPABASE_URL or SUPABASE_KEY in environment variables")
+    def _validate_config(self):
+        """Validate that required environment variables are set."""
+        if not self.config.HF_TOKEN:
+            raise ValueError("Missing required environment variable: HF_TOKEN")
 
     async def initialize(self):
         await self.model_manager.initialize()
 
-    async def exchange_code_and_store(self, code: str) -> Tuple[bool, str]:
-        """Exchange OAuth code for token and store it in Supabase for the user."""
+    async def generate_text(self, prompt: str, **kwargs) -> APIResponse:
+        """Generate text directly."""
         try:
-            if not (self.config.HF_OAUTH_CLIENT_ID and self.config.HF_OAUTH_CLIENT_SECRET and self.config.HF_OAUTH_REDIRECT_URI):
-                return False, "OAuth client id/secret or redirect URI not configured"
-
-            token_url = "https://huggingface.co/api/oauth/token"
-            data = {
-                "grant_type": "authorization_code",
-                "code": code,
-                "client_id": self.config.HF_OAUTH_CLIENT_ID,
-                "client_secret": self.config.HF_OAUTH_CLIENT_SECRET,
-                "redirect_uri": self.config.HF_OAUTH_REDIRECT_URI
-            }
-
-            async with aiohttp.ClientSession() as session:
-                async with session.post(token_url, data=data) as resp:
-                    if resp.status != 200:
-                        text = await resp.text()
-                        logger.error(f"Token exchange failed: {text}")
-                        return False, f"Token exchange failed: {text}"
-                    token_resp = await resp.json()
+            request = GenerationRequest(prompt=prompt, **kwargs)
+            success, text, tokens_used = await self.model_manager.generate(request)
 
-                access_token = token_resp.get('access_token')
-                if not access_token:
-                    return False, "No access token returned from HF"
-
-                # Validate token (whoami)
-                valid, whoami = await self.hf_auth.validate_token(access_token)
-                if not valid or not whoami:
-                    return False, "Failed to validate HF token after exchange"
-
-                # whoami-v2 returns 'user' and 'id' fields often; try to obtain email
-                email = whoami.get('email') or (whoami.get('user', {}).get('email') if isinstance(whoami.get('user'), dict) else None)
-                hf_user_id = whoami.get('id') or whoami.get('user', {}).get('id') if isinstance(whoami.get('user'), dict) else None
-
-                if not email:
-                    # We can still store token but prefer email
-                    email = f"hf_user_{hf_user_id or secrets.token_hex(8)}@nomail"
-
-                # Upsert token into Supabase
-                ok = await self.db.upsert_hf_token_for_email(email=email, hf_token=access_token, hf_user_id=hf_user_id)
-                if not ok:
-                    return False, "Failed to save token in database"
-
-                return True, f"Successfully linked Hugging Face account: {email}"
+            if success:
+                return APIResponse(
+                    success=True,
+                    data={"generated_text": text, "tokens_used": tokens_used}
+                )
+            else:
+                return APIResponse(success=False, error=text)
 
         except Exception as e:
-            logger.error(f"exchange_code error: {e}")
-            return False, str(e)
-
-    async def get_user_keys(self, hf_token: str) -> APIResponse:
-        valid, whoami = await self.hf_auth.validate_token(hf_token)
-        if not valid or not whoami:
-            return APIResponse(success=False, error="Invalid Hugging Face token")
-
-        # Try extract email
-        email = whoami.get('email') or (whoami.get('user', {}).get('email') if isinstance(whoami.get('user'), dict) else None)
-        if not email:
-            return APIResponse(success=False, error="Could not extract email from HF token")
-
-        items = await self.db.list_keys_for_email(email)
-        return APIResponse(success=True, data=items)
+            logger.error(f"Service error during text generation: {e}")
+            return APIResponse(success=False, error="Ocorreu um erro interno no serviço.")
 
-    # Keep other methods such as generate_text / get_user_stats from your original code – simplified here
-
-# ----------------- Gradio UI -----------------
+# ----------------- Enhanced UI -----------------
 class GradioInterface:
-    def __init__(self, service: GemmaSaaSService):
+    def __init__(self, service: GemmaService):
         self.service = service
 
-    def create_hf_authorize_url(self, state: str = None) -> str:
-        cfg = self.service.config
-        client_id = cfg.HF_OAUTH_CLIENT_ID
-        redirect = cfg.HF_OAUTH_REDIRECT_URI
-        scopes = "api:read api:write offline_access"
-        base = "https://huggingface.co/oauth/authorize"
-        params = f"?response_type=code&client_id={client_id}&redirect_uri={redirect}&scope={scopes}"
-        if state:
-            params += f"&state={state}"
-        return base + params
+    def create_custom_css(self):
+        return """
+        :root {
+            --dark-bg: #111111;
+            --panel-bg: #1C1C1C;
+            --border-color: #333333;
+            --text-color: #E0E0E0;
+            --text-light: #A0A0A0;
+            --accent-orange: #FF4500;
+            --accent-orange-hover: #FF6347;
+        }
+        .gradio-container { background-color: var(--dark-bg) !important; }
+        #main_layout { background-color: transparent; border: none !important; box-shadow: none !important; }
+        #right_panel { background-color: var(--panel-bg); border-left: 1px solid var(--border-color); border-radius: 12px; padding: 2rem !important; }
+        #left_panel { background-color: var(--panel-bg); border-radius: 12px; padding: 1rem !important; display: flex !important; flex-direction: column !important; height: 70vh; }
+        #output_display { flex-grow: 1; overflow-y: auto; padding: 1rem; color: var(--text-color); }
+        #output_display p { margin-bottom: 1rem; line-height: 1.6; }
+        #prompt_row { border-top: 1px solid var(--border-color); padding-top: 1rem; }
+        #prompt_input textarea { background-color: #2C2C2C !important; border-color: var(--border-color) !important; color: var(--text-color) !important; border-radius: 8px !important; }
+        #send_button { background-color: var(--accent-orange); color: white; border: none; border-radius: 50% !important; width: 50px !important; height: 50px !important; min-width: 50px !important; transition: background-color 0.3s ease; }
+        #send_button:hover { background-color: var(--accent-orange-hover); }
+        #generate_button {
+            background: linear-gradient(135deg, var(--accent-orange), var(--accent-orange-hover));
+            color: white !important;
+            font-size: 1.2rem !important;
+            font-weight: bold !important;
+            border: none;
+            border-radius: 12px !important;
+            padding: 1rem !important;
+            box-shadow: 0 4px 15px rgba(255, 69, 0, 0.4);
+            transition: all 0.3s ease;
+        }
+        #generate_button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 20px rgba(255, 69, 0, 0.6);
+        }
+        .gr-label { color: var(--text-light) !important; }
+        h2 { color: white; border-bottom: 1px solid var(--border-color); padding-bottom: 0.5rem; margin-bottom: 1rem; }
+        #info_text { color: var(--text-light); line-height: 1.7; }
+        """
 
     async def create_interface(self):
-        cfg = self.service.config
-
-        with gr.Blocks(title="Gemma AI Platform (OAuth)") as app:
-            gr.Markdown("# Gemma AI — Login com Hugging Face")
-
-            with gr.Row():
-                authorize_html = gr.HTML(f"<a class='btn hf-login-btn' target='_blank' href='{self.create_hf_authorize_url()}'>🔐 Login with Hugging Face</a>")
-                gr.Markdown("Depois de autorizar, você será redirecionado de volta para `/hf_callback` e o token será salvo no banco de dados.")
-
-            with gr.Row():
-                hf_token_input = gr.Textbox(label="Ou cole aqui o seu token Hugging Face (opcional)", type="password")
-                show_keys_btn = gr.Button("🔎 Mostrar minhas chaves")
-                keys_out = gr.HTML()
-
-            # Admin: view all users & keys
-            with gr.Accordion("Admin — Lista de usuários e tokens (somente admin)", open=False):
-                admin_email_input = gr.Textbox(label="Admin HF token (para validar)", type="password")
-                list_all_btn = gr.Button("📋 Listar todos os usuários")
-                admin_out = gr.HTML()
-
-            async def handle_show_keys(hf_token: str):
-                if not hf_token or not hf_token.strip():
-                    return '<div class="alert alert-error">❌ Forneça seu token da Hugging Face (ou use o fluxo OAuth)</div>'
-                resp = await self.service.get_user_keys(hf_token)
-                if not resp.success:
-                    return f"<div class='alert alert-error'>❌ {resp.error}</div>"
-                items = resp.data or []
-                if not items:
-                    return '<div class="alert">Nenhuma chave encontrada</div>'
-                html = '<ul>'
-                for it in items:
-                    html += f"<li><strong>{it['type']}</strong>: <code>{it['value']}</code></li>"
-                html += '</ul>'
-                return html
-
-            async def handle_list_all(admin_token: str):
-                # Validate admin token via HF and email check
-                valid, whoami = await self.service.hf_auth.validate_token(admin_token)
-                if not valid or not whoami:
-                    return '<div class="alert alert-error">Token inválido</div>'
-                email = whoami.get('email') or whoami.get('user', {}).get('email')
-                if email != cfg.ADMIN_EMAIL:
-                    return '<div class="alert alert-error">Acesso negado — não é admin</div>'
-
-                users = await self.service.db.get_all_users_stats()
-                if not users:
-                    return '<div class="alert">Nenhum usuário registrado</div>'
-                html = '<table><tr><th>Name</th><th>Email</th><th>Plan</th><th>API Key (obf.)</th><th>HF Token (obf.)</th></tr>'
-                for u in users:
-                    html += f"<tr><td>{u.get('name','')}</td><td>{u.get('email','')}</td><td>{u.get('plan','')}</td><td>{self.service.db._obfuscate(u.get('api_key',''))}</td><td>{self.service.db._obfuscate(u.get('hf_token',''))}</td></tr>"
-                html += '</table>'
-                return html
+        with gr.Blocks(css=self.create_custom_css(), theme=None) as app:
+            with gr.Row(elem_id="main_layout", equal_height=False):
+                with gr.Column(scale=2, elem_id="left_panel_container"):
+                    with gr.Column(elem_id="left_panel"):
+                        output_display = gr.Markdown(elem_id="output_display", value="<p style='color: #A0A0A0;'>Sua resposta aparecerá aqui...</p>")
+                        with gr.Row(elem_id="prompt_row"):
+                            prompt_input = gr.Textbox(
+                                show_label=False,
+                                placeholder="Digite sua mensagem aqui...",
+                                elem_id="prompt_input",
+                                scale=10
+                            )
+                            send_button = gr.Button("➤", elem_id="send_button", scale=1)
+
+                with gr.Column(scale=1, elem_id="right_panel"):
+                    gr.Markdown("## Informações")
+                    gr.Markdown(
+                        """
+                        Este é um ambiente interativo para o modelo de linguagem **Gemma**.
+                        
+                        - **Como usar:** Digite seu prompt na caixa de texto à esquerda e clique no botão de envio ou no botão "Gerar" abaixo.
+                        - **Modelo:** `google/gemma-2-9b-it`
+                        - **Capacidades:** Geração de texto criativo, respostas a perguntas, resumo, tradução e muito mais.
+                        
+                        Sinta-se à vontade para experimentar diferentes tipos de prompts para explorar todo o potencial do modelo.
+                        """,
+                        elem_id="info_text"
+                    )
+                    generate_button = gr.Button("✨ Gerar", elem_id="generate_button")
+
+            # --- Event Handlers ---
+            async def handle_generation(prompt):
+                if not prompt:
+                    return "<p style='color: #FFCC00;'>Por favor, digite um prompt para começar.</p>"
+                
+                # Show a loading indicator
+                yield "<p style='color: #A0A0A0;'>Gerando resposta...</p>"
+
+                response = await self.service.generate_text(prompt=prompt)
+                
+                if response.success:
+                    yield response.data["generated_text"]
+                else:
+                    yield f"<p style='color: #FF4500;'>{response.error}</p>"
 
-            show_keys_btn.click(fn=handle_show_keys, inputs=[hf_token_input], outputs=[keys_out])
-            list_all_btn.click(fn=handle_list_all, inputs=[admin_email_input], outputs=[admin_out])
+            # --- Wiring ---
+            generate_button.click(
+                handle_generation,
+                inputs=[prompt_input],
+                outputs=[output_display]
+            )
+            send_button.click(
+                handle_generation,
+                inputs=[prompt_input],
+                outputs=[output_display]
+            )
+            prompt_input.submit(
+                handle_generation,
+                inputs=[prompt_input],
+                outputs=[output_display]
+            )
 
         return app
 
-# ----------------- Main -----------------
+# ----------------- Main Application -----------------
 async def main():
-    service = GemmaSaaSService()
-    # Model is optional at startup
-    await service.initialize()
-
-    interface = GradioInterface(service)
-    app = await interface.create_interface()
-
-    # --- Add OAuth callback route onto Gradio's internal Starlette app ---
-    async def hf_callback(request: Request):
-        code = request.query_params.get('code')
-        state = request.query_params.get('state')
-        if not code:
-            return HTMLResponse('<h3>Missing code in callback</h3>')
-
-        ok, message = await service.exchange_code_and_store(code)
-        # Simple HTML response - can be improved
-        html = f"<html><body><h3>{'Success' if ok else 'Error'}</h3><p>{message}</p><script>setTimeout(()=>window.close(),1500)</script></body></html>"
-        return HTMLResponse(html)
-
-    # Register route
+    """Main application entry point"""
     try:
-        # `app` from gr.Blocks has attribute `.app` which is a Starlette/FastAPI app
-        app.app.add_api_route("/hf_callback", hf_callback, methods=["GET"])  # type: ignore
-        logger.info("Registered /hf_callback route on Gradio app")
+        service = GemmaService()
+        await service.initialize()
+        
+        interface = GradioInterface(service)
+        app = await interface.create_interface()
+        
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False, 
+            debug=False,
+            show_error=True
+        )
     except Exception as e:
-        logger.error(f"Could not register callback route on Gradio app: {e}")
-
-    # Launch Gradio app
-    app.launch(server_name="0.0.0.0", server_port=7860)
+        logger.critical(f"Failed to start application: {e}", exc_info=True)
+        raise
 
-if __name__ == '__main__':
+if __name__ == "__main__":
+    # To run this, you need a .env file with:
+    # HF_TOKEN="your_hugging_face_token"
     asyncio.run(main())