griptape-nodes 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

griptape_nodes/exe_types/flow.py

@@ -1,19 +1,11 @@
 from __future__ import annotations
 
 import logging
-from queue import Queue
 from typing import TYPE_CHECKING, NamedTuple
 
-from griptape.events import EventBus
-
-from griptape_nodes.exe_types.connections import Connections
-from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_types import NodeResolutionState, StartLoopNode, StartNode
-from griptape_nodes.machines.control_flow import CompleteState, ControlFlowMachine
-from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
-from griptape_nodes.retained_mode.events.execution_events import ControlFlowCancelledEvent
-
 if TYPE_CHECKING:
+    from queue import Queue
+
     from griptape_nodes.exe_types.core_types import Parameter
     from griptape_nodes.exe_types.node_types import BaseNode
 
@@ -28,22 +20,16 @@ class CurrentNodes(NamedTuple):
     current_resolving_node: str | None
 
 
-# The flow will own all of the nodes and the connections
+# The flow will own all of the nodes
 class ControlFlow:
     name: str
-    connections: Connections
     nodes: dict[str, BaseNode]
-    control_flow_machine: ControlFlowMachine
-    single_node_resolution: bool
-    flow_queue: Queue[BaseNode]
+    metadata: dict
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, metadata: dict | None = None) -> None:
         self.name = name
-        self.connections = Connections()
         self.nodes = {}
-        self.control_flow_machine = ControlFlowMachine(self)
-        self.single_node_resolution = False
-        self.flow_queue = Queue()
+        self.metadata = metadata or {}
 
     def add_node(self, node: BaseNode) -> None:
         self.nodes[node.name] = node
@@ -59,15 +45,25 @@ class ControlFlow:
         target_parameter: Parameter,
     ) -> bool:
         if source_node.name in self.nodes and target_node.name in self.nodes:
-            return self.connections.add_connection(source_node, source_parameter, target_node, target_parameter)
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            return (
+                GriptapeNodes.FlowManager()
+                .get_connections()
+                .add_connection(source_node, source_parameter, target_node, target_parameter)
+            )
         return False
 
     def remove_connection(
         self, source_node: BaseNode, source_parameter: Parameter, target_node: BaseNode, target_parameter: Parameter
     ) -> bool:
         if source_node.name in self.nodes and target_node.name in self.nodes:
-            return self.connections.remove_connection(
-                source_node.name, source_parameter.name, target_node.name, target_parameter.name
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            return (
+                GriptapeNodes.FlowManager()
+                .get_connections()
+                .remove_connection(source_node.name, source_parameter.name, target_node.name, target_parameter.name)
             )
         return False
 
@@ -78,343 +74,24 @@ class ControlFlow:
         target_node: BaseNode,
         target_parameter: Parameter,
     ) -> bool:
-        if source_node.name in self.nodes and target_node.name in self.nodes:
-            connected_node_tuple = self.get_connected_output_parameters(node=source_node, param=source_parameter)
-            if connected_node_tuple is not None:
-                for connected_node_values in connected_node_tuple:
-                    connected_node, connected_param = connected_node_values
-                    if connected_node is target_node and connected_param is target_parameter:
-                        return True
-        return False
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-    def start_flow(self, start_node: BaseNode | None = None, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002
-        if self.check_for_existing_running_flow():
-            # If flow already exists, throw an error
-            errormsg = "This workflow is already in progress. Please wait for the current process to finish before starting again."
-            raise RuntimeError(errormsg)
-
-        if start_node is None:
-            if self.flow_queue.empty():
-                errormsg = "No Flow exists. You must create at least one control connection."
-                raise RuntimeError(errormsg)
-            start_node = self.flow_queue.get()
-
-        try:
-            self.control_flow_machine.start_flow(start_node, debug_mode)
-            self.flow_queue.task_done()
-        except Exception:
-            if self.check_for_existing_running_flow():
-                self.cancel_flow_run()
-            raise
-
-    def check_for_existing_running_flow(self) -> bool:
-        if self.control_flow_machine._current_state is not CompleteState and self.control_flow_machine._current_state:
-            # Flow already exists in progress
-            return True
-        return bool(
-            not self.control_flow_machine._context.resolution_machine.is_complete()
-            and self.control_flow_machine._context.resolution_machine.is_started()
-        )
-
-    def resolve_singular_node(self, node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002
-        # Set that we are only working on one node right now! no other stepping allowed
-        if self.check_for_existing_running_flow():
-            # If flow already exists, throw an error
-            errormsg = f"This workflow is already in progress. Please wait for the current process to finish before starting {node.name} again."
-            raise RuntimeError(errormsg)
-        self.single_node_resolution = True
-        # Get the node resolution machine for the current flow!
-        self.control_flow_machine._context.current_node = node
-        resolution_machine = self.control_flow_machine._context.resolution_machine
-        # Set debug mode
-        resolution_machine.change_debug_mode(debug_mode)
-        # Resolve the node.
-        node.state = NodeResolutionState.UNRESOLVED
-        resolution_machine.resolve_node(node)
-        # decide if we can change it back to normal flow mode!
-        if resolution_machine.is_complete():
-            self.single_node_resolution = False
-            self.control_flow_machine._context.current_node = None
-
-    def single_execution_step(self, change_debug_mode: bool) -> None:  # noqa: FBT001
-        # do a granular step
-        if not self.check_for_existing_running_flow():
-            if self.flow_queue.empty():
-                errormsg = "Flow has not yet been started. Cannot step while no flow has begun."
-                raise RuntimeError(errormsg)
-            start_node = self.flow_queue.get()
-            self.control_flow_machine.start_flow(start_node, debug_mode=True)
-            start_node = self.flow_queue.task_done()
-            return
-        self.control_flow_machine.granular_step(change_debug_mode)
-        resolution_machine = self.control_flow_machine._context.resolution_machine
-        if self.single_node_resolution:
-            resolution_machine = self.control_flow_machine._context.resolution_machine
-            if resolution_machine.is_complete():
-                self.single_node_resolution = False
-
-    def single_node_step(self) -> None:
-        # It won't call single_node_step without an existing flow running from US.
-        if not self.check_for_existing_running_flow():
-            if self.flow_queue.empty():
-                errormsg = "Flow has not yet been started. Cannot step while no flow has begun."
-                raise RuntimeError(errormsg)
-            start_node = self.flow_queue.get()
-            self.control_flow_machine.start_flow(start_node, debug_mode=True)
-            start_node = self.flow_queue.task_done()
-            return
-        # Step over a whole node
-        if self.single_node_resolution:
-            msg = "Cannot step through the Control Flow in Single Node Execution"
-            raise RuntimeError(msg)
-        self.control_flow_machine.node_step()
-        # Start the next resolution step now please.
-        if not self.check_for_existing_running_flow() and not self.flow_queue.empty():
-            start_node = self.flow_queue.get()
-            self.flow_queue.task_done()
-            self.control_flow_machine.start_flow(start_node, debug_mode=True)
-
-    def continue_executing(self) -> None:
-        if not self.check_for_existing_running_flow():
-            if self.flow_queue.empty():
-                errormsg = "Flow has not yet been started. Cannot step while no flow has begun."
-                raise RuntimeError(errormsg)
-            start_node = self.flow_queue.get()
-            self.flow_queue.task_done()
-            self.control_flow_machine.start_flow(start_node, debug_mode=False)
-            return
-        # Turn all debugging to false and continue on
-        self.control_flow_machine.change_debug_mode(False)
-        if self.single_node_resolution:
-            if self.control_flow_machine._context.resolution_machine.is_complete():
-                self.single_node_resolution = False
-            else:
-                self.control_flow_machine._context.resolution_machine.update()
-        else:
-            self.control_flow_machine.node_step()
-        # Now it is done executing. make sure it's actually done?
-        if not self.check_for_existing_running_flow() and not self.flow_queue.empty():
-            start_node = self.flow_queue.get()
-            self.flow_queue.task_done()
-            self.control_flow_machine.start_flow(start_node, debug_mode=False)
-
-    def cancel_flow_run(self) -> None:
-        if not self.check_for_existing_running_flow():
-            errormsg = "Flow has not yet been started. Cannot cancel flow that hasn't begun."
-            raise RuntimeError(errormsg)
-        self.clear_flow_queue()
-        self.control_flow_machine.reset_machine()
-        # Reset control flow machine
-        self.single_node_resolution = False
-        logger.debug("Cancelling flow run")
-
-        EventBus.publish_event(
-            ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=ControlFlowCancelledEvent()))
-        )
-
-    def unresolve_whole_flow(self) -> None:
-        for node in self.nodes.values():
-            node.make_node_unresolved(current_states_to_trigger_change_event=None)
-
-    def flow_state(self) -> CurrentNodes:
-        if not self.check_for_existing_running_flow():
-            msg = "Flow hasn't started."
-            raise RuntimeError(msg)
-        current_control_node = (
-            self.control_flow_machine._context.current_node.name
-            if self.control_flow_machine._context.current_node is not None
-            else None
-        )
-        focus_stack_for_node = self.control_flow_machine._context.resolution_machine._context.focus_stack
-        current_resolving_node = focus_stack_for_node[-1].node.name if len(focus_stack_for_node) else None
-        return CurrentNodes(current_control_node, current_resolving_node)
-
-    def clear_flow_queue(self) -> None:
-        self.flow_queue.queue.clear()
+        return GriptapeNodes.FlowManager().has_connection(source_node, source_parameter, target_node, target_parameter)
 
-    def get_connected_output_parameters(self, node: BaseNode, param: Parameter) -> list[tuple[BaseNode, Parameter]]:
-        connections = []
-        if node.name in self.connections.outgoing_index:
-            outgoing_params = self.connections.outgoing_index[node.name]
-            if param.name in outgoing_params:
-                for connection_id in outgoing_params[param.name]:
-                    connection = self.connections.connections[connection_id]
-                    connections.append((connection.target_node, connection.target_parameter))
-        return connections
+    def clear_execution_queue(self) -> None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-    def get_connected_input_parameters(self, node: BaseNode, param: Parameter) -> list[tuple[BaseNode, Parameter]]:
-        connections = []
-        if node.name in self.connections.incoming_index:
-            incoming_params = self.connections.incoming_index[node.name]
-            if param.name in incoming_params:
-                for connection_id in incoming_params[param.name]:
-                    connection = self.connections.connections[connection_id]
-                    connections.append((connection.source_node, connection.source_parameter))
-        return connections
-
-    def get_connected_output_from_node(self, node: BaseNode) -> list[tuple[BaseNode, Parameter]]:
-        connections = []
-        if node.name in self.connections.outgoing_index:
-            connection_ids = [
-                item for value_list in self.connections.outgoing_index[node.name].values() for item in value_list
-            ]
-            for connection_id in connection_ids:
-                connection = self.connections.connections[connection_id]
-                connections.append((connection.target_node, connection.target_parameter))
-        return connections
-
-    def get_connected_input_from_node(self, node: BaseNode) -> list[tuple[BaseNode, Parameter]]:
-        connections = []
-        if node.name in self.connections.incoming_index:
-            connection_ids = [
-                item for value_list in self.connections.incoming_index[node.name].values() for item in value_list
-            ]
-            for connection_id in connection_ids:
-                connection = self.connections.connections[connection_id]
-                connections.append((connection.source_node, connection.source_parameter))
-        return connections
-
-    def get_start_node_queue(self) -> Queue | None:  # noqa: C901, PLR0912
-        # check all nodes in flow
-        # add them all to a stack. We're calling this only if no flow was specified, so we're running them all.
-        self.flow_queue = Queue()
-        # if no nodes, no flow.
-        if not len(self.nodes):
-            return None
-        data_nodes = []
-        valid_data_nodes = []
-        start_nodes = []
-        control_nodes = []
-        for node in self.nodes.values():
-            # if it's a start node, start here! Return the first one!
-            if isinstance(node, StartNode):
-                start_nodes.append(node)
-                continue
-            # no start nodes. let's find the first control node.
-            # if it's a control node, there could be a flow.
-            control_param = False
-            for parameter in node.parameters:
-                if ParameterTypeBuiltin.CONTROL_TYPE.value == parameter.output_type:
-                    control_param = True
-                    break
-            if not control_param:
-                # saving this for later
-                data_nodes.append(node)
-                # If this node doesn't have a control connection..
-                continue
-            cn_mgr = self.connections
-            # check if it has an incoming connection. If it does, it's not a start node
-            has_control_connection = False
-            if node.name in cn_mgr.incoming_index:
-                for param_name in cn_mgr.incoming_index[node.name]:
-                    param = node.get_parameter_by_name(param_name)
-                    if param and ParameterTypeBuiltin.CONTROL_TYPE.value == param.output_type:
-                        # there is a control connection coming in
-                        has_control_connection = True
-                        break
-            # if there is a connection coming in, isn't a start.
-            if has_control_connection and not isinstance(node, StartLoopNode):
-                continue
-            # Does it have an outgoing connection?
-            if node.name in cn_mgr.outgoing_index:
-                # If one of the outgoing connections is control, add it. otherwise don't.
-                for param_name in cn_mgr.outgoing_index[node.name]:
-                    param = node.get_parameter_by_name(param_name)
-                    if param and ParameterTypeBuiltin.CONTROL_TYPE.value == param.output_type:
-                        control_nodes.append(node)
-                        break
-            else:
-                control_nodes.append(node)
-
-        # If we've gotten to this point, there are no control parameters
-        # Let's return a data node that has no OUTGOING data connections!
-        for node in data_nodes:
-            cn_mgr = self.connections
-            # check if it has an outgoing connection. We don't want it to (that means we get the most resolution)
-            if node.name not in cn_mgr.outgoing_index:
-                valid_data_nodes.append(node)
-        # ok now
-        for node in start_nodes:
-            self.flow_queue.put(node)
-        for node in control_nodes:
-            self.flow_queue.put(node)
-        for node in valid_data_nodes:
-            self.flow_queue.put(node)
-
-        return self.flow_queue
-
-    def get_start_node_from_node(self, node: BaseNode) -> BaseNode | None:
-        # backwards chain in control outputs.
-        if node not in self.nodes.values():
-            return None
-        # Go back through incoming control connections to get the start node
-        curr_node = node
-        prev_node = self.get_prev_node(curr_node)
-        # Fencepost loop - get the first previous node name and then we go
-        while prev_node:
-            curr_node = prev_node
-            prev_node = self.get_prev_node(prev_node)
-        return curr_node
-
-    def get_prev_node(self, node: BaseNode) -> BaseNode | None:
-        if node.name in self.connections.incoming_index:
-            parameters = self.connections.incoming_index[node.name]
-            for parameter_name in parameters:
-                parameter = node.get_parameter_by_name(parameter_name)
-                if parameter and ParameterTypeBuiltin.CONTROL_TYPE.value == parameter.output_type:
-                    # this is a control connection
-                    connection_ids = self.connections.incoming_index[node.name][parameter_name]
-                    for connection_id in connection_ids:
-                        connection = self.connections.connections[connection_id]
-                        return connection.get_source_node()
-        return None
-
-    def stop_flow_breakpoint(self, node: BaseNode) -> None:
-        # This will prevent the flow from continuing on.
-        node.stop_flow = True
+        GriptapeNodes.FlowManager().clear_execution_queue()
 
     def get_connections_on_node(self, node: BaseNode) -> list[BaseNode] | None:
-        # get all of the connection ids
-        connected_nodes = []
-        # Handle outgoing connections
-        if node.name in self.connections.outgoing_index:
-            outgoing_params = self.connections.outgoing_index[node.name]
-            outgoing_connection_ids = []
-            for connection_ids in outgoing_params.values():
-                outgoing_connection_ids = outgoing_connection_ids + connection_ids
-            for connection_id in outgoing_connection_ids:
-                connection = self.connections.connections[connection_id]
-                if connection.source_node not in connected_nodes:
-                    connected_nodes.append(connection.target_node)
-        # Handle incoming connections
-        if node.name in self.connections.incoming_index:
-            incoming_params = self.connections.incoming_index[node.name]
-            incoming_connection_ids = []
-            for connection_ids in incoming_params.values():
-                incoming_connection_ids = incoming_connection_ids + connection_ids
-            for connection_id in incoming_connection_ids:
-                connection = self.connections.connections[connection_id]
-                if connection.source_node not in connected_nodes:
-                    connected_nodes.append(connection.source_node)
-        # Return all connected nodes. No duplicates
-        return connected_nodes
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_connections_on_node(self, node)
 
     def get_all_connected_nodes(self, node: BaseNode) -> list[BaseNode]:
-        discovered = {}
-        processed = {}
-        queue = Queue()
-        queue.put(node)
-        discovered[node] = True
-        while not queue.empty():
-            curr_node = queue.get()
-            processed[curr_node] = True
-            next_nodes = self.get_connections_on_node(curr_node)
-            if next_nodes:
-                for next_node in next_nodes:
-                    if next_node not in discovered:
-                        discovered[next_node] = True
-                        queue.put(next_node)
-        return list(processed.keys())
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_all_connected_nodes(self, node)
 
     def get_node_dependencies(self, node: BaseNode) -> list[BaseNode]:
         """Get all upstream nodes that the given node depends on.
@@ -428,18 +105,41 @@ class ControlFlow:
         Returns:
             list[BaseNode]: A list of all nodes that the given node depends on, including the node itself (as the first element)
         """
-        node_list = [node]
-        node_queue = Queue()
-        node_queue.put(node)
-        while not node_queue.empty():
-            curr_node = node_queue.get()
-            input_connections = self.get_connected_input_from_node(curr_node)
-            if input_connections:
-                for input_node, input_parameter in input_connections:
-                    if (
-                        ParameterTypeBuiltin.CONTROL_TYPE.value != input_parameter.output_type
-                        and input_node not in node_list
-                    ):
-                        node_list.append(input_node)
-                        node_queue.put(input_node)
-        return node_list
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_node_dependencies(self, node)
+
+    def get_connected_output_parameters(self, node: BaseNode, param: Parameter) -> list[tuple[BaseNode, Parameter]]:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_connected_output_parameters(node, param)
+
+    def get_connected_input_parameters(self, node: BaseNode, param: Parameter) -> list[tuple[BaseNode, Parameter]]:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_connected_input_parameters(self, node, param)
+
+    def get_connected_output_from_node(self, node: BaseNode) -> list[tuple[BaseNode, Parameter]]:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_connected_output_from_node(self, node)
+
+    def get_connected_input_from_node(self, node: BaseNode) -> list[tuple[BaseNode, Parameter]]:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_connected_input_from_node(self, node)
+
+    def get_start_node_queue(self) -> Queue | None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_start_node_queue()
+
+    def get_start_node_from_node(self, node: BaseNode) -> BaseNode | None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_start_node_from_node(self, node)
+
+    def get_prev_node(self, node: BaseNode) -> BaseNode | None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        return GriptapeNodes.FlowManager().get_prev_node(self, node)

griptape_nodes/exe_types/node_types.py

@@ -65,6 +65,9 @@ class BaseNode(ABC):
     stop_flow: bool = False
     root_ui_element: BaseNodeElement
     _tracked_parameters: list[BaseNodeElement]
+    _entry_control_parameter: Parameter | None = (
+        None  # The control input parameter used to enter this node during execution
+    )
 
     @property
     def parameters(self) -> list[Parameter]:
@@ -92,6 +95,7 @@ class BaseNode(ABC):
         self.root_ui_element._node_context = self
         self.process_generator = None
         self._tracked_parameters = []
+        self.set_entry_control_parameter(None)
 
     # This is gross and we need to have a universal pass on resolution state changes and emission of events. That's what this ticket does!
     # https://github.com/griptape-ai/griptape-nodes/issues/994
@@ -106,6 +110,18 @@ class BaseNode(ABC):
                 )
             )
         self.state = NodeResolutionState.UNRESOLVED
+        # NOTE: _entry_control_parameter is NOT cleared here as it represents execution context
+        # that should persist through the resolve/unresolve cycle during a single execution
+
+    def set_entry_control_parameter(self, parameter: Parameter | None) -> None:
+        """Set the control parameter that was used to enter this node.
+
+        This should only be called by the ControlFlowContext during execution.
+
+        Args:
+            parameter: The control input parameter that triggered this node's execution, or None to clear
+        """
+        self._entry_control_parameter = parameter
 
     def emit_parameter_changes(self) -> None:
         if self._tracked_parameters:
@@ -577,7 +593,7 @@ class BaseNode(ABC):
 
         def _flatten(items: Iterable[Any]) -> Generator[Any, None, None]:
             for item in items:
-                if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
+                if isinstance(item, Iterable) and not isinstance(item, (str, bytes, dict)):
                     yield from _flatten(item)
                 elif item:
                     yield item

griptape_nodes/machines/control_flow.py

@@ -2,10 +2,12 @@
 from __future__ import annotations
 
 import logging
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from griptape.events import EventBus
 
+from griptape_nodes.exe_types.core_types import Parameter
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.machines.fsm import FSM, State
@@ -17,6 +19,15 @@ from griptape_nodes.retained_mode.events.execution_events import (
     SelectedControlOutputEvent,
 )
 
+
+@dataclass
+class NextNodeInfo:
+    """Information about the next node to execute and how to reach it."""
+
+    node: BaseNode
+    entry_parameter: Parameter | None
+
+
 if TYPE_CHECKING:
     from griptape_nodes.exe_types.core_types import Parameter
     from griptape_nodes.exe_types.flow import ControlFlow
@@ -32,21 +43,30 @@ class ControlFlowContext:
     selected_output: Parameter | None
     paused: bool = False
 
-    def __init__(self, flow: ControlFlow) -> None:
-        self.resolution_machine = NodeResolutionMachine(flow)
-        self.flow = flow
+    def __init__(self) -> None:
+        self.resolution_machine = NodeResolutionMachine()
         self.current_node = None
 
-    def get_next_node(self, output_parameter: Parameter) -> BaseNode | None:
+    def get_next_node(self, output_parameter: Parameter) -> NextNodeInfo | None:
+        """Get the next node and the target parameter that will receive the control flow.
+
+        Returns:
+            NextNodeInfo | None: Information about the next node or None if no connection
+        """
         if self.current_node is not None:
-            node = self.flow.connections.get_connected_node(self.current_node, output_parameter)
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            node_connection = (
+                GriptapeNodes.FlowManager().get_connections().get_connected_node(self.current_node, output_parameter)
+            )
+            if node_connection is not None:
+                node, entry_parameter = node_connection
+                return NextNodeInfo(node=node, entry_parameter=entry_parameter)
+            # Continue Execution to the next node that needs to be executed using global execution queue
+            # Get the next node in the execution queue, or None if queue is empty
+            node = GriptapeNodes.FlowManager().get_next_node_from_execution_queue()
             if node is not None:
-                node, _ = node
-            # Continue Execution to the next node that needs to be executed.
-            elif not self.flow.flow_queue.empty():
-                node = self.flow.flow_queue.get()
-                self.flow.flow_queue.task_done()
-            return node
+                return NextNodeInfo(node=node, entry_parameter=None)
         return None
 
     def reset(self) -> None:
@@ -110,10 +130,11 @@ class NextNodeState(State):
             context.current_node.stop_flow = False
             return CompleteState
         next_output = context.current_node.get_next_control_output()
-        next_node = None
+        next_node_info = None
+
         if next_output is not None:
             context.selected_output = next_output
-            next_node = context.get_next_node(context.selected_output)
+            next_node_info = context.get_next_node(context.selected_output)
             EventBus.publish_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(
@@ -124,14 +145,23 @@ class NextNodeState(State):
                     )
                 )
             )
-        elif not context.flow.flow_queue.empty():
-            next_node = context.flow.flow_queue.get()
-            context.flow.flow_queue.task_done()
+        else:
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            # Get the next node in the execution queue, or None if queue is empty
+            next_node = GriptapeNodes.FlowManager().get_next_node_from_execution_queue()
+            if next_node is not None:
+                next_node_info = NextNodeInfo(node=next_node, entry_parameter=None)
+
         # The parameter that will be evaluated next
-        if next_node is None:
+        if next_node_info is None:
             # If no node attached
             return CompleteState
-        context.current_node = next_node
+
+        # Always set the entry control parameter (None for execution queue nodes)
+        next_node_info.node.set_entry_control_parameter(next_node_info.entry_parameter)
+
+        context.current_node = next_node_info.node
         context.selected_output = None
         if not context.paused:
             return ResolveNodeState
@@ -168,12 +198,14 @@ class CompleteState(State):
 
 # MACHINE TIME!!!
 class ControlFlowMachine(FSM[ControlFlowContext]):
-    def __init__(self, flow: ControlFlow) -> None:
-        context = ControlFlowContext(flow)
+    def __init__(self) -> None:
+        context = ControlFlowContext()
         super().__init__(context)
 
     def start_flow(self, start_node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002
         self._context.current_node = start_node
+        # Set entry control parameter for initial node (None for workflow start)
+        start_node.set_entry_control_parameter(None)
         # Set up to debug
         self._context.paused = debug_mode
         self.start(ResolveNodeState)  # Begins the flow