Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v29: PLANEJADOR AUTO-AGENTE | SUPERA PARADOXO MEHON ║
-# ║ 1º: PLANEJA → 2º-N: EXECUTA → N+1: CONVERGE COM HISTÓRICO ║
+# ║ PIPELINE v30: AUTO-PLAN | MESMA UI v27 | COMPATÍVEL HF SPACES ║
+# ║ 1º: MODELO CRIA PLANO → ITERA PELO PRÓPRIO PLANO | SEM 'icon' ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -11,324 +11,251 @@ from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
 
-# ==================== 1. CONFIGURAÇÃO GLOBAL ====================
-api_key = os.getenv("GOOGLE_API_KEY")
+# ==================== 1. CONFIGURAÇÃO ====================
+api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
 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"
+ARQUIVO_CONFIG = "protocolo.json"
+ARQUIVO_HISTORY = "history_v30.json"
+
+# ==================== 2. UTILIDADES (IDÊNTICAS AO v27) ====================
+def carregar_protocolo():
+    try:
+        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: 
+            return f.read()
+    except: 
+        return "[]"
+
+def salvar_protocolo(conteudo):
+    try:
+        json.loads(conteudo)
+        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f: 
+            f.write(conteudo)
+        return "✅ Salvo"
+    except: 
+        return "❌ Erro 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:
+    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:
+    except: 
         return False
 
 def ler_anexo(arquivo):
-    """Processa arquivos anexados"""
-    if not arquivo: return ""
+    if arquivo is None: 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
+            return f"\n\n[ANEXO: {os.path.basename(arquivo.name)}]\n{f.read()}\n[FIM ANEXO]\n"
+    except: return ""
 
-# ==================== 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"""
+# ==================== 3. PLANEJADOR AUTO (1ª AÇÃO) ====================
+def criar_plano_auto(full_input, history_contexto):
+    """MODELO CRIA SEU PRÓPRIO PLANO dinamicamente"""
     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:]
-        ])
+    history_resumo = "\n".join([
+        f"👤: {h[0][:150]}... | 🤖: {h[1][:150]}..." 
+        for h in history_contexto[-3:]
+    ][:300]) if history_contexto else ""
     
-    prompt_planejador = f"""🚀 PLANEJADOR AUTO-AGENTE v29 - SUPERA PARADOXO MEHON
-
-CONTEXTO HISTÓRICO DO USUÁRIO:
+    prompt_planejador = f"""CONTEXTO HISTÓRICO:
 {history_resumo}
 
-INPUT ATUAL: {input_completo}
-
----
+INPUT ATUAL: {full_input}
 
-CRIE PLANO ESTRUTURADO DE 3-6 AGENTES para resolver PERFEITAMENTE:
+CRIE PLANO OTIMIZADO de 3-5 agentes:
 
-📋 FORMATO OBRIGATÓRIO (JSON VÁLIDO):
+FORMATO JSON VÁLIDO:
 [
-  {{"nome": "NomeClaro", "missao": "InstruçãoPrecisade200palavras", "modelo": "flash", "tipo_saida": "texto"}},
-  ...
+  {{"nome": "AnalisadorInput", "missao": "Identifique elementos principais", "modelo": "flash", "tipo_saida": "json"}},
+  {{"nome": "ExecutorFinal", "missao": "Produza resposta final completa", "modelo": "pro", "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!"""
+✅ ÚLTIMO agente = saída FINAL pro usuário"""
 
     try:
-        resp = model_pro.generate_content(prompt_planejador, temperature=0.3)
-        plano_raw = resp.text.strip().replace('``````','').replace('json','')
+        resp = model_pro.generate_content(prompt_planejador, temperature=0.2)
+        plano_raw = resp.text.strip().replace('``````','')
         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]}"
+        if isinstance(plano, list) and len(plano) >= 2:
+            return plano, f"✅ Plano: {len(plano)} agentes"
+        return None, "❌ Plano inválido"
+    except:
+        return None, "❌ Erro plano"
 
-# ==================== 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
+# ==================== 4. ENGINE EXECUÇÃO (ORIGINAL v27) ====================
+def executar_no(timeline, config):
+    if not (model_flash or model_pro):
+        return {"role": "system", "error": "Sem API"}, "(ERRO: API)", "Sem key"
     
-    # 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:]])
+    modelo = model_pro if config.get("modelo") == "pro" else model_flash
+    contexto = json.dumps(timeline[-10:], ensure_ascii=False, indent=2)
     
-    prompt = f"""CONTEXTO DA CADEIA DE PENSAMENTO:
-{contexto_timeline}
-
-HISTÓRICO RECENTE:
-{history_resumo}
+    prompt = f"""--- TIMELINE ---
+{contexto}
+----------------
+AGENTE: {config['nome']}
+MISSÃO: {config['missao']}"""
 
-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']})"
+    log = f"\n🔸 {config['nome']}..."
     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()
+        resp = modelo.generate_content(prompt)
+        out = resp.text
         
-        # Parse output
-        content = json.loads(out.replace('``````','')) if agente_config['tipo_saida']=='json' else out
         tempo = time.time() - inicio
+        content = json.loads(out.strip().replace('``````','')) if config['tipo_saida']=='json' else out
         
-        log += f" ✓ {tempo:.1f}s"
-        return {"role": "assistant", "agent": agente_config['nome'], "content": content}, log, out
-        
+        log += f" (OK - {tempo:.2f}s)"
+        return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
     except Exception as e:
-        log += f" ✗ {str(e)[:50]}"
-        return {"role": "system", "error": str(e)}, log, str(e)
+        return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
 
-# ==================== 5. ORQUESTRADOR PRINCIPAL (MEHON) ====================
-def pipeline_mehon_completo(texto, arquivo, history):
-    """Pipeline completo: PLANEJA → EXECUTA → CONVERGE"""
-    
-    # Processa input
+# ==================== 5. ORQUESTRADOR v30 (PLANO AUTO) ====================
+def orquestrador(texto, arquivo, history, json_config):
+    # 1. Input Check (IDÊNTICO v27)
     anexo = ler_anexo(arquivo)
-    full_input = f"{texto}{anexo}".strip()
+    full_input = f"{texto}\n{anexo}".strip()
     
     if not full_input:
-        yield history, [], "ℹ️ Input vazio - digite algo!"
+        yield history, {}, "Sem input."
         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
+    # 2. Setup (IDÊNTICO v27)
+    history = history + [[texto + (" 📎" if arquivo else ""), None]]
+    timeline = [{"role": "user", "content": full_input}]
+    logs = f"🚀 AUTO-PLAN v30: {datetime.now().strftime('%H:%M:%S')}\n"
     
-    # PASSO 1: PLANEJADOR AUTO-GERA plano dinâmico
-    history[-1][1] = "🎯 Planejador criando agentes sob medida..."
+    history[-1][1] = "🎯 Criando plano dinâmico..."
     yield history, timeline, logs
     
-    plano, log_plano = gerar_plano_auto(full_input, history)
+    # 3. 1ª AÇÃO: CRIA PLANO
+    plano, log_plano = criar_plano_auto(full_input, history)
     if not plano:
-        history[-1][1] = f"❌ {log_plano}"
+        history[-1][1] = log_plano
         yield history, timeline, logs
         return
     
     logs += f"{log_plano}\n"
-    timeline.append({"role": "system", "plano_gerado": plano, "step": "PLANEJAMENTO"})
+    timeline.append({"role": "system", "plano_auto": plano})
+    
+    history[-1][1] = f"✅ Plano criado: {len(plano)} agentes"
     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..."
+    # 4. ITERA PELO PLANO (IDÊNTICO v27)
+    final_response = ""
+    for i, cfg in enumerate(plano):
+        history[-1][1] = f"⚙️ [{i+1}/{len(plano)}] {cfg['nome']}..."
         yield history, timeline, logs
         
-        resultado, log_add, raw = executar_agente_especifico(timeline, agente, history)
-        timeline.append(resultado)
-        logs += f"  {log_add}\n"
+        res, log_add, raw = executar_no(timeline, cfg)
+        timeline.append(res)
+        logs += 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
+        if cfg['tipo_saida'] == 'texto':
+            final_response = res['content']
+            history[-1][1] = final_response[:800] + "..." if len(final_response) > 800 else final_response
             yield history, timeline, logs
     
-    # Finaliza
-    logs += f"\n✅ Pipeline MEHON concluído | {len(plano)} agentes | {len(timeline)} passos"
-    salvar_history(history)  # Auto-save
-    
+    logs += "✅ AUTO-PLAN concluído."
+    salvar_history(history)
     yield history, timeline, logs
 
-# ==================== 6. INTERFACE GRADIO COMPLETA ====================
-def criar_app_mehon_v29():
-    """UI completa e funcional"""
+# ==================== 6. UI LIMPA v27 (SEM 'icon') ====================
+def ui_clean():
     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; }
+    footer {display: none !important;}
+    .contain {border: none !important;}
     """
     
-    history_inicial = carregar_history()
+    config_init = carregar_protocolo()
+    history_init = 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.Blocks(title="PIPELINE v30 - AUTO-PLAN", css=css, theme=gr.themes.Soft()) as app:
         with gr.Tabs():
-            
-            # ABA 1: EXECUÇÃO PRINCIPAL
-            with gr.Tab("💭 Raciocínio MEHON", icon="🧠"):
+            # === ABA 1: CHAT (EXATA v27) ===
+            with gr.Tab("💬 Pipeline"):
                 chatbot = gr.Chatbot(
-                    value=history_inicial,
-                    height=550,
-                    show_copy_button=True,
+                    value=history_init,
+                    label="",
                     show_label=False,
+                    height=600,
+                    show_copy_button=True,
                     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,
+                    with gr.Column(scale=10):
+                        txt_in = gr.Textbox(
+                            show_label=False,
+                            placeholder="Digite input... Modelo criará plano automaticamente!",
+                            lines=1,
+                            max_lines=5,
                             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, min_width=50):
+                        file_in = gr.UploadButton(
+                            "📎",
+                            file_types=[".txt", ".md", ".csv", ".json", ".py", ".yaml"],
+                            size="sm"
                         )
-                    with gr.Column(scale=1):
-                        btn_executar = gr.Button("🚀 EXECUTAR PLANO", variant="primary")
+                    with gr.Column(scale=1, min_width=80):
+                        btn_send = gr.Button("Enviar", variant="primary", size="sm")
                 
-                status_atual = gr.Markdown("Status: Pronto", visible=True)
+                file_status = gr.Markdown("", visible=True)
+                file_in.upload(lambda x: f"📎 Anexo: {os.path.basename(x.name)}", file_in, file_status)
             
-            # ABA 2: DEBUG COMPLETO
-            with gr.Tab("🔍 Plano & Execução", icon="🔬"):
+            # === ABA 2: DEPURAÇÃO (EXATA v27) ===
+            with gr.Tab("🕵️ Depuração"):
                 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)
+                    out_dna = gr.JSON(label="DNA (Timeline)")
+                    out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
             
-            # ABA 3: GERENCIAMENTO
-            with gr.Tab("📁 Histórico & Export", icon="💾"):
-                gr.Markdown("**Histórico persistente em `history_v29.json`**")
+            # === ABA 3: CONFIG (EXATA v27) ===
+            with gr.Tab("⚙️ Config"):
                 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")
+                    btn_save = gr.Button("Salvar Config")
+                    lbl_save = gr.Label(show_label=False)
                 
-                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]
-        )
+                code_json = gr.Code(
+                    value=config_init, 
+                    language="json", 
+                    label="protocolo.json (placeholder - usa auto-plan)"
+                )
+                btn_save.click(salvar_protocolo, code_json, lbl_save)
         
-        # 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)
+        # === TRIGGERS (EXATOS v27) ===
+        triggers = [btn_send.click, txt_in.submit]
+        for trig in triggers:
+            trig(
+                orquestrador,
+                inputs=[txt_in, file_in, chatbot, code_json],
+                outputs=[chatbot, out_dna, out_logs]
+            ).then(
+                lambda: (None, ""),
+                outputs=[txt_in, file_status]
+            )
     
     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
-    )
+    print("🚀 PIPELINE v30 - AUTO-PLAN (HF Spaces compatível)")
+    print("💡 Sem 'icon' | History persistente | Mesmo UI v27")
+    app = ui_clean()
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)