fix(open_responses): preserve spec stream details

Komzpa · Komzpa · commit a6a59c8cfc0d · 2026-05-04T02:18:08.000+04:00
diff --git a/homeassistant/components/open_responses/client.py b/homeassistant/components/open_responses/client.py
@@ -35,7 +35,11 @@ def __init__(self, http_client: AsyncClient, api_key: str, base_url: str) -> Non
         """Initialize the client."""
         self._http_client = http_client
         self._url = f"{base_url.rstrip('/')}/responses"
-        self._headers = {
+        self._json_headers = {
+            "authorization": f"Bearer {api_key}",
+            "accept": "application/json",
+        }
+        self._stream_headers = {
             "authorization": f"Bearer {api_key}",
             "accept": "text/event-stream",
         }
@@ -48,7 +52,7 @@ async def create_response(self, **params: Any) -> dict[str, Any]:
             response = await self._http_client.post(
                 self._url,
                 json=body,
-                headers=self._headers,
+                headers=self._json_headers,
             )
             response.raise_for_status()
         except HTTPStatusError as err:
@@ -69,7 +73,7 @@ async def stream_response(self, **params: Any) -> AsyncGenerator[dict[str, Any]]
                 "POST",
                 self._url,
                 json=body,
-                headers=self._headers,
+                headers=self._stream_headers,
             ) as response:
                 response.raise_for_status()
                 async for event in _iter_sse_events(response.aiter_lines()):
@@ -104,26 +108,49 @@ def _strip_none_values(value: Any) -> Any:
 async def _iter_sse_events(lines: AsyncIterable[str]) -> AsyncGenerator[dict[str, Any]]:
     """Yield JSON server-sent events from an Open Responses stream."""
     event_type: str | None = None
+    data_lines: list[str] = []
+    done = False
+
+    async def flush_event() -> dict[str, Any] | None:
+        nonlocal done, event_type, data_lines
+
+        if not data_lines:
+            event_type = None
+            return None
+
+        data = "\n".join(data_lines)
+        event_type_for_payload = event_type
+        event_type = None
+        data_lines = []
+
+        if data == "[DONE]":
+            done = True
+            return None
+
+        event = json.loads(data)
+        if event_type_for_payload and "type" not in event:
+            event["type"] = event_type_for_payload
+        return event
 
     async for line in lines:
+        if done:
+            return
         if not line:
-            event_type = None
+            if event := await flush_event():
+                yield event
+            if done:
+                return
             continue
         if line.startswith("event:"):
             event_type = line.split(":", 1)[1].strip()
             continue
         if not line.startswith("data:"):
             continue
 
-        data = line.split(":", 1)[1].strip()
-        if data == "[DONE]":
-            return
+        data_lines.append(line.split(":", 1)[1].strip())
 
-        event = json.loads(data)
-        if event_type and "type" not in event:
-            event["type"] = event_type
+    if event := await flush_event():
         yield event
-        event_type = None
 
 
 def _raise_client_error(err: HTTPStatusError) -> None:
diff --git a/homeassistant/components/open_responses/config_flow.py b/homeassistant/components/open_responses/config_flow.py
@@ -12,6 +12,7 @@
     ConfigEntryState,
     ConfigFlow,
     ConfigFlowResult,
+    ConfigSubentry,
     ConfigSubentryFlow,
     SubentryFlowResult,
 )
@@ -60,6 +61,16 @@
     }
 )
 
+DEFAULT_SUBENTRY_TITLES = {
+    "ai_task_data": DEFAULT_AI_TASK_NAME,
+    "conversation": DEFAULT_CONVERSATION_NAME,
+}
+
+
+def _is_default_subentry(subentry: ConfigSubentry) -> bool:
+    """Return whether a subentry is the generated default subentry."""
+    return subentry.title == DEFAULT_SUBENTRY_TITLES.get(subentry.subentry_type)
+
 
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     """Validate Open Responses connection details."""
@@ -84,7 +95,9 @@ def _async_update_default_subentry_models(
     old_model = entry.data[CONF_MODEL]
 
     for subentry in entry.subentries.values():
-        if subentry.data.get(CONF_MODEL) != old_model:
+        if subentry.data.get(CONF_MODEL) != old_model or not _is_default_subentry(
+            subentry
+        ):
             continue
 
         hass.config_entries.async_update_subentry(
diff --git a/homeassistant/components/open_responses/entity.py b/homeassistant/components/open_responses/entity.py
@@ -23,6 +23,7 @@
 from .client import (
     OpenResponsesAuthError,
     OpenResponsesConnectionError,
+    OpenResponsesInvalidModelError,
     OpenResponsesRateLimitError,
 )
 from .const import (
@@ -256,7 +257,7 @@ async def _transform_stream(
                     "native": {
                         "type": "reasoning",
                         "id": item.get("id"),
-                        "summary": [],
+                        "summary": item.get("summary") or [],
                         "encrypted_content": item.get("encrypted_content"),
                     }
                 }
@@ -324,9 +325,9 @@ async def _transform_stream(
                     reason = error.get("message") or reason
                 raise HomeAssistantError(f"Open Responses response failed: {reason}")
         elif event_type == "response.error":
-            raise HomeAssistantError(
-                f"Open Responses response error: {event['message']}"
-            )
+            error = cast(dict[str, Any], event.get("error") or {})
+            reason = error.get("message") or event.get("message") or "unknown reason"
+            raise HomeAssistantError(f"Open Responses response error: {reason}")
 
 
 class OpenResponsesEntity(Entity):
@@ -413,6 +414,9 @@ async def _async_handle_chat_log(
                 raise HomeAssistantError(
                     "Rate limited by Open Responses endpoint"
                 ) from err
+            except OpenResponsesInvalidModelError as err:
+                LOGGER.error("Invalid Open Responses model: %s", err)
+                raise HomeAssistantError("Invalid Open Responses model") from err
             except OpenResponsesConnectionError as err:
                 LOGGER.error("Error talking to Open Responses endpoint: %s", err)
                 raise HomeAssistantError(
@@ -462,7 +466,7 @@ def append_files_to_content() -> ResponseInputMessageContentListParam:
                 content.append(
                     {
                         "type": "input_file",
-                        "filename": str(file_path),
+                        "filename": file_path.name,
                         "file_data": f"data:{mime_type};base64,{base64_file}",
                     }
                 )
diff --git a/tests/components/open_responses/test_client.py b/tests/components/open_responses/test_client.py
@@ -1,12 +1,17 @@
 """Tests for the Open Responses client."""
 
+from collections.abc import AsyncGenerator
+from unittest.mock import AsyncMock
+
 import httpx
 from pydantic import ValidationError
 import pytest
 
 from homeassistant.components.open_responses.client import (
+    OpenResponsesClient,
     OpenResponsesInvalidModelError,
     _format_request_body,
+    _iter_sse_events,
     _raise_client_error,
 )
 
@@ -54,6 +59,58 @@ def test_format_request_body_validates_response_body() -> None:
         )
 
 
+async def test_create_response_requests_json() -> None:
+    """Test non-streaming responses request a JSON response."""
+    response = httpx.Response(
+        200,
+        json={"id": "resp_1"},
+        request=httpx.Request("POST", "https://example.local/v1/responses"),
+    )
+    http_client = AsyncMock()
+    http_client.post.return_value = response
+    client = OpenResponsesClient(http_client, "api-key", "https://example.local/v1")
+
+    assert await client.create_response(
+        model="model",
+        input=[{"type": "message", "role": "user", "content": "ping"}],
+    ) == {"id": "resp_1"}
+
+    assert http_client.post.await_args.kwargs["headers"]["accept"] == "application/json"
+
+
+async def test_iter_sse_events_accumulates_multiline_data() -> None:
+    """Test SSE data lines are joined until the event delimiter."""
+
+    async def lines() -> AsyncGenerator[str]:
+        yield "event: response.output_text.delta"
+        yield 'data: {"delta":'
+        yield 'data: "hello"}'
+        yield ""
+
+    assert [event async for event in _iter_sse_events(lines())] == [
+        {
+            "delta": "hello",
+            "type": "response.output_text.delta",
+        }
+    ]
+
+
+async def test_iter_sse_events_stops_on_done() -> None:
+    """Test the OpenAI stream terminator stops event iteration."""
+
+    async def lines() -> AsyncGenerator[str]:
+        yield 'data: {"type": "response.created"}'
+        yield ""
+        yield "data: [DONE]"
+        yield ""
+        yield 'data: {"type": "response.output_text.delta", "delta": "late"}'
+        yield ""
+
+    assert [event async for event in _iter_sse_events(lines())] == [
+        {"type": "response.created"}
+    ]
+
+
 def test_raise_client_error_detects_invalid_model() -> None:
     """Test model validation errors are separated from endpoint failures."""
     response = httpx.Response(
diff --git a/tests/components/open_responses/test_config_flow.py b/tests/components/open_responses/test_config_flow.py
@@ -219,9 +219,49 @@ async def test_form_handles_invalid_model(hass: HomeAssistant) -> None:
 
 
 async def test_reauth_updates_default_subentry_models(
-    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+    hass: HomeAssistant,
 ) -> None:
     """Test reauth model changes are propagated to generated subentries."""
+    mock_config_entry = MockConfigEntry(
+        title="Open Responses",
+        domain=DOMAIN,
+        data={
+            CONF_API_KEY: "bla",
+            CONF_BASE_URL: "https://example.local/v1",
+            CONF_MODEL: "open-responses-model",
+        },
+        version=1,
+        subentries_data=[
+            config_entries.ConfigSubentryData(
+                data={
+                    **RECOMMENDED_CONVERSATION_OPTIONS,
+                    CONF_MODEL: "open-responses-model",
+                },
+                subentry_type="conversation",
+                title=DEFAULT_CONVERSATION_NAME,
+                unique_id=None,
+            ),
+            config_entries.ConfigSubentryData(
+                data={
+                    **RECOMMENDED_AI_TASK_OPTIONS,
+                    CONF_MODEL: "open-responses-model",
+                },
+                subentry_type="ai_task_data",
+                title=DEFAULT_AI_TASK_NAME,
+                unique_id=None,
+            ),
+            config_entries.ConfigSubentryData(
+                data={
+                    **RECOMMENDED_CONVERSATION_OPTIONS,
+                    CONF_MODEL: "open-responses-model",
+                },
+                subentry_type="conversation",
+                title="My Custom Agent",
+                unique_id=None,
+            ),
+        ],
+    )
+    mock_config_entry.add_to_hass(hass)
     result = await mock_config_entry.start_reauth_flow(hass)
 
     assert result["type"] is FlowResultType.FORM
@@ -254,9 +294,15 @@ async def test_reauth_updates_default_subentry_models(
     assert result2["type"] is FlowResultType.ABORT
     assert result2["reason"] == "reauth_successful"
     assert mock_config_entry.data[CONF_MODEL] == "new-open-responses-model"
-    assert {
-        subentry.data[CONF_MODEL] for subentry in mock_config_entry.subentries.values()
-    } == {"new-open-responses-model"}
+    subentry_models = {
+        subentry.title: subentry.data[CONF_MODEL]
+        for subentry in mock_config_entry.subentries.values()
+    }
+    assert subentry_models == {
+        DEFAULT_AI_TASK_NAME: "new-open-responses-model",
+        DEFAULT_CONVERSATION_NAME: "new-open-responses-model",
+        "My Custom Agent": "open-responses-model",
+    }
 
 
 async def test_creating_conversation_subentry(
diff --git a/tests/components/open_responses/test_entity.py b/tests/components/open_responses/test_entity.py
