Upload ai_studio_code (3).py

ai_studio_code (3).py

@@ -0,0 +1,836 @@
+# -*- coding: utf-8 -*-
+"""
+Pipeline v10 Refatorada e Comentada - Chatbot com Metacognição Pura.
+
+Este arquivo implementa um chatbot avançado utilizando a API Google Gemini.
+A arquitetura se baseia em uma pipeline de múltiplos passos (P0-P8, X1-X2)
+que analisa, raciocina, gera cenários e verifica as respostas antes de
+entregá-las ao usuário.
+
+Esta versão inclui:
+- A lógica completa da pipeline com todos os passos.
+- Correções para a compatibilidade com o componente gr.Chatbot.
+- Logs de depuração detalhados para as chamadas da API Gemini.
+- Comentários extensivos em todo o código para fins didáticos.
+"""
+
+# ============================================================================
+# 1. IMPORTAÇÕES E CONFIGURAÇÃO INICIAL
+# ============================================================================
+
+# Módulos padrão do Python
+import json
+import os
+import base64
+import re
+import warnings
+from datetime import datetime
+from typing import Dict, List, Tuple, Any
+
+# Bibliotecas de terceiros
+import gradio as gr  # Para a criação da interface web
+import google.generativeai as genai  # SDK oficial do Google para a API Gemini
+
+# Ignora avisos de "FutureWarning" que podem ser gerados por dependências
+# da API do Google, mantendo o console mais limpo.
+warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
+
+# --- Configuração da API Gemini ---
+
+# Carrega a chave da API a partir de uma variável de ambiente chamada "GOOGLE_API_KEY".
+# Esta é uma prática de segurança essencial para não expor chaves secretas no código.
+API_KEY = os.getenv("GOOGLE_API_KEY")
+if not API_KEY:
+    # Se a chave não for encontrada, levanta um erro claro para o usuário.
+    raise ValueError("A variável de ambiente GOOGLE_API_KEY não foi configurada.")
+
+# Configura o SDK do Google com a chave de API fornecida.
+genai.configure(api_key=API_KEY)
+
+# --- Definição dos Modelos ---
+
+# Define os modelos a serem usados na pipeline.
+# O "Counselor" é responsável pela maior parte do raciocínio e geração.
+COUNSELOR_MODEL = genai.GenerativeModel("gemini-1.5-flash")
+# O "Supervisor" é um modelo focado na verificação final e garantia de qualidade.
+SUPERVISOR_MODEL = genai.GenerativeModel("gemini-1.5-flash")
+
+# Título que será exibido na interface do Gradio.
+TITLE = "# 🚀 Pipeline v10 REATORADA E COMENTADA\n**P0-P1 → X1-X2 → P2-P8 (com Metacognição Pura e Verificação)**"
+
+
+# ============================================================================
+# 2. PROMPTS CENTRALIZADOS
+# ============================================================================
+# Centralizar os prompts em um dicionário torna o código mais limpo, fácil de ler
+# e de manter. Cada chave corresponde a um passo da pipeline.
+
+PROMPTS = {
+    "P0_ALUNO": """
+Você é um METACOGNITIVO (pensamento interno, NÃO comunicação).
+
+TURNO ANTERIOR: 
+User: {turno_anterior_user}
+Assistant: {turno_anterior_assistant}
+
+NOVA MENSAGEM: {pergunta}
+CONTEXTO VAGO: {historico_compacto}
+
+---
+
+Responda EM METACOGNIÇÃO PURA - TELEGRÁFICO
+NÃO use frases completas. APENAS essência semântica com conectores mínimos.
+
+EXEMPLO CERTO: entendeu-sim | pergunta-nova | avança-tópico | não-reformulou
+
+RETORNE JSON:
+{{
+  "usuario_entendeu": "sim|não",
+  "evidencias": ["entendeu-pergunta", "pediu-clarificação"],
+  "usuario_corrigiu": "sim|não",
+  "correcao_detectada": null|"texto-correção",
+  "correcao_valida": "sim|não|null",
+  "o_que_melhorar": null|"explicar-X-melhor",
+  "decisao": "prosseguir-passo1|reexplicar-passo6|atualizar-resposta-anterior",
+  "motivo": "texto-curtíssimo"
+}}
+""",
+    "P1_TRIAGEM": """
+METACOGNIÇÃO - TRIAGEM INICIAL.
+
+CONTEXTO VAGO: {contexto_vago}
+HISTÓRICO RECENTE (últimas 3): {historico_recente}
+P0: {p0}
+PERGUNTA: {pergunta}
+
+---
+
+CLASSIFIQUE EM TELEGRÁFICO (sem frases).
+
+RETORNE JSON:
+{{
+  "tipo": "objetiva|factual|subjetiva|aberta",
+  "sinais": ["tem-resposta-única-verificável", "sem-contexto-pessoal"],
+  "confianca": "alta|média|baixa",
+  "decisao": "responder-direto|analisar-profundamente",
+  "razao": "curtíssima",
+  "dados_fatuais": ["fato1", "fato2"],
+  "divergencias_fatuais": ["possível-ambiguidade-1"],
+  "objetivo_principal": "objetivo-primário-identificado",
+  "objetivo_secundario": ["objetivo-secundário-1"]
+}}
+""",
+    "X1_PERGUNTAS_NECESSARIAS": """
+X1-PERGUNTAS CRÍTICAS - TELEGRÁFICO
+P1: {p1}
+CONTEXTO: {historico_compacto}
+PERGUNTA PRINCIPAL: {pergunta}
+
+---
+Analise as lacunas factuais e subjetivas na pergunta do usuário e no contexto.
+Liste as perguntas essenciais que você precisa responder internamente antes de formular a resposta final.
+
+RETORNE JSON:
+{{"perguntas": [
+  {{"texto": "pergunta-curta-e-essencial", "necessidade": "alta|média|baixa", "relevancia": "alta|média"}}
+]}}
+""",
+    "X2_RESOLVER_PERGUNTAS": """
+X2-RESOLUÇÃO INTERNA - TELEGRÁFICO
+P1: {p1}
+PERGUNTAS CRÍTICAS (X1): {perguntas_x1}
+CONTEXTO: {historico_compacto}
+
+---
+Para cada pergunta crítica levantada no passo anterior, forneça uma resposta curta e direta baseada no seu conhecimento.
+Avalie sua confiança e o potencial de conflito ou ambiguidade em cada resposta.
+
+RETORNE JSON:
+{{"respostas": [
+  {{"pergunta": "texto-original-da-pergunta-x1",
+    "resposta": "resposta-curta-e-direta",
+    "confianca": "alta|média|baixa",
+    "conflito": "alto|médio|baixo",
+    "razao": "explicação-em-1-2-palavras"}}
+]}}
+""",
+    "P2_CENARIOS": """
+METACOGNIÇÃO - GERAÇÃO DE CENÁRIOS.
+CONTEXTO VAGO: {historico_compacto}
+TRIAGEM P1: {p1}
+X1-PERGUNTAS: {x1}
+X2-RESPOSTAS: {x2}
+PERGUNTA ORIGINAL: {pergunta}
+
+---
+
+Mapeie cenários possíveis onde a resposta à pergunta original mudaria significativamente. Pense nas diferentes perspectivas, contextos ou premissas que alteram a conclusão. Use formato telegráfico.
+
+RETORNE JSON:
+{{
+  "cenarios": {{
+    "provaveis": [{{"id": "C1", "desc": "cenário-provável-1-comprimido", "contexto-relevante": "descreva-o-contexto"}}]
+  }},
+  "total": 1,
+  "tipo_resposta": "múltipla|unívoca",
+  "confianca": "alta|média|baixa",
+  "decisao": "prosseguir|pedir-esclarecimento",
+  "pergunta_esclarecimento": null|"texto-da-pergunta-para-o-usuario"
+}}
+""",
+    "P3_ISOLAR_CENARIOS": """
+METACOGNIÇÃO - EXPLORAÇÃO DE CENÁRIO ISOLADO.
+CENÁRIO P2: {cenario}
+
+---
+Para este cenário específico, defina a essência da resposta em formato telegráfico. Qual seria a conclusão principal e quais as lacunas de informação restantes?
+
+RETORNE JSON:
+{{"id": "{cenario_id}", 
+  "resposta_essencia": "conclusão-principal-e-razoes-em-palavras-chave", 
+  "confianca": "alta|média|baixa",
+  "lacunas": "contexto-ainda-ausente|null"
+}}
+""",
+    "P4_CRUZAR_VALIDACOES": """
+METACOGNIÇÃO - ABSTRAÇÃO DE CONHECIMENTO.
+P1 (Triagem): {p1}
+P2 (Cenários): {p2}
+P3 (Exploração): {p3}
+X2 (Respostas Internas): {x2}
+
+---
+
+Identifique os princípios fundamentais, teorias ou símbolos arquetípicos que sustentam as respostas nos cenários explorados. Abstraia o conhecimento para um nível mais alto. Use formato telegráfico.
+
+RETORNE JSON:
+{{"principios": [{{"nome": "Custo-Oportunidade", "essencia": "escolher-X-implica-renunciar-Y"}}],
+  "simbolos": [{{"nome": "Jornada-do-Herói", "essencia": "transformação-ocorre-através-de-desafios"}}],
+  "principio_central": "nome-do-principio-mais-importante",
+  "simbolo_dominante": "nome-do-simbolo-mais-relevante"
+}}
+""",
+    "P5_LACUNAS_FINAIS": """
+METACOGNIÇÃO - ANÁLISE DE INCERTEZA.
+P1 (Triagem): {p1}
+P4 (Princípios): {p4}
+
+---
+
+Avalie o balanço entre certezas e dúvidas com base em toda a análise feita até agora. A informação disponível é suficiente para dar uma resposta confiante? Use formato telegráfico.
+
+RETORNE JSON:
+{{"analise_cenarios": [{{"cenario": "C1", "certezas": ["certeza1"], "duvidas": ["dúvida1"]}}],
+  "confianca_global": "alta|média|baixa",
+  "balanco": "certezas-superam|equilibrado|duvidas-superam",
+  "decisao": "responder|questionar",
+  "questionamento": null|"texto-da-pergunta-para-o-usuario-se-a-confianca-for-baixa"
+}}
+""",
+    "P6_PONDERAR": """
+METACOGNIÇÃO - JULGAMENTO FINAL (JUIZ DA VERDADE).
+P2 (Cenários): {p2}
+P4 (Princípios): {p4}
+P5 (Lacunas): {p5}
+
+---
+
+Aja como um árbitro socrático. Com base em toda a metacognição, valide as "verdades" encontradas e decida o nível de consciência sobre a complexidade da resposta. Use formato telegráfico.
+
+RETORNE JSON:
+{{"verdade_principal": "a-conclusao-mais-provavel-e-confiavel",
+  "nuances_importantes": ["nuance1", "nuance2"],
+  "confianca_final": "alta|média|baixa",
+  "decisao": "exibir-resposta-completa|exibir-resposta-com-ressalvas|reprocessar",
+  "nivel_consciencia": "alto|médio|baixo"
+}}
+""",
+    "P7_SINTETIZAR": """
+Você é um SINTETIZADOR especialista em transformar METACOGNIÇÃO CRUA em PROSA HUMANIZADA e empática.
+
+DADOS DO JULGAMENTO (P6): {p6}
+
+---
+
+TAREFA: Converta a análise telegráfica do 'Juiz da Verdade' em uma resposta textual fluida, natural e útil para o usuário.
+
+INSTRUÇÕES:
+1.  Use conectores naturais (ex: "porque", "portanto", "isso significa que").
+2.  Expanda abreviações e jargões para uma linguagem clara.
+3.  Estruture a resposta em parágrafos lógicos (introdução, desenvolvimento, nuances/conclusão).
+4.  Incorpore os princípios e nuances de forma natural na explicação.
+5.  Adote um tom de conselheiro: amigável, empático e empoderador.
+6.  NÃO invente informações. Baseie-se estritamente nos dados do P6.
+
+RETORNE A RESPOSTA EM PROSA DENTRO DE UM JSON:
+{{"resposta": "Aqui vai o texto fluido, natural e humano..."}}
+""",
+    "P8_VERIFICAR": """
+Você é um VERIFICADOR FINAL, um guardião rigoroso da qualidade da resposta.
+
+RESPOSTA SINTETIZADA (P7): 
+{resposta_sintetizada}
+
+ANÁLISE DO JUIZ (P6): 
+{p6}
+
+---
+
+Realize uma verificação tripla na resposta sintetizada. Seja crítico.
+
+1.  **VERIFICAÇÃO FACTUAL**: A resposta contém fatos incorretos ou não sustentados pela análise do P6?
+2.  **VERIFICAÇÃO LÓGICA**: Existem falácias, saltos de lógica ou contradições? A conclusão segue a linha de raciocínio?
+3.  **VERIFICAÇÃO ÉTICA**: A resposta é apropriada, segura e imparcial? Inclui os avisos ou ressalvas necessários?
+
+RETORNE SEU VEREDITO EM JSON:
+{{"verificacao_factual": {{"aprovada": true|false, "problemas": ["descrição do problema se houver"]}},
+  "verificacao_logica": {{"aprovada": true|false, "problemas": []}},
+  "verificacao_etica": {{"aprovada": true|false, "problemas": []}},
+  "todas_aprovadas": true|false,
+  "decisao": "exibir-resposta-original|corrigir-e-exibir",
+  "resposta_corrigida": null|"texto da versão corrigida e melhorada da resposta"
+}}
+"""
+}
+
+# ============================================================================
+# 3. CLASSES E FUNÇÕES HELPERS (UTILITÁRIOS)
+# ============================================================================
+
+class Logger:
+    """
+    Uma classe simples para registrar logs formatados no console.
+    Ajuda a visualizar o fluxo de execução e a depurar problemas.
+    """
+    def __init__(self, verbose: bool = True):
+        self.verbose = verbose
+        self.logs = []
+
+    def log(self, msg: str, level: str = "INFO"):
+        """Registra uma mensagem de log com timestamp, nível e formatação."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_msg = f"[{timestamp}] [{level.upper()}] {msg}"
+        self.logs.append(log_msg)
+        if self.verbose:
+            print(log_msg)
+            # Imprime uma linha divisória para logs importantes, melhorando a visualização.
+            if level.upper() in ["TASK", "START", "SUCCESS", "ERROR"]:
+                 print("=" * 70)
+
+# Instância global do Logger para ser usada em todo o script.
+logger = Logger(verbose=True)
+
+def processar_anexo(arquivo: Any) -> Tuple[str, str]:
+    """
+    Processa um arquivo enviado pela interface do Gradio.
+    Atualmente, a lógica de extração está simplificada, mas a estrutura
+    permite a implementação de leitores de PDF, imagens, etc.
+
+    Args:
+        arquivo: O objeto de arquivo vindo do Gradio.
+
+    Returns:
+        Uma tupla contendo (conteúdo_processado, tipo_do_arquivo).
+    """
+    if arquivo is None:
+        return "", "nenhum"
+    
+    # O objeto 'arquivo' do Gradio tem um atributo '.name' que contém o caminho temporário do arquivo.
+    caminho_arquivo = arquivo.name
+    
+    try:
+        if caminho_arquivo.lower().endswith('.pdf'):
+            # A lógica real de leitura de PDF (com PyPDF2, por exemplo) iria aqui.
+            logger.log("Arquivo PDF detectado.", "INFO")
+            return "[Conteúdo do PDF iria aqui]", "pdf"
+        elif any(caminho_arquivo.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.gif']):
+            # A lógica real de processamento de imagem (com Pillow, por exemplo) iria aqui.
+            logger.log("Arquivo de imagem detectado.", "INFO")
+            return "[Dados da imagem iriam aqui]", "imagem"
+        return "", "nao_suportado"
+    except Exception as e:
+        logger.log(f"Erro ao processar anexo: {e}", "ERROR")
+        return "", "erro"
+
+def construir_prompt_com_anexo(pergunta: str, anexo_conteudo: str, tipo_anexo: str) -> str:
+    """
+    Adiciona o conteúdo do anexo ao prompt da pergunta inicial para dar contexto ao modelo.
+
+    Args:
+        pergunta: A pergunta original do usuário.
+        anexo_conteudo: O conteúdo extraído do anexo.
+        tipo_anexo: O tipo do anexo ('pdf', 'imagem', etc.).
+
+    Returns:
+        O prompt final combinado.
+    """
+    if not anexo_conteudo or tipo_anexo in ["nenhum", "erro", "nao_suportado"]:
+        return pergunta
+    # Formata o prompt de maneira diferente dependendo do tipo de arquivo.
+    if tipo_anexo == "pdf":
+        return f"Com base no documento PDF abaixo, responda à pergunta.\n\nDOCUMENTO:\n---\n{anexo_conteudo}\n---\n\nPERGUNTA: {pergunta}"
+    if tipo_anexo == "imagem":
+        return f"Com base na imagem anexada, responda à pergunta: {pergunta}"
+    return pergunta
+
+def parse_json_ultra_robusto(texto: str) -> Dict:
+    """
+    Extrai um objeto JSON de uma string, mesmo que ela contenha texto adicional
+    ou formatação incorreta (como os marcadores ```json).
+
+    Args:
+        texto: A string retornada pela API que pode conter um JSON.
+
+    Returns:
+        Um dicionário Python com o JSON extraído ou um dicionário de erro.
+    """
+    if not texto:
+        return {"erro": "Texto de entrada vazio"}
+
+    # 1. Tenta extrair JSON de blocos de código (```json ... ```), que é comum em modelos de linguagem.
+    match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', texto, re.DOTALL)
+    if match:
+        json_str = match.group(1)
+    else:
+        json_str = texto
+
+    # 2. Tenta carregar a string extraída como JSON.
+    try:
+        return json.loads(json_str)
+    except json.JSONDecodeError:
+        # 3. Se falhar, tenta um método de "fallback": encontrar o primeiro '{' e o último '}'
+        # e tentar fazer o parse do conteúdo entre eles. Isso ajuda a limpar lixo no início/fim.
+        try:
+            inicio = json_str.find('{')
+            fim = json_str.rfind('}') + 1
+            if inicio != -1 and fim != 0:
+                return json.loads(json_str[inicio:fim])
+        except json.JSONDecodeError:
+            logger.log("Falha na extração robusta de JSON.", "WARN")
+            return {"erro": "parse_falhou", "fallback_text": texto[:500]}
+
+def chamar_gemini_json(modelo: genai.GenerativeModel, prompt: str, temperatura: float = 0.5, max_tokens: int = 2000) -> Dict:
+    """
+    Envia um prompt para o modelo Gemini, solicita uma saída JSON, analisa a resposta
+    e inclui logs detalhados para depuração.
+
+    Args:
+        modelo: A instância do modelo Gemini a ser usada.
+        prompt: O prompt formatado para a tarefa específica.
+        temperatura: Controla a criatividade da resposta (valores mais altos = mais criativo).
+        max_tokens: O número máximo de tokens na resposta.
+
+    Returns:
+        Um dicionário Python com a resposta do modelo ou um dicionário de erro.
+    """
+    # Adiciona uma instrução final e explícita ao prompt para garantir que o modelo retorne JSON.
+    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO OBRIGATÓRIA: Sua resposta DEVE ser um único e válido objeto JSON. Não inclua texto antes ou depois do JSON.**"
+    
+    # === INÍCIO DO LOG DE DEPURAÇÃO (INPUT) ===
+    # Imprime o prompt exato que está sendo enviado para a API.
+    # Essencial para depurar o comportamento do modelo.
+    print("\n" + "="*25 + f" 💬 API INPUT PARA [{modelo.model_name}] " + "="*25)
+    print(prompt_completo)
+    print("="*78 + "\n")
+    logger.log(f"Enviando prompt ({len(prompt_completo)} chars) para {modelo.model_name}", "DEBUG")
+    # === FIM DO LOG DE DEPURAÇÃO (INPUT) ===
+
+    try:
+        # Realiza a chamada para a API Gemini.
+        response = modelo.generate_content(
+            prompt_completo,
+            generation_config=genai.types.GenerationConfig(
+                temperature=temperatura,
+                max_output_tokens=max_tokens,
+            )
+        )
+        
+        # Extrai o texto da resposta.
+        resposta_bruta = response.text or ""
+        
+        # === INÍCIO DO LOG DE DEPURAÇÃO (OUTPUT) ===
+        # Imprime a resposta bruta recebida da API antes de qualquer processamento.
+        # Crucial para ver o que o modelo realmente retornou.
+        print("\n" + "="*25 + f" 📥 API RAW OUTPUT DE [{modelo.model_name}] " + "="*25)
+        print(resposta_bruta)
+        print("="*78 + "\n")
+        logger.log(f"Gemini RAW ({len(resposta_bruta)} chars): {resposta_bruta[:400]}...", "DEBUG")
+        # === FIM DO LOG DE DEPURAÇÃO (OUTPUT) ===
+        
+        # Usa o parser robusto para converter a resposta de texto em um dicionário Python.
+        resultado_json = parse_json_ultra_robusto(resposta_bruta)
+        return resultado_json
+        
+    except Exception as e:
+        # Captura qualquer erro durante a chamada da API (ex: problemas de conexão, erros de permissão).
+        logger.log(f"Erro na chamada da API Gemini: {e}", "ERROR")
+        return {"erro": f"API_ERROR: {str(e)}"}
+
+def historico_compacto(historico: List[Dict]) -> str:
+    """
+    Gera uma string curta com as últimas interações do chat para usar como contexto nos prompts.
+    
+    Args:
+        historico: O histórico de conversa no formato interno.
+
+    Returns:
+        Uma string resumida da conversa recente.
+    """
+    if not historico:
+        return "Nenhuma conversa anterior."
+    
+    # Pega as últimas 4 mensagens, formata e junta em uma única string.
+    compacto = []
+    for msg in historico[-4:]:
+        role = "Usuário" if msg["role"] == "user" else "Assistente"
+        content = msg["content"].split('\n')[:80] # Pega só a primeira linha, até 80 caracteres.
+        compacto.append(f"{role}: {content}")
+        
+    return "\n".join(compacto)
+
+def criar_dna() -> Dict:
+    """
+    Inicializa a estrutura de dados 'DNA' que armazena o estado e metadados da conversa.
+
+    Returns:
+        Um dicionário com a estrutura inicial do DNA.
+    """
+    return {
+        "historico_chat": [],
+        "meta": {"total_turnos": 0}
+    }
+
+# ============================================================================
+# 4. PASSOS DA PIPELINE (P0-P8, X1-X2)
+# ============================================================================
+# Cada função representa um passo de raciocínio da pipeline. Elas preparam
+# um prompt, chamam a API e retornam o resultado processado.
+
+def passo_0_aluno(pergunta: str, historico: List[Dict]) -> Dict:
+    """P0: Analisa a pergunta atual em relação à resposta anterior (metacognição)."""
+    logger.log("🧠 P0-ALUNO - Analisando feedback do usuário", "TASK")
+    turno_anterior_user = historico[-2]['content'] if len(historico) >= 2 else 'N/A'
+    turno_anterior_assistant = historico[-1]['content'] if len(historico) >= 1 else 'N/A'
+    
+    prompt = PROMPTS["P0_ALUNO"].format(
+        turno_anterior_user=turno_anterior_user,
+        turno_anterior_assistant=turno_anterior_assistant,
+        pergunta=pergunta,
+        historico_compacto=historico_compacto(historico)
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.3)
+
+def passo_1_triagem(pergunta: str, p0: Dict, historico: List[Dict]) -> Dict:
+    """P1: Faz uma triagem inicial da pergunta para classificar tipo e complexidade."""
+    logger.log("📊 P1-TRIAGEM - Classificando a pergunta", "TASK")
+    historico_recente_json = json.dumps(historico[-6:], indent=2, ensure_ascii=False)
+    p0_json = json.dumps(p0, indent=2, ensure_ascii=False)
+
+    prompt = PROMPTS["P1_TRIAGEM"].format(
+        contexto_vago=historico_compacto(historico),
+        historico_recente=historico_recente_json,
+        p0=p0_json,
+        pergunta=pergunta
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.4)
+
+def passo_x1_perguntas_necessarias(pergunta: str, p1: Dict, historico: List[Dict]) -> Dict:
+    """X1: Identifica quais perguntas internas precisam ser respondidas para resolver a questão."""
+    logger.log("❓ X1-PERGUNTAS CRÍTICAS - Identificando lacunas", "TASK")
+    prompt = PROMPTS["X1_PERGUNTAS_NECESSARIAS"].format(
+        p1=json.dumps(p1, indent=2),
+        historico_compacto=historico_compacto(historico),
+        pergunta=pergunta
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, max_tokens=1500)
+
+def passo_x2_resolver_perguntas(p1: Dict, x1: Dict, historico: List[Dict]) -> Dict:
+    """X2: Responde internamente às perguntas levantadas em X1."""
+    logger.log("✅ X2-RESOLVER PERGUNTAS - Buscando conhecimento interno", "TASK")
+    perguntas_x1 = x1.get("perguntas", [])
+    prompt = PROMPTS["X2_RESOLVER_PERGUNTAS"].format(
+        p1=json.dumps(p1, indent=2),
+        perguntas_x1=json.dumps(perguntas_x1, indent=2),
+        historico_compacto=historico_compacto(historico)
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, max_tokens=2000)
+
+def passo_2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, historico: List[Dict]) -> Dict:
+    """P2: Gera diferentes cenários ou perspectivas para a resposta."""
+    logger.log("🎯 P2-CENÁRIOS - Mapeando possibilidades", "TASK")
+    prompt = PROMPTS["P2_CENARIOS"].format(
+        historico_compacto=historico_compacto(historico),
+        p1=json.dumps(p1, indent=2),
+        x1=json.dumps(x1, indent=2),
+        x2=json.dumps(x2, indent=2),
+        pergunta=pergunta
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.6)
+
+def passo_3_isolar_cenarios(p2: Dict) -> Dict:
+    """P3: Explora cada cenário gerado em P2 de forma isolada."""
+    logger.log("🔍 P3-ISOLAR CENÁRIOS - Explorando cada cenário", "TASK")
+    exploracoes = []
+    cenarios = p2.get('cenarios', {}).get('provaveis', [])
+    for c in cenarios[:3]: # Limita a 3 cenários para evitar complexidade e custos excessivos.
+        prompt = PROMPTS["P3_ISOLAR_CENARIOS"].format(
+            cenario=json.dumps(c, indent=2),
+            cenario_id=c.get('id')
+        )
+        exploracoes.append(chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.5))
+    
+    return {"exploracoes_isoladas": exploracoes}
+
+def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, x2: Dict) -> Dict:
+    """P4: Abstrai princípios e símbolos a partir da análise dos cenários."""
+    logger.log("🔗 P4-VALIDAÇÃO CRUZADA - Identificando princípios", "TASK")
+    prompt = PROMPTS["P4_CRUZAR_VALIDACOES"].format(
+        p1=json.dumps(p1, indent=2),
+        p2=json.dumps(p2, indent=2),
+        p3=json.dumps(p3, indent=2),
+        x2=json.dumps(x2, indent=2)
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.4)
+
+def passo_5_lacunas_finais(p1: Dict, p4: Dict) -> Dict:
+    """P5: Realiza uma análise final de certezas vs. dúvidas."""
+    logger.log("🚨 P5-LACUNAS FINAIS - Avaliando confiança global", "TASK")
+    prompt = PROMPTS["P5_LACUNAS_FINAIS"].format(
+        p1=json.dumps(p1, indent=2),
+        p4=json.dumps(p4, indent=2)
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.3)
+
+def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict:
+    """P6: Atua como um 'Juiz da Verdade', ponderando toda a análise para uma decisão final."""
+    logger.log("⚖️ P6-PONDERAR (JUIZ) - Tomando a decisão final", "TASK")
+    prompt = PROMPTS["P6_PONDERAR"].format(
+        p2=json.dumps(p2, indent=2),
+        p4=json.dumps(p4, indent=2),
+        p5=json.dumps(p5, indent=2)
+    )
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.4)
+
+def passo_7_sintetizar(p6: Dict) -> Dict:
+    """P7: Converte a análise metacognitiva final em uma resposta em prosa humanizada."""
+    logger.log("✍️ P7-SINTETIZAR - Gerando prosa humanizada", "TASK")
+    prompt = PROMPTS["P7_SINTETIZAR"].format(p6=json.dumps(p6, indent=2))
+    # Usa uma temperatura mais alta para uma resposta mais criativa e fluida.
+    return chamar_gemini_json(COUNSELOR_MODEL, prompt, temperatura=0.7, max_tokens=2500)
+
+def passo_8_verificar(p6: Dict, p7: Dict) -> Dict:
+    """P8: Realiza uma verificação tripla (factual, lógica, ética) na resposta final."""
+    logger.log("🛡️ P8-VERIFICAR (SUPERVISOR) - Garantindo a qualidade", "TASK")
+    resposta_sintetizada = p7.get("resposta", "")
+    prompt = PROMPTS["P8_VERIFICAR"].format(
+        resposta_sintetizada=resposta_sintetizada,
+        p6=json.dumps(p6, indent=2)
+    )
+    # Usa o modelo Supervisor e uma temperatura baixa para uma verificação mais objetiva.
+    return chamar_gemini_json(SUPERVISOR_MODEL, prompt, temperatura=0.2)
+
+# ============================================================================
+# 5. ORQUESTRADOR PRINCIPAL
+# ============================================================================
+
+def executar_pipeline(pergunta: str, historico: List[Dict], arquivo_anexo: Any, dna: Dict) -> Tuple[str, List, Dict]:
+    """
+    Orquestra a execução de todos os passos da pipeline, desde a análise
+    inicial até a verificação e entrega da resposta final.
+
+    Args:
+        pergunta: A pergunta enviada pelo usuário.
+        historico: O histórico da conversa no formato interno.
+        arquivo_anexo: O arquivo enviado pelo usuário (se houver).
+        dna: O dicionário de estado da conversa.
+
+    Returns:
+        Uma tupla contendo (resposta_final, novo_historico_interno, dna_atualizado).
+    """
+    logger.log(f"PIPELINE v10 INICIADA: '{pergunta[:50]}...'", "START")
+    
+    if not pergunta or not pergunta.strip():
+        return "Por favor, digite uma pergunta válida.", historico, dna
+    
+    # 1. Processamento de Anexos (se houver).
+    conteudo_anexo, tipo_anexo = processar_anexo(arquivo_anexo)
+    pergunta_final = construir_prompt_com_anexo(pergunta, conteudo_anexo, tipo_anexo)
+    
+    # Bloco try-except para capturar qualquer erro inesperado durante a complexa execução da pipeline.
+    try:
+        # 2. Execução sequencial dos passos da pipeline. O output de um passo serve de input para o próximo.
+        p0 = passo_0_aluno(pergunta_final, historico)
+        p1 = passo_1_triagem(pergunta_final, p0, historico)
+        x1 = passo_x1_perguntas_necessarias(pergunta_final, p1, historico)
+        x2 = passo_x2_resolver_perguntas(p1, x1, historico)
+        p2 = passo_2_cenarios(pergunta_final, p1, x1, x2, historico)
+
+        # 3. Ponto de Interrupção: Se o modelo decidir que precisa de mais informações, ele interrompe aqui.
+        if p2.get("decisao") == "pedir-esclarecimento":
+            esclarecimento = p2.get("pergunta_esclarecimento", "Poderia fornecer mais detalhes?")
+            logger.log(f"Pipeline interrompida para pedir esclarecimento: {esclarecimento}", "INFO")
+            return f"❓ Para te dar uma resposta mais precisa, preciso de um esclarecimento:\n\n> {esclarecimento}", historico, dna
+
+        # 4. Continuação da pipeline com os passos de aprofundamento.
+        p3 = passo_3_isolar_cenarios(p2)
+        p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
+        p5 = passo_5_lacunas_finais(p1, p4)
+
+        # 5. Ponto de Interrupção: Se a confiança global for muito baixa, o modelo pode se recusar a responder.
+        if p5.get("decisao") == "questionar":
+            questionamento = p5.get("questionamento", "Não tenho informações suficientes para responder.")
+            logger.log(f"Pipeline interrompida por baixa confiança: {questionamento}", "INFO")
+            return f"🤔 {questionamento}", historico, dna
+
+        # 6. Passos finais de Julgamento, Geração e Verificação.
+        p6 = passo_6_ponderar(p2, p4, p5)
+        p7 = passo_7_sintetizar(p6)
+        p8 = passo_8_verificar(p6, p7)
+
+        # 7. Seleção da Resposta Final com base na verificação do Supervisor (P8).
+        if p8.get("todas_aprovadas") and p8.get("decisao") != "corrigir-e-exibir":
+            resposta_final = p7.get("resposta", "Não foi possível gerar uma resposta.")
+        else:
+            # Se a verificação falhou, usa a versão corrigida pelo supervisor.
+            resposta_final = p8.get("resposta_corrigida", p7.get("resposta", "Ocorreu um erro na verificação final."))
+            logger.log("Resposta foi corrigida pelo Supervisor (P8).", "WARN")
+
+    except Exception as e:
+        logger.log(f"Erro crítico na execução da pipeline: {e}", "ERROR")
+        return f"❌ Ocorreu um erro inesperado durante o processamento: {e}", historico, dna
+
+    # 8. Atualiza o histórico da conversa e o estado (DNA).
+    novo_historico = historico + [
+        {"role": "user", "content": pergunta},
+        {"role": "assistant", "content": resposta_final}
+    ]
+    dna["historico_chat"].append({"user": pergunta, "assistant": resposta_final})
+    dna["meta"]["total_turnos"] += 1
+    
+    logger.log("PIPELINE CONCLUÍDA COM SUCESSO", "SUCCESS")
+    return resposta_final, novo_historico, dna
+
+# ============================================================================
+# 6. INTERFACE COM GRADIO
+# ============================================================================
+
+def converter_historico_de_gradio(historico_gradio: List[List[str]]) -> List[Dict]:
+    """
+    Converte o formato de histórico do Chatbot Gradio para o formato interno da pipeline.
+    - Formato Gradio: [ ["pergunta1", "resposta1"], ["pergunta2", "resposta2"] ]
+    - Formato Interno: [ {"role": "user", "content": "p1"}, {"role": "assistant", "content": "r1"} ]
+    """
+    historico_interno = []
+    if not historico_gradio:
+        return historico_interno
+    for turno in historico_gradio:
+        pergunta, resposta = turno if turno and turno else "", turno if turno and len(turno) > 1 and turno else ""
+        if pergunta:
+            historico_interno.append({"role": "user", "content": pergunta})
+        if resposta:
+            historico_interno.append({"role": "assistant", "content": resposta})
+    return historico_interno
+
+def converter_historico_para_gradio(historico_interno: List[Dict]) -> List[List[str]]:
+    """
+    Converte o formato de histórico interno da pipeline para o formato do Chatbot Gradio.
+    """
+    historico_gradio = []
+    if not historico_interno:
+        return historico_gradio
+    # Itera de 2 em 2 para formar os pares [pergunta_usuario, resposta_assistente].
+    for i in range(0, len(historico_interno), 2):
+        if i + 1 < len(historico_interno):
+            pergunta = historico_interno[i]['content']
+            resposta = historico_interno[i+1]['content']
+            historico_gradio.append([pergunta, resposta])
+    return historico_gradio
+
+def chat_interface(pergunta: str, historico_gradio: List[List[str]], anexo: Any, dna_json_str: str) -> Tuple[List, str, str, None]:
+    """
+    Função de callback que conecta a lógica da pipeline com a interface do Gradio.
+    É chamada toda vez que o usuário envia uma mensagem.
+
+    Args:
+        pergunta: O texto da caixa de input.
+        historico_gradio: O estado atual do componente chatbot (formato Gradio).
+        anexo: O arquivo enviado pelo componente de upload.
+        dna_json_str: O estado do DNA em formato de string JSON.
+
+    Returns:
+        Uma tupla com os novos valores para os componentes da interface:
+        (novo_historico_gradio, texto_input_limpo, novo_dna_json, anexo_limpo)
+    """
+    logger.log(f"Nova mensagem recebida: '{pergunta[:80]}...'", "INFO")
+    
+    # Carrega o estado do DNA a partir da string JSON. Se falhar, cria um novo.
+    try:
+        dna = json.loads(dna_json_str) if dna_json_str and dna_json_str.strip() else criar_dna()
+    except (json.JSONDecodeError, TypeError):
+        dna = criar_dna()
+
+    # 1. CONVERTE o histórico do formato Gradio para o nosso formato interno.
+    historico_interno = converter_historico_de_gradio(historico_gradio)
+    
+    # 2. EXECUTA a pipeline com os dados de entrada.
+    _ , novo_historico_interno, dna_atualizado = executar_pipeline(pergunta, historico_interno, anexo, dna)
+    
+    # 3. CONVERTE o histórico resultante de volta para o formato que o Gradio entende.
+    novo_historico_gradio = converter_historico_para_gradio(novo_historico_interno)
+    
+    logger.log("Resposta formatada para Gradio.", "INFO")
+    
+    # Retorna os novos estados para atualizar a interface do Gradio.
+    return novo_historico_gradio, "", json.dumps(dna_atualizado, indent=2, ensure_ascii=False), None
+
+# --- Bloco de Execução Principal ---
+if __name__ == "__main__":
+    # 'gr.Blocks' é o container principal para criar interfaces complexas com Gradio.
+    with gr.Blocks(title="Pipeline v10 Refatorada", theme=gr.themes.Soft()) as demo:
+        # Exibe o título usando Markdown.
+        gr.Markdown(TITLE)
+        
+        # Define o layout da interface em linhas e colunas.
+        with gr.Row():
+            with gr.Column(scale=3): # Coluna principal para o chat.
+                chatbot = gr.Chatbot(label="Chat", height=600, bubble_full_width=False)
+            with gr.Column(scale=1): # Coluna lateral para informações adicionais.
+                dna_view = gr.Code(label="DNA (Estado da Conversa)", language="json", interactive=False,
+                                   value=json.dumps(criar_dna(), indent=2, ensure_ascii=False))
+                file_upload = gr.File(label="Anexar PDF ou Imagem", file_types=[".pdf", ".png", ".jpg", ".jpeg"])
+        
+        with gr.Row(): # Linha para os controles de input.
+            input_textbox = gr.Textbox(
+                label="Digite sua pergunta aqui...",
+                lines=3,
+                scale=4, # Ocupa mais espaço na linha.
+            )
+            submit_button = gr.Button("🚀 Enviar (v10)", variant="primary", scale=1)
+
+        # Componente oculto para armazenar o estado do DNA entre as chamadas da interface.
+        # É uma forma de contornar a natureza sem estado do Gradio.
+        dna_json_hidden = gr.Textbox(value=json.dumps(criar_dna()), visible=False)
+
+        # --- Conexão dos Eventos da Interface com as Funções ---
+
+        # Define o que acontece quando o botão de "Enviar" é clicado.
+        submit_button.click(
+            fn=chat_interface, # Função a ser chamada.
+            inputs=[input_textbox, chatbot, file_upload, dna_json_hidden], # Componentes de entrada.
+            outputs=[chatbot, input_textbox, dna_json_hidden, file_upload] # Componentes de saída a serem atualizados.
+        )
+        # Permite que o usuário envie a mensagem apertando "Enter" na caixa de texto.
+        input_textbox.submit(
+            fn=chat_interface,
+            inputs=[input_textbox, chatbot, file_upload, dna_json_hidden],
+            outputs=[chatbot, input_textbox, dna_json_hidden, file_upload]
+        )
+        # Sincroniza o visualizador de DNA com o estado oculto sempre que ele mudar.
+        dna_json_hidden.change(
+            fn=lambda x: x, # Uma função simples que apenas repassa o valor.
+            inputs=[dna_json_hidden],
+            outputs=[dna_view]
+        )
+
+    # Inicia a aplicação web do Gradio.
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)