griptape-nodes 0.66.2__py3-none-any.whl → 0.68.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/event_manager.py

@@ -67,9 +67,28 @@ class EventManager:
         return self._event_queue
 
     def should_suppress_event(self, event: BaseEvent | ProgressEvent) -> bool:
-        """Check if events should be suppressed from being sent to websockets."""
+        """Check if events should be suppressed from being sent to websockets.
+
+        This method checks both the wrapper event type and the payload type for wrapped events.
+        For example, if InvolvedNodesEvent is in the suppression set, an ExecutionGriptapeNodeEvent
+        that wraps an InvolvedNodesEvent will be suppressed.
+        """
         event_type = type(event)
-        return self._event_suppression_counts.get(event_type, 0) > 0
+
+        # Check wrapper type first
+        if self._event_suppression_counts.get(event_type, 0) > 0:
+            return True
+
+        # For wrapped events (like ExecutionGriptapeNodeEvent), also check the payload type
+        wrapped_event = getattr(event, "wrapped_event", None)
+        if wrapped_event is not None:
+            payload = getattr(wrapped_event, "payload", None)
+            if payload is not None:
+                payload_type = type(payload)
+                if self._event_suppression_counts.get(payload_type, 0) > 0:
+                    return True
+
+        return False
 
     def clear_event_suppression(self) -> None:
         """Clear all event suppression counts."""
@@ -433,11 +452,14 @@ class EventTranslationContext:
         self.manager = manager
         self.node_name_mapping = node_name_mapping
         self.original_put_event: Any = None
+        self.original_aput_event: Any = None
 
     def __enter__(self) -> None:
         """Enter the context and start translating events."""
         self.original_put_event = self.manager.put_event
+        self.original_aput_event = self.manager.aput_event
         self.manager.put_event = self._translate_and_put  # type: ignore[method-assign]
+        self.manager.aput_event = self._translate_and_aput  # type: ignore[method-assign]
 
     def __exit__(
         self,
@@ -447,24 +469,168 @@ class EventTranslationContext:
     ) -> None:
         """Exit the context and restore original event sending."""
         self.manager.put_event = self.original_put_event  # type: ignore[method-assign]
+        self.manager.aput_event = self.original_aput_event  # type: ignore[method-assign]
 
-    def _translate_and_put(self, event: Any) -> None:
-        """Translate node names in events and put them in the queue.
+    def _translate_event(self, event: Any) -> Any:
+        """Translate node names in an event.
 
         Args:
-            event: The event to potentially translate and send
+            event: The event to potentially translate
+
+        Returns:
+            The translated event, or the original if no translation needed
         """
+        # Handle wrapped events (like ExecutionGriptapeNodeEvent)
+        wrapped_event = getattr(event, "wrapped_event", None)
+        if wrapped_event is not None:
+            payload = getattr(wrapped_event, "payload", None)
+            if payload is not None:
+                translated_payload = self._translate_payload(payload)
+                if translated_payload is not payload:
+                    # Create a new wrapped event with the translated payload
+                    translated_event = self._create_translated_wrapped_event(event, translated_payload)
+                    if translated_event is not None:
+                        return translated_event
+
         # Check if event has node_name attribute and needs translation
         if hasattr(event, "node_name"):
             node_name = event.node_name
             if node_name in self.node_name_mapping:
                 # Create a copy of the event with the translated node name
-                translated_event = self._copy_event_with_translated_name(event)
-                self.original_put_event(translated_event)
-                return
+                return self._copy_event_with_translated_name(event)
+
+        return event
+
+    def _translate_and_put(self, event: Any) -> None:
+        """Translate node names in events and put them in the queue (sync version).
+
+        Args:
+            event: The event to potentially translate and send
+        """
+        translated_event = self._translate_event(event)
+        self.original_put_event(translated_event)
+
+    async def _translate_and_aput(self, event: Any) -> None:
+        """Translate node names in events and put them in the queue (async version).
+
+        Args:
+            event: The event to potentially translate and send
+        """
+        translated_event = self._translate_event(event)
+        await self.original_aput_event(translated_event)
+
+    def _translate_payload(self, payload: Any) -> Any:
+        """Translate node names in a payload.
+
+        Handles both single node_name and involved_nodes list.
+
+        Args:
+            payload: The payload to translate
+
+        Returns:
+            A new payload with translated names, or the original if no translation needed
+        """
+        # Handle involved_nodes list (e.g., InvolvedNodesEvent)
+        involved_nodes = getattr(payload, "involved_nodes", None)
+        if involved_nodes is not None and isinstance(involved_nodes, list):
+            translated_nodes: list[str] = []
+            any_translated = False
+            for node_name in involved_nodes:
+                if node_name in self.node_name_mapping:
+                    translated_nodes.append(self.node_name_mapping[node_name])
+                    any_translated = True
+                else:
+                    translated_nodes.append(node_name)
+            # Only create new payload if something was translated
+            if any_translated:
+                return self._copy_payload_with_translated_involved_nodes(payload, translated_nodes)
+
+        # Handle single node_name
+        node_name = getattr(payload, "node_name", None)
+        if node_name is not None and node_name in self.node_name_mapping:
+            return self._copy_payload_with_translated_node_name(payload, self.node_name_mapping[node_name])
+
+        return payload
+
+    def _copy_payload_with_translated_involved_nodes(self, payload: Any, translated_nodes: list[str]) -> Any:
+        """Create a copy of a payload with translated involved_nodes.
+
+        Args:
+            payload: The payload to copy
+            translated_nodes: The translated list of node names
+
+        Returns:
+            A new payload instance with translated involved_nodes
+        """
+        payload_class = type(payload)
+
+        if hasattr(payload, "model_dump"):
+            payload_dict = payload.model_dump()
+        elif hasattr(payload, "__dict__"):
+            payload_dict = payload.__dict__.copy()
+        else:
+            return payload
+
+        payload_dict["involved_nodes"] = translated_nodes
+
+        try:
+            return payload_class(**payload_dict)
+        except Exception:
+            return payload
+
+    def _copy_payload_with_translated_node_name(self, payload: Any, translated_name: str) -> Any:
+        """Create a copy of a payload with a translated node_name.
+
+        Args:
+            payload: The payload to copy
+            translated_name: The translated node name
+
+        Returns:
+            A new payload instance with translated node_name
+        """
+        payload_class = type(payload)
+
+        if hasattr(payload, "model_dump"):
+            payload_dict = payload.model_dump()
+        elif hasattr(payload, "__dict__"):
+            payload_dict = payload.__dict__.copy()
+        else:
+            return payload
 
-        # No translation needed, send as-is
-        self.original_put_event(event)
+        payload_dict["node_name"] = translated_name
+
+        try:
+            return payload_class(**payload_dict)
+        except Exception:
+            return payload
+
+    def _create_translated_wrapped_event(self, event: Any, translated_payload: Any) -> Any | None:
+        """Create a new wrapped event with a translated payload.
+
+        Args:
+            event: The original wrapped event (e.g., ExecutionGriptapeNodeEvent)
+            translated_payload: The translated payload
+
+        Returns:
+            A new wrapped event with the translated payload, or None if creation fails
+        """
+        wrapped_event = getattr(event, "wrapped_event", None)
+        if wrapped_event is None:
+            return None
+
+        # Create new wrapped_event with translated payload
+        wrapped_class = type(wrapped_event)
+        try:
+            new_wrapped = wrapped_class(payload=translated_payload)
+        except Exception:
+            return None
+
+        # Create new outer event with new wrapped_event
+        event_class = type(event)
+        try:
+            return event_class(wrapped_event=new_wrapped)
+        except Exception:
+            return None
 
     def _copy_event_with_translated_name(self, event: Any) -> Any:
         """Create a copy of an event with the node name translated to the original name.

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -2319,11 +2319,12 @@ class FlowManager:
                     start_node_parameter_value_commands.append(param_value_command)
 
             # Create parameter command for start node (following single-node pattern exactly)
+            # Use source parameter's default value to ensure type-safe propagation during connection creation
             add_param_request = AddParameterToNodeRequest(
                 node_name=start_node_name,
                 parameter_name=param_name,
                 type=source_param.output_type,
-                default_value=None,
+                default_value=source_param.default_value,
                 tooltip=f"Parameter {target_parameter_name} from node {target_node_name} in packaged flow",
                 initial_setup=True,
             )

griptape_nodes/retained_mode/managers/library_manager.py

@@ -170,7 +170,7 @@ from griptape_nodes.retained_mode.managers.os_manager import OSManager
 from griptape_nodes.retained_mode.managers.settings import LIBRARIES_TO_DOWNLOAD_KEY, LIBRARIES_TO_REGISTER_KEY
 from griptape_nodes.utils.async_utils import subprocess_run
 from griptape_nodes.utils.dict_utils import merge_dicts
-from griptape_nodes.utils.file_utils import find_file_in_directory
+from griptape_nodes.utils.file_utils import find_file_in_directory, find_files_recursive
 from griptape_nodes.utils.git_utils import (
     GitCloneError,
     GitPullError,
@@ -1244,6 +1244,7 @@ class LibraryManager:
             LibraryRegistry.get_library(name=library_name)
             return RegisterLibraryFromFileResultSuccess(
                 library_name=library_name,
+                was_already_loaded=True,
                 result_details=f"Library '{library_name}' already loaded",
             )
         except KeyError:
@@ -1278,6 +1279,7 @@ class LibraryManager:
                 # Already loaded and good to go
                 return RegisterLibraryFromFileResultSuccess(
                     library_name=library_info.library_name,
+                    was_already_loaded=True,
                     result_details=f"Library '{library_info.library_name}' already loaded",
                 )
 
@@ -3107,7 +3109,7 @@ class LibraryManager:
             problems=problems,
         )
 
-    async def load_libraries_request(self, request: LoadLibrariesRequest) -> ResultPayload:  # noqa: ARG002, C901
+    async def load_libraries_request(self, request: LoadLibrariesRequest) -> ResultPayload:  # noqa: ARG002, C901, PLR0912
         """Load all libraries from configuration (backward compatibility wrapper).
 
         This is the legacy entry point that loads all configured libraries.
@@ -3154,6 +3156,14 @@ class LibraryManager:
             else:
                 library_name = lib_path
 
+            # Check if library was already loaded (skip event emission if so)
+            if isinstance(load_result, RegisterLibraryFromFileResultSuccess) and load_result.was_already_loaded:
+                # Library was already loaded - skip events and continue
+                loaded_count += 1
+                continue
+
+            # Library was actually loaded or failed - emit appropriate events
+
             # Emit loading event
             GriptapeNodes.EventManager().put_event(
                 AppEvent(
@@ -3230,8 +3240,8 @@ class LibraryManager:
         def process_path(path: Path) -> None:
             """Process a path, handling both files and directories."""
             if path.is_dir():
-                # Process all library JSON files recursively in the directory
-                discovered_libraries.update(path.rglob(LibraryManager.LIBRARY_CONFIG_GLOB_PATTERN))
+                # Recursively find library files, skipping hidden directories
+                discovered_libraries.update(find_files_recursive(path, LibraryManager.LIBRARY_CONFIG_GLOB_PATTERN))
             elif path.suffix == ".json":
                 discovered_libraries.add(path)
 

griptape_nodes/retained_mode/managers/node_manager.py

@@ -20,6 +20,7 @@ from griptape_nodes.exe_types.core_types import (
 )
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_groups import SubflowNodeGroup
+from griptape_nodes.exe_types.node_groups.base_node_group import BaseNodeGroup
 from griptape_nodes.exe_types.node_types import (
     LOCAL_EXECUTION,
     PRIVATE_EXECUTION,
@@ -135,12 +136,18 @@ from griptape_nodes.retained_mode.events.object_events import (
     RenameObjectResultSuccess,
 )
 from griptape_nodes.retained_mode.events.parameter_events import (
+    AddParameterGroupToNodeRequest,
+    AddParameterGroupToNodeResultFailure,
+    AddParameterGroupToNodeResultSuccess,
     AddParameterToNodeRequest,
     AddParameterToNodeResultFailure,
     AddParameterToNodeResultSuccess,
     AlterParameterDetailsRequest,
     AlterParameterDetailsResultFailure,
     AlterParameterDetailsResultSuccess,
+    AlterParameterGroupDetailsRequest,
+    AlterParameterGroupDetailsResultFailure,
+    AlterParameterGroupDetailsResultSuccess,
     GetCompatibleParametersRequest,
     GetCompatibleParametersResultFailure,
     GetCompatibleParametersResultSuccess,
@@ -239,6 +246,12 @@ class NodeManager:
             ListParametersOnNodeRequest, self.on_list_parameters_on_node_request
         )
         event_manager.assign_manager_to_request_type(AddParameterToNodeRequest, self.on_add_parameter_to_node_request)
+        event_manager.assign_manager_to_request_type(
+            AddParameterGroupToNodeRequest, self.on_add_parameter_group_to_node_request
+        )
+        event_manager.assign_manager_to_request_type(
+            AlterParameterGroupDetailsRequest, self.on_alter_parameter_group_details_request
+        )
         event_manager.assign_manager_to_request_type(
             RemoveParameterFromNodeRequest, self.on_remove_parameter_from_node_request
         )
@@ -487,9 +500,9 @@ class NodeManager:
                         node.end_node = end_node
                         end_node.start_node = node
 
-        # Handle node_names_to_add for SubflowNodeGroup nodes
+        # Handle node_names_to_add for BaseNodeGroup nodes
         if request.node_names_to_add:
-            if isinstance(node, SubflowNodeGroup):
+            if isinstance(node, BaseNodeGroup):
                 nodes_to_add = []
                 for node_name in request.node_names_to_add:
                     try:
@@ -510,7 +523,7 @@ class NodeManager:
             else:
                 warning_details = (
                     f"Attempted to add nodes '{request.node_names_to_add}' to Node '{node.name}'. "
-                    f"Failed because node is not a SubflowNodeGroup."
+                    f"Failed because node is not a BaseNodeGroup."
                 )
                 logger.warning(warning_details)
 
@@ -570,7 +583,7 @@ class NodeManager:
 
     def _get_node_group(
         self, node_group_name: str, node_names: list[str]
-    ) -> SubflowNodeGroup | AddNodesToNodeGroupResultFailure:
+    ) -> BaseNodeGroup | AddNodesToNodeGroupResultFailure:
         """Get the NodeGroup node."""
         try:
             node_group = GriptapeNodes.ObjectManager().get_object_by_name(node_group_name)
@@ -578,7 +591,7 @@ class NodeManager:
             details = f"Attempted to add nodes '{node_names}' to NodeGroup '{node_group_name}'. Failed because NodeGroup was not found."
             return AddNodesToNodeGroupResultFailure(result_details=details)
 
-        if not isinstance(node_group, SubflowNodeGroup):
+        if not isinstance(node_group, BaseNodeGroup):
             details = f"Attempted to add nodes '{node_names}' to '{node_group_name}'. Failed because '{node_group_name}' is not a NodeGroup."
             return AddNodesToNodeGroupResultFailure(result_details=details)
 
@@ -657,7 +670,7 @@ class NodeManager:
 
     def _get_node_group_for_remove(
         self, node_group_name: str, node_names: list[str]
-    ) -> SubflowNodeGroup | RemoveNodeFromNodeGroupResultFailure:
+    ) -> BaseNodeGroup | RemoveNodeFromNodeGroupResultFailure:
         """Get the NodeGroup node for remove operation."""
         try:
             node_group = GriptapeNodes.ObjectManager().get_object_by_name(node_group_name)
@@ -665,7 +678,7 @@ class NodeManager:
             details = f"Attempted to remove nodes '{node_names}' from NodeGroup '{node_group_name}'. Failed because NodeGroup was not found."
             return RemoveNodeFromNodeGroupResultFailure(result_details=details)
 
-        if not isinstance(node_group, SubflowNodeGroup):
+        if not isinstance(node_group, BaseNodeGroup):
             details = f"Attempted to remove nodes '{node_names}' from '{node_group_name}'. Failed because '{node_group_name}' is not a NodeGroup."
             return RemoveNodeFromNodeGroupResultFailure(result_details=details)
 
@@ -1418,6 +1431,72 @@ class NodeManager:
         )
         return result
 
+    def on_add_parameter_group_to_node_request(  # noqa: C901, PLR0911
+        self, request: AddParameterGroupToNodeRequest
+    ) -> ResultPayload:
+        """Handle request to add a ParameterGroup to a node."""
+        node_name = request.node_name
+        node = None
+        parent_group: ParameterGroup | None = None
+
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = "Attempted to add ParameterGroup to a Node from the Current Context. Failed because the Current Context is empty."
+                return AddParameterGroupToNodeResultFailure(result_details=details)
+
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        if node is None:
+            obj_mgr = GriptapeNodes.ObjectManager()
+            node = obj_mgr.attempt_get_object_by_name_as_type(node_name, BaseNode)
+            if node is None:
+                details = f"Attempted to add ParameterGroup '{request.group_name}' to a Node '{node_name}', but no such Node was found."
+                return AddParameterGroupToNodeResultFailure(result_details=details)
+
+        if node.lock:
+            details = f"Attempted to add ParameterGroup '{request.group_name}' to Node '{node_name}'. Failed because the Node was locked."
+            return AddParameterGroupToNodeResultFailure(result_details=details)
+
+        if not request.group_name:
+            details = (
+                f"Attempted to add ParameterGroup to node '{node_name}'. Failed because group_name was not defined."
+            )
+            return AddParameterGroupToNodeResultFailure(result_details=details)
+
+        existing_element = node.get_element_by_name_and_type(request.group_name)
+        if existing_element is not None:
+            details = f"Attempted to add ParameterGroup '{request.group_name}' to node '{node_name}'. Failed because an element with that name already exists."
+            return AddParameterGroupToNodeResultFailure(result_details=details)
+
+        if request.parent_element_name is not None:
+            parent_element = node.get_element_by_name_and_type(request.parent_element_name)
+            if parent_element is None:
+                details = f"Attempted to add ParameterGroup '{request.group_name}' to Parent Element '{request.parent_element_name}' in node '{node_name}'. Failed because parent element didn't exist."
+                return AddParameterGroupToNodeResultFailure(result_details=details)
+
+            if isinstance(parent_element, ParameterGroup):
+                parent_group = parent_element
+
+        new_group = ParameterGroup(
+            name=request.group_name,
+            ui_options=request.ui_options if request.ui_options else {},
+            parent_group_name=parent_group.name if parent_group is not None else None,
+            user_defined=request.is_user_defined,
+        )
+
+        if parent_group is not None:
+            parent_group.add_child(new_group)
+        else:
+            node.add_node_element(new_group)
+
+        details = f"Successfully added ParameterGroup '{request.group_name}' to Node '{node_name}'."
+        logger.debug(details)
+
+        return AddParameterGroupToNodeResultSuccess(
+            group_name=new_group.name, node_name=node_name, result_details=details
+        )
+
     def on_remove_parameter_from_node_request(self, request: RemoveParameterFromNodeRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
         node_name = request.node_name
         node = None
@@ -1592,6 +1671,7 @@ class NodeManager:
             mode_allowed_output=allows_output,
             is_user_defined=getattr(element, "user_defined", False),
             settable=getattr(element, "settable", None),
+            private=getattr(element, "private", False),
             ui_options=getattr(element, "ui_options", None),
             result_details=details,
         )
@@ -1845,6 +1925,55 @@ class NodeManager:
         result = AlterParameterDetailsResultSuccess(result_details=details)
         return result
 
+    def on_alter_parameter_group_details_request(  # noqa: PLR0911
+        self, request: AlterParameterGroupDetailsRequest
+    ) -> ResultPayload:
+        """Handle requests to alter ParameterGroup details (primarily ui_options)."""
+        node_name = request.node_name
+        node = None
+
+        if node_name is None:
+            if not GriptapeNodes.ContextManager().has_current_node():
+                details = f"Attempted to alter details for ParameterGroup '{request.group_name}' from node in the Current Context. Failed because there was no such Node."
+                return AlterParameterGroupDetailsResultFailure(result_details=details)
+            node = GriptapeNodes.ContextManager().get_current_node()
+            node_name = node.name
+
+        if node is None:
+            obj_mgr = GriptapeNodes.ObjectManager()
+            node = obj_mgr.attempt_get_object_by_name_as_type(node_name, BaseNode)
+            if node is None:
+                details = f"Attempted to alter details for ParameterGroup '{request.group_name}' from Node '{node_name}', but no such Node was found."
+                return AlterParameterGroupDetailsResultFailure(result_details=details)
+
+        if node.lock:
+            details = f"Attempted to alter details for ParameterGroup '{request.group_name}' from Node '{node_name}'. Failed because the Node was locked."
+            return AlterParameterGroupDetailsResultFailure(result_details=details)
+
+        # Handle ErrorProxyNode parameter group alteration requests
+        if isinstance(node, ErrorProxyNode):
+            if request.initial_setup:
+                node.record_initialization_request(request)
+                details = f"ParameterGroup '{request.group_name}' alteration recorded for ErrorProxyNode '{node_name}'. Original node '{node.original_node_type}' had loading errors - preserving changes for correct recreation when dependency '{node.original_library_name}' is resolved."
+                result_details = ResultDetails(message=details, level=logging.WARNING)
+                return AlterParameterGroupDetailsResultSuccess(result_details=result_details)
+
+            details = f"Cannot modify ParameterGroup '{request.group_name}' on placeholder node '{node_name}'. This placeholder preserves your workflow structure but doesn't allow modifications."
+            return AlterParameterGroupDetailsResultFailure(result_details=details)
+
+        # Find the ParameterGroup
+        group = node.get_element_by_name_and_type(request.group_name, ParameterGroup)
+        if group is None or not isinstance(group, ParameterGroup):
+            details = f"Attempted to alter details for ParameterGroup '{request.group_name}' from Node '{node_name}'. Failed because no such ParameterGroup was found."
+            return AlterParameterGroupDetailsResultFailure(result_details=details)
+
+        # Update ui_options if provided
+        if request.ui_options is not None:
+            group.ui_options = request.ui_options
+
+        details = f"Successfully altered details for ParameterGroup '{request.group_name}' from Node '{node_name}'."
+        return AlterParameterGroupDetailsResultSuccess(result_details=details)
+
     # For C901 (too complex): Need to give customers explicit reasons for failure on each case.
     def on_get_parameter_value_request(self, request: GetParameterValueRequest) -> ResultPayload:
         node_name = request.node_name
@@ -2555,6 +2684,22 @@ class NodeManager:
 
             # Now creation or alteration of all of the elements.
             element_modification_commands = []
+
+            # Serialize only user-defined ParameterGroups (like parameters)
+            all_groups = node.root_ui_element.find_elements_by_type(ParameterGroup)
+            for group in all_groups:
+                if group.user_defined:
+                    add_group_request = AddParameterGroupToNodeRequest(
+                        node_name=node_name,
+                        group_name=group.name,
+                        parent_element_name=group.parent_group_name,
+                        ui_options=group.ui_options if group.ui_options else {},
+                        is_user_defined=True,
+                        initial_setup=True,
+                    )
+                    element_modification_commands.append(add_group_request)
+
+            # Then serialize parameters
             for parameter in node.parameters:
                 # Create the parameter, or alter it on the existing node
                 if parameter.user_defined:
@@ -2595,6 +2740,23 @@ class NodeManager:
                         alter_param_request = AlterParameterDetailsRequest.create(**diff)
                         element_modification_commands.append(alter_param_request)
 
+            # Check for ParameterGroup alterations (ui_options changes like collapsed state)
+            if reference_node is not None and not isinstance(node, ErrorProxyNode):
+                # Compare ALL groups against the reference node (not just user-defined)
+                # This matches the pattern used for parameter alterations
+                for group in all_groups:
+                    diff = NodeManager._manage_alter_group_details(group, reference_node)
+                    relevant = False
+                    for key in diff:
+                        if key in AlterParameterGroupDetailsRequest.relevant_parameters():
+                            relevant = True
+                            break
+                    if relevant:
+                        diff["group_name"] = group.name
+                        diff["initial_setup"] = True
+                        alter_group_request = AlterParameterGroupDetailsRequest(**diff)
+                        element_modification_commands.append(alter_group_request)
+
             # Now assignment of values to all of the parameters.
             set_value_commands = []
 
@@ -2977,6 +3139,24 @@ class NodeManager:
             return vars(parameter)
         return diff
 
+    @staticmethod
+    def _manage_alter_group_details(group: ParameterGroup, base_node_obj: BaseNode) -> dict:
+        """Compare a ParameterGroup against its base version and return differences.
+
+        Args:
+            group: The current ParameterGroup to compare
+            base_node_obj: The reference node containing the base version
+
+        Returns:
+            Dictionary of differences, or empty dict if no changes
+        """
+        base_group = base_node_obj.get_element_by_name_and_type(group.name, ParameterGroup)
+        if base_group and isinstance(base_group, ParameterGroup):
+            diff = base_group.equals(group)
+        else:
+            return {"ui_options": group.ui_options}
+        return diff
+
     @staticmethod
     def _handle_value_hashing(  # noqa: PLR0913
         value: Any,