livepilot 1.10.0 → 1.10.2

package/mcp_server/runtime/execution_router.py

@@ -1,34 +1,48 @@
-"""Unified execution router for compiled plan steps.
+"""Unified async execution router for compiled plan steps.
 
 Classifies each step by backend (remote_command, mcp_tool, bridge_command)
-and dispatches to the correct execution path. Replaces the pattern of
-sending everything through ableton.send_command() blindly.
+and dispatches through the correct transport. Async-only — there is no
+sync path. Callers that need to execute plans live inside an async tool
+and await execute_plan_steps_async.
 
 Step backends:
-  remote_command — valid Remote Script handler, goes through TCP
-  bridge_command — M4L bridge handler, goes through TCP (requires bridge)
-  mcp_tool — MCP-layer Python function, called directly
-  unknown — not a valid target anywhere
+  remote_command — valid Remote Script handler, goes through the sync TCP
+                    client (ableton.send_command)
+  bridge_command — M4L bridge handler, goes through the async UDP M4L bridge
+                    client (bridge.send_command), NOT through ableton
+  mcp_tool       — in-process Python function, dispatched via an mcp_registry
+                    dict supplied by the server lifespan
+  unknown        — not a valid target anywhere; returns a clear error
+
+Step-result binding:
+  Any step may carry an optional step_id. Later steps may reference an
+  earlier result by setting a param to {"$from_step": "<id>", "path": "a.b"}.
+  Resolved recursively BEFORE dispatch.
 """
 
 from __future__ import annotations
 
+import inspect
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Awaitable, Callable, Optional
 
 from .remote_commands import BRIDGE_COMMANDS, REMOTE_COMMANDS
 
 
 # MCP-only tools that exist as Python functions but NOT as TCP handlers.
 # These must be called through direct import, not ableton.send_command().
+# NOTE: capture_audio is a BRIDGE command (livepilot_bridge.js:146), not MCP.
+# It used to be duplicated here; removed to keep classification unambiguous.
 MCP_TOOLS: frozenset[str] = frozenset({
     "apply_automation_shape",
     "apply_gesture_template",
     "analyze_mix",
     "get_master_spectrum",
     "get_emotional_arc",
-    "capture_audio",
     "get_motif_graph",
+    # Sample-engine workflow tools — async Python that orchestrates multiple
+    # sub-commands (search_browser + load_browser_item + bridge.replace_simpler_sample).
+    "load_sample_to_simpler",
     # Device Forge tools (MCP-only, no TCP handler)
     "generate_m4l_effect",
     "install_m4l_device",
@@ -66,17 +80,75 @@ def classify_step(tool: str) -> str:
     return "unknown"
 
 
-def execute_step(
+# ── Step-result binding ─────────────────────────────────────────────────
+
+def _resolve_binding(binding: dict, step_results: dict) -> Any:
+    """Resolve a {"$from_step": step_id, "path": "a.b.c"} binding.
+
+    Raises ValueError with a clear message on missing step_id or missing key.
+    """
+    step_id = binding["$from_step"]
+    path = binding.get("path", "")
+
+    if step_id not in step_results:
+        available = sorted(step_results.keys())
+        raise ValueError(
+            f"Step binding failed: step_id '{step_id}' not found. "
+            f"Available: {available or '(no earlier results)'}"
+        )
+
+    current = step_results[step_id]
+    if not isinstance(current, dict):
+        raise ValueError(
+            f"Step binding failed: result of '{step_id}' is "
+            f"{type(current).__name__}, not a dict"
+        )
+
+    if not path:
+        return current
+
+    for segment in path.split("."):
+        if not isinstance(current, dict) or segment not in current:
+            keys = list(current.keys()) if isinstance(current, dict) else type(current).__name__
+            raise ValueError(
+                f"Step binding failed: path '{path}' not found in result of "
+                f"'{step_id}'. Available at this level: {keys}"
+            )
+        current = current[segment]
+
+    return current
+
+
+def _resolve_params(params: Any, step_results: dict) -> Any:
+    """Recursively walk params and resolve any $from_step bindings."""
+    if isinstance(params, dict):
+        if "$from_step" in params:
+            return _resolve_binding(params, step_results)
+        return {k: _resolve_params(v, step_results) for k, v in params.items()}
+    if isinstance(params, list):
+        return [_resolve_params(v, step_results) for v in params]
+    return params
+
+
+# ── Async execution path ────────────────────────────────────────────────
+
+async def _execute_step_async(
     tool: str,
     params: dict,
-    ableton: Any = None,
-    ctx: Any = None,
-    declared_backend: str | None = None,
+    ableton: Any,
+    bridge: Any,
+    mcp_registry: dict[str, Callable],
+    ctx: Any,
+    declared_backend: Optional[str] = None,
 ) -> ExecutionResult:
-    """Execute a single plan step through the correct backend."""
-    backend = declared_backend if declared_backend in ("remote_command", "bridge_command", "mcp_tool") else classify_step(tool)
+    """Dispatch a single step through the correct transport, async-aware."""
+    backend = (
+        declared_backend
+        if declared_backend in ("remote_command", "bridge_command", "mcp_tool")
+        else classify_step(tool)
+    )
 
-    if backend in ("remote_command", "bridge_command"):
+    if backend == "remote_command":
         if ableton is None:
             return ExecutionResult(
                 ok=False, backend=backend, tool=tool,
@@ -84,45 +156,95 @@ def execute_step(
             )
         try:
             result = ableton.send_command(tool, params)
+            if isinstance(result, dict) and "error" in result:
+                return ExecutionResult(ok=False, backend=backend, tool=tool, error=result["error"])
             return ExecutionResult(ok=True, backend=backend, tool=tool, result=result)
         except Exception as e:
             return ExecutionResult(ok=False, backend=backend, tool=tool, error=str(e))
 
-    elif backend == "mcp_tool":
-        # MCP tools require direct Python dispatch.
-        # For now, return a clear error — full MCP dispatch is wired per-tool
-        # in the callers (apply_semantic_move, render_preview_variant).
-        return ExecutionResult(
-            ok=False, backend=backend, tool=tool,
-            error=f"MCP tool '{tool}' requires direct Python dispatch — "
-                  f"not executable through TCP. Use the MCP layer directly.",
-        )
+    if backend == "bridge_command":
+        if bridge is None:
+            return ExecutionResult(
+                ok=False, backend=backend, tool=tool,
+                error="M4L bridge unavailable — cannot dispatch bridge command",
+            )
+        try:
+            # M4LBridge.send_command accepts (command, *args) and OSC-encodes
+            # each arg positionally. Plan authors construct params dicts in
+            # the order the bridge command expects; we unpack by insertion
+            # order (Python 3.7+ guarantees this). This keeps plans readable
+            # while matching the real bridge's positional wire format.
+            positional = list(params.values()) if params else []
+            call = bridge.send_command(tool, *positional)
+            result = await call if inspect.isawaitable(call) else call
+            if isinstance(result, dict) and "error" in result:
+                return ExecutionResult(ok=False, backend=backend, tool=tool, error=result["error"])
+            return ExecutionResult(ok=True, backend=backend, tool=tool, result=result)
+        except Exception as e:
+            return ExecutionResult(ok=False, backend=backend, tool=tool, error=str(e))
 
-    else:
-        return ExecutionResult(
-            ok=False, backend="unknown", tool=tool,
-            error=f"Unknown tool '{tool}' — not a Remote Script command, "
-                  f"bridge command, or registered MCP tool",
-        )
+    if backend == "mcp_tool":
+        fn = mcp_registry.get(tool) if mcp_registry else None
+        if fn is None:
+            return ExecutionResult(
+                ok=False, backend=backend, tool=tool,
+                error=(
+                    f"MCP tool '{tool}' not registered in async router dispatch map. "
+                    f"Add it to mcp_server.runtime.mcp_dispatch.build_mcp_dispatch_registry()."
+                ),
+            )
+        try:
+            sig = inspect.signature(fn)
+            kwargs = {"ctx": ctx} if "ctx" in sig.parameters else {}
+            call = fn(params, **kwargs)
+            result = await call if inspect.isawaitable(call) else call
+            if isinstance(result, dict) and "error" in result:
+                return ExecutionResult(ok=False, backend=backend, tool=tool, error=result["error"])
+            return ExecutionResult(ok=True, backend=backend, tool=tool, result=result)
+        except Exception as e:
+            return ExecutionResult(ok=False, backend=backend, tool=tool, error=str(e))
+
+    return ExecutionResult(
+        ok=False, backend="unknown", tool=tool,
+        error=(
+            f"Unknown tool '{tool}' — not a Remote Script command, "
+            f"bridge command, or registered MCP tool"
+        ),
+    )
 
 
-def execute_plan_steps(
+async def execute_plan_steps_async(
     steps: list[dict],
     ableton: Any = None,
+    bridge: Any = None,
+    mcp_registry: Optional[dict[str, Callable]] = None,
     ctx: Any = None,
     stop_on_failure: bool = True,
 ) -> list[ExecutionResult]:
-    """Execute a list of plan steps, returning results for each.
+    """Async plan executor with step-result binding and correct bridge transport.
 
-    Stops on first failure by default. Set stop_on_failure=False
-    to continue past errors (useful for best-effort execution).
+    Supports three backends:
+      - remote_command via ableton.send_command (sync TCP client)
+      - bridge_command via bridge.send_command  (async UDP M4L bridge client)
+      - mcp_tool       via mcp_registry[tool](params, ctx=ctx)
+
+    Step-result binding:
+      Any step may carry an optional "step_id". Later steps may reference an
+      earlier result by setting a param to {"$from_step": "<id>", "path": "a.b"}.
+      The router walks params recursively and resolves bindings before dispatch.
+      Missing ids or missing paths fail that step with a clear error.
+
+    stop_on_failure: Stop the plan on the first failing step (default). Set to
+      False for best-effort execution (each result still recorded).
     """
     results: list[ExecutionResult] = []
+    step_results: dict[str, Any] = {}
+    mcp_registry = mcp_registry or {}
 
     for step in steps:
         tool = step.get("tool") or step.get("command", "")
-        params = step.get("params") or step.get("args", {})
-        # Honor declared backend from step annotations (PR5) if present
+        raw_params = step.get("params") or step.get("args", {}) or {}
+        step_id = step.get("step_id")
         declared_backend = step.get("backend")
 
         if not tool:
@@ -134,9 +256,29 @@ def execute_plan_steps(
                 break
             continue
 
-        result = execute_step(tool, params, ableton=ableton, ctx=ctx, declared_backend=declared_backend)
+        # Resolve any $from_step bindings in params BEFORE dispatch.
+        try:
+            params = _resolve_params(raw_params, step_results)
+        except ValueError as e:
+            results.append(ExecutionResult(
+                ok=False, backend="binding", tool=tool, error=str(e),
+            ))
+            if stop_on_failure:
+                break
+            continue
+
+        result = await _execute_step_async(
+            tool, params,
+            ableton=ableton, bridge=bridge,
+            mcp_registry=mcp_registry, ctx=ctx,
+            declared_backend=declared_backend,
+        )
         results.append(result)
 
+        # Record successful step result for future bindings
+        if result.ok and step_id and isinstance(result.result, dict):
+            step_results[step_id] = result.result
+
         if not result.ok and stop_on_failure:
             break
 

package/mcp_server/runtime/mcp_dispatch.py

@@ -0,0 +1,46 @@
+"""Registry of in-process MCP tools callable from the async execution router.
+
+These tools live as Python async functions in the MCP server — not TCP Remote
+Script handlers and not M4L bridge commands. Plans that want to invoke them
+go through this registry so the async router can dispatch them in-process.
+
+Each entry is a thin wrapper around the real MCP tool import, keeping the
+module cheap to import (no heavy server wiring until a caller actually
+dispatches an MCP step).
+
+To add a new in-process tool to plans:
+  1. Add the tool name to MCP_TOOLS in execution_router.py so classify_step
+     returns "mcp_tool" for it.
+  2. Add an _adapter function here that imports the real implementation and
+     adapts its kwargs from a plan-style params dict.
+  3. Register the adapter in build_mcp_dispatch_registry.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+async def _load_sample_to_simpler(params: dict, ctx: Any = None) -> dict:
+    """Adapter for mcp_server.tools.analyzer.load_sample_to_simpler.
+
+    Accepts the plan-step params dict and unpacks into the real tool's kwargs.
+    """
+    from ..tools.analyzer import load_sample_to_simpler
+    return await load_sample_to_simpler(
+        ctx,
+        track_index=int(params["track_index"]),
+        file_path=str(params["file_path"]),
+        device_index=int(params.get("device_index", 0)),
+    )
+
+
+def build_mcp_dispatch_registry() -> dict[str, Callable]:
+    """Return the canonical registry of MCP-only tools for plan execution.
+
+    Callers (typically the server lifespan init) should call this once and
+    pass the registry to execute_plan_steps_async via the mcp_registry kwarg.
+    """
+    return {
+        "load_sample_to_simpler": _load_sample_to_simpler,
+    }

package/mcp_server/runtime/remote_commands.py

@@ -80,7 +80,10 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "remove_warp_marker", "capture_audio", "capture_stop",
     "check_flucoma", "scrub_clip", "stop_scrub", "get_display_values",
     "get_plugin_params", "map_plugin_param", "get_plugin_presets",
-    "load_sample_to_simpler",
+    # NOTE: load_sample_to_simpler used to live here, but it's actually an
+    # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
+    # command. It has no case in livepilot_bridge.js and no @register handler
+    # in remote_script. See mcp_server/runtime/execution_router.MCP_TOOLS.
 })
 
 # Combined: all valid send_command targets

package/mcp_server/runtime/tools.py

@@ -110,11 +110,16 @@ def get_session_kernel(
         memory_ok=True,
     )
 
-    # Optional subcomponents — degrade gracefully
-    ledger_summary = {}
-    taste_graph = {}
-    anti_prefs = []
-    session_mem = []
+    # Optional subcomponents — degrade gracefully, but reach into the SAME
+    # session-scoped stores the public memory tools read/write via
+    # ctx.lifespan_context.setdefault(...). Creating fresh stores here meant
+    # users who recorded anti-preferences, session memory, or taste signals
+    # through the MCP tools always saw an empty kernel.
+    ledger_summary: dict = {}
+    taste_graph: dict = {}
+    anti_prefs: list = []
+    session_mem: list = []
+    kernel_warnings: list[str] = []
 
     try:
         from .action_ledger import SessionLedger
@@ -122,38 +127,42 @@ def get_session_kernel(
         if ledger is None:
             ledger = SessionLedger()
             ctx.lifespan_context["action_ledger"] = ledger
-        if ledger:
-            recent = ledger.get_recent_moves(limit=10)
-            ledger_summary = {
-                "total_moves": len(ledger._entries),
-                "memory_candidate_count": len(ledger.get_memory_candidates()),
-                "last_move": ledger.get_last_move().to_dict() if ledger.get_last_move() else None,
-                "recent_moves": [entry.to_dict() for entry in recent],
-            }
-    except Exception:
-        pass
-
+        recent = ledger.get_recent_moves(limit=10)
+        ledger_summary = {
+            "total_moves": len(ledger._entries),
+            "memory_candidate_count": len(ledger.get_memory_candidates()),
+            "last_move": ledger.get_last_move().to_dict() if ledger.get_last_move() else None,
+            "recent_moves": [entry.to_dict() for entry in recent],
+        }
+    except Exception as e:
+        kernel_warnings.append(f"ledger_unavailable: {e}")
+
+    # Taste graph + anti-prefs — share stores via lifespan_context, use the
+    # canonical build_taste_graph() so consumers see dimension_weights shape.
     try:
+        from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
-        taste_store = TasteMemoryStore()
-        taste_graph = {d.name: d.to_dict() for d in taste_store._dims.values()
-                       if d.evidence_count > 0}
-    except Exception:
-        pass
-
-    try:
         from ..memory.anti_memory import AntiMemoryStore
-        anti_store = AntiMemoryStore()
-        anti_prefs = anti_store.list_all()
-    except Exception:
-        pass
+        from ..persistence.taste_store import PersistentTasteStore
+        taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
+        anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
+        persistent = ctx.lifespan_context.setdefault("persistent_taste", PersistentTasteStore())
+        graph = build_taste_graph(
+            taste_store=taste_store,
+            anti_store=anti_store,
+            persistent_store=persistent,
+        )
+        taste_graph = graph.to_dict()
+        anti_prefs = [p.to_dict() for p in anti_store.get_anti_preferences()]
+    except Exception as e:
+        kernel_warnings.append(f"taste_graph_unavailable: {e}")
 
     try:
         from ..memory.session_memory import SessionMemoryStore
-        mem_store = SessionMemoryStore()
-        session_mem = mem_store.recent(limit=10)
-    except Exception:
-        pass
+        mem_store = ctx.lifespan_context.setdefault("session_memory", SessionMemoryStore())
+        session_mem = [entry.to_dict() for entry in mem_store.get_recent(limit=10)]
+    except Exception as e:
+        kernel_warnings.append(f"session_memory_unavailable: {e}")
 
     kernel = build_session_kernel(
         session_info=session_info,
@@ -167,4 +176,18 @@ def get_session_kernel(
         anti_preferences=anti_prefs,
     )
 
-    return kernel.to_dict()
+    # Populate routing hints from conductor when request context is available
+    if request_text.strip():
+        try:
+            from ..tools._conductor import classify_request
+            plan = classify_request(request_text)
+            kernel.recommended_engines = [r.engine for r in plan.routes[:3]]
+            kernel.recommended_workflow = plan.workflow_mode
+        except Exception as e:
+            kernel_warnings.append(f"conductor_routing_unavailable: {e}")
+
+    result_dict = kernel.to_dict()
+    if kernel_warnings:
+        # Additive — callers can ignore; debug-mode introspection benefits.
+        result_dict["warnings"] = kernel_warnings
+    return result_dict

package/mcp_server/sample_engine/moves.py

@@ -14,8 +14,8 @@ SAMPLE_CHOP_RHYTHM = SemanticMove(
     targets={"groove": 0.5, "novelty": 0.3, "punch": 0.2},
     protect={"clarity": 0.6, "coherence": 0.5},
     risk_level="medium",
-    compile_plan=[
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load sample into Simpler for slicing"}, "description": "Load into Simpler", "backend": "bridge_command"},
+    plan_template=[
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load sample into Simpler for slicing"}, "description": "Load into Simpler", "backend": "mcp_tool"},
         {"tool": "set_simpler_playback_mode", "params": {"mode": "slice", "description": "Switch to slice mode for rhythmic chopping"}, "description": "Enable slice mode", "backend": "remote_command"},
         {"tool": "crop_simpler", "params": {"description": "Crop to rhythmically relevant region"}, "description": "Crop to useful region", "backend": "bridge_command"},
     ],
@@ -32,8 +32,8 @@ SAMPLE_TEXTURE_LAYER = SemanticMove(
     targets={"depth": 0.4, "motion": 0.3, "warmth": 0.3},
     protect={"clarity": 0.7, "punch": 0.5},
     risk_level="low",
-    compile_plan=[
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load textural sample into Simpler"}, "description": "Load texture sample", "backend": "bridge_command"},
+    plan_template=[
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load textural sample into Simpler"}, "description": "Load texture sample", "backend": "mcp_tool"},
         {"tool": "set_simpler_playback_mode", "params": {"mode": "classic", "description": "Classic mode for sustained texture playback"}, "description": "Classic playback", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "Lower filter cutoff to sit beneath main elements"}, "description": "Filter for background placement", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Add reverb send for spatial depth"}, "description": "Reverb for depth", "backend": "remote_command"},
@@ -50,8 +50,8 @@ SAMPLE_VOCAL_GHOST = SemanticMove(
     targets={"novelty": 0.4, "depth": 0.3, "motion": 0.3},
     protect={"clarity": 0.5},
     risk_level="medium",
-    compile_plan=[
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load vocal sample into Simpler"}, "description": "Load vocal", "backend": "bridge_command"},
+    plan_template=[
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load vocal sample into Simpler"}, "description": "Load vocal", "backend": "mcp_tool"},
         {"tool": "reverse_simpler", "params": {"description": "Reverse for ghostly character"}, "description": "Reverse vocal", "backend": "bridge_command"},
         {"tool": "set_device_parameter", "params": {"description": "Detune -5 to -12 semitones for haunting pitch"}, "description": "Pitch down for ghost effect", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Heavy reverb send 40-60% for wash"}, "description": "Reverb wash", "backend": "remote_command"},
@@ -68,9 +68,9 @@ SAMPLE_BREAK_LAYER = SemanticMove(
     targets={"groove": 0.4, "punch": 0.3, "novelty": 0.3},
     protect={"coherence": 0.6, "clarity": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "create_midi_track", "params": {"description": "New track for break layer"}, "description": "Create break track", "backend": "remote_command"},
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load breakbeat into Simpler"}, "description": "Load break", "backend": "bridge_command"},
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load breakbeat into Simpler"}, "description": "Load break", "backend": "mcp_tool"},
         {"tool": "set_simpler_playback_mode", "params": {"mode": "slice", "slice_by": "transient", "description": "Slice by transients for individual hits"}, "description": "Slice break by transients", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Set break layer volume below main drums"}, "description": "Balance break level", "backend": "remote_command"},
     ],
@@ -87,8 +87,8 @@ SAMPLE_RESAMPLE_DESTROY = SemanticMove(
     targets={"novelty": 0.5, "motion": 0.3, "groove": 0.2},
     protect={"coherence": 0.4},
     risk_level="high",
-    compile_plan=[
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load sample for destruction"}, "description": "Load source material", "backend": "bridge_command"},
+    plan_template=[
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load sample for destruction"}, "description": "Load source material", "backend": "mcp_tool"},
         {"tool": "warp_simpler", "params": {"description": "Extreme warp settings for time-stretch artifacts"}, "description": "Warp for artifacts", "backend": "bridge_command"},
         {"tool": "set_device_parameter", "params": {"description": "Add Redux or bitcrusher for lo-fi destruction"}, "description": "Bitcrush/reduce", "backend": "remote_command"},
         {"tool": "set_device_parameter", "params": {"description": "Saturator drive to maximum for harmonic distortion"}, "description": "Saturate heavily", "backend": "remote_command"},
@@ -105,8 +105,8 @@ SAMPLE_ONE_SHOT_ACCENT = SemanticMove(
     targets={"punch": 0.4, "groove": 0.3, "novelty": 0.3},
     protect={"clarity": 0.6, "coherence": 0.5},
     risk_level="low",
-    compile_plan=[
-        {"tool": "load_sample_to_simpler", "params": {"description": "Load one-shot into Simpler"}, "description": "Load one-shot", "backend": "bridge_command"},
+    plan_template=[
+        {"tool": "load_sample_to_simpler", "params": {"description": "Load one-shot into Simpler"}, "description": "Load one-shot", "backend": "mcp_tool"},
         {"tool": "set_simpler_playback_mode", "params": {"mode": "one_shot", "description": "One-shot mode for trigger playback"}, "description": "One-shot mode", "backend": "remote_command"},
         {"tool": "crop_simpler", "params": {"description": "Tight crop around the transient"}, "description": "Crop to transient", "backend": "bridge_command"},
     ],