Create app.py

app.py

@@ -0,0 +1,335 @@
+# ╔════════════════════════════════════════════════════════════════════════════╗
+# ║ PIPELINE v29: PLANEJADOR AUTO-AGENTE | SUPERA PARADOXO MEHON ║
+# ║ 1º: PLANEJA → 2º-N: EXECUTA → N+1: CONVERGE COM HISTÓRICO ║
+# ╚════════════════════════════════════════════════════════════════════════════╝
+
+import os
+import json
+import re
+import time
+from datetime import datetime
+import gradio as gr
+import google.generativeai as genai
+
+# ==================== 1. CONFIGURAÇÃO GLOBAL ====================
+api_key = os.getenv("GOOGLE_API_KEY")
+if api_key: 
+    genai.configure(api_key=api_key)
+    model_flash = genai.GenerativeModel("gemini-flash-latest")
+    model_pro = genai.GenerativeModel("gemini-pro-latest")
+else:
+    model_flash = model_pro = None
+    print("⚠️ GOOGLE_API_KEY não encontrada. Configure via export GOOGLE_API_KEY=...")
+
+ARQUIVO_HISTORY = "history_v29.json"
+
+# ==================== 2. UTILIDADES DE PERSISTÊNCIA ====================
+def carregar_history():
+    """Carrega histórico persistente"""
+    try:
+        with open(ARQUIVO_HISTORY, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return []
+
+def salvar_history(history):
+    """Salva histórico automaticamente"""
+    try:
+        with open(ARQUIVO_HISTORY, "w", encoding="utf-8") as f:
+            json.dump(history, f, ensure_ascii=False, indent=2)
+        return True
+    except:
+        return False
+
+def ler_anexo(arquivo):
+    """Processa arquivos anexados"""
+    if not arquivo: return ""
+    try:
+        with open(arquivo.name, "r", encoding="utf-8") as f:
+            nome = os.path.basename(arquivo.name)
+            return f"\n\n📎 ANEXO: {nome}\n{f.read()}\n[FIM ANEXO]\n"
+    except:
+        return "❌ Erro lendo anexo"
+
+def exportar_chat(history):
+    """Gera TXT para download"""
+    if not history: return ""
+    timestamp = datetime.now().strftime('%Y-%m-%d_%H%M%S')
+    chat_txt = f"MEHON v29 EXPORT - {timestamp}\n\n"
+    for i, msg in enumerate(history, 1):
+        role = "👤 USUÁRIO" if i % 2 == 1 else "🤖 MEHON"
+        chat_txt += f"{role}:\n{msg}\n\n{'-'*80}\n\n"
+    return chat_txt
+
+# ==================== 3. AGENTE PLANEJADOR (SUPERA MEHON) ====================
+def gerar_plano_auto(input_completo, history_contexto):
+    """AGENTE 1: CRIA PLANO DINÂMICO baseando-se em histórico + input"""
+    if not model_pro: 
+        return None, "❌ Sem API_KEY"
+    
+    # Compacta histórico (últimas 5 trocas, 200 chars cada)
+    history_resumo = ""
+    if len(history_contexto) >= 2:
+        history_resumo = "\n".join([
+            f"👤: {h[0][:200]}... | 🤖: {h[1][:200]}..." 
+            for h in history_contexto[-5:]
+        ])
+    
+    prompt_planejador = f"""🚀 PLANEJADOR AUTO-AGENTE v29 - SUPERA PARADOXO MEHON
+
+CONTEXTO HISTÓRICO DO USUÁRIO:
+{history_resumo}
+
+INPUT ATUAL: {input_completo}
+
+---
+
+CRIE PLANO ESTRUTURADO DE 3-6 AGENTES para resolver PERFEITAMENTE:
+
+📋 FORMATO OBRIGATÓRIO (JSON VÁLIDO):
+[
+  {{"nome": "NomeClaro", "missao": "InstruçãoPrecisade200palavras", "modelo": "flash", "tipo_saida": "texto"}},
+  ...
+]
+
+✅ CRITÉRIOS DO PLANO:
+• DECOMPONHA: problema → análise → cenários → validação → síntese
+• IDENTIFIQUE ambiguidades/possibilidades do input
+• PERSONALIZE com histórico do usuário
+• ÚLTIMO agente SEMPRE gera saída FINAL pro usuário
+• Evite resposta direta - USE CADEIA DE PENSAMENTO
+
+EXEMPLO PLANO BOM:
+[
+  {{"nome": "AnalisadorInput", "missao": "Identifique elementos principais, ambiguidades e contexto", "modelo": "flash", "tipo_saida": "json"}},
+  {{"nome": "ExploradorCenários", "missao": "Liste 3-5 cenários possíveis com probabilidades", "modelo": "pro", "tipo_saida": "json"}},
+  {{"nome": "SintetizadorFinal", "missao": "Converja tudo em resposta única e acionável", "modelo": "pro", "tipo_saida": "texto"}}
+]
+
+APENAS JSON VÁLIDO - SEM TEXTO EXTRA!"""
+
+    try:
+        resp = model_pro.generate_content(prompt_planejador, temperature=0.3)
+        plano_raw = resp.text.strip().replace('``````','').replace('json','')
+        plano = json.loads(plano_raw)
+        
+        # Valida estrutura mínima
+        if not isinstance(plano, list) or len(plano) < 2:
+            return None, "❌ Plano inválido (precisa 2+ agentes)"
+            
+        return plano, f"✅ Plano: {len(plano)} agentes gerados"
+    except Exception as e:
+        return None, f"❌ Erro plano: {str(e)[:100]}"
+
+# ==================== 4. EXECUTOR DE AGENTES DINÂMICOS ====================
+def executar_agente_especifico(timeline, agente_config, history_contexto):
+    """Executa agente específico do plano dinâmico"""
+    if not (model_flash or model_pro): 
+        return {"role": "system", "error": "Sem API"}, "(ERRO: API)", "Sem Google API Key"
+    
+    modelo = model_pro if agente_config.get("modelo") == "pro" else model_flash
+    
+    # Contexto: últimos 8 passos da timeline + histórico
+    contexto_timeline = json.dumps(timeline[-8:], ensure_ascii=False, indent=2)
+    history_resumo = "\n".join([f"👤: {h[0][:100]}... | 🤖: {h[1][:100]}..." for h in history_contexto[-3:]])
+    
+    prompt = f"""CONTEXTO DA CADEIA DE PENSAMENTO:
+{contexto_timeline}
+
+HISTÓRICO RECENTE:
+{history_resumo}
+
+AGENTE ATIVO: {agente_config['nome']}
+MISSÃO ESPECÍFICA: {agente_config['missao']}
+
+{ 'JSON estruturado e válido' if agente_config['tipo_saida']=='json' else 'Resposta clara, completa e finalizada pro usuário' }:"""
+    
+    log = f"🔸 {agente_config['nome']} ({agente_config['modelo']})"
+    try:
+        inicio = time.time()
+        resp = modelo.generate_content(prompt, temperature=0.1 if agente_config['tipo_saida']=='json' else 0.7)
+        out = resp.text.strip()
+        
+        # Parse output
+        content = json.loads(out.replace('``````','')) if agente_config['tipo_saida']=='json' else out
+        tempo = time.time() - inicio
+        
+        log += f" ✓ {tempo:.1f}s"
+        return {"role": "assistant", "agent": agente_config['nome'], "content": content}, log, out
+        
+    except Exception as e:
+        log += f" ✗ {str(e)[:50]}"
+        return {"role": "system", "error": str(e)}, log, str(e)
+
+# ==================== 5. ORQUESTRADOR PRINCIPAL (MEHON) ====================
+def pipeline_mehon_completo(texto, arquivo, history):
+    """Pipeline completo: PLANEJA → EXECUTA → CONVERGE"""
+    
+    # Processa input
+    anexo = ler_anexo(arquivo)
+    full_input = f"{texto}{anexo}".strip()
+    
+    if not full_input:
+        yield history, [], "ℹ️ Input vazio - digite algo!"
+        return
+    
+    # Inicializa pipeline
+    history = history + [[full_input, "🧠 Iniciando raciocínio MEHON..."]]
+    timeline = [{"role": "user", "content": full_input, "timestamp": datetime.now().isoformat()}]
+    logs = f"🚀 MEHON v29 | {datetime.now().strftime('%H:%M:%S')}\n"
+    
+    yield history, timeline, logs
+    
+    # PASSO 1: PLANEJADOR AUTO-GERA plano dinâmico
+    history[-1][1] = "🎯 Planejador criando agentes sob medida..."
+    yield history, timeline, logs
+    
+    plano, log_plano = gerar_plano_auto(full_input, history)
+    if not plano:
+        history[-1][1] = f"❌ {log_plano}"
+        yield history, timeline, logs
+        return
+    
+    logs += f"{log_plano}\n"
+    timeline.append({"role": "system", "plano_gerado": plano, "step": "PLANEJAMENTO"})
+    yield history, timeline, logs
+    
+    # PASSO 2: EXECUTA plano dinâmico sequencialmente
+    resposta_acumulada = ""
+    for i, agente in enumerate(plano):
+        history[-1][1] = f"⚙️ [{i+1}/{len(plano)}] {agente['nome']} pensando..."
+        yield history, timeline, logs
+        
+        resultado, log_add, raw = executar_agente_especifico(timeline, agente, history)
+        timeline.append(resultado)
+        logs += f"  {log_add}\n"
+        
+        # Atualiza chat com output textual
+        if agente.get('tipo_saida') == 'texto' and 'content' in resultado:
+            resposta_acumulada = resultado['content']
+            preview = resposta_acumulada[:900] + "..." if len(resposta_acumulada) > 900 else resposta_acumulada
+            history[-1][1] = preview
+            yield history, timeline, logs
+    
+    # Finaliza
+    logs += f"\n✅ Pipeline MEHON concluído | {len(plano)} agentes | {len(timeline)} passos"
+    salvar_history(history)  # Auto-save
+    
+    yield history, timeline, logs
+
+# ==================== 6. INTERFACE GRADIO COMPLETA ====================
+def criar_app_mehon_v29():
+    """UI completa e funcional"""
+    css = """
+    footer { display: none !important; }
+    .gradio-container { max-width: 1400px; }
+    .mehon-title { font-size: 1.6em; font-weight: bold; color: #1e40af; text-align: center; }
+    .status-bar { background: linear-gradient(90deg, #3b82f6, #1e40af); color: white; padding: 8px; border-radius: 8px; }
+    """
+    
+    history_inicial = carregar_history()
+    
+    with gr.Blocks(title="🚀 PIPELINE MEHON v29", css=css, theme=gr.themes.Soft()) as app:
+        
+        # HEADER
+        gr.Markdown("### 🧠 PIPELINE MEHON v29 - Raciocínio Estruturado Automático")
+        gr.Markdown("*O modelo planeja → executa → converge. Supera respostas probabilísticas diretas.*")
+        
+        with gr.Tabs():
+            
+            # ABA 1: EXECUÇÃO PRINCIPAL
+            with gr.Tab("💭 Raciocínio MEHON", icon="🧠"):
+                chatbot = gr.Chatbot(
+                    value=history_inicial,
+                    height=550,
+                    show_copy_button=True,
+                    show_label=False,
+                    render_markdown=True
+                )
+                
+                with gr.Row():
+                    with gr.Column(scale=8):
+                        txt_input = gr.Textbox(
+                            placeholder="""Qualquer pergunta complexa... 
+O modelo CRIARÁ seu plano de agentes e executará em cadeia!""",
+                            lines=4,
+                            container=False
+                        )
+                    with gr.Column(scale=1):
+                        file_input = gr.File(
+                            label="📎 Anexo", 
+                            file_types=[".txt", ".py", ".json", ".md", ".yaml", ".csv"]
+                        )
+                    with gr.Column(scale=1):
+                        btn_executar = gr.Button("🚀 EXECUTAR PLANO", variant="primary")
+                
+                status_atual = gr.Markdown("Status: Pronto", visible=True)
+            
+            # ABA 2: DEBUG COMPLETO
+            with gr.Tab("🔍 Plano & Execução", icon="🔬"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📋 Plano Gerado")
+                        json_plano = gr.JSON(label="Agentes Dinâmicos", lines=15)
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 Timeline Completa")
+                        timeline_json = gr.JSON(label="Cadeia de Pensamento", lines=15)
+                
+                gr.Markdown("### 📈 Logs de Execução")
+                logs_execucao = gr.Textbox(label="Runtime Logs", lines=12)
+            
+            # ABA 3: GERENCIAMENTO
+            with gr.Tab("📁 Histórico & Export", icon="💾"):
+                gr.Markdown("**Histórico persistente em `history_v29.json`**")
+                with gr.Row():
+                    btn_limpar_chat = gr.Button("🗑️ Limpar Chat", variant="stop")
+                    btn_export_txt = gr.Button("📥 Download TXT", variant="secondary")
+                    btn_salvar_manual = gr.Button("💾 Salvar Manual", variant="secondary")
+                
+                export_content = gr.Textbox(label="Conteúdo para Download", lines=20, max_lines=30)
+                status_ops = gr.Label("Status: OK", visible=True)
+        
+        # ==================== EVENTOS ====================
+        def executar_pipeline_completo(txt, file, hist):
+            """Wrapper para generator do pipeline"""
+            for resultado in pipeline_mehon_completo(txt, file, hist):
+                yield resultado  # [chatbot, timeline, logs]
+        
+        # Trigger principal
+        btn_executar.click(
+            executar_pipeline_completo,
+            inputs=[txt_input, file_input, chatbot],
+            outputs=[chatbot, timeline_json, logs_execucao]
+        ).then(
+            lambda: gr.update(value=""),
+            outputs=[txt_input]
+        )
+        
+        txt_input.submit(
+            executar_pipeline_completo,
+            inputs=[txt_input, file_input, chatbot],
+            outputs=[chatbot, timeline_json, logs_execucao]
+        )
+        
+        # Controles
+        btn_limpar_chat.click(lambda: [], chatbot)
+        btn_export_txt.click(exportar_chat, chatbot, export_content)
+        btn_salvar_manual.click(lambda h: salvar_history(h) or "Salvo!", chatbot, status_ops)
+    
+    return app
+
+# ==================== LAUNCH ====================
+if __name__ == "__main__":
+    print("🚀 Iniciando PIPELINE MEHON v29...")
+    print("💡 Configure GOOGLE_API_KEY para uso completo")
+    print("📁 History salvo em history_v29.json")
+    
+    app = criar_app_mehon_v29()
+    app.launch(
+        server_name="0.0.0.0", 
+        server_port=7861, 
+        share=False,
+        show_error=True,
+        quiet=False
+    )
+