Add OpenRouter integration (home-assistant#143098)

Author: joostlek

.strict-typing

@@ -377,6 +377,7 @@ homeassistant.components.onedrive.*
 homeassistant.components.onewire.*
 homeassistant.components.onkyo.*
 homeassistant.components.open_meteo.*
+homeassistant.components.open_router.*
 homeassistant.components.openai_conversation.*
 homeassistant.components.openexchangerates.*
 homeassistant.components.opensky.*

CODEOWNERS

@@ -0,0 +1,58 @@
+"""The OpenRouter integration."""
+
+from __future__ import annotations
+
+from openai import AsyncOpenAI, AuthenticationError, OpenAIError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers.httpx_client import get_async_client
+
+from .const import LOGGER
+
+PLATFORMS = [Platform.CONVERSATION]
+
+type OpenRouterConfigEntry = ConfigEntry[AsyncOpenAI]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: OpenRouterConfigEntry) -> bool:
+    """Set up OpenRouter from a config entry."""
+    client = AsyncOpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=entry.data[CONF_API_KEY],
+        http_client=get_async_client(hass),
+    )
+
+    # Cache current platform data which gets added to each request (caching done by library)
+    _ = await hass.async_add_executor_job(client.platform_headers)
+
+    try:
+        async for _ in client.with_options(timeout=10.0).models.list():
+            break
+    except AuthenticationError as err:
+        LOGGER.error("Invalid API key: %s", err)
+        raise ConfigEntryError("Invalid API key") from err
+    except OpenAIError as err:
+        raise ConfigEntryNotReady(err) from err
+
+    entry.runtime_data = client
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
+
+    return True
+
+
+async def _async_update_listener(
+    hass: HomeAssistant, entry: OpenRouterConfigEntry
+) -> None:
+    """Handle update."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: OpenRouterConfigEntry) -> bool:
+    """Unload OpenRouter."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/open_router/__init__.py

@@ -0,0 +1,118 @@
+"""Config flow for OpenRouter integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from openai import AsyncOpenAI
+from python_open_router import OpenRouterClient, OpenRouterError
+import voluptuous as vol
+
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
+)
+from homeassistant.const import CONF_API_KEY, CONF_MODEL
+from homeassistant.core import callback
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class OpenRouterConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for OpenRouter."""
+
+    VERSION = 1
+
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this handler."""
+        return {"conversation": ConversationFlowHandler}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            self._async_abort_entries_match(user_input)
+            client = OpenRouterClient(
+                user_input[CONF_API_KEY], async_get_clientsession(self.hass)
+            )
+            try:
+                await client.get_key_data()
+            except OpenRouterError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_create_entry(
+                    title="OpenRouter",
+                    data=user_input,
+                )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_API_KEY): str,
+                }
+            ),
+            errors=errors,
+        )
+
+
+class ConversationFlowHandler(ConfigSubentryFlow):
+    """Handle subentry flow."""
+
+    def __init__(self) -> None:
+        """Initialize the subentry flow."""
+        self.options: dict[str, str] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """User flow to create a sensor subentry."""
+        if user_input is not None:
+            return self.async_create_entry(
+                title=self.options[user_input[CONF_MODEL]], data=user_input
+            )
+        entry = self._get_entry()
+        client = AsyncOpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=entry.data[CONF_API_KEY],
+            http_client=get_async_client(self.hass),
+        )
+        options = []
+        async for model in client.with_options(timeout=10.0).models.list():
+            options.append(SelectOptionDict(value=model.id, label=model.name))  # type: ignore[attr-defined]
+            self.options[model.id] = model.name  # type: ignore[attr-defined]
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_MODEL): SelectSelector(
+                        SelectSelectorConfig(
+                            options=options, mode=SelectSelectorMode.DROPDOWN, sort=True
+                        ),
+                    ),
+                }
+            ),
+        )

homeassistant/components/open_router/config_flow.py

@@ -0,0 +1,6 @@
+"""Constants for the OpenRouter integration."""
+
+import logging
+
+DOMAIN = "open_router"
+LOGGER = logging.getLogger(__package__)

homeassistant/components/open_router/const.py

@@ -0,0 +1,133 @@
+"""Conversation support for OpenRouter."""
+
+from typing import Literal
+
+import openai
+from openai.types.chat import (
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionUserMessageParam,
+)
+
+from homeassistant.components import conversation
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_LLM_HASS_API, CONF_MODEL, MATCH_ALL
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import intent
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import OpenRouterConfigEntry
+from .const import DOMAIN, LOGGER
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: OpenRouterConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up conversation entities."""
+    for subentry_id, subentry in config_entry.subentries.items():
+        async_add_entities(
+            [OpenRouterConversationEntity(config_entry, subentry)],
+            config_subentry_id=subentry_id,
+        )
+
+
+def _convert_content_to_chat_message(
+    content: conversation.Content,
+) -> ChatCompletionMessageParam | None:
+    """Convert any native chat message for this agent to the native format."""
+    LOGGER.debug("_convert_content_to_chat_message=%s", content)
+    if isinstance(content, conversation.ToolResultContent):
+        return None
+
+    role: Literal["user", "assistant", "system"] = content.role
+    if role == "system" and content.content:
+        return ChatCompletionSystemMessageParam(role="system", content=content.content)
+
+    if role == "user" and content.content:
+        return ChatCompletionUserMessageParam(role="user", content=content.content)
+
+    if role == "assistant":
+        return ChatCompletionAssistantMessageParam(
+            role="assistant", content=content.content
+        )
+    LOGGER.warning("Could not convert message to Completions API: %s", content)
+    return None
+
+
+class OpenRouterConversationEntity(conversation.ConversationEntity):
+    """OpenRouter conversation agent."""
+
+    def __init__(self, entry: OpenRouterConfigEntry, subentry: ConfigSubentry) -> None:
+        """Initialize the agent."""
+        self.entry = entry
+        self.subentry = subentry
+        self.model = subentry.data[CONF_MODEL]
+        self._attr_name = subentry.title
+        self._attr_unique_id = subentry.subentry_id
+
+    @property
+    def supported_languages(self) -> list[str] | Literal["*"]:
+        """Return a list of supported languages."""
+        return MATCH_ALL
+
+    async def _async_handle_message(
+        self,
+        user_input: conversation.ConversationInput,
+        chat_log: conversation.ChatLog,
+    ) -> conversation.ConversationResult:
+        """Process a sentence."""
+        options = self.subentry.data
+
+        try:
+            await chat_log.async_provide_llm_data(
+                user_input.as_llm_context(DOMAIN),
+                options.get(CONF_LLM_HASS_API),
+                None,
+                user_input.extra_system_prompt,
+            )
+        except conversation.ConverseError as err:
+            return err.as_conversation_result()
+
+        messages = [
+            m
+            for content in chat_log.content
+            if (m := _convert_content_to_chat_message(content))
+        ]
+
+        client = self.entry.runtime_data
+
+        try:
+            result = await client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                user=chat_log.conversation_id,
+                extra_headers={
+                    "X-Title": "Home Assistant",
+                    "HTTP-Referer": "https://www.home-assistant.io/integrations/open_router",
+                },
+            )
+        except openai.OpenAIError as err:
+            LOGGER.error("Error talking to API: %s", err)
+            raise HomeAssistantError("Error talking to API") from err
+
+        result_message = result.choices[0].message
+
+        chat_log.async_add_assistant_content_without_tools(
+            conversation.AssistantContent(
+                agent_id=user_input.agent_id,
+                content=result_message.content,
+            )
+        )
+
+        intent_response = intent.IntentResponse(language=user_input.language)
+        assert type(chat_log.content[-1]) is conversation.AssistantContent
+        intent_response.async_set_speech(chat_log.content[-1].content or "")
+        return conversation.ConversationResult(
+            response=intent_response,
+            conversation_id=chat_log.conversation_id,
+            continue_conversation=chat_log.continue_conversation,
+        )

homeassistant/components/open_router/conversation.py

@@ -0,0 +1,13 @@
+{
+  "domain": "open_router",
+  "name": "OpenRouter",
+  "after_dependencies": ["assist_pipeline", "intent"],
+  "codeowners": ["@joostlek"],
+  "config_flow": true,
+  "dependencies": ["conversation"],
+  "documentation": "https://www.home-assistant.io/integrations/open_router",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["openai==1.93.3", "python-open-router==0.2.0"]
+}