ha-mcp-dev 7.5.0.dev570__tar.gz → 7.5.0.dev571__tar.gz

{ha_mcp_dev-7.5.0.dev570/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.5.0.dev571}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.5.0.dev570
+Version: 7.5.0.dev571
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-7.5.0.dev570 → ha_mcp_dev-7.5.0.dev571}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.5.0.dev570"
+version = "7.5.0.dev571"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{ha_mcp_dev-7.5.0.dev570 → ha_mcp_dev-7.5.0.dev571}/src/ha_mcp/tools/tools_categories.py

@@ -36,7 +36,11 @@ class CategoryTools:
     @tool(
         name="ha_config_get_category",
         tags={"Labels & Categories"},
-        annotations={"idempotentHint": True, "readOnlyHint": True, "title": "Get Category"},
+        annotations={
+            "idempotentHint": True,
+            "readOnlyHint": True,
+            "title": "Get Category",
+        },
     )
     @log_tool_usage
     async def ha_config_get_category(
@@ -133,7 +137,7 @@ class CategoryTools:
                 available_ids = [cat.get("category_id") for cat in categories[:10]]
                 raise_tool_error(
                     create_error_response(
-                        ErrorCode.ENTITY_NOT_FOUND,
+                        ErrorCode.RESOURCE_NOT_FOUND,
                         f"Category not found: {category_id}",
                         context={
                             "category_id": category_id,
@@ -247,6 +251,22 @@ class CategoryTools:
                     "message": f"Successfully {action_past} category: {name}",
                 }
             else:
+                error_str = str(result.get("error", "")).lower()
+                if "not found" in error_str or "doesn't exist" in error_str:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.RESOURCE_NOT_FOUND,
+                            f"Category not found: {category_id}",
+                            context={
+                                "name": name,
+                                "scope": scope,
+                                "category_id": category_id,
+                            },
+                            suggestions=[
+                                f"Use ha_config_get_category('{scope}') without category_id to see all categories",
+                            ],
+                        )
+                    )
                 raise_tool_error(
                     create_error_response(
                         ErrorCode.SERVICE_CALL_FAILED,
@@ -276,7 +296,11 @@ class CategoryTools:
     @tool(
         name="ha_config_remove_category",
         tags={"Labels & Categories"},
-        annotations={"destructiveHint": True, "idempotentHint": True, "title": "Remove Category"},
+        annotations={
+            "destructiveHint": True,
+            "idempotentHint": True,
+            "title": "Remove Category",
+        },
     )
     @log_tool_usage
     async def ha_config_remove_category(
@@ -333,6 +357,18 @@ class CategoryTools:
                     "message": f"Successfully deleted category: {category_id}",
                 }
             else:
+                error_str = str(result.get("error", "")).lower()
+                if "not found" in error_str or "doesn't exist" in error_str:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.RESOURCE_NOT_FOUND,
+                            f"Category not found: {category_id}",
+                            context={"category_id": category_id, "scope": scope},
+                            suggestions=[
+                                f"Use ha_config_get_category('{scope}') without category_id to see all categories",
+                            ],
+                        )
+                    )
                 raise_tool_error(
                     create_error_response(
                         ErrorCode.SERVICE_CALL_FAILED,

{ha_mcp_dev-7.5.0.dev570 → ha_mcp_dev-7.5.0.dev571}/src/ha_mcp/tools/tools_config_automations.py

@@ -13,6 +13,7 @@ from fastmcp.tools import tool
 from pydantic import Field
 
 from ..client.rest_client import (
+    HomeAssistantAPIError,
     HomeAssistantAuthError,
     HomeAssistantConnectionError,
 )
@@ -864,6 +865,13 @@ class AutomationConfigTools:
         except ToolError:
             raise
         except Exception as e:
+            # 404 during update only — create (identifier=None) never hits this branch.
+            if (
+                identifier
+                and isinstance(e, HomeAssistantAPIError)
+                and e.status_code == 404
+            ):
+                await self._raise_automation_not_found(identifier)
             suggestions = [
                 "Check automation configuration format",
                 "Ensure required fields: alias, trigger, action",
@@ -882,6 +890,57 @@ class AutomationConfigTools:
                 suggestions=suggestions,
             )
 
+    async def _list_automation_entity_ids(self) -> list[str]:
+        """Best-effort list of automation entity_ids (up to 10) from the entity registry.
+
+        Used to populate ``available_automation_ids`` in RESOURCE_NOT_FOUND
+        error context. Returns an empty list on any failure — caller treats
+        absence as "no IDs to report" rather than failing the structured
+        error raise. The 10-entry cap lives here (not at the callers) so a
+        new call site can't accidentally bloat the error payload.
+        """
+        try:
+            result = await self._client.send_websocket_message(
+                {"type": "config/entity_registry/list"}
+            )
+        except Exception as e:
+            logger.debug("Failed to list automation entity_ids from registry: %s", e)
+            return []
+        entries = result.get("result", []) if isinstance(result, dict) else result
+        if not isinstance(entries, list):
+            return []
+        return [
+            entry["entity_id"]
+            for entry in entries
+            if isinstance(entry, dict)
+            and isinstance(entry.get("entity_id"), str)
+            and entry["entity_id"].startswith("automation.")
+        ][:10]
+
+    async def _raise_automation_not_found(self, identifier: str) -> None:
+        """Raise a structured RESOURCE_NOT_FOUND ToolError for a missing automation.
+
+        Single source of truth for the 404→RESOURCE_NOT_FOUND mapping used
+        by both the GET path (``_get_automation_config_internal``) and the
+        mutation paths (``ha_config_set_automation`` update branch,
+        ``ha_config_remove_automation``). Populates
+        ``available_automation_ids`` (up to 10) from the entity registry.
+        """
+        available_ids = await self._list_automation_entity_ids()
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.RESOURCE_NOT_FOUND,
+                f"Automation not found: {identifier}",
+                context={
+                    "automation_id": identifier,
+                    "available_automation_ids": available_ids,
+                },
+                suggestions=[
+                    "Use ha_search_entities(domain_filter='automation') to find existing automations"
+                ],
+            )
+        )
+
     async def _get_automation_config_internal(
         self, identifier: str
     ) -> tuple[dict[str, Any], str]:
@@ -889,8 +948,18 @@ class AutomationConfigTools:
 
         Returns (normalized_config, config_hash) tuple.
         Used internally by _fetch_and_verify_hash and ha_config_get_automation.
+
+        Raises a structured ``RESOURCE_NOT_FOUND`` ToolError via
+        ``_raise_automation_not_found`` when the REST client returns 404.
+        Other ``HomeAssistantAPIError`` instances propagate unchanged to
+        caller exception handlers (``exception_to_structured_error`` route).
         """
-        config_result = await self._client.get_automation_config(identifier)
+        try:
+            config_result = await self._client.get_automation_config(identifier)
+        except HomeAssistantAPIError as e:
+            if e.status_code == 404:
+                await self._raise_automation_not_found(identifier)
+            raise
         normalized_config = _normalize_config_for_roundtrip(config_result)
         config_hash_value = compute_config_hash(normalized_config)
         return normalized_config, config_hash_value
@@ -1169,6 +1238,8 @@ class AutomationConfigTools:
         except ToolError:
             raise
         except Exception as e:
+            if isinstance(e, HomeAssistantAPIError) and e.status_code == 404:
+                await self._raise_automation_not_found(identifier)
             exception_to_structured_error(
                 e,
                 context={"identifier": identifier, "action": "delete"},

{ha_mcp_dev-7.5.0.dev570 → ha_mcp_dev-7.5.0.dev571}/src/ha_mcp/tools/tools_config_dashboards.py

@@ -1530,8 +1530,13 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                 ],
                 context={"action": "delete"},
             )
-            resolved, _ = await _resolve_dashboard(client, url_path)
+            resolved, dashboards = await _resolve_dashboard(client, url_path)
             if resolved is None:
+                available_ids = [
+                    d.get("url_path")
+                    for d in (dashboards or [])[:10]
+                    if d.get("url_path")
+                ]
                 raise_tool_error(
                     create_error_response(
                         ErrorCode.RESOURCE_NOT_FOUND,
@@ -1541,7 +1546,11 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                             "Use ha_config_get_dashboard(list_only=True) to see available dashboards",
                             "YAML-mode and default dashboards are not deletable via this tool",
                         ],
-                        context={"action": "delete", "url_path": url_path},
+                        context={
+                            "action": "delete",
+                            "url_path": url_path,
+                            "available_dashboard_ids": available_ids,
+                        },
                     )
                 )
             resolved_id = resolved["id"]

{ha_mcp_dev-7.5.0.dev570 → ha_mcp_dev-7.5.0.dev571}/src/ha_mcp/tools/tools_config_scripts.py

@@ -13,6 +13,7 @@ from fastmcp.tools import tool
 from pydantic import Field
 
 from ..client.rest_client import (
+    HomeAssistantAPIError,
     HomeAssistantAuthError,
     HomeAssistantConnectionError,
 )
@@ -90,7 +91,10 @@ class ConfigScriptTools:
     async def ha_config_get_script(
         self,
         script_id: Annotated[
-            str, Field(description="Script identifier (e.g., 'morning_routine')")
+            str,
+            Field(
+                description="Script identifier — bare storage key ('morning_routine') or entity_id form ('script.morning_routine'); a leading 'script.' prefix is stripped before lookup."
+            ),
         ],
     ) -> dict[str, Any]:
         """
@@ -100,15 +104,28 @@ class ConfigScriptTools:
 
         The returned `config_hash` is stable across consecutive reads of an unchanged config — `compute_config_hash` documents the underlying contract.
 
-        The returned `script_id` is the canonical storage key resolved by the REST client (matching what `ha_config_set_script` / `ha_config_remove_script` expect), falling back to the input identifier on the rare path where the REST envelope omits it.
+        The returned `script_id` is the canonical bare storage key resolved by the REST client (matching what `ha_config_set_script` / `ha_config_remove_script` expect), falling back to the input identifier on the rare path where the REST envelope omits it. A leading `script.` prefix on the input is stripped before lookup — behavioral parity with `ha_config_get_automation` (mechanism differs: automations resolve via state lookup; scripts strip the prefix).
 
         EXAMPLES:
-        - Get script: ha_config_get_script("morning_routine")
-        - Get script: ha_config_get_script("backup_script")
+        - Get script (bare form): ha_config_get_script("morning_routine")
+        - Get script (entity_id form): ha_config_get_script("script.morning_routine")
 
         For detailed script configuration help, use ha_get_skill_guide.
         """
         try:
+            # Strip BEFORE validate so a bare ``"script."`` (empty after
+            # strip) is rejected as ``VALIDATION_INVALID_PARAMETER`` rather
+            # than slipping through validate (non-empty pre-strip) and
+            # 404-ing at ``get_script_config("")``. Accept entity_id form
+            # (``script.foo``) and bare storage key (``foo``) — behavioral
+            # parity with ``ha_config_get_automation`` (mechanism differs:
+            # automations resolve via state lookup; scripts strip the
+            # prefix). ``_raise_script_not_found`` suggests
+            # ``ha_search_entities(domain_filter='script')`` which returns
+            # entity_ids; without this strip, feeding that output back into
+            # the GET tool fails and reseeds the wrong-tool spiral that
+            # #1297 closes.
+            script_id = script_id.removeprefix("script.")
             # Empty/whitespace script_id would propagate to
             # ``get_script_config`` and surface as a misleading
             # ``RESOURCE_NOT_FOUND``. Extension of the #1312
@@ -122,7 +139,7 @@ class ConfigScriptTools:
                     "Use ha_search_entities(domain_filter='script') to list scripts",
                 ],
             )
-            config_result = await self._client.get_script_config(script_id)
+            config_result = await self._fetch_script_config_envelope(script_id)
             # Extract actual script config body and compute hash before category injection
             actual_config = config_result.get("config", config_result)
             config_hash_value = compute_config_hash(actual_config)
@@ -170,6 +187,76 @@ class ConfigScriptTools:
                 ],
             )
 
+    async def _list_script_entity_ids(self) -> list[str]:
+        """Best-effort list of bare script IDs (up to 10) from the entity registry.
+
+        Returns the bare storage keys (e.g. ``morning_routine``), stripping
+        the ``script.`` entity_id prefix — ``ha_config_get_script`` /
+        ``ha_config_set_script`` / ``ha_config_remove_script`` all take the
+        bare form, so the entity_id prefix would force callers to strip it
+        before retry. Returns an empty list on any failure — caller treats
+        absence as "no IDs to report" rather than failing the structured
+        error raise. The 10-entry cap lives here (not at the callers) so a
+        new call site can't accidentally bloat the error payload.
+        """
+        try:
+            result = await self._client.send_websocket_message(
+                {"type": "config/entity_registry/list"}
+            )
+        except Exception as e:
+            logger.debug("Failed to list script entity_ids from registry: %s", e)
+            return []
+        entries = result.get("result", []) if isinstance(result, dict) else result
+        if not isinstance(entries, list):
+            return []
+        return [
+            entry["entity_id"][len("script.") :]
+            for entry in entries
+            if isinstance(entry, dict)
+            and isinstance(entry.get("entity_id"), str)
+            and entry["entity_id"].startswith("script.")
+        ][:10]
+
+    async def _raise_script_not_found(self, script_id: str) -> None:
+        """Raise a structured RESOURCE_NOT_FOUND ToolError for a missing script.
+
+        Single source of truth for the 404→RESOURCE_NOT_FOUND mapping used
+        by the GET path (``_fetch_script_config_envelope``) and the
+        mutation paths (``ha_config_set_script`` update branch,
+        ``ha_config_remove_script``). Populates ``available_script_ids``
+        (up to 10 bare IDs) from the entity registry.
+        """
+        available_ids = await self._list_script_entity_ids()
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.RESOURCE_NOT_FOUND,
+                f"Script not found: {script_id}",
+                context={
+                    "script_id": script_id,
+                    "available_script_ids": available_ids,
+                },
+                suggestions=[
+                    "Use ha_search_entities(domain_filter='script') to find existing scripts"
+                ],
+            )
+        )
+
+    async def _fetch_script_config_envelope(self, script_id: str) -> dict[str, Any]:
+        """Fetch the raw REST envelope, mapping 404 to RESOURCE_NOT_FOUND.
+
+        Returns the dict envelope from ``rest_client.get_script_config``
+        (``success``/``script_id``/``config`` keys). Raises a structured
+        ``RESOURCE_NOT_FOUND`` ToolError via ``_raise_script_not_found`` on
+        404. Other ``HomeAssistantAPIError`` instances propagate unchanged
+        to caller exception handlers.
+        """
+        try:
+            return cast(dict[str, Any], await self._client.get_script_config(script_id))
+        except HomeAssistantAPIError as e:
+            if e.status_code == 404:
+                await self._raise_script_not_found(script_id)
+            raise
+
     async def _get_script_config_internal(
         self, script_id: str
     ) -> tuple[dict[str, Any], str]:
@@ -178,8 +265,11 @@ class ConfigScriptTools:
         Returns (actual_config, config_hash) tuple where actual_config is
         the inner script body (not the REST wrapper).
         Used internally by _fetch_and_verify_hash and ha_config_get_script.
+
+        404 responses from the REST client are mapped to a structured
+        ``RESOURCE_NOT_FOUND`` ToolError via ``_fetch_script_config_envelope``.
         """
-        config_result = await self._client.get_script_config(script_id)
+        config_result = await self._fetch_script_config_envelope(script_id)
         actual_config = config_result.get("config", config_result)
         config_hash_value = compute_config_hash(actual_config)
         return actual_config, config_hash_value
@@ -223,19 +313,29 @@ class ConfigScriptTools:
         try:
             parsed_config = parse_json_param(config, "config")
         except ValueError as e:
-            raise_tool_error(create_error_response(
-                ErrorCode.VALIDATION_INVALID_JSON,
-                f"Invalid config parameter: {e}",
-                context={"script_id": script_id, "provided_config_type": type(config).__name__},
-            ))
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_JSON,
+                    f"Invalid config parameter: {e}",
+                    context={
+                        "script_id": script_id,
+                        "provided_config_type": type(config).__name__,
+                    },
+                )
+            )
 
         # Ensure config is a dict
         if parsed_config is None or not isinstance(parsed_config, dict):
-            raise_tool_error(create_error_response(
-                ErrorCode.VALIDATION_INVALID_PARAMETER,
-                "Config parameter must be a JSON object",
-                context={"script_id": script_id, "provided_type": type(parsed_config).__name__},
-            ))
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "Config parameter must be a JSON object",
+                    context={
+                        "script_id": script_id,
+                        "provided_type": type(parsed_config).__name__,
+                    },
+                )
+            )
 
         config_dict = cast(dict[str, Any], parsed_config)
 
@@ -250,11 +350,16 @@ class ConfigScriptTools:
             # Strip empty sequence array that would override blueprint
             config_dict = _strip_empty_script_fields(config_dict)
         elif "sequence" not in config_dict:
-            raise_tool_error(create_error_response(
-                ErrorCode.VALIDATION_MISSING_PARAMETER,
-                "config must include either 'sequence' field (for regular scripts) or 'use_blueprint' field (for blueprint-based scripts)",
-                context={"script_id": script_id, "required_fields": ["sequence OR use_blueprint"]},
-            ))
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_MISSING_PARAMETER,
+                    "config must include either 'sequence' field (for regular scripts) or 'use_blueprint' field (for blueprint-based scripts)",
+                    context={
+                        "script_id": script_id,
+                        "required_fields": ["sequence OR use_blueprint"],
+                    },
+                )
+            )
 
         return config_dict, effective_category
 
@@ -270,7 +375,10 @@ class ConfigScriptTools:
     async def ha_config_set_script(
         self,
         script_id: Annotated[
-            str, Field(description="Script identifier (e.g., 'morning_routine')")
+            str,
+            Field(
+                description="Script identifier — bare storage key ('morning_routine') or entity_id form ('script.morning_routine'); a leading 'script.' prefix is stripped before lookup."
+            ),
         ],
         config: Annotated[
             str | dict[str, Any] | None,
@@ -447,6 +555,18 @@ class ConfigScriptTools:
         """
         bp_warnings: list[str] = []
         try:
+            # Strip BEFORE validate so a bare ``"script."`` (empty after
+            # strip) is rejected as ``VALIDATION_INVALID_PARAMETER`` rather
+            # than slipping through validate (non-empty pre-strip) and
+            # writing a phantom ``script.foo`` storage key — HA keys writes
+            # by the literal ``script_id``, so passing ``"script.foo"``
+            # unchanged makes the row invisible to a later
+            # ``ha_config_get_script("foo")``. Behavioral parity with
+            # ``ha_config_get_script`` so an agent that received an
+            # entity_id (``script.foo``) from
+            # ``ha_search_entities(domain_filter='script')`` can update it
+            # without a manual prefix-strip step.
+            script_id = script_id.removeprefix("script.")
             # ``script_id`` is required (always non-None). Reject empty/
             # whitespace up-front so the caller gets a structured parameter
             # error instead of a misleading ``RESOURCE_NOT_FOUND`` from
@@ -488,7 +608,10 @@ class ConfigScriptTools:
                                 "Call ha_config_get_script() first",
                                 "Use the config_hash from that response",
                             ],
-                            context={"action": "python_transform", "script_id": script_id},
+                            context={
+                                "action": "python_transform",
+                                "script_id": script_id,
+                            },
                         )
                     )
 
@@ -507,12 +630,18 @@ class ConfigScriptTools:
                             ErrorCode.VALIDATION_FAILED,
                             message,
                             suggestions=suggestions,
-                            context={"action": "python_transform", "script_id": script_id},
+                            context={
+                                "action": "python_transform",
+                                "script_id": script_id,
+                            },
                         )
                     )
 
                 # Validate transformed config
-                if "sequence" not in transformed_config and "use_blueprint" not in transformed_config:
+                if (
+                    "sequence" not in transformed_config
+                    and "use_blueprint" not in transformed_config
+                ):
                     raise_tool_error(
                         create_error_response(
                             ErrorCode.VALIDATION_FAILED,
@@ -521,7 +650,10 @@ class ConfigScriptTools:
                                 "The transform may have removed required fields",
                                 "Ensure the config still has a 'sequence' or 'use_blueprint' key",
                             ],
-                            context={"action": "python_transform", "script_id": script_id},
+                            context={
+                                "action": "python_transform",
+                                "script_id": script_id,
+                            },
                         )
                     )
                 bp_warnings = _check_best_practices(transformed_config)
@@ -562,7 +694,9 @@ class ConfigScriptTools:
                 )
 
             config_dict, effective_category = self._validate_script_config(
-                config, script_id, category,
+                config,
+                script_id,
+                category,
             )
 
             # Optional hash check for full config updates
@@ -586,7 +720,9 @@ class ConfigScriptTools:
             entity_id = f"script.{script_id}"
             if wait_bool:
                 try:
-                    registered = await wait_for_entity_registered(self._client, entity_id)
+                    registered = await wait_for_entity_registered(
+                        self._client, entity_id
+                    )
                     if not registered:
                         result.setdefault("warnings", []).append(
                             f"Script saved but {entity_id} not yet queryable. "
@@ -600,7 +736,12 @@ class ConfigScriptTools:
             # Apply category to entity registry if provided
             if effective_category and entity_id:
                 await apply_entity_category(
-                    self._client, entity_id, effective_category, "script", result, "script"
+                    self._client,
+                    entity_id,
+                    effective_category,
+                    "script",
+                    result,
+                    "script",
                 )
 
             if bp_warnings:
@@ -629,6 +770,11 @@ class ConfigScriptTools:
                     "Config had best-practice issues that may be related: "
                     + "; ".join(bp_warnings)
                 )
+            # 404 during update only — the create path raises on its own when
+            # the upsert hits an unknown identifier server-side. The bare
+            # script_id form is what callers pass and what the registry stores.
+            if isinstance(e, HomeAssistantAPIError) and e.status_code == 404:
+                await self._raise_script_not_found(script_id)
             exception_to_structured_error(
                 e,
                 context={"script_id": script_id},
@@ -648,7 +794,10 @@ class ConfigScriptTools:
     async def ha_config_remove_script(
         self,
         script_id: Annotated[
-            str, Field(description="Script identifier to delete (e.g., 'old_script')")
+            str,
+            Field(
+                description="Script identifier to delete — bare storage key ('old_script') or entity_id form ('script.old_script'); a leading 'script.' prefix is stripped before lookup."
+            ),
         ],
         wait: Annotated[
             bool | str,
@@ -675,6 +824,14 @@ class ConfigScriptTools:
         **WARNING:** Deleting a script that is used by automations may cause those automations to fail.
         """
         try:
+            # Strip BEFORE validate so a bare ``"script."`` (empty after
+            # strip) is rejected as ``VALIDATION_INVALID_PARAMETER`` rather
+            # than slipping through validate (non-empty pre-strip) and
+            # producing a ``script.script.foo`` entity_id for the
+            # ``wait_for_entity_removed`` watcher below — that mis-formed
+            # entity_id never registers so the watcher times out on a
+            # phantom. Behavioral parity with ``ha_config_get_script``.
+            script_id = script_id.removeprefix("script.")
             # Empty/whitespace would surface as a misleading HA delete-failure.
             validate_identifier_not_empty(
                 script_id,
@@ -705,6 +862,8 @@ class ConfigScriptTools:
         except ToolError:
             raise
         except Exception as e:
+            if isinstance(e, HomeAssistantAPIError) and e.status_code == 404:
+                await self._raise_script_not_found(script_id)
             exception_to_structured_error(
                 e,
                 context={"script_id": script_id},