fix(workflow): support dict-keyed widgets_values for VHS audio/video nodes

VHS_LoadAudioUpload and VHS_LoadVideo carry dict-style widgets_values.
set_input now accepts string keys for dict widgets. A2V, Lipsync, and Style
parameterize_fns updated to use the right keys so file paths actually flow
through at runtime.

modes.py

@@ -20,7 +20,7 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
 
-Patch = tuple[int, int, Any]
+Patch = tuple[int, int | str, Any]
 ParameterizeFn = Callable[[dict[str, Any]], list[Patch]]
 
 
@@ -159,7 +159,7 @@ def _a2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
     return [
         (A2V_NODE_PROMPT, 0, inp["prompt"]),
         (A2V_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
-        (A2V_NODE_AUDIO, 0, inp["audio"]),
+        (A2V_NODE_AUDIO, "audio", inp["audio"]),
         (A2V_NODE_WIDTH, 0, int(inp["width"])),
         (A2V_NODE_HEIGHT, 0, int(inp["height"])),
         (A2V_NODE_FPS, 0, int(inp["fps"])),
@@ -172,7 +172,7 @@ def _lipsync_parameterize(inp: dict[str, Any]) -> list[Patch]:
         (LIPSYNC_NODE_PROMPT, 0, inp["prompt"]),
         (LIPSYNC_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
         (LIPSYNC_NODE_IMAGE, 0, inp["image"]),
-        (LIPSYNC_NODE_AUDIO, 0, inp["audio"]),
+        (LIPSYNC_NODE_AUDIO, "audio", inp["audio"]),
         (LIPSYNC_NODE_FPS, 0, int(inp["fps"])),
         (LIPSYNC_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
     ]
@@ -193,7 +193,7 @@ def _style_parameterize(inp: dict[str, Any]) -> list[Patch]:
     return [
         (STYLE_NODE_PROMPT, 0, inp["prompt"]),
         (STYLE_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
-        (STYLE_NODE_INPUT_VIDEO, 0, inp["input_video"]),
+        (STYLE_NODE_INPUT_VIDEO, "video", inp["input_video"]),
         (STYLE_NODE_FPS, 0, int(inp["fps"])),
         (STYLE_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
     ]

tests/test_workflow.py

@@ -54,3 +54,19 @@ def test_validate_rejects_orphan_link():
     wf["links"].append([99999, 1, 0, 999_999_999, 0, "INT"])  # destination doesn't exist
     with pytest.raises(ValueError, match="orphan link"):
         workflow.validate(wf)
+
+
+def test_set_input_handles_dict_widgets_values():
+    """VHS_* nodes carry dict-style widgets_values; set_input must support str keys."""
+    wf = workflow.load_template("a2v")
+    # Find a node whose widgets_values is a dict (e.g., VHS_LoadAudioUpload).
+    target = next(
+        (n for n in wf["nodes"] if isinstance(n.get("widgets_values"), dict)),
+        None,
+    )
+    assert target is not None, "no dict-widgets node in a2v template"
+    # Pick an existing key to patch (don't invent one — tests should reflect real graph shape).
+    existing_key = next(iter(target["widgets_values"].keys()))
+    workflow.set_input(wf, target["id"], existing_key, "/tmp/new_value.wav")
+    refetched = next(n for n in wf["nodes"] if n["id"] == target["id"])
+    assert refetched["widgets_values"][existing_key] == "/tmp/new_value.wav"

workflow.py

@@ -19,25 +19,54 @@ def load_template(mode: str) -> dict[str, Any]:
     return copy.deepcopy(json.loads(path.read_text()))
 
 
-def set_input(workflow: dict[str, Any], node_id: int, widget_index: int, value: Any) -> None:
+def set_input(workflow: dict[str, Any], node_id: int, widget_index: int | str, value: Any) -> None:
     """Patch a node's widgets_values in place.
 
+    Supports both list-style widgets_values (most ComfyUI nodes — patch by integer index,
+    auto-extending with None) and dict-style widgets_values (VHS_LoadAudioUpload and
+    similar — patch by string key, raising KeyError if the key doesn't exist).
+
     Args:
         workflow: A workflow dict (must have a "nodes" list).
         node_id: The id of the node to patch.
-        widget_index: Position within the node's widgets_values list.
+        widget_index: Integer index (for list widgets) or string key (for dict widgets).
         value: New value.
 
     Raises:
-        KeyError: If no node with the given id exists.
+        KeyError: If no node with the given id exists, or for dict widgets, if the key
+            doesn't already exist on the target dict (we don't add new keys).
+        TypeError: If widget_index type doesn't match the node's widgets_values type.
     """
     for node in workflow["nodes"]:
-        if node.get("id") == node_id:
-            widgets = node.setdefault("widgets_values", [])
-            while len(widgets) <= widget_index:
-                widgets.append(None)
+        if node.get("id") != node_id:
+            continue
+        widgets = node.get("widgets_values")
+        if isinstance(widgets, dict):
+            if not isinstance(widget_index, str):
+                raise TypeError(
+                    f"node {node_id} has dict widgets_values; widget_index must be str, "
+                    f"got {type(widget_index).__name__}"
+                )
+            if widget_index not in widgets:
+                raise KeyError(
+                    f"node {node_id} dict widgets_values has no key {widget_index!r}; "
+                    f"available keys: {list(widgets.keys())}"
+                )
             widgets[widget_index] = value
             return
+        # List/None case — preserve existing list-extension behavior.
+        if not isinstance(widget_index, int):
+            raise TypeError(
+                f"node {node_id} has list widgets_values; widget_index must be int, "
+                f"got {type(widget_index).__name__}"
+            )
+        if widgets is None:
+            widgets = []
+            node["widgets_values"] = widgets
+        while len(widgets) <= widget_index:
+            widgets.append(None)
+        widgets[widget_index] = value
+        return
     raise KeyError(f"node id {node_id} not found in workflow")