gac 3.10.3__py3-none-any.whl

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",
+]

gac/providers/replicate.py

@@ -0,0 +1,156 @@
+"""Replicate API provider for gac."""
+
+import time
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+from gac.providers.base import GenericHTTPProvider, ProviderConfig
+from gac.utils import get_ssl_verify
+
+
+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
+
+        # Create prediction
+        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']}"
+        max_wait_time = 120
+        wait_interval = 2
+        elapsed_time = 0
+
+        while elapsed_time < max_wait_time:
+            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")

gac/providers/streamlake.py

@@ -0,0 +1,31 @@
+"""StreamLake (Vanchin) API provider for gac."""
+
+import os
+
+from gac.errors import AIError
+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

@@ -0,0 +1,40 @@
+"""Synthetic.new API provider for gac."""
+
+import os
+from typing import Any
+
+from gac.errors import AIError
+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

gac/providers/together.py

@@ -0,0 +1,15 @@
+"""Together AI API provider for gac."""
+
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class TogetherProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Together",
+        api_key_env="TOGETHER_API_KEY",
+        base_url="https://api.together.xyz/v1",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Together API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/zai.py

@@ -0,0 +1,31 @@
+"""Z.AI API provider for gac."""
+
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class ZAIProvider(OpenAICompatibleProvider):
+    """Z.AI regular API provider with OpenAI-compatible format."""
+
+    config = ProviderConfig(
+        name="Z.AI",
+        api_key_env="ZAI_API_KEY",
+        base_url="https://api.z.ai/api/paas/v4",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Z.AI API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
+
+
+class ZAICodingProvider(OpenAICompatibleProvider):
+    """Z.AI coding API provider with OpenAI-compatible format."""
+
+    config = ProviderConfig(
+        name="Z.AI Coding",
+        api_key_env="ZAI_API_KEY",
+        base_url="https://api.z.ai/api/coding/paas/v4",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Z.AI Coding API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"