griptape-nodes 0.64.11__py3-none-any.whl → 0.65.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/model_manager.py

@@ -41,6 +41,7 @@ from griptape_nodes.retained_mode.events.model_events import (
     SearchModelsResultSuccess,
 )
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.retained_mode.managers.settings import MODELS_TO_DOWNLOAD_KEY
 from griptape_nodes.utils.async_utils import cancel_subprocess
 
 if TYPE_CHECKING:
@@ -675,9 +676,7 @@ class ModelManager:
         """
         # Get models to download from configuration
         config_manager = GriptapeNodes.ConfigManager()
-        models_to_download = config_manager.get_config_value(
-            "app_events.on_app_initialization_complete.models_to_download", default=[]
-        )
+        models_to_download = config_manager.get_config_value(MODELS_TO_DOWNLOAD_KEY, default=[])
 
         # Find unfinished downloads to resume
         unfinished_models = await asyncio.to_thread(self._find_unfinished_downloads)

griptape_nodes/retained_mode/managers/node_manager.py

@@ -4,6 +4,10 @@ import pickle
 from typing import Any, NamedTuple, cast
 from uuid import uuid4
 
+from griptape_nodes.exe_types.base_iterative_nodes import (
+    BaseIterativeEndNode,
+    BaseIterativeStartNode,
+)
 from griptape_nodes.exe_types.core_types import (
     BaseNodeElement,
     Parameter,
@@ -16,13 +20,14 @@ from griptape_nodes.exe_types.core_types import (
 )
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_types import (
+    LOCAL_EXECUTION,
+    PRIVATE_EXECUTION,
     BaseNode,
-    EndLoopNode,
     ErrorProxyNode,
     NodeDependencies,
     NodeGroupNode,
     NodeResolutionState,
-    StartLoopNode,
+    TransformedParameterValue,
 )
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.machines.sequential_resolution import SequentialResolutionMachine
@@ -105,6 +110,7 @@ from griptape_nodes.retained_mode.events.node_events import (
     ListParametersOnNodeRequest,
     ListParametersOnNodeResultFailure,
     ListParametersOnNodeResultSuccess,
+    MoveNodeToNewFlowRequest,
     RemoveNodeFromNodeGroupRequest,
     RemoveNodeFromNodeGroupResultFailure,
     RemoveNodeFromNodeGroupResultSuccess,
@@ -221,6 +227,7 @@ class NodeManager:
         )
         event_manager.assign_manager_to_request_type(DeleteNodeGroupRequest, self.on_delete_node_group_request)
         event_manager.assign_manager_to_request_type(DeleteNodeRequest, self.on_delete_node_request)
+        event_manager.assign_manager_to_request_type(MoveNodeToNewFlowRequest, self.on_move_node_to_new_flow_request)
         event_manager.assign_manager_to_request_type(
             GetNodeResolutionStateRequest, self.on_get_node_resolution_state_request
         )
@@ -438,7 +445,7 @@ class NodeManager:
             details = f"{details}. WARNING: Had to rename from original node name requested '{request.node_name}' as an object with this name already existed."
 
         # Special handling for paired classes (e.g., create a Start node and it automatically creates a corresponding End node already connected).
-        if isinstance(node, StartLoopNode) and not request.initial_setup:
+        if isinstance(node, BaseIterativeStartNode) and not request.initial_setup:
             # If it's StartLoop, create an EndLoop and connect it to the StartLoop.
             # Get the class name of the node
             node_class_name = node.__class__.__name__
@@ -477,7 +484,7 @@ class NodeManager:
                         )
                     )
                     end_node = self.get_node_by_name(end_loop.node_name)
-                    if not isinstance(end_node, EndLoopNode):
+                    if not isinstance(end_node, BaseIterativeEndNode):
                         msg = f"Attempted to create a paried set of nodes for Node '{final_node_name}'. Failed because paired node '{end_loop.node_name}' was not a proper EndLoop instance. The corresponding node will have to be created by hand and attached manually."
                         logger.error(
                             msg
@@ -533,25 +540,25 @@ class NodeManager:
         except Exception as err:
             details = f"Could not create NodeGroup '{final_node_group_name}': {err}"
             return CreateNodeGroupResultFailure(result_details=details)
-
+        # Add node to the flow so it is discoverable.
+        flow.add_node(node_group)
+        obj_mgr.add_object_by_name(node_group.name, node_group)
+        self._name_to_parent_flow_name[node_group.name] = flow_name
         if request.node_names_to_add:
             nodes_to_add = []
             for node_name in request.node_names_to_add:
                 try:
                     node = self.get_node_by_name(node_name)
+                    nodes_to_add.append(node)
                 except KeyError:
                     details = f"Attempted to add node '{node_name}' to NodeGroup '{final_node_group_name}'. Failed because node was not found."
-                    return CreateNodeGroupResultFailure(result_details=details)
-                nodes_to_add.append(node)
+                    logger.warning(details)
             # Add Nodes manually here, so we don't have to add the NodeGroup and remove it if it fails.
             try:
                 node_group.add_nodes_to_group(nodes_to_add)
-            except Exception:
-                details = f"Failed to add nodes to NodeGroup '{final_node_group_name}'."
-                return CreateNodeGroupResultFailure(result_details=details)
-        flow.add_node(node_group)
-        obj_mgr.add_object_by_name(node_group.name, node_group)
-        self._name_to_parent_flow_name[node_group.name] = flow_name
+            except Exception as err:
+                msg = f"Failed to add nodes to NodeGroup '{final_node_group_name}': {err}"
+                logger.warning(msg)
         if request.flow_name is None:
             details = (
                 f"Successfully created NodeGroup '{final_node_group_name}' in the Current Context (Flow '{flow_name}')"
@@ -766,6 +773,9 @@ class NodeManager:
                 details = f"Attempted to delete NodeGroup '{request.node_group_name}'. Failed to remove nodes from group: {err}"
                 return DeleteNodeGroupResultFailure(result_details=details)
 
+        # Get the subflow name before deleting the NodeGroup
+        subflow_name = node_group.metadata.get("subflow_name")
+
         # Now delete the NodeGroup node itself
         delete_node_request = DeleteNodeRequest(node_name=request.node_group_name)
         delete_result = self.on_delete_node_request(delete_node_request)
@@ -774,6 +784,17 @@ class NodeManager:
             details = f"Attempted to delete NodeGroup '{request.node_group_name}'. Failed to delete the NodeGroup node: {delete_result.result_details}"
             return DeleteNodeGroupResultFailure(result_details=details)
 
+        # Delete the subflow last if it exists
+        if subflow_name is not None:
+            from griptape_nodes.retained_mode.events.flow_events import DeleteFlowRequest
+
+            delete_flow_request = DeleteFlowRequest(flow_name=subflow_name)
+            delete_flow_result = GriptapeNodes.handle_request(delete_flow_request)
+
+            if delete_flow_result.failed():
+                details = f"Attempted to delete NodeGroup '{request.node_group_name}'. Failed to delete subflow '{subflow_name}': {delete_flow_result.result_details}"
+                return DeleteNodeGroupResultFailure(result_details=details)
+
         details = f"Successfully deleted NodeGroup '{request.node_group_name}'"
         return DeleteNodeGroupResultSuccess(result_details=ResultDetails(message=details, level=logging.DEBUG))
 
@@ -812,7 +833,7 @@ class NodeManager:
                     if control_node in connected_nodes:
                         result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
                         cancelled = True
-                        if not result.succeeded():
+                        if result.failed():
                             details = f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
                             return DeleteNodeResultFailure(result_details=details)
             if resolving_node_names is not None and not cancelled:
@@ -820,7 +841,7 @@ class NodeManager:
                     resolving_node = GriptapeNodes.ObjectManager().get_object_by_name(resolving_node_name)
                     if resolving_node in connected_nodes:
                         result = GriptapeNodes.handle_request(CancelFlowRequest(flow_name=parent_flow_name))
-                        if not result.succeeded():
+                        if result.failed():
                             details = f"Attempted to delete a Node '{node.name}'. Failed because running flow could not cancel."
                             return DeleteNodeResultFailure(result_details=details)
                         break  # Only need to cancel once
@@ -828,7 +849,7 @@ class NodeManager:
             parent_flow.clear_execution_queue()
         return None
 
-    def on_delete_node_request(self, request: DeleteNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912 (complex logic, lots of edge cases)
+    def on_delete_node_request(self, request: DeleteNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915 (Complex logic, lots of edge cases)
         node_name = request.node_name
         node = None
         if node_name is None:
@@ -905,6 +926,13 @@ class NodeManager:
                         )
                         return DeleteNodeResultFailure(result_details=details)
 
+        # Check if it's in a node group
+        if isinstance(node.parent_group, NodeGroupNode):
+            try:
+                node.parent_group.delete_nodes_from_group([node])
+            except ValueError as e:
+                details = f"Attempted to delete a Node '{node_name}'. Failed to remove it from the node group: {e}"
+                return DeleteNodeResultFailure(result_details=details)
         # Remove from the owning Flow
         parent_flow.remove_node(node.name)
 
@@ -919,6 +947,74 @@ class NodeManager:
         details = f"Successfully deleted Node '{node_name}'."
         return DeleteNodeResultSuccess(result_details=details)
 
+    def on_move_node_to_new_flow_request(self, request: MoveNodeToNewFlowRequest) -> ResultPayload:  # noqa: PLR0911
+        """Move a node from one flow to another flow.
+
+        Args:
+            request: MoveNodeToNewFlowRequest containing node_name, target_flow_name, source_flow_name
+
+        Returns:
+            MoveNodeToNewFlowResultSuccess or MoveNodeToNewFlowResultFailure
+        """
+        from griptape_nodes.retained_mode.events.node_events import (
+            MoveNodeToNewFlowResultFailure,
+            MoveNodeToNewFlowResultSuccess,
+        )
+
+        node_name = request.node_name
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = (
+                    "Attempted to move a Node from the Current Context. Failed because the Current Context is empty."
+                )
+                return MoveNodeToNewFlowResultFailure(result_details=details)
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(node_name, BaseNode)
+        if node is None:
+            details = f"Attempted to move Node '{node_name}', but no such Node was found."
+            return MoveNodeToNewFlowResultFailure(result_details=details)
+
+        if not request.target_flow_name:
+            details = f"Attempted to move Node '{node_name}'. Failed because target_flow_name is required."
+            return MoveNodeToNewFlowResultFailure(result_details=details)
+
+        source_flow_name = request.source_flow_name
+        if source_flow_name is None:
+            if node_name not in self._name_to_parent_flow_name:
+                details = f"Attempted to move Node '{node_name}'. Failed because Node has no parent flow."
+                return MoveNodeToNewFlowResultFailure(result_details=details)
+            source_flow_name = self._name_to_parent_flow_name[node_name]
+
+        try:
+            source_flow = GriptapeNodes.FlowManager().get_flow_by_name(source_flow_name)
+        except KeyError:
+            details = f"Attempted to move Node '{node_name}' from Flow '{source_flow_name}'. Failed because source flow was not found."
+            return MoveNodeToNewFlowResultFailure(result_details=details)
+
+        try:
+            target_flow = GriptapeNodes.FlowManager().get_flow_by_name(request.target_flow_name)
+        except KeyError:
+            details = f"Attempted to move Node '{node_name}' to Flow '{request.target_flow_name}'. Failed because target flow was not found."
+            return MoveNodeToNewFlowResultFailure(result_details=details)
+
+        if node_name not in source_flow.nodes:
+            details = f"Attempted to move Node '{node_name}' from Flow '{source_flow_name}'. Failed because Node is not in source flow."
+            return MoveNodeToNewFlowResultFailure(result_details=details)
+
+        source_flow.remove_node(node_name)
+        target_flow.add_node(node)
+        self._name_to_parent_flow_name[node_name] = request.target_flow_name
+
+        details = f"Successfully moved Node '{node_name}' from Flow '{source_flow_name}' to Flow '{request.target_flow_name}'."
+        return MoveNodeToNewFlowResultSuccess(
+            node_name=node_name,
+            source_flow_name=source_flow_name,
+            target_flow_name=request.target_flow_name,
+            result_details=details,
+        )
+
     def on_get_node_resolution_state_request(self, request: GetNodeResolutionStateRequest) -> ResultPayload:
         node_name = request.node_name
         node = None
@@ -1974,16 +2070,31 @@ class NodeManager:
                     result = SetParameterValueResultFailure(result_details=details)
                     return result
 
+        # Store original values in temp vars before calling before_value_set
+        parameter_value = request.value
+        parameter_value_type = request.data_type
+
         # Call before_value_set hook (allows nodes to modify values and temporarily control settable state)
         try:
-            modified_value = node.before_value_set(parameter, request.value)
+            modified_value = node.before_value_set(parameter, parameter_value)
             if modified_value is not None:
-                request.value = modified_value
+                # Check if it's a TransformedParameterValue (value + type)
+                if isinstance(modified_value, TransformedParameterValue):
+                    parameter_value = modified_value.value
+                    parameter_value_type = modified_value.parameter_type
+                else:
+                    # Just a value, no type change
+                    parameter_value = modified_value
         except Exception as err:
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because before_value_set hook raised exception: {err}"
             result = SetParameterValueResultFailure(result_details=details)
             return result
 
+        # Update request with potentially transformed values
+        request.value = parameter_value
+        if parameter_value_type is not None:
+            request.data_type = parameter_value_type
+
         # Validate that parameters can be set at all (note: we want the value to be set during initial setup, but not after)
         # We skip this if it's a passthru from a connection or if we're on initial setup; those always trump settable.
         # This check comes *AFTER* before_value_set() to allow nodes to temporarily modify settable state
@@ -1991,7 +2102,7 @@ class NodeManager:
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because that Parameter was flagged as not settable."
             result = SetParameterValueResultFailure(result_details=details)
             return result
-        object_type = request.data_type if request.data_type else parameter.type
+        object_type = parameter_value_type if parameter_value_type else parameter.type
         # If the parameter is control type, we shouldn't check the value being set, since it's just a marker for which path to take, not a real value, and will likely be a string, which doesn't match ControlType.
         if parameter.type != ParameterTypeBuiltin.CONTROL_TYPE.value and not parameter.is_incoming_type_allowed(
             object_type
@@ -2357,7 +2468,7 @@ class NodeManager:
         # Validate here.
         result = self.on_validate_node_dependencies_request(ValidateNodeDependenciesRequest(node_name=node_name))
         try:
-            if not result.succeeded():
+            if result.failed():
                 details = f"Failed to resolve node '{node_name}'. Flow Validation Failed"
                 return StartFlowResultFailure(validation_exceptions=[], result_details=details)
             result = cast("ValidateNodeDependenciesResultSuccess", result)
@@ -2430,13 +2541,21 @@ class NodeManager:
         # This is our current dude.
         with GriptapeNodes.ContextManager().node(node=node):
             # Handle NodeGroupNode specially - skip library lookup entirely
+            library_used = ""
+            lookup_metadata = False
+            library_details = None
             if isinstance(node, NodeGroupNode):
                 # NodeGroupNode doesn't have a library dependency
-                library_details = None
+                execution_env = node.get_parameter_value(node.execution_environment.name)
+                if execution_env not in (LOCAL_EXECUTION, PRIVATE_EXECUTION):
+                    library_used = execution_env
+                    lookup_metadata = True
             else:
                 # Get the library and version details for regular nodes
                 library_used = node.metadata["library"]
-                # Get the library metadata so we can get the version.
+                lookup_metadata = True
+            # Get the library metadata so we can get the version.
+            if lookup_metadata:
                 library_metadata_request = GetLibraryMetadataRequest(library=library_used)
                 # Call LibraryManager directly to avoid error toasts when library is unavailable (expected for ErrorProxyNode)
                 # Per https://github.com/griptape-ai/griptape-nodes/issues/1940
@@ -2465,10 +2584,14 @@ class NodeManager:
 
             # Handle NodeGroupNode specially - emit CreateNodeGroupRequest instead
             if isinstance(node, NodeGroupNode):
+                # Remove node_names_in_group from metadata - it's redundant and will be regenerated
+                metadata_copy = copy.deepcopy(node.metadata)
+                metadata_copy.pop("node_names_in_group", None)
+
                 create_node_request = CreateNodeGroupRequest(
                     node_group_name=node_name,
                     node_names_to_add=list(node.nodes),
-                    metadata=copy.deepcopy(node.metadata),
+                    metadata=metadata_copy,
                 )
             else:
                 # For non-NodeGroupNode, library_details should always be set
@@ -2895,7 +3018,7 @@ class NodeManager:
                 target_parameter_name=connection_command.target_parameter_name,
             )
             result = GriptapeNodes.handle_request(connection_request)
-            if not result.succeeded():
+            if result.failed():
                 details = f"Failed to create a connection between {connection_request.source_node_name} and {connection_request.target_node_name}"
                 logger.warning(details)
         return DeserializeSelectedNodesFromCommandsResultSuccess(
@@ -2907,7 +3030,7 @@ class NodeManager:
         result = GriptapeNodes.handle_request(
             SerializeSelectedNodesToCommandsRequest(nodes_to_serialize=request.nodes_to_duplicate)
         )
-        if not result.succeeded():
+        if result.failed():
             details = "Failed to serialized selected nodes."
             return DuplicateSelectedNodesResultFailure(result_details=details)
         result = GriptapeNodes.handle_request(DeserializeSelectedNodesFromCommandsRequest(positions=request.positions))

griptape_nodes/retained_mode/managers/object_manager.py

@@ -118,7 +118,7 @@ class ObjectManager:
         for flow_name in flows:
             if GriptapeNodes.FlowManager().check_for_existing_running_flow():
                 result = await GriptapeNodes.ahandle_request(CancelFlowRequest(flow_name=flow_name))
-                if not result.succeeded():
+                if result.failed():
                     details = f"Attempted to clear all object state and delete everything. Failed because running flow '{flow_name}' could not cancel."
                     logger.error(details)
                     return ClearAllObjectStateResultFailure(result_details=details)
@@ -153,6 +153,8 @@ class ObjectManager:
 
         # Clear all local workflow variables
         GriptapeNodes.VariablesManager().on_clear_object_state()
+        # Clear all event suppression
+        GriptapeNodes.EventManager().clear_event_suppression()
 
         details = "Successfully cleared all object state (deleted everything)."
         return ClearAllObjectStateResultSuccess(result_details=details)

griptape_nodes/retained_mode/managers/operation_manager.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Self
 
+from griptape_nodes.retained_mode.managers.settings import EVENTS_TO_ECHO_KEY
+
 if TYPE_CHECKING:
     from types import TracebackType
 
@@ -438,7 +440,7 @@ class OperationDepthManager:
         self.payload_converter = PayloadConverter()
 
         # Ask the config manager for the list of events we want echoed.
-        config_events = config_mgr.get_config_value("app_events.events_to_echo_as_retained_mode")
+        config_events = config_mgr.get_config_value(EVENTS_TO_ECHO_KEY)
         self.events_to_echo = set(config_events)
 
     def __enter__(self) -> Self: