davinci-resolve-mcp 2.56.0 → 2.57.0

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.57.0
+
+Community feature requests #72 and #73.
+
+- **Added** OpenCode to the installer's supported MCP clients (issue #72). The
+  installer now writes/merges `~/.config/opencode/opencode.json` using OpenCode's
+  own schema (`type`/`enabled`, a combined `command` array, and an `environment`
+  block), and `--manual` prints a ready-to-paste OpenCode snippet.
+- **Added** `fusion_comp(action="add_fusion_mask", ...)` (issue #73): a one-call
+  Rectangle/Ellipse mask — adds the mask tool, sets its params (`corner_radius`,
+  `width`, `height`, `center`/`center_x`/`center_y`, etc., all 0..1), and
+  optionally wires it into a tool's mask input (`EffectMask` by default). Each
+  input is applied independently so one unsupported parameter never aborts the rest.
+- **Added** `fusion_comp(action="set_text_plus" / "get_text_plus", ...)` (issue
+  #73): read/write the text of a Fusion `Text+` tool or Fusion title template
+  (e.g. a "Deep" title), auto-finding the `Text+` tool when `tool_name` is
+  omitted. Complements `timeline(action="set_title_text")` for generator titles.
+- **Note** (issue #73) per-clip audio Stereo↔Mono conversion is not in
+  Blackmagic's scripting API and was not added. The supported surface is already
+  exposed: `timeline get_track_sub_type` (query channel format), `add_track` with
+  `audioType` (create mono/stereo tracks), `convert_to_stereo` (timeline-wide),
+  and `timeline_item get_source_audio_channel_mapping`.
+
+## What's New in v2.56.1
+
+Final reliability batch from the exhaustive audit (Wave B + P2/P3 selections).
+
+- **Fixed** (EX11) `audio_track_probe` reported `available: true` for track index 0
+  (and negatives); audio tracks are 1-indexed, so it now requires
+  `1 <= index <= track_count`.
+- **Fixed** (EX10) `_find_timeline_item_by_id` no longer silently skips a whole
+  track type when `GetTrackCount` errors — it logs the failure so a real API error
+  isn't mistaken for "item not found".
+- **Fixed** (P3) the raw `timeline_item_color.set_cdl` now validates the ASC-CDL
+  payload (shape/ranges) before `SetCDL`, matching its safe twin — malformed CDL
+  returns a structured error instead of being silently rejected by Resolve.
+- **Fixed** (P2) `media_pool.delete_timelines` is read-back verified: it reports
+  `verified` from the project's timeline count dropping, not the unreliable boolean.
+  `import_folder` now validates its required `path`.
+
 ## What's New in v2.56.0
 
 Destructive-action registry audit (EX-REG) — a systemic version of the EX2 bug.

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.56.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.57.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-34%20(341%20full)-blue.svg)](#server-modes)
@@ -21,7 +21,7 @@ A local browser control panel ships with the server for inspecting Resolve state
 npx davinci-resolve-mcp setup
 ```
 
-Before connecting, open DaVinci Resolve Studio and set **Preferences > General > External scripting using** to **Local**. The npm launcher installs a managed copy under your user application-data directory, then runs the universal Python installer. The installer creates a virtual environment, detects Resolve paths, and can configure Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Zed, Continue, Cline, Roo Code, and JetBrains IDEs.
+Before connecting, open DaVinci Resolve Studio and set **Preferences > General > External scripting using** to **Local**. The npm launcher installs a managed copy under your user application-data directory, then runs the universal Python installer. The installer creates a virtual environment, detects Resolve paths, and can configure Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Zed, Continue, Cline, Roo Code, OpenCode, and JetBrains IDEs.
 
 For source installs:
 

package/docs/SKILL.md

@@ -1219,6 +1219,14 @@ mutation wrappers around the raw Fusion API:
 - `safe_set_inputs(tool_name, inputs, readback?)`
 - `safe_connect_tools(target_tool, input_name, source_tool, dry_run?)`
 - `fusion_boundary_report(include_io?)`
+- `add_fusion_mask(mask_type?, width?, height?, corner_radius?, center?|center_x?/center_y?,
+  angle?, soft_edge?, border_width?, invert?, inputs?, connect_to?, connect_input?, readback?)`
+  — one-call Rectangle/Ellipse mask (e.g. rounded corners): adds the mask tool, sets its
+  params (0..1), and optionally wires it into `connect_to`'s mask input (`EffectMask` default).
+- `set_text_plus(text, tool_name?, input_name?, readback?)` / `get_text_plus(tool_name?, input_name?)`
+  — read/write the text of a Fusion `Text+` tool or Fusion title template (e.g. a "Deep"
+  title). Auto-finds the `Text+` tool when `tool_name` is omitted; `input_name` defaults to
+  `StyledText`. For non-Fusion generator titles, use `timeline(action="set_title_text")` instead.
 
 ---
 

package/docs/install.md

@@ -59,6 +59,7 @@ The installer can automatically configure any of these clients:
 | Roo Code | VS Code global storage |
 | Zed | `~/.config/zed/settings.json` |
 | Continue | `~/.continue/config.json` |
+| OpenCode | `~/.config/opencode/opencode.json` (or project-root `opencode.json`) |
 | JetBrains IDEs | Manual (Settings > Tools > AI Assistant > MCP) |
 
 You can configure multiple clients at once, or use `--clients manual` to get copy-paste config snippets.

package/install.py

@@ -4,7 +4,7 @@ DaVinci Resolve MCP Server — Universal Installer
 
 Supports: macOS, Windows, Linux
 Configures: Claude Desktop, Claude Code, Cursor, VS Code (Copilot),
-            Windsurf, Cline, Roo Code, Zed, Continue, and manual setup.
+            Windsurf, Cline, Roo Code, Zed, Continue, OpenCode, and manual setup.
 
 Usage:
     python install.py                  # Interactive mode
@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.56.0"
+VERSION = "2.57.0"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds
@@ -392,6 +392,16 @@ MCP_CLIENTS = [
         "config_key": "mcpServers",
         "notes": "Open-source AI code assistant",
     },
+    {
+        "id": "opencode",
+        "name": "OpenCode",
+        # OpenCode uses ~/.config/opencode/opencode.json on every platform
+        # (it also reads a project-root opencode.json, but the global file is
+        # the safe default for an installer). See https://opencode.ai/docs/config/
+        "get_path": lambda: home() / ".config" / "opencode" / "opencode.json",
+        "config_key": "mcp",
+        "notes": "AI coding agent (uses its own type/enabled/command-array format)",
+    },
 ]
 
 CLIENT_IDS = [c["id"] for c in MCP_CLIENTS]
@@ -456,6 +466,33 @@ def build_zed_entry(python_path, server_path, api_path, lib_path, system=SYSTEM,
         "settings": {},
     }
 
+
+def build_opencode_entry(python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
+    """Build OpenCode-specific server entry (issue #72).
+
+    OpenCode's schema differs from the standard format in three ways: it wraps
+    the entry in a ``"mcp"`` key, the interpreter and script are a single
+    ``"command"`` array (no separate ``args``), and the environment block is
+    ``"environment"`` rather than ``"env"``. It also expects ``type``/``enabled``
+    discriminators. See https://opencode.ai/docs/mcp-servers/
+    """
+    return {
+        "type": "local",
+        "enabled": True,
+        "command": [str(python_path), str(server_path)],
+        "environment": build_server_env(python_path, api_path, lib_path, system=system, python_home=python_home),
+    }
+
+
+def build_entry_for_client(client, python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
+    """Return the server entry shaped for a specific client's config schema."""
+    builders = {
+        "zed": build_zed_entry,
+        "opencode": build_opencode_entry,
+    }
+    builder = builders.get(client["id"], build_server_entry)
+    return builder(python_path, server_path, api_path, lib_path, system=system, python_home=python_home)
+
 # ─── Config File Operations ──────────────────────────────────────────────────
 
 class ConfigParseError(Exception):
@@ -599,13 +636,9 @@ def write_client_config(client, python_path, server_path, api_path, lib_path, dr
         return False, f"{client['name']} is not available on {platform_name()}"
 
     config_key = client["config_key"]
-    is_zed = client["id"] == "zed"
 
-    # Build the server entry
-    if is_zed:
-        server_entry = build_zed_entry(python_path, server_path, api_path, lib_path)
-    else:
-        server_entry = build_server_entry(python_path, server_path, api_path, lib_path)
+    # Build the server entry (some clients use a non-standard schema)
+    server_entry = build_entry_for_client(client, python_path, server_path, api_path, lib_path)
 
     if dry_run:
         preview = {config_key: {"davinci-resolve": server_entry}}
@@ -637,12 +670,14 @@ def generate_manual_config(python_path, server_path, api_path, lib_path):
     """Generate config snippets for manual setup."""
     entry = build_server_entry(python_path, server_path, api_path, lib_path)
     zed_entry = build_zed_entry(python_path, server_path, api_path, lib_path)
+    opencode_entry = build_opencode_entry(python_path, server_path, api_path, lib_path)
 
     standard = json.dumps({"mcpServers": {"davinci-resolve": entry}}, indent=2)
     vscode_fmt = json.dumps({"servers": {"davinci-resolve": entry}}, indent=2)
     zed_fmt = json.dumps({"context_servers": {"davinci-resolve": zed_entry}}, indent=2)
+    opencode_fmt = json.dumps({"mcp": {"davinci-resolve": opencode_entry}}, indent=2)
 
-    return standard, vscode_fmt, zed_fmt
+    return standard, vscode_fmt, zed_fmt, opencode_fmt
 
 # ─── Virtual Environment ─────────────────────────────────────────────────────
 
@@ -1539,7 +1574,7 @@ def main():
 
     # Show manual config
     if show_manual:
-        standard, vscode_fmt, zed_fmt = generate_manual_config(
+        standard, vscode_fmt, zed_fmt, opencode_fmt = generate_manual_config(
             python_path, server_path, api_path, lib_path
         )
         env_preview = build_server_env(python_path, api_path, lib_path)
@@ -1557,6 +1592,10 @@ def main():
         print()
         for line in zed_fmt.split("\n"):
             print(f"    {line}")
+        print(f"\n  {cyan('OpenCode format')} (add to ~/.config/opencode/opencode.json or a project opencode.json):")
+        print()
+        for line in opencode_fmt.split("\n"):
+            print(f"    {line}")
         print(f"\n  {cyan('JetBrains IDEs')} (IntelliJ, WebStorm, PyCharm, etc.):")
         print(f"    Settings → Tools → AI Assistant → Model Context Protocol (MCP)")
         print(f"    Add server with command: {python_path} {server_path}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.56.0",
+  "version": "2.57.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.56.0"
+VERSION = "2.57.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.55.2"
+VERSION = "2.57.0"
 
 import base64
 import os
@@ -1891,7 +1891,10 @@ def _find_timeline_item_by_id(tl, timeline_item_id) -> Optional[Any]:
     for track_type in ("video", "audio", "subtitle"):
         try:
             track_count = int(tl.GetTrackCount(track_type) or 0)
-        except Exception:
+        except Exception as exc:
+            # Don't silently skip a whole track type on API error — log it so a
+            # genuine API failure isn't mistaken for "item not found" (EX10).
+            logger.warning("_find_timeline_item_by_id: GetTrackCount(%s) failed, skipping: %s", track_type, exc)
             continue
         for track_index in range(1, track_count + 1):
             for item in (tl.GetItemListInTrack(track_type, track_index) or []):
@@ -5691,8 +5694,11 @@ def _audio_capabilities():
 def _audio_track_probe(tl, p: Dict[str, Any]):
     track_index = int(p.get("track_index", 1))
     track_count = int(tl.GetTrackCount("audio") or 0)
-    out = {"track_index": track_index, "track_count": track_count, "available": track_index <= track_count}
-    if track_index > track_count:
+    # Resolve audio tracks are 1-indexed; track_index < 1 is invalid (EX11 — the
+    # old `track_index <= track_count` reported available:true for index 0).
+    out = {"track_index": track_index, "track_count": track_count,
+           "available": 1 <= track_index <= track_count}
+    if not (1 <= track_index <= track_count):
         return out
     for key, getter, args in (
         ("sub_type", "GetTrackSubType", ("audio", track_index)),
@@ -15158,7 +15164,13 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
         blocked = _consume_confirm_token(action="media_pool.delete_timelines", params=p)
         if blocked:
             return blocked
-        return {"success": bool(mp.DeleteTimelines(timelines))}
+        # Read-back: DeleteTimelines' bool is unreliable; verify by the project's
+        # timeline count dropping (P2).
+        before_n = proj.GetTimelineCount()
+        raw = bool(mp.DeleteTimelines(timelines))
+        after_n = proj.GetTimelineCount()
+        return {"success": raw, "verified": after_n < before_n,
+                "timelines_before": before_n, "timelines_after": after_n}
     elif action == "append_to_timeline":
         if p.get("clip_infos") is not None:
             raw = p["clip_infos"]
@@ -15321,6 +15333,8 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
             return _err("Clip not found")
         return {"success": bool(mp.DeleteClipMattes(clip, p["paths"]))}
     elif action == "import_folder":
+        if not p.get("path"):
+            return _err("import_folder requires path")
         return {"success": bool(mp.ImportFolderFromFile(p["path"], p.get("source_clips_path", "")))}
     elif action == "ingest_capabilities":
         return _media_pool_ingest_capabilities()
@@ -20377,7 +20391,12 @@ def timeline_item_color(action: str, params: Optional[Dict[str, Any]] = None) ->
     elif action == "grade_boundary_report":
         return _grade_boundary_report(proj, item, p)
     elif action == "set_cdl":
-        return {"success": bool(item.SetCDL(_normalize_cdl(p["cdl"])))}
+        # Validate ASC-CDL shape before SetCDL (malformed CDL is silently rejected
+        # by Resolve); the raw action shares the safe twin's validator now (P3 #22).
+        validation, err = _validate_cdl_payload(p.get("cdl"))
+        if err:
+            return err
+        return {"success": bool(item.SetCDL(_normalize_cdl(validation["cdl"])))}
     elif action == "copy_grades":
         # Find target items by IDs
         _, tl, _ = _get_tl()
@@ -21524,6 +21543,234 @@ def _fusion_tool_names(comp):
     return [name for name, _ in _iter_fusion_tools(comp)]
 
 
+# Friendly mask aliases -> Fusion tool RegID, for add_fusion_mask (issue #73).
+_MASK_TOOL_ALIASES = {
+    "rectangle": "RectangleMask",
+    "rect": "RectangleMask",
+    "rectanglemask": "RectangleMask",
+    "ellipse": "EllipseMask",
+    "ellipsemask": "EllipseMask",
+    "circle": "EllipseMask",
+}
+
+# Friendly param name -> Fusion input id, for add_fusion_mask. Center is handled
+# separately because it is a Point input (see _fusion_set_point_input).
+_MASK_INPUT_ALIASES = {
+    "corner_radius": "CornerRadius",   # RectangleMask only
+    "width": "Width",
+    "height": "Height",
+    "angle": "Angle",
+    "soft_edge": "SoftEdge",
+    "border_width": "BorderWidth",
+    "invert": "Invert",
+}
+
+
+def _fusion_set_point_input(tool, input_id, value):
+    """Set a Fusion Point input (e.g. a mask Center).
+
+    Point inputs do not accept a plain scalar; the fusionscript bridge variously
+    accepts a 2-element list or a 1-indexed table depending on platform/version.
+    Try the known encodings and report which one took (or the last error).
+    """
+    if isinstance(value, dict):
+        candidates = [value]
+    else:
+        try:
+            x, y = value[0], value[1]
+        except (TypeError, KeyError, IndexError):
+            return False, f"{input_id} must be [x, y] or {{1:x, 2:y}} (got {value!r})", None
+        candidates = [[x, y], {1: x, 2: y}, {"1": x, "2": y}]
+    last_err = None
+    for cand in candidates:
+        try:
+            tool.SetInput(input_id, cand)
+            return True, None, cand
+        except Exception as exc:  # noqa: BLE401 - bridge raises bare exceptions
+            last_err = str(exc)
+    return False, last_err, None
+
+
+def _fusion_add_mask(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Add and configure a Rectangle/Ellipse mask in one call (issue #73).
+
+    Equivalent to add_tool + a sequence of set_input calls, plus optional wiring
+    of the mask into a downstream tool's mask input. Each input is applied
+    independently so a single unsupported parameter does not abort the rest.
+    """
+    raw_type = str(p.get("mask_type", "Rectangle")).strip().lower()
+    tool_type = _MASK_TOOL_ALIASES.get(raw_type)
+    if not tool_type:
+        return _err(
+            "mask_type must be one of: Rectangle, Ellipse "
+            f"(got {p.get('mask_type')!r})"
+        )
+
+    x = p.get("x", -1)
+    y = p.get("y", -1)
+    readback = bool(p.get("readback", True))
+
+    comp.Lock()
+    try:
+        tool = comp.AddTool(tool_type, x, y)
+        if not tool:
+            return _err(
+                f"Failed to add {tool_type}. Verify the comp is editable "
+                "(switch to the Fusion page or target a clip with a Fusion comp)."
+            )
+        name = p.get("name")
+        if name:
+            tool.SetAttrs({"TOOLS_Name": str(name)})
+        attrs = tool.GetAttrs() or {}
+        tool_name = attrs.get("TOOLS_Name", "")
+
+        results: List[Dict[str, Any]] = []
+
+        # Center: accept center=[x,y]/{1:x,2:y}, or center_x / center_y.
+        center = p.get("center")
+        cx, cy = p.get("center_x"), p.get("center_y")
+        if center is None and (cx is not None or cy is not None):
+            center = [cx if cx is not None else 0.5, cy if cy is not None else 0.5]
+        if center is not None:
+            ok, err, applied = _fusion_set_point_input(tool, "Center", center)
+            rec = {"input": "Center", "value": center, "success": ok}
+            if not ok:
+                rec["error"] = err
+            elif readback:
+                try:
+                    rec["readback"] = _ser(tool.GetInput("Center"))
+                except Exception as exc:
+                    rec["readback_error"] = str(exc)
+            results.append(rec)
+
+        # Scalar inputs (friendly aliases) + any raw passthrough inputs.
+        to_set: List[tuple] = []
+        for friendly, fusion_id in _MASK_INPUT_ALIASES.items():
+            if friendly in p:
+                to_set.append((fusion_id, p[friendly]))
+        raw_inputs = p.get("inputs")
+        if isinstance(raw_inputs, dict):
+            for k, v in raw_inputs.items():
+                to_set.append((str(k), v))
+
+        for fusion_id, value in to_set:
+            rec = {"input": fusion_id, "value": value}
+            try:
+                tool.SetInput(fusion_id, value)
+                rec["success"] = True
+                if readback:
+                    try:
+                        rec["readback"] = _ser(tool.GetInput(fusion_id))
+                    except Exception as exc:
+                        rec["readback_error"] = str(exc)
+            except Exception as exc:
+                rec["success"] = False
+                rec["error"] = str(exc)
+            results.append(rec)
+
+        out: Dict[str, Any] = {
+            "success": True,
+            "tool_name": tool_name,
+            "tool_type": attrs.get("TOOLS_RegID", tool_type),
+            "inputs_set": results,
+        }
+
+        # Optional wiring: connect this mask into a tool's mask input.
+        connect_to = p.get("connect_to")
+        if connect_to:
+            input_name = p.get("connect_input", "EffectMask")
+            target = comp.FindTool(str(connect_to))
+            if not target:
+                out["connection"] = {
+                    "success": False,
+                    "error": f"connect_to tool '{connect_to}' not found",
+                }
+            else:
+                try:
+                    ok = bool(target.ConnectInput(input_name, tool))
+                    out["connection"] = {
+                        "success": ok,
+                        "target": str(connect_to),
+                        "input_name": input_name,
+                    }
+                except Exception as exc:
+                    out["connection"] = {"success": False, "error": str(exc)}
+        return out
+    finally:
+        comp.Unlock()
+
+
+def _fusion_find_text_tool(comp, p: Dict[str, Any]):
+    """Find a Text+ (TextPlus) tool in the comp, or the named tool. (issue #73)"""
+    name = p.get("tool_name")
+    if name:
+        tool = comp.FindTool(str(name))
+        if not tool:
+            return None, _err(f"Tool '{name}' not found")
+        return tool, None
+    # Auto-detect the first Text+ tool — this is what a Fusion title template
+    # (e.g. "Deep") exposes its editable copy through.
+    for name_, tool in _iter_fusion_tools(comp):
+        try:
+            reg = (tool.GetAttrs() or {}).get("TOOLS_RegID", "")
+        except Exception:
+            reg = ""
+        if reg in ("TextPlus", "Text+") or "Text" in reg:
+            return tool, None
+    return None, _err(
+        "No Text+ tool found in this comp. Pass tool_name explicitly, or call "
+        "get_tool_list to inspect the node graph."
+    )
+
+
+def _fusion_set_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Set the text of a Fusion Text+ tool / title template. (issue #73)"""
+    text = p.get("text")
+    if not isinstance(text, str):
+        return _err("set_text_plus requires params.text (string)")
+    tool, err = _fusion_find_text_tool(comp, p)
+    if err:
+        return err
+    input_id = p.get("input_name", "StyledText")
+    readback = bool(p.get("readback", True))
+    comp.Lock()
+    try:
+        try:
+            tool.SetInput(input_id, text)
+        except Exception as exc:
+            return _err(f"SetInput({input_id!r}) failed: {exc}")
+        out = {
+            "success": True,
+            "tool_name": (tool.GetAttrs() or {}).get("TOOLS_Name", ""),
+            "input_name": input_id,
+        }
+        if readback:
+            try:
+                out["readback"] = _ser(tool.GetInput(input_id))
+            except Exception as exc:
+                out["readback_error"] = str(exc)
+        return out
+    finally:
+        comp.Unlock()
+
+
+def _fusion_get_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Read the text of a Fusion Text+ tool / title template. (issue #73)"""
+    tool, err = _fusion_find_text_tool(comp, p)
+    if err:
+        return err
+    input_id = p.get("input_name", "StyledText")
+    try:
+        val = tool.GetInput(input_id)
+    except Exception as exc:
+        return _err(f"GetInput({input_id!r}) failed: {exc}")
+    return {
+        "tool_name": (tool.GetAttrs() or {}).get("TOOLS_Name", ""),
+        "input_name": input_id,
+        "text": _ser(val),
+    }
+
+
 @mcp.tool()
 def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """Fusion composition node graph operations.
@@ -21579,6 +21826,17 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       safe_set_inputs(tool_name, inputs, readback?) -> {success, results}
       safe_connect_tools(target_tool, input_name, source_tool, dry_run?) -> {success}
       fusion_boundary_report(include_io?) -> {capabilities, composition}
+      add_fusion_mask(mask_type?, name?, center?|center_x?|center_y?, width?, height?,
+        corner_radius?, angle?, soft_edge?, border_width?, invert?, inputs?, x?, y?,
+        connect_to?, connect_input?, readback?) -> {success, tool_name, inputs_set, connection?}
+        mask_type: "Rectangle" (default) or "Ellipse". One call = add the mask tool,
+        set its params (corner_radius/width/height/center are 0..1), and optionally
+        wire it into connect_to's mask input (connect_input default "EffectMask").
+      set_text_plus(text, tool_name?, input_name?, readback?) -> {success, tool_name, readback?}
+        Set the text of a Fusion Text+ tool / title template (e.g. a "Deep" Fusion
+        title). Auto-finds the Text+ tool if tool_name is omitted; input_name
+        defaults to "StyledText".
+      get_text_plus(tool_name?, input_name?) -> {tool_name, input_name, text}
 
     Common tool_type values: Merge, Background, TextPlus, Transform, Blur,
       ColorCorrector, RectangleMask, EllipseMask, Tracker, MediaIn, MediaOut,
@@ -21618,6 +21876,12 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         return _safe_connect_fusion_tools(comp, p)
     elif action == "fusion_boundary_report":
         return _fusion_boundary_report(comp, p)
+    elif action == "add_fusion_mask":
+        return _fusion_add_mask(comp, p)
+    elif action == "set_text_plus":
+        return _fusion_set_text_plus(comp, p)
+    elif action == "get_text_plus":
+        return _fusion_get_text_plus(comp, p)
 
     # --- Node Management ---
     if action == "add_tool":
@@ -22001,6 +22265,7 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         "get_position","set_position","copy_tool","auto_arrange",
         "bulk_set_inputs",
         "bulk_set_expressions",
+        "add_fusion_mask","set_text_plus","get_text_plus",
         *_FUSION_GROUP_KERNEL_ACTIONS,
         *_FUSION_KERNEL_ACTIONS,
     ])