fix(open_responses): cover review edge cases

Author: Komzpa

homeassistant/components/open_responses/client.py

@@ -4,7 +4,7 @@
 import json
 from typing import Any
 
-from httpx import AsyncClient, HTTPStatusError, RequestError
+from httpx import AsyncClient, HTTPStatusError, RequestError, Response
 from openresponses_types.types import CreateResponseBody
 
 
@@ -20,6 +20,10 @@ class OpenResponsesRateLimitError(OpenResponsesError):
     """Open Responses rate limit error."""
 
 
+class OpenResponsesInvalidModelError(OpenResponsesError):
+    """Open Responses model validation error."""
+
+
 class OpenResponsesConnectionError(OpenResponsesError):
     """Open Responses connection error."""
 
@@ -129,4 +133,23 @@ def _raise_client_error(err: HTTPStatusError) -> None:
         raise OpenResponsesAuthError("Authentication failed")
     if status_code == 429:
         raise OpenResponsesRateLimitError("Rate limited")
+    if status_code == 400 and _response_error_mentions_model(err.response):
+        raise OpenResponsesInvalidModelError("Invalid model")
     raise OpenResponsesConnectionError("Open Responses endpoint error")
+
+
+def _response_error_mentions_model(response: Response) -> bool:
+    """Return whether an error response points at the requested model."""
+    try:
+        body = response.json()
+    except ValueError:
+        return False
+
+    error = body.get("error") if isinstance(body, dict) else None
+    if not isinstance(error, dict):
+        return False
+
+    return any(
+        "model" in str(error.get(key, "")).lower()
+        for key in ("code", "param", "message")
+    )

homeassistant/components/open_responses/config_flow.py

@@ -34,6 +34,7 @@
     OpenResponsesAuthError,
     OpenResponsesClient,
     OpenResponsesConnectionError,
+    OpenResponsesInvalidModelError,
 )
 from .const import (
     CONF_BASE_URL,
@@ -76,6 +77,23 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     )
 
 
+def _async_update_default_subentry_models(
+    hass: HomeAssistant, entry: ConfigEntry, model: str
+) -> None:
+    """Update generated default subentries when reauth changes the model."""
+    old_model = entry.data[CONF_MODEL]
+
+    for subentry in entry.subentries.values():
+        if subentry.data.get(CONF_MODEL) != old_model:
+            continue
+
+        hass.config_entries.async_update_subentry(
+            entry,
+            subentry,
+            data={**subentry.data, CONF_MODEL: model},
+        )
+
+
 class OpenResponsesConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Open Responses."""
 
@@ -107,6 +125,8 @@ async def async_step_user(
                 await validate_input(self.hass, user_input)
             except OpenResponsesAuthError:
                 errors["base"] = "invalid_auth"
+            except OpenResponsesInvalidModelError:
+                errors[CONF_MODEL] = "invalid_model"
             except OpenResponsesConnectionError:
                 errors["base"] = "cannot_connect"
             else:
@@ -119,8 +139,12 @@ async def async_step_user(
                     CONF_MODEL: user_input[CONF_MODEL],
                 }
                 if self.source == SOURCE_REAUTH:
+                    reauth_entry = self._get_reauth_entry()
+                    _async_update_default_subentry_models(
+                        self.hass, reauth_entry, user_input[CONF_MODEL]
+                    )
                     return self.async_update_reload_and_abort(
-                        self._get_reauth_entry(), data_updates=user_input
+                        reauth_entry, data_updates=user_input
                     )
                 return self.async_create_entry(
                     title="Open Responses",

homeassistant/components/open_responses/entity.py

@@ -168,6 +168,58 @@ def _convert_content_to_param(
     return messages
 
 
+async def _async_prepare_message_attachments(
+    hass: HomeAssistant,
+    chat_content: Iterable[conversation.Content],
+    messages: ResponseInputParam,
+) -> None:
+    """Attach files to all matching user messages."""
+    message_index = 0
+
+    for content in chat_content:
+        if isinstance(content, conversation.ToolResultContent):
+            message_index += 1
+            continue
+
+        if (
+            isinstance(content, conversation.AssistantContent)
+            and isinstance(content.native, dict)
+            and content.native.get("type")
+        ):
+            message_index += 1
+            continue
+
+        if content.content or (
+            isinstance(content, conversation.UserContent) and content.attachments
+        ):
+            if isinstance(content, conversation.UserContent) and content.attachments:
+                files = await async_prepare_files_for_prompt(
+                    hass,
+                    [
+                        (attachment.path, attachment.mime_type)
+                        for attachment in content.attachments
+                    ],
+                )
+                message = messages[message_index]
+                assert (
+                    message["type"] == "message"
+                    and message["role"] == "user"
+                    and isinstance(message["content"], str)
+                )
+                message_content: ResponseInputMessageContentListParam = []
+                if message["content"]:
+                    message_content.append(
+                        {"type": "input_text", "text": message["content"]}
+                    )
+                message_content.extend(files)
+                message["content"] = message_content
+
+            message_index += 1
+
+        if isinstance(content, conversation.AssistantContent) and content.tool_calls:
+            message_index += len(content.tool_calls)
+
+
 async def _transform_stream(
     chat_log: conversation.ChatLog,
     stream: AsyncIterable[dict[str, Any]],
@@ -307,7 +359,9 @@ async def _async_handle_chat_log(
     ) -> None:
         """Generate an answer for the chat log."""
         options = self.subentry.data
-        messages = _convert_content_to_param(chat_log.content)
+        chat_content = list(chat_log.content)
+        messages = _convert_content_to_param(chat_content)
+        await _async_prepare_message_attachments(self.hass, chat_content, messages)
 
         model_args: dict[str, Any] = {
             "model": options.get(CONF_MODEL, self.entry.data[CONF_MODEL]),
@@ -329,26 +383,6 @@ async def _async_handle_chat_log(
         if tools:
             model_args["tools"] = tools
 
-        last_content = chat_log.content[-1]
-        if last_content.role == "user" and last_content.attachments:
-            files = await async_prepare_files_for_prompt(
-                self.hass,
-                [(a.path, a.mime_type) for a in last_content.attachments],
-            )
-            last_message = messages[-1]
-            assert (
-                last_message["type"] == "message"
-                and last_message["role"] == "user"
-                and isinstance(last_message["content"], str)
-            )
-            last_message_content: ResponseInputMessageContentListParam = []
-            if last_message["content"]:
-                last_message_content.append(
-                    {"type": "input_text", "text": last_message["content"]}
-                )
-            last_message_content.extend(files)
-            last_message["content"] = last_message_content
-
         if structure and structure_name:
             model_args["text"] = {
                 "format": {

homeassistant/components/open_responses/strings.json

@@ -7,6 +7,7 @@
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_model": "The endpoint rejected the configured model.",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {

tests/components/open_responses/conftest.py

@@ -32,13 +32,19 @@ def mock_config_entry(hass: HomeAssistant) -> MockConfigEntry:
         version=1,
         subentries_data=[
             ConfigSubentryData(
-                data=RECOMMENDED_CONVERSATION_OPTIONS,
+                data={
+                    **RECOMMENDED_CONVERSATION_OPTIONS,
+                    CONF_MODEL: "open-responses-model",
+                },
                 subentry_type="conversation",
                 title=DEFAULT_CONVERSATION_NAME,
                 unique_id=None,
             ),
             ConfigSubentryData(
-                data=RECOMMENDED_AI_TASK_OPTIONS,
+                data={
+                    **RECOMMENDED_AI_TASK_OPTIONS,
+                    CONF_MODEL: "open-responses-model",
+                },
                 subentry_type="ai_task_data",
                 title=DEFAULT_AI_TASK_NAME,
                 unique_id=None,

tests/components/open_responses/test_ai_task.py

@@ -0,0 +1,93 @@
+"""Tests for Open Responses AI tasks."""
+
+from collections.abc import AsyncGenerator
+from copy import deepcopy
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import ai_task
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import selector
+
+from tests.common import MockConfigEntry
+
+
+def _mock_response_stream(calls: list[dict[str, Any]], text: str) -> Any:
+    """Return a streaming response mock."""
+
+    async def stream_response(**params: Any) -> AsyncGenerator[dict[str, Any]]:
+        calls.append(deepcopy(params))
+        yield {
+            "type": "response.output_item.added",
+            "item": {
+                "type": "message",
+                "id": "msg_1",
+                "role": "assistant",
+                "content": [],
+                "status": "in_progress",
+            },
+        }
+        yield {"type": "response.output_text.delta", "delta": text}
+        yield {
+            "type": "response.completed",
+            "response": {"usage": {"input_tokens": 1, "output_tokens": 1}},
+        }
+
+    return stream_response
+
+
+async def test_generate_data(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_init_component: None,
+) -> None:
+    """Test plain-text AI task data generation reaches the client."""
+    calls: list[dict[str, Any]] = []
+    mock_config_entry.runtime_data.stream_response = _mock_response_stream(
+        calls, "The test data"
+    )
+
+    result = await ai_task.async_generate_data(
+        hass,
+        task_name="Test Task",
+        entity_id="ai_task.open_responses_ai_task",
+        instructions="Generate test data",
+    )
+
+    assert result.data == "The test data"
+    assert calls[0]["model"] == "open-responses-model"
+    assert calls[0]["input"][-1] == {
+        "type": "message",
+        "role": "user",
+        "content": "Generate test data",
+    }
+
+
+async def test_generate_structured_data(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_init_component: None,
+) -> None:
+    """Test structured AI task data generation reaches the client."""
+    calls: list[dict[str, Any]] = []
+    mock_config_entry.runtime_data.stream_response = _mock_response_stream(
+        calls, '{"characters":["Mario","Luigi"]}'
+    )
+
+    result = await ai_task.async_generate_data(
+        hass,
+        task_name="Character Task",
+        entity_id="ai_task.open_responses_ai_task",
+        instructions="Generate character data",
+        structure=vol.Schema(
+            {
+                vol.Required("characters"): selector.selector(
+                    {"text": {"multiple": True}}
+                )
+            }
+        ),
+    )
+
+    assert result.data == {"characters": ["Mario", "Luigi"]}
+    assert calls[0]["text"]["format"]["type"] == "json_schema"

tests/components/open_responses/test_client.py

@@ -1,9 +1,14 @@
 """Tests for the Open Responses client."""
 
+import httpx
 from pydantic import ValidationError
 import pytest
 
-from homeassistant.components.open_responses.client import _format_request_body
+from homeassistant.components.open_responses.client import (
+    OpenResponsesInvalidModelError,
+    _format_request_body,
+    _raise_client_error,
+)
 
 
 def test_format_request_body_preserves_tool_parameters() -> None:
@@ -47,3 +52,19 @@ def test_format_request_body_validates_response_body() -> None:
                 "stream": False,
             }
         )
+
+
+def test_raise_client_error_detects_invalid_model() -> None:
+    """Test model validation errors are separated from endpoint failures."""
+    response = httpx.Response(
+        400,
+        json={"error": {"message": "Unknown model", "param": "model"}},
+        request=httpx.Request("POST", "https://example.local/v1/responses"),
+    )
+
+    with pytest.raises(OpenResponsesInvalidModelError):
+        _raise_client_error(
+            httpx.HTTPStatusError(
+                "bad request", request=response.request, response=response
+            )
+        )