davinci-resolve-mcp 2.57.4 → 2.58.0

package/resolve-advanced/vendor/drx-codec/extract-ofx-params.js

@@ -0,0 +1,226 @@
+/**
+ * Decode RESOLVEFX/OFX plugin parameter bags back to {pluginId, params}
+ * specs (P1.6).
+ *
+ * Container structure (per drx-generator.js buildOFXToolEntry +
+ * drx-parameters.RESOLVEFX comments):
+ *
+ *   nodeData.F7.F10 (tool list entry — F1 wraps each tool)
+ *     F1 = standard node marker (varint, fieldNum 1, value 2)
+ *     F2.F21 (OFX container)
+ *       F1 = 0x4F4659 ("OFY" marker varint)
+ *       F2 = pluginId UTF-8 string
+ *       F3 = instanceId UTF-8 string
+ *       F4 = enabled varint (1)
+ *       F5[] = repeated param entries
+ *             F1 = param name UTF-8
+ *             F2 = wrapped value: F2 (float64) OR F5 (UTF-8 string)
+ *
+ * extractOFXTools(toolListBuf | toolListField) returns
+ *   Array<{ pluginId, instanceId, enabled, params: {name: value} }>
+ *
+ * Each `value` is either a number (when F2.F2 was a float64) or a
+ * string (when F2.F5 was UTF-8).
+ *
+ * P2 coverage: tool IDs beyond Film Grain land in the registry as
+ * AutoResearch lands them. The extractor doesn't depend on the tool ID
+ * registry — it surfaces the raw pluginId string from F2 of the OFX
+ * container. Callers can look it up against RESOLVEFX themselves.
+ *
+ * @module drx-codec/extract-ofx-params
+ */
+
+// ─── Mini protobuf reader (CJS-local copy to avoid cross-dep) ────────────
+
+function readVarint(buf, offset) {
+  let result = 0n;
+  let shift = 0n;
+  let cur = offset;
+  while (cur < buf.length) {
+    const byte = buf[cur++];
+    result |= BigInt(byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) return { value: result, next: cur };
+    shift += 7n;
+  }
+  throw new Error('Truncated varint');
+}
+
+function readField(buf, offset) {
+  const tag = readVarint(buf, offset);
+  const tagNum = Number(tag.value);
+  const wireType = tagNum & 0x07;
+  const fieldNum = tagNum >>> 3;
+  let cur = tag.next;
+  if (wireType === 0) {
+    const v = readVarint(buf, cur);
+    return { wireType, fieldNum, value: v.value, next: v.next };
+  }
+  if (wireType === 5) return { wireType, fieldNum, value: buf.readFloatLE(cur), next: cur + 4 };
+  if (wireType === 1) return { wireType, fieldNum, value: buf.readDoubleLE(cur), next: cur + 8 };
+  if (wireType === 2) {
+    const len = readVarint(buf, cur);
+    const start = len.next;
+    const end = start + Number(len.value);
+    return { wireType, fieldNum, value: buf.slice(start, end), next: end };
+  }
+  throw new Error(`Unsupported wire type ${wireType}`);
+}
+
+function readAllFields(buf) {
+  const fields = [];
+  let cur = 0;
+  while (cur < buf.length) {
+    const f = readField(buf, cur);
+    fields.push(f);
+    cur = f.next;
+  }
+  return fields;
+}
+
+function utf8(buf) {
+  return Buffer.isBuffer(buf) ? buf.toString('utf-8') : '';
+}
+
+// ─── OFX decoder ─────────────────────────────────────────────────────────
+
+const OFY_MARKER = 0x4F4659;
+
+/**
+ * Decode an F5 param-entry buffer to {name, value}.
+ * F1 = name (length-delimited UTF-8)
+ * F2 = wrapped value (F2 = float64 OR F5 = UTF-8 string)
+ */
+function decodeParamEntry(entryBuf) {
+  let name = '';
+  let value = null;
+  const fields = readAllFields(entryBuf);
+  for (const f of fields) {
+    if (f.fieldNum === 1 && f.wireType === 2) {
+      name = utf8(f.value);
+    } else if (f.fieldNum === 2 && f.wireType === 2) {
+      // f.value is the wrapped value buffer; walk it for F2 (float64) or F5 (string).
+      const inner = readAllFields(f.value);
+      for (const inn of inner) {
+        if (inn.fieldNum === 2 && inn.wireType === 1) {
+          value = inn.value; // float64
+        } else if (inn.fieldNum === 5 && inn.wireType === 2) {
+          value = utf8(inn.value);
+        }
+      }
+    }
+  }
+  return { name, value };
+}
+
+/**
+ * Decode an OFX container (F2.F21 contents) to one tool record.
+ */
+function decodeOFXContainer(containerBuf) {
+  const fields = readAllFields(containerBuf);
+  let marker = null;
+  let pluginId = '';
+  let instanceId = '';
+  let enabled = false;
+  const params = {};
+  for (const f of fields) {
+    if (f.fieldNum === 1 && f.wireType === 0) {
+      marker = Number(f.value);
+    } else if (f.fieldNum === 2 && f.wireType === 2) {
+      pluginId = utf8(f.value);
+    } else if (f.fieldNum === 3 && f.wireType === 2) {
+      instanceId = utf8(f.value);
+    } else if (f.fieldNum === 4 && f.wireType === 0) {
+      enabled = Number(f.value) === 1;
+    } else if (f.fieldNum === 5 && f.wireType === 2) {
+      const { name, value } = decodeParamEntry(f.value);
+      if (name) params[name] = value;
+    }
+  }
+  return { marker, pluginId, instanceId, enabled, params };
+}
+
+/**
+ * Walk a single tool-list entry (F7.F10[i]) looking for the F2.F21 OFX
+ * container.
+ *
+ * Returns null when the entry isn't an OFX entry (e.g., the standard
+ * node marker at F1=2 carries no plugin payload).
+ */
+function decodeToolEntry(entryBuf) {
+  if (!Buffer.isBuffer(entryBuf) || entryBuf.length === 0) return null;
+  const fields = readAllFields(entryBuf);
+  for (const f of fields) {
+    if (f.fieldNum === 2 && f.wireType === 2) {
+      // F2 wraps F21 container in OFX entries.
+      const inner = readAllFields(f.value);
+      for (const inn of inner) {
+        if (inn.fieldNum === 21 && inn.wireType === 2) {
+          const ofx = decodeOFXContainer(inn.value);
+          if (ofx.marker === OFY_MARKER) return ofx;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract OFX tools from a tool-list buffer (the F7.F10 field value).
+ *
+ * The F7.F10 field is itself a wrapper around repeated F1 entries.
+ * Each F1 entry may be either the standard node marker (no OFX) or
+ * an OFX container.
+ *
+ * @param {Buffer|Object} toolList - raw F10 buffer OR parser-surfaced
+ *   { _fields: [...] } structure
+ * @returns {Array<{pluginId, instanceId, enabled, params}>}
+ */
+function extractOFXTools(toolList) {
+  const tools = [];
+
+  let entries = [];
+  if (Buffer.isBuffer(toolList)) {
+    // toolList is the raw F10 buffer. F1 entries are length-delimited.
+    const fields = readAllFields(toolList);
+    for (const f of fields) {
+      if (f.fieldNum === 1 && f.wireType === 2) entries.push(f.value);
+    }
+  } else if (toolList && Array.isArray(toolList._fields)) {
+    for (const f of toolList._fields) {
+      if (f.fieldNum === 1 && f.wireType === 2 && Buffer.isBuffer(f.value)) {
+        entries.push(f.value);
+      }
+    }
+  } else if (Array.isArray(toolList)) {
+    // Caller passed a pre-extracted entries list.
+    entries = toolList.filter((b) => Buffer.isBuffer(b));
+  } else {
+    return tools;
+  }
+
+  for (const e of entries) {
+    const t = decodeToolEntry(e);
+    if (t) tools.push(t);
+  }
+  return tools;
+}
+
+/**
+ * Convenience: extract the FIRST OFX tool from a tool list. Many use
+ * cases (Film Grain on a node) only have one plugin per node.
+ *
+ * @returns {Object|null}
+ */
+function extractOFXParams(toolList) {
+  const tools = extractOFXTools(toolList);
+  return tools.length > 0 ? tools[0] : null;
+}
+
+module.exports = {
+  extractOFXParams,
+  extractOFXTools,
+  _internals: {
+    decodeOFXContainer, decodeToolEntry, decodeParamEntry,
+    readAllFields, OFY_MARKER,
+  },
+};

package/resolve-advanced/vendor/drx-codec/extract-power-window.js

@@ -0,0 +1,184 @@
+/**
+ * Decode POWER_WINDOWS (Corrector Type 4 + companions) params back to the
+ * spec shape generateDRX's window input accepts (P1.4).
+ *
+ * Encoding (TRUE live-calibrated scales, multi-point fit 2026-06-22, applied
+ * to the generator 2026-07-01 — see test/power-window-transform-calibration):
+ *   WINDOW_TYPE  0x88500008  varint {F2:2} — CONSTANT in every shape's fixture;
+ *                shape is discriminated by which corrector blocks are present,
+ *                not by this flag (circle=ct4; linear=ct4+ct3 mask;
+ *                gradient=ct65554; polygon/curve=ct4+ct6 vertex ring)
+ *   ROTATE       float   stored = −UI°/180
+ *   SIZE         float   stored = 1 + (UI−50)×0.08 (neutral 1.0)
+ *   ASPECT       float   stored = (50−UI)/50 (neutral 0)
+ *   PAN/TILT     float   stored = (UI−50)/50 × 4096 (frame pixels)
+ *   SOFT_REF, SOFT_1..4  float  UI × 16 (SOFT_1–4 live in the ct3 mask block)
+ *   OPACITY      float   UI / 100
+ *   gradient     ct65554: ROTATION −UI°/180, HANDLE_1/2 ±4096 px,
+ *                SOFTNESS UI × 100, OPACITY UI / 100
+ *
+ * SOFT_REF and SOFT_1 both surface as soft1 (prefer SOFT_REF when both).
+ *
+ * @module drx-codec/extract-power-window
+ */
+
+const drxParams = require('../drx-parameters');
+const { POWER_WINDOWS, GRADIENT_WINDOW } = drxParams;
+
+const PW = POWER_WINDOWS;
+const GW = GRADIENT_WINDOW;
+
+function toNumber(v) {
+  if (typeof v === 'bigint') return Number(v);
+  if (typeof v === 'number') return v;
+  // Varint envelope params (e.g. WINDOW_TYPE) may arrive as a parsed {F2: n} message.
+  if (v && typeof v === 'object' && v.F2 !== undefined) return Number(v.F2);
+  return 0;
+}
+
+function round4(v) { return Math.round(v * 1e4) / 1e4; }
+function drxToRotate(v) { return round4(-toNumber(v) * 180); }
+function drxToSize(v) { return round4(50 + (toNumber(v) - 1) / 0.08); }
+function drxToAspect(v) { return round4(50 - toNumber(v) * 50); }
+function drxToPanTilt(v) { return round4(50 + (toNumber(v) / 4096) * 50); }
+function drxSoftToUi(v, scale) { return round4(toNumber(v) / scale); }
+
+// Back-compat shims (old approximate conventions) kept ONLY for _internals users.
+function drxToPan(v) { return drxToPanTilt(v); }
+function drxToTilt(v) { return drxToPanTilt(v); }
+
+/**
+ * Convert the raw DRX window-type flag back to a UI type.
+ *
+ * The wire flag is a CONSTANT varint 2 for every shape (live-confirmed on the
+ * circle/linear/gradient/polygon/curve fixtures), so it cannot discriminate
+ * shape. We disambiguate by sibling params:
+ *   - gradient params (0x08F0xxxx) present → UI 5 (Gradient)
+ *   - SOFT_2..4 present (linear-only mask) → UI 2 (Linear)
+ *   - otherwise → UI 1 (Circle)
+ * Values 3 (Polygon) and 4 (Curve) never appear in this flag; their shape is
+ * carried by the ct6 vertex ring (node.params.polygonVertices).
+ */
+function drxToUiType(drxType, hasLinearSoftness = false) {
+  const t = toNumber(drxType);
+  if (t === 2) return hasLinearSoftness ? 2 : 1;
+  return t;
+}
+
+/**
+ * Extract window settings from a flattened window parameter list
+ * (ct4 transform + ct3 softness mask + ct65554 gradient params).
+ *
+ * @param {Array<{id, value, name}>} parameters
+ * @returns {Object|null} window spec, or null if no window params present
+ */
+function extractPowerWindow(parameters) {
+  if (!Array.isArray(parameters)) return null;
+
+  const out = {};
+  let foundAny = false;
+  let softRefVal;
+  let soft1Val;
+
+  // First pass — sibling-param shape discrimination (see drxToUiType).
+  let hasLinearSoftness = false;
+  let hasGradient = false;
+  for (const p of parameters) {
+    if (p.id === PW.SOFT_2 || p.id === PW.SOFT_3 || p.id === PW.SOFT_4) hasLinearSoftness = true;
+    if (GW && (p.id === GW.SOFTNESS || p.id === GW.ROTATION || p.id === GW.HANDLE_1_POS)) hasGradient = true;
+  }
+
+  for (const param of parameters) {
+    const v = param.value;
+    switch (param.id) {
+      case PW.WINDOW_TYPE:
+        out.type = hasGradient ? 5 : drxToUiType(v, hasLinearSoftness);
+        foundAny = true;
+        break;
+      case PW.ROTATE:
+        out.rotate = drxToRotate(v);
+        foundAny = true;
+        break;
+      case PW.SIZE:
+        out.size = drxToSize(v);
+        foundAny = true;
+        break;
+      case PW.ASPECT:
+        out.aspect = drxToAspect(v);
+        foundAny = true;
+        break;
+      case PW.PAN:
+        out.pan = drxToPanTilt(v);
+        foundAny = true;
+        break;
+      case PW.TILT:
+        out.tilt = drxToPanTilt(v);
+        foundAny = true;
+        break;
+      case PW.OPACITY:
+        out.opacity = round4(toNumber(v) * 100);
+        foundAny = true;
+        break;
+      case PW.SOFT_REF:
+        softRefVal = toNumber(v);
+        foundAny = true;
+        break;
+      case PW.SOFT_1:
+        soft1Val = toNumber(v);
+        foundAny = true;
+        break;
+      case PW.SOFT_2:
+        out.soft2 = drxSoftToUi(v, 16);
+        foundAny = true;
+        break;
+      case PW.SOFT_3:
+        out.soft3 = drxSoftToUi(v, 16);
+        foundAny = true;
+        break;
+      case PW.SOFT_4:
+        out.soft4 = drxSoftToUi(v, 16);
+        foundAny = true;
+        break;
+      default:
+        // Gradient window (ct65554) params.
+        if (GW && param.id === GW.SOFTNESS) {
+          out.type = 5;
+          out.soft1 = drxSoftToUi(v, 100);
+          foundAny = true;
+        } else if (GW && param.id === GW.ROTATION) {
+          out.type = 5;
+          out.rotate = drxToRotate(v);
+          foundAny = true;
+        } else if (GW && param.id === GW.HANDLE_1_POS) {
+          out.type = 5;
+          out.pan = drxToPanTilt(v);
+          foundAny = true;
+        } else if (GW && param.id === GW.HANDLE_2_POS) {
+          out.type = 5;
+          out.tilt = drxToPanTilt(v);
+          foundAny = true;
+        } else if (GW && param.id === GW.OPACITY) {
+          out.type = 5;
+          out.opacity = round4(toNumber(v) * 100);
+          foundAny = true;
+        }
+        break;
+    }
+  }
+
+  // Reconcile SOFT_REF / SOFT_1 if either was present (circle/linear), UI × 16.
+  if (softRefVal !== undefined) {
+    out.soft1 = drxSoftToUi(softRefVal, 16);
+  } else if (soft1Val !== undefined) {
+    out.soft1 = drxSoftToUi(soft1Val, 16);
+  }
+
+  return foundAny ? out : null;
+}
+
+module.exports = {
+  extractPowerWindow,
+  _internals: {
+    drxToRotate, drxToSize, drxToAspect, drxToPanTilt, drxToPan, drxToTilt, drxSoftToUi, drxToUiType, toNumber,
+  },
+};

package/resolve-advanced/vendor/drx-codec/extract-qualifier.js

@@ -0,0 +1,99 @@
+/**
+ * Decode HSL_QUALIFIER (Corrector Type 2) params back to the spec
+ * shape generateDRX's qualifier input accepts (P1.3).
+ *
+ * All percentage-based params store DRX value = UI / 100, so the
+ * extractor multiplies by 100 to recover UI units. mode and modeFlag
+ * (varints) come through as numbers.
+ *
+ * @module drx-codec/extract-qualifier
+ */
+
+const drxParams = require('../drx-parameters');
+const { HSL_QUALIFIER } = drxParams;
+
+// Map of param ID → output key. The duplicate hue params (HUE_WIDTH_DUP,
+// HUE_SOFT_DUP) appear in the protobuf but are linked to the canonical
+// HUE_WIDTH / HUE_SOFT values — we don't surface them separately, only
+// the canonical names. If they disagree, the canonical entry wins
+// (the canonical id appears first in the generator's emission order).
+const PARAM_TO_KEY = new Map([
+  [HSL_QUALIFIER.HUE_CENTER,    'hueCenter'],
+  [HSL_QUALIFIER.HUE_WIDTH,     'hueWidth'],
+  [HSL_QUALIFIER.HUE_SYM,       'hueSymmetry'],
+  [HSL_QUALIFIER.HUE_SOFT,      'hueSoft'],
+  [HSL_QUALIFIER.SAT_HIGH,      'satHigh'],
+  [HSL_QUALIFIER.SAT_LOW,       'satLow'],
+  [HSL_QUALIFIER.SAT_HIGH_SOFT, 'satHighSoft'],
+  [HSL_QUALIFIER.SAT_LOW_SOFT,  'satLowSoft'],
+  [HSL_QUALIFIER.LUM_HIGH,      'lumHigh'],
+  [HSL_QUALIFIER.LUM_LOW,       'lumLow'],
+  [HSL_QUALIFIER.LUM_HIGH_SOFT, 'lumHighSoft'],
+  [HSL_QUALIFIER.LUM_LOW_SOFT,  'lumLowSoft'],
+]);
+
+const VARINT_IDS = new Set([
+  HSL_QUALIFIER.MODE_FLAG,
+  HSL_QUALIFIER.QUALIFIER_MODE,
+]);
+
+/**
+ * Convert a stored DRX float value back to UI percentage.
+ * Tolerates BigInt (from varints) and clamps to a sane range.
+ */
+function drxToUi(v) {
+  if (typeof v === 'bigint') v = Number(v);
+  if (typeof v !== 'number' || !Number.isFinite(v)) return 0;
+  // Multiply by 100 and round to 6 decimals to suppress float32 noise.
+  return Math.round(v * 100 * 1e6) / 1e6;
+}
+
+/**
+ * Convert a varint value (possibly BigInt) to a plain number.
+ */
+function varintToNumber(v) {
+  if (typeof v === 'bigint') return Number(v);
+  if (typeof v === 'number') return v;
+  return 0;
+}
+
+/**
+ * Extract HSL qualifier settings from a corrector's parameter list.
+ *
+ * @param {Array<{id, value, name}>} parameters - parser-surfaced params
+ * @returns {Object|null} qualifier spec or null if not a qualifier corrector
+ */
+function extractQualifier(parameters) {
+  if (!Array.isArray(parameters)) return null;
+
+  const out = {};
+  let foundAny = false;
+  let foundMode = false;
+
+  for (const param of parameters) {
+    if (PARAM_TO_KEY.has(param.id)) {
+      const key = PARAM_TO_KEY.get(param.id);
+      // Don't overwrite if already set (duplicate hue params come after
+      // the canonical ones in the generator's emission order, but the
+      // canonical entries should win).
+      if (out[key] === undefined) {
+        out[key] = drxToUi(param.value);
+        foundAny = true;
+      }
+    } else if (param.id === HSL_QUALIFIER.MODE_FLAG) {
+      out.modeFlag = varintToNumber(param.value);
+      foundMode = true;
+    } else if (param.id === HSL_QUALIFIER.QUALIFIER_MODE) {
+      out.mode = varintToNumber(param.value);
+      foundMode = true;
+    }
+  }
+
+  if (!foundAny && !foundMode) return null;
+  return out;
+}
+
+module.exports = {
+  extractQualifier,
+  _internals: { PARAM_TO_KEY, VARINT_IDS, drxToUi, varintToNumber },
+};

package/resolve-advanced/vendor/drx-codec/index.js

@@ -0,0 +1,109 @@
+/**
+ * drx-codec — DRX Codec Stack
+ *
+ * Deterministic, offline DRX generation and parsing: node-graph generate/parse,
+ * request→grade resolution, tool selection, CDL export, grade merging, and NLP
+ * parsing of colorist vocabulary. All local — no LLM, no network.
+ *
+ * @module drx-codec
+ */
+
+// Core generation
+const drxGenerator = require('./drx-generator');
+const resolvedDrxGenerator = require('./resolved-drx-generator');
+
+// Tool resolution system
+const toolResolver = require('./tool-resolver');
+const vocabularyIntents = require('./vocabulary-intents');
+
+// DRX parsing
+const drxParser = require('./drx-parser');
+
+// CDL export
+const cdlExporter = require('./cdl-exporter');
+
+// Grade merging
+const drxMerger = require('./drx-merger');
+
+// NLP parsing (deterministic colorist-vocabulary → params)
+const colorNlpParser = require('./color-nlp-parser');
+
+// Look recipes / named look presets with concrete adjustment values
+const lookRecipes = require('./training-examples');
+
+// P1.1 — extract custom (YRGB) curves from a corrector's parameter list
+const extractCustomCurvesModule = require('./extract-custom-curves');
+// P1.2 — extract HSL curves (hueVs* / satVs* / lumVs*) from a corrector
+const extractHSLCurvesModule = require('./extract-hsl-curves');
+// P1.3 — extract HSL qualifier regions from a Corrector Type 2 param list
+const extractQualifierModule = require('./extract-qualifier');
+// P1.4 — extract power window settings from a Corrector Type 4 param list
+const extractPowerWindowModule = require('./extract-power-window');
+// P1.5 — extract matte finesse cleanup from a Corrector Type 9 param list
+const extractMatteFinesseModule = require('./extract-matte-finesse');
+// P1.6 — extract RESOLVEFX/OFX plugin parameter bags from a node's tool list
+const extractOFXParamsModule = require('./extract-ofx-params');
+// P5.1 — extract per-node LUT references (Resolve "Right-click → LUT")
+const extractLutRefsModule = require('./extract-lut-refs');
+
+module.exports = {
+  // Core generation
+  drxGenerator,
+  resolvedDrxGenerator,
+
+  // Tool resolution
+  toolResolver,
+  vocabularyIntents,
+
+  // Parsing
+  drxParser,
+
+  // CDL export
+  cdlExporter,
+
+  // Grade merging
+  drxMerger,
+
+  // NLP parsing
+  colorNlpParser,
+
+  // Look recipes
+  lookRecipes,
+
+  // P1.1 — DRX parser parity for custom curves
+  extractCustomCurves: extractCustomCurvesModule.extractCustomCurves,
+
+  // P1.2 — DRX parser parity for HSL curves
+  extractHSLCurves: extractHSLCurvesModule.extractHSLCurves,
+
+  // P1.3 — DRX parser parity for HSL qualifier regions
+  extractQualifier: extractQualifierModule.extractQualifier,
+
+  // P1.4 — DRX parser parity for power windows
+  extractPowerWindow: extractPowerWindowModule.extractPowerWindow,
+
+  // P1.5 — DRX parser parity for matte finesse cleanup
+  // (external matte refs deferred — see resolve-verifications.md)
+  extractMatteFinesse: extractMatteFinesseModule.extractMatteFinesse,
+
+  // P1.6 — DRX parser parity for RESOLVEFX/OFX plugin parameter bags
+  // (Film Grain at minimum; P2.1 will expand the tool registry)
+  extractOFXParams: extractOFXParamsModule.extractOFXParams,
+  extractOFXTools: extractOFXParamsModule.extractOFXTools,
+
+  // P5.1 — DRX parser parity for per-node LUT references
+  extractNodeLutRef: extractLutRefsModule.extractNodeLutRef,
+  extractDrxLutRefs: extractLutRefsModule.extractDrxLutRefs,
+
+  // Convenience functions (backwards-compatible with post-assistant's old index)
+  generateGrade: resolvedDrxGenerator.generateResolvedDRX,
+  generateFromRequest: resolvedDrxGenerator.generateFromRequest,
+  previewTools: resolvedDrxGenerator.previewResolution,
+  extractIntents: (input) => {
+    if (typeof input === 'string' && input.includes(' ')) {
+      return vocabularyIntents.extractIntentsFromRequest(input);
+    }
+    return vocabularyIntents.extractIntents(input);
+  },
+  getAvailableTools: toolResolver.getAvailableTools,
+};