src/llms/openai.py

"""
Provider OpenAI (GPT-4, GPT-3.5, etc)
"""
from typing import Dict, Any
from .base import BaseLLM


class OpenAILLM(BaseLLM):
    """Provider para OpenAI API"""

    def __init__(self, model_id: str, api_key: str, **kwargs):
        """
        Inicializa provider OpenAI

        Args:
            model_id: ID do modelo (gpt-4, gpt-3.5-turbo, etc)
            api_key: API key da OpenAI
            **kwargs: Configurações adicionais
        """
        super().__init__(model_id, **kwargs)
        self.api_key = api_key
        self.client = None

        if api_key:
            try:
                import openai
                self.client = openai.OpenAI(api_key=api_key)
            except ImportError:
                self.last_error = "Biblioteca 'openai' não instalada. Instale com: pip install openai"
            except Exception as e:
                self.last_error = f"Erro ao inicializar OpenAI client: {str(e)}"

    def generate(
        self,
        prompt: str,
        temperature: float = 0.3,
        max_tokens: int = 512,
        **kwargs
    ) -> str:
        """
        Gera resposta usando OpenAI API

        Args:
            prompt: Texto do prompt
            temperature: Temperatura de geração
            max_tokens: Máximo de tokens
            **kwargs: Parâmetros adicionais

        Returns:
            Texto gerado
        """
        # Valida parâmetros
        valid, error_msg = self.validate_parameters(temperature, max_tokens)
        if not valid:
            return f"Erro de validação: {error_msg}"

        if not self.client:
            return f"Erro: Cliente OpenAI não inicializado. {self.last_error}"

        try:
            response = self.client.chat.completions.create(
                model=self.model_id,
                messages=[
                    {"role": "user", "content": prompt}
                ],
                temperature=temperature,
                max_tokens=max_tokens,
                **kwargs
            )

            return response.choices[0].message.content.strip()

        except Exception as e:
            error = f"Erro na geração OpenAI: {str(e)}"
            self.last_error = error
            return error

    def is_available(self) -> bool:
        """
        Verifica se o provider está disponível

        Returns:
            True se cliente foi inicializado
        """
        return self.client is not None

    def get_model_info(self) -> Dict[str, Any]:
        """
        Retorna informações sobre o modelo

        Returns:
            Dicionário com informações
        """
        return {
            "provider": "OpenAI",
            "model_id": self.model_id,
            "available": self.is_available(),
            "api_type": "Chat Completions API",
            "last_error": self.last_error if self.last_error else None
        }