stackchan-mcp 0.12.0__tar.gz → 0.14.0__tar.gz

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackchan-mcp
-Version: 0.12.0
+Version: 0.14.0
 Summary: Two-faced MCP gateway for StackChan (xiaozhi-esp32): bridges stdio MCP clients to the ESP32 over WebSocket + HTTP.
 Project-URL: Homepage, https://github.com/kisaragi-mochi/stackchan-mcp
 Project-URL: Repository, https://github.com/kisaragi-mochi/stackchan-mcp
@@ -25,9 +25,11 @@ Classifier: Topic :: System :: Hardware
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3
 Requires-Dist: mcp<2.0,>=1.27
+Requires-Dist: platformdirs<5.0,>=4.0
 Requires-Dist: pydantic>=2
 Requires-Dist: python-dotenv
 Requires-Dist: pyyaml>=6
+Requires-Dist: tomli<3.0,>=2.0; python_version < '3.11'
 Requires-Dist: websockets>=12
 Requires-Dist: zeroconf>=0.149
 Provides-Extra: stt

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackchan-mcp"
-version = "0.12.0"
+version = "0.14.0"
 description = "Two-faced MCP gateway for StackChan (xiaozhi-esp32): bridges stdio MCP clients to the ESP32 over WebSocket + HTTP."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,6 +34,8 @@ dependencies = [
     "pydantic>=2",
     "python-dotenv",
     "PyYAML>=6",
+    "platformdirs>=4.0,<5.0",
+    "tomli>=2.0,<3.0; python_version < '3.11'",
     # The stdio server captures the active ServerSession via a subclassed
     # Server.run() loop because the public MCP SDK does not yet expose a
     # stable hook for server-side notifications. That subclass relies on

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/stackchan_mcp/capture_server.py

@@ -51,6 +51,7 @@ import json
 import logging
 import os
 import secrets
+import sys
 import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, AsyncIterator
@@ -142,7 +143,11 @@ async def handle_capture(request: web.Request) -> web.Response:
 
     async for part in reader:
         if part.name == "question":
-            question = (await part.read()).decode("utf-8")
+            # Decode defensively: a malformed (non-UTF-8) question field must
+            # not turn a photo upload into a 500. The question is advisory
+            # metadata, so replacing undecodable bytes is preferable to
+            # dropping the whole capture.
+            question = (await part.read()).decode("utf-8", errors="replace")
         elif part.name == "file":
             timestamp = int(time.time() * 1000)
             filename = f"capture_{timestamp}.jpg"
@@ -445,19 +450,26 @@ def create_capture_app(
     dispatches to. May be ``None`` for tests of /capture alone; /pcm
     will return 503 in that case.
     """
-    # ``client_max_size=0`` disables aiohttp's per-request body size
-    # cap (default 1 MiB). The /pcm endpoint legitimately streams
-    # arbitrarily long PCM utterances (multi-minute TTS, live audio
-    # mixes); a 1 MiB cap would silently cut a chunked-transfer
-    # producer off mid-stream once its cumulative body exceeded that
-    # limit — observed in practice with a 200-second TTS push, which
-    # aborted around 36 s in (~2 MiB of source-rate PCM through the
-    # transfer-encoding pipe). The handler itself enforces no separate
-    # cap; back-pressure comes from the device-side Opus push rate
-    # inside ``send_pcm_stream``, which is the right place for it.
-    # /capture only receives JPEG snapshots from the ESP32 (well under
-    # 1 MiB each) so removing the cap costs it nothing.
-    app = web.Application(client_max_size=0)
+    # Raise aiohttp's per-request body cap (default 1 MiB) effectively to
+    # unlimited. The /pcm endpoint legitimately streams arbitrarily long PCM
+    # utterances (multi-minute TTS, live audio mixes); a 1 MiB cap would
+    # silently cut a chunked-transfer producer off mid-stream once its
+    # cumulative body exceeded that limit — observed in practice with a
+    # 200-second TTS push, which aborted around 36 s in (~2 MiB of
+    # source-rate PCM through the transfer-encoding pipe).
+    #
+    # Use ``sys.maxsize`` rather than ``0``. Although ``0`` disables the cap
+    # for ``request.read()`` / ``request.post()`` (both guard with
+    # ``if 0 < max_size``), aiohttp's multipart reader does NOT special-case
+    # ``0``: ``BodyPartReader.read()`` compares ``len(data) > client_max_size``
+    # directly (aiohttp >= 3.14), so a client_max_size of 0 propagated into
+    # ``request.multipart()`` rejects ANY non-empty multipart field with
+    # HTTP 413. /capture reads its ``question`` form field via ``part.read()``,
+    # so with ``client_max_size=0`` every photo upload carrying a non-empty
+    # question 413s ("Failed to upload photo"). A large finite value avoids
+    # that trap while keeping /pcm effectively unbounded. /capture's real
+    # size limit is the explicit CAPTURE_MAX_BYTES check in handle_capture.
+    app = web.Application(client_max_size=sys.maxsize)
     app[CAPTURE_TOKEN_KEY] = capture_token
     app[AVATAR_SETS_KEY] = {}
     app[AVATAR_SETS_LOCK_KEY] = asyncio.Lock()

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/stackchan_mcp/cli.py

@@ -438,9 +438,20 @@ def _run_ownership_check() -> int:
     """Print the current ownership lock status and exit cleanly."""
     from .ownership import is_pid_alive, read_lock
 
-    info = read_lock()
+    # Load ``.env`` first so that a WS_PORT / PORT defined only there resolves
+    # the same per-port lock the running gateway claims. Startup loads ``.env``
+    # before ``_acquire_startup_lock`` (via ``_run_stdio_gateway`` /
+    # ``_run_streamable_http_placeholder``), so ``--check`` must match it —
+    # otherwise a gateway owning ``owner-18765.lock`` would be inspected against
+    # the default ``owner-8765.lock`` and wrongly reported ready. Mirrors how
+    # ``--preflight`` loads ``.env`` inside ``_run_preflight``.
+    _load_dotenv()
+    # Inspect the per-WS_PORT lock this gateway would claim (not the legacy
+    # machine-global owner.lock), so the preflight reflects the actual port.
+    lock_path = _ws_port_lock_path()
+    info = read_lock(lock_path)
     if info is None:
-        print("no current owner")
+        print(f"no current owner (lock: {lock_path.name})")
         print("ownership preflight: ready")
         print("Result: ready. Exit 0.")
     elif is_pid_alive(info["pid"]):
@@ -745,6 +756,28 @@ def _configure_gateway_startup() -> None:
         format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     )
 
+    from .user_defaults import log_user_defaults_startup
+
+    log_user_defaults_startup()
+
+
+def _ws_port_lock_path():
+    """Per-WS_PORT ownership lock path.
+
+    複数機体対応: ownership lock を machine-global な ``owner.lock`` でなく
+    WS_PORT 単位に scope する。 lock は「同一 device を 2 つの gateway が
+    奪い合わない」 ための機構だが、 1 device = 1 gateway = 1 WS ポートで
+    複数機体を同時に動かす構成では global lock が 2 台目以降を誤って弾く。
+    ポート単位なら N gateway が共存でき、 同一ポート二重起動は従来通り弾ける。
+    WS_PORT 未解決時は従来の global パスにフォールバック。
+    """
+    from .ownership import LOCK_DIR
+
+    ws_port, _ = _resolve_ws_port()
+    return LOCK_DIR / (
+        f"owner-{ws_port}.lock" if ws_port is not None else "owner.lock"
+    )
+
 
 def _acquire_startup_lock(
     *,
@@ -760,13 +793,16 @@ def _acquire_startup_lock(
         release_lock_if_owner,
     )
 
+    lock_path = _ws_port_lock_path()
+
     owner_id = generate_owner_id()
     try:
         if mode == _STDIO_TRANSPORT and http_endpoint is None and started_by is None:
-            info = acquire_lock(owner_id)
+            info = acquire_lock(owner_id, path=lock_path)
         else:
             info = acquire_lock(
                 owner_id,
+                path=lock_path,
                 mode=mode,
                 http_endpoint=http_endpoint,
                 started_by=started_by,
@@ -778,12 +814,13 @@ def _acquire_startup_lock(
     try:
         print(
             "stackchan-mcp: acquired ownership lock "
-            f"(owner_id={info['owner_id']}, pid={info['pid']})",
+            f"(owner_id={info['owner_id']}, pid={info['pid']}, "
+            f"lock={lock_path.name})",
             file=sys.stderr,
         )
-        atexit.register(release_lock_if_owner, info)
+        atexit.register(release_lock_if_owner, info, lock_path)
     except BaseException:
-        release_lock_if_owner(info)
+        release_lock_if_owner(info, lock_path)
         raise
 
     return info
@@ -806,7 +843,7 @@ def _run_stdio_gateway(*, advertise_mdns: bool = True) -> None:
         except KeyboardInterrupt:
             pass
     finally:
-        release_lock_if_owner(info)
+        release_lock_if_owner(info, _ws_port_lock_path())
 
 
 def _resolve_mcp_http_endpoint() -> tuple[str, int]:
@@ -916,7 +953,7 @@ def _run_streamable_http_placeholder(*, advertise_mdns: bool = True) -> None:
             pass
     finally:
         if info is not None:
-            release_lock_if_owner(info)
+            release_lock_if_owner(info, _ws_port_lock_path())
 
 
 def main(argv: list[str] | None = None) -> None:

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/stackchan_mcp/esp32_client.py

@@ -43,6 +43,8 @@ RESPONSE_TIMEOUT = 10.0
 ToolCall = tuple[str, dict[str, Any]]
 ToolCallResult = tuple[Any, dict[str, Any] | None]
 
+_SET_AVATAR_TOOL = "self.display.set_avatar"
+
 _TOOL_LANES = {
     "self.robot.": "servo",
     "self.wifi.": "wifi",
@@ -82,6 +84,8 @@ class ESP32Connection:
         self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self._connected = True
         self._initialized = False
+        self._tools_discovered = False
+        self._avatar_render_sent = False
         # Phase 4.5 avatar: pending load_avatar_set calls waiting for the
         # device's `avatar_set_loaded` reply. Keyed by expected checksum
         # so that overlapping fetches (different sets) can be discriminated.
@@ -102,6 +106,14 @@ class ESP32Connection:
     def initialized(self) -> bool:
         return self._initialized
 
+    @property
+    def tools_discovered(self) -> bool:
+        return self._tools_discovered
+
+    @property
+    def avatar_render_sent(self) -> bool:
+        return self._avatar_render_sent
+
     def _next_id(self) -> int:
         self._request_id += 1
         return self._request_id
@@ -162,6 +174,8 @@ class ESP32Connection:
         """Discover tools available on ESP32."""
         all_tools: list[dict[str, Any]] = []
         cursor = ""
+        self._tools_discovered = False
+        discovered = False
 
         while True:
             params: dict[str, Any] = {"cursor": cursor}
@@ -169,6 +183,7 @@ class ESP32Connection:
 
             if error:
                 logger.error("tools/list failed: %s", error)
+                self.tools = all_tools
                 break
 
             tools = result.get("tools", [])
@@ -176,10 +191,12 @@ class ESP32Connection:
 
             next_cursor = result.get("nextCursor", "")
             if not next_cursor:
+                discovered = True
                 break
             cursor = next_cursor
 
         self.tools = all_tools
+        self._tools_discovered = discovered
         logger.info("Discovered %d tools on ESP32", len(all_tools))
         return all_tools
 
@@ -187,6 +204,8 @@ class ESP32Connection:
         self, name: str, arguments: dict[str, Any]
     ) -> tuple[Any, dict[str, Any] | None]:
         """Call a tool on ESP32."""
+        if name == _SET_AVATAR_TOOL:
+            self._avatar_render_sent = True
         return await self.send_mcp_request(
             "tools/call", {"name": name, "arguments": arguments}
         )
@@ -233,6 +252,9 @@ class ESP32Connection:
             return {"ok": False, "checksum": checksum, "error": "device_timeout"}
         except asyncio.CancelledError:
             return {"ok": False, "checksum": checksum, "error": "superseded"}
+        except ConnectionError:
+            self._avatar_set_waiters.pop(checksum, None)
+            return {"ok": False, "checksum": checksum, "error": "disconnected"}
         except Exception as exc:
             self._avatar_set_waiters.pop(checksum, None)
             return {"ok": False, "checksum": checksum, "error": f"send_failed: {exc}"}
@@ -353,6 +375,10 @@ class ESP32Connection:
             if not future.done():
                 future.set_exception(ConnectionError("ESP32 disconnected"))
         self._pending.clear()
+        for future in self._avatar_set_waiters.values():
+            if not future.done():
+                future.set_exception(ConnectionError("ESP32 disconnected"))
+        self._avatar_set_waiters.clear()
 
 
 class ESP32Manager:
@@ -732,6 +758,10 @@ class ESP32Manager:
             vision_token=self._vision_token,
         ):
             await connection.discover_tools()
+            if not connection.tools_discovered:
+                logger.error("ESP32 tools discovery failed")
+                return
+            await self._auto_render_idle_avatar(connection, device_id)
             logger.info(
                 "ESP32 ready: device=%s tools=%d",
                 device_id,
@@ -740,6 +770,37 @@ class ESP32Manager:
         else:
             logger.error("ESP32 MCP initialization failed")
 
+    async def _auto_render_idle_avatar(
+        self, connection: ESP32Connection, device_id: str
+    ) -> None:
+        """Best-effort idle avatar render after a fresh device session init."""
+        if connection.avatar_render_sent:
+            return
+
+        logger.info(
+            "auto-rendering idle avatar (no explicit set_avatar yet): device=%s",
+            device_id,
+        )
+        try:
+            _result, error = await connection.call_tool(
+                _SET_AVATAR_TOOL,
+                {"face": "idle"},
+            )
+        except Exception as exc:
+            logger.warning(
+                "auto-rendering idle avatar failed: device=%s error=%s",
+                device_id,
+                exc,
+            )
+            return
+
+        if error:
+            logger.warning(
+                "auto-rendering idle avatar failed: device=%s error=%s",
+                device_id,
+                error,
+            )
+
     async def _emit_stackchan_event(self, payload: dict[str, Any]) -> None:
         """Forward a firmware-originated stackchan event to the MCP client."""
         event_type = payload.get("event_type")

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/stackchan_mcp/stdio_server.py

@@ -21,6 +21,7 @@ from mcp.types import Notification, TextContent, Tool
 from . import __version__
 from .gateway import get_gateway
 from .notify_config import NotifyConfig, load_notify_config
+from .user_defaults import resolve_default
 from .stt import listen_and_transcribe
 from .tts import synthesize_and_send
 
@@ -388,30 +389,64 @@ async def _handle_follow_pose_stream(
     if not (url.startswith("ws://") or url.startswith("wss://")):
         return _follow_pose_error("url must start with ws:// or wss://")
 
-    flip_yaw = arguments.get("flip_yaw", 1)
+    tool_name = "stackchan_follow_pose_stream"
+
+    flip_yaw = (
+        arguments["flip_yaw"]
+        if "flip_yaw" in arguments
+        else resolve_default(tool_name, "flip_yaw", 1)
+    )
     if not _is_int_arg(flip_yaw) or flip_yaw not in (-1, 1):
         return _follow_pose_error("flip_yaw must be -1 or 1")
 
-    flip_pitch = arguments.get("flip_pitch", 1)
+    flip_pitch = (
+        arguments["flip_pitch"]
+        if "flip_pitch" in arguments
+        else resolve_default(tool_name, "flip_pitch", 1)
+    )
     if not _is_int_arg(flip_pitch) or flip_pitch not in (-1, 1):
         return _follow_pose_error("flip_pitch must be -1 or 1")
 
-    pitch_center_deg = arguments.get("pitch_center_deg", 45)
+    pitch_center_deg = (
+        arguments["pitch_center_deg"]
+        if "pitch_center_deg" in arguments
+        else resolve_default(tool_name, "pitch_center_deg", 45)
+    )
     if (
         not _is_int_arg(pitch_center_deg)
         or not 5 <= pitch_center_deg <= 85
     ):
         return _follow_pose_error("pitch_center_deg must be an integer in 5..85")
 
-    downsample_hz = arguments.get("downsample_hz", 20.0)
-    if not _is_number_arg(downsample_hz) or not 0 < downsample_hz <= 60:
-        return _follow_pose_error("downsample_hz must be a number in (0, 60]")
+    smoothing_window = (
+        arguments["smoothing_window"]
+        if "smoothing_window" in arguments
+        else resolve_default(tool_name, "smoothing_window", 5)
+    )
+    if not _is_int_arg(smoothing_window) or not 1 <= smoothing_window <= 20:
+        return _follow_pose_error("smoothing_window must be an integer in 1..20")
+
+    downsample_hz = (
+        arguments["downsample_hz"]
+        if "downsample_hz" in arguments
+        else resolve_default(tool_name, "downsample_hz", 20.0)
+    )
+    if not _is_number_arg(downsample_hz) or not 0 < downsample_hz <= 20:
+        return _follow_pose_error("downsample_hz must be a number in (0, 20]")
 
-    max_step_deg = arguments.get("max_step_deg", 12.0)
+    max_step_deg = (
+        arguments["max_step_deg"]
+        if "max_step_deg" in arguments
+        else resolve_default(tool_name, "max_step_deg", 12.0)
+    )
     if not _is_number_arg(max_step_deg) or not 0 < max_step_deg <= 30:
         return _follow_pose_error("max_step_deg must be a number in (0, 30]")
 
-    speed_dps = arguments.get("speed_dps", 240)
+    speed_dps = (
+        arguments["speed_dps"]
+        if "speed_dps" in arguments
+        else resolve_default(tool_name, "speed_dps", 240)
+    )
     if not _is_int_arg(speed_dps) or not 1 <= speed_dps <= 240:
         return _follow_pose_error("speed_dps must be an integer in 1..240")
 
@@ -429,6 +464,7 @@ async def _handle_follow_pose_stream(
         flip_yaw=flip_yaw,
         flip_pitch=flip_pitch,
         pitch_center_deg=pitch_center_deg,
+        smoothing_window=smoothing_window,
         downsample_hz=float(downsample_hz),
         max_step_deg=float(max_step_deg),
         speed_dps=speed_dps,
@@ -610,6 +646,14 @@ async def _dispatch_mcp_tool(
             "self.gateway_config.set",
             arguments,
         ),
+        "get_touch_sensor_enabled": (
+            "self.robot.get_touch_sensor_enabled",
+            {},
+        ),
+        "set_touch_sensor_enabled": (
+            "self.robot.set_touch_sensor_enabled",
+            arguments,
+        ),
         "set_avatar": (
             "self.display.set_avatar",
             arguments,
@@ -927,15 +971,29 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                                 "anchor. Defaults to the head's neutral pose."
                             ),
                         },
+                        "smoothing_window": {
+                            "type": "integer",
+                            "default": 5,
+                            "minimum": 1,
+                            "maximum": 20,
+                            "description": (
+                                "Moving-average window size for incoming sensor "
+                                "frames. 1 = passthrough (disable gateway-side "
+                                "smoothing). Default 5."
+                            ),
+                        },
                         "downsample_hz": {
                             "type": "number",
                             "default": 20,
                             "exclusiveMinimum": 0,
-                            "maximum": 60,
+                            "maximum": 20,
                             "description": (
                                 "Cap servo command rate. Recent frames are "
                                 "smoothed; commands are issued at most this "
-                                "frequently."
+                                "frequently. Capped at 20 to match the "
+                                "SCS0009 servo's observed sustained WritePos "
+                                "rate; higher continuous rates can trigger "
+                                "UART hang."
                             ),
                         },
                         "max_step_deg": {
@@ -1062,6 +1120,38 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                     },
                 },
             ),
+            Tool(
+                name="get_touch_sensor_enabled",
+                description=(
+                    "Read the device's NVS-backed head-touch sensor enable "
+                    "flag. When disabled, the firmware stops both the local "
+                    "motion response and the MCP stackchan/event emission; "
+                    "the setting persists across reboot."
+                ),
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="set_touch_sensor_enabled",
+                description=(
+                    "Enable or disable the device's head-touch sensor at "
+                    "runtime. The NVS-backed setting persists across reboot. "
+                    "Disabling stops both the firmware local motion response "
+                    "and the MCP stackchan/event emission."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "enabled": {
+                            "type": "boolean",
+                            "description": (
+                                "True to enable tap/stroke detection; false "
+                                "to disable local reactions and event emission."
+                            ),
+                        },
+                    },
+                    "required": ["enabled"],
+                },
+            ),
             Tool(
                 name="set_avatar",
                 description=(
@@ -1516,10 +1606,22 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                         "speaker_id": {
                             "type": "integer",
                             "description": (
-                                "Engine-specific speaker identifier "
+                                "Engine-specific numeric speaker identifier "
                                 "(e.g. a VOICEVOX speaker ID)."
                             ),
                         },
+                        "speaker_name": {
+                            "type": "string",
+                            "description": (
+                                "Engine-specific string speaker/voice "
+                                "identifier (e.g. an Edge TTS voice name "
+                                "such as 'en-US-AriaNeural'). Distinct from "
+                                "'voice', which selects the engine itself "
+                                "(e.g. 'edge-tts'); use speaker_name for "
+                                "engines whose speaker selector is a string "
+                                "name rather than the numeric speaker_id."
+                            ),
+                        },
                         "reference_audio": {
                             "type": "string",
                             "description": (
@@ -1644,7 +1746,12 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                     "address, then read' patterns, use `i2c_write_read` "
                     "instead. Returns "
                     "{\"ok\": true, \"bytes\": [...]} or "
-                    "{\"ok\": false, \"error\": \"ESP_ERR_TIMEOUT\"} on NACK."
+                    "{\"ok\": false, \"error\": \"ESP_ERR_TIMEOUT\"} on NACK. "
+                    "Optional `scl_speed_hz` (default 400000) sets the I2C "
+                    "clock for this transaction; lower it (e.g. 100000 or "
+                    "200000) for slower Units such as the RCWL-9620 "
+                    "ultrasonic ranger that fail at 400 kHz with "
+                    "ESP_ERR_INVALID_STATE."
                 ),
                 inputSchema={
                     "type": "object",
@@ -1665,6 +1772,19 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                             "minimum": 1,
                             "maximum": 256,
                         },
+                        "scl_speed_hz": {
+                            "type": "integer",
+                            "default": 400000,
+                            "description": (
+                                "I2C clock for this transaction. Default "
+                                "400000; lower it (e.g. 100000 or 200000) "
+                                "for slower Units such as the RCWL-9620 "
+                                "ultrasonic ranger that fail at 400 kHz "
+                                "with ESP_ERR_INVALID_STATE."
+                            ),
+                            "minimum": 100000,
+                            "maximum": 1000000,
+                        },
                     },
                     "required": ["addr", "n_bytes"],
                 },
@@ -1676,7 +1796,11 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                     "on Grove Port A. `bytes` is an array of integers "
                     "(0..255). This tool operates on the external Port A "
                     "bus only; on-board ICs (PMIC, AW9523, touch, etc.) "
-                    "on the internal bus are not reachable."
+                    "on the internal bus are not reachable. Optional "
+                    "`scl_speed_hz` (default 400000) sets the I2C clock for "
+                    "this transaction; lower it (e.g. 100000 or 200000) for "
+                    "slower Units such as the RCWL-9620 ultrasonic ranger "
+                    "that fail at 400 kHz with ESP_ERR_INVALID_STATE."
                 ),
                 inputSchema={
                     "type": "object",
@@ -1700,6 +1824,19 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                                 "maximum": 255,
                             },
                         },
+                        "scl_speed_hz": {
+                            "type": "integer",
+                            "default": 400000,
+                            "description": (
+                                "I2C clock for this transaction. Default "
+                                "400000; lower it (e.g. 100000 or 200000) "
+                                "for slower Units such as the RCWL-9620 "
+                                "ultrasonic ranger that fail at 400 kHz "
+                                "with ESP_ERR_INVALID_STATE."
+                            ),
+                            "minimum": 100000,
+                            "maximum": 1000000,
+                        },
                     },
                     "required": ["addr", "bytes"],
                 },
@@ -1712,7 +1849,11 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                     "single Repeated Start transaction. Common 'set "
                     "register pointer, then read' idiom: pass "
                     "write_bytes=[reg_addr] to read from a specific "
-                    "register."
+                    "register. Optional `scl_speed_hz` (default 400000) "
+                    "sets the I2C clock for this transaction; lower it "
+                    "(e.g. 100000 or 200000) for slower Units such as the "
+                    "RCWL-9620 ultrasonic ranger that fail at 400 kHz with "
+                    "ESP_ERR_INVALID_STATE."
                 ),
                 inputSchema={
                     "type": "object",
@@ -1745,6 +1886,19 @@ def create_server(notify_config: NotifyConfig | None = None) -> StackChanServer:
                             "minimum": 1,
                             "maximum": 256,
                         },
+                        "scl_speed_hz": {
+                            "type": "integer",
+                            "default": 400000,
+                            "description": (
+                                "I2C clock for this transaction. Default "
+                                "400000; lower it (e.g. 100000 or 200000) "
+                                "for slower Units such as the RCWL-9620 "
+                                "ultrasonic ranger that fail at 400 kHz "
+                                "with ESP_ERR_INVALID_STATE."
+                            ),
+                            "minimum": 100000,
+                            "maximum": 1000000,
+                        },
                     },
                     "required": ["addr", "write_bytes", "n_bytes"],
                 },

{stackchan_mcp-0.12.0 → stackchan_mcp-0.14.0}/stackchan_mcp/tts/__init__.py

@@ -54,8 +54,15 @@ def _register_irodori() -> None:
     get_registry().register(IrodoriEngine())
 
 
+def _register_edge_tts() -> None:
+    from .edge_tts import EdgeTTSEngine
+
+    get_registry().register(EdgeTTSEngine())
+
+
 _try_register(_register_voicevox, "voicevox")
 _try_register(_register_irodori, "irodori")
+_try_register(_register_edge_tts, "edge-tts")
 
 
 __all__ = [