griptape-nodes 0.57.1__py3-none-any.whl → 0.58.1__py3-none-any.whl

griptape_nodes/retained_mode/managers/library_manager.py

@@ -100,6 +100,7 @@ from griptape_nodes.retained_mode.managers.library_lifecycle.library_provenance.
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 from griptape_nodes.retained_mode.managers.os_manager import OSManager
 from griptape_nodes.utils.async_utils import subprocess_run
+from griptape_nodes.utils.dict_utils import merge_dicts
 from griptape_nodes.utils.uv_utils import find_uv_bin
 from griptape_nodes.utils.version_utils import get_complete_version_string
 
@@ -881,10 +882,9 @@ class LibraryManager:
                         continue  # SKIP IT
                 else:
                     # We had an existing category. Union our changes into it (not replacing anything that matched).
-                    existing_category_contents = get_category_result.contents
-                    existing_category_contents |= {
-                        k: v for k, v in library_data_setting.contents.items() if k not in existing_category_contents
-                    }
+                    existing_category_contents = merge_dicts(
+                        library_data_setting.contents, get_category_result.contents, add_keys=True, merge_lists=True
+                    )
                     set_category_request = SetConfigCategoryRequest(
                         category=library_data_setting.category, contents=existing_category_contents
                     )
@@ -1128,7 +1128,6 @@ class LibraryManager:
         lib_info = self.get_library_info_by_library_name(request.library_name)
         if lib_info:
             del self._library_file_path_to_info[lib_info.library_path]
-
         details = f"Successfully unloaded (and unregistered) library '{request.library_name}'."
         return UnloadLibraryFromRegistryResultSuccess(result_details=details)
 
@@ -1545,12 +1544,12 @@ class LibraryManager:
         self._remove_missing_libraries_from_config(config_category=user_libraries_section)
 
     async def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
-        GriptapeNodes.EngineIdentityManager().initialize_engine_id()
-        GriptapeNodes.SessionManager().get_saved_session_id()
-
         # App just got init'd. See if there are library JSONs to load!
         await self.load_all_libraries_from_config()
 
+        # Register all secrets now that libraries are loaded and settings are merged
+        GriptapeNodes.SecretsManager().register_all_secrets()
+
         # We have to load all libraries before we attempt to load workflows.
 
         # Load workflows specified by libraries.

griptape_nodes/retained_mode/managers/node_manager.py

@@ -9,6 +9,7 @@ from griptape_nodes.exe_types.core_types import (
     Parameter,
     ParameterContainer,
     ParameterGroup,
+    ParameterMessage,
     ParameterMode,
     ParameterType,
     ParameterTypeBuiltin,
@@ -148,6 +149,18 @@ from griptape_nodes.retained_mode.managers.event_manager import EventManager
 logger = logging.getLogger("griptape_nodes")
 
 
+class SerializedParameterValues(NamedTuple):
+    """Result of serializing parameter output values.
+
+    Attributes:
+        parameter_output_values: Either raw values or UUID references if pickling was used
+        unique_parameter_uuid_to_values: Dictionary of pickled values (None if no pickling needed)
+    """
+
+    parameter_output_values: dict[str, Any]
+    unique_parameter_uuid_to_values: dict[Any, Any] | None
+
+
 class NodeManager:
     _name_to_parent_flow_name: dict[str, str]
 
@@ -888,7 +901,7 @@ class NodeManager:
                 has_non_control_types = True
         if request.input_types is not None:
             for test_type in request.input_types:
-                if test_type.lower == ParameterTypeBuiltin.CONTROL_TYPE.value.lower():
+                if test_type.lower() == ParameterTypeBuiltin.CONTROL_TYPE.value.lower():
                     has_control_type = True
                 else:
                     has_non_control_types = True
@@ -995,12 +1008,19 @@ class NodeManager:
         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)
+            node.remove_node_element(element)
 
             return RemoveParameterFromNodeResultSuccess(
                 result_details=f"Successfully removed parameter group '{request.parameter_name}' and all its children from node '{node_name}'."
             )
 
+        if isinstance(element, ParameterMessage):
+            node.remove_node_element(element)
+
+            return RemoveParameterFromNodeResultSuccess(
+                result_details=f"Successfully removed parameter message '{request.parameter_name}' from node '{node_name}'."
+            )
+
         # No tricky stuff, users!
         # if user_defined doesn't exist, or is false, then it's not user-defined
         if not getattr(element, "user_defined", False):
@@ -1528,11 +1548,11 @@ class NodeManager:
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because that Parameter was flagged as not settable."
             result = SetParameterValueResultFailure(result_details=details)
             return result
-
-        # Well this seems kind of stupid
         object_type = request.data_type if request.data_type else parameter.type
-        # Is this value kosher for the types allowed?
-        if not parameter.is_incoming_type_allowed(object_type):
+        # If the parameter is control type, we shouldn't check the value being set, since it's just a marker for which path to take, not a real value, and will likely be a string, which doesn't match ControlType.
+        if parameter.type != ParameterTypeBuiltin.CONTROL_TYPE.value and not parameter.is_incoming_type_allowed(
+            object_type
+        ):
             details = f"Attempted to set parameter value for '{node_name}.{request.parameter_name}'. Failed because the value's type of '{object_type}' was not in the Parameter's list of allowed types: {parameter.input_types}."
 
             result = SetParameterValueResultFailure(result_details=details)
@@ -2308,9 +2328,10 @@ class NodeManager:
             set_parameter_value_commands=parameter_commands,
             set_lock_commands_per_node=lock_commands,
         )
-        # Set everything in the clipboard!
-        GriptapeNodes.ContextManager()._clipboard.node_commands = final_result
-        GriptapeNodes.ContextManager()._clipboard.parameter_uuid_to_values = unique_uuid_to_values
+        # Set everything in the clipboard if requested
+        if request.copy_to_clipboard:
+            GriptapeNodes.ContextManager()._clipboard.node_commands = final_result
+            GriptapeNodes.ContextManager()._clipboard.parameter_uuid_to_values = unique_uuid_to_values
         return SerializeSelectedNodesToCommandsResultSuccess(
             final_result,
             result_details=f"Successfully serialized {len(request.nodes_to_serialize)} selected nodes to commands.",
@@ -2573,6 +2594,173 @@ class NodeManager:
                 commands.append(output_command)
         return commands if commands else None
 
+    @staticmethod
+    def serialize_parameter_output_values(node: BaseNode, *, use_pickling: bool = False) -> SerializedParameterValues:
+        """Serialize parameter output values with optional pickling for complex objects.
+
+        Args:
+            node: The node whose parameter output values should be serialized
+            use_pickling: If True, use pickle-based serialization; if False, use TypeValidator.safe_serialize
+
+        Returns:
+            SerializedParameterValues containing:
+            - parameter_output_values: Either raw values or UUID references if pickling was used
+            - unique_parameter_uuid_to_values: Dictionary of pickled values (None if no pickling needed)
+        """
+        if not node.parameters:
+            return SerializedParameterValues({}, None)
+
+        if not use_pickling:
+            return NodeManager._serialize_without_pickling(node)
+
+        return NodeManager._serialize_with_pickling(node)
+
+    @staticmethod
+    def _serialize_without_pickling(node: BaseNode) -> SerializedParameterValues:
+        """Serialize parameter values using simple TypeValidator serialization.
+
+        Args:
+            node: The node whose parameter values should be serialized
+
+        Returns:
+            SerializedParameterValues with no pickling
+        """
+        param_values = {}
+        for param in node.parameters:
+            if param.name in node.parameter_output_values:
+                param_values[param.name] = node.parameter_output_values[param.name]
+            else:
+                param_values[param.name] = node.get_parameter_value(param.name)
+        simple_values = TypeValidator.safe_serialize(param_values)
+        return SerializedParameterValues(simple_values, None)
+
+    @staticmethod
+    def _serialize_with_pickling(
+        node: BaseNode,
+    ) -> SerializedParameterValues:
+        """Serialize parameter values using pickle-based serialization with UUID references.
+
+        Args:
+            node: The node whose parameter values should be serialized
+
+        Returns:
+            SerializedParameterValues with pickled values
+        """
+        unique_parameter_uuid_to_values = {}
+        serialized_parameter_value_tracker = SerializedParameterValueTracker()
+        uuid_referenced_values = {}
+
+        for parameter in node.parameters:
+            param_name = parameter.name
+            param_value = NodeManager._get_parameter_value_for_serialization(node, param_name)
+
+            unique_uuid = NodeManager._process_parameter_for_pickling(
+                param_value,
+                param_name,
+                serialized_parameter_value_tracker,
+                unique_parameter_uuid_to_values,
+                uuid_referenced_values,
+            )
+
+            uuid_referenced_values[param_name] = unique_uuid
+
+        return SerializedParameterValues(
+            uuid_referenced_values, unique_parameter_uuid_to_values if unique_parameter_uuid_to_values else None
+        )
+
+    @staticmethod
+    def _get_parameter_value_for_serialization(node: BaseNode, param_name: str) -> Any:
+        """Get parameter value for serialization, checking output values first.
+
+        Args:
+            node: The node to get the parameter value from
+            param_name: The parameter name
+
+        Returns:
+            The parameter value
+        """
+        if param_name in node.parameter_output_values:
+            return node.parameter_output_values[param_name]
+        return node.get_parameter_value(param_name)
+
+    @staticmethod
+    def _process_parameter_for_pickling(
+        param_value: Any,
+        param_name: str,
+        tracker: SerializedParameterValueTracker,
+        unique_parameter_uuid_to_values: dict,
+        uuid_referenced_values: dict,
+    ) -> SerializedNodeCommands.UniqueParameterValueUUID | None:
+        """Process a parameter value for pickle-based serialization.
+
+        Args:
+            param_value: The value to serialize
+            param_name: Parameter name for tracking
+            tracker: Tracker for managing serialization state
+            unique_parameter_uuid_to_values: Dictionary to store pickled values
+            uuid_referenced_values: Dictionary to store UUID references
+
+        Returns:
+            UUID reference for the value, or None if not serializable
+        """
+        try:
+            hash(param_value)
+            value_id = param_value
+        except TypeError:
+            value_id = id(param_value)
+
+        tracker_status = tracker.get_tracker_state(value_id)
+
+        match tracker_status:
+            case SerializedParameterValueTracker.TrackerState.SERIALIZABLE:
+                return tracker.get_uuid_for_value_hash(value_id)
+            case SerializedParameterValueTracker.TrackerState.NOT_SERIALIZABLE:
+                uuid_referenced_values[param_name] = None
+                return None
+            case SerializedParameterValueTracker.TrackerState.NOT_IN_TRACKER:
+                return NodeManager._handle_new_value_for_pickling(
+                    param_value, param_name, tracker, unique_parameter_uuid_to_values, uuid_referenced_values
+                )
+
+    @staticmethod
+    def _handle_new_value_for_pickling(
+        param_value: Any,
+        param_name: str,
+        tracker: SerializedParameterValueTracker,
+        unique_parameter_uuid_to_values: dict,
+        uuid_referenced_values: dict,
+    ) -> SerializedNodeCommands.UniqueParameterValueUUID | None:
+        """Handle a new value that hasn't been seen before in pickling serialization.
+
+        Args:
+            param_value: The value to pickle
+            param_name: Parameter name for tracking
+            tracker: Tracker for managing serialization state
+            unique_parameter_uuid_to_values: Dictionary to store pickled values
+            uuid_referenced_values: Dictionary to store UUID references
+
+        Returns:
+            UUID reference for the value, or None if not serializable
+        """
+        try:
+            hash(param_value)
+            value_id = param_value
+        except TypeError:
+            value_id = id(param_value)
+
+        try:
+            workflow_manager = GriptapeNodes.WorkflowManager()
+            pickled_bytes = workflow_manager._patch_and_pickle_object(param_value)
+        except Exception:
+            tracker.add_as_not_serializable(value_id)
+            uuid_referenced_values[param_name] = None
+            return None
+
+        unique_uuid = SerializedNodeCommands.UniqueParameterValueUUID(str(uuid4()))
+        unique_parameter_uuid_to_values[unique_uuid] = pickled_bytes
+        tracker.add_as_serializable(value_id, unique_uuid)
+        return unique_uuid
+
     def on_rename_parameter_request(self, request: RenameParameterRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
         """Handle renaming a parameter on a node.
 

griptape_nodes/retained_mode/managers/secrets_manager.py

@@ -2,6 +2,7 @@ import logging
 import re
 from os import getenv
 from pathlib import Path
+from typing import Literal, overload
 
 from dotenv import dotenv_values, get_key, load_dotenv, set_key, unset_key
 from dotenv.main import DotEnv
@@ -51,6 +52,25 @@ class SecretsManager:
     def workspace_env_path(self) -> Path:
         return self.config_manager.workspace_path / ".env"
 
+    def register_all_secrets(self) -> None:
+        """Register all secrets from config and library settings.
+
+        This should be called after libraries are loaded and their settings
+        are merged into the config.
+        """
+        secret_names = set()
+
+        secrets_to_register = self.config_manager.get_config_value(
+            "app_events.on_app_initialization_complete.secrets_to_register", default=[]
+        )
+
+        secret_names.update(secrets_to_register)
+
+        # Register each secret (create blank entry if doesn't exist)
+        for secret_name in secret_names:
+            if self.get_secret(secret_name, should_error_on_not_found=False) is None:
+                self.set_secret(secret_name, "")
+
     def on_handle_get_secret_request(self, request: GetSecretValueRequest) -> ResultPayload:
         secret_key = SecretsManager._apply_secret_name_compliance(request.key)
         secret_value = self.get_secret(secret_key, should_error_on_not_found=request.should_error_on_not_found)
@@ -107,6 +127,12 @@ class SecretsManager:
 
         return DeleteSecretValueResultSuccess(result_details=f"Successfully deleted secret: {secret_name}")
 
+    @overload
+    def get_secret(self, secret_name: str, *, should_error_on_not_found: Literal[True] = True) -> str: ...
+
+    @overload
+    def get_secret(self, secret_name: str, *, should_error_on_not_found: Literal[False]) -> str | None: ...
+
     def get_secret(self, secret_name: str, *, should_error_on_not_found: bool = True) -> str | None:
         """Return the secret value with the following search precedence (highest to lowest priority).