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

gac/providers/ollama.py

@@ -1,50 +1,73 @@
-"""Ollama AI provider implementation."""
+"""Ollama API provider for gac."""
 
 import os
+from typing import Any
 
-import httpx
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-from gac.errors import AIError
 
+class OllamaProvider(OpenAICompatibleProvider):
+    """Ollama provider for local LLM models with optional authentication."""
 
-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")
+    config = ProviderConfig(
+        name="Ollama",
+        api_key_env="OLLAMA_API_KEY",
+        base_url="http://localhost:11434",
+    )
 
-    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 __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("/")
 
-    try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        response_data = response.json()
+    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
+
+    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,
+        }
+
+    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")
+
         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,38 +1,32 @@
 """OpenAI API provider for gac."""
 
-import os
-
-import httpx
-
-from gac.errors import AIError
-
-
-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}
-
-    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("OpenAI API returned null content")
-        if content == "":
-            raise AIError.model_error("OpenAI API returned empty content")
-        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,58 +1,21 @@
 """OpenRouter API provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class OpenRouterProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="OpenRouter",
+        api_key_env="OPENROUTER_API_KEY",
+        base_url="https://openrouter.ai/api/v1",
+    )
 
+    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,
-    }
-
-    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("OpenRouter API returned null content")
-        if content == "":
-            raise AIError.model_error("OpenRouter API returned empty content")
-        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
+        """
+        ...

gac/providers/qwen.py

@@ -0,0 +1,64 @@
+"""Qwen API provider for gac with OAuth-only support."""
+
+from gac.errors import AIError
+from gac.oauth import QwenOAuthProvider, TokenStore
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+QWEN_DEFAULT_API_URL = "https://chat.qwen.ai/api/v1"
+
+
+class QwenProvider(OpenAICompatibleProvider):
+    """Qwen provider with OAuth-only authentication."""
+
+    config = ProviderConfig(
+        name="Qwen",
+        api_key_env="",
+        base_url=QWEN_DEFAULT_API_URL,
+    )
+
+    def __init__(self, config: ProviderConfig):
+        """Initialize with OAuth authentication."""
+        super().__init__(config)
+        self._auth_token, self._resolved_base_url = self._get_oauth_token()
+
+    def _get_api_key(self) -> str:
+        """Return placeholder for parent class compatibility (OAuth is used instead)."""
+        return "oauth-token"
+
+    def _get_oauth_token(self) -> tuple[str, str]:
+        """Get Qwen OAuth token from token store.
+
+        Returns:
+            Tuple of (access_token, api_url) for authentication.
+
+        Raises:
+            AIError: If no OAuth token is found.
+        """
+        oauth_provider = QwenOAuthProvider(TokenStore())
+        token = oauth_provider.get_token()
+        if token:
+            resource_url = token.get("resource_url")
+            if resource_url:
+                if not resource_url.startswith(("http://", "https://")):
+                    resource_url = f"https://{resource_url}"
+                if not resource_url.endswith("/v1"):
+                    resource_url = resource_url.rstrip("/") + "/v1"
+                base_url = resource_url
+            else:
+                base_url = QWEN_DEFAULT_API_URL
+            return token["access_token"], base_url
+
+        raise AIError.authentication_error("Qwen OAuth token not found. Run 'gac auth qwen login' to authenticate.")
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with OAuth token."""
+        headers = super()._build_headers()
+        # Replace Bearer token with the stored auth token
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        headers["Authorization"] = f"Bearer {self._auth_token}"
+        return headers
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Qwen API URL with /chat/completions endpoint."""
+        return f"{self._resolved_base_url}/chat/completions"

gac/providers/registry.py

@@ -0,0 +1,58 @@
+"""Provider registry for AI providers."""
+
+from collections.abc import Callable
+from functools import wraps
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gac.providers.base import BaseConfiguredProvider
+
+# Global registry for provider functions
+PROVIDER_REGISTRY: dict[str, Callable[..., str]] = {}
+
+
+def create_provider_func(provider_class: type["BaseConfiguredProvider"]) -> Callable[..., str]:
+    """Create a provider function from a provider class.
+
+    This function creates a callable that:
+    1. Instantiates the provider class
+    2. Calls generate() with the provided arguments
+    3. Is wrapped with @handle_provider_errors for consistent error handling
+
+    Args:
+        provider_class: A provider class with a `config` class attribute
+
+    Returns:
+        A callable function that can be used to generate text
+    """
+    from gac.providers.error_handler import handle_provider_errors
+
+    provider_name = provider_class.config.name
+
+    @handle_provider_errors(provider_name)
+    @wraps(provider_class.generate)
+    def provider_func(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
+        provider = provider_class(provider_class.config)
+        return provider.generate(model=model, messages=messages, temperature=temperature, max_tokens=max_tokens)
+
+    # Add metadata for introspection
+    provider_func.__name__ = f"call_{provider_name.lower().replace(' ', '_').replace('.', '_')}_api"
+    provider_func.__doc__ = f"Call {provider_name} API to generate text."
+
+    return provider_func
+
+
+def register_provider(name: str, provider_class: type["BaseConfiguredProvider"]) -> None:
+    """Register a provider class and auto-generate its function.
+
+    Args:
+        name: Provider name (e.g., "openai", "anthropic")
+        provider_class: The provider class to register
+    """
+    PROVIDER_REGISTRY[name] = create_provider_func(provider_class)
+
+
+__all__ = [
+    "PROVIDER_REGISTRY",
+    "register_provider",
+]