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

gac/providers/__init__.py

@@ -0,0 +1,88 @@
+"""AI provider implementations for commit message generation."""
+
+from .anthropic import call_anthropic_api
+from .azure_openai import call_azure_openai_api
+from .cerebras import call_cerebras_api
+from .chutes import call_chutes_api
+from .claude_code import call_claude_code_api
+from .custom_anthropic import call_custom_anthropic_api
+from .custom_openai import call_custom_openai_api
+from .deepseek import call_deepseek_api
+from .fireworks import call_fireworks_api
+from .gemini import call_gemini_api
+from .groq import call_groq_api
+from .kimi_coding import call_kimi_coding_api
+from .lmstudio import call_lmstudio_api
+from .minimax import call_minimax_api
+from .mistral import call_mistral_api
+from .moonshot import call_moonshot_api
+from .ollama import call_ollama_api
+from .openai import call_openai_api
+from .openrouter import call_openrouter_api
+from .replicate import call_replicate_api
+from .streamlake import call_streamlake_api
+from .synthetic import call_synthetic_api
+from .together import call_together_api
+from .zai import call_zai_api, call_zai_coding_api
+
+# Provider registry - single source of truth for all providers
+PROVIDER_REGISTRY = {
+    "anthropic": call_anthropic_api,
+    "azure-openai": call_azure_openai_api,
+    "cerebras": call_cerebras_api,
+    "claude-code": call_claude_code_api,
+    "chutes": call_chutes_api,
+    "custom-anthropic": call_custom_anthropic_api,
+    "custom-openai": call_custom_openai_api,
+    "deepseek": call_deepseek_api,
+    "fireworks": call_fireworks_api,
+    "gemini": call_gemini_api,
+    "groq": call_groq_api,
+    "kimi-coding": call_kimi_coding_api,
+    "lm-studio": call_lmstudio_api,
+    "minimax": call_minimax_api,
+    "mistral": call_mistral_api,
+    "moonshot": call_moonshot_api,
+    "ollama": call_ollama_api,
+    "openai": call_openai_api,
+    "openrouter": call_openrouter_api,
+    "replicate": call_replicate_api,
+    "streamlake": call_streamlake_api,
+    "synthetic": call_synthetic_api,
+    "together": call_together_api,
+    "zai": call_zai_api,
+    "zai-coding": call_zai_coding_api,
+}
+
+# List of supported provider names - derived from registry keys
+SUPPORTED_PROVIDERS = sorted(PROVIDER_REGISTRY.keys())
+
+__all__ = [
+    "call_anthropic_api",
+    "call_azure_openai_api",
+    "call_cerebras_api",
+    "call_chutes_api",
+    "call_claude_code_api",
+    "call_custom_anthropic_api",
+    "call_custom_openai_api",
+    "call_deepseek_api",
+    "call_fireworks_api",
+    "call_gemini_api",
+    "call_groq_api",
+    "call_kimi_coding_api",
+    "call_lmstudio_api",
+    "call_minimax_api",
+    "call_mistral_api",
+    "call_moonshot_api",
+    "call_ollama_api",
+    "call_openai_api",
+    "call_openrouter_api",
+    "call_replicate_api",
+    "call_streamlake_api",
+    "call_synthetic_api",
+    "call_together_api",
+    "call_zai_api",
+    "call_zai_coding_api",
+    "PROVIDER_REGISTRY",
+    "SUPPORTED_PROVIDERS",
+]

gac/providers/anthropic.py

@@ -0,0 +1,51 @@
+"""Anthropic AI provider implementation."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_anthropic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Anthropic API directly."""
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("ANTHROPIC_API_KEY not found in environment variables")
+
+    url = "https://api.anthropic.com/v1/messages"
+    headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01", "content-type": "application/json"}
+
+    # Convert messages to Anthropic format
+    anthropic_messages = []
+    system_message = ""
+
+    for msg in messages:
+        if msg["role"] == "system":
+            system_message = msg["content"]
+        else:
+            anthropic_messages.append({"role": msg["role"], "content": msg["content"]})
+
+    data = {"model": model, "messages": anthropic_messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    if system_message:
+        data["system"] = system_message
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+        content = response_data["content"][0]["text"]
+        if content is None:
+            raise AIError.model_error("Anthropic API returned null content")
+        if content == "":
+            raise AIError.model_error("Anthropic API returned empty content")
+        return content
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"Anthropic API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"Anthropic API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Anthropic API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Anthropic API: {str(e)}") from e

gac/providers/azure_openai.py

@@ -0,0 +1,97 @@
+"""Azure OpenAI provider for gac.
+
+This provider provides native support for Azure OpenAI Service with proper
+endpoint construction and API version handling.
+"""
+
+import json
+import logging
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def call_azure_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Azure OpenAI Service API.
+
+    Environment variables:
+        AZURE_OPENAI_API_KEY: Azure OpenAI API key (required)
+        AZURE_OPENAI_ENDPOINT: Azure OpenAI endpoint URL (required)
+            Example: https://your-resource.openai.azure.com
+        AZURE_OPENAI_API_VERSION: Azure OpenAI API version (required)
+            Example: 2025-01-01-preview
+            Example: 2024-02-15-preview
+
+    Args:
+        model: The deployment name in Azure OpenAI (e.g., 'gpt-4o', 'gpt-35-turbo')
+        messages: List of message dictionaries with 'role' and 'content' keys
+        temperature: Controls randomness (0.0-1.0)
+        max_tokens: Maximum tokens in the response
+
+    Returns:
+        The generated commit message
+
+    Raises:
+        AIError: If authentication fails, API errors occur, or response is invalid
+    """
+    api_key = os.getenv("AZURE_OPENAI_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("AZURE_OPENAI_API_KEY environment variable not set")
+
+    endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+    if not endpoint:
+        raise AIError.model_error("AZURE_OPENAI_ENDPOINT environment variable not set")
+
+    api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+    if not api_version:
+        raise AIError.model_error("AZURE_OPENAI_API_VERSION environment variable not set")
+
+    # Build Azure OpenAI URL with proper structure
+    endpoint = endpoint.rstrip("/")
+    url = f"{endpoint}/openai/deployments/{model}/chat/completions?api-version={api_version}"
+
+    headers = {"api-key": api_key, "Content-Type": "application/json"}
+
+    data = {"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()
+
+        try:
+            content = response_data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError) as e:
+            logger.error(f"Unexpected response format from Azure OpenAI API. Response: {json.dumps(response_data)}")
+            raise AIError.model_error(
+                f"Azure OpenAI API returned unexpected format. Expected 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("Azure OpenAI API returned null content")
+        if content == "":
+            raise AIError.model_error("Azure OpenAI API returned empty content")
+        return content
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"Azure OpenAI 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"Azure OpenAI API authentication failed: {error_text}") from e
+        elif status_code == 429:
+            raise AIError.rate_limit_error(f"Azure OpenAI API rate limit exceeded: {error_text}") from e
+        else:
+            raise AIError.model_error(f"Azure OpenAI API error: {status_code} - {error_text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Azure OpenAI API request timed out: {str(e)}") from e
+    except AIError:
+        raise
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Azure OpenAI API: {str(e)}") from e

gac/providers/cerebras.py

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

gac/providers/chutes.py

@@ -0,0 +1,71 @@
+"""Chutes.ai API provider for gac."""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_chutes_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Chutes.ai API directly.
+
+    Chutes.ai provides an OpenAI-compatible API for serverless, decentralized AI compute.
+
+    Args:
+        model: The model to use (e.g., 'deepseek-ai/DeepSeek-V3-0324')
+        messages: List of message dictionaries with 'role' and 'content' keys
+        temperature: Controls randomness (0.0-1.0)
+        max_tokens: Maximum tokens in the response
+
+    Returns:
+        The generated commit message
+
+    Raises:
+        AIError: If authentication fails, API errors occur, or response is invalid
+    """
+    api_key = os.getenv("CHUTES_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("CHUTES_API_KEY environment variable not set")
+
+    base_url = os.getenv("CHUTES_BASE_URL", "https://llm.chutes.ai")
+    url = f"{base_url}/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("Chutes.ai API returned null content")
+        if content == "":
+            raise AIError.model_error("Chutes.ai API returned empty content")
+        return content
+    except httpx.HTTPStatusError as e:
+        status_code = e.response.status_code
+        error_text = e.response.text
+
+        if status_code == 429:
+            raise AIError.rate_limit_error(f"Chutes.ai API rate limit exceeded: {error_text}") from e
+        elif status_code in (502, 503):
+            raise AIError.connection_error(f"Chutes.ai API service unavailable: {status_code} - {error_text}") from e
+        else:
+            raise AIError.model_error(f"Chutes.ai API error: {status_code} - {error_text}") from e
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"Chutes.ai API connection error: {str(e)}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Chutes.ai API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Chutes.ai API: {str(e)}") from e

gac/providers/claude_code.py

@@ -0,0 +1,102 @@
+"""Claude Code provider implementation.
+
+This provider allows users with Claude Code subscriptions to use their OAuth tokens
+instead of paying for the expensive Anthropic API.
+"""
+
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_claude_code_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Claude Code API using OAuth token.
+
+    This provider uses the Claude Code subscription OAuth token instead of the Anthropic API key.
+    It authenticates using Bearer token authentication with the special anthropic-beta header.
+
+    Environment variables:
+        CLAUDE_CODE_ACCESS_TOKEN: OAuth access token from Claude Code authentication
+
+    Args:
+        model: Model name (e.g., 'claude-sonnet-4-5')
+        messages: List of message dictionaries with 'role' and 'content' keys
+        temperature: Sampling temperature (0.0-1.0)
+        max_tokens: Maximum tokens in response
+
+    Returns:
+        Generated text response
+
+    Raises:
+        AIError: If authentication fails or API call fails
+    """
+    access_token = os.getenv("CLAUDE_CODE_ACCESS_TOKEN")
+    if not access_token:
+        raise AIError.authentication_error(
+            "CLAUDE_CODE_ACCESS_TOKEN not found in environment variables. "
+            "Please authenticate with Claude Code and set this token."
+        )
+
+    url = "https://api.anthropic.com/v1/messages"
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "anthropic-version": "2023-06-01",
+        "anthropic-beta": "oauth-2025-04-20",
+        "content-type": "application/json",
+    }
+
+    # Convert messages to Anthropic format
+    # IMPORTANT: Claude Code OAuth tokens require the system message to be EXACTLY
+    # "You are Claude Code, Anthropic's official CLI for Claude." with NO additional content.
+    # Any other instructions must be moved to the user message.
+    anthropic_messages = []
+    system_instructions = ""
+
+    for msg in messages:
+        if msg["role"] == "system":
+            system_instructions = msg["content"]
+        else:
+            anthropic_messages.append({"role": msg["role"], "content": msg["content"]})
+
+    # Claude Code requires this exact system message, nothing more
+    system_message = "You are Claude Code, Anthropic's official CLI for Claude."
+
+    # Move any system instructions into the first user message
+    if system_instructions and anthropic_messages:
+        # Prepend system instructions to the first user message
+        first_user_msg = anthropic_messages[0]
+        first_user_msg["content"] = f"{system_instructions}\n\n{first_user_msg['content']}"
+
+    data = {
+        "model": model,
+        "messages": anthropic_messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "system": system_message,
+    }
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+        content = response_data["content"][0]["text"]
+        if content is None:
+            raise AIError.model_error("Claude Code API returned null content")
+        if content == "":
+            raise AIError.model_error("Claude Code API returned empty content")
+        return content
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 401:
+            raise AIError.authentication_error(
+                f"Claude Code authentication failed: {e.response.text}. "
+                "Your token may have expired. Please re-authenticate."
+            ) from e
+        if e.response.status_code == 429:
+            raise AIError.rate_limit_error(f"Claude Code API rate limit exceeded: {e.response.text}") from e
+        raise AIError.model_error(f"Claude Code API error: {e.response.status_code} - {e.response.text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Claude Code API request timed out: {str(e)}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Claude Code API: {str(e)}") from e

gac/providers/custom_anthropic.py

@@ -0,0 +1,133 @@
+"""Custom Anthropic-compatible API provider for gac.
+
+This provider allows users to specify a custom Anthropic-compatible endpoint
+while using the same model capabilities as the standard Anthropic provider.
+"""
+
+import json
+import logging
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def call_custom_anthropic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call a custom Anthropic-compatible API endpoint.
+
+    This provider is useful for:
+    - Anthropic-compatible proxies or gateways
+    - Self-hosted Anthropic-compatible services
+    - Other services implementing the Anthropic Messages API
+
+    Environment variables:
+        CUSTOM_ANTHROPIC_API_KEY: API key for authentication (required)
+        CUSTOM_ANTHROPIC_BASE_URL: Base URL for the API endpoint (required)
+            Example: https://your-proxy.example.com
+        CUSTOM_ANTHROPIC_VERSION: API version header (optional, defaults to '2023-06-01')
+
+    Args:
+        model: The model to use (e.g., 'claude-sonnet-4-5', 'claude-haiku-4-5')
+        messages: List of message dictionaries with 'role' and 'content' keys
+        temperature: Controls randomness (0.0-1.0)
+        max_tokens: Maximum tokens in the response
+
+    Returns:
+        The generated commit message
+
+    Raises:
+        AIError: If authentication fails, API errors occur, or response is invalid
+    """
+    api_key = os.getenv("CUSTOM_ANTHROPIC_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("CUSTOM_ANTHROPIC_API_KEY environment variable not set")
+
+    base_url = os.getenv("CUSTOM_ANTHROPIC_BASE_URL")
+    if not base_url:
+        raise AIError.model_error("CUSTOM_ANTHROPIC_BASE_URL environment variable not set")
+
+    api_version = os.getenv("CUSTOM_ANTHROPIC_VERSION", "2023-06-01")
+
+    if "/v1/messages" not in base_url:
+        base_url = base_url.rstrip("/")
+        url = f"{base_url}/v1/messages"
+    else:
+        url = base_url
+
+    headers = {"x-api-key": api_key, "anthropic-version": api_version, "content-type": "application/json"}
+
+    anthropic_messages = []
+    system_message = ""
+
+    for msg in messages:
+        if msg["role"] == "system":
+            system_message = msg["content"]
+        else:
+            anthropic_messages.append({"role": msg["role"], "content": msg["content"]})
+
+    data = {"model": model, "messages": anthropic_messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    if system_message:
+        data["system"] = system_message
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        try:
+            content_list = response_data.get("content", [])
+            if not content_list:
+                raise AIError.model_error("Custom Anthropic API returned empty content array")
+
+            # Try standard Anthropic format first: content[0].text
+            if "text" in content_list[0]:
+                content = content_list[0]["text"]
+            else:
+                # Extended format (e.g., MiniMax with thinking): find first item with type="text"
+                text_item = next((item for item in content_list if item.get("type") == "text"), None)
+                if text_item and "text" in text_item:
+                    content = text_item["text"]
+                else:
+                    logger.error(
+                        f"Unexpected response format from Custom Anthropic API. Response: {json.dumps(response_data)}"
+                    )
+                    raise AIError.model_error(
+                        "Custom Anthropic API returned unexpected format. Expected 'text' field in content array."
+                    )
+        except AIError:
+            raise
+        except (KeyError, IndexError, TypeError, StopIteration) as e:
+            logger.error(f"Unexpected response format from Custom Anthropic API. Response: {json.dumps(response_data)}")
+            raise AIError.model_error(
+                f"Custom Anthropic API returned unexpected format. Expected Anthropic-compatible response with "
+                f"'content[0].text' or items with type='text', but got: {type(e).__name__}. "
+                f"Check logs for full response structure."
+            ) from e
+
+        if content is None:
+            raise AIError.model_error("Custom Anthropic API returned null content")
+        if content == "":
+            raise AIError.model_error("Custom Anthropic API returned empty content")
+        return content
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"Custom Anthropic 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"Custom Anthropic API authentication failed: {error_text}") from e
+        elif status_code == 429:
+            raise AIError.rate_limit_error(f"Custom Anthropic API rate limit exceeded: {error_text}") from e
+        else:
+            raise AIError.model_error(f"Custom Anthropic API error: {status_code} - {error_text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Custom Anthropic API request timed out: {str(e)}") from e
+    except AIError:
+        raise
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Custom Anthropic API: {str(e)}") from e

gac/providers/custom_openai.py

@@ -0,0 +1,98 @@
+"""Custom OpenAI-compatible API provider for gac.
+
+This provider allows users to specify a custom OpenAI-compatible endpoint
+while using the same model capabilities as the standard OpenAI provider.
+"""
+
+import json
+import logging
+import os
+
+import httpx
+
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def call_custom_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call a custom OpenAI-compatible API endpoint.
+
+    This provider is useful for:
+    - OpenAI-compatible proxies or gateways
+    - Self-hosted OpenAI-compatible services
+    - Other services implementing the OpenAI Chat Completions API
+
+    Environment variables:
+        CUSTOM_OPENAI_API_KEY: API key for authentication (required)
+        CUSTOM_OPENAI_BASE_URL: Base URL for the API endpoint (required)
+            Example: https://your-proxy.example.com/v1
+            Example: https://your-custom-endpoint.com
+
+    Args:
+        model: The model to use (e.g., 'gpt-4', 'gpt-3.5-turbo')
+        messages: List of message dictionaries with 'role' and 'content' keys
+        temperature: Controls randomness (0.0-1.0)
+        max_tokens: Maximum tokens in the response
+
+    Returns:
+        The generated commit message
+
+    Raises:
+        AIError: If authentication fails, API errors occur, or response is invalid
+    """
+    api_key = os.getenv("CUSTOM_OPENAI_API_KEY")
+    if not api_key:
+        raise AIError.authentication_error("CUSTOM_OPENAI_API_KEY environment variable not set")
+
+    base_url = os.getenv("CUSTOM_OPENAI_BASE_URL")
+    if not base_url:
+        raise AIError.model_error("CUSTOM_OPENAI_BASE_URL environment variable not set")
+
+    if "/chat/completions" not in base_url:
+        base_url = base_url.rstrip("/")
+        url = f"{base_url}/chat/completions"
+    else:
+        url = base_url
+
+    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()
+
+        try:
+            content = response_data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError) as e:
+            logger.error(f"Unexpected response format from Custom OpenAI API. Response: {json.dumps(response_data)}")
+            raise AIError.model_error(
+                f"Custom OpenAI 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("Custom OpenAI API returned null content")
+        if content == "":
+            raise AIError.model_error("Custom OpenAI API returned empty content")
+        return content
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"Custom OpenAI 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"Custom OpenAI API authentication failed: {error_text}") from e
+        elif status_code == 429:
+            raise AIError.rate_limit_error(f"Custom OpenAI API rate limit exceeded: {error_text}") from e
+        else:
+            raise AIError.model_error(f"Custom OpenAI API error: {status_code} - {error_text}") from e
+    except httpx.TimeoutException as e:
+        raise AIError.timeout_error(f"Custom OpenAI API request timed out: {str(e)}") from e
+    except AIError:
+        raise
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Custom OpenAI API: {str(e)}") from e