Upload processor_base.py

processors/processor_base.py

@@ -1,5 +1,6 @@
 """
 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
@@ -21,7 +22,7 @@ class ProcessorBase(ABC):
     FEATURES:
     - Carrega configuração do YAML
     - Schema injection automático no system_prompt
-    - Todos os dados vêm do LLM
+    - Compatível com LLMManager (await llm_manager.generate())
     """
 
     def __init__(
@@ -131,7 +132,7 @@ REGRAS CRÍTICAS:
 
     async def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Processa acórdão usando LLM REAL
+        Processa acórdão usando LLM REAL via LLMManager.
 
         Args:
             acordao_data: Dados do acórdão
@@ -164,21 +165,25 @@ REGRAS CRÍTICAS:
                 max_tokens=self.config.llm_config.max_tokens
             )
 
-            # 3. Extrair resultado
+            # 3. Processar resposta do LLMManager
             if response['status'] == 'success':
-                result = response['result']
+                # response['result'] contém o dict do client: {'content': ..., 'tokens_input': ...}
+                llm_result = response['result']
 
-                # Parse JSON se necessário
-                if isinstance(result, str):
+                # 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(result)
-                    except json.JSONDecodeError:
-                        # Se não é JSON válido, tentar extrair do texto
-                        if 'choices' in result:
-                            content = result['choices'][0]['message']['content']
-                            result = json.loads(content)
-                        else:
-                            raise ValueError("Resposta não é JSON válido")
+                        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):
@@ -188,7 +193,9 @@ REGRAS CRÍTICAS:
                 self.confidence_score = self._calculate_confidence(result)
 
             else:
-                raise ValueError(f"Erro na chamada LLM: {response.get('error')}")
+                # 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()
@@ -210,7 +217,7 @@ REGRAS CRÍTICAS:
 
     def validate(self, result: Dict[str, Any]) -> bool:
         """
-        Valida resultado contra schema
+        Valida resultado contra schema.
 
         Args:
             result: Resultado a validar
@@ -221,12 +228,31 @@ REGRAS CRÍTICAS:
         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:
-                    self.add_warning(f"Campo obrigatório ausente: {field}")
-                    return False
+                    missing_fields.append(field)
+
+            if missing_fields:
+                self.add_warning(f"Campos obrigatórios ausentes: {', '.join(missing_fields)}")
+                return False
 
             return True
 
@@ -236,22 +262,33 @@ REGRAS CRÍTICAS:
 
     def _calculate_confidence(self, result: Dict[str, Any]) -> int:
         """
-        Calcula score de confiança baseado no resultado
+        Calcula score de confiança baseado no resultado.
 
         Returns:
             Score 0-100
         """
-        # Lógica simples: quanto mais campos preenchidos, maior confiança
-        schema = self.config.schema
-        required_fields = schema.get('required', [])
+        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
 
-        if not required_fields:
-            return 85  # Padrão
+            filled = sum(1 for field in required_fields if result.get(field))
+            confidence = int((filled / len(required_fields)) * 100)
 
-        filled = sum(1 for field in required_fields if result.get(field))
-        confidence = int((filled / len(required_fields)) * 100)
+            return min(confidence, 100)
 
-        return min(confidence, 100)
+        except Exception:
+            return 85
 
     def post_process(self, result: Dict[str, Any]) -> Dict[str, Any]:
         """Pós-processa resultado"""