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

gac/providers/error_handler.py

@@ -0,0 +1,139 @@
+"""Centralized error handling decorator for AI providers.
+
+This module provides the single authoritative location for converting exceptions
+to AIError types. All provider API functions should be decorated with
+@handle_provider_errors to ensure consistent error handling.
+
+Error Classification:
+    - httpx.ConnectError -> AIError.connection_error
+    - httpx.TimeoutException -> AIError.timeout_error
+    - httpx.HTTPStatusError:
+        - 401 -> AIError.authentication_error
+        - 429 -> AIError.rate_limit_error
+        - 404 -> AIError.model_error
+        - 5xx -> AIError.connection_error (server issues)
+        - other -> AIError.model_error
+    - Other exceptions: String-based classification as fallback
+"""
+
+import re
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+
+MAX_ERROR_RESPONSE_LENGTH = 200
+
+SENSITIVE_PATTERNS = [
+    re.compile(r"sk-[A-Za-z0-9_-]{20,}"),  # OpenAI keys
+    re.compile(r"sk-ant-[A-Za-z0-9_-]{20,}"),  # Anthropic keys
+    re.compile(r"(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}"),  # GitHub tokens
+    re.compile(r"AIza[0-9A-Za-z_-]{20,}"),  # Google API keys
+    re.compile(r"(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{20,}"),  # Stripe keys
+    re.compile(r"xox[baprs]-[A-Za-z0-9-]{20,}"),  # Slack tokens
+    re.compile(r"eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"),  # JWT tokens
+    re.compile(r"Bearer\s+[A-Za-z0-9_-]{20,}"),  # Bearer tokens
+    re.compile(r"[A-Za-z0-9]{32,}"),  # Generic long alphanumeric tokens
+]
+
+
+def sanitize_error_response(text: str) -> str:
+    """Sanitize API error response text for safe logging/display.
+
+    This function:
+    1. Redacts potential API keys and tokens
+    2. Truncates to MAX_ERROR_RESPONSE_LENGTH characters
+
+    Args:
+        text: Raw error response text from an API
+
+    Returns:
+        Sanitized text safe for logging/display
+    """
+    if not text:
+        return ""
+
+    sanitized = text
+    for pattern in SENSITIVE_PATTERNS:
+        sanitized = pattern.sub("[REDACTED]", sanitized)
+
+    if len(sanitized) > MAX_ERROR_RESPONSE_LENGTH:
+        sanitized = sanitized[:MAX_ERROR_RESPONSE_LENGTH] + "..."
+
+    return sanitized
+
+
+def handle_provider_errors(provider_name: str) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to standardize error handling across all AI providers.
+
+    This is the single authoritative location for error handling. Provider
+    implementations should not catch httpx exceptions - they will be caught
+    and converted to appropriate AIError types by this decorator.
+
+    Args:
+        provider_name: Name of the AI provider for error messages
+
+    Returns:
+        Decorator function that wraps provider functions with standardized error handling
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except AIError:
+                # Re-raise AIError exceptions as-is without wrapping
+                raise
+            except httpx.ConnectError as e:
+                raise AIError.connection_error(f"{provider_name}: {e}") from e
+            except httpx.TimeoutException as e:
+                raise AIError.timeout_error(f"{provider_name}: {e}") from e
+            except httpx.HTTPStatusError as e:
+                sanitized_response = sanitize_error_response(e.response.text)
+                if e.response.status_code == 401:
+                    raise AIError.authentication_error(
+                        f"{provider_name}: Invalid API key or authentication failed"
+                    ) from e
+                elif e.response.status_code == 429:
+                    raise AIError.rate_limit_error(
+                        f"{provider_name}: Rate limit exceeded. Please try again later."
+                    ) from e
+                elif e.response.status_code == 404:
+                    raise AIError.model_error(f"{provider_name}: Model not found or endpoint not available") from e
+                elif e.response.status_code >= 500:
+                    raise AIError.connection_error(
+                        f"{provider_name}: Server error (HTTP {e.response.status_code})"
+                    ) from e
+                else:
+                    raise AIError.model_error(
+                        f"{provider_name}: HTTP {e.response.status_code}: {sanitized_response}"
+                    ) from e
+            except Exception as e:
+                # Handle any other unexpected exceptions with string-based classification
+                error_str = str(e).lower()
+                if "authentication" in error_str or "unauthorized" in error_str:
+                    raise AIError.authentication_error(f"Error calling {provider_name} API: {e}") from e
+                elif "rate limit" in error_str or "quota" in error_str:
+                    raise AIError.rate_limit_error(f"Error calling {provider_name} API: {e}") from e
+                elif "timeout" in error_str:
+                    raise AIError.timeout_error(f"Error calling {provider_name} API: {e}") from e
+                elif "connection" in error_str:
+                    raise AIError.connection_error(f"Error calling {provider_name} API: {e}") from e
+                else:
+                    raise AIError.model_error(f"Error calling {provider_name} API: {e}") from e
+
+        return wrapper
+
+    return decorator
+
+
+__all__ = [
+    "MAX_ERROR_RESPONSE_LENGTH",
+    "SENSITIVE_PATTERNS",
+    "handle_provider_errors",
+    "sanitize_error_response",
+]

gac/providers/fireworks.py

@@ -1,48 +1,15 @@
 """Fireworks AI API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+class FireworksProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Fireworks",
+        api_key_env="FIREWORKS_API_KEY",
+        base_url="https://api.fireworks.ai/inference/v1",
+    )
 
-logger = logging.getLogger(__name__)
-
-
-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}
-
-    logger.debug(f"Calling Fireworks 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("Fireworks AI API returned null content")
-        if content == "":
-            raise AIError.model_error("Fireworks AI API returned empty content")
-        logger.debug("Fireworks AI API response received successfully")
-        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,70 +1,74 @@
 """Gemini 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_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"}
-
-    logger.debug(f"Calling Gemini API with model={model}")
-
-    try:
-        response = httpx.post(
-            url, headers=headers, json=payload, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        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")
 
@@ -83,15 +87,4 @@ def call_gemini_api(model: str, messages: list[dict[str, Any]], temperature: flo
         if content_text is None:
             raise AIError.model_error("Gemini API response missing text content")
 
-        logger.debug("Gemini API response received successfully")
         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,67 +1,15 @@
 """Groq API provider for gac."""
 
-import logging
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
+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=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
-        )
-        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,67 +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.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
 
-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=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
+    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,70 +1,80 @@
-"""LM Studio AI provider implementation."""
+"""LM Studio API provider for gac."""
 
-import logging
 import os
 from typing import Any
 
-import httpx
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-from gac.constants import ProviderDefaults
-from gac.errors import AIError
-from gac.utils import get_ssl_verify
 
-logger = logging.getLogger(__name__)
+class LMStudioProvider(OpenAICompatibleProvider):
+    """LM Studio provider for local OpenAI-compatible models."""
 
+    config = ProviderConfig(
+        name="LM Studio",
+        api_key_env="LMSTUDIO_API_KEY",
+        base_url="http://localhost:1234/v1",
+    )
 
-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("/")
+    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"
 
-    url = f"{api_url}/v1/chat/completions"
+    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
 
-    headers = {"Content-Type": "application/json"}
-    api_key = os.getenv("LMSTUDIO_API_KEY")
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
+    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
 
-    payload: dict[str, Any] = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "stream": False,
-    }
+    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"
 
-    logger.debug(f"Calling LM Studio API with model={model}")
+    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
 
-    try:
-        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 []
-        if not choices:
-            raise AIError.model_error("LM Studio API response missing choices")
+    def _parse_response(self, response: dict[str, Any]) -> str:
+        """Parse OpenAI-compatible response with text field fallback."""
+        from gac.errors import AIError
 
-        message = choices[0].get("message") or {}
-        content = message.get("content")
-        if content:
-            logger.debug("LM Studio API response received successfully")
+        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:
-            logger.debug("LM Studio API response received successfully")
+        # 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")