Update app.py

app.py

@@ -10,27 +10,27 @@ import gradio as gr
 import google.generativeai as genai
 
 # ============================================================================
-# CONFIGURAÇÃO
+# CONFIGURAÇÃO GERAL
 # ============================================================================
-# Filtra avisos do gRPC para limpar o console
+# Filtra avisos do sistema para limpar o console
 warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
-# API KEY
+# API KEY - Tenta pegar do ambiente, senão avisa
 API_KEY = os.getenv("GOOGLE_API_KEY", "")
+
 if not API_KEY:
-    print("❌ ERRO CRÍTICO: GOOGLE_API_KEY não encontrada nas variáveis de ambiente.")
-    print("Defina com: export GOOGLE_API_KEY='sua_chave'")
-    # Não paramos o script, mas vai dar erro na chamada
+    print("\n⚠️ AVISO: GOOGLE_API_KEY não encontrada!")
+    print("👉 Para funcionar, defina a chave ou cole no código (não recomendado em prod).\n")
 else:
     print(f"✅ API Key carregada (termina em ...{API_KEY[-4:]})")
 
 genai.configure(api_key=API_KEY)
-model = genai.GenerativeModel("gemini-2.0-flash")
+model = genai.GenerativeModel("gemini-1.5-flash")
 
-TITLE = "# 🛠️ Anise v10.2 DEBUG MODE\n**Console mostra SAÍDA BRUTA**"
+TITLE = "# 🛠️ Anise v10.3 (Stable Debug)\n**Logs Brutos no Terminal | Correção de Estado**"
 
 # ============================================================================
-# SISTEMA DE LOGS & DEBUG
+# SISTEMA DE LOGS & UTILITÁRIOS
 # ============================================================================
 def debug_print(titulo: str, conteudo: any):
     """Imprime no console com formatação visível para debug"""
@@ -43,9 +43,6 @@ def debug_print(titulo: str, conteudo: any):
         print(str(conteudo))
     print(f"{'='*60}\n")
 
-# ============================================================================
-# HELPERS (SEM TRY/EXCEPT PARA DEBUG)
-# ============================================================================
 def processar_anexo(arquivo) -> Tuple[str, str]:
     if arquivo is None: 
         return "", "nenhum"
@@ -54,92 +51,98 @@ def processar_anexo(arquivo) -> Tuple[str, str]:
     print(f"📂 Processando arquivo: {caminho}")
 
     if caminho.lower().endswith('.pdf'):
-        import PyPDF2  # Se falhar aqui, queremos ver o erro de importação
-        with open(caminho, 'rb') as f:
-            leitor = PyPDF2.PdfReader(f)
-            texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:5])
-            print(f"📄 PDF extraído: {len(texto)} caracteres")
-            return texto[:5000], "pdf"
+        try:
+            import PyPDF2
+            with open(caminho, 'rb') as f:
+                leitor = PyPDF2.PdfReader(f)
+                texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:5])
+                print(f"📄 PDF extraído: {len(texto)} caracteres (5 primeiras págs)")
+                return texto[:5000], "pdf"
+        except ImportError:
+            print("❌ Erro: PyPDF2 não instalado. O PDF será ignorado.")
+            return "Erro: Instale PyPDF2", "erro"
+        except Exception as e:
+            print(f"❌ Erro ao ler PDF: {e}")
+            return str(e), "erro"
             
     elif any(caminho.lower().endswith(ext) for ext in ['.png','.jpg','.jpeg','.gif','.webp']):
-        with open(caminho, 'rb') as f:
-            encoded = base64.b64encode(f.read()).decode()
-            print(f"🖼️ Imagem codificada: {len(encoded)} bytes")
-            return encoded, "imagem"
+        try:
+            with open(caminho, 'rb') as f:
+                encoded = base64.b64encode(f.read()).decode()
+                print(f"🖼️ Imagem codificada: {len(encoded)} bytes")
+                return encoded, "imagem"
+        except Exception as e:
+            print(f"❌ Erro ao ler imagem: {e}")
+            return str(e), "erro"
             
     return "", "nao_suportado"
 
 def limpar_json_raw(texto: str) -> str:
-    """Limpa markdown ```json ... ``` para tentar parsear"""
+    """Limpa blocos markdown do texto"""
     texto = re.sub(r'^```json\s*', '', texto, flags=re.MULTILINE)
     texto = re.sub(r'^```\s*', '', texto, flags=re.MULTILINE)
     texto = re.sub(r'```$', '', texto, flags=re.MULTILINE)
     return texto.strip()
 
-def chamar_gemini_json(prompt_base: str, etapa: str, temperatura=0.2, max_tokens=2000) -> Dict:
-    """
-    Chama o Gemini e imprime o RAW OUTPUT.
-    Se falhar o JSON, explode o erro para análise.
-    """
+def chamar_gemini_json(prompt_base: str, etapa: str, temperatura=0.2) -> Dict:
+    """Chama a API e exibe o retorno BRUTO antes de processar."""
+    
     full_prompt = f"""{prompt_base}
 
 ---
-**INSTRUÇÃO DE SISTEMA OBRIGATÓRIA:**
+**SISTEMA OBRIGATÓRIO:**
 1. Responda APENAS com um JSON válido.
-2. NÃO use blocos de código markdown (```json).
-3. NÃO escreva texto antes ou depois do JSON.
+2. NÃO use Markdown.
+3. SEM comentários extras.
 """
     
-    # 1. Chamada API
-    print(f"📡 Enviando requisição para {etapa}...")
-    response = model.generate_content(
-        full_prompt, 
-        generation_config=genai.types.GenerationConfig(
-            temperature=temperatura, 
-            max_output_tokens=max_tokens,
-            # response_mime_type="application/json" # Opcional: força modo JSON estrito do 1.5
+    print(f"📡 Request para {etapa}...")
+    try:
+        response = model.generate_content(
+            full_prompt, 
+            generation_config=genai.types.GenerationConfig(
+                temperature=temperatura, 
+                max_output_tokens=2000
+            )
         )
-    )
-    
+    except Exception as e:
+        print(f"🔥 ERRO NA API: {e}")
+        raise e
+
     raw_text = response.text
-    
-    # 2. PRINT DA SAÍDA BRUTA (O que você pediu)
     print(f"\n🛑 SAÍDA BRUTA GEMINI [{etapa}]:")
-    print(f">>> INICIO RAW <<<\n{raw_text}\n>>> FIM RAW <<<")
+    print(f">>>\n{raw_text}\n<<<")
 
-    # 3. Tentativa de Parse (sem try/except silencioso)
     texto_limpo = limpar_json_raw(raw_text)
     
     if not texto_limpo:
-        raise ValueError(f"[{etapa}] Gemini retornou texto vazio!")
+        raise ValueError(f"[{etapa}] Retorno vazio da API")
 
     try:
-        dados_json = json.loads(texto_limpo)
-        return dados_json
+        return json.loads(texto_limpo)
     except json.JSONDecodeError as e:
-        print(f"❌ FALHA NO PARSE JSON [{etapa}]")
-        print(f"Erro: {e}")
-        print("Tentando corrigir manualmente strings...")
-        # Fallback simples se for apenas texto solto (opcional)
-        raise e # Relança o erro para parar o script e ver o traceback
+        print(f"❌ FALHA NO JSON PARSE [{etapa}] - Erro: {e}")
+        # Relançar erro para parar o script e ver o problema
+        raise e
 
 def historico_compacto(historico: List) -> str:
     if not historico: return "Nenhum."
-    return "\n".join([f"{m['role']}: {str(m['content'])[:100]}..." for m in historico[-4:]])
+    return "\n".join([f"{m.get('role','?')}: {str(m.get('content',''))[:100]}..." for m in historico[-4:]])
 
 def criar_dna() -> Dict:
-    return {"historico": [], "meta": {"turnos": 0}}
+    return {
+        "historico": [], 
+        "meta": {"turnos": 0}
+    }
 
 # ============================================================================
-# PIPELINE - PASSOS (COM LOGS EXPLÍCITOS)
+# PASSOS DO PIPELINE
 # ============================================================================
 
 def passo_0_aluno(pergunta: str, historico: List) -> Dict:
     prompt = f"""ETAPA: P0-INTENÇÃO
 HISTÓRICO: {historico_compacto(historico)}
 PERGUNTA: {pergunta}
-
-Analise a intenção do usuário.
 JSON: {{"relacao": "continua|nova", "intent": "resumo"}}"""
     return chamar_gemini_json(prompt, "P0")
 
@@ -147,8 +150,6 @@ def passo_1_triagem(pergunta: str, p0: Dict) -> Dict:
     prompt = f"""ETAPA: P1-TRIAGEM
 P0: {json.dumps(p0)}
 PERGUNTA: {pergunta}
-
-Classifique a pergunta.
 JSON: {{"tipo": "factual|analitica", "complexidade": "alta|baixa"}}"""
     return chamar_gemini_json(prompt, "P1")
 
@@ -156,124 +157,134 @@ def passo_x1_lacunas(pergunta: str, p1: Dict) -> Dict:
     prompt = f"""ETAPA: X1-LACUNAS
 P1: {json.dumps(p1)}
 PERGUNTA: {pergunta}
-
-Quais perguntas o assistente deve fazer a si mesmo para responder isso perfeitamente?
 JSON: {{"perguntas_internas": ["pergunta1", "pergunta2"]}}"""
     return chamar_gemini_json(prompt, "X1")
 
 def passo_x2_resolver(x1: Dict, historico: List) -> Dict:
     perguntas = x1.get("perguntas_internas", [])
     if not perguntas: return {"respostas": []}
-    
     prompt = f"""ETAPA: X2-RESOLUÇÃO
 PERGUNTAS: {json.dumps(perguntas)}
 CONTEXTO: {historico_compacto(historico)}
-
-Responda as perguntas internas.
-JSON: {{"respostas": [{{"p": "pergunta", "r": "resposta", "confianca": "alta|baixa"}}]}}"""
+JSON: {{"respostas": [{{"p": "...", "r": "...", "confianca": "alta|baixa"}}]}}"""
     return chamar_gemini_json(prompt, "X2")
 
 def passo_2_cenarios(pergunta: str, x2: Dict) -> Dict:
     prompt = f"""ETAPA: P2-CENÁRIOS
 DADOS X2: {json.dumps(x2)}
-PERGUNTA ORIGINAL: {pergunta}
-
-Crie cenários de resposta ou decida parar se faltar informação crítica.
-JSON: {{"decisao": "continuar|parar", "cenarios": ["C1: ...", "C2: ..."], "motivo_parada": "..."}}"""
+PERGUNTA: {pergunta}
+JSON: {{"decisao": "continuar|parar", "cenarios": ["C1...", "C2..."], "motivo_parada": "..."}}"""
     return chamar_gemini_json(prompt, "P2")
 
 def passo_7_sintese(p2: Dict, pergunta: str) -> Dict:
     prompt = f"""ETAPA: P7-FINAL
 CENÁRIOS: {json.dumps(p2)}
 PERGUNTA: {pergunta}
-
-Escreva a resposta final para o usuário.
 JSON: {{"resposta_final": "texto aqui"}}"""
-    return chamar_gemini_json(prompt, "P7", temperatura=0.7)
+    return chamar_gemini_json(prompt, "P7", temperatura=0.6)
 
 # ============================================================================
-# ORQUESTADOR (SEM REDE DE SEGURANÇA)
+# ORQUESTADOR (CORRIGIDO)
 # ============================================================================
 def processar_pipeline(pergunta: str, historico: List, arquivo_anexo=None, dna=None) -> Tuple[str, List, Dict]:
-    # Debug inicial
-    debug_print("INICIO PIPELINE", f"Pergunta: {pergunta}\nAnexo: {arquivo_anexo}")
+    debug_print("INICIO PROCESSAMENTO", f"Msg: {pergunta}")
 
-    if dna is None: dna = criar_dna()
+    # --- CORREÇÃO DE ESTADO CRÍTICA ---
+    # Se DNA for None, ou vazio {}, ou faltar a chave "historico", recria.
+    if dna is None or not isinstance(dna, dict) or "historico" not in dna:
+        print("🔄 Inicializando nova estrutura de DNA...")
+        dna = criar_dna()
     
-    # 1. Processar Anexo
+    # 1. Processamento Anexo
     conteudo_anexo, tipo_anexo = processar_anexo(arquivo_anexo)
     
-    # 2. Montar Prompt com Contexto Visual/Documental
     if tipo_anexo == "pdf":
-        prompt_final = f"CONTEXTO DO PDF:\n{conteudo_anexo}\n---\nPERGUNTA: {pergunta}"
+        prompt_final = f"DOCUMENTO PDF:\n{conteudo_anexo}\n---\nPERGUNTA: {pergunta}"
     elif tipo_anexo == "imagem":
-        prompt_final = f"[IMAGEM BASE64: {conteudo_anexo}]\nAnalise a imagem.\nPERGUNTA: {pergunta}"
+        prompt_final = f"[IMAGEM EM BASE64: {conteudo_anexo}]\nAnalise visualmente.\nPERGUNTA: {pergunta}"
     else:
         prompt_final = pergunta
 
-    # 3. Execução Linear (Se falhar, o erro aparece no console)
+    # 2. Execução (Debug via logs de console)
     p0 = passo_0_aluno(prompt_final, historico)
-    debug_print("P0 Resultado", p0)
+    debug_print("P0", p0)
     
     p1 = passo_1_triagem(prompt_final, p0)
-    debug_print("P1 Resultado", p1)
     
     x1 = passo_x1_lacunas(prompt_final, p1)
-    debug_print("X1 Resultado", x1)
+    debug_print("X1 (Perguntas Internas)", x1)
     
     x2 = passo_x2_resolver(x1, historico)
-    debug_print("X2 Resultado", x2)
     
     p2 = passo_2_cenarios(prompt_final, x2)
-    debug_print("P2 Resultado", p2)
+    debug_print("P2 (Cenários)", p2)
     
-    # Lógica de Parada
     if p2.get("decisao") == "parar":
-        resposta = f"⚠️ Não consigo responder com certeza.\nMotivo: {p2.get('motivo_parada')}"
+        resposta = f"🛑 Parada Solicitada.\nMotivo: {p2.get('motivo_parada')}"
     else:
         p7 = passo_7_sintese(p2, prompt_final)
-        debug_print("P7 Resultado", p7)
-        resposta = p7.get("resposta_final", "Erro na síntese P7")
+        resposta = p7.get("resposta_final", "Erro na geração final (P7)")
+    
+    debug_print("RESPOSTA FINAL", resposta)
 
-    # Atualiza Histórico
+    # 3. Atualização Segura
     novo_hist = historico + [
         {"role": "user", "content": pergunta},
         {"role": "assistant", "content": resposta}
     ]
     
-    dna["historico"].append({"turn": dna["meta"]["turnos"], "p": pergunta, "r": resposta[:20]})
+    # Agora é seguro acessar dna["historico"] pois garantimos a inicialização acima
+    dna["historico"].append({
+        "turn": dna["meta"]["turnos"], 
+        "pergunta": pergunta, 
+        "resposta_abrv": resposta[:50]
+    })
     dna["meta"]["turnos"] += 1
     
     return resposta, novo_hist, dna
 
 # ============================================================================
-# INTERFACE
+# INTERFACE GRÁFICA
 # ============================================================================
 def chat_interface(msg, hist, anexo, dna_json):
-    # Converte string JSON do DNA de volta para dict
-    dna = json.loads(dna_json) if dna_json else {}
-    if hist is None: hist = []
+    # Desserializa
+    try:
+        dna = json.loads(dna_json) if dna_json else {}
+    except:
+        dna = {} # Garante pelo menos dict vazio para ser tratado no pipeline
     
-    # Chama o pipeline (Erros vão aparecer no console do servidor)
-    resp, novo_hist, dna_new = processar_pipeline(msg, hist, anexo, dna)
+    if hist is None: hist = []
     
-    return novo_hist, "", json.dumps(dna_new, indent=2), None
+    # Processa
+    try:
+        resp, novo_hist, dna_new = processar_pipeline(msg, hist, anexo, dna)
+        return novo_hist, "", json.dumps(dna_new, indent=2), None
+    except Exception as e:
+        import traceback
+        erro_str = f"ERRO FATAL: {str(e)}"
+        print(traceback.format_exc())
+        return hist, erro_str, dna_json, None
 
 if __name__ == "__main__":
-    with gr.Blocks(title="Anise Debug", theme=gr.themes.Base()) as demo:
+    with gr.Blocks(title="Anise Stable", theme=gr.themes.Base()) as demo:
         gr.Markdown(TITLE)
         
         with gr.Row():
-            chat = gr.Chatbot(height=500, type="messages", label="Chat")
-            dna_box = gr.Code(label="DNA (JSON State)", language="json")
+            chat = gr.Chatbot(height=500, type="messages", label="Chat Anise")
+            dna_box = gr.Code(label="DNA (JSON State)", language="json", lines=20)
             
         with gr.Row():
-            txt_in = gr.Textbox(label="Pergunta", scale=2)
-            file_in = gr.File(label="Anexo")
-            btn = gr.Button("Enviar", variant="primary")
-            
-        btn.click(chat_interface, [txt_in, chat, file_in, dna_box], [chat, txt_in, dna_box, file_in])
-        txt_in.submit(chat_interface, [txt_in, chat, file_in, dna_box], [chat, txt_in, dna_box, file_in])
+            txt_in = gr.Textbox(label="Mensagem", scale=4)
+            file_in = gr.File(label="Anexo", scale=1)
+        
+        btn = gr.Button("Enviar", variant="primary")
+        
+        # Conexões
+        entradas = [txt_in, chat, file_in, dna_box]
+        saidas = [chat, txt_in, dna_box, file_in]
+        
+        btn.click(chat_interface, inputs=entradas, outputs=saidas)
+        txt_in.submit(chat_interface, inputs=entradas, outputs=saidas)
 
-    print("🚀 Servidor Iniciado! Verifique este console para logs.")
+    print("🚀 Servidor online. Acesse o link local abaixo.")
     demo.launch(server_name="0.0.0.0", server_port=7860)