homeassistant 2025.8.3__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

homeassistant/components/openai_conversation/__init__.py

@@ -320,9 +320,9 @@ async def async_migrate_integration(hass: HomeAssistant) -> None:
                 entity_disabled_by is er.RegistryEntryDisabler.CONFIG_ENTRY
                 and not all_disabled
             ):
-                # Device and entity registries don't update the disabled_by flag
-                # when moving a device or entity from one config entry to another,
-                # so we need to do it manually.
+                # Device and entity registries will set the disabled_by flag to None
+                # when moving a device or entity disabled by CONFIG_ENTRY to an enabled
+                # config entry, but we want to set it to DEVICE or USER instead,
                 entity_disabled_by = (
                     er.RegistryEntryDisabler.DEVICE
                     if device
@@ -337,9 +337,9 @@ async def async_migrate_integration(hass: HomeAssistant) -> None:
             )
 
         if device is not None:
-            # Device and entity registries don't update the disabled_by flag when
-            # moving a device or entity from one config entry to another, so we
-            # need to do it manually.
+            # Device and entity registries will set the disabled_by flag to None
+            # when moving a device or entity disabled by CONFIG_ENTRY to an enabled
+            # config entry, but we want to set it to USER instead,
             device_disabled_by = device.disabled_by
             if (
                 device.disabled_by is dr.DeviceEntryDisabler.CONFIG_ENTRY

homeassistant/components/openai_conversation/entity.py

@@ -3,17 +3,18 @@
 from __future__ import annotations
 
 import base64
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncGenerator, Callable, Iterable
 import json
 from mimetypes import guess_file_type
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal
 
 import openai
 from openai._streaming import AsyncStream
 from openai.types.responses import (
     EasyInputMessageParam,
     FunctionToolParam,
+    ResponseCodeInterpreterToolCall,
     ResponseCompletedEvent,
     ResponseErrorEvent,
     ResponseFailedEvent,
@@ -21,6 +22,8 @@ from openai.types.responses import (
     ResponseFunctionCallArgumentsDoneEvent,
     ResponseFunctionToolCall,
     ResponseFunctionToolCallParam,
+    ResponseFunctionWebSearch,
+    ResponseFunctionWebSearchParam,
     ResponseIncompleteEvent,
     ResponseInputFileParam,
     ResponseInputImageParam,
@@ -29,14 +32,15 @@ from openai.types.responses import (
     ResponseOutputItemAddedEvent,
     ResponseOutputItemDoneEvent,
     ResponseOutputMessage,
-    ResponseOutputMessageParam,
     ResponseReasoningItem,
     ResponseReasoningItemParam,
+    ResponseReasoningSummaryTextDeltaEvent,
     ResponseStreamEvent,
     ResponseTextDeltaEvent,
     ToolParam,
     WebSearchToolParam,
 )
+from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
 from openai.types.responses.response_input_param import FunctionCallOutput
 from openai.types.responses.tool_param import (
     CodeInterpreter,
@@ -143,70 +147,198 @@ def _format_tool(
 
 
 def _convert_content_to_param(
-    content: conversation.Content,
+    chat_content: Iterable[conversation.Content],
 ) -> ResponseInputParam:
     """Convert any native chat message for this agent to the native format."""
     messages: ResponseInputParam = []
-    if isinstance(content, conversation.ToolResultContent):
-        return [
-            FunctionCallOutput(
-                type="function_call_output",
-                call_id=content.tool_call_id,
-                output=json.dumps(content.tool_result),
-            )
-        ]
-
-    if content.content:
-        role: Literal["user", "assistant", "system", "developer"] = content.role
-        if role == "system":
-            role = "developer"
-        messages.append(
-            EasyInputMessageParam(type="message", role=role, content=content.content)
-        )
+    reasoning_summary: list[str] = []
+    web_search_calls: dict[str, ResponseFunctionWebSearchParam] = {}
 
-    if isinstance(content, conversation.AssistantContent) and content.tool_calls:
-        messages.extend(
-            ResponseFunctionToolCallParam(
-                type="function_call",
-                name=tool_call.tool_name,
-                arguments=json.dumps(tool_call.tool_args),
-                call_id=tool_call.id,
+    for content in chat_content:
+        if isinstance(content, conversation.ToolResultContent):
+            if (
+                content.tool_name == "web_search_call"
+                and content.tool_call_id in web_search_calls
+            ):
+                web_search_call = web_search_calls.pop(content.tool_call_id)
+                web_search_call["status"] = content.tool_result.get(  # type: ignore[typeddict-item]
+                    "status", "completed"
+                )
+                messages.append(web_search_call)
+            else:
+                messages.append(
+                    FunctionCallOutput(
+                        type="function_call_output",
+                        call_id=content.tool_call_id,
+                        output=json.dumps(content.tool_result),
+                    )
+                )
+            continue
+
+        if content.content:
+            role: Literal["user", "assistant", "system", "developer"] = content.role
+            if role == "system":
+                role = "developer"
+            messages.append(
+                EasyInputMessageParam(
+                    type="message", role=role, content=content.content
+                )
             )
-            for tool_call in content.tool_calls
-        )
+
+        if isinstance(content, conversation.AssistantContent):
+            if content.tool_calls:
+                for tool_call in content.tool_calls:
+                    if (
+                        tool_call.external
+                        and tool_call.tool_name == "web_search_call"
+                        and "action" in tool_call.tool_args
+                    ):
+                        web_search_calls[tool_call.id] = ResponseFunctionWebSearchParam(
+                            type="web_search_call",
+                            id=tool_call.id,
+                            action=tool_call.tool_args["action"],
+                            status="completed",
+                        )
+                    else:
+                        messages.append(
+                            ResponseFunctionToolCallParam(
+                                type="function_call",
+                                name=tool_call.tool_name,
+                                arguments=json.dumps(tool_call.tool_args),
+                                call_id=tool_call.id,
+                            )
+                        )
+
+            if content.thinking_content:
+                reasoning_summary.append(content.thinking_content)
+
+            if isinstance(content.native, ResponseReasoningItem):
+                messages.append(
+                    ResponseReasoningItemParam(
+                        type="reasoning",
+                        id=content.native.id,
+                        summary=[
+                            {
+                                "type": "summary_text",
+                                "text": summary,
+                            }
+                            for summary in reasoning_summary
+                        ]
+                        if content.thinking_content
+                        else [],
+                        encrypted_content=content.native.encrypted_content,
+                    )
+                )
+                reasoning_summary = []
+
     return messages
 
 
 async def _transform_stream(
     chat_log: conversation.ChatLog,
-    result: AsyncStream[ResponseStreamEvent],
-    messages: ResponseInputParam,
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+    stream: AsyncStream[ResponseStreamEvent],
+) -> AsyncGenerator[
+    conversation.AssistantContentDeltaDict | conversation.ToolResultContentDeltaDict
+]:
     """Transform an OpenAI delta stream into HA format."""
-    async for event in result:
+    last_summary_index = None
+    last_role: Literal["assistant", "tool_result"] | None = None
+
+    async for event in stream:
         LOGGER.debug("Received event: %s", event)
 
         if isinstance(event, ResponseOutputItemAddedEvent):
-            if isinstance(event.item, ResponseOutputMessage):
-                yield {"role": event.item.role}
-            elif isinstance(event.item, ResponseFunctionToolCall):
+            if isinstance(event.item, ResponseFunctionToolCall):
                 # OpenAI has tool calls as individual events
                 # while HA puts tool calls inside the assistant message.
                 # We turn them into individual assistant content for HA
                 # to ensure that tools are called as soon as possible.
                 yield {"role": "assistant"}
+                last_role = "assistant"
+                last_summary_index = None
                 current_tool_call = event.item
+            elif (
+                isinstance(event.item, ResponseOutputMessage)
+                or (
+                    isinstance(event.item, ResponseReasoningItem)
+                    and last_summary_index is not None
+                )  # Subsequent ResponseReasoningItem
+                or last_role != "assistant"
+            ):
+                yield {"role": "assistant"}
+                last_role = "assistant"
+                last_summary_index = None
         elif isinstance(event, ResponseOutputItemDoneEvent):
-            item = event.item.model_dump()
-            item.pop("status", None)
             if isinstance(event.item, ResponseReasoningItem):
-                messages.append(cast(ResponseReasoningItemParam, item))
-            elif isinstance(event.item, ResponseOutputMessage):
-                messages.append(cast(ResponseOutputMessageParam, item))
-            elif isinstance(event.item, ResponseFunctionToolCall):
-                messages.append(cast(ResponseFunctionToolCallParam, item))
+                yield {
+                    "native": ResponseReasoningItem(
+                        type="reasoning",
+                        id=event.item.id,
+                        summary=[],  # Remove summaries
+                        encrypted_content=event.item.encrypted_content,
+                    )
+                }
+                last_summary_index = len(event.item.summary) - 1
+            elif isinstance(event.item, ResponseCodeInterpreterToolCall):
+                yield {
+                    "tool_calls": [
+                        llm.ToolInput(
+                            id=event.item.id,
+                            tool_name="code_interpreter",
+                            tool_args={
+                                "code": event.item.code,
+                                "container": event.item.container_id,
+                            },
+                            external=True,
+                        )
+                    ]
+                }
+                yield {
+                    "role": "tool_result",
+                    "tool_call_id": event.item.id,
+                    "tool_name": "code_interpreter",
+                    "tool_result": {
+                        "output": [output.to_dict() for output in event.item.outputs]  # type: ignore[misc]
+                        if event.item.outputs is not None
+                        else None
+                    },
+                }
+                last_role = "tool_result"
+            elif isinstance(event.item, ResponseFunctionWebSearch):
+                yield {
+                    "tool_calls": [
+                        llm.ToolInput(
+                            id=event.item.id,
+                            tool_name="web_search_call",
+                            tool_args={
+                                "action": event.item.action.to_dict(),
+                            },
+                            external=True,
+                        )
+                    ]
+                }
+                yield {
+                    "role": "tool_result",
+                    "tool_call_id": event.item.id,
+                    "tool_name": "web_search_call",
+                    "tool_result": {"status": event.item.status},
+                }
+                last_role = "tool_result"
         elif isinstance(event, ResponseTextDeltaEvent):
             yield {"content": event.delta}
+        elif isinstance(event, ResponseReasoningSummaryTextDeltaEvent):
+            # OpenAI can output several reasoning summaries
+            # in a single ResponseReasoningItem. We split them as separate
+            # AssistantContent messages. Only last of them will have
+            # the reasoning `native` field set.
+            if (
+                last_summary_index is not None
+                and event.summary_index != last_summary_index
+            ):
+                yield {"role": "assistant"}
+                last_role = "assistant"
+            last_summary_index = event.summary_index
+            yield {"thinking_content": event.delta}
         elif isinstance(event, ResponseFunctionCallArgumentsDeltaEvent):
             current_tool_call.arguments += event.delta
         elif isinstance(event, ResponseFunctionCallArgumentsDoneEvent):
@@ -301,6 +433,33 @@ class OpenAIBaseLLMEntity(Entity):
         """Generate an answer for the chat log."""
         options = self.subentry.data
 
+        messages = _convert_content_to_param(chat_log.content)
+
+        model_args = ResponseCreateParamsStreaming(
+            model=options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL),
+            input=messages,
+            max_output_tokens=options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
+            top_p=options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
+            temperature=options.get(CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE),
+            user=chat_log.conversation_id,
+            store=False,
+            stream=True,
+        )
+
+        if model_args["model"].startswith(("o", "gpt-5")):
+            model_args["reasoning"] = {
+                "effort": options.get(
+                    CONF_REASONING_EFFORT, RECOMMENDED_REASONING_EFFORT
+                ),
+                "summary": "auto",
+            }
+            model_args["include"] = ["reasoning.encrypted_content"]
+
+        if model_args["model"].startswith("gpt-5"):
+            model_args["text"] = {
+                "verbosity": options.get(CONF_VERBOSITY, RECOMMENDED_VERBOSITY)
+            }
+
         tools: list[ToolParam] = []
         if chat_log.llm_api:
             tools = [
@@ -334,39 +493,11 @@ class OpenAIBaseLLMEntity(Entity):
                     ),
                 )
             )
+            model_args.setdefault("include", []).append("code_interpreter_call.outputs")  # type: ignore[union-attr]
 
-        model_args = {
-            "model": options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL),
-            "input": [],
-            "max_output_tokens": options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
-            "top_p": options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
-            "temperature": options.get(CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE),
-            "user": chat_log.conversation_id,
-            "store": False,
-            "stream": True,
-        }
         if tools:
             model_args["tools"] = tools
 
-        if model_args["model"].startswith(("o", "gpt-5")):
-            model_args["reasoning"] = {
-                "effort": options.get(
-                    CONF_REASONING_EFFORT, RECOMMENDED_REASONING_EFFORT
-                )
-            }
-            model_args["include"] = ["reasoning.encrypted_content"]
-
-        if model_args["model"].startswith("gpt-5"):
-            model_args["text"] = {
-                "verbosity": options.get(CONF_VERBOSITY, RECOMMENDED_VERBOSITY)
-            }
-
-        messages = [
-            m
-            for content in chat_log.content
-            for m in _convert_content_to_param(content)
-        ]
-
         last_content = chat_log.content[-1]
 
         # Handle attachments by adding them to the last user message
@@ -399,16 +530,19 @@ class OpenAIBaseLLMEntity(Entity):
 
         # To prevent infinite loops, we limit the number of iterations
         for _iteration in range(MAX_TOOL_ITERATIONS):
-            model_args["input"] = messages
-
             try:
-                result = await client.responses.create(**model_args)
-
-                async for content in chat_log.async_add_delta_content_stream(
-                    self.entity_id, _transform_stream(chat_log, result, messages)
-                ):
-                    if not isinstance(content, conversation.AssistantContent):
-                        messages.extend(_convert_content_to_param(content))
+                stream = await client.responses.create(**model_args)
+
+                messages.extend(
+                    _convert_content_to_param(
+                        [
+                            content
+                            async for content in chat_log.async_add_delta_content_stream(
+                                self.entity_id, _transform_stream(chat_log, stream)
+                            )
+                        ]
+                    )
+                )
             except openai.RateLimitError as err:
                 LOGGER.error("Rate limited by OpenAI: %s", err)
                 raise HomeAssistantError("Rate limited or insufficient funds") from err

homeassistant/components/openai_conversation/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/openai_conversation",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["openai==1.93.3"]
+  "requirements": ["openai==1.99.5"]
 }

homeassistant/components/openai_conversation/translations/cs.json

@@ -22,13 +22,13 @@
                 "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": "\u00daloha AI",
+            "entry_type": "\u00dakol AI",
             "error": {
                 "model_not_supported": "Tento model nen\u00ed podporov\u00e1n, vyberte jin\u00fd model"
             },
             "initiate_flow": {
-                "reconfigure": "P\u0159enastavit \u00falohu AI",
-                "user": "P\u0159idat \u00falohu AI"
+                "reconfigure": "P\u0159enastavit \u00fakol AI",
+                "user": "P\u0159idat \u00fakol AI"
             },
             "step": {
                 "advanced": {

homeassistant/components/openai_conversation/translations/it.json

@@ -146,9 +146,17 @@
                     "example": "Una foto di un cane",
                     "name": "Prompt"
                 },
+                "quality": {
+                    "description": "La qualit\u00e0 dell'immagine che verr\u00e0 generata",
+                    "name": "Qualit\u00e0"
+                },
                 "size": {
                     "description": "La dimensione dell'immagine da generare",
                     "name": "Dimensione"
+                },
+                "style": {
+                    "description": "Lo stile dell'immagine generata",
+                    "name": "Stile"
                 }
             },
             "name": "Genera immagine"

homeassistant/components/openhome/media_player.py

@@ -48,7 +48,7 @@ async def async_setup_entry(
 
     device = hass.data[DOMAIN][config_entry.entry_id]
 
-    entity = OpenhomeDevice(hass, device)
+    entity = OpenhomeDevice(device)
 
     async_add_entities([entity])
 
@@ -100,9 +100,8 @@ class OpenhomeDevice(MediaPlayerEntity):
     _attr_state = MediaPlayerState.PLAYING
     _attr_available = True
 
-    def __init__(self, hass, device):
+    def __init__(self, device):
         """Initialise the Openhome device."""
-        self.hass = hass
         self._device = device
         self._attr_unique_id = device.uuid()
         self._source_index = {}

homeassistant/components/opentherm_gw/translations/it.json

@@ -7,6 +7,7 @@
         "error": {
             "already_configured": "Il dispositivo \u00e8 gi\u00e0 configurato",
             "cannot_connect": "Impossibile connettersi",
+            "id_exists": "L'ID del gateway esiste gi\u00e0",
             "timeout_connect": "Tempo scaduto per stabile la connessione."
         },
         "step": {

homeassistant/components/openweathermap/sensor.py

@@ -51,6 +51,7 @@ from .const import (
     ATTR_API_WEATHER,
     ATTR_API_WEATHER_CODE,
     ATTR_API_WIND_BEARING,
+    ATTR_API_WIND_GUST,
     ATTR_API_WIND_SPEED,
     ATTRIBUTION,
     DOMAIN,
@@ -93,6 +94,13 @@ WEATHER_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.WIND_SPEED,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    SensorEntityDescription(
+        key=ATTR_API_WIND_GUST,
+        name="Wind gust",
+        native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
+        device_class=SensorDeviceClass.WIND_SPEED,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     SensorEntityDescription(
         key=ATTR_API_WIND_BEARING,
         name="Wind bearing",

homeassistant/components/opower/__init__.py

@@ -2,9 +2,13 @@
 
 from __future__ import annotations
 
+from opower import select_utility
+
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import issue_registry as ir
 
+from .const import CONF_UTILITY, DOMAIN
 from .coordinator import OpowerConfigEntry, OpowerCoordinator
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
@@ -12,6 +16,25 @@ PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 async def async_setup_entry(hass: HomeAssistant, entry: OpowerConfigEntry) -> bool:
     """Set up Opower from a config entry."""
+    utility_name = entry.data[CONF_UTILITY]
+    try:
+        select_utility(utility_name)
+    except ValueError:
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            f"unsupported_utility_{entry.entry_id}",
+            is_fixable=True,
+            severity=ir.IssueSeverity.ERROR,
+            translation_key="unsupported_utility",
+            translation_placeholders={"utility": utility_name},
+            data={
+                "entry_id": entry.entry_id,
+                "utility": utility_name,
+                "title": entry.title,
+            },
+        )
+        return False
 
     coordinator = OpowerCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()

homeassistant/components/opower/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/opower",
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
-  "requirements": ["opower==0.15.2"]
+  "requirements": ["opower==0.15.3"]
 }

homeassistant/components/opower/repairs.py

@@ -0,0 +1,44 @@
+"""Repairs for Opower."""
+
+from __future__ import annotations
+
+from homeassistant.components.repairs import RepairsFlow
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResult
+
+
+class UnsupportedUtilityFixFlow(RepairsFlow):
+    """Handler for removing a configuration entry that uses an unsupported utility."""
+
+    def __init__(self, data: dict[str, str]) -> None:
+        """Initialize."""
+        self._entry_id = data["entry_id"]
+        self._placeholders = data.copy()
+        self._placeholders.pop("entry_id")
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> FlowResult:
+        """Handle the first step of a fix flow."""
+        return await self.async_step_confirm()
+
+    async def async_step_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> FlowResult:
+        """Handle the confirm step of a fix flow."""
+        if user_input is not None:
+            await self.hass.config_entries.async_remove(self._entry_id)
+            return self.async_create_entry(title="", data={})
+
+        return self.async_show_form(
+            step_id="confirm", description_placeholders=self._placeholders
+        )
+
+
+async def async_create_fix_flow(
+    hass: HomeAssistant, issue_id: str, data: dict[str, str] | None
+) -> RepairsFlow:
+    """Create flow."""
+    assert issue_id.startswith("unsupported_utility")
+    assert data
+    return UnsupportedUtilityFixFlow(data)

homeassistant/components/opower/strings.json

@@ -10,7 +10,7 @@
         }
       },
       "credentials": {
-        "title": "Enter Credentials",
+        "title": "Enter credentials",
         "data": {
           "username": "[%key:common::config_flow::data::username%]",
           "password": "[%key:common::config_flow::data::password%]",
@@ -34,7 +34,7 @@
       },
       "mfa_code": {
         "title": "Enter security code",
-        "description": "A security code has been sent via your selected method. Please enter it below to complete login.",
+        "description": "Please enter the security code below to complete login.",
         "data": {
           "mfa_code": "Security code"
         },
@@ -70,6 +70,17 @@
     "return_to_grid_migration": {
       "title": "Return to grid statistics for account: {utility_account_id}",
       "description": "We found negative values in your existing consumption statistics, likely because you have solar. We split those in separate return statistics for a better experience in the Energy dashboard.\n\nPlease visit the [Energy configuration page]({energy_settings}) to add the following statistics in the **Return to grid** section:\n\n{target_ids}\n\nOnce you have added them, ignore this issue."
+    },
+    "unsupported_utility": {
+      "title": "Unsupported utility: {utility}",
+      "fix_flow": {
+        "step": {
+          "confirm": {
+            "title": "[%key:component::opower::issues::unsupported_utility::title%]",
+            "description": "The utility `{utility}` used by entry `{title}` is no longer supported by the Opower integration. Select **Submit** to remove this integration entry now."
+          }
+        }
+      }
     }
   },
   "entity": {

homeassistant/components/opower/translations/cs.json

@@ -122,6 +122,17 @@
         "return_to_grid_migration": {
             "description": "Ve va\u0161ich st\u00e1vaj\u00edc\u00edch statistik\u00e1ch spot\u0159eby jsme zjistili z\u00e1porn\u00e9 hodnoty, pravd\u011bpodobn\u011b proto, \u017ee m\u00e1te sol\u00e1rn\u00ed energii. Pro lep\u0161\u00ed p\u0159ehlednost v ovl\u00e1dac\u00edm panelu Energie jsme je rozd\u011blili do samostatn\u00fdch statistik n\u00e1vratnosti.\n\nNav\u0161tivte [str\u00e1nku nastaven\u00ed panelu Energie]({energy_settings}) a p\u0159idejte n\u00e1sleduj\u00edc\u00ed statistiky do sekce **Vracen\u00ed do s\u00edt\u011b**:\n\n{target_ids} \n\nJakmile je p\u0159id\u00e1te, tento probl\u00e9m ignorujte.",
             "title": "Statistika n\u00e1vratu do s\u00edt\u011b pro \u00fa\u010det: {utility_account_id}"
+        },
+        "unsupported_utility": {
+            "fix_flow": {
+                "step": {
+                    "confirm": {
+                        "description": "N\u00e1stroj \"{utility}\" pou\u017e\u00edvan\u00fd polo\u017ekou \"{title}\" ji\u017e nen\u00ed podporov\u00e1n integrac\u00ed Opower. Vyberte **Odeslat** a tuto polo\u017eku integrace ihned odeberte.",
+                        "title": "Nepodporovan\u00fd n\u00e1stroj: {utility}"
+                    }
+                }
+            },
+            "title": "Nepodporovan\u00fd n\u00e1stroj: {utility}"
         }
     }
 }