Delete app.py

app.py

@@ -1,1409 +0,0 @@
-import gradio as gr
-import requests
-import os
-import json
-import PyPDF2
-import docx
-import io
-import time
-import tempfile
-from pdfplumber import open as pdfplumber_open
-from PIL import Image
-import pytesseract
-import cv2
-import numpy as np
-from datetime import datetime
-from ratelimiter import RateLimiter
-import difflib
-from html import escape
-import random
-import logging
-import re
-
-# Configuração do Logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Leitura da API Key (usar Secrets no HF)
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-if not GEMINI_API_KEY:
-    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a como Secret nas configurações do Space.")
-
-# API Endpoint
-GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={GEMINI_API_KEY}"
-
-# Configurações
-CONFIG = {
-    "max_retry_attempts": 3,
-    "retry_delay": 5,
-    "timeout": 120,
-    "temperatura": 0.3,
-    "max_tokens": 8192
-}
-
-# Rate Limiter
-rate_limiter = RateLimiter(max_calls=30, period=60)
-
-# Constantes e Dicionários
-TIPOS_DE_PETICAO = [
-    "Petição Inicial", "Contestação", "Reconvenção", "Impugnação à Contestação",
-    "Embargos de Declaração", "Recurso de Apelação", "Agravo de Instrumento",
-    "Petição de Tutela Provisória"
-]
-DICAS_OAB_MELHORADO = {
-    "Clareza e Concisão": "Seja direto e evite jargões excessivos. Facilite a leitura do juiz.",
-    "Fundamentação Legal": "Sempre cite os artigos de lei, súmulas e jurisprudência pertinentes ao seu argumento.",
-    "Coerência Argumentativa": "Mantenha uma linha lógica de raciocínio do início ao fim da peça.",
-    "Revisão Ortográfica e Gramatical": "Erros de português podem prejudicar a credibilidade da sua peça.",
-    "Formatação": "Utilize parágrafos bem definidos, espaçamento adequado e destaque pontos importantes (negrito, itálico) com moderação.",
-    "Endereçamento (Inicial)": "Em relações de consumo, prefira o foro do domicílio do autor (Art. 101, I, CDC). Verifique a competência (material, territorial).",
-    "Qualificação (Inicial)": "Inclua todos os dados do Art. 319, II, CPC. Use 'XXX' para dados não fornecidos.",
-    "Fatos (Inicial)": "Narrativa cronológica, clara e objetiva, sem juízo de valor.",
-    "Pedidos (Inicial)": "Certos, determinados e líquidos (sempre que possível). Cumule pedidos se necessário (Art. 327, CPC).",
-    "Custas (Inicial)": "Sempre peça a juntada da guia ou a gratuidade de justiça (com declaração).",
-    "Valor da Causa (Inicial)": "Deve corresponder ao benefício econômico pretendido (Art. 292, CPC).",
-    "Preliminares (Contestação)": "Alegue todas as matérias do Art. 337 do CPC antes de discutir o mérito.",
-    "Impugnação Específica (Contestação)": "Conteste cada fato alegado pelo autor, sob pena de presunção de veracidade (Art. 341, CPC).",
-    "Mérito (Contestação)": "Apresente sua versão dos fatos e a fundamentação jurídica que ampara a improcedência dos pedidos do autor.",
-    "Pedidos (Contestação)": "Requeira o acolhimento das preliminares e/ou a improcedência total dos pedidos do autor, além da condenação em custas e honorários.",
-    "Pressupostos Recursais": "Verifique cabimento, tempestividade, preparo (custas recursais), regularidade formal e interesse/legitimidade.",
-    "Dialeticidade (Recurso)": "Impugne especificamente os fundamentos da decisão recorrida (Art. 1010, II e III, CPC para Apelação).",
-    "Delimitação da Matéria (Recurso)": "Indique claramente qual parte da decisão você está recorrendo.",
-    "Fumus Boni Iuris": "Demonstre a plausibilidade do direito alegado com base em provas e argumentos sólidos.",
-    "Periculum in Mora": "Evidencie o risco de dano irreparável ou de difícil reparação se a medida não for concedida imediatamente.",
-    "Reversibilidade": "Se possível, argumente que a medida é reversível caso a decisão final seja diferente (Art. 300, §3º, CPC).",
-}
-HISTORICO = []
-CORRECAO_CACHE = {}
-
-# --- Funções de Extração de Texto ---
-def preprocess_image_for_ocr(img):
-    try:
-        gray = img.convert('L')
-        np_img = np.array(gray)
-        _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        return Image.fromarray(thresh)
-    except Exception as e:
-        logger.error(f"Erro no pré-processamento da imagem: {str(e)}")
-        return f"❌ Erro no pré-processamento: {str(e)}"
-
-def extract_text_from_pdf(file_path_or_obj):
-    text = ""
-    ocr_text = ""
-    try:
-        pdf_reader = pdfplumber_open(file_path_or_obj)
-        for i, page in enumerate(pdf_reader.pages):
-            page_text = page.extract_text()
-            if page_text:
-                text += page_text + "\n"
-            else:
-                logger.warning(f"Página {i+1} sem texto extraível, tentando OCR.")
-                try:
-                    img = page.to_image(resolution=300)
-                    preprocessed_img = preprocess_image_for_ocr(img.original)
-                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por')
-                    if page_ocr_text.strip():
-                        ocr_text += page_ocr_text + "\n"
-                    else:
-                        logger.warning(f"OCR falhou na página {i+1}.")
-                        ocr_text += f"[OCR falhou na página {i+1}]\n"
-                except Exception as ocr_e:
-                    if "Tesseract is not installed or not in your PATH" in str(ocr_e):
-                         logger.error(f"Erro no OCR: Tesseract não encontrado ou não está no PATH. Verifique a instalação e o packages.txt no HF. {str(ocr_e)}")
-                         return "❌ Erro de OCR: Tesseract não encontrado. Verifique a configuração do ambiente."
-                    else:
-                        logger.error(f"Erro no OCR da página {i+1}: {str(ocr_e)}")
-                        ocr_text += f"[Erro no OCR da página {i+1}: {str(ocr_e)}]\n"
-        pdf_reader.close()
-
-        if "❌ Erro de OCR: Tesseract não encontrado." in ocr_text:
-            return ocr_text
-
-        if text.strip() and len(text) > len(ocr_text) * 0.5:
-             logger.info("Usando texto extraído do PDF.")
-             return text
-        elif ocr_text.strip():
-             logger.info("Usando texto do OCR do PDF.")
-             return ocr_text
-        else:
-             logger.warning("Não foi possível extrair texto significativo do PDF.")
-             return "⚠️ Não foi possível extrair texto do PDF (tentativa de OCR falhou ou texto inexistente)."
-
-    except ImportError as ie:
-         logger.error(f"Erro de importação ao processar PDF: {str(ie)}. Verifique se 'pdfplumber' está no requirements.txt.")
-         return f"❌ Erro interno: Falta dependência para PDF ({str(ie)})."
-    except Exception as e:
-        logger.error(f"Erro geral ao processar o PDF: {str(e)}", exc_info=True)
-        try:
-            logger.info("Tentando fallback com PyPDF2.")
-            text_fallback = ""
-            if isinstance(file_path_or_obj, str):
-                with open(file_path_or_obj, 'rb') as f:
-                    reader = PyPDF2.PdfReader(f)
-                    for page in reader.pages:
-                        text_fallback += page.extract_text() or ""
-            else:
-                file_path_or_obj.seek(0)
-                reader = PyPDF2.PdfReader(file_path_or_obj)
-                for page in reader.pages:
-                    text_fallback += page.extract_text() or ""
-
-            if text_fallback.strip():
-                 logger.info("Texto extraído com fallback PyPDF2.")
-                 return text_fallback
-            else:
-                 return f"❌ Erro ao processar o PDF e fallback falhou: {str(e)}"
-        except Exception as fallback_e:
-            logger.error(f"Erro no fallback com PyPDF2: {str(fallback_e)}")
-            return f"❌ Erro crítico ao processar o PDF: {str(e)}"
-
-def extract_text_from_docx(file_path_or_obj):
-    try:
-        doc = docx.Document(file_path_or_obj)
-        text = ""
-        for para in doc.paragraphs:
-            text += para.text + "\n"
-        return text if text.strip() else "⚠️ Documento DOCX vazio ou sem texto."
-    except ImportError as ie:
-        logger.error(f"Erro de importação ao processar DOCX: {str(ie)}. Verifique se 'python-docx' está no requirements.txt.")
-        return f"❌ Erro interno: Falta dependência para DOCX ({str(ie)})."
-    except Exception as e:
-        logger.error(f"Erro ao processar o DOCX: {str(e)}", exc_info=True)
-        return f"❌ Erro ao processar o DOCX: {str(e)}"
-
-def extract_text_from_txt(file_path_or_obj):
-    try:
-        if isinstance(file_path_or_obj, str):
-            with open(file_path_or_obj, 'rb') as f:
-                content = f.read()
-        elif hasattr(file_path_or_obj, 'read'):
-            content = file_path_or_obj.read()
-            if hasattr(file_path_or_obj, 'seek'):
-                 try: file_path_or_obj.seek(0)
-                 except: pass
-        else:
-             return "❌ Tipo de entrada TXT inválido."
-
-        encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
-        for encoding in encodings:
-            try:
-                decoded_text = content.decode(encoding)
-                logger.info(f"Arquivo TXT decodificado com {encoding}.")
-                return decoded_text if decoded_text.strip() else "⚠️ Arquivo TXT vazio."
-            except UnicodeDecodeError:
-                continue
-        logger.error("Não foi possível decodificar o arquivo TXT com encodings comuns.")
-        return "❌ Não foi possível decodificar o arquivo TXT. Verifique o encoding."
-    except Exception as e:
-        logger.error(f"Erro ao processar o TXT: {str(e)}", exc_info=True)
-        return f"❌ Erro ao processar o TXT: {str(e)}"
-
-def process_file(file_obj):
-    logger.info(">>> PROCESS FILE INICIADO")
-    if file_obj is None:
-        logger.warning("--- Nenhum arquivo fornecido para processamento.")
-        return "⚠️ Nenhum arquivo enviado."
-    try:
-        file_path = file_obj.name
-        filename = os.path.basename(file_path).lower()
-        logger.info(f"--- Processando arquivo: {filename} (path: {file_path})")
-
-        try:
-             file_size = os.path.getsize(file_path)
-             logger.info(f"--- Tamanho do arquivo: {file_size} bytes")
-             if file_size > 15 * 1024 * 1024:
-                 logger.warning(f"--- Arquivo {filename} excede o limite de tamanho.")
-                 return "⚠️ O arquivo é muito grande. Máx. 15 MB."
-        except OSError as size_e:
-             logger.warning(f"--- Não foi possível verificar o tamanho do arquivo: {size_e}")
-
-        result_text = ""
-        if filename.endswith('.pdf'):
-            logger.info("--- Chamando extract_text_from_pdf")
-            result_text = extract_text_from_pdf(file_path)
-        elif filename.endswith('.docx'):
-            logger.info("--- Chamando extract_text_from_docx")
-            result_text = extract_text_from_docx(file_path)
-        elif filename.endswith('.txt'):
-            logger.info("--- Chamando extract_text_from_txt")
-            result_text = extract_text_from_txt(file_path)
-        else:
-            logger.warning(f"--- Formato de arquivo não suportado: {filename}")
-            result_text = "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
-
-        logger.info(f"<<< PROCESS FILE FINALIZADO. Resultado: {result_text[:100]}...")
-        return result_text
-
-    except Exception as e:
-        logger.error(f"Erro geral ao processar o arquivo '{getattr(file_obj, 'name', 'N/A')}': {str(e)}", exc_info=True)
-        logger.info("<<< PROCESS FILE FINALIZADO COM ERRO GERAL")
-        return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
-
-# --- Funções de Estruturação de Prompt ---
-def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
-    base = """
-    **Estrutura da Avaliação:**
-    1.  **Análise Geral:** Visão geral concisa (2-3 linhas) sobre a adequação da peça ao caso e tipo, consistência e clareza.
-    2.  **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE dos principais fatores.
-    3.  **Pontos Positivos:** Liste pelo menos 2-3 aspectos bem executados, com justificativa (legal/técnica).
-    4.  **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade (erros crassos primeiro). Para cada ponto:
-        *   Descrição clara do erro/omissão.
-        *   Fundamentação legal/doutrinária do porquê é um erro.
-        *   **Impacto estimado na nota** (ex: -0.5, -1.0, -2.0).
-        *   Sugestão de correção ou como deveria ter sido feito.
-    5.  **Análise Específica dos Requisitos:** Avalie os itens chave da peça (listados abaixo para cada tipo).
-
-    **Critérios Fundamentais (Aplicáveis a Quase Todos):**
-    *   **Coerência:** A peça responde ao caso/situação processual? Os argumentos são lógicos?
-    *   **Fundamentação:** Usou a lei, doutrina e jurisprudência corretamente? Citou artigos relevantes?
-    *   **Linguagem:** Clareza, objetividade, correção gramatical e formalidade adequada?
-    *   **Pedidos:** São claros, certos, determinados e coerentes com a fundamentação?
-    *   **NÃO INVENTAR FATOS:** Penalidade severa (-3.0 a -5.0) se criar fatos não presentes no caso.
-    *   **NÃO SE IDENTIFICAR:** Nota ZERO se houver nome, OAB, CPF, etc., do aluno na peça (exceto nomes das partes do caso). Use "ADVOGADO(A)", "OAB/...".
-    """
-    if modo_treinamento:
-        base += """
-    **Modo de Treinamento:**
-    *   Para cada Ponto a Melhorar, detalhe AINDA MAIS:
-        a) Explicação aprofundada do erro e sua consequência prática.
-        b) Base legal/doutrinária específica.
-        c) **Exemplo de Redação Corrigida** para aquele trecho específico.
-        d) Dica prática relevante (use o banco de dicas se aplicável).
-        e) Possível estratégia alternativa.
-    *   Destaque inconsistências entre a peça e o caso com citações diretas.
-    *   Sugira estratégias jurídicas adicionais ou alternativas viáveis.
-        """
-    return base
-
-def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
-    instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt_especifico = f"""
-    ## Análise de Peça Processual: {tipo_peticao} (Critérios OAB Simulados)
-
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-
-    **Peça do Aluno ({tipo_peticao}):**
-    ```
-    {peticao}
-    ```
-
-    {instrucoes_gerais}
-
-    **Requisitos Específicos para {tipo_peticao}:**
-    """
-    if tipo_peticao == "Petição Inicial":
-        prompt_especifico += """
-       - Endereçamento e competência (Art. 319, I, CPC; leis especiais como CDC Art. 101, I).
-       - Qualificação completa das partes (Art. 319, II, CPC).
-       - Exposição clara e lógica dos fatos (causa de pedir remota).
-       - Fundamentação jurídica pertinente (causa de pedir próxima - Art. 319, III, CPC).
-       - Pedidos certos, determinados e líquidos (se possível) (Art. 319, IV, CPC).
-       - Valor da causa correto e justificado (Art. 291-292, 319, V, CPC).
-       - Indicação das provas pretendidas (Art. 319, VI, CPC).
-       - Opção pela audiência de conciliação/mediação (Art. 319, VII, CPC).
-       - Pedido de citação do réu (forma específica se necessário).
-       - Requerimento de juntada de documentos essenciais (procuração, custas/JG).
-       - Fechamento formal ("Nestes termos pede deferimento", Local, data, Advogado, OAB).
-    **Critérios Adicionais (Inicial):**
-    *   Uso de "XXX" para dados ausentes. Penalizar invenção (-0.5 por ocorrência).
-    *   Falta de pedido de juntada de custas/JG: -1.0 ponto.
-    *   Erro em "Nestes termos, pede deferimento" (com vírgula): -0.2 ponto.
-    *   Analisar foro (Art. 46 CPC vs. Art. 101 CDC): Escolha do foro do consumidor é válida se aplicável; não penalizar, apenas comentar se gerar dificuldades práticas.
-        """
-    elif tipo_peticao == "Contestação":
-        prompt_especifico += """
-       - Endereçamento ao juízo correto onde tramita a ação.
-       - Qualificação completa do réu (se já não constante nos autos, referenciar).
-       - Indicação do processo (número).
-       - Tempestividade (menção implícita ou explícita de que está no prazo).
-       - **Preliminares (Art. 337, CPC):** Alegar TODAS as aplicáveis (inexistência/nulidade citação, incompetência, inépcia, perempção, litispendência, coisa julgada, conexão, incapacidade, convenção de arbitragem, ausência de legitimidade/interesse, falta de caução, indevida concessão de JG).
-       - **Impugnação Específica dos Fatos:** Rebater PONTO A PONTO os fatos alegados na inicial (Art. 341, CPC). A falta de impugnação específica torna o fato incontroverso!
-       - **Mérito:** Apresentar a versão do réu sobre os fatos; apresentar a defesa de mérito direta (negando direito do autor) e/ou indireta (fatos impeditivos, modificativos, extintivos do direito do autor - ex: pagamento, prescrição, compensação).
-       - Fundamentação jurídica da defesa.
-       - **Pedidos:** Requerer acolhimento das preliminares (com extinção ou remessa); NO MÉRITO, requerer a IMPROCEDÊNCIA TOTAL dos pedidos do autor; Requerer a condenação do autor nas custas e honorários advocatícios (Art. 85, CPC).
-       - Indicação das provas que pretende produzir.
-       - Fechamento formal.
-    **Critérios Adicionais (Contestação):**
-    *   A não alegação de preliminar arguível (exceto incompetência absoluta, conexão, convenção de arbitragem) preclui? Avaliar impacto.
-    *   Falha grave na impugnação específica: -2.0 a -4.0 pontos.
-    *   Ausência de pedido de improcedência: -1.5 pontos.
-        """
-    elif tipo_peticao == "Reconvenção":
-         prompt_especifico += """
-       - Apresentada NA MESMA PEÇA da Contestação (Art. 343, CPC).
-       - Endereçamento ao mesmo juízo.
-       - Indicação do processo.
-       - Qualificação completa do réu-reconvinte e do autor-reconvindo (podem ser referenciadas se já completas).
-       - **Conexão com a Ação Principal ou Fundamento de Defesa:** O pedido da reconvenção deve ser conexo (Art. 343, caput).
-       - **Estrutura Similar à Petição Inicial:**
-           - Fatos que fundamentam a reconvenção.
-           - Fundamentação jurídica do pedido reconvencional.
-           - Pedidos específicos da reconvenção (condenação do autor-reconvindo).
-           - Valor da causa para a reconvenção.
-           - Indicação de provas para a reconvenção.
-       - Pedido de intimação do autor-reconvindo para contestar a reconvenção (na pessoa de seu advogado - Art. 343, §1º).
-       - Fechamento formal (pode ser conjunto com a contestação).
-    **Critérios Adicionais (Reconvenção):**
-    *   Ausência de conexão clara: -2.0 pontos.
-    *   Falta de pedido/valor da causa/provas específicos para a reconvenção: -1.0 por item.
-    *   Apresentada em peça separada da contestação (erro formal grave): -3.0 pontos.
-         """
-    elif tipo_peticao == "Impugnação à Contestação":
-         prompt_especifico += """
-       - Endereçamento ao juízo correto.
-       - Indicação do processo.
-       - Qualificação do autor (impugnante).
-       - Tempestividade (prazo de 15 dias - Art. 350/351 CPC).
-       - **Resposta às Preliminares:** Rebater cada preliminar arguida na contestação.
-       - **Resposta a Fatos Impeditivos/Modificativos/Extintivos:** Se o réu alegou fatos novos (Art. 350), o autor DEVE se manifestar sobre eles.
-       - **Resposta a Documentos Novos:** Manifestar-se sobre documentos juntados com a contestação (Art. 437 CPC).
-       - **Ratificação da Inicial:** Reiterar os termos e pedidos da petição inicial.
-       - **Especificação de Provas:** Se o réu apresentou defesa de mérito indireta ou preliminares que exigem prova, o autor deve especificar as provas que pretende produzir para contrapor (Art. 350/351).
-       - Pedidos: Rejeição das preliminares, refutação da defesa de mérito, procedência dos pedidos da inicial.
-       - Fechamento formal.
-    **Critérios Adicionais (Impugnação):**
-    *   Não responder a uma preliminar relevante: -1.5 pontos.
-    *   Não se manifestar sobre fato novo impeditivo/modificativo/extintivo alegado: -2.0 pontos.
-    *   Não ratificar a inicial: -0.5 pontos.
-         """
-    elif tipo_peticao == "Embargos de Declaração":
-         prompt_especifico += """
-       - **Contra Decisão Judicial Específica:** Indicar claramente qual decisão está sendo embargada (sentença, acórdão, decisão interlocutória).
-       - Endereçamento ao PRÓPRIO juízo que proferiu a decisão.
-       - Indicação do processo.
-       - Qualificação das partes (embargante e embargado).
-       - Tempestividade (prazo de 5 dias - Art. 1023 CPC).
-       - **Cabimento (Art. 1022, CPC):** Apontar **PRECISAMENTE** e **FUNDAMENTADAMENTE** a ocorrência de:
-           - **Omissão:** Ponto ou questão sobre o qual o juiz deveria ter se pronunciado e não o fez.
-           - **Contradição:** Afirmações conflitantes DENTRO da própria decisão.
-           - **Obscuridade:** Falta de clareza que impede a compreensão da decisão.
-           - **Erro Material:** Engano manifesto e corrigível de ofício (nome, cálculo, etc.).
-       - **NÃO PODE REJULGAR A CAUSA:** O objetivo é sanar vício, não modificar o mérito (salvo efeitos infringentes excepcionais).
-       - **Pedido:** Requerer o conhecimento dos embargos e seu ACOLHIMENTO para sanar o vício apontado (com ou sem efeitos infringentes, se for o caso).
-       - Fechamento formal.
-    **Critérios Adicionais (Embargos):**
-    *   Usar Embargos para rediscutir o mérito (erro grave): -4.0 pontos.
-    *   Não apontar claramente o vício (omissão/contradição/obscuridade/erro material): -3.0 pontos.
-    *   Endereçar ao tribunal em vez do juízo prolator (erro): -1.0 ponto.
-         """
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt_especifico += """
-       - **Peça de Interposição:**
-           - Endereçamento ao JUIZ que proferiu a sentença (juízo a quo).
-           - Indicação do processo.
-           - Qualificação das partes (apelante e apelado).
-           - Demonstração dos pressupostos de admissibilidade (cabimento - contra sentença Art. 1009; tempestividade - 15 dias Art. 1003, §5º; preparo - juntada das guias ou pedido de JG; regularidade formal).
-           - Pedido de recebimento do recurso, processamento e remessa ao Tribunal (juízo ad quem).
-       - **Razões Recursais:**
-           - Endereçamento ao TRIBUNAL competente (Ex: Egrégio Tribunal de Justiça).
-           - Breve exposição dos fatos e do ocorrido no processo (resumo da lide e da sentença).
-           - **Fundamentos de Fato e de Direito para Reforma/Anulação (Art. 1010, II e III):**
-               - **Error in procedendo:** Erro na condução do processo (ex: cerceamento de defesa). Leva à anulação.
-               - **Error in judicando:** Erro no julgamento do mérito (má aplicação da lei, má valoração da prova). Leva à reforma.
-               - **Princípio da Dialeticidade:** Impugnar ESPECIFICAMENTE os fundamentos da sentença recorrida. Não pode ser cópia da inicial/contestação.
-           - **Pedidos:** Requerer o conhecimento do recurso; o PROVIMENTO para ANULAR ou REFORMAR a sentença (especificar o que se quer: procedência, improcedência, etc.); inversão do ônus da sucumbência.
-       - Fechamento formal (Local, data, Advogado, OAB).
-    **Critérios Adicionais (Apelação):**
-    *   Falta da peça de interposição ou das razões: Nota zero.
-    *   Endereçamento incorreto das razões (para o juiz a quo): -1.0 ponto.
-    *   Ausência de impugnação específica aos fundamentos da sentença (violação dialeticidade): -3.0 a -5.0 pontos.
-    *   Não pedir anulação/reforma de forma clara: -1.5 pontos.
-    *   Falta de comprovação do preparo ou pedido de JG: Recurso deserto (na prática). Avaliar como erro grave (-2.0).
-        """
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt_especifico += """
-       - **Peça Única (Interposição e Razões):**
-       - Endereçamento diretamente ao TRIBUNAL competente (Presidente ou Relator sorteado).
-       - Indicação do processo de origem (número, vara, comarca).
-       - Qualificação completa das partes (agravante e agravado) e seus advogados (com endereços - Art. 1016, IV).
-       - Indicação da decisão agravada (cópia integral OBRIGATÓRIA - Art. 1017, I).
-       - **Cabimento (Art. 1015, CPC ou teses de taxatividade mitigada):** Demonstrar que a decisão interlocutória se encaixa numa das hipóteses legais ou na urgência decorrente da inutilidade futura do julgamento do mérito (Tema 988 STJ).
-       - **Tempestividade:** Prazo de 15 dias (Art. 1003, §5º).
-       - **Preparo:** Juntada das guias ou pedido de JG.
-       - **Peças Obrigatórias (Art. 1017, I):** Cópia da decisão agravada, certidão de intimação (ou outro doc. que comprove tempestividade), procurações das partes.
-       - **Peças Facultativas (Art. 1017, III):** Outras peças úteis para compreensão da controvérsia.
-       - **Razões do Pedido de Reforma/Invalidação (Art. 1016, II e III):** Exposição do fato e do direito; razões pelas quais a decisão deve ser alterada. Foco no erro da decisão interlocutória.
-       - **Pedido de Efeito Suspensivo ou Tutela Antecipada Recursal (Art. 1019, I):** Se houver risco de dano grave, pedir fundamentadamente.
-       - **Pedidos Finais:** Requerer o conhecimento do recurso; (se aplicável) a concessão de efeito suspensivo/tutela antecipada; o PROVIMENTO do agravo para reformar ou invalidar a decisão agravada; a comunicação ao juiz da causa (Art. 1018 - opcional se processo eletrônico).
-       - Fechamento formal.
-    **Critérios Adicionais (Agravo):**
-    *   Ausência de peça obrigatória (decisão, intimação, procurações): Inadmissibilidade (na prática). Erro gravíssimo (-4.0).
-    *   Não demonstrar o cabimento (Art. 1015 ou mitigação): -3.0 pontos.
-    *   Endereçar ao juiz a quo: -1.0 ponto.
-    *   Não indicar o nome e endereço dos advogados: Falha formal (-0.5).
-        """
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt_especifico += """
-       - **Tipo (Urgência ou Evidência):** A petição deve deixar claro qual modalidade se busca. Pode ser requerida em caráter antecedente ou incidental.
-       - Endereçamento ao juízo competente (se antecedente) ou ao juízo da causa (se incidental).
-       - Qualificação completa das partes.
-       - Indicação do processo (se incidental).
-       - **Tutela de Urgência (Art. 300 CPC):**
-           - **Fumus Boni Iuris:** Demonstrar a **probabilidade do direito** alegado. Argumentação e provas pré-constituídas.
-           - **Periculum in Mora:** Demonstrar o **perigo de dano** ou o risco ao resultado útil do processo se tiver que esperar a decisão final. Urgência concreta.
-           - **Reversibilidade (Art. 300, §3º):** Argumentar, se possível, que a medida pode ser revertida caso a decisão final seja improcedente.
-       - **Tutela de Evidência (Art. 311 CPC):**
-           - Demonstrar uma das hipóteses: I - abuso do direito de defesa/propósito protelatório; II - alegações comprovadas apenas documentalmente + tese firmada em julgamento repetitivo ou súmula vinculante; III - pedido reipersecutório com prova documental adequada do contrato de depósito; IV - inicial instruída com prova documental suficiente + réu não opõe prova capaz de gerar dúvida razoável.
-           - **NÃO precisa demonstrar periculum in mora.**
-       - **Pedido Específico:** Indicar CLARAMENTE qual medida liminar está sendo solicitada (obrigação de fazer/não fazer, bloqueio de bens, etc.).
-       - **Se Antecedente (Art. 303 ou 305):** Indicar o pedido final a ser formulado ou apresentar a petição inicial completa no prazo legal.
-       - **Valor da Causa:** Se antecedente, estimar. Se incidental, geralmente já existe.
-       - **Pedidos:** Requerer a concessão da tutela provisória (liminarmente ou após justificação prévia); citação/intimação do réu; (se antecedente) indicação da futura ação principal ou aditamento.
-       - Fechamento formal.
-    **Critérios Adicionais (Tutela):**
-    *   Não demonstrar claramente o Fumus Boni Iuris ou o Periculum in Mora (para Urgência): -3.0 a -5.0 pontos.
-    *   Não enquadrar corretamente numa das hipóteses da Tutela de Evidência: -3.0 pontos.
-    *   Pedido genérico ou pouco claro sobre a medida desejada: -2.0 pontos.
-    *   Confundir os requisitos de Urgência e Evidência: -1.5 pontos.
-        """
-    else:
-        prompt_especifico += """
-       - **Adequação ao Tipo:** A peça corresponde minimamente à estrutura e finalidade do tipo selecionado?
-       - **Clareza:** É possível entender o que o aluno pretende com a peça?
-       - **Fundamentação Mínima:** Há alguma tentativa de basear os argumentos em lei ou fatos?
-       - **Pedido:** Existe um pedido, mesmo que mal formulado?
-        """
-
-    prompt_especifico += "\n\n**Instruções Finais:** Analise a peça do aluno estritamente com base no caso/contexto fornecido e nos critérios acima. Seja rigoroso como um examinador da OAB, mas forneça feedback construtivo e detalhado, especialmente nos 'Pontos a Melhorar'. Gere a resposta **exclusivamente** no formato solicitado (Análise Geral, Nota, Pontos Positivos, etc.)."
-    return prompt_especifico
-
-def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    prompt = f"""
-    **Caso/Contexto Fornecido:**
-    ```
-    {caso}
-    ```
-
-    **Peça Original do Aluno ({tipo_peticao}):**
-    ```
-    {peticao_original}
-    ```
-
-    **Tarefa:** Com base no caso e nos problemas identificados na peça original (implícitos na sua estrutura/conteúdo), **gere uma versão corrigida e aprimorada** da peça ({tipo_peticao}). Siga **rigorosamente** as melhores práticas e os requisitos formais/materiais para este tipo de peça no exame da OAB.
-
-    **Instruções Específicas para a Peça Corrigida ({tipo_peticao}):**
-    """
-    if tipo_peticao == "Petição Inicial":
-        prompt += """
-    1.  **Endereçamento:** Correto e fundamentado (Art. 46 CPC ou Art. 101 CDC se aplicável e justificado).
-    2.  **Qualificação:** Completa (Art. 319, II), usando "XXX" para dados ausentes no caso.
-    3.  **Fatos:** Narre de forma cronológica, clara e fiel ao caso, sem invenções.
-    4.  **Fundamentação:** Cite artigos de lei pertinentes (ex: CC, CDC, CPC) e, se aplicável, súmulas/jurisprudência relevante.
-    5.  **Pedidos:** Claros, certos, determinados (quantificar danos se possível com base no caso). Incluir pedidos cumulados se cabível (principal, danos morais, materiais, etc.).
-    6.  **Valor da Causa:** Correto (soma dos benefícios econômicos - Art. 292).
-    7.  **Provas:** Indicar as provas de forma genérica mas adequada (ex: "protesta provar o alegado por todos os meios de prova em direito admitidos, em especial documental, testemunhal e pericial").
-    8.  **Audiência:** Indicar opção pela audiência (Art. 319, VII).
-    9.  **Citação:** Pedido de citação do réu (ex: "via postal, nos termos do Art. 246, I, CPC").
-    10. **Custas:** Requerimento expresso de juntada da guia paga OU pedido de gratuidade de justiça (se o caso sugerir hipossuficiência, com pedido de juntada de declaração). **NUNCA OMITIR.**
-    11. **Fechamento:** "Nestes termos pede deferimento." (SEM vírgula). Seguido de "Local, data.", "ADVOGADO(A)", "OAB/...". **NUNCA identificar o advogado.**
-        """
-    elif tipo_peticao == "Contestação":
-        prompt += """
-    1.  **Endereçamento:** Ao juízo onde a ação tramita.
-    2.  **Identificação:** Número do processo, qualificação do réu.
-    3.  **Tempestividade:** Pode mencionar ("A presente contestação é tempestiva...").
-    4.  **Estrutura:**
-        *   **Síntese da Inicial:** Breve resumo do que o autor pede.
-        *   **Preliminares (Art. 337):** Argua todas as cabíveis, fundamentando cada uma.
-        *   **Mérito:**
-            *   **Impugnação Específica:** Conteste cada fato relevante da inicial.
-            *   **Defesa de Mérito:** Apresente a versão do réu, fatos impeditivos/modificativos/extintivos, e a fundamentação legal para a improcedência.
-        *   **Reconvenção (Se houver no caso):** Incluir como tópico separado ANTES dos pedidos da contestação.
-    5.  **Pedidos da Contestação:**
-        *   Acolhimento das preliminares (com a consequência - extinção/remessa).
-        *   **IMPROCEDÊNCIA TOTAL** dos pedidos do autor.
-        *   Condenação do autor em custas e honorários.
-    6.  **Provas:** Indicar as provas que o réu pretende produzir.
-    7.  **Fechamento:** Padrão OAB (Local, data, Advogado(a), OAB/...).
-        """
-    elif tipo_peticao == "Reconvenção":
-         prompt += """
-    **IMPORTANTE:** Gere a Reconvenção como parte da Contestação.
-    1.  **Após a defesa de mérito da Contestação e ANTES dos pedidos da Contestação**, insira um tópico claro: "DA RECONVENÇÃO".
-    2.  **Qualificação:** Identifique o Réu como Reconvinte e o Autor como Reconvindo.
-    3.  **Conexão:** Justifique brevemente a conexão com a ação principal ou defesa.
-    4.  **Fatos Reconvencionais:** Narre os fatos que baseiam o pedido do reconvinte.
-    5.  **Direito Reconvencional:** Fundamente juridicamente o pedido do reconvinte.
-    6.  **Pedidos da Reconvenção:** Formule pedidos claros e específicos contra o autor-reconvindo (ex: condenação a pagar X, fazer Y).
-    7.  **Valor da Causa da Reconvenção:** Atribua um valor específico para a reconvenção.
-    8.  **Provas da Reconvenção:** Indique as provas para a reconvenção.
-    9.  **Intimação:** Peça a intimação do autor-reconvindo para contestar a reconvenção.
-    10. **Continue com os Pedidos da Contestação** (improcedência da ação original, etc.).
-    11. **Fechamento:** Padrão OAB.
-         """
-    elif tipo_peticao == "Impugnação à Contestação":
-         prompt += """
-    1.  **Endereçamento:** Ao juízo correto.
-    2.  **Identificação:** Processo, Impugnante.
-    3.  **Tempestividade:** Mencione o prazo de 15 dias.
-    4.  **Estrutura:**
-        *   **Resposta às Preliminares:** Rebata cada preliminar arguida.
-        *   **Resposta aos Fatos Impeditivos/Modificativos/Extintivos:** Manifeste-se sobre fatos novos (Art. 350).
-        *   **Resposta aos Documentos:** Manifeste-se sobre documentos juntados (Art. 437).
-        *   **Ratificação da Inicial:** Reitere os termos e pedidos iniciais.
-    5.  **Pedidos:** Rejeição das preliminares, refutação da defesa, procedência da a��ão.
-    6.  **Provas:** Especifique provas para contrapor a defesa, se necessário.
-    7.  **Fechamento:** Padrão OAB.
-         """
-    elif tipo_peticao == "Embargos de Declaração":
-         prompt += """
-    1.  **Endereçamento:** Ao juízo que proferiu a decisão embargada.
-    2.  **Identificação:** Processo, Embargante, Embargado.
-    3.  **Decisão Embargada:** Indique claramente qual decisão (sentença fls. X, acórdão ID Y).
-    4.  **Tempestividade:** Mencione o prazo de 5 dias.
-    5.  **Cabimento (Art. 1022):**
-        *   Crie um tópico para cada vício alegado (Da Omissão, Da Contradição, etc.).
-        *   Dentro de cada tópico, **transcreva o trecho relevante da decisão** e explique **objetivamente** onde está o vício. NÃO REFAÇA O JULGAMENTO.
-    6.  **Pedido:** Peça o conhecimento e ACOLHIMENTO dos embargos para sanar o(s) vício(s) apontado(s), especificando o que se espera (ex: "para que seja suprida a omissão quanto a...", "para que seja corrigida a contradição entre..."). Se cabível e fundamentado, pedir efeitos infringentes.
-    7.  **Fechamento:** Padrão OAB.
-         """
-    elif tipo_peticao == "Recurso de Apelação":
-        prompt += """
-    1.  **Peça de Interposição:** Ao juízo a quo (quem proferiu a sentença).
-    2.  **Identificação:** Processo, Apelante, Apelado.
-    3.  **Pressupostos:** Cabimento, tempestividade, preparo/JG.
-    4.  **Pedido (Interposição):** Recebimento e remessa ao Tribunal.
-    5.  **Razões Recursais:** Ao Tribunal (ad quem).
-    6.  **Resumo:** Fatos, lide, sentença.
-    7.  **Fundamentos (Art. 1010):** Error in procedendo/judicando. **Dialeticidade OBRIGATÓRIA**.
-    8.  **Pedidos (Razões):** Conhecimento, PROVIMENTO para anular/reformar, inversão sucumbência.
-    9.  **Fechamento:** Padrão OAB.
-        """
-    elif tipo_peticao == "Agravo de Instrumento":
-        prompt += """
-    1.  **Endereçamento:** Diretamente ao Tribunal.
-    2.  **Identificação:** Processo de origem, Agravante, Agravado, Advogados (com endereços).
-    3.  **Decisão Agravada:** Indicar e juntar cópia OBRIGATÓRIA.
-    4.  **Cabimento:** Demonstrar hipótese do Art. 1015 ou mitigação.
-    5.  **Pressupostos:** Tempestividade, preparo/JG.
-    6.  **Peças Obrigatórias (Art. 1017):** Decisão, intimação, procurações. Facultativas: outras úteis.
-    7.  **Razões:** Exposição do fato e direito para reforma/invalidação.
-    8.  **Efeito Suspensivo/Tutela Antecipada:** Pedir fundamentadamente se necessário (Art. 1019, I).
-    9.  **Pedidos Finais:** Conhecimento, efeito suspensivo/tutela (se houver), PROVIMENTO para reformar/invalidar.
-    10. **Fechamento:** Padrão OAB.
-        """
-    elif tipo_peticao == "Petição de Tutela Provisória":
-        prompt += """
-    1.  **Tipo:** Urgência ou Evidência? Antecedente ou Incidental?
-    2.  **Endereçamento:** Juízo competente ou da causa.
-    3.  **Identificação:** Partes, processo (se incidental).
-    4.  **Requisitos:**
-        *   **Urgência (Art. 300):** Fumus Boni Iuris + Periculum in Mora (+ Reversibilidade, se possível).
-        *   **Evidência (Art. 311):** Uma das hipóteses legais (NÃO precisa periculum).
-    5.  **Pedido Específico:** Qual medida liminar é solicitada?
-    6.  **Se Antecedente:** Indicar pedido final ou aditar/completar no prazo.
-    7.  **Pedidos:** Concessão da tutela, citação/intimação.
-    8.  **Fechamento:** Padrão OAB.
-        """
-    else:
-        prompt += """
-    1.  **Estrutura Lógica:** Organize a peça com começo, meio e fim.
-    2.  **Argumentos:** Apresente os argumentos de forma clara.
-    3.  **Pedidos:** Formule um pedido claro ao final.
-    4.  **Formalidades:** Use linguagem adequada e o fechamento padrão OAB.
-        """
-
-    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
-
-# --- 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']}")
-
-    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):
-    logger.info(f">>> CORRIGIR PETICAO INICIADO - Tipo: {tipo_peticao}, Treinamento: {modo_treinamento}")
-    start_time = time.time()
-
-    if not caso or not caso.strip():
-        logger.warning("--- Caso não fornecido.")
-        return "⚠️ Forneça o caso/contexto da peça.", "", "", "", "", ""
-
-    if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
-         logger.warning(f"--- Tipo de petição inválido ou não fornecido: {tipo_peticao}")
-         return "⚠️ Selecione um tipo de petição válido.", "", "", "", "", ""
-
-    peticao_conteudo = ""
-    if peticao_arquivo is not None:
-        logger.info("--- Processando arquivo de petição...")
-        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, "", "", "", "", ""
-        logger.info(f"--- Texto extraído do arquivo ({len(peticao_conteudo)} caracteres).")
-    elif peticao_texto and peticao_texto.strip():
-         peticao_conteudo = peticao_texto
-         logger.info(f"--- Usando texto da petição fornecido ({len(peticao_conteudo)} caracteres).")
-    else:
-        logger.warning("--- Nenhuma petição fornecida (nem texto, nem arquivo).")
-        return "⚠️ Forneça a petição (em texto ou arquivo).", "", "", "", "", ""
-
-    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",
-        "3scr3v4 a p3t1çã0", "f4ç4 a p3t1çã0", "r3d1j4 a p3t1çã0",
-        "3lab0r3 a p3t1çã0", "cr13 a p3t1çã0", "g3r3 a p3t1çã0",
-        "formule", "produza a petição", "desenvolva a petição",
-        "faça para mim", "faça por mim", "escreva para mim",
-    ]
-    peticao_lower = peticao_conteudo.lower()
-    if any(trigger in peticao_lower for trigger in troll_triggers):
-        respostas_troll = [
-            "Hummm... Parece que você quer que *eu* faça o trabalho, né? 😉 Que tal você tentar escrever a peça e *eu* te ajudo a corrigir? Assim você aprende de verdade!",
-            "🚫 Opa! Meu trabalho é *corrigir* e *ensinar*, não fazer a peça do zero. Mostre o que você fez e eu te dou o feedback!",
-            "📚 Lembre-se: a prática leva à perfeição (e à aprovação!). Tente redigir a peça com base no caso, e depois eu analiso para você.",
-            "🤖 Sou um corretor, não um escritor fantasma! Escreva sua versão que eu aponto os caminhos para melhorar.",
-            "💡 Dica de ouro: Comece! Esboce a peça, mesmo que imperfeita. Depois a gente lapida juntos. Mande bala!",
-            "😂 Pedir pra IA fazer a peça é tipo pedir pro GPS dirigir o carro. Ele te guia, mas quem tá no volante é você! Escreva aí!",
-        ]
-        logger.info("--- Detectado pedido para escrever petição. Retornando resposta troll.")
-        return random.choice(respostas_troll), "", "", "", "", ""
-
-    aviso_validacao = ""
-
-    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
-
-    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...")
-    analise = chamar_api(prompt_analise)
-    if analise.startswith("❌") or analise.startswith("⏱️") or analise.startswith("⚠️"):
-        logger.error(f"--- Erro na análise da petição: {analise}")
-        return aviso_validacao + analise, peticao_conteudo, "", "", "", ""
-    logger.info("--- Análise recebida da API.")
-    analise_formatada = formatar_correcao(analise)
-
-    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...")
-    peticao_corrigida_bruta = chamar_api(prompt_peticao)
-
-    peticao_corrigida_final = ""
-    if peticao_corrigida_bruta.startswith("❌") or peticao_corrigida_bruta.startswith("⏱️") or peticao_corrigida_bruta.startswith("⚠️"):
-        logger.error(f"--- Erro ao gerar peça corrigida: {peticao_corrigida_bruta}")
-        peticao_corrigida_final = f"⚠️ Falha ao gerar a versão corrigida:\n{peticao_corrigida_bruta}"
-    else:
-        logger.info("--- Peça corrigida recebida, aplicando pós-correção...")
-        start_markers = ["excelentíssimo", "eméritos julgadores", "meritíssimo juízo"]
-        start_index = -1
-        peticao_lower_corr = peticao_corrigida_bruta.lower()
-        for marker in start_markers:
-            idx = peticao_lower_corr.find(marker)
-            if idx != -1:
-                start_index = idx
-                break
-
-        if start_index != -1:
-             peticao_extraida = peticao_corrigida_bruta[start_index:]
-        else:
-             peticao_extraida = peticao_corrigida_bruta
-
-        peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-        logger.info("--- Pós-correção aplicada.")
-
-    logger.info("--- Calculando diferenças...")
-    diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-    logger.info("--- Diferenças calculadas.")
-
-    correcao_completa_formatada = aviso_validacao + analise_formatada
-    resultado_historico = {
-        "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "tipo_peticao": tipo_peticao,
-        "caso": caso,
-        "peticao_original": peticao_conteudo,
-        "analise_formatada": correcao_completa_formatada,
-        "peticao_corrigida": peticao_corrigida_final,
-        "resumo_diff": resumo_diff,
-        "criticas_diff": criticas_diff
-    }
-    HISTORICO.append(resultado_historico)
-    if len(HISTORICO) > 10:
-        HISTORICO.pop(0)
-
-    CORRECAO_CACHE[cache_key] = {
-        "analise_formatada": correcao_completa_formatada,
-        "peticao_original": peticao_conteudo,
-        "peticao_corrigida": peticao_corrigida_final,
-        "resumo_diff": resumo_diff,
-        "criticas_diff": criticas_diff,
-    }
-
-    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 ---
-def formatar_correcao(texto):
-    texto = texto.replace("### Análise Geral", "## 📝 Análise Geral")
-    texto = texto.replace("### Nota Final", "## ⭐ Nota Final")
-    texto = texto.replace("### Pontos Positivos", "## ✅ Pontos Positivos")
-    texto = texto.replace("### Pontos a Melhorar", "## ⚠️ Pontos a Melhorar")
-    texto = texto.replace("### Análise Específica dos Requisitos", "## 🔎 Análise Específica dos Requisitos")
-
-    linhas = texto.split('\n')
-    linhas_formatadas = []
-    in_list = False
-    for linha in linhas:
-        linha_strip = linha.strip()
-        if linha_strip.startswith("1.") or linha_strip.startswith("2.") or linha_strip.startswith("3.") or linha_strip.startswith("4.") or linha_strip.startswith("5."):
-             linhas_formatadas.append(f"\n**{linha_strip}**")
-             in_list = False
-        elif linha_strip.startswith("- ") or linha_strip.startswith("* "):
-             prefix = "  * " if in_list else "* "
-             linhas_formatadas.append(prefix + linha_strip[2:])
-             in_list = True
-        elif linha_strip.startswith("a)") or linha_strip.startswith("b)") or linha_strip.startswith("c)") or linha_strip.startswith("d)") or linha_strip.startswith("e)"):
-             linhas_formatadas.append(f"    * {linha_strip}")
-             in_list = True
-        else:
-            linhas_formatadas.append(linha)
-            if not linha_strip.startswith(("*", "- ", "a)", "b)", "c)", "d)", "e)"," ")):
-                 in_list = False
-
-    texto_final = "\n".join(linhas_formatadas)
-    nota_pattern = r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})"
-    match = re.search(nota_pattern, texto_final, re.IGNORECASE)
-    if match:
-        nota = match.group(2).replace(",",".")
-        texto_final = re.sub(nota_pattern, f"\\1**{nota}/10**", texto_final, count=1, flags=re.IGNORECASE)
-
-    return texto_final
-
-def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    if not texto_peticao or not texto_peticao.strip():
-        return "Digite algo na petição para receber dicas..."
-
-    dicas_relevantes = []
-    texto_lower = texto_peticao.lower()
-
-    for chave, dica in DICAS_OAB_MELHORADO.items():
-         if chave in ["Clareza e Concisão", "Fundamentação Legal", "Coerência Argumentativa", "Revisão Ortográfica e Gramatical", "Formatação"]:
-              dicas_relevantes.append(f"💡 **{chave}:** {dica}")
-
-    keywords_por_tipo = {
-        "Petição Inicial": ["endereçamento", "qualificação", "fatos", "fundamentos", "pedidos", "valor da causa", "provas", "audiência", "citação", "custas"],
-        "Contestação": ["preliminar", "mérito", "impugnação", "fatos", "improcedência", "provas", "honorários"],
-        "Reconvenção": ["reconvinte", "reconvindo", "conexão", "pedidos reconvencionais"],
-        "Impugnação à Contestação": ["réplica", "preliminar", "fatos novos", "documentos", "ratifica"],
-        "Embargos de Declaração": ["omissão", "contradição", "obscuridade", "erro material", "decisão embargada"],
-        "Recurso de Apelação": ["sentença", "reforma", "anulação", "dialeticidade", "preparo", "tribunal", "razões"],
-        "Agravo de Instrumento": ["decisão interlocutória", "tribunal", "cabimento", "urgência", "efeito suspensivo", "peças obrigatórias"],
-        "Petição de Tutela Provisória": ["urgência", "evidência", "liminar", "periculum", "fumus boni", "probabilidade", "risco"],
-    }
-
-    if tipo_peticao in keywords_por_tipo:
-         for keyword in keywords_por_tipo[tipo_peticao]:
-              if keyword in texto_lower:
-                   for chave, dica in DICAS_OAB_MELHORADO.items():
-                        chave_lower = chave.lower()
-                        if f"({tipo_peticao.split()[0].lower()})" in chave_lower or keyword in chave_lower:
-                            dica_formatada = f"💡 **{chave}:** {dica}"
-                            if dica_formatada not in dicas_relevantes:
-                                 dicas_relevantes.append(dica_formatada)
-
-    if not dicas_relevantes:
-        return "💡 Continue escrevendo ou selecione o tipo de peça para dicas mais específicas."
-
-    return "\n\n".join(dicas_relevantes[:5])
-
-def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith("⚠️") or texto_corrigido.startswith("❌"):
-        return "","",""
-
-    orig_lines = texto_original.splitlines()
-    corr_lines = texto_corrigido.splitlines()
-
-    diff = difflib.ndiff(orig_lines, corr_lines)
-
-    resultado_diff_html = []
-    criticas = []
-    linhas_removidas = 0
-    linhas_adicionadas = 0
-
-    keywords_criticas_removidas = ["invenção", "identificação", "erro crasso", "fundamento incorreto"]
-    keywords_criticas_adicionadas = ["custas", "art. 319", "art. 337", "art. 1022", "art. 1015", "art. 300", "fumus", "periculum", "pedido essencial", "preliminar obrigatória"]
-
-    for linha in diff:
-        texto = linha[2:]
-        texto_escaped = escape(texto)
-        if linha.startswith('  '):
-            resultado_diff_html.append(f"<div class='linha-igual'>{texto_escaped}</div>")
-        elif linha.startswith('- '):
-            linhas_removidas += 1
-            resultado_diff_html.append(f"<div class='linha-removida' title='Removido'><del>{texto_escaped}</del></div>")
-            if any(kw in texto.lower() for kw in keywords_criticas_removidas):
-                 criticas.append(f"<span style='color: red;'>🔴 REMOVIDO (Potencialmente Crítico):</span> {texto_escaped}")
-        elif linha.startswith('+ '):
-            linhas_adicionadas += 1
-            resultado_diff_html.append(f"<div class='linha-adicionada' title='Adicionado'><ins>{texto_escaped}</ins></div>")
-            if any(kw in texto.lower() for kw in keywords_criticas_adicionadas):
-                 criticas.append(f"<span style='color: green;'>🟢 ADICIONADO (Potencialmente Essencial):</span> {texto_escaped}")
-
-    resumo_estatistico = f"""
-**Resumo das Mudanças:**
-*   Linhas Removidas: {linhas_removidas}
-*   Linhas Adicionadas: {linhas_adicionadas}
-*   **Diferença Líquida:** {linhas_adicionadas - linhas_removidas} linhas
-"""
-
-    criticas_texto = "### 🚨 Mudanças Críticas / Essenciais Identificadas:\n" + "\n".join(criticas) if criticas else "Nenhuma mudança crítica/essencial automaticamente detectada."
-
-    css = """
-<style>
-.diff-container { font-family: monospace; white-space: pre-wrap; border: 1px solid #ccc; padding: 10px; background-color: #f9f9f9; }
-.linha-igual { color: #555; }
-.linha-removida { background-color: #ffebee; color: #c62828; text-decoration: line-through; }
-.linha-adicionada { background-color: #e8f5e9; color: #2e7d32; }
-.linha-removida del, .linha-adicionada ins { text-decoration: none; padding: 1px 3px; border-radius: 3px; }
-.linha-removida del { background-color: #ffcdd2; }
-.linha-adicionada ins { background-color: #c8e6c9; }
-.linha-info { color: #0277bd; font-style: italic; }
-</style>
-"""
-    visualizacao_detalhada_html = f"{css}<div class='diff-container'>{''.join(resultado_diff_html)}</div>"
-
-    return visualizacao_detalhada_html, resumo_estatistico, criticas_texto
-
-def calcular_progresso():
-    if not HISTORICO:
-        return "📊 Nenhum progresso registrado ainda."
-
-    notas = []
-    tipos_corrigidos = set()
-    for entry in HISTORICO:
-        tipos_corrigidos.add(entry["tipo_peticao"])
-        nota_str = "N/A"
-        match = re.search(r"\*\*(\d{1,2}[,.]\d{1}|\d{1,2})/10\*\*", entry["analise_formatada"])
-        if match:
-            try:
-                nota = float(match.group(1).replace(",", "."))
-                notas.append(nota)
-                nota_str = f"{nota:.1f}"
-            except ValueError:
-                pass
-
-    total_corridas = len(HISTORICO)
-    media = sum(notas) / len(notas) if notas else 0
-    tendencia = ""
-    if len(notas) > 1:
-        if notas[-1] > notas[-2]:
-             tendencia = "⬆️ Melhorando"
-        elif notas[-1] < notas[-2]:
-             tendencia = "⬇️ Piorando"
-        else:
-             tendencia = "↔️ Estável"
-
-    progresso_texto = f"""
-**📊 Resumo do Progresso:**
-*   **Total de Correções:** {total_corridas}
-*   **Tipos de Peças Corrigidas:** {', '.join(sorted(list(tipos_corrigidos)))}
-*   **Média das Notas (quando aplicável):** {media:.1f}/10 (de {len(notas)} notas válidas)
-*   **Tendência da Última Nota:** {tendencia if tendencia else 'N/A'}
-"""
-    return progresso_texto
-
-def mostrar_historico():
-    if not HISTORICO:
-        return "📜 Histórico vazio."
-
-    historico_md = "### 📜 Histórico de Correções (Últimas 10)\n\n---\n"
-    for i, entry in enumerate(reversed(HISTORICO)):
-        caso_resumo = (entry['caso'][:80] + '...') if len(entry['caso']) > 80 else entry['caso']
-        nota_str = "N/A"
-        match = re.search(r"\*\*(\d{1,2}[,.]\d{1}|\d{1,2})/10\*\*", entry["analise_formatada"])
-        if match:
-             nota_str = f"{match.group(1).replace(',', '.')}/10"
-
-        historico_md += f"**{len(HISTORICO)-i}. Data:** {entry['data']}\n"
-        historico_md += f"**Tipo:** {entry['tipo_peticao']}\n"
-        historico_md += f"**Nota:** {nota_str}\n"
-        historico_md += f"**Caso:** _{caso_resumo}_\n"
-        historico_md += "---\n"
-    return historico_md
-
-def salvar_progresso(caso, peticao, tipo_peticao):
-    logger.info(">>> SALVAR PROGRESSO INICIADO")
-    try:
-        if not caso or not peticao or not tipo_peticao:
-            logger.warning("--- Inputs insuficientes para salvar progresso.")
-            return "", "⚠️ Caso, Petição e Tipo de Petição são necessários para salvar.", None
-
-        dados_progresso = {
-            "tipo_peticao": tipo_peticao,
-            "caso": caso,
-            "peticao": peticao,
-            "timestamp": datetime.now().isoformat()
-        }
-
-        json_content = json.dumps(dados_progresso, ensure_ascii=False, indent=4)
-        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"progresso_peticao_{timestamp_str}.json"
-        temp_dir = tempfile.gettempdir()
-        temp_file_path = os.path.join(temp_dir, filename)
-
-        with open(temp_file_path, 'w', encoding='utf-8') as f:
-            f.write(json_content)
-
-        logger.info(f"--- Progresso salvo com sucesso no arquivo temporário: {temp_file_path}")
-        success_message = (
-            f"✅ Progresso salvo! Baixe o arquivo `{filename}`. "
-            "Use o botão 'Carregar Progresso' e selecione este arquivo para restaurar."
-        )
-        logger.info("<<< SALVAR PROGRESSO FINALIZADO COM SUCESSO")
-        # Retorna o path para o componente gr.File poder oferecer o download
-        return json_content, success_message, temp_file_path
-
-    except Exception as e:
-        logger.error(f"Erro ao salvar progresso: {str(e)}", exc_info=True)
-        logger.info("<<< SALVAR PROGRESSO FINALIZADO COM ERRO")
-        # Retorna None para o path do arquivo em caso de erro
-        return "", f"❌ Erro ao salvar o progresso: {str(e)}", None
-
-def carregar_progresso(arquivo_entrada):
-    logger.info(">>> CARREGAR PROGRESSO INICIADO")
-    if arquivo_entrada is None:
-        logger.warning("--- Nenhum arquivo selecionado para carregar.")
-        return "", "", "", "⚠️ Nenhum arquivo selecionado para carregar."
-
-    try:
-        file_path = arquivo_entrada.name
-        logger.info(f"--- Carregando progresso do arquivo: {file_path}")
-
-        with open(file_path, 'r', encoding='utf-8') as f:
-            dados = json.load(f)
-
-        caso = dados.get("caso")
-        peticao = dados.get("peticao")
-        tipo_peticao = dados.get("tipo_peticao")
-
-        if caso is None or peticao is None or tipo_peticao is None:
-             logger.warning(f"--- Arquivo JSON carregado não contém as chaves esperadas: {dados.keys()}")
-             return "", "", "", "❌ Erro: Arquivo de progresso inválido ou incompleto."
-
-        if tipo_peticao not in TIPOS_DE_PETICAO:
-             logger.warning(f"--- Tipo de petição '{tipo_peticao}' do arquivo não é válido.")
-             # Retorna os dados carregados, mas deixa o dropdown vazio para seleção manual
-             return gr.update(value=None), caso, peticao, f"⚠️ Tipo de petição '{tipo_peticao}' do arquivo não é mais válido. Selecione manualmente."
-
-        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM SUCESSO")
-        # Retorna os valores corretos para atualizar os componentes
-        return tipo_peticao, caso, peticao, "✅ Progresso carregado com sucesso!"
-
-    except json.JSONDecodeError:
-        logger.error(f"Erro ao decodificar JSON do arquivo: {file_path}")
-        return "", "", "", "❌ Erro: Arquivo selecionado não é um JSON válido."
-    except Exception as e:
-        logger.error(f"Erro ao carregar o progresso: {str(e)}", exc_info=True)
-        logger.info("<<< CARREGAR PROGRESSO FINALIZADO COM ERRO")
-        return "", "", "", f"❌ Erro inesperado ao carregar o progresso: {str(e)}"
-
-# --- 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:
-        logger.error("--- Tipo de petição não selecionado para gerar caso.")
-        return "Erro: Tipo de petição não selecionado para gerar caso."
-    prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-    logger.info("--- Prompt de geração de caso estruturado.")
-    caso_gerado = chamar_api(prompt)
-    logger.info(f"--- Resultado da chamada API para gerar caso: {caso_gerado[:100]}...")
-
-    if caso_gerado.startswith("❌") or caso_gerado.startswith("⏱️") or caso_gerado.startswith("⚠️"):
-        logger.error(f"--- Erro ao gerar caso fictício: {caso_gerado}")
-        return f"Falha ao gerar caso fictício.\n{caso_gerado}"
-
-    frase_final_padrao = f"**Situação-Problema:** Na qualidade de advogado(a) de"
-    if frase_final_padrao.lower() not in caso_gerado.lower():
-        logger.warning("--- Frase 'Situação-Problema' não encontrada. Adicionando manualmente.")
-        nomes_possiveis = re.findall(r"[A-Z][a-z]+(?:\s[A-Z][a-z]+)+", caso_gerado)
-        cliente_nome = nomes_possiveis[0] if nomes_possiveis else "[Cliente]"
-        caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente_nome}, elabore a peça processual cabível ({tipo_peticao})."
-
-    logger.info("<<< GERAR CASO FICTICIO FINALIZADO COM SUCESSO")
-    return caso_gerado
-
-# --- Validação Básica ---
-def validar_peticao_basica(peticao):
-    problemas = []
-    peticao_lower = peticao.lower()
-    if "excelentíssimo" not in peticao_lower and "eméritos" not in peticao_lower and "meritíssimo" not in peticao_lower :
-        problemas.append("Endereçamento inicial parece ausente ou incompleto.")
-    if "valor da causa" not in peticao_lower and "valor à causa" not in peticao_lower:
-        problemas.append("Atribuição de Valor da Causa não encontrada (essencial na Inicial).")
-    if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower :
-        problemas.append("Pedido de juntada de custas ou gratuidade de justiça não encontrado (essencial na Inicial).")
-    if "nestes termos" not in peticao_lower and "pede deferimento" not in peticao_lower:
-        problemas.append("Fechamento formal padrão ('Nestes termos pede deferimento') parece ausente.")
-    return problemas
-
-# --- Interface Gradio ---
-def interface_gradio():
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange")) as demo:
-        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")
-                tipo_peticao_input = gr.Dropdown(
-                    label="Selecione o Tipo de Peça Processual",
-                    choices=TIPOS_DE_PETICAO,
-                    value="Petição Inicial"
-                )
-                modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento (Feedback Detalhado)", value=False)
-
-                with gr.Accordion("⚙️ Configurações Avançadas", open=False):
-                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade (Temperatura)")
-                    timeout_slider = gr.Slider(minimum=30, maximum=180, value=CONFIG["timeout"], step=10, label="Timeout da API (segundos)")
-                    max_tokens_slider = gr.Slider(minimum=2048, maximum=8192, value=CONFIG["max_tokens"], step=256, label="Tamanho Máx. Resposta (Tokens)")
-                    def atualizar_config(temp, timeout, tokens):
-                        CONFIG["temperatura"] = temp
-                        CONFIG["timeout"] = timeout
-                        CONFIG["max_tokens"] = tokens
-                        logger.info(f"Configurações atualizadas: Temp={temp}, Timeout={timeout}, Tokens={tokens}")
-                        return f"✅ Configs Atualizadas!"
-                    config_update_btn = gr.Button("💾 Salvar Configs da Sessão")
-                    config_status = gr.Textbox(label="Status Config", interactive=False)
-                    config_update_btn.click(atualizar_config, inputs=[temperatura_slider, timeout_slider, max_tokens_slider], outputs=config_status)
-
-                with gr.Accordion("📊 Dashboard de Progresso", open=False):
-                    progresso_output = gr.Markdown("Clique em 'Atualizar Progresso' para ver suas estatísticas.")
-                    progresso_btn = gr.Button("🔄 Atualizar Progresso")
-
-                with gr.Accordion("📜 Histórico da Sessão", open=False):
-                    historico_output = gr.Markdown("Clique em 'Ver Histórico' para ver suas últimas correções.")
-                    historico_btn = gr.Button("🔄 Ver Histórico")
-
-                with gr.Accordion("💾/📂 Salvar/Carregar Progresso Atual", open=False):
-                     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):
-                gr.Markdown("### 1. Forneça o Caso / Contexto")
-                with gr.Row():
-                     caso_input = gr.Textbox(label="📋 Caso ou Situação Processual", lines=10, placeholder="Insira o texto COMPLETO do caso ou da situação (ex: resumo da inicial para contestação, decisão para embargos/recurso).")
-                     caso_btn = gr.Button("🎲 Gerar Caso Fictício", variant="secondary", scale=0)
-
-                gr.Markdown("### 2. Insira Sua Peça Processual")
-                with gr.Tabs():
-                    with gr.TabItem("✏️ Digitar Texto"):
-                        peticao_texto_input = gr.Textbox(label="Texto da Peça", lines=15, placeholder="Cole ou digite sua peça processual aqui...")
-                        dica_contextual_output = gr.Markdown(value="*Dicas aparecerão aqui enquanto você digita...*")
-                        btn_corrigir = gr.Button("🚀 CORRIGIR E ANALISAR!", variant="primary")
-
-                    with gr.TabItem("📎 Anexar Arquivo"):
-                        peticao_arquivo_input = gr.File(label="Arquivo da Peça (.pdf, .docx, .txt - Máx 15MB)", file_types=[".pdf", ".docx", ".txt"], file_count="single")
-                        arquivo_preview_output = gr.Textbox(label="🔍 Prévia do Conteúdo do Arquivo (Texto Extraído)", lines=5, interactive=False)
-                        btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR E ANALISAR ARQUIVO!", variant="primary")
-
-        processing_message = gr.Markdown("", visible=False)
-
-        with gr.Tabs():
-             with gr.TabItem("📊 Análise e Correção"):
-                  gr.Markdown("### 3. Resultados da Análise")
-                  resultado_analise_output = gr.Markdown(label="Análise Detalhada e Nota")
-
-                  gr.Markdown("### ✨ Versão Sugerida (Corrigida/Aprimorada)")
-                  resultado_peticao_corrigida_output = gr.Textbox(label="Peça Processual Corrigida", lines=20, show_copy_button=True)
-
-             with gr.TabItem("⚖️ Comparativo (Diff)"):
-                  gr.Markdown("### ↔️ Comparativo: Sua Peça vs. Versão Sugerida")
-                  with gr.Row():
-                       with gr.Column(scale=1):
-                            resumo_alteracoes_output = gr.Markdown(label="Resumo das Mudanças")
-                            criticas_output = gr.Markdown(label="Mudanças Críticas/Essenciais")
-                       with gr.Column(scale=3):
-                            visualizacao_detalhada_output = gr.HTML(label="📝 Alterações Detalhadas (Diff)")
-
-        clear_btn = gr.Button("🗑️ Limpar Tudo")
-
-        # --- 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 (6 outputs)
-                return f"❌ Erro interno no processamento: {e}", "", "", "", "", ""
-            logger.info("<<< WRAPPER TEXTO FINALIZADO")
-            return resultado
-
-        def corrigir_peticao_wrapper_arquivo(caso, tipo_peticao, peticao_texto_state, peticao_arquivo):
-            logger.info(">>> WRAPPER ARQUIVO INICIADO")
-            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 (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 ---
-
-        caso_btn.click(
-             fn=gerar_caso_ficticio,
-             inputs=[tipo_peticao_input],
-             outputs=[caso_input],
-             show_progress="full"
-        )
-
-        peticao_texto_input.change(
-             fn=fornecer_dica_contextual,
-             inputs=[peticao_texto_input, tipo_peticao_input],
-             outputs=dica_contextual_output
-        )
-        tipo_peticao_input.change(
-             fn=fornecer_dica_contextual,
-             inputs=[peticao_texto_input, tipo_peticao_input],
-             outputs=dica_contextual_output
-        )
-
-        peticao_arquivo_input.change(
-             fn=process_file,
-             inputs=[peticao_arquivo_input],
-             outputs=[arquivo_preview_output],
-             show_progress="minimal"
-        )
-
-        # 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,
-            outputs=[processing_message],
-            show_progress=False
-        ).then(
-            fn=corrigir_peticao_wrapper_texto,
-            inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None)],
-            # 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(
-            fn=lambda: gr.update(value="", visible=False),
-            inputs=None,
-            outputs=[processing_message]
-        )
-
-        # 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,
-            outputs=[processing_message],
-            show_progress=False
-        ).then(
-            fn=corrigir_peticao_wrapper_arquivo,
-            inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input],
-            # 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(
-            fn=lambda: gr.update(value="", visible=False),
-            inputs=None,
-            outputs=[processing_message]
-        )
-
-        # Botão Limpar - Usando gr.update()
-        clear_btn.click(
-            fn=lambda: [
-                gr.update(value="Petição Inicial"),
-                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 valor do arquivo de download
-            ],
-            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 # 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 - 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 (terceiro output) atualiza o valor do componente progresso_download_file
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file],
-             show_progress="minimal"
-        # REMOVIDO o .then() que mexia com a visibilidade
-        ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
-        )
-
-        carregar_btn.click(
-             fn=lambda: gr.update(value="⏳ Carregando progresso do arquivo...", visible=True),
-             inputs=None, outputs=processing_message, show_progress=False
-        ).then(
-             fn=carregar_progresso,
-             inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status],
-             show_progress="minimal"
-         ).then(
-            lambda: gr.update(value="", visible=False), None, processing_message
-        )
-
-    return demo
-
-# --- Bloco de Execução Principal ---
-if __name__ == "__main__":
-    logger.info("Iniciando a aplicação Gradio...")
-    try:
-        version = pytesseract.get_tesseract_version()
-        logger.info(f"Tesseract versão {version} detectado.")
-    except Exception as e:
-         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.launch()
-    logger.info("Aplicação Gradio encerrada.")