griptape-nodes 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/node_manager.py

@@ -4,12 +4,11 @@ import pickle
 from typing import Any, NamedTuple, cast
 from uuid import uuid4
 
-from griptape.events import EventBus
-
 from griptape_nodes.exe_types.core_types import (
     BaseNodeElement,
     Parameter,
     ParameterContainer,
+    ParameterGroup,
     ParameterMode,
     ParameterTypeBuiltin,
 )
@@ -18,8 +17,6 @@ from griptape_nodes.exe_types.node_types import BaseNode, EndLoopNode, NodeResol
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.node_library.library_registry import LibraryNameAndVersion, LibraryRegistry
 from griptape_nodes.retained_mode.events.base_events import (
-    ExecutionEvent,
-    ExecutionGriptapeNodeEvent,
     ResultPayload,
     ResultPayloadFailure,
 )
@@ -92,7 +89,6 @@ from griptape_nodes.retained_mode.events.parameter_events import (
     AddParameterToNodeRequest,
     AddParameterToNodeResultFailure,
     AddParameterToNodeResultSuccess,
-    AlterElementEvent,
     AlterParameterDetailsRequest,
     AlterParameterDetailsResultFailure,
     AlterParameterDetailsResultSuccess,
@@ -112,6 +108,9 @@ from griptape_nodes.retained_mode.events.parameter_events import (
     RemoveParameterFromNodeRequest,
     RemoveParameterFromNodeResultFailure,
     RemoveParameterFromNodeResultSuccess,
+    RenameParameterRequest,
+    RenameParameterResultFailure,
+    RenameParameterResultSuccess,
     SetParameterValueRequest,
     SetParameterValueResultFailure,
     SetParameterValueResultSuccess,
@@ -156,6 +155,7 @@ class NodeManager:
         )
         event_manager.assign_manager_to_request_type(GetParameterValueRequest, self.on_get_parameter_value_request)
         event_manager.assign_manager_to_request_type(SetParameterValueRequest, self.on_set_parameter_value_request)
+        event_manager.assign_manager_to_request_type(RenameParameterRequest, self.on_rename_parameter_request)
         event_manager.assign_manager_to_request_type(ResolveNodeRequest, self.on_resolve_from_node_request)
         event_manager.assign_manager_to_request_type(GetAllNodeInfoRequest, self.on_get_all_node_info_request)
         event_manager.assign_manager_to_request_type(
@@ -217,7 +217,7 @@ class NodeManager:
             if parent_flow_name == old_name:
                 self._name_to_parent_flow_name[node_name] = new_name
 
-    def on_create_node_request(self, request: CreateNodeRequest) -> ResultPayload:  # noqa: C901, PLR0912, PLR0915
+    def on_create_node_request(self, request: CreateNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
         # Validate as much as possible before we actually create one.
         parent_flow_name = request.override_parent_flow_name
         parent_flow = None
@@ -321,30 +321,53 @@ class NodeManager:
 
         if isinstance(node, StartLoopNode) 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__
+
+            # Get the opposing EndNode
+            # TODO: (griptape) Get paired classes implemented so we dont need to do name stuff. https://github.com/griptape-ai/griptape-nodes/issues/1549
+            end_class_name = node_class_name.replace("Start", "End")
+
+            # Check and see if the class exists
+            libraries_with_node_type = LibraryRegistry.get_libraries_with_node_type(end_class_name)
+            if not libraries_with_node_type:
+                msg = f"End class '{end_class_name}' does not exist for start class '{node_class_name}'"
+                logger.error(msg)
+                return CreateNodeResultFailure()
+
+            # Create the EndNode
             end_loop = GriptapeNodes.handle_request(
                 CreateNodeRequest(
-                    node_type="ForEachEndNode",
+                    node_type=end_class_name,
                     metadata={
                         "position": {"x": node.metadata["position"]["x"] + 650, "y": node.metadata["position"]["y"]}
                     },
                     override_parent_flow_name=parent_flow_name,
                 )
             )
-            if isinstance(end_loop, CreateNodeResultSuccess):
-                # Create Loop between output and input to the start node.
-                GriptapeNodes.handle_request(
-                    CreateConnectionRequest(
-                        source_node_name=node.name,
-                        source_parameter_name="loop",
-                        target_node_name=end_loop.node_name,
-                        target_parameter_name="from_start",
-                    )
+            if not isinstance(end_loop, CreateNodeResultSuccess):
+                msg = f"Failed to create EndLoop node for StartLoop node '{node.name}'"
+                logger.error(msg)
+                return CreateNodeResultFailure()
+
+            # Create Loop between output and input to the start node.
+            GriptapeNodes.handle_request(
+                CreateConnectionRequest(
+                    source_node_name=node.name,
+                    source_parameter_name="loop",
+                    target_node_name=end_loop.node_name,
+                    target_parameter_name="from_start",
                 )
-                end_node = self.get_node_by_name(end_loop.node_name)
-                if isinstance(end_node, EndLoopNode):
-                    # create the connection bt them
-                    node.end_node = end_node
-                    end_node.start_node = node
+            )
+            end_node = self.get_node_by_name(end_loop.node_name)
+            if not isinstance(end_node, EndLoopNode):
+                msg = f"End node '{end_loop.node_name}' is not a valid EndLoopNode"
+                logger.error(msg)
+                return CreateNodeResultFailure()
+
+            # create the connection
+            node.end_node = end_node
+            end_node.start_node = node
 
         return CreateNodeResultSuccess(
             node_name=node.name, node_type=node.__class__.__name__, specific_library_name=request.specific_library_name
@@ -700,6 +723,24 @@ class NodeManager:
         )
         return result
 
+    def generate_unique_parameter_name(self, node: BaseNode, base_name: str) -> str:
+        """Generate a unique parameter name for a node by appending a number if needed.
+
+        Args:
+            node: The node to check for existing parameter names
+            base_name: The desired base name for the parameter
+
+        Returns:
+            A unique parameter name that doesn't conflict with existing parameters
+        """
+        if node.get_parameter_by_name(base_name) is None:
+            return base_name
+
+        counter = 1
+        while node.get_parameter_by_name(f"{base_name}_{counter}") is not None:
+            counter += 1
+        return f"{base_name}_{counter}"
+
     def on_add_parameter_to_node_request(self, request: AddParameterToNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
         node_name = request.node_name
         node = None
@@ -744,6 +785,7 @@ class NodeManager:
                 logger.exception(details)
                 result = AddParameterToNodeResultFailure()
                 return result
+
             return AddParameterToNodeResultSuccess(
                 parameter_name=new_param.name, type=new_param.type, node_name=node_name
             )
@@ -752,13 +794,14 @@ class NodeManager:
             logger.error(details)
             result = AddParameterToNodeResultFailure()
             return result
-        # Does the Node already have a parameter by this name?
-        if node.get_parameter_by_name(request.parameter_name) is not None:
-            details = f"Attempted to add Parameter '{request.parameter_name}' to Node '{node_name}'. Failed because it already had a Parameter with that name on it. Parameter names must be unique within the Node."
-            logger.error(details)
 
-            result = AddParameterToNodeResultFailure()
-            return result
+        # Generate a unique parameter name if needed
+        requested_parameter_name = request.parameter_name
+        if requested_parameter_name is None:
+            # Not allowed to have a parameter with no name, so we'll give it a default name
+            requested_parameter_name = "parameter"
+
+        final_param_name = self.generate_unique_parameter_name(node, requested_parameter_name)
 
         # Let's see if the Parameter is properly formed.
         # If a Parameter is intended for Control, it needs to have that be the exclusive type.
@@ -799,7 +842,7 @@ class NodeManager:
 
         # Let's roll, I guess.
         new_param = Parameter(
-            name=request.parameter_name,
+            name=final_param_name,
             type=request.type,
             input_types=request.input_types,
             output_type=request.output_type,
@@ -822,12 +865,17 @@ class NodeManager:
                 logger.info(new_param.name)
                 node.add_parameter(new_param)
         except Exception as e:
-            details = f"Couldn't add parameter with name {request.parameter_name} to node. Error: {e}"
+            details = f"Couldn't add parameter with name {request.parameter_name} to Node '{node_name}'. Error: {e}"
             logger.error(details)
             return AddParameterToNodeResultFailure()
 
-        details = f"Successfully added Parameter '{request.parameter_name}' to Node '{node_name}'."
-        logger.debug(details)
+        details = f"Successfully added Parameter '{final_param_name}' to Node '{node_name}'."
+        log_level = logging.DEBUG
+        if final_param_name != requested_parameter_name:
+            log_level = logging.WARNING
+            details = f"{details} WARNING: Had to rename from original parameter name '{requested_parameter_name}' as a parameter with this name already existed in node '{node_name}'."
+
+        logger.log(level=log_level, msg=details)
 
         result = AddParameterToNodeResultSuccess(
             parameter_name=new_param.name, type=new_param.type, node_name=node_name
@@ -861,83 +909,87 @@ class NodeManager:
                 result = RemoveParameterFromNodeResultFailure()
                 return result
 
-        # Does the Parameter actually exist on the Node?
-        parameter = node.get_parameter_by_name(request.parameter_name)
-        parameter_group = node.get_group_by_name_or_element_id(request.parameter_name)
-        if parameter is None and parameter_group is None:
-            details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have a Parameter with that name on it."
+        # Does the Element actually exist on the Node?
+        element = node.get_element_by_name_and_type(request.parameter_name)
+        if element is None:
+            details = f"Attempted to remove Element '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have an Element with that name on it."
             logger.error(details)
 
             result = RemoveParameterFromNodeResultFailure()
             return result
-        if parameter_group is not None:
-            for child in parameter_group.find_elements_by_type(Parameter):
+
+        # If it's a ParameterGroup, we need to remove all the Parameters inside it.
+        if isinstance(element, ParameterGroup):
+            for child in element.find_elements_by_type(Parameter):
                 GriptapeNodes.handle_request(RemoveParameterFromNodeRequest(child.name, node_name))
             node.remove_parameter_element_by_name(request.parameter_name)
+
             return RemoveParameterFromNodeResultSuccess()
 
         # No tricky stuff, users!
-        if parameter is not None and parameter.user_defined is False:
-            details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because the Parameter was not user-defined (i.e., critical to the Node implementation). Only user-defined Parameters can be removed from a Node."
+        # if user_defined doesn't exist, or is false, then it's not user-defined
+        if not getattr(element, "user_defined", False):
+            details = f"Attempted to remove Element '{request.parameter_name}' from Node '{node_name}'. Failed because the Element was not user-defined (i.e., critical to the Node implementation). Only user-defined Elements can be removed from a Node."
             logger.error(details)
 
             result = RemoveParameterFromNodeResultFailure()
             return result
 
         # Get all the connections to/from this Parameter.
-        list_node_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
-        list_connections_result = GriptapeNodes.handle_request(request=list_node_connections_request)
-        if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
-            details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to get a list of Connections for the Parameter's Node."
-            logger.error(details)
+        if isinstance(element, Parameter):
+            list_node_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
+            list_connections_result = GriptapeNodes.handle_request(request=list_node_connections_request)
+            if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+                details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to get a list of Connections for the Parameter's Node."
+                logger.error(details)
 
-            result = RemoveParameterFromNodeResultFailure()
-            return result
+                result = RemoveParameterFromNodeResultFailure()
+                return result
 
-        # We have a list of all connections to the NODE. Sift down to just those that are about this PARAMETER.
+            # We have a list of all connections to the NODE. Sift down to just those that are about this PARAMETER.
 
-        # Destroy all the incoming Connections to this PARAMETER
-        for incoming_connection in list_connections_result.incoming_connections:
-            if incoming_connection.target_parameter_name == request.parameter_name:
-                delete_request = DeleteConnectionRequest(
-                    source_node_name=incoming_connection.source_node_name,
-                    source_parameter_name=incoming_connection.source_parameter_name,
-                    target_node_name=node_name,
-                    target_parameter_name=incoming_connection.target_parameter_name,
-                )
-                delete_result = GriptapeNodes.handle_request(delete_request)
-                if isinstance(delete_result, DeleteConnectionResultFailure):
-                    details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to delete a Connection for that Parameter."
-                    logger.error(details)
+            # Destroy all the incoming Connections to this PARAMETER
+            for incoming_connection in list_connections_result.incoming_connections:
+                if incoming_connection.target_parameter_name == request.parameter_name:
+                    delete_request = DeleteConnectionRequest(
+                        source_node_name=incoming_connection.source_node_name,
+                        source_parameter_name=incoming_connection.source_parameter_name,
+                        target_node_name=node_name,
+                        target_parameter_name=incoming_connection.target_parameter_name,
+                    )
+                    delete_result = GriptapeNodes.handle_request(delete_request)
+                    if isinstance(delete_result, DeleteConnectionResultFailure):
+                        details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to delete a Connection for that Parameter."
+                        logger.error(details)
 
-                    result = RemoveParameterFromNodeResultFailure()
+                        result = RemoveParameterFromNodeResultFailure()
 
-        # Destroy all the outgoing Connections from this PARAMETER
-        for outgoing_connection in list_connections_result.outgoing_connections:
-            if outgoing_connection.source_parameter_name == request.parameter_name:
-                delete_request = DeleteConnectionRequest(
-                    source_node_name=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,
-                )
-                delete_result = GriptapeNodes.handle_request(delete_request)
-                if isinstance(delete_result, DeleteConnectionResultFailure):
-                    details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to delete a Connection for that Parameter."
-                    logger.error(details)
+            # Destroy all the outgoing Connections from this PARAMETER
+            for outgoing_connection in list_connections_result.outgoing_connections:
+                if outgoing_connection.source_parameter_name == request.parameter_name:
+                    delete_request = DeleteConnectionRequest(
+                        source_node_name=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,
+                    )
+                    delete_result = GriptapeNodes.handle_request(delete_request)
+                    if isinstance(delete_result, DeleteConnectionResultFailure):
+                        details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because we were unable to delete a Connection for that Parameter."
+                        logger.error(details)
 
-                    result = RemoveParameterFromNodeResultFailure()
+                        result = RemoveParameterFromNodeResultFailure()
 
-        # Delete the Parameter itself.
-        if parameter is not None:
-            node.remove_parameter_element(parameter)
+        # Delete the Element itself.
+        if element is not None:
+            node.remove_parameter_element(element)
         else:
-            details = f"Attempted to remove Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because parameter didn't exist."
+            details = f"Attempted to remove Element '{request.parameter_name}' from Node '{node_name}'. Failed because element didn't exist."
             logger.error(details)
 
             result = RemoveParameterFromNodeResultFailure()
 
-        details = f"Successfully removed Parameter '{request.parameter_name}' from Node '{node_name}'."
+        details = f"Successfully removed Element '{request.parameter_name}' from Node '{node_name}'."
         logger.debug(details)
 
         result = RemoveParameterFromNodeResultSuccess()
@@ -968,39 +1020,43 @@ class NodeManager:
                 result = GetParameterDetailsResultFailure()
                 return result
 
-        # Does the Parameter actually exist on the Node?
-        parameter = node.get_parameter_by_name(request.parameter_name)
-        if parameter is None:
-            details = f"Attempted to get details for Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have a Parameter with that name on it."
-            logger.error(details)
+        # Does the Element actually exist on the Node?
+        element = node.get_element_by_name_and_type(request.parameter_name)
 
-            result = GetParameterDetailsResultFailure()
-            return result
+        if element is None:
+            details = f"Attempted to get details for Element '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have an Element with that name on it."
+            logger.error(details)
+            return GetParameterDetailsResultFailure()
 
         # Let's bundle up the details.
-        modes_allowed = parameter.allowed_modes
-        allows_input = ParameterMode.INPUT in modes_allowed
-        allows_property = ParameterMode.PROPERTY in modes_allowed
-        allows_output = ParameterMode.OUTPUT in modes_allowed
+        allows_input = False
+        allows_property = False
+        allows_output = False
 
-        details = f"Successfully got details for Parameter '{request.parameter_name}' from Node '{node_name}'."
-        logger.debug(details)
+        if isinstance(element, Parameter):
+            modes_allowed = element.allowed_modes
+            allows_input = ParameterMode.INPUT in modes_allowed
+            allows_property = ParameterMode.PROPERTY in modes_allowed
+            allows_output = ParameterMode.OUTPUT in modes_allowed
+
+            details = f"Successfully got details for Element '{request.parameter_name}' from Node '{node_name}'."
+            logger.debug(details)
 
         result = GetParameterDetailsResultSuccess(
-            element_id=parameter.element_id,
-            type=parameter.type,
-            input_types=parameter.input_types,
-            output_type=parameter.output_type,
-            default_value=parameter.default_value,
-            tooltip=parameter.tooltip,
-            tooltip_as_input=parameter.tooltip_as_input,
-            tooltip_as_property=parameter.tooltip_as_property,
-            tooltip_as_output=parameter.tooltip_as_output,
+            element_id=element.element_id,
+            type=getattr(element, "type", ""),
+            input_types=getattr(element, "input_types", []),
+            output_type=getattr(element, "output_type", ""),
+            default_value=getattr(element, "default_value", None),
+            tooltip=getattr(element, "tooltip", ""),
+            tooltip_as_input=getattr(element, "tooltip_as_input", None),
+            tooltip_as_property=getattr(element, "tooltip_as_property", None),
+            tooltip_as_output=getattr(element, "tooltip_as_output", None),
             mode_allowed_input=allows_input,
             mode_allowed_property=allows_property,
             mode_allowed_output=allows_output,
-            is_user_defined=parameter.user_defined,
-            ui_options=parameter.ui_options,
+            is_user_defined=getattr(element, "user_defined", False),
+            ui_options=getattr(element, "ui_options", None),
         )
         return result
 
@@ -1040,7 +1096,7 @@ class NodeManager:
                 return GetNodeElementDetailsResultFailure()
 
         element_details = element.to_dict()
-        # We need to get parameter values from here
+        # We need to get element values from here
         param_to_value = {}
         self._set_param_to_value(node, element, param_to_value)
         if param_to_value:
@@ -1076,17 +1132,18 @@ class NodeManager:
                 # Otherwise, just set it here. It'll be handled in .json() when we send it over.
                 param_to_value[element_id] = value
 
-    def modify_alterable_fields(self, request: AlterParameterDetailsRequest, parameter: Parameter) -> None:
-        if request.tooltip is not None:
-            parameter.tooltip = request.tooltip
-        if request.tooltip_as_input is not None:
-            parameter.tooltip_as_input = request.tooltip_as_input
-        if request.tooltip_as_property is not None:
-            parameter.tooltip_as_property = request.tooltip_as_property
-        if request.tooltip_as_output is not None:
-            parameter.tooltip_as_output = request.tooltip_as_output
-        if request.ui_options is not None:
-            parameter.ui_options = request.ui_options
+    def modify_alterable_fields(self, request: AlterParameterDetailsRequest, parameter: BaseNodeElement) -> None:
+        if isinstance(parameter, Parameter):
+            if request.tooltip:
+                parameter.tooltip = request.tooltip
+            if request.tooltip_as_input is not None:
+                parameter.tooltip_as_input = request.tooltip_as_input
+            if request.tooltip_as_property is not None:
+                parameter.tooltip_as_property = request.tooltip_as_property
+            if request.tooltip_as_output is not None:
+                parameter.tooltip_as_output = request.tooltip_as_output
+        if request.ui_options is not None and hasattr(parameter, "ui_options"):
+            parameter.ui_options = request.ui_options  # type: ignore[attr-defined]
 
     def modify_key_parameter_fields(self, request: AlterParameterDetailsRequest, parameter: Parameter) -> None:
         if request.type is not None:
@@ -1114,7 +1171,67 @@ class NodeManager:
             else:
                 parameter.allowed_modes.discard(ParameterMode.OUTPUT)
 
-    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:
+    def _validate_and_break_invalid_connections(
+        self, node_name: str, parameter: Parameter, request: AlterParameterDetailsRequest
+    ) -> ResultPayload | None:
+        """Validate and break any connections that are no longer valid after a parameter type change.
+
+        This method checks both incoming and outgoing connections for a parameter and removes
+        any that are no longer type-compatible after the parameter's type has been changed.
+
+        Returns:
+            ResultPayload | None: Returns AlterParameterDetailsResultFailure if any connection deletion fails,
+                                 None otherwise.
+        """
+        # Get all connections for this node
+        list_connections_request = ListConnectionsForNodeRequest(node_name=node_name)
+        list_connections_result = self.on_list_connections_for_node_request(list_connections_request)
+
+        if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+            # No connections exist for this node, which is not a failure - just nothing to validate
+            return None
+
+        # Check and break invalid incoming connections
+        for conn in list_connections_result.incoming_connections:
+            if conn.target_parameter_name == request.parameter_name:
+                source_node = self.get_node_by_name(conn.source_node_name)
+                source_param = source_node.get_parameter_by_name(conn.source_parameter_name)
+                if source_param and not parameter.is_incoming_type_allowed(source_param.output_type):
+                    delete_result = GriptapeNodes.FlowManager().on_delete_connection_request(
+                        DeleteConnectionRequest(
+                            source_node_name=conn.source_node_name,
+                            source_parameter_name=conn.source_parameter_name,
+                            target_node_name=node_name,
+                            target_parameter_name=request.parameter_name,
+                        )
+                    )
+                    if isinstance(delete_result, ResultPayloadFailure):
+                        details = f"Failed to delete incompatible incoming connection from {conn.source_node_name}.{conn.source_parameter_name} to {node_name}.{request.parameter_name}: {delete_result}"
+                        logger.error(details)
+                        return AlterParameterDetailsResultFailure()
+
+        # Check and break invalid outgoing connections
+        for conn in list_connections_result.outgoing_connections:
+            if conn.source_parameter_name == request.parameter_name:
+                target_node = self.get_node_by_name(conn.target_node_name)
+                target_param = target_node.get_parameter_by_name(conn.target_parameter_name)
+                if target_param and not target_param.is_incoming_type_allowed(parameter.output_type):
+                    delete_result = GriptapeNodes.FlowManager().on_delete_connection_request(
+                        DeleteConnectionRequest(
+                            source_node_name=node_name,
+                            source_parameter_name=request.parameter_name,
+                            target_node_name=conn.target_node_name,
+                            target_parameter_name=conn.target_parameter_name,
+                        )
+                    )
+                    if isinstance(delete_result, ResultPayloadFailure):
+                        details = f"Failed to delete incompatible outgoing connection from {node_name}.{request.parameter_name} to {conn.target_node_name}.{conn.target_parameter_name}: {delete_result}"
+                        logger.error(details)
+                        return AlterParameterDetailsResultFailure()
+
+        return None
+
+    def on_alter_parameter_details_request(self, request: AlterParameterDetailsRequest) -> ResultPayload:  # noqa: C901
         node_name = request.node_name
         node = None
 
@@ -1137,36 +1254,42 @@ class NodeManager:
 
                 return AlterParameterDetailsResultFailure()
 
-        # Does the Parameter actually exist on the Node?
-        parameter = node.get_parameter_by_name(request.parameter_name)
-        parameter_group = node.get_group_by_name_or_element_id(request.parameter_name)
-        if parameter is None:
-            parameter_group = node.get_group_by_name_or_element_id(request.parameter_name)
-            if parameter_group is None:
-                details = f"Attempted to alter details for Parameter '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have a Parameter with that name on it."
-                logger.error(details)
-
-                return AlterParameterDetailsResultFailure()
-            if request.ui_options is not None:
-                parameter_group.ui_options = request.ui_options
-            return AlterParameterDetailsResultSuccess()
+        # Does the Element actually exist on the Node?
+        element = node.get_element_by_name_and_type(request.parameter_name)
+        if element is None:
+            details = f"Attempted to alter details for Element '{request.parameter_name}' from Node '{node_name}'. Failed because it didn't have an Element with that name on it."
+            logger.error(details)
+            return AlterParameterDetailsResultFailure()
+        if request.ui_options is not None:
+            element.ui_options = request.ui_options  # type: ignore[attr-defined]
+
+        # Check and handle connections if type was changed
+        if isinstance(element, Parameter) and (
+            request.type is not None or request.input_types is not None or request.output_type is not None
+        ):
+            result = self._validate_and_break_invalid_connections(node_name, element, request)
+            if isinstance(result, AlterParameterDetailsResultFailure):
+                return result
 
         # TODO: https://github.com/griptape-ai/griptape-nodes/issues/827
-        # Now change all the values on the Parameter.
-        self.modify_alterable_fields(request, parameter)
+        # Now change all the values on the Element.
+        self.modify_alterable_fields(request, element)
+
         # The rest of these are not alterable
-        if parameter.user_defined is False and request.request_id:
-            # TODO: https://github.com/griptape-ai/griptape-nodes/issues/826
-            details = f"Attempted to alter details for Parameter '{request.parameter_name}' from Node '{node_name}'. Could only alter some values because the Parameter was not user-defined (i.e., critical to the Node implementation). Only user-defined Parameters can be totally modified from a Node."
-            logger.warning(details)
-            return AlterParameterDetailsResultSuccess()
-        self.modify_key_parameter_fields(request, parameter)
+        if isinstance(element, Parameter):
+            if hasattr(element, "user_defined") and element.user_defined is False and request.request_id:  # type: ignore[attr-defined]
+                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/826
+                details = f"Attempted to alter details for Element '{request.parameter_name}' from Node '{node_name}'. Could only alter some values because the Element was not user-defined (i.e., critical to the Node implementation). Only user-defined Elements can be totally modified from a Node."
+                logger.warning(details)
+                return AlterParameterDetailsResultSuccess()
+            self.modify_key_parameter_fields(request, element)
+
         # This field requires the node as well
         if request.default_value is not None:
             # TODO: https://github.com/griptape-ai/griptape-nodes/issues/825
             node.parameter_values[request.parameter_name] = request.default_value
 
-        details = f"Successfully altered details for Parameter '{request.parameter_name}' from Node '{node_name}'."
+        details = f"Successfully altered details for Element '{request.parameter_name}' from Node '{node_name}'."
         logger.debug(details)
 
         result = AlterParameterDetailsResultSuccess()
@@ -1355,18 +1478,12 @@ class NodeManager:
             return NodeManager.ModifiedReturnValue(object_created, modified)
         # Otherwise use set_parameter_value. This calls our converters and validators.
         old_value = node.get_parameter_value(request.parameter_name)
-        modified_parameters = node.set_parameter_value(request.parameter_name, object_created)
+        node.set_parameter_value(request.parameter_name, object_created)
         # Get the "converted" value here.
         finalized_value = node.get_parameter_value(request.parameter_name)
         if old_value != finalized_value:
             modified = True
         # If any parameters were dependent on that value, we're calling this details request to emit the result to the editor.
-        if modified_parameters:
-            for modified_parameter_name in modified_parameters:
-                modified_parameter = node.root_ui_element.find_element_by_name(modified_parameter_name)
-                if modified_parameter is not None:
-                    modified_request = AlterElementEvent(element_details=modified_parameter.to_event(node))
-                    EventBus.publish_event(ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request)))
         return NodeManager.ModifiedReturnValue(finalized_value, modified)
 
     # For C901 (too complex): Need to give customers explicit reasons for failure on each case.
@@ -2255,3 +2372,83 @@ class NodeManager:
             else:
                 commands.append(output_command)
         return commands if commands else None
+
+    def on_rename_parameter_request(self, request: RenameParameterRequest) -> ResultPayload:  # noqa: C901, PLR0912
+        """Handle renaming a parameter on a node.
+
+        Args:
+            request: The rename parameter request containing the old and new parameter names
+
+        Returns:
+            ResultPayload: Success or failure result
+        """
+        # Get the node
+        node_name = request.node_name
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = "Attempted to rename Parameter in the Current Context. Failed because the Current Context was empty."
+                logger.error(details)
+                return RenameParameterResultFailure()
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+        else:
+            try:
+                node = self.get_node_by_name(node_name)
+            except KeyError as err:
+                details = f"Attempted to rename Parameter '{request.parameter_name}' on Node '{node_name}'. Failed because the Node could not be found. Error: {err}"
+                logger.error(details)
+                return RenameParameterResultFailure()
+
+        # Get the parameter
+        parameter = node.get_parameter_by_name(request.parameter_name)
+        if parameter is None:
+            details = f"Attempted to rename Parameter '{request.parameter_name}' on Node '{node_name}'. Failed because the Parameter could not be found."
+            logger.error(details)
+            return RenameParameterResultFailure()
+
+        # Validate the new parameter name
+        if any(char.isspace() for char in request.new_parameter_name):
+            details = f"Failed to rename Parameter '{request.parameter_name}' to '{request.new_parameter_name}'. Parameter names cannot contain any whitespace characters."
+            logger.error(details)
+            return RenameParameterResultFailure()
+
+        # Check for duplicate names
+        if node.does_name_exist(request.new_parameter_name):
+            details = f"Failed to rename Parameter '{request.parameter_name}' to '{request.new_parameter_name}'. A Parameter with that name already exists."
+            logger.error(details)
+            return RenameParameterResultFailure()
+
+        # Get all connections for this node
+        flow_name = self.get_node_parent_flow_by_name(node_name)
+        flow = GriptapeNodes.FlowManager().get_flow_by_name(flow_name)
+
+        # Update connections that reference this parameter
+        if node_name in flow.connections.incoming_index:
+            incoming_connections = flow.connections.incoming_index[node_name]
+            for connection_ids in incoming_connections.values():
+                for connection_id in connection_ids:
+                    connection = flow.connections.connections[connection_id]
+                    if connection.target_parameter.name == request.parameter_name:
+                        connection.target_parameter.name = request.new_parameter_name
+
+        if node_name in flow.connections.outgoing_index:
+            outgoing_connections = flow.connections.outgoing_index[node_name]
+            for connection_ids in outgoing_connections.values():
+                for connection_id in connection_ids:
+                    connection = flow.connections.connections[connection_id]
+                    if connection.source_parameter.name == request.parameter_name:
+                        connection.source_parameter.name = request.new_parameter_name
+
+        # Update parameter name
+        old_name = parameter.name
+        parameter.name = request.new_parameter_name
+
+        # Update parameter values if they exist
+        if old_name in node.parameter_values:
+            node.parameter_values[request.new_parameter_name] = node.parameter_values.pop(old_name)
+        if old_name in node.parameter_output_values:
+            node.parameter_output_values[request.new_parameter_name] = node.parameter_output_values.pop(old_name)
+
+        return RenameParameterResultSuccess(
+            old_parameter_name=old_name, new_parameter_name=request.new_parameter_name, node_name=node_name
+        )