Manual Merge PR #630

Author: matdev83

README.md

@@ -1,4 +1,4 @@
 {
-  "test_count": 5072,
+  "test_count": 5074,
   "last_updated": "1762168167.0802596"
 }

data/test_suite_state.json

@@ -1870,9 +1870,18 @@ async def _chat_completions_code_assist(
                 openai_response = self._extract_generated_text_from_response(
                     response_json
                 )
+            except BackendError:
+                # Preserve backend-specific error codes/details for graceful handling
+                raise
             except Exception as e:
-                logger.error(f"Failed to process API response: {e}", exc_info=True)
-                raise BackendError(f"Failed to process API response: {e}")
+                message = f"Failed to process API response: {e}"
+                logger.error(message, exc_info=True)
+                raise BackendError(
+                    message=message,
+                    backend_name=self.backend_type,
+                    code="gemini_response_processing_failed",
+                    details={"inner_error": str(e)},
+                ) from e
 
             # Calculate usage (best effort)
             encoding = tiktoken.get_encoding("cl100k_base")
@@ -2899,10 +2908,22 @@ async def _probe_model_recovery(
 
             logger.debug(f"Model {model} probe {state.probe_success_count}/2 succeeded")
 
-        except Exception as e:
-            # Probe failed, reset success count
+        except BackendError as error:
             state.probe_success_count = 0
-            logger.debug(f"Model {model} recovery probe failed: {e}")
+            log_message = (
+                f"Model {model} recovery probe failed with backend error: {error}"
+            )
+            if self._is_rate_limit_like_error(error):
+                logger.info(log_message)
+            else:
+                logger.warning(log_message)
+        except Exception as exc:  # pragma: no cover - defensive logging path
+            state.probe_success_count = 0
+            logger.warning(
+                "Model %s recovery probe encountered unexpected error: %s",
+                model,
+                exc,
+            )
 
         return False
 

src/connectors/gemini_oauth_base.py

@@ -679,7 +679,7 @@ async def cancel_stream() -> None:
                 await response.aclose()
 
         async def gen() -> AsyncGenerator[ProcessedResponse, None]:
-            async def text_generator() -> AsyncGenerator[str, None]:
+            async def text_generator() -> AsyncGenerator[dict[Any, Any] | Any, None]:
                 async def iter_sse_messages() -> AsyncGenerator[str, None]:
                     buffer = ""
                     separator = "\n\n"

src/connectors/openai.py

@@ -1087,9 +1087,8 @@ async def chat_completions(
         # Handle reasoning_effort by appending " /think" to the last user message
         # Append by default unless explicitly set to "low"
         reasoning_effort = None
-        if hasattr(request_data, "reasoning_effort"):
-            reasoning_effort = request_data.reasoning_effort
-        elif isinstance(request_data, dict):
+        reasoning_effort = getattr(request_data, "reasoning_effort", None)
+        if reasoning_effort is None and isinstance(request_data, dict):
             reasoning_effort = request_data.get("reasoning_effort")
 
         # Append " /think" unless reasoning_effort is explicitly "low"

src/connectors/qwen_oauth.py

@@ -8,6 +8,6 @@ def _load_project_metadata() -> tuple[str, str]:
     try:
         data = tomli.loads(pyproject.read_text())
         meta = data.get("project", {})
-        return meta.get("name", "llm-interactive-proxy"), meta.get("version", "0.0.0")
+        return meta.get("name", "llm-interactive-proxy"), meta.get("version", "0.1.0")
     except Exception:
         return "llm-interactive-proxy", "0.0.0"

src/core/metadata.py

@@ -75,11 +75,11 @@ def validate_and_normalize(
             try:
                 # Type conversion and validation
                 normalized_value: float | str
-                if param_type == float:
+                if param_type is float:
                     normalized_value = self._validate_float_param(
                         param_name, param_value, rules
                     )
-                elif param_type == str:
+                elif param_type is str:
                     normalized_value = self._validate_string_param(
                         param_name, param_value, rules
                     )

src/core/services/uri_parameter_validator.py

@@ -11,7 +11,7 @@
 import pytest
 from src.core.app.application_builder import ApplicationBuilder
 from src.core.config.app_config import AppConfig
-from src.core.domain.chat import ToolCall
+from src.core.domain.chat import FunctionCall, ToolCall
 from src.core.domain.processed_result import ProcessedResult
 from src.core.domain.session import Session, SessionState
 from src.core.services.session_service_impl import SessionService
@@ -66,7 +66,7 @@ async def test_pytest_compression_end_to_end_with_real_execution():
     tool_call = ToolCall(
         id="call_pytest_test_123",
         type="function",
-        function={"name": "bash", "arguments": json.dumps(pytest_cmd)},
+        function=FunctionCall(name="bash", arguments=json.dumps(pytest_cmd)),
     )
 
     logger.info(
@@ -100,7 +100,7 @@ async def test_pytest_compression_end_to_end_with_real_execution():
     # Note: The reactor service returns None because the handler doesn't swallow the tool call,
     # it just sets the compression state. This is the correct behavior.
     assert (
-        updated_session.state.compress_next_tool_call_reply == True
+        updated_session.state.compress_next_tool_call_reply
     ), "Compression state should be set to True"
 
     # Act - Phase 2: Create mock command result with real pytest output
@@ -314,7 +314,7 @@ async def test_pytest_compression_state_machine_flow():
     await session_service.update_session(session)
 
     # Verify initial state
-    assert session.state.compress_next_tool_call_reply == False
+    assert not session.state.compress_next_tool_call_reply
 
     # Act - Process pytest tool call
     from src.core.interfaces.tool_call_reactor_interface import ToolCallContext
@@ -344,7 +344,7 @@ async def test_pytest_compression_state_machine_flow():
 
     # Assert - State should be set
     updated_session = await session_service.get_session(session_id)
-    assert updated_session.state.compress_next_tool_call_reply == True
+    assert updated_session.state.compress_next_tool_call_reply
     # Note: The reactor service returns None because the handler doesn't swallow the tool call,
     # it just sets the compression state. This is the correct behavior.
     logger.info(

tests/integration/test_pytest_compression_e2e.py

@@ -2,10 +2,71 @@
 
 import pytest
 from src.connectors.gemini_oauth_plan import GeminiOAuthPlanConnector
-from src.core.domain.chat import ChatMessage, ChatRequest
+from src.core.common.exceptions import BackendError
+from src.core.domain.chat import CanonicalChatRequest, ChatMessage, ChatRequest
 from src.core.domain.responses import ResponseEnvelope, StreamingResponseEnvelope
 
 
+@pytest.mark.asyncio
+async def test_code_assist_empty_response_preserves_backend_error():
+    mock_client = AsyncMock()
+    mock_config = MagicMock()
+    mock_translation_service = MagicMock()
+
+    connector = GeminiOAuthPlanConnector(
+        client=mock_client,
+        config=mock_config,
+        translation_service=mock_translation_service,
+    )
+
+    connector.gemini_api_base_url = "https://cloudcode-pa.googleapis.com"
+    connector._oauth_credentials = {"access_token": "fake_token"}
+    connector._refresh_token_if_needed = AsyncMock(return_value=True)
+    connector._discover_project_id = AsyncMock(return_value="fake_project")
+
+    mock_translation_service.from_domain_to_gemini_request.return_value = {
+        "contents": [
+            {
+                "role": "user",
+                "parts": [{"text": "Hello"}],
+            }
+        ]
+    }
+
+    class FakeResponse:
+        status_code = 200
+
+        @staticmethod
+        def json() -> dict[str, list[dict[str, object]]]:
+            return {"candidates": []}
+
+    fake_response = FakeResponse()
+
+    mock_auth_session = MagicMock()
+    mock_auth_session.headers = {}
+    mock_auth_session.request.return_value = fake_response
+
+    request = CanonicalChatRequest(
+        model="gemini-2.5-pro",
+        messages=[ChatMessage(role="user", content="Hello")],
+    )
+
+    with (
+        patch(
+            "google.auth.transport.requests.AuthorizedSession",
+            return_value=mock_auth_session,
+        ),
+        pytest.raises(BackendError) as excinfo,
+    ):
+        await connector._chat_completions_code_assist(
+            request_data=request,
+            processed_messages=[ChatMessage(role="user", content="Hello")],
+            effective_model="gemini-2.5-pro",
+        )
+
+    assert excinfo.value.code == "empty_response"
+
+
 @pytest.mark.asyncio
 async def test_chat_completions_with_tiktoken_usage_calculation():
     """

tests/unit/connectors/test_gemini_oauth_plan_usage.py

@@ -2,7 +2,6 @@
 import shutil
 import tempfile
 import unittest
-from types import SimpleNamespace
 
 from src.core.config.app_config import RewritingConfig
 from src.core.domain.replacement_rule import ReplacementMode
@@ -151,7 +150,7 @@ def tearDown(self):
                                     self.test_config_dir, ignore_errors=True
                                 )
                             )
-                        except:
+                        except Exception:
                             pass
 
     def test_load_rules(self):
@@ -248,7 +247,9 @@ def test_app_config_overrides_default_config_path(self):
         ) as handle:
             handle.write("rewritten custom reply")
 
-        app_config = SimpleNamespace(
+        from src.core.config.app_config import AppConfig
+
+        app_config = AppConfig(
             rewriting=RewritingConfig(enabled=True, config_path=alternate_dir)
         )