livepilot 1.10.4 → 1.10.6

package/mcp_server/sample_engine/tools.py

@@ -1,16 +1,20 @@
-"""Sample Engine MCP tools — 7 intelligence-layer tools.
+"""Sample Engine MCP tools — intelligence-layer tools.
 
-No new Ableton communication — these orchestrate existing tools
-through the analyzer, critics, planner, and technique library.
+Wraps analyzer, critics, planner, technique library, and (as of v1.10.5)
+direct Splice online catalog hunt/download via the gRPC client.
 """
 
 from __future__ import annotations
 
+import logging
+import os
 from typing import Optional
 
 from fastmcp import Context
 
 from ..server import mcp
+
+logger = logging.getLogger(__name__)
 from .models import SampleProfile, SampleIntent, SampleFitReport
 from .analyzer import build_profile_from_filename
 from .critics import run_all_sample_critics
@@ -46,8 +50,8 @@ async def analyze_sample(
                 )
                 if not result.get("error"):
                     file_path = result.get("file_path")
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("m4l get_clip_file_path failed: %s", exc)
 
     if file_path is None:
         return {"error": "Could not determine file path — provide file_path directly"}
@@ -96,7 +100,8 @@ def evaluate_sample_fit(
                 name = track_info.get("name", "").lower()
                 if name:
                     existing_roles.append(name)
-            except Exception:
+            except Exception as exc:
+                logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
 
         # Detect key from MIDI tracks
@@ -118,12 +123,13 @@ def evaluate_sample_fit(
                             mode_suffix = "m" if "minor" in mode else ""
                             song_key = f"{key_result['tonic_name']}{mode_suffix}"
                             break
-                except Exception:
+                except Exception as exc:
+                    logger.debug("key detection on track %d skipped: %s", i, exc)
                     continue
         except ImportError:
             pass
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("session context for evaluate_sample_fit failed: %s", exc)
 
     critics = run_all_sample_critics(
         profile=profile,
@@ -155,7 +161,7 @@ def evaluate_sample_fit(
 
 
 @mcp.tool()
-def search_samples(
+async def search_samples(
     ctx: Context,
     query: str,
     material_type: Optional[str] = None,
@@ -169,6 +175,12 @@ def search_samples(
     Searches all enabled sources in parallel and ranks results.
     Splice results include rich metadata (key, BPM, genre, tags, pack info).
 
+    When the Splice desktop app is running AND grpcio is installed, this
+    searches Splice's ONLINE catalog (19,690+ hits for a generic query)
+    and returns un-downloaded items alongside local files. When gRPC is
+    unavailable, it falls back to the local SQLite index and only returns
+    already-downloaded samples.
+
     query: search text like "dark vocal", "breakbeat", "foley metal"
     material_type: filter by type (vocal, drum_loop, texture, etc.)
     key: prefer samples in this key (e.g., "Cm", "F#")
@@ -188,21 +200,74 @@ def search_samples(
             except ValueError:
                 pass
 
-    # Splice search (richest metadata, searched first)
+    # Splice search — prefer gRPC online catalog when available, fall back
+    # to local SQLite index. See docs/2026-04-14-bugs-discovered.md — P0-2.
     if source in (None, "splice"):
-        splice = SpliceSource()
-        if splice.enabled:
-            splice_results = splice.search(
-                query=query,
-                max_results=max_results,
-                key=key,
-                bpm_min=bpm_min,
-                bpm_max=bpm_max,
-            )
-            for candidate in splice_results:
-                d = candidate.to_dict()
-                d["source_priority"] = 1  # highest
-                results.append(d)
+        grpc_client = None
+        try:
+            grpc_client = ctx.lifespan_context.get("splice_client")
+        except AttributeError:
+            grpc_client = None
+
+        used_grpc = False
+        if grpc_client is not None and getattr(grpc_client, "connected", False):
+            try:
+                grpc_result = await grpc_client.search_samples(
+                    query=query,
+                    key=(key or "").lower().rstrip("m") if key else "",
+                    bpm_min=int(bpm_min) if bpm_min else 0,
+                    bpm_max=int(bpm_max) if bpm_max else 0,
+                    per_page=max_results,
+                    page=1,
+                    purchased_only=False,
+                )
+                for s in grpc_result.samples[:max_results]:
+                    results.append({
+                        "source": "splice",
+                        "name": s.filename,
+                        "file_path": s.local_path or None,
+                        "uri": None,
+                        "freesound_id": None,
+                        "relevance_score": 0,
+                        "source_priority": 1,
+                        "splice_catalog": True,
+                        "downloaded": bool(s.local_path),
+                        "file_hash": s.file_hash,
+                        "metadata": {
+                            "key": s.audio_key,
+                            "bpm": s.bpm,
+                            "tags": ",".join(s.tags) if s.tags else "",
+                            "genre": s.genre or None,
+                            "sample_type": s.sample_type,
+                            "material_type": "vocal" if "vocal" in (s.tags or []) else "unknown",
+                            "pack": s.provider_name,
+                            "pack_uuid": s.pack_uuid,
+                            "duration": s.duration_ms / 1000.0 if s.duration_ms else 0.0,
+                            "is_premium": s.is_premium,
+                            "chord_type": s.chord_type,
+                        },
+                    })
+                used_grpc = True
+            except Exception as exc:
+                logger.warning("Splice gRPC search failed, falling back to SQL: %s", exc)
+                used_grpc = False
+
+        # Also query local index (if not already covered by gRPC) to surface
+        # downloaded-only samples that might not appear in catalog results.
+        if not used_grpc:
+            splice = SpliceSource()
+            if splice.enabled:
+                splice_results = splice.search(
+                    query=query,
+                    max_results=max_results,
+                    key=key,
+                    bpm_min=bpm_min,
+                    bpm_max=bpm_max,
+                )
+                for candidate in splice_results:
+                    d = candidate.to_dict()
+                    d["source_priority"] = 1
+                    results.append(d)
 
     # Browser search
     if source in (None, "browser"):
@@ -223,10 +288,11 @@ def search_samples(
                         d = candidate.to_dict()
                         d["source_priority"] = 2
                         results.append(d)
-                except Exception:
+                except Exception as exc:
+                    logger.debug("browser search %s skipped: %s", category, exc)
                     continue
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("browser search unavailable: %s", exc)
 
     # Filesystem search
     if source in (None, "filesystem"):
@@ -383,7 +449,8 @@ def get_sample_opportunities(ctx: Context) -> dict:
     try:
         ableton = ctx.lifespan_context["ableton"]
         info = ableton.send_command("get_session_info", {})
-    except Exception:
+    except Exception as exc:
+        logger.warning("get_sample_opportunities: Ableton not reachable: %s", exc)
         return {"opportunities": [], "note": "Cannot read session — Ableton not connected"}
 
     track_count = info.get("track_count", 0)
@@ -399,7 +466,8 @@ def get_sample_opportunities(ctx: Context) -> dict:
             for d in devices:
                 if d.get("class_name") in ("OriginalSimpler", "MultiSampler"):
                     has_sampler = True
-        except Exception:
+        except Exception as exc:
+            logger.debug("track scan idx=%d skipped: %s", i, exc)
             continue
 
     # No organic texture
@@ -483,8 +551,8 @@ def plan_slice_workflow(
         if ableton:
             info = ableton.send_command("get_session_info", {})
             tempo = float(info.get("tempo", 120.0))
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("plan_slice_workflow tempo fetch failed (using 120): %s", exc)
 
     # Read slice count from existing Simpler if track provided
     slice_count = 8  # Default transient slice count
@@ -497,8 +565,8 @@ def plan_slice_workflow(
                 })
                 if isinstance(slices, dict) and slices.get("slice_count"):
                     slice_count = slices["slice_count"]
-        except Exception:
-            pass  # Fall back to default
+        except Exception as exc:
+            logger.debug("get_simpler_slices failed (using default 8): %s", exc)
 
     # Build the plan
     plan = plan_slice_steps(
@@ -543,3 +611,296 @@ def plan_slice_workflow(
     plan["style_hint"] = style_hint
 
     return plan
+
+
+# ── v1.10.5 Splice online catalog tools ───────────────────────────────────
+#
+# These expose the SpliceGRPCClient's catalog capabilities as first-class MCP
+# tools so the agent can drive hunt→download→load without a standalone helper
+# script. See docs/2026-04-14-bugs-discovered.md — P0-2.
+#
+# Prerequisites:
+#   - Splice desktop app running (port.conf present in ~/Library/Application
+#     Support/com.splice.Splice/)
+#   - grpcio and protobuf installed (added to requirements.txt in v1.10.5)
+#
+# Credit model (as of 2026-04-14):
+#   - Even with `SoundsStatus: subscribed`, the gRPC `DownloadSample` endpoint
+#     always decrements a monthly credit counter (default 100/month on most
+#     subscription plans).
+#   - The "unlimited downloads in Ableton" the Splice marketing references
+#     only applies to the Splice Sounds.vst3 plugin, which uses a different
+#     HTTPS API that these tools cannot drive.
+#   - `CREDIT_HARD_FLOOR = 5` in client.py reserves 5 credits as a safety
+#     margin — downloads will refuse below the floor.
+
+
+_SPLICE_USER_LIB_DEST = "~/Music/Ableton/User Library/Samples/Splice"
+
+
+@mcp.tool()
+async def get_splice_credits(ctx: Context) -> dict:
+    """Get the user's current Splice credit balance and subscription tier.
+
+    Returns: {
+        "connected": bool,        # whether Splice desktop gRPC is reachable
+        "username": str,
+        "plan": str,              # e.g. "subscribed", "free"
+        "credits_remaining": int,
+        "credit_floor": int,      # safety reserve (typically 5)
+        "can_download": bool,     # credits_remaining > credit_floor
+    }
+
+    Returns connected=False (with zero credits) when the Splice desktop app
+    isn't running or grpcio isn't installed.
+    """
+    from ..splice_client.client import CREDIT_HARD_FLOOR
+
+    client = None
+    try:
+        client = ctx.lifespan_context.get("splice_client")
+    except AttributeError:
+        pass
+
+    if client is None or not getattr(client, "connected", False):
+        return {
+            "connected": False,
+            "username": "",
+            "plan": "",
+            "credits_remaining": 0,
+            "credit_floor": CREDIT_HARD_FLOOR,
+            "can_download": False,
+            "hint": (
+                "Splice gRPC not connected. Ensure Splice desktop app is "
+                "running and grpcio+protobuf are installed in the LivePilot "
+                "venv (pip install grpcio protobuf)."
+            ),
+        }
+
+    try:
+        info = await client.get_credits()
+    except Exception as exc:
+        return {
+            "connected": False,
+            "error": f"get_credits failed: {exc}",
+            "credit_floor": CREDIT_HARD_FLOOR,
+        }
+
+    remaining = int(info.credits)
+    return {
+        "connected": True,
+        "username": info.username,
+        "plan": info.plan,
+        "credits_remaining": remaining,
+        "credit_floor": CREDIT_HARD_FLOOR,
+        "can_download": remaining > CREDIT_HARD_FLOOR,
+    }
+
+
+@mcp.tool()
+async def splice_catalog_hunt(
+    ctx: Context,
+    query: str,
+    bpm_min: int = 0,
+    bpm_max: int = 0,
+    key: str = "",
+    sample_type: str = "",
+    genre: str = "",
+    per_page: int = 10,
+    page: int = 1,
+) -> dict:
+    """Search Splice's ONLINE catalog via gRPC.
+
+    Unlike `search_samples` which can fall back to the local SQLite index,
+    this tool ONLY queries the online catalog — if Splice isn't connected
+    it returns an error instead of local-only results. Use this when you
+    specifically want fresh catalog content.
+
+    query:       free-text search ("mellotron", "lofi chord", "soul vocal")
+    bpm_min:     minimum BPM (0 = no lower bound)
+    bpm_max:     maximum BPM (0 = no upper bound)
+    key:         musical key (e.g. "cm", "f#", "a")
+    sample_type: "loop", "oneshot", or "" for any
+    genre:       genre filter (e.g. "hip hop", "ambient")
+    per_page:    results per page (1-50)
+    page:        page number (1-indexed)
+
+    Returns: {
+        "connected": bool,
+        "total_hits": int,       # total catalog matches
+        "samples": [...],        # sample metadata with file_hash for download
+    }
+
+    Each sample entry contains `file_hash` which you can pass to
+    `splice_download_sample` to trigger a download.
+    """
+    client = None
+    try:
+        client = ctx.lifespan_context.get("splice_client")
+    except AttributeError:
+        pass
+
+    if client is None or not getattr(client, "connected", False):
+        return {
+            "connected": False,
+            "error": "Splice gRPC not connected",
+            "hint": (
+                "Ensure Splice desktop app is running. Also verify grpcio "
+                "and protobuf are installed: `pip install grpcio protobuf`."
+            ),
+            "samples": [],
+            "total_hits": 0,
+        }
+
+    try:
+        result = await client.search_samples(
+            query=query,
+            key=key.lower().rstrip("m") if key else "",
+            chord_type="minor" if key and key.lower().endswith("m") else "",
+            bpm_min=int(bpm_min),
+            bpm_max=int(bpm_max),
+            sample_type=sample_type,
+            genre=genre,
+            per_page=max(1, min(per_page, 50)),
+            page=max(1, int(page)),
+            purchased_only=False,
+        )
+    except Exception as exc:
+        return {
+            "connected": False,
+            "error": f"Splice search failed: {exc}",
+            "samples": [],
+        }
+
+    samples_out = []
+    for s in result.samples:
+        samples_out.append({
+            "file_hash": s.file_hash,
+            "filename": s.filename,
+            "key": s.audio_key,
+            "chord_type": s.chord_type,
+            "bpm": s.bpm,
+            "duration_sec": round((s.duration_ms or 0) / 1000.0, 2),
+            "genre": s.genre,
+            "sample_type": s.sample_type,
+            "tags": list(s.tags) if s.tags else [],
+            "pack": s.provider_name,
+            "pack_uuid": s.pack_uuid,
+            "is_premium": bool(s.is_premium),
+            "is_downloaded": bool(s.local_path),
+            "local_path": s.local_path or None,
+            "preview_url": s.preview_url,
+        })
+
+    return {
+        "connected": True,
+        "query": query,
+        "total_hits": result.total_hits,
+        "returned": len(samples_out),
+        "samples": samples_out,
+        "matching_tags": dict(result.matching_tags) if result.matching_tags else {},
+    }
+
+
+@mcp.tool()
+async def splice_download_sample(
+    ctx: Context,
+    file_hash: str,
+    copy_to_user_library: bool = True,
+) -> dict:
+    """Download a Splice sample by file_hash (costs 1 credit).
+
+    Use `splice_catalog_hunt` first to find samples and get their file_hash.
+    This tool will:
+      1. Check credit balance against the safety floor (refuses if < 5)
+      2. Trigger the download via the Splice desktop gRPC
+      3. Poll until the file appears on disk (up to 30s)
+      4. Optionally copy the file into `~/Music/Ableton/User Library/Samples/
+         Splice/` so Ableton's browser indexes it — this makes the sample
+         loadable via `load_browser_item` with a `query:UserLibrary#Samples:...`
+         URI.
+
+    Returns: {
+        "ok": bool,
+        "local_path": str,              # Splice's own download path
+        "user_library_path": str,       # if copy_to_user_library=True
+        "browser_uri": str,             # ready for load_browser_item
+        "credits_remaining": int,
+    }
+
+    Note: even with an "unlimited" subscription, this gRPC path always
+    decrements credits (typically 100/month allotment). The unlimited
+    downloads inside Ableton's Splice Sounds VST3 use a different API
+    that LivePilot cannot drive programmatically yet.
+    """
+    import shutil
+
+    client = None
+    try:
+        client = ctx.lifespan_context.get("splice_client")
+    except AttributeError:
+        pass
+
+    if client is None or not getattr(client, "connected", False):
+        return {
+            "ok": False,
+            "error": "Splice gRPC not connected",
+        }
+
+    # Credit safety check
+    try:
+        can, remaining = await client.can_afford(1, budget=10)
+    except Exception as exc:
+        return {"ok": False, "error": f"Credit check failed: {exc}"}
+    if not can:
+        return {
+            "ok": False,
+            "error": (
+                f"Credit safety floor hit (remaining={remaining}, "
+                f"hard floor=5). Skipping download."
+            ),
+            "credits_remaining": remaining,
+        }
+
+    # Trigger download
+    try:
+        local_path = await client.download_sample(file_hash, timeout=30.0)
+    except Exception as exc:
+        return {"ok": False, "error": f"Download failed: {exc}"}
+
+    if not local_path:
+        return {
+            "ok": False,
+            "error": "Download did not complete within 30s timeout",
+        }
+
+    response: dict = {
+        "ok": True,
+        "local_path": local_path,
+        "filename": os.path.basename(local_path),
+    }
+
+    # Copy into User Library so Ableton's browser indexes it
+    if copy_to_user_library:
+        dest_dir = os.path.expanduser(_SPLICE_USER_LIB_DEST)
+        try:
+            os.makedirs(dest_dir, exist_ok=True)
+            dest_path = os.path.join(dest_dir, os.path.basename(local_path))
+            if not os.path.exists(dest_path):
+                shutil.copy2(local_path, dest_path)
+            response["user_library_path"] = dest_path
+            # URI format Ableton uses for user_library samples
+            response["browser_uri"] = (
+                f"query:UserLibrary#Samples:Splice:{os.path.basename(local_path)}"
+            )
+        except Exception as exc:
+            response["copy_warning"] = f"Failed to copy to User Library: {exc}"
+
+    # Post-credit count
+    try:
+        info = await client.get_credits()
+        response["credits_remaining"] = int(info.credits)
+    except Exception as exc:
+        logger.warning("post-download credit check failed: %s", exc)
+
+    return response

package/mcp_server/semantic_moves/tools.py

@@ -14,6 +14,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import registry
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 @mcp.tool()
@@ -80,7 +83,8 @@ def preview_semantic_move(
                 info = ableton.send_command("get_session_info")
                 if isinstance(info, dict):
                     session_info = info
-            except Exception:
+            except Exception as exc:
+                logger.debug("preview_semantic_move failed: %s", exc)
                 session_info = {}
 
         state = build_capability_state(

package/mcp_server/server.py

@@ -44,9 +44,9 @@ def _master_has_livepilot_analyzer(ableton: AbletonConnection) -> bool:
     """Check whether the analyzer device is currently on the master track."""
     try:
         track = ableton.send_command("get_master_track")
-    except Exception:
+    except Exception as exc:
+        logger.debug("_master_has_livepilot_analyzer failed: %s", exc)
         return False
-
     devices = track.get("devices", []) if isinstance(track, dict) else []
     for device in devices:
         normalized = " ".join(
@@ -92,7 +92,8 @@ async def lifespan(server):
     splice_client = SpliceGRPCClient()
     try:
         await splice_client.connect()
-    except Exception:
+    except Exception as exc:
+        logger.debug("lifespan failed: %s", exc)
         pass  # client remains in disconnected state
 
     # Start UDP listener for incoming M4L spectral data (port 9880)
@@ -144,10 +145,8 @@ async def lifespan(server):
         ableton.disconnect()
         try:
             await splice_client.disconnect()
-        except Exception:
-            pass
-
-
+        except Exception as exc:
+            logger.debug("lifespan failed: %s", exc)
 mcp = FastMCP("LivePilot", lifespan=lifespan)
 
 # Import tool modules so they register with `mcp`
@@ -199,7 +198,9 @@ from .device_forge import tools as device_forge_tools          # noqa: F401, E40
 from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
 from .atlas import tools as atlas_tools                        # noqa: F401, E402
 from .composer import tools as composer_tools                  # noqa: F401, E402
+import logging
 
+logger = logging.getLogger(__name__)
 
 # ---------------------------------------------------------------------------
 # Schema coercion patch — accept strings for numeric parameters
@@ -213,6 +214,7 @@ from .composer import tools as composer_tools                  # noqa: F401, E40
 # "5" → 5 and "0.75" → 0.75 automatically, so no tool code changes needed.
 # ---------------------------------------------------------------------------
 
+
 def _coerce_schema_property(prop: dict) -> None:
     """Widen a single JSON Schema property to also accept strings."""
     if prop.get("type") in ("integer", "number") and "anyOf" not in prop:
@@ -253,6 +255,7 @@ def _get_all_tools():
     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",
@@ -273,7 +276,6 @@ def _patch_tool_schemas() -> None:
             if isinstance(definition, dict):
                 _coerce_schema_property(definition)
 
-
 _patch_tool_schemas()
 
 
@@ -281,6 +283,5 @@ def main():
     """Run the MCP server over stdio."""
     mcp.run(transport="stdio")
 
-
 if __name__ == "__main__":
     main()

package/mcp_server/services/motif_service.py

@@ -9,6 +9,9 @@ Pure computation — no I/O. Callers provide pre-fetched data.
 from __future__ import annotations
 
 from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def get_motif_data(
@@ -28,13 +31,15 @@ def get_motif_data(
 
     try:
         from ..tools import _motif_engine as motif_engine
+
         motifs = motif_engine.detect_motifs(notes_by_track)
         return {
             "motifs": [m.to_dict() for m in motifs],
             "motif_count": len(motifs),
             "tracks_analyzed": len(notes_by_track),
         }
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_motif_data failed: %s", exc)
         return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
 
 
@@ -60,8 +65,9 @@ def fetch_notes_from_ableton(ableton, tracks: list[dict], max_clips: int = 8) ->
                     "clip_index": clip_idx,
                 })
                 track_notes.extend(result.get("notes", []))
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("fetch_notes_from_ableton failed: %s", exc)
+
         if track_notes:
             notes_by_track[t_idx] = track_notes
     return notes_by_track

package/mcp_server/session_continuity/tools.py

@@ -15,6 +15,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import tracker
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 @mcp.tool()
@@ -200,7 +203,6 @@ def explain_preference_vs_identity(
         "note": "Identity has stronger weight inside a session (0.65 vs 0.35)",
     }
 
-
 # ── Helpers ───────────────────────────────────────────────────────
 
 
@@ -222,9 +224,11 @@ def _get_taste_graph(ctx: Context) -> dict:
         from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
         from ..memory.anti_memory import AntiMemoryStore
+
         taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
         anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
         return build_taste_graph(taste_store=taste_store, anti_store=anti_store).to_dict()
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_taste_graph failed: %s", exc)
+
     return {}