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

gac/providers/minimax.py

@@ -1,48 +1,15 @@
 """MiniMax API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+class MinimaxProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="MiniMax",
+        api_key_env="MINIMAX_API_KEY",
+        base_url="https://api.minimaxi.com/v1",
+    )
 
-logger = logging.getLogger(__name__)
-
-
-def call_minimax_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call MiniMax API directly."""
-    api_key = os.getenv("MINIMAX_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("MINIMAX_API_KEY not found in environment variables")
-
-    url = "https://api.minimax.io/v1/chat/completions"
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-
-    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
-
-    logger.debug(f"Calling MiniMax API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("MiniMax API returned null content")
-        if content == "":
-            raise AIError.model_error("MiniMax API returned empty content")
-        logger.debug("MiniMax API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"MiniMax API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"MiniMax API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"MiniMax API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling MiniMax API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get MiniMax API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/mistral.py

@@ -1,48 +1,15 @@
 """Mistral API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+class MistralProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Mistral",
+        api_key_env="MISTRAL_API_KEY",
+        base_url="https://api.mistral.ai/v1",
+    )
 
-logger = logging.getLogger(__name__)
-
-
-def call_mistral_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Mistral API directly."""
-    api_key = os.getenv("MISTRAL_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("MISTRAL_API_KEY not found in environment variables")
-
-    url = "https://api.mistral.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}
-
-    logger.debug(f"Calling Mistral API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Mistral API returned null content")
-        if content == "":
-            raise AIError.model_error("Mistral API returned empty content")
-        logger.debug("Mistral API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Mistral API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Mistral API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Mistral API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Mistral API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Mistral API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/moonshot.py

@@ -1,48 +1,15 @@
 """Moonshot AI provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+class MoonshotProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Moonshot",
+        api_key_env="MOONSHOT_API_KEY",
+        base_url="https://api.moonshot.cn/v1",
+    )
 
-logger = logging.getLogger(__name__)
-
-
-def call_moonshot_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Moonshot AI API directly."""
-    api_key = os.getenv("MOONSHOT_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("MOONSHOT_API_KEY not found in environment variables")
-
-    url = "https://api.moonshot.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}
-
-    logger.debug(f"Calling Moonshot AI API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Moonshot AI API returned null content")
-        if content == "":
-            raise AIError.model_error("Moonshot AI API returned empty content")
-        logger.debug("Moonshot AI API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Moonshot AI API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Moonshot AI API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Moonshot AI API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Moonshot AI API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Moonshot API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/ollama.py

@@ -1,60 +1,73 @@
-"""Ollama AI provider implementation."""
+"""Ollama API provider for gac."""
 
-import logging
 import os
+from typing import Any
 
-import httpx
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
 
-logger = logging.getLogger(__name__)
+class OllamaProvider(OpenAICompatibleProvider):
+    """Ollama provider for local LLM models with optional authentication."""
 
+    config = ProviderConfig(
+        name="Ollama",
+        api_key_env="OLLAMA_API_KEY",
+        base_url="http://localhost:11434",
+    )
 
-def call_ollama_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Ollama API directly."""
-    api_url = os.getenv("OLLAMA_API_URL", "http://localhost:11434")
-    api_key = os.getenv("OLLAMA_API_KEY")
+    def __init__(self, config: ProviderConfig):
+        """Initialize with configurable URL from environment."""
+        super().__init__(config)
+        # Allow URL override via environment variable
+        api_url = os.getenv("OLLAMA_API_URL", "http://localhost:11434")
+        self.config.base_url = api_url.rstrip("/")
 
-    url = f"{api_url.rstrip('/')}/api/chat"
-    data = {"model": model, "messages": messages, "temperature": temperature, "stream": False}
-    headers = {"Content-Type": "application/json"}
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with optional API key."""
+        headers = super()._build_headers()
+        api_key = os.getenv("OLLAMA_API_KEY")
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        return headers
 
-    logger.debug(f"Calling Ollama API with model={model}")
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build Ollama request body with stream disabled."""
+        return {
+            "messages": messages,
+            "temperature": temperature,
+            "stream": False,
+            **kwargs,
+        }
 
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get API URL with /api/chat endpoint."""
+        return f"{self.config.base_url}/api/chat"
+
+    def _get_api_key(self) -> str:
+        """Get optional API key for Ollama."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            return ""  # Optional API key
+        return api_key
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse Ollama response with flexible format support."""
+        from gac.errors import AIError
 
-        content = None
         # Handle different response formats from Ollama
-        if "message" in response_data and "content" in response_data["message"]:
-            content = response_data["message"]["content"]
-        elif "response" in response_data:
-            content = response_data["response"]
+        if "message" in response and "content" in response["message"]:
+            content = response["message"]["content"]
+        elif "response" in response:
+            content = response["response"]
         else:
-            # Fallback: return the full response as string
-            content = str(response_data)
+            # Fallback: try to serialize response
+            content = str(response) if response else ""
 
         if content is None:
             raise AIError.model_error("Ollama API returned null content")
         if content == "":
             raise AIError.model_error("Ollama API returned empty content")
-        logger.debug("Ollama API response received successfully")
+
         return content
-    except httpx.ConnectError as e:
-        raise AIError.connection_error(f"Ollama connection failed. Make sure Ollama is running: {str(e)}") from e
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Ollama API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Ollama API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Ollama API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Ollama API: {str(e)}") from e

gac/providers/openai.py

@@ -1,48 +1,32 @@
 """OpenAI API provider for gac."""
 
-import logging
-import os
-
-import httpx
-
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
-
-logger = logging.getLogger(__name__)
-
-
-def call_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call OpenAI API directly."""
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("OPENAI_API_KEY not found in environment variables")
-
-    url = "https://api.openai.com/v1/chat/completions"
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-
-    data = {"model": model, "messages": messages, "temperature": temperature, "max_completion_tokens": max_tokens}
-
-    logger.debug(f"Calling OpenAI API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("OpenAI API returned null content")
-        if content == "":
-            raise AIError.model_error("OpenAI API returned empty content")
-        logger.debug("OpenAI API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"OpenAI API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"OpenAI API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"OpenAI API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling OpenAI API: {str(e)}") from e
+from typing import Any
+
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class OpenAIProvider(OpenAICompatibleProvider):
+    """OpenAI API provider with model-specific adjustments."""
+
+    config = ProviderConfig(name="OpenAI", api_key_env="OPENAI_API_KEY", base_url="https://api.openai.com/v1")
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get OpenAI API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build OpenAI-specific request body."""
+        data = super()._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+
+        # OpenAI uses max_completion_tokens instead of max_tokens
+        data["max_completion_tokens"] = data.pop("max_tokens")
+
+        # Handle optional parameters
+        if "response_format" in kwargs:
+            data["response_format"] = kwargs["response_format"]
+        if "stop" in kwargs:
+            data["stop"] = kwargs["stop"]
+
+        return data

gac/providers/openrouter.py

@@ -1,68 +1,21 @@
 """OpenRouter API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+class OpenRouterProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="OpenRouter",
+        api_key_env="OPENROUTER_API_KEY",
+        base_url="https://openrouter.ai/api/v1",
+    )
 
-logger = logging.getLogger(__name__)
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get OpenRouter API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
 
-
-def call_openrouter_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call OpenRouter API directly."""
-    api_key = os.getenv("OPENROUTER_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("OPENROUTER_API_KEY environment variable not set")
-
-    url = "https://openrouter.ai/api/v1/chat/completions"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    data = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    logger.debug(f"Calling OpenRouter API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("OpenRouter API returned null content")
-        if content == "":
-            raise AIError.model_error("OpenRouter API returned empty content")
-        logger.debug("OpenRouter API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        # Handle specific HTTP status codes
-        status_code = e.response.status_code
-        error_text = e.response.text
-
-        # Rate limiting
-        if status_code == 429:
-            raise AIError.rate_limit_error(f"OpenRouter API rate limit exceeded: {error_text}") from e
-        # Service unavailable
-        elif status_code in (502, 503):
-            raise AIError.connection_error(f"OpenRouter API service unavailable: {status_code} - {error_text}") from e
-        # Other HTTP errors
-        else:
-            raise AIError.model_error(f"OpenRouter API error: {status_code} - {error_text}") from e
-    except httpx.ConnectError as e:
-        raise AIError.connection_error(f"OpenRouter API connection error: {str(e)}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"OpenRouter API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling OpenRouter API: {str(e)}") from e
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with OpenRouter-style authorization and HTTP-Referer."""
+        headers = super()._build_headers()
+        headers["HTTP-Referer"] = "https://github.com/codeindolence/gac"
+        return headers

gac/providers/protocol.py

@@ -0,0 +1,71 @@
+"""Provider protocol for type-safe AI provider implementations."""
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ProviderProtocol(Protocol):
+    """Protocol defining the contract for AI providers.
+
+    All providers must implement this protocol to ensure consistent
+    interface and type safety across the codebase.
+
+    This protocol supports both class-based providers (with methods)
+    and function-based providers (used in the registry).
+    """
+
+    def generate(
+        self, model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int, **kwargs: Any
+    ) -> str:
+        """Generate text using the AI model.
+
+        Args:
+            model: The model name to use
+            messages: List of message dictionaries in chat format
+            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 generation-related errors
+        """
+        ...
+
+    @property
+    def name(self) -> str:
+        """Get the provider name.
+
+        Returns:
+            Provider name identifier
+        """
+        ...
+
+    @property
+    def api_key_env(self) -> str:
+        """Get the environment variable name for the API key.
+
+        Returns:
+            Environment variable name
+        """
+        ...
+
+    @property
+    def base_url(self) -> str:
+        """Get the base URL for the API.
+
+        Returns:
+            Base API URL
+        """
+        ...
+
+    @property
+    def timeout(self) -> int:
+        """Get the timeout in seconds.
+
+        Returns:
+            Timeout in seconds
+        """
+        ...