code/llms/openai.py

"""
OpenAI LLM provider implementation.
Supports both sync and async with native async client.
"""

from typing import Optional, Dict, Any, Iterator, AsyncIterator
from .base import BaseLLM
import logging

logger = logging.getLogger(__name__)

class OpenAILLM(BaseLLM):
    """
    LLM provider for OpenAI comparative API.

    Features:
    Advantages:
    - ✅ Fast API
    - ✅ Streaming support
    - ✅ Function calling support
    """

    def __init__(
        self,
        model_name: str = "gpt-4o-mini",
        api_key: Optional[str] = None,
        organization: Optional[str] = None,
        base_url: Optional[str] = None,
        default_temperature: float = 0.7,
        default_max_tokens: Optional[int] = None,
        enable_reasoning: bool = False,
    ):
        """
        Initialize OpenAI LLM provider.

        Args:
            model_name: OpenAI model name
            api_key: OpenAI API key (or set OPENAI_API_KEY env var)
            organization: OpenAI organization ID (optional)
            base_url: Custom API base URL (for Azure OpenAI, etc.)
            default_temperature: Default sampling temperature
            default_max_tokens: Default max tokens to generate
            enable_reasoning: Allow reasoning/thinking tokens (e.g. DeepSeek-R1,
                              deepseek-v4-flash). Default False — injects
                              enable_thinking=False for vLLM-compatible endpoints.
        """
        try:
            from openai import OpenAI, AsyncOpenAI
        except ImportError:
            raise ImportError(
                "openai is required for OpenAILLM. "
                "Install it with: pip install openai"
            )

        self.model_name = model_name
        self.default_temperature = default_temperature
        self.default_max_tokens = default_max_tokens
        self.enable_reasoning = enable_reasoning

        # Initialize OpenAI clients (both sync and async)
        client_kwargs = {}
        if api_key:
            client_kwargs["api_key"] = api_key
        if organization:
            client_kwargs["organization"] = organization
        if base_url:
            client_kwargs["base_url"] = base_url

        self.client = OpenAI(**client_kwargs)
        self.async_client = AsyncOpenAI(**client_kwargs)

        logger.info(
            f"✓ Initialized OpenAI clients (sync + async) with model '{model_name}'"
            f" (reasoning={'on' if enable_reasoning else 'off'})"
        )

    def _inject_disable_thinking(self, kwargs):
        # When reasoning is disabled, inject enable_thinking=False for vLLM-style
        # endpoints that honour chat_template_kwargs. Cloud APIs (OpenAI, DeepSeek)
        # ignore unknown extra_body fields, so this is a no-op for them.
        if self.enable_reasoning:
            return dict(kwargs)
        kwargs = dict(kwargs)
        extra_body = kwargs.get("extra_body", {})
        chat_kwargs = extra_body.get("chat_template_kwargs", {})
        if "enable_thinking" not in chat_kwargs:
            chat_kwargs["enable_thinking"] = False
        extra_body["chat_template_kwargs"] = chat_kwargs
        kwargs["extra_body"] = extra_body
        return kwargs

    def generate(
        self,
        user_prompt: str,
        system_prompt: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = None,
        **kwargs
    ) -> str:
        """
        Generate response using OpenAI API.

        Args:
            user_prompt: The user's prompt, including any context.
            system_prompt: System prompt
            temperature: Sampling temperature
            max_tokens: Max tokens to generate
            **kwargs: Additional OpenAI parameters (top_p, presence_penalty, etc.)

        Returns:
            Generated response
        """
        temperature = temperature if temperature is not None else self.default_temperature
        max_tokens = max_tokens or self.default_max_tokens

        # Build messages
        messages = self._build_messages(user_prompt, system_prompt)
        kwargs = self._inject_disable_thinking(kwargs)

        # When caller requests JSON-only output, use json_object response format
        # to guarantee valid JSON and prevent truncated / extra-quoted keys.
        if system_prompt and "json" in system_prompt.lower() and "response_format" not in kwargs:
            kwargs["response_format"] = {"type": "json_object"}

        try:
            logger.info(f"Generating response with OpenAI model '{self.model_name}'")
            # Call OpenAI API
            completion = self.client.chat.completions.create(
                model=self.model_name,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                **kwargs
            )
            
            # Handle different response types
            if hasattr(completion, 'choices'):
                answer = completion.choices[0].message.content
            elif isinstance(completion, dict):
                answer = completion['choices'][0]['message']['content']
            elif isinstance(completion, str):
                import json
                try:
                    data = json.loads(completion)
                    if 'choices' in data:
                        answer = data['choices'][0]['message']['content']
                    else:
                        answer = completion
                except json.JSONDecodeError:
                    answer = completion
            else:
                answer = str(completion)

            logger.info(
                f"Generated {len(answer)} characters."
            )

            return answer

        except Exception as e:
            logger.error(f"Error calling OpenAI API: {e}")
            raise

    def stream(
        self,
        user_prompt: str,
        system_prompt: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = None,
        **kwargs
    ) -> Iterator[str]:
        """
        Stream response from OpenAI API.

        Args:
            Same as generate()

        Yields:
            Response tokens as they are generated
        """
        temperature = temperature if temperature is not None else self.default_temperature
        max_tokens = max_tokens or self.default_max_tokens

        # Build messages
        messages = self._build_messages(user_prompt, system_prompt)
        kwargs = self._inject_disable_thinking(kwargs)

        try:
            logger.info(f"Streaming response with OpenAI model '{self.model_name}'")
            # Stream from OpenAI
            stream = self.client.chat.completions.create(
                model=self.model_name,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                stream=True,
                **kwargs
            )

            for chunk in stream:
                if chunk.choices[0].delta.content is not None:
                    yield chunk.choices[0].delta.content

        except Exception as e:
            logger.error(f"Error streaming from OpenAI: {e}")
            raise

    def _build_messages(
        self,
        user_prompt: str,
        system_prompt: Optional[str] = None
    ) -> list:
        """
        Build OpenAI messages format.

        Args:
            user_prompt: The user's prompt, including any context.
            system_prompt: System instructions

        Returns:
            List of message dicts
        """
        messages = []

        # System message
        if system_prompt is None:
            system_prompt = self._get_default_system_prompt()
        messages.append({
            "role": "system",
            "content": system_prompt
        })

        messages.append({
            "role": "user",
            "content": user_prompt
        })

        return messages

    def get_model_info(self) -> Dict[str, Any]:
        """Get OpenAI model information."""
        return {
            "provider": "openai",
            "model_name": self.model_name,
            "default_temperature": self.default_temperature,
            "default_max_tokens": self.default_max_tokens,
        }

    def count_tokens(self, text: str) -> int:
        """
        Count tokens in text (approximate).
        
        For accurate counting, use tiktoken library.

        Args:
            text: Text to count tokens for

        Returns:
            Approximate token count
        """
        try:
            import tiktoken

            if "gpt-4" in self.model_name:
                encoding = tiktoken.encoding_for_model("gpt-4")
            elif "gpt-3.5" in self.model_name:
                encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
            else:
                encoding = tiktoken.get_encoding("cl100k_base")
            
            return len(encoding.encode(text))
            
        except ImportError:
            # Fallback: rough estimate (1 token ≈ 4 characters)
            return len(text) // 4
        except Exception as e:
            logger.warning(f"Error counting tokens: {e}")
            return len(text) // 4

    # ==================== ASYNC METHODS ====================

    async def agenerate(
        self,
        user_prompt: str,
        system_prompt: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = None,
        **kwargs
    ) -> str:
        """
        Async generate response using OpenAI API (native async client).

        Args:
            Same as generate()

        Returns:
            Generated response
        """
        temperature = temperature if temperature is not None else self.default_temperature
        max_tokens = max_tokens or self.default_max_tokens

        # Build messages
        messages = self._build_messages(user_prompt, system_prompt)
        kwargs = self._inject_disable_thinking(kwargs)

        try:
            logger.debug(f"Async generating response with OpenAI model '{self.model_name}'")
            # Call OpenAI API asynchronously
            completion = await self.async_client.chat.completions.create(
                model=self.model_name,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                **kwargs
            )

            # Handle different response types (Object, Dict, or String)
            if hasattr(completion, 'choices'):
                # Standard OpenAI object
                answer = completion.choices[0].message.content
            elif isinstance(completion, dict):
                # Dictionary response (some proxies)
                answer = completion['choices'][0]['message']['content']
            elif isinstance(completion, str):
                # String/JSON response
                import json
                try:
                    data = json.loads(completion)
                    if 'choices' in data:
                        answer = data['choices'][0]['message']['content']
                    else:
                        # Maybe it's just the raw text?
                        answer = completion
                except json.JSONDecodeError:
                    answer = completion
            else:
                # Unknown type, try best effort or fail
                logger.warning(f"Unknown completion type: {type(completion)}")
                answer = str(completion)

            logger.debug(
                f"Generated {len(answer)} characters. "
            )

            return answer

        except Exception as e:
            logger.error(f"Error calling OpenAI API: {e}")
            raise

    async def astream(
        self,
        user_prompt: str,
        system_prompt: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = None,
        **kwargs
    ) -> AsyncIterator[str]:
        """
        Async stream response from OpenAI API (native async streaming).

        Args:
            Same as generate()

        Yields:
            Response tokens as they are generated
        """
        temperature = temperature if temperature is not None else self.default_temperature
        max_tokens = max_tokens or self.default_max_tokens

        # Build messages
        messages = self._build_messages(user_prompt, system_prompt)
        kwargs = self._inject_disable_thinking(kwargs)

        try:
            logger.info(f"Async streaming response with OpenAI model '{self.model_name}'")
            # Stream from OpenAI asynchronously
            stream = await self.async_client.chat.completions.create(
                model=self.model_name,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                stream=True,
                **kwargs
            )

            async for chunk in stream:
                if chunk.choices[0].delta.content is not None:
                    yield chunk.choices[0].delta.content

        except Exception as e:
            logger.error(f"Error streaming from OpenAI: {e}")
            raise