homeassistant 2025.6.2__py3-none-any.whl → 2025.7.0b0__py3-none-any.whl

homeassistant/components/ollama/__init__.py

@@ -8,11 +8,16 @@ import logging
 import httpx
 import ollama
 
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import CONF_URL, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+)
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.ssl import get_default_context
 
 from .const import (
@@ -21,6 +26,7 @@ from .const import (
     CONF_MODEL,
     CONF_NUM_CTX,
     CONF_PROMPT,
+    CONF_THINK,
     DEFAULT_TIMEOUT,
     DOMAIN,
 )
@@ -33,6 +39,7 @@ __all__ = [
     "CONF_MODEL",
     "CONF_NUM_CTX",
     "CONF_PROMPT",
+    "CONF_THINK",
     "CONF_URL",
     "DOMAIN",
 ]
@@ -40,8 +47,16 @@ __all__ = [
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = (Platform.CONVERSATION,)
 
+type OllamaConfigEntry = ConfigEntry[ollama.AsyncClient]
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up Ollama."""
+    await async_migrate_integration(hass)
+    return True
+
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: OllamaConfigEntry) -> bool:
     """Set up Ollama from a config entry."""
     settings = {**entry.data, **entry.options}
     client = ollama.AsyncClient(host=settings[CONF_URL], verify=get_default_context())
@@ -51,8 +66,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     except (TimeoutError, httpx.ConnectError) as err:
         raise ConfigEntryNotReady(err) from err
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = client
-
+    entry.runtime_data = client
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
@@ -61,5 +75,69 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload Ollama."""
     if not await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
         return False
-    hass.data[DOMAIN].pop(entry.entry_id)
     return True
+
+
+async def async_migrate_integration(hass: HomeAssistant) -> None:
+    """Migrate integration entry structure."""
+
+    entries = hass.config_entries.async_entries(DOMAIN)
+    if not any(entry.version == 1 for entry in entries):
+        return
+
+    api_keys_entries: dict[str, ConfigEntry] = {}
+    entity_registry = er.async_get(hass)
+    device_registry = dr.async_get(hass)
+
+    for entry in entries:
+        use_existing = False
+        subentry = ConfigSubentry(
+            data=entry.options,
+            subentry_type="conversation",
+            title=entry.title,
+            unique_id=None,
+        )
+        if entry.data[CONF_URL] not in api_keys_entries:
+            use_existing = True
+            api_keys_entries[entry.data[CONF_URL]] = entry
+
+        parent_entry = api_keys_entries[entry.data[CONF_URL]]
+
+        hass.config_entries.async_add_subentry(parent_entry, subentry)
+        conversation_entity = entity_registry.async_get_entity_id(
+            "conversation",
+            DOMAIN,
+            entry.entry_id,
+        )
+        if conversation_entity is not None:
+            entity_registry.async_update_entity(
+                conversation_entity,
+                config_entry_id=parent_entry.entry_id,
+                config_subentry_id=subentry.subentry_id,
+                new_unique_id=subentry.subentry_id,
+            )
+
+        device = device_registry.async_get_device(
+            identifiers={(DOMAIN, entry.entry_id)}
+        )
+        if device is not None:
+            device_registry.async_update_device(
+                device.id,
+                new_identifiers={(DOMAIN, subentry.subentry_id)},
+                add_config_subentry_id=subentry.subentry_id,
+                add_config_entry_id=parent_entry.entry_id,
+            )
+            if parent_entry.entry_id != entry.entry_id:
+                device_registry.async_update_device(
+                    device.id,
+                    remove_config_entry_id=entry.entry_id,
+                )
+
+        if not use_existing:
+            await hass.config_entries.async_remove(entry.entry_id)
+        else:
+            hass.config_entries.async_update_entry(
+                entry,
+                options={},
+                version=2,
+            )

homeassistant/components/ollama/config_flow.py

@@ -14,14 +14,17 @@ import voluptuous as vol
 
 from homeassistant.config_entries import (
     ConfigEntry,
+    ConfigEntryState,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
 )
-from homeassistant.const import CONF_LLM_HASS_API, CONF_URL
-from homeassistant.core import HomeAssistant
+from homeassistant.const import CONF_LLM_HASS_API, CONF_NAME, CONF_URL
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import llm
 from homeassistant.helpers.selector import (
+    BooleanSelector,
     NumberSelector,
     NumberSelectorConfig,
     NumberSelectorMode,
@@ -41,10 +44,12 @@ from .const import (
     CONF_MODEL,
     CONF_NUM_CTX,
     CONF_PROMPT,
+    CONF_THINK,
     DEFAULT_KEEP_ALIVE,
     DEFAULT_MAX_HISTORY,
     DEFAULT_MODEL,
     DEFAULT_NUM_CTX,
+    DEFAULT_THINK,
     DEFAULT_TIMEOUT,
     DOMAIN,
     MAX_NUM_CTX,
@@ -67,7 +72,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ollama."""
 
-    VERSION = 1
+    VERSION = 2
 
     def __init__(self) -> None:
         """Initialize config flow."""
@@ -91,6 +96,8 @@ class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
 
         errors = {}
 
+        self._async_abort_entries_match({CONF_URL: self.url})
+
         try:
             self.client = ollama.AsyncClient(
                 host=self.url, verify=get_default_context()
@@ -143,8 +150,16 @@ class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
             return await self.async_step_download()
 
         return self.async_create_entry(
-            title=_get_title(self.model),
+            title=self.url,
             data={CONF_URL: self.url, CONF_MODEL: self.model},
+            subentries=[
+                {
+                    "subentry_type": "conversation",
+                    "data": {},
+                    "title": _get_title(self.model),
+                    "unique_id": None,
+                }
+            ],
         )
 
     async def async_step_download(
@@ -186,6 +201,14 @@ class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_create_entry(
             title=_get_title(self.model),
             data={CONF_URL: self.url, CONF_MODEL: self.model},
+            subentries=[
+                {
+                    "subentry_type": "conversation",
+                    "data": {},
+                    "title": _get_title(self.model),
+                    "unique_id": None,
+                }
+            ],
         )
 
     async def async_step_failed(
@@ -194,41 +217,62 @@ class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
         """Step after model downloading has failed."""
         return self.async_abort(reason="download_failed")
 
-    @staticmethod
-    def async_get_options_flow(
-        config_entry: ConfigEntry,
-    ) -> OptionsFlow:
-        """Create the options flow."""
-        return OllamaOptionsFlow(config_entry)
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this integration."""
+        return {"conversation": ConversationSubentryFlowHandler}
 
 
-class OllamaOptionsFlow(OptionsFlow):
-    """Ollama options flow."""
+class ConversationSubentryFlowHandler(ConfigSubentryFlow):
+    """Flow for managing conversation subentries."""
 
-    def __init__(self, config_entry: ConfigEntry) -> None:
-        """Initialize options flow."""
-        self.url: str = config_entry.data[CONF_URL]
-        self.model: str = config_entry.data[CONF_MODEL]
+    @property
+    def _is_new(self) -> bool:
+        """Return if this is a new subentry."""
+        return self.source == "user"
 
-    async def async_step_init(
+    async def async_step_set_options(
         self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Manage the options."""
-        if user_input is not None:
+    ) -> SubentryFlowResult:
+        """Set conversation options."""
+        # abort if entry is not loaded
+        if self._get_entry().state != ConfigEntryState.LOADED:
+            return self.async_abort(reason="entry_not_loaded")
+
+        errors: dict[str, str] = {}
+
+        if user_input is None:
+            if self._is_new:
+                options = {}
+            else:
+                options = self._get_reconfigure_subentry().data.copy()
+
+        elif self._is_new:
             return self.async_create_entry(
-                title=_get_title(self.model), data=user_input
+                title=user_input.pop(CONF_NAME),
+                data=user_input,
+            )
+        else:
+            return self.async_update_and_abort(
+                self._get_entry(),
+                self._get_reconfigure_subentry(),
+                data=user_input,
             )
 
-        options: Mapping[str, Any] = self.config_entry.options or {}
-        schema = ollama_config_option_schema(self.hass, options)
+        schema = ollama_config_option_schema(self.hass, self._is_new, options)
         return self.async_show_form(
-            step_id="init",
-            data_schema=vol.Schema(schema),
+            step_id="set_options", data_schema=vol.Schema(schema), errors=errors
         )
 
+    async_step_user = async_step_set_options
+    async_step_reconfigure = async_step_set_options
+
 
 def ollama_config_option_schema(
-    hass: HomeAssistant, options: Mapping[str, Any]
+    hass: HomeAssistant, is_new: bool, options: Mapping[str, Any]
 ) -> dict:
     """Ollama options schema."""
     hass_apis: list[SelectOptionDict] = [
@@ -239,48 +283,72 @@ def ollama_config_option_schema(
         for api in llm.async_get_apis(hass)
     ]
 
-    return {
-        vol.Optional(
-            CONF_PROMPT,
-            description={
-                "suggested_value": options.get(
-                    CONF_PROMPT, llm.DEFAULT_INSTRUCTIONS_PROMPT
+    if is_new:
+        schema: dict[vol.Required | vol.Optional, Any] = {
+            vol.Required(CONF_NAME, default="Ollama Conversation"): str,
+        }
+    else:
+        schema = {}
+
+    schema.update(
+        {
+            vol.Optional(
+                CONF_PROMPT,
+                description={
+                    "suggested_value": options.get(
+                        CONF_PROMPT, llm.DEFAULT_INSTRUCTIONS_PROMPT
+                    )
+                },
+            ): TemplateSelector(),
+            vol.Optional(
+                CONF_LLM_HASS_API,
+                description={"suggested_value": options.get(CONF_LLM_HASS_API)},
+            ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
+            vol.Optional(
+                CONF_NUM_CTX,
+                description={
+                    "suggested_value": options.get(CONF_NUM_CTX, DEFAULT_NUM_CTX)
+                },
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_NUM_CTX,
+                    max=MAX_NUM_CTX,
+                    step=1,
+                    mode=NumberSelectorMode.BOX,
                 )
-            },
-        ): TemplateSelector(),
-        vol.Optional(
-            CONF_LLM_HASS_API,
-            description={"suggested_value": options.get(CONF_LLM_HASS_API)},
-        ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
-        vol.Optional(
-            CONF_NUM_CTX,
-            description={"suggested_value": options.get(CONF_NUM_CTX, DEFAULT_NUM_CTX)},
-        ): NumberSelector(
-            NumberSelectorConfig(
-                min=MIN_NUM_CTX, max=MAX_NUM_CTX, step=1, mode=NumberSelectorMode.BOX
-            )
-        ),
-        vol.Optional(
-            CONF_MAX_HISTORY,
-            description={
-                "suggested_value": options.get(CONF_MAX_HISTORY, DEFAULT_MAX_HISTORY)
-            },
-        ): NumberSelector(
-            NumberSelectorConfig(
-                min=0, max=sys.maxsize, step=1, mode=NumberSelectorMode.BOX
-            )
-        ),
-        vol.Optional(
-            CONF_KEEP_ALIVE,
-            description={
-                "suggested_value": options.get(CONF_KEEP_ALIVE, DEFAULT_KEEP_ALIVE)
-            },
-        ): NumberSelector(
-            NumberSelectorConfig(
-                min=-1, max=sys.maxsize, step=1, mode=NumberSelectorMode.BOX
-            )
-        ),
-    }
+            ),
+            vol.Optional(
+                CONF_MAX_HISTORY,
+                description={
+                    "suggested_value": options.get(
+                        CONF_MAX_HISTORY, DEFAULT_MAX_HISTORY
+                    )
+                },
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=0, max=sys.maxsize, step=1, mode=NumberSelectorMode.BOX
+                )
+            ),
+            vol.Optional(
+                CONF_KEEP_ALIVE,
+                description={
+                    "suggested_value": options.get(CONF_KEEP_ALIVE, DEFAULT_KEEP_ALIVE)
+                },
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=-1, max=sys.maxsize, step=1, mode=NumberSelectorMode.BOX
+                )
+            ),
+            vol.Optional(
+                CONF_THINK,
+                description={
+                    "suggested_value": options.get("think", DEFAULT_THINK),
+                },
+            ): BooleanSelector(),
+        }
+    )
+
+    return schema
 
 
 def _get_title(model: str) -> str:

homeassistant/components/ollama/const.py

@@ -4,6 +4,7 @@ DOMAIN = "ollama"
 
 CONF_MODEL = "model"
 CONF_PROMPT = "prompt"
+CONF_THINK = "think"
 
 CONF_KEEP_ALIVE = "keep_alive"
 DEFAULT_KEEP_ALIVE = -1  # seconds. -1 = indefinite, 0 = never
@@ -15,6 +16,7 @@ CONF_NUM_CTX = "num_ctx"
 DEFAULT_NUM_CTX = 8192
 MIN_NUM_CTX = 2048
 MAX_NUM_CTX = 131072
+DEFAULT_THINK = False
 
 CONF_MAX_HISTORY = "max_history"
 DEFAULT_MAX_HISTORY = 20

homeassistant/components/ollama/conversation.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncGenerator, AsyncIterator, Callable
 import json
 import logging
 from typing import Any, Literal
@@ -11,19 +11,21 @@ import ollama
 from voluptuous_openapi import convert
 
 from homeassistant.components import assist_pipeline, conversation
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import intent, llm
+from homeassistant.helpers import device_registry as dr, intent, llm
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from . import OllamaConfigEntry
 from .const import (
     CONF_KEEP_ALIVE,
     CONF_MAX_HISTORY,
     CONF_MODEL,
     CONF_NUM_CTX,
     CONF_PROMPT,
+    CONF_THINK,
     DEFAULT_KEEP_ALIVE,
     DEFAULT_MAX_HISTORY,
     DEFAULT_NUM_CTX,
@@ -39,12 +41,18 @@ _LOGGER = logging.getLogger(__name__)
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: OllamaConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up conversation entities."""
-    agent = OllamaConversationEntity(config_entry)
-    async_add_entities([agent])
+    for subentry in config_entry.subentries.values():
+        if subentry.subentry_type != "conversation":
+            continue
+
+        async_add_entities(
+            [OllamaConversationEntity(config_entry, subentry)],
+            config_subentry_id=subentry.subentry_id,
+        )
 
 
 def _format_tool(
@@ -129,7 +137,7 @@ def _convert_content(
 
 
 async def _transform_stream(
-    result: AsyncGenerator[ollama.Message],
+    result: AsyncIterator[ollama.ChatResponse],
 ) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
     """Transform the response stream into HA format.
 
@@ -173,17 +181,22 @@ class OllamaConversationEntity(
 ):
     """Ollama conversation agent."""
 
-    _attr_has_entity_name = True
     _attr_supports_streaming = True
 
-    def __init__(self, entry: ConfigEntry) -> None:
+    def __init__(self, entry: OllamaConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""
         self.entry = entry
-
-        # conversation id -> message history
-        self._attr_name = entry.title
-        self._attr_unique_id = entry.entry_id
-        if self.entry.options.get(CONF_LLM_HASS_API):
+        self.subentry = subentry
+        self._attr_name = subentry.title
+        self._attr_unique_id = subentry.subentry_id
+        self._attr_device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, subentry.subentry_id)},
+            name=subentry.title,
+            manufacturer="Ollama",
+            model=entry.data[CONF_MODEL],
+            entry_type=dr.DeviceEntryType.SERVICE,
+        )
+        if self.subentry.data.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
             )
@@ -215,21 +228,43 @@ class OllamaConversationEntity(
         chat_log: conversation.ChatLog,
     ) -> conversation.ConversationResult:
         """Call the API."""
-        settings = {**self.entry.data, **self.entry.options}
-
-        client = self.hass.data[DOMAIN][self.entry.entry_id]
-        model = settings[CONF_MODEL]
+        settings = {**self.entry.data, **self.subentry.data}
 
         try:
-            await chat_log.async_update_llm_data(
-                DOMAIN,
-                user_input,
+            await chat_log.async_provide_llm_data(
+                user_input.as_llm_context(DOMAIN),
                 settings.get(CONF_LLM_HASS_API),
                 settings.get(CONF_PROMPT),
+                user_input.extra_system_prompt,
             )
         except conversation.ConverseError as err:
             return err.as_conversation_result()
 
+        await self._async_handle_chat_log(chat_log)
+
+        # Create intent response
+        intent_response = intent.IntentResponse(language=user_input.language)
+        if not isinstance(chat_log.content[-1], conversation.AssistantContent):
+            raise TypeError(
+                f"Unexpected last message type: {type(chat_log.content[-1])}"
+            )
+        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,
+        )
+
+    async def _async_handle_chat_log(
+        self,
+        chat_log: conversation.ChatLog,
+    ) -> None:
+        """Generate an answer for the chat log."""
+        settings = {**self.entry.data, **self.subentry.data}
+
+        client = self.entry.runtime_data
+        model = settings[CONF_MODEL]
+
         tools: list[dict[str, Any]] | None = None
         if chat_log.llm_api:
             tools = [
@@ -256,6 +291,7 @@ class OllamaConversationEntity(
                     # keep_alive requires specifying unit. In this case, seconds
                     keep_alive=f"{settings.get(CONF_KEEP_ALIVE, DEFAULT_KEEP_ALIVE)}s",
                     options={CONF_NUM_CTX: settings.get(CONF_NUM_CTX, DEFAULT_NUM_CTX)},
+                    think=settings.get(CONF_THINK),
                 )
             except (ollama.RequestError, ollama.ResponseError) as err:
                 _LOGGER.error("Unexpected error talking to Ollama server: %s", err)
@@ -267,7 +303,7 @@ class OllamaConversationEntity(
                 [
                     _convert_content(content)
                     async for content in chat_log.async_add_delta_content_stream(
-                        user_input.agent_id, _transform_stream(response_generator)
+                        self.entity_id, _transform_stream(response_generator)
                     )
                 ]
             )
@@ -275,19 +311,6 @@ class OllamaConversationEntity(
             if not chat_log.unresponded_tool_results:
                 break
 
-        # Create intent response
-        intent_response = intent.IntentResponse(language=user_input.language)
-        if not isinstance(chat_log.content[-1], conversation.AssistantContent):
-            raise TypeError(
-                f"Unexpected last message type: {type(chat_log.content[-1])}"
-            )
-        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,
-        )
-
     def _trim_history(self, message_history: MessageHistory, max_messages: int) -> None:
         """Trims excess messages from a single history.
 
@@ -311,8 +334,9 @@ class OllamaConversationEntity(
             num_keep = 2 * max_messages + 1
             drop_index = len(message_history.messages) - num_keep
             message_history.messages = [
-                message_history.messages[0]
-            ] + message_history.messages[drop_index:]
+                message_history.messages[0],
+                *message_history.messages[drop_index:],
+            ]
 
     async def _async_entry_update_listener(
         self, hass: HomeAssistant, entry: ConfigEntry

homeassistant/components/ollama/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ollama",
   "integration_type": "service",
   "iot_class": "local_polling",
-  "requirements": ["ollama==0.4.7"]
+  "requirements": ["ollama==0.5.1"]
 }