livepilot 1.8.3 → 1.9.0

package/m4l_device/livepilot_bridge.js

@@ -83,7 +83,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.8.3"});
+            send_response({"ok": true, "version": "1.9.0"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -161,6 +161,16 @@ function dispatch(cmd, args) {
         case "get_display_values":
             cmd_get_display_values(args);
             break;
+        // ── Plugin Parameters ──
+        case "get_plugin_params":
+            cmd_get_plugin_params(args);
+            break;
+        case "map_plugin_param":
+            cmd_map_plugin_param(args);
+            break;
+        case "get_plugin_presets":
+            cmd_get_plugin_presets(args);
+            break;
         default:
             send_response({"error": "Unknown command: " + cmd});
     }
@@ -1035,6 +1045,165 @@ function pad2(n) {
     return n < 10 ? "0" + n : "" + n;
 }
 
+// ── Plugin Parameters ──────────────────────────────────────────────────────
+
+function cmd_get_plugin_params(args) {
+    // Returns all parameters for a VST/AU plugin device
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var class_name = cursor_a.get("class_name").toString();
+
+    // Check if this is a plugin device
+    var is_plugin = (class_name === "PluginDevice" || class_name === "AuPluginDevice");
+    if (!is_plugin) {
+        send_response({
+            "error": "Device is " + class_name + ", not a plugin (PluginDevice/AuPluginDevice)"
+        });
+        return;
+    }
+
+    var device_name = cursor_a.get("name").toString();
+    var param_count = cursor_a.getcount("parameters");
+    var params = [];
+    var current = 0;
+    var batch_size = 4;
+
+    function read_batch() {
+        var end = Math.min(current + batch_size, param_count);
+        for (var i = current; i < end; i++) {
+            cursor_b.goto(path + " parameters " + i);
+            params.push({
+                index: i,
+                name: cursor_b.get("name").toString(),
+                value: parseFloat(cursor_b.get("value")),
+                min: parseFloat(cursor_b.get("min")),
+                max: parseFloat(cursor_b.get("max")),
+                default_value: parseFloat(cursor_b.get("default_value")),
+                is_quantized: parseInt(cursor_b.get("is_quantized")) === 1,
+                value_string: String(cursor_b.call("str_for_value", parseFloat(cursor_b.get("value"))))
+            });
+        }
+        current = end;
+
+        if (current < param_count) {
+            var next_task = new Task(read_batch);
+            next_task.schedule(50);
+        } else {
+            send_response({
+                "track": track_idx,
+                "device": device_idx,
+                "name": device_name,
+                "class_name": class_name,
+                "is_plugin": true,
+                "parameter_count": param_count,
+                "parameters": params
+            });
+        }
+    }
+
+    if (param_count > 0) {
+        read_batch();
+    } else {
+        send_response({
+            "track": track_idx,
+            "device": device_idx,
+            "name": device_name,
+            "class_name": class_name,
+            "is_plugin": true,
+            "parameter_count": 0,
+            "parameters": []
+        });
+    }
+}
+
+function cmd_map_plugin_param(args) {
+    // Add a plugin parameter to Ableton's Configure list
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var param_idx = parseInt(args[2]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var param_count = cursor_a.getcount("parameters");
+    if (param_idx < 0 || param_idx >= param_count) {
+        send_response({"error": "Parameter index " + param_idx + " out of range (0.." + (param_count - 1) + ")"});
+        return;
+    }
+
+    // Navigate to the parameter and read its name
+    cursor_b.goto(path + " parameters " + param_idx);
+    var param_name = cursor_b.get("name").toString();
+
+    // Select the parameter — this is how Ableton's Configure mode works
+    // via LiveAPI. The parameter becomes visible in the device's macro panel.
+    try {
+        cursor_a.set("selected_parameter", param_idx);
+        cursor_a.call("store_chosen_bank");
+        send_response({
+            "mapped": true,
+            "parameter_index": param_idx,
+            "parameter_name": param_name
+        });
+    } catch(e) {
+        send_response({
+            "error": "Failed to map parameter: " + e.message,
+            "parameter_index": param_idx,
+            "parameter_name": param_name
+        });
+    }
+}
+
+function cmd_get_plugin_presets(args) {
+    // List plugin's internal presets
+    var track_idx = parseInt(args[0]);
+    var device_idx = parseInt(args[1]);
+    var path = build_device_path(track_idx, device_idx);
+
+    cursor_a.goto(path);
+    var class_name = cursor_a.get("class_name").toString();
+    var device_name = cursor_a.get("name").toString();
+
+    var is_plugin = (class_name === "PluginDevice" || class_name === "AuPluginDevice");
+    if (!is_plugin) {
+        send_response({
+            "error": "Device is " + class_name + ", not a plugin"
+        });
+        return;
+    }
+
+    // Read presets — the presets property returns an array of preset names
+    var presets = [];
+    try {
+        var preset_count = cursor_a.getcount("presets");
+        for (var i = 0; i < preset_count; i++) {
+            cursor_b.goto(path + " presets " + i);
+            presets.push({
+                index: i,
+                name: cursor_b.get("name").toString()
+            });
+        }
+    } catch(e) {
+        // Some plugins don't expose presets via LOM
+    }
+
+    // Try to get selected preset index
+    var selected = -1;
+    try {
+        selected = parseInt(cursor_a.get("selected_preset_index"));
+    } catch(e) {}
+
+    send_response({
+        "track": track_idx,
+        "device": device_idx,
+        "name": device_name,
+        "presets": presets,
+        "selected_preset": selected
+    });
+}
+
 // ── Helpers ────────────────────────────────────────────────────────────────
 
 function build_track_path(track_idx) {

package/mcp_server/__init__.py

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

package/mcp_server/m4l_bridge.py

@@ -97,6 +97,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def __init__(self, cache: SpectralCache):
         self.cache = cache
         self._chunks: dict[str, dict] = {}  # Reassembly buffer for chunked responses
+        self._chunk_id = 0
         self._response_callback: Optional[asyncio.Future] = None
         self._capture_future: Optional[asyncio.Future] = None
 
@@ -106,8 +107,9 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def datagram_received(self, data: bytes, addr: tuple) -> None:
         try:
             self._parse_osc(data)
-        except Exception:
-            pass  # Malformed packet, ignore
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: malformed OSC packet from {addr}: {exc}", file=sys.stderr)
 
     def _parse_osc(self, data: bytes) -> None:
         """Parse a minimal OSC message (address + typed args)."""
@@ -227,12 +229,15 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             result = json.loads(decoded)
             if self._response_callback and not self._response_callback.done():
                 self._response_callback.set_result(result)
-        except Exception:
-            pass
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
 
     def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
         """Reassemble chunked responses."""
-        key = str(total)  # Simple key — assumes one response at a time
+        if index == 0:
+            self._chunk_id += 1
+        key = str(self._chunk_id)
         if key not in self._chunks:
             self._chunks[key] = {"parts": {}, "total": total}
 
@@ -254,8 +259,9 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             result = json.loads(decoded)
             if self._capture_future and not self._capture_future.done():
                 self._capture_future.set_result(result)
-        except Exception:
-            pass
+        except Exception as exc:
+            import sys
+            print(f"LivePilot: failed to decode capture response: {exc}", file=sys.stderr)
 
     def set_response_future(self, future: asyncio.Future) -> None:
         """Set a future to be resolved with the next response."""
@@ -278,29 +284,31 @@ class M4LBridge:
         self.receiver = receiver
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self._m4l_addr = ("127.0.0.1", 9881)
+        self._cmd_lock = asyncio.Lock()
 
     async def send_command(self, command: str, *args: Any, timeout: float = 5.0) -> dict:
         """Send an OSC command to the M4L device and wait for the response."""
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
-        # Create a future for the response
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
-        if self.receiver:
-            self.receiver.set_response_future(future)
-
-        # Build and send OSC message (no leading / — Max udpreceive
-        # passes messagename with / intact to JS, breaking dispatch)
-        osc_data = self._build_osc(command, args)
-        self._sock.sendto(osc_data, self._m4l_addr)
-
-        # Wait for response with timeout
-        try:
-            result = await asyncio.wait_for(future, timeout=timeout)
-            return result
-        except asyncio.TimeoutError:
-            return {"error": "M4L bridge timeout — device may be busy or removed"}
+        async with self._cmd_lock:
+            # Create a future for the response
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
+            if self.receiver:
+                self.receiver.set_response_future(future)
+
+            # Build and send OSC message (no leading / — Max udpreceive
+            # passes messagename with / intact to JS, breaking dispatch)
+            osc_data = self._build_osc(command, args)
+            self._sock.sendto(osc_data, self._m4l_addr)
+
+            # Wait for response with timeout
+            try:
+                result = await asyncio.wait_for(future, timeout=timeout)
+                return result
+            except asyncio.TimeoutError:
+                return {"error": "M4L bridge timeout — device may be busy or removed"}
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
         """Send a capture command to the M4L device and wait for /capture_complete."""

package/mcp_server/memory/technique_store.py

@@ -114,7 +114,7 @@ class TechniqueStore:
     ) -> list[dict]:
         """Search techniques. Returns summaries (no payload)."""
         with self._lock:
-            results = list(self._data["techniques"])
+            results = copy.deepcopy(self._data["techniques"])
 
         # filter by type
         if type_filter:
@@ -156,7 +156,7 @@ class TechniqueStore:
             )
 
         with self._lock:
-            results = list(self._data["techniques"])
+            results = copy.deepcopy(self._data["techniques"])
 
         if type_filter:
             results = [t for t in results if t["type"] == type_filter]

package/mcp_server/server.py

@@ -29,7 +29,16 @@ def _kill_port_holder(port: int) -> None:
         for pid_str in out.splitlines():
             pid = int(pid_str)
             if pid != my_pid:
-                os.kill(pid, signal.SIGTERM)
+                # Only kill if it looks like a Python/LivePilot process
+                try:
+                    cmdline = subprocess.check_output(
+                        ["ps", "-p", str(pid), "-o", "command="],
+                        text=True, timeout=2,
+                    ).strip()
+                    if "mcp_server" in cmdline or "livepilot" in cmdline.lower():
+                        os.kill(pid, signal.SIGTERM)
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    pass  # Can't verify — don't kill
     except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
         pass  # lsof not found or no process — nothing to kill
 
@@ -139,6 +148,12 @@ def _get_all_tools():
     # FastMCP 3.x: mcp._local_provider._components (dict of key -> Tool)
     if hasattr(mcp, "_local_provider") and hasattr(mcp._local_provider, "_components"):
         return list(mcp._local_provider._components.values())
+    import sys
+    print(
+        "LivePilot: WARNING — could not access FastMCP tool registry, "
+        "string-to-number schema coercion will not work",
+        file=sys.stderr,
+    )
     return []
 
 

package/mcp_server/tools/_perception_engine.py

@@ -63,7 +63,8 @@ def _normalize_to_lufs(
     gain_linear = 10 ** (gain_db / 20.0)
     data, sr = _load_audio(file_path)
     normalized = np.clip(data * gain_linear, -1.0, 1.0)
-    tmp_path = tempfile.mktemp(suffix=".wav")
+    tmp_fd, tmp_path = tempfile.mkstemp(suffix=".wav")
+    os.close(tmp_fd)
     try:
         sf.write(tmp_path, normalized, sr)
     except Exception:
@@ -155,7 +156,7 @@ def compute_loudness(file_path: str, detail: str = "summary") -> dict[str, Any]:
 
     # Streaming compliance
     meets_streaming = {
-        name: integrated_lufs >= (target - 1.0)  # ±1 LU tolerance
+        name: abs(integrated_lufs - target) <= 1.0  # ±1 LU tolerance
         for name, target in STREAMING_TARGETS.items()
     }
 

package/mcp_server/tools/analyzer.py

@@ -284,9 +284,15 @@ async def load_sample_to_simpler(
         "uri": uri,
     })
 
-    # Step 2: Replace with the desired sample via M4L bridge
+    # Step 2: Find the newly created device (it's at the end of the chain)
+    track_info = ableton.send_command("get_track_info", {"track_index": track_index})
+    actual_device_index = len(track_info.get("devices", [])) - 1
+    if actual_device_index < 0:
+        actual_device_index = 0
+
+    # Step 3: Replace with the desired sample via M4L bridge
     result = await bridge.send_command(
-        "replace_simpler_sample", track_index, device_index, file_path
+        "replace_simpler_sample", track_index, actual_device_index, file_path
     )
     if "error" in result:
         return result

package/mcp_server/tools/arrangement.py

@@ -11,6 +11,7 @@ from typing import Any, Optional
 from fastmcp import Context
 
 from ..server import mcp
+from .notes import _validate_note
 
 
 def _get_ableton(ctx: Context):
@@ -104,7 +105,13 @@ def create_arrangement_clip(
     length:          total clip length in beats on the timeline
     loop_length:     pattern length to loop within the clip (e.g. 8.0 for an
                      8-beat pattern inside a 128-beat section). Defaults to
-                     the source clip's length.
+                     the source clip's length. Must be > 0.
+
+    When loop_length < source clip length, overlapping copies are placed
+    every loop_length beats. Ableton's "later clip takes priority" rule
+    ensures correct playback. Each copy's internal loop region is set to
+    loop_length beats. For best results, use loop_length >= source length.
+
     name:            optional clip display name
     color_index:     optional 0-69 Ableton color
 
@@ -124,6 +131,8 @@ def create_arrangement_clip(
         "length": length,
     }
     if loop_length is not None:
+        if loop_length <= 0:
+            raise ValueError("loop_length must be > 0")
         params["loop_length"] = loop_length
     if name:
         params["name"] = name
@@ -154,6 +163,8 @@ def add_arrangement_notes(
     _validate_clip_index(clip_index)
     if isinstance(notes, str):
         notes = json.loads(notes)
+    for note in notes:
+        _validate_note(note)
     return _get_ableton(ctx).send_command("add_arrangement_notes", {
         "track_index": track_index,
         "clip_index": clip_index,

package/mcp_server/tools/automation.py

@@ -23,7 +23,9 @@ def _ensure_list(v: Any) -> list:
     if isinstance(v, str):
         import json
         return json.loads(v)
-    return list(v)
+    if isinstance(v, list):
+        return v
+    return [v]
 
 
 @mcp.tool()
@@ -482,7 +484,7 @@ def analyze_for_automation(
         "track_index": track_index,
         "track_name": track_info.get("name", ""),
         "device_count": len(devices),
-        "current_level": meters.get("tracks", [{}])[0].get("level", 0),
+        "current_level": (meters.get("tracks") or [{}])[0].get("level", 0) if meters.get("tracks") else 0,
         "spectrum": spectrum,
         "suggestions": suggestions,
     }

package/mcp_server/tools/devices.py

@@ -1,6 +1,6 @@
-"""Device MCP tools — parameters, racks, browser loading.
+"""Device MCP tools — parameters, racks, browser loading, plugin deep control.
 
-12 tools matching the Remote Script devices domain.
+15 tools matching the Remote Script devices domain + M4L bridge.
 """
 
 from __future__ import annotations
@@ -254,3 +254,96 @@ def get_device_presets(ctx: Context, device_name: str) -> dict:
     return _get_ableton(ctx).send_command("get_device_presets", {
         "device_name": device_name,
     })
+
+
+# ── Plugin Deep Control (M4L Bridge) ────────────────────────────────────
+
+
+def _get_m4l(ctx: Context):
+    """Get M4LBridge from lifespan context."""
+    bridge = ctx.lifespan_context.get("m4l")
+    if not bridge:
+        raise RuntimeError("M4L bridge not initialized")
+    return bridge
+
+
+def _get_spectral(ctx: Context):
+    """Get SpectralCache from lifespan context."""
+    cache = ctx.lifespan_context.get("spectral")
+    if not cache:
+        raise RuntimeError("Spectral cache not initialized")
+    return cache
+
+
+def _require_analyzer(cache) -> None:
+    if not cache.is_connected:
+        raise ValueError(
+            "LivePilot Analyzer not detected. "
+            "Drag 'LivePilot Analyzer' onto the master track."
+        )
+
+
+@mcp.tool()
+async def get_plugin_parameters(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+) -> dict:
+    """Get ALL parameters from a VST/AU plugin including unconfigured ones.
+
+    Returns every parameter the plugin exposes — not just the 128
+    that Ableton's Configure panel shows. Includes name, value, min,
+    max, default, and display string for each.
+    Only works on PluginDevice/AuPluginDevice types.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("get_plugin_params", track_index, device_index)
+
+
+@mcp.tool()
+async def map_plugin_parameter(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+    parameter_index: int,
+) -> dict:
+    """Add a plugin parameter to Ableton's Configure list for automation.
+
+    After mapping, the parameter becomes visible in the device's macro
+    panel and can be automated with set_device_parameter or
+    set_clip_automation like any native parameter.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    if parameter_index < 0:
+        raise ValueError("parameter_index must be >= 0")
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("map_plugin_param", track_index, device_index, parameter_index)
+
+
+@mcp.tool()
+async def get_plugin_presets(
+    ctx: Context,
+    track_index: int,
+    device_index: int,
+) -> dict:
+    """List a VST/AU plugin's internal presets and banks.
+
+    Returns preset names and the currently selected preset index.
+    Only works on PluginDevice/AuPluginDevice types.
+    Requires LivePilot Analyzer on master track.
+    """
+    _validate_track_index(track_index)
+    _validate_device_index(device_index)
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    return await bridge.send_command("get_plugin_presets", track_index, device_index)

package/mcp_server/tools/harmony.py

@@ -226,10 +226,10 @@ def suggest_chromatic_mediants(
 
     mediants = harmony.get_chromatic_mediants(root_pc, quality)
 
-    chord_pcs = set(harmony.chord_to_midi(root_pc, quality))
+    chord_pcs = {p % 12 for p in harmony.chord_to_midi(root_pc, quality)}
     formatted = {}
     for key, (r, q) in mediants.items():
-        mediant_pcs = set(harmony.chord_to_midi(r, q))
+        mediant_pcs = {p % 12 for p in harmony.chord_to_midi(r, q)}
         common = len(chord_pcs & mediant_pcs)
         formatted[key] = {
             "chord": harmony.chord_to_str(r, q),