Revert "ParaAIV3.1"

This reverts commit bc33fdf0aa1d0fe36eb6b469cc18e729fe53198f.

.backups/pre_fix_413/context_builder.py

@@ -1,79 +0,0 @@
-##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

@@ -1,334 +0,0 @@
-"""
-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

@@ -1,79 +0,0 @@
-##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

@@ -1,334 +0,0 @@
-"""
-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

@@ -1,79 +0,0 @@
-##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

@@ -1,334 +0,0 @@
-"""
-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 CORRIGIDO
+Context Builder - Constrói contexto para context injection V13.6
 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
 
-logger = logging.getLogger(__name__)
+from api.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
 
 
 class ContextBuilder:
@@ -22,53 +22,15 @@ class ContextBuilder:
     """
 
     def __init__(self):
-        # CORRIGIDO: Mapear quais campos cada especialista precisa ver
-        # Ajustado para os nomes de campos REAIS que os processadores V13.1 retornam
+        # Mapear quais campos cada especialista precisa ver
         self.context_rules = {
             1: [],  # Segmentador: não precisa de contexto
-
-            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',
-            ]
+            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(
@@ -100,20 +62,10 @@ 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]
-            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")
+
+        logger.debug(f"📦 Contexto para Especialista {specialist_id}: {list(context.keys())}")
 
         return context if context else None
 

core/payload_manager.py

@@ -1,203 +0,0 @@
-##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,58 +1,138 @@
-##PARA.AI/processors/processor_base.py
 """
-ProcessorBase - Classe base para todos os processadores V13.1
-CORRIGIDO: Adiciona truncamento de texto para evitar erro 413
+Classe Base Refatorada - Com Schema Injection automático
+Compatível com LLMManager do PARA.AI
 """
-import json
+from abc import ABC
+from typing import Dict, Any, Optional
+from datetime import datetime
 import logging
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List
+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 base para processadores V13.1
+    Classe abstrata base para processadores
 
-    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
+    FEATURES:
+    - Carrega configuração do YAML
+    - Schema injection automático no system_prompt
+    - Compatível com LLMManager (await llm_manager.generate())
     """
 
-    # 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):
+    def __init__(
+        self,
+        specialist_id: int,
+        llm_manager=None
+    ):
         """
         Args:
-            llm_manager: Instância do LLMManager
-            config_path: Caminho para arquivo de configuração (opcional)
+            specialist_id: ID do especialista (1-9)
+            llm_manager: LLMManager para chamadas LLM
         """
+        self.specialist_id = specialist_id
         self.llm_manager = llm_manager
-        self.config_path = config_path
-        self.config = self._load_config() if config_path else {}
 
-        logger.info(f"✅ {self.__class__.__name__} inicializado")
+        # 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.
 
-    def _load_config(self) -> Dict[str, Any]:
-        """Carrega configuração do processador"""
+        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:
-            if self.config_path:
-                from processors.config_loader import ConfigLoader
-                loader = ConfigLoader(self.config_path)
-                return loader.get_config(self.__class__.__name__)
-            return {}
+            # 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"⚠️ Erro ao carregar config: {e}")
-            return {}
+            logger.warning(f"⚠️ Falha ao injetar schema: {e}")
 
-    @abstractmethod
     async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Processa um acórdão
+        Processa acórdão usando LLM REAL via LLMManager.
 
         Args:
             acordao_data: Dados do acórdão
@@ -60,159 +140,195 @@ class ProcessorBase(ABC):
         Returns:
             Resultado do processamento
         """
-        pass
+        if not self.llm_manager:
+            raise ValueError("❌ LLMManager não configurado")
 
-    # =======================================================================
-    # NOVOS MÉTODOS - Correção erro 413
-    # =======================================================================
+        start_time = datetime.now()
 
-    def truncate_text(self, text: str, max_chars: int = None) -> str:
-        """
-        Trunca texto para evitar erro 413 Payload Too Large
+        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')
+            )
 
-        Args:
-            text: Texto a truncar
-            max_chars: Máximo de caracteres (padrão: MAX_SECTION_CHARS)
+            # 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
+            )
 
-        Returns:
-            Texto truncado
-        """
-        if not text:
-            return ""
+            # 3. Processar resposta do LLMManager
+            if response['status'] == 'success':
+                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
+                llm_result = response['result']
 
-        max_chars = max_chars or self.MAX_SECTION_CHARS
+                # Extrair content e tokens
+                content = llm_result.get('content', '{}')
+                tokens_total = llm_result.get('total_tokens', 0)
 
-        if len(text) <= max_chars:
-            return text
+                # 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
 
-        # Truncar mantendo palavras completas
-        truncated = text[:max_chars]
+                # Validar
+                if not self.validate(result):
+                    self.add_warning("Resultado não passou na validação completa")
 
-        # 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]
+                # Calcular confiança
+                self.confidence_score = self._calculate_confidence(result)
 
-        # Adicionar indicador de truncamento
-        truncated += "... [TEXTO TRUNCADO]"
+            else:
+                # Erro na chamada LLM
+                error_msg = response.get('error', 'Erro desconhecido')
+                raise ValueError(f"Erro na chamada LLM: {error_msg}")
 
-        logger.debug(f"✂️ Texto truncado: {len(text)} → {len(truncated)} chars")
+            # 4. Pós-processar
+            self.execution_time = (datetime.now() - start_time).total_seconds()
 
-        return truncated
+            return self.post_process(result)
 
-    def prepare_sections_for_llm(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        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:
         """
-        Prepara seções truncadas para envio ao LLM
-
-        CORREÇÃO: Trunca cada seção individualmente para evitar erro 413
+        Valida resultado contra schema.
 
         Args:
-            acordao_data: Dados completos do acórdão
+            result: Resultado a validar
 
         Returns:
-            Dados com seções truncadas
+            True se válido
         """
-        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
+        try:
+            # Validação básica: verificar campos required do schema
+            schema = self.config.schema
 
-        CORREÇÃO: Trunca automaticamente antes de enviar
+            # 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
 
-        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
+            required_fields = schema.get('required', [])
+            if not required_fields:
+                logger.debug(f"✓ Schema sem campos required para {self.specialist_name}")
+                return True
 
-        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
-            )
+            # Verifica se result é dict
+            if not isinstance(result, dict):
+                self.add_warning(f"Resultado não é um dict: {type(result)}")
+                return False
 
-            if not response:
-                logger.warning(f"⚠️ LLM retornou resposta vazia")
-                return None
+            # Verifica campos required
+            missing_fields = []
+            for field in required_fields:
+                if field not in result:
+                    missing_fields.append(field)
 
-            # 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
+            if missing_fields:
+                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
+                return False
 
-        except Exception as e:
-            logger.error(f"❌ Erro ao chamar LLM: {e}")
-            return None
+            return True
 
-    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)
+        except Exception as e:
+            self.add_error(f"Erro na validação: {e}")
+            return False
 
-    def merge_results(self, base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+    def _calculate_confidence(self, result: Dict[str, Any]) -> int:
         """
-        Mescla dois dicionários de resultados
-
-        Args:
-            base: Dicionário base
-            update: Dicionário com atualizações
+        Calcula score de confiança baseado no resultado.
 
         Returns:
-            Dicionário mesclado
+            Score 0-100
         """
-        merged = base.copy()
-        merged.update(update)
-        return merged
+        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
+        }