ha-mcp-dev 8.4.3.dev2563__tar.gz → 8.4.3.dev2572__tar.gz

{ha_mcp_dev-8.4.3.dev2563/src/ha_mcp_dev.egg-info → ha_mcp_dev-8.4.3.dev2572}/PKG-INFO

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

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.4.3.dev2563"
+version = "8.4.3.dev2572"
 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-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/config.py

@@ -62,6 +62,10 @@ class Settings(BaseSettings):
     # Tool configuration
     fuzzy_threshold: int = Field(60, alias="FUZZY_THRESHOLD")
 
+    # Optional process-wide outer tool-call concurrency. Zero preserves the
+    # existing unlimited behavior; constrained installs can opt into queuing.
+    ha_tool_concurrency: int = Field(0, ge=0, le=32, alias="HA_TOOL_CONCURRENCY")
+
     # Smart-search config-fetch time budgets (seconds). Bound how long
     # ha_search spends fetching automation/script/scene
     # definitions during the per-id fallback before reporting a partial
@@ -890,6 +894,9 @@ ADVANCED_SETTINGS_FIELDS: tuple[AdvancedField, ...] = (
         True,
     ),
     # Operations.
+    AdvancedField(
+        "ha_tool_concurrency", "HA_TOOL_CONCURRENCY", int, "operations", True
+    ),
     AdvancedField("backup_hint", "BACKUP_HINT", str, "operations", True),
     AdvancedField("enable_websocket", "ENABLE_WEBSOCKET", bool, "operations", True),
     # Dashboard-screenshot engine URL (#1538): docker/.env users could set
@@ -1000,6 +1007,7 @@ _ADVANCED_SETTINGS_BOUNDS: dict[str, tuple[float, float]] = {
     "scene_config_time_budget": (1.0, 600.0),
     "individual_config_timeout": (1.0, 600.0),
     "individual_fetch_batch_size": (1, 100),
+    "ha_tool_concurrency": (1, 32),
     "code_mode_max_duration": (1.0, 300.0),
     "code_mode_max_memory": (1_048_576, 268_435_456),
     "code_mode_max_recursion": (1, 10_000),
@@ -1015,6 +1023,7 @@ _ADVANCED_SETTINGS_BOUNDS: dict[str, tuple[float, float]] = {
 # emits min=sentinel so the number input can still express "off"; the
 # override-apply and UI-POST paths accept the sentinel OR the bounded range.
 _ADVANCED_SETTINGS_SENTINELS: dict[str, int] = {
+    "ha_tool_concurrency": 0,
     "sidecar_pin_port": 0,
 }
 
@@ -1036,6 +1045,7 @@ _ADVANCED_SETTINGS_CHOICES: dict[str, tuple[str, ...]] = {
 # batches addon-origin writes and POSTs them via Supervisor.
 ADDON_SYNCED_ADVANCED_FIELDS: tuple[str, ...] = (
     "backup_hint",
+    "ha_tool_concurrency",
     "verify_ssl",
 )
 

ha_mcp_dev-8.4.3.dev2572/src/ha_mcp/ha_request_queue.py

@@ -0,0 +1,145 @@
+"""Cross-session concurrency control for Home Assistant tool calls."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextvars import ContextVar
+from typing import Any
+
+from fastmcp.server.middleware.middleware import CallNext, Middleware, MiddlewareContext
+
+from .errors import create_timeout_error
+from .tool_dispatch import (
+    CALL_PROXY_META_TOOLS,
+    LOCAL_ONLY_TOOLS,
+    OUTER_QUEUE_ORCHESTRATORS,
+    is_approval_management_call,
+)
+from .tools.helpers import raise_tool_error, safe_progress
+
+logger = logging.getLogger(__name__)
+
+_QUEUE_WAIT_TIMEOUT_SECONDS = 60.0
+_QUEUE_WAIT_HEARTBEAT_SECONDS = 15.0
+_QUEUE_WAIT_WARNING_SECONDS = 15.0
+
+
+def _bypasses_outer_queue(name: str, args: dict[str, Any]) -> bool:
+    """Return whether an outer envelope must run without a queue slot.
+
+    Proxy and orchestration envelopes leave admission to their nested dispatches.
+    Local search does not contact Home Assistant. Approval-management actions
+    must remain available while all configured slots are occupied.
+    """
+    return (
+        name in CALL_PROXY_META_TOOLS
+        or name in LOCAL_ONLY_TOOLS
+        or name in OUTER_QUEUE_ORCHESTRATORS
+        or is_approval_management_call(name, args)
+    )
+
+
+class HomeAssistantRequestQueueMiddleware(Middleware):
+    """Bound concurrent outer tool calls while allowing nested redispatch."""
+
+    def __init__(self, max_concurrency: int = 1) -> None:
+        if not 1 <= max_concurrency <= 32:
+            raise ValueError(
+                "ha_tool_concurrency middleware requires a value between 1 and 32; "
+                "0 is handled by not registering the middleware"
+            )
+        self._semaphore = asyncio.Semaphore(max_concurrency)
+        self._depth: ContextVar[int] = ContextVar(
+            f"ha_request_queue_depth_{id(self)}", default=0
+        )
+
+    async def _acquire_slot(self, context: MiddlewareContext, name: str) -> None:
+        """Acquire an outer-call slot with progress and a bounded wait."""
+        loop = asyncio.get_running_loop()
+        started = loop.time()
+        warned = False
+
+        if not self._semaphore.locked():
+            await self._semaphore.acquire()
+            logger.debug("HA tool queue: acquired slot tool=%s wait=0.000s", name)
+            return
+
+        logger.debug("HA tool queue: waiting for slot tool=%s", name)
+
+        while True:
+            elapsed = loop.time() - started
+            remaining = _QUEUE_WAIT_TIMEOUT_SECONDS - elapsed
+            if remaining <= 0:
+                logger.warning(
+                    "HA tool queue: timed out waiting for slot tool=%s wait=%.1fs",
+                    name,
+                    elapsed,
+                )
+                raise_tool_error(
+                    create_timeout_error(
+                        "Home Assistant tool queue admission",
+                        _QUEUE_WAIT_TIMEOUT_SECONDS,
+                        details=(
+                            f"Tool '{name}' did not start because all configured "
+                            "Home Assistant tool slots remained busy."
+                        ),
+                        context={"tool": name, "phase": "queue_wait"},
+                    )
+                )
+
+            ctx = getattr(context, "fastmcp_context", None)
+            await safe_progress(
+                ctx,
+                progress=0,
+                total=0,
+                message=f"Waiting for Home Assistant tool capacity: {name}",
+            )
+            try:
+                await asyncio.wait_for(
+                    self._semaphore.acquire(),
+                    timeout=min(_QUEUE_WAIT_HEARTBEAT_SECONDS, remaining),
+                )
+            except TimeoutError:
+                elapsed = loop.time() - started
+                if not warned and elapsed >= _QUEUE_WAIT_WARNING_SECONDS:
+                    warned = True
+                    logger.warning(
+                        "HA tool queue: still waiting for slot tool=%s wait=%.1fs",
+                        name,
+                        elapsed,
+                    )
+                continue
+
+            logger.debug(
+                "HA tool queue: acquired slot tool=%s wait=%.3fs",
+                name,
+                loop.time() - started,
+            )
+            return
+
+    async def on_call_tool(
+        self, context: MiddlewareContext, call_next: CallNext
+    ) -> Any:
+        if _bypasses_outer_queue(context.message.name, context.message.arguments or {}):
+            return await call_next(context)
+
+        depth = self._depth.get()
+        if depth:
+            token = self._depth.set(depth + 1)
+            try:
+                return await call_next(context)
+            finally:
+                self._depth.reset(token)
+
+        name = context.message.name
+        await self._acquire_slot(context, name)
+        try:
+            token = self._depth.set(1)
+            try:
+                return await call_next(context)
+            finally:
+                self._depth.reset(token)
+        finally:
+            self._semaphore.release()
+            logger.debug("HA tool queue: released slot tool=%s", name)

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/policy/middleware.py

@@ -13,6 +13,7 @@ from fastmcp.server.middleware.middleware import CallNext, Middleware, Middlewar
 
 from ..errors import ErrorCode, create_error_response
 from ..renamed_tools import current_tool_name
+from ..tool_dispatch import CALL_PROXY_META_TOOLS, is_approval_management_call
 from ..tools.helpers import raise_tool_error, safe_progress
 from .approval_queue import ApprovalQueue, PendingApproval, compute_args_hash
 from .evaluator import (
@@ -26,48 +27,12 @@ from .model import Policy, Rule
 
 logger = logging.getLogger(__name__)
 
-# Dispatching call proxies are a strict subset of the ungated tool-search
-# meta-tools. Only these three execute their envelope's ``name``; search merely
-# returns catalog metadata and must not be unwrapped by other middleware.
-# Gating a call proxy directly would be wrong: rule predicates target the real
-# tool's args (for example args.domain), while the proxy receives a wrapped
-# {"name": "...", "arguments": {...}} envelope. Its dispatch re-enters the
-# middleware chain with the real name and args, so the inner call is gated there.
-CALL_PROXY_META_TOOLS = frozenset(
-    {
-        "ha_call_read_tool",
-        "ha_call_write_tool",
-        "ha_call_delete_tool",
-    }
-)
-# Policy itself also leaves catalog search ungated; unlike the call proxies it
-# never dispatches a tool named in client-supplied arguments.
 PROXY_META_TOOLS = CALL_PROXY_META_TOOLS | {"ha_search_tools"}
 
-# ha_dev_manage_server actions that MANAGE the approval queue itself.
-# Gating these deadlocks by construction: with a wildcard (or
-# ha_dev_manage_server) rule in place, an MCP-only "approve" call would
-# itself require approval — creating a second pending entry instead of
-# deciding the first, so nothing can ever be approved through the tool.
-# Only the queue-management actions are exempt; update_source / restart
-# remain gateable like any other high-stakes action. The exemption is not
-# a free self-approval: approve/deny separately require the
-# dev_tools_security_policy_access setting (off by default, issue #2141).
-_APPROVAL_MANAGEMENT_TOOL = "ha_dev_manage_server"
-_APPROVAL_MANAGEMENT_ACTIONS = frozenset({"list_pending", "approve", "deny"})
-
-
-def _is_approval_management(name: str, args: dict[str, Any]) -> bool:
-    """True for dev-tool calls that manage the approval queue itself."""
-    return (
-        name == _APPROVAL_MANAGEMENT_TOOL
-        and args.get("action") in _APPROVAL_MANAGEMENT_ACTIONS
-    )
-
 
 def _passes_ungated(name: str, args: dict[str, Any]) -> bool:
     """Calls that must bypass gating: proxy meta-tools + queue management."""
-    return name in PROXY_META_TOOLS or _is_approval_management(name, args)
+    return name in PROXY_META_TOOLS or is_approval_management_call(name, args)
 
 
 class PolicyMiddleware(Middleware):

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/read_only.py

@@ -39,8 +39,8 @@ from fastmcp.tools import Tool
 
 from .config import get_global_settings
 from .errors import ErrorCode, create_error_response
-from .policy.middleware import CALL_PROXY_META_TOOLS
 from .renamed_tools import current_tool_name
+from .tool_dispatch import CALL_PROXY_META_TOOLS
 from .tools.helpers import raise_tool_error
 
 if TYPE_CHECKING:

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/server.py

@@ -289,6 +289,15 @@ class HomeAssistantSmartMCPServer:
         # wraps the final tool surface (including the search proxies).
         self._apply_tool_security_policies()
 
+        # Constrained installs can opt into cross-session tool queuing. This
+        # sits after approval gates so a call awaiting approval holds no slot.
+        if self.settings.ha_tool_concurrency:
+            from .ha_request_queue import HomeAssistantRequestQueueMiddleware
+
+            self.mcp.add_middleware(
+                HomeAssistantRequestQueueMiddleware(self.settings.ha_tool_concurrency)
+            )
+
         # Known-secret-value scrub (#2157) — registered just before the
         # visibility outbound half so that half stays innermost (its scan
         # must see truly raw output; a secret value could embed a hidden

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/_handlers_advanced.py

@@ -3,7 +3,8 @@
 Factory returning the ``get_advanced_settings`` / ``save_advanced_settings``
 handlers over the ``ADVANCED_SETTINGS_FIELDS`` registry. Most advanced
 fields write to the shared ``feature_flags.json`` override file;
-``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``verify_ssl``) route
+``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``ha_tool_concurrency``,
+``verify_ssl``) route
 through the Supervisor add-on options in add-on mode instead.
 
 Handlers are module-level (own C901 budget); ``build_advanced_handlers``
@@ -131,10 +132,10 @@ async def _get_advanced_settings(
     Mirrors ``_get_feature_flags`` / ``_get_backup_config`` but for the
     ``ADVANCED_SETTINGS_FIELDS`` registry. Most advanced fields write to
     ``feature_flags.json`` via the shared override file in either deployment
-    mode. ``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``verify_ssl``)
-    are an exception: in addon mode they have ``origin="addon"`` (editable)
-    and saves route through Supervisor so the add-on Configuration tab and
-    the web UI share state.
+    mode. ``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``,
+    ``ha_tool_concurrency``, ``verify_ssl``) are an exception: in addon mode
+    they have ``origin="addon"`` (editable) and saves route through Supervisor
+    so the add-on Configuration tab and the web UI share state.
     """
     from ha_mcp.settings_ui import is_http_settings_mounted
 
@@ -327,7 +328,7 @@ def _validate_one_advanced_field(
                 status_code=409,
             ),
         )
-    # Addon-synced fields (e.g. backup_hint, verify_ssl) are editable in
+    # Addon-synced fields (backup_hint, ha_tool_concurrency, verify_ssl) are editable in
     # addon mode even though their env vars are set — start.py rewrites them
     # from /data/options.json on every boot, so route the write through
     # Supervisor instead of the override file.
@@ -525,11 +526,11 @@ async def _save_advanced_settings(
 ) -> JSONResponse:
     """Persist UI-edited advanced settings.
 
-    Addon-synced fields (``backup_hint``, ``verify_ssl``) in add-on mode
-    route through Supervisor; everything else atomically merges into the
-    shared ``feature_flags.json`` override file. Either sink responds with
-    ``restart_required=True`` (most advanced fields gate one-time startup
-    paths).
+    Addon-synced fields (``backup_hint``, ``ha_tool_concurrency``,
+    ``verify_ssl``) in add-on mode route through Supervisor; everything else
+    atomically merges into the shared ``feature_flags.json`` override file.
+    Either sink responds with ``restart_required=True`` (most advanced fields
+    gate one-time startup paths).
     """
     from ..config import ADVANCED_SETTINGS_FIELDS
 

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/cs.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Časový limit pro každé načtení konfigurace automatizace/skriptu/scény. Rozsah 1–600. Vyžadován restart.",
     "advanced.individual_fetch_batch_size.label": "Velikost dávky načítání konfigurace",
     "advanced.individual_fetch_batch_size.help": "Souběžné načítání konfigurací podle ID. Snižte směrem k 1 na sériových HA serverech. Rozsah 1–100. Vyžadován restart.",
+    "advanced.ha_tool_concurrency.label": "Souběžnost nástrojů Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Volitelný limit pro vnější volání nástrojů Home Assistant napříč všemi relacemi. Vnitřní souběžnost REST, WebSocket a distribuce pro jednotlivé nástroje zůstává nezměněna. Hodnota 0 zachovává neomezené chování. Volání čekající na kapacitu selže po 60 sekundách. Rozsah 0–32. Vyžadován restart.",
     "advanced.backup_hint.label": "Úroveň nápovědy k zálohování",
     "advanced.backup_hint.help": "Určuje, jak silně je LLM vyzváno k vytvoření úplného snímku HA před rizikovými zápisy.",
     "advanced.backup_hint.choices.strong": "Silná",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Nástroje zde uvedené jsou uzamčeny jako připnuté — zobrazují se v horní části karty Nástroje a nelze je odepnout z webového uživatelského rozhraní Nastavení, aniž byste nejprve zrušili toto nastavení. Užitečné v kombinaci s vyhledáváním nástrojů. Názvy nástrojů oddělené čárkami.",
     "addon.verify_ssl.name": "Ověřit certifikát TLS",
     "addon.verify_ssl.description": "Ověřit TLS certifikát serveru Home Assistant. Aplikace (doplněk) se připojuje přes proxy Supervisor, takže to obvykle nemá žádný vliv a mělo by to zůstat zapnuté. Zakazujte pouze v případě, že jste přenastavili aplikaci (doplněk) tak, aby komunikovala s HA přes veřejný HTTPS hostname s The self-signed certifikátem nebo neshodou hostname. Vypnutí oslabuje zabezpečení přenosu – nechte zapnuté, pokud víte, že to potřebujete. Vyžaduje restart, aby se projevilo.",
+    "addon.ha_tool_concurrency.name": "Souběžnost nástrojů Home Assistant",
+    "addon.ha_tool_concurrency.description": "Volitelný limit pro vnější volání nástrojů Home Assistant napříč všemi relacemi. Vnitřní souběžnost REST, WebSocket a distribuce pro jednotlivé nástroje zůstává nezměněna. Hodnota 0 zachovává neomezené chování. Volání čekající na kapacitu selže po 60 sekundách.",
     "addon_stable.enable_tool_search.description": "Nahradit úplný katalog nástrojů vyhledáváním. Snižuje klidový kontext přibližně o 90 %, na asi 5 tisíc tokenů. ⚠️ NEZAPÍNEJTE toto v klientech s vlastním vestavěným vyhledáváním nástrojů / odloženými nástroji (claude.ai, Claude Desktop, Claude Code) – obě vrstvy vyhledávání se střetávají a vestavěné vyhledávání nástrojů v klientovi je zde lepší volbou; nechte to vypnuté. Zda jsou nástroje odloženy, závisí na kombinaci vašeho klienta a modelu: použijte toto, když vaše nastavení načítá celý katalog předem – modely bez nativních odložených nástrojů (např. Gemini, lokální modely kompatibilní s OpenAI, Claude Haiku), klienti, kteří vkládají všechna schémata nástrojů bez ohledu na model (např. GitHub Copilot CLI), nebo menší kontextová okna. Některé modely Codex a ChatGPT také obsahují odložené nástroje – ověřte si funkce přímo u svého klienta/modelu, abyste to nenechávali zbytečně zapnuté. Nástroje se vyhledávají přes ha_search_tools a spouštějí se přes kategorizované proxy (read/write/delete). Vyžaduje restart aplikace (doplněku), aby se projevila změna – poté znovu připojte nebo obnovte MCP server ve svém AI klientovi, aby se znovu načetl seznam nástrojů. Samotný restart aplikace (doplněku) NEAKTUALIZUJE mezipaměť seznamu nástrojů klienta; toto platí po změně jakéhokoli nastavení zde."
   },
   "tools": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/de.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Timeout für jeden Automatisierungs-/Skript-/Szenen-Konfigurations-Abruf. Bereich 1-600. Neustart erforderlich.",
     "advanced.individual_fetch_batch_size.label": "Konfigurations-Abruf-Batch-Größe",
     "advanced.individual_fetch_batch_size.help": "Gleichzeitige Pro-ID-Konfigurations-Abrufe. Senke auf 1 bei seriellen HA-Servern. Bereich 1-100. Neustart erforderlich.",
+    "advanced.ha_tool_concurrency.label": "Home-Assistant-Tool-Gleichzeitigkeit",
+    "advanced.ha_tool_concurrency.help": "Optionales Limit für äußere Home-Assistant-Tool-Aufrufe über alle Sitzungen hinweg. Interne REST-, WebSocket- und tool-spezifische Fan-Out-Gleichzeitigkeit bleibt unverändert. 0 behält das unbegrenzte Verhalten bei. Ein auf Kapazität wartender Aufruf schlägt nach 60 Sekunden fehl. Bereich 0–32. Neustart erforderlich.",
     "advanced.backup_hint.label": "Backup-Hinweis-Level",
     "advanced.backup_hint.help": "Steuert, wie stark das LLM aufgefordert wird, einen vollständigen HA-Snapshot vor riskanten Schreibvorgängen zu erstellen.",
     "advanced.backup_hint.choices.strong": "Stark",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Hier aufgelistete Tools sind gesperrt angeheftet – sie erscheinen oben im Tools-Tab und können nicht vom Web-Settings-UI entfernt werden, ohne diese Option zuerst zu entfernen. Nützlich in Kombination mit Tool Search. Kommagetrennte Tool-Namen.",
     "addon.verify_ssl.name": "TLS-Zertifikat verifizieren",
     "addon.verify_ssl.description": "Überprüfe das TLS-Zertifikat des Home Assistant-Servers. Die App (das Add-on) verbindet sich über den Supervisor-Proxy, daher hat dies normalerweise keine Auswirkungen und sollte aktiviert bleiben. Deaktiviere es nur, wenn du die App (das Add-on) so rekonfiguriert hast, dass sie über einen öffentlichen HTTPS-Hostnamen mit einem selbstsignierten Zertifikat oder einem Hostnamen-Mismatch mit HA kommuniziert. Das Deaktivieren schwächt die Transportsicherheit — lasse es eingeschaltet, es sei denn, du weißt, dass du es brauchst. Erfordert einen Neustart, um wirksam zu werden.",
+    "addon.ha_tool_concurrency.name": "Home-Assistant-Tool-Gleichzeitigkeit",
+    "addon.ha_tool_concurrency.description": "Optionales Limit für äußere Home-Assistant-Tool-Aufrufe über alle Sitzungen hinweg. Interne REST-, WebSocket- und tool-spezifische Fan-Out-Gleichzeitigkeit bleibt unverändert. 0 behält das unbegrenzte Verhalten bei. Ein auf Kapazität wartender Aufruf schlägt nach 60 Sekunden fehl.",
     "addon_stable.enable_tool_search.description": "Ersetze den vollständigen Tool-Katalog durch eine suchend basierte Erkennung. Reduziert den Leerlaufkontext um etwa 90 % auf ca. 5K Token. ⚠️ Aktiviere dies NICHT in Clients mit eigener integrierter Tool-Suche / verzögerten Tools (claude.ai, Claude Desktop, Claude Code) — die beiden Suchschichten kollidieren, und die integrierte Tool-Suche des Clients ist dort die bessere Wahl; lasse dies ausgeschaltet. Ob Tools verzögert werden, hängt von deiner Client- und Modellkombination ab: Verwende dies, wenn dein Setup den vollständigen Katalog im Voraus lädt — Modelle ohne native verzögerte Tools (z. B. Gemini, OpenAI-kompatible lokale Modelle, Claude Haiku), Clients, die alle Tool-Schemas unabhängig vom Modell einbetten (z. B. GitHub Copilot CLI), oder kleinere Kontextfenster. Einige Codex-Modelle und ChatGPT beinhalten ebenfalls verzögerte Tools — überprüfe deinen Client bzw. dein Modell direkt, um dessen Funktionen zu bestätigen, damit du dies nicht unnötig aktiviert lässt. Tools werden über ha_search_tools gefunden und über kategorisierte Proxys (lesen/schreiben/löschen) ausgeführt. Erfordert einen App-(Add-on-)Neustart, um wirksam zu werden — verbinde dich danach neu oder aktualisiere den MCP-Server in deinem KI-Client, damit dieser die Tool-Liste neu lädt. Das alleinige Neustarten der App (des Add-ons) aktualisiert die zwischengespeicherte Tool-Liste eines Clients NICHT; dies gilt nach jeder Änderung einer Einstellung hier."
   },
   "tool_groups": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/en.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Timeout for each automation/script/scene config fetch. Range 1–600. Restart required.",
     "advanced.individual_fetch_batch_size.label": "Config fetch batch size",
     "advanced.individual_fetch_batch_size.help": "Concurrent per-ID config fetches. Lower toward 1 on serial HA servers. Range 1–100. Restart required.",
+    "advanced.ha_tool_concurrency.label": "Home Assistant tool concurrency",
+    "advanced.ha_tool_concurrency.help": "Optional limit on outer Home Assistant tool calls across all sessions. Internal REST, WebSocket, and per-tool fan-out concurrency is unchanged. 0 keeps unlimited behavior. A call waiting for capacity fails after 60 seconds. Range 0–32. Restart required.",
     "advanced.backup_hint.label": "Backup-hint level",
     "advanced.backup_hint.help": "Controls how strongly the LLM is prompted to take a full HA snapshot before risky writes.",
     "advanced.backup_hint.choices.strong": "Strong",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Tools listed here are locked pinned — they appear at the top of the Tools tab and cannot be unpinned from the web Settings UI without unsetting this option first. Useful in combination with Tool Search. Comma-separated tool names.",
     "addon.verify_ssl.name": "Verify TLS certificate",
     "addon.verify_ssl.description": "Verify the Home Assistant server's TLS certificate. The app (add-on) connects via the Supervisor proxy, so this normally has no effect and should stay enabled. Disable only if you've reconfigured the app (add-on) to talk to HA over a public HTTPS hostname with a self-signed certificate or hostname mismatch. Disabling weakens transport security — leave on unless you know you need it. Requires restart to take effect.",
+    "addon.ha_tool_concurrency.name": "Home Assistant tool concurrency",
+    "addon.ha_tool_concurrency.description": "Optional limit on outer Home Assistant tool calls across all sessions. Internal REST, WebSocket, and per-tool fan-out concurrency is unchanged. 0 keeps unlimited behavior. A call waiting for capacity fails after 60 seconds.",
     "addon_stable.enable_tool_search.description": "Replace the full tool catalog with search-based discovery. Reduces idle context by roughly 90%, to about 5K tokens. ⚠️ Do NOT enable this in clients with their own built-in tool search / deferred tools (claude.ai, Claude Desktop, Claude Code) — the two search layers conflict, and the client's built-in tool search is the better choice there; leave this off. Whether tools are deferred depends on your client and model combination: use this when your setup loads the full catalog up front — models without native deferred tools (e.g. Gemini, OpenAI-compatible local models, Claude Haiku), clients that inline all tool schemas regardless of model (e.g. GitHub Copilot CLI), or smaller context windows. Some Codex models and ChatGPT include deferred tools too — check your client/model directly to confirm its features so you don't leave this enabled unnecessarily. Tools are found via ha_search_tools and executed via categorized proxies (read/write/delete). Requires an app (add-on) restart to take effect — then reconnect or refresh the MCP server in your AI client so it reloads the tool list. Restarting the app (add-on) alone does NOT refresh a client's cached tool list; this applies after changing any setting here."
   },
   "tool_groups": {},

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/eo.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Limtempo por ĉiu akirado de aŭtomatiga/skripta/scena agordo. Gamo 1–600. Restartigo necesas.",
     "advanced.individual_fetch_batch_size.label": "Grandeco de agorda akira aro",
     "advanced.individual_fetch_batch_size.help": "Samtempaj agordaj akiroj por ĉiu ID. Malaltigu al 1 ĉe seriaj HA-serviloj. Gamo 1–100. Restartigo necesas.",
+    "advanced.ha_tool_concurrency.label": "Konkureco de hejmaŭtomatigaj iloj de Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Laŭvola limo pri eksteraj vokoj al Home Assistant-iloj tra ĉiuj sesioj. Interna REST-, WebSocket-, kaj perila disbranĉiĝa konkureco restas neŝanĝita. 0 tenas la senliman konduton. Voko atendanta je kapablo malsukcesas post 60 sekundoj. Intervalo 0–32. Postiĝas restartigo.",
     "advanced.backup_hint.label": "Nivelo de rezerva sugesto",
     "advanced.backup_hint.help": "Regulas kiom forte la LLM estas instigita fari plenan HA-momentfoton antaŭ riskaj skriboj.",
     "advanced.backup_hint.choices.strong": "Forta",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Iloj listigitaj ĉi tie estas ŝlositaj fiksitaj — ili aperas ĉe la supro de la langeto 'Iloj' kaj ne povas esti malfiksitaj de la reta Agorda UI sen unue malaktivigi ĉi tiun opcion. Utila kombine kun 'Ilo-Serĉo'. Ilnomoj disigitaj per komoj.",
     "addon.verify_ssl.name": "Kontroli TLS-atestilon",
     "addon.verify_ssl.description": "Kontrolu la TLS-atestilon de la servilo Home Assistant. La programo (aldonaĵo) konektiĝas per la provkuratora prokurservilo (Supervisor proxy), do ĉi tio kutime havas neniun efikon kaj devas resti ebligita. Malŝaltu nur se vi reagordis la programon (aldonaĵo) por komuniki kun HA per publika HTTPS-gastnomo kun memsubskribita atestilo aŭ malkongruo de gastnomo. Malŝalto malfortigas transportan sekurecon — lasu ebligita krom se vi scias, ke vi bezonas tion. Postulas restartigon por ekvalidi.",
+    "addon.ha_tool_concurrency.name": "Konkureco de hejmaŭtomatigaj iloj de Home Assistant",
+    "addon.ha_tool_concurrency.description": "Laŭvola limo pri eksteraj vokoj al Home Assistant-iloj tra ĉiuj sesioj. Interna REST-, WebSocket-, kaj perila disbranĉiĝa konkureco restas neŝanĝita. 0 tenas la senliman konduton. Voko atendanta je kapablo malsukcesas post 60 sekundoj.",
     "addon_stable.enable_tool_search.description": "Anstataŭigu la plenan il-katalogon per serĉ-bazita malkovro. Reduktas senchovan kuntekston je ĉirkaŭ 90%, ĝis proksimume 5K tokenoj. ⚠️ NE ebligu ĉi tion en klientoj kun propra enkonstruita il-serĉo / prokrastitaj iloj (claude.ai, Claude Desktop, Claude Code) — la du serĉ-tavoloj konfliktas, kaj la enkonstruita il-serĉo de la kliento estas la pli bona elekto tie; lasu ĉi tion malŝaltita. Ĉu iloj estas prokrastitaj dependas de via kliento kaj modelo-kombinaĵo: uzu ĉi tion kiam via agordo ŝarĝas la plenan katalogon frue — modeloj sen denaskaj prokrastitaj iloj (ekz. Gemini, OpenAI-kongruaj lokaj modeloj, Claude Haiku), klientoj kiuj enlinias ĉiujn il-skemojn sendepende de modelo (ekz. GitHub Copilot CLI), aŭ pli malgrandaj kuntekstaj fenestroj. Kelkaj Codex-modeloj kaj ChatGPT ankaŭ inkluzivas prokrastitajn ilojn — kontrolu rekte vian klienton/modelon por konfirmi ties funkciojn, por ke vi ne lasu ĉi tion ebligita senbezone. Iloj estas trovitaj per ha_search_tools kaj ekzekutitaj per kategoriigitaj prokurserviloj (legado/skribado/forigo). Postulas restartigon de la programo (aldonaĵo) por ekvalidi — tiam reKonekti aŭ aktualigi la MCP-servilon en via AI-kliento por ke ĝi reŝarĝu la il-liston. Restartigi la programon (aldonaĵo) sole NE aktualigas la kaŝmemoritan il-liston de kliento; ĉi tio aplikiĝas post ŝanĝo de iu ajn agordo ĉi tie."
   },
   "tools": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/es.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Tiempo de espera de cada obtención de configuración de automatización, script o escena. Rango 1–600. Hay que reiniciar.",
     "advanced.individual_fetch_batch_size.label": "Tamaño del lote de obtención de configuraciones",
     "advanced.individual_fetch_batch_size.help": "Obtenciones de configuración por ID en paralelo. Bájalo hacia 1 en servidores HA que responden en serie. Rango 1–100. Hay que reiniciar.",
+    "advanced.ha_tool_concurrency.label": "Concurrencia de herramientas de Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Límite opcional en las llamadas externas a herramientas de Home Assistant en todas las sesiones. La concurrencia interna de REST, WebSocket y de distribución por herramienta no se modifica. 0 mantiene el comportamiento ilimitado. Una llamada que espera capacidad falla después de 60 segundos. Rango de 0 a 32. Requiere reinicio.",
     "advanced.backup_hint.label": "Nivel de la indicación de copia de seguridad",
     "advanced.backup_hint.help": "Controla con cuánta insistencia se pide al LLM que haga una instantánea completa de HA antes de escrituras arriesgadas.",
     "advanced.backup_hint.choices.strong": "Fuerte",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Las herramientas indicadas aquí quedan fijadas de forma bloqueada: aparecen en la parte superior de la pestaña Herramientas y no se pueden desfijar desde la interfaz web de ajustes sin quitar antes esta opción. Resulta útil en combinación con la búsqueda de herramientas. Nombres de herramientas separados por comas.",
     "addon.verify_ssl.name": "Verificar el certificado TLS",
     "addon.verify_ssl.description": "Verifica el certificado TLS del servidor de Home Assistant. La app (add-on) se conecta a través del proxy del Supervisor, por lo que normalmente esto no tiene efecto y debe permanecer habilitado. Desactívalo solo si has reconfigurado la app (add-on) para comunicarse con HA a través de un nombre de host HTTPS público con un certificado autofirmado o un error de coincidencia en el nombre de host. Desactivarlo debilita la seguridad del transporte; déjalo activado a menos que sepas que lo necesitas. Requiere reiniciar para aplicar los cambios.",
+    "addon.ha_tool_concurrency.name": "Concurrencia de herramientas de Home Assistant",
+    "addon.ha_tool_concurrency.description": "Límite opcional en las llamadas externas a herramientas de Home Assistant en todas las sesiones. La concurrencia interna de REST, WebSocket y de distribución por herramienta no se modifica. 0 mantiene el comportamiento ilimitado. Una llamada que espera capacidad falla después de 60 segundos.",
     "addon_stable.enable_tool_search.description": "Reemplaza el catálogo completo de herramientas por un descubrimiento basado en búsquedas. Reduce el contexto inactivo en aproximadamente un 90 %, a unos 5K tokens. ⚠️ NO habilites esto en clientes que tengan su propia búsqueda de herramientas integrada / herramientas diferidas (claude.ai, Claude Desktop, Claude Code); ambas capas de búsqueda entran en conflicto y la búsqueda de herramientas integrada del cliente es la mejor opción en ese caso; déjalo desactivado. El hecho de que las herramientas se diferieran depende de tu combinación de cliente y modelo: úsalo cuando tu configuración cargue el catálogo completo de entrada (modelos sin herramientas diferidas nativas, por ejemplo, Gemini, modelos locales compatibles con OpenAI, Claude Haiku), clientes que insertan todos los esquemas de herramientas sin importar el modelo (por ejemplo, GitHub Copilot CLI), o ventanas de contexto más pequeñas. Algunos modelos de Codex y ChatGPT también incluyen herramientas diferidas; comprueba directamente tu cliente/modelo para confirmar sus características y no dejar esto habilitado innecesariamente. Las herramientas se encuentran mediante ha_search_tools y se ejecutan a través de proxies categorizados (lectura/escritura/eliminación). Requiere reiniciar la app (add-on) para que surta efecto; a continuación, reconecta o actualiza el servidor MCP en tu cliente de IA para que recargue la lista de herramientas. Reiniciar solo la app (add-on) NO actualiza la lista de herramientas almacenada en caché del cliente; esto se aplica después de cambiar cualquier configuración aquí."
   },
   "tool_groups": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/fr.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Délai d'attente pour chaque récupération de configuration d'automatisation/script/scène. Plage 1–600. Redémarrage requis.",
     "advanced.individual_fetch_batch_size.label": "Taille du lot de récupération de configuration",
     "advanced.individual_fetch_batch_size.help": "Récupérations simultanées de configuration par ID. Diminue vers 1 sur les serveurs HA série. Plage 1–100. Redémarrage requis.",
+    "advanced.ha_tool_concurrency.label": "Concurrence des outils Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Limite optionnelle sur les appels d'outils Home Assistant externes pour toutes les sessions. La concurrence interne pour REST, WebSocket et par outil reste inchangée. 0 conserve un comportement illimité. Un appel en attente de capacité échoue après 60 secondes. Plage de 0 à 32. Redémarrage requis.",
     "advanced.backup_hint.label": "Niveau d'indication de sauvegarde",
     "advanced.backup_hint.help": "Contrôle la force avec laquelle le LLM est invité à effectuer un instantané HA complet avant les écritures risquées.",
     "advanced.backup_hint.choices.strong": "Fort",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Les outils listés ici sont verrouillés épinglés — ils apparaissent en haut de l'onglet Outils et ne peuvent pas être retirés de l'interface Web des paramètres sans d'abord supprimer cette option. Utile en combinaison avec la recherche d'outils. Noms d'outils séparés par des virgules.",
     "addon.verify_ssl.name": "Vérifier le certificat TLS",
     "addon.verify_ssl.description": "Vérifier le certificat TLS du serveur Home Assistant. L'application (add-on) se connecte via le proxy du Supervisor, cela n'a donc normalement aucun effet et doit rester activé. Désactivez uniquement si vous avez reconfiguré l'application (add-on) pour communiquer avec HA via un nom d'hôte HTTPS public avec un certificat auto-signé ou une non-correspondance de nom d'hôte. La désactivation affaiblit la sécurité du transport — laissez activé sauf si vous savez que vous en avez besoin. Nécessite un redémarrage pour prendre effet.",
+    "addon.ha_tool_concurrency.name": "Concurrence des outils Home Assistant",
+    "addon.ha_tool_concurrency.description": "Limite optionnelle sur les appels d'outils Home Assistant externes pour toutes les sessions. La concurrence interne pour REST, WebSocket et par outil reste inchangée. 0 conserve un comportement illimité. Un appel en attente de capacité échoue après 60 secondes.",
     "addon_stable.enable_tool_search.description": "Remplacer le catalogue complet d'outils par une découverte basée sur la recherche. Réduit le contexte inactif d'environ 90 %, à environ 5K jetons. ⚠️ N'activez PAS cette option dans les clients disposant de leur propre recherche d'outils intégrée / d'outils différés (claude.ai, Claude Desktop, Claude Code) — les deux couches de recherche entrent en conflit, et la recherche d'outils intégrée du client constitue le meilleur choix dans ce cas ; laissez cette option désactivée. Le fait que les outils soient différés dépend de votre association client et modèle : utilisez cette option lorsque votre configuration charge le catalogue complet au départ — modèles sans outils différés natifs (par ex. Gemini, modèles locaux compatibles OpenAI, Claude Haiku), clients qui intègrent tous les schémas d'outils quel que soit le modèle (par ex. GitHub Copilot CLI), ou fenêtres de contexte plus petites. Certains modèles Codex et ChatGPT incluent également des outils différés — vérifiez directement votre client/modèle pour confirmer ses fonctionnalités afin de ne pas laisser cette option activée inutilement. Les outils sont trouvés via ha_search_tools et exécutés via des proxys catégorisés (lecture/écriture/suppression). Nécessite un redémarrage de l'application (add-on) pour prendre effet — puis reconnectez ou actualisez le serveur MCP dans votre client IA afin qu'il recharge la liste des outils. Le seul redémarrage de l'application (add-on) ne met PAS à jour la liste des outils mise en cache par un client ; cela s'applique après la modification de n'importe quel paramètre ici."
   },
   "tool_groups": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/it.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Timeout di ogni recupero di configurazione di automazione, script o scena. Intervallo 1–600. È necessario il riavvio.",
     "advanced.individual_fetch_batch_size.label": "Dimensione del lotto di recupero delle configurazioni",
     "advanced.individual_fetch_batch_size.help": "Recuperi di configurazione per singolo ID eseguiti in parallelo. Avvicinati a 1 sui server HA che lavorano in sequenza. Intervallo 1–100. È necessario il riavvio.",
+    "advanced.ha_tool_concurrency.label": "Concorrenza degli strumenti di Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Limite opzionale sulle chiamate esterne agli strumenti di Home Assistant in tutte le sessioni. La concorrenza interna di REST, WebSocket e fan-out per strumento rimane invariata. 0 mantiene il comportamento illimitato. Una chiamata in attesa di capacità fallisce dopo 60 secondi. Intervallo 0–32. Riavvio necessario.",
     "advanced.backup_hint.label": "Livello del suggerimento di backup",
     "advanced.backup_hint.help": "Controlla con quanta insistenza l'LLM viene invitato a creare uno snapshot completo di HA prima delle scritture rischiose.",
     "advanced.backup_hint.choices.strong": "Forte",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Gli strumenti elencati qui restano fissati in modo bloccato: compaiono in cima alla scheda Strumenti e non possono essere sganciati dall'interfaccia web delle impostazioni senza prima togliere questa opzione. Utile in combinazione con la ricerca degli strumenti. Nomi degli strumenti separati da virgole.",
     "addon.verify_ssl.name": "Verifica il certificato TLS",
     "addon.verify_ssl.description": "Verifica il certificato TLS del server Home Assistant. L'app (componente aggiuntivo) si connette tramite il proxy Supervisor, quindi questo normalmente non ha effetto e dovrebbe rimanere abilitato. Disabilita solo se hai riconfigurato l'app (componente aggiuntivo) per comunicare con HA su un nome host HTTPS pubblico con un certificato autofirmato o una discrepanza del nome host. La disabilitazione indebolisce la sicurezza del trasporto: lasciala attiva a meno che tu non sappia di averne bisogno. Richiede il riavvio per avere effetto.",
+    "addon.ha_tool_concurrency.name": "Concorrenza degli strumenti di Home Assistant",
+    "addon.ha_tool_concurrency.description": "Limite opzionale sulle chiamate esterne agli strumenti di Home Assistant in tutte le sessioni. La concorrenza interna di REST, WebSocket e fan-out per strumento rimane invariata. 0 mantiene il comportamento illimitato. Una chiamata in attesa di capacità fallisce dopo 60 secondi.",
     "addon_stable.enable_tool_search.description": "Sostituisci il catalogo completo degli strumenti con la scoperta basata sulla ricerca. Riduce il contesto inattivo di circa il 90%, a circa 5K token. ⚠️ NON abilitare questa opzione nei client con ricerca di strumenti integrata / strumenti differiti (claude.ai, Claude Desktop, Claude Code) — i due livelli di ricerca entrano in conflitto e la ricerca di strumenti integrata del client è la scelta migliore in quel caso; lasciala disattivata. Se gli strumenti siano differiti dipende dalla combinazione di client e modello: usalo quando la tua configurazione carica l'intero catalogo in anticipo — modelli senza strumenti differiti nativi (es. Gemini, modelli locali compatibili con OpenAI, Claude Haiku), client che inseriscono tutti gli schemi di strumenti indipendentemente dal modello (es. GitHub Copilot CLI), o finestre di contesto più piccole. Alcuni modelli Codex e ChatGPT includono anch'essi strumenti differiti — verifica direttamente il tuo client/modello per confermare le sue funzionalità in modo da non lasciare questa opzione abilitata inutilmente. Gli strumenti vengono trovati tramite ha_search_tools ed eseguiti tramite proxy categorizzati (lettura/scrittura/eliminazione). Richiede il riavvio dell'app (componente aggiuntivo) per avere effetto — quindi riconnettiti o aggiorna il server MCP nel tuo client di IA in modo che ricarichi l'elenco degli strumenti. Il solo riavvio dell'app (componente aggiuntivo) NON aggiorna l'elenco degli strumenti memorizzato nella cache di un client; questo si applica dopo aver modificato qualsiasi impostazione qui."
   },
   "tool_groups": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/ko.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "자동화/스크립트/장면 설정을 각각 가져올 때의 제한 시간입니다. 범위 1~600. 다시 시작해야 합니다.",
     "advanced.individual_fetch_batch_size.label": "설정 조회 배치 크기",
     "advanced.individual_fetch_batch_size.help": "ID별 설정 조회를 동시에 몇 건까지 할지 정합니다. 직렬 처리에 가까운 HA 서버에서는 1에 가깝게 낮추세요. 범위 1~100. 다시 시작해야 합니다.",
+    "advanced.ha_tool_concurrency.label": "Home Assistant 도구 동시성",
+    "advanced.ha_tool_concurrency.help": "모든 세션에 걸친 외부 Home Assistant 도구 호출에 대한 선택적 제한입니다. 내부 REST, WebSocket 및 도구별 팬아웃 동시성은 변경되지 않습니다. 0은 무제한 동작을 유지합니다. 용량을 기다리는 호출은 60초 후에 실패합니다. 범위는 0~32입니다. 다시 시작이 필요합니다.",
     "advanced.backup_hint.label": "백업 권유 강도",
     "advanced.backup_hint.help": "위험한 쓰기 작업 전에 HA 전체 스냅숏을 만들도록 LLM에 얼마나 강하게 권유할지 정합니다.",
     "advanced.backup_hint.choices.strong": "강하게",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "여기에 나열한 도구는 고정 상태로 잠깁니다. 도구 탭 맨 위에 표시되며, 이 옵션을 먼저 해제하지 않으면 웹 설정 UI에서 고정을 해제할 수 없습니다. 도구 검색과 함께 쓰면 유용합니다. 도구 이름을 쉼표로 구분해 입력하세요.",
     "addon.verify_ssl.name": "TLS 인증서 검증",
     "addon.verify_ssl.description": "Home Assistant 서버의 TLS 인증서를 검증합니다. 앱(애드온)은 Supervisor 프록시를 통해 연결하므로 보통 아무 영향이 없으며 켜 두는 것이 좋습니다. 자체 서명 인증서나 호스트 이름이 일치하지 않는 공개 HTTPS 호스트 이름으로 HA에 접속하도록 앱(애드온)을 다시 구성한 경우에만 끄세요. 끄면 전송 구간 보안이 약해지므로, 반드시 필요한 경우가 아니면 켜 두세요. 적용하려면 다시 시작해야 합니다.",
+    "addon.ha_tool_concurrency.name": "Home Assistant 도구 동시성",
+    "addon.ha_tool_concurrency.description": "모든 세션에 걸친 외부 Home Assistant 도구 호출에 대한 선택적 제한입니다. 내부 REST, WebSocket 및 도구별 팬아웃 동시성은 변경되지 않습니다. 0은 무제한 동작을 유지합니다. 용량을 기다리는 호출은 60초 후에 실패합니다.",
     "addon_stable.enable_tool_search.description": "전체 도구 카탈로그 대신 검색 기반 탐색을 사용합니다. 대기 상태 컨텍스트를 약 90% 줄여 약 5K 토큰 수준으로 낮춥니다. ⚠️ 자체 도구 검색이나 지연 로딩 도구 기능을 갖춘 클라이언트(claude.ai, Claude Desktop, Claude Code)에서는 켜지 마세요. 두 검색 계층이 충돌하며, 그런 환경에서는 클라이언트 내장 도구 검색이 더 낫습니다. 도구가 지연 로딩되는지는 클라이언트와 모델 조합에 따라 다릅니다. 전체 카탈로그를 처음부터 모두 불러오는 환경(네이티브 지연 로딩 도구가 없는 모델(예: Gemini, OpenAI 호환 로컬 모델, Claude Haiku), 모델과 무관하게 모든 도구 스키마를 인라인으로 넣는 클라이언트(예: GitHub Copilot CLI), 컨텍스트 창이 작은 경우)에서 사용하세요. 일부 Codex 모델과 ChatGPT도 지연 로딩 도구를 지원하므로, 불필요하게 켜 두지 않도록 사용 중인 클라이언트/모델의 기능을 직접 확인하세요. 도구는 ha_search_tools로 찾고 범주별 프록시(읽기/쓰기/삭제)를 통해 실행됩니다. 적용하려면 앱(애드온)을 다시 시작한 뒤, AI 클라이언트에서 MCP 서버에 다시 연결하거나 새로 고쳐 도구 목록을 다시 불러오게 하세요. 앱(애드온)만 다시 시작해서는 클라이언트에 캐시된 도구 목록이 갱신되지 않으며, 이는 여기의 어떤 설정을 바꾸든 마찬가지입니다."
   },
   "tool_groups": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/nl.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Time-out voor elke automatisering/script/scène configuratie-ophalen. Bereik 1–600. Herstart vereist.",
     "advanced.individual_fetch_batch_size.label": "Batchgrootte voor configuratie-ophalen",
     "advanced.individual_fetch_batch_size.help": "Gelijktijdige configuratie-ophalingen per ID. Verlaag naar 1 op seriële HA-servers. Bereik 1–100. Herstart vereist.",
+    "advanced.ha_tool_concurrency.label": "Home Assistant-toolgelijktijdigheid",
+    "advanced.ha_tool_concurrency.help": "Optionele limiet voor uiterste Home Assistant-toolaanroepen over alle sessies. Interne REST-, WebSocket- en per-tool fan-out gelijktijdigheid blijft ongewijzigd. 0 behoudt onbeperkt gedrag. Een aanroep die wacht op capaciteit mislukt na 60 seconden. Bereik 0–32. Herstart vereist.",
     "advanced.backup_hint.label": "Back-up hintniveau",
     "advanced.backup_hint.help": "Bepaalt hoe sterk de LLM wordt aangemoedigd om een volledige HA-snapshot te maken vóór risicovolle schrijfbewerkingen.",
     "advanced.backup_hint.choices.strong": "Sterk",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Tools die hier worden vermeld, zijn vastgezet — ze verschijnen bovenaan het tabblad 'Tools' en kunnen niet worden losgemaakt vanuit de webinstellingen-UI zonder eerst deze optie ongedaan te maken. Handig in combinatie met Tool Search. Door komma's gescheiden toolnamen.",
     "addon.verify_ssl.name": "TLS-certificaat verifiëren",
     "addon.verify_ssl.description": "Verifieer het TLS-certificaat van de Home Assistant-server. De app (add-on) maakt verbinding via de Supervisor-proxy, dus dit heeft normaal gesproken geen effect en moet ingeschakeld blijven. Schakel dit alleen uit als je de app (add-on) zo hebt geconfigureerd dat deze via een openbare HTTPS-hostnaam met een zelfondertekend certificaat of een niet-overeenkomende hostnaam met HA communiceert. Uitschakelen verzwakt de transportbeveiliging — laat ingeschakeld tenzij je zeker weet dat je het nodig hebt. Vereist een herstart om van kracht te worden.",
+    "addon.ha_tool_concurrency.name": "Home Assistant tool concurrency",
+    "addon.ha_tool_concurrency.description": "Optionele limiet voor uiterste Home Assistant-toolaanroepen over alle sessies. Interne REST-, WebSocket- en per-tool fan-out gelijktijdigheid blijft ongewijzigd. 0 behoudt onbeperkt gedrag. Een aanroep die wacht op capaciteit mislukt na 60 seconden.",
     "addon_stable.enable_tool_search.description": "Vervang de volledige toolcatalogus door zoekgebaseerde ontdekking. Vermindert inactieve context met ongeveer 90%, tot ongeveer 5K tokens. ⚠️ Schakel dit NIET in bij clients met een ingebouwde toolzoekfunctie / uitgestelde tools (claude.ai, Claude Desktop, Claude Code) — de twee zoeklagen conflicteren en de ingebouwde toolzoekfunctie van de client heeft daar de voorkeur; laat dit uitgeschakeld. Of tools worden uitgesteld hangt af van je client- en modelcombinatie: gebruik dit wanneer je opstelling de volledige catalogus vooraf laadt — modellen zonder native uitgestelde tools (bijv. Gemini, OpenAI-compatibele lokale modellen, Claude Haiku), clients die alle toolschema's inline opnemen ongeacht het model (bijv. GitHub Copilot CLI), of kleinere contextvensters. Sommige Codex-modellen en ChatGPT bevatten ook uitgestelde tools — controleer je client/model direct om de functies te bevestigen zodat je dit niet onnodig ingeschakeld laat. Tools worden gevonden via ha_search_tools en uitgevoerd via gecategoriseerde proxy's (lezen/schrijven/verwijderen). Vereist een herstart van de app (add-on) om van kracht te worden — maak daarna opnieuw verbinding of vernieuw de MCP-server in je AI-client zodat deze de toollijst opnieuw laadt. Alleen de app (add-on) herstarten vernieuwt de gecached toollijst van een client NIET; dit is van toepassing na het wijzigen van een instelling hier."
   },
   "tools": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/pl.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Limit czasu dla każdego pobierania konfiguracji automatyzacji/skryptu/sceny. Zakres 1–600. Wymagany restart.",
     "advanced.individual_fetch_batch_size.label": "Rozmiar partii pobierania konfiguracji",
     "advanced.individual_fetch_batch_size.help": "Równoczesne pobieranie konfiguracji dla każdego ID. Zmniejsz do 1 na szeregowych serwerach HA. Zakres 1–100. Wymagany restart.",
+    "advanced.ha_tool_concurrency.label": "Współbieżność narzędzi Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Opcjonalny limit zewnętrznych wywołań narzędzi Home Assistant we wszystkich sesjach. Wewnętrzna współbieżność REST, WebSocket oraz rozgałęziania dla poszczególnych narzędzi pozostaje bez zmian. Wartość 0 zachowuje zachowanie bez limitu. Wywołanie oczekujące na wolne zasoby kończy się niepowodzeniem po 60 sekundach. Zakres 0–32. Wymagany restart.",
     "advanced.backup_hint.label": "Poziom podpowiedzi o kopii zapasowej",
     "advanced.backup_hint.help": "Kontroluje, jak silnie LLM jest zachęcany do wykonania pełnej migawki HA przed ryzykownymi zapisami.",
     "advanced.backup_hint.choices.strong": "Silny",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Narzędzia wymienione tutaj są zablokowane jako przypięte — pojawiają się na górze zakładki „Narzędzia” i nie można ich odpiąć z interfejsu ustawień sieciowych bez wcześniejszego usunięcia tej opcji. Przydatne w połączeniu z wyszukiwaniem narzędzi. Nazwy narzędzi oddzielone przecinkami.",
     "addon.verify_ssl.name": "Weryfikuj certyfikat TLS",
     "addon.verify_ssl.description": "Zweryfikuj certyfikat TLS serwera Home Assistant. Aplikacja (dodatek) łączy się przez proxy Supervisora, więc zazwyczaj nie ma to wpływu i powinno pozostać włączone. Wyłącz tylko wtedy, gdy skonfigurowano aplikację (dodatek) tak, aby komunikowała się z HA przez publiczną nazwę hosta HTTPS z certyfikatem z podpisem własnym lub niedopasowaniem nazwy hosta. Wyłączenie osłabia bezpieczeństwo transportu — pozostaw włączone, chyba że wiesz, że tego potrzebujesz. Wymaga ponownego uruchomienia, aby zaczęło obowiązywać.",
+    "addon.ha_tool_concurrency.name": "Współbieżność narzędzi Home Assistant",
+    "addon.ha_tool_concurrency.description": "Opcjonalny limit zewnętrznych wywołań narzędzi Home Assistant we wszystkich sesjach. Wewnętrzna współbieżność REST, WebSocket oraz rozgałęziania dla poszczególnych narzędzi pozostaje bez zmian. Wartość 0 zachowuje zachowanie bez limitu. Wywołanie oczekujące na wolne zasoby kończy się niepowodzeniem po 60 sekundach.",
     "addon_stable.enable_tool_search.description": "Zastąp pełny katalog narzędzi wyszukiwaniem. Zmniejsza bezczynny kontekst o około 90%, do około 5K tokenów. ⚠️ NIE włączaj tego w klientach z własnym wbudowanym wyszukiwaniem narzędzi / odroczonymi narzędziami (claude.ai, Claude Desktop, Claude Code) — obie warstwy wyszukiwania będą w konflikcie, a wbudowane wyszukiwanie narzędzi klienta jest w tym przypadku lepszym wyborem; pozostaw to wyłączone. To, czy narzędzia są odraczane, zależy od kombinacji klienta i modelu: użyj tego, gdy konfiguracja ładowała pełny katalog na początku — modele bez natywnych odroczonych narzędzi (np. Gemini, modele lokalne kompatybilne z OpenAI, Claude Haiku), klienci, którzy wstawiają wszystkie schematy narzędzi niezależnie od modelu (np. GitHub Copilot CLI), lub mniejsze okna kontekstu. Niektóre modele Codex i ChatGPT również zawierają odroczone narzędzia — sprawdź bezpośrednio swojego klienta/model, aby potwierdzić jego funkcje, aby nie pozostawiać tego włączonego niepotrzebnie. Narzędzia są wyszukiwane przez ha_search_tools i wykonywane za pośrednictwem skategoryzowanych serwerów proxy (odczyt/zapis/usuwanie). Wymaga ponownego uruchomienia aplikacji (dodatku), aby zaczęło obowiązywać — następnie połącz się ponownie lub odśwież serwer MCP w kliencie AI, aby załadował listę narzędzi ponownie. Samo ponowne uruchomienie aplikacji (dodatku) NIE odświeża listy narzędzi w pamięci podręcznej klienta; dotyczy to zmiany dowolnego ustawienia tutaj."
   },
   "tools": {

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2572}/src/ha_mcp/settings_ui/locales/ru.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Тайм-аут каждой загрузки автоматизации, скрипта или сцены. 1–600. Нужен перезапуск.",
     "advanced.individual_fetch_batch_size.label": "Размер пакета загрузки конфигураций",
     "advanced.individual_fetch_batch_size.help": "Число параллельных загрузок. Для последовательных серверов HA снижайте к 1. 1–100. Нужен перезапуск.",
+    "advanced.ha_tool_concurrency.label": "Параллелизм инструментов Home Assistant",
+    "advanced.ha_tool_concurrency.help": "Необязательный лимит внешних вызовов инструментов Home Assistant во всех сеансах. Внутренний параллелизм REST, WebSocket и вентирования по инструментам остается неизменным. 0 сохраняет неограниченное поведение. Вызов, ожидающий свободных ресурсов, завершается ошибкой через 60 секунд. Диапазон 0–32. Требуется перезапуск.",
     "advanced.backup_hint.label": "Уровень напоминания о резервной копии",
     "advanced.backup_hint.help": "Настраивает, насколько настойчиво LLM предлагает полный снимок HA перед рискованной записью.",
     "advanced.backup_hint.choices.strong": "Настойчивое",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Перечисленные здесь инструменты принудительно закрепляются: они отображаются в верхней части вкладки «Инструменты», и их нельзя открепить в веб-интерфейсе настроек, не очистив сначала этот параметр. Полезно вместе с поиском инструментов. Укажите имена инструментов через запятую.",
     "addon.verify_ssl.name": "Проверять сертификат TLS",
     "addon.verify_ssl.description": "Проверять TLS-сертификат сервера Home Assistant. Приложение (аддон) подключается через прокси Supervisor, поэтому обычно это не оказывает влияния и должно быть включено. Отключайте только в случае перенастройки приложения (аддона) для связи с HA по публичному HTTPS-имени хоста с самоподписанным сертификатом или несовпадением имени хоста. Отключение снижает безопасность передачи данных — оставляйте включенным, только если это необходимо. Требуется перезапуск для применения.",
+    "addon.ha_tool_concurrency.name": "Параллелизм инструментов Home Assistant",
+    "addon.ha_tool_concurrency.description": "Необязательный лимит внешних вызовов инструментов Home Assistant во всех сеансах. Внутренний параллелизм REST, WebSocket и вентирования по инструментам остается неизменным. 0 сохраняет неограниченное поведение. Вызов, ожидающий свободных ресурсов, завершается ошибкой через 60 секунд.",
     "addon_stable.enable_tool_search.description": "Заменить полный каталог инструментов поисковым обнаружением. Снижает объем неиспользуемого контекста примерно на 90%, до примерно 5K токенов. ⚠️ НЕ включайте эту функцию в клиентах со встроенным поиском инструментов / отложенными инструментами (claude.ai, Claude Desktop, Claude Code) — два слоя поиска конфликтуют, и встроенный поиск инструментов клиента в данном случае является лучшим выбором; оставьте ее выключенной. Зависят ли инструменты от отложенного выполнения, определяется комбинацией клиента и модели: используйте этот параметр, когда ваша установка загружает полный каталог заранее — для моделей без нативных отложенных инструментов (например, Gemini, локальные модели с поддержкой OpenAI, Claude Haiku), клиентов, которые передают все схемы инструментов независимо от модели (например, GitHub Copilot CLI), или меньших окон контекста. Некоторые модели Codex и ChatGPT также включают отложенные инструменты — проверьте свой клиент/модель напрямую, чтобы подтвердить поддерживаемые функции и не оставлять этот параметр включенным без необходимости. Инструменты находятся через ha_search_tools и выполняются через категоризированные прокси (чтение/запись/удаление). Требуется перезапуск приложения (аддона) для применения — после этого переподключите или обновите MCP-сервер в вашем ИИ-клиенте, чтобы он перезагрузил список инструментов. Перезапуск только приложения (аддона) НЕ обновляет закэшированный список инструментов клиента; это применяется после изменения любого параметра здесь."
   },
   "tool_groups": {