homeassistant 2025.8.2__py3-none-any.whl → 2025.9.0__py3-none-any.whl

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,
@@ -91,6 +95,8 @@ MAX_TOOL_ITERATIONS = 10
 def _adjust_schema(schema: dict[str, Any]) -> None:
     """Adjust the schema to be compatible with OpenAI API."""
     if schema["type"] == "object":
+        schema.setdefault("strict", True)
+        schema.setdefault("additionalProperties", False)
         if "properties" not in schema:
             return
 
@@ -124,8 +130,6 @@ def _format_structured_output(
 
     _adjust_schema(result)
 
-    result["strict"] = True
-    result["additionalProperties"] = False
     return result
 
 
@@ -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/el.json

@@ -131,6 +131,13 @@
                 "low": "\u03a7\u03b1\u03bc\u03b7\u03bb\u03cc",
                 "medium": "\u039c\u03ad\u03c4\u03c1\u03b9\u03bf"
             }
+        },
+        "verbosity": {
+            "options": {
+                "high": "\u03a5\u03c8\u03b7\u03bb\u03cc",
+                "low": "\u03a7\u03b1\u03bc\u03b7\u03bb\u03cc",
+                "medium": "\u039c\u03ad\u03c4\u03c1\u03b9\u03bf"
+            }
         }
     },
     "services": {

homeassistant/components/openai_conversation/translations/ga.json

@@ -1,4 +1,21 @@
 {
+    "config": {
+        "abort": {
+            "already_configured": "T\u00e1 an tseirbh\u00eds cumraithe cheana f\u00e9in"
+        },
+        "error": {
+            "cannot_connect": "Theip ar an nascadh",
+            "invalid_auth": "F\u00edordheimhni\u00fa neamhbhail\u00ed",
+            "unknown": "Earr\u00e1id gan choinne"
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "api_key": "Eochair API"
+                }
+            }
+        }
+    },
     "config_subentries": {
         "ai_task_data": {
             "abort": {
@@ -11,6 +28,7 @@
             "step": {
                 "advanced": {
                     "data": {
+                        "chat_model": "Samhail",
                         "max_tokens": "Uasmh\u00e9id comhartha\u00ed le tabhairt ar ais mar fhreagra",
                         "temperature": "Teocht",
                         "top_p": "Barr P"
@@ -19,6 +37,7 @@
                 },
                 "init": {
                     "data": {
+                        "name": "Ainm",
                         "recommended": "Socruithe samhail molta"
                     }
                 },
@@ -55,6 +74,7 @@
             "step": {
                 "advanced": {
                     "data": {
+                        "chat_model": "Samhail",
                         "max_tokens": "Uasmh\u00e9id comhartha\u00ed le tabhairt ar ais mar fhreagra",
                         "temperature": "Teocht",
                         "top_p": "Barr P"
@@ -64,6 +84,7 @@
                 "init": {
                     "data": {
                         "llm_hass_api": "C\u00fant\u00f3ir Rialaithe Baile",
+                        "name": "Ainm",
                         "recommended": "Socruithe samhail molta"
                     },
                     "data_description": {

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/openai_conversation/translations/lt.json

@@ -22,9 +22,14 @@
                 "entry_not_loaded": "Negalima prid\u0117ti dalyk\u0173, kol konfig\u016bracija i\u0161jungta.",
                 "reconfigure_successful": "Pakartotinis konfig\u016bravimas buvo s\u0117kmingas"
             },
+            "entry_type": "AI u\u017eduotis",
             "error": {
                 "model_not_supported": "\u0160is modelis nepalaikomas, pasirinkite kit\u0105 model\u012f"
             },
+            "initiate_flow": {
+                "reconfigure": "I\u0161 naujo konfig\u016bruoti DI u\u017eduot\u012f",
+                "user": "Prid\u0117ti dirbtinio intelekto u\u017eduot\u012f"
+            },
             "step": {
                 "advanced": {
                     "data": {

homeassistant/components/openai_conversation/translations/nl.json

@@ -50,7 +50,8 @@
                 "init": {
                     "data": {
                         "llm_hass_api": "Beheer Home Assistant",
-                        "name": "Naam"
+                        "name": "Naam",
+                        "prompt": "Instructies"
                     }
                 }
             }

homeassistant/components/openai_conversation/translations/pt.json

@@ -127,7 +127,8 @@
             "options": {
                 "high": "Alto",
                 "low": "Baixo",
-                "medium": "M\u00e9dio"
+                "medium": "M\u00e9dio",
+                "minimal": "M\u00ednimo"
             }
         },
         "search_context_size": {
@@ -136,6 +137,13 @@
                 "low": "Baixo",
                 "medium": "M\u00e9dio"
             }
+        },
+        "verbosity": {
+            "options": {
+                "high": "Alto",
+                "low": "Baixo",
+                "medium": "M\u00e9dio"
+            }
         }
     },
     "services": {

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/openhome/translations/ga.json

@@ -0,0 +1,7 @@
+{
+    "services": {
+        "invoke_pin": {
+            "name": "Bior\u00e1n s\u00fagartha"
+        }
+    }
+}

homeassistant/components/opensky/translations/ga.json

@@ -4,6 +4,8 @@
             "user": {
                 "data": {
                     "altitude": "Airde",
+                    "latitude": "Domhanleithead",
+                    "longitude": "Domhanfhad",
                     "radius": "Ga"
                 },
                 "description": "L\u00edon isteach an su\u00edomh le rian\u00fa."
@@ -12,6 +14,7 @@
     },
     "options": {
         "error": {
+            "invalid_auth": "F\u00edordheimhni\u00fa neamhbhail\u00ed",
             "no_authentication": "N\u00ed m\u00f3r duit f\u00edordheimhni\u00fa a dh\u00e9anamh le bheith ag cur leis",
             "password_missing": "T\u00e1 an focal faire ar iarraidh",
             "username_missing": "T\u00e1 ainm \u00fas\u00e1ideora ar iarraidh"
@@ -21,7 +24,9 @@
                 "data": {
                     "altitude": "Airde",
                     "contributing_user": "T\u00e1im ag cur le OpenSky",
-                    "radius": "Ga"
+                    "password": "Pasfhocal",
+                    "radius": "Ga",
+                    "username": "Ainm \u00fas\u00e1ideora"
                 },
                 "description": "Is f\u00e9idir leat log\u00e1il isteach i do chuntas OpenSky chun minic\u00edocht na nuashonruithe a mh\u00e9ad\u00fa."
             }