Update app.py

app.py

@@ -5,15 +5,54 @@ import os
 import tempfile
 from pathlib import Path
 
-from gemini_client import AsyncChatbot, Model, load_cookies
+from gemini_client import AsyncChatbot, Model, load_cookies, save_cookies
+from gemini_client.enums import Endpoint, Headers
+from curl_cffi.requests import AsyncSession
 
 app = FastAPI(title="Gemini Chat API", description="API para interagir com Google Gemini")
 
 # Inicializar chatbot globalmente
 chatbot = None
 
-async def init_chatbot():
-    """Inicializa o chatbot com os cookies de forma assíncrona"""
+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.
+    """
+    try:
+        # Criar sessão temporária para verificar/atualizar cookie
+        async with AsyncSession() as temp_session:
+            # Tentar fazer requisição de rotação de cookies
+            rotate_resp = await temp_session.post(
+                Endpoint.ROTATE_COOKIES.value,
+                headers=Headers.ROTATE_COOKIES.value,
+                data='[000,"-0000000000000000000"]',
+                cookies={
+                    "__Secure-1PSID": secure_1psid,
+                    "__Secure-1PSIDTS": secure_1psidts
+                },
+                timeout=20
+            )
+            rotate_resp.raise_for_status()
+            
+            # Obter novo cookie se disponível
+            new_1psidts = rotate_resp.cookies.get("__Secure-1PSIDTS")
+            if new_1psidts and new_1psidts != secure_1psidts:
+                # Salvar novo cookie
+                save_cookies(cookie_path, secure_1psid, new_1psidts, additional_cookies)
+                print(f"✓ Cookie atualizado automaticamente antes da inicialização")
+                return new_1psidts
+    except Exception as e:
+        print(f"Aviso: Não foi possível atualizar cookie proativamente: {e}")
+        # Continuar com o cookie original
+    
+    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 chatbot
     cookie_path = os.getenv("COOKIE_PATH", "cookies.json")
     
@@ -24,6 +63,10 @@ async def init_chatbot():
         # 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 AsyncChatbot diretamente
         chatbot = await AsyncChatbot.create(
             secure_1psid=secure_1psid,
@@ -33,6 +76,50 @@ async def init_chatbot():
             cookie_path=cookie_path
         )
         print(f"Chatbot inicializado com sucesso usando {cookie_path}")
+    except (ValueError, PermissionError) as e:
+        error_str = str(e).lower()
+        # Verificar se é erro relacionado a cookie/autenticação
+        if retry_count < max_retries and ("snlm0e" in error_str or "authentication" in error_str or "cookie" in error_str or "not found" in error_str):
+            print(f"Erro ao inicializar (possível cookie expirado): {e}")
+            print(f"Tentando atualizar cookie e reinicializar (tentativa {retry_count + 1}/{max_retries})...")
+            
+            try:
+                # Carregar cookies novamente
+                secure_1psid, secure_1psidts, additional_cookies = load_cookies(cookie_path)
+                
+                # Forçar atualização do cookie
+                async with AsyncSession() as temp_session:
+                    rotate_resp = await temp_session.post(
+                        Endpoint.ROTATE_COOKIES.value,
+                        headers=Headers.ROTATE_COOKIES.value,
+                        data='[000,"-0000000000000000000"]',
+                        cookies={
+                            "__Secure-1PSID": secure_1psid,
+                            "__Secure-1PSIDTS": secure_1psidts
+                        },
+                        timeout=20
+                    )
+                    rotate_resp.raise_for_status()
+                    
+                    new_1psidts = rotate_resp.cookies.get("__Secure-1PSIDTS")
+                    if new_1psidts:
+                        # Salvar novo cookie
+                        save_cookies(cookie_path, secure_1psid, new_1psidts, additional_cookies)
+                        print(f"✓ Cookie atualizado! Reinicializando...")
+                        
+                        # Retentar inicialização
+                        return await init_chatbot(retry_count=retry_count + 1, max_retries=max_retries)
+                    else:
+                        raise ValueError("Novo cookie não encontrado na resposta de rotação")
+            except Exception as update_error:
+                print(f"Erro ao atualizar cookie: {update_error}")
+                if retry_count < max_retries:
+                    # Tentar mais uma vez
+                    return await init_chatbot(retry_count=retry_count + 1, max_retries=max_retries)
+                raise Exception(f"Falha ao inicializar chatbot após {max_retries} tentativas: {update_error}")
+        else:
+            print(f"Erro ao inicializar chatbot: {e}")
+            raise
     except Exception as e:
         print(f"Erro ao inicializar chatbot: {e}")
         raise