ha-mcp-dev 7.14.2.dev2091__tar.gz → 7.14.2.dev2095__tar.gz

{ha_mcp_dev-7.14.2.dev2091/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.14.2.dev2095}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.14.2.dev2091
+Version: 7.14.2.dev2095
 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.14.2.dev2091 → ha_mcp_dev-7.14.2.dev2095}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.14.2.dev2091"
+version = "7.14.2.dev2095"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-7.14.2.dev2091 → ha_mcp_dev-7.14.2.dev2095}/src/ha_mcp/dashboard_screenshot/paths.py

@@ -347,42 +347,28 @@ async def fetch_dashboard_render_config(
     return cast(dict[str, Any], config)
 
 
-def resolve_dashboard_view(
+def match_dashboard_view(
     dashboard_url_path: str,
     config: dict[str, Any],
-    view_path: str | None,
-) -> DashboardRenderTarget:
-    """Resolve one named Lovelace view to a canonical frontend route."""
-    base_path = dashboard_frontend_path(dashboard_url_path)
-    if view_path is None:
-        views = config.get("views")
-        has_static_views = isinstance(views, list) and bool(views)
-        if "strategy" in config:
-            warning = (
-                "No view_path was supplied; this strategy dashboard generates "
-                "its views at runtime, so only the base route is available."
-            )
-        elif has_static_views:
-            warning = (
-                "No view_path was supplied; the dashboard base route renders "
-                "the first view visible to Puppet's Home Assistant user."
-            )
-        else:
-            warning = (
-                "No view_path was supplied and the dashboard has no static views; "
-                "only the base route is available."
-            )
-        return DashboardRenderTarget(
-            dashboard_url_path=base_path,
-            view_path=None,
-            render_path=base_path,
-            view_index=None,
-            stable=False,
-            warnings=(warning,),
-        )
-
-    cleaned_view_path = view_path
-    if not cleaned_view_path.strip():
+    view_path: str,
+    *,
+    strategy_suggestions: tuple[str, ...] = (
+        "Use dashboard_path with the frontend route instead",
+    ),
+) -> tuple[int, dict[str, Any]]:
+    """Match one named Lovelace view by its configured ``views[].path``.
+
+    Shared by screenshot view resolution and get-mode view scoping so both
+    honour identical semantics: exact match on the configured path, with
+    structured errors for an empty path, a strategy dashboard (no static
+    views to match), and a missing/ambiguous path (the not-found error lists
+    the available paths). Returns ``(view_index, view)``.
+
+    ``strategy_suggestions`` lets each caller phrase the strategy-dashboard
+    remediation in its own vocabulary (the screenshot tools have a
+    ``dashboard_path`` route parameter; config scoping does not).
+    """
+    if not view_path.strip():
         raise_tool_error(
             create_error_response(
                 ErrorCode.VALIDATION_INVALID_PARAMETER,
@@ -397,9 +383,9 @@ def resolve_dashboard_view(
                 "Strategy dashboards do not expose static named view paths.",
                 context={
                     "dashboard_url_path": dashboard_url_path,
-                    "view_path": cleaned_view_path,
+                    "view_path": view_path,
                 },
-                suggestions=["Use dashboard_path with the frontend route instead"],
+                suggestions=list(strategy_suggestions),
             )
         )
     views = config.get("views")
@@ -408,7 +394,7 @@ def resolve_dashboard_view(
     matches = [
         (index, view)
         for index, view in enumerate(views)
-        if _configured_view_path(view) == cleaned_view_path
+        if _configured_view_path(view) == view_path
     ]
     if len(matches) != 1:
         available = [
@@ -420,17 +406,57 @@ def resolve_dashboard_view(
         raise_tool_error(
             create_error_response(
                 ErrorCode.RESOURCE_NOT_FOUND,
-                f"Dashboard view path '{cleaned_view_path}' is {reason}.",
+                f"Dashboard view path '{view_path}' is {reason}.",
                 context={
                     "dashboard_url_path": dashboard_url_path,
-                    "view_path": cleaned_view_path,
+                    "view_path": view_path,
                     "available_view_paths": available,
                 },
                 suggestions=["Use a view_path returned by ha_config_get_dashboard"],
             )
         )
+    return matches[0]
+
 
-    view_index, _ = matches[0]
+def resolve_dashboard_view(
+    dashboard_url_path: str,
+    config: dict[str, Any],
+    view_path: str | None,
+) -> DashboardRenderTarget:
+    """Resolve one named Lovelace view to a canonical frontend route."""
+    base_path = dashboard_frontend_path(dashboard_url_path)
+    if view_path is None:
+        views = config.get("views")
+        has_static_views = isinstance(views, list) and bool(views)
+        if "strategy" in config:
+            warning = (
+                "No view_path was supplied; this strategy dashboard generates "
+                "its views at runtime, so only the base route is available."
+            )
+        elif has_static_views:
+            warning = (
+                "No view_path was supplied; the dashboard base route renders "
+                "the first view visible to Puppet's Home Assistant user."
+            )
+        else:
+            warning = (
+                "No view_path was supplied and the dashboard has no static views; "
+                "only the base route is available."
+            )
+        return DashboardRenderTarget(
+            dashboard_url_path=base_path,
+            view_path=None,
+            render_path=base_path,
+            view_index=None,
+            stable=False,
+            warnings=(warning,),
+        )
+
+    view_index, _ = match_dashboard_view(dashboard_url_path, config, view_path)
+    cleaned_view_path = view_path
+    views = config.get("views")
+    if not isinstance(views, list):
+        views = []
     render_path = _safe_named_render_path(base_path, cleaned_view_path)
     if render_path is None:
         return _fallback_view_target(

{ha_mcp_dev-7.14.2.dev2091 → ha_mcp_dev-7.14.2.dev2095}/src/ha_mcp/tools/config_entry_flow.py

@@ -11,6 +11,7 @@ for the 15 helper types listed in FLOW_HELPER_TYPES.
 """
 
 import asyncio
+import copy
 import logging
 from collections.abc import Iterator
 from enum import StrEnum
@@ -78,6 +79,7 @@ _RECONFIGURE_SUCCESS_REASONS = frozenset(
         "reconfigure_successful",
     }
 )
+_MISSING_DEFAULT = object()
 
 
 class _FlowType(StrEnum):
@@ -172,6 +174,47 @@ def _record_ignored_section_keys(
     )
 
 
+def _field_default_value(field: dict[str, Any]) -> Any:
+    """Return a serialized schema field's default/suggested value, if present."""
+    description = field.get("description")
+    if isinstance(description, dict) and description.get("suggested_value") is not None:
+        return copy.deepcopy(description["suggested_value"])
+    if field.get("suggested_value") is not None:
+        return copy.deepcopy(field["suggested_value"])
+    if "default" in field:
+        return copy.deepcopy(field["default"])
+    return _MISSING_DEFAULT
+
+
+def _schema_default_values(data_schema: list[Any]) -> dict[str, Any]:
+    """Build default form data from serialized schema suggestions/defaults."""
+    defaults: dict[str, Any] = {}
+    for field in data_schema:
+        if not isinstance(field, dict):
+            continue
+        name = field.get("name")
+        nested_schema = field.get("schema")
+        if not isinstance(name, str):
+            continue
+        if isinstance(nested_schema, list):
+            nested_defaults = _schema_default_values(nested_schema)
+            if nested_defaults:
+                defaults[name] = nested_defaults
+            continue
+        default = _field_default_value(field)
+        if default is not _MISSING_DEFAULT:
+            defaults[name] = default
+    return defaults
+
+
+def _required_section_defaults(field: dict[str, Any]) -> dict[str, Any]:
+    """Return default data for a required section, otherwise an empty dict."""
+    nested_schema = field.get("schema")
+    if not field.get("required") or not isinstance(nested_schema, list):
+        return {}
+    return _schema_default_values(nested_schema)
+
+
 def _ignored_keys_warnings(
     ignored_config_keys: set[str], remaining_config: dict[str, Any]
 ) -> list[str]:
@@ -194,10 +237,89 @@ def _ignored_keys_warnings(
     return warnings
 
 
+def _consume_section_schema(
+    field: dict[str, Any],
+    explicit_section: dict[str, Any] | None,
+    remaining_config: dict[str, Any],
+    ignored_config_keys: set[str] | None,
+    consumed_config_keys: set[str] | None,
+    path_prefix: str,
+) -> dict[str, Any]:
+    """Consume config values for a nested flow section."""
+    nested_schema = field.get("schema")
+    if not isinstance(nested_schema, list):
+        return {}
+
+    name = field.get("name")
+    section_path = _section_path(path_prefix, name)
+    nested_data = _required_section_defaults(field)
+
+    if explicit_section is not None:
+        explicit_remaining = dict(explicit_section)
+        nested_data.update(
+            _consume_form_schema(
+                nested_schema,
+                explicit_remaining,
+                ignored_config_keys,
+                consumed_config_keys,
+                section_path,
+            )
+        )
+        _record_ignored_section_keys(
+            ignored_config_keys,
+            explicit_remaining,
+            section_path,
+        )
+
+    nested_data.update(
+        _consume_form_schema(
+            nested_schema,
+            remaining_config,
+            ignored_config_keys,
+            consumed_config_keys,
+            section_path,
+        )
+    )
+    return nested_data
+
+
+def _mark_consumed(
+    consumed_config_keys: set[str] | None,
+    path_prefix: str,
+    name: str,
+) -> None:
+    """Record that a caller-supplied form key, not an injected default, was used."""
+    if consumed_config_keys is not None:
+        consumed_config_keys.add(_section_path(path_prefix, name))
+
+
+def _auto_confirm_form_payload(current_step: dict[str, Any]) -> dict[str, Any] | None:
+    """Return payload for HA preview/confirmation-only forms we can safely advance."""
+    if "preview" not in current_step:
+        return None
+    data_schema = current_step.get("data_schema")
+    if not isinstance(data_schema, list) or len(data_schema) != 1:
+        return None
+    field = data_schema[0]
+    if not isinstance(field, dict) or not field.get("required"):
+        return None
+    name = field.get("name")
+    if not isinstance(name, str) or name in _MENU_SELECTION_KEYS:
+        return None
+    default = _field_default_value(field)
+    if default is not False:
+        return None
+    selector = field.get("selector")
+    if isinstance(selector, dict) and selector and "boolean" not in selector:
+        return None
+    return {name: True}
+
+
 def _consume_form_schema(
     data_schema: list[Any],
     remaining_config: dict[str, Any],
     ignored_config_keys: set[str] | None = None,
+    consumed_config_keys: set[str] | None = None,
     path_prefix: str = "",
 ) -> dict[str, Any]:
     """Consume matching config values and shape nested flow sections.
@@ -208,7 +330,6 @@ def _consume_form_schema(
     ``ignored_config_keys`` with their dotted section path.
     """
     form_data: dict[str, Any] = {}
-    missing = object()
 
     for field in data_schema:
         if not isinstance(field, dict):
@@ -217,47 +338,27 @@ def _consume_form_schema(
         name = field.get("name")
         nested_schema = field.get("schema")
         if isinstance(nested_schema, list):
-            section_path = _section_path(path_prefix, name)
-            explicit_section = (
-                remaining_config.pop(name, missing)
-                if isinstance(name, str)
-                else missing
-            )
-            if explicit_section is not missing and not isinstance(
-                explicit_section, dict
-            ):
-                if isinstance(name, str):
-                    form_data[name] = explicit_section
-                continue
-
-            nested_data: dict[str, Any] = {}
-            if isinstance(explicit_section, dict):
-                explicit_remaining = dict(explicit_section)
-                nested_data.update(
-                    _consume_form_schema(
-                        nested_schema,
-                        explicit_remaining,
-                        ignored_config_keys,
-                        section_path,
-                    )
-                )
-                _record_ignored_section_keys(
-                    ignored_config_keys,
-                    explicit_remaining,
-                    section_path,
-                )
-            nested_data.update(
-                _consume_form_schema(
-                    nested_schema,
-                    remaining_config,
-                    ignored_config_keys,
-                    section_path,
-                )
+            section_name = name if isinstance(name, str) else None
+            explicit_section = None
+            if section_name is not None and section_name in remaining_config:
+                explicit_value = remaining_config.pop(section_name)
+                if not isinstance(explicit_value, dict):
+                    form_data[section_name] = explicit_value
+                    _mark_consumed(consumed_config_keys, path_prefix, section_name)
+                    continue
+                explicit_section = explicit_value
+
+            nested_data = _consume_section_schema(
+                field,
+                explicit_section,
+                remaining_config,
+                ignored_config_keys,
+                consumed_config_keys,
+                path_prefix,
             )
-
             if nested_data:
-                if isinstance(name, str):
-                    form_data[name] = nested_data
+                if section_name is not None:
+                    form_data[section_name] = nested_data
                 else:
                     form_data.update(nested_data)
             continue
@@ -268,6 +369,7 @@ def _consume_form_schema(
             and name in remaining_config
         ):
             form_data[name] = remaining_config.pop(name)
+            _mark_consumed(consumed_config_keys, path_prefix, name)
 
     return form_data
 
@@ -296,6 +398,7 @@ def _handle_form_step(
     current_step: dict[str, Any],
     remaining_config: dict[str, Any],
     ignored_config_keys: set[str] | None = None,
+    consumed_config_keys: set[str] | None = None,
 ) -> dict[str, Any]:
     """Validate a form step and return form data to submit.
 
@@ -337,9 +440,10 @@ def _handle_form_step(
             if key in _MENU_SELECTION_KEYS:
                 continue
             form_data[key] = remaining_config.pop(key)
+            _mark_consumed(consumed_config_keys, "", key)
     else:
         form_data = _consume_form_schema(
-            data_schema, remaining_config, ignored_config_keys
+            data_schema, remaining_config, ignored_config_keys, consumed_config_keys
         )
 
     return form_data
@@ -783,13 +887,17 @@ async def _handle_flow_steps(
             # for subsequent steps (HA can present multi-step forms, e.g.
             # statistics: user step then pick-characteristic step).
             saw_form_step = True
-            form_data = _handle_form_step(
-                flow_id,
-                current_step,
-                remaining_config,
-                ignored_config_keys,
-            )
-            if form_data:
+            consumed_form_keys: set[str] = set()
+            form_data = _auto_confirm_form_payload(current_step)
+            if form_data is None:
+                form_data = _handle_form_step(
+                    flow_id,
+                    current_step,
+                    remaining_config,
+                    ignored_config_keys,
+                    consumed_form_keys,
+                )
+            if consumed_form_keys:
                 any_form_key_consumed = True
             logger.debug(
                 f"Flow step {step_num}: form submit "

{ha_mcp_dev-7.14.2.dev2091 → ha_mcp_dev-7.14.2.dev2095}/src/ha_mcp/tools/tools_bug_report.py

@@ -34,7 +34,7 @@ from ..utils.usage_logger import (
 )
 from .component_api import get_component_caps
 from .helpers import log_tool_usage, register_tool_methods
-from .util_helpers import ANSI_ESCAPE_RE
+from .util_helpers import ANSI_ESCAPE_RE, JSON_STRING_COERCION, project_fields
 
 logger = logging.getLogger(__name__)
 
@@ -676,10 +676,38 @@ class BugReportTools:
                 ),
             ),
         ] = 10,
+        fields: Annotated[
+            str | list[str] | None,
+            JSON_STRING_COERCION,
+            Field(
+                default=None,
+                description=(
+                    "Return only the specified top-level response keys — the "
+                    "full response (both templates + logs + diagnostics, with "
+                    "log content repeated across the raw keys and templates) "
+                    "is very large. "
+                    "None = full response. Typical for a runtime bug: "
+                    "'runtime_bug_template,suggested_title,"
+                    "runtime_bug_submit_url,duplicate_check_urls,"
+                    "anonymization_guide,instructions'; for agent feedback "
+                    "swap in agent_behavior_template and "
+                    "agent_behavior_submit_url. The templates already embed "
+                    "the relevant logs, so the raw log keys are only needed "
+                    "for your own analysis. "
+                    "Available keys: diagnostic_info, recent_logs, "
+                    "startup_logs, addon_logs, core_error_log, log_count, "
+                    "startup_log_count, formatted_report, "
+                    "runtime_bug_template, agent_behavior_template, "
+                    "anonymization_guide, suggested_title, "
+                    "runtime_bug_submit_url, agent_behavior_submit_url, "
+                    "duplicate_check_urls, missing_tool_hint, instructions."
+                ),
+            ),
+        ] = None,
         ctx: Context | None = None,
     ) -> dict[str, Any]:
         """
-        Collect diagnostic information for filing issue reports or feedback.
+        Get diagnostic information and templates for filing issue reports or feedback.
 
         This tool generates templates for TWO types of reports:
         1. **Runtime Bug Report** - For ha-mcp errors, failures, unexpected behavior
@@ -709,7 +737,10 @@ class BugReportTools:
         - "That was inefficient"
 
         **OUTPUT:**
-        Returns both templates plus diagnostic data. Key fields:
+        Returns both templates plus diagnostic data. The full response is
+        LARGE (the captured logs appear in the raw log keys AND inside each
+        template) — pass fields=... to fetch only the keys you need once you
+        know which template applies. Key fields:
         - `runtime_bug_template`, `agent_behavior_template` — pick based on context
         - `recent_logs`, `startup_logs` — captured ha-mcp tool/server log entries
         - `addon_logs` — addon container stdout/stderr (HA add-on installs only;
@@ -843,7 +874,7 @@ class BugReportTools:
             for keyword in search_keywords[:3]  # Limit to top 3 keywords
         ]
 
-        return {
+        result: dict[str, Any] = {
             "success": True,
             "diagnostic_info": diagnostic_info,
             "recent_logs": recent_logs,
@@ -934,6 +965,7 @@ class BugReportTools:
                 "CRITICAL: Always ANONYMIZE the report BEFORE presenting it in markdown code blocks!"
             ),
         }
+        return project_fields(result, fields)
 
 
 def register_bug_report_tools(mcp: Any, client: Any, **kwargs: Any) -> None: