fix(vertexai): preserve reasoning_content as thought parts in multi-turn conversations (#5677)

# What does this PR do?

When thinking-enabled Gemini models (2.5/3) return `reasoning_content`
in assistant messages, that content must be sent back as native
`thought` parts in subsequent multi-turn requests. Without this, the
model loses prior reasoning context across turns.

This PR updates `_convert_assistant_message()` in the VertexAI converter
to extract `reasoning_content` from assistant messages and emit it as a
`{"thought": True, "text": ...}` part, placed before text and
function_call parts. A truthiness guard skips the part when
`reasoning_content` is missing or `None`, preserving backward
compatibility.

## Test Plan

Added parametrized unit tests covering all combinations of
`reasoning_content` with text, tool_calls, both, neither, and `None`:

```bash
uv run pytest tests/unit/providers/inference/vertexai/test_converters_requests.py -v -k "reasoning"
```

Output:

```text
test_assistant_reasoning_content[reasoning_and_text] PASSED
test_assistant_reasoning_content[reasoning_only] PASSED
test_assistant_reasoning_content[no_reasoning] PASSED
test_assistant_reasoning_content[reasoning_none] PASSED
test_assistant_reasoning_content_with_tool_calls[reasoning_and_tool_calls] PASSED
test_assistant_reasoning_content_with_tool_calls[reasoning_text_and_tool_calls] PASSED

6 passed in 0.04s
```

Full converter test suite (110 tests) passes with no regressions:

```bash
uv run pytest tests/unit/providers/inference/vertexai/test_converters_requests.py tests/unit/providers/inference/vertexai/test_converters_responses.py -x --tb=short
```

```text
110 passed in 0.05s
```

Signed-off-by: Major Hayden <major@redhat.com>
Signed-off-by: Major Hayden <major@mhtx.net>

Author: major

src/ogx/providers/remote/inference/vertexai/converters.py

@@ -253,6 +253,16 @@ def _convert_assistant_message(msg: dict[str, Any]) -> dict[str, Any] | None:
     """
     parts: list[dict[str, Any]] = []
 
+    # Preserve prior reasoning in multi-turn conversations with thinking-enabled
+    # Gemini models by emitting reasoning_content as a native thought part.
+    reasoning_content = msg.get("reasoning_content")
+    if reasoning_content:
+        if not isinstance(reasoning_content, str):
+            raise TypeError(
+                f"Failed to convert assistant message: reasoning_content must be a string, got {type(reasoning_content).__name__}"
+            )
+        parts.append({"thought": True, "text": reasoning_content})
+
     text = _extract_text_content(msg.get("content"))
     if text:
         parts.append({"text": text})

tests/unit/providers/inference/vertexai/test_converters_requests.py

@@ -607,6 +607,80 @@ def test_tool_call_id_not_found(self):
         fr = contents[0]["parts"][0]["function_response"]
         assert fr["name"] == "unknown"
 
+    _SEARCH_TOOL_CALL = {
+        "id": "call_1",
+        "type": "function",
+        "function": {"name": "search", "arguments": '{"q": "test"}'},
+    }
+
+    @pytest.mark.parametrize(
+        "message,expected_parts",
+        [
+            pytest.param(
+                {"role": "assistant", "reasoning_content": "I think the answer is 42", "content": "Hello"},
+                [{"thought": True, "text": "I think the answer is 42"}, {"text": "Hello"}],
+                id="reasoning_and_text",
+            ),
+            pytest.param(
+                {"role": "assistant", "reasoning_content": "My reasoning", "content": None},
+                [{"thought": True, "text": "My reasoning"}],
+                id="reasoning_only",
+            ),
+            pytest.param(
+                {"role": "assistant", "content": "Hello"},
+                [{"text": "Hello"}],
+                id="no_reasoning",
+            ),
+            pytest.param(
+                {"role": "assistant", "reasoning_content": None, "content": "Hello"},
+                [{"text": "Hello"}],
+                id="reasoning_none",
+            ),
+        ],
+    )
+    def test_assistant_reasoning_content(self, message, expected_parts):
+        """Test reasoning_content is emitted as thought parts before text parts."""
+        _, contents = convert_openai_messages_to_gemini([message])
+        assert contents[0]["role"] == "model"
+        assert contents[0]["parts"] == expected_parts
+
+    @pytest.mark.parametrize(
+        "reasoning_content",
+        [
+            pytest.param({"type": "thinking", "thinking": "deep thought"}, id="dict_object"),
+            pytest.param(["thinking", "items"], id="list_object"),
+            pytest.param(42, id="integer"),
+        ],
+    )
+    def test_assistant_reasoning_content_must_be_string(self, reasoning_content):
+        """Test that non-string reasoning_content raises TypeError."""
+        message = {"role": "assistant", "reasoning_content": reasoning_content, "content": "Hello"}
+        with pytest.raises(TypeError, match="reasoning_content must be a string"):
+            convert_openai_messages_to_gemini([message])
+
+    @pytest.mark.parametrize(
+        "message,expected_non_fc_parts",
+        [
+            pytest.param(
+                {"role": "assistant", "reasoning_content": "Need a tool", "content": None},
+                [{"thought": True, "text": "Need a tool"}],
+                id="reasoning_and_tool_calls",
+            ),
+            pytest.param(
+                {"role": "assistant", "reasoning_content": "Let me think", "content": "I will search"},
+                [{"thought": True, "text": "Let me think"}, {"text": "I will search"}],
+                id="reasoning_text_and_tool_calls",
+            ),
+        ],
+    )
+    def test_assistant_reasoning_content_with_tool_calls(self, message, expected_non_fc_parts):
+        """Test thought -> text -> function_call ordering when tool_calls are present."""
+        message["tool_calls"] = [self._SEARCH_TOOL_CALL]
+        _, contents = convert_openai_messages_to_gemini([message])
+        parts = contents[0]["parts"]
+        assert parts[: len(expected_non_fc_parts)] == expected_non_fc_parts
+        assert "function_call" in parts[-1]
+
 
 class TestConvertOpenAIToolsToGemini:
     def test_single_function_tool(self):