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

gac/providers/fireworks.py

@@ -1,38 +1,15 @@
 """Fireworks AI API provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class FireworksProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Fireworks",
+        api_key_env="FIREWORKS_API_KEY",
+        base_url="https://api.fireworks.ai/inference/v1",
+    )
 
-
-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
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Fireworks API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/gemini.py

@@ -1,61 +1,74 @@
 """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")
+from gac.providers.base import GenericHTTPProvider, ProviderConfig
+
+
+class GeminiProvider(GenericHTTPProvider):
+    """Google Gemini provider with custom format and role conversion."""
+
+    config = ProviderConfig(
+        name="Gemini",
+        api_key_env="GEMINI_API_KEY",
+        base_url="https://generativelanguage.googleapis.com/v1beta",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Build Gemini URL with model in path."""
+        if model is None:
+            return super()._get_api_url(model)
+        return f"{self.config.base_url}/models/{model}:generateContent"
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with Google API key."""
+        headers = super()._build_headers()
+        # Remove any Authorization header
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        headers["x-goog-api-key"] = 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 Gemini-format request with role conversion and system instruction extraction."""
+        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}]})
+
+        body: dict[str, Any] = {
+            "contents": contents,
+            "generationConfig": {"temperature": temperature, "maxOutputTokens": max_tokens},
+        }
+
+        if system_instruction_parts:
+            body["systemInstruction"] = {"role": "system", "parts": system_instruction_parts}
+
+        return body
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse Gemini response format: candidates[0].content.parts[0].text."""
+        candidates = response.get("candidates")
         if not candidates:
             raise AIError.model_error("Gemini API response missing candidates")
 
@@ -75,13 +88,3 @@ def call_gemini_api(model: str, messages: list[dict[str, Any]], temperature: flo
             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

@@ -1,63 +1,15 @@
 """Groq API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class GroqProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Groq",
+        api_key_env="GROQ_API_KEY",
+        base_url="https://api.groq.com/openai/v1",
+    )
 
-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
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Groq API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/kimi_coding.py

@@ -1,63 +1,27 @@
 """Kimi Coding AI provider implementation."""
 
-import json
-import logging
-import os
+from typing import Any
 
-import httpx
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
+class KimiCodingProvider(OpenAICompatibleProvider):
+    """Kimi Coding API provider using OpenAI-compatible format."""
 
+    config = ProviderConfig(
+        name="Kimi Coding",
+        api_key_env="KIMI_CODING_API_KEY",
+        base_url="https://api.kimi.com/coding/v1",
+    )
 
-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")
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Kimi Coding API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
 
-    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
+    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 max_completion_tokens instead of max_tokens."""
+        data = super()._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        data["max_completion_tokens"] = data.pop("max_tokens")
+        return data

gac/providers/lmstudio.py

@@ -1,59 +1,80 @@
-"""LM Studio AI provider implementation."""
+"""LM Studio 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 LMStudioProvider(OpenAICompatibleProvider):
+    """LM Studio provider for local OpenAI-compatible models."""
 
-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("/")
+    config = ProviderConfig(
+        name="LM Studio",
+        api_key_env="LMSTUDIO_API_KEY",
+        base_url="http://localhost:1234/v1",
+    )
 
-    url = f"{api_url}/v1/chat/completions"
+    def __init__(self, config: ProviderConfig):
+        """Initialize with configurable URL from environment."""
+        super().__init__(config)
+        # Allow URL override via environment variable
+        api_url = os.getenv("LMSTUDIO_API_URL", "http://localhost:1234")
+        api_url = api_url.rstrip("/")
+        self.config.base_url = f"{api_url}/v1"
 
-    headers = {"Content-Type": "application/json"}
-    api_key = os.getenv("LMSTUDIO_API_KEY")
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
+    def _get_api_key(self) -> str:
+        """Get optional API key for LM Studio."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            return ""  # Optional API key
+        return api_key
 
-    payload: dict[str, Any] = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "stream": False,
-    }
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with optional API key."""
+        headers = super()._build_headers()
+        # Remove Bearer token from parent if it was added
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        # Add optional Authorization
+        api_key = os.getenv("LMSTUDIO_API_KEY")
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        return headers
 
-    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")
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get LM Studio API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
 
-        message = choices[0].get("message") or {}
-        content = message.get("content")
-        if content:
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build OpenAI-compatible request body with stream disabled."""
+        body = super()._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        body["stream"] = False
+        return body
+
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse OpenAI-compatible response with text field fallback."""
+        from gac.errors import AIError
+
+        choices = response.get("choices")
+        if not choices or not isinstance(choices, list):
+            raise AIError.model_error("Invalid response: missing choices")
+
+        # First try message.content (standard OpenAI format)
+        choice = choices[0]
+        content = choice.get("message", {}).get("content")
+        if content is not None:
+            if content == "":
+                raise AIError.model_error("Invalid response: empty content")
             return content
 
-        # Some OpenAI-compatible servers return text field directly
-        content = choices[0].get("text")
-        if content:
+        # Fallback to text field (some OpenAI-compatible servers use this)
+        content = choice.get("text")
+        if content is not None:
+            if content == "":
+                raise AIError.model_error("Invalid response: empty 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
+        raise AIError.model_error("Invalid response: missing content")

gac/providers/minimax.py

@@ -1,38 +1,15 @@
 """MiniMax API provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class MinimaxProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="MiniMax",
+        api_key_env="MINIMAX_API_KEY",
+        base_url="https://api.minimaxi.com/v1",
+    )
 
-
-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
+    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,38 +1,15 @@
 """Mistral API provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class MistralProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Mistral",
+        api_key_env="MISTRAL_API_KEY",
+        base_url="https://api.mistral.ai/v1",
+    )
 
-
-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
+    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,38 +1,15 @@
 """Moonshot AI provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class MoonshotProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Moonshot",
+        api_key_env="MOONSHOT_API_KEY",
+        base_url="https://api.moonshot.cn/v1",
+    )
 
-
-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
+    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"