kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/llm/test_dashscope_mapping.py

@@ -0,0 +1,32 @@
+from kolega_code.llm.client import LLMClient
+from kolega_code.llm.providers.anthropic import AnthropicProvider
+from kolega_code.llm.providers.openai import OpenAIProvider
+
+
+# TODO: Fix after qwen-3-coder-plus PR is merged - needs dashscope provider mapping
+def test_llm_client_maps_dashscope_to_openai_provider():
+    client = LLMClient(provider='dashscope', api_key='sk-test')
+    assert isinstance(client.provider, OpenAIProvider)
+    assert client.provider.base_url == 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1'
+
+
+def test_llm_client_maps_moonshot_to_anthropic_provider():
+    client = LLMClient(provider='moonshot', api_key='sk-test')
+    assert isinstance(client.provider, AnthropicProvider)
+    assert client.provider.base_url == 'https://api.moonshot.ai/anthropic'
+    assert client.provider.provider_name == 'moonshot'
+    assert client.provider.use_local_token_counting is True
+
+    thinking = client._prepare_thinking_param(8192)
+    assert thinking.budget_tokens == 8192
+
+
+def test_llm_client_maps_deepseek_to_anthropic_provider():
+    client = LLMClient(provider='deepseek', api_key='sk-test')
+    assert isinstance(client.provider, AnthropicProvider)
+    assert client.provider.base_url == 'https://api.deepseek.com/anthropic'
+    assert client.provider.provider_name == 'deepseek'
+    assert client.provider.use_local_token_counting is True
+
+    thinking = client._prepare_thinking_param(8192)
+    assert thinking.budget_tokens == 8192

kolega_code/agent/tests/llm/test_error_boundary.py

@@ -0,0 +1,322 @@
+"""Test suite for LLM client error boundary functionality.
+
+This module tests that the LLM client correctly maps all exceptions to LLMError
+subclasses, ensuring no raw exceptions escape from the client layer.
+"""
+
+import os
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from anthropic import AnthropicError
+from google.genai.errors import APIError as GoogleAPIError
+from openai import OpenAIError
+
+from kolega_code.llm.client import LLMClient
+from kolega_code.llm.exceptions import (
+    LLMAuthenticationError,
+    LLMContextWindowExceededError,
+    LLMError,
+    LLMInternalServerError,
+    LLMInvalidRequestError,
+    LLMRateLimitError,
+    LLMTimeout,
+    map_to_llm_error,
+)
+from kolega_code.llm.models import Message, MessageHistory
+
+# Check if running in CI environment
+SKIP_IN_CI = bool(os.getenv("CI")) or bool(os.getenv("GITLAB_CI"))
+
+
+class TestErrorMapping:
+    """Test the comprehensive error mapping function."""
+
+    def test_llm_error_passes_through(self):
+        """Test that LLMError instances pass through unchanged."""
+        original_error = LLMInvalidRequestError("test error", provider="test")
+        mapped_error = map_to_llm_error(original_error)
+        assert mapped_error is original_error
+
+    def test_value_error_mapping(self):
+        """Test that ValueError maps to LLMInvalidRequestError."""
+        error = ValueError("Invalid value")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMInvalidRequestError)
+        assert "Invalid parameter" in str(mapped)
+        assert mapped.provider == "test_provider"
+
+    def test_timeout_error_mapping(self):
+        """Test that timeout errors map to LLMTimeout."""
+        # Test standard TimeoutError
+        error = TimeoutError("Request timed out")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMTimeout)
+        assert "Request timeout" in str(mapped)
+
+        # Test asyncio.TimeoutError
+        error = asyncio.TimeoutError("Async timeout")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMTimeout)
+
+    def test_connection_error_mapping(self):
+        """Test that ConnectionError maps to LLMInternalServerError."""
+        error = ConnectionError("Connection failed")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMInternalServerError)
+        assert "Connection error" in str(mapped)
+
+    def test_key_error_mapping(self):
+        """Test that KeyError maps to LLMInvalidRequestError."""
+        error = KeyError("missing_param")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMInvalidRequestError)
+        assert "Missing required parameter" in str(mapped)
+
+    def test_type_error_mapping(self):
+        """Test that TypeError maps to LLMInvalidRequestError."""
+        error = TypeError("Wrong type")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMInvalidRequestError)
+        assert "Invalid parameter type" in str(mapped)
+
+    def test_runtime_error_mapping(self):
+        """Test that RuntimeError maps to LLMInternalServerError."""
+        error = RuntimeError("Runtime issue")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMInternalServerError)
+        assert "Runtime error" in str(mapped)
+
+    def test_generic_exception_mapping(self):
+        """Test that generic exceptions map to base LLMError."""
+
+        class CustomException(Exception):
+            pass
+
+        error = CustomException("Custom error")
+        mapped = map_to_llm_error(error, "test_provider")
+        assert isinstance(mapped, LLMError)
+        assert not isinstance(mapped, (LLMInvalidRequestError, LLMInternalServerError, LLMTimeout))
+        assert "Unexpected error (CustomException)" in str(mapped)
+        assert mapped.provider == "test_provider"
+
+    def test_httpx_remote_protocol_error_mapping(self):
+        """Test that httpx.RemoteProtocolError maps to LLMInternalServerError."""
+        try:
+            import httpx  # type: ignore
+        except Exception:
+            pytest.skip("httpx not installed in test environment")
+
+        error = httpx.RemoteProtocolError(
+            "peer closed connection without sending complete message body (incomplete chunked read)"
+        )
+        mapped = map_to_llm_error(error, "anthropic")
+        assert isinstance(mapped, LLMInternalServerError)
+        assert "HTTPX protocol error" in str(mapped)
+
+    def test_provider_error_mapping(self):
+        """Test that provider-specific errors are mapped correctly."""
+
+        # Create proper mock OpenAI error that inherits from OpenAIError
+        class MockOpenAIError(OpenAIError):
+            def __init__(self, status_code):
+                self.status_code = status_code
+                super().__init__("Rate limit exceeded")
+
+        openai_error = MockOpenAIError(429)
+        mapped = map_to_llm_error(openai_error)
+        assert isinstance(mapped, LLMRateLimitError)
+
+        # Create proper mock Anthropic error
+        class MockAnthropicError(AnthropicError):
+            def __init__(self, status_code):
+                self.status_code = status_code
+                super().__init__("Invalid API key")
+
+        anthropic_error = MockAnthropicError(401)
+        mapped = map_to_llm_error(anthropic_error)
+        assert isinstance(mapped, LLMAuthenticationError)
+
+
+class TestLLMClientErrorBoundary:
+    """Test that the LLM client correctly implements the error boundary."""
+
+    def test_initialization_error_handling(self):
+        """Test that initialization errors are properly mapped."""
+        # Test unsupported provider
+        with pytest.raises(LLMInvalidRequestError) as exc_info:
+            LLMClient(provider="unsupported_provider", api_key="test_key")
+        assert "Invalid parameter: Unsupported provider" in str(exc_info.value)
+        assert exc_info.value.provider == "unsupported_provider"
+
+    @pytest.mark.asyncio
+    async def test_generate_error_handling(self):
+        """Test that generate method errors are properly mapped."""
+        client = LLMClient(provider="openai", api_key="test_key")
+
+        # Mock the provider to raise various exceptions
+        messages = MessageHistory([Message(role="user", content="Test")])
+
+        # Test ValueError
+        client.provider.generate = AsyncMock(side_effect=ValueError("Invalid parameter"))
+        with pytest.raises(LLMInvalidRequestError) as exc_info:
+            await client.generate(messages)
+        assert "Invalid parameter" in str(exc_info.value)
+        assert exc_info.value.provider == "openai"
+
+        # Test ConnectionError
+        client.provider.generate = AsyncMock(side_effect=ConnectionError("Connection lost"))
+        with pytest.raises(LLMInternalServerError) as exc_info:
+            await client.generate(messages)
+        assert "Connection error" in str(exc_info.value)
+
+        # Test that LLMError passes through
+        original_error = LLMRateLimitError("Rate limit hit", provider="openai")
+        client.provider.generate = AsyncMock(side_effect=original_error)
+        with pytest.raises(LLMRateLimitError) as exc_info:
+            await client.generate(messages)
+        assert exc_info.value is original_error
+
+    @pytest.mark.asyncio
+    async def test_count_tokens_error_handling(self):
+        """Test that count_tokens method errors are properly mapped."""
+        client = LLMClient(provider="anthropic", api_key="test_key")
+        messages = MessageHistory([Message(role="user", content="Test")])
+
+        # Test KeyError
+        client.provider.count_tokens = AsyncMock(side_effect=KeyError("model"))
+        with pytest.raises(LLMInvalidRequestError) as exc_info:
+            await client.count_tokens(messages)
+        assert "Missing required parameter" in str(exc_info.value)
+        assert exc_info.value.provider == "anthropic"
+
+        # Test TimeoutError
+        client.provider.count_tokens = AsyncMock(side_effect=asyncio.TimeoutError())
+        with pytest.raises(LLMTimeout) as exc_info:
+            await client.count_tokens(messages)
+        assert "Request timeout" in str(exc_info.value)
+
+    def test_stream_error_handling(self):
+        """Test that stream method errors are properly mapped."""
+        client = LLMClient(provider="google", api_key="test_key")
+        messages = MessageHistory([Message(role="user", content="Test")])
+
+        # Test RuntimeError
+        client.provider.stream = MagicMock(side_effect=RuntimeError("Stream failed"))
+        with pytest.raises(LLMInternalServerError) as exc_info:
+            client.stream(messages)
+        assert "Runtime error" in str(exc_info.value)
+        assert exc_info.value.provider == "google"
+
+        # Test TypeError
+        client.provider.stream = MagicMock(side_effect=TypeError("Invalid type"))
+        with pytest.raises(LLMInvalidRequestError) as exc_info:
+            client.stream(messages)
+        assert "Invalid parameter type" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_provider_specific_error_mapping(self):
+        """Test that provider-specific errors are correctly mapped through the client."""
+        # Test OpenAI error mapping
+        client = LLMClient(provider="openai", api_key="test_key")
+        messages = MessageHistory([Message(role="user", content="Test")])
+
+        # Create proper mock OpenAI error
+        class MockOpenAIError(OpenAIError):
+            def __init__(self, status_code, message="Invalid API key"):
+                self.status_code = status_code
+                super().__init__(message)
+
+        openai_error = MockOpenAIError(401)
+
+        client.provider.generate = AsyncMock(side_effect=openai_error)
+        with pytest.raises(LLMAuthenticationError) as exc_info:
+            await client.generate(messages)
+        assert "OpenAI APIError" in str(exc_info.value)
+
+        # Test Anthropic error mapping
+        client = LLMClient(provider="anthropic", api_key="test_key")
+
+        # Create proper mock Anthropic error
+        class MockAnthropicError(AnthropicError):
+            def __init__(self, status_code, message="Message too long"):
+                self.status_code = status_code
+                super().__init__(message)
+
+        anthropic_error = MockAnthropicError(413)
+
+        client.provider.generate = AsyncMock(side_effect=anthropic_error)
+        with pytest.raises(LLMContextWindowExceededError) as exc_info:  # Should be mapped to context window error
+            await client.generate(messages)
+        assert "AnthropicError" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_no_raw_exceptions_escape(self):
+        """Comprehensive test ensuring no raw exceptions escape the client."""
+        client = LLMClient(provider="openai", api_key="test_key")
+        messages = MessageHistory([Message(role="user", content="Test")])
+
+        # List of various exception types to test
+        test_exceptions = [
+            ValueError("test"),
+            KeyError("test"),
+            TypeError("test"),
+            RuntimeError("test"),
+            ConnectionError("test"),
+            TimeoutError("test"),
+            asyncio.TimeoutError("test"),
+            AttributeError("test"),
+            IndexError("test"),
+            ZeroDivisionError("test"),
+            Exception("generic exception"),
+        ]
+
+        for original_exception in test_exceptions:
+            # Test generate method
+            client.provider.generate = AsyncMock(side_effect=original_exception)
+            with pytest.raises(LLMError) as exc_info:
+                await client.generate(messages)
+            # Verify it's an LLMError subclass, not the original exception
+            assert isinstance(exc_info.value, LLMError)
+            assert type(exc_info.value) != type(original_exception)
+
+            # Test count_tokens method
+            client.provider.count_tokens = AsyncMock(side_effect=original_exception)
+            with pytest.raises(LLMError) as exc_info:
+                await client.count_tokens(messages)
+            assert isinstance(exc_info.value, LLMError)
+
+            # Test stream method
+            client.provider.stream = MagicMock(side_effect=original_exception)
+            with pytest.raises(LLMError) as exc_info:
+                client.stream(messages)
+            assert isinstance(exc_info.value, LLMError)
+
+
+class TestProviderInitialization:
+    """Test error handling during provider initialization."""
+
+    @pytest.mark.skipif(SKIP_IN_CI, reason="Skipping slow test in CI environment")
+    def test_all_supported_providers_initialize(self):
+        """Test that all supported providers can be initialized without error."""
+        supported_providers = ["anthropic", "openai", "google", "together", "groq", "fireworks", "llama", "xai"]
+
+        for provider in supported_providers:
+            try:
+                client = LLMClient(provider=provider, api_key="test_key")
+                assert client.provider_name == provider
+                assert client.provider is not None
+            except Exception as e:
+                # If any exception occurs, it should be an LLMError
+                assert isinstance(e, LLMError), f"Provider {provider} raised non-LLMError: {type(e)}"
+
+    def test_provider_initialization_with_error(self):
+        """Test that provider initialization errors are properly wrapped."""
+        # Mock the provider class to raise an error during initialization
+        with patch("kolega_code.llm.client.OpenAIProvider") as MockProvider:
+            MockProvider.side_effect = RuntimeError("Provider init failed")
+
+            with pytest.raises(LLMInternalServerError) as exc_info:
+                LLMClient(provider="openai", api_key="test_key")
+            assert "Runtime error: Provider init failed" in str(exc_info.value)

kolega_code/agent/tests/llm/test_exceptions.py

@@ -0,0 +1,249 @@
+"""
+Tests for the LLM exception classes and mapping functions.
+"""
+
+import pytest
+
+
+# Assuming OpenAIError, GoogleAPIError, AnthropicError can be imported or mocked
+# For simplicity, we'll mock them here.
+class MockOpenAIError(Exception):
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class MockGoogleAPIError(Exception):
+    def __init__(self, message: str, status: int):
+        super().__init__(message)
+        self.status = status
+
+
+class MockAnthropicError(Exception):
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+from kolega_code.config import ModelProvider
+from kolega_code.llm.exceptions import (
+    LLMAuthenticationError,
+    LLMBadRequestError,
+    LLMContentPolicyViolationError,
+    LLMContextWindowExceededError,
+    LLMError,
+    LLMInternalServerError,
+    LLMInvalidRequestError,
+    LLMNotFoundError,
+    LLMPermissionDeniedError,
+    LLMRateLimitError,
+    LLMTimeout,
+    LLMUnprocessableEntityError,
+    LLMUnsupportedParamsError,
+    map_anthropic_errors,
+    map_google_errors,
+    map_openai_errors,
+)
+
+
+# Test basic exception instantiation
+@pytest.mark.parametrize(
+    "exception_class",
+    [
+        LLMError,
+        LLMBadRequestError,
+        LLMUnsupportedParamsError,
+        LLMContextWindowExceededError,
+        LLMContentPolicyViolationError,
+        LLMInvalidRequestError,
+        LLMAuthenticationError,
+        LLMPermissionDeniedError,
+        LLMNotFoundError,
+        LLMTimeout,
+        LLMUnprocessableEntityError,
+        LLMRateLimitError,
+        LLMInternalServerError,
+    ],
+)
+def test_llm_exception_instantiation(exception_class):
+    """Test that each LLM exception can be instantiated."""
+    message = "Test error message"
+    provider = "test_provider"
+    error = exception_class(message, provider=provider)
+    assert isinstance(error, LLMError)  # Check inheritance
+    assert isinstance(error, Exception)
+    assert str(error) == message
+    assert error.provider == provider
+
+
+# Test OpenAI error mapping
+@pytest.mark.parametrize(
+    "status_code, expected_exception",
+    [
+        (400, LLMInvalidRequestError),
+        (401, LLMAuthenticationError),
+        (403, LLMPermissionDeniedError),
+        (404, LLMNotFoundError),
+        (422, LLMUnprocessableEntityError),
+        (429, LLMRateLimitError),
+        (500, LLMInternalServerError),
+        (999, LLMError),  # Test default case
+    ],
+)
+def test_map_openai_errors(status_code, expected_exception):
+    """Test the mapping of OpenAI error status codes to LLM exceptions."""
+    original_error = MockOpenAIError("OpenAI test error", status_code=status_code)
+    mapped_error = map_openai_errors(original_error)
+    assert isinstance(mapped_error, expected_exception)
+    # Check provider is set correctly - should always be OPENAI
+    assert mapped_error.provider == ModelProvider.OPENAI.value
+    assert "OpenAI APIError:" in str(mapped_error)
+
+
+def test_map_openai_errors_no_status_code():
+    """Test mapping OpenAI errors without a status code."""
+    original_error = Exception("Generic OpenAI error")  # Mock error without status_code
+    # Ensure the base class or a simple Exception can be handled if needed
+    # Re-mocking OpenAIError as a simple Exception for this case
+    mapped_error = map_openai_errors(original_error)
+    assert isinstance(mapped_error, LLMError)
+    assert not isinstance(
+        mapped_error,
+        (
+            LLMInvalidRequestError,
+            LLMAuthenticationError,
+            LLMPermissionDeniedError,
+            LLMNotFoundError,
+            LLMUnprocessableEntityError,
+            LLMRateLimitError,
+            LLMInternalServerError,
+        ),
+    )  # Should be the base LLMError
+    assert mapped_error.provider == ModelProvider.OPENAI.value
+    assert "OpenAI APIError:" in str(mapped_error)
+
+
+# Test Google error mapping
+@pytest.mark.parametrize(
+    "status, expected_exception",
+    [
+        (400, LLMInvalidRequestError),
+        (403, LLMPermissionDeniedError),
+        (429, LLMRateLimitError),
+        (500, LLMInternalServerError),
+        (999, LLMError),  # Test default case
+    ],
+)
+def test_map_google_errors(status, expected_exception):
+    """Test the mapping of Google error statuses to LLM exceptions."""
+    original_error = MockGoogleAPIError("Google test error", status=status)
+    mapped_error = map_google_errors(original_error)
+    assert isinstance(mapped_error, expected_exception)
+    assert mapped_error.provider == ModelProvider.GOOGLE.value
+    if status in [400, 403, 429, 500]:
+        assert "GoogleAPIError:" in str(mapped_error)
+    else:
+        assert "Google APIError:" in str(mapped_error)  # Note the subtle difference in the default message
+
+
+def test_map_google_errors_no_status():
+    """Test mapping Google errors without a status attribute."""
+    original_error = Exception("Generic Google error")  # Mock error without status
+    mapped_error = map_google_errors(original_error)
+    assert isinstance(mapped_error, LLMError)
+    assert not isinstance(
+        mapped_error, (LLMInvalidRequestError, LLMPermissionDeniedError, LLMRateLimitError, LLMInternalServerError)
+    )  # Should be the base LLMError
+    assert mapped_error.provider == ModelProvider.GOOGLE.value
+    assert "Google APIError:" in str(mapped_error)
+
+
+# Test Anthropic error mapping
+@pytest.mark.parametrize(
+    "status_code, expected_exception",
+    [
+        (400, LLMInvalidRequestError),
+        (401, LLMAuthenticationError),
+        (403, LLMPermissionDeniedError),
+        (404, LLMNotFoundError),
+        (413, LLMContextWindowExceededError),
+        (429, LLMRateLimitError),
+        (500, LLMInternalServerError),
+        (529, LLMInternalServerError),
+        (999, LLMError),  # Test default case
+    ],
+)
+def test_map_anthropic_errors(status_code, expected_exception):
+    """Test the mapping of Anthropic error status codes to LLM exceptions."""
+    original_error = MockAnthropicError("Anthropic test error", status_code=status_code)
+    mapped_error = map_anthropic_errors(original_error)
+    assert isinstance(mapped_error, expected_exception)
+    assert mapped_error.provider == ModelProvider.ANTHROPIC.value
+    assert "AnthropicError:" in str(mapped_error)
+
+
+def test_map_anthropic_errors_no_status_code():
+    """Test mapping Anthropic errors without a status code."""
+    original_error = Exception("Generic Anthropic error")  # Mock error without status_code
+    mapped_error = map_anthropic_errors(original_error)
+    assert isinstance(mapped_error, LLMError)
+    assert not isinstance(
+        mapped_error,
+        (
+            LLMInvalidRequestError,
+            LLMAuthenticationError,
+            LLMPermissionDeniedError,
+            LLMNotFoundError,
+            LLMContextWindowExceededError,
+            LLMRateLimitError,
+            LLMInternalServerError,
+        ),
+    )  # Should be the base LLMError
+    assert mapped_error.provider == ModelProvider.ANTHROPIC.value
+    assert "AnthropicError:" in str(mapped_error)
+
+
+def test_map_anthropic_api_status_error_invalid_request():
+    """Ensure Anthropic APIStatusError with invalid_request_error maps to LLMContentPolicyViolationError when message indicates content filtering."""
+    import httpx
+    from anthropic import APIStatusError
+
+    # Build a minimal httpx.Response to satisfy APIStatusError constructor
+    response = httpx.Response(status_code=400, request=httpx.Request("POST", "https://api.anthropic.com/v1/messages"))
+    body = {
+        "type": "error",
+        "error": {
+            "details": None,
+            "type": "invalid_request_error",
+            "message": "Output blocked by content filtering policy",
+        },
+    }
+
+    err = APIStatusError("invalid request", response=response, body=body)
+
+    from kolega_code.llm.exceptions import map_anthropic_errors, LLMContentPolicyViolationError
+
+    mapped = map_anthropic_errors(err)
+    assert isinstance(mapped, LLMContentPolicyViolationError)
+    assert mapped.provider == ModelProvider.ANTHROPIC.value
+    assert "AnthropicError:" in str(mapped)
+
+
+def test_map_anthropic_api_status_error_token_limit():
+    import httpx
+    from anthropic import APIStatusError
+
+    response = httpx.Response(status_code=400, request=httpx.Request("POST", "https://api.anthropic.com/v1/messages"))
+    body = {
+        "type": "error",
+        "error": {
+            "type": "invalid_request_error",
+            "message": "Invalid request: Your request exceeded model token limit: 262144 (requested: 1348145)",
+        },
+    }
+
+    err = APIStatusError("invalid request", response=response, body=body)
+
+    mapped = map_anthropic_errors(err)
+    assert isinstance(mapped, LLMContextWindowExceededError)
+    assert mapped.provider == ModelProvider.ANTHROPIC.value