Delete app.py

app.py

@@ -1,644 +0,0 @@
-# -*- 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 capacidade de pausar the pipeline quando o modelo tem uma
-dúvida, perguntar ao usuário e, em seguida, retomar a execução do ponto de
-parada usando o esclarecimento fornecido.
-"""
-
-# ============================================================================
-# 1. IMPORTAÇÕES E CONFIGURAÇÃO INICIAL
-# ============================================================================
-import json
-import os
-import base64
-import re
-import warnings
-from datetime import datetime
-from typing import Dict, List, Tuple, Any
-
-import gradio as gr
-import google.generativeai as genai
-
-warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
-
-API_KEY = os.getenv("GOOGLE_API_KEY")
-if not API_KEY:
-    raise ValueError("A variável de ambiente GOOGLE_API_KEY não foi configurada.")
-
-genai.configure(api_key=API_KEY)
-
-COUNSELOR_MODEL = genai.GenerativeModel("gemini-2.0-flash")
-SUPERVISOR_MODEL = genai.GenerativeModel("gemini-2.0-flash")
-
-TITLE = "# 🚀 Pipeline v10 | PAUSA & RETOMADA\n**Sistema com gerenciamento de estado para interrupção e continuação do raciocínio.**"
-
-# ============================================================================
-# 2. PROMPTS CENTRALIZADOS
-# ============================================================================
-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
-# ============================================================================
-
-class Logger:
-    def __init__(self, verbose: bool = True):
-        self.verbose = verbose
-
-    def log(self, msg: str, level: str = "INFO"):
-        log_msg = f"[{datetime.now().strftime('%H:%M:%S')}] [{level.upper()}] {msg}"
-        if self.verbose:
-            print(log_msg)
-            if level.upper() in ["TASK", "START", "SUCCESS", "ERROR", "WARN"]:
-                print("=" * 70)
-
-logger = Logger(verbose=True)
-
-
-def processar_anexo(arquivo: Any) -> Tuple[str, str]:
-    if arquivo is None:
-        return "", "nenhum"
-    caminho_arquivo = arquivo.name
-    try:
-        if caminho_arquivo.lower().endswith('.pdf'):
-            return "[Conteúdo do PDF iria aqui]", "pdf"
-        elif any(caminho_arquivo.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.gif']):
-            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:
-    if not anexo_conteudo or tipo_anexo in ["nenhum", "erro", "nao_suportado"]:
-        return pergunta
-    if tipo_anexo == "pdf":
-        return f"Com base no documento PDF, responda: {pergunta}\nDOCUMENTO:\n{anexo_conteudo}"
-    if tipo_anexo == "imagem":
-        return f"Com base na imagem, responda: {pergunta}"
-    return pergunta
-
-
-def parse_json_ultra_robusto(texto: str) -> Dict:
-    if not texto:
-        return {"erro": "Texto de entrada vazio"}
-    try:
-        match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', texto, re.DOTALL)
-        if match:
-            json_str = match.group(1)
-        else:
-            json_str = texto
-        return json.loads(json_str)
-    except json.JSONDecodeError:
-        try:
-            inicio = texto.find('{')
-            fim = texto.rfind('}') + 1
-            if inicio != -1 and fim != 0:
-                return json.loads(texto[inicio:fim])
-        except json.JSONDecodeError:
-            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:
-    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO OBRIGATÓRIA: Sua resposta DEVE ser um único e válido objeto JSON.**"
-    
-    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")
-
-    try:
-        response = modelo.generate_content(
-            prompt_completo,
-            generation_config=genai.types.GenerationConfig(
-                temperature=temperatura,
-                max_output_tokens=max_tokens,
-            )
-        )
-        resposta_bruta = response.text or ""
-        
-        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")
-        
-        return parse_json_ultra_robusto(resposta_bruta)
-        
-    except Exception as e:
-        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:
-    if not historico:
-        return "Nenhuma conversa anterior."
-    compacto = [f"{'User' if m['role'] == 'user' else 'Assistant'}: {m['content'][:80]}" for m in historico[-4:]]
-    return "\n".join(compacto)
-
-
-def criar_dna() -> Dict:
-    return {
-        "historico_chat": [],
-        "meta": {"total_turnos": 0},
-        "pipeline_state": {
-            "status": "completed",
-            "paused_at_step": None,
-            "saved_data": {}
-        }
-    }
-
-# ============================================================================
-# 4. PASSOS DA PIPELINE (P0-P8, X1-X2)
-# ============================================================================
-def passo_0_aluno(pergunta: str, historico: List[Dict]) -> Dict:
-    logger.log("🧠 P0-ALUNO", "TASK")
-    # Simulação para simplificar a demonstração da lógica principal
-    return {"p0_data": True}
-
-def passo_1_triagem(pergunta: str, p0: Dict, historico: List[Dict]) -> Dict:
-    logger.log("📊 P1-TRIAGEM", "TASK")
-    return {"p1_data": True}
-
-def passo_x1_perguntas_necessarias(pergunta: str, p1: Dict, historico: List[Dict]) -> Dict:
-    logger.log("❓ X1-PERGUNTAS", "TASK")
-    return {"x1_data": True}
-
-def passo_x2_resolver_perguntas(p1: Dict, x1: Dict, historico: List[Dict]) -> Dict:
-    logger.log("✅ X2-RESOLVER", "TASK")
-    return {"x2_data": True}
-
-def passo_2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, historico: List[Dict]) -> Dict:
-    logger.log("🎯 P2-CENÁRIOS", "TASK")
-    # Simulação: Para perguntas sobre "dúvida", ele pausa.
-    if "dúvida" in pergunta.lower():
-        logger.log("P2 encontrou ambiguidade. Decidindo pedir esclarecimento.", "INFO")
-        return {"decisao": "pedir-esclarecimento", "pergunta_esclarecimento": "Você pode esclarecer o ponto X sobre a sua dúvida?"}
-    return {"decisao": "prosseguir", "p2_data": True}
-
-def passo_3_isolar_cenarios(p2: Dict) -> Dict:
-    logger.log("🔍 P3-ISOLAR", "TASK")
-    return {"p3_data": True}
-
-def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, x2: Dict) -> Dict:
-    logger.log("🔗 P4-VALIDAÇÃO", "TASK")
-    # Simulação para o P5
-    if p2.get("p2_data"):
-        return {"principio_central": "Certeza"}
-    return {"principio_central": "Incerteza"}
-
-def passo_5_lacunas_finais(p1: Dict, p4: Dict) -> Dict:
-    logger.log("🚨 P5-LACUNAS FINAIS", "TASK")
-    # Simulação de interrupção
-    if p4.get("principio_central") == "Incerteza":
-         return {"decisao": "questionar", "questionamento": "A incerteza é muito alta. Preciso de mais dados sobre Y. Você pode fornecer?"}
-    return {"decisao": "responder", "p5_data": True}
-
-def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict:
-    logger.log("⚖️ P6-PONDERAR", "TASK")
-    return {"p6_data": True}
-
-def passo_7_sintetizar(p6: Dict) -> Dict:
-    logger.log("✍️ P7-SINTETIZAR", "TASK")
-    return {"resposta": "Esta é a resposta final, gerada com sucesso."}
-
-def passo_8_verificar(p6: Dict, p7: Dict) -> Dict:
-    logger.log("🛡️ P8-VERIFICAR", "TASK")
-    return {"todas_aprovadas": True, "resposta_corrigida": None}
-
-# ============================================================================
-# 5. ORQUESTRADOR PRINCIPAL
-# ============================================================================
-
-def iniciar_nova_pipeline(pergunta: str, historico: List[Dict], anexo: Any, dna: Dict) -> Tuple[str, List, Dict]:
-    logger.log(f"INICIANDO NOVA PIPELINE: '{pergunta[:50]}...'", "START")
-    
-    conteudo_anexo, tipo_anexo = processar_anexo(anexo)
-    pergunta_final = construir_prompt_com_anexo(pergunta, conteudo_anexo, tipo_anexo)
-    
-    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)
-
-    if p2.get("decisao") == "pedir-esclarecimento":
-        logger.log("INTERRUPÇÃO no P2. Salvando estado no DNA.", "WARN")
-        dna['pipeline_state'] = {
-            "status": "paused",
-            "paused_at_step": "P2",
-            "saved_data": {
-                'p0': p0, 'p1': p1, 'x1': x1, 'x2': x2,
-                'pergunta_original': pergunta,
-                'historico_original': historico
-            }
-        }
-        esclarecimento = p2.get("pergunta_esclarecimento", "Poderia esclarecer?")
-        return f"❓ DÚVIDA: {esclarecimento}", historico, dna
-
-    p3 = passo_3_isolar_cenarios(p2)
-    p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
-    p5 = passo_5_lacunas_finais(p1, p4)
-
-    if p5.get("decisao") == "questionar":
-        logger.log("INTERRUPÇÃO no P5. Salvando estado no DNA.", "WARN")
-        dna['pipeline_state'] = {
-            "status": "paused",
-            "paused_at_step": "P5",
-            "saved_data": {
-                'p0': p0, 'p1': p1, 'x1': x1, 'x2': x2, 'p2': p2, 'p3': p3, 'p4': p4,
-                'pergunta_original': pergunta,
-                'historico_original': historico
-            }
-        }
-        questionamento = p5.get("questionamento", "Preciso de mais informações.")
-        return f"🤔 PERGUNTA: {questionamento}", historico, dna
-
-    p6 = passo_6_ponderar(p2, p4, p5)
-    p7 = passo_7_sintetizar(p6)
-    p8 = passo_8_verificar(p6, p7)
-    
-    resposta_final = p8.get("resposta_corrigida") or p7.get("resposta", "Não foi possível gerar uma resposta.")
-    
-    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 (NOVA) CONCLUÍDA COM SUCESSO", "SUCCESS")
-    return resposta_final, novo_historico, dna
-
-
-def resumir_pipeline(esclarecimento_usuario: str, dna: Dict) -> Tuple[str, List, Dict]:
-    logger.log(f"RESUMINDO PIPELINE com esclarecimento: '{esclarecimento_usuario[:50]}...'", "START")
-
-    estado_salvo = dna['pipeline_state']['saved_data']
-    ponto_parada = dna['pipeline_state']['paused_at_step']
-    historico = estado_salvo['historico_original']
-    pergunta_original = estado_salvo['pergunta_original']
-    
-    pergunta_atualizada = f"{pergunta_original}\n\n---ESCLARECIMENTO DO USUÁRIO---\n{esclarecimento_usuario}"
-
-    dna['pipeline_state'] = criar_dna()['pipeline_state']
-
-    try:
-        if ponto_parada == 'P2':
-            logger.log("Retomando a partir do passo P3...", "INFO")
-            p1, x1, x2 = estado_salvo['p1'], estado_salvo['x1'], estado_salvo['x2']
-            p2_novo = passo_2_cenarios(pergunta_atualizada, p1, x1, x2, historico)
-
-            p3 = passo_3_isolar_cenarios(p2_novo)
-            p4 = passo_4_cruzar_validacoes(p1, p2_novo, p3, x2)
-            p5 = passo_5_lacunas_finais(p1, p4)
-            p6 = passo_6_ponderar(p2_novo, p4, p5)
-
-        elif ponto_parada == 'P5':
-            logger.log("Retomando a partir do passo P6...", "INFO")
-            p1, p2, p4 = estado_salvo['p1'], estado_salvo['p2'], estado_salvo['p4']
-            p5_novo = passo_5_lacunas_finais(p1, p4)
-            p6 = passo_6_ponderar(p2, p4, p5_novo)
-        
-        else:
-            raise ValueError(f"Ponto de parada desconhecido: {ponto_parada}")
-
-        p7 = passo_7_sintetizar(p6)
-        p8 = passo_8_verificar(p6, p7)
-        
-        resposta_final = p8.get("resposta_corrigida") or p7.get("resposta", "Não foi possível gerar uma resposta.")
-
-    except Exception as e:
-        logger.log(f"Erro ao resumir a pipeline: {e}", "ERROR")
-        return f"Ocorreu um erro ao processar seu esclarecimento: {e}", historico, dna
-
-    novo_historico = historico + [{"role": "user", "content": pergunta_original}, {"role": "assistant", "content": resposta_final}]
-    dna["historico_chat"].append({"user": pergunta_original, "assistant": resposta_final})
-    dna["meta"]["total_turnos"] += 1
-    
-    logger.log("PIPELINE (RESUMIDA) CONCLUÍDA COM SUCESSO", "SUCCESS")
-    return resposta_final, novo_historico, dna
-
-
-def executar_pipeline(pergunta: str, historico: List[Dict], anexo: Any, dna: Dict) -> Tuple[str, List, Dict]:
-    if 'pipeline_state' not in dna or 'status' not in dna['pipeline_state']:
-        dna['pipeline_state'] = criar_dna()['pipeline_state']
-
-    if dna['pipeline_state']['status'] == 'paused':
-        return resumir_pipeline(pergunta, dna)
-    else:
-        return iniciar_nova_pipeline(pergunta, historico, anexo, dna)
-
-# ============================================================================
-# 6. INTERFACE COM GRADIO
-# ============================================================================
-def converter_historico_de_gradio(historico_gradio: List[List[str]]) -> List[Dict]:
-    historico_interno = []
-    if not historico_gradio:
-        return historico_interno
-    for turno in historico_gradio:
-        pergunta = turno[0] if turno and turno[0] is not None else ""
-        resposta = turno[1] if turno and len(turno) > 1 and turno[1] is not None 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]]:
-    historico_gradio = []
-    if not historico_interno:
-        return historico_gradio
-    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]:
-    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()
-
-    historico_interno = converter_historico_de_gradio(historico_gradio)
-    
-    resposta, novo_historico_interno, dna_atualizado = executar_pipeline(pergunta, historico_interno, anexo, dna)
-    
-    novo_historico_gradio = converter_historico_para_gradio(novo_historico_interno)
-    
-    return novo_historico_gradio, "", json.dumps(dna_atualizado, indent=2, ensure_ascii=False), None
-
-# --- Bloco de Execução Principal ---
-if __name__ == "__main__":
-    with gr.Blocks(title="Pipeline v10 com Pausa/Retomada", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(TITLE)
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                chatbot = gr.Chatbot(label="Chat", height=600, bubble_full_width=False)
-            with gr.Column(scale=1):
-                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 Arquivo")
-        
-        with gr.Row():
-            input_textbox = gr.Textbox(
-                label="Digite sua pergunta ou esclarecimento aqui...",
-                placeholder="Ex: Qual a melhor estratégia para... / Sobre o ponto X, quero dizer que...",
-                lines=3,
-                scale=4,
-            )
-            submit_button = gr.Button("🚀 Enviar", variant="primary", scale=1)
-
-        dna_json_hidden = gr.Textbox(value=json.dumps(criar_dna()), visible=False)
-
-        submit_button.click(
-            fn=chat_interface,
-            inputs=[input_textbox, chatbot, file_upload, dna_json_hidden],
-            outputs=[chatbot, input_textbox, dna_json_hidden, file_upload]
-        )
-        input_textbox.submit(
-            fn=chat_interface,
-            inputs=[input_textbox, chatbot, file_upload, dna_json_hidden],
-            outputs=[chatbot, input_textbox, dna_json_hidden, file_upload]
-        )
-        dna_json_hidden.change(
-            fn=lambda x: x,
-            inputs=[dna_json_hidden],
-            outputs=[dna_view]
-        )
-
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)