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

gac/providers/deepseek.py

@@ -0,0 +1,38 @@
+"""DeepSeek API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_deepseek_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call DeepSeek API directly."""
+    api_key = os.getenv("DEEPSEEK_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("DEEPSEEK_API_KEY not found in environment variables")
+
+    url = "https://api.deepseek.com/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("DeepSeek API returned null content")
+        if content == "":
+            raise AIError.model_error("DeepSeek API returned empty content")
+        return content
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"DeepSeek API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"DeepSeek API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"DeepSeek API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling DeepSeek API: {str(e)}") from e

gac/providers/fireworks.py

@@ -0,0 +1,38 @@
+"""Fireworks AI API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_fireworks_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Fireworks AI API directly."""
+    api_key = os.getenv("FIREWORKS_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("FIREWORKS_API_KEY not found in environment variables")
+
+    url = "https://api.fireworks.ai/inference/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("Fireworks AI API returned null content")
+        if content == "":
+            raise AIError.model_error("Fireworks AI API returned empty content")
+        return content
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"Fireworks AI API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"Fireworks AI API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Fireworks AI API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Fireworks AI API: {str(e)}") from e

gac/providers/gemini.py

@@ -0,0 +1,87 @@
+"""Gemini AI provider implementation."""
+
+import os
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_gemini_api(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
+    """Call Gemini API directly."""
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("GEMINI_API_KEY not found in environment variables")
+
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+
+    # Build Gemini request payload, converting roles to supported values.
+    contents: list[dict[str, Any]] = []
+    system_instruction_parts: list[dict[str, str]] = []
+
+    for msg in messages:
+        role = msg.get("role")
+        content_value = msg.get("content")
+        content = "" if content_value is None else str(content_value)
+
+        if role == "system":
+            if content.strip():
+                system_instruction_parts.append({"text": content})
+            continue
+
+        if role == "assistant":
+            gemini_role = "model"
+        elif role == "user":
+            gemini_role = "user"
+        else:
+            raise AIError.model_error(f"Unsupported message role for Gemini API: {role}")
+
+        contents.append({"role": gemini_role, "parts": [{"text": content}]})
+
+    payload: dict[str, Any] = {
+        "contents": contents,
+        "generationConfig": {"temperature": temperature, "maxOutputTokens": max_tokens},
+    }
+
+    if system_instruction_parts:
+        payload["systemInstruction"] = {"role": "system", "parts": system_instruction_parts}
+
+    headers = {"x-goog-api-key": api_key, "Content-Type": "application/json"}
+
+    try:
+        response = httpx.post(url, headers=headers, json=payload, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        # Check for candidates and proper response structure
+        candidates = response_data.get("candidates")
+        if not candidates:
+            raise AIError.model_error("Gemini API response missing candidates")
+
+        candidate = candidates[0]
+        if "content" not in candidate or "parts" not in candidate["content"] or not candidate["content"]["parts"]:
+            raise AIError.model_error("Gemini API response has invalid content structure")
+
+        parts = candidate["content"]["parts"]
+        content_text: str | None = None
+        for part in parts:
+            if isinstance(part, dict):
+                part_text = part.get("text")
+                if isinstance(part_text, str) and part_text:
+                    content_text = part_text
+                    break
+        if content_text is None:
+            raise AIError.model_error("Gemini API response missing text content")
+
+        return content_text
+    except AIError:
+        raise
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"Gemini API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"Gemini API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Gemini API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Gemini API: {str(e)}") from e

gac/providers/groq.py

@@ -0,0 +1,63 @@
+"""Groq API provider for gac."""
+
+import logging
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def call_groq_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Groq API directly."""
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("GROQ_API_KEY not found in environment variables")
+
+    url = "https://api.groq.com/openai/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()
+
+        # Debug logging to understand response structure
+        logger.debug(f"Groq API response: {response_data}")
+
+        # Handle different response formats
+        if "choices" in response_data and len(response_data["choices"]) > 0:
+            choice = response_data["choices"][0]
+            if "message" in choice and "content" in choice["message"]:
+                content = choice["message"]["content"]
+                logger.debug(f"Found content in message.content: {repr(content)}")
+                if content is None:
+                    raise AIError.model_error("Groq API returned null content")
+                if content == "":
+                    raise AIError.model_error("Groq API returned empty content")
+                return content
+            elif "text" in choice:
+                content = choice["text"]
+                logger.debug(f"Found content in choice.text: {repr(content)}")
+                if content is None:
+                    logger.warning("Groq API returned None content in choice.text")
+                    return ""
+                return content
+            else:
+                logger.warning(f"Unexpected choice structure: {choice}")
+
+        # If we can't find content in the expected places, raise an error
+        logger.error(f"Unexpected response format from Groq API: {response_data}")
+        raise AIError.model_error(f"Unexpected response format from Groq API: {response_data}")
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"Groq API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"Groq API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Groq API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Groq API: {str(e)}") from e

gac/providers/kimi_coding.py

@@ -0,0 +1,63 @@
+"""Kimi Coding AI provider implementation."""
+
+import json
+import logging
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def call_kimi_coding_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Kimi Coding API using OpenAI-compatible endpoint."""
+    api_key = os.getenv("KIMI_CODING_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("KIMI_CODING_API_KEY not found in environment variables")
+
+    base_url = "https://api.kimi.com/coding/v1"
+    url = f"{base_url}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    # Use standard OpenAI format - no message conversion needed
+    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()
+
+        try:
+            content = response_data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError) as e:
+            logger.error(f"Unexpected response format from Kimi Coding API. Response: {json.dumps(response_data)}")
+            raise AIError.model_error(
+                f"Kimi Coding API returned unexpected format. Expected OpenAI-compatible 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("Kimi Coding API returned null content")
+        if content == "":
+            raise AIError.model_error("Kimi Coding API returned empty content")
+        return content
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"Kimi Coding 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"Kimi Coding API authentication failed: {error_text}") from e
+        elif status_code == 429:
+            raise AIError.rate_limit_error(f"Kimi Coding API rate limit exceeded: {error_text}") from e
+        else:
+            raise AIError.model_error(f"Kimi Coding API error: {status_code} - {error_text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Kimi Coding API request timed out: {str(e)}") from e
+    except AIError:
+        raise
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Kimi Coding API: {str(e)}") from e

gac/providers/lmstudio.py

@@ -0,0 +1,59 @@
+"""LM Studio AI provider implementation."""
+
+import os
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_lmstudio_api(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
+    """Call LM Studio's OpenAI-compatible API."""
+    api_url = os.getenv("LMSTUDIO_API_URL", "http://localhost:1234")
+    api_url = api_url.rstrip("/")
+
+    url = f"{api_url}/v1/chat/completions"
+
+    headers = {"Content-Type": "application/json"}
+    api_key = os.getenv("LMSTUDIO_API_KEY")
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "stream": False,
+    }
+
+    try:
+        response = httpx.post(url, headers=headers, json=payload, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+        choices = response_data.get("choices") or []
+        if not choices:
+            raise AIError.model_error("LM Studio API response missing choices")
+
+        message = choices[0].get("message") or {}
+        content = message.get("content")
+        if content:
+            return content
+
+        # Some OpenAI-compatible servers return text field directly
+        content = choices[0].get("text")
+        if content:
+            return content
+
+        raise AIError.model_error("LM Studio API response missing content")
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"LM Studio connection failed: {str(e)}") from e
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"LM Studio API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"LM Studio API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"LM Studio API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling LM Studio API: {str(e)}") from e

gac/providers/minimax.py

@@ -0,0 +1,38 @@
+"""MiniMax API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+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}
+
+    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("MiniMax API returned null content")
+        if content == "":
+            raise AIError.model_error("MiniMax API returned empty content")
+        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

gac/providers/mistral.py

@@ -0,0 +1,38 @@
+"""Mistral API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+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}
+
+    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("Mistral API returned null content")
+        if content == "":
+            raise AIError.model_error("Mistral API returned empty content")
+        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

gac/providers/moonshot.py

@@ -0,0 +1,38 @@
+"""Moonshot AI provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+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}
+
+    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("Moonshot AI API returned null content")
+        if content == "":
+            raise AIError.model_error("Moonshot AI API returned empty content")
+        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

gac/providers/ollama.py

@@ -0,0 +1,50 @@
+"""Ollama AI provider implementation."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+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")
+
+    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}"
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        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"]
+        else:
+            # Fallback: return the full response as string
+            content = str(response_data)
+
+        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

@@ -0,0 +1,38 @@
+"""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

gac/providers/openrouter.py

@@ -0,0 +1,58 @@
+"""OpenRouter API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+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