Checklist

• I have searched for related issues but did not get the expected help.
• This bug has not been fixed in the latest version.
• Please note that if your bug description lacks corresponding environment information and a minimal reproducible demo, it will be difficult for us to reproduce and resolve the issue, which will reduce the possibility of receiving feedback, or even lead to the issue being closed.

🐞 Detailed Description of the Problem

Severity: HIGH
File: openjiuwen/core/common/utils/dict_utils.py ~line 163
Discovered by: Property-based testing (Hypothesis)

Summary

rebuild_dict silently drops nested lists when a path contains two consecutive list indices. The result is a structurally wrong output with no error raised.

Reproducer

from openjiuwen.core.common.utils.dict_utils import extract_leaf_nodes, rebuild_dict

data = {'a': [[1]]}
leaves = extract_leaf_nodes(data)
# leaves: [(['a', '[0]', '[0]'], 1)]

result = rebuild_dict(leaves)
print(result)  # {'a': [{}]}  ← wrong, should be {'a': [[1]]}

Expected vs Actual

Root Cause

The primary bug is in the intermediate traversal loop (~line 163–172). When a path element is a list index ('[0]') and current is not already a list, the code saves the old reference in current_parent_ref and rebinds current to a new list — but never writes the new list back into the parent. current_parent_ref is a dead variable; it is assigned and never read again:

# traversal loop — intermediate step (~line 163–176)
if not isinstance(current, list):
    current_parent_ref = current   # ← assigned but never used again
    current = []                   # ← local rebind only; parent still holds {}
# Expand list to required length
while len(current) <= index:
    current.append({})
current = current[index]           # ← steps into {} inside an orphaned list

Because the new list is never linked into the tree, subsequent traversal proceeds through {} placeholders unreachable from result. The same flaw is repeated in the final-value assignment block (~line 189–195):

last_key = path[-1]
if isinstance(last_key, str) and last_key.startswith('[') and last_key.endswith(']'):
    index = int(last_key[1:-1])
    if not isinstance(current, list):
        current = []          # ← same dead rebind
    while len(current) <= index:
        current.append(None)
    current[index] = value    # ← written to orphaned list, discarded

Fixing only the final block would leave the traversal bug intact. Both sites need the same fix.

Impact

Affects any structure with a list-of-lists or list-of-dicts-containing-lists pattern:

{'results': [[1, 2], [3, 4]]}
{'items': [{'tags': ['a', 'b']}]}

The round-trip extract_leaf_nodes → rebuild_dict is not reliable for these shapes.

In current example usage, stream_inputs_schema values are all flat dicts with string refs, so the bug is not triggered by any existing workflow. However, list-valued schemas are a supported shape (the framework handles them in vertex.py:453–456), and any user who passes a nested-list schema to stream_inputs_schema will receive silently corrupted inputs at stream time with no error raised.

Suggested Fix

Track parent and parent_key/parent_index through the loop. At both the intermediate and final list-index sites, write the new list back into the parent before using it:

if not isinstance(current, list):
    new_list = []
    if isinstance(parent, list):
        parent[parent_index] = new_list
    else:
        parent[parent_key] = new_list
    current = new_list

The existing current_parent_ref variable is a dead stub of exactly this intent — it was clearly meant to enable this write-back but was never wired up.

Detailed Environment Information Description

As above.

Additional Information

Version Information

Thanks for your contribution 🎉!