Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║             PIPELINE v31: FRAGMENTAÇÃO, TRANSCRIÇÃO (LOOP) E CATALOGAÇÃO   ║
-# ║        Layout: Chat (Aba 1) | Debug (Aba 2) | Config (Aba 3)               ║
+# ║        PIPELINE v32: FRAGMENTAÇÃO, TRANSCRIÇÃO (LOOP) & CATALOGAÇÃO        ║
+# ║        CORREÇÃO: MANIPULAÇÃO ROBUSTA DE ANEXOS E LIMPEZA DE BUFFER         ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -10,7 +10,7 @@ import time
 from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
-import pypdf # Usando pypdf para a lógica de fragmentação real.
+import pypdf # Certifique-se de que 'pip install pypdf' foi executado
 
 # ==================== 1. CONFIGURAÇÃO ====================
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
@@ -19,14 +19,13 @@ if api_key: genai.configure(api_key=api_key)
 model_flash = genai.GenerativeModel("gemini-flash-latest")
 model_pro   = genai.GenerativeModel("gemini-pro-latest")
 
-# **ATUALIZAÇÃO: Novo protocolo de fragmentação/catalogação**
+# Configuração Padrão do Protocolo
 ARQUIVO_CONFIG = "protocolo_fragmentacao_transcricao.json"
 
 # ==================== 2. UTILIDADES ====================
 
 def carregar_protocolo():
     try:
-        # Tenta carregar o protocolo que está sendo usado
         with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: return f.read()
     except: return "[]"
 
@@ -37,13 +36,22 @@ def salvar_protocolo(conteudo):
         return "✅ Salvo"
     except: return "❌ Erro JSON"
 
-# **FUNÇÃO REAL: Lógica de Fragmentação de PDF com pypdf**
+# **CORREÇÃO: Função de Leitura Robusta**
 def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
-    """Lê o anexo. Se for PDF, usa pypdf para dividir em fragmentos de X páginas."""
-    if arquivo is None: return [], ""
-    filename = arquivo.name
+    """Lê o anexo com segurança, tratando objetos do Gradio."""
+    if arquivo is None: 
+        return [], ""
+    
+    # Tratamento seguro do caminho do arquivo
+    # O Gradio pode enviar um objeto NamedString ou apenas o caminho
+    filename = getattr(arquivo, 'name', arquivo)
+    
+    if not os.path.exists(filename):
+        return [], f"[ERRO SISTEMA: Arquivo temporário não encontrado: {filename}]"
+
     anexo_info = f"[ANEXO SISTEMA: {os.path.basename(filename)}]"
     
+    # Lógica PDF
     if filename.lower().endswith(".pdf"):
         fragments = []
         try:
@@ -57,41 +65,42 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
                 
                 for j in range(start_page, end_page):
                     try:
-                        # Extrai o texto; se vazio (OCR ou complexo), o LLM tentará limpá-lo
-                        text = reader.pages[j].extract_text() or f"[PAG {j+1}: EXTRAÇÃO VAZIA - OCR NECESSÁRIO]"
+                        # Tenta extrair. Se falhar ou vier vazio, coloca um placeholder
+                        text = reader.pages[j].extract_text()
+                        if not text or text.strip() == "":
+                            text = f"[PAG {j+1}: (Texto Vazio/Imagem) - Necessário OCR via LLM]"
                         fragment_text.append(text)
                     except Exception as e:
-                        fragment_text.append(f"[PAG {j+1}: ERRO DE EXTRAÇÃO/ENCODING - {e}]")
+                        fragment_text.append(f"[PAG {j+1}: Erro de Leitura: {e}]")
                 
-                # Monta o input para o LLM: cabeçalho + texto extraído (mesmo que vazio)
-                fragment_header = f"Fragmento {i//paginas_por_fragmento + 1} (Pgs {start_page+1}-{end_page} / Total {total_pages}):\n"
+                # Cabeçalho claro para o LLM saber onde está
+                fragment_header = f"=== FRAGMENTO {i//paginas_por_fragmento + 1} (Páginas {start_page+1} a {end_page} de {total_pages}) ===\n"
                 fragments.append(fragment_header + "\n".join(fragment_text))
 
             return fragments, anexo_info
             
         except Exception as e:
-            return [f"ERRO CRÍTICO NA LEITURA DE PDF: {e}"], anexo_info
+            return [f"ERRO CRÍTICO NA LEITURA DO PDF: {str(e)}"], anexo_info
     
-    # Para arquivos não PDF, lê o conteúdo como um único fragmento.
+    # Lógica para TXT/MD/JSON (Lê como um único fragmento)
     try:
         with open(filename, "r", encoding="utf-8") as f:
             return [f.read()], anexo_info
-    except: return [], ""
+    except: 
+        return [f"Erro ao ler arquivo de texto."], anexo_info
 
 
 # ==================== 3. ENGINE DE EXECUÇÃO ====================
 
-# Modificada para aceitar um fragmento de texto como input (apenas para o Agente de Loop)
 def executar_no(timeline, config, fragmento_input=None):
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
     
+    # Se receber um fragmento direto (Passo 0), usa apenas ele como input
     if fragmento_input is not None:
-        # Se for o Agente de Loop (Passo 0), o prompt é apenas a missão + o fragmento
         input_para_prompt = fragmento_input
     else:
-        # Para os agentes sequenciais, o prompt é a timeline completa (que inclui as transcrições)
-        contexto = json.dumps(timeline, ensure_ascii=False, indent=2)
-        input_para_prompt = contexto
+        # Caso contrário, usa toda a timeline acumulada
+        input_para_prompt = json.dumps(timeline, ensure_ascii=False, indent=2)
 
     prompt = f"--- INPUT PARA O AGENTE ---\n{input_para_prompt}\n----------------\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
     
@@ -102,7 +111,7 @@ def executar_no(timeline, config, fragmento_input=None):
         out = resp.text
         tempo = time.time() - inicio
         
-        # O Agente de Transcrição retorna 'texto', os outros retornam 'json'
+        # Se for JSON, faz o parse. Se for texto (Transcrição), retorna puro.
         content = json.loads(out.strip().replace('```json','').replace('```','')) if config['tipo_saida']=='json' else out
         log += f" (OK - {tempo:.2f}s)"
         return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
@@ -110,17 +119,19 @@ def executar_no(timeline, config, fragmento_input=None):
         return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
 
 
-# ==================== 4. ORQUESTRADOR (LÓGICA DO LOOP) ====================
+# ==================== 4. ORQUESTRADOR ====================
 
 def orquestrador(texto, arquivo, history, json_config):
-    # 1. Input Check e Fragmentação
+    # 1. Leitura e Fragmentação
     fragmentos, anexo_info = ler_anexo_e_fragmentar(arquivo)
     
+    # Validação básica
     if not texto and not fragmentos:
-        yield history, {}, "Sem input."
+        # Se não tem texto E não tem fragmentos válidos
+        yield history, {}, "⚠️ Sem input ou erro ao ler arquivo."
         return
 
-    # 2. Setup
+    # 2. Setup Inicial
     history = history + [[texto + (" 📎" if arquivo else ""), None]]
     try: protocolo = json.loads(json_config)
     except: 
@@ -128,58 +139,61 @@ def orquestrador(texto, arquivo, history, json_config):
         yield history, {}, "Erro JSON"
         return
 
-    # A TIMELINE começa com o input do usuário (pergunta/instrução)
+    # Timeline inicial
     timeline = [{"role": "user", "content": texto}]
     logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
+    if fragmentos: logs += f"📎 Arquivo processado: {len(fragmentos)} fragmentos gerados.\n"
+    
     history[-1][1] = "⏳ Iniciando análise..."
     yield history, timeline, logs
 
-    # --- NOVO: Lógica de Loop/Transcrição (PASSO 0) ---
+    # --- PASSO 0: LOOP DE TRANSCRIÇÃO ---
+    # Verifica se o primeiro passo é o transcritor e se temos arquivo
     concatenated_transcription = anexo_info + "\n\n"
     
     if protocolo and protocolo[0]['nome'] == 'TRANSCRITOR_FRAGMENTO (PASSO 0 - LOOP)' and len(fragmentos) > 0:
         
-        cfg_transcricao = protocolo.pop(0) # Remove o Agente de Loop da lista principal
+        cfg_transcricao = protocolo.pop(0) # Remove o passo 0 da fila
         
         for i, fragmento in enumerate(fragmentos):
-            history[-1][1] = f"⚙️ {cfg_transcricao['nome']} trabalhando no fragmento {i+1}/{len(fragmentos)} (5 Pgs)..."
+            history[-1][1] = f"⚙️ {cfg_transcricao['nome']} processando parte {i+1} de {len(fragmentos)}..."
             yield history, timeline, logs
             
-            # Executa o LLM no fragmento ATUAL, não na timeline
-            # Isso força o Gemini a focar APENAS nas 5 páginas para transcrever/limpar
+            # Chama o LLM passando APENAS o fragmento atual
             res, log_add, raw = executar_no(timeline, cfg_transcricao, fragmento_input=fragmento)
             logs += log_add + "\n"
             
             if 'error' in res:
-                timeline.append(res)
-                yield history, timeline, logs
-                return
+                logs += f"❌ Erro no fragmento {i+1}: {res['error']}\n"
+                # Continua mesmo com erro, ou para? Vamos continuar concatenando o erro para registro.
             
-            # Concatenamos o texto limpo retornado pelo LLM
-            concatenated_transcription += res['content'] + "\n"
+            # Acumula o resultado
+            concatenated_transcription += f"\n--- TRANSCRIÇÃO PARTE {i+1} ---\n{res['content']}\n"
 
-        logs += "\n✅ TRANSCRIÇÃO FRAGMENTADA E CONCATENADA CONCLUÍDA.\n"
+        logs += "\n✅ Transcrição completa.\n"
         
-        # Adiciona o resultado da transcrição concatenada à timeline para os próximos agentes
+        # Adiciona o texto COMPLETO transcrito à timeline para o Bibliotecário ler
         timeline.append({
             "role": "system", 
-            "agent": "TEXTO_DOCUMENTO_COMPLETO", 
+            "agent": "DOCUMENTO_COMPLETO_TRANSCRITO", 
             "content": concatenated_transcription
         })
-        history[-1][1] = "✅ Transcrição completa. Iniciando Catalogação (Passo 1)..."
-        yield history, timeline, logs
         
     elif len(fragmentos) > 0:
-        # Se não há Passo 0 (Transcrição), injeta o texto extraído cru como um bloco
-        timeline.append({"role": "system", "agent": "TEXTO_DOCUMENTO_COMPLETO", "content": concatenated_transcription + "\n".join(fragmentos)})
+        # Se não tinha o passo de transcrição configurado, injeta o texto cru
+        timeline.append({
+            "role": "system", 
+            "agent": "DOCUMENTO_COMPLETO_RAW", 
+            "content": concatenated_transcription + "\n".join(fragmentos)
+        })
 
-    # 5. PASSOS SEGUINTES: EXECUÇÃO SEQUENCIAL (Catalogação)
+    # --- PASSO 1 e SEGUINTES: CATALOGAÇÃO SEQUENCIAL ---
     final_response = ""
-    for cfg in protocolo: # Iteramos sobre a lista (agora começa do BIBLIOTECARIO_CATALOGADOR)
-        
-        history[-1][1] = f"⚙️ {cfg['nome']} trabalhando..."
+    for cfg in protocolo: 
+        history[-1][1] = f"⚙️ {cfg['nome']} analisando..."
         yield history, timeline, logs
         
+        # Executa com a timeline completa
         res, log_add, raw = executar_no(timeline, cfg)
         timeline.append(res)
         logs += log_add + "\n"
@@ -193,8 +207,8 @@ def orquestrador(texto, arquivo, history, json_config):
     logs += "✅ FIM."
     yield history, timeline, logs
 
-# ==================== 5. UI LIMPA (v31) ====================
-# (A UI permanece a mesma)
+
+# ==================== 5. UI LIMPA (v32) ====================
 
 def ui_clean():
     css = """
@@ -204,11 +218,11 @@ def ui_clean():
     
     config_init = carregar_protocolo()
 
-    with gr.Blocks(title="Protocolo Fragmentação/Transcrição", css=css, theme=gr.themes.Soft()) as app:
+    with gr.Blocks(title="AI Bibliotecário", css=css, theme=gr.themes.Soft()) as app:
         
         with gr.Tabs():
             
-            # === ABA 1: CHAT (LIMPO) ===
+            # === ABA 1: CHAT ===
             with gr.Tab("💬 Investigador"):
                 chatbot = gr.Chatbot(
                     label="", 
@@ -222,7 +236,7 @@ def ui_clean():
                     with gr.Column(scale=10):
                         txt_in = gr.Textbox(
                             show_label=False, 
-                            placeholder="Descreva o caso ou instrução...", 
+                            placeholder="Instruções opcionais...", 
                             lines=1,
                             max_lines=5,
                             container=False
@@ -236,23 +250,22 @@ def ui_clean():
                     with gr.Column(scale=1, min_width=80):
                         btn_send = gr.Button("Enviar", variant="primary", size="sm")
                 
-                # Feedback visual sutil do arquivo
+                # Feedback do arquivo
                 file_status = gr.Markdown("", visible=True)
-                file_in.upload(lambda x: f"📎 Anexo: {os.path.basename(x.name)}", file_in, file_status)
+                file_in.upload(lambda x: f"📎 Anexo pronto: {os.path.basename(getattr(x, 'name', x))}", file_in, file_status)
 
-            # === ABA 2: DEPURAÇÃO (ESCONDIDO) ===
+            # === ABA 2: LOGS ===
             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)
 
-            # === ABA 3: CONFIG (TÉCNICO) ===
+            # === ABA 3: CONFIG ===
             with gr.Tab("⚙️ Config"):
                 with gr.Row():
                     btn_save = gr.Button("Salvar Config")
                     lbl_save = gr.Label(show_label=False)
-                # Label para refletir o novo protocolo
-                code_json = gr.Code(value=config_init, language="json", label="protocolo.json") 
+                code_json = gr.Code(value=config_init, language="json", label="protocolo.json")
                 btn_save.click(salvar_protocolo, code_json, lbl_save)
 
         # === TRIGGERS ===
@@ -264,8 +277,9 @@ def ui_clean():
                 inputs=[txt_in, file_in, chatbot, code_json],
                 outputs=[chatbot, out_dna, out_logs]
             ).then(
-                lambda: (None, ""), 
-                outputs=[txt_in, file_status] 
+                # CORREÇÃO: Limpa txt_in E file_in E file_status após o envio
+                lambda: (None, None, ""), 
+                outputs=[txt_in, file_in, file_status] 
             )
 
     return app