livepilot 1.9.16 → 1.9.18

package/mcp_server/connection.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import json
 import os
 import socket
@@ -162,15 +161,20 @@ class AbletonConnection:
             try:
                 response = self._send_raw(command)
             except AbletonConnectionError as exc:
-                # Don't retry timeouts — Ableton may have processed the command
+                # If the send phase succeeded (data left this process),
+                # Ableton may have already applied the command.  Never
+                # replay — the duplicate mutation is worse than the error.
+                if getattr(exc, '_send_completed', False):
+                    raise
+                # Don't retry timeouts either
                 if "Timeout" in str(exc):
                     raise
-                # Retry once with a fresh connection for non-timeout errors
+                # Send itself failed — safe to retry with a fresh connection
                 self.disconnect()
                 self.connect()
                 response = self._send_raw(command)
             except OSError:
-                # Retry once with a fresh connection
+                # Socket error before send — safe to retry
                 self.disconnect()
                 self.connect()
                 response = self._send_raw(command)
@@ -196,15 +200,6 @@ class AbletonConnection:
         self._command_log.append(log_entry)
         return response.get("result", {})
 
-    async def send_command_async(self, command_type: str, params: Optional[dict] = None) -> dict:
-        """Async wrapper around send_command that avoids blocking the event loop.
-
-        Runs the blocking TCP send/receive in a thread pool executor so the
-        asyncio event loop remains responsive to other concurrent MCP tools.
-        """
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, self.send_command, command_type, params)
-
     # ------------------------------------------------------------------
     # Command log
     # ------------------------------------------------------------------
@@ -234,7 +229,9 @@ class AbletonConnection:
             self.disconnect()
             raise AbletonConnectionError(f"Failed to send command: {exc}") from exc
 
-        # Read until newline, preserving any trailing bytes in _recv_buf
+        # Read until newline, preserving any trailing bytes in _recv_buf.
+        # Any error past this point means the send already reached Ableton,
+        # so callers must NOT retry the command (it may have been applied).
         buf = self._recv_buf
         try:
             while b"\n" not in buf:
@@ -242,31 +239,41 @@ class AbletonConnection:
                 if not chunk:
                     self._recv_buf = b""
                     self.disconnect()
-                    raise AbletonConnectionError("Connection closed by Ableton")
+                    err = AbletonConnectionError("Connection closed by Ableton")
+                    err._send_completed = True
+                    raise err
                 buf += chunk
                 if len(buf) > 10 * 1024 * 1024:  # 10 MB
                     self._recv_buf = b""
                     self.disconnect()
-                    raise AbletonConnectionError("Response too large (>10 MB)")
+                    err = AbletonConnectionError("Response too large (>10 MB)")
+                    err._send_completed = True
+                    raise err
         except socket.timeout as exc:
             self._recv_buf = buf
             self.disconnect()
             other_client = _identify_other_tcp_client(self.host, self.port)
             if other_client:
-                raise AbletonConnectionError(
+                err = AbletonConnectionError(
                     "Timeout waiting for response from Ableton. "
                     f"Another LivePilot client appears to be connected on {self.host}:{self.port} "
                     f"({other_client}). Disconnect the other client and retry."
-                ) from exc
-            raise AbletonConnectionError(
+                )
+                err._send_completed = True
+                raise err from exc
+            err = AbletonConnectionError(
                 f"Timeout waiting for response from Ableton ({RECV_TIMEOUT}s)"
-            ) from exc
+            )
+            err._send_completed = True
+            raise err from exc
         except OSError as exc:
             self._recv_buf = b""
             self.disconnect()
-            raise AbletonConnectionError(
+            err = AbletonConnectionError(
                 f"Socket error reading response: {exc}"
-            ) from exc
+            )
+            err._send_completed = True
+            raise err from exc
 
         line, remainder = buf.split(b"\n", 1)
         self._recv_buf = remainder

package/mcp_server/evaluation/tools.py

@@ -6,7 +6,7 @@ to the appropriate engine-specific evaluator via fabric.evaluate().
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest, EvaluationResult

package/mcp_server/m4l_bridge.py

@@ -400,15 +400,18 @@ class M4LBridge:
                 return {"error": "M4L capture timeout — device may be busy or removed"}
 
     async def cancel_capture_future(self) -> None:
-        """Cancel any in-progress capture future (called by capture_stop).
+        """Resolve any in-progress capture future with a stopped result.
 
         Does NOT acquire _cmd_lock — send_capture holds it during recording.
-        Cancelling the future causes send_capture's wait_for to raise
-        CancelledError, which releases the lock naturally.
+        Resolving (not cancelling) the future lets send_capture return a
+        clean partial-result dict instead of raising CancelledError.
         """
         if self.receiver and self.receiver._capture_future \
                 and not self.receiver._capture_future.done():
-            self.receiver._capture_future.cancel()
+            self.receiver._capture_future.set_result({
+                "ok": True,
+                "stopped_early": True,
+            })
             self.receiver._capture_future = None
 
     def _build_osc(self, address: str, args: tuple) -> bytes:

package/mcp_server/mix_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest

package/mcp_server/performance_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .models import EnergyWindow, SceneRole

package/mcp_server/reference_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._research_engine import get_style_tactics

package/mcp_server/sound_design/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .models import (

package/mcp_server/tools/analyzer.py

@@ -634,14 +634,15 @@ async def capture_audio(
 async def capture_stop(ctx: Context) -> dict:
     """Stop an in-progress audio capture early.
 
-    Cancels the running buffer~ recording and returns whatever audio has
-    been captured so far. The partial file is still written to disk.
+    Tells the M4L bridge to stop buffer~ recording and resolves the
+    in-flight capture_audio call with a partial result (stopped_early=True).
+    The partial file is still written to disk by the bridge.
     Requires LivePilot Analyzer on master track.
     """
     cache = _get_spectral(ctx)
     _require_analyzer(cache)
     bridge = _get_m4l(ctx)
-    # Cancel the capture future so send_capture doesn't hang forever
+    # Resolve the capture future so send_capture returns cleanly
     await bridge.cancel_capture_future()
     return await bridge.send_command("capture_stop")
 

package/mcp_server/tools/tracks.py

@@ -176,10 +176,10 @@ def set_group_fold(ctx: Context, track_index: int, folded: bool) -> dict:
 
 @mcp.tool()
 def set_track_input_monitoring(ctx: Context, track_index: int, state: int) -> dict:
-    """Set input monitoring (0=Off, 1=In, 2=Auto). Only for regular tracks, not return tracks."""
-    _validate_track_index(track_index)
+    """Set input monitoring (0=In, 1=Auto, 2=Off). Only for regular tracks, not return tracks."""
+    _validate_track_index(track_index, allow_return=False)
     if state not in (0, 1, 2):
-        raise ValueError("Monitoring state must be 0=Off, 1=In, or 2=Auto")
+        raise ValueError("Monitoring state must be 0=In, 1=Auto, or 2=Off")
     return _get_ableton(ctx).send_command("set_track_input_monitoring", {
         "track_index": track_index,
         "state": state,

package/mcp_server/translation_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation critics.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .critics import build_translation_report, run_all_translation_critics

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.9.16",
+  "version": "1.9.18",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 236 tools, 31 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.9.16"
+__version__ = "1.9.18"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/arrangement.py

@@ -190,13 +190,20 @@ def add_arrangement_notes(song, params):
     try:
         note_specs = []
         for note in notes:
-            spec = Live.Clip.MidiNoteSpecification(
+            kwargs = dict(
                 pitch=int(note["pitch"]),
                 start_time=float(note["start_time"]),
                 duration=float(note["duration"]),
                 velocity=float(note.get("velocity", 100)),
                 mute=bool(note.get("mute", False)),
             )
+            if "probability" in note:
+                kwargs["probability"] = float(note["probability"])
+            if "velocity_deviation" in note:
+                kwargs["velocity_deviation"] = float(note["velocity_deviation"])
+            if "release_velocity" in note:
+                kwargs["release_velocity"] = float(note["release_velocity"])
+            spec = Live.Clip.MidiNoteSpecification(**kwargs)
             note_specs.append(spec)
         clip.add_new_notes(tuple(note_specs))
     finally:
@@ -703,4 +710,4 @@ def toggle_cue_point(song, params):
 def back_to_arranger(song, params):
     """Switch playback from session clips back to the arrangement timeline."""
     song.back_to_arranger = True
-    return {"back_to_arranger": song.back_to_arranger}
+    return {"back_to_arranger": True}

package/remote_script/LivePilot/browser.py

@@ -263,6 +263,7 @@ def load_browser_item(song, params):
         return None
 
     for category in categories:
+        _iterations[0] = 0  # Reset counter per category to avoid premature cutoff
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track

package/remote_script/LivePilot/clip_automation.py

@@ -100,6 +100,7 @@ def set_clip_automation(song, params):
     elif parameter_type == "send":
         if send_index is None:
             raise ValueError("send_index required for send automation")
+        send_index = int(send_index)
         sends = list(track.mixer_device.sends)
         if send_index < 0 or send_index >= len(sends):
             raise IndexError("send_index %d out of range" % send_index)
@@ -107,6 +108,8 @@ def set_clip_automation(song, params):
     elif parameter_type == "device":
         if device_index is None or parameter_index is None:
             raise ValueError("device_index and parameter_index required")
+        device_index = int(device_index)
+        parameter_index = int(parameter_index)
         devices = list(track.devices)
         if device_index < 0 or device_index >= len(devices):
             raise IndexError("device_index %d out of range" % device_index)
@@ -180,6 +183,7 @@ def clear_clip_automation(song, params):
             send_index = params.get("send_index")
             if send_index is None:
                 raise ValueError("send_index required for send automation")
+            send_index = int(send_index)
             sends = list(track.mixer_device.sends)
             if send_index < 0 or send_index >= len(sends):
                 raise IndexError("send_index %d out of range" % send_index)
@@ -189,6 +193,8 @@ def clear_clip_automation(song, params):
             parameter_index = params.get("parameter_index")
             if device_index is None or parameter_index is None:
                 raise ValueError("device_index and parameter_index required")
+            device_index = int(device_index)
+            parameter_index = int(parameter_index)
             devices = list(track.devices)
             if device_index < 0 or device_index >= len(devices):
                 raise IndexError("device_index %d out of range" % device_index)

package/remote_script/LivePilot/clips.py

@@ -72,6 +72,8 @@ def delete_clip(song, params):
     track_index = int(params["track_index"])
     clip_index = int(params["clip_index"])
     clip_slot = get_clip_slot(song, track_index, clip_index)
+    if not clip_slot.has_clip:
+        raise ValueError("No clip in slot %d on track %d" % (clip_index, track_index))
     clip_slot.delete_clip()
     return {"track_index": track_index, "clip_index": clip_index, "deleted": True}
 

package/remote_script/LivePilot/devices.py

@@ -270,6 +270,7 @@ def load_device_by_uri(song, params):
         return None
 
     for category in categories:
+        _iterations[0] = 0  # Reset counter per category to avoid premature cutoff
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track

package/remote_script/LivePilot/utils.py

@@ -54,8 +54,8 @@ def get_track(song, track_index):
         ri = abs(track_index) - 1
         if ri >= len(return_tracks):
             raise IndexError(
-                "Return track index %d out of range (0..%d)"
-                % (ri, len(return_tracks) - 1)
+                "Return track index %d out of range — %d return tracks available"
+                % (ri, len(return_tracks))
             )
         return return_tracks[ri]
     if track_index >= len(tracks):