livepilot 1.27.1 → 1.27.3

package/mcp_server/device_forge/tools.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import tempfile
 from pathlib import Path
 
@@ -48,11 +49,13 @@ async def generate_m4l_effect(
     }
     dt = type_map.get(device_type)
     if dt is None:
-        return {"error": f"Invalid device_type: {device_type}. Use: audio_effect, midi_effect, instrument"}
+        return {"error": f"INVALID_PARAM: Invalid device_type: {device_type}. Use one of: {', '.join(type_map)}"}
 
     parsed_params = []
     if params:
         for p in params:
+            if not isinstance(p, dict) or "name" not in p:
+                return {"error": f"INVALID_PARAM: each param requires a 'name' key, got: {p!r}"}
             parsed_params.append(GenExprParam(
                 name=p["name"],
                 default=p.get("default", 0.5),
@@ -72,9 +75,16 @@ async def generate_m4l_effect(
     if install:
         subdir = _SUBDIR_MAP[dt]
         output_dir = ABLETON_USER_LIBRARY / subdir
-        path = build_device(spec, output_dir=output_dir)
     else:
-        path = build_device(spec, output_dir=tempfile.mkdtemp(prefix="livepilot_forge_"))
+        # Reuse ONE forge directory under the system temp instead of spawning a
+        # fresh mkdtemp() per call (those accumulated, never cleaned). The .amxd
+        # is the returned deliverable so it must persist for the caller.
+        output_dir = Path(tempfile.gettempdir()) / "livepilot_forge"
+
+    # build_device does blocking filesystem I/O (mkdir + write_bytes). This is
+    # an async tool running on the event loop, so offload to a worker thread to
+    # avoid freezing all other handlers + the bridge UDP endpoint.
+    path = await asyncio.to_thread(build_device, spec, output_dir)
 
     return {
         "status": "created",
@@ -113,15 +123,11 @@ async def list_genexpr_templates(
     }
 
 
-@mcp.tool()
-async def install_m4l_device(
-    ctx: Context,
-    source_path: str,
-) -> dict:
-    """Copy a .amxd file to Ableton's User Library.
+def _install_m4l_device_sync(source_path: str) -> dict:
+    """Blocking filesystem work for install_m4l_device (read/mkdir/write).
 
-    Args:
-        source_path: Path to the .amxd file to install
+    Run via asyncio.to_thread from the async tool below so the event loop
+    (and the bridge UDP endpoint) never stalls on disk I/O.
     """
     src = Path(source_path)
     if not src.exists():
@@ -160,3 +166,16 @@ async def install_m4l_device(
         "path": str(dest),
         "hint": "Device now available in Ableton's browser.",
     }
+
+
+@mcp.tool()
+async def install_m4l_device(
+    ctx: Context,
+    source_path: str,
+) -> dict:
+    """Copy a .amxd file to Ableton's User Library.
+
+    Args:
+        source_path: Path to the .amxd file to install
+    """
+    return await asyncio.to_thread(_install_m4l_device_sync, source_path)

package/mcp_server/experiment/engine.py

@@ -17,7 +17,9 @@ The engine itself is pure orchestration logic.
 
 from __future__ import annotations
 
+import asyncio
 import hashlib
+import threading
 import time
 from typing import Optional
 
@@ -28,8 +30,15 @@ import logging
 logger = logging.getLogger(__name__)
 
 # ── In-memory experiment store ───────────────────────────────────────────────
+#
+# _EXPERIMENTS is mutated from both threadpooled sync tools (create_experiment)
+# and event-loop async tools (run_experiment / commit_branch_async) — a
+# module-level lock around the dict ops keeps inserts/reads race-free under
+# mixed sync/async concurrent callers, mirroring preview_studio.engine and
+# wonder_mode.session.
 
 _EXPERIMENTS: dict[str, ExperimentSet] = {}
+_EXPERIMENTS_LOCK = threading.Lock()
 
 
 def _gen_id(prefix: str, seed: str) -> str:
@@ -89,7 +98,8 @@ def create_experiment_from_seeds(
         created_at_ms=now,
     )
 
-    _EXPERIMENTS[exp_id] = experiment
+    with _EXPERIMENTS_LOCK:
+        _EXPERIMENTS[exp_id] = experiment
     return experiment
 
 
@@ -114,12 +124,15 @@ def create_experiment(
 
 def get_experiment(experiment_id: str) -> Optional[ExperimentSet]:
     """Get an experiment by ID."""
-    return _EXPERIMENTS.get(experiment_id)
+    with _EXPERIMENTS_LOCK:
+        return _EXPERIMENTS.get(experiment_id)
 
 
 def list_experiments() -> list[dict]:
     """List all experiment sets."""
-    return [exp.to_dict() for exp in _EXPERIMENTS.values()]
+    with _EXPERIMENTS_LOCK:
+        exps = list(_EXPERIMENTS.values())
+    return [exp.to_dict() for exp in exps]
 
 # ── Run experiments (requires Ableton connection) ────────────────────────────
 
@@ -211,12 +224,16 @@ async def run_branch_async(
     analyze_mix) are skipped in the apply pass — they're used for snapshot
     capture separately.
     """
-    from ..runtime.execution_router import execute_plan_steps_async, filter_apply_steps
+    from ..runtime.execution_router import (
+        execute_plan_steps_async,
+        filter_apply_steps,
+        undo_remote_steps,
+    )
 
     branch.status = "running"
     branch.compiled_plan = compiled_plan
 
-    branch.before_snapshot = capture_fn()
+    branch.before_snapshot = await asyncio.to_thread(capture_fn)
 
     # Filter out read-only verification steps from the apply pass (canonical
     # list lives in execution_router.READ_ONLY_TOOLS).
@@ -244,24 +261,13 @@ async def run_branch_async(
     ]
 
     steps_executed = sum(1 for r in exec_results if r.ok)
-    # Only remote_command steps land on Ableton's linear undo stack. Bridge
-    # (M4L/OSC) and mcp_tool mutations do NOT, so issuing one `undo` per
-    # successful step over-undoes and walks back unrelated prior user edits.
-    # Count undos from remote_command successes alone.
-    undo_count = sum(
-        1 for r in exec_results if r.ok and r.backend == "remote_command"
-    )
     branch.executed_at_ms = int(time.time() * 1000)
-    branch.after_snapshot = capture_fn()
+    branch.after_snapshot = await asyncio.to_thread(capture_fn)
 
-    # Undo only the remote_command steps back to checkpoint. Undo is itself a
-    # remote_command, routed through the normal ableton.send_command path.
-    for _ in range(undo_count):
-        try:
-            ableton.send_command("undo", {})
-        except Exception as exc:
-            logger.debug("run_branch_async failed: %s", exc)
-            break
+    # Undo only the remote_command steps back to checkpoint (bridge/mcp_tool
+    # mutations don't land on Ableton's linear undo stack — see
+    # undo_remote_steps' docstring).
+    await undo_remote_steps(ableton, exec_results)
 
     # A branch is "evaluated" only if it actually applied at least one step.
     # If every step failed, mark it "failed" — this is the truth-release
@@ -442,7 +448,8 @@ def commit_branch(
 
 def discard_experiment(experiment_id: str) -> dict:
     """Discard an entire experiment set."""
-    exp = _EXPERIMENTS.get(experiment_id)
+    with _EXPERIMENTS_LOCK:
+        exp = _EXPERIMENTS.get(experiment_id)
     if not exp:
         return {"error": f"Experiment {experiment_id} not found"}
 

package/mcp_server/experiment/tools.py

@@ -10,6 +10,8 @@
 
 from __future__ import annotations
 
+import asyncio
+import functools
 import time
 from typing import Optional
 
@@ -351,7 +353,7 @@ async def run_experiment(
     if experiment.baseline_transport is None:
         from .baseline import capture_baseline
         try:
-            experiment.baseline_transport = capture_baseline(ableton)
+            experiment.baseline_transport = await asyncio.to_thread(capture_baseline, ableton)
         except Exception as exc:
             logger.debug("baseline capture failed: %s", exc)
             experiment.baseline_transport = None
@@ -365,7 +367,8 @@ async def run_experiment(
         # Between branches (not before the first), restore the baseline so
         # the next before_snapshot reads from the same reference state.
         if pending_seen > 0:
-            engine.prepare_for_next_branch(
+            await asyncio.to_thread(
+                engine.prepare_for_next_branch,
                 ableton, experiment.baseline_transport, stabilize_ms=300,
             )
         pending_seen += 1
@@ -414,7 +417,7 @@ async def run_experiment(
                 results.append(branch.to_dict())
                 continue
 
-            session_info = ableton.send_command("get_session_info")
+            session_info = await ableton.send_command_async("get_session_info")
             kernel = {"session_info": session_info, "mode": "explore"}
             plan = compiler.compile(move, kernel)
             compiled_dict = plan.to_dict()
@@ -422,12 +425,19 @@ async def run_experiment(
         # Pick the capture function — render-verify mode captures audio
         # and extracts a TimbralFingerprint, adding latency but giving
         # classify_branch_outcome real measurable evidence.
+        #
+        # NOTE: bound via functools.partial (not a lambda) so the blocking
+        # `_capture_snapshot*` call is never a "bare" call site in this
+        # function's body — it is only ever invoked downstream inside
+        # `engine.run_branch_async` via `await asyncio.to_thread(capture_fn)`,
+        # which is where the actual off-loop offload happens.
         if render_verify:
-            capture_fn = lambda: _capture_snapshot_with_render_verify(
+            capture_fn = functools.partial(
+                _capture_snapshot_with_render_verify,
                 ctx, duration_seconds=render_duration_seconds,
             )
         else:
-            capture_fn = lambda: _capture_snapshot(ctx)
+            capture_fn = functools.partial(_capture_snapshot, ctx)
 
         # Run the branch through the async router
         await engine.run_branch_async(