davinci-resolve-mcp 2.87.2 → 2.89.0

package/src/granular/project.py

@@ -192,7 +192,7 @@ def save_project() -> str:
     try:
         # Method 1: Try direct save method if available
         try:
-            if hasattr(current_project, "SaveProject"):
+            if _has_method(current_project, "SaveProject"):
                 result = current_project.SaveProject()
                 if result:
                     logger.info(f"Project '{project_name}' saved using SaveProject method")
@@ -204,7 +204,7 @@ def save_project() -> str:
         # Method 2: Try project manager save method
         if not success:
             try:
-                if hasattr(project_manager, "SaveProject"):
+                if _has_method(project_manager, "SaveProject"):
                     result = project_manager.SaveProject()
                     if result:
                         logger.info(f"Project '{project_name}' saved using ProjectManager.SaveProject method")
@@ -1640,8 +1640,9 @@ def generate_speech(text_input: str, voice_model: str = "", timecode: str = "",
     pm, current_project = get_current_project()
     if not current_project:
         return {"error": "No project currently open"}
-    if not hasattr(current_project, "GenerateSpeech"):
-        return {"error": "GenerateSpeech requires DaVinci Resolve 21+ and the AI Speech Generator Extra"}
+    missing = _requires_method(current_project, "GenerateSpeech", "21.0")
+    if missing:
+        return missing
     if not text_input:
         return {"error": "text_input is required"}
     settings: Dict[str, Any] = {"TextInput": text_input}
@@ -1664,6 +1665,28 @@ def generate_speech(text_input: str, voice_model: str = "", timecode: str = "",
         if audio_track is not None:
             settings["AudioTrack"] = audio_track
     new_item = current_project.GenerateSpeech(settings, timecode or "")
-    if not new_item:
-        return {"success": False, "error": "GenerateSpeech returned no media item"}
+    # Without the AI Speech Generator Extra this returns the reason as a STRING,
+    # which is truthy — the old check passed it through to .GetName().
+    ok, message = _ai_result(new_item)
+    if not ok:
+        return {"success": False,
+                "error": message or "GenerateSpeech returned no media item"}
     return {"success": True, "new": new_item.GetName(), "new_id": new_item.GetUniqueId()}
+
+
+@mcp.tool()
+def get_project_attributes_in_current_folder() -> Dict[str, Any]:
+    """Get per-project attributes for every project in the current folder (Resolve 21.0.4+).
+
+    Calls ProjectManager.GetProjectAttributesInCurrentFolder(). Returns a dict
+    keyed by project name with 'lastModifiedDate', 'creationDate', 'notes' and
+    'liveCollaborationMode' — without loading any project.
+    """
+    project_manager = get_project_manager()
+    if not project_manager:
+        return {"error": "Failed to get Project Manager"}
+    missing = _requires_method(project_manager, "GetProjectAttributesInCurrentFolder", "21.0.4")
+    if missing:
+        return missing
+    attributes = project_manager.GetProjectAttributesInCurrentFolder()
+    return {"projects": attributes if attributes else {}}

package/src/granular/resolve_control.py

@@ -186,10 +186,12 @@ def inspect_custom_object(object_path: str) -> Dict[str, Any]:
                     return {"error": f"Method '{method_name}' not found or not callable"}
             else:
                 # It's an attribute access
-                if hasattr(obj, part):
-                    obj = getattr(obj, part)
-                else:
+                # getattr, not hasattr: on a Resolve object hasattr is a
+                # constant True, so the not-found branch could never run.
+                value = getattr(obj, part, None)
+                if value is None:
                     return {"error": f"Attribute '{part}' not found"}
+                obj = value
         
         # Inspect the object we've retrieved
         return inspect_object(obj)
@@ -399,7 +401,19 @@ def get_resolve_version_fields() -> Dict[str, Any]:
         return {"error": "Not connected to DaVinci Resolve"}
     version = resolve.GetVersion()
     if version:
-        return {"major": version[0], "minor": version[1], "patch": version[2], "build": version[3], "suffix": version[4] if len(version) > 4 else ""}
+        # Carry what this build is MISSING, not just what it is. An agent that
+        # only learns the number still has to know which surfaces that number
+        # rules out, and guessing that is issue #132.
+        missing = gates_unavailable_on(resolve.GetVersionString())
+        return {"major": version[0], "minor": version[1], "patch": version[2], "build": version[3],
+                "suffix": version[4] if len(version) > 4 else "",
+                "unavailable_on_this_build": missing,
+                "note": ("Recorded surfaces absent here — do not offer them. An absence "
+                         "from this list is not a promise a method exists; most of the "
+                         "API has never been version-bisected."
+                         if missing else
+                         "Clears every recorded version gate. Surfaces nobody has "
+                         "bisected are still unknown — probe before offering them.")}
     return {"error": "Failed to get version"}
 
 
@@ -536,3 +550,172 @@ def quit_resolve() -> Dict[str, Any]:
         return {"error": "Not connected to DaVinci Resolve"}
     resolve.Quit()
     return {"success": True, "message": "DaVinci Resolve is quitting"}
+
+
+@mcp.tool()
+def get_layout_preset_list() -> Dict[str, Any]:
+    """Get the names of all saved UI layout presets (Resolve 21.0.4+).
+
+    Calls Resolve.GetLayoutPresetList(). These are the names accepted by
+    load_layout_preset_tool, update_layout_preset, export_layout_preset_tool
+    and delete_layout_preset_tool.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "GetLayoutPresetList", "21.0.4")
+    if missing:
+        return missing
+    presets = resolve.GetLayoutPresetList()
+    return {"presets": presets if presets else []}
+
+
+@mcp.tool()
+def get_burn_in_preset_list() -> Dict[str, Any]:
+    """Get the names of all saved data burn-in presets (Resolve 21.0.4+).
+
+    Calls Resolve.GetBurnInPresetList(). These are the names accepted by the
+    'DataBurnIn' render setting, project load_burn_in_preset, and
+    export_burn_in_preset.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "GetBurnInPresetList", "21.0.4")
+    if missing:
+        return missing
+    presets = resolve.GetBurnInPresetList()
+    return {"presets": presets if presets else []}
+
+
+@mcp.tool()
+def delete_burn_in_preset(preset_name: str) -> Dict[str, Any]:
+    """Delete a data burn-in preset by name (Resolve 21.0.4+).
+
+    Args:
+        preset_name: Name of the burn-in preset to delete.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "DeleteBurnInPreset", "21.0.4")
+    if missing:
+        return missing
+    result = resolve.DeleteBurnInPreset(preset_name)
+    return {"success": bool(result), "preset_name": preset_name}
+
+
+@mcp.tool()
+def get_user_preferences_preset_list() -> Dict[str, Any]:
+    """Get the names of all saved user-preferences presets (Resolve 21.0.4+).
+
+    Calls Resolve.GetUserPreferencesPresetList().
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "GetUserPreferencesPresetList", "21.0.4")
+    if missing:
+        return missing
+    presets = resolve.GetUserPreferencesPresetList()
+    return {"presets": presets if presets else []}
+
+
+@mcp.tool()
+def save_user_preferences_preset(preset_name: str) -> Dict[str, Any]:
+    """Save the current user preferences as a named preset (Resolve 21.0.4+).
+
+    Args:
+        preset_name: Name for the new user-preferences preset.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "SaveUserPreferencesPreset", "21.0.4")
+    if missing:
+        return missing
+    result = resolve.SaveUserPreferencesPreset(preset_name)
+    return {"success": bool(result), "preset_name": preset_name}
+
+
+@mcp.tool()
+def load_user_preferences_preset(preset_name: str) -> Dict[str, Any]:
+    """Load a user-preferences preset (Resolve 21.0.4+).
+
+    SESSION-WIDE: this swaps the user's global Resolve preferences, not a
+    project setting. It affects every project open in this Resolve instance.
+    Only call when the user explicitly asked for the switch.
+
+    Args:
+        preset_name: Name of the user-preferences preset to load.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "LoadUserPreferencesPreset", "21.0.4")
+    if missing:
+        return missing
+    result = resolve.LoadUserPreferencesPreset(preset_name)
+    return {"success": bool(result), "preset_name": preset_name}
+
+
+@mcp.tool()
+def delete_user_preferences_preset(preset_name: str) -> Dict[str, Any]:
+    """Delete a user-preferences preset by name (Resolve 21.0.4+).
+
+    Args:
+        preset_name: Name of the user-preferences preset to delete.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "DeleteUserPreferencesPreset", "21.0.4")
+    if missing:
+        return missing
+    result = resolve.DeleteUserPreferencesPreset(preset_name)
+    return {"success": bool(result), "preset_name": preset_name}
+
+
+@mcp.tool()
+def import_user_preferences_preset(import_path: str, preset_name: str = None) -> Dict[str, Any]:
+    """Import a user-preferences preset from a file (Resolve 21.0.4+).
+
+    The imported preset is NOT auto-loaded; it takes its name from the file
+    when preset_name is omitted (measured on Studio 21.0.4.5). Follow with
+    load_user_preferences_preset to activate it.
+
+    Args:
+        import_path: Absolute path to the preset file to import.
+        preset_name: Name to save the imported preset as (filename if None).
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "ImportUserPreferencesPreset", "21.0.4")
+    if missing:
+        return missing
+    if preset_name:
+        result = resolve.ImportUserPreferencesPreset(import_path, preset_name)
+    else:
+        result = resolve.ImportUserPreferencesPreset(import_path)
+        preset_name = os.path.splitext(os.path.basename(import_path))[0]
+    return {"success": bool(result), "preset_name": preset_name, "import_path": import_path,
+            "note": "The imported preset is not auto-loaded; use load_user_preferences_preset to activate it."}
+
+
+@mcp.tool()
+def export_user_preferences_preset(preset_name: str, export_path: str) -> Dict[str, Any]:
+    """Export a user-preferences preset to a file (Resolve 21.0.4+).
+
+    Args:
+        preset_name: Name of the user-preferences preset to export.
+        export_path: Absolute path where the preset file will be saved.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "ExportUserPreferencesPreset", "21.0.4")
+    if missing:
+        return missing
+    result = resolve.ExportUserPreferencesPreset(preset_name, export_path)
+    return {"success": bool(result), "preset_name": preset_name, "export_path": export_path}

package/src/granular/timeline.py

@@ -655,8 +655,8 @@ def timeline_create_compound_clip(
         return {"success": False, "error": "Failed to create compound clip"}
     return {
         "success": True,
-        "name": result.GetName() if hasattr(result, "GetName") else None,
-        "unique_id": result.GetUniqueId() if hasattr(result, "GetUniqueId") else None,
+        "name": result.GetName() if _has_method(result, "GetName") else None,
+        "unique_id": result.GetUniqueId() if _has_method(result, "GetUniqueId") else None,
     }
 
 
@@ -714,8 +714,11 @@ def timeline_export(file_path: str, export_type: str, export_subtype: str = "EXP
         return err
     # Map string constants to resolve constants
     try:
-        etype = getattr(resolve, export_type) if hasattr(resolve, export_type) else export_type
-        esub = getattr(resolve, export_subtype) if hasattr(resolve, export_subtype) else export_subtype
+        # Fall back on the VALUE, not on hasattr: hasattr is a constant True
+        # here, so a build without the constant used to hand Export a None
+        # instead of the string name the fallback was written to pass through.
+        etype = _api_constant(resolve, export_type, export_type)
+        esub = _api_constant(resolve, export_subtype, export_subtype)
     except Exception:
         logger.debug("Could not resolve timeline export constants", exc_info=True)
         etype = export_type
@@ -1087,3 +1090,33 @@ def set_timeline_setting(setting_name: str, setting_value: str) -> Dict[str, Any
         return err
     result = tl.SetSetting(setting_name, setting_value)
     return {"success": bool(result), "setting_name": setting_name, "setting_value": setting_value}
+
+
+@mcp.tool()
+def get_selected_timeline_items() -> Dict[str, Any]:
+    """Get the timeline items currently selected in the timeline (Resolve 21.0.4+).
+
+    Calls Timeline.GetSelectedClips() on the current timeline. An empty list
+    means nothing is selected — that is an answer, not a failure. (Distinct
+    from get_selected_clips, which reads the Media Pool selection.)
+    """
+    _, tl, err = _get_timeline()
+    if err:
+        return err
+    missing = _requires_method(tl, "GetSelectedClips", "21.0.4")
+    if missing:
+        return missing
+    items = tl.GetSelectedClips() or []
+    summaries = []
+    for item in items:
+        entry = {}
+        for getter, key in (("GetName", "name"), ("GetUniqueId", "unique_id"),
+                            ("GetStart", "start"), ("GetEnd", "end")):
+            method = getattr(item, getter, None)
+            if callable(method):
+                try:
+                    entry[key] = method()
+                except Exception:
+                    pass
+        summaries.append(entry)
+    return {"count": len(summaries), "items": summaries}

package/src/granular/timeline_item.py

@@ -2118,7 +2118,7 @@ def ti_export_lut(export_type: str, path: str, item_index: int = 0, track_type:
     if err:
         return err
     try:
-        etype = getattr(resolve, export_type) if hasattr(resolve, export_type) else export_type
+        etype = _api_constant(resolve, export_type, export_type)
     except Exception:
         etype = export_type
     return {"success": bool(item.ExportLUT(etype, path))}

package/src/resolve_mcp_server.py

@@ -34,7 +34,7 @@ from src.utils.update_check import start_background_update_check
 if __name__ == "__main__":
     try:
         start_background_update_check(VERSION, project_dir, logger)
-        logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION} (341 granular tools)")
+        logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION} (353 granular tools)")
         run_fastmcp_stdio(mcp)
     except KeyboardInterrupt:
         logger.info("Server shutdown requested")

package/src/server.py

@@ -8,10 +8,10 @@ Each tool groups related operations via an 'action' parameter.
 
 Usage:
     python src/server.py              # Start the MCP server
-    python src/server.py --full       # Start the 341-tool granular server instead
+    python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.87.2"
+VERSION = "2.89.0"
 
 import base64
 import os
@@ -48,6 +48,7 @@ from src.utils.mcp_stdio import run_fastmcp_stdio
 from src.utils.api_truth import lookup_api_truth, VERIFIED_ON as _API_TRUTH_VERIFIED_ON
 from src.utils import clip_colors as _clip_colors
 from src.utils import resolve_versions as _resolve_versions
+from src.utils.resolve_probe import api_constant as _api_constant, has_method as _probe_has_method
 from src.utils.contracts import validate as _validate_params
 from src.utils.cut_ir import build_cut_list as _build_cut_list
 from src.utils.page_lock import (
@@ -1032,7 +1033,7 @@ def _destructive_versioning_provider() -> Optional[Tuple[Any, Any, str, Optional
         except Exception:
             project_name = None
         try:
-            project_id = proj.GetUniqueId() if hasattr(proj, "GetUniqueId") else None
+            project_id = proj.GetUniqueId() if _has_method(proj, "GetUniqueId") else None
         except Exception:
             project_id = None
         root = resolve_media_analysis_output_root(
@@ -1785,7 +1786,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
         return {"sent": False, "error": f"{type(exc).__name__}: {exc}"}
 
 def _has_method(obj, method_name):
-    return callable(getattr(obj, method_name, None))
+    # `hasattr` is a constant True on Resolve objects — see src/utils/resolve_probe.
+    return _probe_has_method(obj, method_name)
 
 def _requires_method(obj, method_name, min_version):
     if _has_method(obj, method_name):
@@ -5901,10 +5903,11 @@ def _timeline_export_value(value, resolve_obj=None):
     if not raw:
         return "", None
     const_name = raw if raw.startswith("EXPORT_") else None
-    if const_name and resolve_obj is not None and hasattr(resolve_obj, const_name):
-        return getattr(resolve_obj, const_name), const_name
     if const_name:
-        return const_name, const_name
+        # hasattr is a constant True on a Resolve object, so the old presence
+        # test always won and handed Export a None from getattr on a build
+        # without the constant. Fall back on the value instead.
+        return _api_constant(resolve_obj, const_name, const_name), const_name
     return raw, None
 
 
@@ -7383,9 +7386,7 @@ def _safe_auto_sync_audio(mp, p: Dict[str, Any]):
 
 
 def _resolve_audio_constant(resolve_obj, name: str, fallback):
-    if resolve_obj is not None and hasattr(resolve_obj, name):
-        return getattr(resolve_obj, name)
-    return fallback
+    return _api_constant(resolve_obj, name, fallback)
 
 
 def _normalize_auto_sync_settings(settings: Dict[str, Any], resolve_obj=None):
@@ -13787,10 +13788,33 @@ def resolve_control(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
     if action == "get_version":
         update_env = _setup_update_env()
         mcp_update = get_cached_update_status(project_dir, VERSION, env=update_env)
+        version_string = r.GetVersionString()
+        # The first call of nearly every session. Issue #132 is the report of an
+        # agent describing a surface that was not on the user's build, and the
+        # reason it could happen is that nothing in the session ever said which
+        # build that was in terms of what is missing from it. So the answer to
+        # "what am I connected to" now carries what this build does not have,
+        # rather than waiting to be asked.
+        missing = _resolve_versions.gates_unavailable_on(version_string)
         return {
             "product": r.GetProductName(),
             "version": r.GetVersion(),
-            "version_string": r.GetVersionString(),
+            "version_string": version_string,
+            "build": {
+                "unavailable_on_this_build": missing,
+                "known_gates": len(_resolve_versions.VERSION_GATES),
+                "note": (
+                    f"{len(missing)} recorded surface(s) are absent on this build. "
+                    "Do not offer them. An absence from this list is NOT a promise "
+                    "the method exists — most of the scripting API has never been "
+                    "version-bisected, so ask check_version_support for a specific "
+                    "symbol and probe when it answers `unknown`."
+                    if missing else
+                    "This build clears every recorded version gate. That is not a "
+                    "promise about surfaces nobody has bisected — ask "
+                    "check_version_support for a specific symbol before offering it."
+                ),
+            },
             "mcp": {
                 "version": VERSION,
                 "update": mcp_update,
@@ -22792,9 +22816,7 @@ def _resolve_lut_export_type(export_type, resolve_obj=None):
         const_name = raw
     if not const_name:
         return None, _err(f"Unknown LUT export type: {raw}")
-    if resolve_obj and hasattr(resolve_obj, const_name):
-        return getattr(resolve_obj, const_name), None
-    return const_name, None
+    return _api_constant(resolve_obj, const_name, const_name), None
 
 
 def _validate_cdl_payload(cdl):
@@ -27636,7 +27658,7 @@ def _resource_current_project() -> Dict[str, Any]:
     return {
         "open": True,
         "name": proj.GetName(),
-        "id": proj.GetUniqueId() if hasattr(proj, "GetUniqueId") else None,
+        "id": proj.GetUniqueId() if _has_method(proj, "GetUniqueId") else None,
     }
 
 
@@ -27659,7 +27681,7 @@ def _resource_current_timeline() -> Dict[str, Any]:
     return {
         "open": True,
         "name": tl.GetName(),
-        "id": tl.GetUniqueId() if hasattr(tl, "GetUniqueId") else None,
+        "id": tl.GetUniqueId() if _has_method(tl, "GetUniqueId") else None,
         "start_frame": tl.GetStartFrame(),
         "end_frame": tl.GetEndFrame(),
         "start_timecode": tl.GetStartTimecode(),
@@ -27796,9 +27818,9 @@ if __name__ == "__main__":
     start_background_update_check(VERSION, project_dir, logger, env=_setup_update_env())
     _install_threaded_tool_dispatch(mcp)
 
-    # Support --full flag to run the 341-tool granular server instead
+    # Support --full flag to run the 353-tool granular server instead
     if "--full" in sys.argv:
-        logger.info("Starting full 341-tool granular server...")
+        logger.info("Starting full 353-tool granular server...")
         sys.argv = [arg for arg in sys.argv if arg != "--full"]
         from src.granular import mcp as granular_mcp
 

package/src/utils/cloud_operations.py

@@ -9,6 +9,8 @@ the Resolve scripting API.
 import logging
 from typing import Any, Dict, Optional
 
+from src.utils.resolve_probe import has_method
+
 logger = logging.getLogger("davinci-resolve-mcp.cloud_operations")
 
 
@@ -63,7 +65,7 @@ def _project_manager(resolve_obj, method_name: str):
     pm = resolve_obj.GetProjectManager()
     if not pm:
         return None, {"success": False, "error": "Failed to get Project Manager"}
-    if not hasattr(pm, method_name):
+    if not has_method(pm, method_name):
         return None, {
             "success": False,
             "error": f"{method_name} not available in this version of DaVinci Resolve",
@@ -98,7 +100,7 @@ def create_cloud_project(
     return {
         "success": True,
         "project_name": project.GetName(),
-        "project_id": project.GetUniqueId() if hasattr(project, "GetUniqueId") else None,
+        "project_id": project.GetUniqueId() if has_method(project, "GetUniqueId") else None,
     }
 
 
@@ -132,7 +134,7 @@ def load_cloud_project(
     return {
         "success": True,
         "project_name": project.GetName(),
-        "project_id": project.GetUniqueId() if hasattr(project, "GetUniqueId") else None,
+        "project_id": project.GetUniqueId() if has_method(project, "GetUniqueId") else None,
     }
 
 

package/src/utils/object_inspection.py

@@ -14,6 +14,8 @@ import inspect
 import logging
 from typing import Any, Dict, List, Optional, Union, Callable
 
+from src.utils.resolve_probe import has_method
+
 logger = logging.getLogger(__name__)
 
 
@@ -170,7 +172,7 @@ def get_lua_table_keys(lua_table: Any) -> List[str]:
     keys = []
     
     # Check for DaVinci-specific Lua table iteration methods
-    if hasattr(lua_table, 'GetKeyList'):
+    if has_method(lua_table, 'GetKeyList'):
         try:
             # Some DaVinci Resolve objects have a GetKeyList() method
             return lua_table.GetKeyList()
@@ -210,7 +212,7 @@ def convert_lua_to_python(lua_obj: Any) -> Any:
         return lua_obj
         
     # Try to convert Lua tables to Python dicts or lists
-    if hasattr(lua_obj, 'GetKeyList') or hasattr(lua_obj, '__iter__'):
+    if has_method(lua_obj, 'GetKeyList') or hasattr(lua_obj, '__iter__'):
         keys = get_lua_table_keys(lua_obj)
         
         # If we found keys, convert to dict

package/src/utils/project_properties.py

@@ -13,6 +13,8 @@ import logging
 import json
 from typing import Dict, List, Any, Optional, Union
 
+from src.utils.resolve_probe import has_method
+
 # Configure logging
 logger = logging.getLogger("davinci-resolve-mcp.project_properties")
 
@@ -521,7 +523,7 @@ def get_project_metadata(project_obj) -> Dict[str, Any]:
         metadata["name"] = project_obj.GetName()
         
         # Add project path if available
-        if hasattr(project_obj, "GetPath"):
+        if has_method(project_obj, "GetPath"):
             metadata["path"] = project_obj.GetPath()
         
         # Get current timeline

package/src/utils/resolve_probe.py

@@ -0,0 +1,68 @@
+"""Capability probes for DaVinci Resolve API objects, because `hasattr` lies.
+
+Measured on Studio 19.1.3.7, direct connection, 42 checks across Resolve,
+ProjectManager, Project, MediaPool, Timeline, Folder and TimelineItem: bare
+`hasattr(obj, name)` returns **True for every name** — real, borrowed from
+another object type, or entirely invented — while `getattr(obj, name)` returns
+`None` for the ones that do not exist. The full record is in `api_truth` under
+"hasattr() / getattr() on Resolve API objects (attribute fabrication)".
+
+So `hasattr` on a Resolve object is a constant `True`. It carries no
+information, and it fails in two directions that look nothing alike:
+
+    if not hasattr(clip, "RemoveMotionBlur"):        # never taken
+        return {"error": "requires Resolve 21+"}     # dead branch
+    clip.RemoveMotionBlur(...)                       # AttributeError on 19.x
+
+    etype = getattr(r, name) if hasattr(r, name) else name   # else never taken
+    # -> etype is None on a build without that constant, not the string
+    #    fallback the author wrote, and None flows on into the export call.
+
+The second shape is the dangerous one: no exception, no refusal, just a `None`
+travelling further from the mistake with every line.
+
+Use `has_method` where the intent is "can I call this", and `api_constant`
+where the intent is "does this build define this constant, else use my
+fallback". Both take the form that agreed with `dir()` in all 42 checks.
+
+One caveat worth keeping: those 42 checks were on the DIRECT connection. The
+21.0.0 record of the in-app bridge fabricating callables for any name was never
+re-run, so on a bridge build `callable(getattr(...))` may still over-report.
+`dir()` membership is the form unaffected either way — but it is not free on
+every object, and switching to it wholesale would change behaviour on a path we
+have not measured. That trade is recorded here rather than made silently.
+"""
+
+from typing import Any, Optional
+
+__all__ = ["has_method", "api_constant", "MISSING"]
+
+#: Sentinel for "no attribute", distinct from a legitimately-None attribute.
+MISSING = object()
+
+
+def has_method(obj: Any, name: str) -> bool:
+    """True when `name` is a callable on `obj`. The replacement for `hasattr`.
+
+    Returns False for a missing object rather than raising, because every
+    caller here is asking "is this reachable" and a None handle is one of the
+    ways it is not.
+    """
+    if obj is None or not name:
+        return False
+    return callable(getattr(obj, name, None))
+
+
+def api_constant(obj: Any, name: str, default: Optional[Any] = None) -> Any:
+    """The Resolve constant `name`, or `default` when this build lacks it.
+
+    Resolve exposes export/audio type constants as plain attributes
+    (`resolve.EXPORT_AAF`), and callers pass the string name through unchanged
+    when the constant is absent. `getattr` returning None is exactly the signal
+    `hasattr` destroys, so the fallback is driven off the value, not off a
+    presence test.
+    """
+    if obj is None or not name:
+        return default
+    value = getattr(obj, name, None)
+    return default if value is None else value