griptape-nodes 0.57.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -6,6 +6,7 @@ from queue import Queue
 from typing import TYPE_CHECKING, Any, NamedTuple, cast
 from uuid import uuid4
 
+from griptape_nodes.common.node_executor import NodeExecutor
 from griptape_nodes.exe_types.connections import Connections
 from griptape_nodes.exe_types.core_types import (
     Parameter,
@@ -29,6 +30,7 @@ from griptape_nodes.machines.dag_builder import DagBuilder
 from griptape_nodes.machines.parallel_resolution import ParallelResolutionMachine
 from griptape_nodes.machines.sequential_resolution import SequentialResolutionMachine
 from griptape_nodes.node_library.library_registry import LibraryNameAndVersion, LibraryRegistry
+from griptape_nodes.node_library.workflow_registry import LibraryNameAndNodeType
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionEvent,
     ExecutionGriptapeNodeEvent,
@@ -103,9 +105,14 @@ from griptape_nodes.retained_mode.events.flow_events import (
     ListNodesInFlowRequest,
     ListNodesInFlowResultFailure,
     ListNodesInFlowResultSuccess,
+    OriginalNodeParameter,
     PackageNodeAsSerializedFlowRequest,
     PackageNodeAsSerializedFlowResultFailure,
     PackageNodeAsSerializedFlowResultSuccess,
+    PackageNodesAsSerializedFlowRequest,
+    PackageNodesAsSerializedFlowResultFailure,
+    PackageNodesAsSerializedFlowResultSuccess,
+    SanitizedParameterName,
     SerializedFlowCommands,
     SerializeFlowToCommandsRequest,
     SerializeFlowToCommandsResultFailure,
@@ -177,11 +184,20 @@ class PackageNodeInfo(NamedTuple):
     package_flow_name: str
 
 
+class StartNodeIncomingDataResult(NamedTuple):
+    """Result of processing incoming data connections for a start node."""
+
+    parameter_commands: list[AddParameterToNodeRequest]
+    data_connections: list[SerializedFlowCommands.IndirectConnectionSerialization]
+    input_shape_data: WorkflowShapeNodes
+    parameter_value_commands: list[SerializedNodeCommands.IndirectSetParameterValueCommand]
+
+
 class PackagingStartNodeResult(NamedTuple):
-    """Result of creating start node commands and data connections for flow packaging."""
+    """Result of creating start node commands and connections for flow packaging."""
 
     start_node_commands: SerializedNodeCommands
-    start_to_package_data_connections: list[SerializedFlowCommands.IndirectConnectionSerialization]
+    start_to_package_connections: list[SerializedFlowCommands.IndirectConnectionSerialization]
     input_shape_data: WorkflowShapeNodes
     start_node_parameter_value_commands: list[SerializedNodeCommands.IndirectSetParameterValueCommand]
 
@@ -190,10 +206,18 @@ class PackagingEndNodeResult(NamedTuple):
     """Result of creating end node commands and data connections for flow packaging."""
 
     end_node_commands: SerializedNodeCommands
-    package_to_end_data_connections: list[SerializedFlowCommands.IndirectConnectionSerialization]
+    package_to_end_connections: list[SerializedFlowCommands.IndirectConnectionSerialization]
     output_shape_data: WorkflowShapeNodes
 
 
+class MultiNodeEndNodeResult(NamedTuple):
+    """Result of creating end node commands and parameter mappings for multi-node packaging."""
+
+    packaging_result: PackagingEndNodeResult
+    parameter_name_mappings: dict[SanitizedParameterName, OriginalNodeParameter]
+    alter_parameter_commands: list[AlterParameterDetailsRequest]
+
+
 class FlowManager:
     _name_to_parent_name: dict[str, str | None]
     _flow_to_referenced_workflow_name: dict[ControlFlow, str]
@@ -204,6 +228,7 @@ class FlowManager:
     _global_control_flow_machine: ControlFlowMachine | None
     _global_single_node_resolution: bool
     _global_dag_builder: DagBuilder
+    _node_executor: NodeExecutor
 
     def __init__(self, event_manager: EventManager) -> None:
         event_manager.assign_manager_to_request_type(CreateFlowRequest, self.on_create_flow_request)
@@ -240,6 +265,9 @@ class FlowManager:
         event_manager.assign_manager_to_request_type(
             PackageNodeAsSerializedFlowRequest, self.on_package_node_as_serialized_flow_request
         )
+        event_manager.assign_manager_to_request_type(
+            PackageNodesAsSerializedFlowRequest, self.on_package_nodes_as_serialized_flow_request
+        )
         event_manager.assign_manager_to_request_type(FlushParameterChangesRequest, self.on_flush_request)
 
         self._name_to_parent_name = {}
@@ -251,6 +279,7 @@ class FlowManager:
         self._global_control_flow_machine = None  # Track the current control flow machine
         self._global_single_node_resolution = False
         self._global_dag_builder = DagBuilder()
+        self._node_executor = NodeExecutor()
 
     @property
     def global_single_node_resolution(self) -> bool:
@@ -264,6 +293,10 @@ class FlowManager:
     def global_dag_builder(self) -> DagBuilder:
         return self._global_dag_builder
 
+    @property
+    def node_executor(self) -> NodeExecutor:
+        return self._node_executor
+
     def get_connections(self) -> Connections:
         """Get the connections instance."""
         return self._connections
@@ -1249,48 +1282,6 @@ class FlowManager:
         start_end_library_metadata = start_end_library.get_metadata()
         return start_end_library_metadata.library_version
 
-    def _analyze_package_node_connections(
-        self, package_node: BaseNode, node_name: str
-    ) -> ConnectionAnalysis | PackageNodeAsSerializedFlowResultFailure:
-        """Analyze package node connections and separate control from data connections."""
-        # Get connection details using the efficient approach
-        list_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
-        list_connections_result = GriptapeNodes.NodeManager().on_list_connections_for_node_request(
-            list_connections_request
-        )
-
-        if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
-            details = f"Attempted to analyze connections for package node '{node_name}'. Failed because connection listing failed."
-            return PackageNodeAsSerializedFlowResultFailure(result_details=details)
-
-        # Separate control connections from data connections based on package node's parameter types
-        incoming_data_connections = []
-        incoming_control_connections = []
-        for incoming_conn in list_connections_result.incoming_connections:
-            # Get the package node's parameter to check if it's a control type
-            package_param = package_node.get_parameter_by_name(incoming_conn.target_parameter_name)
-            if package_param and ParameterTypeBuiltin.CONTROL_TYPE.value in package_param.input_types:
-                incoming_control_connections.append(incoming_conn)
-            else:
-                incoming_data_connections.append(incoming_conn)
-
-        outgoing_data_connections = []
-        outgoing_control_connections = []
-        for outgoing_conn in list_connections_result.outgoing_connections:
-            # Get the package node's parameter to check if it's a control type
-            package_param = package_node.get_parameter_by_name(outgoing_conn.source_parameter_name)
-            if package_param and ParameterTypeBuiltin.CONTROL_TYPE.value == package_param.output_type:
-                outgoing_control_connections.append(outgoing_conn)
-            else:
-                outgoing_data_connections.append(outgoing_conn)
-
-        return ConnectionAnalysis(
-            incoming_data_connections=incoming_data_connections,
-            incoming_control_connections=incoming_control_connections,
-            outgoing_data_connections=outgoing_data_connections,
-            outgoing_control_connections=outgoing_control_connections,
-        )
-
     def _serialize_package_node(
         self,
         node_name: str,
@@ -1372,7 +1363,7 @@ class FlowManager:
 
         # Create parameter modification commands and connection mappings for the start node based on incoming DATA connections
         start_node_parameter_commands = []
-        start_to_package_data_connections = []
+        start_to_package_connections = []
         start_node_parameter_value_commands = []
         input_shape_data: WorkflowShapeNodes = {}
 
@@ -1437,7 +1428,7 @@ class FlowManager:
                 target_node_uuid=package_node_uuid,
                 target_parameter_name=param_name,
             )
-            start_to_package_data_connections.append(start_to_package_connection)
+            start_to_package_connections.append(start_to_package_connection)
 
         # Build complete SerializedNodeCommands for start node
         start_node_dependencies = NodeDependencies()
@@ -1452,7 +1443,7 @@ class FlowManager:
 
         return PackagingStartNodeResult(
             start_node_commands=start_node_commands,
-            start_to_package_data_connections=start_to_package_data_connections,
+            start_to_package_connections=start_to_package_connections,
             input_shape_data=input_shape_data,
             start_node_parameter_value_commands=start_node_parameter_value_commands,
         )
@@ -1488,7 +1479,7 @@ class FlowManager:
         # Process ALL package node parameters to create end node parameters and connections
         # Note: PROPERTY-only parameters are guaranteed to have OUTPUT mode after serialization
         end_node_parameter_commands = []
-        package_to_end_data_connections = []
+        package_to_end_connections = []
         output_shape_data: WorkflowShapeNodes = {}
 
         for package_param in package_node.parameters:
@@ -1531,7 +1522,7 @@ class FlowManager:
                 target_node_uuid=end_node_uuid,
                 target_parameter_name=end_param_name,
             )
-            package_to_end_data_connections.append(package_to_end_connection)
+            package_to_end_connections.append(package_to_end_connection)
 
         # Build complete SerializedNodeCommands for end node
         end_node_dependencies = NodeDependencies()
@@ -1546,54 +1537,10 @@ class FlowManager:
 
         return PackagingEndNodeResult(
             end_node_commands=end_node_commands,
-            package_to_end_data_connections=package_to_end_data_connections,
+            package_to_end_connections=package_to_end_connections,
             output_shape_data=output_shape_data,
         )
 
-    def _create_start_node_control_connection(
-        self,
-        entry_control_parameter_name: str | None,
-        start_node_uuid: SerializedNodeCommands.NodeUUID,
-        package_node_uuid: SerializedNodeCommands.NodeUUID,
-        package_node: BaseNode,
-    ) -> SerializedFlowCommands.IndirectConnectionSerialization | PackageNodeAsSerializedFlowResultFailure:
-        """Create control flow connection from start node to package node.
-
-        Connects the start node's first control output to the specified or first available package node control input.
-        """
-        if entry_control_parameter_name is not None:
-            # Case 1: Specific entry parameter name provided
-            package_control_input_name = entry_control_parameter_name
-        else:
-            # Case 2: Find the first available control input parameter
-            package_control_input_name = None
-            for param in package_node.parameters:
-                if ParameterTypeBuiltin.CONTROL_TYPE.value in param.input_types:
-                    package_control_input_name = param.name
-                    logger.warning(
-                        "No entry_control_parameter_name specified for packaging node '%s'. "
-                        "Using first available control input parameter: '%s'",
-                        package_node.name,
-                        package_control_input_name,
-                    )
-                    break
-
-            if package_control_input_name is None:
-                details = f"Attempted to package node '{package_node.name}'. Failed because no control input parameters found on the node, so cannot create control flow connection."
-                return PackageNodeAsSerializedFlowResultFailure(result_details=details)
-
-        # StartNode always has a control output parameter with name "exec_out"
-        source_control_parameter_name = "exec_out"
-
-        # Create the connection
-        control_connection = SerializedFlowCommands.IndirectConnectionSerialization(
-            source_node_uuid=start_node_uuid,
-            source_parameter_name=source_control_parameter_name,
-            target_node_uuid=package_node_uuid,
-            target_parameter_name=package_control_input_name,
-        )
-        return control_connection
-
     def _assemble_serialized_flow(  # noqa: PLR0913
         self,
         serialized_package_result: SerializeNodeToCommandsResultSuccess,
@@ -1607,8 +1554,8 @@ class FlowManager:
         """Assemble the complete SerializedFlowCommands from all components."""
         # Combine all connections: Start->Package + Package->End + Control Flow
         all_connections = (
-            start_node_result.start_to_package_data_connections
-            + end_node_result.package_to_end_data_connections
+            start_node_result.start_to_package_connections
+            + end_node_result.package_to_end_connections
             + control_flow_connections
         )
 
@@ -1650,6 +1597,11 @@ class FlowManager:
         )
         packaged_dependencies.libraries.add(start_end_library_dependency)
 
+        # Aggregate node types used
+        packaged_node_types_used = self._aggregate_node_types_used(
+            serialized_node_commands=all_serialized_nodes, sub_flows_commands=[]
+        )
+
         # Build the complete SerializedFlowCommands
         return SerializedFlowCommands(
             flow_initialization_command=create_packaged_flow_request,
@@ -1663,153 +1615,1198 @@ class FlowManager:
             set_lock_commands_per_node=set_lock_commands_per_node,
             sub_flows_commands=[],
             node_dependencies=packaged_dependencies,
+            node_types_used=packaged_node_types_used,
         )
 
-    async def on_start_flow_request(self, request: StartFlowRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
-        # which flow
-        flow_name = request.flow_name
-        if not flow_name:
-            details = "Must provide flow name to start a flow."
+    def on_package_nodes_as_serialized_flow_request(  # noqa: C901, PLR0911
+        self, request: PackageNodesAsSerializedFlowRequest
+    ) -> ResultPayload:
+        """Handle request to package multiple nodes as a serialized flow.
 
-            return StartFlowResultFailure(validation_exceptions=[], result_details=details)
-        # get the flow by ID
-        try:
-            flow = self.get_flow_by_name(flow_name)
-        except KeyError as err:
-            details = f"Cannot start flow. Error: {err}"
-            return StartFlowResultFailure(validation_exceptions=[err], result_details=details)
-        # Check to see if the flow is already running.
-        if self.check_for_existing_running_flow():
-            details = "Cannot start flow. Flow is already running."
-            return StartFlowResultFailure(validation_exceptions=[], result_details=details)
-        # A node has been provided to either start or to run up to.
-        if request.flow_node_name:
-            flow_node_name = request.flow_node_name
-            flow_node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(flow_node_name, BaseNode)
-            if not flow_node:
-                details = f"Provided node with name {flow_node_name} does not exist"
-                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
-            # lets get the first control node in the flow!
-            start_node = self.get_start_node_from_node(flow, flow_node)
-            # if the start is not the node provided, set a breakpoint at the stop (we're running up until there)
-            if not start_node:
-                details = f"Start node for node with name {flow_node_name} does not exist"
-                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
-            if start_node != flow_node:
-                flow_node.stop_flow = True
-        else:
-            # we wont hit this if we dont have a request id, our requests always have nodes
-            # If there is a request, reinitialize the queue
-            self.get_start_node_queue()  # initialize the start flow queue!
-            start_node = None
-        # Run Validation before starting a flow
-        result = await self.on_validate_flow_dependencies_request(
-            ValidateFlowDependenciesRequest(flow_name=flow_name, flow_node_name=start_node.name if start_node else None)
-        )
-        try:
-            if not result.succeeded():
-                details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed"
-                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
-            result = cast("ValidateFlowDependenciesResultSuccess", result)
+        Creates a self-contained flow with Start → [Selected Nodes] → End structure,
+        where artificial start/end nodes interface with external connections only.
+        """
+        # Step 1: Reject empty node list
+        if not request.node_names:
+            return PackageNodesAsSerializedFlowResultFailure(
+                result_details="Attempted to package nodes as serialized flow. Failed because no nodes were specified in the node_names list."
+            )
 
-            if not result.validation_succeeded:
-                details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed."
-                if len(result.exceptions) > 0:
-                    for exception in result.exceptions:
-                        details = f"{details}\n\t{exception}"
-                return StartFlowResultFailure(validation_exceptions=result.exceptions, result_details=details)
-        except Exception as e:
-            details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed: {e}"
-            return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
-        # By now, it has been validated with no exceptions.
-        try:
-            await self.start_flow(flow, start_node, debug_mode=request.debug_mode)
-        except Exception as e:
-            details = f"Failed to kick off flow with name {flow_name}. Exception occurred: {e} "
-            return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
+        # Step 2: Validate library and get version
+        library_version = self._validate_and_get_multi_node_library_info(request=request)
+        if isinstance(library_version, PackageNodesAsSerializedFlowResultFailure):
+            return library_version
 
-        details = f"Successfully kicked off flow with name {flow_name}"
+        # Step 3: Validate all nodes exist
+        validation_result = self._validate_multi_node_request(request)
+        if validation_result is not None:
+            return validation_result
 
-        return StartFlowResultSuccess(result_details=details)
+        # Get the actual node objects for processing
+        nodes_to_package = []
+        for node_name in request.node_names:
+            node = GriptapeNodes.NodeManager().get_node_by_name(node_name)
+            nodes_to_package.append(node)
 
-    def on_get_flow_state_request(self, event: GetFlowStateRequest) -> ResultPayload:
-        flow_name = event.flow_name
-        if not flow_name:
-            details = "Could not get flow state. No flow name was provided."
-            return GetFlowStateResultFailure(result_details=details)
-        try:
-            flow = self.get_flow_by_name(flow_name)
-        except KeyError as err:
-            details = f"Could not get flow state. Error: {err}"
-            return GetFlowStateResultFailure(result_details=details)
-        try:
-            control_nodes, resolving_nodes = self.flow_state(flow)
-        except Exception as e:
-            details = f"Failed to get flow state of flow with name {flow_name}. Exception occurred: {e} "
-            logger.exception(details)
-            return GetFlowStateResultFailure(result_details=details)
-        details = f"Successfully got flow state for flow with name {flow_name}."
-        return GetFlowStateResultSuccess(
-            control_nodes=control_nodes,
-            resolving_node=resolving_nodes,
-            result_details=details,
+        # Step 4: Initialize tracking variables and mappings (moved up so package node serialization can use them)
+        unique_parameter_uuid_to_values = {}
+        serialized_parameter_value_tracker = SerializedParameterValueTracker()
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID] = {}
+        packaged_nodes_set_parameter_value_commands: dict[
+            SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
+        ] = {}
+        packaged_nodes_internal_connections: list[SerializedFlowCommands.IndirectConnectionSerialization] = []
+
+        # Step 5: Serialize nodes with local execution environment to prevent recursive loops
+        serialized_package_nodes = self._serialize_package_nodes_for_local_execution(
+            nodes_to_package=nodes_to_package,
+            unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+            serialized_parameter_value_tracker=serialized_parameter_value_tracker,
+            node_name_to_uuid=node_name_to_uuid,
+            set_parameter_value_commands=packaged_nodes_set_parameter_value_commands,
+            internal_connections=packaged_nodes_internal_connections,
+        )
+        if isinstance(serialized_package_nodes, PackageNodesAsSerializedFlowResultFailure):
+            return serialized_package_nodes
+
+        # Step 6: Inject OUTPUT mode changes for PROPERTY-only parameters to enable value reconciliation after the
+        # packaged workflow is run.
+        # Example: Nodes A -> B -> C. If B has property-only parameters, those values may change during execution,
+        # so we need to send the value back after the packaged flow has run. We do this by making connections from
+        # B's property-only parameters to the End Node, ensuring they're reflected when the packaged flow returns.
+        # Since connections require an OUTPUT parameter mode, we inject that here.
+        self._inject_output_mode_for_property_parameters(nodes_to_package, serialized_package_nodes)
+
+        # Step 7: Analyze external connections (connections from/to nodes outside our selection)
+        node_connections_dict = self._analyze_multi_node_external_connections(package_nodes=nodes_to_package)
+        if isinstance(node_connections_dict, PackageNodesAsSerializedFlowResultFailure):
+            return node_connections_dict
+
+        # Step 8: Create start node with parameters for external incoming connections
+        start_node_result = self._create_multi_node_start_node_with_connections(
+            request=request,
+            library_version=library_version,
+            unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+            serialized_parameter_value_tracker=serialized_parameter_value_tracker,
+            node_name_to_uuid=node_name_to_uuid,
+            external_connections_dict=node_connections_dict,
         )
+        if isinstance(start_node_result, PackageNodesAsSerializedFlowResultFailure):
+            return start_node_result
 
-    def on_cancel_flow_request(self, request: CancelFlowRequest) -> ResultPayload:
-        flow_name = request.flow_name
-        if not flow_name:
-            details = "Could not cancel flow execution. No flow name was provided."
+        # Step 9: Create end node with parameters for external outgoing connections and parameter mappings
+        end_node_result = self._create_multi_node_end_node_with_connections(
+            request=request,
+            package_nodes=nodes_to_package,
+            node_name_to_uuid=node_name_to_uuid,
+            library_version=library_version,
+            node_connections_dict=node_connections_dict,
+        )
+        if isinstance(end_node_result, PackageNodesAsSerializedFlowResultFailure):
+            return end_node_result
 
-            return CancelFlowResultFailure(result_details=details)
-        try:
-            self.get_flow_by_name(flow_name)
-        except KeyError as err:
-            details = f"Could not cancel flow execution. Error: {err}"
+        end_node_packaging_result = end_node_result.packaging_result
+        parameter_name_mappings = end_node_result.parameter_name_mappings
 
-            return CancelFlowResultFailure(result_details=details)
-        try:
-            self.cancel_flow_run()
-        except Exception as e:
-            details = f"Could not cancel flow execution. Exception: {e}"
+        # Step 10: Assemble final SerializedFlowCommands
+        # Collect all connections from start/end nodes and internal package connections
+        all_connections = self._collect_all_connections_for_multi_node_package(
+            start_node_result=start_node_result,
+            end_node_packaging_result=end_node_packaging_result,
+            packaged_nodes_internal_connections=packaged_nodes_internal_connections,
+        )
 
-            return CancelFlowResultFailure(result_details=details)
-        details = f"Successfully cancelled flow execution with name {flow_name}"
+        # Build WorkflowShape from collected parameter shape data
+        workflow_shape = GriptapeNodes.WorkflowManager().build_workflow_shape_from_parameter_info(
+            input_node_params=start_node_result.input_shape_data,
+            output_node_params=end_node_packaging_result.output_shape_data,
+        )
 
-        return CancelFlowResultSuccess(result_details=details)
+        # Create set parameter value commands dict
+        set_parameter_value_commands = {
+            start_node_result.start_node_commands.node_uuid: start_node_result.start_node_parameter_value_commands,
+            **packaged_nodes_set_parameter_value_commands,
+        }
 
-    async def on_single_node_step_request(self, request: SingleNodeStepRequest) -> ResultPayload:
-        flow_name = request.flow_name
-        if not flow_name:
-            details = "Could not advance to the next step of a running workflow. No flow name was provided."
+        # Collect all serialized nodes
+        all_serialized_nodes = [
+            start_node_result.start_node_commands,
+            *serialized_package_nodes,
+            end_node_packaging_result.end_node_commands,
+        ]
 
-            return SingleNodeStepResultFailure(validation_exceptions=[], result_details=details)
-        try:
-            self.get_flow_by_name(flow_name)
-        except KeyError as err:
-            details = f"Could not advance to the next step of a running workflow. No flow with name {flow_name} exists. Error: {err}"
+        # Create comprehensive dependencies from all nodes
+        combined_dependencies = NodeDependencies()
+        for serialized_node in all_serialized_nodes:
+            combined_dependencies.aggregate_from(serialized_node.node_dependencies)
 
-            return SingleNodeStepResultFailure(validation_exceptions=[err], result_details=details)
-        try:
-            flow = self.get_flow_by_name(flow_name)
-            await self.single_node_step(flow)
-        except Exception as e:
-            details = f"Could not advance to the next step of a running workflow. Exception: {e}"
-            return SingleNodeStepResultFailure(validation_exceptions=[], result_details=details)
+        # Extract lock commands from serialized nodes (they're embedded in SerializedNodeCommands)
+        set_lock_commands_per_node = {}
+        for serialized_node in all_serialized_nodes:
+            if serialized_node.lock_node_command:
+                set_lock_commands_per_node[serialized_node.node_uuid] = serialized_node.lock_node_command
 
-        # All completed happily
-        details = f"Successfully advanced to the next step of a running workflow with name {flow_name}"
+        # Create a CreateFlowRequest for the packaged flow so that it can
+        # run as a standalone workflow
+        packaged_flow_metadata = {}  # Keep it simple until we have reason to populate it
 
-        return SingleNodeStepResultSuccess(result_details=details)
+        create_packaged_flow_request = CreateFlowRequest(
+            parent_flow_name=None,  # Standalone flow
+            set_as_new_context=False,  # Let deserializer decide
+            metadata=packaged_flow_metadata,
+        )
 
-    async def on_single_execution_step_request(self, request: SingleExecutionStepRequest) -> ResultPayload:
-        flow_name = request.flow_name
-        if not flow_name:
-            details = "Could not advance to the next step of a running workflow. No flow name was provided."
+        # Aggregate node types used
+        combined_node_types_used = self._aggregate_node_types_used(
+            serialized_node_commands=all_serialized_nodes, sub_flows_commands=[]
+        )
 
-            return SingleExecutionStepResultFailure(result_details=details)
-        try:
-            flow = self.get_flow_by_name(flow_name)
-        except KeyError as err:
+        # Build the complete serialized flow
+        final_serialized_flow = SerializedFlowCommands(
+            flow_initialization_command=create_packaged_flow_request,
+            serialized_node_commands=all_serialized_nodes,
+            serialized_connections=all_connections,
+            unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+            set_parameter_value_commands=set_parameter_value_commands,
+            set_lock_commands_per_node=set_lock_commands_per_node,
+            sub_flows_commands=[],
+            node_dependencies=combined_dependencies,
+            node_types_used=combined_node_types_used,
+        )
+
+        return PackageNodesAsSerializedFlowResultSuccess(
+            serialized_flow_commands=final_serialized_flow,
+            workflow_shape=workflow_shape,
+            packaged_node_names=request.node_names,
+            parameter_name_mappings=parameter_name_mappings,
+            result_details=f"Successfully packaged {len(request.node_names)} nodes as serialized flow.",
+        )
+
+    def _validate_and_get_multi_node_library_info(
+        self, request: PackageNodesAsSerializedFlowRequest
+    ) -> str | PackageNodesAsSerializedFlowResultFailure:
+        """Validate start/end node types exist in library and return library version."""
+        # Early validation - ensure both start and end node types exist in the specified library
+        try:
+            start_end_library = LibraryRegistry.get_library_for_node_type(
+                node_type=request.start_node_type, specific_library_name=request.start_end_specific_library_name
+            )
+        except KeyError as err:
+            details = f"Attempted to package nodes with start node type '{request.start_node_type}' from library '{request.start_end_specific_library_name}'. Failed because start node type was not found in library. Error: {err}."
+            return PackageNodesAsSerializedFlowResultFailure(result_details=details)
+
+        try:
+            LibraryRegistry.get_library_for_node_type(
+                node_type=request.end_node_type, specific_library_name=request.start_end_specific_library_name
+            )
+        except KeyError as err:
+            details = f"Attempted to package nodes with end node type '{request.end_node_type}' from library '{request.start_end_specific_library_name}'. Failed because end node type was not found in library. Error: {err}."
+            return PackageNodesAsSerializedFlowResultFailure(result_details=details)
+
+        # Get the actual library version
+        start_end_library_metadata = start_end_library.get_metadata()
+        return start_end_library_metadata.library_version
+
+    def _validate_multi_node_request(
+        self, request: PackageNodesAsSerializedFlowRequest
+    ) -> None | PackageNodesAsSerializedFlowResultFailure:
+        """Validate that all requested nodes exist and control flow configuration is valid."""
+        # Validate all nodes exist
+        missing_nodes = []
+        for node_name in request.node_names:
+            try:
+                GriptapeNodes.NodeManager().get_node_by_name(node_name)
+            except Exception:
+                missing_nodes.append(node_name)
+
+        if missing_nodes:
+            return PackageNodesAsSerializedFlowResultFailure(
+                result_details=f"Attempted to package nodes as serialized flow. Failed because the following nodes were not found: {', '.join(missing_nodes)}."
+            )
+
+        # Validate control flow configuration for non-empty node lists
+        if request.node_names and request.entry_control_parameter_name and not request.entry_control_node_name:
+            return PackageNodesAsSerializedFlowResultFailure(
+                result_details="Attempted to package nodes as serialized flow. Failed because entry_control_parameter_name was specified but entry_control_node_name was not. For multi-node packaging with a non-empty node list, both must be specified to avoid ambiguity about which node should receive the control connection."
+            )
+
+        # Validate entry_control_node_name exists and is in our package list
+        if request.entry_control_node_name and request.entry_control_node_name not in request.node_names:
+            return PackageNodesAsSerializedFlowResultFailure(
+                result_details=f"Attempted to package nodes as serialized flow. Failed because entry_control_node_name '{request.entry_control_node_name}' is not in the list of nodes to package: {request.node_names}."
+            )
+
+        return None
+
+    def _serialize_package_nodes_for_local_execution(  # noqa: C901, PLR0913
+        self,
+        nodes_to_package: list[BaseNode],
+        unique_parameter_uuid_to_values: dict[SerializedNodeCommands.UniqueParameterValueUUID, Any],
+        serialized_parameter_value_tracker: SerializedParameterValueTracker,
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],  # OUTPUT: will be populated
+        set_parameter_value_commands: dict[  # OUTPUT: will be populated
+            SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
+        ],
+        internal_connections: list[SerializedFlowCommands.IndirectConnectionSerialization],  # OUTPUT: will be populated
+    ) -> list[SerializedNodeCommands] | PackageNodesAsSerializedFlowResultFailure:
+        """Serialize package nodes while temporarily setting execution environment to local to prevent recursive loops.
+
+        This method temporarily overrides each node's execution_environment parameter to LOCAL_EXECUTION
+        during serialization, then restores the original values. This prevents recursive packaging loops
+        that could occur if nodes were configured for remote execution environments.
+
+        Args:
+            nodes_to_package: List of nodes to serialize
+            unique_parameter_uuid_to_values: Shared dictionary for deduplicating parameter values across all nodes
+            serialized_parameter_value_tracker: Tracker for serialized parameter values
+            node_name_to_uuid: OUTPUT - Dictionary mapping node names to UUIDs (populated by this method)
+            set_parameter_value_commands: OUTPUT - Dict mapping node UUIDs to parameter value commands (populated by this method)
+            internal_connections: OUTPUT - List of connections between package nodes (populated by this method)
+
+        Returns:
+            List of SerializedNodeCommands on success, or PackageNodesAsSerializedFlowResultFailure on failure
+        """
+        # Intercept execution_environment for all nodes before serialization
+        original_execution_environments = {}
+        for node in nodes_to_package:
+            original_value = node.get_parameter_value("execution_environment")
+            original_execution_environments[node.name] = original_value
+            node.set_parameter_value("execution_environment", LOCAL_EXECUTION)
+
+        try:
+            # Serialize each node using shared unique_parameter_uuid_to_values dictionary for deduplication
+            serialized_node_commands = []
+
+            for node in nodes_to_package:
+                # Serialize this node using shared dictionaries for value deduplication
+                serialize_request = SerializeNodeToCommandsRequest(
+                    node_name=node.name,
+                    unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+                    serialized_parameter_value_tracker=serialized_parameter_value_tracker,
+                )
+                serialize_result = GriptapeNodes.NodeManager().on_serialize_node_to_commands(serialize_request)
+
+                if not isinstance(serialize_result, SerializeNodeToCommandsResultSuccess):
+                    return PackageNodesAsSerializedFlowResultFailure(
+                        result_details=f"Attempted to package nodes as serialized flow. Failed to serialize node '{node.name}': {serialize_result.result_details}"
+                    )
+
+                # Collect serialized node
+                serialized_node_commands.append(serialize_result.serialized_node_commands)
+
+                # Populate the shared node_name_to_uuid mapping
+                if serialize_result.serialized_node_commands.create_node_command.node_name is not None:
+                    node_name_to_uuid[serialize_result.serialized_node_commands.create_node_command.node_name] = (
+                        serialize_result.serialized_node_commands.node_uuid
+                    )
+
+                # Collect set parameter value commands (references to unique_parameter_uuid_to_values)
+                if serialize_result.set_parameter_value_commands:
+                    set_parameter_value_commands[serialize_result.serialized_node_commands.node_uuid] = (
+                        serialize_result.set_parameter_value_commands
+                    )
+
+            # Build internal connections between package nodes
+            package_node_names_set = {n.name for n in nodes_to_package}
+            for node in nodes_to_package:
+                # Get connections FROM this node TO other nodes in the package
+                list_connections_request = ListConnectionsForNodeRequest(node_name=node.name)
+                list_connections_result = GriptapeNodes.NodeManager().on_list_connections_for_node_request(
+                    list_connections_request
+                )
+
+                if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+                    return PackageNodesAsSerializedFlowResultFailure(
+                        result_details=f"Attempted to package nodes as serialized flow. Failed to list connections for node '{node.name}': {list_connections_result.result_details}"
+                    )
+
+                # Only include connections where BOTH source and target are in the package
+                for outgoing_conn in list_connections_result.outgoing_connections:
+                    if outgoing_conn.target_node_name in package_node_names_set:
+                        source_uuid = node_name_to_uuid[node.name]
+                        target_uuid = node_name_to_uuid[outgoing_conn.target_node_name]
+                        internal_connections.append(
+                            SerializedFlowCommands.IndirectConnectionSerialization(
+                                source_node_uuid=source_uuid,
+                                source_parameter_name=outgoing_conn.source_parameter_name,
+                                target_node_uuid=target_uuid,
+                                target_parameter_name=outgoing_conn.target_parameter_name,
+                            )
+                        )
+        finally:
+            # Always restore original execution_environment values, even on failure
+            for node_name, original_value in original_execution_environments.items():
+                restore_node = GriptapeNodes.NodeManager().get_node_by_name(node_name)
+                restore_node.set_parameter_value("execution_environment", original_value)
+
+        return serialized_node_commands
+
+    def _inject_output_mode_for_property_parameters(
+        self, nodes_to_package: list[BaseNode], serialized_package_nodes: list[SerializedNodeCommands]
+    ) -> None:
+        """Inject OUTPUT mode for PROPERTY-only parameters to enable value reconciliation.
+
+        This method adds ALTER parameter commands to serialized nodes for parameters that have
+        PROPERTY mode but not OUTPUT mode. This allows the orchestrator/caller to reconcile
+        the packaged node's values after execution.
+
+        Args:
+            nodes_to_package: List of nodes being packaged
+            serialized_package_nodes: The serialized node commands to modify
+        """
+        # Apply ALTER parameter commands for PROPERTY-only parameters to enable OUTPUT mode
+        # We need these to emit their values back so that the orchestrator/caller
+        # can reconcile the packaged node's values after it is executed.
+        for package_node in nodes_to_package:
+            # Find the corresponding serialized node
+            serialized_node = None
+            for serialized_node_command in serialized_package_nodes:
+                if serialized_node_command.create_node_command.node_name == package_node.name:
+                    serialized_node = serialized_node_command
+                    break
+
+            if serialized_node is None:
+                error_msg = f"Data integrity error: Could not find serialized node for package node '{package_node.name}'. This indicates a logic error in the serialization process."
+                logger.error(error_msg)
+                raise RuntimeError(error_msg)
+
+            package_alter_parameter_commands = []
+            for package_param in package_node.parameters:
+                has_output_mode = ParameterMode.OUTPUT in package_param.allowed_modes
+                has_property_mode = ParameterMode.PROPERTY in package_param.allowed_modes
+                # If has PROPERTY but not OUTPUT, add ALTER command to enable OUTPUT
+                if has_property_mode and not has_output_mode:
+                    alter_param_request = AlterParameterDetailsRequest(
+                        parameter_name=package_param.name,
+                        node_name=package_node.name,
+                        mode_allowed_output=True,
+                    )
+                    package_alter_parameter_commands.append(alter_param_request)
+
+            # If we have alter parameter commands, append them to the existing element_modification_commands
+            if package_alter_parameter_commands:
+                serialized_node.element_modification_commands.extend(package_alter_parameter_commands)
+
+    def _analyze_multi_node_external_connections(
+        self, package_nodes: list[BaseNode]
+    ) -> dict[str, ConnectionAnalysis] | PackageNodesAsSerializedFlowResultFailure:
+        """Analyze external connections for each package node using filtered single-node analysis.
+
+        This method reuses the existing single-node connection analysis method but applies filtering
+        to only capture "external" connections - those that cross the package boundary.
+
+        External connections are:
+        - Incoming connections where the source node is NOT in the package
+        - Outgoing connections where the target node is NOT in the package
+
+        Internal connections (between nodes within the package) are filtered out by passing
+        the set of package node names to the single-node analysis method.
+
+        Args:
+            package_nodes: List of nodes being packaged together
+
+        Returns:
+            Dictionary mapping node_name -> ConnectionAnalysis, where each ConnectionAnalysis
+            contains only the external connections for that node, or failure result on error
+        """
+        package_node_names_set = {node.name for node in package_nodes}
+        node_connections = {}
+
+        for package_node in package_nodes:
+            # Perform a single node analysis, filtering out internal connections
+            connection_analysis = self._analyze_package_node_connections(
+                package_node=package_node,
+                node_name=package_node.name,
+                package_node_names=package_node_names_set,
+            )
+            if isinstance(connection_analysis, PackageNodeAsSerializedFlowResultFailure):
+                return PackageNodesAsSerializedFlowResultFailure(result_details=connection_analysis.result_details)
+
+            node_connections[package_node.name] = connection_analysis
+
+        return node_connections
+
+    def _analyze_package_node_connections(
+        self, package_node: BaseNode, node_name: str, package_node_names: set[str] | None = None
+    ) -> ConnectionAnalysis | PackageNodeAsSerializedFlowResultFailure:
+        """Analyze package node connections and separate control from data connections."""
+        # Get connection details using the efficient approach
+        list_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
+        list_connections_result = GriptapeNodes.NodeManager().on_list_connections_for_node_request(
+            list_connections_request
+        )
+
+        if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+            details = f"Attempted to analyze connections for package node '{node_name}'. Failed because connection listing failed."
+            return PackageNodeAsSerializedFlowResultFailure(result_details=details)
+
+        # Separate control connections from data connections based on package node's parameter types
+        incoming_data_connections = []
+        incoming_control_connections = []
+        for incoming_conn in list_connections_result.incoming_connections:
+            # Filter out internal connections if package_node_names is provided
+            if package_node_names is not None and incoming_conn.source_node_name in package_node_names:
+                continue
+
+            # Get the package node's parameter to check if it's a control type
+            package_param = package_node.get_parameter_by_name(incoming_conn.target_parameter_name)
+            if package_param and ParameterTypeBuiltin.CONTROL_TYPE.value in package_param.input_types:
+                incoming_control_connections.append(incoming_conn)
+            else:
+                incoming_data_connections.append(incoming_conn)
+
+        outgoing_data_connections = []
+        outgoing_control_connections = []
+        for outgoing_conn in list_connections_result.outgoing_connections:
+            # Filter out internal connections if package_node_names is provided
+            if package_node_names is not None and outgoing_conn.target_node_name in package_node_names:
+                continue
+
+            # Get the package node's parameter to check if it's a control type
+            package_param = package_node.get_parameter_by_name(outgoing_conn.source_parameter_name)
+            if package_param and ParameterTypeBuiltin.CONTROL_TYPE.value == package_param.output_type:
+                outgoing_control_connections.append(outgoing_conn)
+            else:
+                outgoing_data_connections.append(outgoing_conn)
+
+        return ConnectionAnalysis(
+            incoming_data_connections=incoming_data_connections,
+            incoming_control_connections=incoming_control_connections,
+            outgoing_data_connections=outgoing_data_connections,
+            outgoing_control_connections=outgoing_control_connections,
+        )
+
+    def _create_multi_node_end_node_with_connections(
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        package_nodes: list[BaseNode],
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],
+        library_version: str,
+        node_connections_dict: dict[str, ConnectionAnalysis],
+    ) -> MultiNodeEndNodeResult | PackageNodesAsSerializedFlowResultFailure:
+        """Create end node commands and connections for ALL package parameters that meet criteria (copied from single-node)."""
+        # Generate UUID and name for end node
+        end_node_uuid = SerializedNodeCommands.NodeUUID(str(uuid4()))
+        end_node_name = "End_Multi_Package"
+
+        # Build end node CreateNodeRequest
+        end_create_node_command = CreateNodeRequest(
+            node_type=request.end_node_type,
+            specific_library_name=request.start_end_specific_library_name,
+            node_name=end_node_name,
+            metadata={},
+            initial_setup=True,
+            create_error_proxy_on_failure=False,
+        )
+
+        # Create library details
+        end_node_library_details = LibraryNameAndVersion(
+            library_name=request.start_end_specific_library_name,
+            library_version=library_version,
+        )
+
+        # Initialize collections for building the end node
+        end_node_parameter_commands = []
+        package_to_end_connections = []
+        output_shape_data: WorkflowShapeNodes = {}
+        # Parameter name mappings (rosetta stone): maps mangled end node parameter names back to original (node_name, parameter_name)
+        # This is essential for callers to understand which end node outputs correspond to which original node parameters
+        parameter_name_mappings: dict[SanitizedParameterName, OriginalNodeParameter] = {}
+
+        # Handle external control connections first
+        self._create_end_node_control_connections(
+            request=request,
+            package_nodes=package_nodes,
+            node_connections_dict=node_connections_dict,
+            node_name_to_uuid=node_name_to_uuid,
+            end_node_uuid=end_node_uuid,
+            end_node_name=end_node_name,
+            end_node_parameter_commands=end_node_parameter_commands,
+            package_to_end_connections=package_to_end_connections,
+            parameter_name_mappings=parameter_name_mappings,
+            output_shape_data=output_shape_data,
+        )
+
+        # Process ALL parameters with OUTPUT or PROPERTY modes for comprehensive coverage
+        self._create_end_node_data_parameters_and_connections(
+            request=request,
+            package_nodes=package_nodes,
+            node_name_to_uuid=node_name_to_uuid,
+            end_node_uuid=end_node_uuid,
+            end_node_name=end_node_name,
+            end_node_parameter_commands=end_node_parameter_commands,
+            package_to_end_connections=package_to_end_connections,
+            parameter_name_mappings=parameter_name_mappings,
+            output_shape_data=output_shape_data,
+        )
+
+        # Build complete SerializedNodeCommands for end node
+        end_node_dependencies = NodeDependencies()
+        end_node_dependencies.libraries.add(end_node_library_details)
+
+        end_node_commands = SerializedNodeCommands(
+            create_node_command=end_create_node_command,
+            element_modification_commands=end_node_parameter_commands,
+            node_dependencies=end_node_dependencies,
+            node_uuid=end_node_uuid,
+        )
+
+        end_node_result = PackagingEndNodeResult(
+            end_node_commands=end_node_commands,
+            package_to_end_connections=package_to_end_connections,
+            output_shape_data=output_shape_data,
+        )
+
+        return MultiNodeEndNodeResult(
+            packaging_result=end_node_result,
+            parameter_name_mappings=parameter_name_mappings,
+            alter_parameter_commands=[],
+        )
+
+    def _create_end_node_control_connections(  # noqa: PLR0913
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        package_nodes: list[BaseNode],
+        node_connections_dict: dict[str, ConnectionAnalysis],  # Contains only EXTERNAL connections
+        node_name_to_uuid: dict[
+            str, SerializedNodeCommands.NodeUUID
+        ],  # Map node names to UUIDs for connection creation
+        end_node_uuid: SerializedNodeCommands.NodeUUID,
+        end_node_name: str,
+        end_node_parameter_commands: list[
+            AddParameterToNodeRequest
+        ],  # OUTPUT: Will populate with parameters to add to end node
+        package_to_end_connections: list[
+            SerializedFlowCommands.IndirectConnectionSerialization
+        ],  # OUTPUT: Will populate with connections to add
+        parameter_name_mappings: dict[
+            SanitizedParameterName, OriginalNodeParameter
+        ],  # OUTPUT: Will populate rosetta stone for parameter names so customer knows how to map mangled names back to original nodes.
+        output_shape_data: WorkflowShapeNodes,  # OUTPUT: Will populate with workflow shape data
+    ) -> None:
+        """Create control connections and parameters on end node for EXTERNAL control flow connections."""
+        for package_node in package_nodes:
+            node_connection_analysis = node_connections_dict.get(package_node.name)
+            if node_connection_analysis is None:
+                # This node has no external connections (neither incoming nor outgoing), skip it
+                continue
+
+            # Handle external outgoing control connections
+            for control_conn in node_connection_analysis.outgoing_control_connections:
+                # Get the source parameter for validation and processing
+                source_param = package_node.get_parameter_by_name(control_conn.source_parameter_name)
+                if source_param is None:
+                    msg = f"External control connection references parameter '{control_conn.source_parameter_name}' on node '{package_node.name}' which does not exist. This indicates a data consistency issue."
+                    raise ValueError(msg)
+
+                # Use comprehensive helper to process this control parameter
+                self._process_parameter_for_end_node(
+                    request=request,
+                    parameter=source_param,
+                    node_name=package_node.name,
+                    node_uuid=node_name_to_uuid[package_node.name],
+                    end_node_name=end_node_name,
+                    end_node_uuid=end_node_uuid,
+                    tooltip=f"Control output {control_conn.source_parameter_name} from packaged node {package_node.name}",
+                    end_node_parameter_commands=end_node_parameter_commands,
+                    package_to_end_connections=package_to_end_connections,
+                    parameter_name_mappings=parameter_name_mappings,
+                    output_shape_data=output_shape_data,
+                )
+
+    def _create_end_node_data_parameters_and_connections(  # noqa: PLR0913
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        package_nodes: list[BaseNode],
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],
+        end_node_uuid: SerializedNodeCommands.NodeUUID,
+        end_node_name: str,
+        end_node_parameter_commands: list[
+            AddParameterToNodeRequest
+        ],  # OUTPUT: Will populate with parameters to add to end node
+        package_to_end_connections: list[
+            SerializedFlowCommands.IndirectConnectionSerialization
+        ],  # OUTPUT: Will populate with connections to add
+        parameter_name_mappings: dict[
+            SanitizedParameterName, OriginalNodeParameter
+        ],  # OUTPUT: Will populate rosetta stone for parameter names
+        output_shape_data: WorkflowShapeNodes,  # OUTPUT: Will populate with workflow shape data
+    ) -> None:
+        """Create data parameters and connections on end node for all OUTPUT/PROPERTY parameters from packaged nodes."""
+        for package_node in package_nodes:
+            package_node_uuid = node_name_to_uuid[package_node.name]
+
+            for package_param in package_node.parameters:
+                # Only process parameters with OUTPUT or PROPERTY mode
+                has_output_mode = ParameterMode.OUTPUT in package_param.allowed_modes
+                has_property_mode = ParameterMode.PROPERTY in package_param.allowed_modes
+
+                if not has_output_mode and not has_property_mode:
+                    continue
+
+                # Skip control parameters - those are handled by the control connections helper
+                if package_param.output_type == ParameterTypeBuiltin.CONTROL_TYPE.value:
+                    continue
+
+                # Use comprehensive helper to process this data parameter
+                self._process_parameter_for_end_node(
+                    request=request,
+                    parameter=package_param,
+                    node_name=package_node.name,
+                    node_uuid=package_node_uuid,
+                    end_node_name=end_node_name,
+                    end_node_uuid=end_node_uuid,
+                    tooltip=f"Output parameter {package_param.name} from packaged node {package_node.name}",
+                    end_node_parameter_commands=end_node_parameter_commands,
+                    package_to_end_connections=package_to_end_connections,
+                    parameter_name_mappings=parameter_name_mappings,
+                    output_shape_data=output_shape_data,
+                )
+
+    def _process_parameter_for_end_node(  # noqa: PLR0913
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        parameter: Parameter,
+        node_name: str,
+        node_uuid: SerializedNodeCommands.NodeUUID,
+        end_node_name: str,
+        end_node_uuid: SerializedNodeCommands.NodeUUID,
+        tooltip: str,
+        end_node_parameter_commands: list[
+            AddParameterToNodeRequest
+        ],  # OUTPUT: Will populate with parameters to add to end node
+        package_to_end_connections: list[
+            SerializedFlowCommands.IndirectConnectionSerialization
+        ],  # OUTPUT: Will populate with connections to add
+        parameter_name_mappings: dict[
+            SanitizedParameterName, OriginalNodeParameter
+        ],  # OUTPUT: Will populate rosetta stone for parameter names
+        output_shape_data: WorkflowShapeNodes,  # OUTPUT: Will populate with workflow shape data
+    ) -> None:
+        """Process a single parameter for inclusion in the end node, handling all aspects of parameter creation and connection."""
+        # Create sanitized parameter name with collision avoidance
+        sanitized_param_name = self._generate_sanitized_parameter_name(
+            prefix=request.output_parameter_prefix,
+            node_name=node_name,
+            parameter_name=parameter.name,
+        )
+
+        # Build parameter name mapping for rosetta stone
+        parameter_name_mappings[sanitized_param_name] = OriginalNodeParameter(
+            node_name=node_name,
+            parameter_name=parameter.name,
+        )
+
+        # Extract parameter shape info for workflow shape (outputs to external consumers)
+        param_shape_info = GriptapeNodes.WorkflowManager().extract_parameter_shape_info(
+            parameter, include_control_params=True
+        )
+        if param_shape_info is not None:
+            if end_node_name not in output_shape_data:
+                output_shape_data[end_node_name] = {}
+            output_shape_data[end_node_name][sanitized_param_name] = param_shape_info
+
+        # Create parameter command for end node
+        add_param_request = AddParameterToNodeRequest(
+            node_name=end_node_name,
+            parameter_name=sanitized_param_name,
+            type=parameter.output_type,
+            default_value=None,
+            tooltip=tooltip,
+            initial_setup=True,
+        )
+        end_node_parameter_commands.append(add_param_request)
+
+        # Create connection from package node to end node
+        package_to_end_connection = SerializedFlowCommands.IndirectConnectionSerialization(
+            source_node_uuid=node_uuid,
+            source_parameter_name=parameter.name,
+            target_node_uuid=end_node_uuid,
+            target_parameter_name=sanitized_param_name,
+        )
+        package_to_end_connections.append(package_to_end_connection)
+
+    def _create_multi_node_start_node_with_connections(  # noqa: PLR0913
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        library_version: str,
+        unique_parameter_uuid_to_values: dict[SerializedNodeCommands.UniqueParameterValueUUID, Any],
+        serialized_parameter_value_tracker: SerializedParameterValueTracker,
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],
+        external_connections_dict: dict[
+            str, ConnectionAnalysis
+        ],  # Contains EXTERNAL connections only - used to determine which parameters need start node inputs
+    ) -> PackagingStartNodeResult | PackageNodesAsSerializedFlowResultFailure:
+        """Create start node commands and connections for external incoming connections."""
+        # Generate UUID and name for start node
+        start_node_uuid = SerializedNodeCommands.NodeUUID(str(uuid4()))
+        start_node_name = "Start_Package_MultiNode"
+
+        # Build start node CreateNodeRequest
+        start_create_node_command = CreateNodeRequest(
+            node_type=request.start_node_type,
+            specific_library_name=request.start_end_specific_library_name,
+            node_name=start_node_name,
+            metadata={},
+            initial_setup=True,
+            create_error_proxy_on_failure=False,
+        )
+
+        # Create library details
+        start_node_library_details = LibraryNameAndVersion(
+            library_name=request.start_end_specific_library_name,
+            library_version=library_version,
+        )
+
+        # Create parameter modification commands and connection mappings for the start node
+        start_node_parameter_commands = []
+        start_to_package_connections = []
+        start_node_parameter_value_commands = []
+        input_shape_data: WorkflowShapeNodes = {}
+
+        # Iterate through all EXTERNAL, INCOMING, DATA connections.
+        # We will then, for each connection:
+        #  1. Generate a mangled name
+        #  2. Add parameter with the mangled name for each connection source on the Start Node object
+        #  3. Extract the value from the source node and have it assigned to the Start Node so that it can be propagated
+        #  4. Create a connection from the Start Node to the package node
+        for target_node_name, connection_analysis in external_connections_dict.items():
+            result = self._create_start_node_parameters_and_connections_for_incoming_data(
+                target_node_name=target_node_name,
+                incoming_data_connections=connection_analysis.incoming_data_connections,
+                output_parameter_prefix=request.output_parameter_prefix,
+                start_node_name=start_node_name,
+                start_node_uuid=start_node_uuid,
+                start_create_node_command=start_create_node_command,
+                node_name_to_uuid=node_name_to_uuid,
+                unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+                serialized_parameter_value_tracker=serialized_parameter_value_tracker,
+            )
+            if isinstance(result, PackageNodesAsSerializedFlowResultFailure):
+                return result
+
+            # Accumulate results from helper
+            start_node_parameter_commands.extend(result.parameter_commands)
+            start_to_package_connections.extend(result.data_connections)
+            start_node_parameter_value_commands.extend(result.parameter_value_commands)
+            # Merge input shape data
+            for node_name, params in result.input_shape_data.items():
+                if node_name not in input_shape_data:
+                    input_shape_data[node_name] = {}
+                input_shape_data[node_name].update(params)
+
+        # Create all control connections
+        control_connections = self._create_start_node_control_connections(
+            request=request,
+            start_node_uuid=start_node_uuid,
+            node_name_to_uuid=node_name_to_uuid,
+        )
+        if isinstance(control_connections, PackageNodesAsSerializedFlowResultFailure):
+            return control_connections
+
+        # Add control connections to the same list as data connections
+        start_to_package_connections.extend(control_connections)
+
+        # Build complete SerializedNodeCommands for start node
+        start_node_dependencies = NodeDependencies()
+        start_node_dependencies.libraries.add(start_node_library_details)
+
+        start_node_commands = SerializedNodeCommands(
+            create_node_command=start_create_node_command,
+            element_modification_commands=start_node_parameter_commands,
+            node_dependencies=start_node_dependencies,
+            node_uuid=start_node_uuid,
+        )
+
+        return PackagingStartNodeResult(
+            start_node_commands=start_node_commands,
+            start_to_package_connections=start_to_package_connections,
+            input_shape_data=input_shape_data,
+            start_node_parameter_value_commands=start_node_parameter_value_commands,
+        )
+
+    def _create_start_node_parameters_and_connections_for_incoming_data(  # noqa: PLR0913
+        self,
+        target_node_name: str,
+        incoming_data_connections: list[IncomingConnection],
+        output_parameter_prefix: str,
+        start_node_name: str,
+        start_node_uuid: SerializedNodeCommands.NodeUUID,
+        start_create_node_command: CreateNodeRequest,
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],
+        unique_parameter_uuid_to_values: dict[SerializedNodeCommands.UniqueParameterValueUUID, Any],
+        serialized_parameter_value_tracker: SerializedParameterValueTracker,
+    ) -> StartNodeIncomingDataResult | PackageNodesAsSerializedFlowResultFailure:
+        """Create parameters and connections for incoming data connections to a specific target node."""
+        start_node_parameter_commands = []
+        start_to_package_connections = []
+        start_node_parameter_value_commands = []
+        input_shape_data: WorkflowShapeNodes = {}
+
+        for connection in incoming_data_connections:
+            target_parameter_name = connection.target_parameter_name
+
+            # Create sanitized parameter name with prefix + node + parameter
+            param_name = self._generate_sanitized_parameter_name(
+                prefix=output_parameter_prefix,
+                node_name=target_node_name,
+                parameter_name=target_parameter_name,
+            )
+
+            # Get the source node to determine parameter type (from the external connection)
+            try:
+                source_node = GriptapeNodes.NodeManager().get_node_by_name(connection.source_node_name)
+            except ValueError as err:
+                details = f"Attempted to package nodes as serialized flow. Failed because source node '{connection.source_node_name}' from incoming connection could not be found. Error: {err}."
+                return PackageNodesAsSerializedFlowResultFailure(result_details=details)
+
+            # Get the source parameter
+            source_param = source_node.get_parameter_by_name(connection.source_parameter_name)
+            if not source_param:
+                details = f"Attempted to package nodes as serialized flow. Failed because source parameter '{connection.source_parameter_name}' on node '{connection.source_node_name}' from incoming connection could not be found."
+                return PackageNodesAsSerializedFlowResultFailure(result_details=details)
+
+            # Extract parameter shape info for workflow shape (inputs from external sources)
+            param_shape_info = GriptapeNodes.WorkflowManager().extract_parameter_shape_info(
+                source_param, include_control_params=True
+            )
+            if param_shape_info is not None:
+                if start_node_name not in input_shape_data:
+                    input_shape_data[start_node_name] = {}
+                input_shape_data[start_node_name][param_name] = param_shape_info
+
+            # Extract parameter value from source node to set on start node
+            param_value_commands = GriptapeNodes.NodeManager().handle_parameter_value_saving(
+                parameter=source_param,
+                node=source_node,
+                unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
+                serialized_parameter_value_tracker=serialized_parameter_value_tracker,
+                create_node_request=start_create_node_command,
+            )
+            if param_value_commands is not None:
+                # Modify each command to target the start node parameter instead
+                for param_value_command in param_value_commands:
+                    param_value_command.set_parameter_value_command.node_name = start_node_name
+                    param_value_command.set_parameter_value_command.parameter_name = param_name
+                    start_node_parameter_value_commands.append(param_value_command)
+
+            # Create parameter command for start node (following single-node pattern exactly)
+            add_param_request = AddParameterToNodeRequest(
+                node_name=start_node_name,
+                parameter_name=param_name,
+                type=source_param.output_type,
+                default_value=None,
+                tooltip=f"Parameter {target_parameter_name} from node {target_node_name} in packaged flow",
+                initial_setup=True,
+            )
+            start_node_parameter_commands.append(add_param_request)
+
+            # Get target node UUID from mapping
+            target_node_uuid = node_name_to_uuid.get(target_node_name)
+            if target_node_uuid is None:
+                details = f"Attempted to package nodes as serialized flow. Failed because target node '{target_node_name}' UUID not found in mapping."
+                return PackageNodesAsSerializedFlowResultFailure(result_details=details)
+
+            # Create connection from start node to target node
+            start_to_package_connections.append(
+                SerializedFlowCommands.IndirectConnectionSerialization(
+                    source_node_uuid=start_node_uuid,
+                    source_parameter_name=param_name,
+                    target_node_uuid=target_node_uuid,
+                    target_parameter_name=target_parameter_name,
+                )
+            )
+
+        return StartNodeIncomingDataResult(
+            parameter_commands=start_node_parameter_commands,
+            data_connections=start_to_package_connections,
+            input_shape_data=input_shape_data,
+            parameter_value_commands=start_node_parameter_value_commands,
+        )
+
+    def _create_start_node_control_connections(
+        self,
+        request: PackageNodesAsSerializedFlowRequest,
+        start_node_uuid: SerializedNodeCommands.NodeUUID,
+        node_name_to_uuid: dict[str, SerializedNodeCommands.NodeUUID],
+    ) -> list[SerializedFlowCommands.IndirectConnectionSerialization] | PackageNodesAsSerializedFlowResultFailure:
+        """Create control connection from start node to entry control node.
+
+        Args:
+            request: The packaging request with control flow configuration
+            start_node_uuid: UUID of the start node
+            node_name_to_uuid: Mapping of node names to UUIDs for lookup
+
+        Returns:
+            List of control connections or failure result
+        """
+        control_connections = []
+
+        # Connect start node to specified entry control node (if specified)
+        if request.entry_control_node_name:
+            # Get the entry node (already validated to exist)
+            entry_node = GriptapeNodes.NodeManager().get_node_by_name(request.entry_control_node_name)
+            entry_node_uuid = node_name_to_uuid[request.entry_control_node_name]
+
+            # Connect start node to specified entry control node
+            control_connection_result = self._create_start_node_control_connection(
+                entry_control_parameter_name=request.entry_control_parameter_name,
+                start_node_uuid=start_node_uuid,
+                package_node_uuid=entry_node_uuid,
+                package_node=entry_node,
+            )
+            if isinstance(control_connection_result, PackageNodeAsSerializedFlowResultFailure):
+                return PackageNodesAsSerializedFlowResultFailure(
+                    result_details=control_connection_result.result_details
+                )
+
+            control_connections.append(control_connection_result)
+
+        return control_connections
+
+    def _create_start_node_control_connection(
+        self,
+        entry_control_parameter_name: str | None,
+        start_node_uuid: SerializedNodeCommands.NodeUUID,
+        package_node_uuid: SerializedNodeCommands.NodeUUID,
+        package_node: BaseNode,
+    ) -> SerializedFlowCommands.IndirectConnectionSerialization | PackageNodeAsSerializedFlowResultFailure:
+        """Create control flow connection from start node to package node.
+
+        Connects the start node's first control output to the specified or first available package node control input.
+        """
+        if entry_control_parameter_name is not None:
+            # Case 1: Specific entry parameter name provided
+            package_control_input_name = entry_control_parameter_name
+        else:
+            # Case 2: Find the first available control input parameter
+            package_control_input_name = None
+            for param in package_node.parameters:
+                if ParameterTypeBuiltin.CONTROL_TYPE.value in param.input_types:
+                    package_control_input_name = param.name
+                    logger.warning(
+                        "No entry_control_parameter_name specified for packaging node '%s'. "
+                        "Using first available control input parameter: '%s'",
+                        package_node.name,
+                        package_control_input_name,
+                    )
+                    break
+
+            if package_control_input_name is None:
+                details = f"Attempted to package node '{package_node.name}'. Failed because no control input parameters found on the node, so cannot create control flow connection."
+                return PackageNodeAsSerializedFlowResultFailure(result_details=details)
+
+        # StartNode always has a control output parameter with name "exec_out"
+        source_control_parameter_name = "exec_out"
+
+        # Create the connection
+        control_connection = SerializedFlowCommands.IndirectConnectionSerialization(
+            source_node_uuid=start_node_uuid,
+            source_parameter_name=source_control_parameter_name,
+            target_node_uuid=package_node_uuid,
+            target_parameter_name=package_control_input_name,
+        )
+        return control_connection
+
+    def _collect_all_connections_for_multi_node_package(
+        self,
+        start_node_result: PackagingStartNodeResult,
+        end_node_packaging_result: PackagingEndNodeResult,
+        packaged_nodes_internal_connections: list[SerializedFlowCommands.IndirectConnectionSerialization],
+    ) -> list[SerializedFlowCommands.IndirectConnectionSerialization]:
+        """Collect all connections for the multi-node packaged flow.
+
+        Returns a list containing:
+        1. Start node connections (data + control)
+        2. End node connections (data)
+        3. Internal package node connections
+
+        Args:
+            start_node_result: Result containing start node and its connections
+            end_node_packaging_result: Result containing end node and its connections
+            packaged_nodes_internal_connections: Internal connections between package nodes
+
+        Returns:
+            List of all connections for the packaged flow
+        """
+        all_connections = []
+
+        # Add start and end node connections
+        all_connections.extend(start_node_result.start_to_package_connections)
+        all_connections.extend(end_node_packaging_result.package_to_end_connections)
+
+        # Add internal package node connections
+        all_connections.extend(packaged_nodes_internal_connections)
+
+        return all_connections
+
+    def _generate_sanitized_parameter_name(self, prefix: str, node_name: str, parameter_name: str) -> str:
+        """Generate a sanitized parameter name for multi-node packaging.
+
+        Creates a parameter name in the format: prefix + sanitized_node_name + _ + parameter_name
+        Node names are sanitized by replacing spaces and dots with underscores.
+
+        Args:
+            prefix: Prefix for the parameter name (e.g., "packaged_node_")
+            node_name: Original node name (may contain spaces, dots, etc.)
+            parameter_name: Original parameter name
+
+        Returns:
+            Sanitized parameter name safe for use (e.g., "packaged_node_Merge_Texts_merge_string")
+        """
+        sanitized_node_name = node_name.replace(" ", "_").replace(".", "_")
+        return f"{prefix}{sanitized_node_name}_{parameter_name}"
+
+    async def on_start_flow_request(self, request: StartFlowRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
+        # which flow
+        flow_name = request.flow_name
+        if not flow_name:
+            details = "Must provide flow name to start a flow."
+
+            return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+        # get the flow by ID
+        try:
+            flow = self.get_flow_by_name(flow_name)
+        except KeyError as err:
+            details = f"Cannot start flow. Error: {err}"
+            return StartFlowResultFailure(validation_exceptions=[err], result_details=details)
+        # Check to see if the flow is already running.
+        if self.check_for_existing_running_flow():
+            details = "Cannot start flow. Flow is already running."
+            return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+        # A node has been provided to either start or to run up to.
+        if request.flow_node_name:
+            flow_node_name = request.flow_node_name
+            flow_node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(flow_node_name, BaseNode)
+            if not flow_node:
+                details = f"Provided node with name {flow_node_name} does not exist"
+                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+            # lets get the first control node in the flow!
+            start_node = self.get_start_node_from_node(flow, flow_node)
+            # if the start is not the node provided, set a breakpoint at the stop (we're running up until there)
+            if not start_node:
+                details = f"Start node for node with name {flow_node_name} does not exist"
+                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+            if start_node != flow_node:
+                flow_node.stop_flow = True
+        else:
+            # we wont hit this if we dont have a request id, our requests always have nodes
+            # If there is a request, reinitialize the queue
+            self.get_start_node_queue()  # initialize the start flow queue!
+            start_node = None
+        # Run Validation before starting a flow
+        result = await self.on_validate_flow_dependencies_request(
+            ValidateFlowDependenciesRequest(flow_name=flow_name, flow_node_name=start_node.name if start_node else None)
+        )
+        try:
+            if not result.succeeded():
+                details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed"
+                return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+            result = cast("ValidateFlowDependenciesResultSuccess", result)
+
+            if not result.validation_succeeded:
+                details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed."
+                if len(result.exceptions) > 0:
+                    for exception in result.exceptions:
+                        details = f"{details}\n\t{exception}"
+                return StartFlowResultFailure(validation_exceptions=result.exceptions, result_details=details)
+        except Exception as e:
+            details = f"Couldn't start flow with name {flow_name}. Flow Validation Failed: {e}"
+            return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
+        # By now, it has been validated with no exceptions.
+        try:
+            await self.start_flow(
+                flow,
+                start_node,
+                debug_mode=request.debug_mode,
+                pickle_control_flow_result=request.pickle_control_flow_result,
+            )
+        except Exception as e:
+            details = f"Failed to kick off flow with name {flow_name}. Exception occurred: {e} "
+            return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
+
+        details = f"Successfully kicked off flow with name {flow_name}"
+
+        return StartFlowResultSuccess(result_details=details)
+
+    def on_get_flow_state_request(self, event: GetFlowStateRequest) -> ResultPayload:
+        flow_name = event.flow_name
+        if not flow_name:
+            details = "Could not get flow state. No flow name was provided."
+            return GetFlowStateResultFailure(result_details=details)
+        try:
+            flow = self.get_flow_by_name(flow_name)
+        except KeyError as err:
+            details = f"Could not get flow state. Error: {err}"
+            return GetFlowStateResultFailure(result_details=details)
+        try:
+            control_nodes, resolving_nodes = self.flow_state(flow)
+        except Exception as e:
+            details = f"Failed to get flow state of flow with name {flow_name}. Exception occurred: {e} "
+            logger.exception(details)
+            return GetFlowStateResultFailure(result_details=details)
+        details = f"Successfully got flow state for flow with name {flow_name}."
+        return GetFlowStateResultSuccess(
+            control_nodes=control_nodes,
+            resolving_node=resolving_nodes,
+            result_details=details,
+        )
+
+    async def on_cancel_flow_request(self, request: CancelFlowRequest) -> ResultPayload:
+        flow_name = request.flow_name
+        if not flow_name:
+            details = "Could not cancel flow execution. No flow name was provided."
+
+            return CancelFlowResultFailure(result_details=details)
+        try:
+            self.get_flow_by_name(flow_name)
+        except KeyError as err:
+            details = f"Could not cancel flow execution. Error: {err}"
+
+            return CancelFlowResultFailure(result_details=details)
+        try:
+            await self.cancel_flow_run()
+        except Exception as e:
+            details = f"Could not cancel flow execution. Exception: {e}"
+
+            return CancelFlowResultFailure(result_details=details)
+        details = f"Successfully cancelled flow execution with name {flow_name}"
+
+        return CancelFlowResultSuccess(result_details=details)
+
+    async def on_single_node_step_request(self, request: SingleNodeStepRequest) -> ResultPayload:
+        flow_name = request.flow_name
+        if not flow_name:
+            details = "Could not advance to the next step of a running workflow. No flow name was provided."
+
+            return SingleNodeStepResultFailure(validation_exceptions=[], result_details=details)
+        try:
+            self.get_flow_by_name(flow_name)
+        except KeyError as err:
+            details = f"Could not advance to the next step of a running workflow. No flow with name {flow_name} exists. Error: {err}"
+
+            return SingleNodeStepResultFailure(validation_exceptions=[err], result_details=details)
+        try:
+            flow = self.get_flow_by_name(flow_name)
+            await self.single_node_step(flow)
+        except Exception as e:
+            details = f"Could not advance to the next step of a running workflow. Exception: {e}"
+            return SingleNodeStepResultFailure(validation_exceptions=[], result_details=details)
+
+        # All completed happily
+        details = f"Successfully advanced to the next step of a running workflow with name {flow_name}"
+
+        return SingleNodeStepResultSuccess(result_details=details)
+
+    async def on_single_execution_step_request(self, request: SingleExecutionStepRequest) -> ResultPayload:
+        flow_name = request.flow_name
+        if not flow_name:
+            details = "Could not advance to the next step of a running workflow. No flow name was provided."
+
+            return SingleExecutionStepResultFailure(result_details=details)
+        try:
+            flow = self.get_flow_by_name(flow_name)
+        except KeyError as err:
             details = f"Could not advance to the next step of a running workflow. Error: {err}."
 
             return SingleExecutionStepResultFailure(result_details=details)
@@ -1820,7 +2817,7 @@ class FlowManager:
             # We REALLY don't want to fail here, else we'll take the whole engine down
             try:
                 if self.check_for_existing_running_flow():
-                    self.cancel_flow_run()
+                    await self.cancel_flow_run()
             except Exception as e_inner:
                 details = f"Could not cancel flow execution. Exception: {e_inner}"
 
@@ -1941,6 +2938,38 @@ class FlowManager:
 
         return aggregated_deps
 
+    def _aggregate_node_types_used(
+        self, serialized_node_commands: list[SerializedNodeCommands], sub_flows_commands: list[SerializedFlowCommands]
+    ) -> set[LibraryNameAndNodeType]:
+        """Aggregate node types used from nodes and sub-flows.
+
+        Args:
+            serialized_node_commands: List of serialized node commands to aggregate from
+            sub_flows_commands: List of sub-flow commands to aggregate from
+
+        Returns:
+            Set of LibraryNameAndNodeType with all node types used
+
+        Raises:
+            ValueError: If a node command has no library name specified
+        """
+        node_types_used: set[LibraryNameAndNodeType] = set()
+
+        # Collect node types from all nodes in this flow
+        for node_cmd in serialized_node_commands:
+            node_type = node_cmd.create_node_command.node_type
+            library_name = node_cmd.create_node_command.specific_library_name
+            if library_name is None:
+                msg = f"Node type '{node_type}' has no library name specified during serialization"
+                raise ValueError(msg)
+            node_types_used.add(LibraryNameAndNodeType(library_name=library_name, node_type=node_type))
+
+        # Aggregate node types from all sub-flows
+        for sub_flow_cmd in sub_flows_commands:
+            node_types_used.update(sub_flow_cmd.node_types_used)
+
+        return node_types_used
+
     # TODO: https://github.com/griptape-ai/griptape-nodes/issues/861
     # similar manager refactors: https://github.com/griptape-ai/griptape-nodes/issues/806
     def on_serialize_flow_to_commands(self, request: SerializeFlowToCommandsRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
@@ -2086,6 +3115,7 @@ class FlowManager:
                         set_lock_commands_per_node={},
                         sub_flows_commands=[],
                         node_dependencies=sub_flow_dependencies,
+                        node_types_used=set(),
                     )
                     sub_flow_commands.append(serialized_flow)
                 else:
@@ -2102,6 +3132,13 @@ class FlowManager:
         # Aggregate all dependencies from nodes and sub-flows
         aggregated_dependencies = self._aggregate_flow_dependencies(serialized_node_commands, sub_flow_commands)
 
+        # Aggregate all node types used from nodes and sub-flows
+        try:
+            aggregated_node_types_used = self._aggregate_node_types_used(serialized_node_commands, sub_flow_commands)
+        except ValueError as e:
+            details = f"Attempted to serialize Flow '{flow_name}' to commands. Failed while aggregating node types: {e}"
+            return SerializeFlowToCommandsResultFailure(result_details=details)
+
         serialized_flow = SerializedFlowCommands(
             flow_initialization_command=create_flow_request,
             serialized_node_commands=serialized_node_commands,
@@ -2111,6 +3148,7 @@ class FlowManager:
             set_lock_commands_per_node=set_lock_commands_per_node,
             sub_flows_commands=sub_flow_commands,
             node_dependencies=aggregated_dependencies,
+            node_types_used=aggregated_node_types_used,
         )
         details = f"Successfully serialized Flow '{flow_name}' into commands."
         result = SerializeFlowToCommandsResultSuccess(serialized_flow_commands=serialized_flow, result_details=details)
@@ -2258,6 +3296,7 @@ class FlowManager:
         start_node: BaseNode | None = None,
         *,
         debug_mode: bool = False,
+        pickle_control_flow_result: bool = False,
     ) -> None:
         if self.check_for_existing_running_flow():
             # If flow already exists, throw an error
@@ -2274,13 +3313,15 @@ class FlowManager:
 
         # Initialize global control flow machine and DAG builder
 
-        self._global_control_flow_machine = ControlFlowMachine(flow.name)
+        self._global_control_flow_machine = ControlFlowMachine(
+            flow.name, pickle_control_flow_result=pickle_control_flow_result
+        )
         # Set off the request here.
         try:
             await self._global_control_flow_machine.start_flow(start_node, debug_mode)
         except Exception:
             if self.check_for_existing_running_flow():
-                self.cancel_flow_run()
+                await self.cancel_flow_run()
             raise
         GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=InvolvedNodesEvent(involved_nodes=[])))
@@ -2298,11 +3339,16 @@ class FlowManager:
             and self._global_control_flow_machine.context.resolution_machine.is_started()
         )
 
-    def cancel_flow_run(self) -> None:
+    async 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._global_flow_queue.queue.clear()
+
+        # Request cancellation on all nodes and wait for them to complete
+        if self._global_control_flow_machine is not None:
+            await self._global_control_flow_machine.cancel_flow()
+
         # Reset control flow machine
         if self._global_control_flow_machine is not None:
             self._global_control_flow_machine.reset_machine(cancel=True)
@@ -2429,8 +3475,8 @@ class FlowManager:
             except Exception as e:
                 logger.exception("Exception during single node resolution")
                 if self.check_for_existing_running_flow():
-                    self.cancel_flow_run()
-                    raise RuntimeError(e) from e
+                    await self.cancel_flow_run()
+                raise RuntimeError(e) from e
             if resolution_machine.is_complete():
                 self._global_single_node_resolution = False
                 self._global_control_flow_machine.context.current_nodes = []