livepilot 1.9.23 → 1.10.0

package/mcp_server/composer/prompt_parser.py

@@ -0,0 +1,329 @@
+"""Prompt parser — natural language → structured CompositionIntent.
+
+Extracts genre, mood, tempo, key, descriptors, and explicit element requests
+from free-form text prompts. Pure computation, no I/O.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+# ── Data Model ─────────────────────────────────────────────────────
+
+@dataclass
+class CompositionIntent:
+    """Structured representation of a composition request."""
+
+    genre: str = ""
+    sub_genre: str = ""
+    mood: str = ""
+    tempo: int = 0               # 0 = auto-detect from genre
+    key: str = ""                # "" = auto-pick based on mood
+    descriptors: list[str] = field(default_factory=list)
+    explicit_elements: list[str] = field(default_factory=list)
+    energy: float = 0.5          # 0.0-1.0
+    layer_count: int = 0         # 0 = auto (genre determines)
+    duration_bars: int = 64      # total arrangement length
+
+    def to_dict(self) -> dict:
+        return {
+            "genre": self.genre,
+            "sub_genre": self.sub_genre,
+            "mood": self.mood,
+            "tempo": self.tempo,
+            "key": self.key,
+            "descriptors": self.descriptors,
+            "explicit_elements": self.explicit_elements,
+            "energy": self.energy,
+            "layer_count": self.layer_count,
+            "duration_bars": self.duration_bars,
+        }
+
+
+# ── Genre Defaults ─────────────────────────────────────────────────
+# genre → (default_tempo, default_keys, default_energy, layer_range)
+
+GENRE_DEFAULTS: dict[str, dict] = {
+    "techno": {
+        "tempo": 128, "keys": ["Am", "Cm"], "energy": 0.7,
+        "layers_min": 5, "layers_max": 7,
+    },
+    "house": {
+        "tempo": 124, "keys": ["Cm", "Fm"], "energy": 0.6,
+        "layers_min": 5, "layers_max": 6,
+    },
+    "hip hop": {
+        "tempo": 90, "keys": ["Cm", "Gm"], "energy": 0.5,
+        "layers_min": 4, "layers_max": 6,
+    },
+    "ambient": {
+        "tempo": 80, "keys": ["C", "Am"], "energy": 0.2,
+        "layers_min": 3, "layers_max": 5,
+    },
+    "drum and bass": {
+        "tempo": 174, "keys": ["Am", "Em"], "energy": 0.8,
+        "layers_min": 5, "layers_max": 7,
+    },
+    "trap": {
+        "tempo": 140, "keys": ["Cm", "Bbm"], "energy": 0.6,
+        "layers_min": 4, "layers_max": 6,
+    },
+    "lo-fi": {
+        "tempo": 85, "keys": ["Fm", "Cm"], "energy": 0.3,
+        "layers_min": 3, "layers_max": 5,
+    },
+}
+
+# Aliases that map to canonical genre names
+_GENRE_ALIASES: dict[str, str] = {
+    "dnb": "drum and bass",
+    "d&b": "drum and bass",
+    "jungle": "drum and bass",
+    "lofi": "lo-fi",
+    "lo fi": "lo-fi",
+    "hiphop": "hip hop",
+    "hip-hop": "hip hop",
+    "deep house": "house",
+    "tech house": "house",
+    "acid techno": "techno",
+    "hard techno": "techno",
+    "industrial techno": "techno",
+    "minimal techno": "techno",
+    "detroit techno": "techno",
+    "dub techno": "techno",
+}
+
+
+# ── Mood Mapping ───────────────────────────────────────────────────
+# mood → (energy_range, key_bias_list)
+
+MOOD_MAPPING: dict[str, dict] = {
+    "dark": {
+        "energy_min": 0.4, "energy_max": 0.6,
+        "key_bias": ["Am", "Cm", "Em", "Dm"],
+    },
+    "euphoric": {
+        "energy_min": 0.8, "energy_max": 1.0,
+        "key_bias": ["C", "G", "F", "A"],
+    },
+    "melancholic": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["Fm", "Cm", "Dm", "Bbm"],
+    },
+    "aggressive": {
+        "energy_min": 0.8, "energy_max": 0.9,
+        "key_bias": ["Am", "Em", "Bm", "F#m"],
+    },
+    "dreamy": {
+        "energy_min": 0.2, "energy_max": 0.3,
+        "key_bias": ["C", "F", "Bb", "Eb"],
+    },
+    "chill": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["Fm", "Cm", "Gm", "Dm"],
+    },
+    "hypnotic": {
+        "energy_min": 0.5, "energy_max": 0.7,
+        "key_bias": ["Am", "Em", "Dm"],
+    },
+    "ethereal": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["C", "F", "Ab", "Eb"],
+    },
+    "driving": {
+        "energy_min": 0.7, "energy_max": 0.9,
+        "key_bias": ["Am", "Em", "Cm"],
+    },
+    "warm": {
+        "energy_min": 0.3, "energy_max": 0.5,
+        "key_bias": ["F", "Bb", "Eb", "Ab"],
+    },
+}
+
+
+# ── Sub-genre keywords ─────────────────────────────────────────────
+
+_SUB_GENRE_KEYWORDS: list[str] = [
+    "minimal", "deep", "acid", "industrial", "detroit", "dub",
+    "progressive", "melodic", "hard", "dark", "atmospheric",
+    "organic", "analog", "modular", "breakbeat", "uk garage",
+    "2-step", "drill", "boom bap", "old school", "new wave",
+]
+
+
+# ── Descriptor keywords (adjectives that color the composition) ────
+
+_DESCRIPTOR_KEYWORDS: list[str] = [
+    "industrial", "ghostly", "warm", "cold", "metallic", "organic",
+    "spacious", "intimate", "raw", "polished", "gritty", "clean",
+    "distorted", "saturated", "lush", "sparse", "dense", "airy",
+    "punchy", "soft", "crisp", "muddy", "bright", "muted",
+    "psychedelic", "glitchy", "cinematic", "underground", "futuristic",
+    "retro", "vintage", "modern", "classic", "experimental",
+]
+
+
+# ── Element extraction patterns ────────────────────────────────────
+
+_ELEMENT_PATTERNS: list[tuple[str, str]] = [
+    # (regex_pattern, element_name)
+    (r"\bwith\s+vocals?\b", "vocal"),
+    (r"\bwith\s+strings?\b", "strings"),
+    (r"\badd\s+strings?\b", "strings"),
+    (r"\b808\s*bass\b", "808"),
+    (r"\bwith\s+808\b", "808"),
+    (r"\bwith\s+synth\b", "synth"),
+    (r"\bwith\s+pads?\b", "pad"),
+    (r"\bwith\s+piano\b", "piano"),
+    (r"\bwith\s+guitar\b", "guitar"),
+    (r"\bwith\s+brass\b", "brass"),
+    (r"\bwith\s+horns?\b", "brass"),
+    (r"\bwith\s+(?:fx|effects?)\b", "fx"),
+    (r"\bwith\s+risers?\b", "fx"),
+    (r"\bwith\s+(?:perc|percussion)\b", "percussion"),
+    (r"\bwith\s+textures?\b", "texture"),
+    (r"\bghostly\s+vocals?\b", "vocal"),
+    (r"\bvocal\s+chops?\b", "vocal"),
+    (r"\bvocal\s+stabs?\b", "vocal"),
+    (r"\bsub\s*bass\b", "bass"),
+    (r"\breese\s*bass\b", "bass"),
+    (r"\bamen\s+break\b", "drums"),
+    (r"\bbreakbeat\b", "drums"),
+    (r"\bfoley\b", "texture"),
+    (r"\bfield\s+recordings?\b", "texture"),
+    (r"\batmospheric\b", "texture"),
+]
+
+
+# ── Regex helpers ──────────────────────────────────────────────────
+
+_TEMPO_RE = re.compile(r"\b(\d{2,3})\s*bpm\b", re.IGNORECASE)
+
+# Key patterns: C, Cm, C#, C# minor, Db, Dbm, F# minor, Bb major
+_KEY_RE = re.compile(
+    r"\b([A-Ga-g][#b]?)\s*(minor|major|min|maj|m)?\b"
+)
+
+
+# ── Parser ─────────────────────────────────────────────────────────
+
+def parse_prompt(text: str) -> CompositionIntent:
+    """Parse a natural language composition prompt into structured intent.
+
+    Examples:
+        "dark minimal techno 128bpm Cm"
+        "euphoric deep house with vocals"
+        "lo-fi hip hop 85bpm F minor dreamy"
+        "aggressive drum and bass 174bpm Am"
+    """
+    intent = CompositionIntent()
+    text_lower = text.lower().strip()
+
+    # 1. Extract tempo
+    tempo_match = _TEMPO_RE.search(text)
+    if tempo_match:
+        intent.tempo = int(tempo_match.group(1))
+
+    # 2. Extract key (search original text to preserve case)
+    key_match = _KEY_RE.search(text)
+    if key_match:
+        root = key_match.group(1)
+        # Normalize root: uppercase first letter
+        root = root[0].upper() + root[1:] if len(root) > 1 else root.upper()
+        quality = key_match.group(2) or ""
+        quality_lower = quality.lower()
+        if quality_lower in ("minor", "min", "m"):
+            intent.key = f"{root}m"
+        elif quality_lower in ("major", "maj"):
+            intent.key = root
+        else:
+            # Standalone note — check if followed by 'm' in the original
+            intent.key = root
+
+    # 3. Match genre (check aliases first, then canonical names)
+    # Sort by length descending to match longer aliases first
+    all_genres = list(_GENRE_ALIASES.items()) + [
+        (g, g) for g in GENRE_DEFAULTS
+    ]
+    all_genres.sort(key=lambda x: -len(x[0]))
+
+    for alias, canonical in all_genres:
+        if alias in text_lower:
+            intent.genre = canonical
+            # Extract sub-genre from the alias if it differs
+            if alias != canonical and " " in alias:
+                parts = alias.split()
+                for part in parts:
+                    if part != canonical and part in text_lower:
+                        intent.sub_genre = part
+            break
+
+    # 4. Check for sub-genre keywords not caught by alias matching
+    if not intent.sub_genre:
+        for kw in _SUB_GENRE_KEYWORDS:
+            if kw in text_lower and kw != intent.genre:
+                intent.sub_genre = kw
+                break
+
+    # 5. Match mood
+    for mood_name in MOOD_MAPPING:
+        if mood_name in text_lower:
+            intent.mood = mood_name
+            break
+
+    # 6. Extract descriptors
+    for descriptor in _DESCRIPTOR_KEYWORDS:
+        if descriptor in text_lower and descriptor != intent.mood and descriptor != intent.sub_genre:
+            intent.descriptors.append(descriptor)
+
+    # 7. Extract explicit elements
+    seen_elements: set[str] = set()
+    for pattern, element in _ELEMENT_PATTERNS:
+        if re.search(pattern, text_lower) and element not in seen_elements:
+            intent.explicit_elements.append(element)
+            seen_elements.add(element)
+
+    # 8. Apply genre defaults for missing fields
+    genre_info = GENRE_DEFAULTS.get(intent.genre, {})
+
+    if intent.tempo == 0 and genre_info:
+        intent.tempo = genre_info["tempo"]
+
+    if not intent.key:
+        # Use mood bias if available, otherwise genre default
+        if intent.mood and intent.mood in MOOD_MAPPING:
+            intent.key = MOOD_MAPPING[intent.mood]["key_bias"][0]
+        elif genre_info:
+            intent.key = genre_info["keys"][0]
+
+    # 9. Compute energy from mood, fallback to genre
+    if intent.mood and intent.mood in MOOD_MAPPING:
+        mood_info = MOOD_MAPPING[intent.mood]
+        intent.energy = (mood_info["energy_min"] + mood_info["energy_max"]) / 2.0
+    elif genre_info:
+        intent.energy = genre_info["energy"]
+    else:
+        intent.energy = 0.5
+
+    # 10. Determine layer count from genre + energy
+    if intent.layer_count == 0 and genre_info:
+        base_min = genre_info["layers_min"]
+        base_max = genre_info["layers_max"]
+        # Higher energy → more layers
+        energy_factor = intent.energy
+        intent.layer_count = round(
+            base_min + (base_max - base_min) * energy_factor
+        )
+
+    # Fallback defaults
+    if intent.tempo == 0:
+        intent.tempo = 120
+    if not intent.key:
+        intent.key = "Am"
+    if intent.layer_count == 0:
+        intent.layer_count = 5
+
+    return intent

package/mcp_server/composer/tools.py

@@ -0,0 +1,201 @@
+"""Composer Engine MCP tools — 3 tools for auto-composition.
+
+compose: full multi-layer composition from text prompt
+augment_with_samples: add layers to existing session
+get_composition_plan: dry run preview
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from .prompt_parser import parse_prompt
+from .engine import ComposerEngine
+
+
+# Singleton engine — stateless, safe to reuse
+_engine = ComposerEngine()
+
+
+@mcp.tool()
+async def compose(
+    ctx: Context,
+    prompt: str,
+    max_credits: int = 50,
+    dry_run: bool = False,
+) -> dict:
+    """Create a full multi-layer composition from a text prompt.
+
+    Searches Splice's catalog, selects matching samples with critic scoring,
+    downloads them, loads into Ableton, applies processing techniques, and
+    arranges into genre-appropriate sections.
+
+    prompt: "dark minimal techno 128bpm with industrial textures and ghostly vocals"
+    max_credits: maximum Splice credits to spend (default 50, 0 = use only downloaded)
+    dry_run: if True, return the plan without executing (same as get_composition_plan)
+
+    Returns a compiled plan with all execution steps. When dry_run is False,
+    the plan is ready for step-by-step execution by the agent.
+    """
+    # Parse the prompt into structured intent
+    intent = parse_prompt(prompt)
+
+    # Credit safety check
+    splice_client = None
+    credits_remaining = None
+    try:
+        lifespan = ctx.lifespan_context
+        if lifespan and "splice" in lifespan:
+            splice_client = lifespan["splice"]
+            if splice_client and splice_client.connected:
+                credits_remaining = await splice_client.get_credits_remaining()
+    except Exception:
+        pass
+
+    warnings: list[str] = []
+
+    if credits_remaining is not None:
+        if credits_remaining <= 5:
+            warnings.append(
+                f"Splice credits critically low ({credits_remaining}). "
+                f"Using downloaded samples only."
+            )
+            max_credits = 0
+        elif max_credits > credits_remaining - 5:
+            safe_budget = max(0, credits_remaining - 5)
+            warnings.append(
+                f"Budget capped at {safe_budget} credits "
+                f"(remaining: {credits_remaining}, floor: 5)."
+            )
+            max_credits = safe_budget
+
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        warnings.append(
+            "Splice not connected. Plan will use browser/filesystem fallback "
+            "for sample search."
+        )
+
+    # Compose
+    result = _engine.compose(intent, dry_run=dry_run, max_credits=max_credits)
+
+    # Merge warnings
+    result.warnings.extend(warnings)
+
+    output = result.to_dict()
+    output["prompt"] = prompt
+
+    if credits_remaining is not None:
+        output["credits_remaining"] = credits_remaining
+        output["credits_budget"] = max_credits
+
+    return output
+
+
+@mcp.tool()
+async def augment_with_samples(
+    ctx: Context,
+    request: str,
+    max_credits: int = 10,
+    max_layers: int = 3,
+) -> dict:
+    """Add sample-based layers to the existing session.
+
+    Analyzes the request, searches Splice for complementary samples,
+    and creates a plan to add new tracks with appropriate processing.
+
+    request: "add organic textures" or "layer a vocal chop over the verse"
+    max_credits: maximum Splice credits to spend (default 10)
+    max_layers: maximum number of new tracks to add (default 3)
+
+    Returns a compiled plan for adding new layers to the session.
+    """
+    # Credit safety
+    splice_client = None
+    credits_remaining = None
+    try:
+        lifespan = ctx.lifespan_context
+        if lifespan and "splice" in lifespan:
+            splice_client = lifespan["splice"]
+            if splice_client and splice_client.connected:
+                credits_remaining = await splice_client.get_credits_remaining()
+    except Exception:
+        pass
+
+    warnings: list[str] = []
+
+    if credits_remaining is not None:
+        if credits_remaining <= 5:
+            warnings.append(
+                f"Splice credits critically low ({credits_remaining}). "
+                f"Using downloaded samples only."
+            )
+            max_credits = 0
+        elif max_credits > credits_remaining - 5:
+            safe_budget = max(0, credits_remaining - 5)
+            max_credits = safe_budget
+
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        warnings.append(
+            "Splice not connected. Will use browser/filesystem fallback."
+        )
+
+    # Get current session info for context
+    session_context: dict = {}
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            info = ableton.send_command("get_session_info", {})
+            session_context["tempo"] = info.get("tempo", 120)
+            session_context["track_count"] = info.get("track_count", 0)
+    except Exception:
+        pass
+
+    # Augment
+    result = _engine.augment(
+        request=request,
+        max_credits=max_credits,
+        max_layers=max_layers,
+    )
+
+    # Override tempo from session if available
+    if session_context.get("tempo"):
+        result.intent.tempo = int(session_context["tempo"])
+
+    result.warnings.extend(warnings)
+
+    output = result.to_dict()
+    output["request"] = request
+
+    if session_context:
+        output["session_context"] = session_context
+    if credits_remaining is not None:
+        output["credits_remaining"] = credits_remaining
+        output["credits_budget"] = max_credits
+
+    return output
+
+
+@mcp.tool()
+async def get_composition_plan(
+    ctx: Context,
+    prompt: str,
+) -> dict:
+    """Preview what compose would do without executing or spending credits.
+
+    Returns the full layer plan with search queries, technique selections,
+    processing chains, and arrangement sections. Use to review before
+    committing to a full composition.
+
+    prompt: "dark minimal techno 128bpm with industrial textures"
+    """
+    intent = parse_prompt(prompt)
+    plan = _engine.get_plan(intent)
+    plan["prompt"] = prompt
+    plan["note"] = (
+        "This is a dry run. No samples searched, downloaded, or loaded. "
+        "Use compose() to execute this plan."
+    )
+    return plan

package/mcp_server/connection.py

@@ -14,6 +14,11 @@ from typing import Optional
 
 CONNECT_TIMEOUT = 5
 RECV_TIMEOUT = 20
+SINGLE_CLIENT_RETRY_DELAY = 0.25
+COMMAND_RECV_TIMEOUTS = {
+    # Server-side slow write window is 35s; give the client a small buffer.
+    "freeze_track": 40,
+}
 
 
 class AbletonConnectionError(Exception):
@@ -47,6 +52,19 @@ def _friendly_error(code: str, message: str, command_type: str) -> str:
     return " ".join(parts)
 
 
+def _is_single_client_state_error(response: dict) -> bool:
+    """Return True when the server rejected a fresh connection due to single-client guard."""
+    if response.get("ok") is not False:
+        return False
+    err = response.get("error", {})
+    if not isinstance(err, dict):
+        return False
+    return (
+        err.get("code") == "STATE_ERROR"
+        and "Another client is already connected" in str(err.get("message", ""))
+    )
+
+
 def _identify_other_tcp_client(host: str, port: int) -> str | None:
     """Return a short description of another established client on the Live port."""
     try:
@@ -134,9 +152,7 @@ class AbletonConnection:
     def ping(self) -> bool:
         """Send a ping and return True if a pong is received."""
         try:
-            with self._lock:
-                resp = self._send_raw({"type": "ping"})
-            return resp.get("result", {}).get("pong") is True
+            return self.send_command("ping").get("pong") is True
         except Exception:
             return False
 
@@ -151,7 +167,8 @@ class AbletonConnection:
         """
         with self._lock:
             # Ensure we have a connection
-            if not self.is_connected():
+            fresh_connect = not self.is_connected()
+            if fresh_connect:
                 self.connect()
 
             command: dict = {"type": command_type}
@@ -159,7 +176,10 @@ class AbletonConnection:
                 command["params"] = params
 
             try:
-                response = self._send_raw(command)
+                response = self._send_raw(
+                    command,
+                    recv_timeout=COMMAND_RECV_TIMEOUTS.get(command_type, RECV_TIMEOUT),
+                )
             except AbletonConnectionError as exc:
                 # If the send phase succeeded (data left this process),
                 # Ableton may have already applied the command.  Never
@@ -172,12 +192,30 @@ class AbletonConnection:
                 # Send itself failed — safe to retry with a fresh connection
                 self.disconnect()
                 self.connect()
-                response = self._send_raw(command)
+                response = self._send_raw(
+                    command,
+                    recv_timeout=COMMAND_RECV_TIMEOUTS.get(command_type, RECV_TIMEOUT),
+                )
             except OSError:
                 # Socket error before send — safe to retry
                 self.disconnect()
                 self.connect()
-                response = self._send_raw(command)
+                response = self._send_raw(
+                    command,
+                    recv_timeout=COMMAND_RECV_TIMEOUTS.get(command_type, RECV_TIMEOUT),
+                )
+
+            # The single-client guard can briefly reject an immediate reconnect
+            # after this process closes a previous socket. Retry once after a
+            # short delay when the command was rejected before execution.
+            if fresh_connect and _is_single_client_state_error(response):
+                self.disconnect()
+                time.sleep(SINGLE_CLIENT_RETRY_DELAY)
+                self.connect()
+                response = self._send_raw(
+                    command,
+                    recv_timeout=COMMAND_RECV_TIMEOUTS.get(command_type, RECV_TIMEOUT),
+                )
 
         # Log and error handling outside the lock (no socket access needed)
         log_entry = {
@@ -214,7 +252,7 @@ class AbletonConnection:
     # Low-level transport
     # ------------------------------------------------------------------
 
-    def _send_raw(self, command: dict) -> dict:
+    def _send_raw(self, command: dict, recv_timeout: int = RECV_TIMEOUT) -> dict:
         """Send a JSON command (with request_id) and read the response."""
         if self._socket is None:
             raise AbletonConnectionError("Not connected to Ableton Live")
@@ -222,6 +260,7 @@ class AbletonConnection:
         # Don't mutate the caller's dict
         envelope = {**command, "id": str(uuid.uuid4())[:8]}
         payload = json.dumps(envelope) + "\n"
+        self._socket.settimeout(recv_timeout)
 
         try:
             self._socket.sendall(payload.encode("utf-8"))
@@ -283,3 +322,9 @@ class AbletonConnection:
             raise AbletonConnectionError(
                 f"Invalid JSON from Ableton: {line[:200]}"
             ) from exc
+        finally:
+            if self._socket is not None:
+                try:
+                    self._socket.settimeout(RECV_TIMEOUT)
+                except OSError:
+                    pass