feat(graph): improve flow control for merge nodes downstream of conditional branches

[chalitbkb]

Summary

When a ConditionalRouter (If-Else) excludes one branch, merge/combine nodes at the intersection of active and excluded branches were blocked indefinitely. Downstream nodes could not proceed with available data from the active branch.

This fixes four points in the graph engine that caused the bottleneck:

1. Conditionally excluded vertices remained in the run manager predecessor lists
2. mark_branch() marked shared downstream vertices as INACTIVE even with active inputs
3. _get_result() raised ValueError for excluded/inactive predecessors
4. None fallback values were assigned to params, failing Pydantic validation

Changes

graph/base.py

• mark_branch(): After marking vertices as INACTIVE, reactivate any vertex that has at least one active predecessor outside the stopped branch. This keeps merge/combine nodes runnable when they still receive data from the active path.

• exclude_branch_conditionally(): Remove conditionally excluded vertices from run_manager predecessor lists via remove_from_predecessors(). This ensures downstream nodes no longer wait for data that will never arrive from the excluded branch.

vertex/vertex_types.py

• ComponentVertex._get_result(): Before raising ValueError for an unbuilt vertex, check if the vertex is conditionally excluded or inactive. If so, return None instead of crashing.

vertex/base.py

• Vertex._build_vertex_and_update_params(): Catch ValueError from get_result() as a safety net for parallel builds and edge cases. Skip assigning None to params so components use their natural input defaults instead of receiving NoneType which fails Pydantic validation.

Fixes #12994

Summary by CodeRabbit

Release Notes

• Bug Fixes
  • Improved graph execution stability when deactivating branches that feed into merge nodes, allowing downstream processing to continue with available inputs.
  • Enhanced error handling during vertex result retrieval to gracefully manage edge cases.
  • Fixed handling of conditionally excluded vertices in complex graph patterns.

[coderabbitai]

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: 0ee73837-d153-4f46-b7b2-3334686cbcc6

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

Walkthrough

Graph execution now allows merge and combine nodes to proceed when input branches are deactivated or conditionally excluded. Downstream merge vertices are reactivated if they have active external predecessors; conditionally excluded vertices are removed from blocker tracking; vertex result retrieval handles missing data gracefully and skips unavailable inputs from excluded branches.

Changes

Merge/Combine Node Availability

Layer / File(s)	Summary
Graph branch deactivation and exclusion tracking src/lfx/src/lfx/graph/graph/base.py	When a branch is marked INACTIVE, downstream merge vertices are reactivated if they have at least one active predecessor from outside the stopped branch. Conditionally excluded vertices are removed from run_manager predecessor lists so merge nodes no longer wait indefinitely for blocked upstream data.
Vertex result retrieval with state awareness src/lfx/src/lfx/graph/vertex/base.py, src/lfx/src/lfx/graph/vertex/vertex_types.py	Vertex result retrieval wraps get_result() calls in try/except to treat ValueError as None and continue param updates. Cycle-edge target resolution checks if the vertex is conditionally excluded or inactive, allowing merge nodes to use available inputs instead of failing on missing upstream data.

Sequence Diagram

sequenceDiagram
    participant Graph as Graph.mark_branch()
    participant DownstreamV as Downstream Merge Vertex
    participant RunMgr as run_manager
    participant VertexBuild as Vertex._build_vertex_and_update_params()
    participant VertexRes as ComponentVertex._get_result()
    
    Graph->>DownstreamV: scan visited vertices for reactivation
    alt Merge has active external predecessor
        DownstreamV->>Graph: reactivate and clear from visited
    else All predecessors from stopped branch
        DownstreamV->>Graph: remains inactive
    end
    
    Graph->>RunMgr: remove excluded vertices from predecessor lists
    RunMgr-->>Graph: predecessors updated
    
    VertexBuild->>VertexRes: get_result() from upstream
    alt result available
        VertexRes-->>VertexBuild: return result
    else ValueError or excluded
        VertexBuild->>VertexRes: catch exception
        VertexRes-->>VertexBuild: treat as None
    end
    
    VertexBuild->>VertexBuild: continue with available inputs

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

---

Important

Pre-merge checks failed

Please resolve all errors before merging. Addressing warnings is optional.

❌ Failed checks (1 error, 2 warnings)

Check name	Status	Explanation	Resolution
Test Coverage For New Implementations	❌ Error	PR modifies graph flow control but includes no new test files. Review comments cite 2 unaddressed issues: mark_branch lacks iterative reactivation and list/dict functions lack ValueError handling.	Add regression tests for conditional merge flow (mark_branch, exclude_branch, ValueError handling) and implement missing iterative reactivation and error handling per review comments.
Test Quality And Coverage	⚠️ Warning	No tests verify the core conditional merge functionality: ConditionalRouter + Combine, mark_branch reactivation, exclude_branch_conditionally, or ValueError handling.	Add tests for: ConditionalRouter + Combine merge, mark_branch reactivation, exclude_branch_conditionally, ValueError handling in list/dict param building, and async patterns.
Test File Naming And Structure	⚠️ Warning	PR adds critical flow control changes but no new tests cover the mark_branch reactivation, exclude_branch, or ValueError handling logic for conditional merge patterns.	Add tests for ConditionalRouter + Combine merges, mark_branch reactivation for multi-input vertices, and list/dict edge inputs from excluded branches.

✅ Passed checks (6 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately describes the main change: improving flow control for merge nodes downstream of conditional branches, which directly addresses the core problem of blocked merge/combine nodes.
Linked Issues check	✅ Passed	The PR addresses all primary objectives from issue #12994: enabling merge nodes to proceed with available inputs when upstream branches are conditionally excluded, supporting multiple inputs, and preventing indefinite blocking.
Out of Scope Changes check	✅ Passed	All changes are tightly scoped to fixing flow control for merge nodes in conditional branches. No unrelated modifications or scope creep detected.
Docstring Coverage	✅ Passed	Docstring coverage is 83.33% which is sufficient. The required threshold is 80.00%.
Excessive Mock Usage Warning	✅ Passed	Mock usage is appropriate: test_base.py uses real objects; test_vertex_base.py properly isolates ParameterHandler tests with 4 mocks for external dependencies, standard unit test design.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 2

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/lfx/src/lfx/graph/graph/base.py (1)

1057-1076: ⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

Restore scheduler predecessors when a previous exclusion is cleared.

This method removes previous_exclusions from conditionally_excluded_vertices, but it never rebuilds the run_manager.run_predecessors entries that were pruned by remove_from_predecessors(). On a later router iteration, a branch that becomes active again can be treated as already-fulfilled, so downstream merges may run before that re-enabled predecessor actually finishes. That breaks the re-evaluation path used by ConditionalRouter.iterate_and_stop_once() in src/lfx/src/lfx/components/flow_controls/conditional_router.py.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/lfx/src/lfx/graph/graph/base.py` around lines 1057 - 1076, The code
clears previous_exclusions from conditionally_excluded_vertices but never
restores the scheduler predecessor entries that were removed via
run_manager.remove_from_predecessors(), causing re-enabled branches to be
treated as already-fulfilled; update the block that handles previous_exclusions
(using conditional_exclusion_sources, previous_exclusions, and run_manager) to
reinstate each previously-excluded vertex into run_manager.run_predecessors (or
call a run_manager method to add predecessors back) for the current vertex_id so
downstream merge/combine nodes see the restored predecessor relationships when a
branch becomes active again; ensure symmetry with the removal logic used in
run_manager.remove_from_predecessors and adjust any bookkeeping
(_exclude_branch_conditionally, conditionally_excluded_vertices) accordingly.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/lfx/src/lfx/graph/graph/base.py`:
- Around line 1014-1027: The downstream reactivation loop over `visited` in the
block checking `if state == VertexStates.INACTIVE` is single-pass and
order-dependent, which can leave shared descendants inactive; make this pass
iterative by repeating the scan until no vertices were reactivated in an
iteration (e.g., loop while a `changed` flag is true) so previously-skipped
descendants get revisited; use `self.predecessor_map`,
`self.get_vertex(p_id).is_active()`, and `self.mark_vertex(v_id,
VertexStates.ACTIVE)` as-is inside the loop and remove the unused `vertex` local
variable to fix the Ruff warning.

In `@src/lfx/src/lfx/graph/vertex/base.py`:
- Around line 649-657: The current skip logic only avoids setting scalar params
when result is None but still appends/stores None for list/dict inputs; update
_build_list_of_vertices_and_update_params and _build_dict_and_update_params to
mirror the scalar skip behavior: after obtaining result from vertex.get_result
(and after calling _handle_func), if result is None do not extend the params
list or store the dict entry; for lists, filter out None entries before calling
_extend_params_list_with_result (or skip calling it entirely when result is None
or empty after filtering); for dicts, only assign self.params[key] when result
is not None and contains valid entries. Ensure you reference and change
_build_list_of_vertices_and_update_params, _build_dict_and_update_params, and
keep the existing _handle_func(key, result) call sequence.

---

Outside diff comments:
In `@src/lfx/src/lfx/graph/graph/base.py`:
- Around line 1057-1076: The code clears previous_exclusions from
conditionally_excluded_vertices but never restores the scheduler predecessor
entries that were removed via run_manager.remove_from_predecessors(), causing
re-enabled branches to be treated as already-fulfilled; update the block that
handles previous_exclusions (using conditional_exclusion_sources,
previous_exclusions, and run_manager) to reinstate each previously-excluded
vertex into run_manager.run_predecessors (or call a run_manager method to add
predecessors back) for the current vertex_id so downstream merge/combine nodes
see the restored predecessor relationships when a branch becomes active again;
ensure symmetry with the removal logic used in
run_manager.remove_from_predecessors and adjust any bookkeeping
(_exclude_branch_conditionally, conditionally_excluded_vertices) accordingly.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: 1a3caae2-221f-4c81-a202-f8912c3688e2

📥 Commits

Reviewing files that changed from the base of the PR and between fb3d6ec and c5dcfac.

📒 Files selected for processing (3)

• src/lfx/src/lfx/graph/graph/base.py
• src/lfx/src/lfx/graph/vertex/base.py
• src/lfx/src/lfx/graph/vertex/vertex_types.py

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Make the downstream reactivation pass iterative.

visited is a set, so this single pass is order-dependent. If a shared descendant is checked before its upstream merge vertex gets reactivated, it stays INACTIVE because the loop never revisits it. A stopped branch with ... -> merge_a -> merge_b can still deadlock depending on set iteration order. You can also drop the unused vertex local while fixing this, which is the Ruff failure on this hunk.

🔁 Suggested fix

         if state == VertexStates.INACTIVE:
-            for v_id in list(visited):
-                vertex = self.get_vertex(v_id)
-                active_predecessors = [
-                    p_id
-                    for p_id in self.predecessor_map.get(v_id, [])
-                    if p_id not in visited and self.get_vertex(p_id).is_active()
-                ]
-                if active_predecessors:
-                    self.mark_vertex(v_id, VertexStates.ACTIVE)
-                    visited.discard(v_id)
+            changed = True
+            while changed:
+                changed = False
+                for v_id in list(visited):
+                    active_predecessors = [
+                        p_id
+                        for p_id in self.predecessor_map.get(v_id, [])
+                        if p_id not in visited and self.get_vertex(p_id).is_active()
+                    ]
+                    if active_predecessors:
+                        self.mark_vertex(v_id, VertexStates.ACTIVE)
+                        visited.discard(v_id)
+                        changed = True

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	# Reactivate common downstream vertices that have at least one active predecessor
	# outside the stopped branch. Without this, merge/combine nodes that receive input
	# from both active and inactive branches would be blocked forever.
	if state == VertexStates.INACTIVE:
	for v_id in list(visited):
	vertex = self.get_vertex(v_id)
	active_predecessors = [
	p_id
	for p_id in self.predecessor_map.get(v_id, [])
	if p_id not in visited and self.get_vertex(p_id).is_active()
	]
	if active_predecessors:
	self.mark_vertex(v_id, VertexStates.ACTIVE)
	visited.discard(v_id)
	# Reactivate common downstream vertices that have at least one active predecessor
	# outside the stopped branch. Without this, merge/combine nodes that receive input
	# from both active and inactive branches would be blocked forever.
	if state == VertexStates.INACTIVE:
	changed = True
	while changed:
	changed = False
	for v_id in list(visited):
	active_predecessors = [
	p_id
	for p_id in self.predecessor_map.get(v_id, [])
	if p_id not in visited and self.get_vertex(p_id).is_active()
	]
	if active_predecessors:
	self.mark_vertex(v_id, VertexStates.ACTIVE)
	visited.discard(v_id)
	changed = True

🧰 Tools

🪛 GitHub Actions: Ruff Style Check / 0_Ruff Style Check (3.13).txt

[error] 1019-1019: Ruff check failed (F841). Local variable vertex is assigned to but never used.

🪛 GitHub Actions: Ruff Style Check / Ruff Style Check (3.13)

[error] 1019-1019: ruff check failed (F841): Local variable vertex is assigned to but never used

🪛 GitHub Check: Ruff Style Check (3.13)

[failure] 1019-1019: Ruff (F841)
src/lfx/src/lfx/graph/graph/base.py:1019:17: F841 Local variable vertex is assigned to but never used

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/lfx/src/lfx/graph/graph/base.py` around lines 1014 - 1027, The downstream
reactivation loop over `visited` in the block checking `if state ==
VertexStates.INACTIVE` is single-pass and order-dependent, which can leave
shared descendants inactive; make this pass iterative by repeating the scan
until no vertices were reactivated in an iteration (e.g., loop while a `changed`
flag is true) so previously-skipped descendants get revisited; use
`self.predecessor_map`, `self.get_vertex(p_id).is_active()`, and
`self.mark_vertex(v_id, VertexStates.ACTIVE)` as-is inside the loop and remove
the unused `vertex` local variable to fix the Ruff warning.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Apply the same skip logic to list/dict inputs.

This only fixes scalar params. _build_list_of_vertices_and_update_params() still appends None, and _build_dict_and_update_params() still stores it, so merge/combine inputs backed by multi-source edges do not actually drop excluded branches.

🧩 Suggested fix

     async def _build_dict_and_update_params(
         self,
         key,
         vertices_dict: dict[str, Vertex],
     ) -> None:
         """Iterates over a dictionary of vertices, builds each and updates the params dictionary."""
         for sub_key, value in vertices_dict.items():
             if not self._is_vertex(value):
                 self.params[key][sub_key] = value
             else:
-                result = await value.get_result(self, target_handle_name=key)
-                self.params[key][sub_key] = result
+                try:
+                    result = await value.get_result(self, target_handle_name=key)
+                except ValueError:
+                    result = None
+                if result is not None:
+                    self.params[key][sub_key] = result
@@
     async def _build_list_of_vertices_and_update_params(
         self,
         key,
         vertices: list[Vertex],
     ) -> None:
         """Iterates over a list of vertices, builds each and updates the params dictionary."""
         self.params[key] = []
         for vertex in vertices:
-            result = await vertex.get_result(self, target_handle_name=key)
+            try:
+                result = await vertex.get_result(self, target_handle_name=key)
+            except ValueError:
+                result = None
+            if result is None:
+                continue
             # Weird check to see if the params[key] is a list
             # because sometimes it is a Data and breaks the code
             if not isinstance(self.params[key], list):
                 self.params[key] = [self.params[key]]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/lfx/src/lfx/graph/vertex/base.py` around lines 649 - 657, The current
skip logic only avoids setting scalar params when result is None but still
appends/stores None for list/dict inputs; update
_build_list_of_vertices_and_update_params and _build_dict_and_update_params to
mirror the scalar skip behavior: after obtaining result from vertex.get_result
(and after calling _handle_func), if result is None do not extend the params
list or store the dict entry; for lists, filter out None entries before calling
_extend_params_list_with_result (or skip calling it entirely when result is None
or empty after filtering); for dicts, only assign self.params[key] when result
is not None and contains valid entries. Ensure you reference and change
_build_list_of_vertices_and_update_params, _build_dict_and_update_params, and
keep the existing _handle_func(key, result) call sequence.

[ogabrielluiz]

Notes from a review pass on this change. The most concerning one is the params contract change in _build_vertex_and_update_params. I'm not convinced it does what the commit message claims; details inline at vertex/base.py:657.

No tests for any of the four behavior changes. The headline scenario (ConditionalRouter feeding a merge node) is currently uncovered in lfx. The only existing test that imports ConditionalRouterComponent is tests/unit/graph/graph/test_cycles.py, which is module-skipped because lfx doesn't ship langchain_openai. Could you add an end-to-end test that builds the failing graph from the original repro, runs it, and asserts the merge node produces output? Plus a unit test that ComponentVertex._get_result returns None for an excluded vertex would pin the new contract.

Other notes inline.

[ogabrielluiz]

I think this is the load-bearing concern with the PR. The commit message says skipping the assignment lets components "use their natural input defaults instead of receiving NoneType", but self.params[key] was already pre-seeded with the upstream Vertex instance during build_params (via param_handler._set_params_from_normal_edge at param_handler.py:100: params[param_key] = self.vertex.graph.get_vertex(edge.source_id)). When result is None, the gate here just leaves that stale Vertex object in place. It then flows through loading.get_params(self.params) into set_attributes -> _validate_inputs (component.py:1102), which assigns input_.value = <Vertex> and re-triggers Pydantic validation against a Vertex object. The default fallback at component.py:1124 only fires when the key is absent, not when it holds a stale value.

Have you been able to reproduce the original Pydantic failure end-to-end after this change? I think the merge node still fails, just with a different message. If the intent is "absent", the fix would need to be self.params.pop(key, None) here instead of the conditional set.

[chalitbkb]

Fixed. Now the excluded/inactive check happens before calling get_result. When the vertex is excluded or inactive, self.params.pop(key, None) removes the pre-seeded Vertex object and returns early, so the key is truly absent and the component falls through to its natural input default at component.py:1124.

[ogabrielluiz]

I think this except ValueError is too broad. ComponentVertex._get_result raises ValueError for at least four distinct conditions in vertex_types.py: "has not been built yet", "Edge not found between X and Y", "Result not found for X", and "Result not found for X in edge". The new code silently turns all of them into None with no logging, so a misconfigured graph (missing edge, missing result) is indistinguishable from a legitimately excluded branch.

Could you narrow this? Either check vertex.id in self.graph.conditionally_excluded_vertices or not vertex.is_active() before calling get_result, or define a dedicated exception type for the excluded case. The blanket catch loses diagnosability for unrelated bugs.

[chalitbkb]

Fixed. The try/except ValueError block has been removed. The check for conditionally_excluded_vertices or not is_active() now happens before calling vertex.get_result(), so legitimate ValueErrors (edge not found, result not found, etc.) propagate normally. The silent catch is gone.

[ogabrielluiz]

remove_from_predecessors is destructive and there's no inverse. ConditionalRouter.iterate_and_stop_once (conditional_router.py:166) calls exclude_branch_conditionally on every cycle iteration. The top of this function (around line 1041) clears conditional_exclusion_sources for the source but does not restore run_predecessors. The only writers to run_predecessors are remove_from_predecessors (removal) and update_run_state/build_run_map (overwrite). So across cycle iterations where the router toggles branches, the run manager's predecessor accounting monotonically shrinks.

First iteration probably works. Have you tested this inside a loop (e.g. a router being re-evaluated each cycle)? I think we'd want a regression test for the multi-iteration case.

[chalitbkb]

Fixed. When clearing previous exclusions from conditional_exclusion_sources, the code now rebuilds predecessor entries for successors of previously excluded vertices from the full graph adjacency map, then restores them via run_manager.update_run_state(). This prevents the monotonic shrinkage of run_predecessors across cycle iterations.

[ogabrielluiz]

Reactivated vertices get dropped from visited here, and on the next line new_predecessor_map = {k: v ... if k in visited} filters by visited. So the reactivated merge vertex isn't a key in new_predecessor_map, and the subsequent run_manager.update_run_state(new_predecessor_map, ...) never resets that vertex's run_predecessors to the graph-level list. The reactivation flips vertex.state to ACTIVE but the run manager's accounting is left in whatever shape mark_vertex(INACTIVE) left it.

It happens to work in the simple case (the merge proceeds with only active predecessors, which is what you want), but the coupling is coincidental. I think this needs either an explicit comment explaining the invariant, or the reactivated vertex should be kept in visited and the cycle/predecessor filtering handled differently.

[chalitbkb]

Fixed two ways: (1) The reactivation loop is now iterative (while changed) so descendants of reactivated vertices are revisited in the next pass. (2) An explicit comment explains the coupling invariant: reactivated vertices are discarded from visited and therefore omitted from new_predecessor_map, but this is correct when coupled with exclude_branch_conditionally (called right after) which removes excluded branch vertices from successor predecessor lists via remove_from_predecessors.

[ogabrielluiz]

Heads up that is_active() returns False for any non-ACTIVE state, not just conditionally-excluded ones. INACTIVE is set by cycle management at graph/base.py:581 independently of conditional routing. After this change, any cycle-inactivated vertex silently returns None from _get_result where it previously raised.

Is that intentional? The commit message frames the change as "conditionally excluded or inactive", but "inactive" covers a much wider set of cases. If you want to scope this strictly to the conditional-routing case, the check could be just self.id in self.graph.conditionally_excluded_vertices.

[chalitbkb]

Fixed. The check in vertex_types.py is now narrowed to just self.id in self.graph.conditionally_excluded_vertices. The cycle INACTIVE state is handled upstream in the callers (_build_vertex_and_update_params, _build_list_of_vertices_and_update_params, _build_dict_and_update_params in vertex/base.py), which check not vertex.is_active() before calling get_result.

[ogabrielluiz]

Small thing: this whole block is gated on state == VertexStates.INACTIVE, with no symmetric path for state == VertexStates.ACTIVE. mark_branch is called with ACTIVE elsewhere in the codebase (e.g. branch resets). Worth a thought on whether a reset-to-active also needs to restore the run manager's predecessor accounting, since remove_from_predecessors from the earlier INACTIVE pass is still in effect.

[chalitbkb]

Fixed. Added a symmetric path for state == VertexStates.ACTIVE: when activating a branch, the code now also rebuilds predecessor entries for successors of the activated vertices from the full graph adjacency map. This restores any entries that were pruned by a previous INACTIVE+exclude pass via remove_from_predecessors.

[chalitbkb]

@ogabrielluiz thanks for the thorough review. I have addressed all 7 items:1. Params contract (vertex/base.py:657): Now uses self.params.pop(key, None) before get_result when the vertex is excluded/inactive, so the key is truly absent and the component falls through to its input default.2. Blanket except ValueError (vertex/base.py:651): Removed. The excluded/inactive check now happens before calling get_result, so legitimate ValueErrors propagate normally.3. remove_from_predecessors monotonic shrinkage (graph/base.py:1076): When clearing previous exclusions, predecessor entries are rebuilt from the full graph adjacency map and restored via update_run_state.4. Reactivated vertices dropped from visited (graph/base.py:1027): The reactivation loop is now iterative (while changed) to handle descendant chains, and a comment explains the coupling invariant with exclude_branch_conditionally.5. is_active() too broad (vertex_types.py:113): Narrowed to just conditionally_excluded_vertices. The cycle INACTIVE check is handled upstream in the callers in vertex/base.py.6. No symmetric ACTIVE path (graph/base.py:1027): Added successor predecessor rebuild for mark_branch(ACTIVE) to restore any entries pruned by a previous INACTIVE+exclude pass.7. Tests: Added 3 tests in test_conditional_merge.py — two E2E tests (TextInput/ChatInput variants) proving the merge node produces output, and one unit test confirming ComponentVertex._get_result returns None for an excluded vertex. All existing graph tests still pass (63 passed, no regressions).Let me know if there is anything else to adjust!