Create llm/providers/openai_provider.py

llm/providers/openai_provider.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import openai
+
+from core.logging.logger import get_logger
+from llm.providers.base_provider import (
+    BaseProvider,
+    LLMProviderError,
+    LLMMessage,
+    LLMRequest,
+    LLMResponse,
+)
+
+logger = get_logger(__name__)
+
+# Mapping from our role Literal to OpenAI role strings
+_ROLE_MAP: dict[str, str] = {
+    "system": "system",
+    "user": "user",
+    "assistant": "assistant",
+    "tool": "tool",
+}
+
+
+class OpenAIRateLimitError(LLMProviderError):
+    """OpenAI API rate limit exceeded."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, provider_name="openai")
+
+
+class OpenAITimeoutError(LLMProviderError):
+    """OpenAI API request timed out."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, provider_name="openai")
+
+
+class OpenAIAPIError(LLMProviderError):
+    """OpenAI API returned an error response."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        self.status_code = status_code
+        super().__init__(message, provider_name="openai")
+
+
+class OpenAIProvider(BaseProvider):
+    """Concrete LLM provider implementation for OpenAI.
+
+    Uses the ``openai`` Python SDK (>=1.0.0) to call the OpenAI Chat
+    Completions API.
+
+    Args:
+        api_key: OpenAI API key (sk-...).
+        model: Default model to use (e.g. "gpt-4o-mini").
+        default_timeout: Request timeout in seconds.
+        organization: Optional OpenAI organization ID.
+        base_url: Optional custom base URL (for Azure, proxies, etc.).
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = "gpt-4o-mini",
+        default_timeout: float = 60.0,
+        organization: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        super().__init__(name="openai")
+        self._model = model
+        self._default_timeout = default_timeout
+
+        if not api_key or not api_key.strip():
+            raise ValueError("OpenAI API key must not be empty")
+
+        client_kwargs: dict[str, Any] = {
+            "api_key": api_key.strip(),
+            "timeout": default_timeout,
+        }
+        if organization:
+            client_kwargs["organization"] = organization
+        if base_url:
+            client_kwargs["base_url"] = base_url
+
+        self._client = openai.AsyncOpenAI(**client_kwargs)
+
+    @property
+    def model(self) -> str:
+        """Return the default model identifier."""
+        return self._model
+
+    async def generate(self, request: LLMRequest) -> LLMResponse:
+        """Generate a response using the OpenAI Chat Completions API.
+
+        Args:
+            request: The LLM request containing messages and parameters.
+
+        Returns:
+            LLMResponse with the generated content and usage metadata.
+
+        Raises:
+            LLMProviderError: On any OpenAI API failure.
+        """
+        # Build messages payload
+        openai_messages: list[dict[str, str]] = []
+        for msg in request.messages:
+            openai_messages.append({
+                "role": _ROLE_MAP[msg.role],
+                "content": msg.content,
+            })
+
+        model = request.model or self._model
+
+        try:
+            response = await self._client.chat.completions.create(
+                model=model,
+                messages=openai_messages,
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+            )
+
+        except openai.RateLimitError as exc:
+            raise OpenAIRateLimitError(
+                f"OpenAI rate limit exceeded: {exc}"
+            ) from exc
+
+        except openai.APITimeoutError as exc:
+            raise OpenAITimeoutError(
+                f"OpenAI request timed out after {self._default_timeout}s: {exc}"
+            ) from exc
+
+        except openai.APIConnectionError as exc:
+            raise OpenAIAPIError(
+                f"OpenAI connection error: {exc}"
+            ) from exc
+
+        except openai.BadRequestError as exc:
+            raise OpenAIAPIError(
+                f"OpenAI bad request: {exc}",
+                status_code=getattr(exc, "status_code", None),
+            ) from exc
+
+        except openai.APIStatusError as exc:
+            raise OpenAIAPIError(
+                f"OpenAI API error (status={exc.status_code}): {exc.message}",
+                status_code=exc.status_code,
+            ) from exc
+
+        except asyncio.CancelledError:
+            # Do not intercept cancellation — let it propagate
+            raise
+
+        except Exception as exc:
+            raise LLMProviderError(
+                f"Unexpected OpenAI error: {exc}",
+                provider_name="openai",
+            ) from exc
+
+        # Extract response content
+        choice = response.choices[0] if response.choices else None
+        if choice is None or choice.message.content is None:
+            raise OpenAIAPIError(
+                "OpenAI returned empty response — no choices"
+            )
+
+        usage_data: dict[str, int] = {}
+        if response.usage:
+            usage_data = {
+                "prompt_tokens": response.usage.prompt_tokens,
+                "completion_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens,
+            }
+
+        return LLMResponse(
+            content=choice.message.content,
+            model=response.model or model,
+            provider="openai",
+            usage=usage_data,
+        )
+
+    def __repr__(self) -> str:
+        return f"<OpenAIProvider model='{self._model}'>"
+