livepilot 1.10.5 → 1.10.7

package/m4l_device/livepilot_bridge.js

@@ -14,6 +14,17 @@
  *   - Chunk parameter reads: 4 per batch, 50ms delay
  *   - Base64 encode all JSON responses
  *   - Defer all LiveAPI operations via deferlow()
+ *
+ * OSC address convention:
+ *   - OUTGOING (this file → server via udpsend): use WITH leading slash,
+ *       e.g. outlet(0, "/response", encoded). The slash is part of the
+ *       OSC address that udpsend packs into the packet.
+ *   - INCOMING (server → this file via udpreceive): Max's udpreceive
+ *       routes on the selector, so the server's address string must be
+ *       "response"/"cmd" WITHOUT a leading slash (Max would otherwise
+ *       treat the slash as a literal selector character). See
+ *       mcp_server/m4l_bridge.py for the sending side and `_parse_osc`
+ *       for the tolerant normalization.
  */
 
 autowatch = 1;
@@ -84,7 +95,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.10.5"});
+            send_response({"ok": true, "version": "1.10.6"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -172,6 +183,13 @@ function dispatch(cmd, args) {
         case "get_plugin_presets":
             cmd_get_plugin_presets(args);
             break;
+        // ── BUG-A2 / A3: deep-LOM properties not on the automatable surface ──
+        case "simpler_set_warp":
+            cmd_simpler_set_warp(args);
+            break;
+        case "compressor_set_sidechain":
+            cmd_compressor_set_sidechain(args);
+            break;
         default:
             send_response({"error": "Unknown command: " + cmd});
     }
@@ -630,8 +648,13 @@ function detect_key() {
     detected_key = note_names[best_key];
     detected_scale = best_scale;
 
-    // Send to UI
-    outlet(1, "key", detected_key + " " + detected_scale);
+    // Send to UI — use abbreviated scale ("min"/"maj") so text fits in the
+    // 72-pixel presentation widget, and pass a SINGLE symbol so Max's
+    // [route] + [prepend set] chain doesn't split atoms on the internal
+    // space. Max's [comment] displays whatever the `set` message carries.
+    var scale_abbr = (detected_scale === "minor") ? "min" : "maj";
+    var display = detected_key + " " + scale_abbr;  // e.g., "D min"
+    outlet(1, "key", display);
 }
 
 function correlate(a, b) {
@@ -980,6 +1003,206 @@ function cmd_simpler_warp(args) {
     }
 }
 
+// ── BUG-A2: Simpler warping property + warp_mode ─────────────────────
+//
+// Python's Remote Script ControlSurface API only exposes automatable
+// parameters. Simpler's `warping` and `warp_mode` live on the sample
+// child object (SimplerDevice.sample.*) — unreachable from the Python
+// side. Max JS LiveAPI can step INTO the sample child, so we do the
+// property write here and surface the result to the MCP server.
+//
+// args: [track_index, device_index, warp_on (0/1), warp_mode (-1 = leave alone, 0..6)]
+//   warp_mode: 0=Beats, 1=Tones, 2=Texture, 3=Re-Pitch, 4=Complex, 6=Complex Pro
+//
+// Returns: {ok, warping, warp_mode} on success, {error} otherwise.
+function cmd_simpler_set_warp(args) {
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var warp_on = parseInt(args[2]);
+    var warp_mode = args.length > 3 ? parseInt(args[3]) : -1;
+
+    var device_path = build_device_path(track_idx, device_idx);
+    cursor_a.goto(device_path);
+    if (cursor_a.id === 0) {
+        send_response({"error": "Device not found at track " + track_idx + ", device " + device_idx});
+        return;
+    }
+    if (cursor_a.get("class_name").toString() !== "OriginalSimpler") {
+        send_response({"error": "Not a Simpler device (class is " + cursor_a.get("class_name") + ")"});
+        return;
+    }
+
+    // Step into the sample child — warping + warp_mode live there, not on
+    // the device itself.
+    try {
+        cursor_a.goto(device_path + " sample");
+        if (cursor_a.id === 0) {
+            send_response({"error": "Simpler has no sample loaded (warping not applicable)"});
+            return;
+        }
+        cursor_a.set("warping", warp_on ? 1 : 0);
+        if (warp_on && warp_mode >= 0) {
+            cursor_a.set("warp_mode", warp_mode);
+        }
+        // Read back so the caller can confirm the write landed
+        var read_warping = parseInt(cursor_a.get("warping"));
+        var read_warp_mode = parseInt(cursor_a.get("warp_mode"));
+        send_response({
+            "ok": true,
+            "track_index": track_idx,
+            "device_index": device_idx,
+            "warping": read_warping,
+            "warp_mode": read_warp_mode,
+        });
+    } catch(e) {
+        send_response({"error": "simpler_set_warp failed: " + e.message});
+    }
+}
+
+// ── BUG-A3: Compressor sidechain input routing ───────────────────────
+//
+// Sidechain INPUT ROUTING is exposed as LiveAPI properties on the
+// Compressor device in Live 11+: sidechain_input_routing_type and
+// sidechain_input_routing_channel. They don't appear in the automatable
+// parameter list so the Python Remote Script can't reach them; Max JS
+// LiveAPI can.
+//
+// args: [track_index, device_index, routing_type, routing_channel]
+//   routing_type: string — e.g. "1-Audio From" / track name / "Ext. In"
+//   routing_channel: string — "Post FX" / "Pre FX" / "Post Mixer" / ...
+//
+// Returns: {ok, sidechain: {type, channel}} on success.
+// Older Live versions without these properties return a clean error.
+function cmd_compressor_set_sidechain(args) {
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var routing_type = String(args[2] || "");
+    var routing_channel = String(args[3] || "");
+
+    var path = build_device_path(track_idx, device_idx);
+    cursor_a.goto(path);
+    if (cursor_a.id === 0) {
+        send_response({"error": "Device not found at track " + track_idx + ", device " + device_idx});
+        return;
+    }
+    var class_name = String(cursor_a.get("class_name"));
+    if (class_name !== "Compressor2" && class_name !== "Compressor") {
+        send_response({"error": "Not a Compressor device (class is " + class_name + ")"});
+        return;
+    }
+
+    // Helper: read a LiveAPI property that returns a JSON-serialized dict
+    // or list. Max's `get()` wraps results in a single-element array,
+    // and complex properties come back as JSON strings.
+    function read_json_prop(name) {
+        try {
+            var raw = cursor_a.get(name);
+            if (raw === null || raw === undefined) return null;
+            if (Object.prototype.toString.call(raw) === "[object Array]" && raw.length === 1) {
+                raw = raw[0];
+            }
+            if (typeof raw === "string") {
+                try { return JSON.parse(raw); } catch(e) { return raw; }
+            }
+            return raw;
+        } catch(e) {
+            return null;
+        }
+    }
+
+    function find_by_name(list, name) {
+        if (!list || !list.length || !name) return null;
+        for (var i = 0; i < list.length; i++) {
+            var entry = list[i];
+            if (!entry) continue;
+            var n = entry.display_name || entry.name;
+            if (n === name) return entry;
+        }
+        return null;
+    }
+
+    try {
+        // Enable sidechain first — Live rejects routing writes on a
+        // compressor with the sidechain disabled. Property is available
+        // on Live 10+. Try/catch for legacy builds.
+        try { cursor_a.set("sidechain_enabled", 1); } catch(e) {}
+
+        var debug = {};
+
+        // --- Routing TYPE (the source: "1-DRUMS", "Ext. In", "No Input", …)
+        if (routing_type) {
+            var types = read_json_prop("available_sidechain_input_routing_types");
+            debug.requested_type = routing_type;
+            debug.type_count = types && types.length ? types.length : 0;
+            var t_match = find_by_name(types, routing_type);
+            if (t_match && t_match.identifier !== undefined) {
+                // LOM expects a RoutingType object; Max JS accepts a
+                // JSON-encoded {identifier: N} for the `set`.
+                cursor_a.set(
+                    "sidechain_input_routing_type",
+                    JSON.stringify({identifier: t_match.identifier})
+                );
+                debug.set_type = "ok (identifier=" + t_match.identifier + ")";
+            } else {
+                debug.set_type = "FAIL: no matching type";
+                if (types) {
+                    debug.available_types = [];
+                    for (var i = 0; i < types.length; i++) {
+                        debug.available_types.push(types[i].display_name || types[i].name || "?");
+                    }
+                }
+            }
+        }
+
+        // --- Routing CHANNEL (the tap point: "Post FX", "Pre FX", …)
+        if (routing_channel) {
+            var channels = read_json_prop("available_sidechain_input_routing_channels");
+            debug.requested_channel = routing_channel;
+            debug.channel_count = channels && channels.length ? channels.length : 0;
+            var c_match = find_by_name(channels, routing_channel);
+            if (c_match && c_match.identifier !== undefined) {
+                cursor_a.set(
+                    "sidechain_input_routing_channel",
+                    JSON.stringify({identifier: c_match.identifier})
+                );
+                debug.set_channel = "ok (identifier=" + c_match.identifier + ")";
+            } else {
+                debug.set_channel = "FAIL: no matching channel";
+                if (channels) {
+                    debug.available_channels = [];
+                    for (var j = 0; j < channels.length; j++) {
+                        debug.available_channels.push(channels[j].display_name || channels[j].name || "?");
+                    }
+                }
+            }
+        }
+
+        // Read back canonical display_name for confirmation
+        var cur_type = read_json_prop("sidechain_input_routing_type");
+        var cur_channel = read_json_prop("sidechain_input_routing_channel");
+        var read_type_name = (cur_type && cur_type.display_name) || "";
+        var read_channel_name = (cur_channel && cur_channel.display_name) || "";
+
+        send_response({
+            "ok": true,
+            "track_index": track_idx,
+            "device_index": device_idx,
+            "sidechain": {
+                "type": read_type_name,
+                "channel": read_channel_name,
+                "enabled": 1
+            },
+            "debug": debug
+        });
+    } catch(e) {
+        send_response({
+            "error": "compressor_set_sidechain failed: " + e.message
+                     + " (this Live build may not expose sidechain_input_routing_* —"
+                     + " user must set routing manually)"
+        });
+    }
+}
+
 // ── Phase 2: Warp Markers ─────────────────────────────────────────────
 
 function cmd_get_warp_markers(args) {

package/manifest.json

@@ -2,9 +2,9 @@
   "manifest_version": "0.3",
   "name": "livepilot",
   "display_name": "LivePilot — AI for Ableton Live",
-  "version": "1.10.5",
-  "description": "Agentic production system for Ableton Live 12. Make beats, mix tracks, design sounds, and arrange songs with 320 AI-powered tools.",
-  "long_description": "LivePilot is an agentic production system for Ableton Live 12. 320 tools across 43 domains — device atlas (1305 devices), sample intelligence (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, and 12 creative engines.\n\n**What it does:**\n- Creates MIDI clips with notes, chords, and rhythms\n- Loads instruments and effects via Device Atlas (1305 devices indexed)\n- Searches samples across Splice, Ableton browser, and filesystem\n- Plans compositions from text prompts with genre-aware layering\n- Slices samples with intent-based MIDI generation\n- Mixes with volume, panning, sends, and automation\n- Analyzes your mix with real-time spectral data (M4L bridge)\n- Diagnoses stuck sessions and generates creative rescue variants\n- Remembers your production style across sessions\n\n**How it works:**\nLivePilot installs a Remote Script in Ableton that communicates with the AI over a local TCP connection. Everything runs on your machine — no audio leaves your computer.",
+  "version": "1.10.7",
+  "description": "Agentic production system for Ableton Live 12. Make beats, mix tracks, design sounds, and arrange songs with 323 AI-powered tools.",
+  "long_description": "LivePilot is an agentic production system for Ableton Live 12. 323 tools across 45 domains — device atlas (1305 devices), sample intelligence (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, and 12 creative engines.\n\n**What it does:**\n- Creates MIDI clips with notes, chords, and rhythms\n- Loads instruments and effects via Device Atlas (1305 devices indexed)\n- Searches samples across Splice, Ableton browser, and filesystem\n- Plans compositions from text prompts with genre-aware layering\n- Slices samples with intent-based MIDI generation\n- Mixes with volume, panning, sends, and automation\n- Analyzes your mix with real-time spectral data (M4L bridge)\n- Diagnoses stuck sessions and generates creative rescue variants\n- Remembers your production style across sessions\n\n**How it works:**\nLivePilot installs a Remote Script in Ableton that communicates with the AI over a local TCP connection. Everything runs on your machine — no audio leaves your computer.",
   "author": {
     "name": "Pilot Studio",
     "url": "https://github.com/dreamrec/LivePilot"

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.10.5"
+__version__ = "1.10.7"

package/mcp_server/atlas/__init__.py

@@ -115,26 +115,70 @@ class AtlasManager:
         query_words = query_lower.split()
         results: List[Dict[str, Any]] = []
 
+        # BUG-B39: the real atlas scanner emits "instruments" /
+        # "audio_effects" but older callers and test fixtures sometimes
+        # pass the singular "instrument" / "effect". Build a tolerant
+        # category alias set so both forms work.
+        _CAT_ALIASES = {
+            "instrument": {"instrument", "instruments"},
+            "instruments": {"instrument", "instruments"},
+            "effect": {"effect", "effects", "audio_effects"},
+            "effects": {"effect", "effects", "audio_effects"},
+            "audio_effect": {"effect", "effects", "audio_effects",
+                             "audio_effect"},
+            "audio_effects": {"effect", "effects", "audio_effects",
+                              "audio_effect"},
+        }
+        allowed_cats = (
+            _CAT_ALIASES.get(category, {category})
+            if category != "all" else None
+        )
+
         for dev in self._devices:
             # Category filter
-            if category != "all" and dev.get("category", "") != category:
+            if allowed_cats is not None and dev.get("category", "") not in allowed_cats:
                 continue
 
             score = 0
             dev_name = dev.get("name", "")
             dev_name_lower = dev_name.lower()
 
-            # Name scoring: 100pts exact, 50pts substring
+            # Name scoring. BUG-B41 fix: dropped weight dramatically
+            # (was 100 exact / 50 substring) so a device literally
+            # named "Bass" no longer blows past character-tag matches
+            # for a sonic query like "warm analog bass". An exact name
+            # match is still the strongest single signal, but a device
+            # with 2+ matching character-tags now beats a name-only
+            # accident.
             if dev_name_lower == query_lower:
-                score += 100
+                score += 45  # was 100
             elif query_lower in dev_name_lower:
-                score += 50
-
-            # Tag scoring: 30pts per matching tag
-            dev_tags = [t.lower() for t in dev.get("tags", [])]
+                score += 20  # was 50
+            else:
+                # Partial: any query word present in name — small signal
+                for word in query_words:
+                    if len(word) >= 3 and word in dev_name_lower:
+                        score += 5
+
+            # Tag scoring — prefer enriched character_tags.
+            # BUG-B40 / B41: also read character_tags so enriched devices
+            # actually compete with name-based matches.
+            dev_tags = [
+                t.lower() for t in (
+                    dev.get("character_tags") or dev.get("tags", [])
+                )
+            ]
+            # BUG-B41: bumped to 35pts per tag so multi-tag matches beat
+            # a single substring-name match.
             for word in query_words:
                 if word in dev_tags:
-                    score += 30
+                    score += 35
+                # Partial tag match (word appears as substring in a tag)
+                else:
+                    for tag in dev_tags:
+                        if word in tag:
+                            score += 10
+                            break
 
             # Use case scoring: 25pts per match
             for use_case in dev.get("use_cases", []):
@@ -142,10 +186,11 @@ class AtlasManager:
                 for word in query_words:
                     if word in use_lower:
                         score += 25
-                        break  # one match per use_case
+                        break
 
-            # Genre scoring: 20pts primary, 10pts secondary
-            genres = dev.get("genres", {})
+            # Genre scoring: 20pts primary, 10pts secondary.
+            # BUG-B40: also read genre_affinity (enriched field).
+            genres = dev.get("genre_affinity") or dev.get("genres", {}) or {}
             for genre in genres.get("primary", []):
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 20
@@ -153,8 +198,11 @@ class AtlasManager:
                 if query_lower in genre.lower() or genre.lower() in query_lower:
                     score += 10
 
-            # Description keyword scoring: 15pts
-            description = dev.get("description", "").lower()
+            # Description keyword scoring: 15pts.
+            # BUG-B40: prefer sonic_description when present.
+            description = (
+                dev.get("sonic_description") or dev.get("description", "")
+            ).lower()
             for word in query_words:
                 if len(word) >= 3 and word in description:
                     score += 15
@@ -224,7 +272,13 @@ class AtlasManager:
     def chain_suggest(
         self, role: str, genre: str = ""
     ) -> Dict[str, Any]:
-        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad')."""
+        """Suggest a device chain for a given role (e.g., 'bass', 'lead', 'pad').
+
+        BUG-B39 fix: the old code passed category="instrument" (singular)
+        and category="effect" to self.search(), but the atlas stores
+        devices with category="instruments" / "audio_effects" (plural).
+        Every filtered search missed and the chain came back empty.
+        """
         chain: List[Dict[str, Any]] = []
         position = 0
 
@@ -244,8 +298,8 @@ class AtlasManager:
         intent = instrument_intents.get(role_lower, role_lower)
         search_q = f"{intent} {genre}" if genre else intent
 
-        # Find instrument
-        instrument_candidates = self.search(search_q, category="instrument", limit=3)
+        # Find instrument — atlas category is "instruments" (plural)
+        instrument_candidates = self.search(search_q, category="instruments", limit=3)
         if instrument_candidates:
             best = instrument_candidates[0]["device"]
             chain.append({
@@ -255,7 +309,7 @@ class AtlasManager:
             })
             position += 1
 
-        # Stage 2: Effects
+        # Stage 2: Effects — atlas category is "audio_effects"
         effect_stages = [
             ("eq", f"Shape the {role} tone"),
             ("compression", f"Control {role} dynamics"),
@@ -264,7 +318,9 @@ class AtlasManager:
 
         for effect_type, reason in effect_stages:
             effect_q = f"{effect_type} {genre}" if genre else effect_type
-            effect_candidates = self.search(effect_q, category="effect", limit=2)
+            effect_candidates = self.search(
+                effect_q, category="audio_effects", limit=2,
+            )
             if effect_candidates:
                 best = effect_candidates[0]["device"]
                 chain.append({
@@ -295,37 +351,48 @@ class AtlasManager:
             return {"error": f"Device not found: {device_b}"}
 
         def _summarize(dev: Dict[str, Any]) -> Dict[str, Any]:
+            # BUG-B40 fix: enriched atlas entries use character_tags /
+            # sonic_description / genre_affinity — the old _summarize
+            # looked for "tags" / "description" / "genres" which are
+            # the UN-enriched raw scanner fields. We prefer enriched
+            # fields, fall back to raw when enrichment is absent.
             return {
                 "name": dev.get("name", ""),
                 "category": dev.get("category", ""),
-                "tags": dev.get("tags", []),
-                "genres": dev.get("genres", {}),
+                "tags": dev.get("character_tags") or dev.get("tags", []),
+                "genres": dev.get("genre_affinity") or dev.get("genres", {}),
                 "use_cases": dev.get("use_cases", []),
-                "description": dev.get("description", ""),
+                "description": (
+                    dev.get("sonic_description")
+                    or dev.get("description", "")
+                ),
                 "cpu_weight": dev.get("cpu_weight", "unknown"),
                 "sweet_spot": dev.get("sweet_spot", ""),
+                "enriched": dev.get("enriched", False),
             }
 
         summary_a = _summarize(dev_a)
         summary_b = _summarize(dev_b)
 
-        # Recommendation logic: score each for the role
+        # Recommendation logic: score each for the role.
+        # BUG-B40: scorer also reads the enriched field names.
         score_a = 0
         score_b = 0
         if role:
             role_lower = role.lower()
-            # Check use_cases
             for uc in dev_a.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_a += 20
             for uc in dev_b.get("use_cases", []):
                 if role_lower in uc.lower():
                     score_b += 20
-            # Check tags
-            for tag in dev_a.get("tags", []):
+            # Tag scoring — prefer character_tags (enriched)
+            a_tags = dev_a.get("character_tags") or dev_a.get("tags", [])
+            b_tags = dev_b.get("character_tags") or dev_b.get("tags", [])
+            for tag in a_tags:
                 if role_lower in tag.lower():
                     score_a += 10
-            for tag in dev_b.get("tags", []):
+            for tag in b_tags:
                 if role_lower in tag.lower():
                     score_b += 10
 

package/mcp_server/composer/sample_resolver.py

@@ -45,6 +45,10 @@ from pathlib import Path
 from typing import Optional, Tuple
 
 from .layer_planner import LayerSpec
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 _AUDIO_EXTENSIONS = (".wav", ".aif", ".aiff", ".flac")
@@ -216,9 +220,9 @@ async def _splice_resolve(
             query=layer.search_query,
             per_page=5,
         )
-    except Exception:
+    except Exception as exc:
+        logger.debug("_splice_resolve failed: %s", exc)
         return None, "unresolved"
-
     samples = list(result.samples) if result and hasattr(result, "samples") else []
     if not samples:
         return None, "unresolved"
@@ -243,7 +247,8 @@ async def _splice_resolve(
             downloaded = await splice_client.download_sample(file_hash)
             if downloaded and Path(downloaded).exists():
                 return downloaded, "splice_remote"
-        except Exception:
+        except Exception as exc:
+            logger.debug("_splice_resolve failed: %s", exc)
             continue  # try next hit
 
     return None, "unresolved"
@@ -286,7 +291,6 @@ async def resolve_sample_for_layer(
                 lp = hit.get("file_path") if isinstance(hit, dict) else None
                 if lp and Path(lp).exists():
                     return lp, "browser"
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("resolve_sample_for_layer failed: %s", exc)
     return None, "unresolved"

package/mcp_server/composer/tools.py

@@ -14,6 +14,10 @@ from fastmcp import Context
 from ..server import mcp
 from .prompt_parser import parse_prompt
 from .engine import ComposerEngine
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 
 # Singleton engine — stateless, safe to reuse
@@ -29,8 +33,8 @@ def _get_search_roots(ctx: Context) -> list:
         cfg = ctx.lifespan_context.get("sample_search_roots") if hasattr(ctx, "lifespan_context") else None
         if cfg:
             roots.extend(cfg)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_search_roots failed: %s", exc)
     return roots
 
 
@@ -52,7 +56,8 @@ async def _credit_safety_prelude(splice_client, max_credits: int) -> tuple[int,
     try:
         info = await splice_client.get_credits()
         credits_remaining = getattr(info, "credits", None)
-    except Exception:
+    except Exception as exc:
+        logger.debug("_credit_safety_prelude failed: %s", exc)
         credits_remaining = None
 
     if credits_remaining is None:
@@ -153,9 +158,8 @@ async def augment_with_samples(
             info = ableton.send_command("get_session_info", {})
             session_context["tempo"] = info.get("tempo", 120)
             session_context["track_count"] = info.get("track_count", 0)
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("augment_with_samples failed: %s", exc)
     result = await _engine.augment(
         request=request,
         max_credits=max_credits,

package/mcp_server/connection.py

@@ -11,6 +11,10 @@ import time
 import uuid
 from collections import deque
 from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 CONNECT_TIMEOUT = 5
 RECV_TIMEOUT = 20
@@ -153,7 +157,8 @@ class AbletonConnection:
         """Send a ping and return True if a pong is received."""
         try:
             return self.send_command("ping").get("pong") is True
-        except Exception:
+        except Exception as exc:
+            logger.debug("ping failed: %s", exc)
             return False
 
     def send_command(self, command_type: str, params: Optional[dict] = None) -> dict: