Update app.py

app.py

@@ -1,6 +1,5 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║   PIPELINE v40: FRAGMENTAÇÃO + VISÃO PAGINADA + ORQUESTRAÇÃO EM ABAS      ║
-# ║   Upload de PDF → fragmentos → PAGINADOR_VISUAL → confext_upload JSON     ║
+# ║  PIPELINE v41: FRAGMENTAÇÃO + VISÃO PAGINADA + CONFEXT_UPLOAD             ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -27,15 +26,10 @@ ARQUIVO_CONFIG = "protocolo_fragmentacao_visao-3.json"
 # ==================== 2. UTILIDADES ====================
 
 def carregar_protocolo():
-    """
-    Carrega o protocolo JSON de agentes. 
-    Se não existir, usa o protocolo básico de PAGINADOR_VISUAL.
-    """
     try:
         with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
             return f.read()
     except:
-        # fallback: protocolo mínimo de visão paginada
         return json.dumps([
             {
                 "nome": "PAGINADOR_VISUAL",
@@ -54,9 +48,6 @@ def carregar_protocolo():
         ], ensure_ascii=False, indent=2)
 
 def salvar_protocolo(conteudo):
-    """
-    Salva o JSON de protocolo após validar sintaxe.
-    """
     try:
         json.loads(conteudo)
         with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f:
@@ -65,13 +56,17 @@ def salvar_protocolo(conteudo):
     except:
         return "❌ Erro JSON"
 
-# --------- DIVISÃO BURRA: PDF EM BLOCOS DE 5 PÁGINAS ---------
+def log_point(msg, logs):
+    ts = datetime.now().strftime("%H:%M:%S")
+    return logs + f"[{ts}] {msg}\n"
+
+# --------- DIVISÃO BURRA COM TEXTO REAL ---------
 
 def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
     """
-    DIVISÃO BURRA: 
-    - Se PDF: cria fragmentos de metadados indicando blocos de páginas.
-    - Se texto: devolve um único fragmento marcador.
+    Se PDF: lê texto das páginas e cria fragmentos com blocos de até N páginas.
+    Cada fragmento contém o texto bruto dessas páginas.
+    Se não for PDF: devolve um marcador simples.
     """
     if arquivo is None:
         return [], ""
@@ -83,7 +78,6 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
 
     anexo_info = f"[PDF: {os.path.basename(filename)}]"
 
-    # Se não for PDF, tratamos como arquivo texto simples
     if not filename.lower().endswith(".pdf"):
         return [f"[ARQUIVO_TEXTO: {os.path.basename(filename)}]"], anexo_info
 
@@ -96,12 +90,18 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
             start = i + 1
             end = min(i + paginas_por_fragmento, total_pages)
 
-            # Aqui o fragmento é apenas um cabeçalho + marcador
+            bloco_texto = ""
+            for p in range(i, end):
+                try:
+                    t = reader.pages[p].extract_text() or ""
+                except Exception as e:
+                    t = f"\n[ERRO_EXTRACT_PAG_{p+1}: {e}]\n"
+                bloco_texto += f"\n=== PAGINA {p+1}/{total_pages} ===\n{t}\n"
+
             fragment = (
                 f"=== FRAG {i//paginas_por_fragmento + 1} "
                 f"(PÁGS {start}-{end}/{total_pages}) ===\n"
-                f"[PAGINADOR: você está vendo páginas {start}-{end}. "
-                f"Extraia JSON pagina/transcricao_fiel/descricao_visual.]"
+                f"{bloco_texto.strip()}"
             )
             fragments.append(fragment)
 
@@ -112,11 +112,6 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
 # ==================== 3. ENGINE DE EXECUÇÃO ====================
 
 def executar_no(timeline, config, fragmento_input=None):
-    """
-    Executa um nó (agente) do protocolo.
-    - Se fragmento_input for fornecido, ele é o INPUT PARA O AGENTE.
-    - Caso contrário, o input é o JSON da timeline inteira.
-    """
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
 
     if fragmento_input is not None:
@@ -136,13 +131,16 @@ def executar_no(timeline, config, fragmento_input=None):
     try:
         inicio = time.time()
         resp = modelo.generate_content(prompt)
-        out = resp.text
+        out = resp.text or ""
         tempo = time.time() - inicio
 
         if config["tipo_saida"] == "json":
-            # limpeza mínima de cercas de código
             cleaned = out.strip().replace("``````", "")
-            content = json.loads(cleaned)
+            try:
+                content = json.loads(cleaned)
+            except Exception as e:
+                content = []
+                log += f" [ERRO JSON: {e}]"
         else:
             content = out
 
@@ -154,21 +152,12 @@ def executar_no(timeline, config, fragmento_input=None):
 # ==================== 4. ORQUESTRADOR ====================
 
 def orquestrador(texto, arquivo, history, json_config, confext_state):
-    """
-    Pipeline:
-    1) Se houver arquivo, faz divisão burra + visão PAGINADOR_VISUAL por fragmento.
-       - Resultado consolidado em confext_upload (state) por página.
-    2) Timeline recebe um nó de sistema com esse confext_upload.
-    3) Protocolos adicionais (se existirem além do PAGINADOR_VISUAL) usam só esse contexto.
-    """
-    # 1. Fragmentação
     fragmentos, anexo_info = ler_anexo_e_fragmentar(arquivo)
 
     if not texto and not fragmentos:
         yield history, {}, "⚠️ Sem input ou erro ao ler arquivo.", confext_state
         return
 
-    # 2. Setup inicial
     history = history + [[texto + (" 📎" if arquivo else ""), None]]
 
     try:
@@ -181,38 +170,36 @@ def orquestrador(texto, arquivo, history, json_config, confext_state):
     timeline = [{"role": "user", "content": texto}]
     logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
 
-    # Estrutura interna de contexto de anexos
     confext_upload = {
         "arquivo": os.path.basename(getattr(arquivo, "name", "sem_arquivo"))
         if arquivo else None,
         "meta": anexo_info,
-        "paginas": []  # cada item: {pagina, transcricao_fiel, descricao_visual}
+        "paginas": []
     }
 
     if fragmentos:
-        logs += f"📎 PDF dividido: {len(fragmentos)} fragmentos burros.\n"
+        logs = log_point(f"PDF dividido em {len(fragmentos)} fragmentos.", logs)
         history[-1][1] = "⏳ Fragmentando + visão paginada..."
         yield history, timeline, logs, confext_upload
 
-    # 3. PASSO DE VISÃO PAGINADA (PAGINADOR_VISUAL)
-    # Espera-se que seja o primeiro (único) agente, mas tratamos genericamente.
+    # PASSO PAGINADOR_VISUAL (se existir)
     if protocolo and fragmentos:
-        cfg_visao = protocolo[0]  # usamos apenas o primeiro como PAGINADOR_VISUAL
+        cfg_visao = protocolo[0]
+        logs = log_point(f"Usando agente de visão: {cfg_visao['nome']}", logs)
 
         for i, fragmento in enumerate(fragmentos):
-            history[-1][1] = (
-                f"👁️ {cfg_visao['nome']} frag {i+1}/{len(fragmentos)}..."
-            )
+            history[-1][1] = f"👁️ {cfg_visao['nome']} frag {i+1}/{len(fragmentos)}..."
+            logs = log_point(f"Enviando frag {i+1}", logs)
             yield history, timeline, logs, confext_upload
 
             res, log_add, raw = executar_no(timeline, cfg_visao, fragmento_input=fragmento)
             logs += log_add + "\n"
+            logs = log_point(f"Resposta bruta frag {i+1}: {raw[:160]!r}", logs)
 
             if "error" in res:
-                logs += f"❌ Erro frag {i+1}: {res['error']}\n"
+                logs = log_point(f"Erro no frag {i+1}: {res['error']}", logs)
                 continue
 
-            # res['content'] deve ser lista JSON de páginas [{pagina, transcricao_fiel, descricao_visual}, ...]
             try:
                 paginas_res = res["content"]
                 if isinstance(paginas_res, dict):
@@ -220,21 +207,18 @@ def orquestrador(texto, arquivo, history, json_config, confext_state):
                 for p in paginas_res:
                     confext_upload["paginas"].append(p)
             except Exception as e:
-                logs += f"❌ Erro ao incorporar páginas do frag {i+1}: {e}\n"
+                logs = log_point(f"Falha ao anexar páginas do frag {i+1}: {e}", logs)
 
-        logs += "✅ Visões paginadas completas.\n"
+        logs = log_point("Visão paginada concluída.", logs)
 
-    # 4. Injeta confext_upload na timeline como nó de sistema
     timeline.append({
         "role": "system",
         "agent": "CONFEXT_UPLOAD",
         "content": confext_upload
     })
 
-    # 5. Se existirem passos adicionais além do PAGINADOR_VISUAL, executa-os sequencialmente
-    final_response = ""
-    # pula o primeiro passo se ele é o PAGINADOR_VISUAL
     restante = protocolo[1:] if protocolo else []
+    final_response = ""
 
     for cfg in restante:
         history[-1][1] = f"⚙️ {cfg['nome']}..."
@@ -251,14 +235,13 @@ def orquestrador(texto, arquivo, history, json_config, confext_state):
         yield history, timeline, logs, confext_upload
 
     if not restante and not texto:
-        # se não há mais agentes e não houve prompt, só confirma pré-processamento
-        history[-1][1] = "✅ PDF processado. Pronto para perguntas usando contexto interno."
+        history[-1][1] = "✅ PDF processado. Pronto para perguntas usando confext_upload."
         final_response = history[-1][1]
 
-    logs += "✅ FIM.\n"
+    logs = log_point("FIM.", logs)
     yield history, timeline, logs, confext_upload
 
-# ==================== 5. UI LIMPA ====================
+# ==================== 5. UI ====================
 
 def ui_clean():
     css = """
@@ -272,7 +255,6 @@ def ui_clean():
         confext_state = gr.State(value=None)
 
         with gr.Tabs():
-            # === ABA 1: CHAT / INVESTIGADOR ===
             with gr.Tab("💬 Investigador"):
                 chatbot = gr.Chatbot(
                     label="",
@@ -301,21 +283,18 @@ def ui_clean():
                         btn_send = gr.Button("Enviar", variant="primary", size="sm")
 
                 file_status = gr.Markdown("", visible=True)
-                # Mostra nome do arquivo ao subir
                 file_in.upload(
                     lambda x: f"📎 Anexo recebido: {os.path.basename(getattr(x, 'name', x))}",
                     inputs=file_in,
                     outputs=file_status,
                 )
 
-            # === ABA 2: DEPURAÇÃO ===
             with gr.Tab("🕵️ Depuração"):
                 with gr.Row():
                     out_dna = gr.JSON(label="DNA (Timeline)")
                     out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
                 confext_view = gr.JSON(label="confext_upload")
 
-            # === ABA 3: CONFIG ===
             with gr.Tab("⚙️ Config"):
                 with gr.Row():
                     btn_save = gr.Button("Salvar Config")
@@ -323,9 +302,7 @@ def ui_clean():
                 code_json = gr.Code(value=config_init, language="json", label=ARQUIVO_CONFIG)
                 btn_save.click(salvar_protocolo, code_json, lbl_save)
 
-        # === TRIGGERS ===
         def _orq_wrapper(texto, arquivo, history, json_cfg, confext_old):
-            # delega para o orquestrador, passando state antigo
             for h, dna, logs, confext_new in orquestrador(texto, arquivo, history, json_cfg, confext_old):
                 yield h, dna, logs, confext_new