Update app.py

app.py

@@ -141,134 +141,90 @@ def sanitizar_texto(texto: str) -> str:
 # CORREÇÃO DA FUNÇÃO DE CHAMADA DA API (google-genai v1.0+)
 # ===========================================================================
 
-def chamar_gemini_json(model_name: str, prompt: str, temperatura: float = 0.4, max_tokens: int = 8192) -> Dict:
-    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO OBRIGATÓRIA: Sua resposta DEVE ser um único e válido objeto JSON.**"
-    print(f"\n{'='*25} 💬 API INPUT PARA [{model_name}] {'='*25}\n{prompt_completo}\n{'='*78}\n")
+# ============================================================================
+# FUNÇÃO CORRIGIDA: REMOVIDO response_mime_type PARA COMPATIBILIDADE COM TOOLS
+# ============================================================================
+
+def chamar_gemini_json(model_name: str, prompt: str, temperatura: float = 0.7, max_tokens: int = 12000) -> Dict:
+    # 1. Ajuste de Prompt
+    # Modelos "Thinking" funcionam melhor quando explicamos o que queremos, 
+    # mas mantemos a proibição de Markdown no output final para facilitar o regex.
+    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO CRÍTICA: Ao final do seu raciocínio, sua resposta FINAL deve ser estritamente um único objeto JSON válido. Não use blocos de código markdown"
+    
+    print(f"\n{'='*25} 💬 API INPUT PARA [{model_name}] {'='*25}\n{prompt_completo[:300]}...\n{'='*78}\n")
 
     try:
-        # 1. Monta a estrutura de `contents`
-        contents = [
-            types.Content(
-                role="user",
-                parts=[types.Part.from_text(text=prompt_completo)],
-            ),
-        ]
+        # 2. Configurar o Thinking
+        # include_thoughts=True fará com que o pensamento apareça no output (ajuda a debugar), 
+        # mas o seu regex filtrará para pegar só o JSON depois.
+        thinking_config = types.ThinkingConfig(
+            include_thoughts=True 
+        )
 
-        # 2. Define as ferramentas (Google Search)
+        # 3. Ferramentas (Google Search)
         tools = [
             types.Tool(google_search=types.GoogleSearch()),
         ]
 
-        # 3. Monta a configuração
-        # NOTA: Verifique se o modelo suporta 'thinking_config'. Se der erro, remova essa linha.
-        # Models como gemini-2.0-flash-thinking suportam. O 2.5-pro padrão pode não suportar.
-        thinking_config = None
-        if "thinking" in model_name: # Lógica opcional para ativar apenas se for modelo thinking
-             thinking_config = types.ThinkingConfig(thinking_budget=8192) 
-
+        # 4. Configuração da Geração
+        # ATENÇÃO: Modelos "Thinking" exigem temperatura maior ou igual a 0.7 para serem criativos no raciocínio.
+        # removemos 'response_mime_type' pois conflita com Tools e Thinking juntos.
         generate_content_config = types.GenerateContentConfig(
-            temperature=temperatura,
+            temperature=0.7,             # Thinking requer > 0
             max_output_tokens=max_tokens,
-            thinking_config=thinking_config, # Descomente se tiver certeza que o modelo suporta
-            tools=tools,
-            response_mime_type="application/json" # Força JSON nativo se o modelo suportar
+            thinking_config=thinking_config,
+            tools=tools
         )
 
-        # 4. Chamada de API Corrigida
-        # A nova SDK usa client.models.generate_content_stream
-        # O parâmetro de configuração chama-se 'config', não 'generation_config'
+        # 5. Configurar Conteúdo
+        contents = [
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=prompt_completo)],
+            ),
+        ]
+
+        # 6. Chamada API
         stream = CLIENT.models.generate_content_stream(
             model=model_name,
             contents=contents,
             config=generate_content_config,
         )
         
-        # Agrega a resposta do stream
+        # 7. Agregar Resposta
         resposta_bruta = ""
         for chunk in stream:
+            # Captura partes de texto e partes de pensamento (se retornadas como texto no stream)
             if chunk.text:
                 resposta_bruta += chunk.text
+            # Modelos Thinking as vezes retornam "executable_code", garantimos pegar apenas texto
+            
+        print(f"\n{'='*25} 📥 API RAW OUTPUT (Thinking + JSON) {'='*25}\n{resposta_bruta[:500]}... [conteudo longo] ...\n{'='*78}\n")
         
-        print(f"\n{'='*25} 📥 API RAW OUTPUT DE [{model_name}] {'='*25}\n{resposta_bruta}\n{'='*78}\n")
+        # 8. Sanitização e Extração
+        # Como o modelo vai "pensar" primeiro, o texto vai começar com o raciocínio e terminar com o JSON.
+        # O Regex aqui é CRUCIAL.
+        match = re.search(r'(\{.*\})', resposta_bruta, re.DOTALL)
         
-        resposta_sanitizada = sanitizar_texto(resposta_bruta)
-
-        if not resposta_sanitizada:
-            logger.log("A API retornou uma resposta vazia. Causa provável: Filtros de segurança.", "WARN")
-            return {"erro": "API_EMPTY_RESPONSE", "causa_provavel": "Filtro de segurança do modelo."}
-        
-        # Tenta extrair JSON (caso o response_mime_type não seja estritamente respeitado ou venha markdown)
-        match = re.search(r'\{.*\}', resposta_sanitizada, re.DOTALL)
-        if not match:
-            # Tenta parsear direto caso a string inteira seja o JSON
-            try:
-                return json.loads(resposta_sanitizada)
-            except:
-                return {"erro": "JSON_NOT_FOUND", "detalhes": "Nenhum objeto JSON encontrado na resposta da API.", "raw": resposta_sanitizada}
-        
-        return json.loads(match.group(0))
+        if match:
+            json_str = match.group(0)
+            return json.loads(json_str)
+        else:
+            # Fallback: Tenta limpar chars estranhos caso o regex falhe
+            logger.log("Regex primário falhou, tentando limpeza forçada...", "WARN")
+            resposta_sanitizada = sanitizar_texto(resposta_bruta)
+            match_retry = re.search(r'(\{.*\})', resposta_sanitizada, re.DOTALL)
+            if match_retry:
+                return json.loads(match_retry.group(0))
+            
+            return {"erro": "JSON_NOT_FOUND", "raw": resposta_bruta[:500], "detalhes": "O modelo pensou mas não entregou o JSON no formato esperado."}
         
     except Exception as e:
-        logger.log(f"Falha na chamada da API ou no parse do JSON: {e}", "ERROR")
-        return {"erro": "API_CALL_OR_PARSE_FAILED", "detalhes": str(e)}
-
-
-
-def chamar_gemini_json1(model_name: str, prompt: str, temperatura: float = 0.4, max_tokens: int = 92048) -> Dict:
-    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO OBRIGATÓRIA: Sua resposta DEVE ser um único e válido objeto JSON.**"
-    print(f"\n{'='*25} 💬 API INPUT PARA [{model_name}] {'='*25}\n{prompt_completo}\n{'='*78}\n")
+        logger.log(f"Falha na chamada da API com Thinking: {e}", "ERROR")
+        return {"erro": "API_CALL_FAILED", "detalhes": str(e)}
 
-    try:
-        # 1. Monta a estrutura de `contents`
-        contents = [
-            types.Content(
-                role="user",
-                parts=[types.Part.from_text(text=prompt_completo)],
-            ),
-        ]
-
-        # 2. Define as ferramentas a serem usadas
-        tools = [
-            types.Tool(google_search=types.GoogleSearch()),
-        ]
-
-        # 3. Monta a configuração da geração de conteúdo
-        # A sintaxe do 'thinking_config' foi corrigida.
-        generate_content_config = types.GenerateContentConfig(
-            temperature=temperatura,
-            max_output_tokens=max_tokens,
-            thinking_config=types.ThinkingConfig(thinking_budget=8192), # Habilitar se o modelo suportar
-            tools=tools,
-        )
-
-        # 4. Chama o método de stream e agrega os chunks
-        stream = CLIENT.generate_content(
-            model=f"{model_name}", # O nome do modelo agora precisa do prefixo 'models/'
-            contents=contents,
-            generation_config=generate_content_config,
-            stream=True
-        )
         
-        # Agrega a resposta do stream em uma única string
-        resposta_bruta = "".join(chunk.text for chunk in stream)
-        
-        print(f"\n{'='*25} 📥 API RAW OUTPUT DE [{model_name}] {'='*25}\n{resposta_bruta}\n{'='*78}\n")
-        
-        resposta_sanitizada = sanitizar_texto(resposta_bruta)
 
-        if not resposta_sanitizada:
-            logger.log("A API retornou uma resposta vazia. Causa provável: Filtros de segurança.", "WARN")
-            return {"erro": "API_EMPTY_RESPONSE", "causa_provavel": "Filtro de segurança do modelo."}
-        
-        match = re.search(r'\{.*\}', resposta_sanitizada, re.DOTALL)
-        if not match:
-            return {"erro": "JSON_NOT_FOUND", "detalhes": "Nenhum objeto JSON encontrado na resposta da API."}
-        
-        return json.loads(match.group(0))
-        
-    except Exception as e:
-        logger.log(f"Falha na chamada da API ou no parse do JSON: {e}", "ERROR")
-        return {"erro": "API_CALL_OR_PARSE_FAILED", "detalhes": str(e)}
 
 def criar_dna() -> Dict:
     return { "historico_chat": [], "meta": {"total_turnos": 0}, "pipeline_state": { "status": "completed", "paused_at_step": None, "saved_data": {} } }