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

gac/providers/qwen.py

@@ -1,76 +1,64 @@
-"""Qwen API provider for gac with OAuth support."""
+"""Qwen API provider for gac with OAuth-only support."""
 
-import logging
-import os
-
-import httpx
-
-from gac.constants import ProviderDefaults
 from gac.errors import AIError
 from gac.oauth import QwenOAuthProvider, TokenStore
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-logger = logging.getLogger(__name__)
-
-QWEN_API_URL = "https://chat.qwen.ai/api/v1/chat/completions"
-
-
-def get_qwen_auth() -> tuple[str, str]:
-    """Get Qwen authentication (API key or OAuth token).
+QWEN_DEFAULT_API_URL = "https://chat.qwen.ai/api/v1"
 
-    Returns:
-        Tuple of (token, api_url) for authentication.
-    """
-    api_key = os.getenv("QWEN_API_KEY")
-    if api_key:
-        return api_key, QWEN_API_URL
 
-    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("/chat/completions"):
-                resource_url = resource_url.rstrip("/") + "/v1/chat/completions"
-            api_url = resource_url
-        else:
-            api_url = QWEN_API_URL
-        return token["access_token"], api_url
+class QwenProvider(OpenAICompatibleProvider):
+    """Qwen provider with OAuth-only authentication."""
 
-    raise AIError.authentication_error(
-        "Qwen authentication not found. Set QWEN_API_KEY or run 'gac auth qwen login' for OAuth."
+    config = ProviderConfig(
+        name="Qwen",
+        api_key_env="",
+        base_url=QWEN_DEFAULT_API_URL,
     )
 
-
-def call_qwen_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Qwen API with OAuth or API key authentication."""
-    auth_token, api_url = get_qwen_auth()
-
-    headers = {"Authorization": f"Bearer {auth_token}", "Content-Type": "application/json"}
-
-    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
-
-    logger.debug(f"Calling Qwen API with model={model}")
-
-    try:
-        response = httpx.post(api_url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT)
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Qwen API returned null content")
-        if content == "":
-            raise AIError.model_error("Qwen API returned empty content")
-        logger.debug("Qwen API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            raise AIError.authentication_error(f"Qwen authentication failed: {e.response.text}") from e
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Qwen API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Qwen API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Qwen API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Qwen API: {str(e)}") from e
+    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",
+]

gac/providers/replicate.py

@@ -1,110 +1,156 @@
 """Replicate API provider for gac."""
 
-import logging
-import os
+import time
+from typing import Any
 
 import httpx
 
-from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.providers.base import GenericHTTPProvider, ProviderConfig
 from gac.utils import get_ssl_verify
 
-logger = logging.getLogger(__name__)
 
+class ReplicateProvider(GenericHTTPProvider):
+    """Replicate API provider with async prediction polling."""
+
+    config = ProviderConfig(
+        name="Replicate",
+        api_key_env="REPLICATE_API_TOKEN",
+        base_url="https://api.replicate.com/v1",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Replicate API URL with /predictions endpoint."""
+        return f"{self.config.base_url}/predictions"
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with Token-based authorization."""
+        headers = super()._build_headers()
+        # Replace Bearer token with Token format
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        headers["Authorization"] = f"Token {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 Replicate prediction payload with message-to-prompt conversion."""
+        # Convert messages to a single prompt for Replicate
+        prompt_parts = []
+        system_message = None
+
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content", "")
+
+            if role == "system":
+                system_message = content
+            elif role == "user":
+                prompt_parts.append(f"Human: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"Assistant: {content}")
+
+        # Add system message at the beginning if present
+        if system_message:
+            prompt_parts.insert(0, f"System: {system_message}")
+
+        # Add final assistant prompt
+        prompt_parts.append("Assistant:")
+        full_prompt = "\n\n".join(prompt_parts)
+
+        # Replicate prediction payload
+        return {
+            "version": model,  # Replicate uses version string as model identifier
+            "input": {
+                "prompt": full_prompt,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+            },
+        }
+
+    def generate(
+        self,
+        model: str,
+        messages: list[dict[str, Any]],
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        **kwargs: Any,
+    ) -> str:
+        """Override generate to handle Replicate's async polling mechanism."""
+        # Build request components
+        try:
+            url = self._get_api_url(model)
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
+
+        try:
+            headers = self._build_headers()
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
+
+        try:
+            body = self._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
 
-def call_replicate_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Replicate API directly."""
-    api_key = os.getenv("REPLICATE_API_TOKEN")
-    if not api_key:
-        raise AIError.authentication_error("REPLICATE_API_TOKEN not found in environment variables")
-
-    # Replicate uses a different endpoint for language models
-    url = "https://api.replicate.com/v1/predictions"
-    headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
-
-    # Convert messages to a single prompt for Replicate
-    prompt_parts = []
-    system_message = None
-
-    for message in messages:
-        role = message.get("role")
-        content = message.get("content", "")
-
-        if role == "system":
-            system_message = content
-        elif role == "user":
-            prompt_parts.append(f"Human: {content}")
-        elif role == "assistant":
-            prompt_parts.append(f"Assistant: {content}")
-
-    # Add system message at the beginning if present
-    if system_message:
-        prompt_parts.insert(0, f"System: {system_message}")
-
-    # Add final assistant prompt
-    prompt_parts.append("Assistant:")
-    full_prompt = "\n\n".join(prompt_parts)
-
-    # Replicate prediction payload
-    data = {
-        "version": model,  # Replicate uses version string as model identifier
-        "input": {
-            "prompt": full_prompt,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        },
-    }
-
-    logger.debug(f"Calling Replicate API with model={model}")
-
-    try:
         # Create prediction
-        response = httpx.post(
-            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        response.raise_for_status()
-        prediction_data = response.json()
-
-        # Get the prediction URL to check status
+        try:
+            response = httpx.post(url, json=body, headers=headers, timeout=self.config.timeout, verify=get_ssl_verify())
+            response.raise_for_status()
+            prediction_data = response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 429:
+                raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
+            elif e.response.status_code == 401:
+                raise AIError.authentication_error(f"Replicate API authentication failed: {e.response.text}") from e
+            raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
+        except httpx.TimeoutException as e:
+            raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
+        except Exception as e:
+            raise AIError.model_error(f"Error calling Replicate API: {str(e)}") from e
+
+        # Poll for completion
         get_url = f"https://api.replicate.com/v1/predictions/{prediction_data['id']}"
-
-        # Poll for completion (Replicate predictions are async)
         max_wait_time = 120
         wait_interval = 2
         elapsed_time = 0
 
         while elapsed_time < max_wait_time:
-            get_response = httpx.get(
-                get_url, headers=headers, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-            )
-            get_response.raise_for_status()
-            status_data = get_response.json()
-
-            if status_data["status"] == "succeeded":
-                content = status_data["output"]
-                if not content:
-                    raise AIError.model_error("Replicate API returned empty content")
-                logger.debug("Replicate API response received successfully")
-                return content
-            elif status_data["status"] == "failed":
-                raise AIError.model_error(f"Replicate prediction failed: {status_data.get('error', 'Unknown error')}")
-            elif status_data["status"] in ["starting", "processing"]:
-                import time
-
-                time.sleep(wait_interval)
-                elapsed_time += wait_interval
-            else:
-                raise AIError.model_error(f"Replicate API returned unknown status: {status_data['status']}")
+            try:
+                get_response = httpx.get(get_url, headers=headers, timeout=self.config.timeout, verify=get_ssl_verify())
+                get_response.raise_for_status()
+                status_data = get_response.json()
+
+                if status_data["status"] == "succeeded":
+                    content = status_data["output"]
+                    if not content:
+                        raise AIError.model_error("Replicate API returned empty content")
+                    return content
+                elif status_data["status"] == "failed":
+                    raise AIError.model_error(
+                        f"Replicate prediction failed: {status_data.get('error', 'Unknown error')}"
+                    )
+                elif status_data["status"] in ["starting", "processing"]:
+                    time.sleep(wait_interval)
+                    elapsed_time += wait_interval
+                else:
+                    raise AIError.model_error(f"Replicate API returned unknown status: {status_data['status']}")
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 429:
+                    raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
+                raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
+            except httpx.TimeoutException as e:
+                raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
+            except AIError:
+                raise
+            except Exception as e:
+                raise AIError.model_error(f"Error polling Replicate API: {str(e)}") from e
 
         raise AIError.timeout_error("Replicate API prediction timed out")
-
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
-        elif e.response.status_code == 401:
-            raise AIError.authentication_error(f"Replicate API authentication failed: {e.response.text}") from e
-        raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Replicate API: {str(e)}") from e

gac/providers/streamlake.py

@@ -1,61 +1,31 @@
 """StreamLake (Vanchin) 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_streamlake_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call StreamLake (Vanchin) chat completions API."""
-    api_key = os.getenv("STREAMLAKE_API_KEY") or os.getenv("VC_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error(
-            "STREAMLAKE_API_KEY not found in environment variables (VC_API_KEY alias also not set)"
-        )
-
-    url = "https://vanchin.streamlake.ai/api/gateway/v1/endpoints/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 StreamLake 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()
-        choices = response_data.get("choices")
-        if not choices:
-            raise AIError.model_error("StreamLake API returned no choices")
-
-        message = choices[0].get("message", {})
-        content = message.get("content")
-        if content is None:
-            raise AIError.model_error("StreamLake API returned null content")
-        if content == "":
-            raise AIError.model_error("StreamLake API returned empty content")
-
-        logger.debug("StreamLake API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"StreamLake API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"StreamLake API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"StreamLake API request timed out: {str(e)}") from e
-    except Exception as e:  # noqa: BLE001 - convert to AIError
-        raise AIError.model_error(f"Error calling StreamLake API: {str(e)}") from e
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class StreamlakeProvider(OpenAICompatibleProvider):
+    """StreamLake (Vanchin) OpenAI-compatible provider with alternative env vars."""
+
+    config = ProviderConfig(
+        name="StreamLake",
+        api_key_env="STREAMLAKE_API_KEY",
+        base_url="https://vanchin.streamlake.ai/api/gateway/v1/endpoints",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get StreamLake API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
+
+    def _get_api_key(self) -> str:
+        """Get API key from environment with fallback to VC_API_KEY."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            api_key = os.getenv("VC_API_KEY")
+        if not api_key:
+            raise AIError.authentication_error(
+                "STREAMLAKE_API_KEY not found in environment variables (VC_API_KEY alias also not set)"
+            )
+        return api_key

gac/providers/synthetic.py

@@ -1,52 +1,40 @@
 """Synthetic.new API provider for gac."""
 
-import logging
 import os
+from typing import Any
 
-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_synthetic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Synthetic API directly."""
-    # Handle model names without hf: prefix
-    if not model.startswith("hf:"):
-        model = f"hf:{model}"
-
-    api_key = os.getenv("SYNTHETIC_API_KEY") or os.getenv("SYN_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("SYNTHETIC_API_KEY or SYN_API_KEY not found in environment variables")
-
-    url = "https://api.synthetic.new/openai/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 Synthetic.new 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("Synthetic.new API returned null content")
-        if content == "":
-            raise AIError.model_error("Synthetic.new API returned empty content")
-        logger.debug("Synthetic.new API response received successfully")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Synthetic.new API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Synthetic.new API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Synthetic.new API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Synthetic.new API: {str(e)}") from e
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class SyntheticProvider(OpenAICompatibleProvider):
+    """Synthetic.new OpenAI-compatible provider with alternative env vars and model preprocessing."""
+
+    config = ProviderConfig(
+        name="Synthetic",
+        api_key_env="SYNTHETIC_API_KEY",
+        base_url="https://api.synthetic.new/openai/v1/chat/completions",
+    )
+
+    def _get_api_key(self) -> str:
+        """Get API key from environment with fallback to SYN_API_KEY."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            api_key = os.getenv("SYN_API_KEY")
+        if not api_key:
+            raise AIError.authentication_error("SYNTHETIC_API_KEY or SYN_API_KEY not found in environment variables")
+        return api_key
+
+    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 with model name preprocessing and max_completion_tokens."""
+        # Auto-add hf: prefix if not present
+        if not model.startswith("hf:"):
+            model = f"hf:{model}"
+
+        data = super()._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        data["max_completion_tokens"] = data.pop("max_tokens")
+        # Ensure the prefixed model is used
+        data["model"] = model
+        return data