griptape-nodes 0.41.0__py3-none-any.whl → 0.42.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/machines/control_flow.py

@@ -32,20 +32,21 @@ 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:
         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 = GriptapeNodes.FlowManager().get_connections().get_connected_node(self.current_node, output_parameter)
             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()
+            # Continue Execution to the next node that needs to be executed using global execution queue
+            else:
+                # Get the next node in the execution queue, or None if queue is empty
+                node = GriptapeNodes.FlowManager().get_next_node_from_execution_queue()
             return node
         return None
 
@@ -124,9 +125,11 @@ 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()
         # The parameter that will be evaluated next
         if next_node is None:
             # If no node attached
@@ -168,8 +171,8 @@ 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

griptape_nodes/machines/node_resolution.py

@@ -4,7 +4,7 @@ import logging
 from collections.abc import Generator
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from griptape.events import EventBus
 from griptape.utils import with_contextvars
@@ -31,10 +31,6 @@ from griptape_nodes.retained_mode.events.parameter_events import (
     SetParameterValueRequest,
 )
 
-if TYPE_CHECKING:
-    from griptape_nodes.exe_types.flow import ControlFlow
-
-
 logger = logging.getLogger("griptape_nodes")
 
 
@@ -47,12 +43,10 @@ class Focus:
 
 # This is on a per-node basis
 class ResolutionContext:
-    flow: ControlFlow
     focus_stack: list[Focus]
     paused: bool
 
-    def __init__(self, flow: ControlFlow) -> None:
-        self.flow = flow
+    def __init__(self) -> None:
         self.focus_stack = []
         self.paused = False
 
@@ -90,7 +84,9 @@ class InitializeSpotlightState(State):
         if current_node.state == NodeResolutionState.UNRESOLVED:
             # Mark all future nodes unresolved.
             # TODO: https://github.com/griptape-ai/griptape-nodes/issues/862
-            context.flow.connections.unresolve_future_nodes(current_node)
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            GriptapeNodes.FlowManager().get_connections().unresolve_future_nodes(current_node)
             current_node.initialize_spotlight()
         # Set node to resolving - we are now resolving this node.
         current_node.state = NodeResolutionState.RESOLVING
@@ -132,7 +128,9 @@ class EvaluateParameterState(State):
     def on_update(context: ResolutionContext) -> type[State] | None:
         current_node = context.focus_stack[-1].node
         current_parameter = current_node.get_current_parameter()
-        connections = context.flow.connections
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        connections = GriptapeNodes.FlowManager().get_connections()
         if current_parameter is None:
             msg = "No current parameter set."
             raise ValueError(msg)
@@ -270,7 +268,10 @@ class ExecuteNodeState(State):
             )
             current_focus.process_generator = None
             current_focus.scheduled_value = None
-            context.flow.cancel_flow_run()
+
+            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+            GriptapeNodes.FlowManager().cancel_flow_run()
 
             EventBus.publish_event(
                 ExecutionGriptapeNodeEvent(
@@ -320,7 +321,7 @@ class ExecuteNodeState(State):
                 )
             )
             # Pass the value through to the new nodes.
-            conn_output_nodes = context.flow.get_connected_output_parameters(current_node, parameter)
+            conn_output_nodes = GriptapeNodes.FlowManager().get_connected_output_parameters(current_node, parameter)
             for target_node, target_parameter in conn_output_nodes:
                 GriptapeNodes.get_instance().handle_request(
                     SetParameterValueRequest(
@@ -416,6 +417,7 @@ class ExecuteNodeState(State):
 
                 # Once we've passed on the scheduled value, we should clear it out just in case
                 current_focus.scheduled_value = None
+
                 future = ExecuteNodeState.executor.submit(with_contextvars(func))
                 future.add_done_callback(with_contextvars(on_future_done))
             except StopIteration:
@@ -445,8 +447,8 @@ class CompleteState(State):
 class NodeResolutionMachine(FSM[ResolutionContext]):
     """State machine for resolving node dependencies."""
 
-    def __init__(self, flow: ControlFlow) -> None:
-        resolution_context = ResolutionContext(flow)  # Gets the flow
+    def __init__(self) -> None:
+        resolution_context = ResolutionContext()
         super().__init__(resolution_context)
 
     def resolve_node(self, node: BaseNode) -> None:

griptape_nodes/node_library/workflow_registry.py

@@ -13,19 +13,19 @@ from griptape_nodes.utils.metaclasses import SingletonMeta
 
 
 class WorkflowMetadata(BaseModel):
-    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.4.0"
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.6.0"
 
     name: str
     schema_version: str
     engine_version_created_with: str
     node_libraries_referenced: list[LibraryNameAndVersion]
+    workflows_referenced: list[str] | None = None
     description: str | None = None
     image: str | None = None
     is_griptape_provided: bool | None = False
     is_template: bool | None = False
     creation_date: datetime | None = Field(default=None)
     last_modified_date: datetime | None = Field(default=None)
-    published_workflow_id: str | None = Field(default=None)
 
 
 class WorkflowRegistry(metaclass=SingletonMeta):