Update app.py

app.py

@@ -204,8 +204,7 @@ def process_file(file_obj):
         logger.warning("--- Nenhum arquivo fornecido para processamento.")
         return "⚠️ Nenhum arquivo enviado."
     try:
-        # O file_obj do Gradio já é um objeto de arquivo temporário
-        file_path = file_obj.name # Obter o path temporário
+        file_path = file_obj.name
         filename = os.path.basename(file_path).lower()
         logger.info(f"--- Processando arquivo: {filename} (path: {file_path})")
 
@@ -219,7 +218,6 @@ def process_file(file_obj):
              logger.warning(f"--- Não foi possível verificar o tamanho do arquivo: {size_e}")
 
         result_text = ""
-        # Passar o file_path para as funções de extração
         if filename.endswith('.pdf'):
             logger.info("--- Chamando extract_text_from_pdf")
             result_text = extract_text_from_pdf(file_path)
@@ -611,33 +609,113 @@ def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
     prompt += "\n\n**Instrução Final:** Gere **APENAS** o texto completo da peça corrigida abaixo, começando pelo endereçamento e terminando com 'OAB/...'. Não inclua NENHUM comentário, introdução ou explicação ANTES ou DEPOIS do texto da peça."
     return prompt
 
-def pos_corrigir_peticao(peticao_corrigida, tipo_peticao):
-    if "Nestes termos, pede deferimento" in peticao_corrigida:
-        peticao_corrigida = peticao_corrigida.replace("Nestes termos, pede deferimento", "Nestes termos pede deferimento")
+# --- Função de Chamada da API ---
+def chamar_api(prompt):
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {
+            "temperature": CONFIG["temperatura"],
+            "maxOutputTokens": CONFIG["max_tokens"],
+            "topP": 0.95,
+        }
+    }
+    headers = {"Content-Type": "application/json"}
+    logger.info(f"Chamando API Gemini com {len(prompt)} caracteres de prompt. Temperatura: {CONFIG['temperatura']}, Max Tokens: {CONFIG['max_tokens']}")
 
-    if tipo_peticao == "Petição Inicial":
-        if "juntada da guia de custas" not in peticao_corrigida.lower() and "gratuidade de justiça" not in peticao_corrigida.lower():
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2:
-                 peticao_corrigida = partes[0] + "Requer, ainda, a juntada da guia de custas devidamente recolhida.\nNestes termos pede deferimento" + partes[1]
-             else:
-                 peticao_corrigida = peticao_corrigida.replace("Local, data.", "Requer, ainda, a juntada da guia de custas devidamente recolhida.\n\nLocal, data.")
-
-        if "audiência de conciliação" not in peticao_corrigida.lower() and "audiência de mediação" not in peticao_corrigida.lower():
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2:
-                 peticao_corrigida = partes[0] + "Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\nNestes termos pede deferimento" + partes[1]
-             else:
-                 peticao_corrigida = peticao_corrigida.replace("Local, data.", "Opta o Autor pela realização da audiência de conciliação ou mediação (Art. 319, VII, CPC).\n\nLocal, data.")
-
-    linhas = [l.strip() for l in peticao_corrigida.strip().split('\n') if l.strip()]
-    fechamento_padrao = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(term in linhas[-1] for term in ["ADVOGADO", "OAB", "Local", "data"]):
-        linhas.pop()
-    linhas.extend(fechamento_padrao)
-    peticao_corrigida = "\n".join(linhas)
-
-    return peticao_corrigida
+    for tentativa in range(CONFIG["max_retry_attempts"]):
+        try:
+            with rate_limiter:
+                logger.debug(f"Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}...")
+                response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
+
+            logger.debug(f"Status Code recebido: {response.status_code}")
+
+            if response.status_code == 429:
+                retry_after = int(response.headers.get("Retry-After", CONFIG["retry_delay"] * (tentativa + 1)))
+                logger.warning(f"Erro 429 (Too Many Requests). Tentando novamente em {retry_after}s...")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(retry_after)
+                    continue
+                else:
+                    return "❌ Erro 429: Muitas requisições. Tente novamente mais tarde."
+
+            if response.status_code != 200:
+                error_info = {}
+                error_msg = f"Erro desconhecido (Status {response.status_code})"
+                try:
+                    error_info = response.json()
+                    error_msg = error_info.get("error", {}).get("message", error_msg)
+                except json.JSONDecodeError:
+                    error_msg = f"{error_msg}. Resposta não é JSON: {response.text[:200]}"
+                logger.error(f"Erro da API (Status {response.status_code}): {error_msg}")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro da API ({response.status_code}): {error_msg}"
+
+            response_data = response.json()
+
+            if not response_data.get("candidates"):
+                 prompt_feedback = response_data.get("promptFeedback", {})
+                 block_reason = prompt_feedback.get("blockReason")
+                 safety_ratings = prompt_feedback.get("safetyRatings")
+                 logger.error(f"Resposta da API sem 'candidates'. Block Reason: {block_reason}, Safety Ratings: {safety_ratings}")
+                 if block_reason:
+                     return f"❌ A solicitação foi bloqueada pela API. Motivo: {block_reason}. Tente reformular o caso ou a petição."
+                 else:
+                      return "❌ Resposta vazia ou inválida da API (sem 'candidates'). Verifique o log para detalhes."
+
+            candidate = response_data["candidates"][0]
+            finish_reason = candidate.get("finishReason")
+            if finish_reason not in [None, "STOP", "MAX_TOKENS"]:
+                 logger.error(f"Geração interrompida pela API. Motivo: {finish_reason}")
+                 safety_ratings_candidate = candidate.get("safetyRatings", [])
+                 harm_categories = [r['category'] for r in safety_ratings_candidate if r['probability'] not in ['NEGLIGIBLE', 'LOW']]
+                 if harm_categories:
+                      return f"❌ A resposta foi bloqueada por segurança pela API. Motivo: {finish_reason} (Categorias: {', '.join(harm_categories)}). Revise o conteúdo."
+                 else:
+                      return f"❌ A geração da resposta foi interrompida pela API. Motivo: {finish_reason}. Tente novamente ou simplifique a solicitação."
+
+            if "content" not in candidate or "parts" not in candidate["content"] or not candidate["content"]["parts"]:
+                 logger.error("Estrutura de resposta inesperada da API: Faltando content/parts.")
+                 if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                 return "❌ Resposta inválida da API (estrutura inesperada)."
+
+            texto_gerado = candidate["content"]["parts"][0]["text"].strip()
+            logger.info(f"API retornou com sucesso. Tamanho da resposta: {len(texto_gerado)} caracteres.")
+            return texto_gerado
+
+        except requests.Timeout:
+            logger.warning(f"Timeout na tentativa {tentativa + 1}.")
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return "⏱️ Tempo esgotado após múltiplas tentativas. Verifique a conexão ou aumente o timeout."
+        except requests.RequestException as e:
+            logger.error(f"Erro de rede/requisição na tentativa {tentativa + 1}: {e}")
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                 logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
+                 time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                 continue
+            return f"❌ Erro na requisição: {e}"
+        except json.JSONDecodeError as e:
+             logger.error(f"Erro ao decodificar JSON da resposta da API: {e}")
+             logger.debug(f"Resposta que causou erro de JSON: {response.text[:500]}")
+             return f"❌ Erro ao processar a resposta da API (JSON inválido)."
+        except Exception as e:
+            logger.exception(f"Erro inesperado na chamada da API na tentativa {tentativa + 1}: {str(e)}")
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                 logger.info(f"Tentando novamente em {CONFIG['retry_delay'] * (tentativa + 1)}s...")
+                 time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                 continue
+            return f"❌ Erro inesperado: {str(e)}"
+
+    return "❌ Falha ao chamar a API após todas as tentativas."
 
 # --- Função Principal de Correção ---
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
@@ -655,7 +733,7 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     peticao_conteudo = ""
     if peticao_arquivo is not None:
         logger.info("--- Processando arquivo de petição...")
-        peticao_conteudo = process_file(peticao_arquivo) # process_file lida com o objeto Gradio
+        peticao_conteudo = process_file(peticao_arquivo)
         if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
             logger.error(f"--- Erro ao processar arquivo: {peticao_conteudo}")
             return peticao_conteudo, "", "", "", "", ""
@@ -667,7 +745,6 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         logger.warning("--- Nenhuma petição fornecida (nem texto, nem arquivo).")
         return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", "", ""
 
-    # Verificação Anti-Troll
     troll_triggers = [
         "escreva a petição", "faça a petição", "redija a petição",
         "elabore a petição", "crie a petição", "gere a petição",
@@ -691,16 +768,15 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
 
     aviso_validacao = ""
 
-    # Cache Check
     cache_key = f"{tipo_peticao}|{caso[:100]}|{peticao_conteudo[:100]}|{modo_treinamento}"
     if cache_key in CORRECAO_CACHE:
         logger.info("--- Correção encontrada no cache.")
         cached_data = CORRECAO_CACHE[cache_key]
         diff_html_cache, _, _ = calcular_diff_interno(cached_data["peticao_original"], cached_data["peticao_corrigida"])
         logger.info("<<< CORRIGIR PETICAO FINALIZADO (CACHE HIT)")
+        # Retorna 6 elementos para corresponder aos outputs
         return cached_data["analise_formatada"], cached_data["peticao_original"], cached_data["peticao_corrigida"], cached_data["resumo_diff"], cached_data["criticas_diff"], diff_html_cache
 
-    # Chamada para Análise
     logger.info("--- Gerando prompt de análise...")
     prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
     logger.info("--- Enviando para análise da API...")
@@ -711,7 +787,6 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
     logger.info("--- Análise recebida da API.")
     analise_formatada = formatar_correcao(analise)
 
-    # Chamada para Gerar Petição Corrigida
     logger.info("--- Gerando prompt para peça corrigida...")
     prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
     logger.info("--- Enviando para geração da peça corrigida API...")
@@ -740,12 +815,10 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
         peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
         logger.info("--- Pós-correção aplicada.")
 
-    # Cálculo de Diferenças
     logger.info("--- Calculando diferenças...")
     diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
     logger.info("--- Diferenças calculadas.")
 
-    # Histórico e Cache
     correcao_completa_formatada = aviso_validacao + analise_formatada
     resultado_historico = {
         "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
@@ -771,9 +844,10 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
 
     end_time = time.time()
     logger.info(f"<<< CORRIGIR PETICAO FINALIZADO em {end_time - start_time:.2f} segundos.")
+    # Retorna 6 elementos para corresponder aos outputs
     return correcao_completa_formatada, peticao_conteudo, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
 
-# --- Funções Auxiliares (Formatação, Dicas, Diff, etc.) ---
+# --- Funções Auxiliares ---
 def formatar_correcao(texto):
     texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
     texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
@@ -1038,94 +1112,7 @@ def carregar_progresso(arquivo_entrada):
         logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM ERRO")
         return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
 
-def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
-    prompt = f"""
-    Crie um caso fictício **detalhado e realista** para um exercício prático de elaboração de uma peça do tipo **"{tipo_peticao}"**, simulando um cenário de Exame de Ordem (OAB).
-
-    **Instruções Gerais para o Caso:**
-    1.  **Complexidade Adequada:** Deve ter informações suficientes para redigir a peça solicitada, mas sem ser excessivamente longo ou complicado. (Ideal: 15-25 linhas).
-    2.  **Dados Essenciais:** Inclua nomes completos (fictícios) das partes envolvidas, locais (cidades/estados fictícios ou genéricos), datas relevantes, valores monetários (se aplicável), e uma descrição clara da relação jurídica e do conflito.
-    3.  **Coerência:** Os fatos devem ser lógicos e justificar a peça processual indicada.
-    4.  **Foco no Tipo de Peça:** O cenário deve ser construído para exigir especificamente a elaboração de um(a) **{tipo_peticao}**.
-
-    **Instruções Específicas para Gerar Caso para "{tipo_peticao}":**
-    """
-    if tipo_peticao == "Petição Inicial":
-        prompt += """
-    *   Descreva uma situação onde direitos foram violados (contrato descumprido, dano sofrido, etc.) e o cliente (autor) busca a tutela jurisdicional pela primeira vez.
-    *   Inclua elementos que permitam calcular danos materiais e/ou justificar danos morais.
-    *   Forneça dados para qualificação das partes (autor e réu).
-    *   **Exemplo de Tema:** Acidente de consumo, inadimplemento contratual, cobrança indevida, ação de despejo, etc.
-    """
-    elif tipo_peticao == "Contestação":
-        prompt += """
-    *   **Apresente PRIMEIRO um resumo da Petição Inicial** que o réu (seu cliente) recebeu (quem processou, o que alegou, o que pediu).
-    *   **Depois, apresente a versão dos fatos do RÉU**, incluindo informações que permitam:
-        *   Alegar preliminares (ex: incompetência do juízo, ilegitimidade da parte, etc.).
-        *   Impugnar os fatos da inicial.
-        *   Apresentar defesa de mérito (ex: pagamento já realizado, culpa exclusiva da vítima, prescrição, etc.).
-    *   Forneça dados para qualificação do réu.
-    """
-    elif tipo_peticao == "Reconvenção":
-         prompt += """
-    *   Siga a estrutura da **Contestação**: Apresente o resumo da Petição Inicial do autor original.
-    *   Apresente a versão dos fatos do Réu (seu cliente) para a defesa.
-    *   **ADICIONE fatos e fundamentos que permitam ao RÉU fazer um pedido PRÓPRIO contra o AUTOR ORIGINAL**, que seja CONEXO com a ação principal ou com a defesa.
-    *   **Exemplo:** Numa ação de cobrança, o réu contesta e reconvém pedindo indenização por danos que o autor lhe causou no mesmo negócio.
-    """
-    elif tipo_peticao == "Impugnação à Contestação":
-        prompt += """
-    *   Apresente um resumo da Petição Inicial original do seu cliente (Autor).
-    *   **Apresente um resumo da Contestação** apresentada pelo réu, destacando:
-        *   As preliminares arguidas pelo réu (se houver).
-        *   Os fatos novos (impeditivos, modificativos, extintivos) alegados pelo réu.
-        *   Os documentos juntados pelo réu (se houver menção a algum relevante).
-    *   O objetivo é fornecer elementos para o Autor rebater a contestação.
-    """
-    elif tipo_peticao == "Embargos de Declaração":
-        prompt += """
-    *   Descreva brevemente o caso original (quem processou quem e por quê).
-    *   **Apresente o DISPOSITIVO ou um TRECHO FUNDAMENTAL de uma DECISÃO JUDICIAL (sentença, acórdão, etc.)** proferida no caso.
-    *   **INDIQUE CLARAMENTE qual o vício (omissão, contradição, obscuridade ou erro material) presente NESSA DECISÃO**, fornecendo contexto para que o aluno possa identificar e fundamentar os Embargos.
-    *   **Exemplo:** "A sentença julgou procedente o pedido X, mas foi omissa quanto ao pedido Y que também constava na inicial." OU "O acórdão afirmou X na fundamentação, mas concluiu Y no dispositivo, gerando contradição."
-    """
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += """
-    *   Descreva o caso original (Autor vs. Réu, causa de pedir, pedidos).
-    *   **Apresente um resumo da SENTENÇA proferida pelo juiz de primeira instância**, indicando se foi procedente, improcedente, parcialmente procedente, e os principais fundamentos do juiz.
-    *   **FORNEÇA ELEMENTOS que indiquem um ERRO na sentença (error in judicando ou in procedendo)**, que justifiquem a reforma ou anulação pelo Tribunal.
-    *   **Exemplo:** "A sentença julgou improcedente o pedido por falta de provas, ignorando o documento X juntado aos autos." OU "O juiz indeferiu a oitiva da testemunha chave Y, cerceando a defesa do réu, e julgou procedente."
-    *   Indique quem é o cliente (apelante).
-    """
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += """
-    *   Descreva o caso original em andamento.
-    *   **Apresente uma DECISÃO INTERLOCUTÓRIA específica** proferida pelo juiz (NÃO a sentença final).
-    *   **A decisão DEVE se enquadrar numa das hipóteses do Art. 1015 do CPC** (ou justificar a taxatividade mitigada).
-    *   **FORNEÇA ELEMENTOS que indiquem um ERRO nessa decisão interlocutória** E, se possível, a **URGÊNCIA** em revertê-la (risco de dano).
-    *   **Exemplo:** "O juiz indeferiu o pedido de gratuidade de justiça, embora o autor tenha comprovado baixa renda." OU "O juiz deferiu a liminar de busca e apreensão do bem X sem a devida comprovação da mora."
-    *   Indique quem é o cliente (agravante).
-    """
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += """
-    *   Descreva uma situação de conflito onde uma das partes precisa de uma medida **urgente** (risco iminente) ou onde seu direito é **evidente**.
-    *   **FORNEÇA ELEMENTOS claros que demonstrem:**
-        *   **Para Urgência:** A probabilidade do direito (fumus boni iuris) E o perigo de dano ou risco ao resultado útil do processo (periculum in mora).
-        *   **Para Evidência:** Uma das hipóteses do Art. 311 do CPC (ex: defesa protelatória, tese firmada em repetitivo, etc.).
-    *   Indique qual medida específica o cliente deseja (ex: bloqueio de bens, retirada de nome do SPC, etc.).
-    *   Especifique se a tutela é pedida ANTES do processo principal (antecedente) ou DENTRO de um processo já existente (incidental).
-    """
-    else:
-         prompt += "*   Crie um cenário jurídico cível com um conflito claro entre duas ou mais partes."
-
-    prompt += """
-    **Finalize o caso com:**
-    "**Situação-Problema:** Na qualidade de advogado(a) de [Nome do Cliente], elabore a peça processual cabível ({tipo_peticao})."
-
-    **Importante:** Evite criar casos que dependam de conhecimento jurídico EXTREMAMENTE específico ou de nicho. Foque em temas comuns do direito civil e processual civil. Seja criativo!
-    """
-    return prompt
-
+# --- Geração de Caso Fictício ---
 def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
     logger.info(f">>> GERAR CASO FICTICIO INICIADO para: {tipo_peticao}")
     if not tipo_peticao:
@@ -1170,6 +1157,9 @@ def interface_gradio():
         gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️")
         gr.Markdown("Analise e aprimore suas peças processuais! Selecione o tipo, forneça o caso e sua peça (texto ou arquivo).")
 
+        # Definir o Textbox oculto aqui para que as saídas dos botões possam referenciá-lo
+        peticao_original_hidden = gr.Textbox(visible=False, label="Original Hidden")
+
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### Configurações")
@@ -1206,6 +1196,7 @@ def interface_gradio():
                      salvar_btn = gr.Button("💾 Salvar Caso/Peça Atual")
                      carregar_btn = gr.Button("📂 Carregar Caso/Peça de Arquivo")
                      arquivo_progresso_upload = gr.File(label="Selecione o arquivo .json para carregar", file_types=[".json"], scale=2)
+                     # Definido como interactive=False desde o início
                      progresso_download_file = gr.File(label="Baixar Progresso Salvo", interactive=False)
 
             with gr.Column(scale=3):
@@ -1247,16 +1238,17 @@ def interface_gradio():
 
         clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        # --- FUNÇÕES WRAPPER (com logs) ---
+        # --- FUNÇÕES WRAPPER (com try-except) ---
         def corrigir_peticao_wrapper_texto(caso, tipo_peticao, peticao_texto, peticao_arquivo_state):
             logger.info(">>> WRAPPER TEXTO INICIADO")
             is_treinamento = modo_treinamento.value
             logger.info(f"--- Modo Treinamento (Texto): {is_treinamento}")
             try:
+                # A função corrigir_peticao retorna 6 valores
                 resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto, peticao_arquivo_state, is_treinamento)
             except Exception as e:
                 logger.error(f"Erro dentro do wrapper texto chamando corrigir_peticao: {e}", exc_info=True)
-                # Retornar tupla com erro para todos os outputs esperados
+                # Retornar tupla com erro para todos os outputs esperados (6 outputs)
                 return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
             logger.info("<<< WRAPPER TEXTO FINALIZADO")
             return resultado
@@ -1266,16 +1258,18 @@ def interface_gradio():
             is_treinamento = modo_treinamento.value
             logger.info(f"--- Modo Treinamento (Arquivo): {is_treinamento}")
             try:
+                # A função corrigir_peticao retorna 6 valores
                 resultado = corrigir_peticao(caso, tipo_peticao, peticao_texto_state, peticao_arquivo, is_treinamento)
             except Exception as e:
                 logger.error(f"Erro dentro do wrapper arquivo chamando corrigir_peticao: {e}", exc_info=True)
-                 # Retornar tupla com erro para todos os outputs esperados
+                 # Retornar tupla com erro para todos os outputs esperados (6 outputs)
                 return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
             logger.info("<<< WRAPPER ARQUIVO FINALIZADO")
             return resultado
         # --- FIM DAS FUNÇÕES WRAPPER ---
 
-        # --- LÓGICA DOS BOTÕES E EVENTOS (COM CORREÇÃO DO CLEAR_BTN) ---
+
+        # --- LÓGICA DOS BOTÕES E EVENTOS ---
 
         caso_btn.click(
              fn=gerar_caso_ficticio,
@@ -1302,7 +1296,7 @@ def interface_gradio():
              show_progress="minimal"
         )
 
-        # Botão Corrigir (Texto) - Usando wrapper
+        # Botão Corrigir (Texto) - Usando wrapper e output corrigido
         btn_corrigir.click(
             fn=lambda: gr.update(value="⏳ Processando... Gerando análise e correção. Isso pode levar um minuto...", visible=True),
             inputs=None,
@@ -1310,9 +1304,9 @@ def interface_gradio():
             show_progress=False
         ).then(
             fn=corrigir_peticao_wrapper_texto,
-            # Inputs SEM o componente modo_treinamento direto
             inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None)],
-            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
+            # 6 outputs correspondendo aos 6 valores retornados por corrigir_peticao
+            outputs=[resultado_analise_output, peticao_original_hidden, resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
             show_progress="full"
         ).then(
@@ -1321,7 +1315,7 @@ def interface_gradio():
             outputs=[processing_message]
         )
 
-        # Botão Corrigir (Arquivo) - Usando wrapper
+        # Botão Corrigir (Arquivo) - Usando wrapper e output corrigido
         btn_corrigir_arquivo.click(
             fn=lambda: gr.update(value="⏳ Processando arquivo... Gerando análise e correção. Isso pode levar um minuto...", visible=True),
             inputs=None,
@@ -1329,9 +1323,9 @@ def interface_gradio():
             show_progress=False
         ).then(
             fn=corrigir_peticao_wrapper_arquivo,
-             # Inputs SEM o componente modo_treinamento direto
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input],
-            outputs=[resultado_analise_output, gr.Textbox(visible=False), resultado_peticao_corrigida_output,
+            # 6 outputs correspondendo aos 6 valores retornados por corrigir_peticao
+            outputs=[resultado_analise_output, peticao_original_hidden, resultado_peticao_corrigida_output,
                      resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
              show_progress="full"
         ).then(
@@ -1340,53 +1334,49 @@ def interface_gradio():
             outputs=[processing_message]
         )
 
-        # Botão Limpar - CORRIGIDO para usar gr.update()
+        # Botão Limpar - Usando gr.update()
         clear_btn.click(
             fn=lambda: [
                 gr.update(value="Petição Inicial"),
-                gr.update(value=False),            # <--- Usa gr.update()
+                gr.update(value=False),
+                gr.update(value=None),
+                gr.update(value=None),
                 gr.update(value=None),
+                gr.update(value=""),
+                gr.update(value="", visible=False),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(value="*Dicas aparecerão aqui enquanto você digita...*"),
                 gr.update(value=None),
-                gr.update(value=None),             # Limpa o gr.File
-                gr.update(value=""),               # Limpa o preview
-                gr.update(value="", visible=False),# Esconde msg processamento
-                gr.update(value=""),               # Limpa análise
-                gr.update(value=""),               # Limpa peça corrigida
-                gr.update(value=""),               # Limpa resumo diff
-                gr.update(value=""),               # Limpa críticas diff
-                gr.update(value=""),               # Limpa HTML diff
-                gr.update(value="*Dicas aparecerão aqui enquanto você digita...*"), # Reseta dicas
-                gr.update(value=None),             # Limpa upload progresso
-                gr.update(value=None, visible=False) # Limpa e esconde download progresso
+                gr.update(value=None) # Limpa o valor do arquivo de download
             ],
-            inputs=None, # Nenhum input para a função lambda de limpeza
-            outputs=[ # Lista de componentes a serem atualizados
+            inputs=None,
+            outputs=[
                 tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
                 arquivo_preview_output, processing_message, resultado_analise_output,
                 resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output,
                 visualizacao_detalhada_output, dica_contextual_output, arquivo_progresso_upload,
-                progresso_download_file
+                progresso_download_file # Mantém o componente na lista de outputs
             ]
         )
 
         progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
         historico_btn.click(fn=mostrar_historico, outputs=historico_output)
 
-        # Salvar/Carregar Progresso (mantidos como antes, mas wrapper garante que não há bool direto)
+        # Salvar/Carregar Progresso - Lógica de visibilidade do botão de download removida
         salvar_btn.click(
              fn=lambda: gr.update(value="⏳ Salvando progresso atual...", visible=True),
              inputs=None, outputs=processing_message, show_progress=False
         ).then(
              fn=salvar_progresso,
              inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             # Saída para gr.File deve ser o path
+             # Saída para gr.File (terceiro output) atualiza o valor do componente progresso_download_file
              outputs=[gr.Textbox(visible=False), config_status, progresso_download_file],
              show_progress="minimal"
-        ).then(
-            # Atualiza a visibilidade do componente de download
-            fn=lambda file_path: gr.update(visible=bool(file_path), value=file_path),
-            inputs=[progresso_download_file],
-            outputs=[progresso_download_file]
+        # REMOVIDO o .then() que mexia com a visibilidade
         ).then(
             lambda: gr.update(value="", visible=False), None, processing_message
         )
@@ -1397,7 +1387,6 @@ def interface_gradio():
         ).then(
              fn=carregar_progresso,
              inputs=[arquivo_progresso_upload],
-             # Outputs mapeados corretamente para os componentes
              outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status],
              show_progress="minimal"
          ).then(
@@ -1416,6 +1405,5 @@ if __name__ == "__main__":
          logger.warning(f"Tesseract não encontrado ou erro ao verificar versão: {e}. OCR de PDFs pode falhar. Verifique packages.txt.")
 
     app = interface_gradio()
-    # app.queue() # Descomente se precisar lidar com múltiplas requisições
-    app.launch() # share=True geralmente não necessário no HF e pode expor secrets se mal configurado
+    app.launch()
     logger.info("Aplicação Gradio encerrada.")