Shared input incorrectly routed when intermediary node output used

[pablovela5620]

I'm trying to build a simple hand estimation graph. Input is an image, and it consists of 2 nodes, 1 that estimates the hand bounding boxes from the image, and another that takes the bounding box JSON and the same input image to estimate the hand keypoints.

I'm having the following problem when using the output JSON from the hand detection node: the input image doesn't get correctly routed to the keypoint estimation node, as if it's not connected

here is what the code looks like

"""Daggr workflow connecting hand detection and keypoint estimation.

This requires running both apps on separate ports:
- Detection app: pixi run -e dev python tools/app_detection.py (defaults to 7860)
- Keypoint app: pixi run -e dev python tools/app_keypoint.py (port 7861)

Then run this script to launch the daggr graph:
- pixi run -e dev python tools/daggr_wilor.py
"""

from daggr import GradioNode, Graph
import gradio as gr
from gradio_rerun import Rerun


# Shared image input - both detection and keypoint nodes use this
shared_image = gr.Image(label="Input Image")

# Detection node - connects to hand detection app at port 7860
detection_node = GradioNode(
    "http://localhost:7860",
    api_name="/pred_fn",
    name="Hand Detection Node",
    inputs={"rgb_hw3": shared_image},
    outputs={
        "rrd": Rerun(streaming=True, visible=False),
        "detection_json": gr.JSON(visible=True),
    },
)

# Keypoint node - connects to keypoint estimation app at port 7861
# Uses same shared_image input + detection_json from upstream
keypoint_node = GradioNode(
    "http://localhost:7861",
    api_name="/pred_fn",
    name="Keypoint Estimation Node",
    inputs={
        "rgb_hw3": shared_image,  # Same shared input as detection
        "detection_json": detection_node.detection_json,  # Detection results
    },
    outputs={
        "rrd": Rerun(streaming=True, visible=False),
        "keypoint_json": gr.JSON(visible=True),
    },
)


graph = Graph(
    name="WiLor Hand Pose Pipeline",
    nodes=[detection_node, keypoint_node],
)

if __name__ == "__main__":
    graph.launch()

The strange bit is, if I instead of passing detection_node.detection_json to the keypoint estimation node, I just set a fixed value, such as

inputs={
        "rgb_hw3": shared_image,  # Same shared input as detection
        "detection_json": "fixed value",  # Detection results
    },

Then things correctly get routed.

[pablovela5620]

Feel free to take this with a massive grain of sand, but I had Opus take a crack at a fix and it came up with this, and now it seems to work

Opus Fix

Shared Input Incorrectly Routed — Root Cause Analysis

Summary

When two GradioNodes share the same gr.Image() component and an inter-node port connection exists (e.g. detection_node.detection_json), the shared input value is not propagated to the downstream node.

Root Cause

There is a mismatch between how the UI deduplicates shared components and how the executor resolves their values at runtime.

UI side (_build_graph_data, ~L1064–1091)

The rendering code uses component_to_input_node (keyed by id(comp)) to detect that the same component instance is reused. The first node that references the component gets an input node created (e.g. Hand_Detection_Node__rgb_hw3). The second node reuses that same input node via a synthetic edge — no new input node is created.

Executor side (_execute_to_node_streaming, ~L1575–1588)

When building entry_inputs, the code always constructs the lookup key as:

input_node_name = f"{node_name}__{port_name}"

For the second node this produces Keypoint_Estimation_Node__rgb_hw3, but the UI only stored the user's value under Hand_Detection_Node__rgb_hw3. The lookup misses, so rgb_hw3 is never passed to the keypoint node.

The same bug exists in all three entry_inputs construction sites:

• _execute_to_node (~L1478)
• _execute_to_node_streaming (~L1575)
• _execute_workflow_api (~L1801)

Why hardcoded strings work

Replacing detection_node.detection_json with a fixed string removes the _port_connections edge. Without that edge the graph topology changes and the execution path resolves differently, masking this bug.

Fix

The entry_inputs resolution needs the same component_to_input_node deduplication that _build_graph_data already uses:

component_to_input_node: dict[int, str] = {}
for node_name in nodes_to_execute:
    node = self.graph.nodes[node_name]
    if node._input_components:
        node_inputs = {}
        for port_name, comp in node._input_components.items():
            comp_id = id(comp)
            if comp_id in component_to_input_node:
                input_node_name = component_to_input_node[comp_id]
            else:
                input_node_name = f"{node_name}__{port_name}"
                component_to_input_node[comp_id] = input_node_name
            input_node_id = input_node_name.replace(" ", "_").replace("-", "_")
            if input_node_id in input_values:
                value = input_values[input_node_id].get("value")
                if value is not None:
                    node_inputs[port_name] = value
        if node_inputs:
            entry_inputs[node_name] = node_inputs

This must be applied to all three entry_inputs construction sites.