fix(open_responses): align integration with Responses API

Author: Komzpa

homeassistant/components/open_responses/__init__.py

@@ -5,7 +5,6 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.typing import ConfigType
@@ -15,15 +14,17 @@
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-type OpenAIConfigEntry = ConfigEntry[openai.AsyncClient]
+type OpenResponsesConfigEntry = ConfigEntry[openai.AsyncClient]
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Open Responses."""
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) -> bool:
+async def async_setup_entry(
+    hass: HomeAssistant, entry: OpenResponsesConfigEntry
+) -> bool:
     """Set up Open Responses from a config entry."""
     client = openai.AsyncOpenAI(
         api_key=entry.data[CONF_API_KEY],
@@ -34,13 +35,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) -> bo
     # Cache current platform data which gets added to each request (caching done by library)
     _ = await hass.async_add_executor_job(client.platform_headers)
 
-    try:
-        await client.models.list(timeout=10.0)
-    except openai.AuthenticationError as err:
-        raise ConfigEntryAuthFailed(err) from err
-    except openai.OpenAIError as err:
-        raise ConfigEntryNotReady(err) from err
-
     entry.runtime_data = client
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -50,11 +44,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) -> bo
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: OpenResponsesConfigEntry
+) -> bool:
     """Unload Open Responses."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def async_update_options(hass: HomeAssistant, entry: OpenAIConfigEntry) -> None:
+async def async_update_options(
+    hass: HomeAssistant, entry: OpenResponsesConfigEntry
+) -> None:
     """Update options."""
     await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/open_responses/ai_task.py

@@ -1,38 +1,28 @@
 """AI Task integration for Open Responses."""
 
-import base64
 from json import JSONDecodeError
 import logging
 from typing import TYPE_CHECKING
 
-from openai.types.responses.response_output_item import ImageGenerationCall
-
 from homeassistant.components import ai_task, conversation
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.json import json_loads
 
-from .const import (
-    CONF_CHAT_MODEL,
-    CONF_IMAGE_MODEL,
-    RECOMMENDED_CHAT_MODEL,
-    RECOMMENDED_IMAGE_MODEL,
-    UNSUPPORTED_IMAGE_MODELS,
-)
-from .entity import OpenAIBaseLLMEntity
+from .entity import OpenResponsesEntity
 
 if TYPE_CHECKING:
     from homeassistant.config_entries import ConfigSubentry
 
-    from . import OpenAIConfigEntry
+    from . import OpenResponsesConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: OpenAIConfigEntry,
+    config_entry: OpenResponsesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up AI Task entities."""
@@ -41,27 +31,26 @@ async def async_setup_entry(
             continue
 
         async_add_entities(
-            [OpenAITaskEntity(config_entry, subentry)],
+            [OpenResponsesTaskEntity(config_entry, subentry)],
             config_subentry_id=subentry.subentry_id,
         )
 
 
-class OpenAITaskEntity(
+class OpenResponsesTaskEntity(
     ai_task.AITaskEntity,
-    OpenAIBaseLLMEntity,
+    OpenResponsesEntity,
 ):
     """Open Responses AI Task entity."""
 
-    def __init__(self, entry: OpenAIConfigEntry, subentry: ConfigSubentry) -> None:
+    def __init__(
+        self, entry: OpenResponsesConfigEntry, subentry: ConfigSubentry
+    ) -> None:
         """Initialize the entity."""
         super().__init__(entry, subentry)
         self._attr_supported_features = (
             ai_task.AITaskEntityFeature.GENERATE_DATA
             | ai_task.AITaskEntityFeature.SUPPORT_ATTACHMENTS
         )
-        model = self.subentry.data.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-        if not model.startswith(tuple(UNSUPPORTED_IMAGE_MODELS)):
-            self._attr_supported_features |= ai_task.AITaskEntityFeature.GENERATE_IMAGE
 
     async def _async_generate_data(
         self,
@@ -101,56 +90,3 @@ async def _async_generate_data(
             conversation_id=chat_log.conversation_id,
             data=data,
         )
-
-    async def _async_generate_image(
-        self,
-        task: ai_task.GenImageTask,
-        chat_log: conversation.ChatLog,
-    ) -> ai_task.GenImageTaskResult:
-        """Handle a generate image task."""
-        await self._async_handle_chat_log(chat_log, task.name, force_image=True)
-
-        if not isinstance(chat_log.content[-1], conversation.AssistantContent):
-            raise HomeAssistantError(
-                "Last content in chat log is not an AssistantContent"
-            )
-
-        image_call: ImageGenerationCall | None = None
-        for content in reversed(chat_log.content):
-            if not isinstance(content, conversation.AssistantContent):
-                break
-            if isinstance(content.native, ImageGenerationCall):
-                if image_call is None or image_call.result is None:
-                    image_call = content.native
-                else:  # Remove image data from chat log to save memory
-                    content.native.result = None
-
-        if image_call is None or image_call.result is None:
-            raise HomeAssistantError("No image returned")
-
-        image_data = base64.b64decode(image_call.result)
-        image_call.result = None
-
-        if hasattr(image_call, "output_format") and (
-            output_format := image_call.output_format
-        ):
-            mime_type = f"image/{output_format}"
-        else:
-            mime_type = "image/png"
-
-        if hasattr(image_call, "size") and (size := image_call.size):
-            width, height = tuple(size.split("x"))
-        else:
-            width, height = None, None
-
-        return ai_task.GenImageTaskResult(
-            image_data=image_data,
-            conversation_id=chat_log.conversation_id,
-            mime_type=mime_type,
-            width=int(width) if width else None,
-            height=int(height) if height else None,
-            model=self.subentry.data.get(CONF_IMAGE_MODEL, RECOMMENDED_IMAGE_MODEL),
-            revised_prompt=image_call.revised_prompt
-            if hasattr(image_call, "revised_prompt")
-            else None,
-        )