griptape-nodes 0.60.4__py3-none-any.whl → 0.61.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -72,6 +72,9 @@ from griptape_nodes.retained_mode.events.execution_events import (
     SingleNodeStepRequest,
     SingleNodeStepResultFailure,
     SingleNodeStepResultSuccess,
+    StartFlowFromNodeRequest,
+    StartFlowFromNodeResultFailure,
+    StartFlowFromNodeResultSuccess,
     StartFlowRequest,
     StartFlowResultFailure,
     StartFlowResultSuccess,
@@ -239,6 +242,7 @@ class FlowManager:
         event_manager.assign_manager_to_request_type(CreateConnectionRequest, self.on_create_connection_request)
         event_manager.assign_manager_to_request_type(DeleteConnectionRequest, self.on_delete_connection_request)
         event_manager.assign_manager_to_request_type(StartFlowRequest, self.on_start_flow_request)
+        event_manager.assign_manager_to_request_type(StartFlowFromNodeRequest, self.on_start_flow_from_node_request)
         event_manager.assign_manager_to_request_type(SingleNodeStepRequest, self.on_single_node_step_request)
         event_manager.assign_manager_to_request_type(SingleExecutionStepRequest, self.on_single_execution_step_request)
         event_manager.assign_manager_to_request_type(
@@ -2451,6 +2455,65 @@ class FlowManager:
 
         return StartFlowResultSuccess(result_details=details)
 
+    async def on_start_flow_from_node_request(self, request: StartFlowFromNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911
+        # 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 StartFlowFromNodeResultFailure(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 StartFlowFromNodeResultFailure(validation_exceptions=[], result_details=details)
+        node_name = request.node_name
+        if node_name is None:
+            details = "Must provide node name to start a flow."
+            return StartFlowFromNodeResultFailure(validation_exceptions=[], result_details=details)
+        start_node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(node_name, BaseNode)
+        if not start_node:
+            details = f"Provided node with name {node_name} does not exist"
+            return StartFlowResultFailure(validation_exceptions=[], result_details=details)
+        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 StartFlowFromNodeResultFailure(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 StartFlowFromNodeResultFailure(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 StartFlowFromNodeResultFailure(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 StartFlowFromNodeResultFailure(validation_exceptions=[e], result_details=details)
+
+        details = f"Successfully kicked off flow with name {flow_name}"
+
+        return StartFlowFromNodeResultSuccess(result_details=details)
+
     def on_get_flow_state_request(self, event: GetFlowStateRequest) -> ResultPayload:
         flow_name = event.flow_name
         if not flow_name:

griptape_nodes/retained_mode/managers/library_manager.py

@@ -169,6 +169,7 @@ class LibraryManager:
         self._library_event_handler_mappings: dict[type[Payload], dict[str, LibraryManager.RegisteredEventHandler]] = {}
         # LibraryDirectory owns the FSMs and manages library lifecycle
         self._library_directory = LibraryDirectory()
+        self._libraries_loading_complete = asyncio.Event()
 
         event_manager.assign_manager_to_request_type(
             ListRegisteredLibrariesRequest, self.on_list_registered_libraries_request
@@ -204,7 +205,7 @@ class LibraryManager:
         )
         event_manager.assign_manager_to_request_type(GetAllInfoForLibraryRequest, self.get_all_info_for_library_request)
         event_manager.assign_manager_to_request_type(
-            GetAllInfoForAllLibrariesRequest, self.get_all_info_for_all_libraries_request
+            GetAllInfoForAllLibrariesRequest, self.on_get_all_info_for_all_libraries_request
         )
         event_manager.assign_manager_to_request_type(
             LoadMetadataForAllLibrariesRequest, self.load_metadata_for_all_libraries_request
@@ -531,13 +532,13 @@ class LibraryManager:
         sandbox_library_dir_as_posix = sandbox_library_dir.as_posix()
 
         if not sandbox_library_dir.exists():
-            details = "Sandbox directory does not exist."
+            details = "Sandbox directory does not exist. If you wish to create a Sandbox directory to develop custom nodes: in the Griptape Nodes editor, go to Settings -> Libraries and navigate to the Sandbox Settings."
             return LoadLibraryMetadataFromFileResultFailure(
                 library_path=sandbox_library_dir_as_posix,
                 library_name=LibraryManager.SANDBOX_LIBRARY_NAME,
                 status=LibraryStatus.MISSING,
                 problems=[details],
-                result_details=details,
+                result_details=ResultDetails(message=details, level=logging.INFO),
             )
 
         sandbox_node_candidates = self._find_files_in_dir(directory=sandbox_library_dir, extension=".py")
@@ -1170,6 +1171,13 @@ class LibraryManager:
         )
         return result
 
+    async def on_get_all_info_for_all_libraries_request(
+        self, request: GetAllInfoForAllLibrariesRequest
+    ) -> ResultPayload:
+        """Async handler for GetAllInfoForAllLibrariesRequest that waits for library loading to complete."""
+        await self._libraries_loading_complete.wait()
+        return await asyncio.to_thread(self.get_all_info_for_all_libraries_request, request)
+
     def get_all_info_for_library_request(self, request: GetAllInfoForLibraryRequest) -> ResultPayload:  # noqa: PLR0911
         # Does this library exist?
         try:
@@ -1500,48 +1508,53 @@ class LibraryManager:
         return node_class
 
     async def load_all_libraries_from_config(self) -> None:
-        # Load metadata for all libraries to determine which ones can be safely loaded
-        metadata_request = LoadMetadataForAllLibrariesRequest()
-        metadata_result = self.load_metadata_for_all_libraries_request(metadata_request)
-
-        # Check if metadata loading succeeded
-        if not isinstance(metadata_result, LoadMetadataForAllLibrariesResultSuccess):
-            logger.error("Failed to load metadata for all libraries, skipping library registration")
-            return
-
-        # Record all failed libraries in our tracking immediately
-        for failed_library in metadata_result.failed_libraries:
-            self._library_file_path_to_info[failed_library.library_path] = LibraryManager.LibraryInfo(
-                library_path=failed_library.library_path,
-                library_name=failed_library.library_name,
-                status=failed_library.status,
-                problems=failed_library.problems,
-            )
+        self._libraries_loading_complete.clear()
 
-        # Use metadata results to selectively load libraries
-        for library_result in metadata_result.successful_libraries:
-            if library_result.library_schema.name == LibraryManager.SANDBOX_LIBRARY_NAME:
-                # Handle sandbox library - use the schema we already have
-                await self._attempt_generate_sandbox_library_from_schema(
-                    library_schema=library_result.library_schema, sandbox_directory=library_result.file_path
-                )
-            else:
-                # Handle config-based library - register it directly using the file path
-                register_request = RegisterLibraryFromFileRequest(
-                    file_path=library_result.file_path, load_as_default_library=False
+        try:
+            # Load metadata for all libraries to determine which ones can be safely loaded
+            metadata_request = LoadMetadataForAllLibrariesRequest()
+            metadata_result = self.load_metadata_for_all_libraries_request(metadata_request)
+
+            # Check if metadata loading succeeded
+            if not isinstance(metadata_result, LoadMetadataForAllLibrariesResultSuccess):
+                logger.error("Failed to load metadata for all libraries, skipping library registration")
+                return
+
+            # Record all failed libraries in our tracking immediately
+            for failed_library in metadata_result.failed_libraries:
+                self._library_file_path_to_info[failed_library.library_path] = LibraryManager.LibraryInfo(
+                    library_path=failed_library.library_path,
+                    library_name=failed_library.library_name,
+                    status=failed_library.status,
+                    problems=failed_library.problems,
                 )
-                register_result = await self.register_library_from_file_request(register_request)
-                if isinstance(register_result, RegisterLibraryFromFileResultFailure):
-                    # Registration failed - the failure info is already recorded in _library_file_path_to_info
-                    # by register_library_from_file_request, so we just log it here for visibility
-                    logger.warning("Failed to register library from %s", library_result.file_path)
 
-        # Print 'em all pretty
-        self.print_library_load_status()
-
-        # Remove any missing libraries AFTER we've printed them for the user.
-        user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
-        self._remove_missing_libraries_from_config(config_category=user_libraries_section)
+            # Use metadata results to selectively load libraries
+            for library_result in metadata_result.successful_libraries:
+                if library_result.library_schema.name == LibraryManager.SANDBOX_LIBRARY_NAME:
+                    # Handle sandbox library - use the schema we already have
+                    await self._attempt_generate_sandbox_library_from_schema(
+                        library_schema=library_result.library_schema, sandbox_directory=library_result.file_path
+                    )
+                else:
+                    # Handle config-based library - register it directly using the file path
+                    register_request = RegisterLibraryFromFileRequest(
+                        file_path=library_result.file_path, load_as_default_library=False
+                    )
+                    register_result = await self.register_library_from_file_request(register_request)
+                    if isinstance(register_result, RegisterLibraryFromFileResultFailure):
+                        # Registration failed - the failure info is already recorded in _library_file_path_to_info
+                        # by register_library_from_file_request, so we just log it here for visibility
+                        logger.warning("Failed to register library from %s", library_result.file_path)
+
+            # Print 'em all pretty
+            self.print_library_load_status()
+
+            # Remove any missing libraries AFTER we've printed them for the user.
+            user_libraries_section = "app_events.on_app_initialization_complete.libraries_to_register"
+            self._remove_missing_libraries_from_config(config_category=user_libraries_section)
+        finally:
+            self._libraries_loading_complete.set()
 
     async def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
         # App just got init'd. See if there are library JSONs to load!

griptape_nodes/retained_mode/managers/mcp_manager.py

@@ -232,19 +232,27 @@ class MCPManager:
         self, request: UpdateMCPServerRequest
     ) -> UpdateMCPServerResultSuccess | UpdateMCPServerResultFailure:
         """Handle update MCP server request."""
-        servers = self._get_mcp_servers(filter_by={"name": request.name})
-        server_config = servers[0] if servers else None
+        servers = self._get_mcp_servers()
 
-        if server_config is None:
+        # Find the server to update
+        server_index = next((i for i, server in enumerate(servers) if server.name == request.name), None)
+
+        if server_index is None:
             return UpdateMCPServerResultFailure(
                 result_details=f"Failed to update MCP server '{request.name}' - not found"
             )
 
-        # Update only provided fields
-        self._update_server_fields(server_config, request)
+        # Create a backup of the original server and update a copy
+        original_server = servers[server_index]
+        updated_server = original_server.model_copy()
+        self._update_server_fields(updated_server, request)
+
+        # Create a copy of the servers list with the updated server
+        updated_servers = servers.copy()
+        updated_servers[server_index] = updated_server
 
         try:
-            self._save_mcp_servers(servers)
+            self._save_mcp_servers(updated_servers)
         except Exception as e:
             logger.error("Failed to save MCP server '%s': %s", request.name, e)
             return UpdateMCPServerResultFailure(result_details=f"Failed to save MCP server '{request.name}': {e}")

griptape_nodes/retained_mode/managers/node_manager.py

@@ -63,6 +63,9 @@ from griptape_nodes.retained_mode.events.node_events import (
     BatchSetNodeMetadataRequest,
     BatchSetNodeMetadataResultFailure,
     BatchSetNodeMetadataResultSuccess,
+    CanResetNodeToDefaultsRequest,
+    CanResetNodeToDefaultsResultFailure,
+    CanResetNodeToDefaultsResultSuccess,
     CreateNodeRequest,
     CreateNodeResultFailure,
     CreateNodeResultSuccess,
@@ -93,6 +96,9 @@ from griptape_nodes.retained_mode.events.node_events import (
     ListParametersOnNodeRequest,
     ListParametersOnNodeResultFailure,
     ListParametersOnNodeResultSuccess,
+    ResetNodeToDefaultsRequest,
+    ResetNodeToDefaultsResultFailure,
+    ResetNodeToDefaultsResultSuccess,
     SendNodeMessageRequest,
     SendNodeMessageResultFailure,
     SendNodeMessageResultSuccess,
@@ -111,6 +117,10 @@ from griptape_nodes.retained_mode.events.node_events import (
     SetNodeMetadataResultFailure,
     SetNodeMetadataResultSuccess,
 )
+from griptape_nodes.retained_mode.events.object_events import (
+    RenameObjectRequest,
+    RenameObjectResultSuccess,
+)
 from griptape_nodes.retained_mode.events.parameter_events import (
     AddParameterToNodeRequest,
     AddParameterToNodeResultFailure,
@@ -171,6 +181,18 @@ class SerializedParameterValues(NamedTuple):
     unique_parameter_uuid_to_values: dict[Any, Any] | None
 
 
+class CanResetResult(NamedTuple):
+    """Result of checking if a node can be reset to defaults.
+
+    Attributes:
+        can_reset: True if the node can be reset to defaults, False otherwise
+        editor_tooltip_reason: Optional explanation if node cannot be reset
+    """
+
+    can_reset: bool
+    editor_tooltip_reason: str | None
+
+
 class NodeManager:
     _name_to_parent_flow_name: dict[str, str]
 
@@ -233,6 +255,10 @@ class NodeManager:
         event_manager.assign_manager_to_request_type(SetLockNodeStateRequest, self.on_toggle_lock_node_request)
         event_manager.assign_manager_to_request_type(GetFlowForNodeRequest, self.on_get_flow_for_node_request)
         event_manager.assign_manager_to_request_type(SendNodeMessageRequest, self.on_send_node_message_request)
+        event_manager.assign_manager_to_request_type(
+            CanResetNodeToDefaultsRequest, self.on_can_reset_node_to_defaults_request
+        )
+        event_manager.assign_manager_to_request_type(ResetNodeToDefaultsRequest, self.on_reset_node_to_defaults_request)
 
     def handle_node_rename(self, old_name: str, new_name: str) -> None:
         # Get the node itself
@@ -3414,3 +3440,209 @@ class NodeManager:
                 )
 
         return None
+
+    def _check_can_reset_node(self, node: BaseNode) -> CanResetResult:
+        """Check if a node can be reset to defaults.
+
+        Args:
+            node: The node to check
+
+        Returns:
+            CanResetResult with can_reset flag and optional tooltip reason
+        """
+        if node.lock:
+            return CanResetResult(
+                can_reset=False,
+                editor_tooltip_reason="Node is locked. Unlock the node in order to reset it.",
+            )
+
+        return CanResetResult(can_reset=True, editor_tooltip_reason=None)
+
+    def on_can_reset_node_to_defaults_request(self, request: CanResetNodeToDefaultsRequest) -> ResultPayload:
+        """Check if a node can be reset to its default state."""
+        node_name = request.node_name
+        node = None
+
+        # FAILURE CHECK: Validate node_name
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = (
+                    "Attempted to check reset eligibility for a Node from the Current Context. "
+                    "Failed because the Current Context is empty."
+                )
+                return CanResetNodeToDefaultsResultFailure(result_details=details)
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        # FAILURE CHECK: Get source node
+        if node is None:
+            node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(node_name, BaseNode)
+        if node is None:
+            details = f"Attempted to check reset eligibility for Node '{node_name}', but no such Node was found."
+            return CanResetNodeToDefaultsResultFailure(result_details=details)
+
+        # FAILURE CHECK: Get node type and library
+        if "library" not in node.metadata:
+            details = (
+                f"Attempted to check reset eligibility for Node '{node_name}'. "
+                f"Failed because node has no library information in metadata."
+            )
+            return CanResetNodeToDefaultsResultFailure(result_details=details)
+
+        # Check if node can be reset
+        can_reset_result = self._check_can_reset_node(node)
+        if not can_reset_result.can_reset:
+            details = f"Node '{node_name}' cannot be reset: {can_reset_result.editor_tooltip_reason}"
+            return CanResetNodeToDefaultsResultSuccess(
+                can_reset=False,
+                editor_tooltip_reason=can_reset_result.editor_tooltip_reason,
+                result_details=details,
+            )
+
+        # SUCCESS PATH: Node can be reset
+        details = f"Node '{node_name}' can be reset to defaults."
+        return CanResetNodeToDefaultsResultSuccess(
+            can_reset=True,
+            editor_tooltip_reason=None,
+            result_details=details,
+        )
+
+    def on_reset_node_to_defaults_request(self, request: ResetNodeToDefaultsRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
+        """Reset a node to its default state while preserving connections where possible."""
+        node_name = request.node_name
+        node = None
+
+        # FAILURE CHECK: Validate node_name
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = (
+                    "Attempted to reset a Node from the Current Context. Failed because the Current Context is empty."
+                )
+                return ResetNodeToDefaultsResultFailure(result_details=details)
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        # FAILURE CHECK: Get source node
+        if node is None:
+            node = GriptapeNodes.ObjectManager().attempt_get_object_by_name_as_type(node_name, BaseNode)
+        if node is None:
+            details = f"Attempted to reset Node '{node_name}', but no such Node was found."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+
+        # FAILURE CHECK: Get node type and library
+        node_type = node.__class__.__name__
+        if "library" not in node.metadata:
+            details = (
+                f"Attempted to reset Node '{node_name}'. Failed because node has no library information in metadata."
+            )
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+        library_name = node.metadata["library"]
+
+        # FAILURE CHECK: Check if node can be reset
+        can_reset_result = self._check_can_reset_node(node)
+        if not can_reset_result.can_reset:
+            details = f"Attempted to reset Node '{node_name}'. Failed because: {can_reset_result.editor_tooltip_reason}"
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+
+        # FAILURE CHECK: Gather node information
+        all_info_request = GetAllNodeInfoRequest(node_name=node_name)
+        all_info_result = self.on_get_all_node_info_request(all_info_request)
+        if not isinstance(all_info_result, GetAllNodeInfoResultSuccess):
+            details = f"Attempted to reset Node '{node_name}'. Failed to get node information."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+
+        connections = all_info_result.connections
+
+        # FAILURE CHECK: Get parent flow name
+        if node_name not in self._name_to_parent_flow_name:
+            details = f"Attempted to reset Node '{node_name}'. Failed to find parent flow name."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+        parent_flow_name = self._name_to_parent_flow_name[node_name]
+
+        # FAILURE CHECK: Create new node with temporary name
+        temp_node_name = f"{node_name}_temp"
+        create_node_request = CreateNodeRequest(
+            node_type=node_type,
+            specific_library_name=library_name,
+            node_name=temp_node_name,
+            override_parent_flow_name=parent_flow_name,
+            create_error_proxy_on_failure=False,
+        )
+        create_result = self.on_create_node_request(create_node_request)
+        if not isinstance(create_result, CreateNodeResultSuccess):
+            details = f"Attempted to reset Node '{node_name}'. Failed to create new node of type '{node_type}'."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+        new_node_name = create_result.node_name
+
+        # TODO: (griptape-nodes) Don't rely on manually copying metadata fields. https://github.com/griptape-ai/griptape-nodes/issues/2862
+        # Copy only position and size from original node's metadata to preserve layout.
+        # We don't copy the full metadata because it contains instance-specific data that shouldn't be transferred.
+        original_metadata = all_info_result.metadata
+        new_node = self.get_node_by_name(new_node_name)
+        if "position" in original_metadata:
+            new_node.metadata["position"] = copy.deepcopy(original_metadata["position"])
+        if "size" in original_metadata:
+            new_node.metadata["size"] = copy.deepcopy(original_metadata["size"])
+
+        # NON-FATAL: Attempt to reconnect connections
+        failed_incoming: list[IncomingConnection] = []
+        failed_outgoing: list[OutgoingConnection] = []
+
+        for incoming_connection in connections.incoming_connections:
+            connection_request = CreateConnectionRequest(
+                source_node_name=incoming_connection.source_node_name,
+                source_parameter_name=incoming_connection.source_parameter_name,
+                target_node_name=new_node_name,
+                target_parameter_name=incoming_connection.target_parameter_name,
+            )
+            connection_result = GriptapeNodes.FlowManager().on_create_connection_request(connection_request)
+            if not isinstance(connection_result, CreateConnectionResultSuccess):
+                failed_incoming.append(incoming_connection)
+
+        for outgoing_connection in connections.outgoing_connections:
+            connection_request = CreateConnectionRequest(
+                source_node_name=new_node_name,
+                source_parameter_name=outgoing_connection.source_parameter_name,
+                target_node_name=outgoing_connection.target_node_name,
+                target_parameter_name=outgoing_connection.target_parameter_name,
+            )
+            connection_result = GriptapeNodes.FlowManager().on_create_connection_request(connection_request)
+            if not isinstance(connection_result, CreateConnectionResultSuccess):
+                failed_outgoing.append(outgoing_connection)
+
+        # FAILURE CHECK: Delete source node
+        delete_request = DeleteNodeRequest(node_name=node_name)
+        delete_result = self.on_delete_node_request(delete_request)
+        if not isinstance(delete_result, DeleteNodeResultSuccess):
+            details = f"Attempted to reset Node '{node_name}'. Failed to delete original node."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+
+        # FAILURE CHECK: Rename new node to original name
+        rename_request = RenameObjectRequest(
+            object_name=new_node_name, requested_name=node_name, allow_next_closest_name_available=False
+        )
+        rename_result = GriptapeNodes.ObjectManager().on_rename_object_request(rename_request)
+        if not isinstance(rename_result, RenameObjectResultSuccess):
+            details = f"Attempted to reset Node '{node_name}'. Failed to rename new node to original name."
+            return ResetNodeToDefaultsResultFailure(result_details=details)
+
+        # SUCCESS PATH
+        if not failed_incoming and not failed_outgoing:
+            details = f"Successfully reset node '{node_name}' to defaults."
+            log_level = logging.DEBUG
+        else:
+            details = f"Successfully reset node '{node_name}' but one or more connections could not be restored."
+            if failed_incoming:
+                source_node_names = {conn.source_node_name for conn in failed_incoming}
+                details += f" Connections FROM the following nodes were not restored: {source_node_names}."
+            if failed_outgoing:
+                target_node_names = {conn.target_node_name for conn in failed_outgoing}
+                details += f" Connections TO the following nodes were not restored: {target_node_names}."
+            log_level = logging.WARNING
+
+        return ResetNodeToDefaultsResultSuccess(
+            node_name=node_name,
+            failed_incoming_connections=failed_incoming,
+            failed_outgoing_connections=failed_outgoing,
+            result_details=ResultDetails(message=details, level=log_level),
+        )