ParaAIV3.1

.backups/pre_fix_413/context_builder.py

@@ -0,0 +1,79 @@
+##PARA.AI/core/context_builder.py
+"""
+Context Builder - Constrói contexto para context injection V13.6
+Monta JSON parcial que especialista N deve VER (mas não modificar)
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from api.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ContextBuilder:
+    """
+    Constrói contexto para cada especialista
+
+    REGRA:
+    - Especialista N vê output de especialistas 1..N-1
+    - Mas vê apenas os campos RELEVANTES (não tudo)
+    - Evita explodir o prompt com dados desnecessários
+    """
+
+    def __init__(self):
+        # Mapear quais campos cada especialista precisa ver
+        self.context_rules = {
+            1: [],  # Segmentador: não precisa de contexto
+            2: ['secoes_originais'],  # Metadados: vê segmentação
+            3: ['metadados'],  # Classificador: vê metadados
+            4: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Relatório
+            5: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Fundamentação
+            6: ['metadados', 'secoes_originais'],  # Dispositivo
+            7: ['metadados', 'classificacao_tematica', 'RELATORIO', 'FUNDAMENTACAO', 'DECISAO']  # Arquivista
+        }
+
+    def build_context(
+        self, 
+        current_result: Dict[str, Any],
+        specialist_id: int
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Constrói contexto para um especialista específico
+
+        Args:
+            current_result: Resultado acumulado até agora
+            specialist_id: ID do especialista que vai receber o contexto
+
+        Returns:
+            Dicionário com campos relevantes ou None (se não precisa de contexto)
+        """
+        if specialist_id not in self.context_rules:
+            logger.warning(f"⚠️ Especialista {specialist_id} sem regra de contexto")
+            return None
+
+        fields_needed = self.context_rules[specialist_id]
+
+        if not fields_needed:
+            # Especialista não precisa de contexto
+            return None
+
+        # Montar contexto com apenas os campos necessários
+        context = {}
+
+        for field in fields_needed:
+            if field in current_result:
+                context[field] = current_result[field]
+
+        logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())}")
+
+        return context if context else None
+
+    def add_context_rule(self, specialist_id: int, fields: list):
+        """Adiciona/modifica regra de contexto para um especialista"""
+        self.context_rules[specialist_id] = fields
+        logger.info(f"✅ Regra de contexto atualizada para Especialista {specialist_id}")
+
+    def get_context_rules(self) -> Dict[int, list]:
+        """Retorna todas as regras de contexto"""
+        return self.context_rules

.backups/pre_fix_413/processor_base.py

@@ -0,0 +1,334 @@
+"""
+Classe Base Refatorada - Com Schema Injection automático
+Compatível com LLMManager do PARA.AI
+"""
+from abc import ABC
+from typing import Dict, Any, Optional
+from datetime import datetime
+import logging
+import json
+import os
+from pathlib import Path
+
+from processors.config_loader import get_config_loader, SpecialistConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorBase(ABC):
+    """
+    Classe abstrata base para processadores
+
+    FEATURES:
+    - Carrega configuração do YAML
+    - Schema injection automático no system_prompt
+    - Compatível com LLMManager (await llm_manager.generate())
+    """
+
+    def __init__(
+        self,
+        specialist_id: int,
+        llm_manager=None
+    ):
+        """
+        Args:
+            specialist_id: ID do especialista (1-9)
+            llm_manager: LLMManager para chamadas LLM
+        """
+        self.specialist_id = specialist_id
+        self.llm_manager = llm_manager
+
+        # Carregar configuração do YAML
+        config_loader = get_config_loader()
+        self.config: Optional[SpecialistConfig] = config_loader.get_specialist(specialist_id)
+
+        if not self.config:
+            raise ValueError(f"Especialista {specialist_id} não encontrado na configuração")
+
+        self.specialist_name = self.config.name
+        self.execution_time = 0
+        self.confidence_score = 0
+        self.errors = []
+        self.warnings = []
+
+        # 🔥 NOVA FEATURE: Carrega schema JSON e injeta no system_prompt
+        self._inject_schema_in_prompt()
+
+        logger.info(
+            f"✅ {self.specialist_name} inicializado "
+            f"(provider={self.config.llm_config.provider}, "
+            f"model={self.config.llm_config.model})"
+        )
+
+    def _inject_schema_in_prompt(self):
+        """
+        🔥 NOVA FUNÇÃO: Injeta schema JSON no system_prompt.
+
+        Carrega o schema do arquivo JSON correspondente e adiciona
+        ao final do system_prompt para garantir que o LLM retorne
+        JSON na estrutura correta.
+        """
+        try:
+            # Mapeamento de especialista para arquivo schema
+            schema_map = {
+                1: "metadados_schema.json",
+                2: "segmentacao_schema.json",
+                3: "transcricao_schema.json",
+                4: "contexto_schema.json",
+                5: "fundamentacao_schema.json",
+                6: "decisao_schema.json",
+                7: "arquivo_schema.json",
+                8: "relatorio_schema.json",
+                9: "auditoria_schema.json",
+            }
+
+            schema_filename = schema_map.get(self.specialist_id)
+            if not schema_filename:
+                logger.warning(f"⚠️ Schema não mapeado para especialista {self.specialist_id}")
+                return
+
+            # Localiza diretório de schemas
+            base_dir = Path(__file__).parent.parent
+            schema_path = base_dir / "prompts" / "schemas" / schema_filename
+
+            if not schema_path.exists():
+                logger.warning(f"⚠️ Schema não encontrado: {schema_path}")
+                return
+
+            # Carrega schema JSON
+            with open(schema_path, 'r', encoding='utf-8') as f:
+                schema_dict = json.load(f)
+
+            # Formata schema para injeção
+            schema_json = json.dumps(schema_dict, indent=2, ensure_ascii=False)
+
+            # Injeta no system_prompt
+            schema_instruction = f"""
+
+# JSON SCHEMA OBRIGATÓRIO
+
+Você DEVE retornar sua resposta seguindo EXATAMENTE este JSON Schema:
+
+```json
+{schema_json}
+```
+
+REGRAS CRÍTICAS:
+- Retorne APENAS JSON válido (sem comentários, sem texto adicional)
+- Siga TODOS os campos marcados como "required" no schema
+- Respeite os tipos de dados (string, integer, array, object, boolean)
+- Valide enums quando especificados
+- NÃO invente campos que não estão no schema
+- Use formato ISO 8601 para datas (YYYY-MM-DD)
+"""
+
+            # Adiciona schema ao system_prompt
+            self.config.system_prompt = self.config.system_prompt + schema_instruction
+
+            logger.info(f"✅ Schema {schema_filename} injetado em {self.specialist_name}")
+
+        except Exception as e:
+            logger.warning(f"⚠️ Falha ao injetar schema: {e}")
+
+    async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Processa acórdão usando LLM REAL via LLMManager.
+
+        Args:
+            acordao_data: Dados do acórdão
+
+        Returns:
+            Resultado do processamento
+        """
+        if not self.llm_manager:
+            raise ValueError("❌ LLMManager não configurado")
+
+        start_time = datetime.now()
+
+        try:
+            # 1. Formatar prompt do usuário com dados do acórdão
+            user_prompt = self.config.format_user_prompt(
+                tribunal=acordao_data.get('tribunal', 'N/A'),
+                numero_processo=acordao_data.get('numero_processo', 'N/A'),
+                ementa=acordao_data.get('ementa', ''),
+                integra=acordao_data.get('integra', ''),
+                classe_processual=acordao_data.get('classe_processual', 'N/A')
+            )
+
+            # 2. Chamar LLM Manager (system_prompt já tem schema injetado)
+            response = await self.llm_manager.generate(
+                provider=self.config.llm_config.provider,
+                model=self.config.llm_config.model,
+                system_prompt=self.config.system_prompt,  # 🔥 Com schema injetado
+                user_prompt=user_prompt,
+                temperature=self.config.llm_config.temperature,
+                max_tokens=self.config.llm_config.max_tokens
+            )
+
+            # 3. Processar resposta do LLMManager
+            if response['status'] == 'success':
+                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
+                llm_result = response['result']
+
+                # Extrair content e tokens
+                content = llm_result.get('content', '{}')
+                tokens_total = llm_result.get('total_tokens', 0)
+
+                # Parse JSON se for string
+                if isinstance(content, str):
+                    try:
+                        result = json.loads(content)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"❌ JSON inválido: {e}")
+                        logger.debug(f"Content recebido: {content[:500]}")
+                        raise ValueError(f"Resposta não é JSON válido: {e}")
+                else:
+                    result = content
+
+                # Validar
+                if not self.validate(result):
+                    self.add_warning("Resultado não passou na validação completa")
+
+                # Calcular confiança
+                self.confidence_score = self._calculate_confidence(result)
+
+            else:
+                # Erro na chamada LLM
+                error_msg = response.get('error', 'Erro desconhecido')
+                raise ValueError(f"Erro na chamada LLM: {error_msg}")
+
+            # 4. Pós-processar
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return self.post_process(result)
+
+        except Exception as e:
+            self.add_error(f"Erro no processamento: {e}")
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return {
+                "specialist_id": self.specialist_id,
+                "specialist_name": self.specialist_name,
+                "status": "error",
+                "error": str(e),
+                "execution_time": self.execution_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    def validate(self, result: Dict[str, Any]) -> bool:
+        """
+        Valida resultado contra schema.
+
+        Args:
+            result: Resultado a validar
+
+        Returns:
+            True se válido
+        """
+        try:
+            # Validação básica: verificar campos required do schema
+            schema = self.config.schema
+
+            # Verifica se schema existe e tem required fields
+            if not isinstance(schema, dict):
+                logger.warning(f"⚠️ Schema não é um dict para {self.specialist_name}")
+                return True
+
+            required_fields = schema.get('required', [])
+            if not required_fields:
+                logger.debug(f"✓ Schema sem campos required para {self.specialist_name}")
+                return True
+
+            # Verifica se result é dict
+            if not isinstance(result, dict):
+                self.add_warning(f"Resultado não é um dict: {type(result)}")
+                return False
+
+            # Verifica campos required
+            missing_fields = []
+            for field in required_fields:
+                if field not in result:
+                    missing_fields.append(field)
+
+            if missing_fields:
+                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
+                return False
+
+            return True
+
+        except Exception as e:
+            self.add_error(f"Erro na validação: {e}")
+            return False
+
+    def _calculate_confidence(self, result: Dict[str, Any]) -> int:
+        """
+        Calcula score de confiança baseado no resultado.
+
+        Returns:
+            Score 0-100
+        """
+        try:
+            # Lógica simples: quanto mais campos preenchidos, maior confiança
+            schema = self.config.schema
+
+            if not isinstance(schema, dict):
+                return 85  # Padrão se schema inválido
+
+            required_fields = schema.get('required', [])
+
+            if not required_fields:
+                return 85  # Padrão
+
+            if not isinstance(result, dict):
+                return 0
+
+            filled = sum(1 for field in required_fields if result.get(field))
+            confidence = int((filled / len(required_fields)) * 100)
+
+            return min(confidence, 100)
+
+        except Exception:
+            return 85
+
+    def post_process(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Pós-processa resultado"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "result": result,
+            "execution_time": self.execution_time,
+            "confidence_score": self.confidence_score,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "timestamp": datetime.now().isoformat(),
+            "config": {
+                "provider": self.config.llm_config.provider,
+                "model": self.config.llm_config.model,
+                "temperature": self.config.llm_config.temperature
+            }
+        }
+
+    def add_error(self, error_msg: str):
+        """Adiciona erro"""
+        self.errors.append(error_msg)
+        logger.error(f"[{self.specialist_name}] {error_msg}")
+
+    def add_warning(self, warning_msg: str):
+        """Adiciona aviso"""
+        self.warnings.append(warning_msg)
+        logger.warning(f"[{self.specialist_name}] {warning_msg}")
+
+    def get_schema(self) -> Dict[str, Any]:
+        """Retorna schema do especialista"""
+        return self.config.schema
+
+    @property
+    def info(self) -> Dict[str, Any]:
+        """Retorna informações sobre o processador"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "provider": self.config.llm_config.provider,
+            "model": self.config.llm_config.model,
+            "schema": self.config.schema
+        }

.backups/pre_fix_413_20260116_230634/context_builder.py

@@ -0,0 +1,79 @@
+##PARA.AI/core/context_builder.py
+"""
+Context Builder - Constrói contexto para context injection V13.6
+Monta JSON parcial que especialista N deve VER (mas não modificar)
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from api.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ContextBuilder:
+    """
+    Constrói contexto para cada especialista
+
+    REGRA:
+    - Especialista N vê output de especialistas 1..N-1
+    - Mas vê apenas os campos RELEVANTES (não tudo)
+    - Evita explodir o prompt com dados desnecessários
+    """
+
+    def __init__(self):
+        # Mapear quais campos cada especialista precisa ver
+        self.context_rules = {
+            1: [],  # Segmentador: não precisa de contexto
+            2: ['secoes_originais'],  # Metadados: vê segmentação
+            3: ['metadados'],  # Classificador: vê metadados
+            4: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Relatório
+            5: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Fundamentação
+            6: ['metadados', 'secoes_originais'],  # Dispositivo
+            7: ['metadados', 'classificacao_tematica', 'RELATORIO', 'FUNDAMENTACAO', 'DECISAO']  # Arquivista
+        }
+
+    def build_context(
+        self, 
+        current_result: Dict[str, Any],
+        specialist_id: int
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Constrói contexto para um especialista específico
+
+        Args:
+            current_result: Resultado acumulado até agora
+            specialist_id: ID do especialista que vai receber o contexto
+
+        Returns:
+            Dicionário com campos relevantes ou None (se não precisa de contexto)
+        """
+        if specialist_id not in self.context_rules:
+            logger.warning(f"⚠️ Especialista {specialist_id} sem regra de contexto")
+            return None
+
+        fields_needed = self.context_rules[specialist_id]
+
+        if not fields_needed:
+            # Especialista não precisa de contexto
+            return None
+
+        # Montar contexto com apenas os campos necessários
+        context = {}
+
+        for field in fields_needed:
+            if field in current_result:
+                context[field] = current_result[field]
+
+        logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())}")
+
+        return context if context else None
+
+    def add_context_rule(self, specialist_id: int, fields: list):
+        """Adiciona/modifica regra de contexto para um especialista"""
+        self.context_rules[specialist_id] = fields
+        logger.info(f"✅ Regra de contexto atualizada para Especialista {specialist_id}")
+
+    def get_context_rules(self) -> Dict[int, list]:
+        """Retorna todas as regras de contexto"""
+        return self.context_rules

.backups/pre_fix_413_20260116_230634/processor_base.py

@@ -0,0 +1,334 @@
+"""
+Classe Base Refatorada - Com Schema Injection automático
+Compatível com LLMManager do PARA.AI
+"""
+from abc import ABC
+from typing import Dict, Any, Optional
+from datetime import datetime
+import logging
+import json
+import os
+from pathlib import Path
+
+from processors.config_loader import get_config_loader, SpecialistConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorBase(ABC):
+    """
+    Classe abstrata base para processadores
+
+    FEATURES:
+    - Carrega configuração do YAML
+    - Schema injection automático no system_prompt
+    - Compatível com LLMManager (await llm_manager.generate())
+    """
+
+    def __init__(
+        self,
+        specialist_id: int,
+        llm_manager=None
+    ):
+        """
+        Args:
+            specialist_id: ID do especialista (1-9)
+            llm_manager: LLMManager para chamadas LLM
+        """
+        self.specialist_id = specialist_id
+        self.llm_manager = llm_manager
+
+        # Carregar configuração do YAML
+        config_loader = get_config_loader()
+        self.config: Optional[SpecialistConfig] = config_loader.get_specialist(specialist_id)
+
+        if not self.config:
+            raise ValueError(f"Especialista {specialist_id} não encontrado na configuração")
+
+        self.specialist_name = self.config.name
+        self.execution_time = 0
+        self.confidence_score = 0
+        self.errors = []
+        self.warnings = []
+
+        # 🔥 NOVA FEATURE: Carrega schema JSON e injeta no system_prompt
+        self._inject_schema_in_prompt()
+
+        logger.info(
+            f"✅ {self.specialist_name} inicializado "
+            f"(provider={self.config.llm_config.provider}, "
+            f"model={self.config.llm_config.model})"
+        )
+
+    def _inject_schema_in_prompt(self):
+        """
+        🔥 NOVA FUNÇÃO: Injeta schema JSON no system_prompt.
+
+        Carrega o schema do arquivo JSON correspondente e adiciona
+        ao final do system_prompt para garantir que o LLM retorne
+        JSON na estrutura correta.
+        """
+        try:
+            # Mapeamento de especialista para arquivo schema
+            schema_map = {
+                1: "metadados_schema.json",
+                2: "segmentacao_schema.json",
+                3: "transcricao_schema.json",
+                4: "contexto_schema.json",
+                5: "fundamentacao_schema.json",
+                6: "decisao_schema.json",
+                7: "arquivo_schema.json",
+                8: "relatorio_schema.json",
+                9: "auditoria_schema.json",
+            }
+
+            schema_filename = schema_map.get(self.specialist_id)
+            if not schema_filename:
+                logger.warning(f"⚠️ Schema não mapeado para especialista {self.specialist_id}")
+                return
+
+            # Localiza diretório de schemas
+            base_dir = Path(__file__).parent.parent
+            schema_path = base_dir / "prompts" / "schemas" / schema_filename
+
+            if not schema_path.exists():
+                logger.warning(f"⚠️ Schema não encontrado: {schema_path}")
+                return
+
+            # Carrega schema JSON
+            with open(schema_path, 'r', encoding='utf-8') as f:
+                schema_dict = json.load(f)
+
+            # Formata schema para injeção
+            schema_json = json.dumps(schema_dict, indent=2, ensure_ascii=False)
+
+            # Injeta no system_prompt
+            schema_instruction = f"""
+
+# JSON SCHEMA OBRIGATÓRIO
+
+Você DEVE retornar sua resposta seguindo EXATAMENTE este JSON Schema:
+
+```json
+{schema_json}
+```
+
+REGRAS CRÍTICAS:
+- Retorne APENAS JSON válido (sem comentários, sem texto adicional)
+- Siga TODOS os campos marcados como "required" no schema
+- Respeite os tipos de dados (string, integer, array, object, boolean)
+- Valide enums quando especificados
+- NÃO invente campos que não estão no schema
+- Use formato ISO 8601 para datas (YYYY-MM-DD)
+"""
+
+            # Adiciona schema ao system_prompt
+            self.config.system_prompt = self.config.system_prompt + schema_instruction
+
+            logger.info(f"✅ Schema {schema_filename} injetado em {self.specialist_name}")
+
+        except Exception as e:
+            logger.warning(f"⚠️ Falha ao injetar schema: {e}")
+
+    async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Processa acórdão usando LLM REAL via LLMManager.
+
+        Args:
+            acordao_data: Dados do acórdão
+
+        Returns:
+            Resultado do processamento
+        """
+        if not self.llm_manager:
+            raise ValueError("❌ LLMManager não configurado")
+
+        start_time = datetime.now()
+
+        try:
+            # 1. Formatar prompt do usuário com dados do acórdão
+            user_prompt = self.config.format_user_prompt(
+                tribunal=acordao_data.get('tribunal', 'N/A'),
+                numero_processo=acordao_data.get('numero_processo', 'N/A'),
+                ementa=acordao_data.get('ementa', ''),
+                integra=acordao_data.get('integra', ''),
+                classe_processual=acordao_data.get('classe_processual', 'N/A')
+            )
+
+            # 2. Chamar LLM Manager (system_prompt já tem schema injetado)
+            response = await self.llm_manager.generate(
+                provider=self.config.llm_config.provider,
+                model=self.config.llm_config.model,
+                system_prompt=self.config.system_prompt,  # 🔥 Com schema injetado
+                user_prompt=user_prompt,
+                temperature=self.config.llm_config.temperature,
+                max_tokens=self.config.llm_config.max_tokens
+            )
+
+            # 3. Processar resposta do LLMManager
+            if response['status'] == 'success':
+                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
+                llm_result = response['result']
+
+                # Extrair content e tokens
+                content = llm_result.get('content', '{}')
+                tokens_total = llm_result.get('total_tokens', 0)
+
+                # Parse JSON se for string
+                if isinstance(content, str):
+                    try:
+                        result = json.loads(content)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"❌ JSON inválido: {e}")
+                        logger.debug(f"Content recebido: {content[:500]}")
+                        raise ValueError(f"Resposta não é JSON válido: {e}")
+                else:
+                    result = content
+
+                # Validar
+                if not self.validate(result):
+                    self.add_warning("Resultado não passou na validação completa")
+
+                # Calcular confiança
+                self.confidence_score = self._calculate_confidence(result)
+
+            else:
+                # Erro na chamada LLM
+                error_msg = response.get('error', 'Erro desconhecido')
+                raise ValueError(f"Erro na chamada LLM: {error_msg}")
+
+            # 4. Pós-processar
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return self.post_process(result)
+
+        except Exception as e:
+            self.add_error(f"Erro no processamento: {e}")
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return {
+                "specialist_id": self.specialist_id,
+                "specialist_name": self.specialist_name,
+                "status": "error",
+                "error": str(e),
+                "execution_time": self.execution_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    def validate(self, result: Dict[str, Any]) -> bool:
+        """
+        Valida resultado contra schema.
+
+        Args:
+            result: Resultado a validar
+
+        Returns:
+            True se válido
+        """
+        try:
+            # Validação básica: verificar campos required do schema
+            schema = self.config.schema
+
+            # Verifica se schema existe e tem required fields
+            if not isinstance(schema, dict):
+                logger.warning(f"⚠️ Schema não é um dict para {self.specialist_name}")
+                return True
+
+            required_fields = schema.get('required', [])
+            if not required_fields:
+                logger.debug(f"✓ Schema sem campos required para {self.specialist_name}")
+                return True
+
+            # Verifica se result é dict
+            if not isinstance(result, dict):
+                self.add_warning(f"Resultado não é um dict: {type(result)}")
+                return False
+
+            # Verifica campos required
+            missing_fields = []
+            for field in required_fields:
+                if field not in result:
+                    missing_fields.append(field)
+
+            if missing_fields:
+                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
+                return False
+
+            return True
+
+        except Exception as e:
+            self.add_error(f"Erro na validação: {e}")
+            return False
+
+    def _calculate_confidence(self, result: Dict[str, Any]) -> int:
+        """
+        Calcula score de confiança baseado no resultado.
+
+        Returns:
+            Score 0-100
+        """
+        try:
+            # Lógica simples: quanto mais campos preenchidos, maior confiança
+            schema = self.config.schema
+
+            if not isinstance(schema, dict):
+                return 85  # Padrão se schema inválido
+
+            required_fields = schema.get('required', [])
+
+            if not required_fields:
+                return 85  # Padrão
+
+            if not isinstance(result, dict):
+                return 0
+
+            filled = sum(1 for field in required_fields if result.get(field))
+            confidence = int((filled / len(required_fields)) * 100)
+
+            return min(confidence, 100)
+
+        except Exception:
+            return 85
+
+    def post_process(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Pós-processa resultado"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "result": result,
+            "execution_time": self.execution_time,
+            "confidence_score": self.confidence_score,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "timestamp": datetime.now().isoformat(),
+            "config": {
+                "provider": self.config.llm_config.provider,
+                "model": self.config.llm_config.model,
+                "temperature": self.config.llm_config.temperature
+            }
+        }
+
+    def add_error(self, error_msg: str):
+        """Adiciona erro"""
+        self.errors.append(error_msg)
+        logger.error(f"[{self.specialist_name}] {error_msg}")
+
+    def add_warning(self, warning_msg: str):
+        """Adiciona aviso"""
+        self.warnings.append(warning_msg)
+        logger.warning(f"[{self.specialist_name}] {warning_msg}")
+
+    def get_schema(self) -> Dict[str, Any]:
+        """Retorna schema do especialista"""
+        return self.config.schema
+
+    @property
+    def info(self) -> Dict[str, Any]:
+        """Retorna informações sobre o processador"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "provider": self.config.llm_config.provider,
+            "model": self.config.llm_config.model,
+            "schema": self.config.schema
+        }

.backups/pre_fix_413_20260116_231356/context_builder.py

@@ -0,0 +1,79 @@
+##PARA.AI/core/context_builder.py
+"""
+Context Builder - Constrói contexto para context injection V13.6
+Monta JSON parcial que especialista N deve VER (mas não modificar)
+"""
+import logging
+from typing import Dict, Any, Optional
+
+from api.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ContextBuilder:
+    """
+    Constrói contexto para cada especialista
+
+    REGRA:
+    - Especialista N vê output de especialistas 1..N-1
+    - Mas vê apenas os campos RELEVANTES (não tudo)
+    - Evita explodir o prompt com dados desnecessários
+    """
+
+    def __init__(self):
+        # Mapear quais campos cada especialista precisa ver
+        self.context_rules = {
+            1: [],  # Segmentador: não precisa de contexto
+            2: ['secoes_originais'],  # Metadados: vê segmentação
+            3: ['metadados'],  # Classificador: vê metadados
+            4: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Relatório
+            5: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Fundamentação
+            6: ['metadados', 'secoes_originais'],  # Dispositivo
+            7: ['metadados', 'classificacao_tematica', 'RELATORIO', 'FUNDAMENTACAO', 'DECISAO']  # Arquivista
+        }
+
+    def build_context(
+        self, 
+        current_result: Dict[str, Any],
+        specialist_id: int
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Constrói contexto para um especialista específico
+
+        Args:
+            current_result: Resultado acumulado até agora
+            specialist_id: ID do especialista que vai receber o contexto
+
+        Returns:
+            Dicionário com campos relevantes ou None (se não precisa de contexto)
+        """
+        if specialist_id not in self.context_rules:
+            logger.warning(f"⚠️ Especialista {specialist_id} sem regra de contexto")
+            return None
+
+        fields_needed = self.context_rules[specialist_id]
+
+        if not fields_needed:
+            # Especialista não precisa de contexto
+            return None
+
+        # Montar contexto com apenas os campos necessários
+        context = {}
+
+        for field in fields_needed:
+            if field in current_result:
+                context[field] = current_result[field]
+
+        logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())}")
+
+        return context if context else None
+
+    def add_context_rule(self, specialist_id: int, fields: list):
+        """Adiciona/modifica regra de contexto para um especialista"""
+        self.context_rules[specialist_id] = fields
+        logger.info(f"✅ Regra de contexto atualizada para Especialista {specialist_id}")
+
+    def get_context_rules(self) -> Dict[int, list]:
+        """Retorna todas as regras de contexto"""
+        return self.context_rules

.backups/pre_fix_413_20260116_231356/processor_base.py

@@ -0,0 +1,334 @@
+"""
+Classe Base Refatorada - Com Schema Injection automático
+Compatível com LLMManager do PARA.AI
+"""
+from abc import ABC
+from typing import Dict, Any, Optional
+from datetime import datetime
+import logging
+import json
+import os
+from pathlib import Path
+
+from processors.config_loader import get_config_loader, SpecialistConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorBase(ABC):
+    """
+    Classe abstrata base para processadores
+
+    FEATURES:
+    - Carrega configuração do YAML
+    - Schema injection automático no system_prompt
+    - Compatível com LLMManager (await llm_manager.generate())
+    """
+
+    def __init__(
+        self,
+        specialist_id: int,
+        llm_manager=None
+    ):
+        """
+        Args:
+            specialist_id: ID do especialista (1-9)
+            llm_manager: LLMManager para chamadas LLM
+        """
+        self.specialist_id = specialist_id
+        self.llm_manager = llm_manager
+
+        # Carregar configuração do YAML
+        config_loader = get_config_loader()
+        self.config: Optional[SpecialistConfig] = config_loader.get_specialist(specialist_id)
+
+        if not self.config:
+            raise ValueError(f"Especialista {specialist_id} não encontrado na configuração")
+
+        self.specialist_name = self.config.name
+        self.execution_time = 0
+        self.confidence_score = 0
+        self.errors = []
+        self.warnings = []
+
+        # 🔥 NOVA FEATURE: Carrega schema JSON e injeta no system_prompt
+        self._inject_schema_in_prompt()
+
+        logger.info(
+            f"✅ {self.specialist_name} inicializado "
+            f"(provider={self.config.llm_config.provider}, "
+            f"model={self.config.llm_config.model})"
+        )
+
+    def _inject_schema_in_prompt(self):
+        """
+        🔥 NOVA FUNÇÃO: Injeta schema JSON no system_prompt.
+
+        Carrega o schema do arquivo JSON correspondente e adiciona
+        ao final do system_prompt para garantir que o LLM retorne
+        JSON na estrutura correta.
+        """
+        try:
+            # Mapeamento de especialista para arquivo schema
+            schema_map = {
+                1: "metadados_schema.json",
+                2: "segmentacao_schema.json",
+                3: "transcricao_schema.json",
+                4: "contexto_schema.json",
+                5: "fundamentacao_schema.json",
+                6: "decisao_schema.json",
+                7: "arquivo_schema.json",
+                8: "relatorio_schema.json",
+                9: "auditoria_schema.json",
+            }
+
+            schema_filename = schema_map.get(self.specialist_id)
+            if not schema_filename:
+                logger.warning(f"⚠️ Schema não mapeado para especialista {self.specialist_id}")
+                return
+
+            # Localiza diretório de schemas
+            base_dir = Path(__file__).parent.parent
+            schema_path = base_dir / "prompts" / "schemas" / schema_filename
+
+            if not schema_path.exists():
+                logger.warning(f"⚠️ Schema não encontrado: {schema_path}")
+                return
+
+            # Carrega schema JSON
+            with open(schema_path, 'r', encoding='utf-8') as f:
+                schema_dict = json.load(f)
+
+            # Formata schema para injeção
+            schema_json = json.dumps(schema_dict, indent=2, ensure_ascii=False)
+
+            # Injeta no system_prompt
+            schema_instruction = f"""
+
+# JSON SCHEMA OBRIGATÓRIO
+
+Você DEVE retornar sua resposta seguindo EXATAMENTE este JSON Schema:
+
+```json
+{schema_json}
+```
+
+REGRAS CRÍTICAS:
+- Retorne APENAS JSON válido (sem comentários, sem texto adicional)
+- Siga TODOS os campos marcados como "required" no schema
+- Respeite os tipos de dados (string, integer, array, object, boolean)
+- Valide enums quando especificados
+- NÃO invente campos que não estão no schema
+- Use formato ISO 8601 para datas (YYYY-MM-DD)
+"""
+
+            # Adiciona schema ao system_prompt
+            self.config.system_prompt = self.config.system_prompt + schema_instruction
+
+            logger.info(f"✅ Schema {schema_filename} injetado em {self.specialist_name}")
+
+        except Exception as e:
+            logger.warning(f"⚠️ Falha ao injetar schema: {e}")
+
+    async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Processa acórdão usando LLM REAL via LLMManager.
+
+        Args:
+            acordao_data: Dados do acórdão
+
+        Returns:
+            Resultado do processamento
+        """
+        if not self.llm_manager:
+            raise ValueError("❌ LLMManager não configurado")
+
+        start_time = datetime.now()
+
+        try:
+            # 1. Formatar prompt do usuário com dados do acórdão
+            user_prompt = self.config.format_user_prompt(
+                tribunal=acordao_data.get('tribunal', 'N/A'),
+                numero_processo=acordao_data.get('numero_processo', 'N/A'),
+                ementa=acordao_data.get('ementa', ''),
+                integra=acordao_data.get('integra', ''),
+                classe_processual=acordao_data.get('classe_processual', 'N/A')
+            )
+
+            # 2. Chamar LLM Manager (system_prompt já tem schema injetado)
+            response = await self.llm_manager.generate(
+                provider=self.config.llm_config.provider,
+                model=self.config.llm_config.model,
+                system_prompt=self.config.system_prompt,  # 🔥 Com schema injetado
+                user_prompt=user_prompt,
+                temperature=self.config.llm_config.temperature,
+                max_tokens=self.config.llm_config.max_tokens
+            )
+
+            # 3. Processar resposta do LLMManager
+            if response['status'] == 'success':
+                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
+                llm_result = response['result']
+
+                # Extrair content e tokens
+                content = llm_result.get('content', '{}')
+                tokens_total = llm_result.get('total_tokens', 0)
+
+                # Parse JSON se for string
+                if isinstance(content, str):
+                    try:
+                        result = json.loads(content)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"❌ JSON inválido: {e}")
+                        logger.debug(f"Content recebido: {content[:500]}")
+                        raise ValueError(f"Resposta não é JSON válido: {e}")
+                else:
+                    result = content
+
+                # Validar
+                if not self.validate(result):
+                    self.add_warning("Resultado não passou na validação completa")
+
+                # Calcular confiança
+                self.confidence_score = self._calculate_confidence(result)
+
+            else:
+                # Erro na chamada LLM
+                error_msg = response.get('error', 'Erro desconhecido')
+                raise ValueError(f"Erro na chamada LLM: {error_msg}")
+
+            # 4. Pós-processar
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return self.post_process(result)
+
+        except Exception as e:
+            self.add_error(f"Erro no processamento: {e}")
+            self.execution_time = (datetime.now() - start_time).total_seconds()
+
+            return {
+                "specialist_id": self.specialist_id,
+                "specialist_name": self.specialist_name,
+                "status": "error",
+                "error": str(e),
+                "execution_time": self.execution_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    def validate(self, result: Dict[str, Any]) -> bool:
+        """
+        Valida resultado contra schema.
+
+        Args:
+            result: Resultado a validar
+
+        Returns:
+            True se válido
+        """
+        try:
+            # Validação básica: verificar campos required do schema
+            schema = self.config.schema
+
+            # Verifica se schema existe e tem required fields
+            if not isinstance(schema, dict):
+                logger.warning(f"⚠️ Schema não é um dict para {self.specialist_name}")
+                return True
+
+            required_fields = schema.get('required', [])
+            if not required_fields:
+                logger.debug(f"✓ Schema sem campos required para {self.specialist_name}")
+                return True
+
+            # Verifica se result é dict
+            if not isinstance(result, dict):
+                self.add_warning(f"Resultado não é um dict: {type(result)}")
+                return False
+
+            # Verifica campos required
+            missing_fields = []
+            for field in required_fields:
+                if field not in result:
+                    missing_fields.append(field)
+
+            if missing_fields:
+                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
+                return False
+
+            return True
+
+        except Exception as e:
+            self.add_error(f"Erro na validação: {e}")
+            return False
+
+    def _calculate_confidence(self, result: Dict[str, Any]) -> int:
+        """
+        Calcula score de confiança baseado no resultado.
+
+        Returns:
+            Score 0-100
+        """
+        try:
+            # Lógica simples: quanto mais campos preenchidos, maior confiança
+            schema = self.config.schema
+
+            if not isinstance(schema, dict):
+                return 85  # Padrão se schema inválido
+
+            required_fields = schema.get('required', [])
+
+            if not required_fields:
+                return 85  # Padrão
+
+            if not isinstance(result, dict):
+                return 0
+
+            filled = sum(1 for field in required_fields if result.get(field))
+            confidence = int((filled / len(required_fields)) * 100)
+
+            return min(confidence, 100)
+
+        except Exception:
+            return 85
+
+    def post_process(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Pós-processa resultado"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "result": result,
+            "execution_time": self.execution_time,
+            "confidence_score": self.confidence_score,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "timestamp": datetime.now().isoformat(),
+            "config": {
+                "provider": self.config.llm_config.provider,
+                "model": self.config.llm_config.model,
+                "temperature": self.config.llm_config.temperature
+            }
+        }
+
+    def add_error(self, error_msg: str):
+        """Adiciona erro"""
+        self.errors.append(error_msg)
+        logger.error(f"[{self.specialist_name}] {error_msg}")
+
+    def add_warning(self, warning_msg: str):
+        """Adiciona aviso"""
+        self.warnings.append(warning_msg)
+        logger.warning(f"[{self.specialist_name}] {warning_msg}")
+
+    def get_schema(self) -> Dict[str, Any]:
+        """Retorna schema do especialista"""
+        return self.config.schema
+
+    @property
+    def info(self) -> Dict[str, Any]:
+        """Retorna informações sobre o processador"""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "provider": self.config.llm_config.provider,
+            "model": self.config.llm_config.model,
+            "schema": self.config.schema
+        }

core/context_builder.py

@@ -1,14 +1,14 @@
 ##PARA.AI/core/context_builder.py
 """
-Context Builder - Constrói contexto para context injection V13.6
+Context Builder - Constrói contexto para context injection V13.6 CORRIGIDO
 Monta JSON parcial que especialista N deve VER (mas não modificar)
+
+CORREÇÃO: Ajustado mapeamento de campos para compatibilidade V13.1
 """
 import logging
 from typing import Dict, Any, Optional
 
-from api.utils.logger import setup_logger
-
-logger = setup_logger(__name__)
+logger = logging.getLogger(__name__)
 
 
 class ContextBuilder:
@@ -22,15 +22,53 @@ class ContextBuilder:
     """
 
     def __init__(self):
-        # Mapear quais campos cada especialista precisa ver
+        # CORRIGIDO: Mapear quais campos cada especialista precisa ver
+        # Ajustado para os nomes de campos REAIS que os processadores V13.1 retornam
         self.context_rules = {
             1: [],  # Segmentador: não precisa de contexto
-            2: ['secoes_originais'],  # Metadados: vê segmentação
-            3: ['metadados'],  # Classificador: vê metadados
-            4: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Relatório
-            5: ['metadados', 'classificacao_tematica', 'secoes_originais'],  # Fundamentação
-            6: ['metadados', 'secoes_originais'],  # Dispositivo
-            7: ['metadados', 'classificacao_tematica', 'RELATORIO', 'FUNDAMENTACAO', 'DECISAO']  # Arquivista
+
+            2: [  # Metadados: vê segmentação
+                'secoes_originais',
+                'RELATORIO_texto_completo',
+                'FUNDAMENTACAO_texto_completo', 
+                'DISPOSITIVO_texto_completo',
+            ],
+
+            3: [  # Classificador: vê metadados
+                'metadados',
+                'tribunal',
+                'orgao_julgador',
+                'classe_processual',
+            ],
+
+            4: [  # Relatório: vê segmentação, metadados, classificação
+                'metadados',
+                'classificacao_tematica',
+                'RELATORIO_texto_completo',  # CORRIGIDO: nome correto do campo
+            ],
+
+            5: [  # Fundamentação: vê segmentação, metadados, classificação
+                'metadados',
+                'classificacao_tematica',
+                'FUNDAMENTACAO_texto_completo',  # CORRIGIDO: nome correto
+            ],
+
+            6: [  # Dispositivo: vê segmentação, metadados
+                'metadados',
+                'DISPOSITIVO_texto_completo',  # CORRIGIDO: nome correto
+                'ementa',  # Adicionado: dispositivo precisa da ementa
+            ],
+
+            7: [  # Arquivista: vê TUDO (análise meta-cognitiva)
+                'metadados',
+                'classificacao_tematica',
+                'RELATORIO',
+                'FUNDAMENTACAO',
+                'DECISAO',
+                'teses_fragmentadas',
+                'teses_relator',
+                'mapa_pedidos',
+            ]
         }
 
     def build_context(
@@ -62,10 +100,20 @@ class ContextBuilder:
         context = {}
 
         for field in fields_needed:
+            # CORRIGIDO: Buscar campo em diferentes níveis de aninhamento
             if field in current_result:
                 context[field] = current_result[field]
-
-        logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())}")
+            elif 'secoes_originais' in current_result and field in current_result['secoes_originais']:
+                context[field] = current_result['secoes_originais'][field]
+            elif 'metadados' in current_result and isinstance(current_result['metadados'], dict):
+                if field in current_result['metadados']:
+                    context[field] = current_result['metadados'][field]
+
+        # CORRIGIDO: Log mais informativo
+        if context:
+            logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())} ({len(str(context))} chars)")
+        else:
+            logger.debug(f"📦 Contexto para Especialista {specialist_id}: vazio")
 
         return context if context else None
 

core/payload_manager.py

@@ -0,0 +1,203 @@
+##PARA.AI/core/payload_manager.py
+"""
+Payload Manager - Gerencia tamanho de payloads para evitar erro 413
+NOVO: Criado para V13.6
+"""
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PayloadManager:
+    """
+    Gerenciador de payloads para evitar erro 413
+
+    LIMITES GROQ:
+    - Llama 3.1 70B: ~8k tokens contexto (~32k chars)
+    - Erro 413 ocorre em ~128k chars total
+
+    ESTRATÉGIA:
+    - Truncar cada seção para 15k chars
+    - Payload total máximo: 50k chars
+    """
+
+    # Limites conservadores
+    MAX_SECTION_CHARS = 15000
+    MAX_TOTAL_CHARS = 50000
+    MAX_CONTEXT_CHARS = 10000  # Para o contexto de especialistas anteriores
+
+    def __init__(self):
+        logger.info("✅ PayloadManager inicializado")
+
+    def truncate_text(
+        self, 
+        text: str, 
+        max_chars: int = None,
+        add_marker: bool = True
+    ) -> str:
+        """
+        Trunca texto de forma inteligente
+
+        Args:
+            text: Texto a truncar
+            max_chars: Máximo de caracteres (padrão: MAX_SECTION_CHARS)
+            add_marker: Se True, adiciona marcador de truncamento
+
+        Returns:
+            Texto truncado
+        """
+        if not text or not isinstance(text, str):
+            return ""
+
+        max_chars = max_chars or self.MAX_SECTION_CHARS
+
+        if len(text) <= max_chars:
+            return text
+
+        # Truncar
+        truncated = text[:max_chars]
+
+        # Encontrar último espaço para não cortar palavra
+        last_space = truncated.rfind(' ')
+        if last_space > max_chars * 0.9:
+            truncated = truncated[:last_space]
+
+        if add_marker:
+            truncated += "\n\n[... TEXTO TRUNCADO PARA REDUZIR PAYLOAD ...]"
+
+        logger.debug(f"✂️ Truncado: {len(text)} → {len(truncated)} chars")
+
+        return truncated
+
+    def prepare_acordao_for_llm(
+        self, 
+        acordao_data: Dict[str, Any],
+        keep_full: Optional[list] = None
+    ) -> Dict[str, Any]:
+        """
+        Prepara acórdão para LLM truncando textos longos
+
+        Args:
+            acordao_data: Dados completos do acórdão
+            keep_full: Lista de campos para NÃO truncar (opcional)
+
+        Returns:
+            Dados preparados e truncados
+        """
+        keep_full = keep_full or []
+        prepared = acordao_data.copy()
+
+        # Campos de texto para truncar
+        text_fields = {
+            'inteiro_teor': self.MAX_SECTION_CHARS,
+            'ementa': 3000,  # Ementa geralmente é curta
+            'RELATORIO_texto_completo': self.MAX_SECTION_CHARS,
+            'FUNDAMENTACAO_texto_completo': self.MAX_SECTION_CHARS,
+            'DISPOSITIVO_texto_completo': self.MAX_SECTION_CHARS,
+        }
+
+        for field, max_chars in text_fields.items():
+            if field in keep_full:
+                continue
+
+            # Truncar em nível raiz
+            if field in prepared and isinstance(prepared[field], str):
+                prepared[field] = self.truncate_text(prepared[field], max_chars)
+
+            # Truncar em secoes_originais
+            if 'secoes_originais' in prepared and isinstance(prepared['secoes_originais'], dict):
+                if field in prepared['secoes_originais']:
+                    if isinstance(prepared['secoes_originais'][field], str):
+                        prepared['secoes_originais'][field] = self.truncate_text(
+                            prepared['secoes_originais'][field],
+                            max_chars
+                        )
+
+        return prepared
+
+    def truncate_context(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Trunca contexto de especialistas anteriores
+
+        Args:
+            context: Contexto completo
+
+        Returns:
+            Contexto truncado
+        """
+        if not context:
+            return {}
+
+        truncated = {}
+
+        for key, value in context.items():
+            if isinstance(value, str):
+                # Truncar strings longas
+                truncated[key] = self.truncate_text(
+                    value,
+                    self.MAX_CONTEXT_CHARS,
+                    add_marker=False
+                )
+            elif isinstance(value, dict):
+                # Recursivo para dicionários aninhados
+                truncated[key] = self.truncate_context(value)
+            elif isinstance(value, list):
+                # Para listas, truncar strings internas
+                truncated[key] = [
+                    self.truncate_text(item, 1000, add_marker=False)
+                    if isinstance(item, str)
+                    else item
+                    for item in value[:10]  # Máximo 10 itens
+                ]
+            else:
+                # Outros tipos: copiar direto
+                truncated[key] = value
+
+        return truncated
+
+    def estimate_payload_size(self, data: Dict[str, Any]) -> int:
+        """
+        Estima tamanho do payload em caracteres
+
+        Args:
+            data: Dados a estimar
+
+        Returns:
+            Tamanho aproximado em caracteres
+        """
+        import json
+        try:
+            json_str = json.dumps(data, ensure_ascii=False)
+            return len(json_str)
+        except:
+            return len(str(data))
+
+    def is_payload_safe(self, data: Dict[str, Any]) -> bool:
+        """
+        Verifica se payload está dentro dos limites seguros
+
+        Args:
+            data: Dados a verificar
+
+        Returns:
+            True se seguro, False se muito grande
+        """
+        size = self.estimate_payload_size(data)
+
+        if size > self.MAX_TOTAL_CHARS:
+            logger.warning(f"⚠️ Payload muito grande: {size} chars (máx: {self.MAX_TOTAL_CHARS})")
+            return False
+
+        return True
+
+
+# Singleton global
+_payload_manager = None
+
+def get_payload_manager() -> PayloadManager:
+    """Retorna instância singleton do PayloadManager"""
+    global _payload_manager
+    if _payload_manager is None:
+        _payload_manager = PayloadManager()
+    return _payload_manager

processors/processor_base.py

@@ -1,138 +1,58 @@
+##PARA.AI/processors/processor_base.py
 """
-Classe Base Refatorada - Com Schema Injection automático
-Compatível com LLMManager do PARA.AI
+ProcessorBase - Classe base para todos os processadores V13.1
+CORRIGIDO: Adiciona truncamento de texto para evitar erro 413
 """
-from abc import ABC
-from typing import Dict, Any, Optional
-from datetime import datetime
-import logging
 import json
-import os
-from pathlib import Path
-
-from processors.config_loader import get_config_loader, SpecialistConfig
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List
 
 logger = logging.getLogger(__name__)
 
 
 class ProcessorBase(ABC):
     """
-    Classe abstrata base para processadores
+    Classe base para processadores V13.1
 
-    FEATURES:
-    - Carrega configuração do YAML
-    - Schema injection automático no system_prompt
-    - Compatível com LLMManager (await llm_manager.generate())
+    CORREÇÃO V13.6:
+    - Adiciona método truncate_text() para evitar erro 413
+    - Limita seções a 15000 chars cada
+    - Mantém compatibilidade total com código existente
     """
 
-    def __init__(
-        self,
-        specialist_id: int,
-        llm_manager=None
-    ):
+    # NOVO: Limites de caracteres para evitar erro 413
+    MAX_SECTION_CHARS = 15000  # Máximo por seção de texto
+    MAX_TOTAL_CHARS = 50000     # Máximo total do payload
+
+    def __init__(self, llm_manager, config_path: str = None):
         """
         Args:
-            specialist_id: ID do especialista (1-9)
-            llm_manager: LLMManager para chamadas LLM
+            llm_manager: Instância do LLMManager
+            config_path: Caminho para arquivo de configuração (opcional)
         """
-        self.specialist_id = specialist_id
         self.llm_manager = llm_manager
+        self.config_path = config_path
+        self.config = self._load_config() if config_path else {}
 
-        # Carregar configuração do YAML
-        config_loader = get_config_loader()
-        self.config: Optional[SpecialistConfig] = config_loader.get_specialist(specialist_id)
-
-        if not self.config:
-            raise ValueError(f"Especialista {specialist_id} não encontrado na configuração")
-
-        self.specialist_name = self.config.name
-        self.execution_time = 0
-        self.confidence_score = 0
-        self.errors = []
-        self.warnings = []
-
-        # 🔥 NOVA FEATURE: Carrega schema JSON e injeta no system_prompt
-        self._inject_schema_in_prompt()
-
-        logger.info(
-            f"✅ {self.specialist_name} inicializado "
-            f"(provider={self.config.llm_config.provider}, "
-            f"model={self.config.llm_config.model})"
-        )
-
-    def _inject_schema_in_prompt(self):
-        """
-        🔥 NOVA FUNÇÃO: Injeta schema JSON no system_prompt.
+        logger.info(f"✅ {self.__class__.__name__} inicializado")
 
-        Carrega o schema do arquivo JSON correspondente e adiciona
-        ao final do system_prompt para garantir que o LLM retorne
-        JSON na estrutura correta.
-        """
+    def _load_config(self) -> Dict[str, Any]:
+        """Carrega configuração do processador"""
         try:
-            # Mapeamento de especialista para arquivo schema
-            schema_map = {
-                1: "metadados_schema.json",
-                2: "segmentacao_schema.json",
-                3: "transcricao_schema.json",
-                4: "contexto_schema.json",
-                5: "fundamentacao_schema.json",
-                6: "decisao_schema.json",
-                7: "arquivo_schema.json",
-                8: "relatorio_schema.json",
-                9: "auditoria_schema.json",
-            }
-
-            schema_filename = schema_map.get(self.specialist_id)
-            if not schema_filename:
-                logger.warning(f"⚠️ Schema não mapeado para especialista {self.specialist_id}")
-                return
-
-            # Localiza diretório de schemas
-            base_dir = Path(__file__).parent.parent
-            schema_path = base_dir / "prompts" / "schemas" / schema_filename
-
-            if not schema_path.exists():
-                logger.warning(f"⚠️ Schema não encontrado: {schema_path}")
-                return
-
-            # Carrega schema JSON
-            with open(schema_path, 'r', encoding='utf-8') as f:
-                schema_dict = json.load(f)
-
-            # Formata schema para injeção
-            schema_json = json.dumps(schema_dict, indent=2, ensure_ascii=False)
-
-            # Injeta no system_prompt
-            schema_instruction = f"""
-
-# JSON SCHEMA OBRIGATÓRIO
-
-Você DEVE retornar sua resposta seguindo EXATAMENTE este JSON Schema:
-
-```json
-{schema_json}
-```
-
-REGRAS CRÍTICAS:
-- Retorne APENAS JSON válido (sem comentários, sem texto adicional)
-- Siga TODOS os campos marcados como "required" no schema
-- Respeite os tipos de dados (string, integer, array, object, boolean)
-- Valide enums quando especificados
-- NÃO invente campos que não estão no schema
-- Use formato ISO 8601 para datas (YYYY-MM-DD)
-"""
-
-            # Adiciona schema ao system_prompt
-            self.config.system_prompt = self.config.system_prompt + schema_instruction
-
-            logger.info(f"✅ Schema {schema_filename} injetado em {self.specialist_name}")
-
+            if self.config_path:
+                from processors.config_loader import ConfigLoader
+                loader = ConfigLoader(self.config_path)
+                return loader.get_config(self.__class__.__name__)
+            return {}
         except Exception as e:
-            logger.warning(f"⚠️ Falha ao injetar schema: {e}")
+            logger.warning(f"⚠️ Erro ao carregar config: {e}")
+            return {}
 
+    @abstractmethod
     async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Processa acórdão usando LLM REAL via LLMManager.
+        Processa um acórdão
 
         Args:
             acordao_data: Dados do acórdão
@@ -140,195 +60,159 @@ REGRAS CRÍTICAS:
         Returns:
             Resultado do processamento
         """
-        if not self.llm_manager:
-            raise ValueError("❌ LLMManager não configurado")
+        pass
 
-        start_time = datetime.now()
+    # =======================================================================
+    # NOVOS MÉTODOS - Correção erro 413
+    # =======================================================================
 
-        try:
-            # 1. Formatar prompt do usuário com dados do acórdão
-            user_prompt = self.config.format_user_prompt(
-                tribunal=acordao_data.get('tribunal', 'N/A'),
-                numero_processo=acordao_data.get('numero_processo', 'N/A'),
-                ementa=acordao_data.get('ementa', ''),
-                integra=acordao_data.get('integra', ''),
-                classe_processual=acordao_data.get('classe_processual', 'N/A')
-            )
+    def truncate_text(self, text: str, max_chars: int = None) -> str:
+        """
+        Trunca texto para evitar erro 413 Payload Too Large
 
-            # 2. Chamar LLM Manager (system_prompt já tem schema injetado)
-            response = await self.llm_manager.generate(
-                provider=self.config.llm_config.provider,
-                model=self.config.llm_config.model,
-                system_prompt=self.config.system_prompt,  # 🔥 Com schema injetado
-                user_prompt=user_prompt,
-                temperature=self.config.llm_config.temperature,
-                max_tokens=self.config.llm_config.max_tokens
-            )
+        Args:
+            text: Texto a truncar
+            max_chars: Máximo de caracteres (padrão: MAX_SECTION_CHARS)
 
-            # 3. Processar resposta do LLMManager
-            if response['status'] == 'success':
-                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
-                llm_result = response['result']
+        Returns:
+            Texto truncado
+        """
+        if not text:
+            return ""
 
-                # Extrair content e tokens
-                content = llm_result.get('content', '{}')
-                tokens_total = llm_result.get('total_tokens', 0)
+        max_chars = max_chars or self.MAX_SECTION_CHARS
 
-                # Parse JSON se for string
-                if isinstance(content, str):
-                    try:
-                        result = json.loads(content)
-                    except json.JSONDecodeError as e:
-                        logger.error(f"❌ JSON inválido: {e}")
-                        logger.debug(f"Content recebido: {content[:500]}")
-                        raise ValueError(f"Resposta não é JSON válido: {e}")
-                else:
-                    result = content
+        if len(text) <= max_chars:
+            return text
 
-                # Validar
-                if not self.validate(result):
-                    self.add_warning("Resultado não passou na validação completa")
+        # Truncar mantendo palavras completas
+        truncated = text[:max_chars]
 
-                # Calcular confiança
-                self.confidence_score = self._calculate_confidence(result)
+        # Encontrar último espaço para não cortar palavra
+        last_space = truncated.rfind(' ')
+        if last_space > max_chars * 0.9:  # Se estiver próximo do fim
+            truncated = truncated[:last_space]
 
-            else:
-                # Erro na chamada LLM
-                error_msg = response.get('error', 'Erro desconhecido')
-                raise ValueError(f"Erro na chamada LLM: {error_msg}")
+        # Adicionar indicador de truncamento
+        truncated += "... [TEXTO TRUNCADO]"
 
-            # 4. Pós-processar
-            self.execution_time = (datetime.now() - start_time).total_seconds()
+        logger.debug(f"✂️ Texto truncado: {len(text)} → {len(truncated)} chars")
 
-            return self.post_process(result)
+        return truncated
 
-        except Exception as e:
-            self.add_error(f"Erro no processamento: {e}")
-            self.execution_time = (datetime.now() - start_time).total_seconds()
-
-            return {
-                "specialist_id": self.specialist_id,
-                "specialist_name": self.specialist_name,
-                "status": "error",
-                "error": str(e),
-                "execution_time": self.execution_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-    def validate(self, result: Dict[str, Any]) -> bool:
+    def prepare_sections_for_llm(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Valida resultado contra schema.
+        Prepara seções truncadas para envio ao LLM
+
+        CORREÇÃO: Trunca cada seção individualmente para evitar erro 413
 
         Args:
-            result: Resultado a validar
+            acordao_data: Dados completos do acórdão
 
         Returns:
-            True se válido
+            Dados com seções truncadas
         """
-        try:
-            # Validação básica: verificar campos required do schema
-            schema = self.config.schema
-
-            # Verifica se schema existe e tem required fields
-            if not isinstance(schema, dict):
-                logger.warning(f"⚠️ Schema não é um dict para {self.specialist_name}")
-                return True
+        prepared_data = acordao_data.copy()
+
+        # Campos de texto que devem ser truncados
+        text_fields = [
+            'inteiro_teor',
+            'ementa',
+            'RELATORIO_texto_completo',
+            'FUNDAMENTACAO_texto_completo',
+            'DISPOSITIVO_texto_completo',
+        ]
+
+        for field in text_fields:
+            # Verificar em nível raiz
+            if field in prepared_data and isinstance(prepared_data[field], str):
+                prepared_data[field] = self.truncate_text(prepared_data[field])
+
+            # Verificar em secoes_originais
+            if 'secoes_originais' in prepared_data:
+                if field in prepared_data['secoes_originais']:
+                    if isinstance(prepared_data['secoes_originais'][field], str):
+                        prepared_data['secoes_originais'][field] = self.truncate_text(
+                            prepared_data['secoes_originais'][field]
+                        )
+
+        return prepared_data
+
+    async def call_llm(
+        self,
+        prompt: str,
+        system_prompt: str = None,
+        acordao_data: Dict[str, Any] = None,
+        **kwargs
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Chama LLM com truncamento automático de texto
 
-            required_fields = schema.get('required', [])
-            if not required_fields:
-                logger.debug(f"✓ Schema sem campos required para {self.specialist_name}")
-                return True
+        CORREÇÃO: Trunca automaticamente antes de enviar
 
-            # Verifica se result é dict
-            if not isinstance(result, dict):
-                self.add_warning(f"Resultado não é um dict: {type(result)}")
-                return False
+        Args:
+            prompt: Prompt do usuário
+            system_prompt: Prompt do sistema (opcional)
+            acordao_data: Dados do acórdão (serão truncados automaticamente)
+            **kwargs: Argumentos adicionais
 
-            # Verifica campos required
-            missing_fields = []
-            for field in required_fields:
-                if field not in result:
-                    missing_fields.append(field)
+        Returns:
+            Resposta parseada do LLM ou None
+        """
+        try:
+            # NOVO: Truncar dados antes de enviar
+            if acordao_data:
+                acordao_data = self.prepare_sections_for_llm(acordao_data)
+
+            # Chamar LLM normalmente
+            response = await self.llm_manager.chat(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                **kwargs
+            )
 
-            if missing_fields:
-                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
-                return False
+            if not response:
+                logger.warning(f"⚠️ LLM retornou resposta vazia")
+                return None
 
-            return True
+            # Tentar parsear JSON
+            try:
+                result = json.loads(response)
+                return result
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Erro ao parsear resposta JSON: {e}")
+                logger.debug(f"Resposta: {response[:500]}...")
+                return None
 
         except Exception as e:
-            self.add_error(f"Erro na validação: {e}")
-            return False
+            logger.error(f"❌ Erro ao chamar LLM: {e}")
+            return None
+
+    def get_empty_structure(self) -> Dict[str, Any]:
+        """
+        Retorna estrutura vazia padrão
+        Pode ser sobrescrito por processadores específicos
+        """
+        return {}
+
+    def validate_result(self, result: Dict[str, Any]) -> bool:
+        """
+        Valida resultado básico
+        Pode ser sobrescrito por processadores específicos
+        """
+        return result is not None and isinstance(result, dict)
 
-    def _calculate_confidence(self, result: Dict[str, Any]) -> int:
+    def merge_results(self, base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Calcula score de confiança baseado no resultado.
+        Mescla dois dicionários de resultados
+
+        Args:
+            base: Dicionário base
+            update: Dicionário com atualizações
 
         Returns:
-            Score 0-100
+            Dicionário mesclado
         """
-        try:
-            # Lógica simples: quanto mais campos preenchidos, maior confiança
-            schema = self.config.schema
-
-            if not isinstance(schema, dict):
-                return 85  # Padrão se schema inválido
-
-            required_fields = schema.get('required', [])
-
-            if not required_fields:
-                return 85  # Padrão
-
-            if not isinstance(result, dict):
-                return 0
-
-            filled = sum(1 for field in required_fields if result.get(field))
-            confidence = int((filled / len(required_fields)) * 100)
-
-            return min(confidence, 100)
-
-        except Exception:
-            return 85
-
-    def post_process(self, result: Dict[str, Any]) -> Dict[str, Any]:
-        """Pós-processa resultado"""
-        return {
-            "specialist_id": self.specialist_id,
-            "specialist_name": self.specialist_name,
-            "result": result,
-            "execution_time": self.execution_time,
-            "confidence_score": self.confidence_score,
-            "errors": self.errors,
-            "warnings": self.warnings,
-            "timestamp": datetime.now().isoformat(),
-            "config": {
-                "provider": self.config.llm_config.provider,
-                "model": self.config.llm_config.model,
-                "temperature": self.config.llm_config.temperature
-            }
-        }
-
-    def add_error(self, error_msg: str):
-        """Adiciona erro"""
-        self.errors.append(error_msg)
-        logger.error(f"[{self.specialist_name}] {error_msg}")
-
-    def add_warning(self, warning_msg: str):
-        """Adiciona aviso"""
-        self.warnings.append(warning_msg)
-        logger.warning(f"[{self.specialist_name}] {warning_msg}")
-
-    def get_schema(self) -> Dict[str, Any]:
-        """Retorna schema do especialista"""
-        return self.config.schema
-
-    @property
-    def info(self) -> Dict[str, Any]:
-        """Retorna informações sobre o processador"""
-        return {
-            "specialist_id": self.specialist_id,
-            "specialist_name": self.specialist_name,
-            "provider": self.config.llm_config.provider,
-            "model": self.config.llm_config.model,
-            "schema": self.config.schema
-        }
+        merged = base.copy()
+        merged.update(update)
+        return merged