Update app.py

app.py

@@ -1,8 +1,5 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
-# import requests # Não é mais necessário para a API
-import google.generativeai as genai # Importa a biblioteca oficial
-from google.api_core import exceptions as google_exceptions # Para tratar erros da API
 import os
 import json
 import docx
@@ -27,36 +24,20 @@ from html import escape
 import random
 import logging
 import traceback
-import re
+import google.generativeai as genai
+from google.api_core.exceptions import ResourceExhausted, GoogleAPIError
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - [%(funcName)s] - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Carregar Variáveis de Ambiente e Configurar API Key
+# Carrega a chave da API
 load_dotenv()
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.environ.get("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
     raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a no arquivo .env ou como Secret no Hugging Face.")
 
-try:
-    genai.configure(api_key=GEMINI_API_KEY)
-    logger.info("Biblioteca google-generativeai configurada com sucesso.")
-except Exception as e:
-    raise ValueError(f"❌ Erro ao configurar a biblioteca google-generativeai: {e}")
-
-# Constantes e Configurações Globais
-GEMINI_MODEL_NAME = "gemini-1.5-flash-latest" # Modelo a ser usado pela biblioteca
-CONFIG = {"max_retry_attempts": 3, "retry_delay": 5, "timeout_api": 120, "temperatura": 0.3, "max_tokens": 8192} # Timeout não é mais direto na chamada da lib, mas mantemos para retries
-rate_limiter = RateLimiter(max_calls=15, period=60) # Reduzir ainda mais para segurança
-
-# Configurações de Segurança (ajuste conforme necessário)
-# Bloqueia conteúdo de risco ALTO em todas as categorias
-SAFETY_SETTINGS = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
-]
+CONFIG = {"max_retry_attempts": 5, "retry_delay": 10, "timeout": 120, "temperatura": 0.3, "max_tokens": 8192}
+rate_limiter = RateLimiter(max_calls=20, period=60)
 
 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"]
 
@@ -73,8 +54,6 @@ DICAS_OAB_MELHORADO = {
 HISTORICO = []
 CORRECAO_CACHE = {}
 
-# --- Funções Auxiliares (Extração de Texto, Preprocessamento, etc.) ---
-# (Mantidas como na versão anterior, sem alterações significativas)
 def preprocess_image_for_ocr(img_pil):
     if not CV2_AVAILABLE:
         logger.warning("OpenCV não disponível, usando conversão simples para OCR.")
@@ -88,78 +67,127 @@ def preprocess_image_for_ocr(img_pil):
         return img_pil.convert('L')
 
 def extract_text_from_pdf(file_path_or_obj):
-    text = ""; ocr_text_parts = []
+    text = ""
+    ocr_text_parts = []
     try:
         logger.info(f"Abrindo PDF: {getattr(file_path_or_obj, 'name', file_path_or_obj)}")
-        with pdfplumber_open(file_path_or_obj) as pdf:
-            logger.info(f"PDF com {len(pdf.pages)} páginas.")
-            for i, page in enumerate(pdf.pages):
-                page_text = page.extract_text(x_tolerance=2, y_tolerance=2)
-                if page_text and len(page_text.strip()) > 20: text += page_text + "\n"
-                else:
-                    logger.warning(f"Página {i+1} sem texto, tentando OCR.")
-                    try:
-                        img = page.to_image(resolution=200)
-                        preprocessed_img = preprocess_image_for_ocr(img.original)
-                        page_ocr = pytesseract.image_to_string(preprocessed_img, lang='por', config='--psm 6')
-                        if page_ocr and page_ocr.strip(): ocr_text_parts.append(page_ocr)
-                        else: logger.warning(f"OCR vazio pág {i+1}."); ocr_text_parts.append(f"[OCR P{i+1}: Vazio]")
-                    except Exception as e: logger.error(f"Erro OCR pág {i+1}: {e}"); ocr_text_parts.append(f"[Erro OCR P{i+1}: {e}]")
+        pdf_reader = pdfplumber_open(file_path_or_obj)
+        logger.info(f"PDF com {len(pdf_reader.pages)} páginas.")
+        for i, page in enumerate(pdf_reader.pages):
+            page_text = page.extract_text(x_tolerance=2, y_tolerance=2)
+            if page_text and len(page_text.strip()) > 20:
+                text += page_text + "\n"
+            else:
+                logger.warning(f"Página {i+1} sem texto significativo extraído, tentando OCR.")
+                try:
+                    img = page.to_image(resolution=200)
+                    preprocessed_img = preprocess_image_for_ocr(img.original)
+                    page_ocr_text = pytesseract.image_to_string(preprocessed_img, lang='por', config='--psm 6')
+                    if page_ocr_text and page_ocr_text.strip():
+                        ocr_text_parts.append(page_ocr_text)
+                    else:
+                        logger.warning(f"OCR retornou vazio para a página {i+1}.")
+                        ocr_text_parts.append(f"[OCR Página {i+1}: Vazio ou falhou]")
+                except Exception as ocr_e:
+                    logger.error(f"Erro no OCR da página {i+1}: {str(ocr_e)}")
+                    ocr_text_parts.append(f"[Erro OCR Página {i+1}: {str(ocr_e)}]")
+        pdf_reader.close()
         ocr_text = "\n".join(ocr_text_parts)
-        len_text, len_ocr = len(text.strip()), len(ocr_text.strip())
-        if len_text > len_ocr * 0.7: logger.info(f"Usando texto extraído PDF ({len_text} chars)."); return text
-        elif len_ocr > 0: logger.info(f"Usando texto OCR PDF ({len_ocr} chars)."); return ocr_text
-        elif len_text > 0: logger.info("Usando texto extraído curto PDF."); return text
-        else: logger.warning("PDF sem texto extraível."); return "⚠️ PDF sem texto (extração e OCR falharam)."
-    except Exception as e: logger.error(f"Erro PDF: {e}", exc_info=True); return f"❌ Erro PDF: {e}"
+        if text.strip() and len(text) > len(ocr_text) * 0.7:
+            logger.info(f"Usando texto extraído do PDF ({len(text)} chars).")
+            return text
+        elif ocr_text.strip():
+            logger.info(f"Usando texto do OCR do PDF ({len(ocr_text)} chars).")
+            return ocr_text
+        elif text.strip():
+            logger.info("Usando texto extraído curto como fallback.")
+            return text
+        else:
+            logger.warning("Não foi possível extrair texto significativo do PDF.")
+            return "⚠️ Não foi possível extrair texto do PDF (extração e OCR falharam)."
+    except Exception as e:
+        logger.error(f"Erro geral ao processar o PDF: {str(e)}", exc_info=True)
+        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 = "\n".join([p.text for p in doc.paragraphs if p.text])
-        return text if text.strip() else "⚠️ DOCX vazio."
-    except Exception as e: logger.error(f"Erro DOCX: {e}", exc_info=True); return f"❌ Erro DOCX: {e}"
+        text = "\n".join([para.text for para in doc.paragraphs if para.text])
+        return text if text.strip() else "⚠️ Documento DOCX vazio ou sem texto."
+    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:
-        content = b''; encodings = ['utf-8', 'latin-1', 'cp1252']
+        content = b''
         if isinstance(file_path_or_obj, str):
-            with open(file_path_or_obj, 'rb') as f: content = f.read()
+            with open(file_path_or_obj, 'rb') as f:
+                content = f.read()
         elif hasattr(file_path_or_obj, 'read'):
-            if hasattr(file_path_or_obj, 'seek'): try: file_path_or_obj.seek(0) except: pass
+            if hasattr(file_path_or_obj, 'seek') and callable(file_path_or_obj.seek):
+                try:
+                    file_path_or_obj.seek(0)
+                except Exception as seek_e:
+                    logger.warning(f"Não foi possível resetar ponteiro do arquivo: {seek_e}")
             content = file_path_or_obj.read()
-        else: return "❌ Input TXT inválido."
-        for enc in encodings:
-            try: decoded = content.decode(enc); logger.info(f"TXT decodificado: {enc}."); return decoded if decoded.strip() else "⚠️ TXT vazio."
-            except UnicodeDecodeError: continue
-        return "❌ Não foi possível decodificar TXT."
-    except Exception as e: logger.error(f"Erro TXT: {e}", exc_info=True); return f"❌ Erro TXT: {e}"
+        else:
+            return "❌ Tipo de entrada TXT inválido."
+        encodings = ['utf-8', 'latin-1', 'cp1252']
+        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):
-    if file_obj is None: return "⚠️ Nenhum arquivo enviado."
+    logger.info(f"process_file chamado com: {file_obj}")
+    if file_obj is None:
+        logger.warning("Nenhum arquivo fornecido")
+        return "⚠️ Nenhum arquivo enviado."
     try:
-        fpath = getattr(file_obj, 'name', None);
-        if not fpath: return "❌ Erro: Não identificou arquivo."
-        fname = os.path.basename(fpath).lower(); logger.info(f"Processando: {fname}")
+        file_path = getattr(file_obj, 'name', None)
+        if not file_path:
+            logger.error("Não foi possível obter o nome do arquivo (file_obj.name está ausente).")
+            return "❌ Erro: Não foi possível identificar o arquivo enviado."
+        filename = os.path.basename(file_path).lower()
+        logger.info(f"Processando arquivo: {filename}")
         try:
-             fsize = os.path.getsize(fpath); logger.info(f"Tamanho: {fsize} bytes")
-             if fsize > 15*1024*1024: return "⚠️ Arquivo grande (Máx 15MB)."
-        except OSError as e: logger.warning(f"Erro tamanho arquivo: {e}")
-        if fname.endswith('.pdf'): return extract_text_from_pdf(fpath)
-        elif fname.endswith('.docx'): return extract_text_from_docx(fpath)
-        elif fname.endswith('.txt'): return extract_text_from_txt(fpath)
-        else: return "⚠️ Formato não suportado (PDF, DOCX, TXT)."
-    except Exception as e: logger.error(f"Erro process_file: {e}", exc_info=True); return f"❌ Erro processar arquivo: {e}"
-
-# --- Estruturação de Prompts (sem alterações) ---
+            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} ({file_size} bytes) excede o limite de 15MB.")
+                return "⚠️ Arquivo muito grande (Máx 15MB)."
+        except OSError as size_e:
+            logger.warning(f"Não foi possível verificar o tamanho do arquivo: {size_e}")
+        if filename.endswith('.pdf'):
+            return extract_text_from_pdf(file_path)
+        elif filename.endswith('.docx'):
+            return extract_text_from_docx(file_path)
+        elif filename.endswith('.txt'):
+            return extract_text_from_txt(file_path)
+        else:
+            logger.warning(f"Formato de arquivo não suportado: {filename}")
+            return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
+    except Exception as e:
+        logger.error(f"Erro GERAL ao processar o arquivo '{getattr(file_obj, 'name', 'N/A')}': {str(e)}", exc_info=True)
+        return f"❌ Erro inesperado ao processar o arquivo: {str(e)}"
+
 def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
     base = """
     **Estrutura da Avaliação:**
-    1.  **Análise Geral:** Visão geral concisa (2-3 linhas).
-    2.  **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE.
-    3.  **Pontos Positivos:** Liste 2-3 aspectos bem executados, com justificativa.
-    4.  **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade. Para cada: Descrição, Fundamentação legal, Impacto na nota, Sugestão.
-    5.  **Análise Específica dos Requisitos:** Avalie os itens chave da peça.
+    1. **Análise Geral:** Visão geral concisa (2-3 linhas).
+    2. **Nota Final:** 0 a 10 (uma casa decimal), com justificativa BREVE.
+    3. **Pontos Positivos:** Liste 2-3 aspectos bem executados, com justificativa.
+    4. **Pontos a Melhorar:** Liste **TODOS** os problemas em ordem de gravidade. Para cada: Descrição, Fundamentação legal, Impacto na nota, Sugestão.
+    5. **Análise Específica dos Requisitos:** Avalie os itens chave da peça.
     **Critérios Fundamentais:** Coerência, Fundamentação, Linguagem, Pedidos. **NÃO INVENTAR FATOS** (-3 a -5). **NÃO SE IDENTIFICAR** (Nota ZERO)."""
     if modo_treinamento:
         base += """
@@ -168,140 +196,165 @@ def get_instrucoes_gerais_avaliacao(modo_treinamento=False):
 
 def estruturar_prompt_analise(caso, peticao, tipo_peticao, modo_treinamento=False):
     instrucoes_gerais = get_instrucoes_gerais_avaliacao(modo_treinamento)
-    prompt = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos Específicos ({tipo_peticao}):**\n"
-    # (Adicionar requisitos específicos por tipo como antes - omitido por brevidade)
-    if tipo_peticao == "Petição Inicial": prompt += "- Endereçamento/competência...\n**Critérios Adicionais:** Usar 'XXX'..."
-    elif tipo_peticao == "Contestação": prompt += "- Endereçamento...\n**Critérios Adicionais:** Preliminar não arguida..."
-    # ... (outros tipos) ...
-    else: prompt += "- Adequação tipo? Clareza? Fundamentação? Pedido?"
-    prompt += "\n\n**Instruções Finais:** Analise estritamente. Seja rigoroso e construtivo. Gere **exclusivamente** no formato solicitado."
-    return prompt
+    prompt_especifico = f"## Análise: {tipo_peticao}\n**Caso:**\n```\n{caso}\n```\n**Peça Aluno:**\n```\n{peticao}\n```\n{instrucoes_gerais}\n**Requisitos Específicos ({tipo_peticao}):**\n"
+    if tipo_peticao == "Petição Inicial":
+        prompt_especifico += "- Endereçamento/competência (Art. 319, I; CDC 101, I).\n- Qualificação (Art. 319, II).\n- Fatos.\n- Fundamentação (Art. 319, III).\n- Pedidos (Art. 319, IV).\n- Valor causa (Art. 291-292, 319, V).\n- Provas (Art. 319, VI).\n- Audiência (Art. 319, VII).\n- Citação.\n- Docs essenciais (procuração, custas/JG).\n- Fechamento.\n**Critérios Adicionais:** Usar 'XXX'. Falta custas/JG (-1.0). Vírgula em 'pede deferimento' (-0.2). Foro consumidor OK."
+    elif tipo_peticao == "Contestação":
+        prompt_especifico += "- Endereçamento. Qualificação réu. Processo nº. Tempestividade.\n- **Preliminares (Art. 337):** TODAS aplicáveis.\n- **Impugnação Específica Fatos (Art. 341):** PONTO A PONTO.\n- **Mérito:** Versão réu; defesa direta/indireta (fatos impeditivos/modificativos/extintivos).\n- Fundamentação defesa.\n- **Pedidos:** Acolher preliminares; IMPROCEDÊNCIA TOTAL; Condenação sucumbência (Art. 85).\n- Provas. Fechamento.\n**Critérios Adicionais:** Preliminar não arguida preclui? Falha grave impugnação (-2 a -4). Ausência pedido improcedência (-1.5)."
+    elif tipo_peticao == "Reconvenção":
+        prompt_especifico += "- NA MESMA PEÇA da Contestação (Art. 343). Endereçamento. Processo nº.\n- Qualificação réu-reconvinte e autor-reconvindo.\n- **Conexão** (Art. 343).\n- **Estrutura PI:** Fatos, Fundamentos, Pedidos específicos, Valor causa, Provas (da reconvenção).\n- Pedido intimação autor-reconvindo (Art. 343, §1º).\n**Critérios Adicionais:** Sem conexão (-2.0). Falta pedido/valor/provas reconv. (-1.0/item). Peça separada (-3.0)."
+    elif tipo_peticao == "Impugnação à Contestação":
+        prompt_especifico += "- Endereçamento. Processo nº. Qualificação autor. Tempestividade (15d - Art. 350/351).\n- **Resposta Preliminares.**\n- **Resposta Fatos Novos** (Art. 350).\n- **Resposta Documentos** (Art. 437).\n- **Ratificação Inicial.**\n- **Especificação Provas** (contra defesa indireta/preliminares).\n- Pedidos: Rejeitar preliminares; refutar defesa; proceder inicial.\n**Critérios Adicionais:** Não responder preliminar (-1.5). Não manifestar fato novo (-2.0). Não ratificar (-0.5)."
+    elif tipo_peticao == "Embargos de Declaração":
+        prompt_especifico += "- **Contra Decisão Específica.** Endereçamento ao juízo prolator. Processo nº. Partes. Tempestividade (5d - Art. 1023).\n- **Cabimento (Art. 1022):** Apontar PRECISAMENTE: Omissão, Contradição, Obscuridade ou Erro Material.\n- **NÃO REJULGAR CAUSA.**\n- **Pedido:** Conhecimento e ACOLHIMENTO para sanar vício.\n**Critérios Adicionais:** Rediscutir mérito (-4.0). Não apontar vício (-3.0). Endereçar tribunal (-1.0)."
+    elif tipo_peticao == "Recurso de Apelação":
+        prompt_especifico += "- **Interposição:** Ao juízo a quo. Processo nº. Partes. Pressupostos (cabimento Art. 1009; tempestividade 15d; preparo/JG). Pedido recebimento/remessa.\n- **Razões:** Ao TRIBUNAL. Relato. **Fundamentos Reforma/Anulação (Art. 1010):** Error in procedendo/judicando. **Dialeticidade.**\n- **Pedidos:** Conhecimento; PROVIMENTO (anular/reformar); Inversão sucumbência.\n**Critérios Adicionais:** Falta peça (-10). Endereço razões (-1.0). Sem dialeticidade (-3 a -5). Sem pedido reforma/anulação (-1.5). Falta preparo/JG (-2.0)."
+    elif tipo_peticao == "Agravo de Instrumento":
+        prompt_especifico += "- Peça única ao TRIBUNAL. Processo origem. Partes e Advogados (endereços Art. 1016, IV). Cópia decisão agravada (Art. 1017, I).\n- **Cabimento (Art. 1015 / mitigada).** Tempestividade (15d). Preparo/JG.\n- **Peças Obrigatórias (Art. 1017, I):** Decisão, Intimação, Procurações. Facultativas (III).\n- **Razões (Art. 1016):** Motivos reforma/invalidação.\n- **Efeito Suspensivo / Tutela Antecipada Recursal (Art. 1019, I)** (se risco).\n- **Pedidos Finais:** Conhecimento; Efeito/Tutela (se aplicável); PROVIMENTO; Comunicação juiz.\n**Critérios Adicionais:** Falta peça obrigatória (-4.0). Sem cabimento (-3.0). Endereço juiz (-1.0). Sem advogados (-0.5)."
+    elif tipo_peticao == "Petição de Tutela Provisória":
+        prompt_especifico += "- Tipo (Urgência/Evidência). Caráter (Antecedente/Incidental). Endereçamento. Qualificação. Processo (se incidental).\n- **Tutela Urgência (Art. 300):** **Fumus Boni Iuris** E **Periculum in Mora**. **Reversibilidade** (Art. 300, §3º).\n- **Tutela Evidência (Art. 311):** Hipótese I a IV. **NÃO precisa periculum.**\n- **Pedido Específico:** Medida liminar CLARA.\n- **Se Antecedente (Art. 303/305):** Indicar pedido final ou aditar/apresentar inicial. Valor Causa.\n- **Pedidos:** Concessão tutela; citação/intimação; indicação ação/aditamento.\n**Critérios Adicionais:** Sem Fumus/Periculum (-3 a -5). Erro hipótese Evidência (-3.0). Pedido genérico (-2.0)."
+    else:
+        prompt_especifico += "- Adequação ao tipo? Clareza? Fundamentação Mínima? Pedido?"
+    prompt_especifico += "\n\n**Instruções Finais:** Analise estritamente com base no caso e critérios. Seja rigoroso mas construtivo. Gere **exclusivamente** no formato solicitado."
+    return prompt_especifico
 
 def estruturar_prompt_peticao_corrigida(caso, peticao_original, tipo_peticao):
-    prompt = f"**Caso:**\n```\n{caso}\n```\n**Peça Original ({tipo_peticao}):**\n```\n{peticao_original}\n```\n**Tarefa:** Gere versão corrigida ({tipo_peticao}), seguindo práticas OAB.\n**Instruções ({tipo_peticao}):**\n"
-    # (Adicionar instruções específicas por tipo como antes - omitido por brevidade)
-    if tipo_peticao == "Petição Inicial": prompt += "1.Endereçamento... 11.Fechamento ('Nestes termos...')..."
-    elif tipo_peticao == "Contestação": prompt += "1.Endereçamento... 7.Fechamento OAB."
-    # ... (outros tipos) ...
-    else: prompt += "1.Estrutura Lógica. 2.Argumentos. 3.Pedido. 4.Formalidades."
-    prompt += "\n\n**Instrução Final:** Gere **APENAS** texto da peça corrigida (endereçamento até 'OAB/...'). Sem comentários extras."
+    prompt = f"**Caso:**\n```\n{caso}\n```\n**Peça Original ({tipo_peticao}):**\n```\n{peticao_original}\n```\n**Tarefa:** Gere versão corrigida da peça ({tipo_peticao}), seguindo rigorosamente práticas OAB.\n**Instruções Específicas ({tipo_peticao}):**\n"
+    if tipo_peticao == "Petição Inicial":
+        prompt += "1.Endereçamento correto/fundamentado. 2.Qualificação completa (Art.319,II,'XXX'). 3.Fatos cronológicos/fiéis. 4.Fundamentação (artigos, súmulas). 5.Pedidos certos/determinados (quantificar). 6.Valor causa (Art.292). 7.Provas ('protesta provar...'). 8.Audiência (Art.319,VII). 9.Citação (Art.246,I). 10.Custas/JG (NÃO OMITIR). 11.Fechamento ('Nestes termos pede deferimento.', Local, data., ADVOGADO(A), OAB/...). NUNCA identificar."
+    elif tipo_peticao == "Contestação":
+        prompt += "1.Endereçamento juízo ação. 2.Identificação (proc. nº, réu). 3.Tempestividade. 4.Estrutura: Síntese Inicial; Preliminares (Art.337, fund.); Mérito (Impug. Específica + Defesa fund.); Reconvenção (se houver, antes pedidos cont.). 5.Pedidos Cont.: Acolher prelim.; IMPROCEDÊNCIA TOTAL; Sucumbência. 6.Provas réu. 7.Fechamento OAB."
+    elif tipo_peticao == "Reconvenção":
+        prompt += "**IMPORTANTE:** Gere como parte da Contestação.\n1.Após defesa mérito cont., ANTES pedidos cont.: Tópico 'DA RECONVENÇÃO'. 2.Qualificação Reconvinte/Reconvindo. 3.Conexão. 4.Fatos e Direito Reconvencionais. 5.Pedidos Reconv.: Claros contra autor-reconvindo. 6.Valor Causa e Provas Reconv. 7.Intimação autor-reconvindo. 8.Continue com Pedidos Contestação. 9.Fechamento OAB."
+    elif tipo_peticao == "Impugnação à Contestação":
+        prompt += "1.Endereçamento, proc, autor, tempestividade. 2.Tópico: DA(S) PRELIMINAR(ES) - Rebater. 3.Tópico: DO MÉRITO E FATOS NOVOS - Manifestar. 4.Tópico: DA RATIFICAÇÃO INICIAL. 5.Tópico: DAS PROVAS - Especificar. 6.Pedidos: Rejeitar prelim., refutar defesa, proceder inicial. 7.Fechamento OAB."
+    elif tipo_peticao == "Embargos de Declaração":
+        prompt += "1.Endereçamento juízo prolator. Proc, Partes. Decisão embargada ID. Tempestividade (5d). 2.Tópico para cada vício (Art.1022): DA OMISSÃO / DA CONTRADIÇÃO / DA OBSCURIDADE / DO ERRO MATERIAL. 3.Dentro: Transcrever trecho + explicar vício OBJETIVAMENTE. NÃO REJULGAR. 4.Pedido: Conhecimento e ACOLHIMENTO p/ sanar vício(s). 5.Fechamento OAB."
+    elif tipo_peticao == "Recurso de Apelação":
+        prompt += "1.Interposição: Juízo a quo. Proc, Partes. Pressupostos (cabim., temp., prep./JG). Pedido receb./remessa. 2.Razões: Tribunal. Relato. FUNDAMENTOS REFORMA/ANULAÇÃO (Error in proc./judic.). DIALETICIDADE. 3.Pedidos: Conhec.; PROVIMENTO (anular/reformar); Inversão sucumb. 4.Fechamento OAB."
+    elif tipo_peticao == "Agravo de Instrumento":
+        prompt += "1.Peça única Tribunal. Proc. origem, Partes, Advogados (endereços). Decisão agravada ID (juntar cópia). 2.CABIMENTO (Art.1015/mitig.). TEMPESTIVIDADE. PREPARO/JG. PEÇAS OBRIG./FACULT. 3.RAZÕES RECURSAIS: Motivos reforma/invalidação. 4.EFEITO SUSPENSIVO/TUTELA ANTECIPADA (se cabível). 5.PEDIDOS: Conhec.; Efeito/Tutela; PROVIMENTO; Comunicação juiz. 6.Fechamento OAB."
+    elif tipo_peticao == "Petição de Tutela Provisória":
+        prompt += "1.Indicar TIPO(Urg/Evid) e CARÁTER(Antec/Incid). Endereç. Qualif. Proc(se incid). 2.REQUISITOS: Urgência=Fumus+Periculum(+Reversib.). Evidência=Hipótese Art.311. 3.PEDIDO LIMINAR: Medida CLARA. 4.Se Antec.: Indicar pedido final/aditar. Valor Causa. 5.PEDIDOS: Concessão tutela; citação/intim.; indic. ação/adit. 6.Fechamento OAB."
+    else:
+        prompt += "1.Estrutura Lógica. 2.Argumentos Claros. 3.Pedido Claro. 4.Formalidades 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/...'. Sem comentários extras."
     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")
     if tipo_peticao == "Petição Inicial":
-        # (Lógica para adicionar custas e audiência mantida)
         peticao_lower = peticao_corrigida.lower()
         if "juntada da guia de custas" not in peticao_lower and "gratuidade de justiça" not in peticao_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2: peticao_corrigida = partes[0].strip() + "\nRequer, 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.")
+            partes = peticao_corrigida.split("Nestes termos pede deferimento")
+            if len(partes) == 2:
+                peticao_corrigida = partes[0].strip() + "\nRequer, 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_lower and "audiência de mediação" not in peticao_lower:
-             partes = peticao_corrigida.split("Nestes termos pede deferimento")
-             if len(partes) == 2: peticao_corrigida = partes[0].strip() + "\nOpta 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.")
+            partes = peticao_corrigida.split("Nestes termos pede deferimento")
+            if len(partes) == 2:
+                peticao_corrigida = partes[0].strip() + "\nOpta 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 = ["Local, data.", "ADVOGADO(A)", "OAB/..."]
-    while linhas and any(t in linhas[-1] for t in ["ADVOGADO","OAB","Local","data"]): linhas.pop()
-    linhas.extend(fechamento)
+    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)
     return "\n".join(linhas)
 
-# --- Chamada à API Refatorada ---
 def chamar_api(prompt):
-    logger.info(f"Chamando API Gemini (Modelo: {GEMINI_MODEL_NAME})...")
-    model = genai.GenerativeModel(GEMINI_MODEL_NAME, safety_settings=SAFETY_SETTINGS)
-    generation_config = genai.types.GenerationConfig(
-        temperature=CONFIG["temperatura"],
-        max_output_tokens=CONFIG["max_tokens"],
-        top_p=0.95 # Exemplo, pode ser ajustado ou removido
-    )
-
-    for tentativa in range(CONFIG["max_retry_attempts"]):
-        try:
-            with rate_limiter:
-                logger.debug(f"API Call - Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}")
-                response = model.generate_content(
-                    contents=prompt,
-                    generation_config=generation_config,
-                    # request_options={'timeout': CONFIG["timeout_api"]} # Timeout pode ser configurado aqui se suportado
-                )
-
-            # Verifica bloqueio no prompt feedback mesmo sem exceção
-            if response.prompt_feedback.block_reason:
-                logger.error(f"Prompt bloqueado pela API. Motivo: {response.prompt_feedback.block_reason}")
-                return f"❌ Prompt bloqueado: {response.prompt_feedback.block_reason}. Reformule."
-
-            # Verifica se há texto na resposta
-            if not response.text:
-                 # Verifica se a geração foi interrompida por segurança ou outro motivo
-                 if response.candidates and response.candidates[0].finish_reason != genai.types.FinishReason.STOP:
-                      finish_reason = response.candidates[0].finish_reason.name
-                      logger.error(f"Geração API interrompida (sem texto): {finish_reason}")
-                      safety_ratings = response.candidates[0].safety_ratings
-                      harm_cats = [r.category.name for r in safety_ratings if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
-                      if harm_cats: return f"❌ Bloqueado por segurança: {finish_reason} ({','.join(harm_cats)})."
-                      else: return f"❌ Geração interrompida: {finish_reason}."
-                 else:
-                      # Resposta vazia por outro motivo
-                      logger.warning("API retornou resposta sem texto e sem bloqueio aparente.")
-                      return "⚠️ API retornou resposta vazia." # Pode ser token insuficiente, etc.
-
-            logger.info(f"API retornou com sucesso ({len(response.text)} chars).")
-            return response.text
-
-        # Tratamento de Erros Específicos da Biblioteca google-generativeai
-        except google_exceptions.ResourceExhausted as e: # Erro 429 (Rate Limit)
-            logger.warning(f"Erro 429 (Rate Limit) - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1:
-                wait_time = CONFIG['retry_delay'] * (2 ** tentativa) # Backoff exponencial
-                logger.info(f"Aguardando {wait_time}s para retentativa...")
-                time.sleep(wait_time)
-                continue
-            return "❌ Erro 429: Muitas requisições. Tente mais tarde."
-        except google_exceptions.PermissionDenied as e:
-            logger.error(f"Erro de Permissão API: {e}")
-            return f"❌ Erro de Permissão: Verifique sua API Key e acesso ao modelo '{GEMINI_MODEL_NAME}'."
-        except google_exceptions.InvalidArgument as e:
-             logger.error(f"Erro de Argumento Inválido API: {e}")
-             return f"❌ Erro nos parâmetros da API: {e}"
-        except genai.types.BlockedPromptException as e:
-             logger.error(f"Prompt bloqueado pela API (exceção): {e}")
-             return f"❌ Prompt bloqueado. Reformule o conteúdo."
-        except genai.types.StopCandidateException as e:
-             logger.error(f"Geração interrompida pela API (exceção): {e}")
-             # Tenta extrair informação de segurança se disponível no erro
-             return f"❌ Geração interrompida pela API (segurança ou outro motivo)."
-        except google_exceptions.GoogleAPIError as e: # Outros erros da API Google
-            logger.error(f"Erro genérico da API Google - Tentativa {tentativa + 1}: {e}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1:
-                time.sleep(CONFIG['retry_delay'] * (tentativa + 1))
-                continue
-            return f"❌ Erro da API Google: {e}"
-        except Exception as e: # Erros gerais (rede, etc.)
-            logger.exception(f"Erro inesperado - Tentativa {tentativa + 1}: {str(e)}")
-            if tentativa < CONFIG["max_retry_attempts"] - 1:
-                time.sleep(CONFIG['retry_delay'] * (tentativa + 1))
-                continue
-            return f"❌ Erro inesperado: {str(e)}"
-
-    logger.error("Falha API após todas as tentativas.")
-    return "❌ Falha API após múltiplas tentativas."
+    try:
+        # Configura o cliente com a chave da API
+        genai.configure(api_key=GEMINI_API_KEY)
+        
+        # Configurações do modelo
+        generation_config = {
+            "temperature": CONFIG["temperatura"],
+            "max_output_tokens": CONFIG["max_tokens"],
+            "top_p": 0.95,
+        }
+        
+        logger.info(f"Chamando API Gemini. Temp={CONFIG['temperatura']}, MaxTokens={CONFIG['max_tokens']}")
+        
+        for tentativa in range(CONFIG["max_retry_attempts"]):
+            try:
+                with rate_limiter:
+                    logger.debug(f"API Call - Tentativa {tentativa + 1}/{CONFIG['max_retry_attempts']}")
+                    # Chama o modelo
+                    response = genai.generate_content(
+                        model="gemini-1.5-flash-latest",
+                        contents=[{"parts": [{"text": prompt}]}],
+                        generation_config=generation_config
+                    )
+                
+                # Verifica se há conteúdo na resposta
+                if not response.candidates:
+                    logger.error("API Response sem 'candidates'.")
+                    prompt_feedback = getattr(response, "prompt_feedback", {})
+                    block_reason = prompt_feedback.get("block_reason", "Desconhecido")
+                    return f"❌ Bloqueado pela API: {block_reason}."
+                
+                candidate = response.candidates[0]
+                finish_reason = candidate.finish_reason
+                
+                if finish_reason not in ["STOP", "MAX_TOKENS", None]:
+                    logger.error(f"Geração API interrompida: {finish_reason}")
+                    safety_ratings = candidate.safety_ratings
+                    harm_categories = [r.category for r in safety_ratings if r.probability not in ['NEGLIGIBLE', 'LOW']]
+                    if harm_categories:
+                        return f"❌ Bloqueado por segurança: {finish_reason} ({','.join(harm_categories)})."
+                    return f"❌ Geração interrompida: {finish_reason}."
+                
+                texto_gerado = candidate.content.parts[0].text.strip()
+                logger.info(f"API retornou com sucesso ({len(texto_gerado)} chars). Finish: {finish_reason}")
+                return texto_gerado
+            
+            except ResourceExhausted as e:
+                logger.warning(f"Erro 429 (Quota Exceeded) - Tentativa {tentativa + 1}. Aguardando {CONFIG['retry_delay']}s...")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return "❌ Erro 429: Muitas requisições."
+            
+            except GoogleAPIError as e:
+                logger.error(f"Erro API: {str(e)}")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro API: {str(e)}"
+            
+            except Exception as e:
+                logger.exception(f"Erro inesperado API - Tentativa {tentativa + 1}: {str(e)}")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro inesperado API: {str(e)}"
+    
+    except Exception as e:
+        logger.error(f"Erro crítico ao chamar API: {str(e)}", exc_info=True)
+        return f"❌ Erro crítico ao chamar API: {str(e)}"
 
-# --- Função Principal de Correção (Usa a nova chamar_api) ---
 def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
     logger.info(f"Iniciando correção. Tipo={tipo_peticao}, Treinamento={modo_treinamento}")
     start_time = time.time()
     analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html = "", "", "", "", ""
     peticao_conteudo = ""
     try:
-        if not caso or not caso.strip(): return "⚠️ Forneça o caso.", "", "", "", ""
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo.", "", "", "", ""
+        if not caso or not caso.strip():
+            return "⚠️ Forneça o caso.", "", "", "", ""
+        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
+            return "⚠️ Selecione tipo.", "", "", "", ""
         if peticao_arquivo is not None:
             peticao_conteudo = process_file(peticao_arquivo)
-            if peticao_conteudo.startswith(("❌", "⚠️")): return peticao_conteudo, "", "", "", ""
-        elif peticao_texto and peticao_texto.strip(): peticao_conteudo = peticao_texto
-        else: return "⚠️ Forneça a petição.", "", "", "", ""
+            if peticao_conteudo.startswith(("❌", "⚠️")):
+                return peticao_conteudo, "", "", "", ""
+        elif peticao_texto and peticao_texto.strip():
+            peticao_conteudo = peticao_texto
+        else:
+            return "⚠️ Forneça a petição.", "", "", "", ""
         logger.info(f"Petição recebida ({len(peticao_conteudo)} chars).")
         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", "faça para mim", "faça por mim"]
         if any(trigger in peticao_conteudo.lower() for trigger in troll_triggers):
@@ -312,14 +365,13 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
             logger.info("Correção encontrada no cache.")
             cached = CORRECAO_CACHE[cache_key]
             return cached["analise_formatada"], cached["peticao_corrigida"], cached["resumo_diff"], cached["criticas_diff"], cached["diff_html"]
-
         prompt_analise = estruturar_prompt_analise(caso, peticao_conteudo, tipo_peticao, modo_treinamento)
-        analise_bruta = chamar_api(prompt_analise) # Usa a nova função
-        if analise_bruta.startswith(("❌", "⏱️", "⚠️")): return analise_bruta, "", "", "", ""
+        analise_bruta = chamar_api(prompt_analise)
+        if analise_bruta.startswith(("❌", "⏱️", "⚠️")):
+            return analise_bruta, "", "", "", ""
         analise_formatada = formatar_correcao(analise_bruta)
-
         prompt_peticao = estruturar_prompt_peticao_corrigida(caso, peticao_conteudo, tipo_peticao)
-        peticao_corrigida_bruta = chamar_api(prompt_peticao) # Usa a nova função
+        peticao_corrigida_bruta = chamar_api(prompt_peticao)
         if peticao_corrigida_bruta.startswith(("❌", "⏱️", "⚠️")):
             peticao_corrigida_final = f"⚠️ Falha ao gerar versão corrigida:\n{peticao_corrigida_bruta}"
         else:
@@ -328,49 +380,75 @@ def corrigir_peticao(caso, tipo_peticao, peticao_texto=None, peticao_arquivo=Non
             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 idx != -1:
+                    start_index = idx
+                    break
             peticao_extraida = peticao_corrigida_bruta[start_index:] if start_index != -1 else peticao_corrigida_bruta
             peticao_corrigida_final = pos_corrigir_peticao(peticao_extraida, tipo_peticao)
-
         diff_html, resumo_diff, criticas_diff = calcular_diff_interno(peticao_conteudo, peticao_corrigida_final)
-        resultado_cache = {"analise_formatada": analise_formatada,"peticao_corrigida": peticao_corrigida_final,"resumo_diff": resumo_diff,"criticas_diff": criticas_diff,"diff_html": diff_html}
+        resultado_cache = {
+            "analise_formatada": analise_formatada,
+            "peticao_corrigida": peticao_corrigida_final,
+            "resumo_diff": resumo_diff,
+            "criticas_diff": criticas_diff,
+            "diff_html": diff_html
+        }
         CORRECAO_CACHE[cache_key] = resultado_cache
-        HISTORICO.append({"data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),"tipo_peticao": tipo_peticao,"caso": caso,"peticao_original": peticao_conteudo,**resultado_cache})
-        if len(HISTORICO) > 10: HISTORICO.pop(0)
+        HISTORICO.append({
+            "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "tipo_peticao": tipo_peticao,
+            "caso": caso,
+            "peticao_original": peticao_conteudo,
+            **resultado_cache
+        })
+        if len(HISTORICO) > 10:
+            HISTORICO.pop(0)
         end_time = time.time()
         logger.info(f"Correção concluída em {end_time - start_time:.2f} segundos.")
         return analise_formatada, peticao_corrigida_final, resumo_diff, criticas_diff, diff_html
     except Exception as e:
-        logger.exception("Erro GERAL inesperado dentro de corrigir_peticao:")
+        logger.error(f"Erro GERAL inesperado em corrigir_peticao: {str(e)}", exc_info=True)
         return f"❌ Erro inesperado correção: {str(e)}", "", "", "", ""
 
-# --- Funções de Formatação, Dicas, Diff, Progresso, Histórico, Salvar/Carregar ---
-# (Mantidas como na versão anterior, sem alterações lógicas necessárias)
 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")
-    linhas = texto.split('\n'); linhas_formatadas = []
+    linhas = texto.split('\n')
+    linhas_formatadas = []
     in_list = False
     for linha in linhas:
         ls = linha.strip()
-        if ls.startswith(("1.","2.","3.","4.","5.")): linhas_formatadas.append(f"\n**{ls}**"); in_list = False
-        elif ls.startswith(("- ","* ")): prefix = "  * " if in_list else "* "; linhas_formatadas.append(prefix + ls[2:]); in_list = True
-        elif ls.startswith(("a)","b)","c)","d)","e)")): linhas_formatadas.append(f"    * {ls}"); in_list = True
-        else: linhas_formatadas.append(linha); in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
+        if ls.startswith(("1.","2.","3.","4.","5.")):
+            linhas_formatadas.append(f"\n**{ls}**")
+            in_list = False
+        elif ls.startswith(("- ","* ")):
+            prefix = "  * " if in_list else "* "
+            linhas_formatadas.append(prefix + ls[2:])
+            in_list = True
+        elif ls.startswith(("a)","b)","c)","d)","e)")):
+            linhas_formatadas.append(f"    * {ls}")
+            in_list = True
+        else:
+            linhas_formatadas.append(linha)
+            in_list = False if not ls.startswith(("*","- ","a)","b)","c)","d)","e)"," ")) else in_list
     texto_final = "\n".join(linhas_formatadas)
     m = re.search(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", texto_final, re.I)
-    if m: nota = m.group(2).replace(",","."); texto_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", texto_final, count=1, flags=re.I)
+    if m:
+        nota = m.group(2).replace(",",".")
+        texto_final = re.sub(r"(\*\*Nota Final:?\*\*\s*)(\d{1,2}[,.]\d{1}|\d{1,2})", f"\\1**{nota}/10**", texto_final, count=1, flags=re.I)
     return texto_final
 
 def fornecer_dica_contextual(texto_peticao, tipo_peticao):
-    if not texto_peticao or not texto_peticao.strip(): return "*Digite para dicas...*"
+    if not texto_peticao or not texto_peticao.strip():
+        return "*Digite para dicas...*"
     dicas_relevantes = []
     texto_lower = texto_peticao.lower()
     for chave in ["Clareza e Concisão", "Fundamentação Legal", "Revisão Ortográfica"]:
-        if chave in DICAS_OAB_MELHORADO: dicas_relevantes.append(f"💡 **{chave}:** {DICAS_OAB_MELHORADO[chave]}")
+        if chave in DICAS_OAB_MELHORADO:
+            dicas_relevantes.append(f"💡 **{chave}:** {DICAS_OAB_MELHORADO[chave]}")
     keywords_por_tipo = {
         "Petição Inicial": ["endereçamento","qualificação","fatos","fundamentos","pedidos","valor","provas","audiência","citação","custas"],
         "Contestação": ["preliminar","mérito","impugnação","improcedência","honorários","art. 337","art. 341"],
@@ -380,30 +458,40 @@ def fornecer_dica_contextual(texto_peticao, tipo_peticao):
         "Petição de Tutela Provisória": ["urgência","evidência","liminar","periculum","fumus boni","art. 300"],
     }
     if tipo_peticao in keywords_por_tipo:
-         for chave, dica in DICAS_OAB_MELHORADO.items():
-              cl = chave.lower()
-              if f"({tipo_peticao.split()[0].lower()})" in cl or any(kw in cl for kw in keywords_por_tipo[tipo_peticao] if kw in texto_lower):
-                    dica_fmt = f"💡 **{chave}:** {dica}"
-                    if dica_fmt not in dicas_relevantes: dicas_relevantes.append(dica_fmt)
-    if not dicas_relevantes: return "*Continue escrevendo para dicas...*"
+        for chave, dica in DICAS_OAB_MELHORADO.items():
+            cl = chave.lower()
+            if f"({tipo_peticao.split()[0].lower()})" in cl or any(kw in cl for kw in keywords_por_tipo[tipo_peticao] if kw in texto_lower):
+                dica_fmt = f"💡 **{chave}:** {dica}"
+                if dica_fmt not in dicas_relevantes:
+                    dicas_relevantes.append(dica_fmt)
+    if not dicas_relevantes:
+        return "*Continue escrevendo para dicas...*"
     return "\n\n".join(dicas_relevantes[:4])
 
 def calcular_diff_interno(texto_original, texto_corrigido):
-    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")): return "","",""
-    orig_lines = texto_original.splitlines(); corr_lines = texto_corrigido.splitlines()
+    if not texto_original or not texto_corrigido or texto_corrigido.startswith(("⚠️","❌")):
+        return "","",""
+    orig_lines = texto_original.splitlines()
+    corr_lines = texto_corrigido.splitlines()
     diff = difflib.ndiff(orig_lines, corr_lines)
     res_html, crit, l_rem, l_add = [], [], 0, 0
     kw_rem = ["invenção", "identificação", "erro crasso", "incorreto", "prazo"]
     kw_add = ["custas", "art. 319", "art. 337", "art. 1022", "art. 1015", "art. 300", "fumus", "periculum", "essencial", "preliminar", "tempestividade", "cabimento"]
     for linha in diff:
-        txt = linha[2:]; txt_esc = escape(txt)
-        if linha.startswith('  '): res_html.append(f"<div class='linha-igual'>{txt_esc}</div>")
+        txt = linha[2:]
+        txt_esc = escape(txt)
+        if linha.startswith('  '):
+            res_html.append(f"<div class='linha-igual'>{txt_esc}</div>")
         elif linha.startswith('- '):
-            l_rem += 1; res_html.append(f"<div class='linha-removida'><del>{txt_esc}</del></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_rem): crit.append(f"<span style='color:red'>🔴 REMOVIDO:</span> {txt_esc}")
+            l_rem += 1
+            res_html.append(f"<div class='linha-removida'><del>{txt_esc}</del></div>")
+            if txt.strip() and any(kw in txt.lower() for kw in kw_rem):
+                crit.append(f"<span style='color:red'>🔴 REMOVIDO:</span> {txt_esc}")
         elif linha.startswith('+ '):
-            l_add += 1; res_html.append(f"<div class='linha-adicionada'><ins>{txt_esc}</ins></div>")
-            if txt.strip() and any(kw in txt.lower() for kw in kw_add): crit.append(f"<span style='color:green'>🟢 ADICIONADO:</span> {txt_esc}")
+            l_add += 1
+            res_html.append(f"<div class='linha-adicionada'><ins>{txt_esc}</ins></div>")
+            if txt.strip() and any(kw in txt.lower() for kw in kw_add):
+                crit.append(f"<span style='color:green'>🟢 ADICIONADO:</span> {txt_esc}")
     resumo = f"**Resumo:** Rem={l_rem}, Add={l_add}, Saldo={l_add - l_rem}"
     crit_txt = "### 🚨 Mudanças Críticas:\n" + "\n".join(crit) if crit else "*Nenhuma mudança crítica detectada.*"
     css = "<style>.diff-container{font-family:monospace;white-space:pre-wrap;border:1px solid #ccc;padding:10px;background-color:#f9f9f9;max-height:600px;overflow-y:auto}.linha-igual{color:#555}.linha-removida{background-color:#ffebee;color:#c62828}.linha-adicionada{background-color:#e8f5e9;color:#2e7d32}.linha-removida del,.linha-adicionada ins{text-decoration:none;padding:0 2px;border-radius:2px}.linha-removida del{background-color:#ffcdd2}.linha-adicionada ins{background-color:#c8e6c9}</style>"
@@ -411,74 +499,112 @@ def calcular_diff_interno(texto_original, texto_corrigido):
     return html_diff, resumo, crit_txt
 
 def calcular_progresso():
-    if not HISTORICO: return "📊 Nenhum progresso."
+    if not HISTORICO:
+        return "📊 Nenhum progresso."
     notas, tipos = [], set()
     for entry in HISTORICO:
         tipos.add(entry["tipo_peticao"])
         m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
         if m:
-            try: notas.append(float(m.group(1).replace(",", ".")))
-            except ValueError: pass
-    tot = len(HISTORICO); media = sum(notas)/len(notas) if notas else 0; tend = ""
-    if len(notas) > 1: tend = "⬆️" if notas[-1] > notas[-2] else ("⬇️" if notas[-1] < notas[-2] else "↔️")
+            try:
+                notas.append(float(m.group(1).replace(",", ".")))
+            except ValueError:
+                pass
+    tot = len(HISTORICO)
+    media = sum(notas)/len(notas) if notas else 0
+    tend = ""
+    if len(notas) > 1:
+        tend = "⬆️" if notas[-1] > notas[-2] else ("⬇️" if notas[-1] < notas[-2] else "↔️")
     return f"**📊 Resumo:** Corrs:{tot}, Tipos:{len(tipos)}, Média:{media:.1f}/10 ({len(notas)} val), Tend:{tend if tend else 'N/A'}"
 
 def mostrar_historico():
-    if not HISTORICO: return "📜 Histórico vazio."
+    if not HISTORICO:
+        return "📜 Histórico vazio."
     md = "### 📜 Histórico (Últimas 10)\n---\n"
     for i, entry in enumerate(reversed(HISTORICO)):
         caso = (entry['caso'][:70] + '...') if len(entry['caso']) > 70 else entry['caso']
-        nota = "N/A"; m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
-        if m: nota = f"{m.group(1).replace(',', '.')}/10"
+        nota = "N/A"
+        m = re.search(r"Nota Final:?\s*\**(\d{1,2}[,.]\d{1}|\d{1,2})\s*/\s*10", entry["analise_formatada"], re.I)
+        if m:
+            nota = f"{m.group(1).replace(',', '.')}/10"
         md += f"**{len(HISTORICO)-i}.** {entry['data']} | **{entry['tipo_peticao']}** | **Nota:{nota}**\n   **Caso:** _{caso}_\n---\n"
     return md
 
 def salvar_progresso(caso, peticao, tipo_peticao):
     logger.info("Salvando progresso...")
     try:
-        if not caso or not peticao or not tipo_peticao: return "", "⚠️ Inputs necessários.", None
-        dados = {"tipo_peticao": tipo_peticao, "caso": caso, "peticao": peticao, "timestamp": datetime.now().isoformat()}
+        if not caso or not peticao or not tipo_peticao:
+            return "", "⚠️ Inputs necessários.", None
+        dados = {
+            "tipo_peticao": tipo_peticao,
+            "caso": caso,
+            "peticao": peticao,
+            "timestamp": datetime.now().isoformat()
+        }
         json_cont = json.dumps(dados, ensure_ascii=False, indent=4)
         fname = f"progresso_peticao_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
         fpath = os.path.join(tempfile.gettempdir(), fname)
-        with open(fpath, 'w', encoding='utf-8') as f: f.write(json_cont)
+        with open(fpath, 'w', encoding='utf-8') as f:
+            f.write(json_cont)
         logger.info(f"Progresso salvo: {fpath}")
         msg = f"✅ Salvo! Baixe `{fname}`."
         return json_cont, msg, fpath
-    except Exception as e: logger.error(f"Erro salvar: {e}", exc_info=True); return "", f"❌ Erro salvar: {e}", None
+    except Exception as e:
+        logger.error(f"Erro salvar: {e}", exc_info=True)
+        return "", f"❌ Erro salvar: {e}", None
 
 def carregar_progresso(arquivo_entrada):
     logger.info("Carregando progresso...")
-    if arquivo_entrada is None: return "", "", "", "⚠️ Nenhum arquivo."
+    if arquivo_entrada is None:
+        return "", "", "", "⚠️ Nenhum arquivo."
     try:
         fpath = arquivo_entrada.name
         logger.info(f"Carregando: {fpath}")
-        with open(fpath, 'r', encoding='utf-8') as f: dados = json.load(f)
+        with open(fpath, 'r', encoding='utf-8') as f:
+            dados = json.load(f)
         caso, peticao, tipo = dados.get("caso"), dados.get("peticao"), dados.get("tipo_peticao")
-        if not all([caso, peticao, tipo]): return "", "", "", "❌ Arquivo inválido."
-        if tipo not in TIPOS_DE_PETICAO: return caso, peticao, "", f"⚠️ Tipo '{tipo}' inválido."
+        if not all([caso, peticao, tipo]):
+            return "", "", "", "❌ Arquivo inválido."
+        if tipo not in TIPOS_DE_PETICAO:
+            return caso, peticao, "", f"⚠️ Tipo '{tipo}' inválido."
         logger.info("Progresso carregado.")
         return tipo, caso, peticao, "✅ Progresso carregado!"
-    except Exception as e: logger.error(f"Erro carregar: {e}", exc_info=True); return "", "", "", f"❌ Erro carregar: {e}"
+    except Exception as e:
+        logger.error(f"Erro carregar: {e}", exc_info=True)
+        return "", "", "", f"❌ Erro carregar: {e}"
 
-# --- Geração de Casos (Usa a nova chamar_api) ---
 def estruturar_prompt_geracao_caso(tipo_peticao="Petição Inicial"):
     prompt = f"Crie caso fictício **detalhado e realista** p/ peça **'{tipo_peticao}'** (simulado OAB).\n**Geral:**\n1.Complexidade adequada (15-25l).\n2.Dados Essenciais (nomes,locais,datas,valores,relação,conflito).\n3.Coerência.\n4.Foco no Tipo Peça.\n**Específico '{tipo_peticao}':**\n"
-    # (Adicionar instruções específicas por tipo como antes - omitido por brevidade)
-    if tipo_peticao == "Petição Inicial": prompt += "* Descreva violação direitos... * Tema: Consumo, Contrato, etc."
-    elif tipo_peticao == "Contestação": prompt += "* Resumo PI recebida... * Versão Réu..."
-    # ... (outros tipos) ...
-    else: prompt += "* Crie cenário cível com conflito claro."
-    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça processual cabível ({tipo_peticao})."\n**Importante:** Temas comuns. Criativo!'
+    if tipo_peticao == "Petição Inicial":
+        prompt += "* Descreva violação direitos. * Inclua danos. * Dados qualificação. * Tema: Consumo, Contrato, etc."
+    elif tipo_peticao == "Contestação":
+        prompt += "* Resumo PI recebida. * Versão Réu (p/ preliminares, impugnação, mérito). * Dados qualificação réu."
+    elif tipo_peticao == "Reconvenção":
+        prompt += "* Estrutura Contestação + Fatos/Fundamentos p/ pedido PRÓPRIO CONEXO do Réu contra Autor."
+    elif tipo_peticao == "Impugnação à Contestação":
+        prompt += "* Resumo PI Autor. * Resumo Contestação Réu (preliminares, fatos novos, docs). * Objetivo: Rebater contestação."
+    elif tipo_peticao == "Embargos de Declaração":
+        prompt += "* Breve caso. * TRECHO DECISÃO JUDICIAL. * INDIQUE VÍCIO (omissão/contradição/obscuridade/erro material) NESSA DECISÃO."
+    elif tipo_peticao == "Recurso de Apelação":
+        prompt += "* Caso original. * Resumo SENTENÇA. * ELEMENTOS indicando ERRO (in judicando/procedendo). * Indique cliente (apelante)."
+    elif tipo_peticao == "Agravo de Instrumento":
+        prompt += "* Caso em andamento. * DECISÃO INTERLOCUTÓRIA. * Enquadrar Art.1015/mitigação. * ELEMENTOS indicando ERRO + URGÊNCIA. * Indique cliente (agravante)."
+    elif tipo_peticao == "Petição de Tutela Provisória":
+        prompt += "* Situação URGENTE ou EVIDENTE. * ELEMENTOS: Urgência=Fumus+Periculum; Evidência=Hipótese Art.311. * Medida específica. * Antecedente ou Incidental."
+    else:
+        prompt += "* Crie cenário cível com conflito claro."
+    prompt += f'\n**Finalize:**\n"**Situação-Problema:** Advogado(a) de [Nome Cliente], elabore a peça processual cabível ({tipo_peticao})."\n**Importante:** Temas comuns. Seja criativo!'
     return prompt
 
 def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
-    logger.info(f"Gerando caso para: {tipo_peticao}")
     try:
-        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO: return "⚠️ Selecione tipo válido."
+        logger.info(f"Gerando caso para: {tipo_peticao}")
+        if not tipo_peticao or tipo_peticao not in TIPOS_DE_PETICAO:
+            return "⚠️ Selecione tipo válido."
         prompt = estruturar_prompt_geracao_caso(tipo_peticao)
-        caso_gerado = chamar_api(prompt) # Usa a nova função
-        if caso_gerado.startswith(("❌","⏱️","⚠️")): return f"⚠️ Falha gerar caso:\n{caso_gerado}"
+        caso_gerado = chamar_api(prompt)
+        if caso_gerado.startswith(("❌","⏱️","⚠️")):
+            return f"⚠️ Falha gerar caso:\n{caso_gerado}"
         frase_final = "**Situação-Problema:** Na qualidade de advogado(a) de"
         if frase_final.lower() not in caso_gerado.lower():
             logger.warning("Frase final não encontrada. Adicionando.")
@@ -487,21 +613,20 @@ def gerar_caso_ficticio(tipo_peticao="Petição Inicial"):
             caso_gerado += f"\n\n**Situação-Problema:** Na qualidade de advogado(a) de {cliente}, elabore a peça processual cabível ({tipo_peticao})."
         logger.info("Caso gerado.")
         return caso_gerado
-    except Exception as e: logger.exception("Erro gerar_caso:"); return f"❌ Erro gerar caso: {e}"
+    except Exception as e:
+        logger.error(f"Erro ao gerar caso: {str(e)}", exc_info=True)
+        return f"❌ Erro ao gerar caso: {str(e)}"
 
-# --- Função para Atualizar Config ---
 def atualizar_config(temp, timeout, tokens):
     CONFIG["temperatura"] = temp
-    # CONFIG["timeout_api"] = timeout # Timeout da API não é mais usado diretamente
+    CONFIG["timeout"] = timeout
     CONFIG["max_tokens"] = tokens
-    logger.info(f"Configs atualizadas: Temp={temp}, Max Tokens={tokens}")
-    # Atualiza config do modelo se já instanciado (ou recria na próxima chamada)
-    # model.generation_config.temperature = temp # Exemplo, requer acesso à instância do modelo
-    return f"✅ Configs Atualizadas (Temp: {temp}, Tokens: {tokens})!"
+    logger.info(f"Configs atualizadas: Temp={temp}, Timeout={timeout}, Tokens={tokens}")
+    return "✅ Configs Atualizadas!"
 
-# --- Interface Gradio ---
 def interface_gradio():
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange")) as demo:
+    logger.info(f"Versão do Gradio: {gr.__version__}")
+    with gr.Blocks(theme=gr.themes.Default()) as demo:
         gr.Markdown("# ⚖️ Corretor Jurídico OAB Master ⚖️\nAnalise e aprimore suas peças processuais!")
         with gr.Row():
             with gr.Column(scale=1):
@@ -510,8 +635,7 @@ def interface_gradio():
                 modo_treinamento = gr.Checkbox(label="🎓 Modo Treinamento", value=False)
                 with gr.Accordion("🛠️ Opções Avançadas", open=False):
                     temperatura_slider = gr.Slider(0.0, 1.0, value=CONFIG["temperatura"], step=0.1, label="Criatividade")
-                    # Timeout Slider removido pois não se aplica diretamente à lib google-genai
-                    # timeout_slider = gr.Slider(30, 180, value=CONFIG["timeout_api"], step=10, label="Timeout (s)")
+                    timeout_slider = gr.Slider(30, 180, value=CONFIG["timeout"], step=10, label="Timeout (s)")
                     max_tokens_slider = gr.Slider(2048, 8192, value=CONFIG["max_tokens"], step=256, label="Max Tokens")
                     config_update_btn = gr.Button("💾 Salvar Configs")
                     config_status = gr.Textbox(label="Status", interactive=False, lines=1)
@@ -522,15 +646,15 @@ def interface_gradio():
                     historico_output = gr.Markdown("*Atualize para ver.*")
                     historico_btn = gr.Button("🔄 Ver Histórico")
                 with gr.Accordion("💾📂 Salvar/Carregar", open=False):
-                     salvar_btn = gr.Button("💾 Salvar")
-                     carregar_btn = gr.Button("📂 Carregar")
-                     arquivo_progresso_upload = gr.File(label="Selecione .json", file_types=[".json"])
-                     progresso_download_file = gr.File(label="Baixar Progresso", interactive=False)
+                    salvar_btn = gr.Button("💾 Salvar")
+                    carregar_btn = gr.Button("📂 Carregar")
+                    arquivo_progresso_upload = gr.File(label="Selecione .json", file_types=[".json"])
+                    progresso_download_file = gr.File(label="Baixar Progresso", interactive=False)
             with gr.Column(scale=3):
                 gr.Markdown("### 1. Caso / Contexto")
                 with gr.Row():
-                     caso_input = gr.Textbox(label="📋 Caso", lines=8, placeholder="Insira o texto do caso...")
-                     caso_btn = gr.Button("🎲 Gerar", variant="secondary", scale=0)
+                    caso_input = gr.Textbox(label="📋 Caso", lines=8, placeholder="Insira o texto do caso...")
+                    caso_btn = gr.Button("🎲 Gerar", variant="secondary", scale=0)
                 gr.Markdown("### 2. Sua Peça")
                 with gr.Tabs():
                     with gr.TabItem("✏️ Texto"):
@@ -541,73 +665,136 @@ def interface_gradio():
                         peticao_arquivo_input = gr.File(label="Arquivo (.pdf,.docx,.txt)", file_types=[".pdf",".docx",".txt"])
                         arquivo_preview_output = gr.Textbox(label="🔍 Prévia", lines=4, interactive=False)
                         btn_corrigir_arquivo = gr.Button("🚀 CORRIGIR ARQUIVO!", variant="primary")
-
         processing_message = gr.Markdown("", visible=False)
         gr.Markdown("--- \n ### 3. Resultados")
         with gr.Tabs():
-             with gr.TabItem("📊 Análise e Correção"):
-                  resultado_analise_output = gr.Markdown(label="Análise e Nota")
-                  resultado_peticao_corrigida_output = gr.Textbox(label="✨ Versão Sugerida", lines=18, show_copy_button=True)
-             with gr.TabItem("⚖️ Comparativo"):
-                  gr.Markdown("### ↔️ Comparativo (Diff)")
-                  with gr.Row():
-                       with gr.Column(scale=1): resumo_alteracoes_output = gr.Markdown(label="Resumo"); criticas_output = gr.Markdown(label="Críticas")
-                       with gr.Column(scale=3): visualizacao_detalhada_output = gr.HTML(label="Detalhes")
+            with gr.TabItem("📊 Análise e Correção"):
+                resultado_analise_output = gr.Markdown(label="Análise e Nota")
+                resultado_peticao_corrigida_output = gr.Textbox(label="✨ Versão Sugerida", lines=18, show_copy_button=True)
+            with gr.TabItem("⚖️ Comparativo"):
+                gr.Markdown("### ↔️ Comparativo (Diff)")
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        resumo_alteracoes_output = gr.Markdown(label="Resumo")
+                        criticas_output = gr.Markdown(label="Críticas")
+                    with gr.Column(scale=3):
+                        visualizacao_detalhada_output = gr.HTML(label="Detalhes")
         clear_btn = gr.Button("🗑️ Limpar Tudo")
 
-        # --- Eventos ---
-        caso_btn.click(lambda: gr.update(value="⏳ Gerando...", visible=True), outputs=processing_message).then(
-             fn=gerar_caso_ficticio, inputs=[tipo_peticao_input], outputs=[caso_input]
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
+        caso_btn.click(
+            fn=lambda: (logger.info("Botão Gerar clicado"), gr.update(value="⏳ Gerando...", visible=True))[1],
+            outputs=processing_message
+        ).then(
+            fn=gerar_caso_ficticio,
+            inputs=[tipo_peticao_input],
+            outputs=[caso_input]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            outputs=processing_message
+        )
 
-        peticao_texto_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        tipo_peticao_input.change(fornecer_dica_contextual, [peticao_texto_input, tipo_peticao_input], dica_contextual_output)
-        peticao_arquivo_input.change(process_file, [peticao_arquivo_input], [arquivo_preview_output])
+        peticao_texto_input.change(
+            fornecer_dica_contextual,
+            [peticao_texto_input, tipo_peticao_input],
+            dica_contextual_output
+        )
+        tipo_peticao_input.change(
+            fornecer_dica_contextual,
+            [peticao_texto_input, tipo_peticao_input],
+            dica_contextual_output
+        )
+        peticao_arquivo_input.change(
+            process_file,
+            [peticao_arquivo_input],
+            [arquivo_preview_output]
+        )
 
-        btn_corrigir.click(lambda: gr.update(value="⏳ Processando texto...", visible=True), outputs=processing_message).then(
+        btn_corrigir.click(
+            fn=lambda: (logger.info("Botão Corrigir Texto clicado"), gr.update(value="⏳ Processando texto...", visible=True))[1],
+            outputs=processing_message
+        ).then(
             fn=corrigir_peticao,
             inputs=[caso_input, tipo_peticao_input, peticao_texto_input, gr.State(None), modo_treinamento],
             outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1 # Limita execuções simultâneas para evitar sobrecarga/rate limit
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
+            concurrency_limit=None
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            outputs=processing_message
+        )
 
-        btn_corrigir_arquivo.click(lambda: gr.update(value="⏳ Processando arquivo...", visible=True), outputs=processing_message).then(
+        btn_corrigir_arquivo.click(
+            fn=lambda: (logger.info("Botão Corrigir Arquivo clicado"), gr.update(value="⏳ Processando arquivo...", visible=True))[1],
+            outputs=processing_message
+        ).then(
             fn=corrigir_peticao,
             inputs=[caso_input, tipo_peticao_input, gr.State(None), peticao_arquivo_input, modo_treinamento],
             outputs=[resultado_analise_output, resultado_peticao_corrigida_output, resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output],
-            concurrency_limit=1
-        ).then(lambda: gr.update(value="", visible=False), outputs=processing_message)
+            concurrency_limit=None
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            outputs=processing_message
+        )
 
-        # Atualiza config - removido timeout_slider dos inputs
-        config_update_btn.click(atualizar_config, [temperatura_slider, max_tokens_slider], config_status)
-        progresso_btn.click(calcular_progresso, outputs=progresso_output)
-        historico_btn.click(mostrar_historico, outputs=historico_output)
+        config_update_btn.click(
+            atualizar_config,
+            [temperatura_slider, timeout_slider, max_tokens_slider],
+            config_status
+        )
+        progresso_btn.click(
+            calcular_progresso,
+            outputs=progresso_output
+        )
+        historico_btn.click(
+            mostrar_historico,
+            outputs=historico_output
+        )
 
-        salvar_btn.click(lambda: gr.update(value="⏳ Salvando...", visible=True), outputs=processing_message).then(
-             fn=salvar_progresso, inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
-             outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
-        ).then(lambda x: gr.update(visible=bool(x)), [progresso_download_file], [progresso_download_file]
-        ).then(lambda: gr.update(value="", visible=False), None, processing_message)
+        salvar_btn.click(
+            fn=lambda: (logger.info("Botão Salvar clicado"), gr.update(value="⏳ Salvando...", visible=True))[1],
+            outputs=processing_message
+        ).then(
+            fn=salvar_progresso,
+            inputs=[caso_input, peticao_texto_input, tipo_peticao_input],
+            outputs=[gr.Textbox(visible=False), config_status, progresso_download_file]
+        ).then(
+            fn=lambda x: gr.update(visible=bool(x)),
+            inputs=[progresso_download_file],
+            outputs=[progresso_download_file]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            outputs=processing_message
+        )
 
-        carregar_btn.click(lambda: gr.update(value="⏳ Carregando...", visible=True), outputs=processing_message).then(
-             fn=carregar_progresso, inputs=[arquivo_progresso_upload],
-             outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
-         ).then(lambda: gr.update(value="", visible=False), None, processing_message)
+        carregar_btn.click(
+            fn=lambda: (logger.info("Botão Carregar clicado"), gr.update(value="⏳ Carregando...", visible=True))[1],
+            outputs=processing_message
+        ).then(
+            fn=carregar_progresso,
+            inputs=[arquivo_progresso_upload],
+            outputs=[tipo_peticao_input, caso_input, peticao_texto_input, config_status]
+        ).then(
+            fn=lambda: gr.update(value="", visible=False),
+            outputs=processing_message
+        )
 
         clear_btn.click(
             fn=lambda: ["Petição Inicial", False, None, None, None, None, "*Dicas...*", "", "", "", "", "", None, None, ""],
-            outputs=[tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
-                     arquivo_preview_output, dica_contextual_output, resultado_analise_output, resultado_peticao_corrigida_output,
-                     resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
-                     arquivo_progresso_upload, progresso_download_file, config_status]
+            outputs=[
+                tipo_peticao_input, modo_treinamento, caso_input, peticao_texto_input, peticao_arquivo_input,
+                arquivo_preview_output, dica_contextual_output, resultado_analise_output, resultado_peticao_corrigida_output,
+                resumo_alteracoes_output, criticas_output, visualizacao_detalhada_output,
+                arquivo_progresso_upload, progresso_download_file, config_status
+            ]
         )
+
     return demo
 
 if __name__ == "__main__":
     logger.info("Iniciando a aplicação Gradio...")
-    # Configuração opcional Tesseract (se necessário)
-    # try: pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract' # Ex: Linux
-    # except Exception as e: logger.warning(f"Tesseract não configurado: {e}")
-    app = interface_gradio()
-    app.launch()
+    try:
+        app = interface_gradio()
+        app.launch(debug=True)
+    except Exception as e:
+        logger.error(f"Erro ao iniciar Gradio: {str(e)}", exc_info=True)
+        raise
     logger.info("Aplicação Gradio encerrada.")