homeassistant 2025.7.0b8__py3-none-any.whl → 2025.7.0b9__py3-none-any.whl

homeassistant/components/ollama/conversation.py

@@ -2,41 +2,18 @@
 
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, AsyncIterator, Callable
-import json
-import logging
-from typing import Any, Literal
-
-import ollama
-from voluptuous_openapi import convert
+from typing import Literal
 
 from homeassistant.components import assist_pipeline, conversation
 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 device_registry as dr, intent, llm
+from homeassistant.helpers import intent
 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,
-    DOMAIN,
-)
-from .models import MessageHistory, MessageRole
-
-# Max number of back and forth with the LLM to generate a response
-MAX_TOOL_ITERATIONS = 10
-
-_LOGGER = logging.getLogger(__name__)
+from .const import CONF_PROMPT, DOMAIN
+from .entity import OllamaBaseLLMEntity
 
 
 async def async_setup_entry(
@@ -55,129 +32,10 @@ async def async_setup_entry(
         )
 
 
-def _format_tool(
-    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
-) -> dict[str, Any]:
-    """Format tool specification."""
-    tool_spec = {
-        "name": tool.name,
-        "parameters": convert(tool.parameters, custom_serializer=custom_serializer),
-    }
-    if tool.description:
-        tool_spec["description"] = tool.description
-    return {"type": "function", "function": tool_spec}
-
-
-def _fix_invalid_arguments(value: Any) -> Any:
-    """Attempt to repair incorrectly formatted json function arguments.
-
-    Small models (for example llama3.1 8B) may produce invalid argument values
-    which we attempt to repair here.
-    """
-    if not isinstance(value, str):
-        return value
-    if (value.startswith("[") and value.endswith("]")) or (
-        value.startswith("{") and value.endswith("}")
-    ):
-        try:
-            return json.loads(value)
-        except json.decoder.JSONDecodeError:
-            pass
-    return value
-
-
-def _parse_tool_args(arguments: dict[str, Any]) -> dict[str, Any]:
-    """Rewrite ollama tool arguments.
-
-    This function improves tool use quality by fixing common mistakes made by
-    small local tool use models. This will repair invalid json arguments and
-    omit unnecessary arguments with empty values that will fail intent parsing.
-    """
-    return {k: _fix_invalid_arguments(v) for k, v in arguments.items() if v}
-
-
-def _convert_content(
-    chat_content: (
-        conversation.Content
-        | conversation.ToolResultContent
-        | conversation.AssistantContent
-    ),
-) -> ollama.Message:
-    """Create tool response content."""
-    if isinstance(chat_content, conversation.ToolResultContent):
-        return ollama.Message(
-            role=MessageRole.TOOL.value,
-            content=json.dumps(chat_content.tool_result),
-        )
-    if isinstance(chat_content, conversation.AssistantContent):
-        return ollama.Message(
-            role=MessageRole.ASSISTANT.value,
-            content=chat_content.content,
-            tool_calls=[
-                ollama.Message.ToolCall(
-                    function=ollama.Message.ToolCall.Function(
-                        name=tool_call.tool_name,
-                        arguments=tool_call.tool_args,
-                    )
-                )
-                for tool_call in chat_content.tool_calls or ()
-            ],
-        )
-    if isinstance(chat_content, conversation.UserContent):
-        return ollama.Message(
-            role=MessageRole.USER.value,
-            content=chat_content.content,
-        )
-    if isinstance(chat_content, conversation.SystemContent):
-        return ollama.Message(
-            role=MessageRole.SYSTEM.value,
-            content=chat_content.content,
-        )
-    raise TypeError(f"Unexpected content type: {type(chat_content)}")
-
-
-async def _transform_stream(
-    result: AsyncIterator[ollama.ChatResponse],
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
-    """Transform the response stream into HA format.
-
-    An Ollama streaming response may come in chunks like this:
-
-    response: message=Message(role="assistant", content="Paris")
-    response: message=Message(role="assistant", content=".")
-    response: message=Message(role="assistant", content=""), done: True, done_reason: "stop"
-    response: message=Message(role="assistant", tool_calls=[...])
-    response: message=Message(role="assistant", content=""), done: True, done_reason: "stop"
-
-    This generator conforms to the chatlog delta stream expectations in that it
-    yields deltas, then the role only once the response is done.
-    """
-
-    new_msg = True
-    async for response in result:
-        _LOGGER.debug("Received response: %s", response)
-        response_message = response["message"]
-        chunk: conversation.AssistantContentDeltaDict = {}
-        if new_msg:
-            new_msg = False
-            chunk["role"] = "assistant"
-        if (tool_calls := response_message.get("tool_calls")) is not None:
-            chunk["tool_calls"] = [
-                llm.ToolInput(
-                    tool_name=tool_call["function"]["name"],
-                    tool_args=_parse_tool_args(tool_call["function"]["arguments"]),
-                )
-                for tool_call in tool_calls
-            ]
-        if (content := response_message.get("content")) is not None:
-            chunk["content"] = content
-        if response_message.get("done"):
-            new_msg = True
-        yield chunk
-
-
 class OllamaConversationEntity(
-    conversation.ConversationEntity, conversation.AbstractConversationAgent
+    conversation.ConversationEntity,
+    conversation.AbstractConversationAgent,
+    OllamaBaseLLMEntity,
 ):
     """Ollama conversation agent."""
 
@@ -185,17 +43,7 @@ class OllamaConversationEntity(
 
     def __init__(self, entry: OllamaConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""
-        self.entry = entry
-        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,
-        )
+        super().__init__(entry, subentry)
         if self.subentry.data.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
@@ -255,89 +103,6 @@ class OllamaConversationEntity(
             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 = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-        message_history: MessageHistory = MessageHistory(
-            [_convert_content(content) for content in chat_log.content]
-        )
-        max_messages = int(settings.get(CONF_MAX_HISTORY, DEFAULT_MAX_HISTORY))
-        self._trim_history(message_history, max_messages)
-
-        # Get response
-        # To prevent infinite loops, we limit the number of iterations
-        for _iteration in range(MAX_TOOL_ITERATIONS):
-            try:
-                response_generator = await client.chat(
-                    model=model,
-                    # Make a copy of the messages because we mutate the list later
-                    messages=list(message_history.messages),
-                    tools=tools,
-                    stream=True,
-                    # 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)
-                raise HomeAssistantError(
-                    f"Sorry, I had a problem talking to the Ollama server: {err}"
-                ) from err
-
-            message_history.messages.extend(
-                [
-                    _convert_content(content)
-                    async for content in chat_log.async_add_delta_content_stream(
-                        self.entity_id, _transform_stream(response_generator)
-                    )
-                ]
-            )
-
-            if not chat_log.unresponded_tool_results:
-                break
-
-    def _trim_history(self, message_history: MessageHistory, max_messages: int) -> None:
-        """Trims excess messages from a single history.
-
-        This sets the max history to allow a configurable size history may take
-        up in the context window.
-
-        Note that some messages in the history may not be from ollama only, and
-        may come from other anents, so the assumptions here may not strictly hold,
-        but generally should be effective.
-        """
-        if max_messages < 1:
-            # Keep all messages
-            return
-
-        # Ignore the in progress user message
-        num_previous_rounds = message_history.num_user_messages - 1
-        if num_previous_rounds >= max_messages:
-            # Trim history but keep system prompt (first message).
-            # Every other message should be an assistant message, so keep 2x
-            # message objects. Also keep the last in progress user message
-            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:],
-            ]
-
     async def _async_entry_update_listener(
         self, hass: HomeAssistant, entry: ConfigEntry
     ) -> None:

homeassistant/components/ollama/entity.py

@@ -0,0 +1,261 @@
+"""Base entity for the Ollama integration."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, AsyncIterator, Callable
+import json
+import logging
+from typing import Any
+
+import ollama
+from voluptuous_openapi import convert
+
+from homeassistant.components import conversation
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr, llm
+from homeassistant.helpers.entity import Entity
+
+from . import OllamaConfigEntry
+from .const import (
+    CONF_KEEP_ALIVE,
+    CONF_MAX_HISTORY,
+    CONF_MODEL,
+    CONF_NUM_CTX,
+    CONF_THINK,
+    DEFAULT_KEEP_ALIVE,
+    DEFAULT_MAX_HISTORY,
+    DEFAULT_NUM_CTX,
+    DOMAIN,
+)
+from .models import MessageHistory, MessageRole
+
+# Max number of back and forth with the LLM to generate a response
+MAX_TOOL_ITERATIONS = 10
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _format_tool(
+    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
+) -> dict[str, Any]:
+    """Format tool specification."""
+    tool_spec = {
+        "name": tool.name,
+        "parameters": convert(tool.parameters, custom_serializer=custom_serializer),
+    }
+    if tool.description:
+        tool_spec["description"] = tool.description
+    return {"type": "function", "function": tool_spec}
+
+
+def _fix_invalid_arguments(value: Any) -> Any:
+    """Attempt to repair incorrectly formatted json function arguments.
+
+    Small models (for example llama3.1 8B) may produce invalid argument values
+    which we attempt to repair here.
+    """
+    if not isinstance(value, str):
+        return value
+    if (value.startswith("[") and value.endswith("]")) or (
+        value.startswith("{") and value.endswith("}")
+    ):
+        try:
+            return json.loads(value)
+        except json.decoder.JSONDecodeError:
+            pass
+    return value
+
+
+def _parse_tool_args(arguments: dict[str, Any]) -> dict[str, Any]:
+    """Rewrite ollama tool arguments.
+
+    This function improves tool use quality by fixing common mistakes made by
+    small local tool use models. This will repair invalid json arguments and
+    omit unnecessary arguments with empty values that will fail intent parsing.
+    """
+    return {k: _fix_invalid_arguments(v) for k, v in arguments.items() if v}
+
+
+def _convert_content(
+    chat_content: (
+        conversation.Content
+        | conversation.ToolResultContent
+        | conversation.AssistantContent
+    ),
+) -> ollama.Message:
+    """Create tool response content."""
+    if isinstance(chat_content, conversation.ToolResultContent):
+        return ollama.Message(
+            role=MessageRole.TOOL.value,
+            content=json.dumps(chat_content.tool_result),
+        )
+    if isinstance(chat_content, conversation.AssistantContent):
+        return ollama.Message(
+            role=MessageRole.ASSISTANT.value,
+            content=chat_content.content,
+            tool_calls=[
+                ollama.Message.ToolCall(
+                    function=ollama.Message.ToolCall.Function(
+                        name=tool_call.tool_name,
+                        arguments=tool_call.tool_args,
+                    )
+                )
+                for tool_call in chat_content.tool_calls or ()
+            ],
+        )
+    if isinstance(chat_content, conversation.UserContent):
+        return ollama.Message(
+            role=MessageRole.USER.value,
+            content=chat_content.content,
+        )
+    if isinstance(chat_content, conversation.SystemContent):
+        return ollama.Message(
+            role=MessageRole.SYSTEM.value,
+            content=chat_content.content,
+        )
+    raise TypeError(f"Unexpected content type: {type(chat_content)}")
+
+
+async def _transform_stream(
+    result: AsyncIterator[ollama.ChatResponse],
+) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+    """Transform the response stream into HA format.
+
+    An Ollama streaming response may come in chunks like this:
+
+    response: message=Message(role="assistant", content="Paris")
+    response: message=Message(role="assistant", content=".")
+    response: message=Message(role="assistant", content=""), done: True, done_reason: "stop"
+    response: message=Message(role="assistant", tool_calls=[...])
+    response: message=Message(role="assistant", content=""), done: True, done_reason: "stop"
+
+    This generator conforms to the chatlog delta stream expectations in that it
+    yields deltas, then the role only once the response is done.
+    """
+
+    new_msg = True
+    async for response in result:
+        _LOGGER.debug("Received response: %s", response)
+        response_message = response["message"]
+        chunk: conversation.AssistantContentDeltaDict = {}
+        if new_msg:
+            new_msg = False
+            chunk["role"] = "assistant"
+        if (tool_calls := response_message.get("tool_calls")) is not None:
+            chunk["tool_calls"] = [
+                llm.ToolInput(
+                    tool_name=tool_call["function"]["name"],
+                    tool_args=_parse_tool_args(tool_call["function"]["arguments"]),
+                )
+                for tool_call in tool_calls
+            ]
+        if (content := response_message.get("content")) is not None:
+            chunk["content"] = content
+        if response_message.get("done"):
+            new_msg = True
+        yield chunk
+
+
+class OllamaBaseLLMEntity(Entity):
+    """Ollama base LLM entity."""
+
+    def __init__(self, entry: OllamaConfigEntry, subentry: ConfigSubentry) -> None:
+        """Initialize the entity."""
+        self.entry = entry
+        self.subentry = subentry
+        self._attr_name = subentry.title
+        self._attr_unique_id = subentry.subentry_id
+
+        model, _, version = subentry.data[CONF_MODEL].partition(":")
+        self._attr_device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, subentry.subentry_id)},
+            name=subentry.title,
+            manufacturer="Ollama",
+            model=model,
+            sw_version=version or "latest",
+            entry_type=dr.DeviceEntryType.SERVICE,
+        )
+
+    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 = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
+        message_history: MessageHistory = MessageHistory(
+            [_convert_content(content) for content in chat_log.content]
+        )
+        max_messages = int(settings.get(CONF_MAX_HISTORY, DEFAULT_MAX_HISTORY))
+        self._trim_history(message_history, max_messages)
+
+        # Get response
+        # To prevent infinite loops, we limit the number of iterations
+        for _iteration in range(MAX_TOOL_ITERATIONS):
+            try:
+                response_generator = await client.chat(
+                    model=model,
+                    # Make a copy of the messages because we mutate the list later
+                    messages=list(message_history.messages),
+                    tools=tools,
+                    stream=True,
+                    # 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)
+                raise HomeAssistantError(
+                    f"Sorry, I had a problem talking to the Ollama server: {err}"
+                ) from err
+
+            message_history.messages.extend(
+                [
+                    _convert_content(content)
+                    async for content in chat_log.async_add_delta_content_stream(
+                        self.entity_id, _transform_stream(response_generator)
+                    )
+                ]
+            )
+
+            if not chat_log.unresponded_tool_results:
+                break
+
+    def _trim_history(self, message_history: MessageHistory, max_messages: int) -> None:
+        """Trims excess messages from a single history.
+
+        This sets the max history to allow a configurable size history may take
+        up in the context window.
+
+        Note that some messages in the history may not be from ollama only, and
+        may come from other anents, so the assumptions here may not strictly hold,
+        but generally should be effective.
+        """
+        if max_messages < 1:
+            # Keep all messages
+            return
+
+        # Ignore the in progress user message
+        num_previous_rounds = message_history.num_user_messages - 1
+        if num_previous_rounds >= max_messages:
+            # Trim history but keep system prompt (first message).
+            # Every other message should be an assistant message, so keep 2x
+            # message objects. Also keep the last in progress user message
+            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:],
+            ]

homeassistant/components/ollama/strings.json

@@ -3,24 +3,17 @@
     "step": {
       "user": {
         "data": {
-          "url": "[%key:common::config_flow::data::url%]",
-          "model": "Model"
+          "url": "[%key:common::config_flow::data::url%]"
         }
-      },
-      "download": {
-        "title": "Downloading model"
       }
     },
     "abort": {
-      "download_failed": "Model downloading failed",
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
     },
     "error": {
+      "invalid_url": "[%key:common::config_flow::error::invalid_host%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "progress": {
-      "download": "Please wait while the model is downloaded, which may take a very long time. Check your Ollama server logs for more details."
     }
   },
   "config_subentries": {
@@ -33,6 +26,7 @@
       "step": {
         "set_options": {
           "data": {
+            "model": "Model",
             "name": "[%key:common::config_flow::data::name%]",
             "prompt": "Instructions",
             "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
@@ -47,11 +41,19 @@
             "num_ctx": "Maximum number of text tokens the model can process. Lower to reduce Ollama RAM, or increase for a large number of exposed entities.",
             "think": "If enabled, the LLM will think before responding. This can improve response quality but may increase latency."
           }
+        },
+        "download": {
+          "title": "Downloading model"
         }
       },
       "abort": {
         "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-        "entry_not_loaded": "Cannot add things while the configuration is disabled."
+        "entry_not_loaded": "Failed to add agent. The configuration is disabled.",
+        "download_failed": "Model downloading failed",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      },
+      "progress": {
+        "download": "Please wait while the model is downloaded, which may take a very long time. Check your Ollama server logs for more details."
       }
     }
   }

homeassistant/components/ollama/translations/bg.json

@@ -10,7 +10,6 @@
         "step": {
             "user": {
                 "data": {
-                    "model": "\u041c\u043e\u0434\u0435\u043b",
                     "url": "URL"
                 }
             }

homeassistant/components/ollama/translations/ca.json

@@ -1,22 +1,12 @@
 {
     "config": {
-        "abort": {
-            "download_failed": "Ha fallat la baixada del model"
-        },
         "error": {
             "cannot_connect": "Ha fallat la connexi\u00f3",
             "unknown": "Error inesperat"
         },
-        "progress": {
-            "download": "Espera mentre es baixa el model, aix\u00f2 pot trigar molt temps. Consulta els registres del teu servidor Ollama per a m\u00e9s detalls."
-        },
         "step": {
-            "download": {
-                "title": "Baixant model"
-            },
             "user": {
                 "data": {
-                    "model": "Model",
                     "url": "URL"
                 }
             }

homeassistant/components/ollama/translations/cs.json

@@ -1,23 +1,15 @@
 {
     "config": {
         "abort": {
-            "already_configured": "Slu\u017eba je ji\u017e nastavena",
-            "download_failed": "Sta\u017een\u00ed modelu se nezda\u0159ilo"
+            "already_configured": "Slu\u017eba je ji\u017e nastavena"
         },
         "error": {
             "cannot_connect": "Nepoda\u0159ilo se p\u0159ipojit",
             "unknown": "Neo\u010dek\u00e1van\u00e1 chyba"
         },
-        "progress": {
-            "download": "Po\u010dkejte, ne\u017e se model st\u00e1hne, co\u017e m\u016f\u017ee trvat velmi dlouho. Dal\u0161\u00ed podrobnosti naleznete v protokolech serveru Ollama."
-        },
         "step": {
-            "download": {
-                "title": "Stahov\u00e1n\u00ed modelu"
-            },
             "user": {
                 "data": {
-                    "model": "Model",
                     "url": "URL"
                 }
             }
@@ -26,7 +18,6 @@
     "config_subentries": {
         "conversation": {
             "abort": {
-                "entry_not_loaded": "Nelze p\u0159id\u00e1vat polo\u017eky, pokud je nastaven\u00ed zak\u00e1z\u00e1no.",
                 "reconfigure_successful": "P\u0159enastaven\u00ed bylo \u00fasp\u011b\u0161n\u00e9"
             },
             "entry_type": "Agent pro konverzaci",