Update app.py

app.py

@@ -1,4 +1,4 @@
-# --- INÍCIO DO CÓDIGO FINAL CORRIGIDO ---
+# --- INÍCIO DO CÓDIGO FINAL ---
 
 import gradio as gr
 import os
@@ -9,94 +9,138 @@ import json
 api_key = os.getenv("GOOGLE_API_KEY")
 if not api_key:
     # ⚠️ SUBSTITUA PELA SUA CHAVE REAL ANTES DE EXECUTAR
-    api_key = "AIzaSyBedFD-iX0G6_DODAnjKZNEJbe6mjyHiR0"
+    api_key = "SUA_API_KEY_AQUI"
 
 genai.configure(api_key=api_key)
+model = genai.GenerativeModel('gemini-1.5-pro-latest')
 
-# CORREÇÃO 1: Usando o nome do modelo mais recente e recomendado.
-model = genai.GenerativeModel('gemini-2.5-pro')
-
-# --- PROMPT DE SISTEMA ---
+# --- PROMPT DE SISTEMA MESTRE (SEGUINDO SEU PROTOCOLO) ---
 PROMPT_SISTEMA = """
-Você é um assistente de raciocínio estruturado. Sua função é executar um protocolo de análise de 5 passos antes de fornecer uma resposta final.
-Sua saída DEVE SER SEMPRE um objeto JSON válido, sem nenhum outro texto antes ou depois.
-
-O protocolo funciona da seguinte forma:
-1.  **Passo 1 (Análise Primária):** Receba a dúvida inicial do usuário. Avalie a clareza.
-2.  **Passo 2 (Análise de Propósito):** Infira 'para que' o usuário quer a resposta (estudo, curiosidade, etc.). Se a confiança for baixa, formule uma pergunta para esclarecer.
-3.  **Passo 3 (Análise de Motivação):** Infira 'por que' o usuário quer a resposta (medo, interesse súbito, etc.). Se a confiança for baixa, formule uma pergunta.
-4.  **Passo 4 (Coerência):** Verifique se todas as informações são coerentes.
-5.  **Passo 5 (Resposta Final):** Quando tiver confiança média ou alta em todos os passos, gere a resposta completa para o usuário.
-
-**Estrutura do JSON de Saída:**
+Você é um especialista em análise de intenções que opera sob um protocolo de 5 passos.
+Sua função é conduzir uma conversa para entender completamente a dúvida de um usuário ANTES de respondê-la.
+Sua SAÍDA DEVE SER SEMPRE E SOMENTE um objeto JSON válido.
+
+**PROTOCOLO DE EXECUÇÃO OBRIGATÓRIO:**
+
+Analise o `estado_pipeline` atual e o `historico_conversa`. Decida qual passo executar. Sua resposta em JSON deve conter o estado COMPLETAMENTE ATUALIZADO.
+
+---
+**Passo 1: Análise Primária (Clareza)**
+- **Meta:** A dúvida é compreensível?
+- **Ação:** Analise o `duvida_inicial`.
+- **Decisão:**
+  - Se a clareza for 'baixa' (ex: "flibbertigibbet quântico"), sua resposta JSON DEVE conter: `{"proximo_passo": "aguardando_usuario", "pergunta_para_usuario": "Interessante! O termo que você usou não é padrão. Poderia me dar mais contexto?", ...}`.
+  - Se a clareza for 'media' ou 'alta', atualize `estado.clareza.confianca` para 'alta' e defina `proximo_passo` como `"passo_2_proposito"`.
+
+---
+**Passo 2: Análise de Propósito (Para Que)**
+- **Meta:** Para qual fim a resposta servirá?
+- **Ação:** Analise o histórico para inferir o objetivo prático (`para_que`).
+- **Decisão:**
+  - Se a confiança for 'baixa' (ex: uma pergunta ampla como "o que é asteroide?"), sua resposta JSON DEVE conter: `{"proximo_passo": "aguardando_usuario", "pergunta_para_usuario": "Claro! Para te dar a melhor resposta, qual o seu objetivo? Você está estudando, curioso, escrevendo uma história...?", ...}`.
+  - Se a confiança for 'media' ou 'alta', preencha `estado.proposito.valor` e `estado.proposito.confianca`, e defina `proximo_passo` como `"passo_3_motivacao"`.
+
+---
+**Passo 3: Análise de Motivação (Porquê) e Interesses**
+- **Meta:** Por que o usuário precisa da resposta agora?
+- **Ação:** Analise o histórico para inferir a motivação (`porque`).
+- **Decisão:**
+  - Se a confiança for 'baixa', sua resposta JSON DEVE conter: `{"proximo_passo": "aguardando_usuario", "pergunta_para_usuario": "Entendi. E o que te despertou esse interesse agora? Algo específico que você viu ou ouviu?", ...}`.
+  - Se a confiança for 'media' ou 'alta', preencha `estado.motivacao.valor` e `estado.motivacao.confianca`, e defina `proximo_passo` como `"passo_4_coerencia"`.
+
+---
+**Passo 4: Análise de Coerência**
+- **Meta:** As informações coletadas fazem sentido juntas?
+- **Ação:** Revise `clareza`, `proposito` e `motivacao` em busca de contradições ou lacunas.
+- **Decisão:**
+  - Se a coerência for 'baixa' (ex: propósito é 'estudo', motivação é 'medo de impacto'), formule uma pergunta para resolver a incerteza. Ex: `{"pergunta_para_usuario": "Ok, entendi que é para estudo, mas notei uma preocupação. Você gostaria de focar nos aspectos científicos ou também nos riscos de impacto?", ...}` e `proximo_passo` como `aguardando_usuario`.
+  - Se a coerência for 'alta', atualize `estado.coerencia.confianca` e defina `proximo_passo` como `"passo_5_resposta_final"`.
+
+---
+**Passo 5: Geração da Resposta Final**
+- **Meta:** Tenho tudo para dar uma resposta completa e personalizada.
+- **Ação:** Verifique se todos os passos anteriores têm confiança 'media' ou 'alta'.
+- **Decisão:**
+  - Se sim, construa uma resposta final detalhada, adaptada ao propósito e motivação do usuário. Coloque essa resposta no campo `"resposta_final"` do JSON. Defina `"proximo_passo"` como `"concluido"`.
+  - Se não, volte ao passo com a confiança mais baixa e formule uma nova pergunta.
+
+**ESTRUTURA JSON DE SAÍDA OBRIGATÓRIA:**
 {
-  "proximo_passo": "string",
-  "justificativa_raciocinio": "string",
-  "pergunta_para_usuario": "string | null",
-  "dados_coletados": {
-    "duvida_inicial": "string",
-    "para_que": {"valor": "string | null", "confianca": "baixa|media|alta"},
-    "porque": {"valor": "string | null", "confianca": "baixa|media|alta"}
-  },
-  "resposta_final": "string | null"
+  "raciocinio_do_passo": "Sua breve justificativa interna para a decisão tomada.",
+  "proximo_passo": "string", // "passo_2_proposito", "passo_3_motivacao", "aguardando_usuario", "concluido", etc.
+  "pergunta_para_usuario": "string | null", // A pergunta exata a ser feita ao usuário, se houver.
+  "estado_pipeline_atualizado": { ... }, // O objeto de estado completo e atualizado.
+  "resposta_final": "string | null" // A resposta final, apenas no Passo 5.
 }
-
-**Instrução:**
-Analise o 'Estado Atual da Pipeline' e o 'Histórico da Conversa' fornecidos. Retorne o objeto JSON que representa a próxima ação a ser tomada.
-NÃO responda diretamente ao usuário no histórico. Seu único trabalho é gerar o JSON para a aplicação.
 """
 
 # --- GERENCIAMENTO DE ESTADO ---
 def resetar_estado():
     return {
-        "passo_atual": "passo_1_analise_primaria",
-        "dados_coletados": {
-            "duvida_inicial": None,
-            "para_que": {"valor": None, "confianca": "baixa"},
-            "porque": {"valor": None, "confianca": "baixa"}
-        },
-        "historico_conversa_gemini": []
+        "passo_atual": "passo_1_clareza",
+        "duvida_inicial": None,
+        "clareza": {"confianca": "baixa"},
+        "proposito": {"valor": None, "confianca": "baixa"},
+        "motivacao": {"valor": None, "confianca": "baixa"},
+        "coerencia": {"confianca": "baixa"}
     }
 
-estado_pipeline = resetar_estado()
+estado_pipeline_global = resetar_estado()
+historico_conversa_global = []
 
 # --- FUNÇÃO PRINCIPAL DO CHATBOT ---
 def handle_chat(mensagem, historico_chat_gradio):
-    global estado_pipeline
+    global estado_pipeline_global, historico_conversa_global
 
-    estado_pipeline["historico_conversa_gemini"].append({"role": "user", "parts": [mensagem]})
+    # Adiciona a mensagem atual ao histórico da conversa
+    historico_conversa_global.append({"role": "user", "content": mensagem})
 
-    if estado_pipeline["passo_atual"] == "passo_1_analise_primaria":
-        estado_pipeline["dados_coletados"]["duvida_inicial"] = mensagem
+    # Se for a primeira mensagem, define a dúvida inicial no estado
+    if estado_pipeline_global["duvida_inicial"] is None:
+        estado_pipeline_global["duvida_inicial"] = mensagem
 
+    # Constrói o prompt para o Gemini
     prompt_completo = f"""
     {PROMPT_SISTEMA}
+
     ---
-    **Estado Atual da Pipeline:**
-    {json.dumps(estado_pipeline, indent=2)}
+    **HISTÓRICO DA CONVERSA ATÉ AGORA:**
+    {json.dumps(historico_conversa_global, indent=2)}
+
+    ---
+    **ESTADO ATUAL DA PIPELINE:**
+    {json.dumps(estado_pipeline_global, indent=2)}
     ---
-    **Instrução Final:** Baseado no estado e no histórico, gere o próximo JSON de ação.
+
+    **Instrução Final:** Baseado no estado e no histórico, execute o próximo passo do protocolo e gere o JSON de saída correspondente.
     """
 
     try:
         response = model.generate_content(prompt_completo)
         
+        # Limpa e extrai o JSON da resposta
         resposta_texto = response.text.strip().replace("```json", "").replace("```", "")
         decisao_json = json.loads(resposta_texto)
 
-        estado_pipeline["passo_atual"] = decisao_json.get("proximo_passo")
-        estado_pipeline["dados_coletados"] = decisao_json.get("dados_coletados", estado_pipeline["dados_coletados"])
+        # O LLM é a fonte da verdade: atualiza o estado global com o que foi retornado
+        estado_pipeline_global = decisao_json.get("estado_pipeline_atualizado", estado_pipeline_global)
         
+        # Decide o que mostrar ao usuário
         if decisao_json.get("resposta_final"):
             resposta_para_usuario = decisao_json["resposta_final"]
-            estado_pipeline = resetar_estado()
+            historico_conversa_global.append({"role": "model", "content": resposta_para_usuario})
+            # Reseta tudo para a próxima conversa
+            estado_pipeline_global = resetar_estado()
+            historico_conversa_global = []
             return resposta_para_usuario
 
         elif decisao_json.get("pergunta_para_usuario"):
             resposta_para_usuario = decisao_json["pergunta_para_usuario"]
+            historico_conversa_global.append({"role": "model", "content": resposta_para_usuario})
             return resposta_para_usuario
             
         else:
+            # Caso de erro onde o JSON é válido mas não tem ação para o usuário
             return "Ocorreu um erro no meu raciocínio. Poderia tentar reformular sua pergunta?"
 
     except (json.JSONDecodeError, AttributeError, Exception) as e:
@@ -105,19 +149,27 @@ def handle_chat(mensagem, historico_chat_gradio):
             print(f"Resposta recebida: {response.text}")
         except:
             print("Não foi possível extrair o texto da resposta.")
-        return "Desculpe, tive um problema ao processar sua solicitação. Vamos tentar novamente."
+        return "Desculpe, tive um problema técnico ao processar sua solicitação. Por favor, tente novamente."
 
 
 # --- INTERFACE GRADIO ---
+def on_clear_chat():
+    """Função para ser chamada quando o botão 'Clear' do Gradio é pressionado."""
+    global estado_pipeline_global, historico_conversa_global
+    estado_pipeline_global = resetar_estado()
+    historico_conversa_global = []
+    print("Chat e estado resetados.")
+
 iface = gr.ChatInterface(
     fn=handle_chat,
-    title="🤖 Protótipo de IA com Raciocínio Estruturado",
-    description="Este chatbot segue um protocolo interno de 5 passos para analisar sua dúvida antes de responder. A conversa é guiada por um modelo Gemini que gera instruções em JSON.",
+    title="🤖 Protótipo de IA com Protocolo de Raciocínio",
+    description="Este chatbot segue um protocolo rigoroso para entender sua dúvida antes de responder. A conversa é guiada por um LLM que gerencia o estado do fluxo.",
     chatbot=gr.Chatbot(height=500),
     textbox=gr.Textbox(placeholder="Qual é a sua dúvida?", container=False, scale=7),
 )
+iface.clear_btn.click(on_clear_chat) # Garante que o estado interno seja limpo junto com o chat
 
 if __name__ == "__main__":
     iface.launch()
 
-# --- FIM DO CÓDIGO FINAL CORRIGIDO ---
+# --- FIM DO CÓDIGO FINAL ---