Update app.py

app.py

@@ -1,1048 +1,63 @@
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-import tempfile
-from typing import Optional, Union
-from pathlib import Path
-import os
-import re
-import requests
-import time
-import base64
-import io
-from PIL import Image
-import json
-import subprocess
+from gemini_webapi import GeminiClient
+from gemini_webapi.constants import Model
 
-from gemini_client import AsyncChatbot, Model, load_cookies
+app = FastAPI(title="Gemini API Wrapper")
 
-from fastapi.staticfiles import StaticFiles
+# Cookies extraídos do Request Header
+Secure_1PSID = "g.a0007Qjc5GP_JJ8G6lqxKsBvwooBDG0kaQQpdrq1eVMavCuae6YHM71QR0oHtpOONkPxs87_PQACgYKAZcSARISFQHGX2MiBLscUC-RI65KuaeNsGHqgxoVAUF8yKrfh50pYTc-6ectdvp0W-we0076"
+Secure_1PSIDTS = "sidts-CjEBBj1CYg2xMC8tsq0_lfxB86j60YwUfK4SqcUpqZa2YB6plmNmcG7NIPUU8YX38glqEAA"
 
-app = FastAPI(title="Gemini Chat API", description="API para interagir com Google Gemini")
+client = None
 
-# Criar diretório static se não existir
-os.makedirs("static", exist_ok=True)
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Inicializar chatbot globalmente
-
-# Inicializar chatbots globalmente
-chatbots = {}
-upscale_chatbot = None
-
-async def update_cookie_if_needed(cookie_path: str, secure_1psid: str, secure_1psidts: str, additional_cookies: dict):
-    """
-    Tenta atualizar o cookie __Secure-1PSIDTS se necessário.
-    Retorna o novo cookie ou o original se não precisar atualizar.
-    """
-    # Não tentar atualizar proativamente - deixar o sistema fazer isso quando necessário
-    # Isso evita erros 401/404 quando o cookie já expirou
-    return secure_1psidts
-
-async def init_chatbot(retry_count=0, max_retries=2):
-    """
-    Inicializa o chatbot com os cookies de forma assíncrona.
-    Tenta atualizar cookies automaticamente se falhar.
-    """
-
-    global chatbots, upscale_chatbot
-    cookie_path = os.getenv("COOKIE_PATH", "cookies.json")
-    
-    if not os.path.exists(cookie_path):
-        raise FileNotFoundError(f"Arquivo de cookies não encontrado: {cookie_path}")
-    
-    try:
-        # Carregar cookies
-        secure_1psid, secure_1psidts, additional_cookies = load_cookies(cookie_path)
-        
-        # Tentar atualizar cookie proativamente antes de inicializar
-        if retry_count == 0:
-            secure_1psidts = await update_cookie_if_needed(cookie_path, secure_1psid, secure_1psidts, additional_cookies)
-        
-        # Criar Chatbot Flash (Padrão/Rápido)
-        chatbots['flash'] = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.G_3_0_FLASH,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path
-        )
-        print(f"Chatbot Flash (3.0) inicializado com sucesso")
-
-        # Criar Chatbot Thinking (Raciocínio) - Timeout maior
-        chatbots['thinking'] = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.G_3_0_THINKING,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path,
-            timeout=120 # Timeout maior para thinking
-        )
-        print(f"Chatbot Thinking (3.0) inicializado com sucesso")
-
-        # Fallback/Default
-        chatbots['default'] = chatbots['flash']
-
-        # Criar instância de Upscale separada
-        upscale_chatbot = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.NANO_BANANA,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path
-        )
-        print(f"Upscale Chatbot inicializado com sucesso usando modelo NANO_BANANA")
-
-    except (ValueError, PermissionError) as e:
-        error_str = str(e).lower()
-        # Se o erro é relacionado a cookie expirado, não tentar atualizar novamente
-        # O sistema já tentou atualizar automaticamente e falhou
-        print(f"Erro ao inicializar chatbot: {e}")
-        print(f"AVISO: Cookies podem estar expirados. Por favor, atualize manualmente os cookies em {cookie_path}")
-        print(f"Para atualizar: acesse https://gemini.google.com/app e copie os novos cookies __Secure-1PSID e __Secure-1PSIDTS")
-        raise
-    except Exception as e:
-        print(f"Erro ao inicializar chatbot: {e}")
-        raise
-
-# Inicializar na startup
 @app.on_event("startup")
 async def startup_event():
-    await init_chatbot()
-
-@app.get("/")
-def root():
-    """Endpoint raiz"""
-    return {"status": "ok", "message": "Gemini Chat API está funcionando"}
-
-def srt_time_to_seconds(timestamp):
-    """Converte timestamp SRT (HH:MM:SS,mmm) para segundos"""
-    try:
-        time_part, ms_part = timestamp.split(",")
-        h, m, s = map(int, time_part.split(":"))
-        ms = int(ms_part)
-        return h * 3600 + m * 60 + s + ms / 1000.0
-    except:
-        return 0.0
-
-def seconds_to_srt_time(seconds):
-    """Converte segundos para timestamp SRT (HH:MM:SS,mmm)"""
-    hours = int(seconds // 3600)
-    minutes = int((seconds % 3600) // 60)
-    secs = int(seconds % 60)
-    ms = int((seconds % 1) * 1000)
-    return f"{hours:02d}:{minutes:02d}:{secs:02d},{ms:03d}"
-
-def cut_srt_by_time(srt_content, start_time, end_time):
-    """
-    Corta legendas SRT baseado em tempo de início e fim.
-    Ajusta os timestamps para começar do zero.
-    
-    Parâmetros:
-    - srt_content: Conteúdo SRT original
-    - start_time: Tempo de início em segundos
-    - end_time: Tempo de fim em segundos
-    
-    Retorna: SRT cortado e ajustado
-    """
-    if start_time is None or end_time is None:
-        return srt_content
-    
-    # Padrão para capturar legendas
-    pattern = re.compile(r"(\d+)\s*\n([^-\n]+?) --> ([^-\n]+?)\s*\n((?:(?!^\d+\s*\n).+\n?)*)", re.MULTILINE)
-    matches = pattern.findall(srt_content)
-    
-    filtered_subtitles = []
-    for num, start, end, text in matches:
-        start_seconds = srt_time_to_seconds(start.strip())
-        end_seconds = srt_time_to_seconds(end.strip())
-        
-        # Verificar se a legenda está dentro do intervalo [start_time, end_time]
-        # Incluir legendas que se sobrepõem parcialmente
-        if end_seconds > start_time and start_seconds < end_time:
-            # Ajustar timestamps para começar do zero
-            new_start = max(0, start_seconds - start_time)
-            new_end = min(end_time - start_time, end_seconds - start_time)
-            
-            # Garantir que new_end > new_start
-            if new_end > new_start:
-                filtered_subtitles.append({
-                    'start': new_start,
-                    'end': new_end,
-                    'text': text.strip()
-                })
-    
-    # Gerar SRT cortado
-    srt_cut = ""
-    for i, sub in enumerate(filtered_subtitles, 1):
-        start_srt = seconds_to_srt_time(sub['start'])
-        end_srt = seconds_to_srt_time(sub['end'])
-        srt_cut += f"{i}\n{start_srt} --> {end_srt}\n{sub['text']}\n\n"
-    
-    return srt_cut.strip()
-
-def clean_and_validate_srt(srt_content):
-    """Limpa e valida conteúdo SRT seguindo o padrão do example.py"""
-    # Tentar extrair conteúdo de blocos de código ```srt ou ```
-    if "```" in srt_content:
-        # Padrão regex para capturar conteúdo dentro de ```srt ... ``` ou ``` ... ```
-        code_block_pattern = re.compile(r"```(?:srt)?\n(.*?)```", re.DOTALL | re.IGNORECASE)
-        match = code_block_pattern.search(srt_content)
-        if match:
-             srt_content = match.group(1).strip()
-    
-    # Se ainda tiver muito texto antes do primeiro timestamp, tentar limpar
-    # Procura pelo primeiro padrão "1\n00:00"
-    first_block_pattern = re.compile(r"^\s*\d+\s*\n\d{2}:\d{2}:\d{2},\d{3}", re.MULTILINE)
-    match = first_block_pattern.search(srt_content)
-    if match:
-         srt_content = srt_content[match.start():]
-    
-    # Padrão mais flexível para capturar timestamps mal formatados
-    pattern = re.compile(r"(\d+)\s*\n([^-\n]+?) --> ([^-\n]+?)\s*\n((?:(?!^\d+\s*\n).+\n?)*)", re.MULTILINE)
-    matches = pattern.findall(srt_content)
-    
-    def corrigir_timestamp(timestamp):
-        timestamp = timestamp.strip()
-        
-        # Se já está correto, retorna
-        if re.match(r"\d{2}:\d{2}:\d{2},\d{3}", timestamp):
-            return timestamp
-        
-        # Formato: MM:SS,mmm -> HH:MM:SS,mmm
-        if re.match(r"\d{2}:\d{2},\d{3}", timestamp):
-            return f"00:{timestamp}"
-        
-        # Formato: M:SS,mmm -> HH:MM:SS,mmm
-        if re.match(r"\d{1}:\d{2},\d{3}", timestamp):
-            parts = timestamp.split(":")
-            minutes = parts[0].zfill(2)
-            return f"00:{minutes}:{parts[1]}"
-        
-        # Formato: SS,mmm -> HH:MM:SS,mmm
-        if re.match(r"\d{1,2},\d{3}", timestamp):
-            seconds_ms = timestamp.split(",")
-            seconds = seconds_ms[0].zfill(2)
-            return f"00:00:{seconds},{seconds_ms[1]}"
-        
-        # Outros formatos problemáticos
-        if re.match(r"\d{2}:\d{2}:\d{3}", timestamp):
-            parts = timestamp.split(":")
-            if len(parts) == 3:
-                h, m, s_ms = parts
-                if len(s_ms) == 3:
-                    return f"{h}:{m}:00,{s_ms}"
-                elif len(s_ms) >= 4:
-                    s = s_ms[:-3]
-                    ms = s_ms[-3:]
-                    return f"{h}:{m}:{s.zfill(2)},{ms}"
-        
-        return timestamp
-    
-    srt_corrigido = ""
-    for i, (num, start, end, text) in enumerate(matches, 1):
-        text = text.strip()
-        if not text:
-            continue
-        
-        # Verificar se a legenda tem mais de 2 linhas
-        text_lines = [line.strip() for line in text.split('\n') if line.strip()]
-        if len(text_lines) > 2:
-            # Limitar a 2 linhas, juntando as extras na segunda linha
-            text = text_lines[0] + '\n' + ' '.join(text_lines[1:])
-        
-        start_corrigido = corrigir_timestamp(start)
-        end_corrigido = corrigir_timestamp(end)
-        srt_corrigido += f"{i}\n{start_corrigido} --> {end_corrigido}\n{text}\n\n"
-    
-    return srt_corrigido.strip()
-
-def download_file_with_retry(url: str, max_retries: int = 3, timeout: int = 300):
-    """
-    Baixa arquivo com retry logic e tratamento de rate limiting.
-    
-    Parâmetros:
-    - url: URL do arquivo
-    - max_retries: Número máximo de tentativas
-    - timeout: Timeout em segundos
-    
-    Retorna: Response object do requests
-    """
-    headers = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        'Accept': '*/*',
-        'Accept-Language': 'en-US,en;q=0.9',
-        'Accept-Encoding': 'gzip, deflate, br',
-        'Connection': 'keep-alive',
-        'Upgrade-Insecure-Requests': '1'
-    }
-    
-    for attempt in range(max_retries):
-        try:
-            if attempt > 0:
-                # Backoff exponencial: 2^attempt segundos
-                wait_time = 2 ** attempt
-                print(f"⏳ Aguardando {wait_time}s antes de tentar novamente (tentativa {attempt + 1}/{max_retries})...")
-                time.sleep(wait_time)
-            
-            print(f"📥 Tentativa {attempt + 1}/{max_retries} - Baixando arquivo de: {url}")
-            response = requests.get(url, headers=headers, timeout=timeout, stream=True)
-            
-            # Tratar erro 429 (Too Many Requests)
-            if response.status_code == 429:
-                retry_after = response.headers.get('Retry-After')
-                if retry_after:
-                    wait_time = int(retry_after)
-                    print(f"⚠️ Rate limit atingido. Aguardando {wait_time}s conforme Retry-After header...")
-                    time.sleep(wait_time)
-                elif attempt < max_retries - 1:
-                    # Se não houver Retry-After, usar backoff exponencial
-                    wait_time = (2 ** attempt) * 5  # 5s, 10s, 20s...
-                    print(f"⚠️ Rate limit atingido. Aguardando {wait_time}s antes de tentar novamente...")
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    raise HTTPException(
-                        status_code=429,
-                        detail=f"Rate limit atingido após {max_retries} tentativas. Tente novamente mais tarde."
-                    )
-            
-            response.raise_for_status()
-            return response
-            
-        except requests.exceptions.HTTPError as e:
-            if e.response.status_code == 429 and attempt < max_retries - 1:
-                continue
-            elif attempt == max_retries - 1:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Erro ao baixar arquivo após {max_retries} tentativas: {str(e)}"
-                )
-            else:
-                raise
-        except requests.exceptions.RequestException as e:
-            if attempt == max_retries - 1:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Erro ao baixar arquivo após {max_retries} tentativas: {str(e)}"
-                )
-            continue
-    
-    raise HTTPException(
-        status_code=400,
-        detail=f"Falha ao baixar arquivo após {max_retries} tentativas"
-    )
-
-class ChatRequest(BaseModel):
-    message: str
-    context: Optional[str] = None
-    model: Optional[str] = "flash" # 'flash' or 'thinking'
-
-@app.post("/chat")
-async def chat_endpoint(request: ChatRequest):
-    """
-    Endpoint para conversas de texto simples.
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-    
-    try:
-        requested_model = request.model.lower() if request.model else "flash"
-        if "thinking" in requested_model:
-            selected_chatbot = chatbots.get('thinking', chatbots['default'])
-        else:
-            selected_chatbot = chatbots.get('flash', chatbots['default'])
-
-        prompt = request.message
-        if request.context:
-            prompt = f"Contexto: {request.context}\n\nMensagem: {request.message}"
-            
-        print(f"💬 Chat request ({requested_model}): {prompt[:50]}...")
-        response_gemini = await selected_chatbot.ask(prompt)
-        
-        if response_gemini.get("error"):
-            raise HTTPException(
-                status_code=500,
-                detail=f"Erro no Gemini: {response_gemini.get('content', 'Erro desconhecido')}"
-            )
-            
-        return {"response": response_gemini.get("content", "")}
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-def extract_json_from_text(text: str):
-    """
-    Extrai JSON válido de uma string que pode conter markdown.
-    Remove vírgulas finais (trailing commas) que quebram o json.loads.
-    """
-    text = text.strip()
-    
-    # Remover blocos de código markdown
-    if "```json" in text:
-        text = text.split("```json")[1].split("```")[0].strip()
-    elif "```" in text:
-        # Tenta achar onde fecha o bloco
-        parts = text.split("```")
-        if len(parts) >= 2:
-            text = parts[1].strip()
-        
-    # Tentar encontrar o início e fim de um array JSON ou objeto
-    start_idx = text.find('[')
-    end_idx = text.rfind(']')
-    
-    if start_idx != -1 and end_idx != -1:
-        text = text[start_idx:end_idx+1]
-    else:
-        # Tentar objeto se não for array
-        start_idx = text.find('{')
-        end_idx = text.rfind('}')
-        if start_idx != -1 and end_idx != -1:
-            text = text[start_idx:end_idx+1]
-
-    # Remover trailing commas (vírgulas antes de fechamento de } ou ])
-    # Ex: {"a": 1,} -> {"a": 1}
-    # Ex: [1, 2,] -> [1, 2]
-    import re
-    text = re.sub(r',\s*([\]}])', r'\1', text)
-
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError as e:
-        print(f"Erro ao decodificar JSON: {e}")
-        # Tentativa desesperada: se falhar, tentar usar ast.literal_eval se parecer python dict/list
-        # Mas cuidado com segurança. Melhor retornar erro por enquanto.
-        return None
-
-def cut_video(input_path: str, output_path: str, start: str, end: str):
-    """
-    Corta um vídeo usando ffmpeg.
-    """
-    try:
-        command = [
-            "ffmpeg", "-y",
-            "-i", input_path,
-            "-ss", start,
-            "-to", end,
-            "-c:v", "libx264", "-c:a", "aac",
-            "-strict", "experimental",
-            output_path
-        ]
-        # Executar comando silenciando output para não poluir logs, mas capturando erro
-        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"Erro ao cortar vídeo: {e.stderr.decode()}")
-        return False
-
-
-class GenerateElementsRequest(BaseModel):
-    video_url: str
-    context: Optional[str] = None
-    start: Optional[str] = None
-    end: Optional[str] = None
-    model: Optional[str] = "flash"
-    comments: Optional[list] = None
-
-
-@app.post("/generate-elements")
-async def generate_elements_endpoint(request: GenerateElementsRequest):
-    """
-    Gera elementos a partir de um vídeo (ou trecho dele).
-    Duplicação do generate-titles para personalização futura do prompt.
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-
-    temp_file = None
-    cut_file = None
-
-    try:
-        # 1. Validar e Baixar Vídeo
-        if not request.video_url:
-            raise HTTPException(status_code=400, detail="URL do vídeo é obrigatória")
-
-        print(f"📥 [GenerateElements] Baixando vídeo: {request.video_url}")
-        
-        # Baixar direto para um arquivo temporário
-        response = download_file_with_retry(request.video_url, timeout=600)
-        
-        content_type = response.headers.get('content-type', '').lower()
-        ext = '.mp4' 
-        if 'webm' in content_type: ext = '.webm'
-        elif 'mkv' in content_type: ext = '.mkv'
-        
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
-        for chunk in response.iter_content(chunk_size=1024*1024):
-            if chunk:
-                temp_file.write(chunk)
-        temp_file.close()
-
-        video_path_to_analyze = temp_file.name
-
-        # 2. Cortar Vídeo se necessário
-        if request.start and request.end:
-            print(f"✂️ [GenerateElements] Cortando vídeo de {request.start} até {request.end}...")
-            cut_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
-            cut_file.close()
-            
-            success = cut_video(temp_file.name, cut_file.name, request.start, request.end)
-            if success:
-                video_path_to_analyze = cut_file.name
-                print(f"✅ Vídeo cortado: {video_path_to_analyze}")
-            else:
-                print("⚠️ Falha ao cortar vídeo, usando original.")
-
-        # 3. Preparar Prompt
-        contexto_add = f"\n{request.context}" if request.context else ""
-        
-        comentarios_add = ""
-        if request.comments:
-            comentarios_add = "\nCOMENTÁRIOS DO POST (Use como forte inspiração para criar títulos mais reais e humanizados):\n"
-            for c in request.comments:
-                text = c.get("text", "").strip()
-                if text:
-                    likes = c.get("like_count", 0)
-                    comentarios_add += f"- {text} ({likes} curtidas)\n"
-        
-        prompt = f"""
-IDIOMA: Todo o conteúdo gerado (título, descrição) DEVE ser em PORTUGUÊS DO BRASIL. Mesmo que o vídeo esteja em outro idioma, a saída final deve ser inteiramente em pt-BR.
-
-Crie um título e uma descrição analisando o vídeo, o contexto e os comentários fornecidos. Corrija qualquer informação imprecisa, utilize técnicas modernas que prendem o leitor a ler até o final.
-A legenda deve ser compatível e do tamanho de uma legenda do Instagram.
-A descrição deve ser sem tópicos, apenas descrição limpa e direta, sem conclusões parecendo IA e sem enrolação ou redundâncias.
-Quero informações concretas e factuais, não pensamentos, opiniões ou imaginações.
-Não seja redundante, cada frase precisa adicionar informação nova.
-LEMBRE-SE: Como os comentários são feitos por humanos reais, você DEVE olhar para eles e usá-los como inspiração, se necessário, para gerar títulos com uma pegada MUITO mais humanizada, baseando-se nas reações reais.
-Se inspire rigorosamente no modo de escrita dos exemplos fornecidos.
-
-ESTILO DE ESCRITA OBRIGATÓRIO:
-
-- Tom INFORMAL e conversacional que mistura precisão factual com fluidez de quem tá contando algo pra um amigo
-- Use LINGUAGEM COLOQUIAL brasileira: "tava" em vez de "estava", "pra" em vez de "para", "tá" em vez de "está", "pro" em vez de "para o", "num" em vez de "em um", "aí" em vez de "então", "tipo" como conectivo casual quando fizer sentido
-- Use conectivos naturais como aliás, na verdade, por exemplo, definitivamente, inclusive, etc, pra criar ritmo
-- Palavras-chave em MAIÚSCULA pra ênfase quando fizer sentido
-- Informações diretas, sem rodeios, cada frase deve acrescentar um dado novo
-- NUNCA termine com frases que pareçam conclusões de IA
-- Evite palavras como consolidou, definiu, simboliza especialmente no final
-- Termine a descrição sempre com um FATO CONCRETO como número, prêmio, data ou detalhe técnico relevante
-- NUNCA use travessões em nenhuma parte do texto
-- NUNCA faça perguntas retóricas ou diretas ao final da descrição
-- NUNCA utilize termos como "O vídeo resgata", "O vídeo mostra", etc... a descrição deve ser sempre direta.
-- A descrição NÃO precisa ser 100% coloquial, mas o tom geral deve soar natural e humano, nunca robótico ou acadêmico
-
-LEGENDA:
-- Define se o vídeo precisa de legendas (se há fala importante que precisa ser traduzida ou transcrita).
-- Responda com true se houver diálogo/fala crucial.
-- Responda com false se for apenas visual, música de fundo ou fala irrelevante.
-
-TÍTULOS E EMOJIS:
-
-- O público primário é Geração Z, portanto o tom DEVE ser descontraído e informal
-- O uso de "Quando" no início do título é UMA OPÇÃO ESTILÍSTICA recomendada, não obrigatória
-- Varie estruturas de título, podendo usar afirmações diretas, contrastes, dados impactantes ou frases curtas
-- Emojis são opcionais e devem ser usados apenas quando reforçam a emoção do contexto
-- Não use emojis em todos os títulos
-- O título só deve ter UM emoji, NUNCA DOIS.
-- PRIORIZE emojis de humor e emoção da Geração Z: 💀 (choque/morri), 😭 (choro de riso/emoção), 🥀 (melancolia/dor), 💅 (deboche), 🫠 (derretendo), 😵 (chocado), 🫣 (constrangimento), 🤡 (palhaçada), 🥲 (sorriso triste). Use 🥹 e 🥺 pra momentos fofos/emocionantes. Evite emojis genéricos como �, ❤️, 😊.
-- Se for utilizado coração, SEMPRE deve ser coração sem ser o vermelho ou branco... dependendo do contexto.
-- MUITO IMPORTANTE: Mantenha as quebras de linha na descrição utilizando `\\n\\n` no JSON pra separar os parágrafos, assim o texto não fica tudo numa única linha.
-
-Contexto que pode ajudar: {contexto_add}
-{comentarios_add}
-
-EXEMPLOS (saída esperada em JSON):
-
-[
-  {{
-    "title": "É incrível como ele era vulnerável e emotivo antes de perder qualquer traço de humanidade 💀",
-    "description": "No episódio 3 da 1ª temporada de Breaking Bad (...And the Bag's in the River), Walter White reconstrói um prato quebrado e descobre que falta um único estilhaço. Ele percebe que Krazy-8, o traficante que tava preso no porão dele, escondeu a peça pontiaguda pra usar como arma. O Walt tava decidido a libertar o cara, mas a prova física da traição forçou ele a estrangular o traficante pra sobreviver.\\n\\nFoi nesse momento que o professor de química entendeu que a empatia seria a condenação dele. Morria, naquele instante, o mestre de escola, e surgia a lógica inflexível de Heisenberg 🔥",
-    "legenda": false
-  }},
-  {{
-    "title": "Imagina escrever uma música do próprio livro e vê-la ganhar vida em live-action 🥹",
-    "description": "Jogos Vorazes deu vida a \\"The Hanging Tree\\", de Suzanne Collins, depois que a canção apareceu pela primeira vez em seu livro Mockingjay. Na Parte 1 de Mockingjay, no Distrito 12, o que começa como uma lembrança solene do pai de Katniss transforma-se em um grito de mobilização para que os distritos se oponham à Capital. Enquanto Snow manipula a mente de Peeta no silêncio do Distrito 13, a canção deixa muito claro que o poder de uma ideia é a única coisa que o medo não consegue deter. Até porque, nada representa uma ameaça maior para um tirano do que um povo que não tem mais nada a perder 🎯",
-    "legenda": true
-  }},
-  {{
-    "title": "Normal People foi tão bom porque o Paul Mescal não tava atuando 🥹",
-    "description": "🥹 Paul Mescal era um ator de teatro praticamente desconhecido até ser escalado como Connell Waldron em Normal People. A adaptação do best-seller de Sally Rooney rendeu a Mescal o BAFTA de Melhor Ator e uma indicação ao Emmy, consolidando a química dele com a Daisy Edgar-Jones como uma das mais realistas da televisão recente.\\n\\nA produção usou uma coordenadora de intimidade pra garantir que as cenas de vulnerabilidade fossem autênticas, focando mais na linguagem corporal e no silêncio do que em diálogos expositivos. Filmada na Irlanda e na Itália, a série mostra com precisão técnica a transição da vida escolar em Sligo pra universidade no Trinity College, fugindo dos clichês estéticos típicos de romances juvenis e apostando no naturalismo das atuações.",
-    "legenda": true
-  }},
-  {{
-    "title": "O exato momento em que Carl supera seu luto de décadas 🥺",
-    "description": "🍇 O broche que o Carl entrega pro Russell é uma tampa de refrigerante de uva (Grape Soda) original dos anos 30, o mesmo objeto que a Ellie deu pro Carl quando eles se conheceram na infância.\\n\\nNo final de Up: Altas Aventuras (2009), o Russell, com 8 anos, tá lidando com a falta do pai durante a cerimônia de formatura dos Exploradores da Natureza. Carl Fredricksen sobe ao palco e entrega pro garoto a \\"Insígnia Ellie\\", a mais alta distinção que ele tem. É o momento preciso em que o Carl supera o luto de décadas, passando o legado de aventura pro Russell e assumindo o papel de figura paterna pro garoto.\\n\\nDirigido por Pete Docter, o longa fez história ao ser a primeira animação a abrir o Festival de Cannes e levou os Oscars de Melhor Filme de Animação e Melhor Trilha Sonora.",
-    "legenda": true
-  }},
-  {{
-    "title": "“Ei, olha só... meu turno acabou de terminar” 😭",
-    "description": "No filme \\"Atração Perigosa\\" (2010), o Ben Affleck definitivamente caprichou no realismo tático quando mostrou a cultura criminosa de Charlestown, Boston. Nessa cena, por exemplo, logo após o assalto ao banco em North End, o policial interpretado por Jack Walsh simplesmente ignora a gangue do Doug MacRay, que tava equipada com fuzis automáticos e usando as famosas máscaras de freira. A escolha do cara é uma das reações mais pragmáticas do gênero policial... autopreservação pura diante de uma desvantagem letal óbvia. O filme, aliás, inspirado no livro \\"Prince of Thieves\\", rendeu pro Jeremy Renner uma indicação ao Oscar de Melhor Ator Coadjuvante pela atuação dele como o instável James Coughlin.",
-    "legenda": false
-  }},
-  {{
-    "title": "Quando um \\"Eu te odeio\\" carrega mais amor que um \\"Eu te amo\\" 😝",
-    "description": "No episódio \\"Fun Run\\" (4x01), Jim finge um pedido de casamento apenas para amarrar o cadarço, arrancando esse \\"eu te odeio\\" de Pam. O momento marca o MELHOR INÍCIO de temporada da série, quando o casal finalmente assume o namoro após três anos de tensão e o famoso beijo no \\"Casino Night\\" 🥹. A naturalidade da cena é, na verdade, fruto de um processo rigoroso de escalação... Greg Daniels, o showrunner, realizou inúmeros testes de química cruzada até que John Krasinski e Jenna Fischer se encontrassem. No dia do teste final, antes mesmo de começarem, Fischer perguntou a Krasinski se ele seria o Jim, e ele respondeu: \\"Você é minha Pam\\". A produção de The Office escolheu um estilo de romance \\"slow burn\\", no qual o afeto se desenvolvia em silêncio, por meio de olhares e piadas internas, evitando o melodrama típico das sitcoms dos anos 2000.",
-    "legenda": true
-  }},
-  {{
-    "title": "Dominic Monaghan simplesmente enganou Elijah Wood por 10 minutos e o resultado foi esse 😭",
-    "description": "Durante a turnê de divulgação de O Retorno do Rei em 2004, Dominic Monaghan, intérprete do hobbit Merry, assumiu o papel de um jornalista alemão fictício chamado Hans Jensen para entrevistar seu colega de elenco Elijah Wood. Monaghan estava em uma sala diferente com um modulador de voz, o que permitiu que ele fizesse perguntas cada vez mais absurdas enquanto Elijah, em um estúdio em Nova York, tentava manter o profissionalismo. O ponto alto da pegadinha ocorre quando Monaghan questiona Elijah repetidamente sobre o uso de perucas, gerando uma crise de riso incontrolável no ator ao perceber a bizarrice da situação. Curiosamente, a ironia técnica do momento reside no fato de que todos os atores principais de O Senhor dos Anéis utilizaram perucas durante os dezoito meses de filmagem na Nova Zelândia para garantir a continuidade visual dos personagens. O registro completo dessa entrevista foi incluído oficialmente como um easter egg nos extras do DVD da Versão Estendida de O Senhor dos Anéis: O Retorno do Rei.",
-    "legenda": true
-  }},
-  {{
-    "title": "E o Justin Bieber que já demonstrava um senso rítmico absurdo aos dois anos de idade? 😵",
-    "description": "O Justin Bieber tinha só dois anos quando a mãe dele, Pattie Mallette, gravou esse vídeo caseiro na cozinha da casa deles em Stratford, Ontário. A habilidade dele em manter o tempo rítmico e fazer viradas rápidas usando só as mãos e uma superfície improvisada impressiona pela coordenação motora absurda pra idade dele.\\n\\nO Justin aprendeu a tocar bateria de forma autodidata antes de passar pro piano e pro violão, instrumentos que ele dominou antes de ser descoberto no YouTube em 2007. O cara, inclusive, tocou bateria profissionalmente em várias turnês internacionais, mostrando que a base percussiva foi o fundamento da formação musical dele.\\n\\nEsse registro em particular virou uma das cenas mais icônicas do documentário \\"Never Say Never\\", que arrecadou 99 milhões de dólares no mundo todo.",
-    "legenda": true
-  }},
-  {{
-    "title": "Quando o James Franco foi apresentar o Oscar e a avó dele resolveu flertar com o Mark Wahlberg 😭",
-    "description": "A fim de atrair um público mais jovem, a 83ª edição do Academy Awards, realizada em 2011, escalou James Franco e Anne Hathaway como apresentadores. Franco fez uma apresentação espontânea de sua avó, Mitsue \\"Mitzie\\" Verne, que se encontrava na plateia. Quando pegou o microfone, ela direcionou sua atenção a Mark Wahlberg, referindo-se a ele pelo apelido de sua carreira inicial, \\"Marky Mark\\". A interação rompeu o protocolo oficial da premiação e provocou uma reação autêntica de Wahlberg, que riu ao ser apontado diante das câmeras.\\n\\nA tentativa da Academia de modernizar o evento por meio de interações não roteirizadas entre os convidados da primeira fila e os apresentadores foi um dos principais destaques da edição do Oscar.\\n\\nMitzie Verne, aliás, era uma personalidade reconhecida no cenário artístico de Cleveland, cidade onde estabeleceu a Verne Interactive Collective Gallery em 1953.",
-    "legenda": true
-  }},
-  {{
-    "title": "O mano é inocente demais pra esse mundo tão cruel 😭",
-    "description": "Estátuas vivas são artistas de rua que usam técnicas rigorosas de controle da respiração e relaxamento muscular pra ficarem imóveis por períodos de 30 a 60 minutos. O artista Donald Eleanor, por exemplo, usa maquiagem metálica e figurinos rígidos pra parecer um objeto inanimado em locais públicos. Quando o pedestre interage ou oferece uma gorjeta, o performer rompe a imobilidade com movimentos fluidos e robóticos, criando um contraste visual instantâneo. A parada exige meses de treinamento pra evitar o reflexo automático de piscar ou reagir a distrações externas, tipo sons e mudanças climáticas.\\n\\nA técnica de \\"locking\\", por exemplo, permite que o ator trave as articulações em ângulos determinados, mantendo uma postura estável e sem oscilações.",
-    "legenda": false
-  }},
-  {{
-    "title": "Os bastidores de Jumanji sendo mais engraçados que o próprio filme 😭",
-    "description": "Durante as filmagens de Jumanji: Bem-Vindo à Selva (2017) no Havaí, a produção precisou ser interrompida porque Jack Black se recusou a continuar gravando antes de terminar sua refeição. Kevin Hart registrou o momento em que o colega de elenco, ainda caracterizado como o professor Sheldon Oberon, ignora a pressão do cronograma para finalizar um prato de arroz.\\n\\nDwayne Johnson, o The Rock, aliás, aparece no vídeo sendo transportado por uma plataforma móvel enquanto Kevin Hart ironiza o \\"nível de Hollywood\\" do set. A química entre o quarteto principal foi fundamental para o sucesso do longa, que utilizou locações reais como a Reserva Kualoa para criar o ambiente imersivo do jogo.\\n\\nO filme arrecadou 962 milhões de dólares globalmente, tornando-se a maior bilheteria da Sony Pictures nos Estados Unidos até o lançamento de Homem-Aranha: Sem Volta para Casa.",
-    "legenda": true
-  }},
-  {{
-    "title": "O mano genuinamente se sentiu violado 😭",
-    "description": "O cara tava sob efeito de sedativos pesados após um procedimento cirúrgico quando esse registro foi feito numa unidade hospitalar. Ele apresenta aquele estado de desorientação típico do despertar anestésico, que afeta temporariamente as funções cognitivas e a percepção de realidade do paciente. Nas imagens, ele tenta vestir a própria camiseta enquanto interage com a equipe de enfermagem de forma confusa e cômica.\\n\\nA sedação consciente, técnica comum em procedimentos ambulatoriais, usa medicamentos que induzem ao relaxamento profundo e, frequentemente, causam amnésia retrógrada.",
-    "legenda": true
-  }}
-]
-
-INSTRUÇÕES FINAIS:
-
-Mande apenas o JSON na resposta. Verifique se o JSON é válido. Responda em uma lista de objetos, mesmo que seja apenas um item.
-
-NUNCA adicione perguntas, sugestões ou qualquer texto adicional após o JSON.
-Se o contexto enviado pelo usuário não for verdadeiro ou estiver impreciso, ignore completamente. Gere uma legenda para o Instagram correta e factual, inspirada nos exemplos acima. NUNCA cite ou mencione a imprecisão do contexto original (ex: não escreva "Justin Bieber não teve o carro quebrado em 2018 como sugere a legenda do vídeo"). Simplesmente apresente a informação correta de forma natural.
-"""
-
-        # 4. Enviar para o Gemini
-        model_name = request.model or "flash"
-        chatbot = chatbots.get(model_name, chatbots.get('flash', chatbots['default']))
-        
-        print(f"🧠 [GenerateElements] Enviando para Gemini ({model_name})...")
-        
-        response_gemini = await chatbot.ask(prompt, video=video_path_to_analyze)
-        
-        if response_gemini.get("error"):
-            raise HTTPException(status_code=500, detail=f"Erro no Gemini: {response_gemini.get('content')}")
-            
-        content = response_gemini.get("content", "")
-        print(f"✅ Resposta recebida ({len(content)} chars)")
-        
-        # 5. Processar Resposta (JSON)
-        titles_data = extract_json_from_text(content)
-        
-        if not titles_data:
-            print(f"⚠️ Falha ao extrair JSON. Conteúdo bruto: {content[:200]}...")
-            return JSONResponse(content={"raw_content": content, "error": "Failed to parse JSON"}, status_code=200)
-
-        # Garantir que seja uma lista
-        if isinstance(titles_data, dict):
-            titles_data = [titles_data]
-            
-        return titles_data
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno: {str(e)}")
-    finally:
-        # Limpar arquivos temporários
-        if temp_file and os.path.exists(temp_file.name):
-            try:
-                os.unlink(temp_file.name)
-            except: pass
-        if cut_file and os.path.exists(cut_file.name):
-            try:
-                os.unlink(cut_file.name)
-            except: pass
-
-
-
-
-# ==========================================
-# GROQ ENDPOINT
-# ==========================================
-
-GROQ_API_KEY = "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"
-
-GROQ_SUPPORTED_LANGUAGES = {
-    "af", "am", "ar", "as", "az", "ba", "be", "bg", "bn", "bo", "br", "bs", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fa", "fi", "fo", "fr", "gl", "gu", "ha", "haw", "he", "hi", "hr", "ht", "hu", "hy", "id", "is", "it", "ja", "jw", "ka", "kk", "km", "kn", "ko", "la", "lb", "ln", "lo", "lt", "lv", "mg", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "ne", "nl", "nn", "no", "oc", "pa", "pl", "ps", "pt", "ro", "ru", "sa", "sd", "si", "sk", "sl", "sn", "so", "sq", "sr", "su", "sv", "sw", "ta", "te", "tg", "th", "tk", "tl", "tr", "tt", "uk", "ur", "uz", "vi", "yi", "yo", "zh", "yue"
-}
-
-class GroqRequest(BaseModel):
-    url: str
-    language: Optional[str] = None
-    temperature: Optional[float] = 0.4
-    has_bg_music: Optional[bool] = False # Default to False for speed/resources
-    time_start: Optional[float] = None
-    time_end: Optional[float] = None
-
-def groq_json_to_srt(data):
-    """Converte resposta verbose_json do Whisper/Groq para SRT usando segmentos (frases)."""
-    srt_output = ""
-    
-    segments = data.get("segments") or []
-    for i, segment in enumerate(segments, 1):
-        start = seconds_to_srt_time(segment["start"])
-        end = seconds_to_srt_time(segment["end"])
-        text = segment["text"].strip()
-        srt_output += f"{i}\n{start} --> {end}\n{text}\n\n"
-            
-    return srt_output
-
-def groq_words_to_text(data):
-    """Extrai timestamps word-level do Groq e formata como texto legível."""
-    words = data.get("words") or []
-    if not words:
-        return ""
-    
-    lines = []
-    for w in words:
-        word_text = w.get("word", "").strip()
-        start = w.get("start", 0)
-        end = w.get("end", 0)
-        lines.append(f"  [{start:.3f}s - {end:.3f}s] {word_text}")
-    
-    return "\n".join(lines)
-
-from srt_utils import apply_netflix_style_filter, process_audio_for_transcription, shift_srt_timestamps
-
-async def get_groq_srt_base(url: str, language: Optional[str] = None, temperature: Optional[float] = 0.4, has_bg_music: bool = False, time_start: float = None, time_end: float = None):
-    """
-    Helper para gerar SRT base usando Groq (dando suporte a filtro Netflix).
-    Retorna (srt_filtered, srt_word_level, processed_audio_url)
-    Agora faz download e pré-processamento do áudio localmente para melhorar qualidade.
-    """
-    if not url:
-         raise HTTPException(status_code=400, detail="URL é obrigatória para processamento Groq")
-
-    # 1. Baixar arquivo
-    print(f"⬇️ [Groq] Baixando arquivo para pré-processamento...")
-    try:
-        response = download_file_with_retry(url)
-    except Exception as e:
-        print(f"⚠️ Falha ao baixar arquivo para Groq: {e}")
-        raise HTTPException(status_code=400, detail=f"Falha ao baixar arquivo: {e}")
-
-    # Salvar temp
-    content_type = response.headers.get('content-type', '').lower()
-    ext = '.mp3' # Default fallback
-    if 'video' in content_type: ext = '.mp4'
-    elif 'audio' in content_type: ext = '.mp3'
-    
-    # Usar arquivo estático para poder retornar URL
-    import uuid
-    filename = f"audio_{int(time.time())}_{uuid.uuid4().hex[:8]}{ext}"
-    filepath = os.path.join("static", filename)
-    
-    with open(filepath, "wb") as f:
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                f.write(chunk)
-    
-    processed_audio_url = None
-    processed_filename = None
-    
-    try:
-        # 2. Pré-processar (Remover ruído, filtrar voz, etc)
-        groq_url = "https://api.groq.com/openai/v1/audio/transcriptions"
-        groq_headers = {
-            "Authorization": f"Bearer {GROQ_API_KEY}"
+    global client
+    print("Iniciando cliente do Gemini em plano de fundo...")
+    client = GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)
+    # Mantém os cookies renovando automaticamente e a conexão viva
+    await client.init(timeout=30, auto_close=False, close_delay=300, auto_refresh=True)
+    print("Cliente inicializado com sucesso!")
+
+class PromptRequest(BaseModel):
+    prompt: str
+    model: int = 0 # 0 por padrão (unspecified)
+
+@app.post("/ask")
+async def ask_gemini(request: PromptRequest):
+    if not client:
+        raise HTTPException(status_code=500, detail="Gemini client is not initialized yet.")
+    
+    # 0 = Padrão
+    # 2 = 3.0 Pro
+    # 3 = 3.0 Flash
+    # 4 = 3.0 Flash Thinking
+    # 5 = 3.1 Pro
+    modelo_selecionado = "unspecified"
+    if request.model == 2:
+        modelo_selecionado = Model.G_3_0_PRO
+    elif request.model == 3:
+        modelo_selecionado = Model.G_3_0_FLASH
+    elif request.model == 4:
+        modelo_selecionado = Model.G_3_0_FLASH_THINKING
+    elif request.model == 5:
+        modelo_selecionado = "gemini-3.1-pro"
+        
+    try:
+        response = await client.generate_content(request.prompt, model=modelo_selecionado)
+        
+        result = {
+            "text": response.text,
         }
         
-        print(f"🔊 [Groq] Pré-processando áudio (has_bg_music={has_bg_music})...")
-        processed_file_path = process_audio_for_transcription(filepath, has_bg_music=has_bg_music, time_start=time_start, time_end=time_end)
-        
-        if processed_file_path != filepath:
-             pass
-             
-        processed_filename = os.path.basename(processed_file_path)
-        processed_audio_url = f"/static/{processed_filename}"
-
-        # 3. Enviar áudio PROCESSADO para Groq (segments + word-level)
-        with open(processed_file_path, "rb") as f:
-            files = [
-                ("model", (None, "whisper-large-v3")),
-                ("file", ("audio.mp3", f, "audio/mpeg")),
-                ("temperature", (None, str(temperature))),
-                ("response_format", (None, "verbose_json")),
-                ("timestamp_granularities[]", (None, "segment")),
-                ("timestamp_granularities[]", (None, "word"))
-            ]
-            
-            if language and language in GROQ_SUPPORTED_LANGUAGES:
-                files.append(("language", (None, language)))
+        # Opcional: Se houver pensamentos (Flash Thinking) ou imagens, retorna também
+        if hasattr(response, 'thoughts') and response.thoughts:
+            result["thoughts"] = response.thoughts
             
-            print(f"🧠 [Groq] Enviando ÁUDIO PROCESSADO para API...")
+        if hasattr(response, 'images') and response.images:
+            result["images"] = [{"title": img.title, "url": img.url} for img in response.images]
             
-            max_retries = 3
-            result = None
-            
-            for attempt in range(max_retries):
-                try:
-                    f.seek(0)
-                    
-                    response_groq = requests.post(groq_url, headers=groq_headers, files=files, timeout=300)
-                    
-                    if response_groq.status_code == 200:
-                        result = response_groq.json()
-                        break
-                    
-                    error_msg = response_groq.text.lower()
-                    is_deadline = "context deadline exceeded" in error_msg
-                    is_server = response_groq.status_code >= 500
-                    
-                    if (is_deadline or is_server) and attempt < max_retries - 1:
-                        wait_time = 2 * (attempt + 1)
-                        print(f"⚠️ Erro transiente Groq ({response_groq.status_code}). Retentando em {wait_time}s...")
-                        await asyncio.sleep(wait_time)
-                        continue
-                        
-                    raise HTTPException(status_code=response_groq.status_code, detail=f"Erro Groq: {response_groq.text}")
-                    
-                except requests.RequestException as e:
-                    if attempt < max_retries - 1:
-                        print(f"⚠️ Erro conexão Groq. Retentando...")
-                        await asyncio.sleep(2)
-                        continue
-                    raise HTTPException(status_code=500, detail=f"Erro conexão Groq: {e}")
-
-    finally:
-        # Cleanup do arquivo original
-        if filepath and os.path.exists(filepath) and filepath != processed_file_path:
-             try: os.unlink(filepath)
-             except: pass
-
-    # Converter para SRT
-    srt_base = groq_json_to_srt(result)
-    word_level_text = groq_words_to_text(result)
-    
-    return srt_base, srt_base, processed_audio_url, word_level_text
-
-@app.post("/subtitle/groq")
-async def generate_subtitle_groq(request: GroqRequest):
-    """
-    Endpoint para gerar legendas usando Groq API.
-    Agora envia a URL diretamente para a API do Groq e aplica filtro Netflix.
-    """
-    try:
-        srt_filtered, srt_word, processed_audio_url, _word_level = await get_groq_srt_base(
-            url=request.url, 
-            language=request.language, 
-            temperature=request.temperature,
-            has_bg_music=request.has_bg_music,
-            time_start=request.time_start,
-            time_end=request.time_end
-        )
-        
-        # Shift timestamps if needed
-        if request.time_start and request.time_start > 0:
-            srt_filtered = shift_srt_timestamps(srt_filtered, request.time_start)
-            srt_word = shift_srt_timestamps(srt_word, request.time_start)
-        
-        return JSONResponse(content={
-            "srt": srt_filtered,
-            "srt_word": srt_word
-        })
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno: {str(e)}")
-
-class GeminiSubtitleRequest(BaseModel):
-    url: str
-    has_bg_music: Optional[bool] = False
-    context: Optional[str] = "N/A"
-    model: Optional[str] = "flash" # 'flash' or 'thinking'
-    time_start: Optional[float] = None
-    time_end: Optional[float] = None
-
-@app.post("/subtitle")
-async def generate_subtitle(request: GeminiSubtitleRequest):
-    """
-    Endpoint PRINCIPAL: 
-    1. Baixa e Processa áudio (Demucs opcional + Filtros FFmpeg)
-    2. Gera SRT base via Groq (Whisper)
-    3. Envia Áudio Processado + SRT Base + Prompt para Gemini
-    4. Gemini analisa entonação/contexto e traduz/corrige.
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-        
-    try:
-        # 1. Obter SRT base + Caminho do áudio processado
-        print("🚀 Iniciando pipeline completo de legendagem Gemini...")
-        
-        srt_filtered, srt_word, processed_audio_url, word_level_text = await get_groq_srt_base(
-            url=request.url,
-            language="en", 
-            temperature=0.4,
-            has_bg_music=request.has_bg_music,
-            time_start=request.time_start,
-            time_end=request.time_end
-        )
-        
-        # Converter URL /static/xyz.mp3 para path local
-        # processed_audio_url ex: "/static/audio_..."
-        # Converter URL /static/xyz.mp3 para path local
-        # processed_audio_url ex: "/static/audio_..."
-        filename = processed_audio_url.split("/")[-1]
-        
-        # O arquivo pode estar em static/ (se não processado) ou static/processed/ (se processado)
-        processed_audio_path = os.path.join("static", filename)
-        
-        if not os.path.exists(processed_audio_path):
-             # Tentar subpasta processed
-             processed_audio_path = os.path.join("static", "processed", filename)
-             
-        if not os.path.exists(processed_audio_path):
-             raise HTTPException(status_code=500, detail=f"Arquivo de áudio processado não encontrado: {processed_audio_path}")
-             
-        # 2. Selecionar Modelo Gemini
-        requested_model = request.model.lower()
-        chatbot_key = 'thinking' if 'thinking' in requested_model else 'flash'
-        chatbot = chatbots.get(chatbot_key, chatbots['default'])
-            
-        print(f"🧠 [Gemini] Enviando SRT + Áudio para análise ({chatbot_key})...")
-        
-        # 3. Montar Prompt
-        context_default = "Separe a legenda corretamente, nunca deixe muito texto em uma só legenda. Traduza corretamente e separe quem fala também, nunca bote 2 falantes numa mesma legenda. Se baseie no legenda por palavra pra se basear no timing."
-        processed_context = request.context if request.context and request.context.strip() not in ["", "N/A"] else context_default
-        
-        prompt = f"""
-IDIOMA: A legenda traduzida DEVE ser inteiramente em PORTUGUÊS DO BRASIL (pt-BR). Independente do idioma original do vídeo.
-
-Traduza essa legenda pro português do Brasil, corrija qualquer erro de formatação, pontuação e mantenha timestamps e os textos nos seus respectivos blocos de legenda.
-Deve traduzir exatamente o texto da legenda observando o contexto, não é pra migrar, por exemplo, textos de um bloco de legenda pra outro. Deve traduzir exatamente o texto de cada bloco de legenda, manter sempre as palavras, nunca retirar.
-Mande o SRT completo, sem textos adicionais na resposta, apenas o SRT traduzido. Também analise o áudio anexado pra ver se algo foi legendado incorretamente ou errado, ou se algo não for legendado. Se não for, inclua, sem mudar o timestamp já existente. A legenda acima é uma base gerada pelo Whisper que precisa ser analisada e traduzida, não o resultado final.
-A legenda deve ser totalmente traduzida corretamente analisando o contexto e a entonação de falar. Se alguém estiver gritando, ESCREVA MAIÚSCULO! etc... Adapte gírias e qualquer coisa do tipo. Não deve ser literal a tradução, deve se adaptar.
-
-TIMING E TIMESTAMPS:
-- Abaixo da legenda base (SRT), você receberá também os TIMESTAMPS POR PALAVRA (word-level) gerados pelo Whisper.
-- Esses timestamps indicam o início e fim exato de cada palavra falada no áudio.
-- USE esses timestamps para verificar se os blocos de legenda estão sincronizados corretamente.
-- Se perceber que uma palavra está no bloco errado (começa depois do timestamp do bloco seguinte, por exemplo), MOVA-A para o bloco correto.
-- Se precisar criar novos blocos ou ajustar timestamps, baseie-se nos timestamps word-level para garantir precisão.
-- Os timestamps por palavra são a fonte de verdade para saber QUANDO cada palavra é falada.
-
-MÚSICA E LETRAS:
-- Se houver música/canto no vídeo, VOCÊ DEVE LEGENDAR A LETRA.
-- Adicione o símbolo ♪ no início e no final de cada frase cantada. Ex: ♪ Hello, it's me ♪
-- PESQUISE NA INTERNET a letra correta da música e sua tradução oficial/mais aceita para garantir que está correto. Tente identificar a música pelo áudio se não souber.
-- Mantenha a sincronia com o áudio.
-
-EXEMPLO:
-
-(Original): 1
-00:00:01,000 --> 00:00:04,000
-hey what are you doing here i thought you left already
-
-2
-00:00:04,500 --> 00:00:07,200
-yeah i was going to but then i realized i forgot my keys
-
-3
-00:00:07,900 --> 00:00:10,500
-you always forget something man this is crazy
-
-4
-00:00:11,000 --> 00:00:14,000
-relax it's not a big deal stop acting like that
-
-5
-00:00:14,500 --> 00:00:17,800
-i am not acting you said you would be on time
-
-6
-00:00:18,000 --> 00:00:21,500
-okay okay i'm sorry can we just go now
-
-7
-00:00:22,000 --> 00:00:25,000
-fine but if we are late again it's on you
-
-(Traduzido, como você deveria traduzir): 1
-00:00:01,000 --> 00:00:04,000
-Ué, o que você tá fazendo aqui? Não era pra você já ter ido embora?
-
-2
-00:00:04,500 --> 00:00:07,200
-Eu ia, mas aí percebi que esqueci minhas chaves.
-
-3
-00:00:07,900 --> 00:00:10,500
-Cara, você SEMPRE esquece alguma coisa, isso é surreal!
-
-4
-00:00:11,000 --> 00:00:14,000
-Ah, relaxa! Não é o fim do mundo, para de drama.
-
-5
-00:00:14,500 --> 00:00:17,800
-Não é drama! Você falou que ia chegar no horário!
-
-6
-00:00:18,000 --> 00:00:21,500
-Tá, tá... foi mal. Bora logo?
-
-7
-00:00:22,000 --> 00:00:25,000
-Tá bom. Mas se a gente se atrasar de novo, a culpa é SUA!
-
-INSTRUÇÕES/CONTEXTO DO USUÁRIO (OPCIONAL): {processed_context}
-
---- LEGENDA BASE (WHISPER) ---
-{srt_filtered}
-
---- TIMESTAMPS POR PALAVRA (WORD-LEVEL) ---
-{word_level_text}
-"""
-        
-        # 4. Enviar para Gemini
-        response = await chatbot.ask(prompt, audio=processed_audio_path)
-        
-        content = response.get("content", "")
-        if response.get("error"):
-            raise HTTPException(status_code=500, detail=f"Erro no Gemini: {content}")
-            
-        # Limpar markdown do SRT se houver
-        cleaned_srt = clean_and_validate_srt(content)
-        
-        # Shift final timestamps if needed
-        if request.time_start and request.time_start > 0:
-            cleaned_srt = shift_srt_timestamps(cleaned_srt, request.time_start)
-            # original_srt was already shifted? No, srt_filtered comes from get_groq_srt_base which is 0-based
-            # But wait, did we shift srt_filtered before sending to Gemini?
-            # NO. srt_filtered is 0-based.
-            # So send 0-based to Gemini. Gemini returns 0-based.
-            # We shift cleaned_srt.
-            # Optionally shift original_srt for reference
-            srt_filtered = shift_srt_timestamps(srt_filtered, request.time_start)
-        
-        return JSONResponse(content={
-            "srt": cleaned_srt,
-            "original_srt": srt_filtered,
-            "srt_word_level": word_level_text,
-            "used_audio_processed": True
-        })
-
+        return result
     except Exception as e:
-        import traceback
-        traceback.print_exc()
         raise HTTPException(status_code=500, detail=str(e))