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

gac/providers/kimi_coding.py

@@ -0,0 +1,67 @@
+"""Kimi Coding AI provider implementation."""
+
+import json
+import logging
+import os
+
+import httpx
+
+from gac.constants import ProviderDefaults
+from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
+
+
+def call_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=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
+        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

@@ -1,11 +1,16 @@
 """LM Studio AI provider implementation."""
 
+import logging
 import os
 from typing import Any
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_lmstudio_api(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
@@ -28,8 +33,12 @@ def call_lmstudio_api(model: str, messages: list[dict[str, Any]], temperature: f
         "stream": False,
     }
 
+    logger.debug(f"Calling LM Studio API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=payload, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=payload, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         choices = response_data.get("choices") or []
@@ -39,11 +48,13 @@ def call_lmstudio_api(model: str, messages: list[dict[str, Any]], temperature: f
         message = choices[0].get("message") or {}
         content = message.get("content")
         if content:
+            logger.debug("LM Studio API response received successfully")
             return content
 
         # Some OpenAI-compatible servers return text field directly
         content = choices[0].get("text")
         if content:
+            logger.debug("LM Studio API response received successfully")
             return content
 
         raise AIError.model_error("LM Studio API response missing content")

gac/providers/minimax.py

@@ -1,10 +1,15 @@
 """MiniMax API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_minimax_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -18,8 +23,12 @@ def call_minimax_api(model: str, messages: list[dict], temperature: float, max_t
 
     data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
 
+    logger.debug(f"Calling MiniMax API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         content = response_data["choices"][0]["message"]["content"]
@@ -27,6 +36,7 @@ def call_minimax_api(model: str, messages: list[dict], temperature: float, max_t
             raise AIError.model_error("MiniMax API returned null content")
         if content == "":
             raise AIError.model_error("MiniMax API returned empty content")
+        logger.debug("MiniMax API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 429:

gac/providers/mistral.py

@@ -0,0 +1,48 @@
+"""Mistral API provider for gac."""
+
+import logging
+import os
+
+import httpx
+
+from gac.constants import ProviderDefaults
+from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
+
+
+def call_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}
+
+    logger.debug(f"Calling Mistral API with model={model}")
+
+    try:
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        content = response_data["choices"][0]["message"]["content"]
+        if content is None:
+            raise AIError.model_error("Mistral API returned null content")
+        if content == "":
+            raise AIError.model_error("Mistral API returned empty content")
+        logger.debug("Mistral API response received successfully")
+        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,48 @@
+"""Moonshot AI provider for gac."""
+
+import logging
+import os
+
+import httpx
+
+from gac.constants import ProviderDefaults
+from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
+
+
+def call_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}
+
+    logger.debug(f"Calling Moonshot AI API with model={model}")
+
+    try:
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
+        response.raise_for_status()
+        response_data = response.json()
+        content = response_data["choices"][0]["message"]["content"]
+        if content is None:
+            raise AIError.model_error("Moonshot AI API returned null content")
+        if content == "":
+            raise AIError.model_error("Moonshot AI API returned empty content")
+        logger.debug("Moonshot AI API response received successfully")
+        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

@@ -1,10 +1,15 @@
 """Ollama AI provider implementation."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_ollama_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -18,8 +23,12 @@ def call_ollama_api(model: str, messages: list[dict], temperature: float, max_to
     if api_key:
         headers["Authorization"] = f"Bearer {api_key}"
 
+    logger.debug(f"Calling Ollama API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
 
@@ -37,6 +46,7 @@ def call_ollama_api(model: str, messages: list[dict], temperature: float, max_to
             raise AIError.model_error("Ollama API returned null content")
         if content == "":
             raise AIError.model_error("Ollama API returned empty content")
+        logger.debug("Ollama API response received successfully")
         return content
     except httpx.ConnectError as e:
         raise AIError.connection_error(f"Ollama connection failed. Make sure Ollama is running: {str(e)}") from e

gac/providers/openai.py

@@ -1,10 +1,15 @@
 """OpenAI API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -18,8 +23,12 @@ def call_openai_api(model: str, messages: list[dict], temperature: float, max_to
 
     data = {"model": model, "messages": messages, "temperature": temperature, "max_completion_tokens": max_tokens}
 
+    logger.debug(f"Calling OpenAI API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         content = response_data["choices"][0]["message"]["content"]
@@ -27,6 +36,7 @@ def call_openai_api(model: str, messages: list[dict], temperature: float, max_to
             raise AIError.model_error("OpenAI API returned null content")
         if content == "":
             raise AIError.model_error("OpenAI API returned empty content")
+        logger.debug("OpenAI API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 429:

gac/providers/openrouter.py

@@ -1,10 +1,15 @@
 """OpenRouter API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_openrouter_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -26,8 +31,12 @@ def call_openrouter_api(model: str, messages: list[dict], temperature: float, ma
         "max_tokens": max_tokens,
     }
 
+    logger.debug(f"Calling OpenRouter API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         content = response_data["choices"][0]["message"]["content"]
@@ -35,6 +44,7 @@ def call_openrouter_api(model: str, messages: list[dict], temperature: float, ma
             raise AIError.model_error("OpenRouter API returned null content")
         if content == "":
             raise AIError.model_error("OpenRouter API returned empty content")
+        logger.debug("OpenRouter API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         # Handle specific HTTP status codes

gac/providers/qwen.py

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

gac/providers/replicate.py

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

gac/providers/streamlake.py

@@ -1,10 +1,15 @@
 """StreamLake (Vanchin) API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_streamlake_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -25,8 +30,12 @@ def call_streamlake_api(model: str, messages: list[dict], temperature: float, ma
         "max_tokens": max_tokens,
     }
 
+    logger.debug(f"Calling StreamLake API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         choices = response_data.get("choices")
@@ -40,6 +49,7 @@ def call_streamlake_api(model: str, messages: list[dict], temperature: float, ma
         if content == "":
             raise AIError.model_error("StreamLake API returned empty content")
 
+        logger.debug("StreamLake API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 429:

gac/providers/synthetic.py

@@ -1,10 +1,15 @@
 """Synthetic.new API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_synthetic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -22,8 +27,12 @@ def call_synthetic_api(model: str, messages: list[dict], temperature: float, max
 
     data = {"model": model, "messages": messages, "temperature": temperature, "max_completion_tokens": max_tokens}
 
+    logger.debug(f"Calling Synthetic.new API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         content = response_data["choices"][0]["message"]["content"]
@@ -31,6 +40,7 @@ def call_synthetic_api(model: str, messages: list[dict], temperature: float, max
             raise AIError.model_error("Synthetic.new API returned null content")
         if content == "":
             raise AIError.model_error("Synthetic.new API returned empty content")
+        logger.debug("Synthetic.new API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 429:

gac/providers/together.py

@@ -1,10 +1,15 @@
 """Together AI API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def call_together_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
@@ -18,8 +23,12 @@ def call_together_api(model: str, messages: list[dict], temperature: float, max_
 
     data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
 
+    logger.debug(f"Calling Together AI API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
         content = response_data["choices"][0]["message"]["content"]
@@ -27,6 +36,7 @@ def call_together_api(model: str, messages: list[dict], temperature: float, max_
             raise AIError.model_error("Together AI API returned null content")
         if content == "":
             raise AIError.model_error("Together AI API returned empty content")
+        logger.debug("Together AI API response received successfully")
         return content
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 429: