gac 3.6.0__py3-none-any.whl → 3.10.10__py3-none-any.whl

gac/providers/azure_openai.py

@@ -4,94 +4,54 @@ This provider provides native support for Azure OpenAI Service with proper
 endpoint construction and API version handling.
 """
 
-import json
-import logging
 import os
-
-import httpx
+from typing import Any
 
 from gac.errors import AIError
-
-logger = logging.getLogger(__name__)
-
-
-def call_azure_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Azure OpenAI Service API.
-
-    Environment variables:
-        AZURE_OPENAI_API_KEY: Azure OpenAI API key (required)
-        AZURE_OPENAI_ENDPOINT: Azure OpenAI endpoint URL (required)
-            Example: https://your-resource.openai.azure.com
-        AZURE_OPENAI_API_VERSION: Azure OpenAI API version (required)
-            Example: 2025-01-01-preview
-            Example: 2024-02-15-preview
-
-    Args:
-        model: The deployment name in Azure OpenAI (e.g., 'gpt-4o', 'gpt-35-turbo')
-        messages: List of message dictionaries with 'role' and 'content' keys
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-
-    Returns:
-        The generated commit message
-
-    Raises:
-        AIError: If authentication fails, API errors occur, or response is invalid
-    """
-    api_key = os.getenv("AZURE_OPENAI_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("AZURE_OPENAI_API_KEY environment variable not set")
-
-    endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
-    if not endpoint:
-        raise AIError.model_error("AZURE_OPENAI_ENDPOINT environment variable not set")
-
-    api_version = os.getenv("AZURE_OPENAI_API_VERSION")
-    if not api_version:
-        raise AIError.model_error("AZURE_OPENAI_API_VERSION environment variable not set")
-
-    # Build Azure OpenAI URL with proper structure
-    endpoint = endpoint.rstrip("/")
-    url = f"{endpoint}/openai/deployments/{model}/chat/completions?api-version={api_version}"
-
-    headers = {"api-key": api_key, "Content-Type": "application/json"}
-
-    data = {"messages": messages, "temperature": temperature, "max_tokens": max_tokens}
-
-    try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        response_data = response.json()
-
-        try:
-            content = response_data["choices"][0]["message"]["content"]
-        except (KeyError, IndexError, TypeError) as e:
-            logger.error(f"Unexpected response format from Azure OpenAI API. Response: {json.dumps(response_data)}")
-            raise AIError.model_error(
-                f"Azure OpenAI API returned unexpected format. Expected response with "
-                f"'choices[0].message.content', but got: {type(e).__name__}. Check logs for full response structure."
-            ) from e
-
-        if content is None:
-            raise AIError.model_error("Azure OpenAI API returned null content")
-        if content == "":
-            raise AIError.model_error("Azure OpenAI API returned empty content")
-        return content
-    except httpx.ConnectError as e:
-        raise AIError.connection_error(f"Azure OpenAI API connection failed: {str(e)}") from e
-    except httpx.HTTPStatusError as e:
-        status_code = e.response.status_code
-        error_text = e.response.text
-
-        if status_code == 401:
-            raise AIError.authentication_error(f"Azure OpenAI API authentication failed: {error_text}") from e
-        elif status_code == 429:
-            raise AIError.rate_limit_error(f"Azure OpenAI API rate limit exceeded: {error_text}") from e
-        else:
-            raise AIError.model_error(f"Azure OpenAI API error: {status_code} - {error_text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Azure OpenAI API request timed out: {str(e)}") from e
-    except AIError:
-        raise
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Azure OpenAI API: {str(e)}") from e
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class AzureOpenAIProvider(OpenAICompatibleProvider):
+    """Azure OpenAI-compatible provider with custom URL construction and headers."""
+
+    config = ProviderConfig(
+        name="Azure OpenAI",
+        api_key_env="AZURE_OPENAI_API_KEY",
+        base_url="",  # Will be set in __init__
+    )
+
+    def __init__(self, config: ProviderConfig):
+        """Initialize with Azure-specific endpoint and API version."""
+        endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+        if not endpoint:
+            raise AIError.model_error("AZURE_OPENAI_ENDPOINT environment variable not set")
+
+        api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+        if not api_version:
+            raise AIError.model_error("AZURE_OPENAI_API_VERSION environment variable not set")
+
+        self.api_version = api_version
+        self.endpoint = endpoint.rstrip("/")
+        config.base_url = ""  # Will be set dynamically in _get_api_url
+        super().__init__(config)
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Build Azure-specific URL with deployment name and API version."""
+        if model is None:
+            return super()._get_api_url(model)
+        return f"{self.endpoint}/openai/deployments/{model}/chat/completions?api-version={self.api_version}"
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with api-key instead of Bearer token."""
+        headers = super()._build_headers()
+        # Replace Bearer token with api-key
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        headers["api-key"] = self.api_key
+        return headers
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build request body for Azure OpenAI."""
+        return {"messages": messages, "temperature": temperature, "max_tokens": max_tokens, **kwargs}

gac/providers/base.py

@@ -0,0 +1,329 @@
+"""Base configured provider class to eliminate code duplication."""
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from gac.constants import ProviderDefaults
+from gac.errors import AIError
+from gac.providers.protocol import ProviderProtocol
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ProviderConfig:
+    """Configuration for AI providers."""
+
+    name: str
+    api_key_env: str
+    base_url: str
+    timeout: int = ProviderDefaults.HTTP_TIMEOUT
+    headers: dict[str, str] | None = None
+
+    def __post_init__(self) -> None:
+        """Initialize default headers if not provided."""
+        if self.headers is None:
+            self.headers = {"Content-Type": "application/json"}
+
+
+class BaseConfiguredProvider(ABC, ProviderProtocol):
+    """Base class for configured AI providers.
+
+    This class eliminates code duplication by providing:
+    - Standardized HTTP handling with httpx
+    - Common error handling patterns
+    - Flexible configuration via ProviderConfig
+    - Template methods for customization
+
+    Implements ProviderProtocol for type safety.
+    """
+
+    def __init__(self, config: ProviderConfig):
+        self.config = config
+        self._api_key: str | None = None  # Lazy load
+
+    @property
+    def api_key(self) -> str:
+        """Lazy-load API key when needed."""
+        if self.config.api_key_env:
+            # Always check environment for fresh value to support test isolation
+            return self._get_api_key()
+        return ""
+
+    @property
+    def name(self) -> str:
+        """Get the provider name."""
+        return self.config.name
+
+    @property
+    def api_key_env(self) -> str:
+        """Get the environment variable name for the API key."""
+        return self.config.api_key_env
+
+    @property
+    def base_url(self) -> str:
+        """Get the base URL for the API."""
+        return self.config.base_url
+
+    @property
+    def timeout(self) -> int:
+        """Get the timeout in seconds."""
+        return self.config.timeout
+
+    def _get_api_key(self) -> str:
+        """Get API key from environment variables."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            raise AIError.authentication_error(f"{self.config.api_key_env} not found in environment variables")
+        return api_key
+
+    @abstractmethod
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build the request body for the API call.
+
+        Args:
+            messages: List of message dictionaries
+            temperature: Temperature parameter
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Request body dictionary
+        """
+        pass
+
+    @abstractmethod
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse the API response and extract content.
+
+        Args:
+            response: Response dictionary from API
+
+        Returns:
+            Generated text content
+        """
+        pass
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers for the API request.
+
+        Can be overridden by subclasses to add provider-specific headers.
+        """
+        headers = self.config.headers.copy() if self.config.headers else {}
+        return headers
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get the API URL for the request.
+
+        Can be overridden by subclasses for dynamic URLs.
+
+        Args:
+            model: Model name (for providers that need model-specific URLs)
+
+        Returns:
+            API URL string
+        """
+        return self.config.base_url
+
+    def _make_http_request(self, url: str, body: dict[str, Any], headers: dict[str, str]) -> dict[str, Any]:
+        """Make the HTTP request.
+
+        Error handling is delegated to the @handle_provider_errors decorator
+        which wraps the provider's API function. This avoids duplicate exception
+        handling and ensures consistent error classification across all providers.
+
+        Args:
+            url: API URL
+            body: Request body
+            headers: Request headers
+
+        Returns:
+            Response JSON dictionary
+
+        Raises:
+            httpx.HTTPStatusError: For HTTP errors (handled by decorator)
+            httpx.TimeoutException: For timeout errors (handled by decorator)
+            httpx.RequestError: For network errors (handled by decorator)
+        """
+        response = httpx.post(url, json=body, headers=headers, timeout=self.config.timeout, verify=get_ssl_verify())
+        response.raise_for_status()
+        return response.json()
+
+    def generate(
+        self,
+        model: str,
+        messages: list[dict[str, Any]],
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        **kwargs: Any,
+    ) -> str:
+        """Generate text using the AI provider.
+
+        Error handling is delegated to the @handle_provider_errors decorator
+        which wraps the provider's API function. This ensures consistent error
+        classification across all providers.
+
+        Args:
+            model: Model name to use
+            messages: List of message dictionaries
+            temperature: Temperature parameter (0.0-2.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Generated text content
+
+        Raises:
+            AIError: For any API-related errors (via decorator)
+        """
+        logger.debug(f"Generating with {self.config.name} provider (model={model})")
+
+        # Build request components
+        url = self._get_api_url(model)
+        headers = self._build_headers()
+        body = self._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+
+        # Add model to body if not already present
+        if "model" not in body:
+            body["model"] = model
+
+        # Make HTTP request
+        response_data = self._make_http_request(url, body, headers)
+
+        # Parse response
+        return self._parse_response(response_data)
+
+
+class OpenAICompatibleProvider(BaseConfiguredProvider):
+    """Base class for OpenAI-compatible providers.
+
+    Handles standard OpenAI API format with minimal customization needed.
+    """
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build OpenAI-style request body.
+
+        Note: Subclasses should override this if they need max_completion_tokens
+        instead of max_tokens (like OpenAI provider does).
+        """
+        return {"messages": messages, "temperature": temperature, "max_tokens": max_tokens, **kwargs}
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with OpenAI-style authorization."""
+        headers = super()._build_headers()
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse OpenAI-style response."""
+        choices = response.get("choices")
+        if not choices or not isinstance(choices, list):
+            raise AIError.model_error("Invalid response: missing choices")
+        content = choices[0].get("message", {}).get("content")
+        if content is None:
+            raise AIError.model_error("Invalid response: null content")
+        if content == "":
+            raise AIError.model_error("Invalid response: empty content")
+        return content
+
+
+class AnthropicCompatibleProvider(BaseConfiguredProvider):
+    """Base class for Anthropic-compatible providers."""
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with Anthropic-style authorization."""
+        headers = super()._build_headers()
+        api_key = self._get_api_key()
+        headers["x-api-key"] = api_key
+        headers["anthropic-version"] = "2023-06-01"
+        return headers
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build Anthropic-style request body."""
+        # Convert messages to Anthropic format
+        anthropic_messages = []
+        system_message = ""
+
+        for msg in messages:
+            if msg["role"] == "system":
+                system_message = msg["content"]
+            else:
+                anthropic_messages.append({"role": msg["role"], "content": msg["content"]})
+
+        body = {"messages": anthropic_messages, "temperature": temperature, "max_tokens": max_tokens, **kwargs}
+
+        if system_message:
+            body["system"] = system_message
+
+        return body
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse Anthropic-style response."""
+        content = response.get("content")
+        if not content or not isinstance(content, list):
+            raise AIError.model_error("Invalid response: missing content")
+
+        text_content = content[0].get("text")
+        if text_content is None:
+            raise AIError.model_error("Invalid response: null content")
+        if text_content == "":
+            raise AIError.model_error("Invalid response: empty content")
+        return text_content
+
+
+class GenericHTTPProvider(BaseConfiguredProvider):
+    """Base class for completely custom providers."""
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Default implementation - override this in subclasses."""
+        return {"messages": messages, "temperature": temperature, "max_tokens": max_tokens, **kwargs}
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Default implementation - override this in subclasses."""
+        # Try OpenAI-style first
+        choices = response.get("choices")
+        if choices and isinstance(choices, list):
+            content = choices[0].get("message", {}).get("content")
+            if content:
+                return content
+
+        # Try Anthropic-style
+        content = response.get("content")
+        if content and isinstance(content, list):
+            return content[0].get("text", "")
+
+        # Try Ollama-style
+        message = response.get("message", {})
+        if "content" in message:
+            return message["content"]
+
+        # Fallback - try to find any string content
+        for value in response.values():
+            if isinstance(value, str) and len(value) > 10:  # Assume longer strings are content
+                return value
+
+        raise AIError.model_error("Could not extract content from response")
+
+
+__all__ = [
+    "AnthropicCompatibleProvider",
+    "BaseConfiguredProvider",
+    "GenericHTTPProvider",
+    "OpenAICompatibleProvider",
+    "ProviderConfig",
+]

gac/providers/cerebras.py

@@ -1,38 +1,15 @@
 """Cerebras AI provider implementation."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class CerebrasProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Cerebras",
+        api_key_env="CEREBRAS_API_KEY",
+        base_url="https://api.cerebras.ai/v1",
+    )
 
-
-def call_cerebras_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Cerebras API directly."""
-    api_key = os.getenv("CEREBRAS_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("CEREBRAS_API_KEY not found in environment variables")
-
-    url = "https://api.cerebras.ai/v1/chat/completions"
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-
-    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
-
-    try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Cerebras API returned null content")
-        if content == "":
-            raise AIError.model_error("Cerebras API returned empty content")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Cerebras API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Cerebras API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Cerebras API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Cerebras API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Cerebras API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/chutes.py

@@ -2,70 +2,24 @@
 
 import os
 
-import httpx
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-from gac.errors import AIError
 
+class ChutesProvider(OpenAICompatibleProvider):
+    """Chutes.ai OpenAI-compatible provider with custom base URL."""
 
-def call_chutes_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Chutes.ai API directly.
+    config = ProviderConfig(
+        name="Chutes",
+        api_key_env="CHUTES_API_KEY",
+        base_url="",  # Will be set in __init__
+    )
 
-    Chutes.ai provides an OpenAI-compatible API for serverless, decentralized AI compute.
+    def __init__(self, config: ProviderConfig):
+        """Initialize with base URL from environment or default."""
+        base_url = os.getenv("CHUTES_BASE_URL", "https://llm.chutes.ai")
+        config.base_url = f"{base_url.rstrip('/')}/v1"
+        super().__init__(config)
 
-    Args:
-        model: The model to use (e.g., 'deepseek-ai/DeepSeek-V3-0324')
-        messages: List of message dictionaries with 'role' and 'content' keys
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-
-    Returns:
-        The generated commit message
-
-    Raises:
-        AIError: If authentication fails, API errors occur, or response is invalid
-    """
-    api_key = os.getenv("CHUTES_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("CHUTES_API_KEY environment variable not set")
-
-    base_url = os.getenv("CHUTES_BASE_URL", "https://llm.chutes.ai")
-    url = f"{base_url}/v1/chat/completions"
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    data = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Chutes.ai API returned null content")
-        if content == "":
-            raise AIError.model_error("Chutes.ai API returned empty content")
-        return content
-    except httpx.HTTPStatusError as e:
-        status_code = e.response.status_code
-        error_text = e.response.text
-
-        if status_code == 429:
-            raise AIError.rate_limit_error(f"Chutes.ai API rate limit exceeded: {error_text}") from e
-        elif status_code in (502, 503):
-            raise AIError.connection_error(f"Chutes.ai API service unavailable: {status_code} - {error_text}") from e
-        else:
-            raise AIError.model_error(f"Chutes.ai API error: {status_code} - {error_text}") from e
-    except httpx.ConnectError as e:
-        raise AIError.connection_error(f"Chutes.ai API connection error: {str(e)}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Chutes.ai API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Chutes.ai API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Chutes API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"