fix(acp): preserve reasoning_content in non-stream responses and add newline separators to progress lines

Accumulate reasoning_content alongside content in _chat_completions_non_streaming so non-stream clients receive thinking/progress data. Append newline separators to _acp_progress_reasoning_line outputs so concatenated reasoning chunks render on separate lines. Add regression tests for both behaviors.

Author: Mateusz

src/connectors/acp_core/base_connector.py

@@ -579,8 +579,8 @@ def _acp_progress_reasoning_line(
             tc = update.get("toolCall")
             if isinstance(tc, dict):
                 name = tc.get("name") or tc.get("toolName") or tc.get("title") or "tool"
-                return f"[tool] {name}"
-            return "[tool]"
+                return f"[tool] {name}\n"
+            return "[tool]\n"
         if session_update_kind == "tool_call_update":
             tcu = update.get("toolCallUpdate")
             if not isinstance(tcu, dict):
@@ -589,19 +589,19 @@ def _acp_progress_reasoning_line(
                 name = tcu.get("name") or tcu.get("toolName") or "tool"
                 status = tcu.get("status") or tcu.get("state")
                 if isinstance(status, str) and status:
-                    return f"[tool] {name}: {status}"
-                return f"[tool] {name} …"
-            return "[tool] …"
+                    return f"[tool] {name}: {status}\n"
+                return f"[tool] {name} …\n"
+            return "[tool] …\n"
         if session_update_kind == "plan":
             title = update.get("title")
             if isinstance(title, str) and title.strip():
-                return f"[plan] {title.strip()}"
-            return "[plan]"
+                return f"[plan] {title.strip()}\n"
+            return "[plan]\n"
         if session_update_kind == "current_mode_update":
             mode = update.get("modeId") or update.get("mode")
             if isinstance(mode, str) and mode:
-                return f"[mode] {mode}"
-            return "[mode]"
+                return f"[mode] {mode}\n"
+            return "[mode]\n"
         return None
 
     def _session_update_to_stream_piece(
@@ -1009,12 +1009,18 @@ async def _stream_with_keepalive() -> AsyncIterator[ProcessedResponse]:
                 cancellable_registered = True
             try:
                 fragments: list[str] = []
+                reasoning_fragments: list[str] = []
                 async for piece in self._iter_acp_stream_pieces(
                     runtime, prompt_request_id, requested_model
                 ):
                     if piece.content:
                         fragments.append(piece.content)
+                    if piece.reasoning_content:
+                        reasoning_fragments.append(piece.reasoning_content)
                 full_response = "".join(fragments)
+                full_reasoning = (
+                    "".join(reasoning_fragments) if reasoning_fragments else None
+                )
 
                 response = CanonicalChatResponse(
                     id=str(uuid.uuid4()),
@@ -1027,6 +1033,7 @@ async def _stream_with_keepalive() -> AsyncIterator[ProcessedResponse]:
                             message=ChatCompletionChoiceMessage(
                                 role="assistant",
                                 content=full_response,
+                                reasoning_content=full_reasoning,
                             ),
                             finish_reason="stop",
                         )

tests/unit/connectors/acp_core/test_base_connector.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import AsyncGenerator
 from pathlib import Path
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 from src.connectors.acp_core.base_connector import BaseAcpConnector
-from src.connectors.acp_core.types import (
-    ACPNotification,
-    ACPProcessRuntime,
-    AcpStreamPiece,
-)
+from src.connectors.acp_core.types import ACPNotification, ACPProcessRuntime
+from src.connectors.acp_core.types import AcpStreamPiece as AcpStreamPiece
 from src.connectors.contracts import ConnectorChatCompletionsRequest
 from src.core.domain.chat import CanonicalChatRequest, ChatMessage
+from src.core.domain.responses import ResponseEnvelope
 
 
 class DummyAcpConnector(BaseAcpConnector):
@@ -112,7 +111,7 @@ def test_session_update_tool_call_maps_to_progress_piece(
         },
     )
     piece = connector._session_update_to_stream_piece(msg)
-    assert piece == AcpStreamPiece(reasoning_content="[tool] read_file")
+    assert piece == AcpStreamPiece(reasoning_content="[tool] read_file\n")
 
 
 def test_resolve_stream_keepalive_interval_from_config(
@@ -162,3 +161,36 @@ async def test_base_acp_connector_history_injected_logic(
         prompt_text_2 = sent_params_2["prompt"][0]["text"]
         assert "System Note:" not in prompt_text_2
         assert prompt_text_2 == "hello"
+
+
+@pytest.mark.asyncio
+async def test_non_streaming_chat_completions_preserve_reasoning_content(
+    connector: DummyAcpConnector,
+) -> None:
+    connector.is_functional = True
+    connector._default_project_dir = Path("/tmp/dummy")
+    runtime = connector._create_runtime(Path("/tmp/dummy"), "dummy/model")
+
+    async def _mock_iter(
+        _: ACPProcessRuntime, __: int, ___: str
+    ) -> AsyncGenerator[AcpStreamPiece, None]:
+        yield AcpStreamPiece(reasoning_content="plan step\n")
+        yield AcpStreamPiece(content="Answer")
+        yield AcpStreamPiece(reasoning_content="tool finished\n")
+
+    with (
+        patch.object(connector, "_acquire_runtime", AsyncMock(return_value=runtime)),
+        patch.object(
+            connector,
+            "_prepare_prompt_request_locked",
+            AsyncMock(return_value=(5, "dummy/model")),
+        ),
+        patch.object(connector, "_iter_acp_stream_pieces", side_effect=_mock_iter),
+    ):
+        response = await connector.chat_completions(_make_request())
+
+    assert isinstance(response, ResponseEnvelope)
+    assert isinstance(response.content, dict)
+    message = response.content["choices"][0]["message"]
+    assert message["content"] == "Answer"
+    assert message["reasoning_content"] == "plan step\ntool finished\n"

tests/unit/connectors/test_gemini_cli_acp.py

@@ -254,6 +254,43 @@ async def _read(_: ACPProcessRuntime) -> ACPNotification:
 
 
 class TestGeminiCliAcpChatCompletions:
+    async def test_non_streaming_chat_completions_preserve_reasoning_content(
+        self, connector: GeminiCliAcpConnector, temp_workspace: Path
+    ) -> None:
+        connector.is_functional = True
+        connector._default_project_dir = temp_workspace
+        runtime = connector._create_runtime(temp_workspace, "gemini-2.5-flash")
+
+        async def _mock_iter(
+            _: ACPProcessRuntime, __: int, ___: str
+        ) -> AsyncGenerator[AcpStreamPiece, None]:
+            yield AcpStreamPiece(reasoning_content="[tool] read_file\n")
+            yield AcpStreamPiece(content="Hello")
+            yield AcpStreamPiece(reasoning_content="[tool] read_file: complete\n")
+            yield AcpStreamPiece(content=" world")
+
+        with (
+            patch.object(
+                connector, "_acquire_runtime", AsyncMock(return_value=runtime)
+            ),
+            patch.object(
+                connector,
+                "_prepare_prompt_request_locked",
+                AsyncMock(return_value=(5, "google/gemini-2.5-flash")),
+            ),
+            patch.object(connector, "_iter_acp_stream_pieces", side_effect=_mock_iter),
+        ):
+            response = await connector.chat_completions(_make_request())
+
+        assert isinstance(response, ResponseEnvelope)
+        assert isinstance(response.content, dict)
+        message = response.content["choices"][0]["message"]
+        assert message["content"] == "Hello world"
+        assert (
+            message["reasoning_content"]
+            == "[tool] read_file\n[tool] read_file: complete\n"
+        )
+
     async def test_non_streaming_chat_completions(
         self, connector: GeminiCliAcpConnector, temp_workspace: Path
     ) -> None: